@codegrammer/co-od 0.1.0

package/dist/commands/daemon.js

@@ -0,0 +1,202 @@
+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",
+        watch: [],
+        autoExecute: false,
+        maxConcurrent: 1,
+        dir: process.cwd(),
+    };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--as" && args[i + 1]) {
+            parsed.as = args[++i];
+        }
+        else if (args[i] === "--role" && args[i + 1]) {
+            parsed.role = args[++i];
+        }
+        else if (args[i] === "--provider" && args[i + 1]) {
+            parsed.provider = args[++i];
+        }
+        else if (args[i] === "--watch" && args[i + 1]) {
+            parsed.watch = args[++i].split(",");
+        }
+        else if (args[i] === "--auto-execute") {
+            parsed.autoExecute = true;
+        }
+        else if (args[i] === "--instructions" && args[i + 1]) {
+            parsed.instructions = args[++i];
+        }
+        else if (args[i] === "--max-concurrent" && args[i + 1]) {
+            parsed.maxConcurrent = parseInt(args[++i], 10) || 1;
+        }
+        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.roomId = args[i];
+        }
+    }
+    // Default watch events if none specified
+    if (parsed.watch.length === 0) {
+        parsed.watch = ["task.assigned", "patch.proposed", "run.requested"];
+    }
+    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>]");
+        process.exit(1);
+    }
+    if (parsed.server) {
+        process.env.CO_ODE_SERVER = parsed.server;
+    }
+    const adapter = getAdapter(parsed.provider);
+    const isAvailable = await adapter.available();
+    if (!isAvailable) {
+        console.error(`Error: '${adapter.name}' is not installed or not in PATH.`);
+        process.exit(1);
+    }
+    // Register as an agent in the room
+    const agentName = parsed.as || `cli-${process.env.USER || "agent"}`;
+    console.error(`[${timestamp()}] Registering agent "${agentName}" in room ${parsed.roomId}...`);
+    let agentId;
+    try {
+        const reg = await api.post(`/api/rooms/${parsed.roomId}/agents`, {
+            name: agentName,
+            role: parsed.role || "worker",
+            provider: parsed.provider,
+            capabilities: parsed.watch,
+            instructions: parsed.instructions,
+        });
+        agentId = reg.agentId;
+        console.error(`[${timestamp()}] Registered as agent ${agentId}`);
+    }
+    catch (err) {
+        console.error(`[${timestamp()}] Failed to register agent: ${err}`);
+        process.exit(1);
+    }
+    console.error(`[${timestamp()}] Watching for events: ${parsed.watch.join(", ")}`);
+    console.error(`[${timestamp()}] Auto-execute: ${parsed.autoExecute}`);
+    console.error(`[${timestamp()}] Max concurrent: ${parsed.maxConcurrent}`);
+    console.error(`[${timestamp()}] Press Ctrl+C to stop.\n`);
+    let cursor;
+    let activeRuns = 0;
+    const processedEvents = new Set();
+    // Handle graceful shutdown
+    let stopping = false;
+    process.on("SIGINT", () => {
+        if (stopping)
+            process.exit(1);
+        stopping = true;
+        console.error(`\n[${timestamp()}] Stopping daemon... (Ctrl+C again to force)`);
+        if (activeRuns === 0)
+            process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        stopping = true;
+        process.exit(0);
+    });
+    // Event polling loop
+    while (!stopping) {
+        try {
+            const queryParams = cursor ? `?cursor=${cursor}` : "";
+            const data = await api.get(`/api/rooms/${parsed.roomId}/events${queryParams}`);
+            if (data.cursor) {
+                cursor = data.cursor;
+            }
+            const events = (data.events || []).filter((e) => parsed.watch.includes(e.type) && !processedEvents.has(e._id));
+            for (const event of events) {
+                processedEvents.add(event._id);
+                console.error(`[${timestamp()}] Event: ${event.type} ${JSON.stringify(event.payload || {}).slice(0, 100)}`);
+                if (activeRuns >= parsed.maxConcurrent) {
+                    console.error(`[${timestamp()}] Skipping — at max concurrent (${parsed.maxConcurrent})`);
+                    continue;
+                }
+                if (parsed.autoExecute) {
+                    // Auto-dispatch
+                    const goal = event.payload?.goal ||
+                        event.payload?.description ||
+                        `Handle event: ${event.type}`;
+                    activeRuns++;
+                    console.error(`[${timestamp()}] Dispatching: ${goal.slice(0, 80)}`);
+                    // Create a run on the server
+                    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),
+                        });
+                        console.error(`\n[${timestamp()}] Run ${runId} ${result.exitCode === 0 ? "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(),
+                                        },
+                                    ],
+                                },
+                            });
+                        }
+                        catch {
+                            console.error(`[${timestamp()}] Warning: failed to report completion`);
+                        }
+                    })
+                        .catch((err) => {
+                        console.error(`[${timestamp()}] Run failed: ${err}`);
+                    })
+                        .finally(() => {
+                        activeRuns--;
+                        if (stopping && activeRuns === 0)
+                            process.exit(0);
+                    });
+                }
+                else {
+                    // Print event, wait for user confirmation
+                    const goal = event.payload?.goal ||
+                        event.payload?.description ||
+                        `Handle event: ${event.type}`;
+                    console.error(`[${timestamp()}] Pending: ${goal.slice(0, 120)}`);
+                    console.error(`[${timestamp()}] (use --auto-execute to handle automatically)`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[${timestamp()}] Poll error: ${err}`);
+        }
+        // Wait before next poll
+        await new Promise((r) => setTimeout(r, 3000));
+    }
+}

