@cursorpool-dev/cli 0.5.9 → 0.5.10

package/test/repair.test.ts

@@ -207,6 +207,137 @@ test('repair restarts stopped service and updates install record', async () => {
   }
 });
 
+test('repair accepts version-family compatibility entries with wildcard commits', async () => {
+  const fixture = await createFixtureApp();
+  const familyCompatEntry: CompatibilityManifestEntry = {
+    ...fixture.compatEntry,
+    cursorVersion: '3.5',
+    cursorCommit: '*',
+  };
+
+  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: [familyCompatEntry],
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45207, runtimeId: 'runtime-repaired-family' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45207, runtimeId: 'runtime-repaired-family' };
+      },
+    });
+
+    assert.match(output, /compat: supported/);
+    assert.match(output, /repair: ok/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('repair passes platform through when checking and repairing the full patch set', async () => {
+  const fixture = await createFixtureApp();
+  let workbenchTargetRelativePath: string | undefined;
+  const linuxDebTargetRelativePath =
+    'resources/app/extensions/cursor-agent-exec/dist/main.js';
+  const linuxDebWorkbenchRelativePath =
+    'resources/app/out/vs/workbench/workbench.desktop.main.js';
+
+  try {
+    await mkdir(join(fixture.appPath, 'resources/app/extensions/cursor-agent-exec/dist'), {
+      recursive: true,
+    });
+    await mkdir(join(fixture.appPath, 'resources/app/out/vs/workbench'), { recursive: true });
+    await writeFile(
+      join(fixture.appPath, 'resources/app/product.json'),
+      JSON.stringify({
+        version: '3.5.38',
+        commit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+      }),
+      'utf8',
+    );
+    await writeFile(
+      join(fixture.appPath, linuxDebTargetRelativePath),
+      `${fixture.targetContent}${CURSOR_POOL_PATCH_MARKER}\n`,
+      'utf8',
+    );
+    await writeFile(
+      join(fixture.appPath, linuxDebWorkbenchRelativePath),
+      'function workbenchWithoutMarker(){}\n',
+      'utf8',
+    );
+    await bundleExtension({ installPath: fixture.extensionInstallPath });
+    await writeInstallRecord(
+      createInstallRecordFixture(fixture, {
+        targetRelativePath: linuxDebTargetRelativePath,
+        originalSha256: '*',
+      }),
+      { installRecordFile: fixture.installRecordFile },
+    );
+
+    await repair({
+      realAppPath: fixture.appPath,
+      productRelativePath: 'resources/app/product.json',
+      platform: 'linux',
+      arch: process.arch,
+      yes: true,
+      runtimeFile: fixture.runtimeFile,
+      backupDir: fixture.backupDir,
+      installRecordFile: fixture.installRecordFile,
+      extensionInstallPath: fixture.extensionInstallPath,
+      compatEntries: [
+        {
+          ...fixture.compatEntry,
+          platform: 'linux',
+          arch: process.arch,
+          targetRelativePath: linuxDebTargetRelativePath,
+          expectedSha256: '*',
+        },
+      ],
+      startDetachedService: async () => {
+        await writeRuntimeInfo(
+          { host: '127.0.0.1', port: 45208, runtimeId: 'runtime-repaired-linux-platform' },
+          { runtimeFile: fixture.runtimeFile },
+        );
+        return { host: '127.0.0.1', port: 45208, runtimeId: 'runtime-repaired-linux-platform' };
+      },
+      patchCursorAgentExec: async (_appPath, options = {}) => ({
+        targetPath: join(fixture.appPath, options.targetRelativePath ?? targetRelativePath),
+        backupPath: join(fixture.backupDir, 'agent.bak'),
+        beforeHash: 'before',
+        afterHash: 'after',
+        markerPresent: true,
+      }),
+      patchCursorWorkbenchAuthGate: async (_appPath, options = {}) => {
+        workbenchTargetRelativePath = options.targetRelativePath;
+        return {
+          targetPath: join(fixture.appPath, options.targetRelativePath ?? workbenchRelativePath),
+          backupPath: join(fixture.backupDir, 'workbench.bak'),
+          beforeHash: 'before',
+          afterHash: 'after',
+          markerPresent: true,
+        };
+      },
+    });
+
+    assert.equal(
+      workbenchTargetRelativePath,
+      linuxDebWorkbenchRelativePath,
+    );
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
 test('repair restores missing extension bundle', async () => {
   const fixture = await createFixtureApp();
 

package/test/restore.test.ts

@@ -5,6 +5,8 @@ import { join, normalize } from 'node:path';
 import test from 'node:test';
 import { CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR } from '../../patcher/src/marker';
 import { patchCursorAgentExec } from '../../patcher/src/patchCursorAgentExec';
+import { patchCursorAlwaysLocal } from '../../patcher/src/patchCursorAlwaysLocal';
+import { patchCursorWorkbenchAuthGate } from '../../patcher/src/patchCursorWorkbenchAuthGate';
 import {
   installIdForAppPath,
   readInstallRecord,
@@ -16,15 +18,57 @@ import { trialIdForAppPath, writeTrialRecord } from '../src/trial';
 
 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-restore-'));
   const appPath = join(tempDir, 'Cursor.app');
   const targetPath = join(appPath, targetRelativePath);
+  const alwaysLocalPath = join(appPath, alwaysLocalRelativePath);
+  const workbenchPath = join(appPath, workbenchRelativePath);
   const targetContent = `function main() { return "agent"; }\n${CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR}\nmain();\n`;
+  const alwaysLocalContent = 'function alwaysLocal(){}\n';
+  const workbenchContent = workbenchFixture();
   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({
@@ -34,12 +78,18 @@ async function createFixtureApp() {
     'utf8',
   );
   await writeFile(targetPath, targetContent, 'utf8');
+  await writeFile(alwaysLocalPath, alwaysLocalContent, 'utf8');
+  await writeFile(workbenchPath, workbenchContent, 'utf8');
 
   return {
     appPath,
     tempDir,
     targetPath,
+    alwaysLocalPath,
+    workbenchPath,
     targetContent,
+    alwaysLocalContent,
+    workbenchContent,
     backupDir: join(tempDir, 'backups'),
     trialRecordDir: join(tempDir, 'trials'),
   };
@@ -49,7 +99,7 @@ test('restore reports ok and replaces patched fixture bytes with backup bytes',
   const fixture = await createFixtureApp();
 
   try {
-    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    await patchFullSet(fixture.appPath, fixture.backupDir);
 
     const output = await restore({
       appPath: fixture.appPath,
@@ -59,6 +109,8 @@ test('restore reports ok and replaces patched fixture bytes with backup bytes',
     assert.match(output, /mode: disposable/);
     assert.match(output, /restore: ok/);
     assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+    assert.equal(await readFile(fixture.alwaysLocalPath, 'utf8'), fixture.alwaysLocalContent);
+    assert.equal(await readFile(fixture.workbenchPath, 'utf8'), fixture.workbenchContent);
   } finally {
     await rm(fixture.tempDir, { recursive: true, force: true });
   }
@@ -68,7 +120,7 @@ test('restore discovers backup directory from the trial record', async () => {
   const fixture = await createFixtureApp();
 
   try {
-    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    await patchFullSet(fixture.appPath, fixture.backupDir);
     await writeTrialRecord(
       {
         trialId: trialIdForAppPath(fixture.appPath),
@@ -96,6 +148,8 @@ test('restore discovers backup directory from the trial record', async () => {
     assert.match(output, /mode: disposable/);
     assert.match(output, /restore: ok/);
     assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+    assert.equal(await readFile(fixture.alwaysLocalPath, 'utf8'), fixture.alwaysLocalContent);
+    assert.equal(await readFile(fixture.workbenchPath, 'utf8'), fixture.workbenchContent);
   } finally {
     await rm(fixture.tempDir, { recursive: true, force: true });
   }
@@ -136,7 +190,7 @@ test('real-mode restore uses install record backup and keeps install record', as
   const runtimeFile = join(fixture.tempDir, 'runtime.json');
 
   try {
-    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    await patchFullSet(fixture.appPath, fixture.backupDir);
     const record = createInstallRecordFixture(fixture, { runtimeFile });
     await writeInstallRecord(record, { installRecordFile });
 
@@ -150,6 +204,8 @@ test('real-mode restore uses install record backup and keeps install record', as
     assert.match(output, /install-record: recorded/);
     assert.match(output, /restore: ok/);
     assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+    assert.equal(await readFile(fixture.alwaysLocalPath, 'utf8'), fixture.alwaysLocalContent);
+    assert.equal(await readFile(fixture.workbenchPath, 'utf8'), fixture.workbenchContent);
     assert.deepEqual(await readInstallRecord({ installRecordFile }), record);
   } finally {
     await rm(fixture.tempDir, { recursive: true, force: true });

package/test/target.test.ts

@@ -16,6 +16,34 @@ test('resolveCursorTarget treats explicit appPath as disposable mode', () => {
   );
 });
 
+test('resolveCursorTarget treats Linux deb Cursor root as real mode', () => {
+  assert.deepEqual(
+    resolveCursorTarget({
+      appPath: '/usr/share/cursor/',
+      platform: 'linux',
+    }),
+    {
+      mode: 'real',
+      appPath: '/usr/share/cursor',
+      requiresConfirmation: true,
+    },
+  );
+});
+
+test('resolveCursorTarget keeps Linux AppImage extraction roots disposable', () => {
+  assert.deepEqual(
+    resolveCursorTarget({
+      appPath: '/home/debian/.cursor-pool/appimages/Cursor-abc/squashfs-root',
+      platform: 'linux',
+    }),
+    {
+      mode: 'disposable',
+      appPath: '/home/debian/.cursor-pool/appimages/Cursor-abc/squashfs-root',
+      requiresConfirmation: false,
+    },
+  );
+});
+
 test('resolveCursorTarget rejects the real Cursor app as disposable appPath', () => {
   assert.throws(
     () => resolveCursorTarget({ appPath: '/Applications/Cursor.app' }),