consensus-cli 0.1.2 → 0.1.5

package/CHANGELOG.md

@@ -5,6 +5,22 @@ This project follows Semantic Versioning.
 
 ## Unreleased
 
+## 0.1.5 - 2026-01-25
+- Add Claude Code process detection with prompt/resume parsing.
+- Apply CLI-specific palettes (Codex/OpenCode/Claude Code) across tiles and lane items.
+- Add Claude CLI parsing unit tests.
+- Update README with Claude Code support.
+
+## 0.1.4 - 2026-01-24
+- Fix OpenCode event tracking build error (pid activity typing).
+
+## 0.1.3 - 2026-01-24
+- Add OpenCode integration (API sessions, event stream, storage fallback).
+- Autostart OpenCode server with opt-out and CLI flags.
+- Split servers into a dedicated lane with distinct palette.
+- Improve layout keys to prevent tile overlap.
+- Add OpenCode unit/integration tests and configuration docs.
+
 ## 0.1.2 - 2026-01-24
 - Lower CPU threshold for active detection.
 - Increase activity window defaults for long-running turns.

package/README.md

@@ -1,12 +1,16 @@
 # consensus-cli
 
-Live isometric atlas for Codex CLI processes, rendered in a local browser.
+[![npm](https://img.shields.io/npm/v/consensus-cli.svg?color=0f766e)](https://www.npmjs.com/package/consensus-cli)
+[![GitHub release](https://img.shields.io/github/v/release/integrate-your-mind/consensus-cli?display_name=tag&color=2563eb)](https://github.com/integrate-your-mind/consensus-cli/releases)
+[![License](https://img.shields.io/npm/l/consensus-cli.svg?color=6b7280)](LICENSE)
+
+Live isometric atlas for Codex, OpenCode, and Claude Code sessions, rendered in a local browser.
 
 ## Status
 Beta. Local-only, no hosted service.
 
 ## Who it's for
-Developers running multiple Codex sessions who want a visual, at-a-glance view of activity.
+Developers running multiple Codex, OpenCode, or Claude Code sessions who want a visual, at-a-glance view of activity.
 
 ## Core use cases
 - Track which agents are active right now.
@@ -15,7 +19,7 @@ Developers running multiple Codex sessions who want a visual, at-a-glance view o
 
 ## Scope (non-goals)
 - Does not start, stop, or manage processes.
-- Does not connect to remote Codex instances.
+- Does not connect to remote Codex, OpenCode, or Claude Code instances.
 - No authentication or multi-user access.
 
 ## Quickstart
@@ -27,6 +31,8 @@ npm run dev
 The server prints the local URL (default `http://127.0.0.1:8787`).
 Consensus reads local Codex CLI sessions and does not require API keys.
 You just need Codex CLI installed and signed in (Pro subscription or team plan).
+If OpenCode is installed, Consensus will auto-start its local server.
+If Claude Code is installed, it will appear automatically (run `claude` once to sign in).
 
 ## Run via npx
 ```bash
@@ -39,17 +45,19 @@ consensus dev server running on http://127.0.0.1:8787
 ```
 
 ## What you get
-- One tile per running `codex` process.
+- One tile per running `codex`, `opencode`, or `claude` process.
 - Activity state (active/idle/error) from CPU and recent events.
-- Best-effort "doing" summary from Codex session JSONL.
+- Best-effort "doing" summary from Codex session JSONL, OpenCode events, or Claude CLI flags.
 - Click a tile for details and recent events.
-- Active lane that highlights what is working right now.
+- Active lane for agents plus a dedicated lane for servers.
 
 ## How it works
-1) Scan OS process list for Codex.
-2) Resolve recent session JSONL under `CODEX_HOME/sessions/`.
-3) Poll and push snapshots over WebSocket.
-4) Render tiles on a canvas with isometric projection.
+1) Scan OS process list for Codex + OpenCode + Claude Code.
+2) Resolve Codex session JSONL under `CODEX_HOME/sessions/`.
+3) Query the OpenCode local server API and event stream (with storage fallback).
+4) Read Claude Code CLI flags to infer current work.
+5) Poll and push snapshots over WebSocket.
+6) Render tiles on a canvas with isometric projection.
 
 ## Install options
 - Local dev: `npm install` + `npm run dev`
