@cursorpool-dev/cli 0.5.6

package/src/repair.ts

@@ -0,0 +1,383 @@
+import { readFile } from 'node:fs/promises';
+import { join, normalize } from 'node:path';
+import {
+  patchCursorAgentExec,
+  patchCursorWorkbenchAuthGate,
+} from '@cursor-pool/patcher';
+import { sha256File } from '@cursor-pool/patcher/hash';
+import {
+  containsAnyCursorPoolMarkerText,
+  containsCursorPoolMarker,
+} from '@cursor-pool/patcher/marker';
+import { readRuntimeInfo, type RuntimeInfo } from '@cursor-pool/service';
+import type { CompatibilityManifestEntry } from '@cursor-pool/shared/manifest';
+import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
+import { DEFAULT_COMPAT_ENTRIES, loadCompatEntries, type CompatManifestFetchResponse } from './compat';
+import {
+  confirmRealOperation,
+  formatRealOperationSummary,
+  type ConfirmRealOperationOptions,
+} from './confirm';
+import { findCursor, type FindCursorOptions } from './cursor';
+import { detectEnvironment, type DetectEnvironmentOptions } from './environment';
+import {
+  bundleExtension,
+  getExtensionState,
+  resolveExtensionInstallPath,
+} from './extensionBundle';
+import {
+  getLinkedExtensionState,
+  linkExtensionBundle,
+  linkedExtensionPathForDir,
+} from './extensionLink';
+import {
+  installIdForAppPath,
+  readInstallRecord,
+  writeInstallRecord,
+  type InstallRecord,
+  type InstallRecordOptions,
+} from './installRecord';
+import { startDetachedService, stopRuntimeService } from './serviceProcess';
+import { resolveCursorTarget, type CursorTargetOptions } from './target';
+import { adHocResignApp } from './adHocResign';
+import {
+  formatCursorPatchSetState,
+  patchCursorSet,
+  readCursorPatchSetState,
+} from './patchSet';
+
+export type RepairOptions = FindCursorOptions &
+  CursorTargetOptions &
+  DetectEnvironmentOptions &
+  InstallRecordOptions &
+  Pick<ConfirmRealOperationOptions, 'yes' | 'isInteractive' | 'askConfirmation'> & {
+    runtimeFile?: string;
+    backupDir?: string;
+    extensionInstallPath?: string;
+    cursorExtensionsDir?: string;
+    serviceLogFile?: string;
+    compatEntries?: CompatibilityManifestEntry[];
+    apiBaseUrl?: string;
+    compatManifestUrl?: string;
+    fetchCompatManifest?: (url: string) => Promise<CompatManifestFetchResponse>;
+    stopServiceAfterRepair?: boolean;
+    startDetachedService?: typeof startDetachedService;
+    bundleExtension?: typeof bundleExtension;
+    linkExtensionBundle?: typeof linkExtensionBundle;
+    patchCursorAgentExec?: typeof patchCursorAgentExec;
+    patchCursorWorkbenchAuthGate?: typeof patchCursorWorkbenchAuthGate;
+    adHocResignApp?: typeof adHocResignApp;
+  };
+
+const PACKAGE_VERSION = '0.5.6';
+
+function normalizeAppPath(path: string) {
+  return normalize(path).replace(/\/+$/, '');
+}
+
+function assertRealRepairInstallRecord(
+  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;
+}
+
+function resolveRepairCompatEntry({
+  cursorVersion,
+  cursorCommit,
+  platform,
+  arch,
+  entries,
+}: {
+  cursorVersion: string;
+  cursorCommit: string;
+  platform: string;
+  arch: string;
+  entries?: CompatibilityManifestEntry[];
+}) {
+  const compatEntries = entries ?? DEFAULT_COMPAT_ENTRIES;
+  const entry = compatEntries.find(
+    (candidate) =>
+      candidate.platform === platform &&
+      candidate.arch === arch &&
+      candidate.cursorVersion === cursorVersion &&
+      candidate.cursorCommit === cursorCommit,
+  );
+
+  if (!entry) {
+    throw new Error(
+      `No compatibility entry for Cursor ${cursorVersion} ${cursorCommit} on ${platform}/${arch}`,
+    );
+  }
+
+  return entry;
+}
+
+async function isRuntimeHealthy(runtimeFile: string) {
+  const runtime = await readRuntimeInfo({ runtimeFile });
+  if (!runtime) {
+    return false;
+  }
+
+  try {
+    const response = await fetch(`http://${runtime.host}:${runtime.port}/health`);
+    const health = (await response.json()) as { ok?: unknown; runtimeId?: unknown };
+    return response.ok && health.ok === true && health.runtimeId === runtime.runtimeId;
+  } catch {
+    return false;
+  }
+}
+
+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 stopRuntimeServiceStartedByRepair(
+  runtimeFile: string,
+  startedRuntimeByRepair: RuntimeInfo | undefined,
+) {
+  if (!startedRuntimeByRepair) {
+    return;
+  }
+
+  const currentRuntime = await readRuntimeInfo({ runtimeFile });
+  if (sameRuntime(currentRuntime, startedRuntimeByRepair)) {
+    await stopRuntimeService(runtimeFile);
+  }
+}
+
+async function readPatchState(targetPath: string) {
+  const content = await readFile(targetPath, 'utf8');
+  const markerPresent = containsCursorPoolMarker(content);
+  return {
+    markerPresent,
+    legacyMarkerPresent: !markerPresent && containsAnyCursorPoolMarkerText(content),
+    currentHash: await sha256File(targetPath),
+  };
+}
+
+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;
+}
+
+export async function repair(options: RepairOptions = {}) {
+  const target = resolveCursorTarget(options);
+  if (target.mode !== 'real') {
+    throw new Error('repair is only supported for real Cursor installs in MVP-1');
+  }
+
+  const cursor = await findCursor({ ...options, appPath: target.appPath });
+  const environment = detectEnvironment(options);
+  const compatEntries = await loadCompatEntries({
+    compatEntries: options.compatEntries,
+    apiBaseUrl: options.apiBaseUrl,
+    compatManifestUrl: options.compatManifestUrl,
+    fetchManifest: options.fetchCompatManifest,
+  });
+  const installRecord = assertRealRepairInstallRecord(
+    await readInstallRecord({ installRecordFile: options.installRecordFile }),
+    cursor.appPath,
+  );
+  const compat = resolveRepairCompatEntry({
+    cursorVersion: cursor.version,
+    cursorCommit: cursor.commit,
+    platform: environment.platform,
+    arch: environment.arch,
+    entries: compatEntries,
+  });
+  if (compat.supportStatus === 'blocked' || compat.supportStatus === 'unknown') {
+    throw new Error(`compat: ${compat.supportStatus}`);
+  }
+  const targetPath = join(cursor.appPath, compat.targetRelativePath);
+  const runtimeFile = options.runtimeFile ?? installRecord.runtimeFile ?? DEFAULT_RUNTIME_FILE;
+  const backupDir = options.backupDir ?? installRecord.backupDir;
+  const extensionInstallPath =
+    options.extensionInstallPath ?? installRecord.extensionInstallPath;
+  const resolvedExtensionInstallPath = resolveExtensionInstallPath(extensionInstallPath);
+  const extensionLinkedPath = options.cursorExtensionsDir
+    ? linkedExtensionPathForDir(options.cursorExtensionsDir)
+    : installRecord.extensionLinkedPath;
+
+  const summary = {
+    operation: 'repair' as const,
+    appPath: cursor.appPath,
+    targetPath,
+    backupPath: backupDir,
+    runtimeFile,
+    extensionInstallPath: resolvedExtensionInstallPath,
+    extensionLinkedPath,
+  };
+  formatRealOperationSummary(summary);
+  await confirmRealOperation({
+    summary,
+    yes: options.yes,
+    isInteractive: options.isInteractive,
+    askConfirmation: options.askConfirmation,
+  });
+
+  const patchState = await readPatchState(targetPath);
+  if (!patchState.markerPresent) {
+    const matchesInstallOriginal =
+      installRecord.originalSha256 && patchState.currentHash === installRecord.originalSha256;
+    if (
+      !patchState.legacyMarkerPresent &&
+      patchState.currentHash !== compat.expectedSha256 &&
+      !matchesInstallOriginal
+    ) {
+      throw new Error('patch: changed');
+    }
+  }
+
+  const output = [
+    `Cursor ${cursor.version} (${cursor.commit})`,
+    'mode: real',
+    `app: ${cursor.appPath}`,
+    `compat: ${compat.supportStatus}`,
+  ];
+
+  let serviceStatus = 'running';
+  let startedRuntimeByRepair: RuntimeInfo | undefined;
+  if (!(await isRuntimeHealthy(runtimeFile))) {
+    const startService = options.startDetachedService ?? startDetachedService;
+    startedRuntimeByRepair = await startService({
+      runtimeFile,
+      logFile: options.serviceLogFile ?? '~/.cursor-pool/logs/service.log',
+    });
+    serviceStatus = 'repaired';
+  }
+  output.push(`service: ${serviceStatus}`);
+
+  let extensionState = await getExtensionState(extensionInstallPath);
+  let extensionStatus = 'bundled';
+  if (extensionState === 'missing') {
+    const repairBundle = options.bundleExtension ?? bundleExtension;
+    const bundled = await repairBundle({ installPath: extensionInstallPath });
+    if (bundled.state === 'missing') {
+      throw new Error('Extension bundle is missing packages/extension/dist/extension.js');
+    }
+    extensionState = bundled.state;
+    extensionStatus = 'repaired';
+  }
+  output.push(`extension: ${extensionStatus}`);
+
+  if (options.cursorExtensionsDir) {
+    const linkedPath = linkedExtensionPathForDir(options.cursorExtensionsDir);
+    const linkedState = await getLinkedExtensionState(linkedPath);
+    if (linkedState === 'missing') {
+      const repairLink = options.linkExtensionBundle ?? linkExtensionBundle;
+      const linked = await repairLink({
+        sourceBundlePath: resolvedExtensionInstallPath,
+        cursorExtensionsDir: options.cursorExtensionsDir,
+      });
+      if (linked.state === 'missing') {
+        throw new Error('Linked extension source bundle is missing');
+      }
+      extensionState = linked.state;
+      output.push('linked-extension: repaired');
+    } else {
+      extensionState = linkedState;
+      output.push('linked-extension: linked');
+    }
+  } else if (extensionLinkedPath) {
+    const linkedState = await getLinkedExtensionState(extensionLinkedPath);
+    if (linkedState === 'linked') {
+      extensionState = linkedState;
+      output.push('linked-extension: linked');
+    }
+  }
+
+  const patchSetState = await readCursorPatchSetState(cursor.appPath, {
+    agentExecTargetRelativePath: compat.targetRelativePath,
+  });
+
+  if (patchSetState.allApplied) {
+    output.push('patch: applied');
+    output.push('resign: skipped');
+  } else {
+    const repairedPatchSet = await patchCursorSet(cursor.appPath, {
+      backupDir,
+      agentExecTargetRelativePath: compat.targetRelativePath,
+      patchCursorAgentExec: options.patchCursorAgentExec,
+      patchCursorWorkbenchAuthGate: options.patchCursorWorkbenchAuthGate,
+    });
+    output.push(
+      `patch: ${repairedPatchSet.before.appliedCount === 0 ? 'repaired' : `repaired ${formatCursorPatchSetState(repairedPatchSet.after)}`}`,
+    );
+    const resignState = await maybeAdHocResign({
+      appPath: cursor.appPath,
+      platform: environment.platform,
+      requiresAdHocResign: compat.requiresAdHocResign,
+      resign: options.adHocResignApp ?? adHocResignApp,
+    });
+    output.push(`resign: ${resignState}`);
+  }
+
+  const now = new Date().toISOString();
+  await writeInstallRecord(
+    {
+      ...installRecord,
+      installId: installIdForAppPath(cursor.appPath),
+      mode: 'real',
+      appPath: cursor.appPath,
+      cursorVersion: cursor.version,
+      cursorCommit: cursor.commit,
+      targetRelativePath: compat.targetRelativePath,
+      compatSupportStatus: compat.supportStatus,
+      runtimeFile,
+      backupDir,
+      extensionInstallPath: resolvedExtensionInstallPath,
+      extensionLinkedPath,
+      extensionState,
+      cliVersion: installRecord.cliVersion ?? PACKAGE_VERSION,
+      extensionVersion: installRecord.extensionVersion ?? PACKAGE_VERSION,
+      serviceVersion: installRecord.serviceVersion ?? PACKAGE_VERSION,
+      lastOperation: 'repair',
+      lastOperationStatus: 'ok',
+      updatedAt: now,
+    },
+    { installRecordFile: options.installRecordFile },
+  );
+
+  if (options.stopServiceAfterRepair) {
+    await stopRuntimeServiceStartedByRepair(runtimeFile, startedRuntimeByRepair);
+  }
+
+  output.push('install-record: recorded');
+  output.push('repair: ok');
+  return output.join('\n');
+}

