@cursorpool-dev/cli 0.5.6

package/src/install.ts

@@ -0,0 +1,614 @@
+import { cp, mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import {
+  patchCursorAgentExec,
+  patchCursorWorkbenchAuthGate,
+  restoreCursorAgentExec,
+  restoreCursorAlwaysLocal,
+  restoreCursorWorkbenchAuthGate,
+} from '@cursor-pool/patcher';
+import { sha256File } from '@cursor-pool/patcher/hash';
+import { startServer } from '@cursor-pool/service';
+import {
+  readRuntimeInfo,
+  resolveRuntimeFile,
+  writeRuntimeInfo,
+  type RuntimeInfo,
+} from '@cursor-pool/service';
+import type { CompatibilityManifestEntry } from '@cursor-pool/shared/manifest';
+import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
+import { writeClientConfig } from '@cursor-pool/shared/clientConfig';
+import { containsCursorPoolMarker } from '@cursor-pool/patcher/marker';
+import { detectEnvironment, type DetectEnvironmentOptions } from './environment';
+import { findCursor, type FindCursorOptions } from './cursor';
+import { loadCompatEntries, resolveCompatEntry, type CompatManifestFetchResponse } from './compat';
+import {
+  bundleExtension,
+  getExtensionState,
+  removeExtensionBundle,
+  resolveExtensionInstallPath,
+} from './extensionBundle';
+import {
+  getLinkedExtensionState,
+  linkExtensionBundle,
+  linkedExtensionPathForDir,
+  refreshCursorExtensionsIndex,
+  removeLinkedExtensionBundle,
+  restoreLinkedExtensionSnapshot,
+  snapshotLinkedExtensionBundle,
+  type LinkedExtensionSnapshot,
+} from './extensionLink';
+import { startDetachedService, stopRuntimeService } from './serviceProcess';
+import { installUserAutostart } from './autostart';
+import {
+  assertDisposableCursorAppPath,
+  deleteTrialRecord,
+  readTrialRecord,
+  trialIdForAppPath,
+  writeTrialRecord,
+  type TrialRecord,
+  type TrialRecordOptions,
+} from './trial';
+import { resolveCursorTarget, type CursorTargetOptions } from './target';
+import {
+  confirmRealOperation,
+  formatRealOperationSummary,
+  type ConfirmRealOperationOptions,
+} from './confirm';
+import {
+  deleteInstallRecord,
+  installIdForAppPath,
+  readInstallRecord,
+  writeInstallRecord,
+  type InstallRecord,
+  type InstallRecordOptions,
+} from './installRecord';
+import { adHocResignApp } from './adHocResign';
+import {
+  formatCursorPatchSetState,
+  patchCursorSet,
+  readCursorPatchSetState,
+  restoreCursorSet,
+} from './patchSet';
+
+export type InstallOptions = FindCursorOptions &
+  DetectEnvironmentOptions &
+  CursorTargetOptions &
+  TrialRecordOptions &
+  InstallRecordOptions &
+  Pick<ConfirmRealOperationOptions, 'yes' | 'isInteractive' | 'askConfirmation'> & {
+    runtimeFile?: string;
+    backupDir?: string;
+    extensionInstallPath?: string;
+    cursorExtensionsDir?: string;
+    serviceLogFile?: string;
+    clientConfigFile?: string;
+    startDetachedService?: typeof startDetachedService;
+    installUserAutostart?: typeof installUserAutostart;
+    bundleExtension?: typeof bundleExtension;
+    linkExtensionBundle?: typeof linkExtensionBundle;
+    compatEntries?: CompatibilityManifestEntry[];
+    apiBaseUrl?: string;
+    compatManifestUrl?: string;
+    fetchCompatManifest?: (url: string) => Promise<CompatManifestFetchResponse>;
+    stopServiceAfterInstall?: boolean;
+    patchCursorAgentExec?: typeof patchCursorAgentExec;
+    patchCursorWorkbenchAuthGate?: typeof patchCursorWorkbenchAuthGate;
+    restoreCursorAgentExec?: typeof restoreCursorAgentExec;
+    restoreCursorAlwaysLocal?: typeof restoreCursorAlwaysLocal;
+    restoreCursorWorkbenchAuthGate?: typeof restoreCursorWorkbenchAuthGate;
+    adHocResignApp?: typeof adHocResignApp;
+    fetchHealth?: (url: string) => Promise<{ ok: boolean; healthy: boolean }>;
+  };
+
+const REAL_CURSOR_EXTENSIONS_DIR = '~/.cursor/extensions';
+const PACKAGE_VERSION = '0.5.6';
+
+async function maybeAdHocResign({
+  appPath,
+  platform,
+  requiresAdHocResign,
+  resign,
+}: {
+  appPath: string;
+  platform: NodeJS.Platform;
+  requiresAdHocResign: boolean;
+  resign: typeof adHocResignApp;
+}) {
+  if (platform !== 'darwin' || !requiresAdHocResign) {
+    return 'skipped' as const;
+  }
+
+  await resign(appPath);
+  return 'ad-hoc' as const;
+}
+
+async function assertExpectedHash(targetPath: string, expectedSha256: string) {
+  const currentHash = await sha256File(targetPath);
+  if (currentHash !== expectedSha256) {
+    const content = await readFile(targetPath, 'utf8');
+    if (containsCursorPoolMarker(content)) {
+      return;
+    }
+    throw new Error(`Patch target hash mismatch: expected ${expectedSha256}, got ${currentHash}`);
+  }
+}
+
+async function startInstallService(options: InstallOptions) {
+  if (options.stopServiceAfterInstall) {
+    const service = await startServer({ runtimeFile: options.runtimeFile });
+    return {
+      host: service.host,
+      port: service.port,
+      runtimeId: service.runtimeId,
+      stop: service.stop,
+    };
+  }
+
+  const startDetached = options.startDetachedService ?? startDetachedService;
+  const runtime = await startDetached({
+    runtimeFile: options.runtimeFile ?? DEFAULT_RUNTIME_FILE,
+    logFile: options.serviceLogFile ?? '~/.cursor-pool/logs/service.log',
+    configFile: options.clientConfigFile,
+    apiBaseUrl: options.apiBaseUrl,
+  });
+  return {
+    ...runtime,
+    stop: () => stopRuntimeService(options.runtimeFile ?? DEFAULT_RUNTIME_FILE),
+  };
+}
+
+async function writeInstallClientConfig(options: InstallOptions) {
+  if (!options.apiBaseUrl) {
+    return;
+  }
+  await writeClientConfig(
+    { apiBaseUrl: options.apiBaseUrl },
+    { configFile: options.clientConfigFile },
+  );
+}
+
+async function installAutostart(options: InstallOptions, targetMode: 'real' | 'disposable') {
+  if (options.stopServiceAfterInstall && !options.installUserAutostart) {
+    return { state: 'skipped' as const };
+  }
+  if (targetMode !== 'real' && !options.installUserAutostart) {
+    return { state: 'skipped' as const };
+  }
+  const installAutostartFn = options.installUserAutostart ?? installUserAutostart;
+  return installAutostartFn({
+    runtimeFile: options.runtimeFile ?? DEFAULT_RUNTIME_FILE,
+    serviceLogFile: options.serviceLogFile,
+    configFile: options.clientConfigFile,
+  });
+}
+
+function sameRuntime(a: RuntimeInfo | null | undefined, b: RuntimeInfo | null | undefined) {
+  return Boolean(
+    a &&
+      b &&
+      a.host === b.host &&
+      a.port === b.port &&
+      a.runtimeId === b.runtimeId,
+  );
+}
+
+async function restoreRuntimeState(
+  runtimeFile: string | undefined,
+  existingRuntime: RuntimeInfo | null,
+  service: Awaited<ReturnType<typeof startInstallService>> | undefined,
+) {
+  const resolvedRuntimeFile = resolveRuntimeFile(runtimeFile);
+  const currentRuntime = await readRuntimeInfo({ runtimeFile: resolvedRuntimeFile });
+  if (service && !sameRuntime(currentRuntime, service)) {
+    return;
+  }
+
+  if (existingRuntime) {
+    await writeRuntimeInfo(existingRuntime, { runtimeFile: resolvedRuntimeFile });
+    return;
+  }
+
+  await rm(resolvedRuntimeFile, { force: true });
+}
+
+async function snapshotExtensionBundle(installPath: string | undefined) {
+  if ((await getExtensionState(installPath)) === 'missing') {
+    return undefined;
+  }
+
+  const resolvedInstallPath = resolveExtensionInstallPath(installPath);
+  const snapshotRoot = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-snapshot-'));
+  const snapshotPath = join(snapshotRoot, 'cursor-pool-status');
+  await cp(resolvedInstallPath, snapshotPath, { recursive: true });
+  return { root: snapshotRoot, path: snapshotPath };
+}
+
+async function restoreExtensionBundle(
+  installPath: string,
+  snapshot: Awaited<ReturnType<typeof snapshotExtensionBundle>>,
+) {
+  if (!snapshot) {
+    return;
+  }
+
+  await rm(installPath, { recursive: true, force: true });
+  await mkdir(dirname(installPath), { recursive: true });
+  await cp(snapshot.path, installPath, { recursive: true });
+}
+
+function assertLinkedPathInsideCursorExtensionsDir(linkedPath: string, cursorExtensionsDir: string) {
+  const expectedLinkedPath = resolve(linkedExtensionPathForDir(cursorExtensionsDir));
+  const resolvedLinkedPath = resolve(linkedPath);
+  if (resolvedLinkedPath !== expectedLinkedPath) {
+    throw new Error(`Unsafe linked extension path: ${linkedPath}`);
+  }
+}
+
+async function removeInstallLinkedExtensionBundle(
+  linkedPath: string,
+  cursorExtensionsDir: string | undefined,
+) {
+  if (!cursorExtensionsDir) {
+    await removeLinkedExtensionBundle(linkedPath);
+    return;
+  }
+
+  assertLinkedPathInsideCursorExtensionsDir(linkedPath, cursorExtensionsDir);
+  await rm(linkedPath, { recursive: true, force: true });
+}
+
+async function restoreInstallLinkedExtensionSnapshot(
+  linkedPath: string,
+  snapshot: LinkedExtensionSnapshot | null | undefined,
+  cursorExtensionsDir: string | undefined,
+) {
+  if (!snapshot) {
+    return;
+  }
+
+  if (!cursorExtensionsDir) {
+    await restoreLinkedExtensionSnapshot(linkedPath, snapshot);
+    return;
+  }
+
+  assertLinkedPathInsideCursorExtensionsDir(linkedPath, cursorExtensionsDir);
+  await rm(linkedPath, { recursive: true, force: true });
+  await mkdir(dirname(linkedPath), { recursive: true });
+  await cp(snapshot.root, linkedPath, { recursive: true });
+}
+
+async function linkInstallExtensionBundle({
+  sourceBundlePath,
+  cursorExtensionsDir,
+}: {
+  sourceBundlePath: string;
+  cursorExtensionsDir: string;
+}): ReturnType<typeof linkExtensionBundle> {
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+  if ((await getLinkedExtensionState(sourceBundlePath)) === 'missing') {
+    return { state: 'missing', linkedPath };
+  }
+
+  await removeInstallLinkedExtensionBundle(linkedPath, cursorExtensionsDir);
+  await mkdir(dirname(linkedPath), { recursive: true });
+  await cp(sourceBundlePath, linkedPath, { recursive: true });
+  await refreshCursorExtensionsIndex(cursorExtensionsDir, linkedPath);
+  return { state: 'linked', linkedPath };
+}
+
+export async function install(options: InstallOptions = {}) {
+  const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
+  const appPath =
+    target.mode === 'disposable'
+      ? assertDisposableCursorAppPath(target.appPath, { platform: environment.platform })
+      : target.appPath;
+  const cursorExtensionsDir =
+    options.cursorExtensionsDir ?? (target.mode === 'real' ? REAL_CURSOR_EXTENSIONS_DIR : undefined);
+  const cursor = await findCursor({ ...options, appPath });
+  const compatEntries = await loadCompatEntries({
+    compatEntries: options.compatEntries,
+    apiBaseUrl: options.apiBaseUrl,
+    compatManifestUrl: options.compatManifestUrl,
+    fetchManifest: options.fetchCompatManifest,
+  });
+  const compat = resolveCompatEntry(cursor, environment, { entries: compatEntries });
+  const targetPath = join(cursor.appPath, compat.targetRelativePath);
+  const originalSha256 = await sha256File(targetPath);
+  await assertExpectedHash(targetPath, compat.expectedSha256);
+  const patchSetBeforeInstall = await readCursorPatchSetState(cursor.appPath, {
+    agentExecTargetRelativePath: compat.targetRelativePath,
+    platform: environment.platform,
+  });
+  const wasPatchedBeforeInstall = patchSetBeforeInstall.allApplied;
+  const existingTrialRecord = await readTrialRecord(cursor.appPath, {
+    trialRecordDir: options.trialRecordDir,
+  });
+  const existingInstallRecord = await readInstallRecord({
+    installRecordFile: options.installRecordFile,
+  });
+  const existingRuntime = await readRuntimeInfo({ runtimeFile: options.runtimeFile });
+  const existingExtensionState = await getExtensionState(options.extensionInstallPath);
+
+  let service: Awaited<ReturnType<typeof startInstallService>> | undefined;
+  let extension: Awaited<ReturnType<typeof bundleExtension>> | undefined;
+  let extensionInstallPath: string | undefined;
+  let extensionLinkedPath: string | undefined;
+  let previousTrialRecord: TrialRecord | null = existingTrialRecord;
+  let extensionSnapshot: Awaited<ReturnType<typeof snapshotExtensionBundle>> | undefined;
+  let linkedExtensionSnapshot: LinkedExtensionSnapshot | null | undefined;
+  let extensionCreatedByInstall = false;
+  let linkedExtensionCreatedByInstall = false;
+  let patchApplied = false;
+  let wroteTrialRecord = false;
+  let previousInstallRecord: InstallRecord | null = existingInstallRecord;
+  let wroteInstallRecord = false;
+  let resignState: 'ad-hoc' | 'skipped' = 'skipped';
+  let patchState = 'skipped';
+  let autostartState = 'skipped';
+
+  try {
+    if (target.requiresConfirmation) {
+      const summary = {
+        operation: 'install' as const,
+        appPath: cursor.appPath,
+        targetPath,
+        backupPath: options.backupDir ?? '~/.cursor-pool/backups',
+        runtimeFile: options.runtimeFile ?? DEFAULT_RUNTIME_FILE,
+        extensionInstallPath: resolveExtensionInstallPath(options.extensionInstallPath),
+        extensionLinkedPath: cursorExtensionsDir
+          ? linkedExtensionPathForDir(cursorExtensionsDir)
+          : undefined,
+      };
+      formatRealOperationSummary(summary);
+      await confirmRealOperation({
+        summary,
+        yes: options.yes,
+        isInteractive: options.isInteractive,
+        askConfirmation: options.askConfirmation,
+      });
+    }
+    previousTrialRecord = await readTrialRecord(cursor.appPath, {
+      trialRecordDir: options.trialRecordDir,
+    });
+    previousInstallRecord = await readInstallRecord({
+      installRecordFile: options.installRecordFile,
+    });
+    extensionInstallPath = resolveExtensionInstallPath(options.extensionInstallPath);
+    extensionSnapshot = await snapshotExtensionBundle(options.extensionInstallPath);
+    const bundle = options.bundleExtension ?? bundleExtension;
+    extension = await bundle({
+      installPath: options.extensionInstallPath,
+    });
+    if (extension.state === 'missing') {
+      throw new Error('Extension bundle is missing packages/extension/dist/extension.js');
+    }
+    extensionCreatedByInstall = existingExtensionState === 'missing';
+    if (cursorExtensionsDir) {
+      extensionLinkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+      linkedExtensionSnapshot = await snapshotLinkedExtensionBundle(extensionLinkedPath);
+      const existingLinkedState = await getLinkedExtensionState(extensionLinkedPath);
+      linkedExtensionCreatedByInstall = existingLinkedState === 'missing';
+      const linkBundle = options.linkExtensionBundle ?? linkInstallExtensionBundle;
+      const linked = await linkBundle({
+        sourceBundlePath: extension.installPath,
+        cursorExtensionsDir,
+      });
+      if (linked.state === 'missing') {
+        throw new Error('Linked extension source bundle is missing');
+      }
+      extensionLinkedPath = linked.linkedPath;
+      extension.state = linked.state;
+    }
+
+    await writeInstallClientConfig(options);
+    service = await startInstallService(options);
+    autostartState = (await installAutostart(options, target.mode)).state;
+    const patchSet = await patchCursorSet(cursor.appPath, {
+      backupDir: options.backupDir,
+      platform: environment.platform,
+      agentExecTargetRelativePath: compat.targetRelativePath,
+      patchCursorAgentExec: options.patchCursorAgentExec,
+      patchCursorWorkbenchAuthGate: options.patchCursorWorkbenchAuthGate,
+    });
+    patchApplied = !patchSet.before.allApplied;
+    patchState = patchSet.before.allApplied ? 'already applied' : formatCursorPatchSetState(patchSet.after);
+    resignState = await maybeAdHocResign({
+      appPath: cursor.appPath,
+      platform: environment.platform,
+      requiresAdHocResign: compat.requiresAdHocResign,
+      resign: options.adHocResignApp ?? adHocResignApp,
+    });
+
+    const health = await (options.fetchHealth ?? fetchHealth)(
+      `http://${service.host}:${service.port}/health`,
+    );
+    if (!health.ok || !health.healthy) {
+      throw new Error('Service health check failed');
+    }
+
+    const now = new Date().toISOString();
+    const installState = {
+      appPath: cursor.appPath,
+      cursorVersion: cursor.version,
+      cursorCommit: cursor.commit,
+      targetRelativePath: compat.targetRelativePath,
+      originalSha256,
+      compatSupportStatus: compat.supportStatus,
+      runtimeFile: options.runtimeFile ?? DEFAULT_RUNTIME_FILE,
+      backupDir: options.backupDir ?? '~/.cursor-pool/backups',
+      extensionInstallPath: extension.installPath,
+      extensionLinkedPath,
+      extensionState: extension.state,
+    };
+    if (target.mode === 'real') {
+      await writeInstallRecord(
+        {
+          installId: installIdForAppPath(cursor.appPath),
+          mode: 'real',
+          ...installState,
+          cliVersion: PACKAGE_VERSION,
+          extensionVersion: PACKAGE_VERSION,
+          serviceVersion: PACKAGE_VERSION,
+          lastOperation: 'install',
+          lastOperationStatus: 'ok',
+          createdAt: previousInstallRecord?.createdAt ?? now,
+          updatedAt: now,
+        },
+        { installRecordFile: options.installRecordFile },
+      );
+      wroteInstallRecord = true;
+    } else {
+      await writeTrialRecord(
+        {
+          trialId: trialIdForAppPath(cursor.appPath),
+          ...installState,
+          createdAt: now,
+          updatedAt: now,
+        },
+        { trialRecordDir: options.trialRecordDir },
+      );
+      wroteTrialRecord = true;
+    }
+
+    return [
+      `Cursor ${cursor.version} (${cursor.commit})`,
+      `mode: ${target.mode}`,
+      `app: ${cursor.appPath}`,
+      `compat: ${compat.supportStatus}`,
+      `extension: ${extension.state}`,
+      `service: running ${service.host}:${service.port}`,
+      `autostart: ${autostartState}`,
+      `patch: ${patchState}`,
+      `resign: ${resignState}`,
+      'health: ok',
+      target.mode === 'real' ? 'install-record: recorded' : 'trial: recorded',
+    ].join('\n');
+  } catch (error) {
+    const rollbackErrors: unknown[] = [];
+    let shouldRestorePatch = patchApplied;
+    try {
+      shouldRestorePatch =
+        shouldRestorePatch ||
+        (!wasPatchedBeforeInstall &&
+          (await readCursorPatchSetState(cursor.appPath, {
+            agentExecTargetRelativePath: compat.targetRelativePath,
+            platform: environment.platform,
+          })).appliedCount > 0);
+    } catch (rollbackError) {
+      rollbackErrors.push(rollbackError);
+    }
+    if (shouldRestorePatch) {
+      try {
+        await restoreCursorSet(cursor.appPath, {
+          backupDir: options.backupDir,
+          platform: environment.platform,
+          restoreCursorAgentExec: options.restoreCursorAgentExec,
+          restoreCursorAlwaysLocal: options.restoreCursorAlwaysLocal,
+          restoreCursorWorkbenchAuthGate: options.restoreCursorWorkbenchAuthGate,
+        });
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    }
+    try {
+      await service?.stop();
+    } catch (rollbackError) {
+      rollbackErrors.push(rollbackError);
+    }
+    try {
+      await restoreRuntimeState(options.runtimeFile, existingRuntime, service);
+    } catch (rollbackError) {
+      rollbackErrors.push(rollbackError);
+    }
+    if (extensionLinkedPath && linkedExtensionSnapshot) {
+      try {
+        await restoreInstallLinkedExtensionSnapshot(
+          extensionLinkedPath,
+          linkedExtensionSnapshot,
+          cursorExtensionsDir,
+        );
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    } else if (linkedExtensionCreatedByInstall && extensionLinkedPath) {
+      try {
+        await removeInstallLinkedExtensionBundle(extensionLinkedPath, cursorExtensionsDir);
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    }
+    if (extensionCreatedByInstall && extension) {
+      try {
+        await removeExtensionBundle(extension.installPath);
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    } else if (extensionSnapshot) {
+      try {
+        const restoreInstallPath =
+          extension?.installPath ??
+          extensionInstallPath ??
+          resolveExtensionInstallPath(options.extensionInstallPath);
+        await restoreExtensionBundle(restoreInstallPath, extensionSnapshot);
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    }
+    if (!previousTrialRecord && (extension || wroteTrialRecord)) {
+      try {
+        await deleteTrialRecord(cursor.appPath, { trialRecordDir: options.trialRecordDir });
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    } else if (previousTrialRecord && wroteTrialRecord) {
+      try {
+        await writeTrialRecord(previousTrialRecord, { trialRecordDir: options.trialRecordDir });
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    }
+    if (!previousInstallRecord && wroteInstallRecord) {
+      try {
+        await deleteInstallRecord({ installRecordFile: options.installRecordFile });
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    } else if (previousInstallRecord && wroteInstallRecord) {
+      try {
+        await writeInstallRecord(previousInstallRecord, {
+          installRecordFile: options.installRecordFile,
+        });
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    }
+    if (rollbackErrors.length > 0 && error instanceof Error) {
+      throw new Error(error.message, {
+        cause: new AggregateError(rollbackErrors, 'Install rollback cleanup failed'),
+      });
+    }
+    throw error;
+  } finally {
+    if (extensionSnapshot) {
+      await rm(extensionSnapshot.root, { recursive: true, force: true });
+    }
+    if (linkedExtensionSnapshot) {
+      await rm(linkedExtensionSnapshot.root, { recursive: true, force: true });
+    }
+    if (options.stopServiceAfterInstall) {
+      await service?.stop();
+    }
+  }
+}
+
+async function fetchHealth(url: string) {
+  const response = await fetch(url);
+  const health = (await response.json()) as { ok?: unknown };
+  return {
+    ok: response.ok,
+    healthy: health.ok === true,
+  };
+}