@cursorpool-dev/cli 0.5.6

package/test/status.test.ts

@@ -0,0 +1,615 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { createServer, type Server } from 'node:http';
+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 { CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR } from '../../patcher/src/marker';
+import { patchCursorAgentExec } from '../../patcher/src/patchCursorAgentExec';
+import { patchCursorAlwaysLocal } from '../../patcher/src/patchCursorAlwaysLocal';
+import { patchCursorWorkbenchAuthGate } from '../../patcher/src/patchCursorWorkbenchAuthGate';
+import { startServer } from '../../service/src/server';
+import { writeRuntimeInfo } from '../../service/src/runtime';
+import type { CompatibilityManifestEntry } from '../../shared/src/manifest';
+import { bundleExtension } from '../src/extensionBundle';
+import { linkExtensionBundle, linkedExtensionPathForDir } from '../src/extensionLink';
+import {
+  installIdForAppPath,
+  writeInstallRecord,
+  type InstallRecord,
+} from '../src/installRecord';
+import { status } from '../src/status';
+import { trialIdForAppPath, writeTrialRecord } from '../src/trial';
+
+const targetRelativePath =
+  'Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js';
+const alwaysLocalRelativePath =
+  'Contents/Resources/app/extensions/cursor-always-local/dist/main.js';
+const workbenchRelativePath = 'Contents/Resources/app/out/vs/workbench/workbench.desktop.main.js';
+const composerAuthGateAnchor =
+  'get when(){return p()&&!fzC},get fallback(){return he(DGC,{})}';
+const composerSubmitAuthGateAnchor =
+  'if(!p()){e.cursorAuthenticationService.login(),e.commandService.executeCommand(wV,"general");return}';
+const agentLoopRunAnchor = 'await this.agentClientService.run(te,H,$e,Ne,Ce,T,ze,me,we,[],ct)';
+const buildFlagsLocalModeAnchor = 'localMode:!1';
+const localProviderConfigAnchor =
+  'async getLocalAgentProviderConfig(e){const t="[AgentClientService][getLocalAgentProviderConfig]",i=L0.localMode?await this.shellEnvironmentService.getShellEnv():{},r=e?.credentials,s=r?.case==="apiKeyCredentials"?r.value:void 0,o=this.reactiveStorageService.applicationUserPersistentStorage,a=o.useOpenAIKey===!0?this.cursorAuthenticationService.openAIKey()??void 0:void 0,u=xgS({apiKeyCandidates:[{value:s?.apiKey,source:"modelDetails.apiKeyCredentials.apiKey"},{value:a,source:"storage.openAIKey"}],baseUrlCandidates:[{value:s?.baseUrl,source:"modelDetails.apiKeyCredentials.baseUrl"},{value:o.openAIBaseUrl,source:"storage.openAIBaseUrl"}]});return{baseUrl:u.baseUrl,apiKey:u.apiKey}}createDefaultLocalModel(e){return "default"}';
+const agentClientRunLocalModeAnchor =
+  'if(L0.localMode){try{g.onNetworkPhaseStart?.()}catch(b){this.logService.warn("[AgentClientService] onNetworkPhaseStart callback failed in local mode",b)}return this.runLocalAgentInExtensionHost(e,t,i,r,s,a,d,h,g)}return this.client.run(e,t,i,r,s,o,a,u,d,h,g)';
+
+function workbenchFixture() {
+  return [
+    `function composer(){return he(Mt,{${composerAuthGateAnchor},get children(){return "controls"}})}`,
+    `async function submit(){${composerSubmitAuthGateAnchor};return "submitted";}`,
+    `const flags={${buildFlagsLocalModeAnchor}}`,
+    localProviderConfigAnchor,
+    `async function runAgentLoop(){${agentLoopRunAnchor}}`,
+    `async function agentClientRun(){const g={};${agentClientRunLocalModeAnchor}}`,
+  ].join(';');
+}
+
+async function patchFullSet(appPath: string, backupDir: string) {
+  await patchCursorAgentExec(appPath, { backupDir });
+  await patchCursorAlwaysLocal(appPath, { backupDir });
+  await patchCursorWorkbenchAuthGate(appPath, { backupDir });
+}
+
+async function listen(server: Server) {
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+
+  const address = server.address();
+  assert.equal(typeof address, 'object');
+  assert.ok(address);
+  return address.port;
+}
+
+async function close(server: Server) {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+}
+
+async function startStatusRuntime(
+  latestTakeover: unknown,
+  runtimeId = 'status-runtime',
+) {
+  const server = createServer((request, response) => {
+    if (request.method === 'GET' && request.url === '/health') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ ok: true, runtimeId }));
+      return;
+    }
+
+    if (request.method === 'GET' && request.url === '/agent/takeover/latest') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(JSON.stringify(latestTakeover));
+      return;
+    }
+
+    if (request.method === 'GET' && request.url === '/platform/status') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ state: 'logged-out' }));
+      return;
+    }
+
+    response.writeHead(404, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: false }));
+  });
+  const port = await listen(server);
+
+  return { server, port, runtimeId };
+}
+
+async function createFixtureApp() {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-cli-status-'));
+  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`;
+  await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-agent-exec/dist'), {
+    recursive: true,
+  });
+  await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-always-local/dist'), {
+    recursive: true,
+  });
+  await mkdir(join(appPath, 'Contents/Resources/app/out/vs/workbench'), {
+    recursive: true,
+  });
+  await writeFile(
+    join(appPath, 'Contents/Resources/app/product.json'),
+    JSON.stringify({
+      version: '3.5.38',
+      commit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    }),
+    'utf8',
+  );
+  await writeFile(targetPath, targetContent, 'utf8');
+  await writeFile(join(appPath, alwaysLocalRelativePath), 'function alwaysLocal(){}\n', 'utf8');
+  await writeFile(join(appPath, workbenchRelativePath), workbenchFixture(), 'utf8');
+
+  const compatEntry: CompatibilityManifestEntry = {
+    platform: process.platform,
+    arch: process.arch,
+    cursorVersion: '3.5.38',
+    cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    supportStatus: 'supported',
+    targetRelativePath,
+    expectedSha256: createHash('sha256').update(targetContent).digest('hex'),
+    structureSignature: 'fixture',
+    patchStrategy: 'cursor-agent-exec-snippet',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'external-backup',
+    minCliVersion: '0.0.0',
+    minExtensionVersion: '0.0.0',
+    minServiceVersion: '0.0.0',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: false,
+    userMessage: 'fixture supported',
+  };
+
+  return {
+    appPath,
+    tempDir,
+    runtimeFile: join(tempDir, 'runtime.json'),
+    backupDir: join(tempDir, 'backups'),
+    compatEntry,
+  };
+}
+
+test('status reports Cursor version, compatibility, patch, and runtime service state', async () => {
+  const fixture = await createFixtureApp();
+  const service = await startServer({ runtimeFile: fixture.runtimeFile });
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+
+    const output = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(output, /Cursor 3\.5\.38/);
+    assert.match(output, /mode: disposable/);
+    assert.match(output, /app: .*Cursor\.app/);
+    assert.match(output, /compat: supported/);
+    assert.match(output, /patch: applied/);
+    assert.match(output, /service: running/);
+    assert.match(output, /extension: missing/);
+    assert.match(output, /runtime: /);
+    assert.match(output, /trial: missing/);
+    assert.match(output, /takeover: missing/);
+    assert.doesNotMatch(output, /canary:|request-check:|request-gateway:/);
+  } finally {
+    await service.stop();
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status reports logged-out platform state without requiring runtime service', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+
+    const output = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      platformSessionFile: join(fixture.tempDir, 'missing-platform-session.json'),
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(output, /service: stopped/);
+    assert.match(output, /platform: logged-out/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status reports logged-in platform user, device, and heartbeat', async () => {
+  const fixture = await createFixtureApp();
+  const platformSessionFile = join(fixture.tempDir, 'platform-session.json');
+  let service: Awaited<ReturnType<typeof startServer>> | undefined;
+  const server = createServer((request, response) => {
+    if (request.method === 'GET' && request.url === '/me') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(
+        JSON.stringify({
+          user: { id: 'user-1', email: 'user@example.test' },
+          device: {
+            id: 'device-1',
+            status: 'active',
+            lastHeartbeatAt: '2026-05-30T08:00:00.000Z',
+          },
+        }),
+      );
+      return;
+    }
+
+    response.writeHead(404, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: false }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      platformSessionFile,
+      JSON.stringify({
+        apiBaseUrl: `http://127.0.0.1:${port}`,
+        deviceToken: 'device-token',
+        createdAt: '2026-05-30T00:00:00.000Z',
+        user: { id: 'old-user', email: 'old@example.test' },
+        device: {
+          id: 'old-device',
+          status: 'pending',
+          lastHeartbeatAt: '2026-05-29T00:00:00.000Z',
+        },
+      }),
+      'utf8',
+    );
+    service = await startServer({
+      runtimeFile: fixture.runtimeFile,
+      platformSessionFile,
+    });
+
+    const output = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      platformSessionFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(output, /platform: logged-in/);
+    assert.match(output, /user: user@example\.test/);
+    assert.match(output, /device: active device-1/);
+    assert.match(output, /heartbeat: 2026-05-30T08:00:00\.000Z/);
+  } finally {
+    await service?.stop();
+    await close(server);
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status uses local platform session cache without calling platform API when service is stopped', async () => {
+  const fixture = await createFixtureApp();
+  const platformSessionFile = join(fixture.tempDir, 'platform-session.json');
+  let requestedMe = false;
+  const server = createServer((request, response) => {
+    if (request.method === 'GET' && request.url === '/me') {
+      requestedMe = true;
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ ok: true }));
+      return;
+    }
+
+    response.writeHead(404, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: false }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      platformSessionFile,
+      JSON.stringify({
+        apiBaseUrl: `http://127.0.0.1:${port}`,
+        deviceToken: 'device-token',
+        createdAt: '2026-05-30T00:00:00.000Z',
+        user: { id: 'user-1', email: 'cached@example.test' },
+        device: {
+          id: 'device-1',
+          status: 'active',
+          lastHeartbeatAt: '2026-05-30T08:00:00.000Z',
+        },
+      }),
+      'utf8',
+    );
+
+    const output = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      platformSessionFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.equal(requestedMe, false);
+    assert.match(output, /service: stopped/);
+    assert.match(output, /platform: offline/);
+    assert.match(output, /user: cached@example\.test/);
+    assert.match(output, /device: active device-1/);
+  } finally {
+    await close(server);
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status reports stopped when runtime file points at an unreachable service', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await writeRuntimeInfo(
+      { host: '127.0.0.1', port: 45123, runtimeId: 'stale-runtime-fixture' },
+      { runtimeFile: fixture.runtimeFile },
+    );
+
+    const output = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(output, /patch: applied/);
+    assert.match(output, /service: stopped/);
+    assert.match(output, /extension: missing/);
+    assert.match(output, /mode: disposable/);
+    assert.match(output, /trial: missing/);
+    assert.match(output, /takeover: unavailable/);
+    assert.doesNotMatch(output, /canary:|request-check:|request-gateway:/);
+    assert.doesNotMatch(output, /service: running/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status reports latest answered takeover without sensitive response content', async () => {
+  const fixture = await createFixtureApp();
+  const runtime = await startStatusRuntime({
+    ok: true,
+    takeover: {
+      state: 'answered',
+      requestId: 'req-takeover-1',
+      source: 'cursor-agent-exec',
+      model: 'gpt-test',
+      content: '来自 Cursor Pool 本地测试 provider',
+      prompt: 'must not appear',
+    },
+  });
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await writeRuntimeInfo(
+      { host: '127.0.0.1', port: runtime.port, runtimeId: runtime.runtimeId },
+      { runtimeFile: fixture.runtimeFile },
+    );
+
+    const output = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(
+      output,
+      /takeover: answered requestId=req-takeover-1 source=cursor-agent-exec model=gpt-test content=present/,
+    );
+    assert.doesNotMatch(output, /来自 Cursor Pool 本地测试 provider|must not appear|prompt/);
+  } finally {
+    await close(runtime.server);
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status reports latest rejected takeover reason', async () => {
+  const fixture = await createFixtureApp();
+  const runtime = await startStatusRuntime({
+    ok: true,
+    takeover: {
+      state: 'rejected',
+      requestId: 'req-takeover-2',
+      reason: 'mode-released',
+    },
+  });
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await writeRuntimeInfo(
+      { host: '127.0.0.1', port: runtime.port, runtimeId: runtime.runtimeId },
+      { runtimeFile: fixture.runtimeFile },
+    );
+
+    const output = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(
+      output,
+      /takeover: rejected requestId=req-takeover-2 reason=mode-released/,
+    );
+  } finally {
+    await close(runtime.server);
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status rejects malicious takeover values before output', async () => {
+  const fixture = await createFixtureApp();
+  const runtime = await startStatusRuntime({
+    ok: true,
+    takeover: {
+      state: 'answered',
+      requestId: 'req takeover apiKey=secret',
+      source: 'cursor-agent-exec apiKey=secret',
+      model: 'sk-secret-token',
+      content: 'secret prompt leak',
+    },
+  });
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await writeRuntimeInfo(
+      { host: '127.0.0.1', port: runtime.port, runtimeId: runtime.runtimeId },
+      { runtimeFile: fixture.runtimeFile },
+    );
+
+    const output = await status({
+      appPath: fixture.appPath,
+      runtimeFile: fixture.runtimeFile,
+      trialRecordDir: join(fixture.tempDir, 'trials'),
+      extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(
+      output,
+      /takeover: answered requestId=unknown source=unknown model=unknown content=present/,
+    );
+    assert.doesNotMatch(output, /apiKey|secret|prompt|leak|sk-secret-token|req takeover/);
+  } finally {
+    await close(runtime.server);
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status reports linked extension state from the trial record', async () => {
+  const fixture = await createFixtureApp();
+  const trialRecordDir = join(fixture.tempDir, 'trials');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+  const cursorExtensionsDir = join(fixture.tempDir, 'Extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+  const now = '2026-05-30T00:00:00.000Z';
+
+  try {
+    await bundleExtension({ installPath: extensionInstallPath });
+    await linkExtensionBundle({ sourceBundlePath: extensionInstallPath, cursorExtensionsDir });
+    await writeTrialRecord(
+      {
+        trialId: trialIdForAppPath(fixture.appPath),
+        appPath: fixture.appPath,
+        cursorVersion: '3.5.38',
+        cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+        targetRelativePath,
+        originalSha256: fixture.compatEntry.expectedSha256,
+        compatSupportStatus: 'supported',
+        runtimeFile: fixture.runtimeFile,
+        backupDir: fixture.backupDir,
+        extensionInstallPath,
+        extensionLinkedPath: linkedPath,
+        extensionState: 'linked',
+        createdAt: now,
+        updatedAt: now,
+      },
+      { trialRecordDir },
+    );
+
+    const output = await status({
+      appPath: fixture.appPath,
+      trialRecordDir,
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(output, /extension: linked/);
+    assert.match(output, /mode: disposable/);
+    assert.match(output, /trial: recorded/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+function createInstallRecordFixture(
+  fixture: Awaited<ReturnType<typeof createFixtureApp>>,
+  overrides: Partial<InstallRecord> = {},
+): InstallRecord {
+  const now = '2026-05-30T00:00:00.000Z';
+  return {
+    installId: installIdForAppPath(fixture.appPath),
+    mode: 'real',
+    appPath: fixture.appPath,
+    cursorVersion: '3.5.38',
+    cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    targetRelativePath,
+    originalSha256: fixture.compatEntry.expectedSha256,
+    compatSupportStatus: 'supported',
+    runtimeFile: fixture.runtimeFile,
+    backupDir: fixture.backupDir,
+    extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+    extensionLinkedPath: linkedExtensionPathForDir(join(fixture.tempDir, 'extensions')),
+    extensionState: 'linked',
+    cliVersion: '0.0.0',
+    extensionVersion: '0.0.0',
+    serviceVersion: '0.0.0',
+    lastOperation: 'install',
+    lastOperationStatus: 'ok',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}
+
+test('status reports real mode from the install record', async () => {
+  const fixture = await createFixtureApp();
+  const installRecordFile = join(fixture.tempDir, 'install.json');
+  const cursorExtensionsDir = join(fixture.tempDir, 'extensions');
+  const extensionInstallPath = join(fixture.tempDir, 'extensions/cursor-pool-status');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+
+  try {
+    await patchFullSet(fixture.appPath, fixture.backupDir);
+    await bundleExtension({ installPath: extensionInstallPath });
+    await linkExtensionBundle({ sourceBundlePath: extensionInstallPath, cursorExtensionsDir });
+    await writeInstallRecord(
+      createInstallRecordFixture(fixture, {
+        extensionInstallPath,
+        extensionLinkedPath: linkedPath,
+      }),
+      { installRecordFile },
+    );
+
+    const output = await status({
+      realAppPath: fixture.appPath,
+      installRecordFile,
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(output, /mode: real/);
+    assert.match(output, /extension: linked/);
+    assert.match(output, /runtime: /);
+    assert.match(output, /install-record: recorded/);
+    assert.doesNotMatch(output, /trial:/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('status reports stale install record when recorded cursor commit differs', async () => {
+  const fixture = await createFixtureApp();
+  const installRecordFile = join(fixture.tempDir, 'install.json');
+
+  try {
+    await writeInstallRecord(
+      createInstallRecordFixture(fixture, {
+        cursorCommit: 'different-recorded-commit',
+      }),
+      { installRecordFile },
+    );
+
+    const output = await status({
+      realAppPath: fixture.appPath,
+      installRecordFile,
+      compatEntries: [fixture.compatEntry],
+    });
+
+    assert.match(output, /mode: real/);
+    assert.match(output, /install-record: stale/);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});

package/test/target.test.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { resolveCursorTarget } from '../src/target';
+
+test('resolveCursorTarget treats explicit appPath as disposable mode', () => {
+  assert.deepEqual(
+    resolveCursorTarget({
+      appPath: '/Users/example/Desktop/Cursor-Pool-Trial.app',
+      defaultRealAppPath: '/Applications/Cursor.app',
+    }),
+    {
+      mode: 'disposable',
+      appPath: '/Users/example/Desktop/Cursor-Pool-Trial.app',
+      requiresConfirmation: false,
+    },
+  );
+});
+
+test('resolveCursorTarget rejects the real Cursor app as disposable appPath', () => {
+  assert.throws(
+    () => resolveCursorTarget({ appPath: '/Applications/Cursor.app' }),
+    /Refusing to install into real Cursor app/,
+  );
+});
+
+test('resolveCursorTarget uses real mode when appPath is not provided', () => {
+  assert.deepEqual(
+    resolveCursorTarget({ defaultRealAppPath: '/Applications/Cursor-Real.app' }),
+    {
+      mode: 'real',
+      appPath: '/Applications/Cursor-Real.app',
+      requiresConfirmation: true,
+    },
+  );
+});
+
+test('resolveCursorTarget prefers injected realAppPath for real mode', () => {
+  assert.deepEqual(
+    resolveCursorTarget({
+      realAppPath: '/Volumes/Apps/Cursor.app',
+      defaultRealAppPath: '/Applications/Cursor.app',
+    }),
+    {
+      mode: 'real',
+      appPath: '/Volumes/Apps/Cursor.app',
+      requiresConfirmation: true,
+    },
+  );
+});