@cursorpool-dev/cli 0.5.6 → 0.5.8

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,
@@ -7,16 +7,18 @@ import {
   restoreCursorAgentExec,
   restoreCursorAlwaysLocal,
   restoreCursorWorkbenchAuthGate,
+  containsCursorWorkbenchAuthGateMarker,
 } from '@cursor-pool/patcher';
 import { sha256File } from '@cursor-pool/patcher/hash';
 import { startServer } from '@cursor-pool/service';
+import { assertBundledTakeoverPlan } from '@cursor-pool/takeover-plans';
 import {
   readRuntimeInfo,
   resolveRuntimeFile,
   writeRuntimeInfo,
   type RuntimeInfo,
 } from '@cursor-pool/service';
-import type { CompatibilityManifestEntry } from '@cursor-pool/shared/manifest';
+import type { CompatibilityManifestEntry, CompatibilityPatchTarget } from '@cursor-pool/shared/manifest';
 import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
 import { writeClientConfig } from '@cursor-pool/shared/clientConfig';
 import { containsCursorPoolMarker } from '@cursor-pool/patcher/marker';
@@ -32,6 +34,7 @@ import {
 import {
   getLinkedExtensionState,
   linkExtensionBundle,
+  linkedExtensionPathForSource,
   linkedExtensionPathForDir,
   refreshCursorExtensionsIndex,
   removeLinkedExtensionBundle,
@@ -100,10 +103,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.8';
+const AUTOSTART_SERVICE_STARTUP_TIMEOUT_MS = 30_000;
+
+function delay(ms: number) {
+  return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
 
 async function maybeAdHocResign({
   appPath,
@@ -124,38 +133,124 @@ async function maybeAdHocResign({
   return 'ad-hoc' as const;
 }
 
-async function assertExpectedHash(targetPath: string, expectedSha256: string) {
+function markerPredicateForPatchTarget(target: CompatibilityPatchTarget) {
+  if (target.name === 'workbench' || target.verifyMarker === 'cursor-pool-workbench') {
+    return containsCursorWorkbenchAuthGateMarker;
+  }
+  return containsCursorPoolMarker;
+}
+
+async function assertExpectedHash(
+  targetPath: string,
+  expectedSha256: string,
+  containsExpectedMarker = containsCursorPoolMarker,
+) {
   const currentHash = await sha256File(targetPath);
   if (currentHash !== expectedSha256) {
     const content = await readFile(targetPath, 'utf8');
-    if (containsCursorPoolMarker(content)) {
+    if (containsExpectedMarker(content)) {
       return;
     }
     throw new Error(`Patch target hash mismatch: expected ${expectedSha256}, got ${currentHash}`);
   }
 }
 
-async function startInstallService(options: InstallOptions) {
+function compatPatchTargets(compat: CompatibilityManifestEntry): CompatibilityPatchTarget[] {
+  if (compat.patchTargets?.length) {
+    return compat.patchTargets;
+  }
+  return [
+    {
+      name: 'agent-exec',
+      targetRelativePath: compat.targetRelativePath,
+      expectedSha256: compat.expectedSha256,
+      patchStrategy: compat.patchStrategy,
+      verifyMarker: compat.verifyMarker,
+    },
+  ];
+}
+
+function workbenchTargetRelativePathFromCompat(compat: CompatibilityManifestEntry) {
+  return compat.patchTargets?.find((target) => target.name === 'workbench')?.targetRelativePath;
+}
+
+async function assertExpectedPatchTargetHashes(appPath: string, compat: CompatibilityManifestEntry) {
+  for (const target of compatPatchTargets(compat)) {
+    await assertExpectedHash(
+      join(appPath, target.targetRelativePath),
+      target.expectedSha256,
+      markerPredicateForPatchTarget(target),
+    );
+  }
+}
+
+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 +279,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 &&
@@ -286,11 +418,12 @@ async function linkInstallExtensionBundle({
   sourceBundlePath: string;
   cursorExtensionsDir: string;
 }): ReturnType<typeof linkExtensionBundle> {
-  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
   if ((await getLinkedExtensionState(sourceBundlePath)) === 'missing') {
+    const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
     return { state: 'missing', linkedPath };
   }
 
+  const linkedPath = await linkedExtensionPathForSource(cursorExtensionsDir, sourceBundlePath);
   await removeInstallLinkedExtensionBundle(linkedPath, cursorExtensionsDir);
   await mkdir(dirname(linkedPath), { recursive: true });
   await cp(sourceBundlePath, linkedPath, { recursive: true });
@@ -314,13 +447,19 @@ export async function install(options: InstallOptions = {}) {
     compatManifestUrl: options.compatManifestUrl,
     fetchManifest: options.fetchCompatManifest,
   });
-  const compat = resolveCompatEntry(cursor, environment, { entries: compatEntries });
+  const adapterVersion = PACKAGE_VERSION === '0.5.8'
+    ? undefined
+    : PACKAGE_VERSION.split('-', 1)[0].split('+', 1)[0];
+  const compat = resolveCompatEntry(cursor, environment, { entries: compatEntries, adapterVersion });
+  assertBundledTakeoverPlan(compat.takeoverPlanId);
+  const workbenchTargetRelativePath = workbenchTargetRelativePathFromCompat(compat);
   const targetPath = join(cursor.appPath, compat.targetRelativePath);
   const originalSha256 = await sha256File(targetPath);
-  await assertExpectedHash(targetPath, compat.expectedSha256);
+  await assertExpectedPatchTargetHashes(cursor.appPath, compat);
   const patchSetBeforeInstall = await readCursorPatchSetState(cursor.appPath, {
     agentExecTargetRelativePath: compat.targetRelativePath,
     platform: environment.platform,
+    workbenchTargetRelativePath,
   });
   const wasPatchedBeforeInstall = patchSetBeforeInstall.allApplied;
   const existingTrialRecord = await readTrialRecord(cursor.appPath, {
@@ -348,6 +487,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,12 +544,14 @@ 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,
       agentExecTargetRelativePath: compat.targetRelativePath,
+      workbenchTargetRelativePath,
       patchCursorAgentExec: options.patchCursorAgentExec,
       patchCursorWorkbenchAuthGate: options.patchCursorWorkbenchAuthGate,
     });
@@ -421,6 +563,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`,
@@ -434,6 +581,7 @@ export async function install(options: InstallOptions = {}) {
       appPath: cursor.appPath,
       cursorVersion: cursor.version,
       cursorCommit: cursor.commit,
+      takeoverPlanId: compat.takeoverPlanId,
       targetRelativePath: compat.targetRelativePath,
       originalSha256,
       compatSupportStatus: compat.supportStatus,
@@ -478,11 +626,13 @@ export async function install(options: InstallOptions = {}) {
       `mode: ${target.mode}`,
       `app: ${cursor.appPath}`,
       `compat: ${compat.supportStatus}`,
+      `takeover-plan: ${compat.takeoverPlanId}`,
       `extension: ${extension.state}`,
       `service: running ${service.host}:${service.port}`,
       `autostart: ${autostartState}`,
       `patch: ${patchState}`,
       `resign: ${resignState}`,
+      `launcher: ${launcherState}`,
       'health: ok',
       target.mode === 'real' ? 'install-record: recorded' : 'trial: recorded',
     ].join('\n');
@@ -496,6 +646,7 @@ export async function install(options: InstallOptions = {}) {
           (await readCursorPatchSetState(cursor.appPath, {
             agentExecTargetRelativePath: compat.targetRelativePath,
             platform: environment.platform,
+            workbenchTargetRelativePath,
           })).appliedCount > 0);
     } catch (rollbackError) {
       rollbackErrors.push(rollbackError);
@@ -505,6 +656,7 @@ export async function install(options: InstallOptions = {}) {
         await restoreCursorSet(cursor.appPath, {
           backupDir: options.backupDir,
           platform: environment.platform,
+          workbenchTargetRelativePath,
           restoreCursorAgentExec: options.restoreCursorAgentExec,
           restoreCursorAlwaysLocal: options.restoreCursorAlwaysLocal,
           restoreCursorWorkbenchAuthGate: options.restoreCursorWorkbenchAuthGate,

package/src/installRecord.ts

@@ -13,6 +13,7 @@ export type InstallRecord = {
   appPath: string;
   cursorVersion: string;
   cursorCommit: string;
+  takeoverPlanId: string;
   targetRelativePath: string;
   originalSha256: string;
   compatSupportStatus: CompatibilityManifestEntry['supportStatus'];
@@ -91,6 +92,7 @@ export function isInstallRecordStale(record: InstallRecord | null, actual: Insta
     'appPath',
     'cursorVersion',
     'cursorCommit',
+    'takeoverPlanId',
     'targetRelativePath',
     'originalSha256',
     'compatSupportStatus',

package/src/patchSet.ts

@@ -144,6 +144,10 @@ export async function patchCursorSet(appPath: string, options: PatchCursorSetOpt
 
 export async function restoreCursorSet(appPath: string, options: RestoreCursorSetOptions = {}) {
   const restoreErrors: unknown[] = [];
+  const before = await readCursorPatchSetState(appPath, {
+    platform: options.platform,
+    workbenchTargetRelativePath: options.workbenchTargetRelativePath,
+  });
   const restore = async (operation: () => Promise<unknown>) => {
     try {
       await operation();
@@ -152,12 +156,14 @@ export async function restoreCursorSet(appPath: string, options: RestoreCursorSe
     }
   };
 
-  await restore(() =>
-    (options.restoreCursorWorkbenchAuthGate ?? restoreCursorWorkbenchAuthGate)(appPath, {
-      backupDir: options.backupDir,
-      targetRelativePath: workbenchRelativePath(options),
-    }),
-  );
+  if (before.patches.some((patch) => patch.name === 'workbench' && patch.markerPresent)) {
+    await restore(() =>
+      (options.restoreCursorWorkbenchAuthGate ?? restoreCursorWorkbenchAuthGate)(appPath, {
+        backupDir: options.backupDir,
+        targetRelativePath: workbenchRelativePath(options),
+      }),
+    );
+  }
   const alwaysLocalPath = resolveCursorAlwaysLocalPath(appPath, alwaysLocalRelativePath(options));
   const shouldRestoreAlwaysLocal =
     Boolean(options.restoreCursorAlwaysLocal) ||

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.8',
+    serviceVersion: '0.5.8',
+    extensionVersion: '0.5.8',
   };
 }
 

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.8';
 
 function normalizeAppPath(path: string) {
   return normalize(path).replace(/\/+$/, '');
@@ -96,6 +96,10 @@ function assertRealRepairInstallRecord(
   return record;
 }
 
+function workbenchTargetRelativePathFromCompat(compat: CompatibilityManifestEntry) {
+  return compat.patchTargets?.find((target) => target.name === 'workbench')?.targetRelativePath;
+}
+
 function resolveRepairCompatEntry({
   cursorVersion,
   cursorCommit,
@@ -223,6 +227,7 @@ export async function repair(options: RepairOptions = {}) {
   if (compat.supportStatus === 'blocked' || compat.supportStatus === 'unknown') {
     throw new Error(`compat: ${compat.supportStatus}`);
   }
+  const workbenchTargetRelativePath = workbenchTargetRelativePathFromCompat(compat);
   const targetPath = join(cursor.appPath, compat.targetRelativePath);
   const runtimeFile = options.runtimeFile ?? installRecord.runtimeFile ?? DEFAULT_RUNTIME_FILE;
   const backupDir = options.backupDir ?? installRecord.backupDir;
@@ -323,6 +328,8 @@ export async function repair(options: RepairOptions = {}) {
 
   const patchSetState = await readCursorPatchSetState(cursor.appPath, {
     agentExecTargetRelativePath: compat.targetRelativePath,
+    platform: environment.platform,
+    workbenchTargetRelativePath,
   });
 
   if (patchSetState.allApplied) {
@@ -331,7 +338,9 @@ export async function repair(options: RepairOptions = {}) {
   } else {
     const repairedPatchSet = await patchCursorSet(cursor.appPath, {
       backupDir,
+      platform: environment.platform,
       agentExecTargetRelativePath: compat.targetRelativePath,
+      workbenchTargetRelativePath,
       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,
@@ -14,6 +14,11 @@ import {
   type InstallRecordOptions,
 } from './installRecord';
 import { stopRuntimeService } from './serviceProcess';
+import {
+  formatCursorPatchSetState,
+  readCursorPatchSetState,
+  restoreCursorSet,
+} from './patchSet';
 import { resolveCursorTarget, type CursorTargetOptions } from './target';
 import { assertDisposableCursorAppPath, readTrialRecord, type TrialRecordOptions } from './trial';
 
@@ -132,9 +137,12 @@ export async function restore(options: RestoreOptions = {}) {
     });
   }
 
-  const result = await restoreCursorAgentExec(cursor.appPath, {
+  await restoreCursorSet(cursor.appPath, {
     backupDir,
-    targetRelativePath,
+    agentExecTargetRelativePath: targetRelativePath,
+  });
+  const patchSetState = await readCursorPatchSetState(cursor.appPath, {
+    agentExecTargetRelativePath: targetRelativePath,
   });
   if (target.mode === 'real') {
     await stopRuntimeServiceIfRecorded(runtimeFile);
@@ -145,7 +153,7 @@ export async function restore(options: RestoreOptions = {}) {
     `mode: ${target.mode}`,
     `app: ${cursor.appPath}`,
     'restore: ok',
-    `patch: ${result.markerPresent ? 'applied' : 'missing'}`,
+    `patch: ${formatCursorPatchSetState(patchSetState)}`,
     target.mode === 'real'
       ? `install-record: ${realInstallRecord ? 'recorded' : 'missing'}`
       : `trial: ${trialRecord ? 'recorded' : 'missing'}`,

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/status.ts

@@ -49,6 +49,10 @@ type LatestTakeoverResponse = {
   };
 };
 
+function workbenchTargetRelativePathFromCompat(compat: CompatibilityManifestEntry) {
+  return compat.patchTargets?.find((target) => target.name === 'workbench')?.targetRelativePath;
+}
+
 const MAX_CANARY_FIELD_LENGTH = 256;
 
 function isSafeCanaryString(value: unknown): value is string {
@@ -158,6 +162,7 @@ export async function status(options: StatusOptions = {}) {
     fetchManifest: options.fetchCompatManifest,
   });
   const compat = resolveCompatEntry(cursor, environment, { entries: compatEntries });
+  const workbenchTargetRelativePath = workbenchTargetRelativePathFromCompat(compat);
   const installRecord =
     target.mode === 'real'
       ? await readInstallRecord({ installRecordFile: options.installRecordFile })
@@ -189,6 +194,7 @@ export async function status(options: StatusOptions = {}) {
   const patchSetState = await readCursorPatchSetState(cursor.appPath, {
     agentExecTargetRelativePath: compat.targetRelativePath,
     platform: environment.platform,
+    workbenchTargetRelativePath,
   });
   const serviceRunning = await isRuntimeHealthy(runtime);
   const takeoverStatus = await getTakeoverStatus(runtime, serviceRunning);

package/src/trial.ts

@@ -12,6 +12,7 @@ export type TrialRecord = {
   appPath: string;
   cursorVersion: string;
   cursorCommit: string;
+  takeoverPlanId: string;
   targetRelativePath: string;
   originalSha256: string;
   compatSupportStatus: 'supported' | 'canary' | 'warning' | 'blocked' | 'unknown';

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