@codegrammer/co-od 0.1.6 → 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/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.6",
-  "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"
   }
-}
+}