mixdog 0.7.18 → 0.8.0

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

@@ -1,130 +0,0 @@
-/**
- * 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

@@ -1,166 +0,0 @@
-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,
-};