@codegrammer/co-od 0.1.2 → 0.1.4

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/init.d.ts

@@ -0,0 +1 @@
+export declare function run(args: string[]): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,168 @@
+import * as api from "../api-client.js";
+import { getAdapter } from "../adapters/index.js";
+import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+function parseArgs(args) {
+    const parsed = {
+        dir: process.cwd(),
+        provider: "claude",
+    };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--dir" && args[i + 1]) {
+            parsed.dir = args[++i];
+        }
+        else if (args[i] === "--name" && args[i + 1]) {
+            parsed.name = args[++i];
+        }
+        else if (args[i] === "--provider" && args[i + 1]) {
+            parsed.provider = args[++i];
+        }
+        else if (args[i] === "--server" && args[i + 1]) {
+            parsed.server = args[++i];
+        }
+        else if (!args[i].startsWith("--") && !parsed.name) {
+            parsed.name = args[i];
+        }
+    }
+    return parsed;
+}
+function timestamp() {
+    return new Date().toISOString().slice(11, 19);
+}
+export async function run(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.error(`Usage: co-od init [name] [--dir <path>] [--provider claude|codex|openclaw]
+
+Sets up a new co-ode project:
+  1. Creates a room on co-od.dev
+  2. Links it to your local project directory
+  3. Adds a default agent
+  4. Generates a .co-od config file
+  5. Ready to go — start giving tasks
+
+Examples:
+  co-od init                          # Uses current dir name as room name
+  co-od init "my-saas-app"            # Custom room name
+  co-od init --provider codex         # Use Codex as default agent
+  co-od init --dir ~/projects/app     # Different directory
+`);
+        process.exit(0);
+    }
+    const parsed = parseArgs(args);
+    if (parsed.server) {
+        process.env.CO_ODE_SERVER = parsed.server;
+    }
+    // Ensure logged in
+    const token = api.getSessionToken();
+    if (!token) {
+        console.error(`[${timestamp()}] Not logged in. Run: co-od login`);
+        process.exit(1);
+    }
+    const projectDir = parsed.dir;
+    const roomName = parsed.name || basename(projectDir);
+    console.error(`\n  co-od init\n`);
+    console.error(`  project:  ${projectDir}`);
+    console.error(`  room:     ${roomName}`);
+    console.error(`  provider: ${parsed.provider}\n`);
+    // Step 1: Check provider is available
+    console.error(`  [1/5] Checking ${parsed.provider} CLI...`);
+    const adapter = getAdapter(parsed.provider);
+    const available = await adapter.available();
+    if (!available) {
+        console.error(`        ✗ ${adapter.name} not found on PATH`);
+        console.error(`        Install it first, then run co-od init again.`);
+        process.exit(1);
+    }
+    console.error(`        ✓ ${adapter.name} available`);
+    // Step 2: Create room
+    console.error(`  [2/5] Creating room "${roomName}"...`);
+    let roomId;
+    try {
+        const res = await api.post("/api/rooms", { name: roomName });
+        roomId = res.roomId || res.room?._id || "";
+        if (!roomId)
+            throw new Error("No room ID returned");
+        console.error(`        ✓ Room created: ${roomId.slice(0, 12)}...`);
+    }
+    catch (err) {
+        console.error(`        ✗ Failed to create room: ${err}`);
+        process.exit(1);
+    }
+    // Step 3: Add default agent
+    console.error(`  [3/5] Adding default agent...`);
+    let agentId;
+    try {
+        const agentName = parsed.provider === "codex" ? "Codex Builder"
+            : parsed.provider === "openclaw" ? "OpenClaw Agent"
+                : "Claude Builder";
+        const res = await api.post(`/api/rooms/${roomId}/agents`, {
+            name: agentName,
+            type: "builder",
+            executionMode: parsed.provider === "codex" ? "local_codex" : "local_claude_code",
+            provider: parsed.provider === "codex" ? "openai"
+                : parsed.provider === "openclaw" ? "openclaw"
+                    : "anthropic",
+            permissions: {
+                "fs.read": true,
+                "fs.write": true,
+                "fs.applyPatch": true,
+                "exec.run": true,
+                "net.egress": false,
+                "ports.expose": false,
+                "secrets.read": false,
+            },
+        });
+        agentId = res.agentId || "";
+        console.error(`        ✓ Agent "${agentName}" added`);
+    }
+    catch (err) {
+        console.error(`        ✗ Failed to add agent: ${err}`);
+        agentId = "";
+    }
+    // Step 4: Save config
+    console.error(`  [4/5] Saving config...`);
+    const config = {
+        roomId,
+        roomName,
+        projectDir,
+        provider: parsed.provider,
+        agentId,
+        server: api.getBaseUrl(),
+        createdAt: new Date().toISOString(),
+    };
+    // Save to project dir
+    const configPath = join(projectDir, ".co-od.json");
+    try {
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        console.error(`        ✓ ${configPath}`);
+    }
+    catch {
+        console.error(`        ✗ Could not write ${configPath}`);
+    }
+    // Also save room mapping to global config
+    const globalConfigDir = join(homedir(), ".co-od");
+    const roomsMapPath = join(globalConfigDir, "rooms.json");
+    try {
+        mkdirSync(globalConfigDir, { recursive: true });
+        let rooms = {};
+        if (existsSync(roomsMapPath)) {
+            rooms = JSON.parse(require("node:fs").readFileSync(roomsMapPath, "utf-8"));
+        }
+        rooms[roomId] = { roomId, projectDir, name: roomName };
+        writeFileSync(roomsMapPath, JSON.stringify(rooms, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // Non-fatal
+    }
+    // Step 5: Done
+    console.error(`  [5/5] Ready!\n`);
+    console.error(`  Your room is live. Next steps:\n`);
+    console.error(`    co-od run ${roomId.slice(0, 12)} "describe your task"   # run a single task`);
+    console.error(`    co-od daemon ${roomId.slice(0, 12)} --auto-execute       # autonomous mode`);
+    console.error(`    co-od share                                    # invite teammates\n`);
+    console.error(`  Or open in browser:`);
+    console.error(`    ${api.getBaseUrl()}/rooms/${roomId}\n`);
+    // Output JSON for scripting
+    console.log(JSON.stringify(config, null, 2));
+}

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/index.js

@@ -2,11 +2,12 @@
 "use strict";
 const VERSION = "0.1.0";
 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>]" },
     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|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>]" },
+    daemon: { desc: "Autonomous watch mode for a room", usage: "co-od daemon <room> [--as <name>] [--auto-execute] [--handoff-to <agent>]" },
     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]" },
@@ -58,6 +59,11 @@ async function main() {
     }
     // Route to command
     switch (command) {
+        case "init": {
+            const { run } = await import("./commands/init.js");
+            await run(commandArgs);
+            break;
+        }
         case "login": {
             const { run } = await import("./commands/login.js");
             await run(commandArgs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codegrammer/co-od",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "CLI for co-ode \u2014 run AI agents in shared rooms from the command line",
   "type": "module",
   "bin": {