autodev-cli 1.4.187 → 1.4.188

package/out/providers/grok/tui.d.ts

@@ -1,5 +1,12 @@
 import { RateLimitDetector } from '../../rateLimit';
 import type { ProviderId } from '../../providers';
+export declare function grokAgentStdioSupported(): boolean;
+/**
+ * Whether the persistent ACP path is active. Gated on grok supporting `agent
+ * stdio` AND the AUTODEV_GROK_PERSISTENT env override (default ON when supported;
+ * set to 'false'/'0'/'off' to force the legacy one-shot headless path).
+ */
+export declare function grokAcpEnabled(): boolean;
 /** True while a grok turn is running for the given workspace root. */
 export declare function isGrokTuiBusy(root: string): boolean;
 /** Epoch-ms of the most recent streamed pane activity, or 0 if none. */
@@ -69,6 +76,24 @@ export declare function sendGrokPrompt(root: string, promptFilePath: string, std
  * to a stateless relaunch instead of hanging the loop.
  */
 export declare function sendGrokCliPrompt(root: string, promptFilePath: string, resolvedSessionId: string | undefined, stdoutFile: string, exitFile: string, log: (msg: string) => void, model?: string, showOutput?: () => void): void;
+/**
+ * Fire-and-forget: run ONE turn through the persistent ACP session. Streams
+ * assistant text to stdoutFile and writes the exit code to exitFile exactly once
+ * at turn end — preserving the taskLoop contract byte-for-byte. The grok process
+ * STAYS ALIVE between turns; a crash/exit is detected and the NEXT turn respawns
+ * + session/load restores context. If the ACP handshake can't be established
+ * (older grok, or a transient spawn failure) it transparently FALLS BACK to the
+ * legacy one-shot headless path so nothing regresses.
+ */
+export declare function sendGrokAcpPrompt(root: string, promptFilePath: string, resolvedSessionId: string | undefined, stdoutFile: string, exitFile: string, log: (msg: string) => void, providerId: 'grok-cli' | 'grok-tui', model?: string, showOutput?: () => void): void;
+/**
+ * Deliver a mid-run steer to the LIVE persistent grok process (a queued
+ * session/prompt). Returns true only when a live ACP session accepted it; false
+ * lets the caller fall back to the durable TODO buffer (at-least-once).
+ */
+export declare function steerGrokAcp(root: string, text: string, log: (msg: string) => void): boolean;
+/** True if a persistent ACP session for this root is mid-turn. */
+export declare function isGrokAcpBusy(root: string): boolean;
 /**
  * grok-tui: persistent — run the turn in the per-workspace tmux session so
  * grok's in-process context accumulates across tasks. Falls back to the old

package/out/providers/grok/tui.js

@@ -70,6 +70,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.grokAgentStdioSupported = grokAgentStdioSupported;
+exports.grokAcpEnabled = grokAcpEnabled;
 exports.isGrokTuiBusy = isGrokTuiBusy;
 exports.getGrokTuiLastActivity = getGrokTuiLastActivity;
 exports.forceIdleGrokTui = forceIdleGrokTui;
@@ -77,6 +79,9 @@ exports.tmuxAvailable = tmuxAvailable;
 exports.grokSessionArgsFor = grokSessionArgsFor;
 exports.sendGrokPrompt = sendGrokPrompt;
 exports.sendGrokCliPrompt = sendGrokCliPrompt;
+exports.sendGrokAcpPrompt = sendGrokAcpPrompt;
+exports.steerGrokAcp = steerGrokAcp;
+exports.isGrokAcpBusy = isGrokAcpBusy;
 exports.decideGrokRunMode = decideGrokRunMode;
 exports.decideHeadlessGrokMode = decideHeadlessGrokMode;
 exports.resumeProbeVerdict = resumeProbeVerdict;
@@ -102,6 +107,7 @@ const authClassify_1 = require("./authClassify");
 const grokEvents_1 = require("../../core/grokEvents");
 const sessions_1 = require("./sessions");
 const redactSecrets_1 = require("../../core/redactSecrets");
+const GrokAcpSession_1 = require("./GrokAcpSession");
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -156,6 +162,39 @@ const _resumeFailCount = (root) => _resumeFailures.get(root) ?? 0;
 const _noteResumeFailure = (root) => { _resumeFailures.set(root, _resumeFailCount(root) + 1); };
 const _noteResumeSuccess = (root) => { _resumeFailures.delete(root); };
 const _tmuxSessions = new Map();
+/**
+ * Live PERSISTENT `grok agent stdio` ACP sessions by root (the persistent-process
+ * model). ONE long-lived grok per workspace serves many turns without exiting;
+ * resume happens only at (re)start via session/load. See GrokAcpSession.
+ */
+const _acpSessions = new Map();
+/** Cached probe: does this grok build expose `agent stdio` (the ACP transport)? */
+let _grokAgentStdioSupported = null;
+function grokAgentStdioSupported() {
+    if (_grokAgentStdioSupported !== null) {
+        return _grokAgentStdioSupported;
+    }
+    try {
+        const out = child_process.execFileSync(GROK_BIN, ['agent', '--help'], { encoding: 'utf8', timeout: 8_000, stdio: ['ignore', 'pipe', 'ignore'] });
+        _grokAgentStdioSupported = /\bstdio\b/.test(out);
+    }
+    catch {
+        _grokAgentStdioSupported = false;
+    }
+    return _grokAgentStdioSupported;
+}
+/**
+ * Whether the persistent ACP path is active. Gated on grok supporting `agent
+ * stdio` AND the AUTODEV_GROK_PERSISTENT env override (default ON when supported;
+ * set to 'false'/'0'/'off' to force the legacy one-shot headless path).
+ */
+function grokAcpEnabled() {
+    const raw = String(process.env['AUTODEV_GROK_PERSISTENT'] ?? '').toLowerCase();
+    if (raw === 'false' || raw === '0' || raw === 'off' || raw === 'no') {
+        return false;
+    }
+    return grokAgentStdioSupported();
+}
 // Per-root set of grok tool_call ids already emitted as PreToolUse, so a re-scan of
 // the transcript can't emit the SAME tool call twice → duplicate rows in the office
 // hook feed (observed ~2.4× per call). PostToolUse is already dedup'd by pending.delete;
@@ -2257,8 +2296,154 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
  * to a stateless relaunch instead of hanging the loop.
  */
 function sendGrokCliPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput) {
+    if (grokAcpEnabled()) {
+        sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, 'grok-cli', model, showOutput);
+        return;
+    }
     sendGrokPersistentHeadless(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, 'grok-cli', model, showOutput);
 }
