consensus-cli 0.1.2 → 0.1.5

package/dist/opencodeEvents.js

@@ -0,0 +1,388 @@
+import { redactText } from "./redact.js";
+const MAX_EVENTS = 50;
+const STALE_TTL_MS = 30 * 60 * 1000;
+const RECONNECT_MIN_MS = 10000;
+const sessionActivity = new Map();
+const pidActivity = new Map();
+let connecting = false;
+let connected = false;
+let lastConnectAt = 0;
+let lastFailureAt = 0;
+function nowMs() {
+    return Date.now();
+}
+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 nowMs();
+}
+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.text === "string")
+            return value.text;
+        if (typeof value.content === "string")
+            return value.content;
+        if (typeof value.message === "string")
+            return value.message;
+        if (value.message && typeof value.message.content === "string") {
+            return value.message.content;
+        }
+    }
+    return undefined;
+}
+function getSessionId(raw) {
+    return (raw?.sessionId ||
+        raw?.session_id ||
+        raw?.session?.id ||
+        raw?.session?.sessionId ||
+        raw?.properties?.sessionId ||
+        raw?.properties?.session_id);
+}
+function getPid(raw) {
+    const pid = raw?.pid ||
+        raw?.process?.pid ||
+        raw?.properties?.pid ||
+        raw?.properties?.processId;
+    if (typeof pid === "number" && Number.isFinite(pid))
+        return pid;
+    if (typeof pid === "string") {
+        const parsed = Number(pid);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function summarizeEvent(raw) {
+    const typeRaw = raw?.type ||
+        raw?.event ||
+        raw?.name ||
+        raw?.kind ||
+        raw?.properties?.type ||
+        "event";
+    const type = typeof typeRaw === "string" ? typeRaw : "event";
+    const lowerType = type.toLowerCase();
+    const status = raw?.status || raw?.state || raw?.properties?.status;
+    const statusStr = typeof status === "string" ? status.toLowerCase() : "";
+    const isError = !!raw?.error || lowerType.includes("error") || statusStr.includes("error");
+    let inFlight;
+    if (lowerType.includes("started") ||
+        statusStr.includes("started") ||
+        statusStr.includes("running") ||
+        statusStr.includes("processing") ||
+        statusStr.includes("in_progress")) {
+        inFlight = true;
+    }
+    else if (lowerType.includes("completed") ||
+        lowerType.includes("finished") ||
+        lowerType.includes("done") ||
+        lowerType.includes("ended") ||
+        statusStr.includes("completed") ||
+        statusStr.includes("finished") ||
+        statusStr.includes("done") ||
+        statusStr.includes("ended") ||
+        statusStr.includes("idle") ||
+        statusStr.includes("stopped") ||
+        statusStr.includes("paused") ||
+        isError) {
+        inFlight = false;
+    }
+    if (lowerType.includes("compaction")) {
+        const phase = statusStr || raw?.phase || raw?.properties?.phase;
+        const summary = phase ? `compaction: ${phase}` : "compaction";
+        return { summary, kind: "other", isError, type, inFlight };
+    }
+    const cmd = raw?.command ||
+        raw?.cmd ||
+        raw?.input?.command ||
+        raw?.input?.cmd ||
+        raw?.properties?.command ||
+        raw?.properties?.cmd ||
+        (Array.isArray(raw?.args) ? raw.args.join(" ") : undefined);
+    if (typeof cmd === "string" && cmd.trim()) {
+        const summary = redactText(`cmd: ${cmd.trim()}`) || `cmd: ${cmd.trim()}`;
+        return { summary, kind: "command", isError, type, inFlight };
+    }
+    const pathHint = raw?.path ||
+        raw?.file ||
+        raw?.filename ||
+        raw?.target ||
+        raw?.properties?.path ||
+        raw?.properties?.file;
+    if (typeof pathHint === "string" && pathHint.trim() && lowerType.includes("file")) {
+        const summary = redactText(`edit: ${pathHint.trim()}`) || `edit: ${pathHint.trim()}`;
+        return { summary, kind: "edit", isError, type, inFlight };
+    }
+    const tool = raw?.tool ||
+        raw?.tool_name ||
+        raw?.toolName ||
+        raw?.properties?.tool ||
+        raw?.properties?.tool_name;
+    if (typeof tool === "string" && tool.trim() && lowerType.includes("tool")) {
+        const summary = redactText(`tool: ${tool.trim()}`) || `tool: ${tool.trim()}`;
+        return { summary, kind: "tool", isError, type, inFlight };
+    }
+    const promptText = extractText(raw?.prompt) ||
+        extractText(raw?.input) ||
+        extractText(raw?.instruction) ||
+        extractText(raw?.properties?.prompt);
+    if (promptText && lowerType.includes("prompt")) {
+        const trimmed = promptText.replace(/\s+/g, " ").trim();
+        const snippet = trimmed.slice(0, 120);
+        const summary = redactText(`prompt: ${snippet}`) || `prompt: ${snippet}`;
+        return { summary, kind: "prompt", isError, type, inFlight };
+    }
+    const messageText = extractText(raw?.message) ||
+        extractText(raw?.content) ||
+        extractText(raw?.text) ||
+        extractText(raw?.properties?.message);
+    if (messageText) {
+        const trimmed = messageText.replace(/\s+/g, " ").trim();
+        const snippet = trimmed.slice(0, 80);
+        const summary = redactText(snippet) || snippet;
+        return { summary, kind: "message", isError, type, inFlight };
+    }
+    if (type && type !== "event") {
+        const summary = redactText(`event: ${type}`) || `event: ${type}`;
+        return { summary, kind: "other", isError, type, inFlight };
+    }
+    return { kind: "other", isError, type, inFlight };
+}
+function ensureActivity(key, map, now) {
+    const existing = map.get(key);
+    if (existing) {
+        existing.lastSeenAt = now;
+        return existing;
+    }
+    const fresh = {
+        events: [],
+        summary: {},
+        lastSeenAt: now,
+    };
+    map.set(key, fresh);
+    return fresh;
+}
+function recordEvent(state, entry, kind) {
+    state.events.push(entry);
+    if (state.events.length > MAX_EVENTS) {
+        state.events = state.events.slice(-MAX_EVENTS);
+    }
+    state.lastEventAt = Math.max(state.lastEventAt || 0, entry.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 (entry.isError)
+        state.lastError = entry;
+    state.summary = {
+        current: state.events[state.events.length - 1]?.summary,
+        lastCommand: state.lastCommand?.summary,
+        lastEdit: state.lastEdit?.summary,
+        lastMessage: state.lastMessage?.summary,
+        lastTool: state.lastTool?.summary,
+        lastPrompt: state.lastPrompt?.summary,
+    };
+}
+function handleRawEvent(raw) {
+    const ts = parseTimestamp(raw?.ts ||
+        raw?.timestamp ||
+        raw?.time ||
+        raw?.created_at ||
+        raw?.createdAt ||
+        raw?.properties?.time ||
+        raw?.properties?.timestamp);
+    const sessionId = getSessionId(raw);
+    const pid = getPid(raw);
+    const { summary, kind, isError, type, inFlight } = summarizeEvent(raw);
+    const entry = summary
+        ? {
+            ts,
+            type: typeof type === "string" ? type : "event",
+            summary,
+            isError,
+        }
+        : null;
+    const now = nowMs();
+    if (sessionId) {
+        const state = ensureActivity(sessionId, sessionActivity, now);
+        if (entry) {
+            recordEvent(state, entry, kind);
+        }
+        else {
+            state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
+            if (isError) {
+                state.lastError = {
+                    ts,
+                    type: typeof type === "string" ? type : "event",
+                    summary: "error",
+                    isError,
+                };
+            }
+        }
+        if (typeof inFlight === "boolean")
+            state.inFlight = inFlight;
+    }
+    if (typeof pid === "number") {
+        const state = ensureActivity(pid, pidActivity, now);
+        if (entry) {
+            recordEvent(state, entry, kind);
+        }
+        else {
+            state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
+            if (isError) {
+                state.lastError = {
+                    ts,
+                    type: typeof type === "string" ? type : "event",
+                    summary: "error",
+                    isError,
+                };
+            }
+        }
+        if (typeof inFlight === "boolean")
+            state.inFlight = inFlight;
+    }
+}
+export function ingestOpenCodeEvent(raw) {
+    handleRawEvent(raw);
+}
+function pruneStale() {
+    const cutoff = nowMs() - STALE_TTL_MS;
+    for (const [key, state] of sessionActivity.entries()) {
+        if (state.lastSeenAt < cutoff)
+            sessionActivity.delete(key);
+    }
+    for (const [key, state] of pidActivity.entries()) {
+        if (state.lastSeenAt < cutoff)
+            pidActivity.delete(key);
+    }
+}
+async function connectStream(host, port) {
+    connecting = true;
+    lastConnectAt = nowMs();
+    try {
+        const response = await fetch(`http://${host}:${port}/global/event`, {
+            headers: {
+                Accept: "text/event-stream",
+            },
+        });
+        if (!response.ok || !response.body) {
+            connected = false;
+            connecting = false;
+            lastFailureAt = nowMs();
+            return;
+        }
+        connected = true;
+        connecting = false;
+        const reader = response.body.getReader();
+        let buffer = "";
+        let currentEvent;
+        let dataLines = [];
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += Buffer.from(value).toString("utf8");
+            let idx;
+            while ((idx = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, idx).trimEnd();
+                buffer = buffer.slice(idx + 1);
+                if (!line) {
+                    if (dataLines.length) {
+                        const payload = dataLines.join("\n");
+                        try {
+                            const parsed = JSON.parse(payload);
+                            const raw = parsed?.payload ?? parsed;
+                            if (currentEvent && typeof raw === "object" && !raw.type) {
+                                raw.type = currentEvent;
+                            }
+                            if (parsed?.type && typeof raw === "object" && !raw.type) {
+                                raw.type = parsed.type;
+                            }
+                            handleRawEvent(raw);
+                        }
+                        catch {
+                            // ignore malformed payloads
+                        }
+                    }
+                    currentEvent = undefined;
+                    dataLines = [];
+                    continue;
+                }
+                if (line.startsWith("event:")) {
+                    currentEvent = line.slice(6).trim();
+                    continue;
+                }
+                if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trim());
+                }
+            }
+        }
+    }
+    catch {
+        lastFailureAt = nowMs();
+    }
+    finally {
+        connected = false;
+        connecting = false;
+    }
+}
+export function ensureOpenCodeEventStream(host, port) {
+    if (process.env.CONSENSUS_OPENCODE_EVENTS === "0")
+        return;
+    const now = nowMs();
+    if (connecting || connected)
+        return;
+    if (now - lastConnectAt < RECONNECT_MIN_MS)
+        return;
+    if (now - lastFailureAt < RECONNECT_MIN_MS)
+        return;
+    pruneStale();
+    void connectStream(host, port);
+}
+export function getOpenCodeActivityBySession(sessionId) {
+    if (!sessionId)
+        return null;
+    const state = sessionActivity.get(sessionId);
+    if (!state)
+        return null;
+    const events = state.events.slice(-20);
+    const hasError = !!state.lastError || events.some((ev) => ev.isError);
+    return {
+        events,
+        summary: state.summary,
+        lastEventAt: state.lastEventAt,
+        hasError,
+        inFlight: state.inFlight,
+    };
+}
+export function getOpenCodeActivityByPid(pid) {
+    if (typeof pid !== "number")
+        return null;
+    const state = pidActivity.get(pid);
+    if (!state)
+        return null;
+    const events = state.events.slice(-20);
+    const hasError = !!state.lastError || events.some((ev) => ev.isError);
+    return {
+        events,
+        summary: state.summary,
+        lastEventAt: state.lastEventAt,
+        hasError,
+        inFlight: state.inFlight,
+    };
+}

