consensus-cli 0.1.2 → 0.1.5

package/dist/scan.js

@@ -6,6 +6,12 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { deriveStateWithHold } from "./activity.js";
 import { listRecentSessions, findSessionById, pickSessionForProcess, resolveCodexHome, summarizeTail, updateTail, } from "./codexLogs.js";
+import { getOpenCodeSessions } from "./opencodeApi.js";
+import { ensureOpenCodeServer } from "./opencodeServer.js";
+import { ensureOpenCodeEventStream, getOpenCodeActivityByPid, getOpenCodeActivityBySession, } from "./opencodeEvents.js";
+import { getOpenCodeSessionForDirectory } from "./opencodeStorage.js";
+import { deriveOpenCodeState } from "./opencodeState.js";
+import { deriveClaudeState, summarizeClaudeCommand } from "./claudeCli.js";
 import { redactText } from "./redact.js";
 const execFileAsync = promisify(execFile);
 const repoCache = new Map();
@@ -27,13 +33,50 @@ function isCodexProcess(cmd, name, matchRe) {
         return true;
     return false;
 }
+function isOpenCodeProcess(cmd, name) {
+    if (!cmd && !name)
+        return false;
+    if (name === "opencode")
+        return true;
+    if (!cmd)
+        return false;
+    const firstToken = cmd.trim().split(/\s+/)[0];
+    const base = path.basename(firstToken);
+    if (base === "opencode")
+        return true;
+    return false;
+}
+function isClaudeProcess(cmd, name) {
+    if (!cmd && !name)
+        return false;
+    if (name === "claude")
+        return true;
+    if (!cmd)
+        return false;
+    const firstToken = cmd.trim().split(/\s+/)[0];
+    const base = path.basename(firstToken);
+    if (base === "claude" || base === "claude.exe")
+        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"))
+    if (cmd.includes(" codex") || cmd.startsWith("codex") || cmd.includes("/codex"))
         return "tui";
+    if (cmd.includes(" opencode") || cmd.startsWith("opencode") || cmd.includes("/opencode")) {
+        if (cmd.includes(" serve") || cmd.includes("--serve") || cmd.includes(" web")) {
+            return "opencode-server";
+        }
+        if (cmd.includes(" run"))
+            return "opencode-cli";
+        return "opencode-tui";
+    }
+    const claudeInfo = summarizeClaudeCommand(cmd);
+    if (claudeInfo)
+        return claudeInfo.kind;
     return "unknown";
 }
 function shortenCmd(cmd, max = 120) {
@@ -44,6 +87,25 @@ function shortenCmd(cmd, max = 120) {
 }
 function parseDoingFromCmd(cmd) {
     const parts = cmd.split(/\s+/g);
+    const claudeInfo = summarizeClaudeCommand(cmd);
+    if (claudeInfo?.doing)
+        return claudeInfo.doing;
+    const openIndex = parts.findIndex((part) => part === "opencode" || part.endsWith("/opencode"));
+    if (openIndex !== -1) {
+        const mode = parts[openIndex + 1];
+        if (mode === "serve" || mode === "web")
+            return `opencode ${mode}`;
+        if (mode === "run") {
+            for (let i = openIndex + 2; i < parts.length; i += 1) {
+                const part = parts[i];
+                if (!part || part.startsWith("-"))
+                    continue;
+                return `opencode run: ${part}`;
+            }
+            return "opencode run";
+        }
+        return "opencode";
+    }
     const execIndex = parts.indexOf("exec");
     if (execIndex !== -1) {
         for (let i = execIndex + 1; i < parts.length; i += 1) {
@@ -89,12 +151,43 @@ function extractSessionId(cmd) {
     }
     return undefined;
 }
+function extractOpenCodeSessionId(cmd) {
+    const parts = cmd.split(/\s+/g);
+    const sessionFlag = parts.findIndex((part) => part === "--session" || part === "--session-id" || part === "-s");
+    if (sessionFlag !== -1) {
+        const token = parts[sessionFlag + 1];
+        if (token)
+            return token;
+    }
+    return undefined;
+}
 function normalizeTitle(value) {
     if (!value)
         return undefined;
     return value.replace(/^prompt:\s*/i, "").trim();
 }
-function deriveTitle(doing, repo, pid) {
+function parseTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value < 100000000000 ? value * 1000 : value;
+    }
+    if (typeof value === "string") {
+        const parsed = Date.parse(value);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function coerceNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function deriveTitle(doing, repo, pid, kind) {
     if (doing) {
         const trimmed = doing.trim();
         if (trimmed.startsWith("cmd:"))
@@ -110,7 +203,12 @@ function deriveTitle(doing, repo, pid) {
     }
     if (repo)
         return repo;
-    return `codex#${pid}`;
+    const prefix = kind.startsWith("opencode")
+        ? "opencode"
+        : kind.startsWith("claude")
+            ? "claude"
+            : "codex";
+    return `${prefix}#${pid}`;
 }
 function sanitizeSummary(summary) {
     if (!summary)
@@ -146,6 +244,35 @@ async function getCwdsForPids(pids) {
             if (cwd)
                 result.set(pid, cwd);
         }
+        if (result.size > 0) {
+            return result;
+        }
+    }
+    catch {
+        // fall through to lsof
+    }
+    try {
+        const { stdout } = await execFileAsync("lsof", [
+            "-a",
+            "-p",
+            pids.join(","),
+            "-d",
+            "cwd",
+            "-Fn",
+        ]);
+        let currentPid = null;
+        const lines = stdout.split(/\r?\n/).filter(Boolean);
+        for (const line of lines) {
+            if (line.startsWith("p")) {
+                const pid = Number(line.slice(1));
+                currentPid = Number.isNaN(pid) ? null : pid;
+            }
+            else if (line.startsWith("n") && currentPid) {
+                const cwd = line.slice(1).trim();
+                if (cwd)
+                    result.set(currentPid, cwd);
+            }
+        }
     }
     catch {
         return result;
@@ -210,7 +337,15 @@ export async function scanCodexProcesses() {
     }
     const processes = await psList();
     const codexProcs = processes.filter((proc) => isCodexProcess(proc.cmd, proc.name, matchRe));
-    const pids = codexProcs.map((proc) => proc.pid);
+    const codexPidSet = new Set(codexProcs.map((proc) => proc.pid));
+    const opencodeProcs = processes
+        .filter((proc) => isOpenCodeProcess(proc.cmd, proc.name))
+        .filter((proc) => !codexPidSet.has(proc.pid));
+    const opencodePidSet = new Set(opencodeProcs.map((proc) => proc.pid));
+    const claudeProcs = processes
+        .filter((proc) => isClaudeProcess(proc.cmd, proc.name))
+        .filter((proc) => !codexPidSet.has(proc.pid) && !opencodePidSet.has(proc.pid));
+    const pids = Array.from(new Set([...codexProcs, ...opencodeProcs, ...claudeProcs].map((proc) => proc.pid)));
     let usage = {};
     try {
         usage = (await pidusage(pids));
@@ -222,6 +357,32 @@ export async function scanCodexProcesses() {
     const startTimes = await getStartTimesForPids(pids);
     const codexHome = resolveCodexHome();
     const sessions = await listRecentSessions(codexHome);
+    const opencodeHost = process.env.CONSENSUS_OPENCODE_HOST || "127.0.0.1";
+    const opencodePort = Number(process.env.CONSENSUS_OPENCODE_PORT || 4096);
+    const opencodeResult = await getOpenCodeSessions(opencodeHost, opencodePort, {
+        silent: true,
+        timeoutMs: Number(process.env.CONSENSUS_OPENCODE_TIMEOUT_MS || 1000),
+    });
+    await ensureOpenCodeServer(opencodeHost, opencodePort, opencodeResult);
+    if (opencodeProcs.length) {
+        ensureOpenCodeEventStream(opencodeHost, opencodePort);
+    }
+    const opencodeSessions = opencodeResult.ok ? opencodeResult.sessions : [];
+    const opencodeApiAvailable = opencodeResult.ok;
+    const opencodeSessionsByPid = new Map();
+    const opencodeSessionsByDir = new Map();
+    for (const session of opencodeSessions) {
+        const pid = coerceNumber(session.pid);
+        if (typeof pid === "number") {
+            opencodeSessionsByPid.set(pid, session);
+        }
+        if (typeof session.directory === "string") {
+            opencodeSessionsByDir.set(session.directory, session);
+        }
+        if (typeof session.cwd === "string") {
+            opencodeSessionsByDir.set(session.cwd, session);
+        }
+    }
     const agents = [];
     const seenIds = new Set();
     for (const proc of codexProcs) {
@@ -287,7 +448,7 @@ export async function scanCodexProcesses() {
         const cmdShort = shortenCmd(cmd);
         const kind = inferKind(cmd);
         const startedAt = startMs ? Math.floor(startMs / 1000) : undefined;
-        const computedTitle = title || deriveTitle(doing, repoName, proc.pid);
+        const computedTitle = title || deriveTitle(doing, repoName, proc.pid, kind);
         const safeSummary = sanitizeSummary(summary);
         agents.push({
             id,
@@ -310,6 +471,181 @@ export async function scanCodexProcesses() {
             events,
         });
     }
+    const opencodeEventWindowMs = Number(process.env.CONSENSUS_OPENCODE_EVENT_ACTIVE_MS || 90000);
+    const opencodeHoldMs = Number(process.env.CONSENSUS_OPENCODE_ACTIVE_HOLD_MS || 120000);
+    const cpuThreshold = Number(process.env.CONSENSUS_CPU_ACTIVE || 1);
+    for (const proc of opencodeProcs) {
+        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
+            : startTimes.get(proc.pid);
+        const cmdRaw = proc.cmd || proc.name || "";
+        const sessionByPid = opencodeSessionsByPid.get(proc.pid);
+        const cwdMatch = cwds.get(proc.pid);
+        const sessionByDir = sessionByPid
+            ? undefined
+            : opencodeSessionsByDir.get(cwdMatch || "");
+        const session = sessionByPid || sessionByDir;
+        const storageSession = !session && cwdMatch ? await getOpenCodeSessionForDirectory(cwdMatch) : undefined;
+        const sessionId = session?.id || storageSession?.id || extractOpenCodeSessionId(cmdRaw);
+        const sessionTitle = normalizeTitle(session?.title || session?.name || storageSession?.title);
+        const sessionCwd = session?.cwd || session?.directory || storageSession?.directory;
+        const cwdRaw = sessionCwd || cwds.get(proc.pid);
+        const cwd = redactText(cwdRaw) || cwdRaw;
+        const repoRoot = cwdRaw ? findRepoRoot(cwdRaw) : null;
+        const repoName = repoRoot ? path.basename(repoRoot) : undefined;
+        const lastActivityAt = parseTimestamp(session?.lastActivity ||
+            session?.lastActivityAt ||
+            storageSession?.time?.updated ||
+            storageSession?.time?.created ||
+            session?.time?.updated ||
+            session?.time?.created ||
+            session?.updatedAt ||
+            session?.updated ||
+            session?.createdAt ||
+            session?.created);
+        const statusRaw = typeof session?.status === "string" ? session.status : undefined;
+        const status = statusRaw?.toLowerCase();
+        const statusIsError = !!status && /error|failed|failure/.test(status);
+        const statusIsIdle = !!status && /idle|stopped|paused/.test(status);
+        let hasError = statusIsError;
+        const model = typeof session?.model === "string" ? session.model : undefined;
+        let doing = sessionTitle;
+        let summary;
+        let events;
+        const eventActivity = getOpenCodeActivityBySession(sessionId) || getOpenCodeActivityByPid(proc.pid);
+        let lastEventAt = eventActivity?.lastEventAt;
+        let inFlight = eventActivity?.inFlight;
+        if (eventActivity) {
+            events = eventActivity.events;
+            summary = eventActivity.summary || summary;
+            lastEventAt = eventActivity.lastEventAt || lastEventAt;
+            if (eventActivity.hasError)
+                hasError = true;
+            if (eventActivity.inFlight)
+                inFlight = true;
+            if (eventActivity.summary?.current)
+                doing = eventActivity.summary.current;
+        }
+        if (!lastEventAt && statusIsIdle) {
+            lastEventAt = undefined;
+        }
+        if (!doing) {
+            doing =
+                parseDoingFromCmd(proc.cmd || "") || shortenCmd(proc.cmd || proc.name || "");
+        }
+        if (doing)
+            summary = { current: doing };
+        const id = `${proc.pid}`;
+        const cached = activityCache.get(id);
+        const kind = inferKind(cmdRaw);
+        const activity = deriveOpenCodeState({
+            cpu,
+            hasError,
+            lastEventAt: lastEventAt,
+            inFlight,
+            status,
+            isServer: kind === "opencode-server",
+            previousActiveAt: cached?.lastActiveAt,
+            now,
+            cpuThreshold,
+            eventWindowMs: opencodeEventWindowMs,
+            holdMs: opencodeHoldMs,
+        });
+        let state = activity.state;
+        const hasSignal = statusIsIdle ||
+            statusIsError ||
+            typeof lastEventAt === "number" ||
+            typeof inFlight === "boolean";
+        if (!opencodeApiAvailable && !hasSignal)
+            state = "idle";
+        if (!hasSignal && cpu <= cpuThreshold) {
+            state = "idle";
+        }
+        activityCache.set(id, { lastActiveAt: activity.lastActiveAt, lastSeenAt: now });
+        seenIds.add(id);
+        const cmd = redactText(cmdRaw) || cmdRaw;
+        const cmdShort = shortenCmd(cmd);
+        const startedAt = startMs ? Math.floor(startMs / 1000) : undefined;
+        const computedTitle = sessionTitle || deriveTitle(doing, repoName, proc.pid, kind);
+        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,
+            repo: repoName,
+            cwd,
+            model,
+            summary: safeSummary,
+            events,
+        });
+    }
+    for (const proc of claudeProcs) {
+        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
+            : startTimes.get(proc.pid);
+        const cmdRaw = proc.cmd || proc.name || "";
+        const claudeInfo = summarizeClaudeCommand(cmdRaw);
+        const doing = claudeInfo?.doing ||
+            parseDoingFromCmd(cmdRaw) ||
+            shortenCmd(cmdRaw || proc.name || "");
+        const summary = doing ? { current: doing } : undefined;
+        const model = claudeInfo?.model;
+        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 kind = claudeInfo?.kind || inferKind(cmdRaw);
+        const id = `${proc.pid}`;
+        const cached = activityCache.get(id);
+        const activity = deriveClaudeState({
+            cpu,
+            info: claudeInfo,
+            previousActiveAt: cached?.lastActiveAt,
+            now,
+        });
+        const state = activity.state;
+        activityCache.set(id, { lastActiveAt: state === "active" ? activity.lastActiveAt : undefined, lastSeenAt: now });
+        seenIds.add(id);
+        const cmd = redactText(cmdRaw) || cmdRaw;
+        const cmdShort = shortenCmd(cmd);
+        const startedAt = startMs ? Math.floor(startMs / 1000) : undefined;
+        const computedTitle = deriveTitle(doing, repoName, proc.pid, kind);
+        const safeSummary = sanitizeSummary(summary);
+        agents.push({
+            id,
+            pid: proc.pid,
+            startedAt,
+            title: redactText(computedTitle) || computedTitle,
+            cmd,
+            cmdShort,
+            kind,
+            cpu,
+            mem,
+            state,
+            doing: redactText(doing) || doing,
+            repo: repoName,
+            cwd,
+            model,
+            summary: safeSummary,
+        });
+    }
     for (const id of activityCache.keys()) {
         if (!seenIds.has(id)) {
             activityCache.delete(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "consensus-cli",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "private": false,
   "license": "Apache-2.0",
   "repository": {