consensus-cli 0.1.0

package/dist/codexLogs.js

@@ -0,0 +1,332 @@
+import fsp from "fs/promises";
+import os from "os";
+import path from "path";
+import { redactText } from "./redact.js";
+const SESSION_WINDOW_MS = 30 * 60 * 1000;
+const SESSION_SCAN_INTERVAL_MS = 5000;
+const MAX_READ_BYTES = 512 * 1024;
+const MAX_EVENTS = 50;
+let cachedSessions = [];
+let lastSessionScan = 0;
+const tailStates = new Map();
+export function resolveCodexHome(env = process.env) {
+    const override = env.CONSENSUS_CODEX_HOME || env.CODEX_HOME;
+    return override ? path.resolve(override) : path.join(os.homedir(), ".codex");
+}
+async function walk(dir, out, windowMs) {
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const now = Date.now();
+    await Promise.all(entries.map(async (entry) => {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walk(fullPath, out, windowMs);
+            return;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+            return;
+        try {
+            const stat = await fsp.stat(fullPath);
+            if (now - stat.mtimeMs <= windowMs) {
+                out.push({ path: fullPath, mtimeMs: stat.mtimeMs });
+            }
+        }
+        catch {
+            return;
+        }
+    }));
+}
+export async function listRecentSessions(codexHome, windowMs = SESSION_WINDOW_MS) {
+    const now = Date.now();
+    if (now - lastSessionScan < SESSION_SCAN_INTERVAL_MS) {
+        return cachedSessions.filter((item) => now - item.mtimeMs <= windowMs);
+    }
+    lastSessionScan = now;
+    const sessionsDir = path.join(codexHome, "sessions");
+    const results = [];
+    await walk(sessionsDir, results, windowMs);
+    results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    cachedSessions = results;
+    return results;
+}
+export function pickSessionForProcess(sessions, startTimeMs) {
+    if (sessions.length === 0)
+        return undefined;
+    if (!startTimeMs)
+        return sessions[0];
+    let best = sessions[0];
+    let bestDelta = Math.abs(best.mtimeMs - startTimeMs);
+    for (const session of sessions) {
+        const delta = Math.abs(session.mtimeMs - startTimeMs);
+        if (delta < bestDelta) {
+            best = session;
+            bestDelta = delta;
+        }
+    }
+    return best;
+}
+function getEventTimestamp(ev) {
+    const ts = ev.ts || ev.timestamp || ev.time || ev.created_at || ev.createdAt;
+    if (typeof ts === "number") {
+        if (ts < 100000000000) {
+            return ts * 1000;
+        }
+        return ts;
+    }
+    if (typeof ts === "string") {
+        const parsed = Date.parse(ts);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return Date.now();
+}
+function extractModel(ev) {
+    const model = ev.model || ev?.metadata?.model || ev?.data?.model || ev?.item?.model;
+    return typeof model === "string" ? model : undefined;
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(extractText).filter(Boolean).join(" ");
+    if (value && typeof value === "object") {
+        if (typeof value.content === "string")
+            return value.content;
+        if (typeof value.text === "string")
+            return value.text;
+        if (typeof value.message === "string")
+            return value.message;
+        if (value.message && typeof value.message.content === "string")
+            return value.message.content;
+    }
+    return undefined;
+}
+function summarizeEvent(ev) {
+    const item = ev?.item || ev?.data?.item || ev?.delta?.item || ev?.message?.item;
+    const rawType = ev?.type || ev?.event?.type || "event";
+    const rawItemType = item?.type || item?.item_type || item?.itemType;
+    const type = typeof rawType === "string"
+        ? rawType
+        : typeof rawItemType === "string"
+            ? rawItemType
+            : "event";
+    const status = item?.status || ev?.status || ev?.error?.status;
+    const isError = !!ev?.error ||
+        type.includes("error") ||
+        status === "error" ||
+        status === "failed" ||
+        status === "failure";
+    const model = extractModel(ev);
+    const itemType = typeof rawItemType === "string" ? rawItemType : undefined;
+    const cmd = item?.command ||
+        item?.cmd ||
+        item?.input?.command ||
+        item?.input?.cmd ||
+        (Array.isArray(item?.args) ? item.args.join(" ") : undefined) ||
+        ev?.command ||
+        ev?.cmd;
+    if (typeof cmd === "string" && cmd.trim()) {
+        const summary = redactText(`cmd: ${cmd.trim()}`) || `cmd: ${cmd.trim()}`;
+        return { summary, kind: "command", isError, model, type };
+    }
+    const pathHint = item?.path || item?.file || item?.filename || item?.target || ev?.path;
+    const editTypes = new Set(["file_change", "file_edit", "file_write"]);
+    if (typeof pathHint === "string" &&
+        pathHint.trim() &&
+        (editTypes.has(itemType || "") || /file_change|file_edit|file_write/i.test(type))) {
+        const summary = redactText(`edit: ${pathHint.trim()}`) || `edit: ${pathHint.trim()}`;
+        return { summary, kind: "edit", isError, model, type };
+    }
+    const toolName = item?.tool_name ||
+        item?.tool?.name ||
+        item?.tool ||
+        ev?.tool_name ||
+        ev?.tool?.name ||
+        ev?.tool;
+    const toolTypes = new Set(["tool_call", "mcp_tool_call", "tool", "tool_execution"]);
+    if (typeof toolName === "string" &&
+        toolName.trim() &&
+        (toolTypes.has(itemType || "") || /tool/i.test(type))) {
+        const summary = redactText(`tool: ${toolName.trim()}`) || `tool: ${toolName.trim()}`;
+        return { summary, kind: "tool", isError, model, type };
+    }
+    const promptText = extractText(item?.input) ||
+        extractText(item?.prompt) ||
+        extractText(item?.instruction) ||
+        extractText(ev?.input) ||
+        extractText(ev?.prompt) ||
+        extractText(ev?.instruction) ||
+        extractText(ev?.data?.input) ||
+        extractText(ev?.data?.prompt);
+    if (promptText &&
+        (itemType === "prompt" || /thread\.started|turn\.started|prompt/i.test(String(type)))) {
+        const trimmed = promptText.replace(/\s+/g, " ").trim();
+        if (trimmed) {
+            const snippet = trimmed.slice(0, 120);
+            const summary = redactText(`prompt: ${snippet}`) || `prompt: ${snippet}`;
+            return { summary, kind: "prompt", isError, model, type };
+        }
+    }
+    const messageText = extractText(item?.content) ||
+        extractText(item?.message) ||
+        extractText(ev?.message) ||
+        extractText(item?.text) ||
+        extractText(ev?.text);
+    if (messageText && itemType !== "reasoning") {
+        const trimmed = messageText.replace(/\s+/g, " ").trim();
+        if (trimmed) {
+            const snippet = trimmed.slice(0, 80);
+            const summary = redactText(snippet) || snippet;
+            return { summary, kind: "message", isError, model, type };
+        }
+    }
+    const fallbackBits = [
+        typeof type === "string" && type !== "event" ? type : undefined,
+        itemType,
+    ].filter(Boolean);
+    if (fallbackBits.length) {
+        const summary = redactText(`event: ${fallbackBits.join(" ")}`) || `event: ${fallbackBits.join(" ")}`;
+        return { summary, kind: "other", isError, model, type };
+    }
+    return { kind: "other", isError, model, type };
+}
+export async function updateTail(sessionPath) {
+    let stat;
+    try {
+        stat = await fsp.stat(sessionPath);
+    }
+    catch {
+        return null;
+    }
+    const prev = tailStates.get(sessionPath);
+    const state = prev ||
+        {
+            path: sessionPath,
+            offset: 0,
+            partial: "",
+            events: [],
+        };
+    if (stat.size < state.offset) {
+        state.offset = 0;
+        state.partial = "";
+        state.events = [];
+        state.lastEventAt = undefined;
+        state.lastCommand = undefined;
+        state.lastEdit = undefined;
+        state.lastMessage = undefined;
+        state.lastTool = undefined;
+        state.lastError = undefined;
+        state.model = undefined;
+    }
+    const prevOffset = state.offset;
+    let readStart = prevOffset;
+    let trimmed = false;
+    const delta = stat.size - prevOffset;
+    if (delta > MAX_READ_BYTES) {
+        readStart = Math.max(0, stat.size - MAX_READ_BYTES);
+        trimmed = true;
+        state.partial = "";
+    }
+    if (stat.size <= readStart) {
+        tailStates.set(sessionPath, state);
+        return state;
+    }
+    const readLength = stat.size - readStart;
+    const buffer = Buffer.alloc(readLength);
+    try {
+        const handle = await fsp.open(sessionPath, "r");
+        await handle.read(buffer, 0, readLength, readStart);
+        await handle.close();
+    }
+    catch {
+        return null;
+    }
+    let text = buffer.toString("utf8");
+    if (trimmed) {
+        const firstNewline = text.indexOf("\n");
+        if (firstNewline !== -1) {
+            text = text.slice(firstNewline + 1);
+        }
+    }
+    const combined = state.partial + text;
+    const lines = combined.split(/\r?\n/);
+    state.partial = lines.pop() || "";
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let ev;
+        try {
+            ev = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const ts = getEventTimestamp(ev);
+        const { summary, kind, isError, model, type } = summarizeEvent(ev);
+        if (model)
+            state.model = model;
+        if (summary) {
+            const entry = {
+                ts,
+                type: typeof type === "string" ? type : "event",
+                summary,
+                isError,
+            };
+            state.events.push(entry);
+            state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
+            if (kind === "command")
+                state.lastCommand = entry;
+            if (kind === "edit")
+                state.lastEdit = entry;
+            if (kind === "message")
+                state.lastMessage = entry;
+            if (kind === "tool")
+                state.lastTool = entry;
+            if (kind === "prompt")
+                state.lastPrompt = entry;
+            if (isError)
+                state.lastError = entry;
+            if (state.events.length > MAX_EVENTS) {
+                state.events = state.events.slice(-MAX_EVENTS);
+            }
+        }
+        else {
+            state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
+            if (isError) {
+                state.lastError = {
+                    ts,
+                    type: typeof type === "string" ? type : "event",
+                    summary: "error",
+                    isError,
+                };
+            }
+        }
+    }
+    state.offset = stat.size;
+    tailStates.set(sessionPath, state);
+    return state;
+}
+export function summarizeTail(state) {
+    const title = state.lastPrompt?.summary;
+    const doing = state.lastCommand?.summary ||
+        state.lastEdit?.summary ||
+        state.lastMessage?.summary ||
+        state.events[state.events.length - 1]?.summary;
+    const events = state.events.slice(-20);
+    const hasError = !!state.lastError || events.some((event) => event.isError);
+    const lastEventAt = state.lastEventAt || events[events.length - 1]?.ts;
+    const summary = {
+        current: doing,
+        lastCommand: state.lastCommand?.summary,
+        lastEdit: state.lastEdit?.summary,
+        lastMessage: state.lastMessage?.summary,
+        lastTool: state.lastTool?.summary,
+        lastPrompt: state.lastPrompt?.summary,
+    };
+    return { doing, title, events, model: state.model, hasError, summary, lastEventAt };
+}

package/dist/redact.js

@@ -0,0 +1,20 @@
+const REDACT_ENABLED = process.env.CONSENSUS_REDACT_PII !== "0";
+const HOME_PATTERNS = [
+    /\/Users\/[^/\s]+/g,
+    /\/home\/[^/\s]+/g,
+    /C:\\Users\\[^\\\s]+/gi,
+];
+const EMAIL_PATTERN = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+export function redactText(value) {
+    if (!value || !REDACT_ENABLED)
+        return value;
+    let output = value;
+    for (const pattern of HOME_PATTERNS) {
+        output = output.replace(pattern, "~");
+    }
+    output = output.replace(EMAIL_PATTERN, "<redacted-email>");
+    return output;
+}
+export function isRedactionEnabled() {
+    return REDACT_ENABLED;
+}

package/dist/scan.js

@@ -0,0 +1,259 @@
+import psList from "ps-list";
+import pidusage from "pidusage";
+import fs from "fs";
+import path from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { deriveState } from "./activity.js";
+import { listRecentSessions, pickSessionForProcess, resolveCodexHome, summarizeTail, updateTail, } from "./codexLogs.js";
+import { redactText } from "./redact.js";
+const execFileAsync = promisify(execFile);
+const repoCache = new Map();
+function isCodexProcess(cmd, name, matchRe) {
+    if (!cmd && !name)
+        return false;
+    if (matchRe) {
+        return matchRe.test(cmd || "") || matchRe.test(name || "");
+    }
+    const cmdLine = cmd || "";
+    if (name === "codex")
+        return true;
+    if (cmdLine === "codex" || cmdLine.startsWith("codex "))
+        return true;
+    if (cmdLine.includes("/codex") || cmdLine.includes(" codex "))
+        return true;
+    return false;
+}
+function inferKind(cmd) {
+    if (cmd.includes(" app-server"))
+        return "app-server";
+    if (cmd.includes(" exec"))
+        return "exec";
+    if (cmd.includes(" codex") || cmd.startsWith("codex"))
+        return "tui";
+    return "unknown";
+}
+function shortenCmd(cmd, max = 120) {
+    const clean = cmd.replace(/\s+/g, " ").trim();
+    if (clean.length <= max)
+        return clean;
+    return `${clean.slice(0, max - 3)}...`;
+}
+function parseDoingFromCmd(cmd) {
+    const parts = cmd.split(/\s+/g);
+    const execIndex = parts.indexOf("exec");
+    if (execIndex !== -1) {
+        for (let i = execIndex + 1; i < parts.length; i += 1) {
+            const part = parts[i];
+            if (part === "--") {
+                const next = parts[i + 1];
+                return next ? `exec: ${next}` : "exec";
+            }
+            if (!part.startsWith("-")) {
+                return `exec: ${part}`;
+            }
+        }
+        return "exec";
+    }
+    const resumeIndex = parts.indexOf("resume");
+    if (resumeIndex !== -1) {
+        const token = parts[resumeIndex + 1];
+        return token ? `resume: ${token}` : "resume";
+    }
+    const monitorIndex = parts.indexOf("monitor");
+    if (monitorIndex !== -1) {
+        return "monitor";
+    }
+    if (cmd.includes("app-server"))
+        return "app-server";
+    if (cmd.startsWith("codex"))
+        return "codex";
+    return undefined;
+}
+function normalizeTitle(value) {
+    if (!value)
+        return undefined;
+    return value.replace(/^prompt:\s*/i, "").trim();
+}
+function deriveTitle(doing, repo, pid) {
+    if (doing) {
+        const trimmed = doing.trim();
+        if (trimmed.startsWith("cmd:"))
+            return `Run ${trimmed.slice(4).trim()}`;
+        if (trimmed.startsWith("edit:"))
+            return `Editing ${trimmed.slice(5).trim()}`;
+        if (trimmed.startsWith("tool:"))
+            return `Tool ${trimmed.slice(5).trim()}`;
+        if (trimmed.startsWith("exec:"))
+            return `Exec ${trimmed.slice(5).trim()}`;
+        if (trimmed.startsWith("resume:"))
+            return `Resume ${trimmed.slice(7).trim()}`;
+    }
+    if (repo)
+        return repo;
+    return `codex#${pid}`;
+}
+function sanitizeSummary(summary) {
+    if (!summary)
+        return undefined;
+    const cleaned = {};
+    for (const [key, value] of Object.entries(summary)) {
+        if (typeof value !== "string")
+            continue;
+        cleaned[key] = redactText(value) || value;
+    }
+    return cleaned;
+}
+async function getCwdsForPids(pids) {
+    const result = new Map();
+    if (pids.length === 0)
+        return result;
+    if (process.platform === "win32")
+        return result;
+    try {
+        const { stdout } = await execFileAsync("ps", [
+            "-o",
+            "pid=,cwd=",
+            "-p",
+            pids.join(","),
+        ]);
+        const lines = stdout.split(/\r?\n/).filter(Boolean);
+        for (const line of lines) {
+            const match = line.match(/^\s*(\d+)\s+(.*)$/);
+            if (!match)
+                continue;
+            const pid = Number(match[1]);
+            const cwd = match[2].trim();
+            if (cwd)
+                result.set(pid, cwd);
+        }
+    }
+    catch {
+        return result;
+    }
+    return result;
+}
+function findRepoRoot(cwd) {
+    if (repoCache.has(cwd))
+        return repoCache.get(cwd) || null;
+    let current = cwd;
+    while (true) {
+        const gitPath = path.join(current, ".git");
+        if (fs.existsSync(gitPath)) {
+            repoCache.set(cwd, current);
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    repoCache.set(cwd, null);
+    return null;
+}
+export async function scanCodexProcesses() {
+    const matchEnv = process.env.CONSENSUS_PROCESS_MATCH;
+    let matchRe;
+    if (matchEnv) {
+        try {
+            matchRe = new RegExp(matchEnv);
+        }
+        catch {
+            matchRe = undefined;
+        }
+    }
+    const processes = await psList();
+    const codexProcs = processes.filter((proc) => isCodexProcess(proc.cmd, proc.name, matchRe));
+    const pids = codexProcs.map((proc) => proc.pid);
+    let usage = {};
+    try {
+        usage = (await pidusage(pids));
+    }
+    catch {
+        usage = {};
+    }
+    const cwds = await getCwdsForPids(pids);
+    const codexHome = resolveCodexHome();
+    const sessions = await listRecentSessions(codexHome);
+    const agents = [];
+    for (const proc of codexProcs) {
+        const stats = usage[proc.pid] || {};
+        const cpu = typeof stats.cpu === "number" ? stats.cpu : 0;
+        const mem = typeof stats.memory === "number" ? stats.memory : 0;
+        const elapsed = stats.elapsed;
+        const startMs = typeof elapsed === "number" ? Date.now() - elapsed : undefined;
+        const session = pickSessionForProcess(sessions, startMs);
+        let doing;
+        let events;
+        let model;
+        let hasError = false;
+        let title;
+        let summary;
+        let lastEventAt;
+        if (session) {
+            const tail = await updateTail(session.path);
+            if (tail) {
+                const tailSummary = summarizeTail(tail);
+                doing = tailSummary.doing;
+                events = tailSummary.events;
+                model = tailSummary.model;
+                hasError = tailSummary.hasError;
+                title = normalizeTitle(tailSummary.title);
+                summary = tailSummary.summary;
+                lastEventAt = tailSummary.lastEventAt;
+            }
+        }
+        if (!doing) {
+            doing =
+                parseDoingFromCmd(proc.cmd || "") || shortenCmd(proc.cmd || proc.name || "");
+        }
+        if (!summary && doing) {
+            summary = { current: doing };
+        }
+        const cwdRaw = cwds.get(proc.pid);
+        const cwd = redactText(cwdRaw) || cwdRaw;
+        const repoRoot = cwdRaw ? findRepoRoot(cwdRaw) : null;
+        const repoName = repoRoot ? path.basename(repoRoot) : undefined;
+        const state = deriveState({ cpu, hasError, lastEventAt });
+        const cmdRaw = proc.cmd || proc.name || "";
+        const cmd = redactText(cmdRaw) || cmdRaw;
+        const cmdShort = shortenCmd(cmd);
+        const kind = inferKind(cmd);
+        const id = `${proc.pid}`;
+        const startedAt = startMs ? Math.floor(startMs / 1000) : undefined;
+        const computedTitle = title || deriveTitle(doing, repoName, proc.pid);
+        const safeSummary = sanitizeSummary(summary);
+        agents.push({
+            id,
+            pid: proc.pid,
+            startedAt,
+            lastEventAt,
+            title: redactText(computedTitle) || computedTitle,
+            cmd,
+            cmdShort,
+            kind,
+            cpu,
+            mem,
+            state,
+            doing: redactText(doing) || doing,
+            sessionPath: redactText(session?.path) || session?.path,
+            repo: repoName,
+            cwd,
+            model,
+            summary: safeSummary,
+            events,
+        });
+    }
+    return { ts: Date.now(), agents };
+}
+const isDirectRun = process.argv[1] && process.argv[1].endsWith("scan.js");
+if (isDirectRun) {
+    scanCodexProcesses()
+        .then((snapshot) => {
+        process.stdout.write(`${JSON.stringify(snapshot, null, 2)}\n`);
+    })
+        .catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/server.js

@@ -0,0 +1,61 @@
+import express from "express";
+import http from "http";
+import path from "path";
+import { WebSocketServer, WebSocket } from "ws";
+import { fileURLToPath } from "url";
+import { scanCodexProcesses } from "./scan.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const app = express();
+const server = http.createServer(app);
+const wss = new WebSocketServer({ server });
+const port = Number(process.env.CONSENSUS_PORT || 8787);
+const host = process.env.CONSENSUS_HOST || "127.0.0.1";
+const pollMs = Math.max(250, Number(process.env.CONSENSUS_POLL_MS || 1000));
+const publicDir = path.join(__dirname, "..", "public");
+app.use(express.static(publicDir));
+app.get("/api/snapshot", async (_req, res) => {
+    try {
+        const snapshot = await scanCodexProcesses();
+        res.json(snapshot);
+    }
+    catch (err) {
+        res.status(500).json({ error: "scan_failed" });
+    }
+});
+app.get("/health", (_req, res) => {
+    res.json({ ok: true });
+});
+let lastSnapshot = { ts: Date.now(), agents: [] };
+let scanning = false;
+async function tick() {
+    if (scanning)
+        return;
+    scanning = true;
+    try {
+        lastSnapshot = await scanCodexProcesses();
+        const payload = JSON.stringify(lastSnapshot);
+        for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(payload);
+            }
+        }
+    }
+    catch (err) {
+        // Keep server alive on scan errors.
+    }
+    finally {
+        scanning = false;
+    }
+}
+wss.on("connection", (socket) => {
+    socket.send(JSON.stringify(lastSnapshot));
+});
+setInterval(tick, pollMs);
+server.listen(port, host, () => {
+    const url = `http://${host}:${port}`;
+    process.stdout.write(`consensus dev server running on ${url}\n`);
+});
+tick().catch(() => {
+    // initial scan failure is non-fatal
+});

package/dist/tail.js

@@ -0,0 +1,27 @@
+import { summarizeTail, updateTail } from "./codexLogs.js";
+const target = process.argv[2];
+if (!target) {
+    console.error("usage: npm run tail -- <session.jsonl>");
+    process.exit(1);
+}
+let running = false;
+async function tick() {
+    if (running)
+        return;
+    running = true;
+    try {
+        const state = await updateTail(target);
+        if (state) {
+            const summary = summarizeTail(state);
+            process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+        }
+    }
+    finally {
+        running = false;
+    }
+}
+setInterval(tick, 1000);
+tick().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/types.js

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