@cursorpool-dev/cli 0.5.6

package/node_modules/@cursor-pool/patcher/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@cursor-pool/patcher",
+  "version": "0.5.6",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./hash": "./src/hash.ts",
+    "./marker": "./src/marker.ts"
+  },
+  "dependencies": {
+    "@cursor-pool/shared": "0.5.6"
+  },
+  "scripts": {
+    "test": "tsx --test test/*.test.ts"
+  }
+}

package/node_modules/@cursor-pool/patcher/src/alwaysLocalMarker.ts

@@ -0,0 +1,86 @@
+import { readFile } from 'node:fs/promises';
+
+export const CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_MARKER =
+  'CURSOR_POOL_CURSOR_ALWAYS_LOCAL_TAKEOVER_PATCH';
+export const CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_BEGIN_MARKER =
+  `/* ${CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_MARKER}: begin */`;
+export const CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_END_MARKER =
+  `/* ${CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_MARKER}: end */`;
+export const CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_SIGNATURE =
+  '__cursorPoolAlwaysLocalTakeover';
+
+export function buildCursorAlwaysLocalTakeoverPatchSnippet() {
+  return `
+${CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_BEGIN_MARKER}
+;(() => {
+  try {
+    const fs = require('node:fs');
+    const os = require('node:os');
+    const path = require('node:path');
+    const http = require('node:http');
+    const runtimePath =
+      process.env.CURSOR_POOL_RUNTIME_FILE ||
+      path.join(os.homedir(), '.cursor-pool', 'runtime.json');
+    if (!fs.existsSync(runtimePath)) return;
+    const runtime = JSON.parse(fs.readFileSync(runtimePath, 'utf8'));
+    if (!runtime || runtime.host !== '127.0.0.1' || typeof runtime.port !== 'number') return;
+    const requestId = \`takeover-\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2)}\`;
+    const payload = JSON.stringify({
+      requestId,
+      source: 'cursor-always-local',
+      model: 'unknown',
+      stream: true,
+      messagesShape: 'redacted',
+    });
+    const request = http.request(
+      {
+        hostname: '127.0.0.1',
+        port: runtime.port,
+        path: '/agent/takeover',
+        method: 'POST',
+        timeout: 1000,
+        headers: {
+          'content-type': 'application/json',
+          'content-length': Buffer.byteLength(payload),
+        },
+      },
+      (response) => {
+        response.resume();
+      },
+    );
+    request.on('error', () => {});
+    request.on('timeout', () => request.destroy());
+    request.end(payload);
+    globalThis.__cursorPoolAlwaysLocalTakeover = {
+      host: '127.0.0.1',
+      source: 'cursor-always-local',
+    };
+  } catch {}
+})();
+${CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_END_MARKER}
+`;
+}
+
+export function containsCursorAlwaysLocalTakeoverMarker(content: string) {
+  const beginIndex = content.indexOf(CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_BEGIN_MARKER);
+  const endIndex = content.indexOf(CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_END_MARKER);
+
+  return (
+    beginIndex >= 0 &&
+    endIndex > beginIndex &&
+    content
+      .slice(beginIndex, endIndex)
+      .includes(CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_SIGNATURE)
+  );
+}
+
+export function containsAnyCursorAlwaysLocalTakeoverMarkerText(content: string) {
+  return (
+    content.includes(CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_MARKER) ||
+    content.includes(CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_SIGNATURE)
+  );
+}
+
+export async function hasCursorAlwaysLocalTakeoverMarker(filePath: string) {
+  return containsCursorAlwaysLocalTakeoverMarker(await readFile(filePath, 'utf8'));
+}

package/node_modules/@cursor-pool/patcher/src/hash.ts

@@ -0,0 +1,7 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+
+export async function sha256File(filePath: string) {
+  const bytes = await readFile(filePath);
+  return createHash('sha256').update(bytes).digest('hex');
+}

package/node_modules/@cursor-pool/patcher/src/index.ts

