@cursorpool-dev/cli 0.5.6 → 0.5.8

package/test/compat.test.ts

@@ -15,12 +15,34 @@ import {
 } from '../src/compat';
 
 function remoteRuleFor(cursorVersion: string, cursorCommit: string): CompatibilityManifestEntry {
+  const cursorMajor = cursorVersion.replace(/^(\d+\.\d+).*/, '$1');
+  const planByMajor: Record<string, string> = {
+    '3.5': 'cursor-3.5-mac-agent-f-workbench-p-l0',
+    '3.6': 'cursor-3.6-mac-agent-c-workbench-h-uv',
+    '3.7': 'cursor-3.7-mac-agent-et-workbench-wv',
+  };
   return {
     platform: 'darwin',
     arch: 'arm64',
-    cursorVersion,
+    officialSourceUrl: 'https://cursor.com/download',
+    officialDownloadUrl: `https://api2.cursor.sh/updates/download/golden/darwin-arm64/cursor/${cursorVersion.replace(/^(\d+\.\d+).*/, '$1')}`,
+    officialDownloadPlatform: 'darwin-arm64',
+    verifiedCursorVersion: cursorVersion,
+    cursorVersion: cursorMajor,
     cursorCommit,
     supportStatus: 'supported',
+    adapterVersion: '0.5.8',
+    takeoverPlanId: planByMajor[cursorMajor] ?? `cursor-${cursorMajor}-remote-plan`,
+    structureFamily: 'mac-agent-c-workbench-h-uv',
+    patchTargets: [
+      {
+        name: 'agent-exec',
+        targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
+        expectedSha256: 'remote-sha256',
+        patchStrategy: 'cursor-agent-exec-snippet',
+        verifyMarker: 'cursor-pool',
+      },
+    ],
     targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
     expectedSha256: 'remote-sha256',
     structureSignature: 'remote-structure',
@@ -70,13 +92,161 @@ test('default compatibility manifest supports Cursor 3.6.21 on macOS arm64', ()
   assert.equal(
     DEFAULT_COMPAT_ENTRIES.some(
       (candidate) =>
-        candidate.cursorVersion === '3.6.21' &&
+        candidate.cursorVersion === '3.6' &&
         candidate.cursorCommit === 'e7a7e93f4d75f8272503ecf33cedbaae10114a10',
     ),
     true,
   );
 });
 
+test('default compatibility entries are keyed by official Cursor major download versions only', () => {
+  assert.deepEqual(
+    Array.from(new Set(DEFAULT_COMPAT_ENTRIES.map((entry) => entry.cursorVersion))).sort(),
+    ['3.4', '3.5', '3.6', '3.7'],
+  );
+  assert.equal(
+    DEFAULT_COMPAT_ENTRIES.every((entry) =>
+      entry.officialDownloadUrl?.startsWith(
+        `https://api2.cursor.sh/updates/download/golden/${entry.officialDownloadPlatform}/cursor/${entry.cursorVersion}`,
+      ),
+    ),
+    true,
+  );
+  assert.equal(
+    DEFAULT_COMPAT_ENTRIES.some((entry) => entry.officialSourceUrl !== 'https://cursor.com/download'),
+    false,
+  );
+  assert.equal(
+    DEFAULT_COMPAT_ENTRIES.some((entry) => entry.platform === 'linux' || entry.platform === 'win32'),
+    false,
+  );
+});
+
+test('default compatibility manifest supports Cursor 3.4.20 on macOS arm64 with the v0.4 adapter', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/Applications/Cursor.app',
+      version: '3.4.20',
+      commit: '0cf8b06883f54e26bb4f0fb8647c9500ccb43310',
+    },
+    {
+      platform: 'darwin',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+    { adapterVersion: '0.4.8' },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.adapterVersion, '0.4.8');
+  assert.equal(entry.cursorVersion, '3.4');
+  assert.equal(entry.structureFamily, 'mac-agent-D-workbench-U0');
+  assert.equal(entry.patchTargets?.map((target) => target.name).join(','), 'agent-exec,workbench');
+});
+
+test('default compatibility manifest does not match Cursor 3.4.20 from the v0.5 adapter', () => {
+  assert.throws(
+    () =>
+      resolveCompatEntry(
+        {
+          appPath: '/Applications/Cursor.app',
+          version: '3.4.20',
+          commit: '0cf8b06883f54e26bb4f0fb8647c9500ccb43310',
+        },
+        {
+          platform: 'darwin',
+          arch: 'arm64',
+          nodeVersion: process.version,
+        },
+        { adapterVersion: '0.5.8' },
+      ),
+    /No compatibility entry for Cursor 3\.4\.20/,
+  );
+});
+
+test('default compatibility manifest supports Cursor 3.6.31 on macOS arm64 with the v0.5 adapter', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/Applications/Cursor.app',
+      version: '3.6.31',
+      commit: '81fcf2931d7687b4ff3f3017858d0c6dee7e2a60',
+    },
+    {
+      platform: 'darwin',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+    { adapterVersion: '0.5.8' },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.adapterVersion, '0.5.8');
+  assert.equal(entry.cursorVersion, '3.6');
+  assert.equal(entry.structureFamily, 'mac-agent-c-workbench-h-uv');
+  assert.equal(entry.patchTargets?.map((target) => target.name).join(','), 'agent-exec,workbench');
+});
+
+test('default compatibility manifest supports Cursor 3.7.12 on macOS arm64 with the v0.6 adapter', () => {
+  const entry = resolveCompatEntry(
+    {
+      appPath: '/Applications/Cursor.app',
+      version: '3.7.12',
+      commit: 'b887a26c4f70bd8136bfffeda812b24194ec9ce0',
+    },
+    {
+      platform: 'darwin',
+      arch: 'arm64',
+      nodeVersion: process.version,
+    },
+    { adapterVersion: '0.6.0' },
+  );
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.adapterVersion, '0.6.0');
+  assert.equal(entry.cursorVersion, '3.7');
+  assert.equal(entry.structureFamily, 'mac-3.7-agent-Et-workbench-wv');
+  assert.equal(entry.patchTargets?.map((target) => target.name).join(','), 'agent-exec,workbench');
+});
+
+test('default compatibility manifest does not match Cursor 3.7.12 from the v0.5 adapter', () => {
+  assert.throws(
+    () =>
+      resolveCompatEntry(
+        {
+          appPath: '/Applications/Cursor.app',
+          version: '3.7.12',
+          commit: 'b887a26c4f70bd8136bfffeda812b24194ec9ce0',
+        },
+        {
+          platform: 'darwin',
+          arch: 'arm64',
+          nodeVersion: process.version,
+        },
+        { adapterVersion: '0.5.8' },
+      ),
+    /No compatibility entry for Cursor 3\.7\.12/,
+  );
+});
+
+test('default compatibility manifest does not claim unverified Linux Cursor packages as supported', () => {
+  assert.throws(
+    () =>
+      resolveCompatEntry(
+        {
+          appPath: '/home/xubuntu/.cursor-pool/appimages/Cursor-89aa899ccc46fb58/squashfs-root',
+          version: '3.6.31',
+          commit: '81fcf2931d7687b4ff3f3017858d0c6dee7e2a60',
+        },
+        {
+          platform: 'linux',
+          arch: 'x64',
+          nodeVersion: process.version,
+        },
+      ),
+    /No compatibility entry for Cursor 3\.6\.31/,
+  );
+});
+
 test('default compatibility manifest supports Cursor 3.5.38 on macOS x64 for Rosetta-launched installers', () => {
   const entry = resolveCompatEntry(
     {
@@ -93,6 +263,7 @@ test('default compatibility manifest supports Cursor 3.5.38 on macOS x64 for Ros
 
   assert.equal(entry.supportStatus, 'supported');
   assert.equal(entry.requiresAdHocResign, true);
+  assert.equal(entry.cursorVersion, '3.5');
   assert.equal(entry.targetRelativePath, CURSOR_AGENT_EXEC_RELATIVE_PATH);
   assert.equal(
     entry.expectedSha256,
@@ -146,7 +317,8 @@ test('loads remote compatibility entries from api base url when signature is val
     },
   });
 
-  assert.equal(entries[0]?.cursorVersion, '3.7.0');
+  assert.equal(entries[0]?.cursorVersion, '3.7');
+  assert.equal(entries[0]?.verifiedCursorVersion, '3.7.0');
 });
 
 test('loads compatibility entries from a local file URL for disposable client validation', async () => {
@@ -190,3 +362,66 @@ test('falls back to injected compatibility entries before fetching remote manife
 
   assert.equal(entries, injected);
 });
+
+test('resolveCompatEntry only matches the current adapter version when provided', () => {
+  const cursor = {
+    appPath: '/Applications/Cursor.app',
+    version: '3.7.12',
+    commit: 'b887a26c4f70bd8136bfffeda812b24194ec9ce0',
+  };
+  const environment = {
+    platform: 'darwin' as const,
+    arch: 'arm64',
+    nodeVersion: process.version,
+  };
+  const matchingRule = remoteRuleFor(cursor.version, cursor.commit);
+  const otherAdapterRule = {
+    ...matchingRule,
+    adapterVersion: '0.6.0',
+    userMessage: 'Cursor 3.7.12 needs the 0.6 adapter.',
+  };
+
+  assert.throws(
+    () =>
+      resolveCompatEntry(cursor, environment, {
+        entries: [otherAdapterRule],
+        adapterVersion: '0.5.8',
+      }),
+    /No compatibility entry for Cursor 3\.7\.12/,
+  );
+
+  const resolved = resolveCompatEntry(cursor, environment, {
+    entries: [otherAdapterRule],
+    adapterVersion: '0.6.0',
+  });
+  assert.equal(resolved.adapterVersion, '0.6.0');
+});
+
+test('resolveCompatEntry rejects legacy rules without adapterVersion when current adapter is known', () => {
+  const cursor = {
+    appPath: '/Applications/Cursor.app',
+    version: '3.6.21',
+    commit: 'e7a7e93f4d75f8272503ecf33cedbaae10114a10',
+  };
+  const environment = {
+    platform: 'darwin' as const,
+    arch: 'arm64',
+    nodeVersion: process.version,
+  };
+  const { adapterVersion: _adapterVersion, ...legacyRule } = remoteRuleFor(cursor.version, cursor.commit);
+
+  assert.throws(
+    () =>
+      resolveCompatEntry(cursor, environment, {
+        entries: [legacyRule],
+        adapterVersion: '0.5.8',
+      }),
+    /No compatibility entry for Cursor 3\.6\.21/,
+  );
+
+  const resolved = resolveCompatEntry(cursor, environment, {
+    entries: [legacyRule],
+  });
+  assert.equal(resolved.cursorVersion, '3.6');
+  assert.equal(resolved.verifiedCursorVersion, '3.6.21');
+});

package/test/cursor-pool-bin.test.ts

@@ -59,6 +59,7 @@ test('CLI common options include target, record, trial, extension, and service l
       cursorExtensionsDir: '/tmp/Cursor-Pool-Trial-Extensions',
       userDataDir: '/tmp/Cursor-Pool-Trial-UserData',
       serviceLogFile: '/tmp/service.log',
+      configFile: undefined,
       diagnosticsFile: '/tmp/diagnostics.jsonl',
       sessionFile: '/tmp/session.json',
       code: 'CODE-123',

package/test/cursor.test.ts

@@ -1,6 +1,9 @@
 import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import test from 'node:test';
-import { defaultCursorAppPath } from '../src/cursor';
+import { defaultCursorAppPath, findCursor } from '../src/cursor';
 
 test('defaultCursorAppPath resolves the user-level Windows Cursor install directory', () => {
   assert.equal(
@@ -18,3 +21,59 @@ test('defaultCursorAppPath gives a helpful Windows error when LOCALAPPDATA is un
     /LOCALAPPDATA is required to auto-detect Cursor on Windows/,
   );
 });
+
+test('findCursor extracts Linux AppImage files before reading product metadata', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-linux-appimage-'));
+  const appImagePath = join(tempDir, 'Cursor.AppImage');
+  const extractedRoots: string[] = [];
+
+  try {
+    await writeFile(appImagePath, '#!/bin/sh\n', { mode: 0o755 });
+
+    const cursor = await findCursor({
+      appPath: appImagePath,
+      platform: 'linux',
+      appImageExtract: async (path, outputRoot) => {
+        assert.equal(path, appImagePath);
+        extractedRoots.push(outputRoot);
+        const extractedPath = join(outputRoot, 'squashfs-root');
+        await mkdir(join(extractedPath, 'usr/share/cursor/resources/app'), { recursive: true });
+        await writeFile(
+          join(extractedPath, 'usr/share/cursor/resources/app/product.json'),
+          JSON.stringify({ version: '3.6.31', commit: 'linux-commit' }),
+          'utf8',
+        );
+        return extractedPath;
+      },
+    });
+
+    assert.equal(cursor.version, '3.6.31');
+    assert.equal(cursor.commit, 'linux-commit');
+    assert.match(cursor.appPath, /squashfs-root$/);
+    assert.equal(extractedRoots.length, 1);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('findCursor keeps macOS app bundle product path unchanged', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-macos-app-'));
+  const appPath = join(tempDir, 'Cursor.app');
+
+  try {
+    await mkdir(join(appPath, 'Contents/Resources/app'), { recursive: true });
+    await writeFile(
+      join(appPath, 'Contents/Resources/app/product.json'),
+      JSON.stringify({ version: '3.5.38', commit: 'mac-commit' }),
+      'utf8',
+    );
+
+    const cursor = await findCursor({ appPath, platform: 'darwin' });
+
+    assert.equal(cursor.appPath, appPath);
+    assert.equal(cursor.version, '3.5.38');
+    assert.equal(cursor.commit, 'mac-commit');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/test/e2e-install.test.ts

@@ -13,6 +13,16 @@ import {
   CURSOR_POOL_PATCH_MARKER,
 } from '../../patcher/src/marker';
 import { backupPathForCursorAgentExec } from '../../patcher/src/patchCursorAgentExec';
+import { CURSOR_WORKBENCH_RELATIVE_PATH } from '../../patcher/src/patchCursorWorkbenchAuthGate';
+import {
+  CURSOR_WORKBENCH_AGENT_CLIENT_RUN_LOCAL_MODE_ANCHOR,
+  CURSOR_WORKBENCH_AGENT_EDITOR_SEND_BUTTON_AUTH_GATE_ANCHOR,
+  CURSOR_WORKBENCH_AGENT_EDITOR_SEND_BUTTON_LOGIN_ANCHOR,
+  CURSOR_WORKBENCH_AGENT_LOOP_RUN_ANCHOR,
+  CURSOR_WORKBENCH_BUILD_FLAGS_LOCAL_MODE_ANCHOR,
+  CURSOR_WORKBENCH_COMPOSER_AUTH_GATE_ANCHOR,
+  CURSOR_WORKBENCH_COMPOSER_SUBMIT_AUTH_GATE_ANCHOR,
+} from '../../patcher/src/workbenchAuthGateMarker';
 import type { CompatibilityManifestEntry } from '../../shared/src/manifest';
 import { getExtensionState } from '../src/extensionBundle';
 import { getLinkedExtensionState, linkedExtensionPathForDir } from '../src/extensionLink';
@@ -35,30 +45,70 @@ const targetRelativePath =
 const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
 const serviceServerPath = resolve(repoRoot, 'packages/service/src/server.ts');
 
+function workbenchFixtureContent() {
+  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"}';
+  return [
+    `function composer(){return he(Mt,{${CURSOR_WORKBENCH_COMPOSER_AUTH_GATE_ANCHOR},get children(){return "controls"}})}`,
+    `async function submit(){${CURSOR_WORKBENCH_COMPOSER_SUBMIT_AUTH_GATE_ANCHOR};return "submitted";}`,
+    `function agentEditorControls(){const T=()=>{${CURSOR_WORKBENCH_AGENT_EDITOR_SEND_BUTTON_LOGIN_ANCHOR};return n.handleSubmit()};return he(Mt,{${CURSOR_WORKBENCH_AGENT_EDITOR_SEND_BUTTON_AUTH_GATE_ANCHOR}"controls"}})}`,
+    `const flags={${CURSOR_WORKBENCH_BUILD_FLAGS_LOCAL_MODE_ANCHOR}}`,
+    localProviderConfigAnchor,
+    `async function runAgentLoop(){${CURSOR_WORKBENCH_AGENT_LOOP_RUN_ANCHOR}}`,
+    `async function agentClientRun(){const g={...p,isRunningInTest:p.isRunningInTest??this.environmentService.enableSmokeTestDriver===!0,clientSupportsInlineImages:!0};${CURSOR_WORKBENCH_AGENT_CLIENT_RUN_LOCAL_MODE_ANCHOR}}`,
+  ].join(';');
+}
+
 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`;
+  const workbenchPath = join(appPath, CURSOR_WORKBENCH_RELATIVE_PATH);
+  const workbenchContent = workbenchFixtureContent();
   await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-agent-exec/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: cursorVersion, commit: cursorCommit }),
     'utf8',
   );
   await writeFile(targetPath, targetContent, 'utf8');
+  await writeFile(workbenchPath, workbenchContent, 'utf8');
 
   const originalHash = createHash('sha256').update(targetContent).digest('hex');
+  const workbenchOriginalHash = createHash('sha256').update(workbenchContent).digest('hex');
   const compatEntry: CompatibilityManifestEntry = {
     platform: process.platform,
     arch: process.arch,
     cursorVersion,
     cursorCommit,
     supportStatus: 'supported',
+    takeoverPlanId: 'cursor-3.6-mac-agent-c-workbench-h-uv',
     targetRelativePath,
     expectedSha256: originalHash,
+    adapterVersion: '0.5.8',
+    structureFamily: 'fixture-agent-exec-workbench',
+    patchTargets: [
+      {
+        name: 'agent-exec',
+        targetRelativePath,
+        expectedSha256: originalHash,
+        patchStrategy: 'cursor-agent-exec-snippet',
+        verifyMarker: 'cursor-pool',
+      },
+      {
+        name: 'workbench',
+        targetRelativePath: CURSOR_WORKBENCH_RELATIVE_PATH,
+        expectedSha256: workbenchOriginalHash,
+        patchStrategy: 'cursor-workbench-auth-gate',
+        verifyMarker: 'cursor-pool-workbench',
+      },
+    ],
     structureSignature: 'fixture',
     patchStrategy: 'cursor-agent-exec-snippet',
     verifyMarker: 'cursor-pool',
@@ -77,6 +127,9 @@ async function createFixtureApp(prefix: string) {
     targetPath,
     targetContent,
     originalHash,
+    workbenchPath,
+    workbenchContent,
+    workbenchOriginalHash,
     runtimeFile: join(tempDir, 'runtime.json'),
     backupDir: join(tempDir, 'backups'),
     compatEntry,

package/test/extensionLink.test.ts

@@ -12,12 +12,12 @@ import {
   snapshotLinkedExtensionBundle,
 } from '../src/extensionLink';
 
-async function createSourceBundle(tempDir: string) {
+async function createSourceBundle(tempDir: string, version = '0.0.0') {
   const sourceBundlePath = join(tempDir, 'source/extensions/cursor-pool-status');
   await mkdir(join(sourceBundlePath, 'dist'), { recursive: true });
   await writeFile(
     join(sourceBundlePath, 'package.json'),
-    JSON.stringify({ name: 'cursorpool', publisher: 'cursor-pool', version: '0.0.0' }),
+    JSON.stringify({ name: 'cursorpool', publisher: 'cursor-pool', version }),
     'utf8',
   );
   await writeFile(join(sourceBundlePath, 'dist/extension.js'), 'export function activate() {}\n', 'utf8');
@@ -54,6 +54,52 @@ test('linkExtensionBundle copies source bundle into Cursor extensions directory'
   }
 });
 
+test('linkExtensionBundle uses the source manifest version for the linked directory and index', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-version-'));
+  const sourceBundlePath = await createSourceBundle(tempDir, '0.5.6');
+  const cursorExtensionsDir = join(tempDir, 'Extensions');
+  await mkdir(cursorExtensionsDir, { recursive: true });
+  await writeFile(join(cursorExtensionsDir, 'extensions.json'), '[]', 'utf8');
+
+  try {
+    const result = await linkExtensionBundle({ sourceBundlePath, cursorExtensionsDir });
+    const index = JSON.parse(await readFile(join(cursorExtensionsDir, 'extensions.json'), 'utf8'));
+
+    assert.deepEqual(result, {
+      state: 'linked',
+      linkedPath: join(cursorExtensionsDir, 'cursor-pool.extension-0.5.6'),
+    });
+    assert.equal(await getLinkedExtensionState(result.linkedPath), 'linked');
+    assert.deepEqual(index.at(-1), {
+      identifier: { id: 'cursor-pool.cursorpool' },
+      location: {
+        $mid: 1,
+        path: result.linkedPath,
+        scheme: 'file',
+      },
+      relativeLocation: 'cursor-pool.extension-0.5.6',
+      version: '0.5.6',
+    });
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('linkExtensionBundle rejects unsafe source manifest versions before linking', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-version-unsafe-'));
+  const sourceBundlePath = await createSourceBundle(tempDir, '../../bad');
+  const cursorExtensionsDir = join(tempDir, 'Extensions');
+
+  try {
+    await assert.rejects(
+      linkExtensionBundle({ sourceBundlePath, cursorExtensionsDir }),
+      /Unsafe extension version/,
+    );
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
 test('linkExtensionBundle refreshes Cursor extensions index with runtime extension id', async () => {
   const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-index-'));
   const sourceBundlePath = await createSourceBundle(tempDir);