@cursorpool-dev/cli 0.5.6

package/node_modules/@cursor-pool/patcher/test/patchCursorAgentExec.test.ts

@@ -0,0 +1,630 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+import { sha256File } from '../src/hash';
+import {
+  buildCursorAgentExecPatchSnippet,
+  CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR,
+  CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHORS,
+  CURSOR_POOL_PATCH_BEGIN_MARKER,
+  CURSOR_POOL_PATCH_END_MARKER,
+  CURSOR_POOL_PATCH_MARKER,
+  CURSOR_POOL_PATCH_SIGNATURE,
+  hasCursorPoolMarker,
+  injectCursorAgentExecPatchSnippet,
+} from '../src/marker';
+import {
+  backupPathForCursorAgentExec,
+  patchCursorAgentExec,
+} from '../src/patchCursorAgentExec';
+
+const targetRelativePath =
+  'Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js';
+
+async function createFixture(
+  content = `function main() { return "agent"; }\n${CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR}\nmain();\n`,
+) {
+  const base = await mkdtemp(join(tmpdir(), 'cursor-pool-patcher-'));
+  const appPath = join(base, `Fixture-${Date.now()}-${Math.random()}.app`);
+  await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-agent-exec/dist'), {
+    recursive: true,
+  });
+  await writeFile(join(appPath, targetRelativePath), content, 'utf8');
+
+  return {
+    appPath,
+    targetPath: join(appPath, targetRelativePath),
+  };
+}
+
+test('patch changes the target hash after computing the original hash and adds a detectable marker', async () => {
+  const tempDir = join(tmpdir(), `cursor-pool-patcher-backups-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    const beforeHash = await sha256File(fixture.targetPath);
+    assert.equal(await hasCursorPoolMarker(fixture.targetPath), false);
+
+    const result = await patchCursorAgentExec(fixture.appPath, { backupDir: tempDir });
+
+    const afterPatchHash = await sha256File(fixture.targetPath);
+    const markerPresent = await hasCursorPoolMarker(fixture.targetPath);
+
+    assert.equal(result.beforeHash, beforeHash);
+    assert.equal(afterPatchHash !== beforeHash, true);
+    assert.equal(result.afterHash, afterPatchHash);
+    assert.equal(markerPresent, true);
+    assert.match(result.backupPath, new RegExp(`^${tempDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('patch supports a custom Linux Cursor agent exec relative path', async () => {
+  const tempDir = join(tmpdir(), `cursor-pool-patcher-linux-path-${Date.now()}-${Math.random()}`);
+  const appPath = join(tempDir, 'squashfs-root');
+  const customTargetRelativePath =
+    'usr/share/cursor/resources/app/extensions/cursor-agent-exec/dist/main.js';
+  const targetPath = join(appPath, customTargetRelativePath);
+
+  try {
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeFile(
+      targetPath,
+      `function main() { return "linux"; }\n${CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR}\nmain();\n`,
+      'utf8',
+    );
+
+    const result = await patchCursorAgentExec(appPath, {
+      backupDir: tempDir,
+      targetRelativePath: customTargetRelativePath,
+    });
+
+    assert.equal(result.targetPath, targetPath);
+    assert.equal(await hasCursorPoolMarker(targetPath), true);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('patch failure restores original target bytes from runtime backup', async () => {
+  const tempDir = join(tmpdir(), `cursor-pool-patcher-rollback-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    const beforeHash = await sha256File(fixture.targetPath);
+    const beforeBytes = await readFile(fixture.targetPath, 'utf8');
+
+    await assert.rejects(
+      patchCursorAgentExec(fixture.appPath, {
+        backupDir: tempDir,
+        patchContent: () => {
+          throw new Error('synthetic patch failure');
+        },
+      }),
+      /synthetic patch failure/,
+    );
+
+    assert.equal(await sha256File(fixture.targetPath), beforeHash);
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), beforeBytes);
+    assert.equal(await hasCursorPoolMarker(fixture.targetPath), false);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('patch rolls back when patched content lacks a valid marker pair', async () => {
+  const tempDir = join(tmpdir(), `cursor-pool-patcher-invalid-marker-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    const beforeHash = await sha256File(fixture.targetPath);
+    const beforeBytes = await readFile(fixture.targetPath, 'utf8');
+
+    await assert.rejects(
+      patchCursorAgentExec(fixture.appPath, {
+        backupDir: tempDir,
+        patchContent: (content) => `${content}\n/* ${CURSOR_POOL_PATCH_MARKER}: begin */\n`,
+      }),
+      /valid patch marker/,
+    );
+
+    assert.equal(await sha256File(fixture.targetPath), beforeHash);
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), beforeBytes);
+    assert.equal(await hasCursorPoolMarker(fixture.targetPath), false);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('patch fails without the Cursor Agent provider registration anchor', async () => {
+  const tempDir = join(tmpdir(), `cursor-pool-patcher-missing-anchor-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture('function main() { return "agent"; }\nmain();\n');
+
+  try {
+    await assert.rejects(
+      patchCursorAgentExec(fixture.appPath, { backupDir: tempDir }),
+      /provider registration anchor/,
+    );
+    assert.equal(await hasCursorPoolMarker(fixture.targetPath), false);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('already-patched target refuses success when backup is missing', async () => {
+  const tempDir = join(tmpdir(), `cursor-pool-patcher-missing-backup-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    await writeFile(
+      fixture.targetPath,
+      `${await readFile(fixture.targetPath, 'utf8')}${buildCursorAgentExecPatchSnippet()}`,
+      'utf8',
+    );
+
+    await assert.rejects(
+      patchCursorAgentExec(fixture.appPath, { backupDir: tempDir }),
+      /backup.*missing/i,
+    );
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('already-patched target refuses success when backup is also patched', async () => {
+  const tempDir = join(tmpdir(), `cursor-pool-patcher-invalid-backup-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    const patchedContent = `${await readFile(fixture.targetPath, 'utf8')}${buildCursorAgentExecPatchSnippet()}`;
+    await writeFile(fixture.targetPath, patchedContent, 'utf8');
+
+    const backupPath = await backupPathForCursorAgentExec(fixture.appPath, fixture.targetPath, tempDir);
+    await mkdir(tempDir, { recursive: true });
+    await writeFile(backupPath, patchedContent, 'utf8');
+
+    await assert.rejects(
+      patchCursorAgentExec(fixture.appPath, { backupDir: tempDir }),
+      /backup.*patch marker/i,
+    );
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('patch upgrades an older Cursor Pool marker from clean backup instead of stacking snippets', async () => {
+  const tempDir = join(tmpdir(), `cursor-pool-patcher-upgrade-${Date.now()}-${Math.random()}`);
+  const fixture = await createFixture();
+
+  try {
+    const originalContent = await readFile(fixture.targetPath, 'utf8');
+    const backupPath = await backupPathForCursorAgentExec(fixture.appPath, fixture.targetPath, tempDir);
+    await mkdir(tempDir, { recursive: true });
+    await writeFile(backupPath, originalContent, 'utf8');
+    await writeFile(
+      fixture.targetPath,
+      `${originalContent}
+${CURSOR_POOL_PATCH_BEGIN_MARKER}
+;(() => { globalThis.__cursorPoolAgentExecLoopback = true; })();
+${CURSOR_POOL_PATCH_END_MARKER}
+`,
+      'utf8',
+    );
+
+    const result = await patchCursorAgentExec(fixture.appPath, { backupDir: tempDir });
+    const patchedContent = await readFile(fixture.targetPath, 'utf8');
+
+    assert.equal(result.markerPresent, true);
+    assert.equal(await hasCursorPoolMarker(fixture.targetPath), true);
+    assert.equal(patchedContent.includes('__cursorPoolAgentExecLoopback'), false);
+    assert.equal(patchedContent.includes(CURSOR_POOL_PATCH_SIGNATURE), true);
+    assert.equal((patchedContent.match(new RegExp(CURSOR_POOL_PATCH_MARKER, 'g')) ?? []).length, 2);
+    assert.equal(await readFile(backupPath, 'utf8'), originalContent);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('agent exec patch snippet wraps the Cursor Agent provider instead of sending side-channel events', () => {
+  const snippet = buildCursorAgentExecPatchSnippet();
+
+  for (const expected of [
+    CURSOR_POOL_PATCH_MARKER,
+    CURSOR_POOL_PATCH_SIGNATURE,
+    "require('node:fs')",
+    "require('node:os')",
+    "require('node:path')",
+    "require('node:http')",
+    'CURSOR_POOL_RUNTIME_FILE',
+    '.cursor-pool',
+    'runtime.json',
+    'registerAgentExecProvider',
+    'wrapCursorPoolProvider',
+    'requestCursorPoolTakeover',
+    '/agent/takeover',
+    'createSession',
+    'runLocalAgent',
+    'fetchLocalProviderModels',
+    "runtime.host !== '127.0.0.1'",
+    "typeof runtime.port !== 'number'",
+    "typeof runtime.runtimeId !== 'string'",
+    "hostname: '127.0.0.1'",
+    'port: runtime.port',
+    "method: 'POST'",
+    'timeout: 1000',
+    "'content-type': 'application/json'",
+    "'content-length': Buffer.byteLength(body)",
+    "request.on('error'",
+    "request.on('timeout'",
+    'request.destroy()',
+    'request.end(body)',
+  ]) {
+    assert.equal(snippet.includes(expected), true, `expected snippet to include ${expected}`);
+  }
+
+  assert.equal(snippet.includes('createStream(context, requestBytes, abortSignal)'), false);
+
+  for (const removedSideChannel of [
+    "sendLoopback('/agent/canary')",
+    "sendLoopback('/agent/request-check')",
+    "sendLoopback('/agent/request-gateway')",
+    'response.resume()',
+  ]) {
+    assert.equal(
+      snippet.includes(removedSideChannel),
+      false,
+      `expected snippet not to include removed side-channel ${removedSideChannel}`,
+    );
+  }
+
+  const payloadMatch = snippet.match(
+    /const body = JSON\.stringify\(\{\n(?<body>[\s\S]*?)\n        \}\);/,
+  );
+  assert.ok(payloadMatch?.groups?.body, 'expected snippet to build a JSON.stringify payload object');
+  assert.equal(
+    payloadMatch.groups.body,
+    [
+      '          requestId,',
+      "          source: 'cursor-agent-exec',",
+      "          model: context?.modelName || 'unknown',",
+      '          stream: true,',
+      "          bodyShape: 'redacted',",
+    ].join('\n'),
+  );
+
+  for (const forbiddenPayloadKey of [
+    'runtimeId',
+    'routeToken',
+    'receivedAt',
+    'prompt',
+    'messages',
+    'apiKey',
+    'authorization',
+    'cookie',
+    'cursorAuthToken',
+    'providerSecret',
+  ]) {
+    assert.equal(
+      payloadMatch.groups.body.includes(forbiddenPayloadKey),
+      false,
+      `expected payload not to include ${forbiddenPayloadKey}`,
+    );
+  }
+
+  for (const sensitiveKey of [
+    'prompt',
+    'messages',
+    'apiKey',
+    'authorization',
+    'cookie',
+    'cursorAuthToken',
+    'providerSecret',
+  ]) {
+    assert.equal(
+      snippet.includes(sensitiveKey),
+      false,
+      `expected snippet not to include sensitive key ${sensitiveKey}`,
+    );
+  }
+});
+
+test('agent exec patch injects the wrapper before Cursor registers the provider', () => {
+  const content = `before();${CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR}after();`;
+  const patched = injectCursorAgentExecPatchSnippet(content);
+
+  assert.equal(patched.includes(CURSOR_POOL_PATCH_SIGNATURE), true);
+  assert.equal(
+    patched.indexOf(CURSOR_POOL_PATCH_SIGNATURE) < patched.indexOf(CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR),
+    true,
+  );
+});
+
+test('agent exec patch supports the Cursor 3.6 registerAgentExecProvider anchor', () => {
+  const anchor = 'const ht=c.cursor.registerAgentExecProvider(mt);';
+  assert.equal(CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHORS.includes(anchor), true);
+
+  const patched = injectCursorAgentExecPatchSnippet(`before();${anchor}after();`);
+
+  assert.equal(patched.includes(CURSOR_POOL_PATCH_SIGNATURE), true);
+  assert.ok(patched.indexOf(CURSOR_POOL_PATCH_SIGNATURE) < patched.indexOf(anchor));
+});
+
+test('agent exec provider wrapper works when Cursor API object is minified as c', async () => {
+  const snippet = buildCursorAgentExecPatchSnippet();
+  const registered: unknown[] = [];
+  const runtime = { host: '127.0.0.1', port: 32123, runtimeId: 'runtime-test' };
+  const originalProvider = {
+    async runLocalAgent() {
+      return 'ok';
+    },
+  };
+
+  const fn = new Function(
+    'registered',
+    'originalProvider',
+    'runtime',
+    `
+const require = (specifier) => {
+  if (specifier === 'node:fs') {
+    return {
+      existsSync: () => true,
+      readFileSync: () => JSON.stringify(runtime),
+    };
+  }
+  if (specifier === 'node:os') {
+    return { homedir: () => '/home/test' };
+  }
+  if (specifier === 'node:path') {
+    return { join: (...parts) => parts.join('/') };
+  }
+  if (specifier === 'node:http') {
+    return { request() { return { on() { return this; }, end() {}, destroy() {} }; } };
+  }
+  throw new Error('unexpected require ' + specifier);
+};
+const process = { env: {} };
+const c = {
+  cursor: {
+    registerAgentExecProvider(provider) {
+      registered.push(provider);
+      return { dispose() {} };
+    },
+  },
+};
+${snippet}
+c.cursor.registerAgentExecProvider(originalProvider);
+return registered[0];`,
+  );
+
+  const wrappedProvider = fn(registered, originalProvider, runtime) as typeof originalProvider;
+
+  assert.equal(registered.length, 1);
+  assert.notEqual(wrappedProvider, originalProvider);
+  assert.equal(await wrappedProvider.runLocalAgent(), 'ok');
+});
+
+test('agent exec provider wrapper preserves original runLocalAgent so Cursor local client can consume OpenAI endpoint', async () => {
+  const snippet = buildCursorAgentExecPatchSnippet();
+  const runtime = { host: '127.0.0.1', port: 32123, runtimeId: 'runtime-test' };
+  const calls: string[] = [];
+  const originalProvider = {
+    async runLocalAgent() {
+      calls.push('original-runLocalAgent');
+    },
+  };
+  const registered: unknown[] = [];
+  const sandbox = {
+    require(specifier: string) {
+      if (specifier === 'node:fs') {
+        return {
+          existsSync: () => true,
+          readFileSync: () => JSON.stringify(runtime),
+        };
+      }
+      if (specifier === 'node:os') {
+        return { homedir: () => '/home/test' };
+      }
+      if (specifier === 'node:path') {
+        return { join: (...parts: string[]) => parts.join('/') };
+      }
+      if (specifier === 'node:http') {
+        return {
+          request(_options: unknown, callback: (response: unknown) => void) {
+            const handlers = new Map<string, () => void>();
+            return {
+              on(event: string, handler: () => void) {
+                handlers.set(event, handler);
+                return this;
+              },
+              end(body: string) {
+                calls.push(body);
+                callback({
+                  setEncoding() {},
+                  on(event: string, handler: (chunk?: string) => void) {
+                    if (event === 'data') {
+                      handler(JSON.stringify({
+                        state: 'answered',
+                        requestId: 'takeover-1',
+                        source: 'cursor-agent-exec',
+                        model: 'gpt-test',
+                        content: '来自 Cursor Pool 本地测试 provider',
+                      }));
+                    }
+                    if (event === 'end') {
+                      handler();
+                    }
+                  },
+                });
+              },
+              destroy() {},
+            };
+          },
+        };
+      }
+      throw new Error(`unexpected require ${specifier}`);
+    },
+    process: { env: {} },
+    globalThis: {} as Record<string, unknown>,
+    F: {
+      cursor: {
+        registerAgentExecProvider(provider: unknown) {
+          registered.push(provider);
+          return { dispose() {} };
+        },
+      },
+    },
+  };
+
+  Function(
+    'require',
+    'process',
+    'globalThis',
+    'F',
+    'originalProvider',
+    'registered',
+    `${snippet}
+F.cursor.registerAgentExecProvider(originalProvider);
+return registered[0];`,
+  ).call(
+    sandbox,
+    sandbox.require,
+    sandbox.process,
+    sandbox.globalThis,
+    sandbox.F,
+    originalProvider,
+    registered,
+  );
+
+  const wrappedProvider = registered[0] as typeof originalProvider;
+  await wrappedProvider.runLocalAgent(
+    {
+      runOptions: { generationUUID: 'req-1' },
+      modelDetails: undefined,
+      defaultModel: undefined,
+    },
+    {},
+  );
+
+  assert.deepEqual(calls, ['original-runLocalAgent']);
+  assert.equal((sandbox.globalThis.__cursorPoolAgentExecTakeover as { lastAnswer?: unknown }).lastAnswer, undefined);
+});
+
+test('agent exec provider wrapper preserves original createStream so Cursor stream frames are not swallowed', async () => {
+  const snippet = buildCursorAgentExecPatchSnippet();
+  const runtime = { host: '127.0.0.1', port: 32123, runtimeId: 'runtime-test' };
+  const calls: string[] = [];
+  const originalFrame = new Uint8Array([77, 1, 2, 3]);
+  const originalProvider = {
+    createSession() {
+      return {
+        createStream() {
+          return async function* originalStream() {
+            calls.push('original-createStream');
+            yield originalFrame;
+          };
+        },
+      };
+    },
+  };
+  const registered: unknown[] = [];
+  const sandbox = {
+    require(specifier: string) {
+      if (specifier === 'node:fs') {
+        return {
+          existsSync: () => true,
+          readFileSync: () => JSON.stringify(runtime),
+        };
+      }
+      if (specifier === 'node:os') {
+        return { homedir: () => '/home/test' };
+      }
+      if (specifier === 'node:path') {
+        return { join: (...parts: string[]) => parts.join('/') };
+      }
+      if (specifier === 'node:http') {
+        return {
+          request(_options: unknown, callback: (response: unknown) => void) {
+            return {
+              on() {
+                return this;
+              },
+              end(body: string) {
+                calls.push(body);
+                callback({
+                  setEncoding() {},
+                  on(event: string, handler: (chunk?: string) => void) {
+                    if (event === 'data') {
+                      handler(JSON.stringify({
+                        state: 'answered',
+                        requestId: 'takeover-1',
+                        source: 'cursor-agent-exec',
+                        model: 'gpt-test',
+                        content: '来自 Cursor Pool 本地测试 provider',
+                      }));
+                    }
+                    if (event === 'end') {
+                      handler();
+                    }
+                  },
+                });
+              },
+              destroy() {},
+            };
+          },
+        };
+      }
+      throw new Error(`unexpected require ${specifier}`);
+    },
+    process: { env: {} },
+    globalThis: {} as Record<string, unknown>,
+    F: {
+      cursor: {
+        registerAgentExecProvider(provider: unknown) {
+          registered.push(provider);
+          return { dispose() {} };
+        },
+      },
+    },
+  };
+
+  Function(
+    'require',
+    'process',
+    'globalThis',
+    'F',
+    'originalProvider',
+    'registered',
+    `${snippet}
+F.cursor.registerAgentExecProvider(originalProvider);
+return registered[0];`,
+  ).call(
+    sandbox,
+    sandbox.require,
+    sandbox.process,
+    sandbox.globalThis,
+    sandbox.F,
+    originalProvider,
+    registered,
+  );
+
+  const wrappedProvider = registered[0] as typeof originalProvider;
+  const session = wrappedProvider.createSession();
+  const frames = [];
+  for await (const frame of session.createStream({ requestId: 'stream-1', modelName: 'gpt-test' }, new Uint8Array(), { aborted: false })()) {
+    frames.push(frame);
+  }
+
+  assert.deepEqual(calls, ['original-createStream']);
+  assert.deepEqual(frames, [originalFrame]);
+  assert.equal((sandbox.globalThis.__cursorPoolAgentExecTakeover as { lastAnswer?: unknown }).lastAnswer, undefined);
+});