package/src/restore.ts

@@ -0,0 +1,153 @@
+import { normalize } from 'node:path';
+import { restoreCursorAgentExec, resolveCursorAgentExecPath } from '@cursor-pool/patcher';
+import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
+import {
+  confirmRealOperation,
+  formatRealOperationSummary,
+  type ConfirmRealOperationOptions,
+} from './confirm';
+import { findCursor, type FindCursorOptions } from './cursor';
+import {
+  installIdForAppPath,
+  readInstallRecord,
+  type InstallRecord,
+  type InstallRecordOptions,
+} from './installRecord';
+import { stopRuntimeService } from './serviceProcess';
+import { resolveCursorTarget, type CursorTargetOptions } from './target';
+import { assertDisposableCursorAppPath, readTrialRecord, type TrialRecordOptions } from './trial';
+
+export type RestoreOptions = FindCursorOptions &
+  CursorTargetOptions &
+  TrialRecordOptions &
+  InstallRecordOptions & {
+    backupDir?: string;
+    runtimeFile?: string;
+  } & Pick<ConfirmRealOperationOptions, 'yes' | 'isInteractive' | 'askConfirmation'>;
+
+async function stopRuntimeServiceIfRecorded(runtimeFile: string | undefined) {
+  if (!runtimeFile) {
+    return;
+  }
+
+  await stopRuntimeService(runtimeFile);
+}
+
+function realRuntimeFile(options: RestoreOptions, recordRuntimeFile: string | undefined) {
+  return recordRuntimeFile ?? options.runtimeFile ?? DEFAULT_RUNTIME_FILE;
+}
+
+function normalizeAppPath(path: string) {
+  return normalize(path).replace(/\/+$/, '');
+}
+
+function assertRealRestoreInstallRecord(
+  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;
+}
+
+function formatRestoreConfirmation({
+  cursorAppPath,
+  targetRelativePath,
+  backupDir,
+  runtimeFile,
+}: {
+  cursorAppPath: string;
+  targetRelativePath?: string;
+  backupDir: string | undefined;
+  runtimeFile: string | undefined;
+}) {
+  const summary = {
+    operation: 'restore' as const,
+    appPath: cursorAppPath,
+    targetPath: resolveCursorAgentExecPath(cursorAppPath, targetRelativePath),
+    backupPath: backupDir,
+    runtimeFile,
+  };
+  formatRealOperationSummary(summary);
+  return summary;
+}
+
+export async function restore(options: RestoreOptions = {}) {
+  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'
+      ? assertRealRestoreInstallRecord(installRecord, cursor.appPath)
+      : null;
+
+  const backupDir =
+    target.mode === 'real'
+      ? realInstallRecord?.backupDir ?? options.backupDir
+      : options.backupDir ?? trialRecord?.backupDir;
+  const runtimeFile =
+    target.mode === 'real'
+      ? realRuntimeFile(options, realInstallRecord?.runtimeFile)
+      : options.runtimeFile ?? trialRecord?.runtimeFile;
+  const targetRelativePath =
+    target.mode === 'real'
+      ? realInstallRecord?.targetRelativePath
+      : trialRecord?.targetRelativePath;
+
+  if (target.requiresConfirmation) {
+    const summary = formatRestoreConfirmation({
+      cursorAppPath: cursor.appPath,
+      targetRelativePath,
+      backupDir,
+      runtimeFile,
+    });
+    await confirmRealOperation({
+      summary,
+      yes: options.yes,
+      isInteractive: options.isInteractive,
+      askConfirmation: options.askConfirmation,
+    });
+  }
+
+  const result = await restoreCursorAgentExec(cursor.appPath, {
+    backupDir,
+    targetRelativePath,
+  });
+  if (target.mode === 'real') {
+    await stopRuntimeServiceIfRecorded(runtimeFile);
+  }
+
+  return [
+    `Cursor ${cursor.version} (${cursor.commit})`,
+    `mode: ${target.mode}`,
+    `app: ${cursor.appPath}`,
+    'restore: ok',
+    `patch: ${result.markerPresent ? 'applied' : 'missing'}`,
+    target.mode === 'real'
+      ? `install-record: ${realInstallRecord ? 'recorded' : 'missing'}`
+      : `trial: ${trialRecord ? 'recorded' : 'missing'}`,
+  ].join('\n');
+}

