@cursorpool-dev/cli 0.5.8 → 0.5.10

package/test/extensionLink.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { isAbsolute, join, relative } from 'node:path';
 import test from 'node:test';
 import {
   getLinkedExtensionState,
@@ -12,12 +12,12 @@ import {
   snapshotLinkedExtensionBundle,
 } from '../src/extensionLink';
 
-async function createSourceBundle(tempDir: string, version = '0.0.0') {
+async function createSourceBundle(tempDir: string) {
   const sourceBundlePath = join(tempDir, 'source/extensions/cursor-pool-status');
   await mkdir(join(sourceBundlePath, 'dist'), { recursive: true });
   await writeFile(
     join(sourceBundlePath, 'package.json'),
-    JSON.stringify({ name: 'cursorpool', publisher: 'cursor-pool', version }),
+    JSON.stringify({ name: 'cursorpool', publisher: 'cursor-pool', version: '0.0.0' }),
     'utf8',
   );
   await writeFile(join(sourceBundlePath, 'dist/extension.js'), 'export function activate() {}\n', 'utf8');
@@ -54,52 +54,6 @@ test('linkExtensionBundle copies source bundle into Cursor extensions directory'
   }
 });
 
-test('linkExtensionBundle uses the source manifest version for the linked directory and index', async () => {
-  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-version-'));
-  const sourceBundlePath = await createSourceBundle(tempDir, '0.5.6');
-  const cursorExtensionsDir = join(tempDir, 'Extensions');
-  await mkdir(cursorExtensionsDir, { recursive: true });
-  await writeFile(join(cursorExtensionsDir, 'extensions.json'), '[]', 'utf8');
-
-  try {
-    const result = await linkExtensionBundle({ sourceBundlePath, cursorExtensionsDir });
-    const index = JSON.parse(await readFile(join(cursorExtensionsDir, 'extensions.json'), 'utf8'));
-
-    assert.deepEqual(result, {
-      state: 'linked',
-      linkedPath: join(cursorExtensionsDir, 'cursor-pool.extension-0.5.6'),
-    });
-    assert.equal(await getLinkedExtensionState(result.linkedPath), 'linked');
-    assert.deepEqual(index.at(-1), {
-      identifier: { id: 'cursor-pool.cursorpool' },
-      location: {
-        $mid: 1,
-        path: result.linkedPath,
-        scheme: 'file',
-      },
-      relativeLocation: 'cursor-pool.extension-0.5.6',
-      version: '0.5.6',
-    });
-  } finally {
-    await rm(tempDir, { recursive: true, force: true });
-  }
-});
-
-test('linkExtensionBundle rejects unsafe source manifest versions before linking', async () => {
-  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-version-unsafe-'));
-  const sourceBundlePath = await createSourceBundle(tempDir, '../../bad');
-  const cursorExtensionsDir = join(tempDir, 'Extensions');
-
-  try {
-    await assert.rejects(
-      linkExtensionBundle({ sourceBundlePath, cursorExtensionsDir }),
-      /Unsafe extension version/,
-    );
-  } finally {
-    await rm(tempDir, { recursive: true, force: true });
-  }
-});
-
 test('linkExtensionBundle refreshes Cursor extensions index with runtime extension id', async () => {
   const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-index-'));
   const sourceBundlePath = await createSourceBundle(tempDir);
@@ -169,6 +123,29 @@ test('linkExtensionBundle refreshes Cursor extensions index with runtime extensi
   }
 });
 
+test('linkExtensionBundle writes an absolute linked extension location for relative cursor extensions dir', async () => {
+  const tempDir = await mkdtemp(join(process.cwd(), '.cursor-pool-extension-link-relative-'));
+  const sourceBundlePath = await createSourceBundle(tempDir);
+  const cursorExtensionsDir = join(tempDir, 'Extensions');
+  const relativeCursorExtensionsDir = relative(process.cwd(), cursorExtensionsDir);
+  await mkdir(cursorExtensionsDir, { recursive: true });
+  await writeFile(join(cursorExtensionsDir, 'extensions.json'), '[]\n', 'utf8');
+
+  try {
+    const result = await linkExtensionBundle({
+      sourceBundlePath,
+      cursorExtensionsDir: relativeCursorExtensionsDir,
+    });
+    const index = JSON.parse(await readFile(join(cursorExtensionsDir, 'extensions.json'), 'utf8'));
+
+    assert.equal(isAbsolute(result.linkedPath), true);
+    assert.equal(isAbsolute(index.at(-1).location.path), true);
+    assert.equal(index.at(-1).location.path, result.linkedPath);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
 test('linkExtensionBundle reports missing when source bundle is absent', async () => {
   const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-missing-'));
   const cursorExtensionsDir = join(tempDir, 'Extensions');

package/test/install.test.ts

@@ -69,36 +69,15 @@ async function createFixtureApp() {
   );
   await writeFile(targetPath, targetContent, 'utf8');
   await writeFile(join(appPath, alwaysLocalRelativePath), 'function alwaysLocal(){}\n', 'utf8');
-  const workbenchContent = workbenchFixture();
-  await writeFile(join(appPath, workbenchRelativePath), workbenchContent, 'utf8');
+  await writeFile(join(appPath, workbenchRelativePath), workbenchFixture(), 'utf8');
 
   const expectedSha256 = createHash('sha256').update(targetContent).digest('hex');
-  const workbenchSha256 = createHash('sha256').update(workbenchContent).digest('hex');
   const compatEntry: CompatibilityManifestEntry = {
     platform: process.platform,
     arch: process.arch,
-    cursorVersion: '3.5',
+    cursorVersion: '3.5.38',
     cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
     supportStatus: 'supported',
-    adapterVersion: '0.5.8',
-    takeoverPlanId: 'cursor-3.5-mac-agent-f-workbench-p-l0',
-    structureFamily: 'mac-agent-F-workbench-p-L0',
-    patchTargets: [
-      {
-        name: 'agent-exec',
-        targetRelativePath,
-        expectedSha256,
-        patchStrategy: 'cursor-agent-exec-snippet',
-        verifyMarker: 'cursor-pool',
-      },
-      {
-        name: 'workbench',
-        targetRelativePath: workbenchRelativePath,
-        expectedSha256: workbenchSha256,
-        patchStrategy: 'cursor-workbench-auth-gate',
-        verifyMarker: 'cursor-pool-workbench',
-      },
-    ],
     targetRelativePath,
     expectedSha256,
     structureSignature: 'fixture',
@@ -162,10 +141,9 @@ async function createLinuxFixtureApp() {
   const compatEntry: CompatibilityManifestEntry = {
     platform: 'linux',
     arch: process.arch,
-    cursorVersion: '3.6',
+    cursorVersion: '3.6.31',
     cursorCommit: 'linux-commit',
     supportStatus: 'supported',
-    takeoverPlanId: 'cursor-3.6-mac-agent-c-workbench-h-uv',
     targetRelativePath,
     expectedSha256,
     structureSignature: 'linux-fixture',
@@ -210,7 +188,7 @@ async function createRemoteOnlyFixtureApp() {
   );
   const compatEntry = {
     ...fixture.compatEntry,
-    cursorVersion: '3.7',
+    cursorVersion: '3.7.0',
     cursorCommit: 'remote-commit',
     userMessage: 'remote fixture supported',
   };
@@ -234,7 +212,6 @@ test('install reports Cursor version, simulated extension, service, patch, and h
     assert.match(output, /Cursor 3\.5\.38/);
     assert.match(output, /mode: disposable/);
     assert.match(output, /app: .*Cursor\.app/);
-    assert.match(output, /takeover-plan: cursor-3\.5-mac-agent-f-workbench-p-l0/);
     assert.match(output, /extension: bundled/);
     assert.match(output, /trial: recorded/);
     assert.match(output, /service: running/);
@@ -310,36 +287,6 @@ test('install can use a signed remote compatibility manifest from api base url',
   }
 });
 
-test('install rejects when a secondary patch target hash does not match', async () => {
-  const fixture = await createFixtureApp();
-  const compatEntry: CompatibilityManifestEntry = {
-    ...fixture.compatEntry,
-    patchTargets: fixture.compatEntry.patchTargets?.map((target) =>
-      target.name === 'workbench'
-        ? { ...target, expectedSha256: 'f'.repeat(64) }
-        : target,
-    ),
-  };
-
-  try {
-    await assert.rejects(
-      () =>
-        install({
-          appPath: fixture.appPath,
-          runtimeFile: fixture.runtimeFile,
-          backupDir: fixture.backupDir,
-          trialRecordDir: join(fixture.tempDir, 'trials'),
-          extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
-          compatEntries: [compatEntry],
-          stopServiceAfterInstall: true,
-        }),
-      /Patch target hash mismatch/,
-    );
-  } finally {
-    await rm(fixture.tempDir, { recursive: true, force: true });
-  }
-});
-
 test('install passes API base URL to detached service startup', async () => {
   const fixture = await createFixtureApp();
   const serviceCalls: Record<string, unknown>[] = [];
@@ -548,7 +495,6 @@ test('real-mode install writes install record and reports real mode', async () =
     });
 
     assert.match(output, /mode: real/);
-    assert.match(output, /takeover-plan: cursor-3\.5-mac-agent-f-workbench-p-l0/);
     assert.match(output, /patch: applied/);
     assert.match(output, /install-record: recorded/);
     assert.doesNotMatch(output, /trial: recorded/);
@@ -559,7 +505,6 @@ test('real-mode install writes install record and reports real mode', async () =
     assert.equal(record.mode, 'real');
     assert.equal(record.appPath, fixture.appPath);
     assert.equal(record.cursorVersion, '3.5.38');
-    assert.equal(record.takeoverPlanId, 'cursor-3.5-mac-agent-f-workbench-p-l0');
     assert.equal(record.extensionInstallPath, extensionInstallPath);
     assert.equal(record.extensionLinkedPath, linkedExtensionPathForDir(cursorExtensionsDir));
     assert.equal(record.lastOperation, 'install');
@@ -573,7 +518,6 @@ test('real-mode install rolls back install record after health failure', async (
   const fixture = await createFixtureApp();
   const installRecordFile = join(fixture.tempDir, 'install.json');
   const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
-  const cursorExtensionsDir = join(fixture.tempDir, 'real-extensions');
 
   try {
     await assert.rejects(
@@ -584,7 +528,6 @@ test('real-mode install rolls back install record after health failure', async (
         backupDir: fixture.backupDir,
         installRecordFile,
         extensionInstallPath,
-        cursorExtensionsDir,
         compatEntries: [fixture.compatEntry],
         stopServiceAfterInstall: true,
         fetchHealth: async () => ({ ok: false, healthy: false }),
@@ -603,7 +546,6 @@ test('real-mode install requires confirmation when yes is missing', async () =>
   const originalTargetContent = await readFile(fixture.targetPath, 'utf8');
   const installRecordFile = join(fixture.tempDir, 'install.json');
   const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
-  const cursorExtensionsDir = join(fixture.tempDir, 'real-extensions');
 
   try {
     await assert.rejects(
@@ -614,7 +556,6 @@ test('real-mode install requires confirmation when yes is missing', async () =>
         backupDir: fixture.backupDir,
         installRecordFile,
         extensionInstallPath,
-        cursorExtensionsDir,
         compatEntries: [fixture.compatEntry],
         stopServiceAfterInstall: true,
       }),
@@ -653,7 +594,6 @@ test('install links extension into an explicit Cursor extensions directory', asy
     assert.equal(await getLinkedExtensionState(linkedPath), 'linked');
 
     const trialRecord = await readTrialRecord(fixture.appPath, { trialRecordDir });
-    assert.equal(trialRecord?.takeoverPlanId, 'cursor-3.5-mac-agent-f-workbench-p-l0');
     assert.equal(trialRecord?.extensionState, 'linked');
     assert.equal(trialRecord?.extensionInstallPath, extensionInstallPath);
     assert.equal(trialRecord?.extensionLinkedPath, linkedPath);

package/test/patchSet.test.ts

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { readCursorPatchSetState } from '../src/patchSet';
+
+async function withLinuxCursorApp(rootKind: 'deb' | 'appimage') {
+  const tempDir = await mkdtemp(join(tmpdir(), `cursor-pool-patchset-${rootKind}-`));
+  const appPath = rootKind === 'deb' ? join(tempDir, 'cursor') : join(tempDir, 'squashfs-root');
+  const resourceRoot =
+    rootKind === 'deb' ? join(appPath, 'resources/app') : join(appPath, 'usr/share/cursor/resources/app');
+  await mkdir(join(resourceRoot, 'extensions/cursor-agent-exec/dist'), { recursive: true });
+  await mkdir(join(resourceRoot, 'out/vs/workbench'), { recursive: true });
+  await writeFile(
+    join(resourceRoot, 'extensions/cursor-agent-exec/dist/main.js'),
+    'function agent(){}\n',
+    'utf8',
+  );
+  await writeFile(
+    join(resourceRoot, 'out/vs/workbench/workbench.desktop.main.js'),
+    'function workbench(){}\n',
+    'utf8',
+  );
+  return { appPath, tempDir, resourceRoot };
+}
+
+test('readCursorPatchSetState resolves Linux deb install patch targets from /usr/share/cursor root', async () => {
+  const fixture = await withLinuxCursorApp('deb');
+
+  try {
+    const state = await readCursorPatchSetState(fixture.appPath, {
+      platform: 'linux',
+      agentExecTargetRelativePath: 'resources/app/extensions/cursor-agent-exec/dist/main.js',
+    });
+
+    assert.equal(
+      state.patches.find((patch) => patch.name === 'agent-exec')?.targetPath,
+      join(fixture.resourceRoot, 'extensions/cursor-agent-exec/dist/main.js'),
+    );
+    assert.equal(
+      state.patches.find((patch) => patch.name === 'workbench')?.targetPath,
+      join(fixture.resourceRoot, 'out/vs/workbench/workbench.desktop.main.js'),
+    );
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('readCursorPatchSetState keeps Linux AppImage squashfs-root patch targets unchanged', async () => {
+  const fixture = await withLinuxCursorApp('appimage');
+
+  try {
+    const state = await readCursorPatchSetState(fixture.appPath, {
+      platform: 'linux',
+      agentExecTargetRelativePath:
+        'usr/share/cursor/resources/app/extensions/cursor-agent-exec/dist/main.js',
+    });
+
+    assert.equal(
+      state.patches.find((patch) => patch.name === 'agent-exec')?.targetPath,
+      join(fixture.resourceRoot, 'extensions/cursor-agent-exec/dist/main.js'),
+    );
+    assert.equal(
+      state.patches.find((patch) => patch.name === 'workbench')?.targetPath,
+      join(fixture.resourceRoot, 'out/vs/workbench/workbench.desktop.main.js'),
+    );
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});

package/test/repair.test.ts

@@ -89,7 +89,6 @@ async function createFixtureApp() {
     cursorVersion: '3.5.38',
     cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
     supportStatus: 'supported',
-    takeoverPlanId: 'cursor-3.6-mac-agent-c-workbench-h-uv',
     targetRelativePath,
     expectedSha256: createHash('sha256').update(targetContent).digest('hex'),
     structureSignature: 'fixture',
@@ -208,6 +207,137 @@ test('repair restarts stopped service and updates install record', async () => {
   }
 });
 
+test('repair accepts version-family compatibility entries with wildcard commits', async () => {
+  const fixture = await createFixtureApp();
+  const familyCompatEntry: CompatibilityManifestEntry = {
+    ...fixture.compatEntry,
+    cursorVersion: '3.5',
+    cursorCommit: '*',
+  };
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    await seedInstallRecord(fixture);
+
+    const output = await repair({
+      realAppPath: fixture.appPath,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [familyCompatEntry],
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45207, runtimeId: 'runtime-repaired-family' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45207, runtimeId: 'runtime-repaired-family' };
+      },
+    });
+
+    assert.match(output, /compat: supported/);
+    assert.match(output, /repair: ok/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair passes platform through when checking and repairing the full patch set', async () => {
+  const fixture = await createFixtureApp();
+  let workbenchTargetRelativePath: string | undefined;
+  const linuxDebTargetRelativePath =
+    'resources/app/extensions/cursor-agent-exec/dist/main.js';
+  const linuxDebWorkbenchRelativePath =
+    'resources/app/out/vs/workbench/workbench.desktop.main.js';
+
+  try {
+    await mkdir(join(fixture.appPath, 'resources/app/extensions/cursor-agent-exec/dist'), {
+      recursive: true,
+    });
+    await mkdir(join(fixture.appPath, 'resources/app/out/vs/workbench'), { recursive: true });
+    await writeFile(
+      join(fixture.appPath, 'resources/app/product.json'),
+      JSON.stringify({
+        version: '3.5.38',
+        commit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+      }),
+      'utf8',
+    );
+    await writeFile(
+      join(fixture.appPath, linuxDebTargetRelativePath),
+      `${fixture.targetContent}${CURSOR_POOL_PATCH_MARKER}\n`,
+      'utf8',
+    );
+    await writeFile(
+      join(fixture.appPath, linuxDebWorkbenchRelativePath),
+      'function workbenchWithoutMarker(){}\n',
+      'utf8',
+    );
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    await writeInstallRecord(
+      createInstallRecordFixture(fixture, {
+        targetRelativePath: linuxDebTargetRelativePath,
+        originalSha256: '*',
+      }),
+      { installRecordFile: fixture.installRecordFile },
+    );
+
+    await repair({
+      realAppPath: fixture.appPath,
+      productRelativePath: 'resources/app/product.json',
+      platform: 'linux',
+      arch: process.arch,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [
+        {
+          ...fixture.compatEntry,
+          platform: 'linux',
+          arch: process.arch,
+          targetRelativePath: linuxDebTargetRelativePath,
+          expectedSha256: '*',
+        },
+      ],
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45208, runtimeId: 'runtime-repaired-linux-platform' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45208, runtimeId: 'runtime-repaired-linux-platform' };
+      },
+      patchCursorAgentExec: async (_appPath, options = {}) => ({
+        targetPath: join(fixture.appPath, options.targetRelativePath ?? targetRelativePath),
+        backupPath: join(fixture.backupDir, 'agent.bak'),
+        beforeHash: 'before',
+        afterHash: 'after',
+        markerPresent: true,
+      }),
+      patchCursorWorkbenchAuthGate: async (_appPath, options = {}) => {
+        workbenchTargetRelativePath = options.targetRelativePath;
+        return {
+          targetPath: join(fixture.appPath, options.targetRelativePath ?? workbenchRelativePath),
+          backupPath: join(fixture.backupDir, 'workbench.bak'),
+          beforeHash: 'before',
+          afterHash: 'after',
+          markerPresent: true,
+        };
+      },
+    });
+
+    assert.equal(
+      workbenchTargetRelativePath,
+      linuxDebWorkbenchRelativePath,
+    );
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
 test('repair restores missing extension bundle', async () => {
   const fixture = await createFixtureApp();
 

package/test/restore.test.ts

@@ -5,6 +5,8 @@ import { join, normalize } from 'node:path';
 import test from 'node:test';
 import { CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR } from '../../patcher/src/marker';
 import { patchCursorAgentExec } from '../../patcher/src/patchCursorAgentExec';
+import { patchCursorAlwaysLocal } from '../../patcher/src/patchCursorAlwaysLocal';
+import { patchCursorWorkbenchAuthGate } from '../../patcher/src/patchCursorWorkbenchAuthGate';
 import {
   installIdForAppPath,
   readInstallRecord,
@@ -16,15 +18,57 @@ import { trialIdForAppPath, writeTrialRecord } from '../src/trial';
 
 const targetRelativePath =
   'Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js';
+const alwaysLocalRelativePath =
+  'Contents/Resources/app/extensions/cursor-always-local/dist/main.js';
+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 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() {
+  return [
+    `function composer(){return he(Mt,{${composerAuthGateAnchor},get children(){return "controls"}})}`,
+    `async function submit(){${composerSubmitAuthGateAnchor};return "submitted";}`,
+    `const flags={${buildFlagsLocalModeAnchor}}`,
+    localProviderConfigAnchor,
+    `async function runAgentLoop(){${agentLoopRunAnchor}}`,
+    `async function agentClientRun(){const g={};${agentClientRunLocalModeAnchor}}`,
+  ].join(';');
+}
+
+async function patchFullSet(appPath: string, backupDir: string) {
+  await patchCursorAgentExec(appPath, { backupDir });
+  await patchCursorAlwaysLocal(appPath, { backupDir });
+  await patchCursorWorkbenchAuthGate(appPath, { backupDir });
+}
 
 async function createFixtureApp() {
   const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-cli-restore-'));
   const appPath = join(tempDir, 'Cursor.app');
   const targetPath = join(appPath, targetRelativePath);
+  const alwaysLocalPath = join(appPath, alwaysLocalRelativePath);
+  const workbenchPath = join(appPath, workbenchRelativePath);
   const targetContent = `function main() { return "agent"; }\n${CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR}\nmain();\n`;
+  const alwaysLocalContent = 'function alwaysLocal(){}\n';
+  const workbenchContent = workbenchFixture();
   await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-agent-exec/dist'), {
     recursive: true,
   });
+  await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-always-local/dist'), {
+    recursive: true,
+  });
+  await mkdir(join(appPath, 'Contents/Resources/app/out/vs/workbench'), {
+    recursive: true,
+  });
   await writeFile(
     join(appPath, 'Contents/Resources/app/product.json'),
     JSON.stringify({
@@ -34,12 +78,18 @@ async function createFixtureApp() {
     'utf8',
   );
   await writeFile(targetPath, targetContent, 'utf8');
+  await writeFile(alwaysLocalPath, alwaysLocalContent, 'utf8');
+  await writeFile(workbenchPath, workbenchContent, 'utf8');
 
   return {
     appPath,
     tempDir,
     targetPath,
+    alwaysLocalPath,
+    workbenchPath,
     targetContent,
+    alwaysLocalContent,
+    workbenchContent,
     backupDir: join(tempDir, 'backups'),
     trialRecordDir: join(tempDir, 'trials'),
   };
@@ -49,7 +99,7 @@ test('restore reports ok and replaces patched fixture bytes with backup bytes',
   const fixture = await createFixtureApp();
 
   try {
-    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    await patchFullSet(fixture.appPath, fixture.backupDir);
 
     const output = await restore({
       appPath: fixture.appPath,
@@ -59,6 +109,8 @@ test('restore reports ok and replaces patched fixture bytes with backup bytes',
     assert.match(output, /mode: disposable/);
     assert.match(output, /restore: ok/);
     assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+    assert.equal(await readFile(fixture.alwaysLocalPath, 'utf8'), fixture.alwaysLocalContent);
+    assert.equal(await readFile(fixture.workbenchPath, 'utf8'), fixture.workbenchContent);
   } finally {
     await rm(fixture.tempDir, { recursive: true, force: true });
   }
@@ -68,7 +120,7 @@ test('restore discovers backup directory from the trial record', async () => {
   const fixture = await createFixtureApp();
 
   try {
-    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    await patchFullSet(fixture.appPath, fixture.backupDir);
     await writeTrialRecord(
       {
         trialId: trialIdForAppPath(fixture.appPath),
@@ -96,6 +148,8 @@ test('restore discovers backup directory from the trial record', async () => {
     assert.match(output, /mode: disposable/);
     assert.match(output, /restore: ok/);
     assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+    assert.equal(await readFile(fixture.alwaysLocalPath, 'utf8'), fixture.alwaysLocalContent);
+    assert.equal(await readFile(fixture.workbenchPath, 'utf8'), fixture.workbenchContent);
   } finally {
     await rm(fixture.tempDir, { recursive: true, force: true });
   }
@@ -136,7 +190,7 @@ test('real-mode restore uses install record backup and keeps install record', as
   const runtimeFile = join(fixture.tempDir, 'runtime.json');
 
   try {
-    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    await patchFullSet(fixture.appPath, fixture.backupDir);
     const record = createInstallRecordFixture(fixture, { runtimeFile });
     await writeInstallRecord(record, { installRecordFile });
 
@@ -150,6 +204,8 @@ test('real-mode restore uses install record backup and keeps install record', as
     assert.match(output, /install-record: recorded/);
     assert.match(output, /restore: ok/);
     assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+    assert.equal(await readFile(fixture.alwaysLocalPath, 'utf8'), fixture.alwaysLocalContent);
+    assert.equal(await readFile(fixture.workbenchPath, 'utf8'), fixture.workbenchContent);
     assert.deepEqual(await readInstallRecord({ installRecordFile }), record);
   } finally {
     await rm(fixture.tempDir, { recursive: true, force: true });

package/test/status.test.ts

@@ -136,7 +136,6 @@ async function createFixtureApp() {
     cursorVersion: '3.5.38',
     cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
     supportStatus: 'supported',
-    takeoverPlanId: 'cursor-3.6-mac-agent-c-workbench-h-uv',
     targetRelativePath,
     expectedSha256: createHash('sha256').update(targetContent).digest('hex'),
     structureSignature: 'fixture',

package/test/target.test.ts

@@ -16,6 +16,34 @@ test('resolveCursorTarget treats explicit appPath as disposable mode', () => {
   );
 });
 
+test('resolveCursorTarget treats Linux deb Cursor root as real mode', () => {
+  assert.deepEqual(
+    resolveCursorTarget({
+      appPath: '/usr/share/cursor/',
+      platform: 'linux',
+    }),
+    {
+      mode: 'real',
+      appPath: '/usr/share/cursor',
+      requiresConfirmation: true,
+    },
+  );
+});
+
+test('resolveCursorTarget keeps Linux AppImage extraction roots disposable', () => {
+  assert.deepEqual(
+    resolveCursorTarget({
+      appPath: '/home/debian/.cursor-pool/appimages/Cursor-abc/squashfs-root',
+      platform: 'linux',
+    }),
+    {
+      mode: 'disposable',
+      appPath: '/home/debian/.cursor-pool/appimages/Cursor-abc/squashfs-root',
+      requiresConfirmation: false,
+    },
+  );
+});
+
 test('resolveCursorTarget rejects the real Cursor app as disposable appPath', () => {
   assert.throws(
     () => resolveCursorTarget({ appPath: '/Applications/Cursor.app' }),