package/dist/commands/join.d.ts

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

package/dist/commands/join.js

@@ -0,0 +1,49 @@
+import { authenticate } from "../auth.js";
+import { connectToRoom } from "../connect.js";
+function parseArgs(args) {
+    const parsed = { dir: process.cwd() };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--server" && args[i + 1]) {
+            parsed.server = args[++i];
+        }
+        else if (args[i] === "--invite-token" && args[i + 1]) {
+            parsed.inviteToken = args[++i];
+        }
+        else if (args[i] === "--dir" && args[i + 1]) {
+            parsed.dir = args[++i];
+        }
+        else if (!args[i].startsWith("--")) {
+            parsed.roomId = args[i];
+        }
+    }
+    return parsed;
+}
+export async function run(args) {
+    const parsed = parseArgs(args);
+    if (!parsed.roomId) {
+        console.error("Usage: co-od join <room-id> [--invite-token <tok>] [--dir <path>]");
+        process.exit(1);
+    }
+    const serverUrl = parsed.server ||
+        process.env.CO_ODE_SERVER ||
+        "https://co-ode.vercel.app";
+    console.error(`[co-od] Joining room ${parsed.roomId}...`);
+    console.error(`[co-od] Server: ${serverUrl}`);
+    console.error(`[co-od] Working directory: ${parsed.dir}`);
+    // Authenticate
+    const { sessionToken, realtimeToken, terminalWsUrl } = await authenticate({
+        serverUrl,
+        roomId: parsed.roomId,
+        inviteToken: parsed.inviteToken,
+    });
+    console.error(`[co-od] Authenticated successfully`);
+    // Connect to room (blocks until disconnect)
+    await connectToRoom({
+        terminalWsUrl,
+        realtimeToken,
+        roomId: parsed.roomId,
+        workDir: parsed.dir,
+        serverUrl,
+        sessionToken,
+    });
+}

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,93 @@
+import { 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 parseArgs(args) {
+    const parsed = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--token" && args[i + 1]) {
+            parsed.token = args[++i];
+        }
+        else if (args[i] === "--server" && args[i + 1]) {
+            parsed.server = args[++i];
+        }
+    }
+    return parsed;
+}
+function saveSession(sessionToken, user) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(SESSION_FILE, JSON.stringify({
+        sessionToken,
+        expiresAt: Date.now() + 23 * 60 * 60 * 1000,
+        user: user || "api-token-user",
+    }, null, 2));
+}
+async function deviceAuthFlow(serverUrl) {
+    // 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());
+    // Open browser for approval
+    console.error(`\nTo authenticate, open this URL in your browser:\n`);
+    console.error(`  ${verificationUrl}\n`);
+    console.error(`Your code: ${code}\n`);
+    try {
+        const open = (await import("open")).default;
+        await open(verificationUrl);
+        console.error(`Browser opened. Waiting for approval...`);
+    }
+    catch {
+        console.error(`Could not open browser automatically. Please open the URL manually.`);
+    }
+    // Poll for token
+    const pollInterval = 2000;
+    const deadline = expiresAt;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 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) {
+            continue;
+        }
+        if (tokenRes.ok) {
+            const body = (await tokenRes.json());
+            if (body.token) {
+                return { token: body.token, user: body.user };
+            }
+        }
+        throw new Error(`Unexpected auth response: ${tokenRes.status}`);
+    }
+    throw new Error("Auth timed out. Please try again.");
+}
+export async function run(args) {
+    const parsed = parseArgs(args);
+    const serverUrl = parsed.server ||
+        process.env.CO_ODE_SERVER ||
+        "https://co-ode.vercel.app";
+    // --token flag: headless/CI mode
+    if (parsed.token) {
+        saveSession(parsed.token);
+        console.log(`Logged in with API token. Session saved to ${SESSION_FILE}`);
+        return;
+    }
+    // Interactive browser auth
+    console.error(`[co-od] Starting browser authentication...`);
+    console.error(`[co-od] Server: ${serverUrl}`);
+    const { token, user } = await deviceAuthFlow(serverUrl);
+    saveSession(token, user);
+    const displayName = user || "authenticated user";
+    console.log(`Logged in as ${displayName}. Session saved to ${SESSION_FILE}`);
+}