package/dist/opencodeServer.js

@@ -0,0 +1,91 @@
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+import { getOpenCodeSessions } from "./opencodeApi.js";
+const execFileAsync = promisify(execFile);
+const AUTOSTART_ENABLED = process.env.CONSENSUS_OPENCODE_AUTOSTART !== "0";
+const CHECK_INTERVAL_MS = 30000;
+const INSTALL_CHECK_INTERVAL_MS = 5 * 60000;
+const START_BACKOFF_MS = 60000;
+let lastAttemptAt = 0;
+let lastInstallCheck = 0;
+let lastStartAt = 0;
+let opencodeInstalled = null;
+let startedPid = null;
+let startInFlight = false;
+async function isOpenCodeInstalled() {
+    const now = Date.now();
+    if (opencodeInstalled !== null && now - lastInstallCheck < INSTALL_CHECK_INTERVAL_MS) {
+        return opencodeInstalled;
+    }
+    lastInstallCheck = now;
+    try {
+        await execFileAsync("opencode", ["--version"]);
+        opencodeInstalled = true;
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            opencodeInstalled = false;
+        }
+        else {
+            opencodeInstalled = true;
+        }
+    }
+    return opencodeInstalled;
+}
+function spawnOpenCodeServer(host, port) {
+    if (startInFlight)
+        return;
+    startInFlight = true;
+    const child = spawn("opencode", ["serve", "--hostname", host, "--port", String(port)], {
+        stdio: "ignore",
+        detached: true,
+    });
+    child.unref();
+    startedPid = child.pid ?? null;
+    child.on("error", () => {
+        startInFlight = false;
+    });
+    child.on("spawn", () => {
+        startInFlight = false;
+    });
+}
+export async function ensureOpenCodeServer(host, port, existingResult) {
+    if (!AUTOSTART_ENABLED)
+        return;
+    const now = Date.now();
+    if (now - lastAttemptAt < CHECK_INTERVAL_MS)
+        return;
+    lastAttemptAt = now;
+    const installed = await isOpenCodeInstalled();
+    if (!installed)
+        return;
+    const result = existingResult ?? (await getOpenCodeSessions(host, port, { silent: true }));
+    if (result.ok)
+        return;
+    if (result.reachable)
+        return;
+    if (now - lastStartAt < START_BACKOFF_MS)
+        return;
+    lastStartAt = now;
+    spawnOpenCodeServer(host, port);
+}
+function stopOpenCodeServer() {
+    if (!startedPid)
+        return;
+    try {
+        process.kill(startedPid);
+    }
+    catch {
+        // ignore failures
+    }
+    startedPid = null;
+}
+process.on("exit", stopOpenCodeServer);
+process.on("SIGINT", () => {
+    stopOpenCodeServer();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    stopOpenCodeServer();
+    process.exit(0);
+});

