@cursorpool-dev/cli 0.5.9 → 0.5.10

package/src/patchSet.ts

@@ -54,13 +54,43 @@ const LINUX_WORKBENCH_RELATIVE_PATH =
   'usr/share/cursor/resources/app/out/vs/workbench/workbench.desktop.main.js';
 const LINUX_ALWAYS_LOCAL_RELATIVE_PATH =
   'usr/share/cursor/resources/app/extensions/cursor-always-local/dist/main.js';
+const LINUX_DEB_WORKBENCH_RELATIVE_PATH =
+  'resources/app/out/vs/workbench/workbench.desktop.main.js';
+const LINUX_DEB_ALWAYS_LOCAL_RELATIVE_PATH =
+  'resources/app/extensions/cursor-always-local/dist/main.js';
 
-function workbenchRelativePath(options: { platform?: NodeJS.Platform; workbenchTargetRelativePath?: string }) {
-  return options.workbenchTargetRelativePath ?? (options.platform === 'linux' ? LINUX_WORKBENCH_RELATIVE_PATH : CURSOR_WORKBENCH_RELATIVE_PATH);
+function linuxUsesDebRoot(options: { agentExecTargetRelativePath?: string }) {
+  return options.agentExecTargetRelativePath?.startsWith('resources/app/') ?? false;
 }
 
-function alwaysLocalRelativePath(options: { platform?: NodeJS.Platform; alwaysLocalTargetRelativePath?: string }) {
-  return options.alwaysLocalTargetRelativePath ?? (options.platform === 'linux' ? LINUX_ALWAYS_LOCAL_RELATIVE_PATH : CURSOR_ALWAYS_LOCAL_RELATIVE_PATH);
+function workbenchRelativePath(options: {
+  platform?: NodeJS.Platform;
+  agentExecTargetRelativePath?: string;
+  workbenchTargetRelativePath?: string;
+}) {
+  if (options.workbenchTargetRelativePath) {
+    return options.workbenchTargetRelativePath;
+  }
+  if (options.platform === 'linux') {
+    return linuxUsesDebRoot(options) ? LINUX_DEB_WORKBENCH_RELATIVE_PATH : LINUX_WORKBENCH_RELATIVE_PATH;
+  }
+  return CURSOR_WORKBENCH_RELATIVE_PATH;
+}
+
+function alwaysLocalRelativePath(options: {
+  platform?: NodeJS.Platform;
+  agentExecTargetRelativePath?: string;
+  alwaysLocalTargetRelativePath?: string;
+}) {
+  if (options.alwaysLocalTargetRelativePath) {
+    return options.alwaysLocalTargetRelativePath;
+  }
+  if (options.platform === 'linux') {
+    return linuxUsesDebRoot(options)
+      ? LINUX_DEB_ALWAYS_LOCAL_RELATIVE_PATH
+      : LINUX_ALWAYS_LOCAL_RELATIVE_PATH;
+  }
+  return CURSOR_ALWAYS_LOCAL_RELATIVE_PATH;
 }
 
 async function fileContainsMarker(
@@ -143,6 +173,11 @@ export async function patchCursorSet(appPath: string, options: PatchCursorSetOpt
 }
 
 export async function restoreCursorSet(appPath: string, options: RestoreCursorSetOptions = {}) {
+  const before = await readCursorPatchSetState(appPath, {
+    agentExecTargetRelativePath: options.agentExecTargetRelativePath,
+    platform: options.platform,
+    workbenchTargetRelativePath: options.workbenchTargetRelativePath,
+  });
   const restoreErrors: unknown[] = [];
   const restore = async (operation: () => Promise<unknown>) => {
     try {
@@ -173,10 +208,17 @@ export async function restoreCursorSet(appPath: string, options: RestoreCursorSe
   await restore(() =>
     (options.restoreCursorAgentExec ?? restoreCursorAgentExec)(appPath, {
       backupDir: options.backupDir,
+      targetRelativePath: options.agentExecTargetRelativePath,
     }),
   );
 
   if (restoreErrors.length > 0) {
     throw new AggregateError(restoreErrors, 'Failed to restore one or more Cursor patches.');
   }
+  const after = await readCursorPatchSetState(appPath, {
+    agentExecTargetRelativePath: options.agentExecTargetRelativePath,
+    platform: options.platform,
+    workbenchTargetRelativePath: options.workbenchTargetRelativePath,
+  });
+  return { before, after };
 }

package/src/platform.ts

@@ -82,9 +82,9 @@ function buildDeviceInfo() {
     name: hostname(),
     os: osPlatform(),
     arch: arch(),
-    cliVersion: '0.5.9',
-    serviceVersion: '0.5.9',
-    extensionVersion: '0.5.9',
+    cliVersion: '0.5.10',
+    serviceVersion: '0.5.10',
+    extensionVersion: '0.5.10',
   };
 }
 

package/src/repair.ts

@@ -69,7 +69,7 @@ export type RepairOptions = FindCursorOptions &
     adHocResignApp?: typeof adHocResignApp;
   };
 
-const PACKAGE_VERSION = '0.5.9';
+const PACKAGE_VERSION = '0.5.10';
 
 function normalizeAppPath(path: string) {
   return normalize(path).replace(/\/+$/, '');
@@ -110,12 +110,14 @@ function resolveRepairCompatEntry({
   entries?: CompatibilityManifestEntry[];
 }) {
   const compatEntries = entries ?? DEFAULT_COMPAT_ENTRIES;
+  const versionFamily = cursorVersion.match(/^(\d+\.\d+)(?:\.|$)/)?.[1];
   const entry = compatEntries.find(
     (candidate) =>
       candidate.platform === platform &&
       candidate.arch === arch &&
-      candidate.cursorVersion === cursorVersion &&
-      candidate.cursorCommit === cursorCommit,
+      (candidate.cursorVersion === cursorVersion ||
+        candidate.cursorVersion === versionFamily) &&
+      (candidate.cursorCommit === '*' || candidate.cursorCommit === cursorCommit),
   );
 
   if (!entry) {
@@ -196,13 +198,13 @@ async function maybeAdHocResign({
 }
 
 export async function repair(options: RepairOptions = {}) {
-  const target = resolveCursorTarget(options);
+  const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
   if (target.mode !== 'real') {
     throw new Error('repair is only supported for real Cursor installs in MVP-1');
   }
 
   const cursor = await findCursor({ ...options, appPath: target.appPath });
-  const environment = detectEnvironment(options);
   const compatEntries = await loadCompatEntries({
     compatEntries: options.compatEntries,
     apiBaseUrl: options.apiBaseUrl,
@@ -323,6 +325,7 @@ export async function repair(options: RepairOptions = {}) {
   }
 
   const patchSetState = await readCursorPatchSetState(cursor.appPath, {
+    platform: environment.platform,
     agentExecTargetRelativePath: compat.targetRelativePath,
   });
 
@@ -332,6 +335,7 @@ export async function repair(options: RepairOptions = {}) {
   } else {
     const repairedPatchSet = await patchCursorSet(cursor.appPath, {
       backupDir,
+      platform: environment.platform,
       agentExecTargetRelativePath: compat.targetRelativePath,
       patchCursorAgentExec: options.patchCursorAgentExec,
       patchCursorWorkbenchAuthGate: options.patchCursorWorkbenchAuthGate,

package/src/restore.ts

@@ -1,5 +1,5 @@
 import { normalize } from 'node:path';
-import { restoreCursorAgentExec, resolveCursorAgentExecPath } from '@cursor-pool/patcher';
+import { resolveCursorAgentExecPath } from '@cursor-pool/patcher';
 import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
 import {
   confirmRealOperation,
@@ -7,6 +7,7 @@ import {
   type ConfirmRealOperationOptions,
 } from './confirm';
 import { findCursor, type FindCursorOptions } from './cursor';
+import { detectEnvironment, type DetectEnvironmentOptions } from './environment';
 import {
   installIdForAppPath,
   readInstallRecord,
@@ -16,8 +17,10 @@ import {
 import { stopRuntimeService } from './serviceProcess';
 import { resolveCursorTarget, type CursorTargetOptions } from './target';
 import { assertDisposableCursorAppPath, readTrialRecord, type TrialRecordOptions } from './trial';
+import { formatCursorPatchSetState, restoreCursorSet } from './patchSet';
 
 export type RestoreOptions = FindCursorOptions &
+  DetectEnvironmentOptions &
   CursorTargetOptions &
   TrialRecordOptions &
   InstallRecordOptions & {
@@ -85,9 +88,12 @@ function formatRestoreConfirmation({
 }
 
 export async function restore(options: RestoreOptions = {}) {
-  const target = resolveCursorTarget(options);
+  const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
   const appPath =
-    target.mode === 'disposable' ? assertDisposableCursorAppPath(target.appPath) : target.appPath;
+    target.mode === 'disposable'
+      ? assertDisposableCursorAppPath(target.appPath, { platform: environment.platform })
+      : target.appPath;
   const cursor = await findCursor({ ...options, appPath });
   const installRecord =
     target.mode === 'real'
@@ -132,9 +138,10 @@ export async function restore(options: RestoreOptions = {}) {
     });
   }
 
-  const result = await restoreCursorAgentExec(cursor.appPath, {
+  const result = await restoreCursorSet(cursor.appPath, {
     backupDir,
-    targetRelativePath,
+    agentExecTargetRelativePath: targetRelativePath,
+    platform: environment.platform,
   });
   if (target.mode === 'real') {
     await stopRuntimeServiceIfRecorded(runtimeFile);
@@ -145,7 +152,7 @@ export async function restore(options: RestoreOptions = {}) {
     `mode: ${target.mode}`,
     `app: ${cursor.appPath}`,
     'restore: ok',
-    `patch: ${result.markerPresent ? 'applied' : 'missing'}`,
+    `patch: ${formatCursorPatchSetState(result.after)}`,
     target.mode === 'real'
       ? `install-record: ${realInstallRecord ? 'recorded' : 'missing'}`
       : `trial: ${trialRecord ? 'recorded' : 'missing'}`,

package/src/status.ts

@@ -146,10 +146,12 @@ async function getTakeoverStatus(
 }
 
 export async function status(options: StatusOptions = {}) {
-  const target = resolveCursorTarget(options);
-  const appPath =
-    target.mode === 'disposable' ? assertDisposableCursorAppPath(target.appPath) : target.appPath;
   const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
+  const appPath =
+    target.mode === 'disposable'
+      ? assertDisposableCursorAppPath(target.appPath, { platform: environment.platform })
+      : target.appPath;
   const cursor = await findCursor({ ...options, appPath });
   const compatEntries = await loadCompatEntries({
     compatEntries: options.compatEntries,

package/src/target.ts

@@ -20,8 +20,20 @@ export type CursorTarget =
       requiresConfirmation: true;
     };
 
+function isLinuxRealCursorPath(appPath: string, platform: NodeJS.Platform | undefined) {
+  return platform === 'linux' && appPath.replace(/\/+$/, '') === '/usr/share/cursor';
+}
+
 export function resolveCursorTarget(options: CursorTargetOptions = {}): CursorTarget {
   if (options.appPath) {
+    if (isLinuxRealCursorPath(options.appPath, options.platform)) {
+      return {
+        mode: 'real',
+        appPath: options.appPath.replace(/\/+$/, ''),
+        requiresConfirmation: true,
+      };
+    }
+
     return {
       mode: 'disposable',
       appPath: assertDisposableCursorAppPath(options.appPath, { platform: options.platform }),

package/src/uninstall.ts

@@ -28,6 +28,7 @@ import { restore } from './restore';
 import type { RestoreOptions } from './restore';
 import { stopRuntimeService } from './serviceProcess';
 import { removeUserAutostart } from './autostart';
+import { detectEnvironment } from './environment';
 import { resolveCursorTarget, type CursorTargetOptions } from './target';
 import {
   assertDisposableCursorAppPath,
@@ -107,9 +108,12 @@ async function removeRecordedLinkedExtensionBundle(
 }
 
 export async function uninstall(options: UninstallOptions = {}) {
-  const target = resolveCursorTarget(options);
+  const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
   const appPath =
-    target.mode === 'disposable' ? assertDisposableCursorAppPath(target.appPath) : target.appPath;
+    target.mode === 'disposable'
+      ? assertDisposableCursorAppPath(target.appPath, { platform: environment.platform })
+      : target.appPath;
   const cursor = await findCursor({ ...options, appPath });
   const installRecord =
     target.mode === 'real'

package/test/compat.test.ts

@@ -177,6 +177,96 @@ test('default compatibility manifest supports Cursor 3.6.31 Linux x64 AppImage',
   );
 });
 
+test('default compatibility manifest supports Cursor 3.7.12 Linux arm64 deb installs', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/usr/share/cursor',
+      version: '3.7.12',
+      commit: 'b887a26c4f70bd8136bfffeda812b24194ec9ce0',
+    },
+    {
+      platform: 'linux',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.requiresAdHocResign, false);
+  assert.equal(
+    entry.targetRelativePath,
+    'resources/app/extensions/cursor-agent-exec/dist/main.js',
+  );
+  assert.equal(
+    entry.expectedSha256,
+    '9ce7a2f40a98a27eb1b609a79e0e1707bad5fbb02493693f6f18945a7640dde4',
+  );
+});
+
+test('default compatibility manifest supports verified Cursor 3.4 Linux arm64 deb installs', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/usr/share/cursor',
+      version: '3.4.20',
+      commit: '0cf8b06883f54e26bb4f0fb8647c9500ccb43310',
+    },
+    {
+      platform: 'linux',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.requiresAdHocResign, false);
+  assert.equal(
+    entry.targetRelativePath,
+    'resources/app/extensions/cursor-agent-exec/dist/main.js',
+  );
+  assert.equal(
+    entry.expectedSha256,
+    '4ccb7526e5ece8f6a98a99724a048977698cbf52cb2033ec06f2b5a0a085fe71',
+  );
+});
+
+test('default compatibility manifest supports verified Cursor 3.5 and 3.6 Linux arm64 deb installs', () => {
+  const cases = [
+    {
+      version: '3.5.38',
+      commit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+      expectedSha256: 'cb18f0237278884a39e2ce2b8664255e12689ad0803c20096c38e86c36acc51f',
+    },
+    {
+      version: '3.6.31',
+      commit: '81fcf2931d7687b4ff3f3017858d0c6dee7e2a60',
+      expectedSha256: '05bfa29eacb8271c378765ead4bf881f806b97549dd13367183aa7a9331c1131',
+    },
+  ];
+
+  for (const fixture of cases) {
+    const entry = resolveCompatEntry(
+      {
+        appPath: '/usr/share/cursor',
+        version: fixture.version,
+        commit: fixture.commit,
+      },
+      {
+        platform: 'linux',
+        arch: 'arm64',
+        nodeVersion: process.version,
+      },
+    );
+
+    assert.equal(entry.supportStatus, 'supported');
+    assert.equal(entry.requiresAdHocResign, false);
+    assert.equal(
+      entry.targetRelativePath,
+      'resources/app/extensions/cursor-agent-exec/dist/main.js',
+    );
+    assert.equal(entry.expectedSha256, fixture.expectedSha256);
+  }
+});
+
 test('default compatibility manifest supports Cursor 3.5.38 on macOS x64 for Rosetta-launched installers', () => {
   const entry = resolveCompatEntry(
     {

package/test/cursor.test.ts

@@ -22,6 +22,60 @@ test('defaultCursorAppPath gives a helpful Windows error when LOCALAPPDATA is un
   );
 });
 
+test('defaultCursorAppPath auto-detects Linux deb installs from the cursor launcher on PATH', () => {
+  assert.equal(
+    defaultCursorAppPath({
+      platform: 'linux',
+      execFileSync: (command, args) => {
+        if (command === 'which' && args[0] === 'cursor') {
+          return '/usr/bin/cursor\n';
+        }
+        if (command === 'readlink' && args.join(' ') === '-f /usr/bin/cursor') {
+          return '/usr/share/cursor/bin/cursor\n';
+        }
+        throw new Error(`unexpected command: ${command} ${args.join(' ')}`);
+      },
+    }),
+    '/usr/share/cursor',
+  );
+});
+
+test('findCursor auto-detects Linux deb installs from the cursor launcher on PATH', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-linux-deb-'));
+  const appPath = join(tempDir, 'usr/share/cursor');
+  const launcherPath = join(appPath, 'bin/cursor');
+
+  try {
+    await mkdir(join(appPath, 'resources/app'), { recursive: true });
+    await mkdir(join(appPath, 'bin'), { recursive: true });
+    await writeFile(launcherPath, '#!/bin/sh\n', 'utf8');
+    await writeFile(
+      join(appPath, 'resources/app/product.json'),
+      JSON.stringify({ version: '3.7.12', commit: 'linux-arm64-commit' }),
+      'utf8',
+    );
+
+    const cursor = await findCursor({
+      platform: 'linux',
+      execFile: async (command, args) => {
+        if (command === 'which' && args[0] === 'cursor') {
+          return { stdout: '/usr/bin/cursor\n' };
+        }
+        if (command === 'readlink' && args.join(' ') === '-f /usr/bin/cursor') {
+          return { stdout: `${launcherPath}\n` };
+        }
+        throw new Error(`unexpected command: ${command} ${args.join(' ')}`);
+      },
+    });
+
+    assert.equal(cursor.appPath, appPath);
+    assert.equal(cursor.version, '3.7.12');
+    assert.equal(cursor.commit, 'linux-arm64-commit');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
 test('findCursor extracts Linux AppImage files before reading product metadata', async () => {
   const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-linux-appimage-'));
   const appImagePath = join(tempDir, 'Cursor.AppImage');

package/test/e2e-install.test.ts

@@ -32,23 +32,59 @@ const cursorVersion = '3.5.38';
 const cursorCommit = '009bb5a3600dd98fe1c1f25798f767f686e14750';
 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 repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
 const serviceServerPath = resolve(repoRoot, 'packages/service/src/server.ts');
+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 createFixtureApp(prefix: string) {
   const tempDir = await mkdtemp(join(tmpdir(), prefix));
   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`;
   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({ version: cursorVersion, commit: cursorCommit }),
     'utf8',
   );
   await writeFile(targetPath, targetContent, 'utf8');
+  await writeFile(alwaysLocalPath, 'function alwaysLocal(){}\n', 'utf8');
+  await writeFile(workbenchPath, workbenchFixture(), 'utf8');
 
   const originalHash = createHash('sha256').update(targetContent).digest('hex');
   const compatEntry: CompatibilityManifestEntry = {

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 });
+  }
+});