@@ -0,0 +1,55 @@
+export const packageRole = 'patcher';
+export { sha256File } from './hash';
+export {
+  buildCursorAgentExecPatchSnippet,
+  containsCursorPoolMarker,
+  CURSOR_POOL_PATCH_MARKER,
+  hasCursorPoolMarker,
+} from './marker';
+export {
+  buildCursorAlwaysLocalTakeoverPatchSnippet,
+  containsCursorAlwaysLocalTakeoverMarker,
+  containsAnyCursorAlwaysLocalTakeoverMarkerText,
+  CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_MARKER,
+  hasCursorAlwaysLocalTakeoverMarker,
+} from './alwaysLocalMarker';
+export {
+  backupPathForCursorAgentExec,
+  CURSOR_AGENT_EXEC_RELATIVE_PATH,
+  patchCursorAgentExec,
+  resolveCursorAgentExecPath,
+  type PatchCursorAgentExecOptions,
+  type PatchCursorAgentExecResult,
+} from './patchCursorAgentExec';
+export {
+  backupPathForCursorAlwaysLocal,
+  CURSOR_ALWAYS_LOCAL_RELATIVE_PATH,
+  patchCursorAlwaysLocal,
+  resolveCursorAlwaysLocalPath,
+  type PatchCursorAlwaysLocalOptions,
+  type PatchCursorAlwaysLocalResult,
+} from './patchCursorAlwaysLocal';
+export {
+  backupPathForCursorWorkbenchAuthGate,
+  CURSOR_WORKBENCH_RELATIVE_PATH,
+  patchCursorWorkbenchAuthGate,
+  resolveCursorWorkbenchPath,
+  type PatchCursorWorkbenchAuthGateOptions,
+  type PatchCursorWorkbenchAuthGateResult,
+} from './patchCursorWorkbenchAuthGate';
+export {
+  containsCursorWorkbenchAuthGateMarker,
+  containsAnyCursorWorkbenchAuthGateMarkerText,
+} from './workbenchAuthGateMarker';
+export {
+  restoreCursorAgentExec,
+  type RestoreCursorAgentExecResult,
+} from './restoreCursorAgentExec';
+export {
+  restoreCursorAlwaysLocal,
+  type RestoreCursorAlwaysLocalResult,
+} from './restoreCursorAlwaysLocal';
+export {
+  restoreCursorWorkbenchAuthGate,
+  type RestoreCursorWorkbenchAuthGateResult,
+} from './restoreCursorWorkbenchAuthGate';

package/node_modules/@cursor-pool/patcher/src/marker.ts

