@cursorpool-dev/cli 0.5.8 → 0.5.10

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.10';
 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);
@@ -655,8 +603,8 @@ export async function install(options: InstallOptions = {}) {
       try {
         await restoreCursorSet(cursor.appPath, {
           backupDir: options.backupDir,
+          agentExecTargetRelativePath: compat.targetRelativePath,
           platform: environment.platform,
-          workbenchTargetRelativePath,
           restoreCursorAgentExec: options.restoreCursorAgentExec,
           restoreCursorAlwaysLocal: options.restoreCursorAlwaysLocal,
           restoreCursorWorkbenchAuthGate: options.restoreCursorWorkbenchAuthGate,

package/src/installRecord.ts

@@ -13,7 +13,6 @@ export type InstallRecord = {
   appPath: string;
   cursorVersion: string;
   cursorCommit: string;
-  takeoverPlanId: string;
   targetRelativePath: string;
   originalSha256: string;
   compatSupportStatus: CompatibilityManifestEntry['supportStatus'];
@@ -92,7 +91,6 @@ export function isInstallRecordStale(record: InstallRecord | null, actual: Insta
     'appPath',
     'cursorVersion',
     'cursorCommit',
-    'takeoverPlanId',
     'targetRelativePath',
     'originalSha256',
     'compatSupportStatus',

package/src/patchSet.ts

@@ -54,13 +54,43 @@ const LINUX_WORKBENCH_RELATIVE_PATH =
   'usr/share/cursor/resources/app/out/vs/workbench/workbench.desktop.main.js';
 const LINUX_ALWAYS_LOCAL_RELATIVE_PATH =
   'usr/share/cursor/resources/app/extensions/cursor-always-local/dist/main.js';
+const LINUX_DEB_WORKBENCH_RELATIVE_PATH =
+  'resources/app/out/vs/workbench/workbench.desktop.main.js';
+const LINUX_DEB_ALWAYS_LOCAL_RELATIVE_PATH =
+  'resources/app/extensions/cursor-always-local/dist/main.js';
 
-function workbenchRelativePath(options: { platform?: NodeJS.Platform; workbenchTargetRelativePath?: string }) {
-  return options.workbenchTargetRelativePath ?? (options.platform === 'linux' ? LINUX_WORKBENCH_RELATIVE_PATH : CURSOR_WORKBENCH_RELATIVE_PATH);
+function linuxUsesDebRoot(options: { agentExecTargetRelativePath?: string }) {
+  return options.agentExecTargetRelativePath?.startsWith('resources/app/') ?? false;
 }
 
-function alwaysLocalRelativePath(options: { platform?: NodeJS.Platform; alwaysLocalTargetRelativePath?: string }) {
-  return options.alwaysLocalTargetRelativePath ?? (options.platform === 'linux' ? LINUX_ALWAYS_LOCAL_RELATIVE_PATH : CURSOR_ALWAYS_LOCAL_RELATIVE_PATH);
+function workbenchRelativePath(options: {
+  platform?: NodeJS.Platform;
+  agentExecTargetRelativePath?: string;
+  workbenchTargetRelativePath?: string;
+}) {
+  if (options.workbenchTargetRelativePath) {
+    return options.workbenchTargetRelativePath;
+  }
+  if (options.platform === 'linux') {
+    return linuxUsesDebRoot(options) ? LINUX_DEB_WORKBENCH_RELATIVE_PATH : LINUX_WORKBENCH_RELATIVE_PATH;
+  }
+  return CURSOR_WORKBENCH_RELATIVE_PATH;
+}
+
+function alwaysLocalRelativePath(options: {
+  platform?: NodeJS.Platform;
+  agentExecTargetRelativePath?: string;
+  alwaysLocalTargetRelativePath?: string;
+}) {
+  if (options.alwaysLocalTargetRelativePath) {
+    return options.alwaysLocalTargetRelativePath;
+  }
+  if (options.platform === 'linux') {
+    return linuxUsesDebRoot(options)
+      ? LINUX_DEB_ALWAYS_LOCAL_RELATIVE_PATH
+      : LINUX_ALWAYS_LOCAL_RELATIVE_PATH;
+  }
+  return CURSOR_ALWAYS_LOCAL_RELATIVE_PATH;
 }
 
 async function fileContainsMarker(
@@ -143,11 +173,12 @@ export async function patchCursorSet(appPath: string, options: PatchCursorSetOpt
 }
 
 export async function restoreCursorSet(appPath: string, options: RestoreCursorSetOptions = {}) {
-  const restoreErrors: unknown[] = [];
   const before = await readCursorPatchSetState(appPath, {
+    agentExecTargetRelativePath: options.agentExecTargetRelativePath,
     platform: options.platform,
     workbenchTargetRelativePath: options.workbenchTargetRelativePath,
   });
+  const restoreErrors: unknown[] = [];
   const restore = async (operation: () => Promise<unknown>) => {
     try {
       await operation();
@@ -156,14 +187,12 @@ export async function restoreCursorSet(appPath: string, options: RestoreCursorSe
     }
   };
 
-  if (before.patches.some((patch) => patch.name === 'workbench' && patch.markerPresent)) {
-    await restore(() =>
-      (options.restoreCursorWorkbenchAuthGate ?? restoreCursorWorkbenchAuthGate)(appPath, {
-        backupDir: options.backupDir,
-        targetRelativePath: workbenchRelativePath(options),
-      }),
-    );
-  }
+  await restore(() =>
+    (options.restoreCursorWorkbenchAuthGate ?? restoreCursorWorkbenchAuthGate)(appPath, {
+      backupDir: options.backupDir,
+      targetRelativePath: workbenchRelativePath(options),
+    }),
+  );
   const alwaysLocalPath = resolveCursorAlwaysLocalPath(appPath, alwaysLocalRelativePath(options));
   const shouldRestoreAlwaysLocal =
     Boolean(options.restoreCursorAlwaysLocal) ||
@@ -179,10 +208,17 @@ export async function restoreCursorSet(appPath: string, options: RestoreCursorSe
   await restore(() =>
     (options.restoreCursorAgentExec ?? restoreCursorAgentExec)(appPath, {
       backupDir: options.backupDir,
+      targetRelativePath: options.agentExecTargetRelativePath,
     }),
   );
 
   if (restoreErrors.length > 0) {
     throw new AggregateError(restoreErrors, 'Failed to restore one or more Cursor patches.');
   }
+  const after = await readCursorPatchSetState(appPath, {
+    agentExecTargetRelativePath: options.agentExecTargetRelativePath,
+    platform: options.platform,
+    workbenchTargetRelativePath: options.workbenchTargetRelativePath,
+  });
+  return { before, after };
 }

package/src/platform.ts

@@ -82,9 +82,9 @@ function buildDeviceInfo() {
     name: hostname(),
     os: osPlatform(),
     arch: arch(),
-    cliVersion: '0.5.8',
-    serviceVersion: '0.5.8',
-    extensionVersion: '0.5.8',
+    cliVersion: '0.5.10',
+    serviceVersion: '0.5.10',
+    extensionVersion: '0.5.10',
   };
 }
 

package/src/repair.ts

@@ -69,7 +69,7 @@ export type RepairOptions = FindCursorOptions &
     adHocResignApp?: typeof adHocResignApp;
   };
 
-const PACKAGE_VERSION = '0.5.8';
+const PACKAGE_VERSION = '0.5.10';
 
 function normalizeAppPath(path: string) {
   return normalize(path).replace(/\/+$/, '');
@@ -96,10 +96,6 @@ function assertRealRepairInstallRecord(
   return record;
 }
 
-function workbenchTargetRelativePathFromCompat(compat: CompatibilityManifestEntry) {
-  return compat.patchTargets?.find((target) => target.name === 'workbench')?.targetRelativePath;
-}
-
 function resolveRepairCompatEntry({
   cursorVersion,
   cursorCommit,
@@ -114,12 +110,14 @@ function resolveRepairCompatEntry({
   entries?: CompatibilityManifestEntry[];
 }) {
   const compatEntries = entries ?? DEFAULT_COMPAT_ENTRIES;
+  const versionFamily = cursorVersion.match(/^(\d+\.\d+)(?:\.|$)/)?.[1];
   const entry = compatEntries.find(
     (candidate) =>
       candidate.platform === platform &&
       candidate.arch === arch &&
-      candidate.cursorVersion === cursorVersion &&
-      candidate.cursorCommit === cursorCommit,
+      (candidate.cursorVersion === cursorVersion ||
+        candidate.cursorVersion === versionFamily) &&
+      (candidate.cursorCommit === '*' || candidate.cursorCommit === cursorCommit),
   );
 
   if (!entry) {
@@ -200,13 +198,13 @@ async function maybeAdHocResign({
 }
 
 export async function repair(options: RepairOptions = {}) {
-  const target = resolveCursorTarget(options);
+  const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
   if (target.mode !== 'real') {
     throw new Error('repair is only supported for real Cursor installs in MVP-1');
   }
 
   const cursor = await findCursor({ ...options, appPath: target.appPath });
-  const environment = detectEnvironment(options);
   const compatEntries = await loadCompatEntries({
     compatEntries: options.compatEntries,
     apiBaseUrl: options.apiBaseUrl,
@@ -227,7 +225,6 @@ export async function repair(options: RepairOptions = {}) {
   if (compat.supportStatus === 'blocked' || compat.supportStatus === 'unknown') {
     throw new Error(`compat: ${compat.supportStatus}`);
   }
-  const workbenchTargetRelativePath = workbenchTargetRelativePathFromCompat(compat);
   const targetPath = join(cursor.appPath, compat.targetRelativePath);
   const runtimeFile = options.runtimeFile ?? installRecord.runtimeFile ?? DEFAULT_RUNTIME_FILE;
   const backupDir = options.backupDir ?? installRecord.backupDir;
@@ -261,6 +258,7 @@ export async function repair(options: RepairOptions = {}) {
       installRecord.originalSha256 && patchState.currentHash === installRecord.originalSha256;
     if (
       !patchState.legacyMarkerPresent &&
+      compat.expectedSha256 !== '*' &&
       patchState.currentHash !== compat.expectedSha256 &&
       !matchesInstallOriginal
     ) {
@@ -327,9 +325,8 @@ export async function repair(options: RepairOptions = {}) {
   }
 
   const patchSetState = await readCursorPatchSetState(cursor.appPath, {
-    agentExecTargetRelativePath: compat.targetRelativePath,
     platform: environment.platform,
-    workbenchTargetRelativePath,
+    agentExecTargetRelativePath: compat.targetRelativePath,
   });
 
   if (patchSetState.allApplied) {
@@ -340,7 +337,6 @@ export async function repair(options: RepairOptions = {}) {
       backupDir,
       platform: environment.platform,
       agentExecTargetRelativePath: compat.targetRelativePath,
-      workbenchTargetRelativePath,
       patchCursorAgentExec: options.patchCursorAgentExec,
       patchCursorWorkbenchAuthGate: options.patchCursorWorkbenchAuthGate,
     });

package/src/restore.ts

@@ -7,6 +7,7 @@ import {
   type ConfirmRealOperationOptions,
 } from './confirm';
 import { findCursor, type FindCursorOptions } from './cursor';
+import { detectEnvironment, type DetectEnvironmentOptions } from './environment';
 import {
   installIdForAppPath,
   readInstallRecord,
@@ -14,15 +15,12 @@ import {
   type InstallRecordOptions,
 } from './installRecord';
 import { stopRuntimeService } from './serviceProcess';
-import {
-  formatCursorPatchSetState,
-  readCursorPatchSetState,
-  restoreCursorSet,
-} from './patchSet';
 import { resolveCursorTarget, type CursorTargetOptions } from './target';
 import { assertDisposableCursorAppPath, readTrialRecord, type TrialRecordOptions } from './trial';
+import { formatCursorPatchSetState, restoreCursorSet } from './patchSet';
 
 export type RestoreOptions = FindCursorOptions &
+  DetectEnvironmentOptions &
   CursorTargetOptions &
   TrialRecordOptions &
   InstallRecordOptions & {
@@ -90,9 +88,12 @@ function formatRestoreConfirmation({
 }
 
 export async function restore(options: RestoreOptions = {}) {
-  const target = resolveCursorTarget(options);
+  const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
   const appPath =
-    target.mode === 'disposable' ? assertDisposableCursorAppPath(target.appPath) : target.appPath;
+    target.mode === 'disposable'
+      ? assertDisposableCursorAppPath(target.appPath, { platform: environment.platform })
+      : target.appPath;
   const cursor = await findCursor({ ...options, appPath });
   const installRecord =
     target.mode === 'real'
@@ -137,12 +138,10 @@ export async function restore(options: RestoreOptions = {}) {
     });
   }
 
-  await restoreCursorSet(cursor.appPath, {
+  const result = await restoreCursorSet(cursor.appPath, {
     backupDir,
     agentExecTargetRelativePath: targetRelativePath,
-  });
-  const patchSetState = await readCursorPatchSetState(cursor.appPath, {
-    agentExecTargetRelativePath: targetRelativePath,
+    platform: environment.platform,
   });
   if (target.mode === 'real') {
     await stopRuntimeServiceIfRecorded(runtimeFile);
@@ -153,7 +152,7 @@ export async function restore(options: RestoreOptions = {}) {
     `mode: ${target.mode}`,
     `app: ${cursor.appPath}`,
     'restore: ok',
-    `patch: ${formatCursorPatchSetState(patchSetState)}`,
+    `patch: ${formatCursorPatchSetState(result.after)}`,
     target.mode === 'real'
       ? `install-record: ${realInstallRecord ? 'recorded' : 'missing'}`
       : `trial: ${trialRecord ? 'recorded' : 'missing'}`,

package/src/status.ts

@@ -49,10 +49,6 @@ type LatestTakeoverResponse = {
   };
 };
 
-function workbenchTargetRelativePathFromCompat(compat: CompatibilityManifestEntry) {
-  return compat.patchTargets?.find((target) => target.name === 'workbench')?.targetRelativePath;
-}
-
 const MAX_CANARY_FIELD_LENGTH = 256;
 
 function isSafeCanaryString(value: unknown): value is string {
@@ -150,10 +146,12 @@ async function getTakeoverStatus(
 }
 
 export async function status(options: StatusOptions = {}) {
-  const target = resolveCursorTarget(options);
-  const appPath =
-    target.mode === 'disposable' ? assertDisposableCursorAppPath(target.appPath) : target.appPath;
   const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
+  const appPath =
+    target.mode === 'disposable'
+      ? assertDisposableCursorAppPath(target.appPath, { platform: environment.platform })
+      : target.appPath;
   const cursor = await findCursor({ ...options, appPath });
   const compatEntries = await loadCompatEntries({
     compatEntries: options.compatEntries,
@@ -162,7 +160,6 @@ export async function status(options: StatusOptions = {}) {
     fetchManifest: options.fetchCompatManifest,
   });
   const compat = resolveCompatEntry(cursor, environment, { entries: compatEntries });
-  const workbenchTargetRelativePath = workbenchTargetRelativePathFromCompat(compat);
   const installRecord =
     target.mode === 'real'
       ? await readInstallRecord({ installRecordFile: options.installRecordFile })
@@ -194,7 +191,6 @@ export async function status(options: StatusOptions = {}) {
   const patchSetState = await readCursorPatchSetState(cursor.appPath, {
     agentExecTargetRelativePath: compat.targetRelativePath,
     platform: environment.platform,
-    workbenchTargetRelativePath,
   });
   const serviceRunning = await isRuntimeHealthy(runtime);
   const takeoverStatus = await getTakeoverStatus(runtime, serviceRunning);

package/src/target.ts

@@ -20,8 +20,20 @@ export type CursorTarget =
       requiresConfirmation: true;
     };
 
+function isLinuxRealCursorPath(appPath: string, platform: NodeJS.Platform | undefined) {
+  return platform === 'linux' && appPath.replace(/\/+$/, '') === '/usr/share/cursor';
+}
+
 export function resolveCursorTarget(options: CursorTargetOptions = {}): CursorTarget {
   if (options.appPath) {
+    if (isLinuxRealCursorPath(options.appPath, options.platform)) {
+      return {
+        mode: 'real',
+        appPath: options.appPath.replace(/\/+$/, ''),
+        requiresConfirmation: true,
+      };
+    }
+
     return {
       mode: 'disposable',
       appPath: assertDisposableCursorAppPath(options.appPath, { platform: options.platform }),

package/src/trial.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join, normalize } from 'node:path';
+import { dirname, join, normalize, resolve } from 'node:path';
 import { DEFAULT_MACOS_CURSOR_APP_PATH } from './cursor';
 
 export type ExtensionState = 'bundled' | 'linked' | 'manual-step-required' | 'missing';
@@ -12,7 +12,6 @@ export type TrialRecord = {
   appPath: string;
   cursorVersion: string;
   cursorCommit: string;
-  takeoverPlanId: string;
   targetRelativePath: string;
   originalSha256: string;
   compatSupportStatus: 'supported' | 'canary' | 'warning' | 'blocked' | 'unknown';
@@ -40,7 +39,7 @@ function resolveHomePath(path: string) {
 }
 
 function normalizeAppPath(path: string) {
-  return normalize(path).replace(/\/+$/, '');
+  return resolve(normalize(path).replace(/\/+$/, ''));
 }
 
 function isRealCursorAppPath(path: string) {

package/src/uninstall.ts

@@ -28,6 +28,7 @@ import { restore } from './restore';
 import type { RestoreOptions } from './restore';
 import { stopRuntimeService } from './serviceProcess';
 import { removeUserAutostart } from './autostart';
+import { detectEnvironment } from './environment';
 import { resolveCursorTarget, type CursorTargetOptions } from './target';
 import {
   assertDisposableCursorAppPath,
@@ -107,9 +108,12 @@ async function removeRecordedLinkedExtensionBundle(
 }
 
 export async function uninstall(options: UninstallOptions = {}) {
-  const target = resolveCursorTarget(options);
+  const environment = detectEnvironment(options);
+  const target = resolveCursorTarget({ ...options, platform: environment.platform });
   const appPath =
-    target.mode === 'disposable' ? assertDisposableCursorAppPath(target.appPath) : target.appPath;
+    target.mode === 'disposable'
+      ? assertDisposableCursorAppPath(target.appPath, { platform: environment.platform })
+      : target.appPath;
   const cursor = await findCursor({ ...options, appPath });
   const installRecord =
     target.mode === 'real'