+// ---------------------------------------------------------------------------
+// PERSISTENT-PROCESS (ACP) path — one long-lived `grok agent stdio` per root.
+// ---------------------------------------------------------------------------
+/** Get (or lazily create) the persistent ACP session for a root. */
+function getOrCreateAcpSession(root, providerId, model, log, resolvedSessionId) {
+    let sess = _acpSessions.get(root);
+    if (sess) {
+        return sess;
+    }
+    // Resume-on-(re)start: seed the id to session/load from the persisted id, else
+    // the newest grok session on disk for this cwd (works whether that session was
+    // created by a prior ACP run or the legacy headless `--continue`).
+    const seedId = resolvedSessionId || (0, sessionState_1.getSessionId)(root, providerId) || (0, sessions_1.getGrokLatestSessionId)(root) || undefined;
+    const hooks = {
+        emitHook: (name, extra) => {
+            if (name === 'Notification' && typeof extra['message'] === 'string') {
+                const msg = (0, redactSecrets_1.redactSecrets)(String(extra['message'])).slice(0, 1200);
+                if (!msg.trim()) {
+                    return;
+                }
+                _emitGrokHook(root, 'Notification', { ...extra, message: msg });
+            }
+            else {
+                _emitGrokHook(root, name, (0, redactSecrets_1.redactDeep)(extra));
+            }
+        },
+        log,
+    };
+    sess = new GrokAcpSession_1.GrokAcpSession({ root, model, bin: GROK_BIN, hooks, initialSessionId: seedId });
+    _acpSessions.set(root, sess);
+    return sess;
+}
+/**
+ * Fire-and-forget: run ONE turn through the persistent ACP session. Streams
+ * assistant text to stdoutFile and writes the exit code to exitFile exactly once
+ * at turn end — preserving the taskLoop contract byte-for-byte. The grok process
+ * STAYS ALIVE between turns; a crash/exit is detected and the NEXT turn respawns
+ * + session/load restores context. If the ACP handshake can't be established
+ * (older grok, or a transient spawn failure) it transparently FALLS BACK to the
+ * legacy one-shot headless path so nothing regresses.
+ */
+function sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, providerId, model, showOutput) {
+    try {
+        fs.writeFileSync(stdoutFile, '', 'utf8');
+    }
+    catch { /* ignore */ }
+    try {
+        fs.writeFileSync(exitFile, '', 'utf8');
+    }
+    catch { /* ignore */ }
+    let promptText = '';
+    try {
+        promptText = fs.readFileSync(promptFilePath, 'utf8');
+    }
+    catch (err) {
+        try {
+            fs.appendFileSync(stdoutFile, `\n[Grok ACP: cannot read prompt file: ${err?.message ?? err}]\n`, 'utf8');
+        }
+        catch { /* ignore */ }
+        try {
+            fs.writeFileSync(exitFile, '1\n', 'utf8');
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    const sess = getOrCreateAcpSession(root, providerId, model, log, resolvedSessionId);
+    _busyRoots.add(root);
+    if (showOutput) {
+        try {
+            showOutput();
+        }
+        catch { /* ignore */ }
+    }
+    const sink = (text) => { try {
+        fs.appendFileSync(stdoutFile, text, 'utf8');
+    }
+    catch { /* ignore */ } };
+    void (async () => {
+        try {
+            await sess.ensureReady();
+        }
+        catch (err) {
+            // ACP unavailable / handshake failed → clean fallback to the one-shot path
+            // (which writes its own stdout/exit + hooks). Nothing regresses.
+            log(`Grok ACP: startup failed (${err?.message ?? err}); stderr="${sess.stderrSnapshot.slice(0, 200)}" — falling back to headless one-shot`);
+            try {
+                sess.close();
+            }
+            catch { /* ignore */ }
+            _acpSessions.delete(root);
+            _busyRoots.delete(root);
+            sendGrokPersistentHeadless(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, providerId, model, showOutput);
+            return;
+        }
+        // Persist the session id so a restart can session/load it (resume-on-restart).
+        if (sess.sessionId) {
+            try {
+                (0, sessionState_1.saveSessionId)(root, providerId, sess.sessionId);
+            }
+            catch { /* ignore */ }
+        }
+        let res;
+        try {
+            res = await sess.runTurn(promptText, sink);
+        }
+        catch (err) {
+            res = { clean: false, stopReason: 'exception', error: err?.message ?? String(err) };
+        }
+        if (!res.clean && res.error) {
+            try {
+                fs.appendFileSync(stdoutFile, `\n[Grok ACP: turn ended ${res.stopReason} — ${res.error}]\n`, 'utf8');
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            fs.writeFileSync(exitFile, `${res.clean ? 0 : 1}\n`, 'utf8');
+        }
+        catch { /* ignore */ }
+        _busyRoots.delete(root);
+    })();
+}
+/**
+ * Deliver a mid-run steer to the LIVE persistent grok process (a queued
+ * session/prompt). Returns true only when a live ACP session accepted it; false
+ * lets the caller fall back to the durable TODO buffer (at-least-once).
+ */
+function steerGrokAcp(root, text, log) {
+    const sess = _acpSessions.get(root);
+    if (!sess || !sess.isAlive()) {
+        return false;
+    }
+    const ok = sess.steer(text);
+    if (ok) {
+        log(`Grok ACP: steered live process (${text.length} chars) — queued to the running session`);
+    }
+    return ok;
+}
+/** True if a persistent ACP session for this root is mid-turn. */
+function isGrokAcpBusy(root) {
+    const sess = _acpSessions.get(root);
+    return !!sess && sess.isBusy();
+}
 /**
  * grok-tui: persistent — run the turn in the per-workspace tmux session so
  * grok's in-process context accumulates across tasks. Falls back to the old
@@ -2357,6 +2542,12 @@ function resumeProbeVerdict(args) {
     return 'wait';
 }
 function sendGrokTuiPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput) {
+    // Preferred persistent model: ONE long-lived `grok agent stdio` (ACP). Cleaner
+    // than the tmux PTY (no pane-scraping, real steering, unified with grok-cli).
+    if (grokAcpEnabled()) {
+        sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, 'grok-tui', model, showOutput);
+        return;
+    }
     const mode = decideGrokRunMode({ tmuxAvailable: tmuxAvailable(), providerId: 'grok-tui' });
     if (mode.useTmux) {
         runGrokTmuxTurn(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput);
@@ -2491,6 +2682,22 @@ async function steerGrokTui(root, text, log) {
  * persisted session id so a later task relaunches with --resume (context intact).
  */
 function closeGrokTuiSession(root, _log) {
+    const acp = _acpSessions.get(root);
+    if (acp) {
+        // Reap grok's whole worker subtree (grok forks a per-turn worker child), then
+        // close — SIGKILL of just the parent would orphan the worker to init.
+        if (acp.pid) {
+            try {
+                (0, killProcessTree_1.killProcessTree)(acp.pid);
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            acp.close();
+        }
+        catch { /* ignore */ }
+        _acpSessions.delete(root);
+    }
     const child = _activeChildren.get(root);
     if (child) {
         if (child.pid) {
@@ -2522,6 +2729,19 @@ function closeGrokTuiSession(root, _log) {
 }
 /** Kill all live grok sessions — called on SDK/extension shutdown. */
 function closeAllGrokTuiSessions() {
+    for (const acp of _acpSessions.values()) {
+        if (acp.pid) {
+            try {
+                (0, killProcessTree_1.killProcessTree)(acp.pid);
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            acp.close();
+        }
+        catch { /* ignore */ }
+    }
+    _acpSessions.clear();
     for (const child of _activeChildren.values()) {
         if (child.pid) {
             (0, killProcessTree_1.killProcessTree)(child.pid);