package/dist/opencodeState.js

@@ -0,0 +1,36 @@
+import { deriveStateWithHold } from "./activity.js";
+export function deriveOpenCodeState(input) {
+    const status = input.status?.toLowerCase();
+    const statusIsError = !!status && /error|failed|failure/.test(status);
+    const statusIsActive = !!status && /running|active|processing/.test(status);
+    const statusIsIdle = !!status && /idle|stopped|paused/.test(status);
+    const activity = deriveStateWithHold({
+        cpu: input.cpu,
+        hasError: input.hasError,
+        lastEventAt: input.lastEventAt,
+        inFlight: input.inFlight,
+        previousActiveAt: input.previousActiveAt,
+        now: input.now,
+        cpuThreshold: input.cpuThreshold,
+        eventWindowMs: input.eventWindowMs,
+        holdMs: input.holdMs,
+    });
+    let state = activity.state;
+    if (statusIsError) {
+        state = "error";
+    }
+    else if (statusIsIdle) {
+        state = "idle";
+    }
+    else if (statusIsActive && state !== "active") {
+        state = "idle";
+    }
+    const cpuThreshold = input.cpuThreshold ?? Number(process.env.CONSENSUS_CPU_ACTIVE || 1);
+    if (input.isServer) {
+        state = input.cpu > cpuThreshold ? "active" : "idle";
+    }
+    if (state === "idle") {
+        return { state, lastActiveAt: undefined };
+    }
+    return { state, lastActiveAt: activity.lastActiveAt };
+}

