@codegrammer/co-od 0.1.0

package/dist/commands/status.js

@@ -0,0 +1,38 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getSession, getBaseUrl } from "../api-client.js";
+const CONFIG_DIR = join(homedir(), ".co-ode");
+const SESSION_FILE = join(CONFIG_DIR, "session.json");
+function parseArgs(args) {
+    return { json: args.includes("--json") };
+}
+function getStatusInfo() {
+    const session = getSession();
+    const server = getBaseUrl();
+    return {
+        loggedIn: session !== null,
+        user: session?.user || null,
+        sessionFile: SESSION_FILE,
+        sessionExpires: session
+            ? new Date(session.expiresAt).toLocaleString()
+            : null,
+        server,
+    };
+}
+export async function run(args) {
+    const parsed = parseArgs(args);
+    const info = getStatusInfo();
+    if (parsed.json) {
+        console.log(JSON.stringify(info, null, 2));
+        return;
+    }
+    console.log(`co-od status`);
+    console.log(`${"=".repeat(40)}`);
+    console.log(`Logged in:       ${info.loggedIn ? "yes" : "no"}`);
+    if (info.loggedIn) {
+        console.log(`User:            ${info.user || "(unknown)"}`);
+        console.log(`Session expires: ${info.sessionExpires}`);
+    }
+    console.log(`Session file:    ${info.sessionFile}`);
+    console.log(`Server:          ${info.server}`);
+}

package/dist/connect.d.ts

@@ -0,0 +1,10 @@
+interface ConnectOptions {
+    terminalWsUrl: string;
+    realtimeToken: string;
+    roomId: string;
+    workDir: string;
+    serverUrl: string;
+    sessionToken: string;
+}
+export declare function connectToRoom(options: ConnectOptions): Promise<void>;
+export {};

package/dist/connect.js

