@gakim-digital/dexter-bridge 0.11.20 → 0.11.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gakim-digital/dexter-bridge",
-  "version": "0.11.20",
+  "version": "0.11.22",
   "description": "Local bridge for InstaWebAI and Dexter — runs Codex, Claude Code, or OpenCode on your machine.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -52,6 +52,7 @@ import {
 } from './nativeSkills.js';
 import { createLocalAgentAdapter } from './providers/index.js';
 import { discoverClaudeCodeModels } from './providers/claudeAgentSdk.js';
+import { cursorInstallCommand, cursorLauncher, readCursorVersion } from './providers/cursorAcp.js';
 import {
   collectOutcomeWorkspaceChanges,
   materializeModelTurnImages,
@@ -1531,6 +1532,8 @@ function controlCancellationSource(response) {
   return 'unknown';
 }
 
+const MAX_OUTCOME_DURATION_MS = 24 * 60 * 60 * 1000;
+
 function boundedDurationMs(value, fallback, minimum = 10, maximum = 60 * 60 * 1000) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) return fallback;
@@ -1734,6 +1737,26 @@ async function callProviderAdapter(
   }
 }
 
+// Cursor starts through its own launcher (on Windows, the bundled node.exe
+// behind cursor-agent.cmd), so its version is read through that launcher.
+async function resolveCursorRuntime(options = {}) {
+  const platform = options.platform || process.platform;
+  const launcher = cursorLauncher({
+    env: processEnvWithCliPath(options.env || process.env, platform),
+    platform,
+  });
+  const { error, output } = await readCursorVersion(launcher);
+  if (error) {
+    return {
+      ok: false,
+      command: launcher?.command || 'cursor-agent',
+      code: 'DEXTER_AGENT_NOT_FOUND',
+      error: `Cursor CLI is not installed. Run \`${cursorInstallCommand(platform)}\`, then \`cursor-agent login\`.`,
+    };
+  }
+  return { ok: true, command: launcher.command, output, version: parseAgentVersion(output) };
+}
+
 export async function resolveAgentRuntime(definition, modelDefinition, options = {}) {
   const platform = options.platform || process.platform;
   const childEnv = processEnvWithCliPath(options.env || process.env, platform);
@@ -2340,12 +2363,15 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
         ? requestedModel.trim()
         : definition.model
     );
+  // Dexter owns the run limit (a 2-hour safety limit for local runs), so it is
+  // not clamped here; the inactivity timeout below is the stall guard.
   const outcomeMaxDurationMs = boundedDurationMs(
     run?.outcome?.maxDurationMs
       ?? options.maxDurationMs
       ?? options.env?.DEXTER_BRIDGE_AGENT_MAX_DURATION_MS,
     20 * 60_000,
     1_000,
+    MAX_OUTCOME_DURATION_MS,
   );
   const outcomeInactivityTimeoutMs = Math.min(
     outcomeMaxDurationMs,
@@ -3331,12 +3357,14 @@ export async function checkAgentAvailability(agent, model, options = {}) {
   }
   const definition = definitionForAgent(normalizedAgent);
   const selectedModel = model ? companionModelDefinition(model?.id || model, normalizedAgent) : undefined;
-  const runtime = await resolveAgentRuntime(definition, selectedModel, {
-    env: options.env,
-    platform: options.platform,
-    existsSync: options.existsSync,
-    inspect: options.inspectRuntime,
-  });
+  const runtime = normalizedAgent === 'cursor' && !options.inspectRuntime
+    ? await resolveCursorRuntime(options)
+    : await resolveAgentRuntime(definition, selectedModel, {
+      env: options.env,
+      platform: options.platform,
+      existsSync: options.existsSync,
+      inspect: options.inspectRuntime,
+    });
   const supportedModels = companionModelsForAgent(normalizedAgent).filter((candidate) =>
     modelSupportsAgentVersion(candidate, runtime.version),
   );

package/src/providers/cursorAcp.js

@@ -108,15 +108,94 @@ export function parseCursorStatus(output) {
   };
 }
 
