@shepai/cli 1.120.0-pr360.cadec27 → 1.120.0-pr381.69e0404

package/dist/packages/core/src/infrastructure/services/agents/common/agent-executor-factory.service.js

@@ -45,7 +45,7 @@ export class AgentExecutorFactory {
                 executor = new ClaudeCodeExecutorService(this.spawn);
                 break;
             case 'cursor':
-                executor = new CursorExecutorService(this.spawn);
+                executor = new CursorExecutorService(this.spawn, _authConfig);
                 break;
             case 'dev':
                 executor = new DevAgentExecutorService();

package/dist/packages/core/src/infrastructure/services/agents/common/executors/cursor-executor.service.d.ts

@@ -8,7 +8,7 @@
  * Uses constructor dependency injection for the spawn function
  * to enable testability without mocking node:child_process directly.
  */
-import type { AgentType, AgentFeature } from '../../../../../domain/generated/output.js';
+import type { AgentType, AgentFeature, AgentConfig } from '../../../../../domain/generated/output.js';
 import type { IAgentExecutor, AgentExecutionOptions, AgentExecutionResult, AgentExecutionStreamEvent } from '../../../../../application/ports/output/agents/agent-executor.interface.js';
 import type { SpawnFunction } from '../types.js';
 /**
@@ -17,10 +17,11 @@ import type { SpawnFunction } from '../types.js';
  */
 export declare class CursorExecutorService implements IAgentExecutor {
     private readonly spawn;
+    private readonly authConfig?;
     readonly agentType: AgentType;
     /** When true, suppresses debug logging (set per-call via options.silent) */
     private silent;
-    constructor(spawn: SpawnFunction);
+    constructor(spawn: SpawnFunction, authConfig?: AgentConfig | undefined);
     /** Debug logging — writes to stdout so it appears in the worker log file */
     private log;
     supportsFeature(feature: AgentFeature): boolean;
@@ -33,16 +34,35 @@ export declare class CursorExecutorService implements IAgentExecutor {
     private buildArgs;
     private buildStreamArgs;
     /**
-     * Spawn the agent process, handling Windows specially via PowerShell.
+     * Resolve the cursor CLI's bundled node.exe and index.js paths on Windows.
      *
-     * On Windows, cursor CLI ships as `agent.cmd` which requires `shell: true`,
-     * but cmd.exe mangles long `-p` arguments (8191-char limit + special chars).
-     * Solution: write prompt to a temp file, invoke agent via PowerShell which
-     * reads the file and passes the content as `-p`. PowerShell handles long
-     * strings natively (32K limit) and doesn't mangle arguments.
+     * The cursor CLI installs to `%LOCALAPPDATA%\cursor-agent\` with:
+     *   - `agent.cmd` / `cursor-agent.ps1` (shell wrappers)
+     *   - `versions/<YYYY.MM.DD-commit>/node.exe` + `index.js`
+     *
+     * Spawning via agent.cmd creates a problematic nesting chain:
+     *   PowerShell → agent.cmd → PowerShell → cursor-agent.ps1 → node.exe
+     * This chain hangs on Windows CI runners. Direct invocation bypasses it.
+     *
+     * @returns `{ nodePath, indexPath }` or `undefined` if not found
+     */
+    private resolveCursorBinary;
+    /**
+     * Spawn the agent process, handling Windows specially.
+     *
+     * On Windows, the cursor CLI ships as `agent.cmd` which spawns PowerShell
+     * which runs `cursor-agent.ps1` which runs `node.exe index.js`. This triple
+     * nesting (PowerShell → cmd.exe → PowerShell → node.exe) hangs on Windows
+     * CI runners. Solution: resolve the cursor CLI's bundled `node.exe` and
+     * `index.js` directly, bypassing all shell wrappers.
      *
      * On Linux/macOS, spawn `agent` directly — no shell needed.
      */
+    /**
+     * Build the subprocess environment: strip CLAUDECODE, inject CURSOR_API_KEY
+     * from authConfig when token auth is configured.
+     */
+    private buildEnv;
     private spawnAgent;
     private parseStreamLine;
 }

package/dist/packages/core/src/infrastructure/services/agents/common/executors/cursor-executor.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cursor-executor.service.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/common/executors/cursor-executor.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EAC1B,MAAM,4EAA4E,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAuBjD;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,cAAc;IAM9C,OAAO,CAAC,QAAQ,CAAC,KAAK;IALlC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAyB;IAEtD,4EAA4E;IAC5E,OAAO,CAAC,MAAM,CAAS;gBAEM,KAAK,EAAE,aAAa;IAEjD,4EAA4E;IAC5E,OAAO,CAAC,GAAG;IAMX,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAIzC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAoItF,aAAa,CAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,CAAC,yBAAyB,CAAC;IAkF3C;;OAEG;IACH,OAAO,CAAC,cAAc;IAkCtB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,eAAe;IAOvB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,UAAU;IA2DlB,OAAO,CAAC,eAAe;CAgDxB"}
+{"version":3,"file":"cursor-executor.service.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/common/executors/cursor-executor.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACZ,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EAC1B,MAAM,4EAA4E,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAuBjD;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,cAAc;IAOxD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;IAP9B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAyB;IAEtD,4EAA4E;IAC5E,OAAO,CAAC,MAAM,CAAS;gBAGJ,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,WAAW,YAAA;IAG3C,4EAA4E;IAC5E,OAAO,CAAC,GAAG;IAMX,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAIzC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA2MtF,aAAa,CAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,CAAC,yBAAyB,CAAC;IAiH3C;;OAEG;IACH,OAAO,CAAC,cAAc;IAyCtB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,eAAe;IAOvB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,mBAAmB;IAwC3B;;;;;;;;;;OAUG;IACH;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,UAAU;IA+ElB,OAAO,CAAC,eAAe;CAgDxB"}

package/dist/packages/core/src/infrastructure/services/agents/common/executors/cursor-executor.service.js

@@ -8,7 +8,7 @@
  * Uses constructor dependency injection for the spawn function
  * to enable testability without mocking node:child_process directly.
  */
-import { writeFileSync, unlinkSync } from 'node:fs';
+import { writeFileSync, unlinkSync, readdirSync, existsSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -36,11 +36,13 @@ const SUPPORTED_FEATURES = new Set(['session-resume', 'streaming']);
  */
 export class CursorExecutorService {
     spawn;
+    authConfig;
     agentType = 'cursor';
     /** When true, suppresses debug logging (set per-call via options.silent) */
     silent = false;
-    constructor(spawn) {
+    constructor(spawn, authConfig) {
         this.spawn = spawn;
+        this.authConfig = authConfig;
     }
     /** Debug logging — writes to stdout so it appears in the worker log file */
     log(message) {
@@ -58,19 +60,34 @@ export class CursorExecutorService {
         // stream-json is unreliable on Windows where shell: true can mangle args.
         const args = this.buildArgs(prompt, options);
         const { proc, tmpFile } = this.spawnAgent(prompt, args, options);
+        // Diagnostic: verify streams are connected and process is alive
+        this.log(`[diag] proc.pid=${proc.pid}, killed=${proc.killed}`);
+        this.log(`[diag] stdout=${!!proc.stdout}, stderr=${!!proc.stderr}, stdin=${!!proc.stdin}`);
+        this.log(`[diag] CURSOR_API_KEY set=${!!process.env.CURSOR_API_KEY}, len=${process.env.CURSOR_API_KEY?.length ?? 0}`);
+        this.log(`[diag] authConfig.token set=${!!this.authConfig?.token}, method=${this.authConfig?.authMethod ?? 'none'}`);
+        this.log(`[diag] platform=${process.platform}, cwd=${options?.cwd ?? '(inherited)'}`);
         return new Promise((resolve, reject) => {
             let lineBuffer = '';
             let stderr = '';
             let timedOut = false;
             let timeoutId;
+            let stdoutChunks = 0;
+            let stderrChunks = 0;
+            const startTime = Date.now();
             // Accumulated from JSON events or raw text fallback
             let resultText = '';
             let rawText = '';
             let sessionId;
             let metadata;
+            // Periodic heartbeat to prove the executor is alive and waiting
+            const heartbeatId = setInterval(() => {
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                this.log(`[diag] heartbeat ${elapsed}s: stdout_chunks=${stdoutChunks}, stderr_chunks=${stderrChunks}, pid_killed=${proc.killed}`);
+            }, 15_000);
             if (options?.timeout) {
                 timeoutId = setTimeout(() => {
                     timedOut = true;
+                    this.log(`[diag] TIMEOUT after ${options.timeout}ms — killing process tree`);
                     // On Windows, proc.kill() may not kill the entire process tree
                     // (PowerShell + child agent process). Use taskkill /T for tree kill.
                     if (process.platform === 'win32' && proc.pid) {
@@ -78,9 +95,11 @@ export class CursorExecutorService {
                             execFileSync('taskkill', ['/F', '/T', '/PID', String(proc.pid)], {
                                 stdio: 'ignore',
                             });
+                            this.log(`[diag] taskkill /T /PID ${proc.pid} succeeded`);
                         }
                         catch {
                             proc.kill();
+                            this.log(`[diag] taskkill failed, fell back to proc.kill()`);
                         }
                     }
                     else {
@@ -107,17 +126,35 @@ export class CursorExecutorService {
                         if (parsed.duration_ms !== undefined) {
                             metadata = { ...metadata, duration_ms: parsed.duration_ms };
                         }
+                        if (parsed.is_error) {
+                            this.log(`[diag] result event has is_error=true: ${JSON.stringify(parsed).slice(0, 300)}`);
+                        }
+                    }
+                    else if (parsed.type === 'error') {
+                        this.log(`[diag] cursor error event: ${JSON.stringify(parsed).slice(0, 500)}`);
+                    }
+                    else if (parsed.type !== 'user' &&
+                        parsed.type !== 'system' &&
+                        parsed.type !== 'thinking' &&
+                        parsed.type !== 'tool_call') {
+                        this.log(`[diag] unknown event type="${parsed.type}": ${JSON.stringify(parsed).slice(0, 300)}`);
                     }
-                    // user, system, thinking events: logged but don't affect result
                 }
                 catch {
                     // Non-JSON output — accumulate as raw text fallback
-                    if (line.length > 0)
+                    if (line.length > 0) {
                         rawText += `${line}\n`;
+                        this.log(`[diag] non-JSON line (${line.length} chars): ${line.slice(0, 200)}`);
+                    }
                 }
             };
             proc.stdout?.on('data', (chunk) => {
-                lineBuffer += chunk.toString();
+                stdoutChunks++;
+                const data = chunk.toString();
+                if (stdoutChunks <= 3) {
+                    this.log(`[diag] stdout chunk #${stdoutChunks}: ${data.length} bytes, first 200: ${data.slice(0, 200).replace(/\n/g, '\\n')}`);
+                }
+                lineBuffer += data;
                 const lines = lineBuffer.split('\n');
                 lineBuffer = lines.pop() ?? '';
                 for (const line of lines) {
@@ -127,19 +164,22 @@ export class CursorExecutorService {
                 }
             });
             proc.stderr?.on('data', (chunk) => {
+                stderrChunks++;
                 const data = chunk.toString();
                 stderr += data;
-                this.log(`stderr: ${data.trimEnd()}`);
+                this.log(`[diag] stderr chunk #${stderrChunks}: ${data.trimEnd()}`);
                 // Detect fatal errors early so callers don't waste time retrying
                 if (data.includes('Cannot use this model')) {
                     if (timeoutId)
                         clearTimeout(timeoutId);
+                    clearInterval(heartbeatId);
                     proc.kill();
                     reject(new Error(data.trim()));
                 }
             });
             proc.on('error', (error) => {
-                this.log(`Process error event: ${error.message}`);
+                this.log(`[diag] Process ERROR event: ${error.message} (code=${error.code})`);
+                clearInterval(heartbeatId);
                 if (timeoutId)
                     clearTimeout(timeoutId);
                 if (error.code === 'ENOENT') {
@@ -150,6 +190,8 @@ export class CursorExecutorService {
                 }
             });
             proc.on('close', (code) => {
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                clearInterval(heartbeatId);
                 // Clean up temp file on Windows
                 if (tmpFile) {
                     try {
@@ -163,7 +205,7 @@ export class CursorExecutorService {
                     processLine(lineBuffer.trim());
                 // Use raw text as fallback when no JSON result was captured
                 const finalText = resultText || rawText.trim();
-                this.log(`Process closed with code ${code}, result=${finalText.length} chars`);
+                this.log(`[diag] Process CLOSE: code=${code}, elapsed=${elapsed}s, stdout_chunks=${stdoutChunks}, stderr_chunks=${stderrChunks}, result=${finalText.length} chars, raw=${rawText.length} chars`);
                 if (timeoutId)
                     clearTimeout(timeoutId);
                 if (timedOut) {
@@ -171,9 +213,17 @@ export class CursorExecutorService {
                     return;
                 }
                 if (code !== 0 && code !== null) {
-                    reject(new Error(stderr.trim() || `Process exited with code ${code}`));
+                    const errMsg = stderr.trim() || `Process exited with code ${code}`;
+                    this.log(`[diag] non-zero exit — rejecting with: ${errMsg.slice(0, 200)}`);
+                    reject(new Error(errMsg));
                     return;
                 }
+                if (stdoutChunks === 0 && stderrChunks === 0) {
+                    this.log(`[diag] WARNING: process exited with code 0 but produced ZERO output (stdout=0, stderr=0, elapsed=${elapsed}s)`);
+                }
+                if (!finalText && code === 0) {
+                    this.log(`[diag] WARNING: process exited code=0 but result is empty (resultText=${resultText.length}, rawText=${rawText.length})`);
+                }
                 const result = { result: finalText };
                 if (sessionId)
                     result.sessionId = sessionId;
@@ -184,20 +234,25 @@ export class CursorExecutorService {
         });
     }
     async *executeStream(prompt, options) {
+        this.silent = options?.silent ?? false;
         const args = this.buildStreamArgs(prompt, options);
         const { proc, tmpFile } = this.spawnAgent(prompt, args, options);
+        this.log(`[stream] pid=${proc.pid}, stdout=${!!proc.stdout}, stderr=${!!proc.stderr}`);
         let lineBuffer = '';
         let stderr = '';
+        let stdoutChunks = 0;
+        let stderrChunks = 0;
+        const startTime = Date.now();
         const queue = [];
         let resolve = null;
         let error = null;
-        function enqueue(event) {
+        const enqueue = (event) => {
             queue.push(event);
             if (resolve) {
                 resolve();
                 resolve = null;
             }
-        }
+        };
         function waitForItem() {
             if (queue.length > 0)
                 return Promise.resolve();
@@ -205,8 +260,18 @@ export class CursorExecutorService {
                 resolve = r;
             });
         }
+        // Heartbeat for stream mode too
+        const heartbeatId = setInterval(() => {
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            this.log(`[stream] heartbeat ${elapsed}s: stdout_chunks=${stdoutChunks}, stderr_chunks=${stderrChunks}, pid_killed=${proc.killed}`);
+        }, 30_000);
         proc.stdout?.on('data', (chunk) => {
-            lineBuffer += chunk.toString();
+            stdoutChunks++;
+            const data = chunk.toString();
+            if (stdoutChunks <= 3) {
+                this.log(`[stream] stdout chunk #${stdoutChunks}: ${data.length} bytes`);
+            }
+            lineBuffer += data;
             const lines = lineBuffer.split('\n');
             lineBuffer = lines.pop() ?? '';
             for (const line of lines) {
@@ -219,13 +284,21 @@ export class CursorExecutorService {
             }
         });
         proc.stderr?.on('data', (chunk) => {
-            stderr += chunk.toString();
+            stderrChunks++;
+            const data = chunk.toString();
+            stderr += data;
+            this.log(`[stream] stderr chunk #${stderrChunks}: ${data.trimEnd()}`);
         });
         proc.on('error', (err) => {
+            this.log(`[stream] Process ERROR: ${err.message}`);
+            clearInterval(heartbeatId);
             error = err;
             enqueue(null);
         });
         proc.on('close', (code) => {
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            clearInterval(heartbeatId);
+            this.log(`[stream] Process CLOSE: code=${code}, elapsed=${elapsed}s, stdout_chunks=${stdoutChunks}, stderr_chunks=${stderrChunks}`);
             if (tmpFile) {
                 try {
                     unlinkSync(tmpFile);
@@ -239,8 +312,10 @@ export class CursorExecutorService {
                 if (event)
                     enqueue(event);
             }
-            if (code !== 0 && code !== null && stderr.trim()) {
-                enqueue({ type: 'error', content: stderr.trim(), timestamp: new Date() });
+            if (code !== 0 && code !== null) {
+                const errMsg = stderr.trim() || `Process exited with code ${code}`;
+                this.log(`[stream] non-zero exit: ${errMsg}`);
+                enqueue({ type: 'error', content: errMsg, timestamp: new Date() });
             }
             enqueue(null);
         });
@@ -286,6 +361,10 @@ export class CursorExecutorService {
             }
             if (parsed.type === 'user')
                 return; // Skip echoed input
+            // Log any unrecognized event type so nothing is silently dropped
+            if (!['assistant', 'tool_call', 'result', 'user', 'system', 'thinking'].includes(parsed.type)) {
+                this.log(`[diag] unhandled stream event type="${parsed.type}": ${line.slice(0, 200)}`);
+            }
         }
         catch {
             if (line.length > 0)
@@ -310,36 +389,115 @@ export class CursorExecutorService {
         return args;
     }
     /**
-     * Spawn the agent process, handling Windows specially via PowerShell.
+     * Resolve the cursor CLI's bundled node.exe and index.js paths on Windows.
+     *
+     * The cursor CLI installs to `%LOCALAPPDATA%\cursor-agent\` with:
+     *   - `agent.cmd` / `cursor-agent.ps1` (shell wrappers)
+     *   - `versions/<YYYY.MM.DD-commit>/node.exe` + `index.js`
      *
-     * On Windows, cursor CLI ships as `agent.cmd` which requires `shell: true`,
-     * but cmd.exe mangles long `-p` arguments (8191-char limit + special chars).
-     * Solution: write prompt to a temp file, invoke agent via PowerShell which
-     * reads the file and passes the content as `-p`. PowerShell handles long
-     * strings natively (32K limit) and doesn't mangle arguments.
+     * Spawning via agent.cmd creates a problematic nesting chain:
+     *   PowerShell → agent.cmd → PowerShell → cursor-agent.ps1 → node.exe
+     * This chain hangs on Windows CI runners. Direct invocation bypasses it.
+     *
+     * @returns `{ nodePath, indexPath }` or `undefined` if not found
+     */
+    resolveCursorBinary() {
+        const localAppData = process.env.LOCALAPPDATA;
+        if (!localAppData) {
+            this.log('[diag] resolveCursorBinary: LOCALAPPDATA not set');
+            return undefined;
+        }
+        const versionsDir = join(localAppData, 'cursor-agent', 'versions');
+        if (!existsSync(versionsDir)) {
+            this.log(`[diag] resolveCursorBinary: versions dir not found: ${versionsDir}`);
+            return undefined;
+        }
+        // Find the latest version directory (format: YYYY.MM.DD-commit)
+        const versionPattern = /^\d{4}\.\d{1,2}\.\d{1,2}-[a-f0-9]+$/;
+        const versions = readdirSync(versionsDir)
+            .filter((d) => versionPattern.test(d))
+            .sort()
+            .reverse();
+        if (versions.length === 0) {
+            this.log(`[diag] resolveCursorBinary: no version dirs in ${versionsDir}`);
+            return undefined;
+        }
+        const versionDir = join(versionsDir, versions[0]);
+        const nodePath = join(versionDir, 'node.exe');
+        const indexPath = join(versionDir, 'index.js');
+        if (!existsSync(nodePath) || !existsSync(indexPath)) {
+            this.log(`[diag] resolveCursorBinary: missing binary — node=${existsSync(nodePath)}, index=${existsSync(indexPath)}`);
+            return undefined;
+        }
+        this.log(`[diag] resolveCursorBinary: resolved version=${versions[0]}`);
+        return { nodePath, indexPath };
+    }
+    /**
+     * Spawn the agent process, handling Windows specially.
+     *
+     * On Windows, the cursor CLI ships as `agent.cmd` which spawns PowerShell
+     * which runs `cursor-agent.ps1` which runs `node.exe index.js`. This triple
+     * nesting (PowerShell → cmd.exe → PowerShell → node.exe) hangs on Windows
+     * CI runners. Solution: resolve the cursor CLI's bundled `node.exe` and
+     * `index.js` directly, bypassing all shell wrappers.
      *
      * On Linux/macOS, spawn `agent` directly — no shell needed.
      */
-    spawnAgent(prompt, args, options) {
+    /**
+     * Build the subprocess environment: strip CLAUDECODE, inject CURSOR_API_KEY
+     * from authConfig when token auth is configured.
+     */
+    buildEnv(extra) {
         const { CLAUDECODE: _, ...cleanEnv } = process.env;
+        // Inject CURSOR_API_KEY from stored settings so the cursor CLI authenticates
+        // even when the env var isn't inherited (e.g. direct node.exe invocation on Windows).
+        if (this.authConfig?.authMethod === 'token' && this.authConfig.token) {
+            cleanEnv.CURSOR_API_KEY = this.authConfig.token;
+            this.log(`[diag] buildEnv: injected CURSOR_API_KEY from authConfig (${this.authConfig.token.length} chars)`);
+        }
+        else {
+            this.log(`[diag] buildEnv: NO token injection (authMethod=${this.authConfig?.authMethod ?? 'none'}, hasToken=${!!this.authConfig?.token}, envKey=${!!cleanEnv.CURSOR_API_KEY})`);
+        }
+        const env = extra ? { ...cleanEnv, ...extra } : cleanEnv;
+        this.log(`[diag] buildEnv: final CURSOR_API_KEY in env=${!!env.CURSOR_API_KEY}, len=${env.CURSOR_API_KEY?.length ?? 0}`);
+        return env;
+    }
+    spawnAgent(prompt, args, options) {
         const cwd = options?.cwd;
         if (IS_WINDOWS) {
-            // Write prompt to temp file to bypass cmd.exe argument mangling
+            const resolved = this.resolveCursorBinary();
+            if (resolved) {
+                // Direct invocation: node.exe index.js <args>
+                // No shell wrappers, no nesting, no hangs.
+                const directArgs = [resolved.indexPath, ...args];
+                this.log(`Windows direct mode: ${resolved.nodePath}`);
+                this.log(`Args: ${directArgs.map((a) => (a.length > 80 ? `${a.slice(0, 77)}...` : a)).join(' ')}`);
+                const proc = this.spawn(resolved.nodePath, directArgs, {
+                    cwd,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    windowsHide: true,
+                    env: this.buildEnv({ CURSOR_INVOKED_AS: 'agent' }),
+                });
+                this.log(`Direct PID: ${proc.pid ?? 'undefined (spawn may have failed)'}`);
+                if (proc.stdin)
+                    proc.stdin.end();
+                return { proc, tmpFile: undefined };
+            }
+            // Fallback: if direct resolution fails, use PowerShell + temp file
+            this.log('[diag] Windows fallback: cursor binary not resolved, using PowerShell + temp file');
             const tmpFile = join(tmpdir(), `shep-cursor-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.txt`);
             writeFileSync(tmpFile, prompt, 'utf8');
-            // Build the agent args WITHOUT -p and the prompt (they go via temp file)
             const agentFlags = args.filter((a) => a !== '-p' && a !== prompt).join(' ');
             const safePath = tmpFile.replace(/'/g, "''");
             const psCmd = `$p = Get-Content -Raw '${safePath}'; & agent ${agentFlags} -p $p`;
-            this.log(`Windows PowerShell mode: wrote ${prompt.length} chars to ${tmpFile}`);
-            this.log(`PS command: ${psCmd.replace(prompt, `<${prompt.length} chars>`)}`);
+            this.log(`[diag] PS command: ${psCmd.replace(prompt, `<${prompt.length} chars>`)}`);
             const proc = this.spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', psCmd], {
                 cwd,
                 stdio: ['pipe', 'pipe', 'pipe'],
                 windowsHide: true,
-                env: cleanEnv,
+                env: this.buildEnv(),
             });
-            this.log(`PowerShell PID: ${proc.pid ?? 'undefined (spawn may have failed)'}`);
+            this.log(`[diag] PowerShell PID: ${proc.pid ?? 'undefined (spawn may have failed)'}`);
             if (proc.stdin)
                 proc.stdin.end();
             return { proc, tmpFile };
@@ -347,7 +505,7 @@ export class CursorExecutorService {
         // Linux/macOS: spawn agent directly, no shell needed
         const spawnOpts = {
             stdio: ['pipe', 'pipe', 'pipe'],
-            env: cleanEnv,
+            env: this.buildEnv(),
         };
         if (cwd)
             spawnOpts.cwd = cwd;

package/dist/packages/core/src/infrastructure/services/tool-installer/tool-installer.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-installer.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/tool-installer/tool-installer.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sEAAsE,CAAC;AAClH,OAAO,KAAK,EACV,sBAAsB,EACtB,kBAAkB,EAEnB,MAAM,qCAAqC,CAAC;AA2B7C,qBACa,wBAAyB,YAAW,qBAAqB;IACpE;;;OAGG;IACG,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAoC1E;;;OAGG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAqB9D;;;OAGG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAChC,OAAO,CAAC,sBAAsB,CAAC;IAwFlC;;OAEG;IACH,OAAO,CAAC,6BAA6B;CA4BtC"}
+{"version":3,"file":"tool-installer.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/tool-installer/tool-installer.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sEAAsE,CAAC;AAClH,OAAO,KAAK,EACV,sBAAsB,EACtB,kBAAkB,EAEnB,MAAM,qCAAqC,CAAC;AA2B7C,qBACa,wBAAyB,YAAW,qBAAqB;IACpE;;;OAGG;IACG,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAoC1E;;;OAGG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAqB9D;;;OAGG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAChC,OAAO,CAAC,sBAAsB,CAAC;IAgFlC;;OAEG;IACH,OAAO,CAAC,6BAA6B;CA4BtC"}

package/dist/packages/core/src/infrastructure/services/tool-installer/tool-installer.service.js

@@ -107,14 +107,9 @@ let ToolInstallerServiceImpl = class ToolInstallerServiceImpl {
         }
         return new Promise((resolve) => {
             let output = '';
-            // Inherit stdin when running in an interactive terminal so that commands
-            // requiring sudo can prompt the user for a password. In non-interactive
-            // contexts (web UI, CI) stdin is piped and closed immediately to prevent
-            // the process from hanging waiting for input.
-            const isInteractive = process.stdin.isTTY === true;
             const child = spawn(installCommand.command, [], {
                 shell: true,
-                stdio: [isInteractive ? 'inherit' : 'pipe', 'pipe', 'pipe'],
+                stdio: ['pipe', 'pipe', 'pipe'],
                 env: {
                     ...process.env,
                     DEBIAN_FRONTEND: 'noninteractive',
@@ -122,10 +117,8 @@ let ToolInstallerServiceImpl = class ToolInstallerServiceImpl {
                     GPG_TTY: '',
                 },
             });
-            // Close stdin in non-interactive mode to prevent prompts from hanging
-            if (!isInteractive) {
-                child.stdin?.end();
-            }
+            // Close stdin immediately to prevent interactive prompts
+            child.stdin?.end();
             // Stream output from stdout and stderr
             const pipeOutput = (stream) => {
                 if (!stream)

package/dist/packages/core/src/infrastructure/services/tool-installer/tools/claude-code.json

@@ -8,21 +8,17 @@
   "platforms": ["linux", "darwin", "win32"],
   "iconUrl": "https://cdn.simpleicons.org/claude",
   "binary": "claude",
-  "packageManager": "npm",
+  "packageManager": "curl",
   "commands": {
-    "linux": "npm install -g @anthropic-ai/claude-code",
-    "darwin": "npm install -g @anthropic-ai/claude-code",
+    "linux": "curl -fsSL https://claude.ai/install.sh | bash",
+    "darwin": "curl -fsSL https://claude.ai/install.sh | bash",
     "win32": "npm install -g @anthropic-ai/claude-code"
   },
   "timeout": 300000,
-  "documentationUrl": "https://docs.anthropic.com/en/docs/claude-code/overview",
+  "documentationUrl": "https://code.claude.com/docs/en/overview",
   "verifyCommand": "claude --version",
   "autoInstall": true,
-  "openDirectory": {
-    "linux": "cd {dir} && exec claude",
-    "darwin": "cd {dir} && exec claude",
-    "win32": "cd /d {dir} && claude"
-  },
+  "openDirectory": "cd {dir} && exec claude",
   "spawnOptions": {
     "shell": true,
     "stdio": "inherit",
@@ -30,7 +26,6 @@
   },
   "terminalCommand": {
     "linux": "x-terminal-emulator -e bash -c 'cd {dir} && exec claude'",
-    "darwin": "osascript -e 'tell application \"Terminal\" to do script \"cd {dir} && exec claude\"'",
-    "win32": "start cmd /k \"cd /d {dir} && claude\""
+    "darwin": "open -a Terminal.app bash -c 'cd {dir} && exec claude'"
   }
 }

package/dist/src/presentation/cli/commands/install.command.js

@@ -117,14 +117,7 @@ function printInstallInstructions(metadata) {
     // Print open directory command if available
     if (metadata.openDirectory) {
         console.log(fmt.heading('Open Directory'));
-        if (typeof metadata.openDirectory === 'string') {
-            console.log(`${colors.muted('$')} ${metadata.openDirectory}`);
-        }
-        else {
-            for (const [platform, cmd] of Object.entries(metadata.openDirectory)) {
-                console.log(`${colors.muted(`[${platform}]`)} ${cmd}`);
-            }
-        }
+        console.log(`${colors.muted('$')} ${metadata.openDirectory}`);
         console.log();
     }
     // Print documentation link

package/dist/src/presentation/web/app/actions/check-agent-auth.d.ts

@@ -10,8 +10,6 @@ export interface AgentAuthStatus {
     binaryName: string | null;
     /** Instructions to authenticate if not authenticated */
     authCommand: string | null;
-    /** Platform-resolved install command (e.g. "npm install -g @google/gemini-cli") */
-    installCommand: string | null;
 }
 /**
  * Check agent tool installation + auth status.

package/dist/src/presentation/web/app/actions/check-agent-auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-agent-auth.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/check-agent-auth.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,aAAa,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,wDAAwD;IACxD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,mFAAmF;IACnF,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AA4FD;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,eAAe,CAAC,CAwF/D"}
+{"version":3,"file":"check-agent-auth.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/check-agent-auth.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,aAAa,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,wDAAwD;IACxD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AA4FD;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,eAAe,CAAC,CAiF/D"}

package/dist/src/presentation/web/app/actions/check-agent-auth.js

@@ -20,7 +20,7 @@ const AGENT_TOOL_MAP = {
 };
 const AGENT_BINARY_MAP = {
     'claude-code': 'claude',
-    cursor: 'cursor-agent',
+    cursor: 'agent',
     'gemini-cli': 'gemini',
 };
 /**
@@ -113,7 +113,6 @@ export async function checkAgentAuth() {
             label: 'Unknown',
             binaryName: null,
             authCommand: null,
-            installCommand: null,
         };
     }
     const label = AGENT_LABELS[agentType] ?? agentType;
@@ -128,18 +127,15 @@ export async function checkAgentAuth() {
             label,
             binaryName: null,
             authCommand: null,
-            installCommand: null,
         };
     }
     // Check if tool is installed
     let installed = false;
-    let installCommand = null;
     try {
         const useCase = resolve('ListToolsUseCase');
         const tools = await useCase.execute();
         const tool = tools.find((t) => t.id === toolId);
         installed = tool?.status.status === 'available';
-        installCommand = tool?.installCommand ?? null;
     }
     catch {
         installed = false;
@@ -152,7 +148,6 @@ export async function checkAgentAuth() {
             label,
             binaryName,
             authCommand: binaryName ? `Install ${label} first` : null,
-            installCommand,
         };
     }
     // Tier 1: instant file/env check
@@ -165,7 +160,6 @@ export async function checkAgentAuth() {
             label,
             binaryName,
             authCommand: binaryName,
-            installCommand,
         };
     }
     // Tier 2: subprocess verify (best effort, ~200ms)
@@ -180,6 +174,5 @@ export async function checkAgentAuth() {
         label,
         binaryName,
         authCommand: authenticated ? null : binaryName,
-        installCommand,
     };
 }