@@ -0,0 +1,145 @@
+import WebSocket from "ws";
+import { createLocalPty } from "./pty.js";
+import { runPrompt, isRunning } from "./promptRunner.js";
+export async function connectToRoom(options) {
+    const { terminalWsUrl, realtimeToken, roomId, workDir, serverUrl, sessionToken } = options;
+    // Build the PTY provider WebSocket URL
+    // terminalWsUrl is like ws://host:port — append the pty-provider path
+    const baseUrl = terminalWsUrl.replace(/\/$/, "");
+    const wsUrl = `${baseUrl}/pty-provider?roomId=${encodeURIComponent(roomId)}&token=${encodeURIComponent(realtimeToken)}`;
+    console.error(`[co-ode] Connecting to terminal gateway...`);
+    const ws = new WebSocket(wsUrl);
+    const pty = createLocalPty(workDir);
+    let reconnecting = false;
+    let tokenRefreshTimer = null;
+    // Wire PTY output → WebSocket
+    pty.onData((data) => {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: "output", data }));
+        }
+    });
+    ws.on("open", () => {
+        console.error(`[co-ode] Connected! Terminal is now shared with the room.`);
+        console.error(`[co-ode] Room members can see your terminal and send Claude Code prompts.`);
+        console.error(`[co-ode] Press Ctrl+C to disconnect.\n`);
+        // Send initial connection info
+        ws.send(JSON.stringify({
+            type: "connected",
+            cwd: workDir,
+            data: `[co-ode] Remote CLI connected from ${workDir}\r\n\r\n`,
+        }));
+        // Schedule token refresh (45 minutes — tokens last 1 hour)
+        tokenRefreshTimer = setTimeout(() => refreshToken(options), 45 * 60 * 1000);
+    });
+    ws.on("message", (raw) => {
+        try {
+            const msg = JSON.parse(raw.toString());
+            switch (msg.type) {
+                case "input":
+                    // Browser client typed something → forward to local PTY
+                    if (msg.data) {
+                        pty.write(msg.data);
+                    }
+                    break;
+                case "resize":
+                    if (msg.cols && msg.rows) {
+                        pty.resize(msg.cols, msg.rows);
+                    }
+                    break;
+                case "ping":
+                    ws.send(JSON.stringify({ type: "pong" }));
+                    break;
+                case "prompt.dispatch":
+                    // Room member sent a Claude Code prompt
+                    if (isRunning()) {
+                        ws.send(JSON.stringify({ type: "prompt.busy", runId: msg.runId }));
+                        break;
+                    }
+                    ws.send(JSON.stringify({ type: "prompt.ack", runId: msg.runId }));
+                    void runPrompt({
+                        runId: msg.runId,
+                        goal: msg.goal,
+                        token: msg.token,
+                        completeUrl: msg.completeUrl,
+                        heartbeatUrl: msg.heartbeatUrl,
+                        heartbeatIntervalMs: msg.heartbeatIntervalMs || 10000,
+                    }, {
+                        workDir,
+                        roomId,
+                        serverUrl,
+                        onOutput: (data) => {
+                            if (ws.readyState === WebSocket.OPEN) {
+                                ws.send(JSON.stringify({ type: "output", data }));
+                            }
+                        },
+                    }).then(() => {
+                        ws.send(JSON.stringify({
+                            type: "prompt.complete",
+                            runId: msg.runId,
+                            status: "done",
+                        }));
+                    });
+                    break;
+            }
+        }
+        catch {
+            // Ignore malformed messages
+        }
+    });
+    ws.on("close", () => {
+        if (!reconnecting) {
+            console.error(`\n[co-ode] Disconnected from room.`);
+            cleanup();
+            process.exit(0);
+        }
+    });
+    ws.on("error", (err) => {
+        console.error(`[co-ode] WebSocket error: ${err.message}`);
+    });
+    // Handle Ctrl+C gracefully
+    const cleanup = () => {
+        if (tokenRefreshTimer)
+            clearTimeout(tokenRefreshTimer);
+        pty.kill();
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.close();
+        }
+    };
+    process.on("SIGINT", () => {
+        console.error(`\n[co-ode] Disconnecting...`);
+        cleanup();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+    });
+    // Keep the process alive
+    await new Promise(() => {
+        // Never resolves — process stays alive until SIGINT/SIGTERM or ws close
+    });
+}
+async function refreshToken(options) {
+    try {
+        console.error(`[co-ode] Refreshing realtime token...`);
+        const res = await fetch(`${options.serverUrl}/api/rooms/${options.roomId}/realtime/session`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${options.sessionToken}`,
+            },
+            body: JSON.stringify({ ttlSeconds: 3600 }),
+        });
+        if (res.ok) {
+            const data = (await res.json());
+            options.realtimeToken = data.token;
+            console.error(`[co-ode] Token refreshed`);
+        }
+        else {
+            console.error(`[co-ode] Warning: token refresh failed (${res.status})`);
+        }
+    }
+    catch (err) {
+        console.error(`[co-ode] Warning: token refresh error: ${err}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+declare const VERSION = "0.1.0";
+declare const COMMANDS: Record<string, {
+    desc: string;
+    usage: string;
+}>;
+declare function printHelp(): void;
+declare function getArg(args: string[], flag: string): string | undefined;
+declare function main(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+"use strict";
+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]" },
+    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]" },
+    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]" },
+};
+function printHelp() {
+    console.error(`co-od v${VERSION} — CLI for co-ode rooms\n`);
+    console.error("Usage: co-od <command> [options]\n");
+    console.error("Commands:");
+    const maxLen = Math.max(...Object.keys(COMMANDS).map((k) => k.length));
+    for (const [name, { desc }] of Object.entries(COMMANDS)) {
+        console.error(`  ${name.padEnd(maxLen + 2)}${desc}`);
+    }
+    console.error(`\nRun 'co-od <command> --help' for command-specific usage.`);
+    console.error(`\nOptions:`);
+    console.error(`  --help, -h       Show this help message`);
+    console.error(`  --version, -v    Show version`);
+}
+function getArg(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
+async function main() {
+    const args = process.argv.slice(2);
+    // Global flags
+    if (args.includes("--version") || args.includes("-v")) {
+        console.log(VERSION);
+        process.exit(0);
+    }
+    if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+        printHelp();
+        process.exit(0);
+    }
+    const command = args[0];
+    const commandArgs = args.slice(1);
+    // Show command-specific help
+    if (commandArgs.includes("--help") || commandArgs.includes("-h")) {
+        const cmd = COMMANDS[command];
+        if (cmd) {
+            console.error(`${cmd.desc}\n`);
+            console.error(`Usage: ${cmd.usage}`);
+        }
+        else {
+            console.error(`Unknown command: ${command}`);
+            printHelp();
+        }
+        process.exit(0);
+    }
+    // Route to command
+    switch (command) {
+        case "login": {
+            const { run } = await import("./commands/login.js");
+            await run(commandArgs);
+            break;
+        }
+        case "rooms": {
+            const { run } = await import("./commands/rooms.js");
+            await run(commandArgs);
+            break;
+        }
+        case "run": {
+            const { run } = await import("./commands/run.js");
+            await run(commandArgs);
+            break;
+        }
+        case "join": {
+            const { run } = await import("./commands/join.js");
+            await run(commandArgs);
+            break;
+        }
+        case "daemon": {
+            const { run } = await import("./commands/daemon.js");
+            await run(commandArgs);
+            break;
+        }
+        case "share": {
+            const { run } = await import("./commands/share.js");
+            await run(commandArgs);
+            break;
+        }
+        case "connect": {
+            const { run } = await import("./commands/connect.js");
+            await run(commandArgs);
+            break;
+        }
+        case "status": {
+            const { run } = await import("./commands/status.js");
+            await run(commandArgs);
+            break;
+        }
+        default:
+            console.error(`Unknown command: ${command}\n`);
+            printHelp();
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(`[co-od] Fatal: ${err.message || err}`);
+    process.exit(1);
+});

