@cursorpool-dev/cli 0.5.6

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

@@ -0,0 +1,658 @@
+import assert from 'node:assert/strict';
+import { execFile, spawn } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import test from 'node:test';
+import { promisify } from 'node:util';
+import { parseCommonOptions } from '../bin/cursor-pool';
+
+const cliRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const repoRoot = resolve(cliRoot, '../..');
+const binPath = resolve(cliRoot, 'bin/cursor-pool.ts');
+const execFileAsync = promisify(execFile);
+
+test('CLI common options include target, record, trial, extension, and service log paths', () => {
+  assert.deepEqual(
+    parseCommonOptions([
+      '--app-path',
+      '/tmp/Cursor.app',
+      '--real-app-path',
+      '/Applications/Cursor.app',
+      '--runtime-file',
+      '/tmp/runtime.json',
+      '--backup-dir',
+      '/tmp/backups',
+      '--install-record-file',
+      '/tmp/install-record.json',
+      '--trial-record-dir',
+      '/tmp/trials',
+      '--extension-install-path',
+      '/tmp/extensions/cursor-pool-status',
+      '--cursor-extensions-dir',
+      '/tmp/Cursor-Pool-Trial-Extensions',
+      '--user-data-dir',
+      '/tmp/Cursor-Pool-Trial-UserData',
+      '--service-log-file',
+      '/tmp/service.log',
+      '--diagnostics-file',
+      '/tmp/diagnostics.jsonl',
+      '--session-file',
+      '/tmp/session.json',
+      '--code',
+      'CODE-123',
+      '--api-base-url',
+      'https://platform.example.test',
+      '--compat-manifest-url',
+      'https://cdn.example.test/compat.json',
+      '--yes',
+    ]),
+    {
+      appPath: '/tmp/Cursor.app',
+      realAppPath: '/Applications/Cursor.app',
+      runtimeFile: '/tmp/runtime.json',
+      backupDir: '/tmp/backups',
+      installRecordFile: '/tmp/install-record.json',
+      trialRecordDir: '/tmp/trials',
+      extensionInstallPath: '/tmp/extensions/cursor-pool-status',
+      cursorExtensionsDir: '/tmp/Cursor-Pool-Trial-Extensions',
+      userDataDir: '/tmp/Cursor-Pool-Trial-UserData',
+      serviceLogFile: '/tmp/service.log',
+      diagnosticsFile: '/tmp/diagnostics.jsonl',
+      sessionFile: '/tmp/session.json',
+      code: 'CODE-123',
+      apiBaseUrl: 'https://platform.example.test',
+      compatManifestUrl: 'https://cdn.example.test/compat.json',
+      yes: true,
+    },
+  );
+});
+
+test('CLI common options reject missing values before command execution', () => {
+  assert.throws(
+    () => parseCommonOptions(['--runtime-file', '--service-log-file', '/tmp/service.log']),
+    /runtime_file_missing_value/,
+  );
+  assert.throws(
+    () => parseCommonOptions(['--code', '--api-base-url', 'https://platform.example.test']),
+    /code_missing_value/,
+  );
+});
+
+test('CLI login command is recognized', async () => {
+  const child = spawn(
+    'pnpm',
+    [
+      'exec',
+      'tsx',
+      binPath,
+      'login',
+      '--code',
+      'CODE-123',
+      '--api-base-url',
+      'https://platform.example.test',
+      '--runtime-file',
+      '/tmp/cursor-pool-missing-runtime.json',
+    ],
+    {
+      cwd: repoRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const stderrChunks: Buffer[] = [];
+  child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+  const exitCode = await new Promise<number | null>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('exit', resolve);
+  });
+
+  const stderr = Buffer.concat(stderrChunks).toString('utf8');
+
+  assert.equal(exitCode, 1);
+  assert.match(stderr, /Cursor Pool service runtime is unavailable/);
+  assert.doesNotMatch(stderr, /Unknown command: login/);
+});
+
+test('CLI platform status commands are recognized', async () => {
+  for (const command of ['whoami', 'heartbeat', 'logout']) {
+    const child = spawn(
+      'pnpm',
+      [
+        'exec',
+        'tsx',
+        binPath,
+        command,
+        '--runtime-file',
+        `/tmp/cursor-pool-missing-${command}-runtime.json`,
+      ],
+      {
+        cwd: repoRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
+    );
+
+    const stderrChunks: Buffer[] = [];
+    child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+    const exitCode = await new Promise<number | null>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('exit', resolve);
+    });
+
+    const stderr = Buffer.concat(stderrChunks).toString('utf8');
+
+    assert.equal(exitCode, 1);
+    assert.match(stderr, /Cursor Pool service runtime is unavailable/);
+    assert.doesNotMatch(stderr, new RegExp(`Unknown command: ${command}`));
+  }
+});
+
+test('CLI stop command is recognized and idempotent without runtime', async () => {
+  const child = spawn(
+    'pnpm',
+    [
+      'exec',
+      'tsx',
+      binPath,
+      'stop',
+      '--runtime-file',
+      '/tmp/cursor-pool-missing-stop-runtime.json',
+    ],
+    {
+      cwd: repoRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const stdoutChunks: Buffer[] = [];
+  const stderrChunks: Buffer[] = [];
+  child.stdout.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
+  child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+  const exitCode = await new Promise<number | null>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('exit', resolve);
+  });
+
+  const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+  const stderr = Buffer.concat(stderrChunks).toString('utf8');
+
+  assert.equal(exitCode, 0, stderr);
+  assert.match(stdout, /service: not-running/);
+  assert.doesNotMatch(stderr, /Unknown command: stop/);
+});
+
+test('CLI start command is recognized and starts a disposable runtime service', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-bin-start-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const serviceLogFile = join(tempDir, 'service.log');
+
+  try {
+    const child = spawn(
+      'pnpm',
+      [
+        'exec',
+        'tsx',
+        binPath,
+        'start',
+        '--runtime-file',
+        runtimeFile,
+        '--service-log-file',
+        serviceLogFile,
+      ],
+      {
+        cwd: repoRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
+    );
+
+    const stdoutChunks: Buffer[] = [];
+    const stderrChunks: Buffer[] = [];
+    child.stdout.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
+    child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+    const exitCode = await new Promise<number | null>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('exit', resolve);
+    });
+
+    const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+    const stderr = Buffer.concat(stderrChunks).toString('utf8');
+
+    assert.equal(exitCode, 0, stderr);
+    assert.match(stdout, /service: started 127\.0\.0\.1:\d+/);
+    assert.doesNotMatch(stderr, /Unknown command: start/);
+  } finally {
+    const stop = spawn(
+      'pnpm',
+      ['exec', 'tsx', binPath, 'stop', '--runtime-file', runtimeFile],
+      {
+        cwd: repoRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
+    );
+    await new Promise<number | null>((resolve, reject) => {
+      stop.once('error', reject);
+      stop.once('exit', resolve);
+    });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('CLI start rejects missing runtime file value before starting service', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-bin-missing-runtime-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const serviceLogFile = join(tempDir, 'service.log');
+
+  try {
+    const child = spawn(
+      'pnpm',
+      [
+        'exec',
+        'tsx',
+        binPath,
+        'start',
+        '--runtime-file',
+        '--service-log-file',
+        serviceLogFile,
+      ],
+      {
+        cwd: repoRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
+    );
+
+    const stderrChunks: Buffer[] = [];
+    child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+    const exitCode = await new Promise<number | null>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('exit', resolve);
+    });
+
+    const stderr = Buffer.concat(stderrChunks).toString('utf8');
+    assert.equal(exitCode, 1);
+    assert.match(stderr, /runtime_file_missing_value/);
+    await assert.rejects(readFile(runtimeFile, 'utf8'), /ENOENT/);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('CLI bin executes launch-command with isolated paths', async () => {
+  const child = spawn(
+    'pnpm',
+    [
+      'exec',
+      'tsx',
+      binPath,
+      'launch-command',
+      '--app-path',
+      '/Users/example/Desktop/Cursor-Pool-Trial.app',
+      '--user-data-dir',
+      '/Users/example/Desktop/Cursor-Pool-Trial-UserData',
+      '--cursor-extensions-dir',
+      '/Users/example/Desktop/Cursor-Pool-Trial-Extensions',
+    ],
+    {
+      cwd: repoRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const stdoutChunks: Buffer[] = [];
+  const stderrChunks: Buffer[] = [];
+  child.stdout.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
+  child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+  const exitCode = await new Promise<number | null>((resolveExit, reject) => {
+    child.once('error', reject);
+    child.once('exit', resolveExit);
+  });
+
+  const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+  assert.equal(exitCode, 0, Buffer.concat(stderrChunks).toString('utf8'));
+  assert.match(stdout, /Contents\/MacOS\/Cursor/);
+  assert.match(stdout, /--user-data-dir/);
+  assert.match(stdout, /--extensions-dir/);
+  assert.match(stdout, /--new-window/);
+  assert.doesNotMatch(stdout, /open -n/);
+});
+
+test('CLI bin executes when spawned through tsx', async () => {
+  const child = spawn(
+    'pnpm',
+    [
+      'exec',
+      'tsx',
+      binPath,
+      'status',
+      '--app-path',
+      '/Applications/Cursor.app',
+    ],
+    {
+      cwd: repoRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const stdoutChunks: Buffer[] = [];
+  const stderrChunks: Buffer[] = [];
+  child.stdout.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
+  child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+  const exitCode = await new Promise<number | null>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('exit', resolve);
+  });
+
+  assert.equal(exitCode, 1);
+  assert.equal(Buffer.concat(stdoutChunks).toString('utf8'), '');
+  assert.match(
+    Buffer.concat(stderrChunks).toString('utf8'),
+    /Refusing to install into real Cursor app/,
+  );
+});
+
+test('CLI status ignores diagnostics-only limit option', async () => {
+  const child = spawn(
+    'pnpm',
+    [
+      'exec',
+      'tsx',
+      binPath,
+      'status',
+      '--app-path',
+      '/Applications/Cursor.app',
+      '--limit',
+      '0',
+    ],
+    {
+      cwd: repoRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const stderrChunks: Buffer[] = [];
+  child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+  const exitCode = await new Promise<number | null>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('exit', resolve);
+  });
+
+  const stderr = Buffer.concat(stderrChunks).toString('utf8');
+
+  assert.equal(exitCode, 1);
+  assert.match(stderr, /Refusing to install into real Cursor app/);
+  assert.doesNotMatch(stderr, /--limit must be a positive integer/);
+});
+
+test('CLI diagnostics rejects missing limit value', async () => {
+  const child = spawn(
+    'pnpm',
+    ['exec', 'tsx', binPath, 'diagnostics', '--limit', '--json'],
+    {
+      cwd: repoRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const stderrChunks: Buffer[] = [];
+  child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+  const exitCode = await new Promise<number | null>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('exit', resolve);
+  });
+
+  const stderr = Buffer.concat(stderrChunks).toString('utf8');
+  assert.equal(exitCode, 1);
+  assert.match(stderr, /limit_missing_value/);
+});
+
+test('CLI repair command is recognized', async () => {
+  const child = spawn(
+    'pnpm',
+    [
+      'exec',
+      'tsx',
+      binPath,
+      'repair',
+      '--app-path',
+      '/Applications/Cursor.app',
+    ],
+    {
+      cwd: repoRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const stderrChunks: Buffer[] = [];
+  child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+  const exitCode = await new Promise<number | null>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('exit', resolve);
+  });
+
+  const stderr = Buffer.concat(stderrChunks).toString('utf8');
+
+  assert.equal(exitCode, 1);
+  assert.doesNotMatch(stderr, /Unknown command: repair/);
+});
+
+test('CLI bin executes when spawned through a symlinked path', async () => {
+  const tempDir = await mkdtemp(resolve(tmpdir(), 'cursor-pool-bin-symlink-'));
+  const symlinkPath = resolve(tempDir, 'cursor-pool.ts');
+  await symlink(binPath, symlinkPath);
+
+  try {
+    const child = spawn(
+      'pnpm',
+      [
+        'exec',
+        'tsx',
+        symlinkPath,
+        'status',
+        '--app-path',
+        '/Applications/Cursor.app',
+      ],
+      {
+        cwd: repoRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
+    );
+
+    const stdoutChunks: Buffer[] = [];
+    const stderrChunks: Buffer[] = [];
+    child.stdout.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
+    child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+    const exitCode = await new Promise<number | null>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('exit', resolve);
+    });
+
+    assert.equal(exitCode, 1);
+    assert.equal(Buffer.concat(stdoutChunks).toString('utf8'), '');
+    assert.match(
+      Buffer.concat(stderrChunks).toString('utf8'),
+      /Refusing to install into real Cursor app/,
+    );
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('CLI bin executes diagnostics with an injected diagnostics file', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-bin-diagnostics-'));
+  const diagnosticsFile = join(tempDir, 'diagnostics.jsonl');
+
+  try {
+    await mkdir(dirname(diagnosticsFile), { recursive: true });
+    await writeFile(
+      diagnosticsFile,
+      `${JSON.stringify({
+        requestId: 'req-1',
+        requestType: 'agent',
+        source: 'cursor-agent-exec',
+        model: 'unknown',
+        receivedAt: '2026-05-30T00:00:01.000Z',
+        runtimeId: 'runtime-1',
+        prompt: 'do not print',
+        apiKey: 'secret',
+      })}\n`,
+      'utf8',
+    );
+
+    const child = spawn(
+      'pnpm',
+      [
+        'exec',
+        'tsx',
+        binPath,
+        'diagnostics',
+        '--diagnostics-file',
+        diagnosticsFile,
+      ],
+      {
+        cwd: repoRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
+    );
+
+    const stdoutChunks: Buffer[] = [];
+    const stderrChunks: Buffer[] = [];
+    child.stdout.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
+    child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+    const exitCode = await new Promise<number | null>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('exit', resolve);
+    });
+
+    const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+    const stderr = Buffer.concat(stderrChunks).toString('utf8');
+
+    assert.equal(exitCode, 0, stderr);
+    assert.match(stdout, /diagnostics: 1 entry/);
+    assert.match(stdout, /requestId=req-1/);
+    assert.doesNotMatch(stdout, /prompt|secret/);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('packed npm client runs from a clean user project without global tsx', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-packed-client-'));
+  const packDir = join(tempDir, 'packages');
+  const userDir = join(tempDir, 'user');
+  await mkdir(packDir, { recursive: true });
+  await mkdir(userDir, { recursive: true });
+
+  try {
+    const packageDirs = ['shared', 'patcher', 'service', 'extension', 'cli'];
+    const tarballs: string[] = [];
+    for (const name of packageDirs) {
+      const { stdout } = await execFileAsync(
+        'pnpm',
+        ['pack', '--pack-destination', packDir],
+        { cwd: join(repoRoot, 'packages', name) },
+      );
+      tarballs.push(stdout.trim().split('\n').at(-1) ?? '');
+    }
+
+    await writeFile(join(userDir, 'package.json'), '{"private":true}\n', 'utf8');
+    await execFileAsync('npm', ['install', ...tarballs], { cwd: userDir });
+
+    let result:
+      | { code?: number; stdout: string; stderr: string }
+      | { code: number; stdout?: string; stderr?: string };
+    try {
+      result = await execFileAsync(
+        join(userDir, 'node_modules/.bin/cursor-pool'),
+        ['status', '--app-path', '/Applications/Cursor.app'],
+        { cwd: userDir },
+      );
+    } catch (error) {
+      result = error as { code: number; stdout?: string; stderr?: string };
+    }
+
+    assert.equal(result.code, 1);
+    assert.match(result.stderr ?? '', /Refusing to install into real Cursor app/);
+    assert.doesNotMatch(result.stderr ?? '', /tsx: No such file or directory/);
+    assert.doesNotMatch(result.stderr ?? '', /Cannot find module/);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('single packed npm client installs from a clean user project', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-single-packed-client-'));
+  const packDir = join(tempDir, 'packages');
+  const userDir = join(tempDir, 'user');
+  await mkdir(packDir, { recursive: true });
+  await mkdir(userDir, { recursive: true });
+
+  try {
+    const { stdout } = await execFileAsync(
+      'pnpm',
+      ['pack', '--pack-destination', packDir],
+      { cwd: cliRoot },
+    );
+    const tarball = stdout.trim().split('\n').at(-1) ?? '';
+
+    await writeFile(join(userDir, 'package.json'), '{"private":true}\n', 'utf8');
+    await execFileAsync('npm', ['install', tarball], { cwd: userDir });
+    const runtimeFile = join(userDir, 'runtime.json');
+    const serviceLogFile = join(userDir, 'service.log');
+    const clientBin = join(userDir, 'node_modules/.bin/cursor-pool');
+
+    try {
+      const start = await execFileAsync(
+        clientBin,
+        ['start', '--runtime-file', runtimeFile, '--service-log-file', serviceLogFile],
+        { cwd: userDir },
+      );
+      assert.match(start.stdout, /service: started 127\.0\.0\.1:\d+/);
+      assert.doesNotMatch(start.stderr, /Cannot find module|tsx: No such file or directory/);
+
+      const runningStatus = await execFileAsync(
+        clientBin,
+        ['status', '--runtime-file', runtimeFile],
+        { cwd: userDir },
+      );
+      assert.match(runningStatus.stdout, /service: running/);
+    } finally {
+      await execFileAsync(
+        clientBin,
+        ['stop', '--runtime-file', runtimeFile],
+        { cwd: userDir },
+      );
+    }
+
+    let result:
+      | { code?: number; stdout: string; stderr: string }
+      | { code: number; stdout?: string; stderr?: string };
+    try {
+      result = await execFileAsync(
+        clientBin,
+        ['status', '--app-path', '/Applications/Cursor.app'],
+        { cwd: userDir },
+      );
+    } catch (error) {
+      result = error as { code: number; stdout?: string; stderr?: string };
+    }
+
+    assert.equal(result.code, 1);
+    assert.match(result.stderr ?? '', /Refusing to install into real Cursor app/);
+    assert.doesNotMatch(result.stderr ?? '', /tsx: No such file or directory/);
+    assert.doesNotMatch(result.stderr ?? '', /Cannot find module/);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/test/cursor.test.ts

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { defaultCursorAppPath } from '../src/cursor';
+
+test('defaultCursorAppPath resolves the user-level Windows Cursor install directory', () => {
+  assert.equal(
+    defaultCursorAppPath({
+      platform: 'win32',
+      env: { LOCALAPPDATA: 'C:\\Users\\dev\\AppData\\Local' },
+    }),
+    'C:\\Users\\dev\\AppData\\Local\\Programs\\Cursor',
+  );
+});
+
+test('defaultCursorAppPath gives a helpful Windows error when LOCALAPPDATA is unavailable', () => {
+  assert.throws(
+    () => defaultCursorAppPath({ platform: 'win32', env: {} }),
+    /LOCALAPPDATA is required to auto-detect Cursor on Windows/,
+  );
+});