@codegrammer/co-od 0.1.5 → 0.1.7

package/dist/adapters/codex.js

@@ -1,9 +1,73 @@
 import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
 import { existsSync } from "node:fs";
 function which(cmd) {
     const paths = (process.env.PATH || "").split(":");
     return paths.some((dir) => existsSync(`${dir}/${cmd}`));
 }
+/**
+ * Parse a Codex JSONL event and report it as an agent step to co-ode.
+ * Codex events: thread.started, turn.started, turn.completed,
+ * item.started, item.completed (with item types: command_execution,
+ * file_change, mcp_tool_call, agent_message, reasoning, plan_update)
+ */
+async function reportCodexEvent(event, config) {
+    const type = event.type;
+    const item = event.item;
+    // Only report completed items as steps
+    if (type !== "item.completed" || !item)
+        return;
+    const itemType = item.type;
+    let stepKind;
+    let description;
+    let payload = {};
+    switch (itemType) {
+        case "command_execution":
+            stepKind = "tool_call";
+            description = item.command || "exec";
+            payload = { command: item.command, exitCode: item.exit_code };
+            break;
+        case "file_change":
+            stepKind = "tool_call";
+            description = `write ${item.path || "file"}`;
+            payload = { path: item.path };
+            break;
+        case "mcp_tool_call":
+            stepKind = "tool_call";
+            description = item.tool_name || "mcp_tool";
+            payload = { tool: item.tool_name };
+            break;
+        case "agent_message":
+            stepKind = "observation";
+            description = (item.text || "").slice(0, 200);
+            payload = { text: (item.text || "").slice(0, 4000) };
+            break;
+        case "plan_update":
+            stepKind = "plan";
+            description = "plan updated";
+            payload = { plan: item.plan };
+            break;
+        default:
+            return; // Skip reasoning, web_search, etc.
+    }
+    try {
+        await fetch(`${config.serverUrl}/api/rooms/${config.roomId}/agent-runs/${config.runId}/steps`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${config.sessionToken}`,
+            },
+            body: JSON.stringify({
+                kind: stepKind,
+                input: { description, payload },
+                output: { success: true, payload },
+            }),
+        });
+    }
+    catch {
+        // Non-fatal — don't break Codex execution
+    }
+}
 export class CodexAdapter {
     name = "codex";
     async available() {
@@ -11,25 +75,82 @@ export class CodexAdapter {
     }
     async execute(goal, options) {
         const { workDir, onOutput, signal } = options;
+        const hasRoomContext = Boolean(options.roomId && options.runId && options.serverUrl && options.sessionToken);
+        // Use --json for JSONL event streaming when we have room context
+        const args = ["exec", "--full-auto"];
+        if (hasRoomContext)
+            args.push("--json");
+        args.push("--", goal);
         return new Promise((resolve, reject) => {
-            const child = spawn("codex", ["exec", "--full-auto", "--", goal], {
+            const child = spawn("codex", args, {
                 cwd: workDir,
-                env: { ...process.env },
+                env: {
+                    ...process.env,
+                    CO_OD_ROOM_ID: options.roomId || "",
+                    CO_OD_RUN_ID: options.runId || "",
+                },
                 stdio: ["pipe", "pipe", "pipe"],
             });
             let stdout = "";
             let stderr = "";
+            let lastAgentMessage = "";
             child.stdout?.setEncoding("utf-8");
             child.stderr?.setEncoding("utf-8");
-            child.stdout?.on("data", (chunk) => {
-                stdout += chunk;
-                onOutput?.(chunk);
-            });
+            if (hasRoomContext) {
+                // Parse JSONL events from stdout for real-time reporting
+                const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+                rl.on("line", (line) => {
+                    stdout += line + "\n";
+                    try {
+                        const event = JSON.parse(line);
+                        // Extract final agent message for display
+                        if (event.type === "item.completed" &&
+                            event.item?.type === "agent_message") {
+                            lastAgentMessage =
+                                event.item.text || "";
+                        }
+                        // Report progress to co-ode
+                        const config = {
+                            roomId: options.roomId,
+                            runId: options.runId,
+                            serverUrl: options.serverUrl,
+                            sessionToken: options.sessionToken,
+                        };
+                        void reportCodexEvent(event, config);
+                        // Feed human-readable output to onOutput
+                        const itemType = event.item?.type;
+                        if (event.type === "item.completed" && itemType === "command_execution") {
+                            onOutput?.(`$ ${event.item.command}\n`);
+                        }
+                        else if (event.type === "item.completed" && itemType === "file_change") {
+                            onOutput?.(`[write] ${event.item.path}\n`);
+                        }
+                        else if (event.type === "item.completed" && itemType === "agent_message") {
+                            onOutput?.(`${(event.item.text || "").slice(0, 500)}\n`);
+                        }
+                    }
+                    catch {
+                        // Not valid JSON — pass through as raw output
+                        onOutput?.(line + "\n");
+                    }
+                });
+            }
+            else {
+                // No room context — raw output mode (original behavior)
+                child.stdout?.on("data", (chunk) => {
+                    stdout += chunk;
+                    onOutput?.(chunk);
+                });
+            }
             child.stderr?.on("data", (chunk) => {
                 stderr += chunk;
                 onOutput?.(chunk);
             });
             child.on("exit", (code) => {
+                // If we parsed JSONL, include the last agent message in stdout for the caller
+                if (hasRoomContext && lastAgentMessage) {
+                    stdout += `\n--- Agent Response ---\n${lastAgentMessage}\n`;
+                }
                 resolve({ exitCode: code ?? 1, stdout, stderr });
             });
             child.on("error", (err) => {

package/dist/adapters/index.d.ts

@@ -1,3 +1,3 @@
 import type { AgentAdapter } from "./base.js";
 export declare function getAdapter(provider: string): AgentAdapter;
-export declare const PROVIDER_LIST = "claude|codex|openclaw";
+export declare const PROVIDER_LIST = "claude|codex|openclaw|zeroclaw";

package/dist/adapters/index.js

@@ -14,4 +14,4 @@ export function getAdapter(provider) {
     // Default to claude
     return new ClaudeAdapter();
 }
-export const PROVIDER_LIST = "claude|codex|openclaw";
+export const PROVIDER_LIST = "claude|codex|openclaw|zeroclaw";

package/dist/adapters/openclaw.js

@@ -4,7 +4,7 @@ import { spawn } from "node:child_process";
  *
  * Supports both the legacy `openclaw` CLI and the newer `zeroclaw` CLI.
  * Sends tasks via `zeroclaw agent -m <goal>` (non-interactive single-shot mode).
- * Falls back to the HTTP gateway if running as a daemon.
+ * Reports tool calls and file changes as agent steps when room context is available.
  */
 const ZEROCLAW_BIN = process.env.ZEROCLAW_BIN || "zeroclaw";
 const OPENCLAW_BIN = process.env.OPENCLAW_BIN || "openclaw";
@@ -28,6 +28,62 @@ async function findBinary() {
     }
     return null;
 }
+/**
+ * Report a step to the co-ode room.
+ */
+async function reportStep(config, kind, description, payload = {}) {
+    try {
+        await fetch(`${config.serverUrl}/api/rooms/${config.roomId}/agent-runs/${config.runId}/steps`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${config.sessionToken}`,
+            },
+            body: JSON.stringify({
+                kind,
+                input: { description, payload },
+                output: { success: true, payload },
+            }),
+        });
+    }
+    catch {
+        // Non-fatal
+    }
+}
+/**
+ * Parse openclaw/zeroclaw output lines for tool calls and file changes.
+ * ZeroClaw outputs structured markers like:
+ *   [TOOL] tool_name: description
+ *   [FILE] path/to/file
+ *   [EXEC] command
+ *   [DONE] summary
+ */
+function parseOutputLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[TOOL]")) {
+        return { kind: "tool_call", description: trimmed.slice(6).trim(), payload: {} };
+    }
+    if (trimmed.startsWith("[FILE]")) {
+        const path = trimmed.slice(6).trim();
+        return { kind: "tool_call", description: `write ${path}`, payload: { path } };
+    }
+    if (trimmed.startsWith("[EXEC]")) {
+        const cmd = trimmed.slice(6).trim();
+        return { kind: "tool_call", description: cmd, payload: { command: cmd } };
+    }
+    if (trimmed.startsWith("[DONE]")) {
+        return { kind: "observation", description: trimmed.slice(6).trim(), payload: {} };
+    }
+    // Also detect common patterns from unstructured output
+    if (trimmed.match(/^(reading|writing|creating|editing|modifying)\s/i)) {
+        return { kind: "tool_call", description: trimmed.slice(0, 100), payload: {} };
+    }
+    if (trimmed.match(/^\$\s+/)) {
+        const cmd = trimmed.slice(2).trim();
+        return { kind: "tool_call", description: cmd, payload: { command: cmd } };
+    }
+    return null;
+}
 export class OpenClawAdapter {
     name = "openclaw";
     async available() {
@@ -44,26 +100,52 @@ export class OpenClawAdapter {
             };
         }
         const { bin } = found;
+        const hasRoomContext = Boolean(options.roomId && options.runId && options.serverUrl && options.sessionToken);
+        const reportConfig = hasRoomContext
+            ? {
+                roomId: options.roomId,
+                runId: options.runId,
+                serverUrl: options.serverUrl,
+                sessionToken: options.sessionToken,
+            }
+            : null;
         // zeroclaw agent -m "goal" — single-shot non-interactive mode
         const args = ["agent", "-m", goal];
         return new Promise((resolve) => {
             const child = spawn(bin, args, {
                 cwd: options.workDir,
-                env: { ...process.env },
+                env: {
+                    ...process.env,
+                    CO_OD_ROOM_ID: options.roomId || "",
+                    CO_OD_RUN_ID: options.runId || "",
+                },
                 stdio: ["pipe", "pipe", "pipe"],
             });
             if (options.signal) {
                 options.signal.addEventListener("abort", () => {
                     child.kill("SIGTERM");
-                });
+                }, { once: true });
             }
             let stdout = "";
             let stderr = "";
+            let lineBuffer = "";
             child.stdout?.setEncoding("utf-8");
             child.stderr?.setEncoding("utf-8");
             child.stdout?.on("data", (chunk) => {
                 stdout += chunk;
                 options.onOutput?.(chunk);
+                // Parse lines for step reporting
+                if (reportConfig) {
+                    lineBuffer += chunk;
+                    const lines = lineBuffer.split("\n");
+                    lineBuffer = lines.pop() || "";
+                    for (const line of lines) {
+                        const parsed = parseOutputLine(line);
+                        if (parsed) {
+                            void reportStep(reportConfig, parsed.kind, parsed.description, parsed.payload);
+                        }
+                    }
+                }
             });
             child.stderr?.on("data", (chunk) => {
                 stderr += chunk;
@@ -77,6 +159,13 @@ export class OpenClawAdapter {
                 });
             });
             child.on("close", (code) => {
+                // Flush remaining line buffer
+                if (reportConfig && lineBuffer.trim()) {
+                    const parsed = parseOutputLine(lineBuffer);
+                    if (parsed) {
+                        void reportStep(reportConfig, parsed.kind, parsed.description, parsed.payload);
+                    }
+                }
                 resolve({
                     exitCode: code ?? 1,
                     stdout,

package/dist/api-client.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 const CONFIG_DIR = join(homedir(), ".co-ode");
 const SESSION_FILE = join(CONFIG_DIR, "session.json");
 function getBaseUrl() {
-    return (process.env.CO_ODE_SERVER || "https://co-ode.vercel.app");
+    return (process.env.CO_ODE_SERVER || "https://co-od.dev");
 }
 function getSessionToken() {
     try {

package/dist/commands/join.js

@@ -26,7 +26,7 @@ export async function run(args) {
     }
     const serverUrl = parsed.server ||
         process.env.CO_ODE_SERVER ||
-        "https://co-ode.vercel.app";
+        "https://co-od.dev";
     console.error(`[co-od] Joining room ${parsed.roomId}...`);
     console.error(`[co-od] Server: ${serverUrl}`);
     console.error(`[co-od] Working directory: ${parsed.dir}`);

package/dist/commands/login.js

@@ -76,7 +76,7 @@ export async function run(args) {
     const parsed = parseArgs(args);
     const serverUrl = parsed.server ||
         process.env.CO_ODE_SERVER ||
-        "https://co-ode.vercel.app";
+        "https://co-od.dev";
     // --token flag: headless/CI mode
     if (parsed.token) {
         saveSession(parsed.token);

package/dist/commands/start.d.ts

@@ -8,4 +8,4 @@
  * 5. Open browser to room
  * 6. Done — user types a task in the browser
  */
-export declare function run(_args: string[]): Promise<void>;
+export declare function run(args: string[]): Promise<void>;

package/dist/commands/start.js

@@ -129,9 +129,37 @@ async function openBrowser(url) {
         log(`Open in browser: ${url}`);
     }
 }
-export async function run(_args) {
+async function isBridgeRunning() {
+    try {
+        const res = await fetch("http://127.0.0.1:4786/health", { signal: AbortSignal.timeout(1500) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function run(args) {
     const dir = process.cwd();
     const projectName = basename(dir);
+    const existing = findExistingConfig(dir);
+    const bridgeUp = await isBridgeRunning();
+    const hasToken = !!api.getSessionToken();
+    // ── FAST PATH: everything's already set up ──
+    // If config exists + bridge running + logged in → just show status, don't open browser
+    if (existing && bridgeUp && hasToken && !args.includes("--open")) {
+        const url = `${api.getBaseUrl()}/rooms/${existing.roomId}`;
+        console.error(`  co-od · ${existing.roomName}\n`);
+        console.error(`  room:    ${url}`);
+        console.error(`  bridge:  running (port 4786)`);
+        console.error(`  project: ${dir}\n`);
+        console.error(`  Everything is running. Commands:\n`);
+        console.error(`    co-od run ${existing.roomId.slice(0, 12)} "your task"    # single task`);
+        console.error(`    co-od daemon ${existing.roomId.slice(0, 12)} --auto-execute  # autonomous`);
+        console.error(`    co-od share                                   # invite teammate`);
+        console.error(`    co-od --open                                  # open browser\n`);
+        return;
+    }
+    // ── SETUP PATH: first time or something needs fixing ──
     console.error(`
   ┌─────────────────────────────┐
   │         co-od               │
@@ -140,13 +168,18 @@ export async function run(_args) {
   └─────────────────────────────┘
 `);
     // Step 1: Login
-    log("[1/5] Checking authentication...");
-    const loggedIn = await ensureLoggedIn();
-    if (!loggedIn) {
-        log("✗ Login required. Run: co-od login");
-        process.exit(1);
+    if (!hasToken) {
+        log("[1/5] Checking authentication...");
+        const loggedIn = await ensureLoggedIn();
+        if (!loggedIn) {
+            log("✗ Login required. Run: co-od login");
+            process.exit(1);
+        }
+        log("✓ logged in\n");
+    }
+    else {
+        log("[1/5] ✓ logged in");
     }
-    log("✓ logged in\n");
     // Step 2: Detect environment
     log("[2/5] Detecting environment...");
     const provider = detectProvider();
@@ -162,7 +195,6 @@ export async function run(_args) {
     log(`✓ project: ${dir}\n`);
     // Step 3: Find or create room
     log("[3/5] Setting up room...");
-    const existing = findExistingConfig(dir);
     let roomId;
     let roomName;
     if (existing) {
@@ -171,7 +203,6 @@ export async function run(_args) {
         log(`✓ found existing room: ${roomName}`);
     }
     else {
-        // Create new room
         roomName = projectName;
         try {
             const res = await api.post("/api/rooms", { name: roomName });
@@ -222,9 +253,14 @@ export async function run(_args) {
         }
     }
     console.error("");
-    // Step 4: Start bridge
-    log("[4/5] Starting local bridge...");
-    startBridgeBackground();
+    // Step 4: Start bridge (only if not already running)
+    if (bridgeUp) {
+        log("[4/5] ✓ local bridge already running");
+    }
+    else {
+        log("[4/5] Starting local bridge...");
+        startBridgeBackground();
+    }
     console.error("");
     // Step 5: Open browser
     log("[5/5] Opening workspace...\n");

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-declare const VERSION = "0.1.0";
+declare const VERSION = "0.1.6";
 declare const COMMANDS: Record<string, {
     desc: string;
     usage: string;

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 "use strict";
-const VERSION = "0.1.0";
+const VERSION = "0.1.6";
 const COMMANDS = {
     init: { desc: "Set up a new co-ode project", usage: "co-od init [name] [--dir <path>] [--provider claude|codex|openclaw]" },
     login: { desc: "Authenticate with co-ode", usage: "co-od login [--token <t>]" },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codegrammer/co-od",
-  "version": "0.1.5",
-  "description": "CLI for co-ode \u2014 run AI agents in shared rooms from the command line",
+  "version": "0.1.7",
+  "description": "CLI for co-ode — run AI agents in shared rooms from the command line",
   "type": "module",
   "bin": {
     "co-ode": "./dist/index.js",
@@ -49,4 +49,4 @@
     "@types/ws": "^8.5.13",
     "typescript": "^5.6.2"
   }
-}
+}