@cursorpool-dev/cli 0.5.6

package/node_modules/@cursor-pool/patcher/test/patchCursorWorkbench.test.ts

@@ -0,0 +1,770 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { Script } from 'node:vm';
+import test from 'node:test';
+import { sha256File } from '../src/hash';
+import {
+  CURSOR_POOL_WORKBENCH_AUTH_GATE_MARKER,
+  CURSOR_POOL_WORKBENCH_AUTH_GATE_SIGNATURE,
+  CURSOR_POOL_WORKBENCH_AGENT_LOOP_SIGNATURE,
+  CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE,
+  CURSOR_POOL_WORKBENCH_SUBMIT_GATE_SIGNATURE,
+  containsCursorWorkbenchAuthGateMarker,
+  injectCursorWorkbenchAuthGatePatch,
+} from '../src/workbenchAuthGateMarker';
+import {
+  patchCursorWorkbenchAuthGate,
+  backupPathForCursorWorkbenchAuthGate,
+  resolveCursorWorkbenchPath,
+} from '../src/patchCursorWorkbenchAuthGate';
+import { restoreCursorWorkbenchAuthGate } from '../src/restoreCursorWorkbenchAuthGate';
+
+const workbenchRelativePath = 'Contents/Resources/app/out/vs/workbench/workbench.desktop.main.js';
+const composerAuthGateAnchor =
+  'get when(){return p()&&!fzC},get fallback(){return he(DGC,{})}';
+const composerSubmitAuthGateAnchor =
+  'if(!p()){e.cursorAuthenticationService.login(),e.commandService.executeCommand(wV,"general");return}';
+const agentEditorSendButtonAuthGateAnchor =
+  'get when(){return t()},get fallback(){return(()=>{var D=avx();return Pe(D,he(sl,{keybinding:" \\u23CE",onClick:T,hintText:"Log in to use Cloud Agents",variant:"secondary",children:"Log in"})),D})()},get children(){return';
+const agentEditorSendButtonLoginAnchor =
+  'if(!t()){e.cursorAuthenticationService.login();return}';
+const agentLoopRunAnchor = 'await this.agentClientService.run(te,H,$e,Ne,Ce,T,ze,me,we,[],ct)';
+const buildFlagsLocalModeAnchor = 'localMode:!1';
+const localProviderConfigAnchor =
+  'async getLocalAgentProviderConfig(e){const t="[AgentClientService][getLocalAgentProviderConfig]",i=L0.localMode?await this.shellEnvironmentService.getShellEnv():{},r=e?.credentials,s=r?.case==="apiKeyCredentials"?r.value:void 0,o=this.reactiveStorageService.applicationUserPersistentStorage,a=o.useOpenAIKey===!0?this.cursorAuthenticationService.openAIKey()??void 0:void 0,u=xgS({apiKeyCandidates:[{value:s?.apiKey,source:"modelDetails.apiKeyCredentials.apiKey"},{value:a,source:"storage.openAIKey"}],baseUrlCandidates:[{value:s?.baseUrl,source:"modelDetails.apiKeyCredentials.baseUrl"},{value:o.openAIBaseUrl,source:"storage.openAIBaseUrl"}]});return{baseUrl:u.baseUrl,apiKey:u.apiKey}}createDefaultLocalModel(e){return "default"}';
+const agentClientRunLocalModeAnchor =
+  'if(L0.localMode){try{g.onNetworkPhaseStart?.()}catch(b){this.logService.warn("[AgentClientService] onNetworkPhaseStart callback failed in local mode",b)}return this.runLocalAgentInExtensionHost(e,t,i,r,s,a,d,h,g)}return this.client.run(e,t,i,r,s,o,a,u,d,h,g)';
+
+function workbenchFixture(extra = '') {
+  return [
+    `function composer(){return he(Mt,{${composerAuthGateAnchor},get children(){return "controls"}})}`,
+    `async function submit(){${composerSubmitAuthGateAnchor};return "submitted";}`,
+    `function agentEditorControls(){const T=()=>{${agentEditorSendButtonLoginAnchor};return n.handleSubmit()};return he(Mt,{${agentEditorSendButtonAuthGateAnchor}"controls"}})}`,
+    `const flags={${buildFlagsLocalModeAnchor}}`,
+    localProviderConfigAnchor,
+    `async function runAgentLoop(){${agentLoopRunAnchor}}`,
+    `async function agentClientRun(){const g={...p,isRunningInTest:p.isRunningInTest??this.environmentService.enableSmokeTestDriver===!0,clientSupportsInlineImages:!0};${agentClientRunLocalModeAnchor}}`,
+    extra,
+  ].join(';');
+}
+
+async function createFixture(
+  content = workbenchFixture(),
+) {
+  const base = await mkdtemp(join(tmpdir(), 'cursor-pool-workbench-patcher-'));
+  const appPath = join(base, `Fixture-${Date.now()}-${Math.random()}.app`);
+  await mkdir(join(appPath, 'Contents/Resources/app/out/vs/workbench'), {
+    recursive: true,
+  });
+  await writeFile(join(appPath, workbenchRelativePath), content, 'utf8');
+
+  return {
+    appPath,
+    targetPath: join(appPath, workbenchRelativePath),
+  };
+}
+
+test('workbench auth gate patch renders composer controls only with official login or active platform mode', () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const markerStart = patched.indexOf(CURSOR_POOL_WORKBENCH_AUTH_GATE_SIGNATURE);
+  const objectStart = patched.lastIndexOf('get when()', markerStart);
+  const objectEnd = patched.indexOf('get fallback()', markerStart) + 'get fallback(){return he(DGC,{})}'.length;
+  const objectLiteral = patched.slice(objectStart, objectEnd);
+
+  assert.equal(containsCursorWorkbenchAuthGateMarker(patched), true);
+  assert.equal(patched.includes(CURSOR_POOL_WORKBENCH_AUTH_GATE_MARKER), true);
+  assert.equal(patched.includes(CURSOR_POOL_WORKBENCH_AUTH_GATE_SIGNATURE), true);
+  assert.equal(patched.includes(CURSOR_POOL_WORKBENCH_SUBMIT_GATE_SIGNATURE), true);
+  assert.equal(patched.includes(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE), true);
+  assert.equal(
+    patched.includes('get when(){return (p()||((globalThis.__cursorPoolEnsurePlatformModeGuard||(globalThis.__cursorPoolEnsurePlatformModeGuard=()=>{'),
+    true,
+  );
+  assert.equal(patched.includes(composerAuthGateAnchor), false);
+  assert.equal(patched.includes(composerSubmitAuthGateAnchor), false);
+  assert.equal(
+    patched.includes(
+      'if(!p()&&!globalThis.__cursorPoolIsPlatformModeActive?.()){e.cursorAuthenticationService.login(),e.commandService.executeCommand(wV,"general");return}',
+    ),
+    true,
+  );
+  assert.doesNotThrow(() => new Function('he', 'DGC', `return ({${objectLiteral}});`));
+});
+
+test('workbench auth gate patch lets the Agent Editor send controls render in platform mode', () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+
+  assert.equal(patched.includes(agentEditorSendButtonAuthGateAnchor), false);
+  assert.equal(patched.includes(agentEditorSendButtonLoginAnchor), false);
+  assert.equal(
+    patched.includes('get when(){return t()||((globalThis.__cursorPoolEnsurePlatformModeGuard||(globalThis.__cursorPoolEnsurePlatformModeGuard=()=>{'),
+    true,
+  );
+  assert.equal(
+    patched.includes(
+      'if(!t()&&!((globalThis.__cursorPoolEnsurePlatformModeGuard||(globalThis.__cursorPoolEnsurePlatformModeGuard=()=>{',
+    ),
+    true,
+  );
+});
+
+test('workbench auth gate patch treats old V6 markers as legacy and reapplies Agent Editor gates', () => {
+  const oldV6Patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture()).replaceAll(
+    'CURSOR_POOL_MVP1_WORKBENCH_AUTH_GATE_PATCH_V9_ALWAYS_NATIVE_LOCAL',
+    'CURSOR_POOL_MVP1_WORKBENCH_AUTH_GATE_PATCH_V6_ACTIVE_ONLY_NATIVE_LOCAL_AGENT',
+  ).replace('["__cursorPoolWorkbenchAgentEditorSendButton"]:true,\n', '')
+    .replace('["__cursorPoolWorkbenchAgentEditorSubmit"]:true,\n', '')
+    .replace(
+      'get when(){return t()||globalThis.__cursorPoolIsPlatformModeActive?.()}',
+      'get when(){return t()}',
+    )
+    .replace(
+      'if(!t()&&!globalThis.__cursorPoolIsPlatformModeActive?.()){e.cursorAuthenticationService.login();return}',
+      'if(!t()){e.cursorAuthenticationService.login();return}',
+    );
+
+  assert.equal(containsCursorWorkbenchAuthGateMarker(oldV6Patched), false);
+  const repatched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+
+  assert.equal(containsCursorWorkbenchAuthGateMarker(repatched), true);
+  assert.equal(
+    repatched.includes('get when(){return t()||((globalThis.__cursorPoolEnsurePlatformModeGuard||(globalThis.__cursorPoolEnsurePlatformModeGuard=()=>{'),
+    true,
+  );
+});
+
+test('patchCursorWorkbenchAuthGate upgrades old V9 always-active guard from clean backup', async () => {
+  const backupDir = join(tmpdir(), `cursor-pool-workbench-v9-upgrade-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    const originalContent = await readFile(fixture.targetPath, 'utf8');
+    const backupPath = await backupPathForCursorWorkbenchAuthGate(
+      fixture.appPath,
+      fixture.targetPath,
+      backupDir,
+    );
+    await mkdir(dirname(backupPath), { recursive: true });
+    await writeFile(backupPath, originalContent, 'utf8');
+    const oldV9Patched = injectCursorWorkbenchAuthGatePatch(originalContent)
+      .replaceAll(
+        CURSOR_POOL_WORKBENCH_AUTH_GATE_MARKER,
+        'CURSOR_POOL_MVP1_WORKBENCH_AUTH_GATE_PATCH_V9_ALWAYS_NATIVE_LOCAL',
+      )
+      .replace(
+        /globalThis\.__cursorPoolIsPlatformModeActive=\(\)=>\{try\{.*?\}\},void 0\)/,
+        'globalThis.__cursorPoolIsPlatformModeActive=()=>!0,void 0)',
+      );
+    await writeFile(fixture.targetPath, oldV9Patched, 'utf8');
+
+    const result = await patchCursorWorkbenchAuthGate(fixture.appPath, { backupDir });
+    const upgraded = await readFile(fixture.targetPath, 'utf8');
+
+    assert.notEqual(result.afterHash, result.beforeHash);
+    assert.equal(containsCursorWorkbenchAuthGateMarker(upgraded), true);
+    assert.equal(upgraded.includes('CURSOR_POOL_MVP1_WORKBENCH_AUTH_GATE_PATCH_V9_ALWAYS_NATIVE_LOCAL'), false);
+    assert.equal(upgraded.includes('cursorPoolPlatformModeActive'), true);
+    assert.equal(upgraded.includes('globalThis.__cursorPoolIsPlatformModeActive=()=>!0'), false);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('workbench auth gate patch keeps the native agent loop instead of appending fake AI bubbles', () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+
+  assert.equal(patched.includes(CURSOR_POOL_WORKBENCH_AGENT_LOOP_SIGNATURE), true);
+  assert.equal(patched.includes(agentLoopRunAnchor), true);
+  assert.equal(patched.includes('/agent/takeover'), false);
+  assert.equal(patched.includes('fetch("http://127.0.0.1:56393/agent/takeover"'), false);
+  assert.equal(patched.includes('appendComposerBubbles'), false);
+  assert.equal(patched.includes('Tt=bt.content'), false);
+  assert.equal(patched.includes('De("status","completed")'), false);
+  assert.equal(patched.includes('return}}await this.agentClientService.run'), false);
+});
+
+test('workbench auth gate patch delegates agent turns to the local service only in platform mode', () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+
+  assert.equal(patched.includes(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE), true);
+  assert.equal(patched.includes('localMode:!1'), true);
+  assert.equal(patched.includes('localMode:!0'), false);
+  assert.equal(patched.includes('__cursorPoolIsPlatformModeActive'), true);
+  assert.equal(patched.includes('cursorPoolPlatformModeActive'), true);
+  assert.equal(patched.includes('/platform/status'), true);
+  assert.equal(patched.includes('mode?.state==="active"'), true);
+  assert.equal(patched.includes('platformMode==="active"'), true);
+  assert.equal(patched.includes('__cursorPoolRuntimeBaseUrl'), true);
+  assert.equal(patched.includes('baseUrl:r'), true);
+  assert.equal(patched.includes('baseUrl:"http://127.0.0.1:56393"'), false);
+  assert.equal(patched.includes('apiKey:"cursor-pool-local"'), true);
+  assert.equal(patched.includes('if(((globalThis.__cursorPoolEnsurePlatformModeGuard||(globalThis.__cursorPoolEnsurePlatformModeGuard=()=>{'), true);
+  assert.equal(patched.includes('if(!0||L0.localMode)'), false);
+  assert.equal(patched.includes('return this.runLocalAgentInExtensionHost(e,t,i,r,s,a,d,h,g)'), true);
+  assert.equal(patched.includes('return this.client.run(e,t,i,r,s,o,a,u,d,h,g)'), true);
+});
+
+test('workbench auth gate patch reads the local service port from runtime json', () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const markerStart = patched.indexOf(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE);
+  const objectStart = patched.lastIndexOf('get when()', markerStart);
+  const objectEnd = patched.indexOf('get fallback()', markerStart) + 'get fallback(){return he(DGC,{})}'.length;
+  const objectLiteral = patched.slice(objectStart, objectEnd);
+  const runtime = { host: '127.0.0.1', port: 61372, runtimeId: 'runtime-dynamic' };
+  const sandboxGlobal = {
+    localStorage: {
+      getItem() {
+        return null;
+      },
+      setItem() {},
+    },
+    setInterval() {
+      return 1;
+    },
+  } as { __cursorPoolRuntimeBaseUrl?: () => string | null };
+  const fakeRequire = (moduleName: string) => {
+    if (moduleName === 'node:fs') {
+      return {
+        existsSync: () => true,
+        readFileSync: (path: string) =>
+          path.endsWith('runtime.json')
+            ? JSON.stringify(runtime)
+            : JSON.stringify({ device: { status: 'inactive' } }),
+      };
+    }
+    if (moduleName === 'node:os') {
+      return { homedir: () => '/Users/tester' };
+    }
+    if (moduleName === 'node:path') {
+      return { join: (...parts: string[]) => parts.join('/') };
+    }
+    throw new Error(`unexpected module ${moduleName}`);
+  };
+
+  new Function(
+    'he',
+    'DGC',
+    'globalThis',
+    'require',
+    'process',
+    `return ({${objectLiteral}});`,
+  )(
+    () => undefined,
+    {},
+    sandboxGlobal,
+    fakeRequire,
+    { env: {} },
+  );
+
+  assert.equal(sandboxGlobal.__cursorPoolRuntimeBaseUrl?.(), 'http://127.0.0.1:61372');
+});
+
+test('workbench platform-mode guard self-bootstraps from the real session file shape', async () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const gatePrefix = 'get when(){return t()||';
+  const gateStart = patched.indexOf(gatePrefix);
+  const gateEnd = patched.indexOf('},get fallback(){return', gateStart);
+  const gateExpression = patched.slice(gateStart + gatePrefix.length, gateEnd);
+  const sandboxGlobal = {
+    localStorage: {
+      getItem() {
+        return null;
+      },
+      setItem() {},
+    },
+  } as {
+    __cursorPoolIsPlatformModeActive?: () => boolean;
+    __cursorPoolEnsurePlatformModeGuard?: () => void;
+  };
+  const session = {
+    device: { status: 'active' },
+    platformMode: 'active',
+    activeProductId: 'prod_basic',
+    platformModeStartedAt: '2026-06-04T03:10:06.880Z',
+  };
+  const fakeRequire = (moduleName: string) => {
+    if (moduleName === 'node:fs') {
+      return {
+        existsSync: () => true,
+        readFileSync: () => JSON.stringify(session),
+      };
+    }
+    if (moduleName === 'node:os') {
+      return { homedir: () => '/Users/tester' };
+    }
+    if (moduleName === 'node:path') {
+      return { join: (...parts: string[]) => parts.join('/') };
+    }
+    throw new Error(`unexpected module ${moduleName}`);
+  };
+
+  const gate = new Function(
+    't',
+    'globalThis',
+    'require',
+    'process',
+    `return ${gateExpression};`,
+  )(
+    () => false,
+    sandboxGlobal,
+    fakeRequire,
+    { env: {} },
+  );
+
+  assert.equal(gate, true);
+  assert.equal(sandboxGlobal.__cursorPoolIsPlatformModeActive?.(), true);
+});
+
+test('workbench platform-mode runtime guard does not trust stale renderer storage without verified timestamp', async () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const markerStart = patched.indexOf(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE);
+  const objectStart = patched.lastIndexOf('get when()', markerStart);
+  const objectEnd = patched.indexOf('get fallback()', markerStart) + 'get fallback(){return he(DGC,{})}'.length;
+  const objectLiteral = patched.slice(objectStart, objectEnd);
+  const values = new Map([['cursorPoolPlatformModeActive', '1']]);
+  const sandboxGlobal = {
+    localStorage: {
+      getItem(key: string) {
+        return values.get(key) ?? null;
+      },
+      setItem(key: string, value: string) {
+        values.set(key, value);
+      },
+    },
+    setInterval() {
+      return 1;
+    },
+  } as { __cursorPoolIsPlatformModeActive?: () => boolean };
+
+  new Function(
+    'he',
+    'DGC',
+    'globalThis',
+    'require',
+    `return ({${objectLiteral}});`,
+  )(
+    () => undefined,
+    {},
+    sandboxGlobal,
+    () => {
+      throw new Error('node require unavailable');
+    },
+  );
+
+  assert.equal(sandboxGlobal.__cursorPoolIsPlatformModeActive?.(), false);
+});
+
+test('workbench platform-mode runtime guard trusts recently verified renderer cache synchronously', async () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const markerStart = patched.indexOf(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE);
+  const objectStart = patched.lastIndexOf('get when()', markerStart);
+  const objectEnd = patched.indexOf('get fallback()', markerStart) + 'get fallback(){return he(DGC,{})}'.length;
+  const objectLiteral = patched.slice(objectStart, objectEnd);
+  const values = new Map([
+    ['cursorPoolPlatformModeActive', '1'],
+    ['cursorPoolPlatformModeCheckedAt', String(Date.now())],
+  ]);
+  const sandboxGlobal = {
+    localStorage: {
+      getItem(key: string) {
+        return values.get(key) ?? null;
+      },
+      setItem(key: string, value: string) {
+        values.set(key, value);
+      },
+    },
+    setInterval() {
+      return 1;
+    },
+  } as { __cursorPoolIsPlatformModeActive?: () => boolean };
+
+  new Function(
+    'he',
+    'DGC',
+    'globalThis',
+    'require',
+    `return ({${objectLiteral}});`,
+  )(
+    () => undefined,
+    {},
+    sandboxGlobal,
+    () => {
+      throw new Error('node require unavailable');
+    },
+  );
+
+  assert.equal(sandboxGlobal.__cursorPoolIsPlatformModeActive?.(), true);
+});
+
+test('workbench platform-mode runtime guard lets inactive session override stale renderer storage', async () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const markerStart = patched.indexOf(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE);
+  const objectStart = patched.lastIndexOf('get when()', markerStart);
+  const objectEnd = patched.indexOf('get fallback()', markerStart) + 'get fallback(){return he(DGC,{})}'.length;
+  const objectLiteral = patched.slice(objectStart, objectEnd);
+  const values = new Map([['cursorPoolPlatformModeActive', '1']]);
+  const sandboxGlobal = {
+    localStorage: {
+      getItem(key: string) {
+        return values.get(key) ?? null;
+      },
+      setItem(key: string, value: string) {
+        values.set(key, value);
+      },
+    },
+    fetch: async () => ({ ok: true, json: async () => ({ mode: { state: 'inactive' } }) }),
+    setInterval() {
+      return 1;
+    },
+    setTimeout(callback: () => unknown) {
+      callback();
+      return 1;
+    },
+    location: {
+      reload() {},
+    },
+  } as { __cursorPoolIsPlatformModeActive?: () => boolean };
+  const fakeRequire = (moduleName: string) => {
+    if (moduleName === 'node:fs') {
+      return {
+        existsSync: () => true,
+        readFileSync: (path: string) =>
+          path.endsWith('runtime.json')
+            ? JSON.stringify({ host: '127.0.0.1', port: 61372, runtimeId: 'runtime-inactive-test' })
+            : JSON.stringify({
+                device: { status: 'active' },
+                selectedProductId: 'prod_basic',
+              }),
+      };
+    }
+    if (moduleName === 'node:os') {
+      return { homedir: () => '/Users/tester' };
+    }
+    if (moduleName === 'node:path') {
+      return { join: (...parts: string[]) => parts.join('/') };
+    }
+    throw new Error(`unexpected module ${moduleName}`);
+  };
+
+  new Function('he', 'DGC', 'globalThis', 'require', 'process', `return ({${objectLiteral}});`)(
+    () => undefined,
+    {},
+    sandboxGlobal,
+    fakeRequire,
+    { env: {} },
+  );
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.equal(sandboxGlobal.__cursorPoolIsPlatformModeActive?.(), false);
+  assert.equal(values.get('cursorPoolPlatformModeActive'), '0');
+});
+
+test('workbench platform-mode runtime guard stores fetched active state and reloads', async () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const markerStart = patched.indexOf(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE);
+  const objectStart = patched.lastIndexOf('get when()', markerStart);
+  const objectEnd = patched.indexOf('get fallback()', markerStart) + 'get fallback(){return he(DGC,{})}'.length;
+  const objectLiteral = patched.slice(objectStart, objectEnd);
+  const values = new Map([['cursorPoolPlatformModeActive', '0']]);
+  let reloads = 0;
+  let fetchedUrl = '';
+  const timers: Array<() => unknown> = [];
+  const sandboxGlobal = {
+    localStorage: {
+      getItem(key: string) {
+        return values.get(key) ?? null;
+      },
+      setItem(key: string, value: string) {
+        values.set(key, value);
+      },
+    },
+    fetch: async (url: string) => {
+      fetchedUrl = url;
+      return { ok: true, json: async () => ({ mode: { state: 'active' } }) };
+    },
+    setInterval(callback: () => unknown) {
+      timers.push(callback);
+      return 1;
+    },
+    setTimeout(callback: () => unknown) {
+      callback();
+      return 1;
+    },
+    location: {
+      reload() {
+        reloads += 1;
+      },
+    },
+  } as { __cursorPoolIsPlatformModeActive?: () => boolean };
+  const fakeRequire = (moduleName: string) => {
+    if (moduleName === 'node:fs') {
+      return {
+        existsSync: () => true,
+        readFileSync: (path: string) =>
+          path.endsWith('runtime.json')
+            ? JSON.stringify({ host: '127.0.0.1', port: 61372, runtimeId: 'runtime-fetch-test' })
+            : JSON.stringify({ device: { status: 'inactive' } }),
+      };
+    }
+    if (moduleName === 'node:os') {
+      return { homedir: () => '/Users/tester' };
+    }
+    if (moduleName === 'node:path') {
+      return { join: (...parts: string[]) => parts.join('/') };
+    }
+    throw new Error(`unexpected module ${moduleName}`);
+  };
+
+  new Function('he', 'DGC', 'globalThis', 'require', 'process', `return ({${objectLiteral}});`)(
+    () => undefined,
+    {},
+    sandboxGlobal,
+    fakeRequire,
+    { env: {} },
+  );
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.equal(fetchedUrl, 'http://127.0.0.1:61372/platform/status');
+  assert.equal(values.get('cursorPoolPlatformModeActive'), '1');
+  assert.equal(sandboxGlobal.__cursorPoolIsPlatformModeActive?.(), true);
+  assert.equal(reloads, 1);
+});
+
+test('workbench platform-mode runtime guard falls back to the default local port without node require', async () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const markerStart = patched.indexOf(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE);
+  const objectStart = patched.lastIndexOf('get when()', markerStart);
+  const objectEnd = patched.indexOf('get fallback()', markerStart) + 'get fallback(){return he(DGC,{})}'.length;
+  const objectLiteral = patched.slice(objectStart, objectEnd);
+  const values = new Map([['cursorPoolPlatformModeActive', '0']]);
+  let fetchedUrl = '';
+  let reloads = 0;
+  const sandboxGlobal = {
+    localStorage: {
+      getItem(key: string) {
+        return values.get(key) ?? null;
+      },
+      setItem(key: string, value: string) {
+        values.set(key, value);
+      },
+    },
+    fetch: async (url: string) => {
+      fetchedUrl = url;
+      return { ok: true, json: async () => ({ mode: { state: 'active' } }) };
+    },
+    setInterval() {
+      return 1;
+    },
+    setTimeout(callback: () => unknown) {
+      callback();
+      return 1;
+    },
+    location: {
+      reload() {
+        reloads += 1;
+      },
+    },
+  } as { __cursorPoolIsPlatformModeActive?: () => boolean };
+
+  new Script(`(({he,DGC,globalThis})=>({${objectLiteral}}))`).runInNewContext({
+    he: () => undefined,
+    DGC: {},
+    globalThis: sandboxGlobal,
+  })({ he: () => undefined, DGC: {}, globalThis: sandboxGlobal });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.equal(fetchedUrl, 'http://127.0.0.1:56393/platform/status');
+  assert.equal(values.get('cursorPoolPlatformModeActive'), '1');
+  assert.equal(sandboxGlobal.__cursorPoolIsPlatformModeActive?.(), true);
+  assert.equal(reloads, 1);
+});
+
+test('workbench platform-mode runtime guard is renderer-safe without node require', () => {
+  const patched = injectCursorWorkbenchAuthGatePatch(workbenchFixture());
+  const markerStart = patched.indexOf(CURSOR_POOL_WORKBENCH_NATIVE_LOCAL_AGENT_SIGNATURE);
+  const objectStart = patched.lastIndexOf('get when()', markerStart);
+  const objectEnd = patched.indexOf('get fallback()', markerStart) + 'get fallback(){return he(DGC,{})}'.length;
+  const objectLiteral = patched.slice(objectStart, objectEnd);
+  const sandboxGlobal = {} as { __cursorPoolIsPlatformModeActive?: () => boolean };
+
+  new Script(`(({he,DGC,globalThis})=>({${objectLiteral}}))`).runInNewContext({
+    he: () => undefined,
+    DGC: {},
+    globalThis: sandboxGlobal,
+  })({ he: () => undefined, DGC: {}, globalThis: sandboxGlobal });
+
+  assert.equal(sandboxGlobal.__cursorPoolIsPlatformModeActive?.(), false);
+});
+
+test('workbench auth gate patch fails when the composer login anchor is missing', () => {
+  assert.throws(
+    () => injectCursorWorkbenchAuthGatePatch(workbenchFixture().replace(composerAuthGateAnchor, '')),
+    /composer auth gate anchor/,
+  );
+});
+
+test('workbench auth gate patch fails when the composer submit login anchor is missing', () => {
+  assert.throws(
+    () => injectCursorWorkbenchAuthGatePatch(workbenchFixture().replace(composerSubmitAuthGateAnchor, '')),
+    /composer submit auth gate anchor/,
+  );
+});
+
+test('workbench auth gate patch fails when the agent loop run anchor is missing', () => {
+  assert.throws(
+    () => injectCursorWorkbenchAuthGatePatch(workbenchFixture().replace(agentLoopRunAnchor, '')),
+    /agent loop run anchor/,
+  );
+});
+
+test('workbench auth gate patch fails when native local agent anchors are missing', () => {
+  assert.throws(
+    () => injectCursorWorkbenchAuthGatePatch(workbenchFixture().replace(buildFlagsLocalModeAnchor, '')),
+    /localMode build flag anchor/,
+  );
+  assert.throws(
+    () => injectCursorWorkbenchAuthGatePatch(workbenchFixture().replace(localProviderConfigAnchor, '')),
+    /local provider config anchor/,
+  );
+  assert.throws(
+    () => injectCursorWorkbenchAuthGatePatch(workbenchFixture().replace(agentClientRunLocalModeAnchor, '')),
+    /agent client run localMode anchor/,
+  );
+});
+
+test('patchCursorWorkbenchAuthGate writes a backup and marker', async () => {
+  const backupDir = join(tmpdir(), `cursor-pool-workbench-backups-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    const beforeHash = await sha256File(fixture.targetPath);
+    const result = await patchCursorWorkbenchAuthGate(fixture.appPath, { backupDir });
+    const patchedContent = await readFile(fixture.targetPath, 'utf8');
+
+    assert.equal(result.targetPath, resolveCursorWorkbenchPath(fixture.appPath));
+    assert.equal(result.beforeHash, beforeHash);
+    assert.equal(result.afterHash, await sha256File(fixture.targetPath));
+    assert.equal(result.markerPresent, true);
+    assert.equal(containsCursorWorkbenchAuthGateMarker(patchedContent), true);
+    assert.equal(await readFile(result.backupPath, 'utf8'), await readFile(result.backupPath, 'utf8'));
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('patchCursorWorkbenchAuthGate supports Linux Cursor relative paths', async () => {
+  const base = await mkdtemp(join(tmpdir(), 'cursor-pool-workbench-linux-'));
+  const appPath = join(base, 'squashfs-root');
+  const linuxWorkbenchRelativePath =
+    'usr/share/cursor/resources/app/out/vs/workbench/workbench.desktop.main.js';
+  const targetPath = join(appPath, linuxWorkbenchRelativePath);
+  const backupDir = join(tmpdir(), `cursor-pool-workbench-linux-backups-${Date.now()}-${Math.random()}`);
+
+  try {
+    await mkdir(join(appPath, 'usr/share/cursor/resources/app/out/vs/workbench'), {
+      recursive: true,
+    });
+    await writeFile(targetPath, workbenchFixture(), 'utf8');
+
+    assert.equal(resolveCursorWorkbenchPath(appPath, linuxWorkbenchRelativePath), targetPath);
+    const beforeHash = await sha256File(targetPath);
+    const result = await patchCursorWorkbenchAuthGate(appPath, {
+      backupDir,
+      targetRelativePath: linuxWorkbenchRelativePath,
+    });
+    const patchedContent = await readFile(targetPath, 'utf8');
+
+    assert.equal(result.targetPath, targetPath);
+    assert.equal(result.beforeHash, beforeHash);
+    assert.notEqual(result.afterHash, beforeHash);
+    assert.equal(containsCursorWorkbenchAuthGateMarker(patchedContent), true);
+  } finally {
+    await rm(base, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('restoreCursorWorkbenchAuthGate returns patched target to original hash and removes marker', async () => {
+  const backupDir = join(tmpdir(), `cursor-pool-workbench-restore-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    const beforeHash = await sha256File(fixture.targetPath);
+    const patch = await patchCursorWorkbenchAuthGate(fixture.appPath, { backupDir });
+    assert.equal(containsCursorWorkbenchAuthGateMarker(await readFile(fixture.targetPath, 'utf8')), true);
+
+    const restore = await restoreCursorWorkbenchAuthGate(fixture.appPath, { backupDir });
+
+    assert.equal(patch.beforeHash, beforeHash);
+    assert.equal(restore.beforeHash, patch.afterHash);
+    assert.equal(restore.afterHash, beforeHash);
+    assert.equal(containsCursorWorkbenchAuthGateMarker(await readFile(fixture.targetPath, 'utf8')), false);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('restoreCursorWorkbenchAuthGate supports Linux Cursor relative paths', async () => {
+  const base = await mkdtemp(join(tmpdir(), 'cursor-pool-workbench-linux-restore-'));
+  const appPath = join(base, 'squashfs-root');
+  const linuxWorkbenchRelativePath =
+    'usr/share/cursor/resources/app/out/vs/workbench/workbench.desktop.main.js';
+  const targetPath = join(appPath, linuxWorkbenchRelativePath);
+  const backupDir = join(tmpdir(), `cursor-pool-workbench-linux-restore-backups-${Date.now()}-${Math.random()}`);
+
+  try {
+    await mkdir(join(appPath, 'usr/share/cursor/resources/app/out/vs/workbench'), {
+      recursive: true,
+    });
+    await writeFile(targetPath, workbenchFixture(), 'utf8');
+    const beforeHash = await sha256File(targetPath);
+    await patchCursorWorkbenchAuthGate(appPath, {
+      backupDir,
+      targetRelativePath: linuxWorkbenchRelativePath,
+    });
+
+    const restore = await restoreCursorWorkbenchAuthGate(appPath, {
+      backupDir,
+      targetRelativePath: linuxWorkbenchRelativePath,
+    });
+
+    assert.equal(restore.targetPath, targetPath);
+    assert.equal(restore.afterHash, beforeHash);
+    assert.equal(containsCursorWorkbenchAuthGateMarker(await readFile(targetPath, 'utf8')), false);
+  } finally {
+    await rm(base, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('restoreCursorWorkbenchAuthGate refuses a backup that contains auth gate marker text', async () => {
+  const backupDir = join(tmpdir(), `cursor-pool-workbench-bad-backup-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    await patchCursorWorkbenchAuthGate(fixture.appPath, { backupDir });
+    const patchedHash = await sha256File(fixture.targetPath);
+    const backupPath = await backupPathForCursorWorkbenchAuthGate(
+      fixture.appPath,
+      fixture.targetPath,
+      backupDir,
+    );
+    await writeFile(backupPath, await readFile(fixture.targetPath, 'utf8'), 'utf8');
+
+    await assert.rejects(
+      restoreCursorWorkbenchAuthGate(fixture.appPath, { backupDir }),
+      /backup.*patch marker/i,
+    );
+
+    assert.equal(await sha256File(fixture.targetPath), patchedHash);
+    assert.equal(containsCursorWorkbenchAuthGateMarker(await readFile(fixture.targetPath, 'utf8')), true);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});