@@ -0,0 +1,159 @@
+import { readFile } from 'node:fs/promises';
+
+export const CURSOR_POOL_PATCH_MARKER = 'CURSOR_POOL_MVP0_CURSOR_AGENT_EXEC_PATCH_V3_FAIL_CLOSED';
+export const CURSOR_POOL_PATCH_BEGIN_MARKER = `/* ${CURSOR_POOL_PATCH_MARKER}: begin */`;
+export const CURSOR_POOL_PATCH_END_MARKER = `/* ${CURSOR_POOL_PATCH_MARKER}: end */`;
+export const CURSOR_POOL_PATCH_SIGNATURE = '__cursorPoolAgentExecTakeover';
+export const CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR =
+  'const ht=F.cursor.registerAgentExecProvider(mt);';
+export const CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHORS = [
+  CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR,
+  'const ht=c.cursor.registerAgentExecProvider(mt);',
+];
+
+export function buildCursorAgentExecPatchSnippet() {
+  return `
+${CURSOR_POOL_PATCH_BEGIN_MARKER}
+;(() => {
+  try {
+    const fs = require('node:fs');
+    const os = require('node:os');
+    const path = require('node:path');
+    const http = require('node:http');
+    const runtimePath =
+      process.env.CURSOR_POOL_RUNTIME_FILE ||
+      path.join(os.homedir(), '.cursor-pool', 'runtime.json');
+    if (!fs.existsSync(runtimePath)) return;
+    const runtime = JSON.parse(fs.readFileSync(runtimePath, 'utf8'));
+    if (
+      !runtime ||
+      runtime.host !== '127.0.0.1' ||
+      typeof runtime.port !== 'number' ||
+      typeof runtime.runtimeId !== 'string'
+    ) {
+      return;
+    }
+    if (!globalThis.__cursorPoolAgentExecTakeover) {
+      globalThis.__cursorPoolAgentExecTakeover = {
+        host: '127.0.0.1',
+        source: 'cursor-agent-exec',
+        runtimeId: runtime.runtimeId,
+      };
+    }
+    const requestCursorPoolTakeover = (context) =>
+      new Promise((resolve) => {
+        const requestId =
+          context?.requestId ||
+          \`agent-\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2)}\`;
+        const body = JSON.stringify({
+          requestId,
+          source: 'cursor-agent-exec',
+          model: context?.modelName || 'unknown',
+          stream: true,
+          bodyShape: 'redacted',
+        });
+        const request = http.request(
+          {
+            hostname: '127.0.0.1',
+            port: runtime.port,
+            path: '/agent/takeover',
+            method: 'POST',
+            timeout: 1000,
+            headers: {
+              'content-type': 'application/json',
+              'content-length': Buffer.byteLength(body),
+            },
+          },
+          (response) => {
+            let text = '';
+            response.setEncoding?.('utf8');
+            response.on('data', (chunk) => {
+              text += chunk;
+            });
+            response.on('end', () => {
+              try {
+                resolve(JSON.parse(text));
+              } catch {
+                resolve({ state: 'rejected', requestId, reason: 'invalid-session' });
+              }
+            });
+          },
+        );
+        request.on('error', () => resolve({ state: 'rejected', requestId, reason: 'invalid-session' }));
+        request.on('timeout', () => {
+          request.destroy();
+          resolve({ state: 'rejected', requestId, reason: 'invalid-session' });
+        });
+        request.end(body);
+      });
+    const wrapCursorPoolProvider = (provider) => {
+      if (!provider || provider.__cursorPoolWrappedAgentExecProvider) {
+        return provider;
+      }
+      const wrapped = Object.create(Object.getPrototypeOf(provider));
+      Object.assign(wrapped, provider);
+      if (typeof provider.runLocalAgent === 'function') {
+        wrapped.runLocalAgent = provider.runLocalAgent.bind(provider);
+      }
+      if (typeof provider.createSession === 'function') {
+        wrapped.createSession = provider.createSession.bind(provider);
+      }
+      if (typeof provider.fetchLocalProviderModels === 'function') {
+        wrapped.fetchLocalProviderModels = provider.fetchLocalProviderModels.bind(provider);
+      }
+      wrapped.__cursorPoolWrappedAgentExecProvider = true;
+      return wrapped;
+    };
+    const cursorApi =
+      typeof F !== 'undefined' && F.cursor?.registerAgentExecProvider
+        ? F
+        : typeof c !== 'undefined' && c.cursor?.registerAgentExecProvider
+          ? c
+          : undefined;
+    if (cursorApi?.cursor?.registerAgentExecProvider) {
+      const originalRegisterAgentExecProvider = cursorApi.cursor.registerAgentExecProvider.bind(cursorApi.cursor);
+      cursorApi.cursor.registerAgentExecProvider = (provider) =>
+        originalRegisterAgentExecProvider(wrapCursorPoolProvider(provider));
+    }
+  } catch {}
+})();
+${CURSOR_POOL_PATCH_END_MARKER}
+`;
+}
+
+export function injectCursorAgentExecPatchSnippet(content: string) {
+  if (containsCursorPoolMarker(content)) {
+    return content;
+  }
+  const snippet = buildCursorAgentExecPatchSnippet();
+  const anchor = CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHORS.find((candidate) =>
+    content.includes(candidate)
+  );
+  const anchorIndex = anchor ? content.indexOf(anchor) : -1;
+  if (anchorIndex < 0) {
+    throw new Error('Cursor Agent Exec provider registration anchor was not found.');
+  }
+  return `${content.slice(0, anchorIndex)}${snippet}${content.slice(anchorIndex)}`;
+}
+
+export function containsCursorPoolMarker(content: string) {
+  const beginIndex = content.indexOf(CURSOR_POOL_PATCH_BEGIN_MARKER);
+  const endIndex = content.indexOf(CURSOR_POOL_PATCH_END_MARKER);
+
+  return (
+    beginIndex >= 0 &&
+    endIndex > beginIndex &&
+    content.slice(beginIndex, endIndex).includes(CURSOR_POOL_PATCH_SIGNATURE)
+  );
+}
+
+export function containsAnyCursorPoolMarkerText(content: string) {
+  return (
+    content.includes(CURSOR_POOL_PATCH_MARKER) ||
+    content.includes(CURSOR_POOL_PATCH_SIGNATURE)
+  );
+}
+
+export async function hasCursorPoolMarker(filePath: string) {
+  return containsCursorPoolMarker(await readFile(filePath, 'utf8'));
+}

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

