mixdog 0.7.1

package/src/agent/orchestrator/session/stream-watchdog.mjs

@@ -0,0 +1,130 @@
+/**
+ * Stream watchdog — aborts sessions that have been silent too long.
+ *
+ * Measures the wall-clock gap since each session's last stream delta.
+ * Long total duration is fine; no progress for too long is not.
+ *
+ * Thresholds:
+ *   300s (5m) — soft: emit tool_stream_stalled telemetry once per session.
+ *   600s (10m) — hard: abort the session's controller with a StreamStalledAbortError,
+ *                emit tool_stream_aborted telemetry, stop tracking it.
+ *                Provider adapters use shorter first-byte/first-meaningful
+ *                deadlines from stall-policy.mjs; this watchdog is the backup
+ *                net for anything that escapes adapter-level cancellation.
+ *
+ * Tick interval is 15s, so a real stall is noticed within (threshold + 15s).
+ */
+import { traceStreamAborted, traceStreamStalled } from '../bridge-trace.mjs';
+import { STALL_ABORT_MS, STALL_TICK_MS, STALL_WARN_MS } from '../stall-policy.mjs';
+
+const SOFT_STALL_MS = STALL_WARN_MS;
+const HARD_STALL_MS = STALL_ABORT_MS;
+const TICK_MS = STALL_TICK_MS;
+
+let _tickHandle = null;
+const _softWarned = new Set(); // sessionIds that already received a soft warning
+
+export class StreamStalledAbortError extends Error {
+    constructor(info) {
+        super(`stream stalled ${info.staleSeconds}s (last: ${info.lastToolCall || 'unknown'}, stage: ${info.stage || 'unknown'})`);
+        this.name = 'StreamStalledAbortError';
+        this.info = info;
+    }
+}
+
+function computeStaleSeconds(entry) {
+    if (!entry) return null;
+    // Prefer real stream deltas, then explicit progress markers such as
+    // provider retries / stage changes, then askStartedAt for true no-first-byte
+    // stalls.
+    const ref = entry.lastStreamDeltaAt || entry.lastProgressAt || entry.updatedAt || entry.askStartedAt;
+    if (!ref) return null;
+    return Math.round((Date.now() - ref) / 1000);
+}
+
+function shouldSkip(sessionId, entry) {
+    if (!sessionId || !entry) return true;
+    if (entry.closed) return true;
+    if (!entry.controller || entry.controller.signal?.aborted) return true;
+    // Watchdog is active once an ask has started, even before the first
+    // stream delta lands. Connect-phase hangs were invisible before — a
+    // provider that accepted the request but never returned a first token
+    // would stay 'running' forever. askStartedAt closes that gap.
+    if (!entry.lastStreamDeltaAt && !entry.askStartedAt) return true;
+    // Server silence while the client runs a tool is expected, not a stall.
+    // The next streaming phase refreshes lastStreamDeltaAt on its own.
+    if (entry.stage === 'tool_running') return true;
+    return false;
+}
+
+/**
+ * Examine one runtime entry and apply watchdog logic.
+ * Exposed for tests — pass a fake entry shape and observe effects.
+ *
+ * @param {string} sessionId
+ * @param {object} entry - runtime entry (must carry controller, lastStreamDeltaAt, etc.)
+ * @param {{onSoft?: Function, onHard?: Function}} [hooks]
+ * @returns {'skip'|'continue'|'soft'|'hard'}
+ */
+export function inspectEntry(sessionId, entry, hooks = {}) {
+    if (shouldSkip(sessionId, entry)) return 'skip';
+    const staleSeconds = computeStaleSeconds(entry);
+    if (staleSeconds === null) return 'skip';
+
+    const info = {
+        sessionId,
+        staleSeconds,
+        lastToolCall: entry.lastToolCall || null,
+        stage: entry.stage || null,
+    };
+
+    if (staleSeconds * 1000 >= HARD_STALL_MS) {
+        traceStreamAborted({ sessionId, info });
+        try {
+            entry.controller.abort(new StreamStalledAbortError(info));
+        } catch {
+            // Abort controller may reject non-Error reasons on older runtimes — fall through.
+        }
+        _softWarned.delete(sessionId);
+        hooks.onHard?.(info);
+        return 'hard';
+    }
+
+    if (staleSeconds * 1000 >= SOFT_STALL_MS) {
+        if (!_softWarned.has(sessionId)) {
+            _softWarned.add(sessionId);
+            traceStreamStalled({ sessionId, info });
+            hooks.onSoft?.(info);
+        }
+        return 'soft';
+    }
+
+    // Delta updated under soft threshold — clear any prior warn mark so
+    // a fresh stall later can warn again.
+    if (_softWarned.has(sessionId) && staleSeconds * 1000 < SOFT_STALL_MS) {
+        _softWarned.delete(sessionId);
+    }
+    return 'continue';
+}
+
+/**
+ * Start the periodic watchdog. Single global timer; iterates all sessions
+ * via the supplied accessor on each tick.
+ *
+ * @param {() => Iterable<[string, object]>} runtimeIterator - returns [sessionId, entry] pairs
+ */
+export function startWatchdog(runtimeIterator) {
+    if (_tickHandle) return;
+    const tick = () => {
+        try {
+            for (const [sessionId, entry] of runtimeIterator()) {
+                inspectEntry(sessionId, entry);
+            }
+        } catch (e) {
+            process.stderr.write(`[stream-watchdog] tick failed: ${e.message}\n`);
+        }
+    };
+    _tickHandle = setInterval(tick, TICK_MS);
+    // Do not keep the process alive just for the watchdog.
+    if (typeof _tickHandle.unref === 'function') _tickHandle.unref();
+}

