@codegrammer/co-od 0.1.0

package/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: co-od
+description: CLI for connecting local dev environments to co-ode rooms
+version: 0.1.0
+---
+
+# co-od CLI
+
+Run AI agents in co-ode rooms from the command line.
+
+## Commands
+
+- `co-od login` -- authenticate via browser (or `--token <t>` for CI)
+- `co-od rooms` -- list rooms (supports `--json`)
+- `co-od run <room> <goal>` -- execute a single task, fire-and-forget
+- `co-od join <room>` -- join a room as an interactive agent (PTY + WebSocket)
+- `co-od daemon <room>` -- autonomous watch mode, polls for events and executes
+- `co-od share` -- generate a relay code for teammates
+- `co-od connect <code>` -- connect to a shared relay
+- `co-od status` -- show login state and session info
+
+## Provider Support
+
+Use `--provider claude|codex` on `run`, `daemon`, and `share` commands.
+
+- `claude` (default) -- spawns `claude -p --dangerously-skip-permissions`
+- `codex` -- spawns `codex exec --full-auto`
+
+## Usage with Claude Code
+
+Dispatch tasks to a room from within Claude Code hooks:
+
+```bash
+co-od run room_abc123 "Fix the failing tests in src/utils" --json
+```
+
+## Environment Variables
+
+- `CO_ODE_SERVER` -- override the server URL (default: https://co-ode.vercel.app)
+
+## Session
+
+Sessions are cached at `~/.co-ode/session.json` (valid for 23 hours).

package/dist/adapters/base.d.ts

@@ -0,0 +1,15 @@
+export interface AgentAdapter {
+    name: string;
+    available(): Promise<boolean>;
+    execute(goal: string, options: ExecuteOptions): Promise<ExecuteResult>;
+}
+export interface ExecuteOptions {
+    workDir: string;
+    onOutput?: (data: string) => void;
+    signal?: AbortSignal;
+}
+export interface ExecuteResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}

package/dist/adapters/base.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/claude.d.ts

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

package/dist/adapters/claude.js

@@ -0,0 +1,45 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+function which(cmd) {
+    const paths = (process.env.PATH || "").split(":");
+    return paths.some((dir) => existsSync(`${dir}/${cmd}`));
+}
+export class ClaudeAdapter {
+    name = "claude";
+    async available() {
+        return which("claude");
+    }
+    async execute(goal, options) {
+        const { workDir, onOutput, signal } = options;
+        return new Promise((resolve, reject) => {
+            const child = spawn("claude", ["-p", "--dangerously-skip-permissions", "--", goal], {
+                cwd: workDir,
+                env: { ...process.env },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            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);
+            });
+            child.on("exit", (code) => {
+                resolve({ exitCode: code ?? 1, stdout, stderr });
+            });
+            child.on("error", (err) => {
+                reject(err);
+            });
+            if (signal) {
+                signal.addEventListener("abort", () => {
+                    child.kill("SIGTERM");
+                }, { once: true });
+            }
+        });
+    }
+}

package/dist/adapters/codex.d.ts

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

package/dist/adapters/codex.js

@@ -0,0 +1,45 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+function which(cmd) {
+    const paths = (process.env.PATH || "").split(":");
+    return paths.some((dir) => existsSync(`${dir}/${cmd}`));
+}
+export class CodexAdapter {
+    name = "codex";
+    async available() {
+        return which("codex");
+    }
+    async execute(goal, options) {
+        const { workDir, onOutput, signal } = options;
+        return new Promise((resolve, reject) => {
+            const child = spawn("codex", ["exec", "--full-auto", "--", goal], {
+                cwd: workDir,
+                env: { ...process.env },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            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);
+            });
+            child.on("exit", (code) => {
+                resolve({ exitCode: code ?? 1, stdout, stderr });
+            });
+            child.on("error", (err) => {
+                reject(err);
+            });
+            if (signal) {
+                signal.addEventListener("abort", () => {
+                    child.kill("SIGTERM");
+                }, { once: true });
+            }
+        });
+    }
+}

package/dist/api-client.d.ts

@@ -0,0 +1,13 @@
+interface CachedSession {
+    sessionToken: string;
+    expiresAt: number;
+    user?: string;
+}
+declare function getBaseUrl(): string;
+declare function getSessionToken(): string | null;
+export declare function getSession(): CachedSession | null;
+declare function requireToken(): string;
+export declare function get<T = unknown>(path: string): Promise<T>;
+export declare function post<T = unknown>(path: string, body?: unknown): Promise<T>;
+export declare function poll<T = unknown>(path: string, intervalMs: number, condition: (data: T) => boolean, signal?: AbortSignal): Promise<T>;
+export { getBaseUrl, getSessionToken, requireToken };