-function runCommand(command, args, env, timeoutMs = 15_000) {
+export const CURSOR_INSTALL_COMMAND = 'curl https://cursor.com/install -fsS | bash';
+export const CURSOR_WINDOWS_INSTALL_COMMAND = "irm 'https://cursor.com/install?win32=true' | iex";
+
+export function cursorInstallCommand(platform = process.platform) {
+  return platform === 'win32' ? CURSOR_WINDOWS_INSTALL_COMMAND : CURSOR_INSTALL_COMMAND;
+}
+
+const CURSOR_VERSION_DIRECTORY = /^(\d{4})\.(\d{1,2})\.(\d{1,2})(?:-\d{2}-\d{2}-\d{2})?-[a-f0-9]+$/;
+
+function cursorVersionRank(name) {
+  const [, year, month, day] = name.match(CURSOR_VERSION_DIRECTORY);
+  return Number(`${year}${month.padStart(2, '0')}${day.padStart(2, '0')}`);
+}
+
+// Same choice as Cursor's own cursor-agent.ps1: a build next to the launcher,
+// otherwise the newest build under versions\.
+function newestCursorBuild(root, fileSystem) {
+  const hasBuild = (directory) =>
+    fileSystem.existsSync(path.win32.join(directory, 'node.exe'))
+    && fileSystem.existsSync(path.win32.join(directory, 'index.js'));
+  if (hasBuild(root)) return root;
+  let names = [];
+  try {
+    names = fileSystem.readdirSync(path.win32.join(root, 'versions'));
+  } catch {
+    return null;
+  }
+  return names
+    .filter((name) => CURSOR_VERSION_DIRECTORY.test(name))
+    .sort((left, right) => cursorVersionRank(right) - cursorVersionRank(left) || right.localeCompare(left))
+    .map((name) => path.win32.join(root, 'versions', name))
+    .find(hasBuild) || null;
+}
+
+/**
+ * The command and leading arguments that start the Cursor CLI, or null when
+ * it is not installed. On Windows the CLI is a cursor-agent.cmd shim that runs
+ * PowerShell, which runs the node.exe bundled with the newest installed build.
+ * Node can start a .cmd only through a shell, and stopping that shell leaves
+ * Cursor running, so the bridge starts the bundled node.exe directly, as the
+ * shim does. The installer's folder is checked by path because a bridge that
+ * was already running does not see the PATH change the installer makes.
+ */
+export function cursorLauncher({ env = process.env, platform = process.platform, fileSystem = fs } = {}) {
+  const override = String(env.DEXTER_BRIDGE_CURSOR_BIN || '').trim();
+  if (platform !== 'win32') return { command: override || 'cursor-agent', args: [], env };
+  if (override && !/\.(cmd|bat|ps1)$/i.test(override)) return { command: override, args: [], env };
+  const roots = [
+    ...(override ? [path.win32.dirname(override)] : []),
+    ...String(env.PATH || env.Path || '')
+      .split(';')
+      .filter((directory) => directory && fileSystem.existsSync(path.win32.join(directory, 'cursor-agent.cmd'))),
+    ...(env.LOCALAPPDATA ? [path.win32.join(env.LOCALAPPDATA, 'cursor-agent')] : []),
+  ];
+  for (const root of new Set(roots)) {
+    const build = newestCursorBuild(root, fileSystem);
+    if (build) {
+      return {
+        command: path.win32.join(build, 'node.exe'),
+        args: [path.win32.join(build, 'index.js')],
+        env: { ...env, CURSOR_INVOKED_AS: 'cursor-agent.cmd' },
+      };
+    }
+  }
+  return null;
+}
+
+function notInstalledError(code = 'ENOENT') {
+  return Object.assign(new Error('Cursor CLI not found.'), { code });
+}
+
+function runCommand(launcher, args, timeoutMs = 15_000) {
+  if (!launcher) return Promise.resolve({ error: notInstalledError(), output: '' });
   return new Promise((resolve) => {
-    execFile(command, args, { env, timeout: timeoutMs }, (error, stdout, stderr) => {
-      resolve({ error, output: `${stdout || ''}${stderr || ''}`.trim() });
-    });
+    execFile(
+      launcher.command,
+      [...launcher.args, ...args],
+      { env: launcher.env, timeout: timeoutMs, windowsHide: true },
+      (error, stdout, stderr) => {
+        resolve({ error, output: `${stdout || ''}${stderr || ''}`.trim() });
+      },
+    );
   });
 }
 
-export const CURSOR_INSTALL_COMMAND = 'curl https://cursor.com/install -fsS | bash';
+export function readCursorVersion(launcher) {
+  return runCommand(launcher, ['--version']);
+}
 
 function runInteractive(command, args, env, spawnImpl) {
   return new Promise((resolve) => {
@@ -126,6 +205,17 @@ function runInteractive(command, args, env, spawnImpl) {
   });
 }
 
+function installCursorCli(platform, env, spawnImpl) {
+  return platform === 'win32'
+    ? runInteractive(
+      'powershell.exe',
+      ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', CURSOR_WINDOWS_INSTALL_COMMAND],
+      env,
+      spawnImpl,
+    )
+    : runInteractive('bash', ['-c', CURSOR_INSTALL_COMMAND], env, spawnImpl);
+}
+
 function setupError(message) {
   return Object.assign(new Error(message), { code: 'CURSOR_SETUP_INCOMPLETE', exitCode: 2 });
 }
@@ -137,28 +227,31 @@ function setupError(message) {
  */
 export async function setUpCursorCli({
   env = process.env,
-  command = env.DEXTER_BRIDGE_CURSOR_BIN || 'cursor-agent',
   confirm,
   log = console.log,
   platform = process.platform,
+  findCursor = () => cursorLauncher({ env, platform }),
   run = runCommand,
   spawnImpl = spawn,
 } = {}) {
+  const installCommand = cursorInstallCommand(platform);
+  let launcher = null;
   const readStatus = async () => {
-    const result = await run(command, ['status'], env);
-    if (result.error?.code === 'ENOENT') return { installed: false, signedIn: false };
+    launcher = findCursor();
+    const result = await run(launcher, ['status']);
+    if (!launcher || result.error?.code === 'ENOENT') return { installed: false, signedIn: false };
     return { installed: true, ...parseCursorStatus(result.output) };
   };
   let status = await readStatus();
   if (!status.installed) {
-    if (platform === 'win32' || !confirm) {
-      throw setupError(`Cursor CLI is not installed. Run \`${CURSOR_INSTALL_COMMAND}\`, then run this command again.`);
+    if (!confirm) {
+      throw setupError(`Cursor CLI is not installed. Run \`${installCommand}\`, then run this command again.`);
     }
     if (!(await confirm('Cursor CLI is not installed. Install it now? (Y/n) '))) {
       throw setupError('Cursor CLI is required to connect Cursor to Dexter.');
     }
-    if (!(await runInteractive('bash', ['-c', CURSOR_INSTALL_COMMAND], env, spawnImpl))) {
-      throw setupError(`Cursor CLI install failed. Run \`${CURSOR_INSTALL_COMMAND}\` yourself, then run this command again.`);
+    if (!(await installCursorCli(platform, env, spawnImpl))) {
+      throw setupError(`Cursor CLI install failed. Run \`${installCommand}\` yourself, then run this command again.`);
     }
     status = await readStatus();
     if (!status.installed) {
@@ -170,7 +263,7 @@ export async function setUpCursorCli({
       throw setupError('Cursor is not signed in. Run `cursor-agent login`, then run this command again.');
     }
     log('Sign in to Cursor in your browser…');
-    await runInteractive(command, ['login'], env, spawnImpl);
+    await runInteractive(launcher.command, [...launcher.args, 'login'], launcher.env, spawnImpl);
     status = await readStatus();
     if (!status.signedIn) {
       throw setupError('Cursor sign-in did not finish. Run this command again to retry.');
@@ -183,24 +276,28 @@ export async function setUpCursorCli({
 export function createCursorAcpAdapter({
   env = process.env,
   trace,
-  command = env.DEXTER_BRIDGE_CURSOR_BIN || 'cursor-agent',
+  platform = process.platform,
+  findCursor = () => cursorLauncher({ env, platform }),
   models = [],
   createClient = createJsonRpcClient,
 } = {}) {
   const activeTurns = new Map();
+  const notInstalledMessage =
+    `Cursor CLI is not installed. Run \`${cursorInstallCommand(platform)}\`, then \`cursor-agent login\`.`;
 
   async function detect() {
-    const version = await runCommand(command, ['--version'], env);
+    const launcher = findCursor();
+    const version = await runCommand(launcher, ['--version']);
     if (version.error) {
       return {
         ok: false,
         installed: false,
         signedIn: false,
         agent: 'cursor',
-        error: 'Cursor CLI is not installed. Run `curl https://cursor.com/install -fsS | bash`, then `cursor-agent login`.',
+        error: notInstalledMessage,
       };
     }
-    const status = parseCursorStatus((await runCommand(command, ['status'], env)).output);
+    const status = parseCursorStatus((await runCommand(launcher, ['status'])).output);
     return {
       ok: status.signedIn,
       installed: true,
@@ -228,6 +325,10 @@ export function createCursorAcpAdapter({
   }) {
     const turnKey = sessionId || runId;
     if (!turnKey) throw new Error('A Cursor turn requires a session id.');
+    const launcher = findCursor();
+    if (!launcher) {
+      throw Object.assign(new Error(notInstalledMessage), { code: 'DEXTER_AGENT_NOT_FOUND', retryable: false });
+    }
     const temporaryWorkspace = cwd
       ? null
       : fs.mkdtempSync(path.join(os.tmpdir(), 'dexter-cursor-'));
@@ -267,9 +368,9 @@ export function createCursorAcpAdapter({
     };
 
     const client = createClient({
-      command,
-      args: ['acp'],
-      env,
+      command: launcher.command,
+      args: [...launcher.args, 'acp'],
+      env: launcher.env,
       cwd: workspace,
       onServerRequest: async (message) => {
         if (message.method === 'session/request_permission') {

package/src/runtimeProfiles.js

@@ -1,5 +1,6 @@
 import crypto from 'node:crypto';
 import { createLocalAgentAdapter } from './providers/index.js';
+import { cursorInstallCommand } from './providers/cursorAcp.js';
 
 const DRIVER_LABELS = {
   'codex-app-server': 'Codex',
@@ -174,7 +175,7 @@ export function diagnosticsFromAgentCheck(check, env = process.env) {
       check?.error || `${label} is not installed on this computer.`,
       {
         codex: 'Install Codex (npm i -g @openai/codex), then restart the bridge.',
-        cursor: 'Install the Cursor CLI (curl https://cursor.com/install -fsS | bash), then restart the bridge.',
+        cursor: `Install the Cursor CLI (${cursorInstallCommand()}), then restart the bridge.`,
       }[check?.agent]
         || 'Install Claude Code (npm i -g @anthropic-ai/claude-code), then restart the bridge.',
     );