@cursorpool-dev/cli 0.5.8 → 0.5.9

package/src/compat.ts

@@ -5,171 +5,129 @@ import type {
   CompatibilityManifestEntry,
   CompatibilityManifestEnvelope,
 } from '@cursor-pool/shared/manifest';
-import {
-  CURSOR_AGENT_EXEC_RELATIVE_PATH,
-  CURSOR_WORKBENCH_RELATIVE_PATH,
-} from '@cursor-pool/patcher';
+import { CURSOR_AGENT_EXEC_RELATIVE_PATH } from '@cursor-pool/patcher';
 import type { CliEnvironment } from './environment';
 import type { CursorInfo } from './cursor';
 
-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 {
+export const DEFAULT_COMPAT_ENTRIES: CompatibilityManifestEntry[] = [
+  {
     platform: 'darwin',
-    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,
+    arch: 'arm64',
+    cursorVersion: '3.4',
+    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: input.agentSha256,
-    structureSignature: input.structureFamily,
+    expectedSha256: '*',
+    structureSignature: 'ep1-cursor-3-4-family',
     patchStrategy: 'cursor-agent-exec-snippet',
     verifyMarker: 'cursor-pool',
     restoreStrategy: 'external-backup',
-    minCliVersion: '0.5.8',
-    minExtensionVersion: '0.5.8',
-    minServiceVersion: '0.5.8',
+    minCliVersion: '0.5.9',
+    minExtensionVersion: '0.5.9',
+    minServiceVersion: '0.5.9',
     requiresWritableAppBundle: true,
     requiresAdHocResign: true,
-    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({
+    userMessage: 'Cursor 3.4.x is supported for MVP-0.',
+  },
+  {
+    platform: 'darwin',
     arch: 'arm64',
-    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 arm64 is supported by the v0.5 adapter.',
-  }),
-  macCompatEntry({
+    cursorVersion: '3.5',
+    cursorCommit: '*',
+    supportStatus: 'supported',
+    targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
+    expectedSha256: '*',
+    structureSignature: 'ep1-cursor-3-5-family',
+    patchStrategy: 'cursor-agent-exec-snippet',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'external-backup',
+    minCliVersion: '0.5.9',
+    minExtensionVersion: '0.5.9',
+    minServiceVersion: '0.5.9',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: true,
+    userMessage: 'Cursor 3.5.x is supported for MVP-0.',
+  },
+  {
+    platform: 'darwin',
     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({
+    cursorVersion: '3.5',
+    cursorCommit: '*',
+    supportStatus: 'supported',
+    targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
+    expectedSha256: '*',
+    structureSignature: 'ep1-cursor-3-5-family',
+    patchStrategy: 'cursor-agent-exec-snippet',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'external-backup',
+    minCliVersion: '0.5.9',
+    minExtensionVersion: '0.5.9',
+    minServiceVersion: '0.5.9',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: true,
+    userMessage: 'Cursor 3.5.x is supported for MVP-0 under Rosetta-launched installers.',
+  },
+  {
+    platform: 'darwin',
     arch: 'arm64',
-    officialMajorVersion: '3.6',
-    verifiedCursorVersion: '3.6.21',
-    cursorVersion: '3.6.21',
-    cursorCommit: 'e7a7e93f4d75f8272503ecf33cedbaae10114a10',
-    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({
+    cursorVersion: '3.6',
+    cursorCommit: '*',
+    supportStatus: 'supported',
+    targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
+    expectedSha256: '*',
+    structureSignature: 'ep1-cursor-3-6-family',
+    patchStrategy: 'cursor-agent-exec-snippet',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'external-backup',
+    minCliVersion: '0.5.9',
+    minExtensionVersion: '0.5.9',
+    minServiceVersion: '0.5.9',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: true,
+    userMessage: 'Cursor 3.6.x is supported for MVP-0.',
+  },
+  {
+    platform: 'darwin',
     arch: 'arm64',
-    officialMajorVersion: '3.6',
-    verifiedCursorVersion: '3.6.31',
+    cursorVersion: '3.7',
+    cursorCommit: '*',
+    supportStatus: 'supported',
+    targetRelativePath: CURSOR_AGENT_EXEC_RELATIVE_PATH,
+    expectedSha256: '*',
+    structureSignature: 'ep1-cursor-3-7-family',
+    patchStrategy: 'cursor-agent-exec-snippet',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'external-backup',
+    minCliVersion: '0.5.9',
+    minExtensionVersion: '0.5.9',
+    minServiceVersion: '0.5.9',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: true,
+    userMessage: 'Cursor 3.7.x is supported for MVP-0.',
+  },
+  {
+    platform: 'linux',
+    arch: 'x64',
     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.',
-  }),
+    supportStatus: 'supported',
+    targetRelativePath: 'usr/share/cursor/resources/app/extensions/cursor-agent-exec/dist/main.js',
+    expectedSha256: '05bfa29eacb8271c378765ead4bf881f806b97549dd13367183aa7a9331c1131',
+    structureSignature: 'linux-appimage-3-6-31-cursor-agent-exec',
+    patchStrategy: 'cursor-agent-exec-snippet',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'external-backup',
+    minCliVersion: '0.5.7',
+    minExtensionVersion: '0.5.7',
+    minServiceVersion: '0.5.7',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: false,
+    userMessage: 'Cursor 3.6.31 Linux x64 AppImage is supported.',
+  },
 ];
 
 export type ResolveCompatOptions = {
   entries?: CompatibilityManifestEntry[];
-  adapterVersion?: string;
 };
 
 export type CompatManifestFetchResponse = {
@@ -220,34 +178,6 @@ 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');
@@ -263,23 +193,12 @@ 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'),
@@ -301,10 +220,8 @@ function canonicalRuleSegment(rule: RemoteCompatibilityManifestRule) {
     rule.platform,
     rule.arch,
     rule.cursorVersion,
-    rule.verifiedCursorVersion ?? '',
     rule.cursorCommit,
     rule.supportStatus,
-    rule.takeoverPlanId,
     String(rule.revision ?? 1),
   ].join(':');
 }
@@ -318,6 +235,27 @@ function safeEqualHex(left: string, right: string) {
   return timingSafeEqual(leftBuffer, rightBuffer);
 }
 
+function cursorVersionFamily(version: string) {
+  const match = version.match(/^(\d+\.\d+)(?:\.|$)/);
+  return match?.[1];
+}
+
+function compatEntryMatches(
+  candidate: CompatibilityManifestEntry,
+  cursor: CursorInfo,
+  environment: CliEnvironment,
+) {
+  if (candidate.platform !== environment.platform || candidate.arch !== environment.arch) {
+    return false;
+  }
+  const versionMatches =
+    candidate.cursorVersion === cursor.version ||
+    candidate.cursorVersion === cursorVersionFamily(cursor.version);
+  const commitMatches =
+    candidate.cursorCommit === '*' || candidate.cursorCommit === cursor.commit;
+  return versionMatches && commitMatches;
+}
+
 export function buildCompatManifestSignature(
   version: number,
   rules: RemoteCompatibilityManifestRule[],
@@ -356,11 +294,6 @@ 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`;
 }
@@ -407,12 +340,7 @@ export function resolveCompatEntry(
 ) {
   const entries = options.entries ?? DEFAULT_COMPAT_ENTRIES;
   const entry = entries.find(
-    (candidate) =>
-      candidate.platform === environment.platform &&
-      candidate.arch === environment.arch &&
-      candidate.cursorVersion === officialCursorMajorVersion(cursor.version) &&
-      candidate.cursorCommit === cursor.commit &&
-      (!options.adapterVersion || candidate.adapterVersion === options.adapterVersion),
+    (candidate) => compatEntryMatches(candidate, cursor, environment),
   );
 
   if (!entry) {

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.8',
+    version: typeof sourceManifest.version === 'string' ? sourceManifest.version : '0.5.9',
     displayName: 'Cursor Pool 平台模式',
     publisher: 'cursor-pool',
     type: sourceManifest.type,

package/src/extensionLink.ts

@@ -4,8 +4,7 @@ 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.8';
-const LINKED_EXTENSION_DIRNAME_PREFIX = 'cursor-pool.extension-';
+export const LINKED_EXTENSION_DIRNAME = 'cursor-pool.extension-0.5.9';
 const RUNTIME_EXTENSION_ID = 'cursor-pool.cursorpool';
 const STALE_EXTENSION_IDS = new Set([
   RUNTIME_EXTENSION_ID,
@@ -49,17 +48,10 @@ 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.8';
+  const version = typeof manifest.version === 'string' ? manifest.version : '0.5.9';
   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))) {
@@ -71,13 +63,11 @@ 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 ?? '') &&
-      !relativeLocation.startsWith(LINKED_EXTENSION_DIRNAME_PREFIX) &&
+      entry.relativeLocation !== LINKED_EXTENSION_DIRNAME &&
       entry.relativeLocation !== 'keg1255.cursorpool-1.0.52'
     );
   });
@@ -89,7 +79,7 @@ export async function refreshCursorExtensionsIndex(cursorExtensionsDir: string,
       path: linkedPath,
       scheme: 'file',
     },
-    relativeLocation,
+    relativeLocation: LINKED_EXTENSION_DIRNAME,
     version: manifest.version,
   });
   await writeFile(indexPath, `${JSON.stringify(nextEntries, null, 2)}\n`, 'utf8');
@@ -102,23 +92,15 @@ function assertSafeLinkedExtensionPath(linkedPath: string) {
     (segment) => segment === 'extensions' || segment === 'Extensions',
   );
 
-  if (!basename(resolvedLinkedPath).startsWith(LINKED_EXTENSION_DIRNAME_PREFIX) || !hasExtensionsParent) {
+  if (basename(resolvedLinkedPath) !== LINKED_EXTENSION_DIRNAME || !hasExtensionsParent) {
     throw new Error(
-      `Unsafe linked extension path for recursive removal: ${linkedPath}. Expected an extensions/${LINKED_EXTENSION_DIRNAME_PREFIX}<version> bundle path.`,
+      `Unsafe linked extension path for recursive removal: ${linkedPath}. Expected an extensions/${LINKED_EXTENSION_DIRNAME} bundle path.`,
     );
   }
 }
 
 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),
-  );
+  return join(resolve(resolveExtensionInstallPath(cursorExtensionsDir)), LINKED_EXTENSION_DIRNAME);
 }
 
 export async function getLinkedExtensionState(linkedPath: string | undefined): Promise<LinkedExtensionState> {
@@ -137,10 +119,7 @@ export async function linkExtensionBundle({
   cursorExtensionsDir,
 }: LinkExtensionBundleOptions): Promise<LinkExtensionBundleResult> {
   const resolvedSourceBundlePath = resolveExtensionInstallPath(sourceBundlePath);
-  const linkedPath =
-    (await getLinkedExtensionState(resolvedSourceBundlePath)) === 'missing'
-      ? linkedExtensionPathForDir(cursorExtensionsDir)
-      : await linkedExtensionPathForSource(cursorExtensionsDir, resolvedSourceBundlePath);
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
 
   if ((await getLinkedExtensionState(resolvedSourceBundlePath)) === 'missing') {
     return { state: 'missing', linkedPath };

package/src/install.ts

@@ -7,18 +7,16 @@ import {
   restoreCursorAgentExec,
   restoreCursorAlwaysLocal,
   restoreCursorWorkbenchAuthGate,
-  containsCursorWorkbenchAuthGateMarker,
 } from '@cursor-pool/patcher';
 import { sha256File } from '@cursor-pool/patcher/hash';
 import { startServer } from '@cursor-pool/service';
-import { assertBundledTakeoverPlan } from '@cursor-pool/takeover-plans';
 import {
   readRuntimeInfo,
   resolveRuntimeFile,
   writeRuntimeInfo,
   type RuntimeInfo,
 } from '@cursor-pool/service';
-import type { CompatibilityManifestEntry, CompatibilityPatchTarget } from '@cursor-pool/shared/manifest';
+import type { CompatibilityManifestEntry } from '@cursor-pool/shared/manifest';
 import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
 import { writeClientConfig } from '@cursor-pool/shared/clientConfig';
 import { containsCursorPoolMarker } from '@cursor-pool/patcher/marker';
@@ -34,7 +32,6 @@ import {
 import {
   getLinkedExtensionState,
   linkExtensionBundle,
-  linkedExtensionPathForSource,
   linkedExtensionPathForDir,
   refreshCursorExtensionsIndex,
   removeLinkedExtensionBundle,
@@ -107,7 +104,7 @@ export type InstallOptions = FindCursorOptions &
   };
 
 const REAL_CURSOR_EXTENSIONS_DIR = '~/.cursor/extensions';
-const PACKAGE_VERSION = '0.5.8';
+const PACKAGE_VERSION = '0.5.9';
 const AUTOSTART_SERVICE_STARTUP_TIMEOUT_MS = 30_000;
 
 function delay(ms: number) {
@@ -133,57 +130,17 @@ async function maybeAdHocResign({
   return 'ad-hoc' as const;
 }
 
-function markerPredicateForPatchTarget(target: CompatibilityPatchTarget) {
-  if (target.name === 'workbench' || target.verifyMarker === 'cursor-pool-workbench') {
-    return containsCursorWorkbenchAuthGateMarker;
-  }
-  return containsCursorPoolMarker;
-}
-
-async function assertExpectedHash(
-  targetPath: string,
-  expectedSha256: string,
-  containsExpectedMarker = containsCursorPoolMarker,
-) {
+async function assertExpectedHash(targetPath: string, expectedSha256: string) {
   const currentHash = await sha256File(targetPath);
   if (currentHash !== expectedSha256) {
     const content = await readFile(targetPath, 'utf8');
-    if (containsExpectedMarker(content)) {
+    if (containsCursorPoolMarker(content)) {
       return;
     }
     throw new Error(`Patch target hash mismatch: expected ${expectedSha256}, got ${currentHash}`);
   }
 }
 
-function compatPatchTargets(compat: CompatibilityManifestEntry): CompatibilityPatchTarget[] {
-  if (compat.patchTargets?.length) {
-    return compat.patchTargets;
-  }
-  return [
-    {
-      name: 'agent-exec',
-      targetRelativePath: compat.targetRelativePath,
-      expectedSha256: compat.expectedSha256,
-      patchStrategy: compat.patchStrategy,
-      verifyMarker: compat.verifyMarker,
-    },
-  ];
-}
-
-function workbenchTargetRelativePathFromCompat(compat: CompatibilityManifestEntry) {
-  return compat.patchTargets?.find((target) => target.name === 'workbench')?.targetRelativePath;
-}
-
-async function assertExpectedPatchTargetHashes(appPath: string, compat: CompatibilityManifestEntry) {
-  for (const target of compatPatchTargets(compat)) {
-    await assertExpectedHash(
-      join(appPath, target.targetRelativePath),
-      target.expectedSha256,
-      markerPredicateForPatchTarget(target),
-    );
-  }
-}
-
 async function startServiceFromAutostart(options: InstallOptions, targetMode: 'real' | 'disposable') {
   const autostart = await installAutostart(options, targetMode);
   const runtimeFile = options.runtimeFile ?? DEFAULT_RUNTIME_FILE;
@@ -418,12 +375,11 @@ async function linkInstallExtensionBundle({
   sourceBundlePath: string;
   cursorExtensionsDir: string;
 }): ReturnType<typeof linkExtensionBundle> {
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
   if ((await getLinkedExtensionState(sourceBundlePath)) === 'missing') {
-    const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
     return { state: 'missing', linkedPath };
   }
 
-  const linkedPath = await linkedExtensionPathForSource(cursorExtensionsDir, sourceBundlePath);
   await removeInstallLinkedExtensionBundle(linkedPath, cursorExtensionsDir);
   await mkdir(dirname(linkedPath), { recursive: true });
   await cp(sourceBundlePath, linkedPath, { recursive: true });
@@ -447,19 +403,15 @@ export async function install(options: InstallOptions = {}) {
     compatManifestUrl: options.compatManifestUrl,
     fetchManifest: options.fetchCompatManifest,
   });
-  const adapterVersion = PACKAGE_VERSION === '0.5.8'
-    ? undefined
-    : PACKAGE_VERSION.split('-', 1)[0].split('+', 1)[0];
-  const compat = resolveCompatEntry(cursor, environment, { entries: compatEntries, adapterVersion });
-  assertBundledTakeoverPlan(compat.takeoverPlanId);
-  const workbenchTargetRelativePath = workbenchTargetRelativePathFromCompat(compat);
+  const compat = resolveCompatEntry(cursor, environment, { entries: compatEntries });
   const targetPath = join(cursor.appPath, compat.targetRelativePath);
   const originalSha256 = await sha256File(targetPath);
-  await assertExpectedPatchTargetHashes(cursor.appPath, compat);
+  if (compat.expectedSha256 !== '*') {
+    await assertExpectedHash(targetPath, compat.expectedSha256);
+  }
   const patchSetBeforeInstall = await readCursorPatchSetState(cursor.appPath, {
     agentExecTargetRelativePath: compat.targetRelativePath,
     platform: environment.platform,
-    workbenchTargetRelativePath,
   });
   const wasPatchedBeforeInstall = patchSetBeforeInstall.allApplied;
   const existingTrialRecord = await readTrialRecord(cursor.appPath, {
@@ -551,7 +503,6 @@ export async function install(options: InstallOptions = {}) {
       backupDir: options.backupDir,
       platform: environment.platform,
       agentExecTargetRelativePath: compat.targetRelativePath,
-      workbenchTargetRelativePath,
       patchCursorAgentExec: options.patchCursorAgentExec,
       patchCursorWorkbenchAuthGate: options.patchCursorWorkbenchAuthGate,
     });
@@ -581,7 +532,6 @@ export async function install(options: InstallOptions = {}) {
       appPath: cursor.appPath,
       cursorVersion: cursor.version,
       cursorCommit: cursor.commit,
-      takeoverPlanId: compat.takeoverPlanId,
       targetRelativePath: compat.targetRelativePath,
       originalSha256,
       compatSupportStatus: compat.supportStatus,
@@ -626,7 +576,6 @@ export async function install(options: InstallOptions = {}) {
       `mode: ${target.mode}`,
       `app: ${cursor.appPath}`,
       `compat: ${compat.supportStatus}`,
-      `takeover-plan: ${compat.takeoverPlanId}`,
       `extension: ${extension.state}`,
       `service: running ${service.host}:${service.port}`,
       `autostart: ${autostartState}`,
@@ -646,7 +595,6 @@ export async function install(options: InstallOptions = {}) {
           (await readCursorPatchSetState(cursor.appPath, {
             agentExecTargetRelativePath: compat.targetRelativePath,
             platform: environment.platform,
-            workbenchTargetRelativePath,
           })).appliedCount > 0);
     } catch (rollbackError) {
       rollbackErrors.push(rollbackError);
@@ -656,7 +604,6 @@ export async function install(options: InstallOptions = {}) {
         await restoreCursorSet(cursor.appPath, {
           backupDir: options.backupDir,
           platform: environment.platform,
-          workbenchTargetRelativePath,
           restoreCursorAgentExec: options.restoreCursorAgentExec,
           restoreCursorAlwaysLocal: options.restoreCursorAlwaysLocal,
           restoreCursorWorkbenchAuthGate: options.restoreCursorWorkbenchAuthGate,