@cursorpool-dev/cli 0.5.6

package/test/repair.test.ts

@@ -0,0 +1,575 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, normalize } from 'node:path';
+import test from 'node:test';
+import { patchCursorAgentExec } from '../../patcher/src/patchCursorAgentExec';
+import { patchCursorAlwaysLocal } from '../../patcher/src/patchCursorAlwaysLocal';
+import { patchCursorWorkbenchAuthGate } from '../../patcher/src/patchCursorWorkbenchAuthGate';
+import {
+  CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR,
+  CURSOR_POOL_PATCH_MARKER,
+} from '../../patcher/src/marker';
+import { startServer } from '../../service/src/server';
+import { writeRuntimeInfo } from '../../service/src/runtime';
+import type { CompatibilityManifestEntry } from '../../shared/src/manifest';
+import { bundleExtension, getExtensionState } from '../src/extensionBundle';
+import { getLinkedExtensionState, linkedExtensionPathForDir } from '../src/extensionLink';
+import {
+  installIdForAppPath,
+  readInstallRecord,
+  writeInstallRecord,
+  type InstallRecord,
+} from '../src/installRecord';
+import { repair } from '../src/repair';
+
+const targetRelativePath =
+  'Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js';
+const alwaysLocalRelativePath =
+  'Contents/Resources/app/extensions/cursor-always-local/dist/main.js';
+const workbenchRelativePath = 'Contents/Resources/app/out/vs/workbench/workbench.desktop.main.js';
+const composerAuthGateAnchor =
+  'get when(){return p()&&!fzC},get fallback(){return he(DGC,{})}';
+const composerSubmitAuthGateAnchor =
+  'if(!p()){e.cursorAuthenticationService.login(),e.commandService.executeCommand(wV,"general");return}';
+const agentLoopRunAnchor = 'await this.agentClientService.run(te,H,$e,Ne,Ce,T,ze,me,we,[],ct)';
+const buildFlagsLocalModeAnchor = 'localMode:!1';
+const localProviderConfigAnchor =
+  'async getLocalAgentProviderConfig(e){const t="[AgentClientService][getLocalAgentProviderConfig]",i=L0.localMode?await this.shellEnvironmentService.getShellEnv():{},r=e?.credentials,s=r?.case==="apiKeyCredentials"?r.value:void 0,o=this.reactiveStorageService.applicationUserPersistentStorage,a=o.useOpenAIKey===!0?this.cursorAuthenticationService.openAIKey()??void 0:void 0,u=xgS({apiKeyCandidates:[{value:s?.apiKey,source:"modelDetails.apiKeyCredentials.apiKey"},{value:a,source:"storage.openAIKey"}],baseUrlCandidates:[{value:s?.baseUrl,source:"modelDetails.apiKeyCredentials.baseUrl"},{value:o.openAIBaseUrl,source:"storage.openAIBaseUrl"}]});return{baseUrl:u.baseUrl,apiKey:u.apiKey}}createDefaultLocalModel(e){return "default"}';
+const agentClientRunLocalModeAnchor =
+  'if(L0.localMode){try{g.onNetworkPhaseStart?.()}catch(b){this.logService.warn("[AgentClientService] onNetworkPhaseStart callback failed in local mode",b)}return this.runLocalAgentInExtensionHost(e,t,i,r,s,a,d,h,g)}return this.client.run(e,t,i,r,s,o,a,u,d,h,g)';
+
+function workbenchFixture() {
+  return [
+    `function composer(){return he(Mt,{${composerAuthGateAnchor},get children(){return "controls"}})}`,
+    `async function submit(){${composerSubmitAuthGateAnchor};return "submitted";}`,
+    `const flags={${buildFlagsLocalModeAnchor}}`,
+    localProviderConfigAnchor,
+    `async function runAgentLoop(){${agentLoopRunAnchor}}`,
+    `async function agentClientRun(){const g={};${agentClientRunLocalModeAnchor}}`,
+  ].join(';');
+}
+
+async function patchFullSet(appPath: string, backupDir: string) {
+  await patchCursorAgentExec(appPath, { backupDir });
+  await patchCursorAlwaysLocal(appPath, { backupDir });
+  await patchCursorWorkbenchAuthGate(appPath, { backupDir });
+}
+
+async function createFixtureApp() {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-cli-repair-'));
+  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 mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-always-local/dist'), {
+    recursive: true,
+  });
+  await mkdir(join(appPath, 'Contents/Resources/app/out/vs/workbench'), {
+    recursive: true,
+  });
+  await writeFile(
+    join(appPath, 'Contents/Resources/app/product.json'),
+    JSON.stringify({
+      version: '3.5.38',
+      commit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    }),
+    'utf8',
+  );
+  await writeFile(targetPath, targetContent, 'utf8');
+  await writeFile(join(appPath, alwaysLocalRelativePath), 'function alwaysLocal(){}\n', 'utf8');
+  await writeFile(join(appPath, workbenchRelativePath), workbenchFixture(), 'utf8');
+
+  const compatEntry: CompatibilityManifestEntry = {
+    platform: process.platform,
+    arch: process.arch,
+    cursorVersion: '3.5.38',
+    cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    supportStatus: 'supported',
+    targetRelativePath,
+    expectedSha256: createHash('sha256').update(targetContent).digest('hex'),
+    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,
+    runtimeFile: join(tempDir, 'runtime.json'),
+    backupDir: join(tempDir, 'backups'),
+    installRecordFile: join(tempDir, 'install.json'),
+    extensionInstallPath: join(tempDir, 'extensions/cursor-pool-status'),
+    cursorExtensionsDir: join(tempDir, 'Extensions'),
+    compatEntry,
+  };
+}
+
+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: '3.5.38',
+    cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    targetRelativePath,
+    originalSha256: fixture.compatEntry.expectedSha256,
+    compatSupportStatus: 'supported',
+    runtimeFile: fixture.runtimeFile,
+    backupDir: fixture.backupDir,
+    extensionInstallPath: fixture.extensionInstallPath,
+    extensionLinkedPath: linkedExtensionPathForDir(fixture.cursorExtensionsDir),
+    extensionState: 'linked',
+    cliVersion: '0.0.0',
+    extensionVersion: '0.0.0',
+    serviceVersion: '0.0.0',
+    lastOperation: 'install',
+    lastOperationStatus: 'ok',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}
+
+function resignCompatEntry(entry: CompatibilityManifestEntry): CompatibilityManifestEntry {
+  return {
+    ...entry,
+    requiresAdHocResign: true,
+  };
+}
+
+async function seedInstallRecord(fixture: Awaited<ReturnType<typeof createFixtureApp>>) {
+  const record = createInstallRecordFixture(fixture);
+  await writeInstallRecord(record, { installRecordFile: fixture.installRecordFile });
+  return record;
+}
+
+test('repair restarts stopped service and updates install record', async () => {
+  const fixture = await createFixtureApp();
+  let starts = 0;
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    const record = await seedInstallRecord(fixture);
+    await writeRuntimeInfo(
+      { host: '127.0.0.1', port: 45123, runtimeId: 'stale-runtime-fixture' },
+      { runtimeFile: fixture.runtimeFile },
+    );
+
+    const output = await repair({
+      realAppPath: fixture.appPath,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [fixture.compatEntry],
+      startDetachedService: async () => {
+        starts += 1;
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45200, runtimeId: 'runtime-repaired' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45200, runtimeId: 'runtime-repaired' };
+      },
+    });
+
+    assert.equal(starts, 1);
+    assert.match(output, /service: repaired/);
+    assert.match(output, /repair: ok/);
+    const repairedRecord = await readInstallRecord({
+      installRecordFile: fixture.installRecordFile,
+    });
+    assert.ok(repairedRecord);
+    assert.equal(repairedRecord.lastOperation, 'repair');
+    assert.equal(repairedRecord.lastOperationStatus, 'ok');
+    assert.equal(repairedRecord.createdAt, record.createdAt);
+    assert.notEqual(repairedRecord.updatedAt, record.updatedAt);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair restores missing extension bundle', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await seedInstallRecord(fixture);
+
+    const output = await repair({
+      realAppPath: fixture.appPath,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      cursorExtensionsDir: fixture.cursorExtensionsDir,
+      compatEntries: [fixture.compatEntry],
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45201, runtimeId: 'runtime-repaired' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45201, runtimeId: 'runtime-repaired' };
+      },
+    });
+
+    assert.match(output, /extension: repaired/);
+    assert.match(output, /linked-extension: repaired/);
+    assert.equal(await getExtensionState(fixture.extensionInstallPath), 'bundled');
+    assert.equal(
+      await getLinkedExtensionState(linkedExtensionPathForDir(fixture.cursorExtensionsDir)),
+      'linked',
+    );
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair preserves linked extension state from install record without explicit extensions dir', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    await seedInstallRecord(fixture);
+    await mkdir(join(linkedExtensionPathForDir(fixture.cursorExtensionsDir), 'dist'), { recursive: true });
+    await writeFile(
+      join(linkedExtensionPathForDir(fixture.cursorExtensionsDir), 'package.json'),
+      JSON.stringify({ publisher: 'cursor-pool', name: 'extension', version: '0.0.0' }),
+      'utf8',
+    );
+    await writeFile(
+      join(linkedExtensionPathForDir(fixture.cursorExtensionsDir), 'dist/extension.js'),
+      'module.exports = {};\n',
+      'utf8',
+    );
+
+    const output = await repair({
+      realAppPath: fixture.appPath,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [fixture.compatEntry],
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45206, runtimeId: 'runtime-repaired' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45206, runtimeId: 'runtime-repaired' };
+      },
+    });
+
+    const repairedRecord = await readInstallRecord({
+      installRecordFile: fixture.installRecordFile,
+    });
+
+    assert.match(output, /linked-extension: linked/);
+    assert.equal(repairedRecord?.extensionState, 'linked');
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair reapplies missing patch when compat is supported', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    await seedInstallRecord(fixture);
+
+    const output = await repair({
+      realAppPath: fixture.appPath,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [fixture.compatEntry],
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45202, runtimeId: 'runtime-repaired' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45202, runtimeId: 'runtime-repaired' };
+      },
+    });
+
+    assert.match(output, /patch: repaired/);
+    assert.match(await readFile(fixture.targetPath, 'utf8'), new RegExp(CURSOR_POOL_PATCH_MARKER));
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair ad-hoc resigns macOS Cursor when reapplying a patch requires resigning', async () => {
+  const fixture = await createFixtureApp();
+  const resignCalls: string[] = [];
+
+  try {
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    await seedInstallRecord(fixture);
+
+    const output = await repair({
+      realAppPath: fixture.appPath,
+      yes: true,
+      platform: 'darwin',
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [resignCompatEntry(fixture.compatEntry)],
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45205, runtimeId: 'runtime-repaired' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45205, runtimeId: 'runtime-repaired' };
+      },
+      adHocResignApp: async (appPath) => {
+        resignCalls.push(appPath);
+      },
+    });
+
+    assert.deepEqual(resignCalls, [fixture.appPath]);
+    assert.match(output, /patch: repaired/);
+    assert.match(output, /resign: ad-hoc/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair blocks changed patch target without marker', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    const record = await seedInstallRecord(fixture);
+    await writeFile(fixture.targetPath, `${fixture.targetContent}\n// user change\n`, 'utf8');
+
+    await assert.rejects(
+      repair({
+        realAppPath: fixture.appPath,
+        yes: true,
+        runtimeFile: fixture.runtimeFile,
+        backupDir: fixture.backupDir,
+        installRecordFile: fixture.installRecordFile,
+        extensionInstallPath: fixture.extensionInstallPath,
+        compatEntries: [fixture.compatEntry],
+        startDetachedService: async () => {
+          throw new Error('must not start service after patch safety failure');
+        },
+      }),
+      /patch: changed/,
+    );
+
+    assert.deepEqual(await readInstallRecord({ installRecordFile: fixture.installRecordFile }), record);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair blocks unsupported compat before repairing extension even when patch is applied', async () => {
+  const fixture = await createFixtureApp();
+  const blockedCompatEntry: CompatibilityManifestEntry = {
+    ...fixture.compatEntry,
+    supportStatus: 'blocked',
+    userMessage: 'fixture blocked',
+  };
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    const record = await seedInstallRecord(fixture);
+
+    await assert.rejects(
+      repair({
+        realAppPath: fixture.appPath,
+        yes: true,
+        runtimeFile: fixture.runtimeFile,
+        backupDir: fixture.backupDir,
+        installRecordFile: fixture.installRecordFile,
+        extensionInstallPath: fixture.extensionInstallPath,
+        compatEntries: [blockedCompatEntry],
+        startDetachedService: async () => {
+          throw new Error('must not start service for blocked compat');
+        },
+      }),
+      /compat: blocked/,
+    );
+
+    assert.equal(await getExtensionState(fixture.extensionInstallPath), 'missing');
+    assert.deepEqual(await readInstallRecord({ installRecordFile: fixture.installRecordFile }), record);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair blocks unknown compat before repairing extension even when patch is applied', async () => {
+  const fixture = await createFixtureApp();
+  const unknownCompatEntry: CompatibilityManifestEntry = {
+    ...fixture.compatEntry,
+    supportStatus: 'unknown',
+    userMessage: 'fixture unknown',
+  };
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    const record = await seedInstallRecord(fixture);
+
+    await assert.rejects(
+      repair({
+        realAppPath: fixture.appPath,
+        yes: true,
+        runtimeFile: fixture.runtimeFile,
+        backupDir: fixture.backupDir,
+        installRecordFile: fixture.installRecordFile,
+        extensionInstallPath: fixture.extensionInstallPath,
+        compatEntries: [unknownCompatEntry],
+        startDetachedService: async () => {
+          throw new Error('must not start service for unknown compat');
+        },
+      }),
+      /compat: unknown/,
+    );
+
+    assert.equal(await getExtensionState(fixture.extensionInstallPath), 'missing');
+    assert.deepEqual(await readInstallRecord({ installRecordFile: fixture.installRecordFile }), record);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair rejects mismatched install record before mutation', async () => {
+  const fixture = await createFixtureApp();
+  const otherFixture = await createFixtureApp();
+  let starts = 0;
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    const patchedBytes = await readFile(fixture.targetPath, 'utf8');
+    const wrongRecord = createInstallRecordFixture(otherFixture);
+    await writeInstallRecord(wrongRecord, { installRecordFile: fixture.installRecordFile });
+
+    await assert.rejects(
+      repair({
+        realAppPath: fixture.appPath,
+        yes: true,
+        runtimeFile: fixture.runtimeFile,
+        backupDir: fixture.backupDir,
+        installRecordFile: fixture.installRecordFile,
+        extensionInstallPath: fixture.extensionInstallPath,
+        compatEntries: [fixture.compatEntry],
+        startDetachedService: async () => {
+          starts += 1;
+          throw new Error('must not start service for mismatched record');
+        },
+      }),
+      new RegExp(`Install record does not match Cursor app: ${normalize(fixture.appPath)}`),
+    );
+
+    assert.equal(starts, 0);
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), patchedBytes);
+    assert.deepEqual(
+      await readInstallRecord({ installRecordFile: fixture.installRecordFile }),
+      wrongRecord,
+    );
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+    await rm(otherFixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair does not stop an already healthy service after repair', async () => {
+  const fixture = await createFixtureApp();
+  const service = await startServer({ runtimeFile: fixture.runtimeFile });
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    await seedInstallRecord(fixture);
+
+    const output = await repair({
+      realAppPath: fixture.appPath,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterRepair: true,
+      startDetachedService: async () => {
+        throw new Error('must not start service when existing service is healthy');
+      },
+    });
+
+    const health = await fetch(`http://127.0.0.1:${service.port}/health`);
+    const body = (await health.json()) as { ok?: unknown; runtimeId?: unknown };
+
+    assert.match(output, /service: running/);
+    assert.equal(health.ok, true);
+    assert.equal(body.ok, true);
+    assert.equal(body.runtimeId, service.runtimeId);
+  } finally {
+    await service.stop();
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair does not stop service when runtime file changes after restart', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    await seedInstallRecord(fixture);
+
+    const output = await repair({
+      realAppPath: fixture.appPath,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [fixture.compatEntry],
+      stopServiceAfterRepair: true,
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45203, runtimeId: 'runtime-started-by-repair' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45204, runtimeId: 'runtime-written-by-other-owner' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45203, runtimeId: 'runtime-started-by-repair' };
+      },
+    });
+
+    const runtimeBytes = await readFile(fixture.runtimeFile, 'utf8');
+
+    assert.match(output, /service: repaired/);
+    assert.match(runtimeBytes, /runtime-written-by-other-owner/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});