@codegrammer/co-od 0.1.1 → 0.1.3

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/commands/daemon.js

@@ -36,6 +36,9 @@ function parseArgs(args) {
         else if (args[i] === "--server" && args[i + 1]) {
             parsed.server = args[++i];
         }
+        else if (args[i] === "--handoff-to" && args[i + 1]) {
+            parsed.handoffTo = args[++i];
+        }
         else if (!args[i].startsWith("--")) {
             parsed.roomId = args[i];
         }
@@ -128,41 +131,66 @@ export async function run(args) {
                     activeRuns++;
                     console.error(`[${timestamp()}] Dispatching: ${goal.slice(0, 80)}`);
                     // Create a run on the server
+                    const sessionToken = api.getSessionToken();
+                    const baseUrl = api.getBaseUrl();
                     api
                         .post(`/api/rooms/${parsed.roomId}/agent-runs`, { goal, provider: parsed.provider, agentId, eventId: event._id })
                         .then(async ({ runId }) => {
                         const result = await adapter.execute(goal, {
                             workDir: parsed.dir,
                             onOutput: (data) => process.stderr.write(data),
+                            // Room context enables Claude Code hooks for live reporting
+                            roomId: parsed.roomId,
+                            runId,
+                            serverUrl: baseUrl,
+                            sessionToken: sessionToken || undefined,
                         });
-                        console.error(`\n[${timestamp()}] Run ${runId} ${result.exitCode === 0 ? "succeeded" : "failed"}`);
+                        const succeeded = result.exitCode === 0;
+                        console.error(`\n[${timestamp()}] Run ${runId} ${succeeded ? "succeeded" : "failed"}`);
                         // Report completion
                         try {
-                            await api.post(`/api/rooms/${parsed.roomId}/agent-runs/${runId}/handoff`, {
-                                ok: result.exitCode === 0,
-                                run: {
-                                    status: result.exitCode === 0 ? "succeeded" : "failed",
-                                    steps: [
-                                        {
-                                            kind: result.exitCode === 0 ? "observation" : "error",
-                                            input: { description: goal },
-                                            output: {
-                                                success: result.exitCode === 0,
-                                                payload: {
-                                                    stdout: result.stdout.slice(-4096),
-                                                    stderr: result.stderr.slice(-2048),
-                                                    exitCode: result.exitCode,
-                                                },
-                                            },
-                                            created_at: Date.now(),
-                                        },
-                                    ],
+                            await api.post(`/api/rooms/${parsed.roomId}/agent-runs/${runId}/steps`, {
+                                kind: succeeded ? "observation" : "error",
+                                input: { description: succeeded ? "Task completed" : "Task failed" },
+                                output: {
+                                    success: succeeded,
+                                    payload: {
+                                        stdout: result.stdout.slice(-4096),
+                                        stderr: result.stderr.slice(-2048),
+                                        exitCode: result.exitCode,
+                                    },
                                 },
                             });
                         }
                         catch {
                             console.error(`[${timestamp()}] Warning: failed to report completion`);
                         }
+                        // Agent-to-agent handoff
+                        const handoffTarget = parsed.handoffTo ||
+                            event.payload?.handoffTo ||
+                            null;
+                        if (succeeded && handoffTarget && parsed.roomId) {
+                            console.error(`[${timestamp()}] Handing off to "${handoffTarget}"...`);
+                            try {
+                                // Find target agent by name
+                                const agents = await api.get(`/api/rooms/${parsed.roomId}/agents`);
+                                const target = agents.agents?.find((a) => a.name.toLowerCase() === handoffTarget.toLowerCase() || a._id === handoffTarget);
+                                if (target) {
+                                    await api.post(`/api/rooms/${parsed.roomId}/agent-runs/${runId}/handoff`, {
+                                        targetAgentId: target._id,
+                                        context: `Completed: ${goal}. Output: ${result.stdout.slice(-500)}`,
+                                        goal: `Continue from "${agentName}": ${goal}`,
+                                    });
+                                    console.error(`[${timestamp()}] Handed off to "${target.name}" (${target._id})`);
+                                }
+                                else {
+                                    console.error(`[${timestamp()}] Handoff target "${handoffTarget}" not found in room`);
+                                }
+                            }
+                            catch (err) {
+                                console.error(`[${timestamp()}] Handoff failed: ${err}`);
+                            }
+                        }
                     })
                         .catch((err) => {
                         console.error(`[${timestamp()}] Run failed: ${err}`);

package/dist/commands/run.js

@@ -57,12 +57,16 @@ export async function run(args) {
     if (!parsed.json) {
         console.error(`[co-od] Run ${runId} created. Executing with ${adapter.name}...`);
     }
-    // Execute locally
+    // Execute locally — with room context for live hooks reporting
     const result = await adapter.execute(parsed.goal, {
         workDir: parsed.dir,
         onOutput: parsed.json
             ? undefined
             : (data) => process.stderr.write(data),
+        roomId: parsed.roomId,
+        runId,
+        serverUrl: api.getBaseUrl(),
+        sessionToken: api.getSessionToken() || undefined,
     });
     // Report completion
     if (!parsed.json) {

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/package.json

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