package/dist/api-client.js

@@ -0,0 +1,89 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+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");
+}
+function getSessionToken() {
+    try {
+        const data = JSON.parse(readFileSync(SESSION_FILE, "utf-8"));
+        if (data.expiresAt > Date.now()) {
+            return data.sessionToken;
+        }
+    }
+    catch {
+        // No session
+    }
+    return null;
+}
+export function getSession() {
+    try {
+        const data = JSON.parse(readFileSync(SESSION_FILE, "utf-8"));
+        if (data.expiresAt > Date.now()) {
+            return data;
+        }
+    }
+    catch {
+        // No session
+    }
+    return null;
+}
+function requireToken() {
+    const token = getSessionToken();
+    if (!token) {
+        console.error("[co-od] Not logged in. Run `co-od login` first.");
+        process.exit(1);
+    }
+    return token;
+}
+function headers(token) {
+    return {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`,
+    };
+}
+export async function get(path) {
+    const token = requireToken();
+    const url = `${getBaseUrl()}${path}`;
+    const res = await fetch(url, { headers: headers(token) });
+    if (!res.ok) {
+        throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+}
+export async function post(path, body) {
+    const token = requireToken();
+    const url = `${getBaseUrl()}${path}`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: headers(token),
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+        throw new Error(`POST ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+}
+export async function poll(path, intervalMs, condition, signal) {
+    while (true) {
+        if (signal?.aborted) {
+            throw new Error("Polling aborted");
+        }
+        const data = await get(path);
+        if (condition(data)) {
+            return data;
+        }
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(resolve, intervalMs);
+            if (signal) {
+                signal.addEventListener("abort", () => {
+                    clearTimeout(timer);
+                    reject(new Error("Polling aborted"));
+                }, { once: true });
+            }
+        });
+    }
+}
+export { getBaseUrl, getSessionToken, requireToken };

package/dist/auth.d.ts

@@ -0,0 +1,11 @@
+interface AuthResult {
+    sessionToken: string;
+    realtimeToken: string;
+    terminalWsUrl: string;
+}
+export declare function authenticate({ serverUrl, roomId, inviteToken, }: {
+    serverUrl: string;
+    roomId: string;
+    inviteToken?: string;
+}): Promise<AuthResult>;
+export {};

package/dist/auth.js

