[WRONG BRANCH] fix(cursor): remove spoofable connection status

gui/src/pages/integrations/CursorIntegrationPage.tsx

@@ -5,17 +5,16 @@ import { formatTokens } from "../../format-tokens";
 import { navigateHash } from "../../hash-routing";
 import { useI18n, useT, type TKey } from "../../i18n/shared";
 import { Notice } from "../../ui";
-import { formatRelativeTime, relativeTimeLabelsFromT } from "../../provider-workspace/usage";
-import { CURSOR_SEEN_WINDOW_MS, loadCursorIntegrationStatus, type CursorIntegrationStatus } from "./cursor-api";
+import { loadCursorIntegrationStatus, type CursorIntegrationStatus } from "./cursor-api";
 
 /**
  * The Cursor tab is a read-only companion, not a switch.
  *
  * Cursor Private Inference keeps its gateway settings in a SQLite database the running app
  * rewrites and its API key in the OS keychain, both out of bounds for this proxy. So the page
  * does the three things it can do honestly: say which Cursor builds are installed, hand the
- * user the two values Cursor's own form wants, and report whether a Cursor client has called
- * us since the proxy started. Everything shown is a GET of one status route.
+ * user the two values Cursor's own form wants, and predict the model controls it will render.
+ * Everything shown is a GET of one status route.
  */
 
 function CopyValue({ value, label }: { value: string; label: string }) {
@@ -61,29 +60,23 @@ function DetectionRow({ labelKey, installed, path, version }: { labelKey: TKey;
 
 export default function CursorIntegrationPage({ apiBase, active }: { apiBase: string; active: boolean }) {
   const { t, locale } = useI18n();
-  // The clock is sampled when a payload arrives, never during render: the "seen within 24h"
-  // badge and the relative time must agree with each other and stay stable across re-renders.
-  const [sampledAt, setSampledAt] = useState(() => Date.now());
   const fetchStatus = useCallback(
     async (signal: AbortSignal) => {
       const payload = await loadCursorIntegrationStatus(apiBase, signal);
       // The overview paints a null read as "unknown"; the page has room to say why.
       if (!payload) throw new Error("cursor status unavailable");
-      setSampledAt(Date.now());
       return payload;
     },
     [apiBase],
   );
-  // Polls while the tab is open so "Refresh model list" in Cursor shows up here within seconds.
+  // Poll while the tab is open so install and catalog changes show up without a reload.
   const resource = useDataSurface<CursorIntegrationStatus>(
     `integration-cursor-page:${apiBase}`,
     [apiBase],
     fetchStatus,
     { isEmpty: () => false, enabled: active, pollMs: 15_000, pauseWhenHidden: true },
   );
   const status = resource.state.data ?? null;
-  const labels = relativeTimeLabelsFromT(t);
-
   return (
     <section className="integration-native-page cursor-page" aria-labelledby="cursor-integration-title">
       <h3 id="cursor-integration-title">{t("integrations.cursor.title")}</h3>
@@ -124,19 +117,6 @@ export default function CursorIntegrationPage({ apiBase, active }: { apiBase: st
               )}
           </div>
 
-          <div className="cursor-card" data-seen={status.lastSeen ? "true" : "false"}>
-            <h4>{t("integrations.cursor.connection")}</h4>
-            {status.lastSeen
-              ? (
-                <p>
-                  <span className={`badge ${sampledAt - status.lastSeen.at < CURSOR_SEEN_WINDOW_MS ? "badge-green" : "badge-muted"}`}>
-                    {t("integrations.cursor.seen", { time: formatRelativeTime(status.lastSeen.at, labels, sampledAt), ua: status.lastSeen.userAgent })}
-                  </span>
-                </p>
-              )
-              : <p className="muted">{t("integrations.cursor.neverSeen")}</p>}
-          </div>
-
           <div className="cursor-card">
             <h4>{t("integrations.cursor.models")}</h4>
             <p className="muted">{t("integrations.cursor.modelsHint")}</p>

gui/src/pages/integrations/cursor-api.ts

@@ -4,11 +4,6 @@
  */
 import { readJsonIfOk } from "../../fetch-json";
 
-export interface CursorSeen {
-  at: number;
-  userAgent: string;
-}
-
 export interface CursorModelExpectation {
   id: string;
   reasoning: string[] | null;
@@ -19,7 +14,6 @@ export interface CursorIntegrationStatus {
   privateInference: { installed: boolean; path: string | null; version: string | null };
   regularCursor: { installed: boolean; path: string | null };
   gateway: { baseUrl: string; apiKeyMode: "credential" | "placeholder"; placeholder: string };
-  lastSeen: CursorSeen | null;
   models: CursorModelExpectation[];
   guideUrl: string;
 }
@@ -36,6 +30,3 @@ export async function loadCursorIntegrationStatus(apiBase: string, signal?: Abor
     return null;
   }
 }
-
-/** 24h is the window inside which a Cursor request counts as "connected". */
-export const CURSOR_SEEN_WINDOW_MS = 24 * 60 * 60 * 1000;

gui/src/pages/integrations/overview-clients.ts

@@ -21,7 +21,7 @@ import {
   type IntegrationStatus,
 } from "./integration-api";
 import type { NativeIntegrationClientId, NativeStatus } from "./native-api";
-import { CURSOR_SEEN_WINDOW_MS, type CursorIntegrationStatus } from "./cursor-api";
+import type { CursorIntegrationStatus } from "./cursor-api";
 
 export type OverviewClientId =
   | "codex"
@@ -438,10 +438,10 @@ function grokRow(
 
 
 /**
- * Cursor has no switch: its gateway is configured inside Cursor, and this proxy never
- * writes there. "Applied" therefore means a Cursor client actually called us recently.
+ * Cursor has no switch: its gateway is configured inside Cursor, and this proxy cannot
+ * verify that configuration. Installation detection must not be reported as "applied".
  */
-function cursorRow(payload: CursorIntegrationStatus | null, now = Date.now()): OverviewRow {
+function cursorRow(payload: CursorIntegrationStatus | null): OverviewRow {
   const base = {
     id: "cursor" as const,
     hash: "integrations/cursor",
@@ -457,13 +457,12 @@ function cursorRow(payload: CursorIntegrationStatus | null, now = Date.now()): O
   if (!payload.privateInference.installed) {
     return { ...base, state: "not-installed", installed: false, applied: false, detailKey: "integrations.detail.cursorAbsent" };
   }
-  const seenRecently = payload.lastSeen !== null && now - payload.lastSeen.at < CURSOR_SEEN_WINDOW_MS;
   return {
     ...base,
-    state: seenRecently ? "current" : "absent",
+    state: "absent",
     installed: true,
-    applied: seenRecently,
-    detailKey: seenRecently ? "integrations.detail.cursorSeen" : "integrations.detail.cursorNeverSeen",
+    applied: false,
+    detailKey: null,
   };
 }
 

gui/tests/cursor-integration-page.test.tsx

@@ -32,7 +32,6 @@ function payload(overrides: Partial<CursorIntegrationStatus> = {}): CursorIntegr
     privateInference: { installed: true, path: "/Applications/Cursor Private Inference.app", version: "3.18.25" },
     regularCursor: { installed: true, path: "/Applications/Cursor.app" },
     gateway: { baseUrl: "http://127.0.0.1:10100/v1", apiKeyMode: "placeholder", placeholder: "opencodex" },
-    lastSeen: null,
     models: [
       { id: "gpt-5.6-sol", reasoning: ["low", "medium", "high", "xhigh"], context: { defaultWindow: 272_000, longWindow: 922_000 } },
       { id: "kimi/k3", reasoning: null, context: null },
@@ -113,29 +112,6 @@ test("reads its own status route and renders the gateway values with copy button
   expect(copies.length).toBe(2);
 });
 
-test("a never-seen install tells the user to press Refresh model list", async () => {
-  await mount();
-  expect(textOf()).toContain("Refresh model list in Cursor");
-  expect(container.querySelector("[data-seen='false']")).not.toBeNull();
-});
-
-test("a recent request renders the relative time and the user agent", async () => {
-  statusResponse = () => json(payload({ lastSeen: { at: Date.now() - 3 * 60_000, userAgent: "Cursor/3.18.25" } }));
-  await mount();
-  const text = textOf();
-  expect(text).toContain("Cursor/3.18.25");
-  expect(text).toContain("3m ago");
-  expect(container.querySelector("[data-seen='true'] .badge-green")).not.toBeNull();
-});
-
-test("a stale request keeps the timestamp but drops the green badge", async () => {
-  statusResponse = () => json(payload({ lastSeen: { at: Date.now() - 3 * 86_400_000, userAgent: "Cursor/3.18.25" } }));
-  await mount();
-  expect(textOf()).toContain("3d ago");
-  expect(container.querySelector("[data-seen='true'] .badge-green")).toBeNull();
-  expect(container.querySelector("[data-seen='true'] .badge-muted")).not.toBeNull();
-});
-
 test("regular Cursor alone gets the tunnel explanation, not a gateway promise", async () => {
   statusResponse = () => json(payload({ privateInference: { installed: false, path: null, version: null } }));
   await mount();
@@ -273,17 +249,12 @@ test("overview: an unreadable source is unknown, not 'not installed'", () => {
   expect(row.toggle).toBeNull();
 });
 
-test("overview: installed but never seen is absent; a recent request is current and applied", () => {
+test("overview: an installed Cursor remains unapplied because its configuration cannot be verified", () => {
   const idle = cursorRow(payload());
   expect(idle.state).toBe("absent");
   expect(idle.installed).toBe(true);
   expect(idle.applied).toBe(false);
-  expect(idle.detailKey).toBe("integrations.detail.cursorNeverSeen");
-
-  const seen = cursorRow(payload({ lastSeen: { at: Date.now() - 60_000, userAgent: "Cursor/3.18.25" } }));
-  expect(seen.state).toBe("current");
-  expect(seen.applied).toBe(true);
-  expect(seen.detailKey).toBe("integrations.detail.cursorSeen");
+  expect(idle.detailKey).toBeNull();
 
   const missing = cursorRow(payload({ privateInference: { installed: false, path: null, version: null } }));
   expect(missing.state).toBe("not-installed");

gui/tests/integrations-overview-rows.test.ts

@@ -217,15 +217,14 @@ test("every client counts toward the summary, not just the file clients", () =>
       privateInference: { installed: true, path: "/Applications/Cursor Private Inference.app", version: "3.18.25" },
       regularCursor: { installed: false, path: null },
       gateway: { baseUrl: "http://127.0.0.1:10100/v1", apiKeyMode: "placeholder", placeholder: "opencodex-loopback" },
-      lastSeen: { at: Date.now() - 60_000, userAgent: "Cursor/3.18.25" },
       models: [],
       guideUrl: "https://example.invalid/guide",
     },
   }));
   const counts = countOverviewRows(rows.rows);
-  // codex + claude + desktop + grok + cursor + opencode. Keys are deliberately absent:
+  // codex + claude + desktop + grok + opencode. Keys and Cursor are deliberately absent:
   // an issued credential is not an applied client.
-  expect(counts.applied).toBe(6);
+  expect(counts.applied).toBe(5);
   expect(counts.stale).toBe(1);
   expect(counts.unknown).toBe(0);
 });

src/server/index.ts

@@ -226,7 +226,6 @@ import {
 import { detectInstall } from "../update/index";
 import { readyProtocolMetadata } from "../remote/protocol";
 import { modelCapabilityFields } from "./models-capabilities";
-import { recordCursorSeen } from "../integrations/cursor-seen";
 
 export const MAX_WS_FRAME_BYTES = 50 * 1024 * 1024;
 const WEBSOCKET_IDLE_TIMEOUT_SECONDS = 0;
@@ -1332,9 +1331,6 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
         if (!isAllowedRequestOrigin(req, policy)) {
           return withCors(formatErrorResponse(403, "origin_rejected", "cross-origin data-plane request blocked"), req, policy);
         }
-        // The Integrations page reports whether a Cursor client has reached this proxy; the
-        // recorder keeps only a bounded User-Agent value and a timestamp, in memory.
-        recordCursorSeen(req.headers);
         let goModels;
         let modelEntitlements;
         try {

src/server/management/cursor-integration-routes.ts

@@ -5,12 +5,10 @@
  * this proxy: its settings live in a SQLite database the running app rewrites and its API key
  * in the OS keychain, both out of bounds for opencodex. So this route only answers the three
  * questions the dashboard needs — which Cursor builds are installed, what to paste into the
- * gateway form, and whether a Cursor client has actually called `/v1/models` since the proxy
- * started — plus which active models will show Cursor's Reasoning and Context controls.
+ * gateway form, and which active models will show Cursor's Reasoning and Context controls.
  */
 import { readRuntimePort } from "../../config/process-state";
 import { filterCatalogVisibleModels, nativeContextLimits, nativeOpenAiContextTier, uniqueCatalogModelsForRawPublicList, visibleNativeSlugs } from "../../codex/catalog";
-import { cursorLastSeen, type CursorSeen } from "../../integrations/cursor-seen";
 import { detectCursorInstalls, type CursorInstall } from "../../integrations/cursor-detect";
 import { configuredApiAuthToken, isApiAuthRequired, jsonResponse } from "../auth-cors";
 import { fetchAllModels } from "../management-api";
@@ -24,7 +22,6 @@ export interface CursorIntegrationStatus {
   privateInference: { installed: boolean; path: string | null; version: string | null };
   regularCursor: { installed: boolean; path: string | null };
   gateway: { baseUrl: string; apiKeyMode: "credential" | "placeholder"; placeholder: string };
-  lastSeen: CursorSeen | null;
   models: Array<{
     id: string;
     reasoning: string[] | null;
@@ -83,7 +80,6 @@ export async function buildCursorIntegrationStatus(
       apiKeyMode,
       placeholder: CURSOR_GATEWAY_PLACEHOLDER_KEY,
     },
-    lastSeen: cursorLastSeen(),
     models,
     guideUrl: CURSOR_GUIDE_URL,
   };

tests/cursor-integration-status.test.ts

@@ -8,7 +8,6 @@ import {
   seedCodexModelEntitlementsForTests,
 } from "../src/codex/model-entitlements";
 import { cursorProductJsonCandidates, detectCursorInstalls, type CursorDetectDeps } from "../src/integrations/cursor-detect";
-import { cursorLastSeen, recordCursorSeen, resetCursorSeenForTests } from "../src/integrations/cursor-seen";
 import { cursorEffortFamily } from "../src/server/models-capabilities";
 import { startServer } from "../src/server";
 import type { OcxConfig } from "../src/types";
@@ -64,22 +63,6 @@ describe("detectCursorInstalls", () => {
   });
 });
 
-describe("cursor last-seen recorder", () => {
-  beforeEach(() => resetCursorSeenForTests());
-  afterEach(() => resetCursorSeenForTests());
-
-  test("records only a Cursor user agent, bounded and validated", () => {
-    recordCursorSeen(new Headers({ "user-agent": "curl/8.7.1" }), 1000);
-    expect(cursorLastSeen()).toBeNull();
-    recordCursorSeen(new Headers({ "user-agent": "Cursor/3.18.25" }), 2000);
-    expect(cursorLastSeen()).toEqual({ at: 2000, userAgent: "Cursor/3.18.25" });
-    // A padded or oversized value is not the shape Cursor sends and is ignored.
-    recordCursorSeen(new Headers({ "user-agent": `Cursor/${"x".repeat(60)}` }), 3000);
-    recordCursorSeen(new Headers({ "user-agent": "Cursor/3.18.25 <script>" }), 4000);
-    expect(cursorLastSeen()?.at).toBe(2000);
-  });
-});
-
 describe("cursorEffortFamily", () => {
   test("mirrors Cursor's local picker table and strips provider prefixes", () => {
     expect(cursorEffortFamily("gpt-5.6-sol")).toEqual(["low", "medium", "high", "xhigh"]);
@@ -119,19 +102,17 @@ describe("GET /api/native-integrations/cursor", () => {
   beforeEach(() => {
     testHome = mkdtempSync(join(tmpdir(), "ocx-cursor-status-"));
     process.env.OPENCODEX_HOME = testHome;
-    resetCursorSeenForTests();
   });
 
   afterEach(() => {
     resetCodexModelEntitlementCacheForTests();
-    resetCursorSeenForTests();
     if (previousHome === undefined) delete process.env.OPENCODEX_HOME;
     else process.env.OPENCODEX_HOME = previousHome;
     if (testHome) removeTreeWithRetry(testHome);
     testHome = "";
   });
 
-  test("reports gateway values, model expectations, and a last-seen Cursor request", async () => {
+  test("reports gateway values and model expectations without trusting Cursor user agents", async () => {
     seedCodexModelEntitlementsForTests("main", ["gpt-5.6-sol"]);
     saveConfig(statusConfig());
     const server = startServer(0);
@@ -143,15 +124,14 @@ describe("GET /api/native-integrations/cursor", () => {
       expect(before.status).toBe(200);
       const first = await before.json() as {
         gateway: { baseUrl: string; apiKeyMode: string; placeholder: string };
-        lastSeen: unknown;
         models: Array<{ id: string; reasoning: string[] | null; context: { defaultWindow: number; longWindow: number } | null }>;
         privateInference: { installed: boolean };
         guideUrl: string;
       };
       expect(first.gateway.baseUrl).toBe(`http://127.0.0.1:${server.port}/v1`);
       expect(first.gateway.apiKeyMode).toBe("placeholder");
       expect(first.gateway.placeholder).toBe("opencodex-loopback");
-      expect(first.lastSeen).toBeNull();
+      expect("lastSeen" in first).toBe(false);
       expect(typeof first.privateInference.installed).toBe("boolean");
       expect(first.guideUrl).toContain("cursor-private-inference");
       const k3 = first.models.find(model => model.id === "kimi/k3");
@@ -166,9 +146,8 @@ describe("GET /api/native-integrations/cursor", () => {
       const discovery = await fetch(new URL("/v1/models", server.url), { headers: { "user-agent": "Cursor/3.18.25" } });
       expect(discovery.status).toBe(200);
       const after = await fetch(new URL("/api/native-integrations/cursor", server.url), { headers });
-      const second = await after.json() as { lastSeen: { at: number; userAgent: string } | null };
-      expect(second.lastSeen?.userAgent).toBe("Cursor/3.18.25");
-      expect(typeof second.lastSeen?.at).toBe("number");
+      const second = await after.json() as Record<string, unknown>;
+      expect("lastSeen" in second).toBe(false);
     } finally {
       await server.stop(true);
     }