@holon-run/agentinbox 0.2.0 → 0.3.0

package/dist/src/runtime_gate.js

@@ -0,0 +1,464 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeTerminalStateProbe = exports.ClaudeCodeRuntimePresenceProbe = exports.TmuxTerminalStateProbe = exports.Iterm2TerminalStateProbe = exports.CodexRuntimePresenceProbe = exports.DefaultActivationGate = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const DEFAULT_ITERM2_SAMPLE_DELAY_MS = 250;
+const DEFAULT_TMUX_SAMPLE_DELAY_MS = 250;
+const ACTIVE_BUFFER_MARKERS = [
+    "esc to interrupt",
+    "Working (",
+    "⠼ ",
+];
+const TYPING_PROMPT_PREFIXES = [
+    "› ",
+    "> ",
+];
+class DefaultActivationGate {
+    runtimeProbes;
+    terminalProbes;
+    constructor(runtimeProbes = [
+        new CodexRuntimePresenceProbe(),
+        new ClaudeCodeRuntimePresenceProbe(),
+    ], terminalProbes = [
+        new Iterm2TerminalStateProbe(),
+        new ClaudeCodeTerminalStateProbe(),
+        new TmuxTerminalStateProbe(),
+    ]) {
+        this.runtimeProbes = runtimeProbes;
+        this.terminalProbes = terminalProbes;
+    }
+    async evaluate(target) {
+        const runtimeProbe = this.runtimeProbes.find((probe) => probe.supports(target));
+        const runtimePresence = runtimeProbe ? await runtimeProbe.check(target) : "unknown";
+        const terminalProbe = this.terminalProbes.find((probe) => probe.supports(target));
+        const terminalState = terminalProbe
+            ? await terminalProbe.check(target)
+            : { presence: "unknown", busy: "unknown" };
+        if (runtimePresence === "gone") {
+            return { outcome: "offline", reason: "runtime_gone" };
+        }
+        if (terminalState.presence === "gone") {
+            return { outcome: "offline", reason: "terminal_gone" };
+        }
+        if (terminalState.busy === "busy") {
+            return { outcome: "defer", reason: "terminal_busy" };
+        }
+        return { outcome: "inject", reason: "gate_unknown_or_idle" };
+    }
+}
+exports.DefaultActivationGate = DefaultActivationGate;
+class CodexRuntimePresenceProbe {
+    killFn;
+    constructor(killFn = (pid, signal) => process.kill(pid, signal)) {
+        this.killFn = killFn;
+    }
+    supports(target) {
+        return target.runtimeKind === "codex" && Number.isInteger(target.runtimePid);
+    }
+    async check(target) {
+        if (!Number.isInteger(target.runtimePid)) {
+            return "unknown";
+        }
+        try {
+            this.killFn(target.runtimePid, 0);
+            return "alive";
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error ? String(error.code ?? "") : "";
+            if (code === "ESRCH") {
+                return "gone";
+            }
+            return "unknown";
+        }
+    }
+}
+exports.CodexRuntimePresenceProbe = CodexRuntimePresenceProbe;
+class Iterm2TerminalStateProbe {
+    execAsync;
+    options;
+    constructor(execAsync = execFileAsync, options = {}) {
+        this.execAsync = execAsync;
+        this.options = options;
+    }
+    supports(target) {
+        // Only support iTerm2 targets that are NOT Claude Code
+        // Claude Code targets are handled by ClaudeCodeTerminalStateProbe
+        return (target.backend === "iterm2" &&
+            target.runtimeKind !== "claude_code" &&
+            typeof target.itermSessionId === "string" &&
+            target.itermSessionId.length > 0);
+    }
+    async check(target) {
+        const sessionId = target.itermSessionId?.trim();
+        if (!sessionId) {
+            return { presence: "unknown", busy: "unknown" };
+        }
+        let it2api;
+        try {
+            it2api = resolveIterm2ApiPath(this.options.iterm2ApiPath);
+        }
+        catch {
+            return { presence: "unknown", busy: "unknown" };
+        }
+        const presence = await this.checkSessionPresence(it2api, sessionId);
+        if (presence !== "available") {
+            return { presence, busy: "unknown" };
+        }
+        await this.tryReadPrompt(it2api, sessionId);
+        const first = await this.readBufferTail(it2api, sessionId);
+        if (!first) {
+            return { presence: "available", busy: "unknown" };
+        }
+        await (this.options.sleep ?? sleep)(this.options.sampleDelayMs ?? DEFAULT_ITERM2_SAMPLE_DELAY_MS);
+        const second = await this.readBufferTail(it2api, sessionId);
+        if (!second) {
+            return { presence: "available", busy: "unknown" };
+        }
+        if (first !== second) {
+            return { presence: "available", busy: "busy" };
+        }
+        if (containsActiveBufferMarker(second)) {
+            return { presence: "available", busy: "busy" };
+        }
+        return { presence: "available", busy: "unknown" };
+    }
+    async checkSessionPresence(it2api, sessionId) {
+        try {
+            const result = await this.execAsync(it2api, ["list-sessions"]);
+            const sessions = result.stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            return sessions.includes(sessionId) ? "available" : "gone";
+        }
+        catch {
+            return "unknown";
+        }
+    }
+    async tryReadPrompt(it2api, sessionId) {
+        try {
+            await this.execAsync(it2api, ["get-prompt", sessionId]);
+        }
+        catch {
+            return;
+        }
+    }
+    async readBufferTail(it2api, sessionId) {
+        try {
+            const result = await this.execAsync(it2api, ["get-buffer", sessionId]);
+            return normalizeBufferTail(result.stdout);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.Iterm2TerminalStateProbe = Iterm2TerminalStateProbe;
+class TmuxTerminalStateProbe {
+    execAsync;
+    options;
+    constructor(execAsync = execFileAsync, options = {}) {
+        this.execAsync = execAsync;
+        this.options = options;
+    }
+    supports(target) {
+        return target.backend === "tmux" && typeof target.tmuxPaneId === "string" && target.tmuxPaneId.trim().length > 0;
+    }
+    async check(target) {
+        const paneId = target.tmuxPaneId?.trim();
+        if (!paneId) {
+            return { presence: "unknown", busy: "unknown" };
+        }
+        const paneState = await this.readPaneState(paneId);
+        if (paneState === "missing") {
+            return { presence: "gone", busy: "unknown" };
+        }
+        if (paneState === "unknown") {
+            return { presence: "unknown", busy: "unknown" };
+        }
+        if (paneState.dead) {
+            return { presence: "gone", busy: "unknown" };
+        }
+        const first = await this.readBufferTail(paneId);
+        if (!first) {
+            return { presence: "available", busy: "unknown" };
+        }
+        await (this.options.sleep ?? sleep)(this.options.sampleDelayMs ?? DEFAULT_TMUX_SAMPLE_DELAY_MS);
+        const second = await this.readBufferTail(paneId);
+        if (!second) {
+            return { presence: "available", busy: "unknown" };
+        }
+        if (first !== second) {
+            return { presence: "available", busy: "busy" };
+        }
+        if (containsActiveBufferMarker(second)) {
+            return { presence: "available", busy: "busy" };
+        }
+        if (paneState.active && hasVisibleTypingPrompt(second)) {
+            return { presence: "available", busy: "busy" };
+        }
+        return { presence: "available", busy: "unknown" };
+    }
+    async readPaneState(paneId) {
+        try {
+            const result = await this.execAsync("tmux", ["display-message", "-p", "-t", paneId, "#{pane_active} #{pane_dead}"]);
+            const [active, dead] = result.stdout.trim().split(/\s+/, 2);
+            if (!active || !dead) {
+                return "unknown";
+            }
+            return {
+                active: active === "1",
+                dead: dead === "1",
+            };
+        }
+        catch (error) {
+            if (isTmuxMissingPaneError(error)) {
+                return "missing";
+            }
+            return "unknown";
+        }
+    }
+    async readBufferTail(paneId) {
+        try {
+            const result = await this.execAsync("tmux", ["capture-pane", "-p", "-t", paneId, "-S", "-20"]);
+            return normalizeBufferTail(result.stdout);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.TmuxTerminalStateProbe = TmuxTerminalStateProbe;
+function containsActiveBufferMarker(bufferTail) {
+    return ACTIVE_BUFFER_MARKERS.some((marker) => bufferTail.includes(marker));
+}
+function hasVisibleTypingPrompt(bufferTail) {
+    const lines = bufferTail
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length > 0);
+    const lastLine = lines.at(-1);
+    if (!lastLine) {
+        return false;
+    }
+    for (const prefix of TYPING_PROMPT_PREFIXES) {
+        if (lastLine.startsWith(prefix) && lastLine.slice(prefix.length).trim().length > 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function normalizeBufferTail(buffer) {
+    const normalized = buffer
+        .replace(/\r/g, "")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .slice(-20)
+        .join("\n")
+        .trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function resolveIterm2ApiPath(override) {
+    if (override) {
+        return override;
+    }
+    const candidates = [
+        "/Applications/iTerm.app/Contents/Resources/it2api",
+        "/Applications/iTerm.app/Contents/Resources/utilities/it2api",
+    ];
+    for (const candidate of candidates) {
+        if (node_fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("unable to locate iTerm2 it2api helper");
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isTmuxMissingPaneError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const candidate = `${error.message} ${"stderr" in error ? String(error.stderr ?? "") : ""}`;
+    return candidate.includes("can't find pane");
+}
+class ClaudeCodeRuntimePresenceProbe {
+    killFn;
+    sessionFileReader;
+    constructor(killFn = (pid, signal) => process.kill(pid, signal), sessionFileReader) {
+        this.killFn = killFn;
+        this.sessionFileReader = sessionFileReader;
+    }
+    supports(target) {
+        return target.runtimeKind === "claude_code" && Number.isInteger(target.runtimePid);
+    }
+    async check(target) {
+        if (!Number.isInteger(target.runtimePid)) {
+            return "unknown";
+        }
+        try {
+            // 1. Check if process exists
+            this.killFn(target.runtimePid, 0);
+            // 2. Verify session file exists and is valid
+            const sessionInfo = await (this.sessionFileReader ?? this.defaultSessionFileReader)(target.runtimePid);
+            if (!sessionInfo) {
+                return "gone"; // Process exists but session file is invalid/missing
+            }
+            // 3. Verify session ID matches (prevent PID reuse)
+            if (target.runtimeSessionId && sessionInfo.sessionId !== target.runtimeSessionId) {
+                return "gone";
+            }
+            return "alive";
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error ? String(error.code ?? "") : "";
+            if (code === "ESRCH") {
+                return "gone"; // Process doesn't exist
+            }
+            return "unknown";
+        }
+    }
+    defaultSessionFileReader = async (pid) => {
+        const sessionFile = node_path_1.default.join(node_os_1.default.homedir(), ".claude", "sessions", `${pid}.json`);
+        try {
+            const content = await node_fs_1.default.promises.readFile(sessionFile, "utf8");
+            const session = JSON.parse(content);
+            if (!session.sessionId || typeof session.sessionId !== "string") {
+                return null;
+            }
+            return {
+                sessionId: session.sessionId,
+                cwd: session.cwd,
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+}
+exports.ClaudeCodeRuntimePresenceProbe = ClaudeCodeRuntimePresenceProbe;
+class ClaudeCodeTerminalStateProbe {
+    sessionFileReader;
+    logFileStatReader;
+    sleepFn;
+    constructor(sessionFileReader, logFileStatReader, sleepFn = sleep) {
+        this.sessionFileReader = sessionFileReader;
+        this.logFileStatReader = logFileStatReader;
+        this.sleepFn = sleepFn;
+    }
+    supports(target) {
+        return target.runtimeKind === "claude_code";
+    }
+    async check(target) {
+        if (!target.runtimePid || !target.runtimeSessionId) {
+            return { presence: "unknown", busy: "unknown" };
+        }
+        try {
+            // 1. Read session file to get cwd
+            const sessionData = await (this.sessionFileReader ?? this.defaultSessionFileReader)(target.runtimePid);
+            if (!sessionData) {
+                return { presence: "gone", busy: "unknown" };
+            }
+            // 2. Verify session ID matches
+            if (sessionData.sessionId !== target.runtimeSessionId) {
+                return { presence: "gone", busy: "unknown" };
+            }
+            // 3. Construct log file path using Claude Code's encoding rules
+            const sanitizedProjectPath = sessionData.cwd.replace(/[^a-zA-Z0-9]/g, '-');
+            const logFile = node_path_1.default.join(node_os_1.default.homedir(), ".claude", "projects", sanitizedProjectPath, `${target.runtimeSessionId}.jsonl`);
+            // 4. Check log file activity
+            const busy = await this.checkLogFileActivity(logFile);
+            // 5. Check iTerm2 session presence if available
+            const presence = target.backend === "iterm2" && target.itermSessionId
+                ? await this.checkIterm2Presence(target.itermSessionId)
+                : "available";
+            return { presence, busy };
+        }
+        catch (error) {
+            console.warn('Claude Code state check failed:', error);
+            return { presence: "unknown", busy: "unknown" };
+        }
+    }
+    defaultSessionFileReader = async (pid) => {
+        const sessionFile = node_path_1.default.join(node_os_1.default.homedir(), ".claude", "sessions", `${pid}.json`);
+        try {
+            const content = await node_fs_1.default.promises.readFile(sessionFile, "utf8");
+            const session = JSON.parse(content);
+            if (!session.sessionId || typeof session.sessionId !== "string") {
+                return null;
+            }
+            return {
+                sessionId: session.sessionId,
+                cwd: session.cwd,
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    defaultLogFileStatReader = async (filePath) => {
+        try {
+            const stats = await node_fs_1.default.promises.stat(filePath);
+            return { mtimeMs: stats.mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    };
+    async checkLogFileActivity(logFile) {
+        try {
+            const statResult = await (this.logFileStatReader ?? this.defaultLogFileStatReader)(logFile);
+            if (!statResult) {
+                return "unknown";
+            }
+            const timeSinceLastActivity = Date.now() - statResult.mtimeMs;
+            // Activity within last 5 seconds = busy
+            if (timeSinceLastActivity < 5000) {
+                return "busy";
+            }
+            // Secondary sampling to confirm (avoid false positives)
+            await this.sleepFn(250);
+            const statResult2 = await (this.logFileStatReader ?? this.defaultLogFileStatReader)(logFile);
+            if (!statResult2) {
+                return "unknown";
+            }
+            const timeSinceLastActivity2 = Date.now() - statResult2.mtimeMs;
+            if (statResult2.mtimeMs > statResult.mtimeMs && timeSinceLastActivity2 < 5000) {
+                return "busy";
+            }
+            // Activity within last 30 seconds = idle but recently active
+            return timeSinceLastActivity2 < 30000 ? "idle" : "unknown";
+        }
+        catch {
+            return "unknown";
+        }
+    }
+    async checkIterm2Presence(itermSessionId) {
+        try {
+            const it2api = resolveIterm2ApiPath();
+            const result = await execFileAsync(it2api, ["list-sessions"]);
+            const lines = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+            // Parse session IDs from iTerm2 output format: "Session \"...\" id=<UUID> ..."
+            const sessionIds = lines
+                .map((line) => {
+                const match = line.match(/id=([A-F0-9-]+)/);
+                return match ? match[1] : null;
+            })
+                .filter((id) => id !== null);
+            return sessionIds.includes(itermSessionId) ? "available" : "gone";
+        }
+        catch {
+            return "unknown";
+        }
+    }
+}
+exports.ClaudeCodeTerminalStateProbe = ClaudeCodeTerminalStateProbe;