@cursorpool-dev/cli 0.5.6

package/src/uninstall.ts

@@ -0,0 +1,213 @@
+import { rm } from 'node:fs/promises';
+import { basename, dirname, normalize, resolve } from 'node:path';
+import { sha256File } from '@cursor-pool/patcher/hash';
+import { hasCursorPoolMarker } from '@cursor-pool/patcher/marker';
+import { resolveCursorAgentExecPath } from '@cursor-pool/patcher';
+import { resolveRuntimeFile } from '@cursor-pool/service';
+import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
+import {
+  confirmRealOperation,
+  formatRealOperationSummary,
+  type ConfirmRealOperationOptions,
+} from './confirm';
+import { findCursor } from './cursor';
+import { removeExtensionBundle } from './extensionBundle';
+import {
+  LINKED_EXTENSION_DIRNAME,
+  linkedExtensionPathForDir,
+  removeLinkedExtensionBundle,
+} from './extensionLink';
+import {
+  deleteInstallRecord,
+  installIdForAppPath,
+  readInstallRecord,
+  type InstallRecord,
+  type InstallRecordOptions,
+} from './installRecord';
+import { restore } from './restore';
+import type { RestoreOptions } from './restore';
+import { stopRuntimeService } from './serviceProcess';
+import { removeUserAutostart } from './autostart';
+import { resolveCursorTarget, type CursorTargetOptions } from './target';
+import {
+  assertDisposableCursorAppPath,
+  deleteTrialRecord,
+  readTrialRecord,
+  type TrialRecordOptions,
+} from './trial';
+
+export type UninstallOptions = RestoreOptions &
+  CursorTargetOptions &
+  TrialRecordOptions & {
+    runtimeFile?: string;
+    extensionInstallPath?: string;
+    cursorExtensionsDir?: string;
+    removeUserAutostart?: typeof removeUserAutostart;
+  } & InstallRecordOptions &
+  Pick<ConfirmRealOperationOptions, 'yes' | 'isInteractive' | 'askConfirmation'>;
+
+function normalizeAppPath(path: string) {
+  return normalize(path).replace(/\/+$/, '');
+}
+
+function assertRealUninstallInstallRecord(
+  record: InstallRecord | null,
+  cursorAppPath: string,
+) {
+  if (!record) {
+    throw new Error('install-record: missing');
+  }
+
+  const normalizedCursorAppPath = normalizeAppPath(cursorAppPath);
+  const recordMatches =
+    record.mode === 'real' &&
+    normalizeAppPath(record.appPath) === normalizedCursorAppPath &&
+    record.installId === installIdForAppPath(cursorAppPath);
+
+  if (!recordMatches) {
+    throw new Error(`Install record does not match Cursor app: ${normalizedCursorAppPath}`);
+  }
+
+  return record;
+}
+
+async function removeRecordedLinkedExtensionBundle(
+  linkedPath: string | undefined,
+  cursorExtensionsDir: string | undefined,
+) {
+  if (!linkedPath) {
+    return;
+  }
+
+  if (basename(resolve(linkedPath)) !== LINKED_EXTENSION_DIRNAME) {
+    throw new Error(`Unsafe linked extension path for recursive removal: ${linkedPath}`);
+  }
+
+  if (cursorExtensionsDir) {
+    const expectedLinkedPath = resolve(linkedExtensionPathForDir(cursorExtensionsDir));
+    if (resolve(linkedPath) !== expectedLinkedPath) {
+      throw new Error(`Unsafe linked extension path: ${linkedPath}`);
+    }
+
+    await rm(linkedPath, { recursive: true, force: true });
+    return;
+  }
+
+  try {
+    await removeLinkedExtensionBundle(linkedPath);
+    return;
+  } catch (error) {
+    const parentName = basename(dirname(resolve(linkedPath)));
+    if (!parentName.endsWith('Extensions')) {
+      throw error;
+    }
+  }
+
+  await rm(linkedPath, { recursive: true, force: true });
+}
+
+export async function uninstall(options: UninstallOptions = {}) {
+  const target = resolveCursorTarget(options);
+  const appPath =
+    target.mode === 'disposable' ? assertDisposableCursorAppPath(target.appPath) : target.appPath;
+  const cursor = await findCursor({ ...options, appPath });
+  const installRecord =
+    target.mode === 'real'
+      ? await readInstallRecord({ installRecordFile: options.installRecordFile })
+      : null;
+  const trialRecord =
+    target.mode === 'disposable'
+      ? await readTrialRecord(cursor.appPath, {
+          trialRecordDir: options.trialRecordDir,
+        })
+      : null;
+  const realInstallRecord =
+    target.mode === 'real'
+      ? assertRealUninstallInstallRecord(installRecord, cursor.appPath)
+      : null;
+  const backupDir =
+    target.mode === 'real'
+      ? realInstallRecord?.backupDir
+      : options.backupDir ?? trialRecord?.backupDir;
+  const runtimeFile =
+    target.mode === 'real'
+      ? realInstallRecord?.runtimeFile ?? DEFAULT_RUNTIME_FILE
+      : options.runtimeFile ?? trialRecord?.runtimeFile;
+  const extensionInstallPath =
+    target.mode === 'real'
+      ? realInstallRecord?.extensionInstallPath
+      : options.extensionInstallPath ?? trialRecord?.extensionInstallPath;
+  const extensionLinkedPath =
+    target.mode === 'real'
+      ? realInstallRecord?.extensionLinkedPath
+      : options.cursorExtensionsDir
+        ? linkedExtensionPathForDir(options.cursorExtensionsDir)
+        : trialRecord?.extensionLinkedPath;
+  const targetRelativePath =
+    target.mode === 'real'
+      ? realInstallRecord?.targetRelativePath
+      : trialRecord?.targetRelativePath;
+  const targetPath = resolveCursorAgentExecPath(cursor.appPath, targetRelativePath);
+  if (target.requiresConfirmation) {
+    const summary = {
+      operation: 'uninstall' as const,
+      appPath: cursor.appPath,
+      targetPath,
+      backupPath: backupDir,
+      runtimeFile,
+      extensionInstallPath,
+      extensionLinkedPath,
+    };
+    formatRealOperationSummary(summary);
+    await confirmRealOperation({
+      summary,
+      yes: options.yes,
+      isInteractive: options.isInteractive,
+      askConfirmation: options.askConfirmation,
+    });
+  }
+
+  const targetHash = await sha256File(targetPath);
+  const targetChangedFromRecordedOriginal =
+    target.mode === 'real'
+      ? Boolean(realInstallRecord) && targetHash !== realInstallRecord?.originalSha256
+      : Boolean(trialRecord) && targetHash !== trialRecord?.originalSha256;
+  const shouldRestore =
+    (await hasCursorPoolMarker(targetPath)) || targetChangedFromRecordedOriginal;
+  const restoreOutput = shouldRestore
+    ? await restore({ ...options, backupDir, yes: target.mode === 'real' ? true : options.yes })
+    : [
+        `Cursor ${cursor.version} (${cursor.commit})`,
+        `mode: ${target.mode}`,
+        `app: ${cursor.appPath}`,
+        'restore: skipped',
+        'patch: missing',
+      ].join('\n');
+  const removeAutostart = options.removeUserAutostart ?? removeUserAutostart;
+  await removeAutostart();
+  if (runtimeFile) {
+    await stopRuntimeService(resolveRuntimeFile(runtimeFile));
+    await rm(resolveRuntimeFile(runtimeFile), { force: true });
+  }
+  await removeRecordedLinkedExtensionBundle(
+    extensionLinkedPath,
+    target.mode === 'real' ? undefined : options.cursorExtensionsDir,
+  );
+  if (extensionInstallPath) {
+    await removeExtensionBundle(extensionInstallPath);
+  }
+  if (target.mode === 'real') {
+    await deleteInstallRecord({ installRecordFile: options.installRecordFile });
+  } else {
+    await deleteTrialRecord(cursor.appPath, { trialRecordDir: options.trialRecordDir });
+  }
+
+  return [
+    restoreOutput,
+    extensionInstallPath || extensionLinkedPath ? 'extension: removed' : 'extension: skipped',
+    'autostart: removed',
+    runtimeFile ? 'service: stopped' : 'service: skipped',
+    target.mode === 'real' ? 'install-record: removed' : 'trial: removed',
+    'uninstall: ok',
+  ].join('\n');
+}