@@ -62,6 +70,10 @@ consensus dev server running on http://127.0.0.1:8787
 - `CONSENSUS_PORT`: server port (default `8787`).
 - `CONSENSUS_POLL_MS`: polling interval in ms (default `1000`).
 - `CONSENSUS_CODEX_HOME`: override Codex home (default `~/.codex`).
+- `CONSENSUS_OPENCODE_HOST`: OpenCode server host (default `127.0.0.1`).
+- `CONSENSUS_OPENCODE_PORT`: OpenCode server port (default `4096`).
+- `CONSENSUS_OPENCODE_AUTOSTART`: set to `0` to disable OpenCode autostart.
+- `CONSENSUS_OPENCODE_EVENTS`: set to `0` to disable OpenCode event stream.
 - `CONSENSUS_PROCESS_MATCH`: regex to match codex processes.
 - `CONSENSUS_REDACT_PII`: set to `0` to disable redaction (default enabled).
 - `CONSENSUS_EVENT_ACTIVE_MS`: active window after last event in ms (default `300000`).

package/dist/claudeCli.js

@@ -0,0 +1,125 @@
+import { deriveStateWithHold } from "./activity.js";
+const CLAUDE_BINARIES = new Set(["claude", "claude.exe"]);
+export function splitArgs(command) {
+    if (!command)
+        return [];
+    const args = [];
+    const regex = /"([^"]*)"|'([^']*)'|\S+/g;
+    let match;
+    while ((match = regex.exec(command)) !== null) {
+        const token = match[1] ?? match[2] ?? match[0];
+        if (token)
+            args.push(token);
+    }
+    return args;
+}
+function findClaudeIndex(parts) {
+    for (let i = 0; i < parts.length; i += 1) {
+        const base = parts[i] ? parts[i].split(/[/\\]/).pop() || "" : "";
+        if (CLAUDE_BINARIES.has(base))
+            return i;
+    }
+    return -1;
+}
+function readFlagValue(parts, flag) {
+    const idx = parts.indexOf(flag);
+    if (idx === -1)
+        return undefined;
+    const value = parts[idx + 1];
+    if (!value || value.startsWith("-"))
+        return undefined;
+    return value;
+}
+function findPrompt(parts, startIndex) {
+    for (let i = startIndex; i < parts.length; i += 1) {
+        const part = parts[i];
+        if (!part)
+            continue;
+        if (part === "-p" || part === "--print") {
+            const next = parts[i + 1];
+            if (next && !next.startsWith("-"))
+                return next;
+        }
+        if (part.startsWith("-")) {
+            const skipFlags = new Set([
+                "--output-format",
+                "--input-format",
+                "--model",
+                "--max-turns",
+                "--max-budget-usd",
+                "--tools",
+                "--allowedTools",
+                "--disallowedTools",
+                "--resume",
+                "-r",
+                "--session-id",
+                "--continue",
+                "-c",
+            ]);
+            if (skipFlags.has(part)) {
+                i += 1;
+            }
+            continue;
+        }
+        return part;
+    }
+    return undefined;
+}
+export function parseClaudeCommand(command) {
+    const parts = splitArgs(command);
+    const claudeIndex = findClaudeIndex(parts);
+    if (claudeIndex === -1)
+        return null;
+    const hasPrint = parts.includes("-p") || parts.includes("--print");
+    const continued = parts.includes("--continue") || parts.includes("-c");
+    const resume = readFlagValue(parts, "--resume") || readFlagValue(parts, "-r");
+    const model = readFlagValue(parts, "--model");
+    const prompt = findPrompt(parts, claudeIndex + 1);
+    return {
+        kind: hasPrint ? "claude-cli" : "claude-tui",
+        prompt,
+        resume,
+        continued,
+        model,
+        print: hasPrint,
+    };
+}
+export function summarizeClaudeCommand(command) {
+    const info = parseClaudeCommand(command);
+    if (!info)
+        return null;
+    if (info.prompt) {
+        return { ...info, doing: `prompt: ${info.prompt}` };
+    }
+    if (info.resume) {
+        return { ...info, doing: `resume: ${info.resume}` };
+    }
+    if (info.continued) {
+        return { ...info, doing: "continue" };
+    }
+    if (info.print) {
+        return { ...info, doing: "claude print" };
+    }
+    return { ...info, doing: "claude" };
+}
+export function deriveClaudeState(input) {
+    const info = input.info ?? null;
+    const baseThreshold = input.cpuThreshold ??
+        Number(process.env.CONSENSUS_CLAUDE_CPU_ACTIVE || process.env.CONSENSUS_CPU_ACTIVE || 1);
+    const hasWork = !!info?.prompt || !!info?.resume || !!info?.continued;
+    const isTui = info?.kind === "claude-tui";
+    const effectiveThreshold = isTui && !hasWork ? baseThreshold * 3 : baseThreshold;
+    const result = deriveStateWithHold({
+        cpu: input.cpu,
+        hasError: false,
+        lastEventAt: undefined,
+        inFlight: hasWork,
+        previousActiveAt: input.previousActiveAt,
+        now: input.now,
+        cpuThreshold: effectiveThreshold,
+    });
+    if (!hasWork && input.cpu <= effectiveThreshold) {
+        return { state: "idle", lastActiveAt: undefined };
+    }
+    return result;
+}

