@neta-art/cohub-cli 1.0.0

package/dist/commands/spaces.js

@@ -0,0 +1,675 @@
+import { resolveToken } from "../auth.js";
+import { createClient } from "../client.js";
+import { table, json as outJson, ok, error, handleHttp } from "../output.js";
+function requireSpace(program) {
+    let current = program;
+    while (current) {
+        const opts = current.opts();
+        if (opts.space)
+            return String(opts.space);
+        current = current.parent ?? null;
+    }
+    return error("Missing required option", "Add -s, --space <id> to target a space");
+}
+export function registerSpaces(program) {
+    const spacesCmd = program.command("spaces").description("Space management");
+    // ── spaces ls ──
+    spacesCmd
+        .command("ls")
+        .alias("list")
+        .description("List all spaces")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const client = createClient(token);
+        try {
+            const items = await client.spaces.list();
+            if (opts.json)
+                return outJson(items);
+            table(items, [
+                { key: "id", label: "ID" },
+                { key: "name", label: "Name" },
+                { key: "createdAt", label: "Created" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    // ── spaces get ──
+    spacesCmd
+        .command("get <id>")
+        .description("Show space details")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const client = createClient(token);
+        try {
+            const space = await client.spaces.get(id);
+            if (opts.json)
+                return outJson(space);
+            table([space], [
+                { key: "id", label: "ID" },
+                { key: "name", label: "Name" },
+                { key: "description", label: "Description" },
+                { key: "status", label: "Status" },
+                { key: "createdAt", label: "Created" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    // ── spaces create ──
+    spacesCmd
+        .command("create")
+        .description("Create a new space")
+        .option("-n, --name <name>", "Space name")
+        .option("-d, --description <desc>", "Space description")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const client = createClient(token);
+        try {
+            const result = await client.spaces.create({
+                name: opts.name,
+                description: opts.description,
+            });
+            if (opts.json)
+                return outJson(result);
+            ok(`Space created: ${result.space.id}`);
+            table([result.space], [
+                { key: "id", label: "ID" },
+                { key: "name", label: "Name" },
+                { key: "taskRunId", label: "Task" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    // ── spaces rename ──
+    spacesCmd
+        .command("rename <id> <name>")
+        .description("Rename a space")
+        .action(async (id, name) => {
+        const token = resolveToken() ?? missingAuth();
+        const client = createClient(token);
+        try {
+            await client.space(id).rename(name);
+            ok(`Space renamed to "${name}"`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    // ── spaces files ──
+    registerFiles(spacesCmd);
+    // ── spaces sessions ──
+    registerSessions(spacesCmd);
+    // ── spaces members ──
+    registerMembers(spacesCmd);
+    // ── spaces access ──
+    registerAccess(spacesCmd);
+    // ── spaces checkpoints ──
+    registerCheckpoints(spacesCmd);
+    // ── spaces usage ──
+    spacesCmd
+        .command("usage [days]")
+        .description("Space usage statistics (default: 30 days)")
+        .option("--json", "Output as JSON")
+        .action(async (days, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const usage = await client.space(spaceId).usage.get(Number.parseInt(days ?? "30", 10));
+            if (opts.json)
+                return outJson(usage);
+            console.log("\n  Summary:");
+            table([usage.summary], [
+                { key: "totalTokens", label: "Tokens" },
+                { key: "costTotal", label: "Cost ($)" },
+                { key: "requestCount", label: "Requests" },
+                { key: "successCount", label: "Success" },
+                { key: "errorCount", label: "Errors" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
+// ── File operations ──
+function registerFiles(spacesCmd) {
+    const filesCmd = spacesCmd
+        .command("files")
+        .description("File operations")
+        .hook("preAction", () => { requireSpace(spacesCmd); });
+    filesCmd
+        .command("ls [path]")
+        .alias("list")
+        .description("List directory tree")
+        .option("--json", "Output as JSON")
+        .action(async (path, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const tree = await client.space(spaceId).files.list(path ?? "");
+            if (opts.json)
+                return outJson(tree);
+            if (tree.entries.length === 0) {
+                console.log("  (empty)");
+                return;
+            }
+            table(tree.entries, [
+                { key: "name", label: "Name" },
+                { key: "type", label: "Type" },
+                { key: "size", label: "Size" },
+                { key: "mtimeMs", label: "Modified" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    filesCmd
+        .command("cat <path>")
+        .description("Read file content")
+        .action(async (path) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const file = await client.space(spaceId).files.read(path);
+            console.log(file.content);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    filesCmd
+        .command("write <path>")
+        .description("Write file content")
+        .option("-c, --content <text>", "File content")
+        .option("-e, --encoding <enc>", "Encoding (utf-8 or base64)", "utf-8")
+        .action(async (path, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        let content = opts.content ?? "";
+        if (!content && !process.stdin.isTTY) {
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(chunk);
+            content = Buffer.concat(chunks).toString();
+        }
+        if (!content)
+            return error("No content provided", "Use -c or pipe via stdin");
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).files.write({
+                path,
+                content,
+                encoding: opts.encoding,
+            });
+            ok(`Written ${result.size} bytes to ${result.path}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    filesCmd
+        .command("mkdir <path>")
+        .description("Create a directory")
+        .action(async (path) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            await client.space(spaceId).files.createDir(path);
+            ok(`Directory created: ${path}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    filesCmd
+        .command("rm <path>")
+        .description("Delete a file or directory")
+        .option("-r, --recursive", "Delete recursively")
+        .action(async (path, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            await client.space(spaceId).files.delete(path, opts.recursive ?? false);
+            ok(`Deleted: ${path}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    filesCmd
+        .command("mv <from> <to>")
+        .description("Move or rename")
+        .action(async (from, to) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            await client.space(spaceId).files.move({ fromPath: from, toPath: to });
+            ok(`Moved: ${from} → ${to}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    filesCmd
+        .command("upload <files...>")
+        .description("Upload files to a directory")
+        .option("--dir <dir>", "Target directory", "")
+        .action(async (_files) => {
+        error("Upload requires browser File API", "Use the web interface for now");
+    });
+}
+// ── Session operations ──
+function registerSessions(spacesCmd) {
+    const sessionsCmd = spacesCmd
+        .command("sessions")
+        .description("Session operations")
+        .hook("preAction", () => { requireSpace(spacesCmd); });
+    sessionsCmd
+        .command("ls")
+        .alias("list")
+        .description("List sessions")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).sessions.list();
+            if (opts.json)
+                return outJson(result);
+            if (result.sessions.length === 0) {
+                console.log("  (empty)");
+                return;
+            }
+            table(result.sessions, [
+                { key: "id", label: "ID" },
+                { key: "title", label: "Title" },
+                { key: "totalMessages", label: "Messages" },
+                { key: "createdAt", label: "Created" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    sessionsCmd
+        .command("create [title]")
+        .description("Create a session")
+        .option("--json", "Output as JSON")
+        .action(async (title, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).sessions.create({ title });
+            if (opts.json)
+                return outJson(result);
+            ok(`Session created: ${result.session.id}`);
+            table([result.session], [
+                { key: "id", label: "ID" },
+                { key: "title", label: "Title" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    sessionsCmd
+        .command("get <id>")
+        .description("Session details")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).session(id).get();
+            if (opts.json)
+                return outJson(result);
+            table([result.session], [
+                { key: "id", label: "ID" },
+                { key: "title", label: "Title" },
+                { key: "totalMessages", label: "Messages" },
+                { key: "totalToolCalls", label: "Tool Calls" },
+                { key: "createdAt", label: "Created" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    sessionsCmd
+        .command("rename <id> <name>")
+        .description("Rename a session")
+        .action(async (id, name) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            await client.space(spaceId).session(id).rename(name);
+            ok(`Session renamed to "${name}"`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    // ── sessions messages ──
+    registerMessages(sessionsCmd);
+    // ── sessions tail ──
+    sessionsCmd
+        .command("tail <id>")
+        .description("Stream realtime session events")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        const session = client.space(spaceId).session(id);
+        process.stdout.write("  Listening for events...\n\n");
+        session.on("turn.progress", (e) => {
+            if (opts.json) {
+                console.log(JSON.stringify(e));
+            }
+            else {
+                const blocks = e.payload?.content;
+                const text = blocks?.find((b) => b.type === "text")?.text;
+                if (text)
+                    process.stdout.write(text);
+            }
+        });
+        session.on("turn.final", () => {
+            process.stdout.write("\n\n  ✓ Done\n");
+            process.exit(0);
+        });
+        session.on("turn.error", (e) => {
+            process.stderr.write(`\n  ✗ Error\n`);
+            if (opts.json)
+                process.stderr.write(JSON.stringify(e) + "\n");
+            process.exit(1);
+        });
+    });
+}
+// ── Message operations ──
+function registerMessages(sessionsCmd) {
+    const msgsCmd = sessionsCmd.command("messages").description("Message operations");
+    msgsCmd
+        .command("ls <sessionId>")
+        .alias("list")
+        .description("List session messages")
+        .option("--json", "Output as JSON")
+        .option("--limit <n>", "Page size", "50")
+        .action(async (sessionId, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(sessionsCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).session(sessionId).messages.listPaginated({
+                limit: Number.parseInt(opts.limit ?? "50", 10),
+            });
+            if (opts.json)
+                return outJson(result);
+            if (result.messages.length === 0) {
+                console.log("  (empty)");
+                return;
+            }
+            table(result.messages, [
+                { key: "id", label: "ID" },
+                { key: "role", label: "Role" },
+                { key: "createdAt", label: "Created" },
+            ]);
+            if (result.hasMore) {
+                console.log(`\n  (more — use --cursor ${result.nextCursor} for next page)`);
+            }
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    msgsCmd
+        .command("send <sessionId> [content...]")
+        .description("Send a message to a session")
+        .option("-m, --model <model>", "Model name")
+        .option("-p, --provider <provider>", "Provider name")
+        .option("--json", "Output as JSON")
+        .action(async (sessionId, words, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        let content = words.join(" ");
+        if (!content && !process.stdin.isTTY) {
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(chunk);
+            content = Buffer.concat(chunks).toString().trim();
+        }
+        if (!content)
+            return error("No content", "Pass as argument or pipe via stdin");
+        const spaceId = requireSpace(sessionsCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).session(sessionId).messages.send({
+                content: [{ type: "text", text: content }],
+                model: opts.model,
+                provider: opts.provider,
+            });
+            if (opts.json)
+                return outJson(result);
+            ok(`Message sent — userMessageId: ${result.userMessageId}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
+// ── Member operations ──
+function registerMembers(spacesCmd) {
+    const memCmd = spacesCmd
+        .command("members")
+        .description("Member management")
+        .hook("preAction", () => { requireSpace(spacesCmd); });
+    memCmd
+        .command("ls")
+        .alias("list")
+        .description("List space members")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).members.list();
+            if (opts.json)
+                return outJson(result);
+            if (result.items.length === 0) {
+                console.log("  (empty)");
+                return;
+            }
+            table(result.items, [
+                { key: "userId", label: "User ID" },
+                { key: "role", label: "Role" },
+                { key: "createdAt", label: "Since" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    memCmd
+        .command("update <userId> <role>")
+        .description("Change member role (host | builder | guest)")
+        .action(async (userId, role) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            await client.space(spaceId).members.update(userId, role);
+            ok(`${userId} → ${role}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    memCmd
+        .command("remove <userId>")
+        .description("Remove a member")
+        .action(async (userId) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            await client.space(spaceId).members.remove(userId);
+            ok(`${userId} removed`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
+// ── Access control ──
+function registerAccess(spacesCmd) {
+    const accCmd = spacesCmd
+        .command("access")
+        .description("Access control")
+        .hook("preAction", () => { requireSpace(spacesCmd); });
+    accCmd
+        .command("get")
+        .description("Get access policy")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const policy = await client.space(spaceId).access.get();
+            if (opts.json)
+                return outJson(policy);
+            table([policy], [
+                { key: "signed_in_user", label: "Signed-in" },
+                { key: "anonymous_user", label: "Anonymous" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    accCmd
+        .command("set")
+        .description("Set access policy")
+        .option("--signed-in <role>", "Role for signed-in users (host|builder|guest|null)")
+        .option("--anonymous <role>", "Role for anonymous users (host|builder|guest|null)")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const policy = await client.space(spaceId).access.set({
+                signed_in_user: (opts.signedIn ?? null),
+                anonymous_user: (opts.anonymous ?? null),
+            });
+            if (opts.json)
+                return outJson(policy);
+            ok("Access policy updated");
+            table([policy], [
+                { key: "signed_in_user", label: "Signed-in" },
+                { key: "anonymous_user", label: "Anonymous" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
+// ── Checkpoint operations ──
+function registerCheckpoints(spacesCmd) {
+    const cpCmd = spacesCmd
+        .command("checkpoints")
+        .description("Checkpoint management")
+        .hook("preAction", () => { requireSpace(spacesCmd); });
+    cpCmd
+        .command("ls")
+        .alias("list")
+        .description("List checkpoints")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).checkpoints.list();
+            if (opts.json)
+                return outJson(result);
+            if (result.checkpoints.length === 0) {
+                console.log("  (empty)");
+                return;
+            }
+            table(result.checkpoints, [
+                { key: "id", label: "ID" },
+                { key: "commitHash", label: "Commit" },
+                { key: "description", label: "Description" },
+                { key: "createdAt", label: "Created" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cpCmd
+        .command("get <id>")
+        .description("Checkpoint details")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).checkpoints.get(id);
+            if (opts.json)
+                return outJson(result);
+            table([result.checkpoint], [
+                { key: "id", label: "ID" },
+                { key: "commitHash", label: "Commit" },
+                { key: "description", label: "Description" },
+                { key: "forkCount", label: "Forks" },
+                { key: "createdAt", label: "Created" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cpCmd
+        .command("create [description]")
+        .description("Create a checkpoint")
+        .option("--json", "Output as JSON")
+        .action(async (description, opts) => {
+        const token = resolveToken() ?? missingAuth();
+        const spaceId = requireSpace(spacesCmd);
+        const client = createClient(token);
+        try {
+            const result = await client.space(spaceId).checkpoints.create(description ?? null);
+            if (opts.json)
+                return outJson(result);
+            ok(`Checkpoint created — taskRunId: ${result.taskRunId}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
+function missingAuth() {
+    return error("Not authenticated", "Run 'cohub auth login <token>'");
+}

package/dist/commands/tasks.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerTasks(program: Command): void;