@cursorpool-dev/cli 0.5.6

package/test/e2e-install.test.ts

@@ -0,0 +1,773 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+import { getServiceStatus } from '../../extension/src/api';
+import { sha256File } from '../../patcher/src/hash';
+import {
+  CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR,
+  CURSOR_POOL_PATCH_MARKER,
+} from '../../patcher/src/marker';
+import { backupPathForCursorAgentExec } from '../../patcher/src/patchCursorAgentExec';
+import type { CompatibilityManifestEntry } from '../../shared/src/manifest';
+import { getExtensionState } from '../src/extensionBundle';
+import { getLinkedExtensionState, linkedExtensionPathForDir } from '../src/extensionLink';
+import { install } from '../src/install';
+import {
+  installIdForAppPath,
+  readInstallRecord,
+  writeInstallRecord,
+  type InstallRecord,
+} from '../src/installRecord';
+import { restore } from '../src/restore';
+import { status } from '../src/status';
+import { readTrialRecord, trialIdForAppPath, writeTrialRecord } from '../src/trial';
+import { uninstall } from '../src/uninstall';
+
+const cursorVersion = '3.5.38';
+const cursorCommit = '009bb5a3600dd98fe1c1f25798f767f686e14750';
+const targetRelativePath =
+  'Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js';
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
+const serviceServerPath = resolve(repoRoot, 'packages/service/src/server.ts');
+
+async function createFixtureApp(prefix: string) {
+  const tempDir = await mkdtemp(join(tmpdir(), prefix));
+  const appPath = join(tempDir, 'Cursor.app');
+  const targetPath = join(appPath, targetRelativePath);
+  const targetContent = `function main() { return "agent"; }\n${CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR}\nmain();\n`;
+  await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-agent-exec/dist'), {
+    recursive: true,
+  });
+  await writeFile(
+    join(appPath, 'Contents/Resources/app/product.json'),
+    JSON.stringify({ version: cursorVersion, commit: cursorCommit }),
+    'utf8',
+  );
+  await writeFile(targetPath, targetContent, 'utf8');
+
+  const originalHash = createHash('sha256').update(targetContent).digest('hex');
+  const compatEntry: CompatibilityManifestEntry = {
+    platform: process.platform,
+    arch: process.arch,
+    cursorVersion,
+    cursorCommit,
+    supportStatus: 'supported',
+    targetRelativePath,
+    expectedSha256: originalHash,
+    structureSignature: 'fixture',
+    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: 'fixture supported',
+  };
+
+  return {
+    appPath,
+    tempDir,
+    targetPath,
+    targetContent,
+    originalHash,
+    runtimeFile: join(tempDir, 'runtime.json'),
+    backupDir: join(tempDir, 'backups'),
+    compatEntry,
+  };
+}
+
+async function assertRuntimeFileMissing(runtimeFile: string) {
+  await assert.rejects(stat(runtimeFile), /ENOENT/);
+}
+
+function createInstallRecordFixture(
+  fixture: Awaited<ReturnType<typeof createFixtureApp>>,
+  overrides: Partial<InstallRecord> = {},
+): InstallRecord {
+  const now = '2026-05-30T00:00:00.000Z';
+  return {
+    installId: installIdForAppPath(fixture.appPath),
+    mode: 'real',
+    appPath: fixture.appPath,
+    cursorVersion,
+    cursorCommit,
+    targetRelativePath,
+    originalSha256: fixture.originalHash,
+    compatSupportStatus: 'supported',
+    runtimeFile: fixture.runtimeFile,
+    backupDir: fixture.backupDir,
+    extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+    extensionLinkedPath: linkedExtensionPathForDir(join(fixture.tempDir, 'Cursor-Extensions')),
+    extensionState: 'linked',
+    cliVersion: '0.0.0',
+    extensionVersion: '0.0.0',
+    serviceVersion: '0.0.0',
+    lastOperation: 'install',
+    lastOperationStatus: 'ok',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}
+
+async function waitForChildService(runtimeFile: string) {
+  const child = spawn(
+    'pnpm',
+    [
+      'exec',
+      'tsx',
+      '-e',
+      [
+        `import { startServer } from ${JSON.stringify(serviceServerPath)};`,
+        'void (async () => {',
+        '  const service = await startServer({ runtimeFile: process.env.RUNTIME_FILE });',
+        '  console.log(JSON.stringify({ port: service.port }));',
+        '})();',
+      ].join('\n'),
+    ],
+    {
+      cwd: repoRoot,
+      env: { ...process.env, RUNTIME_FILE: runtimeFile },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const stderrChunks: Buffer[] = [];
+  child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+
+  const port = await new Promise<number>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(
+        new Error(
+          `Timed out waiting for child service. stderr: ${Buffer.concat(stderrChunks).toString('utf8')}`,
+        ),
+      );
+    }, 5000);
+
+    child.once('error', (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.stdout.once('data', (chunk: Buffer) => {
+      clearTimeout(timeout);
+      try {
+        resolve((JSON.parse(chunk.toString('utf8')) as { port: number }).port);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+
+  return { child, port };
+}
+
+test('e2e install/status/restore/status/uninstall flow uses fixture app only', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-flow-');
+  const cursorExtensionsDir = join(fixture.tempDir, 'Extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+
+  try {
+    assert.equal(await sha256File(fixture.targetPath), fixture.originalHash);
+
+    const initialStatus = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+    assert.match(initialStatus, /patch: missing/);
+    assert.match(initialStatus, /service: stopped/);
+    assert.deepEqual(await getServiceStatus(fixture.runtimeFile), {
+      service: 'stopped',
+      runtime: null,
+    });
+
+    const installOutput = await install({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      cursorExtensionsDir,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterInstall: true,
+    });
+    assert.match(installOutput, /extension: linked/);
+    assert.match(installOutput, /trial: recorded/);
+    assert.match(installOutput, /service: running/);
+    assert.match(installOutput, /patch: applied/);
+    assert.equal(await getLinkedExtensionState(linkedPath), 'linked');
+    assert.match(await readFile(fixture.targetPath, 'utf8'), new RegExp(CURSOR_POOL_PATCH_MARKER));
+    assert.notEqual(await sha256File(fixture.targetPath), fixture.originalHash);
+    assert.equal(
+      await readFile(
+        await backupPathForCursorAgentExec(
+          fixture.appPath,
+          fixture.targetPath,
+          fixture.backupDir,
+        ),
+        'utf8',
+      ),
+      fixture.targetContent,
+    );
+
+    const installedStatus = await status({
+      appPath: fixture.appPath,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      compatEntries: [fixture.compatEntry],
+    });
+    assert.match(installedStatus, /app: .*Cursor\.app/);
+    assert.match(installedStatus, /patch: applied/);
+    assert.match(installedStatus, /service: stopped/);
+    assert.match(installedStatus, /extension: linked/);
+    assert.match(installedStatus, /runtime: /);
+    assert.match(installedStatus, /trial: recorded/);
+
+    const extensionStatus = await getServiceStatus(fixture.runtimeFile);
+    assert.equal(extensionStatus.service, 'stopped');
+
+    const restoreOutput = await restore({
+      appPath: fixture.appPath,
+      backupDir: fixture.backupDir,
+    });
+    assert.match(restoreOutput, /restore: ok/);
+    assert.match(restoreOutput, /app: .*Cursor\.app/);
+    assert.match(restoreOutput, /patch: missing/);
+    assert.equal(await sha256File(fixture.targetPath), fixture.originalHash);
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+
+    const restoredStatus = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+    assert.match(restoredStatus, /patch: missing/);
+    assert.match(restoredStatus, /service: stopped/);
+
+    const restoredExtensionStatus = await getServiceStatus(fixture.runtimeFile);
+    assert.equal(restoredExtensionStatus.service, 'stopped');
+
+    const uninstallOutput = await uninstall({
+      appPath: fixture.appPath,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+    });
+    assert.match(uninstallOutput, /restore: skipped/);
+    assert.match(uninstallOutput, /mode: disposable/);
+    assert.match(uninstallOutput, /extension: removed/);
+    assert.match(uninstallOutput, /service: stopped/);
+    assert.match(uninstallOutput, /trial: removed/);
+    assert.match(uninstallOutput, /uninstall: ok/);
+    assert.equal(await sha256File(fixture.targetPath), fixture.originalHash);
+    assert.equal(await getLinkedExtensionState(linkedPath), 'missing');
+    await assertRuntimeFileMissing(fixture.runtimeFile);
+
+    const uninstalledStatus = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+    assert.match(uninstalledStatus, /patch: missing/);
+    assert.match(uninstalledStatus, /service: stopped/);
+    assert.deepEqual(await getServiceStatus(fixture.runtimeFile), {
+      service: 'stopped',
+      runtime: null,
+    });
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('uninstall stops a service discovered only from runtime file', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-child-uninstall-');
+  const { child, port } = await waitForChildService(fixture.runtimeFile);
+
+  try {
+    const health = await fetch(`http://127.0.0.1:${port}/health`);
+    assert.equal(health.ok, true);
+
+    const uninstallOutput = await uninstall({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+    });
+    assert.match(uninstallOutput, /service: stopped/);
+    await assertRuntimeFileMissing(fixture.runtimeFile);
+    await assert.rejects(fetch(`http://127.0.0.1:${port}/health`), /fetch failed/);
+  } finally {
+    child.kill();
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('disposable uninstall without a trial record does not remove default install assets', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-unrecorded-uninstall-');
+  const originalHome = process.env.HOME;
+  const sandboxHome = join(fixture.tempDir, 'home');
+  const defaultRuntimeFile = join(sandboxHome, '.cursor-pool/runtime.json');
+  const defaultExtensionPath = join(sandboxHome, '.cursor-pool/extensions/cursor-pool-status');
+
+  try {
+    process.env.HOME = sandboxHome;
+    await mkdir(dirname(defaultRuntimeFile), { recursive: true });
+    await writeFile(defaultRuntimeFile, '{"sentinel":true}\n', 'utf8');
+    await mkdir(join(defaultExtensionPath, 'dist'), { recursive: true });
+    await writeFile(join(defaultExtensionPath, 'package.json'), '{"name":"sentinel"}\n', 'utf8');
+    await writeFile(join(defaultExtensionPath, 'dist/extension.js'), 'sentinel\n', 'utf8');
+
+    const uninstallOutput = await uninstall({
+      appPath: fixture.appPath,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+    });
+
+    assert.match(uninstallOutput, /restore: skipped/);
+    assert.match(uninstallOutput, /mode: disposable/);
+    assert.match(uninstallOutput, /extension: skipped/);
+    assert.match(uninstallOutput, /service: skipped/);
+    assert.match(uninstallOutput, /trial: removed/);
+    assert.match(uninstallOutput, /uninstall: ok/);
+    assert.equal(await readFile(defaultRuntimeFile, 'utf8'), '{"sentinel":true}\n');
+    assert.equal(await getExtensionState(defaultExtensionPath), 'bundled');
+  } finally {
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('uninstall discovers backup, runtime, and extension paths from trial record', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-record-uninstall-');
+  const trialRecordDir = join(fixture.tempDir, 'trials');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+
+  try {
+    await install({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      trialRecordDir,
+      extensionInstallPath,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterInstall: true,
+    });
+
+    const uninstallOutput = await uninstall({
+      appPath: fixture.appPath,
+      trialRecordDir,
+    });
+
+    assert.match(uninstallOutput, /restore: ok/);
+    assert.match(uninstallOutput, /patch: missing/);
+    assert.match(uninstallOutput, /extension: removed/);
+    assert.match(uninstallOutput, /service: stopped/);
+    assert.match(uninstallOutput, /trial: removed/);
+    assert.equal(await sha256File(fixture.targetPath), fixture.originalHash);
+    await assertRuntimeFileMissing(fixture.runtimeFile);
+    assert.equal(await getExtensionState(extensionInstallPath), 'missing');
+    assert.equal(await readTrialRecord(fixture.appPath, { trialRecordDir }), null);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('uninstall removes linked extension recorded from a custom cursor extensions dir', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-custom-linked-uninstall-');
+  const trialRecordDir = join(fixture.tempDir, 'trials');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+  const cursorExtensionsDir = join(fixture.tempDir, 'Cursor-Pool-Trial-Extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+
+  try {
+    await install({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      trialRecordDir,
+      extensionInstallPath,
+      cursorExtensionsDir,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterInstall: true,
+    });
+
+    assert.equal(await getLinkedExtensionState(linkedPath), 'linked');
+
+    const uninstallOutput = await uninstall({
+      appPath: fixture.appPath,
+      trialRecordDir,
+    });
+
+    assert.match(uninstallOutput, /extension: removed/);
+    assert.equal(await getLinkedExtensionState(linkedPath), 'missing');
+    assert.equal(await getExtensionState(extensionInstallPath), 'missing');
+    assert.equal(await readTrialRecord(fixture.appPath, { trialRecordDir }), null);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('uninstall removes linked extension from an explicit custom cursor extensions dir', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-explicit-custom-linked-uninstall-');
+  const trialRecordDir = join(fixture.tempDir, 'trials');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+  const cursorExtensionsDir = join(fixture.tempDir, 'Cursor-Pool-Trial-Extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+
+  try {
+    await install({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      trialRecordDir,
+      extensionInstallPath,
+      cursorExtensionsDir,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterInstall: true,
+    });
+
+    assert.equal(await getLinkedExtensionState(linkedPath), 'linked');
+
+    const uninstallOutput = await uninstall({
+      appPath: fixture.appPath,
+      trialRecordDir,
+      cursorExtensionsDir,
+    });
+
+    assert.match(uninstallOutput, /uninstall: ok/);
+    assert.match(uninstallOutput, /extension: removed/);
+    assert.equal(await getLinkedExtensionState(linkedPath), 'missing');
+    assert.equal(await getExtensionState(extensionInstallPath), 'missing');
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('uninstall rejects unsafe recorded linked extension path without removing it', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-unsafe-linked-uninstall-');
+  const trialRecordDir = join(fixture.tempDir, 'trials');
+  const unsafeLinkedPath = join(fixture.tempDir, 'unsafe-parent/cursor-pool.extension-0.0.0');
+  const sentinelPath = join(unsafeLinkedPath, 'sentinel.txt');
+  const now = '2026-05-30T00:00:00.000Z';
+
+  await mkdir(unsafeLinkedPath, { recursive: true });
+  await writeFile(sentinelPath, 'do not remove\n', 'utf8');
+  await writeTrialRecord(
+    {
+      trialId: trialIdForAppPath(fixture.appPath),
+      appPath: fixture.appPath,
+      cursorVersion,
+      cursorCommit,
+      targetRelativePath,
+      originalSha256: fixture.originalHash,
+      compatSupportStatus: 'supported',
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      extensionLinkedPath: unsafeLinkedPath,
+      extensionState: 'linked',
+      createdAt: now,
+      updatedAt: now,
+    },
+    { trialRecordDir },
+  );
+
+  try {
+    await assert.rejects(
+      uninstall({
+        appPath: fixture.appPath,
+        trialRecordDir,
+      }),
+      /Unsafe linked extension path/,
+    );
+
+    assert.equal(await readFile(sentinelPath, 'utf8'), 'do not remove\n');
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('uninstall restores changed target bytes even when the patch marker is absent', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-changed-target-uninstall-');
+  const trialRecordDir = join(fixture.tempDir, 'trials');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+
+  try {
+    await install({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      trialRecordDir,
+      extensionInstallPath,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterInstall: true,
+    });
+    await writeFile(fixture.targetPath, 'function main() { return "rewritten"; }\nmain();\n');
+
+    const uninstallOutput = await uninstall({
+      appPath: fixture.appPath,
+      trialRecordDir,
+    });
+
+    assert.match(uninstallOutput, /restore: ok/);
+    assert.match(uninstallOutput, /patch: missing/);
+    assert.equal(await sha256File(fixture.targetPath), fixture.originalHash);
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+    await assertRuntimeFileMissing(fixture.runtimeFile);
+    assert.equal(await getExtensionState(extensionInstallPath), 'missing');
+    assert.equal(await readTrialRecord(fixture.appPath, { trialRecordDir }), null);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('real-mode uninstall discovers paths from install record and removes only project files', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-real-uninstall-');
+  const installRecordFile = join(fixture.tempDir, 'install-record.json');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+  const cursorExtensionsDir = join(fixture.tempDir, '.cursor/extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+  const unrelatedExtensionDir = join(cursorExtensionsDir, 'unrelated.extension');
+  const unrelatedSentinel = join(unrelatedExtensionDir, 'sentinel.txt');
+
+  try {
+    await mkdir(unrelatedExtensionDir, { recursive: true });
+    await writeFile(unrelatedSentinel, 'do not remove\n', 'utf8');
+
+    await install({
+      realAppPath: fixture.appPath,
+      installRecordFile,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      extensionInstallPath,
+      cursorExtensionsDir,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterInstall: true,
+      yes: true,
+      isInteractive: false,
+    });
+
+    assert.match(await readFile(fixture.targetPath, 'utf8'), new RegExp(CURSOR_POOL_PATCH_MARKER));
+    assert.equal(await getLinkedExtensionState(linkedPath), 'linked');
+
+    const uninstallOutput = await uninstall({
+      realAppPath: fixture.appPath,
+      installRecordFile,
+      yes: true,
+      isInteractive: false,
+    });
+
+    assert.match(uninstallOutput, /mode: real/);
+    assert.match(uninstallOutput, /restore: ok/);
+    assert.match(uninstallOutput, /extension: removed/);
+    assert.match(uninstallOutput, /service: stopped/);
+    assert.match(uninstallOutput, /install-record: removed/);
+    assert.match(uninstallOutput, /uninstall: ok/);
+    assert.equal(await sha256File(fixture.targetPath), fixture.originalHash);
+    await assertRuntimeFileMissing(fixture.runtimeFile);
+    assert.equal(await getExtensionState(extensionInstallPath), 'missing');
+    assert.equal(await getLinkedExtensionState(linkedPath), 'missing');
+    assert.equal(await readFile(unrelatedSentinel, 'utf8'), 'do not remove\n');
+    assert.equal(await readInstallRecord({ installRecordFile }), null);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('real-mode uninstall ignores explicit override paths', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-real-uninstall-overrides-');
+  const installRecordFile = join(fixture.tempDir, 'install-record.json');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+  const cursorExtensionsDir = join(fixture.tempDir, '.cursor/extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+  const overrideBackupDir = join(fixture.tempDir, 'override/backups');
+  const overrideRuntimeFile = join(fixture.tempDir, 'override/runtime.json');
+  const overrideExtensionInstallPath = join(
+    fixture.tempDir,
+    'override/extensions/cursor-pool-status',
+  );
+  const overrideCursorExtensionsDir = join(fixture.tempDir, 'override/.cursor/extensions');
+  const overrideLinkedPath = linkedExtensionPathForDir(overrideCursorExtensionsDir);
+  const prompts: string[] = [];
+
+  try {
+    await mkdir(dirname(overrideRuntimeFile), { recursive: true });
+    await writeFile(overrideRuntimeFile, '{"sentinel":true}\n', 'utf8');
+    await mkdir(join(overrideExtensionInstallPath, 'dist'), { recursive: true });
+    await writeFile(
+      join(overrideExtensionInstallPath, 'package.json'),
+      '{"name":"override"}\n',
+      'utf8',
+    );
+    await writeFile(
+      join(overrideExtensionInstallPath, 'dist/extension.js'),
+      'override extension\n',
+      'utf8',
+    );
+    await mkdir(join(overrideLinkedPath, 'dist'), { recursive: true });
+    await writeFile(join(overrideLinkedPath, 'package.json'), '{"name":"override-linked"}\n', 'utf8');
+    await writeFile(join(overrideLinkedPath, 'dist/extension.js'), 'override linked\n', 'utf8');
+
+    await install({
+      realAppPath: fixture.appPath,
+      installRecordFile,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      extensionInstallPath,
+      cursorExtensionsDir,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterInstall: true,
+      yes: true,
+      isInteractive: false,
+    });
+
+    const uninstallOutput = await uninstall({
+      realAppPath: fixture.appPath,
+      installRecordFile,
+      backupDir: overrideBackupDir,
+      runtimeFile: overrideRuntimeFile,
+      extensionInstallPath: overrideExtensionInstallPath,
+      cursorExtensionsDir: overrideCursorExtensionsDir,
+      isInteractive: true,
+      askConfirmation: (prompt) => {
+        prompts.push(prompt);
+        return true;
+      },
+    });
+
+    assert.match(uninstallOutput, /mode: real/);
+    assert.match(uninstallOutput, /install-record: removed/);
+    assert.equal(await sha256File(fixture.targetPath), fixture.originalHash);
+    await assertRuntimeFileMissing(fixture.runtimeFile);
+    assert.equal(await getExtensionState(extensionInstallPath), 'missing');
+    assert.equal(await getLinkedExtensionState(linkedPath), 'missing');
+    assert.equal(await readFile(overrideRuntimeFile, 'utf8'), '{"sentinel":true}\n');
+    assert.equal(await getExtensionState(overrideExtensionInstallPath), 'bundled');
+    assert.equal(await getLinkedExtensionState(overrideLinkedPath), 'linked');
+    assert.equal(prompts.length, 1);
+    assert.match(prompts[0], new RegExp(fixture.backupDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+    assert.match(prompts[0], new RegExp(fixture.runtimeFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+    assert.match(
+      prompts[0],
+      new RegExp(extensionInstallPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
+    );
+    assert.match(prompts[0], new RegExp(linkedPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+    assert.doesNotMatch(
+      prompts[0],
+      new RegExp(overrideBackupDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
+    );
+    assert.equal(await readInstallRecord({ installRecordFile }), null);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('real-mode uninstall rejects mismatched install record before mutation', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-real-uninstall-safety-');
+  const otherFixture = await createFixtureApp('cursor-pool-cli-e2e-real-uninstall-other-');
+  const installRecordFile = join(fixture.tempDir, 'install-record.json');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+  const cursorExtensionsDir = join(fixture.tempDir, '.cursor/extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+
+  try {
+    await install({
+      realAppPath: fixture.appPath,
+      installRecordFile,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      extensionInstallPath,
+      cursorExtensionsDir,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterInstall: true,
+      yes: true,
+      isInteractive: false,
+    });
+
+    const wrongRecord = createInstallRecordFixture(otherFixture);
+    await writeInstallRecord(wrongRecord, { installRecordFile });
+
+    await assert.rejects(
+      uninstall({
+        realAppPath: fixture.appPath,
+        installRecordFile,
+        yes: true,
+        isInteractive: false,
+      }),
+      /Install record does not match Cursor app/,
+    );
+
+    assert.match(await readFile(fixture.targetPath, 'utf8'), new RegExp(CURSOR_POOL_PATCH_MARKER));
+    assert.equal(await getLinkedExtensionState(linkedPath), 'linked');
+    assert.deepEqual(await readInstallRecord({ installRecordFile }), wrongRecord);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+    await rm(otherFixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('e2e install failure rolls back target bytes, runtime, and service', async () => {
+  const fixture = await createFixtureApp('cursor-pool-cli-e2e-rollback-');
+  let startedPort: number | undefined;
+
+  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: [fixture.compatEntry],
+        patchCursorAgentExec: async (appPath, options) => {
+          const { patchCursorAgentExec } = await import(
+            '../../patcher/src/patchCursorAgentExec'
+          );
+          const result = await patchCursorAgentExec(appPath, options);
+          const runtime = JSON.parse(await readFile(fixture.runtimeFile, 'utf8')) as {
+            port: number;
+          };
+          startedPort = runtime.port;
+          throw new Error('synthetic post-patch failure');
+        },
+      }),
+      /synthetic post-patch failure/,
+    );
+
+    assert.equal(await sha256File(fixture.targetPath), fixture.originalHash);
+    assert.doesNotMatch(await readFile(fixture.targetPath, 'utf8'), /cursor-pool/);
+    await assertRuntimeFileMissing(fixture.runtimeFile);
+    assert.equal(typeof startedPort, 'number');
+    await assert.rejects(fetch(`http://127.0.0.1:${startedPort}/health`), /fetch failed/);
+
+    const rolledBackStatus = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+    assert.match(rolledBackStatus, /patch: missing/);
+    assert.match(rolledBackStatus, /service: stopped/);
+    assert.deepEqual(await getServiceStatus(fixture.runtimeFile), {
+      service: 'stopped',
+      runtime: null,
+    });
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});