@cursorpool-dev/cli 0.5.6 → 0.5.8

package/test/install.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { createHash } from 'node:crypto';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
@@ -8,7 +8,7 @@ import {
   CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR,
   CURSOR_POOL_PATCH_MARKER,
 } from '../../patcher/src/marker';
-import { writeRuntimeInfo } from '../../service/src/runtime';
+import { readRuntimeInfo, writeRuntimeInfo } from '../../service/src/runtime';
 import type { CompatibilityManifestEntry } from '../../shared/src/manifest';
 import { buildCompatManifestSignature } from '../src/compat';
 import { getExtensionState } from '../src/extensionBundle';
@@ -69,15 +69,36 @@ async function createFixtureApp() {
   );
   await writeFile(targetPath, targetContent, 'utf8');
   await writeFile(join(appPath, alwaysLocalRelativePath), 'function alwaysLocal(){}\n', 'utf8');
-  await writeFile(join(appPath, workbenchRelativePath), workbenchFixture(), 'utf8');
+  const workbenchContent = workbenchFixture();
+  await writeFile(join(appPath, workbenchRelativePath), workbenchContent, '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.38',
+    cursorVersion: '3.5',
     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',
@@ -141,9 +162,10 @@ async function createLinuxFixtureApp() {
   const compatEntry: CompatibilityManifestEntry = {
     platform: 'linux',
     arch: process.arch,
-    cursorVersion: '3.6.31',
+    cursorVersion: '3.6',
     cursorCommit: 'linux-commit',
     supportStatus: 'supported',
+    takeoverPlanId: 'cursor-3.6-mac-agent-c-workbench-h-uv',
     targetRelativePath,
     expectedSha256,
     structureSignature: 'linux-fixture',
@@ -188,7 +210,7 @@ async function createRemoteOnlyFixtureApp() {
   );
   const compatEntry = {
     ...fixture.compatEntry,
-    cursorVersion: '3.7.0',
+    cursorVersion: '3.7',
     cursorCommit: 'remote-commit',
     userMessage: 'remote fixture supported',
   };
@@ -212,6 +234,7 @@ 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/);
@@ -225,6 +248,7 @@ test('install reports Cursor version, simulated extension, service, patch, and h
 
 test('install detects Linux Cursor AppImage layout under usr/share/cursor', async () => {
   const fixture = await createLinuxFixtureApp();
+  const launcherFile = join(fixture.tempDir, 'bin/cursor-pool-cursor');
 
   try {
     const output = await install({
@@ -235,14 +259,20 @@ test('install detects Linux Cursor AppImage layout under usr/share/cursor', asyn
       backupDir: fixture.backupDir,
       trialRecordDir: join(fixture.tempDir, 'trials'),
       extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      linuxLauncherFile: launcherFile,
       compatEntries: [fixture.compatEntry],
       stopServiceAfterInstall: true,
     });
 
     assert.match(output, /Cursor 3\.6\.31/);
     assert.match(output, /patch: applied/);
+    assert.match(output, /launcher: .*cursor-pool-cursor/);
     assert.match(output, /health: ok/);
     assert.match(await readFile(fixture.targetPath, 'utf8'), new RegExp(CURSOR_POOL_PATCH_MARKER));
+    const launcher = await readFile(launcherFile, 'utf8');
+    assert.match(launcher, /AppRun/);
+    assert.match(launcher, /--no-sandbox/);
+    assert.equal((await stat(launcherFile)).mode & 0o111, 0o111);
   } finally {
     await rm(fixture.tempDir, { recursive: true, force: true });
   }
@@ -280,6 +310,36 @@ 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>[] = [];
@@ -350,6 +410,124 @@ test('install persists API base URL and installs user autostart for real client
   }
 });
 
+test('Linux real install falls back to user systemd when detached service startup is unhealthy', async () => {
+  const fixture = await createLinuxFixtureApp();
+  const configFile = join(fixture.tempDir, 'client-config.json');
+  const cursorExtensionsDir = join(fixture.tempDir, 'real-extensions');
+  const installRecordFile = join(fixture.tempDir, 'install.json');
+  const launcherFile = join(fixture.tempDir, 'bin/cursor-pool-cursor');
+  const calls: string[] = [];
+
+  try {
+    const output = await install({
+      realAppPath: fixture.appPath,
+      yes: true,
+      platform: 'linux',
+      arch: process.arch,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile,
+      cursorExtensionsDir,
+      clientConfigFile: configFile,
+      linuxLauncherFile: launcherFile,
+      compatEntries: [fixture.compatEntry],
+      startDetachedService: async () => {
+        calls.push('detached');
+        throw new Error('Detached service failed to become healthy');
+      },
+      installUserAutostart: async (options) => {
+        calls.push('autostart');
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 56393, runtimeId: 'systemd-runtime' },
+          { runtimeFile: options.runtimeFile },
+        );
+        return { state: 'installed' as const };
+      },
+      fetchHealth: async (url) => {
+        calls.push(`health:${url}`);
+        return { ok: true, healthy: true };
+      },
+    });
+
+    assert.deepEqual(calls, [
+      'detached',
+      'autostart',
+      'health:http://127.0.0.1:56393/health',
+      'health:http://127.0.0.1:56393/health',
+    ]);
+    assert.match(output, /mode: real/);
+    assert.match(output, /service: running 127\.0\.0\.1:56393/);
+    assert.match(output, /autostart: installed/);
+    assert.match(output, /health: ok/);
+    assert.deepEqual(await readRuntimeInfo({ runtimeFile: fixture.runtimeFile }), {
+      host: '127.0.0.1',
+      port: 56393,
+      runtimeId: 'systemd-runtime',
+    });
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('Linux real install waits for delayed user systemd runtime during fallback', async () => {
+  const fixture = await createLinuxFixtureApp();
+  const configFile = join(fixture.tempDir, 'client-config.json');
+  const cursorExtensionsDir = join(fixture.tempDir, 'real-extensions');
+  const installRecordFile = join(fixture.tempDir, 'install.json');
+  const launcherFile = join(fixture.tempDir, 'bin/cursor-pool-cursor');
+  const calls: string[] = [];
+
+  try {
+    const output = await install({
+      realAppPath: fixture.appPath,
+      yes: true,
+      platform: 'linux',
+      arch: process.arch,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile,
+      cursorExtensionsDir,
+      clientConfigFile: configFile,
+      linuxLauncherFile: launcherFile,
+      compatEntries: [fixture.compatEntry],
+      startDetachedService: async () => {
+        calls.push('detached');
+        throw new Error('Detached service failed to become healthy');
+      },
+      installUserAutostart: async (options) => {
+        calls.push('autostart');
+        setTimeout(() => {
+          void writeRuntimeInfo(
+            { host: '127.0.0.1', port: 56394, runtimeId: 'delayed-systemd-runtime' },
+            { runtimeFile: options.runtimeFile },
+          );
+        }, 100);
+        return { state: 'installed' as const };
+      },
+      fetchHealth: async (url) => {
+        calls.push(`health:${url}`);
+        return { ok: true, healthy: true };
+      },
+    });
+
+    assert.match(output, /service: running 127\.0\.0\.1:56394/);
+    assert.match(output, /autostart: installed/);
+    assert.match(output, /health: ok/);
+    assert.deepEqual(await readRuntimeInfo({ runtimeFile: fixture.runtimeFile }), {
+      host: '127.0.0.1',
+      port: 56394,
+      runtimeId: 'delayed-systemd-runtime',
+    });
+    assert.deepEqual(calls.slice(0, 3), [
+      'detached',
+      'autostart',
+      'health:http://127.0.0.1:56394/health',
+    ]);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
 test('real-mode install writes install record and reports real mode', async () => {
   const fixture = await createFixtureApp();
   const installRecordFile = join(fixture.tempDir, 'install.json');
@@ -370,6 +548,7 @@ 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/);
@@ -380,6 +559,7 @@ 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');
@@ -393,6 +573,7 @@ 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(
@@ -403,6 +584,7 @@ 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 }),
@@ -421,6 +603,7 @@ 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(
@@ -431,6 +614,7 @@ test('real-mode install requires confirmation when yes is missing', async () =>
         backupDir: fixture.backupDir,
         installRecordFile,
         extensionInstallPath,
+        cursorExtensionsDir,
         compatEntries: [fixture.compatEntry],
         stopServiceAfterInstall: true,
       }),
@@ -469,6 +653,7 @@ 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/repair.test.ts

@@ -89,6 +89,7 @@ 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/serviceProcess.test.ts

@@ -6,10 +6,19 @@ import { fileURLToPath } from 'node:url';
 import test from 'node:test';
 import { readRuntimeInfo } from '../../service/src/runtime';
 import { startServer } from '../../service/src/server';
-import { startDetachedService, stopRuntimeService, waitForRuntimeHealth } from '../src/serviceProcess';
+import {
+  DEFAULT_DETACHED_SERVICE_STARTUP_TIMEOUT_MS,
+  startDetachedService,
+  stopRuntimeService,
+  waitForRuntimeHealth,
+} from '../src/serviceProcess';
 
 const cliRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 
+test('default detached service startup timeout allows slow Linux VMs', () => {
+  assert.equal(DEFAULT_DETACHED_SERVICE_STARTUP_TIMEOUT_MS, 30_000);
+});
+
 test('startDetachedService starts a service discoverable by runtime file', async () => {
   const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-'));
   const runtimeFile = join(tempDir, 'runtime.json');

package/test/status.test.ts

@@ -136,6 +136,7 @@ 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',