@cursorpool-dev/cli 0.5.6

package/test/installRecord.test.ts

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  deleteInstallRecord,
+  installIdForAppPath,
+  installRecordPath,
+  isInstallRecordStale,
+  readInstallRecord,
+  writeInstallRecord,
+  type InstallRecord,
+} from '../src/installRecord';
+
+function installRecordFixture(appPath: string, overrides: Partial<InstallRecord> = {}) {
+  return {
+    installId: installIdForAppPath(appPath),
+    mode: 'real' as const,
+    appPath,
+    cursorVersion: '3.6.21',
+    cursorCommit: 'e7a7e93f4d75f8272503ecf33cedbaae10114a10',
+    targetRelativePath: 'Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js',
+    originalSha256: 'abc123',
+    compatSupportStatus: 'supported' as const,
+    runtimeFile: join(appPath, 'runtime.json'),
+    backupDir: join(appPath, 'backups'),
+    extensionInstallPath: join(appPath, 'extensions/cursor-pool-status'),
+    extensionLinkedPath: join(appPath, 'Cursor-Pool-Extensions/cursor-pool.extension-0.0.0'),
+    extensionState: 'linked' as const,
+    cliVersion: '0.0.0',
+    extensionVersion: '0.0.0',
+    serviceVersion: '0.0.0',
+    lastOperation: 'install',
+    lastOperationStatus: 'ok',
+    createdAt: '2026-05-30T00:00:00.000Z',
+    updatedAt: '2026-05-30T00:00:01.000Z',
+    ...overrides,
+  } satisfies InstallRecord;
+}
+
+test('install records round-trip through an injected install record file', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-install-record-'));
+  const installRecordFile = join(tempDir, 'nested/install.json');
+  const appPath = join(tempDir, 'Cursor.app');
+
+  try {
+    const record = installRecordFixture(appPath);
+
+    await writeInstallRecord(record, { installRecordFile });
+
+    const saved = await readInstallRecord({ installRecordFile });
+    assert.deepEqual(saved, record);
+    assert.deepEqual(JSON.parse(await readFile(installRecordFile, 'utf8')), record);
+
+    await deleteInstallRecord({ installRecordFile });
+    assert.equal(await readInstallRecord({ installRecordFile }), null);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('writeInstallRecord rejects install ids that do not match the app path', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-install-record-'));
+  const installRecordFile = join(tempDir, 'install.json');
+
+  try {
+    await assert.rejects(
+      writeInstallRecord(
+        installRecordFixture(join(tempDir, 'Cursor.app'), {
+          installId: 'not-the-app-path-id',
+        }),
+        { installRecordFile },
+      ),
+      /Install record id does not match app path/,
+    );
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('installRecordPath returns an explicit install record file path', () => {
+  assert.equal(
+    installRecordPath({ installRecordFile: '/tmp/cursor-pool/install.json' }),
+    '/tmp/cursor-pool/install.json',
+  );
+});
+
+test('isInstallRecordStale compares tracked install state fields', () => {
+  const current = installRecordFixture('/Users/example/Desktop/Cursor.app');
+
+  assert.equal(isInstallRecordStale(current, current), false);
+  assert.equal(
+    isInstallRecordStale(current, {
+      ...current,
+      cursorCommit: 'different-cursor-commit',
+    }),
+    true,
+  );
+  assert.equal(
+    isInstallRecordStale(current, {
+      ...current,
+      extensionState: 'missing',
+    }),
+    true,
+  );
+});

package/test/launch.test.ts

@@ -0,0 +1,138 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildLaunchCommand,
+  inspectLaunchProcesses,
+  launchCommand,
+  launchStatus,
+} from '../src/launch';
+
+test('buildLaunchCommand prints a direct executable command with isolated paths', () => {
+  const appPath = '/Users/example/Desktop/Cursor-Pool-Trial.app';
+  const userDataDir = '/Users/example/Desktop/Cursor-Pool-Trial-UserData';
+  const cursorExtensionsDir = '/Users/example/Desktop/Cursor-Pool-Trial-Extensions';
+
+  const output = buildLaunchCommand({ appPath, userDataDir, cursorExtensionsDir });
+
+  assert.match(output, /Cursor-Pool-Trial\.app\/Contents\/MacOS\/Cursor/);
+  assert.match(output, /--user-data-dir/);
+  assert.match(output, /Cursor-Pool-Trial-UserData/);
+  assert.match(output, /--extensions-dir/);
+  assert.match(output, /Cursor-Pool-Trial-Extensions/);
+  assert.match(output, /--new-window/);
+  assert.doesNotMatch(output, /open -n/);
+});
+
+test('launchCommand rejects the real macOS Cursor app', async () => {
+  await assert.rejects(
+    launchCommand({
+      appPath: '/Applications/Cursor.app',
+      userDataDir: '/tmp/user-data',
+      cursorExtensionsDir: '/tmp/extensions',
+    }),
+    /Refusing to install into real Cursor app/,
+  );
+});
+
+test('launchCommand requires explicit user data and extensions paths', async () => {
+  await assert.rejects(
+    launchCommand({
+      appPath: '/Users/example/Desktop/Cursor-Pool-Trial.app',
+      cursorExtensionsDir: '/tmp/extensions',
+    }),
+    /Missing required --user-data-dir/,
+  );
+
+  await assert.rejects(
+    launchCommand({
+      appPath: '/Users/example/Desktop/Cursor-Pool-Trial.app',
+      userDataDir: '/tmp/user-data',
+    }),
+    /Missing required --cursor-extensions-dir/,
+  );
+});
+
+const appPath = '/Users/example/Desktop/Cursor-Pool-Trial.app';
+const userDataDir = '/Users/example/Desktop/Cursor-Pool-Trial-UserData';
+const cursorExtensionsDir = '/Users/example/Desktop/Cursor-Pool-Trial-Extensions';
+
+test('inspectLaunchProcesses reports not-running when no target app process exists', () => {
+  const status = inspectLaunchProcesses({
+    psOutput: '1 0 /Applications/Cursor.app/Contents/MacOS/Cursor\n',
+    appPath,
+    userDataDir,
+    cursorExtensionsDir,
+  });
+
+  assert.equal(status.launch, 'not-running');
+  assert.equal(status.app, 'missing');
+});
+
+test('inspectLaunchProcesses detects isolated user data and extensions args', () => {
+  const status = inspectLaunchProcesses({
+    psOutput: [
+      `100 1 ${appPath}/Contents/MacOS/Cursor --user-data-dir ${userDataDir} --extensions-dir ${cursorExtensionsDir} --new-window`,
+      `101 100 ${appPath}/Contents/Frameworks/Cursor Helper.app/Contents/MacOS/Cursor Helper --user-data-dir=${userDataDir}`,
+    ].join('\n'),
+    appPath,
+    userDataDir,
+    cursorExtensionsDir,
+  });
+
+  assert.deepEqual(status, {
+    launch: 'running',
+    app: 'matched',
+    userData: 'isolated',
+    extensions: 'isolated',
+    realUserData: 'absent',
+    realExtensions: 'absent',
+  });
+});
+
+test('inspectLaunchProcesses detects real Cursor user data pollution', () => {
+  const status = inspectLaunchProcesses({
+    psOutput: [
+      `${appPath}/Contents/MacOS/Cursor`,
+      `${appPath}/Contents/Frameworks/Cursor Helper.app/Contents/MacOS/Cursor Helper --user-data-dir=/Users/example/Library/Application Support/Cursor`,
+    ].join('\n'),
+    appPath,
+    userDataDir,
+    cursorExtensionsDir,
+    homeDir: '/Users/example',
+  });
+
+  assert.equal(status.launch, 'running');
+  assert.equal(status.userData, 'real-cursor');
+  assert.equal(status.realUserData, 'present');
+});
+
+test('inspectLaunchProcesses ignores crashpad paths under real Cursor user data', () => {
+  const status = inspectLaunchProcesses({
+    psOutput: [
+      `100 1 ${appPath}/Contents/MacOS/Cursor --user-data-dir ${userDataDir} --extensions-dir ${cursorExtensionsDir} --new-window`,
+      `101 100 ${appPath}/Contents/Frameworks/Electron Framework.framework/Helpers/chrome_crashpad_handler --database=/Users/example/Library/Application Support/Cursor/Crashpad`,
+      `102 100 ${appPath}/Contents/Frameworks/Cursor Helper.app/Contents/MacOS/Cursor Helper --user-data-dir=${userDataDir}`,
+    ].join('\n'),
+    appPath,
+    userDataDir,
+    cursorExtensionsDir,
+    homeDir: '/Users/example',
+  });
+
+  assert.equal(status.userData, 'isolated');
+  assert.equal(status.realUserData, 'absent');
+});
+
+test('launchStatus formats process inspection output', async () => {
+  const output = await launchStatus({
+    appPath,
+    userDataDir,
+    cursorExtensionsDir,
+    psOutput: `${appPath}/Contents/MacOS/Cursor --user-data-dir=${userDataDir}`,
+  });
+
+  assert.match(output, /launch: running/);
+  assert.match(output, /app: matched/);
+  assert.match(output, /user-data: isolated/);
+  assert.match(output, /real-user-data: absent/);
+});

package/test/platform.test.ts

@@ -0,0 +1,226 @@
+import assert from 'node:assert/strict';
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { writeRuntimeInfo } from '../../service/src/runtime';
+import {
+  formatPlatformLogin,
+  formatPlatformStatus,
+  heartbeat,
+  login,
+  logout,
+  whoami,
+} from '../src/platform';
+
+function readBody(request: IncomingMessage) {
+  return new Promise<Record<string, unknown>>((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    request.on('data', (chunk: Buffer) => chunks.push(chunk));
+    request.on('error', reject);
+    request.on('end', () => {
+      resolve(
+        chunks.length === 0
+          ? {}
+          : (JSON.parse(Buffer.concat(chunks).toString('utf8')) as Record<string, unknown>),
+      );
+    });
+  });
+}
+
+function writeJson(response: ServerResponse, body: Record<string, unknown>) {
+  const payload = JSON.stringify(body);
+  response.writeHead(200, {
+    'content-type': 'application/json',
+    'content-length': Buffer.byteLength(payload),
+  });
+  response.end(payload);
+}
+
+async function createLocalService(handler: (request: IncomingMessage, body: Record<string, unknown>) => void) {
+  const server = createServer(async (request, response) => {
+    const body = await readBody(request);
+    handler(request, body);
+
+    if (request.url === '/platform/status') {
+      writeJson(response, {
+        state: 'logged-in',
+        user: { id: 'usr_1', email: 'dev@example.com' },
+        device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:30Z' },
+      });
+      return;
+    }
+
+    if (request.url === '/platform/heartbeat') {
+      writeJson(response, {
+        state: 'logged-in',
+        user: { id: 'usr_1', email: 'dev@example.com' },
+        device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:01:00Z' },
+      });
+      return;
+    }
+
+    if (request.url === '/platform/logout') {
+      writeJson(response, { state: 'logged-out' });
+      return;
+    }
+
+    if (request.url === '/platform/login') {
+      writeJson(response, {
+        state: 'logged-in',
+        user: { id: 'usr_1', email: 'dev@example.com' },
+        device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+      });
+      return;
+    }
+
+    response.writeHead(404);
+    response.end();
+  });
+
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const address = server.address();
+  assert.equal(typeof address, 'object');
+
+  return {
+    port: address?.port as number,
+    close: () => new Promise<void>((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    }),
+  };
+}
+
+test('formatPlatformStatus reports logged-in user, device, and heartbeat', () => {
+  assert.equal(
+    formatPlatformStatus({
+      state: 'logged-in',
+      user: { id: 'usr_1', email: 'dev@example.com' },
+      device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:30Z' },
+    }),
+    [
+      'platform: logged-in',
+      'user: dev@example.com',
+      'device: active dev_1',
+      'heartbeat: 2026-05-30T00:00:30Z',
+    ].join('\n'),
+  );
+});
+
+test('formatPlatformStatus reports logged-out state', () => {
+  assert.equal(formatPlatformStatus({ state: 'logged-out' }), 'platform: logged-out');
+});
+
+test('formatPlatformLogin matches platform status formatting', () => {
+  assert.equal(
+    formatPlatformLogin({
+      state: 'logged-in',
+      user: { id: 'usr_1', email: 'dev@example.com' },
+      device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+    }),
+    [
+      'platform: logged-in',
+      'user: dev@example.com',
+      'device: active dev_1',
+      'heartbeat: 2026-05-30T00:00:00Z',
+    ].join('\n'),
+  );
+});
+
+test('platform commands call local service platform routes', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-cli-platform-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const calls: Array<{ method?: string; url?: string; body: Record<string, unknown> }> = [];
+  const service = await createLocalService((request, body) => {
+    calls.push({ method: request.method, url: request.url, body });
+  });
+
+  try {
+    await writeRuntimeInfo(
+      { host: '127.0.0.1', port: service.port, runtimeId: 'runtime-1' },
+      { runtimeFile },
+    );
+
+    const loginOutput = await login({
+      runtimeFile,
+      code: 'CODE-123',
+      apiBaseUrl: 'https://platform.example.test',
+    });
+    assert.match(loginOutput, /platform: logged-in/);
+
+    const whoamiOutput = await whoami({ runtimeFile });
+    assert.match(whoamiOutput, /heartbeat: 2026-05-30T00:00:30Z/);
+
+    const heartbeatOutput = await heartbeat({ runtimeFile });
+    assert.match(heartbeatOutput, /heartbeat: 2026-05-30T00:01:00Z/);
+
+    assert.equal(await logout({ runtimeFile }), 'platform: logged-out');
+
+    assert.deepEqual(
+      calls.map((call) => [call.method, call.url]),
+      [
+        ['POST', '/platform/login'],
+        ['GET', '/platform/status'],
+        ['POST', '/platform/heartbeat'],
+        ['POST', '/platform/logout'],
+      ],
+    );
+    assert.equal(calls[0]?.body.code, 'CODE-123');
+    assert.equal(calls[0]?.body.apiBaseUrl, 'https://platform.example.test');
+    assert.equal(typeof (calls[0]?.body.device as Record<string, unknown>).name, 'string');
+    assert.equal((calls[2]?.body as Record<string, unknown>).serviceStatus, 'running');
+    assert.equal(JSON.stringify(calls), JSON.stringify(calls).replace(/deviceToken/g, ''));
+  } finally {
+    await service.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('platform commands require service runtime', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-cli-platform-missing-'));
+
+  try {
+    await assert.rejects(
+      whoami({ runtimeFile: join(tempDir, 'runtime.json') }),
+      /Cursor Pool service runtime is unavailable/,
+    );
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('platform commands reject per-command session files', async () => {
+  await assert.rejects(
+    login({
+      code: 'CODE-123',
+      apiBaseUrl: 'https://platform.example.test',
+      sessionFile: '/tmp/session.json',
+    }),
+    /--session-file is managed by the local service/,
+  );
+  await assert.rejects(
+    whoami({ sessionFile: '/tmp/session.json' }),
+    /--session-file is managed by the local service/,
+  );
+  await assert.rejects(
+    heartbeat({ sessionFile: '/tmp/session.json' }),
+    /--session-file is managed by the local service/,
+  );
+  await assert.rejects(
+    logout({ sessionFile: '/tmp/session.json' }),
+    /--session-file is managed by the local service/,
+  );
+});
+
+test('login requires code and apiBaseUrl', async () => {
+  await assert.rejects(
+    login({ code: 'CODE-123', apiBaseUrl: undefined as unknown as string }),
+    /--api-base-url is required/,
+  );
+  await assert.rejects(
+    login({ code: undefined as unknown as string, apiBaseUrl: 'https://platform.example.test' }),
+    /--code is required/,
+  );
+});