orquesta-agent 0.2.211 → 0.2.213

package/dist/executor.js

@@ -30,6 +30,7 @@ async function loadPtySpawn() {
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { randomUUID } from 'crypto';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import * as logger from './logger.js';
@@ -39,7 +40,8 @@ const nodeRequire = createRequire(import.meta.url);
 import { isSandboxAvailable, buildBwrapArgs, shQuote, ensureStrictProjectDirs, encodeClaudeProjectDir } from './sandbox.js';
 import { parseCoordSpec, runCoordination } from './coordination.js';
 import { parseSudosudoInstallSpec, runSudosudoInstall } from './sudosudo.js';
-import { sendOutput, sendComplete, sendError, sendSupervisionRequest, sendExecutionResumed, updatePromptStatus, persistOutputLogs, clearOutputBuffer, sendRequirement, persistRequirement, sendQAInstructions, persistQAInstructions, sendPlanItemsGenerated, sendSessionOutput, sendSessionStarted, sendSessionEnded, sendSessionError, reportAgentError } from './supabase.js';
+import { sendOutput, sendComplete, sendError, sendSupervisionRequest, sendExecutionResumed, updatePromptStatus, persistOutputLogs, clearOutputBuffer, sendRequirement, persistRequirement, sendQAInstructions, persistQAInstructions, sendPlanItemsGenerated, sendSessionOutput, sendSessionStarted, sendSessionEnded, sendSessionError, sendSessionLog, reportAgentError } from './supabase.js';
+import { startTranscriptTail } from './claude-transcript.js';
 import { createThinkingLog, createToolCallLog, createToolResultLog, createOutputLog, createErrorLog, createSystemLog, } from './types/agent-logs.js';
 /**
  * Build args for the `script` PTY wrapper, accounting for BSD vs util-linux differences.
@@ -668,17 +670,65 @@ export function isOrquestaCliAvailable() {
     orquestaCliCache = { available, at: now };
     return available;
 }
+// Resolve a claude binary that ACTUALLY runs — not one that merely exists on
+// PATH. The claude-code npm package's `bin/claude` launcher can be broken: a
+// Windows `claude.exe` shim (ASCII, no +x) landed on a Linux box, so a bare
+// `claude` resolves to it and every spawn dies instantly (exit 126, or exit 0 /
+// no output) while the REAL native binary ships fine as an optional platform
+// subpackage (@anthropic-ai/claude-code-<plat>-<arch>/claude). The old detection
+// just ran `claude --version` and, when it (briefly) passed, reported the CLI as
+// available+authenticated — so the dashboard showed "authenticated" while
+// interactive sessions "exited early". Field report: EHive DLM server,
+// 2026-06-15. Resolve a binary that runs `--version`, preferring PATH, then the
+// platform subpackage; return null if none works (honest "no CLI").
+let claudeBinaryCache = null;
+export function resolveClaudeBinary() {
+    const now = Date.now();
+    if (claudeBinaryCache && now - claudeBinaryCache.at < CLI_DETECTION_TTL_MS)
+        return claudeBinaryCache.path;
+    let resolved = null;
+    // 1. `claude` on PATH that actually executes (the broken launcher exists but
+    //    exit-126s, which --version surfaces — so this rejects it).
+    try {
+        execSync('claude --version', { stdio: 'pipe', timeout: 15000 });
+        resolved = 'claude';
+    }
+    catch { /* missing or broken launcher */ }
+    // 2. PATH claude missing/broken → run the native binary claude-code ships as an
+    //    optional platform subpackage, directly.
+    if (!resolved) {
+        const exe = process.platform === 'win32' ? 'claude.exe' : 'claude';
+        const sub = `claude-code-${process.platform}-${process.arch}`;
+        const roots = [];
+        try {
+            const p = execSync('npm root -g', { stdio: 'pipe', timeout: 5000, encoding: 'utf-8' }).trim();
+            if (p)
+                roots.push(p);
+        }
+        catch { /* npm slow/absent */ }
+        roots.push(path.join(os.homedir(), '.npm-global', 'lib', 'node_modules'), '/usr/local/lib/node_modules', '/usr/lib/node_modules');
+        for (const root of roots) {
+            const cand = path.join(root, '@anthropic-ai', 'claude-code', 'node_modules', '@anthropic-ai', sub, exe);
+            try {
+                fs.accessSync(cand, fs.constants.X_OK);
+                execSync(`"${cand}" --version`, { stdio: 'pipe', timeout: 15000 });
+                resolved = cand;
+                break;
+            }
+            catch { /* not under this root / not runnable */ }
+        }
+        if (resolved)
+            warnCliOnce(`claude on PATH is broken or wrong-platform; using native binary ${resolved}. Reinstall to fix: npm i -g @anthropic-ai/claude-code`);
+    }
+    claudeBinaryCache = { path: resolved, at: now };
+    return resolved;
+}
 export function isClaudeCliAvailable() {
     const now = Date.now();
     if (claudeCliCache && now - claudeCliCache.at < CLI_DETECTION_TTL_MS) {
         return claudeCliCache.available;
     }
-    let available = false;
-    try {
-        execSync('claude --version', { stdio: 'pipe', timeout: 15000 });
-        available = true;
-    }
-    catch { /* not installed or detection slow */ }
+    const available = resolveClaudeBinary() !== null;
     claudeCliCache = { available, at: now };
     return available;
 }