@@ -0,0 +1,154 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".co-ode");
+const SESSION_FILE = join(CONFIG_DIR, "session.json");
+function loadCachedSession() {
+    try {
+        const data = JSON.parse(readFileSync(SESSION_FILE, "utf-8"));
+        if (data.expiresAt > Date.now()) {
+            return data;
+        }
+    }
+    catch {
+        // No cached session
+    }
+    return null;
+}
+function saveCachedSession(session) {
+    try {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+        writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+    }
+    catch {
+        // Non-fatal
+    }
+}
+async function deviceAuthFlow(serverUrl) {
+    // Step 1: Request a device code
+    const authorizeRes = await fetch(`${serverUrl}/api/auth/cli/authorize`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({}),
+    });
+    if (!authorizeRes.ok) {
+        throw new Error(`Failed to start auth flow: ${authorizeRes.status}`);
+    }
+    const { code, verificationUrl, expiresAt } = (await authorizeRes.json());
+    // Step 2: Open browser for approval
+    console.error(`\n[co-ode] To authenticate, open this URL in your browser:\n`);
+    console.error(`  ${verificationUrl}\n`);
+    console.error(`[co-ode] Your code: ${code}\n`);
+    try {
+        const open = (await import("open")).default;
+        await open(verificationUrl);
+        console.error(`[co-ode] Browser opened. Waiting for approval...`);
+    }
+    catch {
+        console.error(`[co-ode] Could not open browser automatically. Please open the URL manually.`);
+    }
+    // Step 3: Poll for token
+    const pollInterval = 2000;
+    const deadline = expiresAt;
+    while (Date.now() < deadline) {
+        await sleep(pollInterval);
+        const tokenRes = await fetch(`${serverUrl}/api/auth/cli/token`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ code }),
+        });
+        if (tokenRes.status === 410) {
+            throw new Error("Auth code expired. Please try again.");
+        }
+        if (tokenRes.status === 202) {
+            // Still pending
+            continue;
+        }
+        if (tokenRes.ok) {
+            const { token } = (await tokenRes.json());
+            if (token) {
+                // Cache for 23 hours (tokens last 24h)
+                saveCachedSession({
+                    sessionToken: token,
+                    expiresAt: Date.now() + 23 * 60 * 60 * 1000,
+                });
+                return token;
+            }
+        }
+        throw new Error(`Unexpected auth response: ${tokenRes.status}`);
+    }
+    throw new Error("Auth timed out. Please try again.");
+}
+export async function authenticate({ serverUrl, roomId, inviteToken, }) {
+    // Try cached session first
+    let sessionToken;
+    const cached = loadCachedSession();
+    if (cached) {
+        console.error(`[co-ode] Using cached session`);
+        sessionToken = cached.sessionToken;
+    }
+    else {
+        // If invite token provided, redeem it first
+        if (inviteToken) {
+            console.error(`[co-ode] Redeeming invite token...`);
+            const inviteRes = await fetch(`${serverUrl}/api/invites`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ token: inviteToken }),
+            });
+            if (!inviteRes.ok) {
+                console.error(`[co-ode] Warning: invite redemption failed (${inviteRes.status}), continuing with auth...`);
+            }
+        }
+        sessionToken = await deviceAuthFlow(serverUrl);
+    }
+    // Get realtime session for the room
+    console.error(`[co-ode] Getting realtime session for room ${roomId}...`);
+    const realtimeRes = await fetch(`${serverUrl}/api/rooms/${roomId}/realtime/session`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${sessionToken}`,
+        },
+        body: JSON.stringify({ ttlSeconds: 3600 }),
+    });
+    if (!realtimeRes.ok) {
+        // Cached session may be invalid, clear it and retry
+        if (cached) {
+            console.error(`[co-ode] Cached session invalid, re-authenticating...`);
+            try {
+                const { unlinkSync } = await import("node:fs");
+                unlinkSync(SESSION_FILE);
+            }
+            catch { /* ignore */ }
+            sessionToken = await deviceAuthFlow(serverUrl);
+            const retryRes = await fetch(`${serverUrl}/api/rooms/${roomId}/realtime/session`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${sessionToken}`,
+                },
+                body: JSON.stringify({ ttlSeconds: 3600 }),
+            });
+            if (!retryRes.ok) {
+                throw new Error(`Failed to get realtime session: ${retryRes.status}`);
+            }
+            const data = (await retryRes.json());
+            return {
+                sessionToken,
+                realtimeToken: data.token,
+                terminalWsUrl: data.terminalWsUrl,
+            };
+        }
+        throw new Error(`Failed to get realtime session: ${realtimeRes.status}`);
+    }
+    const realtimeData = (await realtimeRes.json());
+    return {
+        sessionToken,
+        realtimeToken: realtimeData.token,
+        terminalWsUrl: realtimeData.terminalWsUrl,
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/connect.d.ts

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

package/dist/commands/connect.js

@@ -0,0 +1,43 @@
+import * as api from "../api-client.js";
+function parseArgs(args) {
+    const parsed = {
+        provider: "claude",
+        dir: process.cwd(),
+    };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--provider" && args[i + 1]) {
+            parsed.provider = args[++i];
+        }
+        else if (args[i] === "--dir" && args[i + 1]) {
+            parsed.dir = args[++i];
+        }
+        else if (args[i] === "--server" && args[i + 1]) {
+            parsed.server = args[++i];
+        }
+        else if (!args[i].startsWith("--")) {
+            parsed.code = args[i];
+        }
+    }
+    return parsed;
+}
+export async function run(args) {
+    const parsed = parseArgs(args);
+    if (!parsed.code) {
+        console.error("Usage: co-od connect <relay-code>");
+        process.exit(1);
+    }
+    if (parsed.server) {
+        process.env.CO_ODE_SERVER = parsed.server;
+    }
+    console.error(`[co-od] Connecting to relay ${parsed.code}...`);
+    const res = await api.post("/api/relay/join", {
+        code: parsed.code,
+    });
+    if (!res.ok) {
+        console.error(`[co-od] Failed to join relay. Code may be invalid or expired.`);
+        process.exit(1);
+    }
+    console.log(`Connected to relay ${parsed.code}`);
+    console.log(`You can now dispatch tasks to the shared machine.`);
+    console.log(`\nRelay ID: ${res.relayId}`);
+}

package/dist/commands/daemon.d.ts

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