package/test/autostart.test.ts

@@ -0,0 +1,151 @@
+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 { installUserAutostart, removeUserAutostart } from '../src/autostart';
+
+test('installUserAutostart writes a macOS user LaunchAgent without admin paths', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-autostart-'));
+  const launchAgentFile = join(tempDir, 'home/Library/LaunchAgents/com.cursor-pool.service.plist');
+  const calls: string[][] = [];
+
+  try {
+    const result = await installUserAutostart({
+      platform: 'darwin',
+      launchAgentFile,
+      nodeCommand: '/usr/local/bin/node',
+      cliEntry: join(tempDir, 'home/.cursor-pool/client/node_modules/@cursorpool-dev/cli/bin/cursor-pool.mjs'),
+      tsxLoader: join(tempDir, 'home/.cursor-pool/client/node_modules/tsx/dist/esm/index.mjs'),
+      serviceEntry: join(tempDir, 'home/.cursor-pool/client/node_modules/@cursorpool-dev/cli/node_modules/@cursor-pool/service/src/entry.ts'),
+      runtimeFile: join(tempDir, 'home/.cursor-pool/runtime.json'),
+      serviceLogFile: join(tempDir, 'home/.cursor-pool/logs/service.log'),
+      configFile: join(tempDir, 'home/.cursor-pool/client-config.json'),
+      uid: 501,
+      execFile: async (_command, args) => {
+        calls.push(args);
+        return { stdout: '', stderr: '' };
+      },
+    });
+
+    assert.equal(result.state, 'installed');
+    const plist = await readFile(launchAgentFile, 'utf8');
+    assert.match(plist, /<key>Label<\/key>\s*<string>com\.cursor-pool\.service<\/string>/);
+    assert.match(plist, /<string>\/usr\/local\/bin\/node<\/string>/);
+    assert.match(plist, /<string>--import<\/string>/);
+    assert.match(plist, /<string>.*tsx\/dist\/esm\/index\.mjs<\/string>/);
+    assert.match(plist, /<string>.*service\/src\/entry\.ts<\/string>/);
+    assert.doesNotMatch(plist, /<string>start<\/string>/);
+    assert.match(plist, /<string>--runtime-file<\/string>/);
+    assert.match(plist, /<string>--service-log-file<\/string>/);
+    assert.match(plist, /<string>--config-file<\/string>/);
+    assert.doesNotMatch(plist, /sudo|\/Library\/LaunchDaemons/);
+    assert.deepEqual(calls, [
+      ['bootstrap', 'gui/501', launchAgentFile],
+      ['kickstart', '-k', 'gui/501/com.cursor-pool.service'],
+    ]);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('removeUserAutostart removes the macOS user LaunchAgent idempotently', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-autostart-'));
+  const launchAgentFile = join(tempDir, 'home/Library/LaunchAgents/com.cursor-pool.service.plist');
+  const calls: string[][] = [];
+
+  try {
+    await installUserAutostart({
+      platform: 'darwin',
+      launchAgentFile,
+      nodeCommand: '/usr/local/bin/node',
+      cliEntry: join(tempDir, 'cursor-pool.mjs'),
+      uid: 501,
+      execFile: async () => ({ stdout: '', stderr: '' }),
+    });
+
+    const result = await removeUserAutostart({
+      platform: 'darwin',
+      launchAgentFile,
+      uid: 501,
+      execFile: async (_command, args) => {
+        calls.push(args);
+        return { stdout: '', stderr: '' };
+      },
+    });
+
+    assert.equal(result.state, 'removed');
+    assert.deepEqual(calls, [['bootout', 'gui/501/com.cursor-pool.service']]);
+    await assert.rejects(readFile(launchAgentFile, 'utf8'), /ENOENT/);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('installUserAutostart writes a Windows user startup command', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-autostart-'));
+  const startupFile = join(tempDir, 'Startup/CursorPoolService.cmd');
+
+  try {
+    const result = await installUserAutostart({
+      platform: 'win32',
+      windowsStartupFile: startupFile,
+      nodeCommand: 'C:\\Program Files\\nodejs\\node.exe',
+      cliEntry: 'C:\\Users\\demo\\.cursor-pool\\client\\node_modules\\@cursor-pool\\cli\\bin\\cursor-pool.mjs',
+      tsxLoader: 'C:\\Users\\demo\\.cursor-pool\\client\\node_modules\\tsx\\dist\\esm\\index.mjs',
+      serviceEntry: 'C:\\Users\\demo\\.cursor-pool\\client\\node_modules\\@cursor-pool\\cli\\node_modules\\@cursor-pool\\service\\src\\entry.ts',
+      runtimeFile: 'C:\\Users\\demo\\.cursor-pool\\runtime.json',
+      serviceLogFile: 'C:\\Users\\demo\\.cursor-pool\\logs\\service.log',
+      configFile: 'C:\\Users\\demo\\.cursor-pool\\client-config.json',
+    });
+
+    assert.equal(result.state, 'installed');
+    const script = await readFile(startupFile, 'utf8');
+    assert.match(script, /start "" \/min/);
+    assert.match(script, /node\.exe/);
+    assert.match(script, /"--import"/);
+    assert.match(script, /tsx\\dist\\esm\\index\.mjs/);
+    assert.match(script, /service\\src\\entry\.ts/);
+    assert.doesNotMatch(script, /"start"/);
+    assert.match(script, /"--runtime-file"/);
+    assert.match(script, /"--config-file"/);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('installUserAutostart writes a Linux user systemd service', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-autostart-'));
+  const serviceFile = join(tempDir, 'systemd/cursor-pool.service');
+  const calls: string[][] = [];
+
+  try {
+    const result = await installUserAutostart({
+      platform: 'linux',
+      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',
+      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',
+      configFile: '/home/demo/.cursor-pool/client-config.json',
+      execFile: async (_command, args) => {
+        calls.push(args);
+        return { stdout: '', stderr: '' };
+      },
+    });
+
+    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, /--config-file/);
+    assert.match(service, /Restart=always/);
+    assert.deepEqual(calls, [
+      ['--user', 'daemon-reload'],
+      ['--user', 'enable', '--now', 'cursor-pool.service'],
+    ]);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/test/compat.test.ts

@@ -0,0 +1,192 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { CURSOR_AGENT_EXEC_RELATIVE_PATH } from '../../patcher/src/patchCursorAgentExec';
+import type { CompatibilityManifestEntry } from '../../shared/src/manifest';
+import {
+  buildCompatManifestSignature,
+  compatManifestUrlFromApiBaseUrl,
+  DEFAULT_COMPAT_ENTRIES,
+  loadCompatEntries,
+  resolveCompatEntry,
+  verifyCompatManifestEnvelope,
+} from '../src/compat';
+
+function remoteRuleFor(cursorVersion: string, cursorCommit: string): CompatibilityManifestEntry {
+  return {
+    platform: 'darwin',
+    arch: 'arm64',
+    cursorVersion,
+    cursorCommit,
+    supportStatus: 'supported',
+    targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
+    expectedSha256: 'remote-sha256',
+    structureSignature: 'remote-structure',
+    patchStrategy: 'cursor-agent-exec-snippet',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'external-backup',
+    minCliVersion: '0.0.0',
+    minExtensionVersion: '0.0.0',
+    minServiceVersion: '0.0.0',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: false,
+    userMessage: 'Remote Cursor build is supported.',
+  };
+}
+
+function signedEnvelope(version: number, rules: CompatibilityManifestEntry[]) {
+  return {
+    version,
+    signatureAlgorithm: 'hmac-sha256-dev',
+    signatureKeyId: 'dev-compatibility-key',
+    signature: buildCompatManifestSignature(version, rules),
+    rules,
+  };
+}
+
+test('default compatibility manifest supports Cursor 3.6.21 on macOS arm64', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/Users/example/Desktop/Cursor-Pool-Agent-Canary.app',
+      version: '3.6.21',
+      commit: 'e7a7e93f4d75f8272503ecf33cedbaae10114a10',
+    },
+    {
+      platform: 'darwin',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.requiresAdHocResign, true);
+  assert.equal(entry.targetRelativePath, CURSOR_AGENT_EXEC_RELATIVE_PATH);
+  assert.equal(
+    entry.expectedSha256,
+    '222512631b78fddcdca3fa76c0dd458a7a86751dde19c998ceb31b3fe1905ebf',
+  );
+  assert.equal(
+    DEFAULT_COMPAT_ENTRIES.some(
+      (candidate) =>
+        candidate.cursorVersion === '3.6.21' &&
+        candidate.cursorCommit === 'e7a7e93f4d75f8272503ecf33cedbaae10114a10',
+    ),
+    true,
+  );
+});
+
+test('default compatibility manifest supports Cursor 3.5.38 on macOS x64 for Rosetta-launched installers', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/Applications/Cursor.app',
+      version: '3.5.38',
+      commit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    },
+    {
+      platform: 'darwin',
+      arch: 'x64',
+      nodeVersion: process.version,
+    },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.requiresAdHocResign, true);
+  assert.equal(entry.targetRelativePath, CURSOR_AGENT_EXEC_RELATIVE_PATH);
+  assert.equal(
+    entry.expectedSha256,
+    'cb18f0237278884a39e2ce2b8664255e12689ad0803c20096c38e86c36acc51f',
+  );
+});
+
+test('verifies a remote compatibility manifest envelope with the development signature', () => {
+  const rules = [remoteRuleFor('3.7.0', 'remote-commit')];
+  const envelope = {
+    version: 7,
+    signatureAlgorithm: 'hmac-sha256-dev',
+    signatureKeyId: 'dev-compatibility-key',
+    signature: buildCompatManifestSignature(7, rules),
+    rules,
+  };
+
+  assert.deepEqual(verifyCompatManifestEnvelope(envelope), rules);
+});
+
+test('rejects remote compatibility manifest with an invalid signature', () => {
+  const rules = [remoteRuleFor('3.7.0', 'remote-commit')];
+
+  assert.throws(
+    () =>
+      verifyCompatManifestEnvelope({
+        version: 7,
+        signatureAlgorithm: 'hmac-sha256-dev',
+        signatureKeyId: 'dev-compatibility-key',
+        signature: 'bad',
+        rules,
+      }),
+    /compat manifest signature invalid/,
+  );
+});
+
+test('derives compatibility manifest url from api base url', () => {
+  assert.equal(
+    compatManifestUrlFromApiBaseUrl('https://platform.example.test/root/'),
+    'https://platform.example.test/root/api/client/compatibility/manifest',
+  );
+});
+
+test('loads remote compatibility entries from api base url when signature is valid', async () => {
+  const rules = [remoteRuleFor('3.7.0', 'remote-commit')];
+  const entries = await loadCompatEntries({
+    apiBaseUrl: 'https://platform.example.test/root',
+    fetchManifest: async (url) => {
+      assert.equal(url, 'https://platform.example.test/root/api/client/compatibility/manifest');
+      return { ok: true, json: async () => signedEnvelope(8, rules) };
+    },
+  });
+
+  assert.equal(entries[0]?.cursorVersion, '3.7.0');
+});
+
+test('loads compatibility entries from a local file URL for disposable client validation', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-compat-file-url-'));
+  const manifestPath = join(tempDir, 'compat.json');
+  const rules = [remoteRuleFor('3.9.0', 'file-commit')];
+  await writeFile(manifestPath, JSON.stringify(signedEnvelope(9, rules)), 'utf8');
+
+  try {
+    const entries = await loadCompatEntries({
+      compatManifestUrl: `file://${manifestPath}`,
+      fetchManifest: async () => {
+        throw new Error('fetch should not be called for file URLs');
+      },
+    });
+
+    assert.deepEqual(entries, rules);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('falls back to default compatibility entries when remote manifest is unavailable', async () => {
+  const entries = await loadCompatEntries({
+    apiBaseUrl: 'https://platform.example.test',
+    fetchManifest: async () => ({ ok: false, json: async () => ({}) }),
+  });
+
+  assert.equal(entries, DEFAULT_COMPAT_ENTRIES);
+});
+
+test('falls back to injected compatibility entries before fetching remote manifest', async () => {
+  const injected = [remoteRuleFor('3.8.0', 'injected-commit')];
+  const entries = await loadCompatEntries({
+    compatEntries: injected,
+    apiBaseUrl: 'https://platform.example.test',
+    fetchManifest: async () => {
+      throw new Error('fetch should not be called');
+    },
+  });
+
+  assert.equal(entries, injected);
+});

package/test/confirm.test.ts

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  confirmRealOperation,
+  formatRealOperationSummary,
+} from '../src/confirm';
+
+test('formatRealOperationSummary outputs provided operation paths', () => {
+  assert.equal(
+    formatRealOperationSummary({
+      operation: 'install',
+      appPath: '/Applications/Cursor.app',
+      targetPath: '/Applications/Cursor.app/Contents/Resources/app/out/main.js',
+      backupPath: '/tmp/backups/main.js',
+      runtimeFile: '/tmp/runtime.json',
+      extensionInstallPath: '/tmp/extensions/cursor-pool-status',
+      extensionLinkedPath: '/tmp/Cursor/extensions/cursor-pool-status',
+      restorePath: '/tmp/restore/main.js',
+    }),
+    [
+      'operation: install',
+      'app: /Applications/Cursor.app',
+      'target: /Applications/Cursor.app/Contents/Resources/app/out/main.js',
+      'backup: /tmp/backups/main.js',
+      'runtime: /tmp/runtime.json',
+      'extension-install: /tmp/extensions/cursor-pool-status',
+      'extension-linked: /tmp/Cursor/extensions/cursor-pool-status',
+      'restore: /tmp/restore/main.js',
+    ].join('\n'),
+  );
+});
+
+test('formatRealOperationSummary omits optional paths when missing', () => {
+  assert.equal(
+    formatRealOperationSummary({
+      operation: 'restore',
+      appPath: '/Applications/Cursor.app',
+      targetPath: '/Applications/Cursor.app/target.js',
+    }),
+    [
+      'operation: restore',
+      'app: /Applications/Cursor.app',
+      'target: /Applications/Cursor.app/target.js',
+    ].join('\n'),
+  );
+});
+
+test('confirmRealOperation allows yes without asking', async () => {
+  let asked = false;
+
+  await confirmRealOperation({
+    yes: true,
+    isInteractive: false,
+    summary: {
+      operation: 'install',
+      appPath: '/Applications/Cursor.app',
+      targetPath: '/Applications/Cursor.app/target.js',
+    },
+    askConfirmation: async () => {
+      asked = true;
+      return false;
+    },
+  });
+
+  assert.equal(asked, false);
+});
+
+test('confirmRealOperation rejects non-interactive real operation without yes', async () => {
+  await assert.rejects(
+    confirmRealOperation({
+      yes: false,
+      isInteractive: false,
+      summary: {
+        operation: 'uninstall',
+        appPath: '/Applications/Cursor.app',
+        targetPath: '/Applications/Cursor.app/target.js',
+      },
+    }),
+    /Pass --yes to confirm uninstall for real Cursor/,
+  );
+});
+
+test('confirmRealOperation allows injected confirmation approval', async () => {
+  await confirmRealOperation({
+    yes: false,
+    isInteractive: true,
+    summary: {
+      operation: 'restore',
+      appPath: '/Applications/Cursor.app',
+      targetPath: '/Applications/Cursor.app/target.js',
+    },
+    askConfirmation: async (prompt) => {
+      assert.match(prompt, /operation: restore/);
+      assert.match(prompt, /Proceed\?/);
+      return true;
+    },
+  });
+});
+
+test('confirmRealOperation rejects injected confirmation denial', async () => {
+  await assert.rejects(
+    confirmRealOperation({
+      yes: false,
+      isInteractive: true,
+      summary: {
+        operation: 'repair',
+        appPath: '/Applications/Cursor.app',
+        targetPath: '/Applications/Cursor.app/target.js',
+      },
+      askConfirmation: async () => false,
+    }),
+    /repair cancelled/,
+  );
+});