@@ -797,9 +847,11 @@ export function checkClaudeAuth() {
     // Preferred: ask the CLI directly. Claude Code v2.x stores credentials
     // in the OS keychain (libsecret on Linux, Keychain on macOS) and the
     // legacy ~/.claude/.credentials.json file may not exist. `claude auth
-    // status --json` resolves auth regardless of storage backend.
+    // status --json` resolves auth regardless of storage backend. Use the
+    // resolved binary (PATH `claude` may be the broken launcher).
     try {
-        const out = execSync('claude auth status --json', {
+        const claudeBin = resolveClaudeBinary() || 'claude';
+        const out = execSync(`"${claudeBin}" auth status --json`, {
             stdio: ['ignore', 'pipe', 'ignore'],
             timeout: 5000,
             encoding: 'utf-8',
@@ -1687,9 +1739,14 @@ ${userRequestBody}`;
         }
         const cliCommand = selectedCli;
         // The string used to actually INVOKE the CLI. kimi usually isn't on PATH
-        // (installed at ~/.kimi-code/bin), so resolve its absolute path; claude/orquesta
-        // are invoked by name as before. (cliCommand stays the TYPE for flag decisions.)
-        const cliBinary = cliCommand === 'kimi' ? (resolveKimiBinary() || 'kimi') : (cliCommand || 'claude');
+        // (installed at ~/.kimi-code/bin) and claude's PATH launcher may be broken, so
+        // resolve their real absolute paths; orquesta is invoked by name as before.
+        // (cliCommand stays the TYPE for flag decisions.)
+        const cliBinary = cliCommand === 'kimi'
+            ? (resolveKimiBinary() || 'kimi')
+            : cliCommand === 'claude'
+                ? (resolveClaudeBinary() || 'claude')
+                : (cliCommand || 'claude');
         const cwd = workingDirectory || process.cwd();
         logger.info(`CLI Selection: ${cliCommand} (${reason})`);
         logger.info(`Spawning: ${cliBinary} -p "${fullContent.slice(0, 50)}..." in ${cwd}`);
@@ -3187,9 +3244,14 @@ export async function startSession(options) {
     const { cli: selectedCli } = selectCli();
     const cliCommand = selectedCli || 'claude';
     // Actual invocation string — kimi usually isn't on PATH (installed at
-    // ~/.kimi-code/bin), so resolve its absolute path. The absolute path also
-    // resolves identically inside bwrap (/ is ro-bound). cliCommand stays the TYPE.
-    const cliBinary = cliCommand === 'kimi' ? (resolveKimiBinary() || 'kimi') : cliCommand;
+    // ~/.kimi-code/bin) and claude's PATH launcher may be broken/wrong-platform, so
+    // resolve their real absolute paths. The absolute path also resolves identically
+    // inside bwrap (/ is ro-bound). cliCommand stays the TYPE.
+    const cliBinary = cliCommand === 'kimi'
+        ? (resolveKimiBinary() || 'kimi')
+        : cliCommand === 'claude'
+            ? (resolveClaudeBinary() || 'claude')
+            : cliCommand;
     logger.info(`Interactive session CLI: ${cliCommand}${cliCommand === 'kimi' ? ` (${cliBinary})` : ''}`);
     // Best-effort model + cli label reported in session:started so the dashboard
     // can tag the interactive prompt (same mapping dispatched prompts use on
@@ -3323,6 +3385,23 @@ export async function startSession(options) {
             logger.info(`[Session] Resuming most recent conversation (--continue) for ${cliCommand}`);
         }
     }
+    // Pin the transcript file name so the structured-log tailer
+    // (claude-transcript.ts) knows exactly which ~/.claude/projects/<cwd>/<id>.jsonl
+    // to follow. claude only:
+    //  - --resume <id>: claude appends to that same <id>.jsonl → tail it directly.
+    //  - fresh session: mint a uuid + pass --session-id (can't combine with resume).
+    //  - plain --continue: claude reattaches its OWN prior id (unknown to us) → null,
+    //    and the tailer adopts the newest transcript touched since startup.
+    let claudeTranscriptId = null;
+    if (cliCommand === 'claude') {
+        if (resumeSessionId) {
+            claudeTranscriptId = resumeSessionId;
+        }
+        else if (!resume) {
+            claudeTranscriptId = randomUUID();
+            ptyArgs.push('--session-id', claudeTranscriptId);
+        }
+    }
     // Per-project endpoint override (only the orquesta CLI understands --endpoint).
     if (cliCommand === 'orquesta' && globalCliEndpoint) {
         ptyArgs.push('--endpoint', globalCliEndpoint);
@@ -3407,6 +3486,7 @@ export async function startSession(options) {
         pendingPhoneTimer: null,
         lastPtyOutputAt: Date.now(),
         rogerthatWatcher: null,
+        transcriptTail: null,
     };
     sessions.set(sessionId, session);
     ensureSessionReaper(); // reap this session if it's later abandoned without session:end
@@ -3414,6 +3494,25 @@ export async function startSession(options) {
     // the PTY as if the operator had typed it, so they can hold a full
     // conversation from the phone without touching the dashboard.
     session.rogerthatWatcher = startRogerthatMonitor(sessionId);
+    // Tail claude's on-disk transcript and broadcast STRUCTURED logs (tool_call /
+    // tool_result / output / thinking) so the dashboard persists a rich timeline
+    // instead of scraped terminal chrome. claude only: orquesta-cli self-reports
+    // via its prompt-reporter, and kimi has no structured transcript yet.
+    if (cliCommand === 'claude') {
+        session.transcriptTail = startTranscriptTail({
+            sessionFileId: claudeTranscriptId,
+            startedAtMs: startTime,
+            // The agent has no per-turn promptId (the dashboard owns it), so we tag the
+            // broadcast with none — the dashboard attaches each entry to its active prompt.
+            getPromptId: () => undefined,
+            onLog: (entry) => {
+                if (!sessions.get(sessionId)?.isActive)
+                    return;
+                void sendSessionLog(channel, sessionId, entry);
+            },
+            log: (msg) => logger.debug(`[Session ${sessionId}] ${msg}`),
+        });
+    }
     // Send session:started only after Claude produces its first output.
     // This ensures the UI doesn't activate the input field before Claude is
     // actually ready — early input would otherwise be silently ignored.
@@ -3499,6 +3598,10 @@ export async function startSession(options) {
                 exitingSession.rogerthatWatcher?.close();
             }
             catch { /* already closed */ }
+            try {
+                exitingSession.transcriptTail?.stop();
+            }
+            catch { /* already stopped */ }
             if (exitingSession.pendingPhoneTimer) {
                 clearTimeout(exitingSession.pendingPhoneTimer);
                 exitingSession.pendingPhoneTimer = null;
@@ -3822,6 +3925,10 @@ export function terminateSession(sessionId) {
             s.rogerthatWatcher?.close();
         }
         catch { /* already closed */ }
+        try {
+            s.transcriptTail?.stop();
+        }
+        catch { /* already stopped */ }
         if (s.pendingPhoneTimer) {
             clearTimeout(s.pendingPhoneTimer);
             s.pendingPhoneTimer = null;