@@ -0,0 +1,154 @@
+import { createHash } from 'node:crypto';
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { joinCursorAppPath } from '@cursor-pool/shared/paths';
+import { DEFAULT_RUNTIME_DIR } from '@cursor-pool/shared/runtime';
+import { sha256File } from './hash';
+import {
+  buildCursorAgentExecPatchSnippet,
+  containsAnyCursorPoolMarkerText,
+  containsCursorPoolMarker,
+  injectCursorAgentExecPatchSnippet,
+} from './marker';
+
+export const CURSOR_AGENT_EXEC_RELATIVE_PATH =
+  'Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js';
+
+export type PatchCursorAgentExecOptions = {
+  backupDir?: string;
+  targetRelativePath?: string;
+  patchContent?: (content: string) => string;
+};
+
+export type PatchCursorAgentExecResult = {
+  targetPath: string;
+  backupPath: string;
+  beforeHash: string;
+  afterHash: string;
+  markerPresent: boolean;
+};
+
+function resolveHomePath(path: string) {
+  if (path.startsWith('~/')) {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+
+function resolveBackupDir(backupDir = join(DEFAULT_RUNTIME_DIR, 'backups')) {
+  return resolveHomePath(backupDir);
+}
+
+export function resolveCursorAgentExecPath(
+  appPath: string,
+  targetRelativePath = CURSOR_AGENT_EXEC_RELATIVE_PATH,
+) {
+  return joinCursorAppPath(appPath, targetRelativePath);
+}
+
+export async function backupPathForCursorAgentExec(
+  appPath: string,
+  targetPath = resolveCursorAgentExecPath(appPath),
+  backupDir?: string,
+) {
+  const appPathHash = createHash('sha256').update(appPath).digest('hex').slice(0, 16);
+  const targetPathHash = createHash('sha256')
+    .update(targetPath)
+    .digest('hex')
+    .slice(0, 16);
+  return join(
+    resolveBackupDir(backupDir),
+    `${basename(appPath).replaceAll('/', '_')}-${appPathHash}-${targetPathHash}.main.js.bak`,
+  );
+}
+
+function defaultPatchContent(content: string) {
+  if (containsCursorPoolMarker(content)) {
+    return content;
+  }
+  return injectCursorAgentExecPatchSnippet(content);
+}
+
+function containsLegacyCursorPoolMarker(content: string) {
+  return containsAnyCursorPoolMarkerText(content) && !containsCursorPoolMarker(content);
+}
+
+async function readBackupContent(backupPath: string) {
+  try {
+    return await readFile(backupPath, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error(`Patch backup is missing: ${backupPath}`);
+    }
+    throw error;
+  }
+}
+
+export async function validateUnpatchedBackup(backupPath: string) {
+  const backupContent = await readBackupContent(backupPath);
+  if (containsAnyCursorPoolMarkerText(backupContent)) {
+    throw new Error(`Patch backup contains patch marker and is unsafe: ${backupPath}`);
+  }
+  return backupContent;
+}
+
+export async function patchCursorAgentExec(
+  appPath: string,
+  options: PatchCursorAgentExecOptions = {},
+): Promise<PatchCursorAgentExecResult> {
+  const targetPath = resolveCursorAgentExecPath(appPath, options.targetRelativePath);
+  const beforeHash = await sha256File(targetPath);
+  const backupPath = await backupPathForCursorAgentExec(
+    appPath,
+    targetPath,
+    options.backupDir,
+  );
+  const content = await readFile(targetPath, 'utf8');
+
+  if (containsCursorPoolMarker(content)) {
+    await validateUnpatchedBackup(backupPath);
+    return {
+      targetPath,
+      backupPath,
+      beforeHash,
+      afterHash: beforeHash,
+      markerPresent: true,
+    };
+  }
+
+  await mkdir(dirname(backupPath), { recursive: true });
+  if (containsLegacyCursorPoolMarker(content)) {
+    await validateUnpatchedBackup(backupPath);
+  } else {
+    await copyFile(targetPath, backupPath);
+  }
+
+  try {
+    const patchBaseContent = containsLegacyCursorPoolMarker(content)
+      ? await readBackupContent(backupPath)
+      : content;
+    const patchedContent = (options.patchContent ?? defaultPatchContent)(patchBaseContent);
+    await writeFile(targetPath, patchedContent, 'utf8');
+
+    const afterHash = await sha256File(targetPath);
+    const markerPresent = containsCursorPoolMarker(
+      await readFile(targetPath, 'utf8'),
+    );
+
+    if (!markerPresent) {
+      throw new Error('Patch did not write a valid patch marker pair.');
+    }
+
+    return {
+      targetPath,
+      backupPath,
+      beforeHash,
+      afterHash,
+      markerPresent,
+    };
+  } catch (error) {
+    await copyFile(backupPath, targetPath);
+    throw error;
+  }
+}

package/node_modules/@cursor-pool/patcher/src/patchCursorAlwaysLocal.ts

@@ -0,0 +1,142 @@
+import { createHash } from 'node:crypto';
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { joinCursorAppPath } from '@cursor-pool/shared/paths';
+import { DEFAULT_RUNTIME_DIR } from '@cursor-pool/shared/runtime';
+import {
+  buildCursorAlwaysLocalTakeoverPatchSnippet,
+  containsAnyCursorAlwaysLocalTakeoverMarkerText,
+  containsCursorAlwaysLocalTakeoverMarker,
+} from './alwaysLocalMarker';
+import { sha256File } from './hash';
+
+export const CURSOR_ALWAYS_LOCAL_RELATIVE_PATH =
+  'Contents/Resources/app/extensions/cursor-always-local/dist/main.js';
+
+export type PatchCursorAlwaysLocalOptions = {
+  backupDir?: string;
+  patchContent?: (content: string) => string;
+  targetRelativePath?: string;
+};
+
+export type PatchCursorAlwaysLocalResult = {
+  targetPath: string;
+  backupPath: string;
+  beforeHash: string;
+  afterHash: string;
+  markerPresent: boolean;
+};
+
+function resolveHomePath(path: string) {
+  if (path.startsWith('~/')) {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+
+function resolveBackupDir(backupDir = join(DEFAULT_RUNTIME_DIR, 'backups')) {
+  return resolveHomePath(backupDir);
+}
+
+export function resolveCursorAlwaysLocalPath(
+  appPath: string,
+  targetRelativePath = CURSOR_ALWAYS_LOCAL_RELATIVE_PATH,
+) {
+  return joinCursorAppPath(appPath, targetRelativePath);
+}
+
+export async function backupPathForCursorAlwaysLocal(
+  appPath: string,
+  targetPath = resolveCursorAlwaysLocalPath(appPath),
+  backupDir?: string,
+) {
+  const appPathHash = createHash('sha256').update(appPath).digest('hex').slice(0, 16);
+  const targetPathHash = createHash('sha256')
+    .update(targetPath)
+    .digest('hex')
+    .slice(0, 16);
+  return join(
+    resolveBackupDir(backupDir),
+    `${basename(appPath).replaceAll('/', '_')}-${appPathHash}-${targetPathHash}.always-local.main.js.bak`,
+  );
+}
+
+function defaultPatchContent(content: string) {
+  if (containsCursorAlwaysLocalTakeoverMarker(content)) {
+    return content;
+  }
+  return `${content}${buildCursorAlwaysLocalTakeoverPatchSnippet()}`;
+}
+
+async function readBackupContent(backupPath: string) {
+  try {
+    return await readFile(backupPath, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error(`Patch backup is missing: ${backupPath}`);
+    }
+    throw error;
+  }
+}
+
+export async function validateUnpatchedAlwaysLocalBackup(backupPath: string) {
+  const backupContent = await readBackupContent(backupPath);
+  if (containsAnyCursorAlwaysLocalTakeoverMarkerText(backupContent)) {
+    throw new Error(`Patch backup contains patch marker and is unsafe: ${backupPath}`);
+  }
+  return backupContent;
+}
+
+export async function patchCursorAlwaysLocal(
+  appPath: string,
+  options: PatchCursorAlwaysLocalOptions = {},
+): Promise<PatchCursorAlwaysLocalResult> {
+  const targetPath = resolveCursorAlwaysLocalPath(appPath, options.targetRelativePath);
+  const beforeHash = await sha256File(targetPath);
+  const backupPath = await backupPathForCursorAlwaysLocal(
+    appPath,
+    targetPath,
+    options.backupDir,
+  );
+  const content = await readFile(targetPath, 'utf8');
+
+  if (containsCursorAlwaysLocalTakeoverMarker(content)) {
+    await validateUnpatchedAlwaysLocalBackup(backupPath);
+    return {
+      targetPath,
+      backupPath,
+      beforeHash,
+      afterHash: beforeHash,
+      markerPresent: true,
+    };
+  }
+
+  await mkdir(dirname(backupPath), { recursive: true });
+  await copyFile(targetPath, backupPath);
+
+  try {
+    const patchedContent = (options.patchContent ?? defaultPatchContent)(content);
+    await writeFile(targetPath, patchedContent, 'utf8');
+
+    const afterHash = await sha256File(targetPath);
+    const markerPresent = containsCursorAlwaysLocalTakeoverMarker(
+      await readFile(targetPath, 'utf8'),
+    );
+
+    if (!markerPresent) {
+      throw new Error('Patch did not write a valid patch marker pair.');
+    }
+
+    return {
+      targetPath,
+      backupPath,
+      beforeHash,
+      afterHash,
+      markerPresent,
+    };
+  } catch (error) {
+    await copyFile(backupPath, targetPath);
+    throw error;
+  }
+}