@codegrammer/co-od 0.1.0 → 0.1.2

package/dist/adapters/base.d.ts

@@ -7,6 +7,11 @@ export interface ExecuteOptions {
     workDir: string;
     onOutput?: (data: string) => void;
     signal?: AbortSignal;
+    /** Room context — enables hooks that report activity to the room */
+    roomId?: string;
+    runId?: string;
+    serverUrl?: string;
+    sessionToken?: string;
 }
 export interface ExecuteResult {
     exitCode: number;

package/dist/adapters/claude.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { generateHooksDir, cleanupHooksDir } from "../hooks-generator.js";
 function which(cmd) {
     const paths = (process.env.PATH || "").split(":");
     return paths.some((dir) => existsSync(`${dir}/${cmd}`));
@@ -11,10 +12,34 @@ export class ClaudeAdapter {
     }
     async execute(goal, options) {
         const { workDir, onOutput, signal } = options;
+        // Generate hooks config if room context is available
+        let hooksDir = null;
+        const args = ["-p", "--dangerously-skip-permissions"];
+        if (options.roomId && options.runId && options.serverUrl && options.sessionToken) {
+            try {
+                hooksDir = generateHooksDir({
+                    roomId: options.roomId,
+                    runId: options.runId,
+                    serverUrl: options.serverUrl,
+                    sessionToken: options.sessionToken,
+                });
+                // Add the hooks dir so Claude Code picks up the settings.local.json
+                args.push("--add-dir", hooksDir);
+                onOutput?.(`[co-od] Live activity reporting enabled for this run\n`);
+            }
+            catch {
+                // Non-fatal — run without hooks
+            }
+        }
+        args.push("--", goal);
         return new Promise((resolve, reject) => {
-            const child = spawn("claude", ["-p", "--dangerously-skip-permissions", "--", goal], {
+            const child = spawn("claude", 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 = "";
@@ -30,9 +55,13 @@ export class ClaudeAdapter {
                 onOutput?.(chunk);
             });
             child.on("exit", (code) => {
+                if (hooksDir)
+                    cleanupHooksDir(hooksDir);
                 resolve({ exitCode: code ?? 1, stdout, stderr });
             });
             child.on("error", (err) => {
+                if (hooksDir)
+                    cleanupHooksDir(hooksDir);
                 reject(err);
             });
             if (signal) {

package/dist/adapters/index.d.ts

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

package/dist/adapters/index.js

@@ -0,0 +1,17 @@
+import { ClaudeAdapter } from "./claude.js";
+import { CodexAdapter } from "./codex.js";
+import { OpenClawAdapter } from "./openclaw.js";
+const adapters = {
+    claude: () => new ClaudeAdapter(),
+    codex: () => new CodexAdapter(),
+    openclaw: () => new OpenClawAdapter(),
+    zeroclaw: () => new OpenClawAdapter(),
+};
+export function getAdapter(provider) {
+    const factory = adapters[provider.toLowerCase()];
+    if (factory)
+        return factory();
+    // Default to claude
+    return new ClaudeAdapter();
+}
+export const PROVIDER_LIST = "claude|codex|openclaw";

package/dist/adapters/openclaw.d.ts

@@ -0,0 +1,6 @@
+import type { AgentAdapter, ExecuteOptions, ExecuteResult } from "./base.js";
+export declare class OpenClawAdapter implements AgentAdapter {
+    name: string;
+    available(): Promise<boolean>;
+    execute(goal: string, options: ExecuteOptions): Promise<ExecuteResult>;
+}

package/dist/adapters/openclaw.js

@@ -0,0 +1,88 @@
+import { spawn } from "node:child_process";
+/**
+ * OpenClaw / ZeroClaw adapter.
+ *
+ * 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.
+ */
+const ZEROCLAW_BIN = process.env.ZEROCLAW_BIN || "zeroclaw";
+const OPENCLAW_BIN = process.env.OPENCLAW_BIN || "openclaw";
+async function findBinary() {
+    for (const [bin, variant] of [
+        [ZEROCLAW_BIN, "zeroclaw"],
+        [OPENCLAW_BIN, "openclaw"],
+    ]) {
+        try {
+            const child = spawn("sh", ["-lc", `command -v ${bin}`], { stdio: "pipe" });
+            const ok = await new Promise((resolve) => {
+                child.on("close", (code) => resolve(code === 0));
+                child.on("error", () => resolve(false));
+            });
+            if (ok)
+                return { bin, variant };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export class OpenClawAdapter {
+    name = "openclaw";
+    async available() {
+        const found = await findBinary();
+        return found !== null;
+    }
+    async execute(goal, options) {
+        const found = await findBinary();
+        if (!found) {
+            return {
+                exitCode: 127,
+                stdout: "",
+                stderr: "Neither zeroclaw nor openclaw CLI found on PATH. Install: brew install zeroclaw",
+            };
+        }
+        const { bin } = found;
+        // 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 },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            if (options.signal) {
+                options.signal.addEventListener("abort", () => {
+                    child.kill("SIGTERM");
+                });
+            }
+            let stdout = "";
+            let stderr = "";
+            child.stdout?.setEncoding("utf-8");
+            child.stderr?.setEncoding("utf-8");
+            child.stdout?.on("data", (chunk) => {
+                stdout += chunk;
+                options.onOutput?.(chunk);
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderr += chunk;
+                options.onOutput?.(chunk);
+            });
+            child.on("error", (err) => {
+                resolve({
+                    exitCode: 127,
+                    stdout,
+                    stderr: stderr || err.message,
+                });
+            });
+            child.on("close", (code) => {
+                resolve({
+                    exitCode: code ?? 1,
+                    stdout,
+                    stderr,
+                });
+            });
+        });
+    }
+}

package/dist/commands/daemon.js

@@ -1,6 +1,5 @@
+import { getAdapter, PROVIDER_LIST } from "../adapters/index.js";
 import * as api from "../api-client.js";
-import { ClaudeAdapter } from "../adapters/claude.js";
-import { CodexAdapter } from "../adapters/codex.js";
 function parseArgs(args) {
     const parsed = {
         provider: "claude",
@@ -47,22 +46,13 @@ function parseArgs(args) {
     }
     return parsed;
 }
-function getAdapter(provider) {
-    switch (provider) {
-        case "codex":
-            return new CodexAdapter();
-        case "claude":
-        default:
-            return new ClaudeAdapter();
-    }
-}
 function timestamp() {
     return new Date().toISOString().slice(11, 19);
 }
 export async function run(args) {
     const parsed = parseArgs(args);
     if (!parsed.roomId) {
-        console.error("Usage: co-od daemon <room-id> [--as <name>] [--role <role>] [--provider claude|codex] [--watch <events>] [--auto-execute] [--max-concurrent <n>]");
+        console.error(`Usage: co-od daemon <room-id> [--as <name>] [--role <role>] [--provider ${PROVIDER_LIST}] [--watch <events>] [--auto-execute] [--max-concurrent <n>]`);
         process.exit(1);
     }
     if (parsed.server) {

package/dist/commands/run.js

@@ -1,6 +1,5 @@
+import { getAdapter, PROVIDER_LIST } from "../adapters/index.js";
 import * as api from "../api-client.js";
-import { ClaudeAdapter } from "../adapters/claude.js";
-import { CodexAdapter } from "../adapters/codex.js";
 function parseArgs(args) {
     const parsed = {
         provider: "claude",
@@ -29,19 +28,10 @@ function parseArgs(args) {
     parsed.goal = positional.slice(1).join(" ");
     return parsed;
 }
-function getAdapter(provider) {
-    switch (provider) {
-        case "codex":
-            return new CodexAdapter();
-        case "claude":
-        default:
-            return new ClaudeAdapter();
-    }
-}
 export async function run(args) {
     const parsed = parseArgs(args);
     if (!parsed.roomId) {
-        console.error("Usage: co-od run <room-id> <goal> [--provider claude|codex] [--dir <path>] [--json]");
+        console.error(`Usage: co-od run <room-id> <goal> [--provider ${PROVIDER_LIST}] [--dir <path>] [--json]`);
         process.exit(1);
     }
     if (!parsed.goal) {

package/dist/commands/share.js

@@ -1,6 +1,5 @@
+import { getAdapter } from "../adapters/index.js";
 import * as api from "../api-client.js";
-import { ClaudeAdapter } from "../adapters/claude.js";
-import { CodexAdapter } from "../adapters/codex.js";
 function parseArgs(args) {
     const parsed = {
         provider: "claude",
@@ -19,15 +18,6 @@ function parseArgs(args) {
     }
     return parsed;
 }
-function getAdapter(provider) {
-    switch (provider) {
-        case "codex":
-            return new CodexAdapter();
-        case "claude":
-        default:
-            return new ClaudeAdapter();
-    }
-}
 function timestamp() {
     return new Date().toISOString().slice(11, 19);
 }

package/dist/hooks-generator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generates Claude Code hooks configuration that reports agent activity
+ * back to a co-ode room in real time.
+ *
+ * When `co-od daemon` or `co-od run` spawns Claude Code, it generates
+ * a temporary hooks config so every tool call, notification, and completion
+ * gets reported to the room's activity stream.
+ */
+export interface HooksConfig {
+    roomId: string;
+    runId: string;
+    serverUrl: string;
+    sessionToken: string;
+}
+/**
+ * Generate a .claude/settings.local.json with hooks that report to co-ode.
+ * Returns the path to the generated directory (use as --add-dir or cwd).
+ */
+export declare function generateHooksDir(config: HooksConfig): string;
+/**
+ * Clean up hooks dir after run completes.
+ */
+export declare function cleanupHooksDir(dir: string): void;

package/dist/hooks-generator.js

@@ -0,0 +1,169 @@
+/**
+ * Generates Claude Code hooks configuration that reports agent activity
+ * back to a co-ode room in real time.
+ *
+ * When `co-od daemon` or `co-od run` spawns Claude Code, it generates
+ * a temporary hooks config so every tool call, notification, and completion
+ * gets reported to the room's activity stream.
+ */
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+/**
+ * Generate a .claude/settings.local.json with hooks that report to co-ode.
+ * Returns the path to the generated directory (use as --add-dir or cwd).
+ */
+export function generateHooksDir(config) {
+    const dir = join(tmpdir(), `co-od-hooks-${config.runId}`);
+    const claudeDir = join(dir, ".claude");
+    mkdirSync(claudeDir, { recursive: true });
+    const reportScript = generateReportScript(config);
+    const reportScriptPath = join(dir, "co-od-report.mjs");
+    writeFileSync(reportScriptPath, reportScript, "utf-8");
+    // Claude Code hooks configuration
+    const hooks = {
+        hooks: {
+            PostToolUse: [
+                {
+                    matcher: "*",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node "${reportScriptPath}" post-tool-use "$TOOL_NAME" "$TOOL_INPUT" "$TOOL_OUTPUT"`,
+                        },
+                    ],
+                },
+            ],
+            Notification: [
+                {
+                    matcher: "*",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node "${reportScriptPath}" notification "$NOTIFICATION_TYPE" "$NOTIFICATION_MESSAGE"`,
+                        },
+                    ],
+                },
+            ],
+            Stop: [
+                {
+                    matcher: "*",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node "${reportScriptPath}" stop "$STOP_REASON"`,
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+    writeFileSync(join(claudeDir, "settings.local.json"), JSON.stringify(hooks, null, 2), "utf-8");
+    return dir;
+}
+/**
+ * Generate the report script that hooks call.
+ * This is a standalone Node.js script — no imports, no deps.
+ */
+function generateReportScript(config) {
+    return `#!/usr/bin/env node
+// Auto-generated by co-od CLI — reports Claude Code activity to a co-ode room
+const ROOM_ID = ${JSON.stringify(config.roomId)};
+const RUN_ID = ${JSON.stringify(config.runId)};
+const SERVER = ${JSON.stringify(config.serverUrl)};
+const TOKEN = ${JSON.stringify(config.sessionToken)};
+
+const [,, event, ...args] = process.argv;
+
+async function report() {
+  const payload = { roomId: ROOM_ID, runId: RUN_ID, event, args, ts: Date.now() };
+
+  // Map hook events to agent step updates
+  let stepKind = "observation";
+  let description = "";
+
+  if (event === "post-tool-use") {
+    const [toolName, toolInput, toolOutput] = args;
+    stepKind = "tool_call";
+    description = toolName || "tool_call";
+
+    // Report as a step on the run
+    try {
+      await fetch(SERVER + "/api/rooms/" + ROOM_ID + "/agent-runs/" + RUN_ID + "/steps", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "authorization": "Bearer " + TOKEN,
+        },
+        body: JSON.stringify({
+          kind: stepKind,
+          input: {
+            description: description,
+            payload: { toolInput: (toolInput || "").slice(0, 2000) },
+          },
+          output: {
+            success: true,
+            payload: { toolOutput: (toolOutput || "").slice(0, 4000) },
+          },
+        }),
+      });
+    } catch {
+      // Non-fatal — don't break Claude Code execution
+    }
+  }
+
+  if (event === "notification") {
+    const [type, message] = args;
+    try {
+      await fetch(SERVER + "/api/rooms/" + ROOM_ID + "/messages", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "authorization": "Bearer " + TOKEN,
+        },
+        body: JSON.stringify({
+          body_md: "[agent] " + (message || type || "notification"),
+          author_type: "agent",
+        }),
+      });
+    } catch {
+      // Non-fatal
+    }
+  }
+
+  if (event === "stop") {
+    const [reason] = args;
+    try {
+      await fetch(SERVER + "/api/rooms/" + ROOM_ID + "/agent-runs/" + RUN_ID + "/steps", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "authorization": "Bearer " + TOKEN,
+        },
+        body: JSON.stringify({
+          kind: "observation",
+          input: { description: "Agent stopped: " + (reason || "complete") },
+          output: { success: true, payload: { reason: reason || "complete" } },
+        }),
+      });
+    } catch {
+      // Non-fatal
+    }
+  }
+}
+
+report().catch(() => process.exit(0));
+`;
+}
+/**
+ * Clean up hooks dir after run completes.
+ */
+export function cleanupHooksDir(dir) {
+    try {
+        const { rmSync } = require("node:fs");
+        rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // Non-fatal
+    }
+}

package/dist/index.js

@@ -4,10 +4,10 @@ const VERSION = "0.1.0";
 const COMMANDS = {
     login: { desc: "Authenticate with co-ode", usage: "co-od login [--token <t>]" },
     rooms: { desc: "List your rooms", usage: "co-od rooms [--json]" },
-    run: { desc: "Execute a single task in a room", usage: "co-od run <room> <goal> [--provider claude|codex] [--dir <path>] [--json]" },
+    run: { desc: "Execute a single task in a room", usage: "co-od run <room> <goal> [--provider claude|codex|openclaw] [--dir <path>] [--json]" },
     join: { desc: "Join a room as an interactive agent", usage: "co-od join <room> [--invite-token <tok>] [--dir <path>]" },
     daemon: { desc: "Autonomous watch mode for a room", usage: "co-od daemon <room> [--as <name>] [--auto-execute] [--watch <events>]" },
-    share: { desc: "Generate a relay code for teammates", usage: "co-od share [--provider claude|codex]" },
+    share: { desc: "Generate a relay code for teammates", usage: "co-od share [--provider claude|codex|openclaw]" },
     connect: { desc: "Connect to a relay via code", usage: "co-od connect <code>" },
     status: { desc: "Show current login and running state", usage: "co-od status [--json]" },
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codegrammer/co-od",
-  "version": "0.1.0",
-  "description": "CLI for co-ode — run AI agents in shared rooms from the command line",
+  "version": "0.1.2",
+  "description": "CLI for co-ode \u2014 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"
   }
-}
+}