package/dist/promptRunner.d.ts

@@ -0,0 +1,17 @@
+interface PromptDispatch {
+    runId: string;
+    goal: string;
+    token: string;
+    completeUrl: string;
+    heartbeatUrl: string;
+    heartbeatIntervalMs: number;
+}
+interface PromptRunnerOptions {
+    workDir: string;
+    onOutput: (data: string) => void;
+    roomId?: string;
+    serverUrl?: string;
+}
+export declare function isRunning(): boolean;
+export declare function runPrompt(dispatch: PromptDispatch, options: PromptRunnerOptions): Promise<void>;
+export {};

package/dist/promptRunner.js

@@ -0,0 +1,172 @@
+import { spawn } from "node:child_process";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+let currentRun = null;
+export function isRunning() {
+    return currentRun !== null;
+}
+export async function runPrompt(dispatch, options) {
+    if (currentRun) {
+        throw new Error("A prompt is already running");
+    }
+    const { runId, goal, token, completeUrl, heartbeatUrl, heartbeatIntervalMs } = dispatch;
+    const { workDir, onOutput } = options;
+    onOutput(`\r\n[co-ode] Received prompt: ${goal}\r\n`);
+    onOutput(`[co-ode] Running Claude Code...\r\n\r\n`);
+    // Start heartbeat loop
+    const heartbeatTimer = setInterval(async () => {
+        try {
+            const res = await fetch(heartbeatUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${token}`,
+                    "x-local-bridge-token": token,
+                },
+                body: JSON.stringify({ runId }),
+            });
+            if (res.ok) {
+                const body = (await res.json());
+                if (body.continue === false) {
+                    onOutput(`\r\n[co-ode] Server requested cancellation\r\n`);
+                    cancelCurrentRun();
+                }
+            }
+        }
+        catch {
+            // Heartbeat failure is non-fatal
+        }
+    }, heartbeatIntervalMs || 10000);
+    // Write MCP config so Claude Code discovers co-od tools natively
+    const apiOrigin = completeUrl ? new URL(completeUrl).origin : (options.serverUrl || "");
+    const mcpConfigDir = join(tmpdir(), `co-ode-mcp-${runId}`);
+    const mcpConfigPath = join(mcpConfigDir, "mcp.json");
+    try {
+        mkdirSync(mcpConfigDir, { recursive: true });
+        writeFileSync(mcpConfigPath, JSON.stringify({
+            mcpServers: {
+                "co-ode": {
+                    command: "npx",
+                    args: ["@co-ode/mcp-server"],
+                    env: {
+                        CO_ODE_API_URL: apiOrigin,
+                        CO_ODE_ROOM_ID: options.roomId || "",
+                        CO_ODE_TOKEN: token,
+                    },
+                },
+            },
+        }, null, 2));
+    }
+    catch {
+        // Non-fatal — Claude Code will work without MCP tools
+    }
+    // Spawn claude -p with MCP config
+    const child = spawn("claude", ["-p", goal, "--add-dir", workDir, "--mcp-config", mcpConfigPath], {
+        cwd: workDir,
+        env: {
+            ...process.env,
+            CO_ODE_API_URL: apiOrigin,
+            CO_ODE_ROOM_ID: options.roomId || "",
+            CO_ODE_TOKEN: token,
+            CO_ODE_RUN_ID: runId,
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    currentRun = { runId, process: child, heartbeatTimer };
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf-8");
+    child.stderr?.setEncoding("utf-8");
+    child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+        onOutput(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk;
+        onOutput(chunk);
+    });
+    return new Promise((resolve) => {
+        child.on("exit", async (code) => {
+            clearInterval(heartbeatTimer);
+            const succeeded = code === 0;
+            onOutput(`\r\n[co-ode] Claude Code ${succeeded ? "completed" : `exited with code ${code}`}\r\n`);
+            // Post completion
+            try {
+                await fetch(completeUrl, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        authorization: `Bearer ${token}`,
+                        "x-local-bridge-token": token,
+                    },
+                    body: JSON.stringify({
+                        ok: succeeded,
+                        run: {
+                            status: succeeded ? "succeeded" : "failed",
+                            steps: [
+                                {
+                                    kind: succeeded ? "observation" : "error",
+                                    input: { description: goal },
+                                    output: {
+                                        success: succeeded,
+                                        payload: {
+                                            stdout: stdout.slice(-4096),
+                                            stderr: stderr.slice(-2048),
+                                            exitCode: code,
+                                        },
+                                    },
+                                    created_at: Date.now(),
+                                },
+                            ],
+                        },
+                    }),
+                });
+            }
+            catch (err) {
+                onOutput(`[co-ode] Warning: failed to post completion: ${err}\r\n`);
+            }
+            currentRun = null;
+            resolve();
+        });
+        child.on("error", async (err) => {
+            clearInterval(heartbeatTimer);
+            onOutput(`\r\n[co-ode] Failed to spawn Claude Code: ${err.message}\r\n`);
+            onOutput(`[co-ode] Make sure 'claude' CLI is installed and in PATH\r\n`);
+            try {
+                await fetch(completeUrl, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        authorization: `Bearer ${token}`,
+                        "x-local-bridge-token": token,
+                    },
+                    body: JSON.stringify({
+                        ok: false,
+                        run: {
+                            status: "failed",
+                            steps: [
+                                {
+                                    kind: "error",
+                                    input: { description: "Failed to spawn Claude Code" },
+                                    output: { success: false, payload: { message: err.message } },
+                                    created_at: Date.now(),
+                                },
+                            ],
+                        },
+                    }),
+                });
+            }
+            catch {
+                // Non-fatal
+            }
+            currentRun = null;
+            resolve();
+        });
+    });
+}
+function cancelCurrentRun() {
+    if (currentRun) {
+        currentRun.process.kill("SIGTERM");
+    }
+}

package/dist/pty.d.ts

@@ -0,0 +1,13 @@
+export interface PtyHandle {
+    onData: (cb: (data: string) => void) => void;
+    write: (data: string) => void;
+    resize: (cols: number, rows: number) => void;
+    kill: () => void;
+}
+/**
+ * Creates a local PTY-like shell process.
+ * Uses child_process.spawn with a pseudo-TTY via stdio pipes.
+ * For a production version, node-pty would give true PTY support,
+ * but this works without native compilation.
+ */
+export declare function createLocalPty(cwd: string): PtyHandle;

package/dist/pty.js

@@ -0,0 +1,52 @@
+import { spawn } from "node:child_process";
+/**
+ * Creates a local PTY-like shell process.
+ * Uses child_process.spawn with a pseudo-TTY via stdio pipes.
+ * For a production version, node-pty would give true PTY support,
+ * but this works without native compilation.
+ */
+export function createLocalPty(cwd) {
+    const shell = process.env.SHELL || "/bin/bash";
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    const child = spawn(shell, ["-i"], {
+        cwd,
+        env: {
+            ...process.env,
+            TERM: "xterm-256color",
+            COLUMNS: String(cols),
+            LINES: String(rows),
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const dataCallbacks = [];
+    child.stdout?.setEncoding("utf-8");
+    child.stderr?.setEncoding("utf-8");
+    child.stdout?.on("data", (chunk) => {
+        for (const cb of dataCallbacks)
+            cb(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+        for (const cb of dataCallbacks)
+            cb(chunk);
+    });
+    child.on("exit", () => {
+        for (const cb of dataCallbacks)
+            cb("\r\n[co-ode] Shell process exited\r\n");
+    });
+    return {
+        onData(cb) {
+            dataCallbacks.push(cb);
+        },
+        write(data) {
+            child.stdin?.write(data);
+        },
+        resize(_cols, _rows) {
+            // With child_process we can't truly resize without node-pty
+            // But we update env for new subprocesses
+        },
+        kill() {
+            child.kill("SIGTERM");
+        },
+    };
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@codegrammer/co-od",
+  "version": "0.1.0",
+  "description": "CLI for co-ode — run AI agents in shared rooms from the command line",
+  "type": "module",
+  "bin": {
+    "co-ode": "./dist/index.js",
+    "co-od": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "SKILL.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -w -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "lint": "echo noop"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "cli",
+    "claude",
+    "codex",
+    "multiplayer",
+    "coding",
+    "collaboration",
+    "rooms"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hacksurvivor/co-ode.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://co-od.dev",
+  "license": "MIT",
+  "author": "co-ode contributors",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "ws": "^8.18.0",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.13",
+    "typescript": "^5.6.2"
+  }
+}