terminal-agent-workboard 0.0.1

package/dist/status.js

@@ -0,0 +1,230 @@
+const statusOrder = [
+    "Needs input",
+    "Rate limited",
+    "Working",
+    "Return pending",
+    "WIP",
+    "human handoff",
+    "session switching",
+    "agent routing",
+    "Completed"
+];
+export function orderedStatuses() {
+    return statusOrder;
+}
+export function inferStatus(capture, exists) {
+    if (!exists)
+        return "Completed";
+    const text = capture.toLowerCase();
+    if (isAgentRateLimited(capture)) {
+        return "Rate limited";
+    }
+    if (isAgentInitializationBlocked(capture)) {
+        return "Needs input";
+    }
+    if (extractCodexPromptText(capture)) {
+        return "Needs input";
+    }
+    if (hasIdleAgentPrompt(capture)) {
+        return "Needs input";
+    }
+    if (/(need(s)? input|waiting for input|approve|confirm|permission|continue\?|y\/n|\[y\/n\])/.test(text)) {
+        return "Needs input";
+    }
+    if (/(handoff|human handoff|manual intervention|blocked by human)/.test(text)) {
+        return "human handoff";
+    }
+    if (/(routing|route to|select agent|agent routing)/.test(text)) {
+        return "agent routing";
+    }
+    if (/(switching|switched session|session switching|attach-session)/.test(text)) {
+        return "session switching";
+    }
+    if (/(return pending|to return|pending return)/.test(text)) {
+        return "Return pending";
+    }
+    if (hasCompletedLine(capture)) {
+        return "Completed";
+    }
+    if (/(wip|draft|in progress)/.test(text)) {
+        return "WIP";
+    }
+    return "Working";
+}
+export function summarize(capture) {
+    if (isAgentRateLimited(capture)) {
+        return rateLimitedMessage();
+    }
+    if (isAgentInitializationBlocked(capture)) {
+        return initializationBlockedMessage();
+    }
+    const codexPromptText = extractCodexPromptText(capture);
+    if (codexPromptText) {
+        return `Codex prompt awaiting input: ${codexPromptText}`.slice(0, 96);
+    }
+    const latestMessageLines = extractLatestMessageLines(capture);
+    if (latestMessageLines.length > 0) {
+        return latestMessageLines[0]?.replace(/\s+/g, " ").slice(0, 96) ?? "session started";
+    }
+    const lines = capture
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map(cleanLine)
+        .filter(Boolean)
+        .filter((line) => !isPromptLine(line))
+        .filter((line) => !isFooterLine(line))
+        .filter((line) => !isCodexNoiseLine(line));
+    const assistantLine = [...lines].reverse().find((line) => isAssistantLine(line));
+    const last = assistantLine ?? lines.at(-1) ?? "session started";
+    return stripAssistantPrefix(last).replace(/\s+/g, " ").slice(0, 96);
+}
+export function extractLatestMessageLines(capture) {
+    if (isAgentRateLimited(capture)) {
+        return [rateLimitedMessage()];
+    }
+    if (isAgentInitializationBlocked(capture)) {
+        return [initializationBlockedMessage()];
+    }
+    const rawLines = capture.split(/\r?\n/);
+    const assistantStart = findLastIndex(rawLines, (line) => isAssistantLine(cleanLine(line.trim())));
+    if (assistantStart < 0)
+        return [];
+    const lines = [];
+    for (const rawLine of rawLines.slice(assistantStart)) {
+        const line = cleanLine(rawLine.trimEnd());
+        if (!line) {
+            if (lines.length > 0)
+                lines.push("");
+            continue;
+        }
+        if (lines.length > 0 && (isPromptLine(line) || isFooterLine(line) || isThinkingLine(line))) {
+            break;
+        }
+        if (lines.length > 0 && /^Claude Code v/i.test(line)) {
+            break;
+        }
+        if (isAssistantLine(line)) {
+            lines.push(stripAssistantPrefix(line));
+            continue;
+        }
+        lines.push(line);
+    }
+    return trimBlankEdges(lines).slice(0, 40);
+}
+export function ageLabel(iso) {
+    const elapsed = Math.max(0, Date.now() - new Date(iso).getTime());
+    const seconds = Math.floor(elapsed / 1000);
+    if (seconds < 60)
+        return `${Math.max(1, seconds)}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
+}
+export function isAgentInitializationBlocked(capture) {
+    const text = capture.toLowerCase();
+    return (/update available/.test(text) &&
+        /press enter to continue/.test(text) &&
+        /(update now|skip until next version|release notes)/.test(text));
+}
+export function initializationBlockedMessage() {
+    return "Agent initialization needs input. Use /open or Ctrl+O to finish setup in tmux.";
+}
+export function isAgentRateLimited(capture) {
+    const text = capture.toLowerCase();
+    return (/approaching rate limits?/.test(text) ||
+        /rate limit (?:reached|exceeded|hit)/.test(text) ||
+        /(?:daily|weekly|monthly|usage|quota|5-?h(?:our)?) limit (?:reached|exceeded|hit)/.test(text) ||
+        /you'?ve reached your [^\n]{0,60}(?:usage|quota|rate) limit/.test(text) ||
+        /(?:quota|usage) exhausted/.test(text) ||
+        /usage limit hit/.test(text) ||
+        /out of (?:credits|quota|tokens)/.test(text));
+}
+export function rateLimitedMessage() {
+    return "Agent quota/rate limit reached. Use /open or Ctrl+O to switch model or wait for reset.";
+}
+function hasIdleAgentPrompt(capture) {
+    const lines = capture
+        .split(/\r?\n/)
+        .map((line) => cleanLine(line.trim()))
+        .filter(Boolean)
+        .filter((line) => !isFooterLine(line))
+        .filter((line) => !isCodexNoiseLine(line));
+    const lastMeaningful = lines.at(-1) ?? "";
+    const hasAssistantResponse = lines.some((line) => isAssistantLine(line));
+    return hasAssistantResponse && isPromptLine(lastMeaningful);
+}
+function cleanLine(line) {
+    return line
+        .replace(/\u00a0/g, " ")
+        .replace(/[│╭╮╰╯─]+/g, "")
+        .trim();
+}
+function isPromptLine(line) {
+    return /^[>❯›$#]\s*$/.test(line) || /^[\w.-]+[$#]\s*$/.test(line);
+}
+function isFooterLine(line) {
+    return (/^\? for shortcuts\b/.test(line) ||
+        /^← for agents\b/.test(line) ||
+        /^for shortcuts ·/.test(line) ||
+        /for shortcuts · .*for agents/.test(line));
+}
+function isAssistantLine(line) {
+    return /^[⏺●]\s+/.test(line);
+}
+function isThinkingLine(line) {
+    return /^[✻✽✶]\s+/.test(line);
+}
+function hasCompletedLine(capture) {
+    return capture
+        .split(/\r?\n/)
+        .map((line) => cleanLine(line.trim()).toLowerCase())
+        .some((line) => line === "done" ||
+        line === "completed" ||
+        /^done[.!:]?$/.test(line) ||
+        /^completed[.!:]?$/.test(line) ||
+        /\ball tests pass\b/.test(line) ||
+        /\bpr #[0-9]+ merged\b/.test(line) ||
+        /^success\b/.test(line) ||
+        /^finished\b/.test(line));
+}
+function extractCodexPromptText(capture) {
+    const promptLine = capture
+        .split(/\r?\n/)
+        .map((line) => cleanLine(line.trim()))
+        .reverse()
+        .find((line) => /^›\s+\S/.test(line));
+    if (!promptLine)
+        return null;
+    return promptLine.replace(/^›\s+/, "").trim() || null;
+}
+function isCodexNoiseLine(line) {
+    return (/^gpt-[\w.-]+\s+.*·/.test(line) ||
+        /^model:\s+/.test(line) ||
+        /^directory:\s+/.test(line) ||
+        /^tip:\s+/i.test(line) ||
+        /^learn more:/i.test(line));
+}
+function stripAssistantPrefix(line) {
+    return line.replace(/^[⏺●]\s+/, "");
+}
+function trimBlankEdges(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && !lines[start]?.trim())
+        start++;
+    while (end > start && !lines[end - 1]?.trim())
+        end--;
+    return lines.slice(start, end);
+}
+function findLastIndex(items, predicate) {
+    for (let index = items.length - 1; index >= 0; index--) {
+        if (predicate(items[index]))
+            return index;
+    }
+    return -1;
+}

package/dist/store.js

@@ -0,0 +1,32 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export class SessionStore {
+    path;
+    constructor(cwd) {
+        this.path = join(cwd, ".agent-workboard", "state.json");
+    }
+    read() {
+        if (!existsSync(this.path))
+            return [];
+        const parsed = JSON.parse(readFileSync(this.path, "utf8"));
+        return parsed.sessions ?? [];
+    }
+    write(sessions) {
+        mkdirSync(dirname(this.path), { recursive: true });
+        writeFileSync(this.path, `${JSON.stringify({ sessions }, null, 2)}\n`);
+    }
+    upsert(session) {
+        const sessions = this.read();
+        const index = sessions.findIndex((candidate) => candidate.id === session.id);
+        if (index >= 0) {
+            sessions[index] = session;
+        }
+        else {
+            sessions.push(session);
+        }
+        this.write(sessions);
+    }
+    remove(id) {
+        this.write(this.read().filter((session) => session.id !== id));
+    }
+}

package/dist/terminalInput.js

@@ -0,0 +1,86 @@
+import { useEffect, useRef } from "react";
+import { useStdin } from "ink";
+const CTRL_LEFT = new Set(["\u001B[1;5D", "\u001B[5D"]);
+const CTRL_RIGHT = new Set(["\u001B[1;5C", "\u001B[5C"]);
+const META_LEFT = new Set(["\u001B[1;3D", "\u001B[3D", "\u001Bb"]);
+const META_RIGHT = new Set(["\u001B[1;3C", "\u001B[3C", "\u001Bf"]);
+const HOME = new Set(["\u001B[H", "\u001B[1~", "\u001B[7~", "\u001BOH"]);
+const END = new Set(["\u001B[F", "\u001B[4~", "\u001B[8~", "\u001BOF"]);
+const SHIFT_RETURN = new Set([
+    "\n",
+    "\u001B\r",
+    "\u001B\n",
+    "\u001B[13;2u",
+    "\u001B[13;2~",
+    "\u001B[27;2;13~"
+]);
+export function parseTerminalInput(data) {
+    const raw = String(data);
+    let input = raw;
+    const key = {
+        upArrow: raw === "\u001B[A",
+        downArrow: raw === "\u001B[B",
+        leftArrow: raw === "\u001B[D" || CTRL_LEFT.has(raw) || META_LEFT.has(raw),
+        rightArrow: raw === "\u001B[C" || CTRL_RIGHT.has(raw) || META_RIGHT.has(raw),
+        home: HOME.has(raw),
+        end: END.has(raw),
+        return: raw === "\r" || SHIFT_RETURN.has(raw),
+        escape: raw === "\u001B",
+        ctrl: CTRL_LEFT.has(raw) || CTRL_RIGHT.has(raw),
+        shift: SHIFT_RETURN.has(raw),
+        tab: raw === "\t" || raw === "\u001B[Z",
+        backspace: raw === "\u007F" || raw === "\b",
+        delete: raw === "\u001B[3~" || raw === "\u001B[P",
+        meta: META_LEFT.has(raw) || META_RIGHT.has(raw)
+    };
+    if (raw.length === 1 && raw <= "\u001A" && !key.return) {
+        input = String.fromCharCode(raw.charCodeAt(0) + "a".charCodeAt(0) - 1);
+        key.ctrl = true;
+    }
+    if (raw.startsWith("\u001B") && !isKnownEscape(key)) {
+        input = raw.slice(1);
+        key.meta = true;
+    }
+    if (key.tab && raw === "\u001B[Z")
+        key.shift = true;
+    if (key.tab || key.backspace || key.delete)
+        input = "";
+    return { input, key };
+}
+export function useTerminalInput(handler, options = {}) {
+    const { stdin, setRawMode } = useStdin();
+    const isActive = options.isActive ?? true;
+    const handlerRef = useRef(handler);
+    handlerRef.current = handler;
+    useEffect(() => {
+        if (!isActive)
+            return;
+        setRawMode(true);
+        return () => setRawMode(false);
+    }, [isActive, setRawMode]);
+    useEffect(() => {
+        if (!isActive)
+            return;
+        const onData = (data) => {
+            const parsed = parseTerminalInput(data);
+            handlerRef.current(parsed.input, parsed.key);
+        };
+        stdin?.on("data", onData);
+        return () => {
+            stdin?.off("data", onData);
+        };
+    }, [isActive, stdin]);
+}
+function isKnownEscape(key) {
+    return (key.upArrow ||
+        key.downArrow ||
+        key.leftArrow ||
+        key.rightArrow ||
+        key.home ||
+        key.end ||
+        key.return ||
+        key.tab ||
+        key.delete ||
+        key.ctrl ||
+        key.meta);
+}

package/dist/tmux.js

@@ -0,0 +1,42 @@
+import { execFileSync, spawnSync } from "node:child_process";
+export class Tmux {
+    available() {
+        const result = spawnSync("tmux", ["-V"], { stdio: "ignore" });
+        return result.status === 0;
+    }
+    hasSession(name) {
+        const result = spawnSync("tmux", ["has-session", "-t", name], { stdio: "ignore" });
+        return result.status === 0;
+    }
+    newSession(name, cwd, command) {
+        execFileSync("tmux", ["new-session", "-d", "-s", name, "-c", cwd, command], {
+            stdio: "ignore"
+        });
+    }
+    sendKeys(name, input) {
+        execFileSync("tmux", ["send-keys", "-t", name, "-l", input], {
+            stdio: "ignore"
+        });
+        execFileSync("tmux", ["send-keys", "-t", name, "C-m"], {
+            stdio: "ignore"
+        });
+    }
+    capture(name, lines = 80) {
+        try {
+            return execFileSync("tmux", ["capture-pane", "-pt", name, "-S", `-${lines}`], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"]
+            });
+        }
+        catch {
+            return "";
+        }
+    }
+    kill(name) {
+        spawnSync("tmux", ["kill-session", "-t", name], { stdio: "ignore" });
+    }
+    attach(name) {
+        process.stdout.write("\x1b[2J\x1b[H");
+        spawnSync("tmux", ["attach-session", "-t", name], { stdio: "inherit" });
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};