package/src/serviceCommands.ts

@@ -0,0 +1,79 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
+import { readClientConfig } from '@cursor-pool/shared/clientConfig';
+import { readRuntimeInfo, resolveRuntimeFile } from '@cursor-pool/service';
+import {
+  startDetachedService,
+  stopRuntimeService,
+  waitForRuntimeHealth,
+} from './serviceProcess';
+
+export type LocalServiceCommandOptions = {
+  runtimeFile?: string;
+  serviceLogFile?: string;
+  apiBaseUrl?: string;
+  configFile?: string;
+  startDetachedService?: typeof startDetachedService;
+  stopRuntimeService?: typeof stopRuntimeService;
+};
+
+const DEFAULT_SERVICE_LOG_FILE = '~/.cursor-pool/logs/service.log';
+
+function resolveTildePath(path: string) {
+  if (path.startsWith('~/')) {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+
+function formatRuntimeAddress(runtime: { host: string; port: number }) {
+  return `${runtime.host}:${runtime.port}`;
+}
+
+export async function startLocalServiceCommand(options: LocalServiceCommandOptions = {}) {
+  const runtimeFile = options.runtimeFile ?? DEFAULT_RUNTIME_FILE;
+  const logFile = options.serviceLogFile ?? DEFAULT_SERVICE_LOG_FILE;
+  const resolvedRuntimeFile = resolveRuntimeFile(runtimeFile);
+  const resolvedLogFile = resolveTildePath(logFile);
+  const existingRuntime = await readRuntimeInfo({ runtimeFile });
+  const clientConfig = await readClientConfig({ configFile: options.configFile });
+
+  if (existingRuntime && await waitForRuntimeHealth(runtimeFile, 250)) {
+    const runtime = await readRuntimeInfo({ runtimeFile });
+    if (!runtime) {
+      throw new Error('Runtime became unavailable after health check');
+    }
+    return [
+      `service: already-running ${formatRuntimeAddress(runtime)}`,
+      `runtime: ${resolvedRuntimeFile}`,
+      `log: ${resolvedLogFile}`,
+    ].join('\n');
+  }
+
+  const startDetached = options.startDetachedService ?? startDetachedService;
+  const runtime = await startDetached({
+    runtimeFile,
+    logFile,
+    configFile: options.configFile,
+    apiBaseUrl: options.apiBaseUrl ?? clientConfig.apiBaseUrl,
+  });
+
+  return [
+    `service: started ${formatRuntimeAddress(runtime)}`,
+    `runtime: ${resolvedRuntimeFile}`,
+    `log: ${resolvedLogFile}`,
+  ].join('\n');
+}
+
+export async function stopLocalServiceCommand(options: LocalServiceCommandOptions = {}) {
+  const runtimeFile = options.runtimeFile ?? DEFAULT_RUNTIME_FILE;
+  const resolvedRuntimeFile = resolveRuntimeFile(runtimeFile);
+  const stopRuntime = options.stopRuntimeService ?? stopRuntimeService;
+  const stopped = await stopRuntime(runtimeFile);
+
+  return [
+    `service: ${stopped ? 'stopped' : 'not-running'}`,
+    `runtime: ${resolvedRuntimeFile}`,
+  ].join('\n');
+}