package/dist/commands/rooms.d.ts

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

package/dist/commands/rooms.js

@@ -0,0 +1,57 @@
+import * as api from "../api-client.js";
+function parseArgs(args) {
+    const parsed = { json: false };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--json") {
+            parsed.json = true;
+        }
+        else if (args[i] === "--server" && args[i + 1]) {
+            parsed.server = args[++i];
+        }
+    }
+    return parsed;
+}
+function padRight(str, len) {
+    if (str.length >= len)
+        return str.slice(0, len);
+    return str + " ".repeat(len - str.length);
+}
+function printTable(rooms) {
+    if (rooms.length === 0) {
+        console.log("No rooms found.");
+        return;
+    }
+    const header = [
+        padRight("ID", 26),
+        padRight("NAME", 30),
+        padRight("STATUS", 12),
+        padRight("AGENTS", 8),
+        padRight("MEMBERS", 8),
+    ].join("  ");
+    console.log(header);
+    console.log("-".repeat(header.length));
+    for (const room of rooms) {
+        const row = [
+            padRight(room._id || "", 26),
+            padRight(room.name || "(unnamed)", 30),
+            padRight(room.status || "idle", 12),
+            padRight(String(room.agents?.length ?? 0), 8),
+            padRight(String(room.members?.length ?? 0), 8),
+        ].join("  ");
+        console.log(row);
+    }
+}
+export async function run(args) {
+    const parsed = parseArgs(args);
+    if (parsed.server) {
+        process.env.CO_ODE_SERVER = parsed.server;
+    }
+    const data = await api.get("/api/rooms");
+    const rooms = data.rooms || [];
+    if (parsed.json) {
+        console.log(JSON.stringify(rooms, null, 2));
+    }
+    else {
+        printTable(rooms);
+    }
+}

package/dist/commands/run.d.ts

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

package/dist/commands/run.js

@@ -0,0 +1,119 @@
+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",
+        dir: process.cwd(),
+        json: false,
+    };
+    const positional = [];
+    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] === "--json") {
+            parsed.json = true;
+        }
+        else if (args[i] === "--server" && args[i + 1]) {
+            parsed.server = args[++i];
+        }
+        else if (!args[i].startsWith("--")) {
+            positional.push(args[i]);
+        }
+    }
+    parsed.roomId = positional[0];
+    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]");
+        process.exit(1);
+    }
+    if (!parsed.goal) {
+        console.error("Error: goal is required");
+        console.error("Usage: co-od run <room-id> <goal>");
+        process.exit(1);
+    }
+    if (parsed.server) {
+        process.env.CO_ODE_SERVER = parsed.server;
+    }
+    const adapter = getAdapter(parsed.provider);
+    const isAvailable = await adapter.available();
+    if (!isAvailable) {
+        console.error(`Error: '${adapter.name}' is not installed or not in PATH.`);
+        process.exit(1);
+    }
+    // Create the agent run on the server
+    if (!parsed.json) {
+        console.error(`[co-od] Creating run in room ${parsed.roomId}...`);
+    }
+    const createRes = await api.post(`/api/rooms/${parsed.roomId}/agent-runs`, { goal: parsed.goal, provider: parsed.provider });
+    const runId = createRes.runId;
+    if (!parsed.json) {
+        console.error(`[co-od] Run ${runId} created. Executing with ${adapter.name}...`);
+    }
+    // Execute locally
+    const result = await adapter.execute(parsed.goal, {
+        workDir: parsed.dir,
+        onOutput: parsed.json
+            ? undefined
+            : (data) => process.stderr.write(data),
+    });
+    // Report completion
+    if (!parsed.json) {
+        console.error(`\n[co-od] Run ${result.exitCode === 0 ? "succeeded" : "failed"} (exit ${result.exitCode})`);
+    }
+    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: parsed.goal },
+                        output: {
+                            success: result.exitCode === 0,
+                            payload: {
+                                stdout: result.stdout.slice(-4096),
+                                stderr: result.stderr.slice(-2048),
+                                exitCode: result.exitCode,
+                            },
+                        },
+                        created_at: Date.now(),
+                    },
+                ],
+            },
+        });
+    }
+    catch {
+        if (!parsed.json) {
+            console.error("[co-od] Warning: failed to report completion to server");
+        }
+    }
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            runId,
+            status: result.exitCode === 0 ? "succeeded" : "failed",
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        }));
+    }
+    process.exit(result.exitCode === 0 ? 0 : 1);
+}

