@cursorpool-dev/cli 0.5.6 → 0.5.8

package/src/compat.ts

@@ -5,72 +5,171 @@ import type {
   CompatibilityManifestEntry,
   CompatibilityManifestEnvelope,
 } from '@cursor-pool/shared/manifest';
-import { CURSOR_AGENT_EXEC_RELATIVE_PATH } from '@cursor-pool/patcher';
+import {
+  CURSOR_AGENT_EXEC_RELATIVE_PATH,
+  CURSOR_WORKBENCH_RELATIVE_PATH,
+} from '@cursor-pool/patcher';
 import type { CliEnvironment } from './environment';
 import type { CursorInfo } from './cursor';
 
-export const DEFAULT_COMPAT_ENTRIES: CompatibilityManifestEntry[] = [
-  {
+function macPatchTargets(agentSha256: string, workbenchSha256: string) {
+  return [
+    {
+      name: 'agent-exec',
+      targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
+      expectedSha256: agentSha256,
+      patchStrategy: 'cursor-agent-exec-snippet',
+      verifyMarker: 'cursor-pool',
+    },
+    {
+      name: 'workbench',
+      targetRelativePath: CURSOR_WORKBENCH_RELATIVE_PATH,
+      expectedSha256: workbenchSha256,
+      patchStrategy: 'cursor-workbench-auth-gate',
+      verifyMarker: 'cursor-pool-workbench',
+    },
+  ];
+}
+
+function macCompatEntry(input: {
+  arch: 'arm64' | 'x64';
+  officialMajorVersion: string;
+  verifiedCursorVersion: string;
+  cursorVersion: string;
+  cursorCommit: string;
+  adapterVersion: string;
+  structureFamily: string;
+  takeoverPlanId: string;
+  agentSha256: string;
+  workbenchSha256: string;
+  userMessage: string;
+}): CompatibilityManifestEntry {
+  return {
     platform: 'darwin',
-    arch: 'arm64',
-    cursorVersion: '3.5.38',
-    cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    arch: input.arch,
+    officialSourceUrl: 'https://cursor.com/download',
+    officialDownloadUrl: `https://api2.cursor.sh/updates/download/golden/darwin-${input.arch}/cursor/${input.officialMajorVersion}`,
+    officialDownloadPlatform: `darwin-${input.arch}`,
+    verifiedCursorVersion: input.verifiedCursorVersion,
+    cursorVersion: input.officialMajorVersion,
+    cursorCommit: input.cursorCommit,
     supportStatus: 'supported',
+    adapterVersion: input.adapterVersion,
+    takeoverPlanId: input.takeoverPlanId,
+    structureFamily: input.structureFamily,
+    patchTargets: macPatchTargets(input.agentSha256, input.workbenchSha256),
     targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
-    expectedSha256: 'cb18f0237278884a39e2ce2b8664255e12689ad0803c20096c38e86c36acc51f',
-    structureSignature: 'ep1-verified-current',
+    expectedSha256: input.agentSha256,
+    structureSignature: input.structureFamily,
     patchStrategy: 'cursor-agent-exec-snippet',
     verifyMarker: 'cursor-pool',
     restoreStrategy: 'external-backup',
-    minCliVersion: '0.5.6',
-    minExtensionVersion: '0.5.6',
-    minServiceVersion: '0.5.6',
+    minCliVersion: '0.5.8',
+    minExtensionVersion: '0.5.8',
+    minServiceVersion: '0.5.8',
     requiresWritableAppBundle: true,
     requiresAdHocResign: true,
-    userMessage: 'Cursor 3.5.38 is supported for MVP-0.',
-  },
-  {
-    platform: 'darwin',
+    userMessage: input.userMessage,
+  };
+}
+
+export const DEFAULT_COMPAT_ENTRIES: CompatibilityManifestEntry[] = [
+  macCompatEntry({
+    arch: 'arm64',
+    officialMajorVersion: '3.4',
+    verifiedCursorVersion: '3.4.20',
+    cursorVersion: '3.4.20',
+    cursorCommit: '0cf8b06883f54e26bb4f0fb8647c9500ccb43310',
+    adapterVersion: '0.4.8',
+    structureFamily: 'mac-agent-D-workbench-U0',
+    takeoverPlanId: 'cursor-3.4-mac-agent-d-workbench-u0',
+    agentSha256: 'c63ae78a3b72df82db224839d552b1f8ca38011e45a37a55ae4ccd75fcdc125f',
+    workbenchSha256: '01a7005df6a76159b4edafee3c4a233003626e082212f9d042a81239a2bde388',
+    userMessage: 'Cursor 3.4.20 macOS arm64 is supported by the v0.4 adapter.',
+  }),
+  macCompatEntry({
     arch: 'x64',
+    officialMajorVersion: '3.4',
+    verifiedCursorVersion: '3.4.20',
+    cursorVersion: '3.4.20',
+    cursorCommit: '0cf8b06883f54e26bb4f0fb8647c9500ccb43310',
+    adapterVersion: '0.4.8',
+    structureFamily: 'mac-agent-D-workbench-U0',
+    takeoverPlanId: 'cursor-3.4-mac-agent-d-workbench-u0',
+    agentSha256: 'c63ae78a3b72df82db224839d552b1f8ca38011e45a37a55ae4ccd75fcdc125f',
+    workbenchSha256: '01a7005df6a76159b4edafee3c4a233003626e082212f9d042a81239a2bde388',
+    userMessage: 'Cursor 3.4.20 macOS x64 is supported by the v0.4 adapter.',
+  }),
+  macCompatEntry({
+    arch: 'arm64',
+    officialMajorVersion: '3.5',
+    verifiedCursorVersion: '3.5.38',
     cursorVersion: '3.5.38',
     cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
-    supportStatus: 'supported',
-    targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
-    expectedSha256: 'cb18f0237278884a39e2ce2b8664255e12689ad0803c20096c38e86c36acc51f',
-    structureSignature: 'ep1-verified-current',
-    patchStrategy: 'cursor-agent-exec-snippet',
-    verifyMarker: 'cursor-pool',
-    restoreStrategy: 'external-backup',
-    minCliVersion: '0.5.6',
-    minExtensionVersion: '0.5.6',
-    minServiceVersion: '0.5.6',
-    requiresWritableAppBundle: true,
-    requiresAdHocResign: true,
-    userMessage: 'Cursor 3.5.38 is supported for MVP-0 under Rosetta-launched installers.',
-  },
-  {
-    platform: 'darwin',
+    adapterVersion: '0.5.8',
+    structureFamily: 'mac-agent-F-workbench-p-L0',
+    takeoverPlanId: 'cursor-3.5-mac-agent-f-workbench-p-l0',
+    agentSha256: 'cb18f0237278884a39e2ce2b8664255e12689ad0803c20096c38e86c36acc51f',
+    workbenchSha256: '19762fb81b7d5f1a42ffa8c0c487648432874d0892cfcdb32824b107f6dcf99d',
+    userMessage: 'Cursor 3.5.38 macOS arm64 is supported by the v0.5 adapter.',
+  }),
+  macCompatEntry({
+    arch: 'x64',
+    officialMajorVersion: '3.5',
+    verifiedCursorVersion: '3.5.38',
+    cursorVersion: '3.5.38',
+    cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    adapterVersion: '0.5.8',
+    structureFamily: 'mac-agent-F-workbench-p-L0',
+    takeoverPlanId: 'cursor-3.5-mac-agent-f-workbench-p-l0',
+    agentSha256: 'cb18f0237278884a39e2ce2b8664255e12689ad0803c20096c38e86c36acc51f',
+    workbenchSha256: '19762fb81b7d5f1a42ffa8c0c487648432874d0892cfcdb32824b107f6dcf99d',
+    userMessage: 'Cursor 3.5.38 macOS x64 is supported by the v0.5 adapter.',
+  }),
+  macCompatEntry({
     arch: 'arm64',
+    officialMajorVersion: '3.6',
+    verifiedCursorVersion: '3.6.21',
     cursorVersion: '3.6.21',
     cursorCommit: 'e7a7e93f4d75f8272503ecf33cedbaae10114a10',
-    supportStatus: 'supported',
-    targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
-    expectedSha256: '222512631b78fddcdca3fa76c0dd458a7a86751dde19c998ceb31b3fe1905ebf',
-    structureSignature: 'ep1-verified-cursor-3-6-21',
-    patchStrategy: 'cursor-agent-exec-snippet',
-    verifyMarker: 'cursor-pool',
-    restoreStrategy: 'external-backup',
-    minCliVersion: '0.5.6',
-    minExtensionVersion: '0.5.6',
-    minServiceVersion: '0.5.6',
-    requiresWritableAppBundle: true,
-    requiresAdHocResign: true,
-    userMessage: 'Cursor 3.6.21 is supported for MVP-0.',
-  },
+    adapterVersion: '0.5.8',
+    structureFamily: 'mac-agent-c-workbench-h-uv',
+    takeoverPlanId: 'cursor-3.6-mac-agent-c-workbench-h-uv',
+    agentSha256: '222512631b78fddcdca3fa76c0dd458a7a86751dde19c998ceb31b3fe1905ebf',
+    workbenchSha256: '97562e30eebf41b9e162eb100966a2caf09c1c2fcf55bc87d5a84f9de67511f5',
+    userMessage: 'Cursor 3.6.21 macOS arm64 is supported by the v0.5 adapter.',
+  }),
+  macCompatEntry({
+    arch: 'arm64',
+    officialMajorVersion: '3.6',
+    verifiedCursorVersion: '3.6.31',
+    cursorVersion: '3.6.31',
+    cursorCommit: '81fcf2931d7687b4ff3f3017858d0c6dee7e2a60',
+    adapterVersion: '0.5.8',
+    structureFamily: 'mac-agent-c-workbench-h-uv',
+    takeoverPlanId: 'cursor-3.6-mac-agent-c-workbench-h-uv',
+    agentSha256: '05bfa29eacb8271c378765ead4bf881f806b97549dd13367183aa7a9331c1131',
+    workbenchSha256: '97562e30eebf41b9e162eb100966a2caf09c1c2fcf55bc87d5a84f9de67511f5',
+    userMessage: 'Cursor 3.6.31 macOS arm64 is supported by the v0.5 adapter.',
+  }),
+  macCompatEntry({
+    arch: 'arm64',
+    officialMajorVersion: '3.7',
+    verifiedCursorVersion: '3.7.12',
+    cursorVersion: '3.7.12',
+    cursorCommit: 'b887a26c4f70bd8136bfffeda812b24194ec9ce0',
+    adapterVersion: '0.6.0',
+    structureFamily: 'mac-3.7-agent-Et-workbench-wv',
+    takeoverPlanId: 'cursor-3.7-mac-agent-et-workbench-wv',
+    agentSha256: '9ce7a2f40a98a27eb1b609a79e0e1707bad5fbb02493693f6f18945a7640dde4',
+    workbenchSha256: 'e91aa502a84d5b1653a2c1f3a71a2d4160ab5f1de5809dd230756ecc0cc27db9',
+    userMessage: 'Cursor 3.7.12 macOS arm64 is supported by the v0.6 adapter.',
+  }),
 ];
 
 export type ResolveCompatOptions = {
   entries?: CompatibilityManifestEntry[];
+  adapterVersion?: string;
 };
 
 export type CompatManifestFetchResponse = {
@@ -121,6 +220,34 @@ function asBoolean(value: unknown, field: string) {
   return value;
 }
 
+function asOptionalString(value: unknown, field: string) {
+  if (value === undefined) {
+    return undefined;
+  }
+  return asString(value, field);
+}
+
+function normalizePatchTargets(value: unknown) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error('compat manifest patchTargets invalid');
+  }
+  return value.map((target) => {
+    if (!isRecord(target)) {
+      throw new Error('compat manifest patchTarget invalid');
+    }
+    return {
+      name: asString(target.name, 'patchTargets.name'),
+      targetRelativePath: asString(target.targetRelativePath, 'patchTargets.targetRelativePath'),
+      expectedSha256: asString(target.expectedSha256, 'patchTargets.expectedSha256'),
+      patchStrategy: asString(target.patchStrategy, 'patchTargets.patchStrategy'),
+      verifyMarker: asString(target.verifyMarker, 'patchTargets.verifyMarker'),
+    };
+  });
+}
+
 function normalizeRule(value: unknown): RemoteCompatibilityManifestRule {
   if (!isRecord(value)) {
     throw new Error('compat manifest rule invalid');
@@ -136,12 +263,23 @@ function normalizeRule(value: unknown): RemoteCompatibilityManifestRule {
   ) {
     throw new Error('compat manifest revision invalid');
   }
+  const adapterVersion = asOptionalString(value.adapterVersion, 'adapterVersion');
+  const structureFamily = asOptionalString(value.structureFamily, 'structureFamily');
+  const patchTargets = normalizePatchTargets(value.patchTargets);
   return {
     platform: asString(value.platform, 'platform'),
     arch: asString(value.arch, 'arch'),
+    ...(value.officialSourceUrl === undefined ? {} : { officialSourceUrl: asString(value.officialSourceUrl, 'officialSourceUrl') }),
+    ...(value.officialDownloadUrl === undefined ? {} : { officialDownloadUrl: asString(value.officialDownloadUrl, 'officialDownloadUrl') }),
+    ...(value.officialDownloadPlatform === undefined ? {} : { officialDownloadPlatform: asString(value.officialDownloadPlatform, 'officialDownloadPlatform') }),
+    ...(value.verifiedCursorVersion === undefined ? {} : { verifiedCursorVersion: asString(value.verifiedCursorVersion, 'verifiedCursorVersion') }),
     cursorVersion: asString(value.cursorVersion, 'cursorVersion'),
     cursorCommit: asString(value.cursorCommit, 'cursorCommit'),
     supportStatus,
+    ...(adapterVersion === undefined ? {} : { adapterVersion }),
+    takeoverPlanId: asString(value.takeoverPlanId, 'takeoverPlanId'),
+    ...(structureFamily === undefined ? {} : { structureFamily }),
+    ...(patchTargets === undefined ? {} : { patchTargets }),
     targetRelativePath: asString(value.targetRelativePath, 'targetRelativePath'),
     expectedSha256: asString(value.expectedSha256, 'expectedSha256'),
     structureSignature: asString(value.structureSignature, 'structureSignature'),
@@ -163,8 +301,10 @@ function canonicalRuleSegment(rule: RemoteCompatibilityManifestRule) {
     rule.platform,
     rule.arch,
     rule.cursorVersion,
+    rule.verifiedCursorVersion ?? '',
     rule.cursorCommit,
     rule.supportStatus,
+    rule.takeoverPlanId,
     String(rule.revision ?? 1),
   ].join(':');
 }
@@ -216,6 +356,11 @@ export function verifyCompatManifestEnvelope(
   return rules.map(({ revision, ...rule }) => rule);
 }
 
+function officialCursorMajorVersion(cursorVersion: string) {
+  const match = cursorVersion.match(/^(\d+\.\d+)(?:\.|$)/);
+  return match?.[1] ?? cursorVersion;
+}
+
 export function compatManifestUrlFromApiBaseUrl(apiBaseUrl: string) {
   return `${apiBaseUrl.replace(/\/+$/, '')}/api/client/compatibility/manifest`;
 }
@@ -265,8 +410,9 @@ export function resolveCompatEntry(
     (candidate) =>
       candidate.platform === environment.platform &&
       candidate.arch === environment.arch &&
-      candidate.cursorVersion === cursor.version &&
-      candidate.cursorCommit === cursor.commit,
+      candidate.cursorVersion === officialCursorMajorVersion(cursor.version) &&
+      candidate.cursorCommit === cursor.commit &&
+      (!options.adapterVersion || candidate.adapterVersion === options.adapterVersion),
   );
 
   if (!entry) {

package/src/cursor.ts

@@ -1,7 +1,12 @@
-import { readFile } from 'node:fs/promises';
-import { join, win32 } from 'node:path';
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { promisify } from 'node:util';
+import { chmod, mkdir, readFile, rm, stat } from 'node:fs/promises';
+import { basename, join, win32 } from 'node:path';
+import { homedir } from 'node:os';
 
 export const DEFAULT_MACOS_CURSOR_APP_PATH = '/Applications/Cursor.app';
+const execFileAsync = promisify(execFile);
 
 export type CursorInfo = {
   appPath: string;
@@ -14,6 +19,7 @@ export type FindCursorOptions = {
   productRelativePath?: string;
   platform?: NodeJS.Platform;
   env?: NodeJS.ProcessEnv;
+  appImageExtract?: (appImagePath: string, outputRoot: string) => Promise<string>;
 };
 
 type CursorProductJson = {
@@ -43,7 +49,8 @@ function readString(value: unknown) {
 }
 
 export async function findCursor(options: FindCursorOptions = {}): Promise<CursorInfo> {
-  const appPath = options.appPath ?? defaultCursorAppPath(options);
+  const rawAppPath = options.appPath ?? defaultCursorAppPath(options);
+  const appPath = await resolveCursorAppPath(rawAppPath, options);
   const productJsonPath = await resolveProductJsonPath(appPath, options);
   const product = JSON.parse(await readFile(productJsonPath, 'utf8')) as CursorProductJson;
   const version = readString(product.version);
@@ -66,6 +73,55 @@ export async function findCursor(options: FindCursorOptions = {}): Promise<Curso
   };
 }
 
+async function pathIsFile(path: string) {
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function linuxAppImageExtractRoot(appImagePath: string) {
+  const hash = createHash('sha256').update(appImagePath).digest('hex').slice(0, 16);
+  const name = basename(appImagePath).replace(/\.AppImage$/i, '').replace(/[^A-Za-z0-9._-]/g, '-');
+  return join(homedir(), '.cursor-pool/appimages', `${name}-${hash}`);
+}
+
+async function defaultExtractLinuxAppImage(appImagePath: string, outputRoot: string) {
+  await rm(outputRoot, { recursive: true, force: true });
+  await mkdir(outputRoot, { recursive: true });
+  await chmod(appImagePath, 0o755).catch(() => undefined);
+  await execFileAsync(appImagePath, ['--appimage-extract'], {
+    cwd: outputRoot,
+    maxBuffer: 1024 * 1024 * 20,
+  });
+  return join(outputRoot, 'squashfs-root');
+}
+
+async function resolveCursorAppPath(appPath: string, options: FindCursorOptions) {
+  if (
+    (options.platform ?? process.platform) !== 'linux' ||
+    !/\.AppImage$/i.test(appPath) ||
+    !(await pathIsFile(appPath))
+  ) {
+    return appPath;
+  }
+
+  const outputRoot = linuxAppImageExtractRoot(appPath);
+  const extractedPath = join(outputRoot, 'squashfs-root');
+  try {
+    await readFile(join(extractedPath, 'usr/share/cursor/resources/app/product.json'), 'utf8');
+    return extractedPath;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const extract = options.appImageExtract ?? defaultExtractLinuxAppImage;
+  return extract(appPath, outputRoot);
+}
+
 async function resolveProductJsonPath(appPath: string, options: FindCursorOptions) {
   if (options.productRelativePath) {
     return join(appPath, options.productRelativePath);

package/src/extensionBundle.ts

@@ -55,7 +55,7 @@ async function exists(path: string) {
 function buildRuntimeManifest(sourceManifest: Record<string, unknown>) {
   return {
     name: 'cursorpool',
-    version: typeof sourceManifest.version === 'string' ? sourceManifest.version : '0.5.6',
+    version: typeof sourceManifest.version === 'string' ? sourceManifest.version : '0.5.8',
     displayName: 'Cursor Pool 平台模式',
     publisher: 'cursor-pool',
     type: sourceManifest.type,

package/src/extensionLink.ts

@@ -4,7 +4,8 @@ import { basename, dirname, join, resolve } from 'node:path';
 import { resolveExtensionInstallPath } from './extensionBundle';
 import type { ExtensionState } from './trial';
 
-export const LINKED_EXTENSION_DIRNAME = 'cursor-pool.extension-0.5.6';
+export const LINKED_EXTENSION_DIRNAME = 'cursor-pool.extension-0.5.8';
+const LINKED_EXTENSION_DIRNAME_PREFIX = 'cursor-pool.extension-';
 const RUNTIME_EXTENSION_ID = 'cursor-pool.cursorpool';
 const STALE_EXTENSION_IDS = new Set([
   RUNTIME_EXTENSION_ID,
@@ -48,10 +49,17 @@ async function readRuntimeManifest(linkedPath: string) {
   };
   const publisher = typeof manifest.publisher === 'string' ? manifest.publisher : 'cursor-pool';
   const name = typeof manifest.name === 'string' ? manifest.name : 'cursorpool';
-  const version = typeof manifest.version === 'string' ? manifest.version : '0.5.6';
+  const version = typeof manifest.version === 'string' ? manifest.version : '0.5.8';
   return { id: `${publisher}.${name}`, version };
 }
 
+function linkedExtensionDirnameForVersion(version: string) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(version)) {
+    throw new Error(`Unsafe extension version: ${version}`);
+  }
+  return `${LINKED_EXTENSION_DIRNAME_PREFIX}${version}`;
+}
+
 export async function refreshCursorExtensionsIndex(cursorExtensionsDir: string, linkedPath: string) {
   const indexPath = join(resolveExtensionInstallPath(cursorExtensionsDir), 'extensions.json');
   if (!(await exists(indexPath))) {
@@ -63,11 +71,13 @@ export async function refreshCursorExtensionsIndex(cursorExtensionsDir: string,
     relativeLocation?: string;
   }>;
   const manifest = await readRuntimeManifest(linkedPath);
+  const relativeLocation = basename(linkedPath);
   const nextEntries = entries.filter((entry) => {
     const id = entry.identifier?.id;
+    const relativeLocation = entry.relativeLocation ?? '';
     return (
       !STALE_EXTENSION_IDS.has(id ?? '') &&
-      entry.relativeLocation !== LINKED_EXTENSION_DIRNAME &&
+      !relativeLocation.startsWith(LINKED_EXTENSION_DIRNAME_PREFIX) &&
       entry.relativeLocation !== 'keg1255.cursorpool-1.0.52'
     );
   });
@@ -79,7 +89,7 @@ export async function refreshCursorExtensionsIndex(cursorExtensionsDir: string,
       path: linkedPath,
       scheme: 'file',
     },
-    relativeLocation: LINKED_EXTENSION_DIRNAME,
+    relativeLocation,
     version: manifest.version,
   });
   await writeFile(indexPath, `${JSON.stringify(nextEntries, null, 2)}\n`, 'utf8');
@@ -92,9 +102,9 @@ function assertSafeLinkedExtensionPath(linkedPath: string) {
     (segment) => segment === 'extensions' || segment === 'Extensions',
   );
 
-  if (basename(resolvedLinkedPath) !== LINKED_EXTENSION_DIRNAME || !hasExtensionsParent) {
+  if (!basename(resolvedLinkedPath).startsWith(LINKED_EXTENSION_DIRNAME_PREFIX) || !hasExtensionsParent) {
     throw new Error(
-      `Unsafe linked extension path for recursive removal: ${linkedPath}. Expected an extensions/${LINKED_EXTENSION_DIRNAME} bundle path.`,
+      `Unsafe linked extension path for recursive removal: ${linkedPath}. Expected an extensions/${LINKED_EXTENSION_DIRNAME_PREFIX}<version> bundle path.`,
     );
   }
 }
@@ -103,6 +113,14 @@ export function linkedExtensionPathForDir(cursorExtensionsDir: string) {
   return join(resolveExtensionInstallPath(cursorExtensionsDir), LINKED_EXTENSION_DIRNAME);
 }
 
+export async function linkedExtensionPathForSource(cursorExtensionsDir: string, sourceBundlePath: string) {
+  const manifest = await readRuntimeManifest(sourceBundlePath);
+  return join(
+    resolveExtensionInstallPath(cursorExtensionsDir),
+    linkedExtensionDirnameForVersion(manifest.version),
+  );
+}
+
 export async function getLinkedExtensionState(linkedPath: string | undefined): Promise<LinkedExtensionState> {
   if (!linkedPath) {
     return 'missing';
@@ -119,7 +137,10 @@ export async function linkExtensionBundle({
   cursorExtensionsDir,
 }: LinkExtensionBundleOptions): Promise<LinkExtensionBundleResult> {
   const resolvedSourceBundlePath = resolveExtensionInstallPath(sourceBundlePath);
-  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+  const linkedPath =
+    (await getLinkedExtensionState(resolvedSourceBundlePath)) === 'missing'
+      ? linkedExtensionPathForDir(cursorExtensionsDir)
+      : await linkedExtensionPathForSource(cursorExtensionsDir, resolvedSourceBundlePath);
 
   if ((await getLinkedExtensionState(resolvedSourceBundlePath)) === 'missing') {
     return { state: 'missing', linkedPath };