package/src/agent/orchestrator/session/tool-result-offload.mjs

@@ -0,0 +1,166 @@
+import { existsSync, mkdirSync } from 'fs';
+import { readdir, rmdir, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { getPluginData } from '../config.mjs';
+import { normalizeOutputPath } from '../tools/builtin/path-utils.mjs';
+import { classifyResultKind } from './result-classification.mjs';
+
+const TOOL_RESULT_OFFLOAD_THRESHOLD_CHARS = 50_000;
+const TOOL_RESULT_PREVIEW_CHARS = 2_000;
+const TOOL_RESULT_SHELL_THRESHOLD_CHARS = 30_000;
+const TOOL_RESULT_SEARCH_THRESHOLD_CHARS = 50_000;
+const TOOL_RESULT_GREP_THRESHOLD_CHARS = 20_000;
+export const TOOL_RESULT_OFFLOAD_PREFIX = '[tool output offloaded:';
+
+// Per-tool persistence limits mirror Claude Code's per-tool maxResultSizeChars
+// rather than a single global value: Grep persists at 20k (CC GrepTool), Glob
+// and list/find_* at the 50k system default (CC DEFAULT_MAX_RESULT_SIZE_CHARS;
+// tighter than CC Glob's 100k by design), and Bash/bash_session/job_wait at 30k
+// (CC BASH_MAX_OUTPUT_LENGTH default). Read/head/tail/diff stay inline
+// (Infinity) — they are self-bound by FileRead semantics and the upstream
+// READ_MAX_SIZE_BYTES cap, so persisting to a sidecar to be re-read would be
+// circular. These values keep context-rich IO tools from turning into "read
+// saved output" loops while bounding the per-call inline footprint per CC.
+const INLINE_THRESHOLD_BY_TOOL = new Map([
+    ['read', Infinity],
+    ['head', Infinity],
+    ['tail', Infinity],
+    ['diff', Infinity],
+    ['grep', TOOL_RESULT_GREP_THRESHOLD_CHARS],
+    ['glob', TOOL_RESULT_SEARCH_THRESHOLD_CHARS],
+    ['list', TOOL_RESULT_SEARCH_THRESHOLD_CHARS],
+    ['tree', TOOL_RESULT_SEARCH_THRESHOLD_CHARS],
+    ['find_files', TOOL_RESULT_SEARCH_THRESHOLD_CHARS],
+    ['code_graph', TOOL_RESULT_SEARCH_THRESHOLD_CHARS],
+    ['bash', TOOL_RESULT_SHELL_THRESHOLD_CHARS],
+    ['bash_session', TOOL_RESULT_SHELL_THRESHOLD_CHARS],
+    ['job_wait', TOOL_RESULT_SHELL_THRESHOLD_CHARS],
+]);
+
+function getOffloadThreshold(toolName) {
+    const key = String(toolName || '').toLowerCase();
+    return INLINE_THRESHOLD_BY_TOOL.get(key) ?? TOOL_RESULT_OFFLOAD_THRESHOLD_CHARS;
+}
+
+// Sanitize sessionId before using it as a path segment. A raw `..` or slash
+// would let the sidecar dir — and clearOffloadSession's readdir+unlink — escape
+// the tool-results root (arbitrary .txt deletion). Strip to [A-Za-z0-9_-];
+// dropping '.' collapses '..' to '__'. Real ids are sess_<digits>, unaffected.
+function safeSessionSegment(sessionId) {
+    return String(sessionId ?? '').replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 200) || '_invalid';
+}
+
+function ensureToolResultsDir(sessionId) {
+    const dir = join(getPluginData(), 'tool-results', safeSessionSegment(sessionId));
+    // R4 data-at-rest: offloaded tool output may contain secrets / file
+    // contents; clamp dir to owner-only on POSIX (advisory on Windows).
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+
+// Map tool-call IDs to safe generated filenames. toolCallId arrives from
+// the provider and may contain path-unsafe characters (slashes, dots, etc.).
+// Use a monotonic counter keyed by sessionId so the sidecar path is
+// deterministic-ish within a session but never tainted by provider input.
+const _offloadCounters = new Map();
+
+function buildPreview(text, maxChars = TOOL_RESULT_PREVIEW_CHARS) {
+    if (text.length <= maxChars) {
+        return { preview: text, truncated: false };
+    }
+    const headBudget = Math.floor(maxChars * 0.6);
+    const tailBudget = maxChars - headBudget;
+    let head = text.slice(0, headBudget);
+    const headCut = head.lastIndexOf('\n');
+    if (headCut > Math.floor(headBudget * 0.6)) head = head.slice(0, headCut);
+    let tail = text.slice(Math.max(0, text.length - tailBudget));
+    const tailCut = tail.indexOf('\n');
+    if (tailCut !== -1 && tailCut < Math.floor(tailBudget * 0.4)) tail = tail.slice(tailCut + 1);
+    const omittedKb = Math.max(1, Math.round((text.length - head.length - tail.length) / 1024));
+    return {
+        preview: `${head}\n\n... [preview middle omitted — ${omittedKb} KB] ...\n\n${tail}`,
+        truncated: true,
+    };
+}
+
+function countLines(text) {
+    if (!text) return 0;
+    let lines = 1;
+    for (let i = 0; i < text.length; i += 1) {
+        if (text.charCodeAt(i) === 10) lines += 1;
+    }
+    return lines;
+}
+
+export async function maybeOffloadToolResult(sessionId, toolCallId, toolName, result) {
+    if (!sessionId || !toolCallId) return result;
+    if (typeof result !== 'string') return result;
+    if (result.length <= getOffloadThreshold(toolName)) return result;
+    // Keep error surfaces inline so the model can self-correct without an
+    // extra read turn — but only up to the global default. A giant error
+    // (e.g. a megabyte of stack/diff/dump) still offloads so it can't blow up
+    // context; small errors (the overwhelming majority) stay inline.
+    if (classifyResultKind(result) === 'error'
+        && result.length <= TOOL_RESULT_OFFLOAD_THRESHOLD_CHARS) return result;
+
+    // Generate a safe filename — never trust toolCallId as a path component.
+    const count = (_offloadCounters.get(sessionId) ?? 0) + 1;
+    _offloadCounters.set(sessionId, count);
+    const safeId = `r${count}`;
+
+    const dir = ensureToolResultsDir(sessionId);
+    const filePath = join(dir, `${safeId}.txt`);
+
+    // Count lines while the string is in hand — single pass, no re-read.
+    const lines = countLines(result);
+    await writeFile(filePath, result, { encoding: 'utf-8', mode: 0o600 });
+
+    const { preview, truncated } = buildPreview(result);
+    const sizeKb = Math.max(1, Math.round(result.length / 1024));
+    const displayPath = normalizeOutputPath(filePath);
+    const header = `${TOOL_RESULT_OFFLOAD_PREFIX} ${toolName} → ${displayPath} (${sizeKb} KB, ${lines} lines)]`;
+    const suffix = truncated ? '\n... [preview truncated — use read on the saved path for full output]' : '';
+    return `${header}\n\n${preview}${suffix}`;
+}
+
+// Drop a session's offload sidecars on session close. Unlinks every
+// tool-results/<sessionId>/*.txt entry, rmdirs the directory, and drops
+// the sessionId entry from the module-level counter Map so a long-running
+// mcp-server process doesn't accumulate per-session state across the
+// lifetime of the bridge.
+export async function clearOffloadSession(sessionId) {
+    if (!sessionId) return;
+    _offloadCounters.delete(sessionId);
+    const dir = join(getPluginData(), 'tool-results', safeSessionSegment(sessionId));
+    if (!existsSync(dir)) return;
+    try {
+        const entries = await readdir(dir);
+        await Promise.all(entries
+            .filter((name) => name.endsWith('.txt'))
+            .map((name) => unlink(join(dir, name)).catch(() => { /* best-effort */ })));
+        await rmdir(dir).catch(() => { /* best-effort: non-empty / already gone */ });
+    } catch { /* best-effort */ }
+}
+
+export function isOffloadedToolResultText(text) {
+    return typeof text === 'string' && text.startsWith(TOOL_RESULT_OFFLOAD_PREFIX);
+}
+
+export function compactOffloadedToolResultText(text) {
+    if (!isOffloadedToolResultText(text)) return text;
+    const value = String(text);
+    const lineEnd = value.indexOf('\n');
+    const firstLine = lineEnd === -1 ? value : value.slice(0, lineEnd);
+    return `${firstLine}\n[preview omitted — use read on the saved path if needed]`;
+}
+
+export const _internals = {
+    TOOL_RESULT_OFFLOAD_THRESHOLD_CHARS,
+    TOOL_RESULT_SHELL_THRESHOLD_CHARS,
+    TOOL_RESULT_SEARCH_THRESHOLD_CHARS,
+    TOOL_RESULT_GREP_THRESHOLD_CHARS,
+    getOffloadThreshold,
+    TOOL_RESULT_PREVIEW_CHARS,
+    buildPreview,
+    countLines,
+};