package/dist/commands/share.d.ts

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

package/dist/commands/share.js

@@ -0,0 +1,118 @@
+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",
+        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];
+        }
+    }
+    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.server) {
+        process.env.CO_ODE_SERVER = parsed.server;
+    }
+    // Register a relay
+    console.error(`[co-od] Registering relay...`);
+    const reg = await api.post("/api/relay/register", {
+        provider: parsed.provider,
+    });
+    console.log(`\nRelay code: ${reg.code}`);
+    console.log(`Share this with teammates to let them dispatch tasks to your machine.\n`);
+    console.error(`[${timestamp()}] Relay active. Expires at ${new Date(reg.expiresAt).toLocaleTimeString()}`);
+    console.error(`[${timestamp()}] Waiting for jobs... (Ctrl+C to stop)\n`);
+    const adapter = getAdapter(parsed.provider);
+    // Handle graceful shutdown
+    let stopping = false;
+    let activeJobs = 0;
+    process.on("SIGINT", () => {
+        if (stopping)
+            process.exit(1);
+        stopping = true;
+        console.error(`\n[${timestamp()}] Stopping relay... (Ctrl+C again to force)`);
+        if (activeJobs === 0)
+            process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        stopping = true;
+        process.exit(0);
+    });
+    // Poll for jobs
+    while (!stopping) {
+        try {
+            const data = await api.post("/api/relay/poll", {
+                code: reg.code,
+            });
+            if (data.job) {
+                const job = data.job;
+                console.error(`[${timestamp()}] Job received: ${job.goal.slice(0, 100)}`);
+                const jobAdapter = job.provider ? getAdapter(job.provider) : adapter;
+                activeJobs++;
+                jobAdapter
+                    .execute(job.goal, {
+                    workDir: parsed.dir,
+                    onOutput: (out) => process.stderr.write(out),
+                })
+                    .then(async (result) => {
+                    console.error(`\n[${timestamp()}] Job ${job.jobId} ${result.exitCode === 0 ? "succeeded" : "failed"}`);
+                    // Report completion
+                    try {
+                        await api.post("/api/relay/complete", {
+                            code: reg.code,
+                            jobId: job.jobId,
+                            ok: result.exitCode === 0,
+                            stdout: result.stdout.slice(-4096),
+                            stderr: result.stderr.slice(-2048),
+                            exitCode: result.exitCode,
+                        });
+                    }
+                    catch {
+                        console.error(`[${timestamp()}] Warning: failed to report job completion`);
+                    }
+                })
+                    .catch((err) => {
+                    console.error(`[${timestamp()}] Job error: ${err}`);
+                })
+                    .finally(() => {
+                    activeJobs--;
+                    if (stopping && activeJobs === 0)
+                        process.exit(0);
+                });
+            }
+        }
+        catch (err) {
+            // Relay may have expired
+            const errMsg = String(err);
+            if (errMsg.includes("404") || errMsg.includes("410")) {
+                console.error(`[${timestamp()}] Relay expired. Exiting.`);
+                process.exit(0);
+            }
+            console.error(`[${timestamp()}] Poll error: ${err}`);
+        }
+        await new Promise((r) => setTimeout(r, 3000));
+    }
+}

package/dist/commands/status.d.ts

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