@cursorpool-dev/cli 0.5.6 → 0.5.9

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,
@@ -123,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

@@ -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';
@@ -225,6 +225,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 +236,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 });
   }
@@ -350,6 +357,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');

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/trial.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import { mkdir, mkdtemp, readFile, rm, symlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, relative, resolve } from 'node:path';
 import test from 'node:test';
 import {
   assertDisposableCursorAppPath,
@@ -55,6 +55,20 @@ test('assertDisposableCursorAppPath accepts a disposable app copy path', () => {
   );
 });
 
+test('assertDisposableCursorAppPath normalizes relative disposable app paths to absolute paths', async () => {
+  const tempDir = await mkdtemp(join(process.cwd(), '.cursor-pool-relative-app-path-'));
+  const appPath = join(tempDir, 'Cursor-Trial.app');
+
+  try {
+    await mkdir(appPath, { recursive: true });
+    const relativeAppPath = relative(process.cwd(), appPath);
+
+    assert.equal(assertDisposableCursorAppPath(relativeAppPath), resolve(appPath));
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
 test('assertDisposableCursorAppPath rejects non app bundle paths', () => {
   assert.throws(
     () => assertDisposableCursorAppPath('/Users/example/Desktop/Cursor-Pool-Trial'),