package/dist/opencodeStorage.js

@@ -0,0 +1,127 @@
+import fsp from "fs/promises";
+import os from "os";
+import path from "path";
+const PROJECT_SCAN_INTERVAL_MS = 60000;
+const SESSION_SCAN_INTERVAL_MS = 5000;
+let projectCache = [];
+let projectCacheAt = 0;
+const sessionCache = new Map();
+export function resolveOpenCodeHome(env = process.env) {
+    const override = env.CONSENSUS_OPENCODE_HOME;
+    if (override)
+        return path.resolve(override);
+    return path.join(os.homedir(), ".local", "share", "opencode");
+}
+async function listProjectEntries(home) {
+    const now = Date.now();
+    if (now - projectCacheAt < PROJECT_SCAN_INTERVAL_MS)
+        return projectCache;
+    projectCacheAt = now;
+    const projectDir = path.join(home, "storage", "project");
+    let entries;
+    try {
+        entries = await fsp.readdir(projectDir, { withFileTypes: true });
+    }
+    catch {
+        projectCache = [];
+        return projectCache;
+    }
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json"))
+            continue;
+        const fullPath = path.join(projectDir, entry.name);
+        try {
+            const raw = await fsp.readFile(fullPath, "utf8");
+            const data = JSON.parse(raw);
+            results.push({
+                id: data.id || entry.name.replace(/\.json$/, ""),
+                worktree: data.worktree || data.directory,
+                time: data.time,
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    projectCache = results;
+    return results;
+}
+function pickProjectId(projects, cwd) {
+    const normalized = cwd.replace(/\\/g, "/");
+    let best;
+    for (const project of projects) {
+        if (!project.worktree)
+            continue;
+        const projectPath = project.worktree.replace(/\\/g, "/");
+        if (normalized === projectPath || normalized.startsWith(`${projectPath}/`)) {
+            if (!best || (projectPath.length > (best.worktree?.length || 0))) {
+                best = project;
+            }
+        }
+    }
+    return best?.id;
+}
+async function readLatestSessionForProject(home, projectId) {
+    const now = Date.now();
+    const cached = sessionCache.get(projectId);
+    if (cached && now - cached.scannedAt < SESSION_SCAN_INTERVAL_MS) {
+        return cached.session;
+    }
+    const sessionDir = path.join(home, "storage", "session", projectId);
+    let entries;
+    try {
+        entries = await fsp.readdir(sessionDir, { withFileTypes: true });
+    }
+    catch {
+        sessionCache.set(projectId, { session: undefined, scannedAt: now });
+        return undefined;
+    }
+    let latestPath = null;
+    let latestMtime = 0;
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.startsWith("ses_") || !entry.name.endsWith(".json"))
+            continue;
+        const fullPath = path.join(sessionDir, entry.name);
+        try {
+            const stat = await fsp.stat(fullPath);
+            if (stat.mtimeMs > latestMtime) {
+                latestMtime = stat.mtimeMs;
+                latestPath = fullPath;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (!latestPath) {
+        sessionCache.set(projectId, { session: undefined, scannedAt: now });
+        return undefined;
+    }
+    try {
+        const raw = await fsp.readFile(latestPath, "utf8");
+        const data = JSON.parse(raw);
+        const session = {
+            id: data.id,
+            title: data.title,
+            directory: data.directory,
+            time: data.time,
+        };
+        sessionCache.set(projectId, { session, scannedAt: now });
+        return session;
+    }
+    catch {
+        sessionCache.set(projectId, { session: undefined, scannedAt: now });
+        return undefined;
+    }
+}
+export async function getOpenCodeSessionForDirectory(cwd, env = process.env) {
+    if (!cwd)
+        return undefined;
+    const home = resolveOpenCodeHome(env);
+    const projects = await listProjectEntries(home);
+    const projectId = pickProjectId(projects, cwd);
+    if (!projectId)
+        return undefined;
+    return await readLatestSessionForProject(home, projectId);
+}