package/dist/cli.js

@@ -27,6 +27,9 @@ function printHelp() {
     process.stdout.write(`  --port <port>        Port (default 8787)\n`);
     process.stdout.write(`  --poll <ms>          Poll interval in ms\n`);
     process.stdout.write(`  --codex-home <path>  Override CODEX_HOME\n`);
+    process.stdout.write(`  --opencode-host <h>  OpenCode host (default 127.0.0.1)\n`);
+    process.stdout.write(`  --opencode-port <p>  OpenCode port (default 4096)\n`);
+    process.stdout.write(`  --no-opencode-autostart  Disable OpenCode server autostart\n`);
     process.stdout.write(`  --process-match <re> Regex for process matching\n`);
     process.stdout.write(`  --no-redact          Disable PII redaction\n`);
     process.stdout.write(`  -h, --help           Show help\n`);
@@ -40,6 +43,9 @@ const host = readArg("--host");
 const port = readArg("--port");
 const poll = readArg("--poll");
 const codexHome = readArg("--codex-home");
+const opencodeHost = readArg("--opencode-host");
+const opencodePort = readArg("--opencode-port");
+const noOpenCodeAutostart = hasFlag("--no-opencode-autostart");
 const match = readArg("--process-match");
 const noRedact = hasFlag("--no-redact");
 if (host)
@@ -50,6 +56,12 @@ if (poll)
     env.CONSENSUS_POLL_MS = poll;
 if (codexHome)
     env.CONSENSUS_CODEX_HOME = codexHome;
+if (opencodeHost)
+    env.CONSENSUS_OPENCODE_HOST = opencodeHost;
+if (opencodePort)
+    env.CONSENSUS_OPENCODE_PORT = opencodePort;
+if (noOpenCodeAutostart)
+    env.CONSENSUS_OPENCODE_AUTOSTART = "0";
 if (match)
     env.CONSENSUS_PROCESS_MATCH = match;
 if (noRedact)

package/dist/codexLogs.js

@@ -266,6 +266,8 @@ export async function updateTail(sessionPath) {
             partial: "",
             events: [],
         };
+    const prevMtime = state.lastMtimeMs;
+    state.lastMtimeMs = stat.mtimeMs;
     if (stat.size < state.offset) {
         state.offset = 0;
         state.partial = "";
@@ -313,15 +315,15 @@ export async function updateTail(sessionPath) {
     state.partial = lines.pop() || "";
     const startRe = /(turn|item|response)\.started/i;
     const endRe = /(turn|item|response)\.(completed|failed|errored)/i;
-    for (const line of lines) {
+    const processLine = (line) => {
         if (!line.trim())
-            continue;
+            return false;
         let ev;
         try {
             ev = JSON.parse(line);
         }
         catch {
-            continue;
+            return false;
         }
         const ts = getEventTimestamp(ev);
         const { summary, kind, isError, model, type } = summarizeEvent(ev);
@@ -357,20 +359,39 @@ export async function updateTail(sessionPath) {
             if (state.events.length > MAX_EVENTS) {
                 state.events = state.events.slice(-MAX_EVENTS);
             }
+            return true;
         }
-        else {
-            state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
-            if (isError) {
-                state.lastError = {
-                    ts,
-                    type: typeof type === "string" ? type : "event",
-                    summary: "error",
-                    isError,
-                };
-            }
+        state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
+        if (isError) {
+            state.lastError = {
+                ts,
+                type: typeof type === "string" ? type : "event",
+                summary: "error",
+                isError,
+            };
+            return true;
+        }
+        return true;
+    };
+    let parsedAny = false;
+    for (const line of lines) {
+        if (processLine(line))
+            parsedAny = true;
+    }
+    const candidate = state.partial.trim();
+    if (candidate.startsWith("{") && candidate.endsWith("}")) {
+        if (processLine(candidate)) {
+            parsedAny = true;
+            state.partial = "";
         }
     }
     state.offset = stat.size;
+    if (!state.lastEventAt && typeof stat.mtimeMs === "number") {
+        state.lastEventAt = stat.mtimeMs;
+    }
+    else if (stat.size > prevOffset && prevMtime && prevMtime !== stat.mtimeMs) {
+        state.lastEventAt = Math.max(state.lastEventAt || 0, stat.mtimeMs);
+    }
     tailStates.set(sessionPath, state);
     return state;
 }

package/dist/opencodeApi.js

@@ -0,0 +1,84 @@
+function shouldWarn(options) {
+    return options?.silent ? false : true;
+}
+export async function getOpenCodeSessions(host = "localhost", port = 4096, options) {
+    const controller = new AbortController();
+    const timeoutMs = options?.timeoutMs ?? 5000;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const warn = shouldWarn(options);
+    try {
+        const response = await fetch(`http://${host}:${port}/session`, {
+            headers: {
+                Accept: "application/json",
+                "User-Agent": "consensus-scanner",
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            if (warn) {
+                console.warn(`OpenCode API error: ${response.status} ${response.statusText}`);
+            }
+            return { ok: false, sessions: [], status: response.status, reachable: true };
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (!contentType.includes("json")) {
+            if (warn) {
+                console.warn(`OpenCode API non-JSON response (${contentType || "unknown"})`);
+            }
+            return { ok: false, sessions: [], status: response.status, reachable: true, error: "non_json" };
+        }
+        const payload = await response.json();
+        if (Array.isArray(payload))
+            return { ok: true, sessions: payload, reachable: true };
+        if (payload && typeof payload === "object" && Array.isArray(payload.sessions)) {
+            return { ok: true, sessions: payload.sessions, reachable: true };
+        }
+        if (payload && typeof payload === "object" && Array.isArray(payload.data)) {
+            return { ok: true, sessions: payload.data, reachable: true };
+        }
+        return { ok: true, sessions: [], reachable: true };
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (warn) {
+            console.warn("Failed to fetch OpenCode sessions:", error);
+        }
+        const errorCode = typeof error?.cause?.code === "string"
+            ? error.cause.code
+            : typeof error?.code === "string"
+                ? error.code
+                : undefined;
+        return { ok: false, sessions: [], error: errorCode, reachable: false };
+    }
+}
+export async function getOpenCodeSession(sessionId, host = "localhost", port = 4096, options) {
+    const controller = new AbortController();
+    const timeoutMs = options?.timeoutMs ?? 5000;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const warn = shouldWarn(options);
+    try {
+        const response = await fetch(`http://${host}:${port}/session/${sessionId}`, {
+            headers: {
+                Accept: "application/json",
+                "User-Agent": "consensus-scanner",
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            if (warn) {
+                console.warn(`OpenCode API error for session ${sessionId}: ${response.status} ${response.statusText}`);
+            }
+            return null;
+        }
+        return await response.json();
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (warn) {
+            console.warn(`Failed to fetch OpenCode session ${sessionId}:`, error);
+        }
+        return null;
+    }
+}