@cursorpool-dev/cli 0.5.6 → 0.5.9

package/src/cursor.ts

@@ -1,7 +1,12 @@
-import { readFile } from 'node:fs/promises';
-import { join, win32 } from 'node:path';
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { promisify } from 'node:util';
+import { chmod, mkdir, readFile, rm, stat } from 'node:fs/promises';
+import { basename, join, win32 } from 'node:path';
+import { homedir } from 'node:os';
 
 export const DEFAULT_MACOS_CURSOR_APP_PATH = '/Applications/Cursor.app';
+const execFileAsync = promisify(execFile);
 
 export type CursorInfo = {
   appPath: string;
@@ -14,6 +19,7 @@ export type FindCursorOptions = {
   productRelativePath?: string;
   platform?: NodeJS.Platform;
   env?: NodeJS.ProcessEnv;
+  appImageExtract?: (appImagePath: string, outputRoot: string) => Promise<string>;
 };
 
 type CursorProductJson = {
@@ -43,7 +49,8 @@ function readString(value: unknown) {
 }
 
 export async function findCursor(options: FindCursorOptions = {}): Promise<CursorInfo> {
-  const appPath = options.appPath ?? defaultCursorAppPath(options);
+  const rawAppPath = options.appPath ?? defaultCursorAppPath(options);
+  const appPath = await resolveCursorAppPath(rawAppPath, options);
   const productJsonPath = await resolveProductJsonPath(appPath, options);
   const product = JSON.parse(await readFile(productJsonPath, 'utf8')) as CursorProductJson;
   const version = readString(product.version);
@@ -66,6 +73,55 @@ export async function findCursor(options: FindCursorOptions = {}): Promise<Curso
   };
 }
 
+async function pathIsFile(path: string) {
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function linuxAppImageExtractRoot(appImagePath: string) {
+  const hash = createHash('sha256').update(appImagePath).digest('hex').slice(0, 16);
+  const name = basename(appImagePath).replace(/\.AppImage$/i, '').replace(/[^A-Za-z0-9._-]/g, '-');
+  return join(homedir(), '.cursor-pool/appimages', `${name}-${hash}`);
+}
+
+async function defaultExtractLinuxAppImage(appImagePath: string, outputRoot: string) {
+  await rm(outputRoot, { recursive: true, force: true });
+  await mkdir(outputRoot, { recursive: true });
+  await chmod(appImagePath, 0o755).catch(() => undefined);
+  await execFileAsync(appImagePath, ['--appimage-extract'], {
+    cwd: outputRoot,
+    maxBuffer: 1024 * 1024 * 20,
+  });
+  return join(outputRoot, 'squashfs-root');
+}
+
+async function resolveCursorAppPath(appPath: string, options: FindCursorOptions) {
+  if (
+    (options.platform ?? process.platform) !== 'linux' ||
+    !/\.AppImage$/i.test(appPath) ||
+    !(await pathIsFile(appPath))
+  ) {
+    return appPath;
+  }
+
+  const outputRoot = linuxAppImageExtractRoot(appPath);
+  const extractedPath = join(outputRoot, 'squashfs-root');
+  try {
+    await readFile(join(extractedPath, 'usr/share/cursor/resources/app/product.json'), 'utf8');
+    return extractedPath;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const extract = options.appImageExtract ?? defaultExtractLinuxAppImage;
+  return extract(appPath, outputRoot);
+}
+
 async function resolveProductJsonPath(appPath: string, options: FindCursorOptions) {
   if (options.productRelativePath) {
     return join(appPath, options.productRelativePath);

package/src/extensionBundle.ts

@@ -55,7 +55,7 @@ async function exists(path: string) {
 function buildRuntimeManifest(sourceManifest: Record<string, unknown>) {
   return {
     name: 'cursorpool',
-    version: typeof sourceManifest.version === 'string' ? sourceManifest.version : '0.5.6',
+    version: typeof sourceManifest.version === 'string' ? sourceManifest.version : '0.5.9',
     displayName: 'Cursor Pool 平台模式',
     publisher: 'cursor-pool',
     type: sourceManifest.type,

package/src/extensionLink.ts

@@ -4,7 +4,7 @@ import { basename, dirname, join, resolve } from 'node:path';
 import { resolveExtensionInstallPath } from './extensionBundle';
 import type { ExtensionState } from './trial';
 
-export const LINKED_EXTENSION_DIRNAME = 'cursor-pool.extension-0.5.6';
+export const LINKED_EXTENSION_DIRNAME = 'cursor-pool.extension-0.5.9';
 const RUNTIME_EXTENSION_ID = 'cursor-pool.cursorpool';
 const STALE_EXTENSION_IDS = new Set([
   RUNTIME_EXTENSION_ID,
@@ -48,7 +48,7 @@ async function readRuntimeManifest(linkedPath: string) {
   };
   const publisher = typeof manifest.publisher === 'string' ? manifest.publisher : 'cursor-pool';
   const name = typeof manifest.name === 'string' ? manifest.name : 'cursorpool';
-  const version = typeof manifest.version === 'string' ? manifest.version : '0.5.6';
+  const version = typeof manifest.version === 'string' ? manifest.version : '0.5.9';
   return { id: `${publisher}.${name}`, version };
 }
 
@@ -100,7 +100,7 @@ function assertSafeLinkedExtensionPath(linkedPath: string) {
 }
 
 export function linkedExtensionPathForDir(cursorExtensionsDir: string) {
-  return join(resolveExtensionInstallPath(cursorExtensionsDir), LINKED_EXTENSION_DIRNAME);
+  return join(resolve(resolveExtensionInstallPath(cursorExtensionsDir)), LINKED_EXTENSION_DIRNAME);
 }
 
 export async function getLinkedExtensionState(linkedPath: string | undefined): Promise<LinkedExtensionState> {

package/src/install.ts

@@ -1,5 +1,5 @@
-import { cp, mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { chmod, cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import {
   patchCursorAgentExec,
@@ -100,10 +100,16 @@ export type InstallOptions = FindCursorOptions &
     restoreCursorWorkbenchAuthGate?: typeof restoreCursorWorkbenchAuthGate;
     adHocResignApp?: typeof adHocResignApp;
     fetchHealth?: (url: string) => Promise<{ ok: boolean; healthy: boolean }>;
+    linuxLauncherFile?: string;
   };
 
 const REAL_CURSOR_EXTENSIONS_DIR = '~/.cursor/extensions';
-const PACKAGE_VERSION = '0.5.6';
+const PACKAGE_VERSION = '0.5.9';
+const AUTOSTART_SERVICE_STARTUP_TIMEOUT_MS = 30_000;
+
+function delay(ms: number) {
+  return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
 
 async function maybeAdHocResign({
   appPath,
@@ -135,27 +141,73 @@ async function assertExpectedHash(targetPath: string, expectedSha256: string) {
   }
 }
 
-async function startInstallService(options: InstallOptions) {
+async function startServiceFromAutostart(options: InstallOptions, targetMode: 'real' | 'disposable') {
+  const autostart = await installAutostart(options, targetMode);
+  const runtimeFile = options.runtimeFile ?? DEFAULT_RUNTIME_FILE;
+  const fetchHealthFn = options.fetchHealth ?? fetchHealth;
+  const startedAt = Date.now();
+  let runtime: RuntimeInfo | null = null;
+
+  while (Date.now() - startedAt < AUTOSTART_SERVICE_STARTUP_TIMEOUT_MS) {
+    runtime = await readRuntimeInfo({ runtimeFile });
+    const health = runtime
+      ? await fetchHealthFn(`http://${runtime.host}:${runtime.port}/health`)
+      : null;
+    if (runtime && health?.ok && health.healthy) {
+      return {
+        service: {
+          ...runtime,
+          stop: () => stopRuntimeService(runtimeFile),
+        },
+        autostartState: autostart.state,
+      };
+    }
+    await delay(50);
+  }
+
+  throw new Error('Autostart service failed to become healthy');
+}
+
+async function startInstallService(
+  options: InstallOptions,
+  targetMode: 'real' | 'disposable',
+  platform: NodeJS.Platform,
+) {
   if (options.stopServiceAfterInstall) {
     const service = await startServer({ runtimeFile: options.runtimeFile });
     return {
-      host: service.host,
-      port: service.port,
-      runtimeId: service.runtimeId,
-      stop: service.stop,
+      service: {
+        host: service.host,
+        port: service.port,
+        runtimeId: service.runtimeId,
+        stop: service.stop,
+      },
+      autostartState: 'skipped' as const,
     };
   }
 
   const startDetached = options.startDetachedService ?? startDetachedService;
-  const runtime = await startDetached({
-    runtimeFile: options.runtimeFile ?? DEFAULT_RUNTIME_FILE,
-    logFile: options.serviceLogFile ?? '~/.cursor-pool/logs/service.log',
-    configFile: options.clientConfigFile,
-    apiBaseUrl: options.apiBaseUrl,
-  });
+  let runtime: RuntimeInfo;
+  try {
+    runtime = await startDetached({
+      runtimeFile: options.runtimeFile ?? DEFAULT_RUNTIME_FILE,
+      logFile: options.serviceLogFile ?? '~/.cursor-pool/logs/service.log',
+      configFile: options.clientConfigFile,
+      apiBaseUrl: options.apiBaseUrl,
+    });
+  } catch (error) {
+    if (platform === 'linux' && targetMode === 'real') {
+      return startServiceFromAutostart(options, targetMode);
+    }
+    throw error;
+  }
+
   return {
-    ...runtime,
-    stop: () => stopRuntimeService(options.runtimeFile ?? DEFAULT_RUNTIME_FILE),
+    service: {
+      ...runtime,
+      stop: () => stopRuntimeService(options.runtimeFile ?? DEFAULT_RUNTIME_FILE),
+    },
+    autostartState: undefined,
   };
 }
 
@@ -184,6 +236,43 @@ async function installAutostart(options: InstallOptions, targetMode: 'real' | 'd
   });
 }
 
+function defaultLinuxLauncherFile() {
+  return join(homedir(), '.local/bin/cursor-pool-cursor');
+}
+
+function shellSingleQuote(value: string) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+async function installLinuxLauncher({
+  appPath,
+  platform,
+  launcherFile,
+}: {
+  appPath: string;
+  platform: NodeJS.Platform;
+  launcherFile?: string;
+}) {
+  if (platform !== 'linux') {
+    return 'skipped';
+  }
+
+  const targetFile = launcherFile ?? defaultLinuxLauncherFile();
+  await mkdir(dirname(targetFile), { recursive: true });
+  await writeFile(
+    targetFile,
+    [
+      '#!/usr/bin/env sh',
+      'set -eu',
+      `exec ${shellSingleQuote(join(appPath, 'AppRun'))} --no-sandbox "$@"`,
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+  await chmod(targetFile, 0o755);
+  return targetFile;
+}
+
 function sameRuntime(a: RuntimeInfo | null | undefined, b: RuntimeInfo | null | undefined) {
   return Boolean(
     a &&
@@ -317,7 +406,9 @@ export async function install(options: InstallOptions = {}) {
   const compat = resolveCompatEntry(cursor, environment, { entries: compatEntries });
   const targetPath = join(cursor.appPath, compat.targetRelativePath);
   const originalSha256 = await sha256File(targetPath);
-  await assertExpectedHash(targetPath, compat.expectedSha256);
+  if (compat.expectedSha256 !== '*') {
+    await assertExpectedHash(targetPath, compat.expectedSha256);
+  }
   const patchSetBeforeInstall = await readCursorPatchSetState(cursor.appPath, {
     agentExecTargetRelativePath: compat.targetRelativePath,
     platform: environment.platform,
@@ -348,6 +439,7 @@ export async function install(options: InstallOptions = {}) {
   let resignState: 'ad-hoc' | 'skipped' = 'skipped';
   let patchState = 'skipped';
   let autostartState = 'skipped';
+  let launcherState = 'skipped';
 
   try {
     if (target.requiresConfirmation) {
@@ -404,8 +496,9 @@ export async function install(options: InstallOptions = {}) {
     }
 
     await writeInstallClientConfig(options);
-    service = await startInstallService(options);
-    autostartState = (await installAutostart(options, target.mode)).state;
+    const started = await startInstallService(options, target.mode, environment.platform);
+    service = started.service;
+    autostartState = started.autostartState ?? (await installAutostart(options, target.mode)).state;
     const patchSet = await patchCursorSet(cursor.appPath, {
       backupDir: options.backupDir,
       platform: environment.platform,
@@ -421,6 +514,11 @@ export async function install(options: InstallOptions = {}) {
       requiresAdHocResign: compat.requiresAdHocResign,
       resign: options.adHocResignApp ?? adHocResignApp,
     });
+    launcherState = await installLinuxLauncher({
+      appPath: cursor.appPath,
+      platform: environment.platform,
+      launcherFile: options.linuxLauncherFile,
+    });
 
     const health = await (options.fetchHealth ?? fetchHealth)(
       `http://${service.host}:${service.port}/health`,
@@ -483,6 +581,7 @@ export async function install(options: InstallOptions = {}) {
       `autostart: ${autostartState}`,
       `patch: ${patchState}`,
       `resign: ${resignState}`,
+      `launcher: ${launcherState}`,
       'health: ok',
       target.mode === 'real' ? 'install-record: recorded' : 'trial: recorded',
     ].join('\n');

package/src/platform.ts

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

package/src/repair.ts

@@ -69,7 +69,7 @@ export type RepairOptions = FindCursorOptions &
     adHocResignApp?: typeof adHocResignApp;
   };
 
-const PACKAGE_VERSION = '0.5.6';
+const PACKAGE_VERSION = '0.5.9';
 
 function normalizeAppPath(path: string) {
   return normalize(path).replace(/\/+$/, '');
@@ -256,6 +256,7 @@ export async function repair(options: RepairOptions = {}) {
       installRecord.originalSha256 && patchState.currentHash === installRecord.originalSha256;
     if (
       !patchState.legacyMarkerPresent &&
+      compat.expectedSha256 !== '*' &&
       patchState.currentHash !== compat.expectedSha256 &&
       !matchesInstallOriginal
     ) {

package/src/serviceProcess.ts

@@ -18,6 +18,7 @@ export type StartDetachedServiceOptions = {
 const require = createRequire(import.meta.url);
 const DEFAULT_SERVICE_ENTRY = require.resolve('@cursor-pool/service/entry');
 const TSX_ESM_LOADER = require.resolve('tsx/esm');
+export const DEFAULT_DETACHED_SERVICE_STARTUP_TIMEOUT_MS = 30_000;
 function resolveTildePath(path: string) {
   if (path.startsWith('~/')) {
     return join(homedir(), path.slice(2));
@@ -132,7 +133,7 @@ export async function startDetachedService(
   let healthy = false;
   try {
     const startedAt = Date.now();
-    const timeoutMs = options.startupTimeoutMs ?? 5000;
+    const timeoutMs = options.startupTimeoutMs ?? DEFAULT_DETACHED_SERVICE_STARTUP_TIMEOUT_MS;
     while (Date.now() - startedAt < timeoutMs) {
       if (startupError) {
         throw startupError;

package/src/trial.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join, normalize } from 'node:path';
+import { dirname, join, normalize, resolve } from 'node:path';
 import { DEFAULT_MACOS_CURSOR_APP_PATH } from './cursor';
 
 export type ExtensionState = 'bundled' | 'linked' | 'manual-step-required' | 'missing';
@@ -39,7 +39,7 @@ function resolveHomePath(path: string) {
 }
 
 function normalizeAppPath(path: string) {
-  return normalize(path).replace(/\/+$/, '');
+  return resolve(normalize(path).replace(/\/+$/, ''));
 }
 
 function isRealCursorAppPath(path: string) {

package/test/autostart.test.ts

@@ -125,7 +125,7 @@ test('installUserAutostart writes a Linux user systemd service', async () => {
       linuxServiceFile: serviceFile,
       nodeCommand: '/usr/bin/node',
       cliEntry: '/home/demo/.cursor-pool/client/node_modules/@cursorpool-dev/cli/bin/cursor-pool.mjs',
-      tsxLoader: '/home/demo/.cursor-pool/client/node_modules/tsx/dist/esm/index.mjs',
+      tsxLoader: '/home/demo/.cursor-pool/client/node_modules/@cursorpool-dev/cli/node_modules/tsx/dist/esm/index.mjs',
       serviceEntry: '/home/demo/.cursor-pool/client/node_modules/@cursorpool-dev/cli/node_modules/@cursor-pool/service/src/entry.ts',
       runtimeFile: '/home/demo/.cursor-pool/runtime.json',
       serviceLogFile: '/home/demo/.cursor-pool/logs/service.log',
@@ -138,10 +138,11 @@ test('installUserAutostart writes a Linux user systemd service', async () => {
 
     assert.equal(result.state, 'installed');
     const service = await readFile(serviceFile, 'utf8');
-    assert.match(service, /ExecStart=\/usr\/bin\/node --import .*tsx\/dist\/esm\/index\.mjs .*service\/src\/entry\.ts --runtime-file/);
+    assert.match(service, /ExecStart=\/usr\/bin\/node --import .*@cursorpool-dev\/cli\/node_modules\/tsx\/dist\/esm\/index\.mjs .*service\/src\/entry\.ts --runtime-file/);
     assert.match(service, /--config-file/);
     assert.match(service, /Restart=always/);
     assert.deepEqual(calls, [
+      ['--user', 'unmask', 'cursor-pool.service'],
       ['--user', 'daemon-reload'],
       ['--user', 'enable', '--now', 'cursor-pool.service'],
     ]);
@@ -149,3 +150,23 @@ test('installUserAutostart writes a Linux user systemd service', async () => {
     await rm(tempDir, { recursive: true, force: true });
   }
 });
+
+test('installUserAutostart resolves the default tsx loader from the packaged CLI dependency tree', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-autostart-default-tsx-'));
+  const serviceFile = join(tempDir, 'systemd/cursor-pool.service');
+
+  try {
+    await installUserAutostart({
+      platform: 'linux',
+      linuxServiceFile: serviceFile,
+      nodeCommand: '/usr/bin/node',
+      execFile: async () => ({ stdout: '', stderr: '' }),
+    });
+
+    const service = await readFile(serviceFile, 'utf8');
+    assert.match(service, /--import .*tsx\/dist\/esm\/index\.mjs/);
+    assert.doesNotMatch(service, /\.cursor-pool\/client\/node_modules\/tsx\/dist\/esm\/index\.mjs/);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/test/compat.test.ts

@@ -46,7 +46,7 @@ function signedEnvelope(version: number, rules: CompatibilityManifestEntry[]) {
   };
 }
 
-test('default compatibility manifest supports Cursor 3.6.21 on macOS arm64', () => {
+test('default compatibility manifest supports the Cursor 3.6 macOS arm64 version family', () => {
   const entry = resolveCompatEntry(
     {
       appPath: '/Users/example/Desktop/Cursor-Pool-Agent-Canary.app',
@@ -63,20 +63,120 @@ test('default compatibility manifest supports Cursor 3.6.21 on macOS arm64', ()
   assert.equal(entry.supportStatus, 'supported');
   assert.equal(entry.requiresAdHocResign, true);
   assert.equal(entry.targetRelativePath, CURSOR_AGENT_EXEC_RELATIVE_PATH);
+  assert.equal(entry.cursorVersion, '3.6');
+  assert.equal(entry.cursorCommit, '*');
+  assert.equal(entry.expectedSha256, '*');
   assert.equal(
-    entry.expectedSha256,
-    '222512631b78fddcdca3fa76c0dd458a7a86751dde19c998ceb31b3fe1905ebf',
+    DEFAULT_COMPAT_ENTRIES.some(
+      (candidate) =>
+        candidate.platform === 'darwin' &&
+        candidate.arch === 'arm64' &&
+        candidate.cursorVersion === '3.6' &&
+        candidate.cursorCommit === '*',
+    ),
+    true,
   );
+});
+
+test('default compatibility manifest supports the Cursor 3.4 macOS arm64 version family', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/Users/example/Desktop/Cursor-3.4.0.app',
+      version: '3.4.0',
+      commit: 'cursor-3-4-family-commit',
+    },
+    {
+      platform: 'darwin',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.requiresAdHocResign, true);
+  assert.equal(entry.targetRelativePath, CURSOR_AGENT_EXEC_RELATIVE_PATH);
+  assert.equal(entry.cursorVersion, '3.4');
+  assert.equal(entry.cursorCommit, '*');
+  assert.equal(entry.expectedSha256, '*');
   assert.equal(
     DEFAULT_COMPAT_ENTRIES.some(
       (candidate) =>
-        candidate.cursorVersion === '3.6.21' &&
-        candidate.cursorCommit === 'e7a7e93f4d75f8272503ecf33cedbaae10114a10',
+        candidate.platform === 'darwin' &&
+        candidate.arch === 'arm64' &&
+        candidate.cursorVersion === '3.4' &&
+        candidate.cursorCommit === '*',
     ),
     true,
   );
 });
 
+test('default compatibility manifest accepts later Cursor 3.6 patch versions on macOS arm64', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/Users/example/Desktop/Cursor-3.6.31.app',
+      version: '3.6.31',
+      commit: '81fcf2931d7687b4ff3f3017858d0c6dee7e2a60',
+    },
+    {
+      platform: 'darwin',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.cursorVersion, '3.6');
+  assert.equal(entry.cursorCommit, '*');
+  assert.equal(entry.expectedSha256, '*');
+});
+
+test('default compatibility manifest supports the Cursor 3.7 macOS arm64 version family', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/Users/example/Desktop/Cursor-3.7.12.app',
+      version: '3.7.12',
+      commit: 'b887a26c4f70bd8136bfffeda812b24194ec9ce0',
+    },
+    {
+      platform: 'darwin',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.targetRelativePath, CURSOR_AGENT_EXEC_RELATIVE_PATH);
+  assert.equal(entry.cursorVersion, '3.7');
+  assert.equal(entry.cursorCommit, '*');
+  assert.equal(entry.expectedSha256, '*');
+});
+
+test('default compatibility manifest supports Cursor 3.6.31 Linux x64 AppImage', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/home/xubuntu/.cursor-pool/appimages/Cursor-89aa899ccc46fb58/squashfs-root',
+      version: '3.6.31',
+      commit: '81fcf2931d7687b4ff3f3017858d0c6dee7e2a60',
+    },
+    {
+      platform: 'linux',
+      arch: 'x64',
+      nodeVersion: process.version,
+    },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.requiresAdHocResign, false);
+  assert.equal(
+    entry.targetRelativePath,
+    'usr/share/cursor/resources/app/extensions/cursor-agent-exec/dist/main.js',
+  );
+  assert.equal(
+    entry.expectedSha256,
+    '05bfa29eacb8271c378765ead4bf881f806b97549dd13367183aa7a9331c1131',
+  );
+});
+
 test('default compatibility manifest supports Cursor 3.5.38 on macOS x64 for Rosetta-launched installers', () => {
   const entry = resolveCompatEntry(
     {
@@ -94,10 +194,9 @@ test('default compatibility manifest supports Cursor 3.5.38 on macOS x64 for Ros
   assert.equal(entry.supportStatus, 'supported');
   assert.equal(entry.requiresAdHocResign, true);
   assert.equal(entry.targetRelativePath, CURSOR_AGENT_EXEC_RELATIVE_PATH);
-  assert.equal(
-    entry.expectedSha256,
-    'cb18f0237278884a39e2ce2b8664255e12689ad0803c20096c38e86c36acc51f',
-  );
+  assert.equal(entry.cursorVersion, '3.5');
+  assert.equal(entry.cursorCommit, '*');
+  assert.equal(entry.expectedSha256, '*');
 });
 
 test('verifies a remote compatibility manifest envelope with the development signature', () => {

package/test/cursor-pool-bin.test.ts

@@ -59,6 +59,7 @@ test('CLI common options include target, record, trial, extension, and service l
       cursorExtensionsDir: '/tmp/Cursor-Pool-Trial-Extensions',
       userDataDir: '/tmp/Cursor-Pool-Trial-UserData',
       serviceLogFile: '/tmp/service.log',
+      configFile: undefined,
       diagnosticsFile: '/tmp/diagnostics.jsonl',
       sessionFile: '/tmp/session.json',
       code: 'CODE-123',

package/test/cursor.test.ts

@@ -1,6 +1,9 @@
 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 { defaultCursorAppPath } from '../src/cursor';
+import { defaultCursorAppPath, findCursor } from '../src/cursor';
 
 test('defaultCursorAppPath resolves the user-level Windows Cursor install directory', () => {
   assert.equal(
@@ -18,3 +21,59 @@ test('defaultCursorAppPath gives a helpful Windows error when LOCALAPPDATA is un
     /LOCALAPPDATA is required to auto-detect Cursor on Windows/,
   );
 });
+
+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');
+  const extractedRoots: string[] = [];
+
+  try {
+    await writeFile(appImagePath, '#!/bin/sh\n', { mode: 0o755 });
+
+    const cursor = await findCursor({
+      appPath: appImagePath,
+      platform: 'linux',
+      appImageExtract: async (path, outputRoot) => {
+        assert.equal(path, appImagePath);
+        extractedRoots.push(outputRoot);
+        const extractedPath = join(outputRoot, 'squashfs-root');
+        await mkdir(join(extractedPath, 'usr/share/cursor/resources/app'), { recursive: true });
+        await writeFile(
+          join(extractedPath, 'usr/share/cursor/resources/app/product.json'),
+          JSON.stringify({ version: '3.6.31', commit: 'linux-commit' }),
+          'utf8',
+        );
+        return extractedPath;
+      },
+    });
+
+    assert.equal(cursor.version, '3.6.31');
+    assert.equal(cursor.commit, 'linux-commit');
+    assert.match(cursor.appPath, /squashfs-root$/);
+    assert.equal(extractedRoots.length, 1);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('findCursor keeps macOS app bundle product path unchanged', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-macos-app-'));
+  const appPath = join(tempDir, 'Cursor.app');
+
+  try {
+    await mkdir(join(appPath, 'Contents/Resources/app'), { recursive: true });
+    await writeFile(
+      join(appPath, 'Contents/Resources/app/product.json'),
+      JSON.stringify({ version: '3.5.38', commit: 'mac-commit' }),
+      'utf8',
+    );
+
+    const cursor = await findCursor({ appPath, platform: 'darwin' });
+
+    assert.equal(cursor.appPath, appPath);
+    assert.equal(cursor.version, '3.5.38');
+    assert.equal(cursor.commit, 'mac-commit');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});