@neta-art/cohub-cli 1.0.0

package/README.md

@@ -0,0 +1,15 @@
+# @neta-art/cohub-cli
+
+CLI for [Cohub](https://cohub.neta.art) — spaces, sessions, and agent collaboration.
+
+## Installation
+
+```bash
+npm install -g @neta-art/cohub-cli
+```
+
+## Usage
+
+```bash
+cohub --help
+```

package/bin/cohub.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/auth.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolve auth token with priority:
+ *   1. COHUB_EXECUTION_TOKEN environment variable
+ *   2. ~/.config/cohub/token file
+ */
+export declare function resolveToken(): string | null;
+export declare function saveToken(token: string): void;
+export declare function clearToken(): void;
+export declare function tokenSource(): "env" | "file" | null;

package/dist/auth.js

@@ -0,0 +1,35 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const TOKEN_DIR = join(homedir(), ".config", "cohub");
+const TOKEN_PATH = join(TOKEN_DIR, "token");
+/**
+ * Resolve auth token with priority:
+ *   1. COHUB_EXECUTION_TOKEN environment variable
+ *   2. ~/.config/cohub/token file
+ */
+export function resolveToken() {
+    if (process.env.COHUB_EXECUTION_TOKEN) {
+        return process.env.COHUB_EXECUTION_TOKEN.trim();
+    }
+    if (existsSync(TOKEN_PATH)) {
+        return readFileSync(TOKEN_PATH, "utf-8").trim();
+    }
+    return null;
+}
+export function saveToken(token) {
+    mkdirSync(TOKEN_DIR, { recursive: true });
+    writeFileSync(TOKEN_PATH, token.trim());
+}
+export function clearToken() {
+    if (existsSync(TOKEN_PATH)) {
+        rmSync(TOKEN_PATH);
+    }
+}
+export function tokenSource() {
+    if (process.env.COHUB_EXECUTION_TOKEN)
+        return "env";
+    if (existsSync(TOKEN_PATH))
+        return "file";
+    return null;
+}

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import { CohubHttpClient } from "@neta-art/cohub/http";
+export declare function createClient(token: string, baseUrl?: string): CohubHttpClient;

package/dist/client.js

@@ -0,0 +1,7 @@
+import { CohubHttpClient } from "@neta-art/cohub/http";
+export function createClient(token, baseUrl) {
+    return new CohubHttpClient({
+        baseUrl,
+        getAccessToken: () => token,
+    });
+}

package/dist/commands/auth.d.ts

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

package/dist/commands/auth.js

@@ -0,0 +1,51 @@
+import { resolveToken, saveToken, clearToken, tokenSource } from "../auth.js";
+import { createClient } from "../client.js";
+import { table, json as outJson, ok, error, spinner, handleHttp } from "../output.js";
+export function registerAuth(program) {
+    const auth = program.command("auth").description("Authentication management");
+    auth
+        .command("login <token>")
+        .description("Set auth token")
+        .action((token) => {
+        saveToken(token);
+        ok("Token saved to ~/.config/cohub/token");
+    });
+    auth
+        .command("whoami")
+        .description("Show current user info")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated", "Run 'cohub auth login <token>'");
+        const client = createClient(token);
+        const sp = spinner();
+        sp.start("Fetching user info");
+        try {
+            const user = await client.user.getMe();
+            sp.stop("Done");
+            if (opts.json)
+                return outJson(user);
+            const src = tokenSource();
+            const u = user;
+            console.log(`  Auth source: ${src}\n`);
+            table([u], [
+                { key: "id", label: "ID" },
+                { key: "name", label: "Name" },
+                { key: "email", label: "Email" },
+                { key: "created_at", label: "Created" },
+            ]);
+        }
+        catch (e) {
+            sp.stop("Failed");
+            handleHttp(e);
+        }
+    });
+    auth
+        .command("logout")
+        .description("Clear stored token")
+        .action(() => {
+        clearToken();
+        ok("Token cleared");
+    });
+}

package/dist/commands/channels.d.ts

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

package/dist/commands/channels.js

@@ -0,0 +1,84 @@
+import { resolveToken } from "../auth.js";
+import { createClient } from "../client.js";
+import { table, json as outJson, ok, error, handleHttp } from "../output.js";
+export function registerChannels(program) {
+    const cmd = program.command("channels").description("Channel management");
+    cmd
+        .command("ls")
+        .alias("list")
+        .description("List channels")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated", "Run 'cohub auth login <token>'");
+        const client = createClient(token);
+        try {
+            const items = await client.channels.list();
+            if (opts.json)
+                return outJson(items);
+            if (items.length === 0)
+                return console.log("  (empty)");
+            table(items, [
+                { key: "id", label: "ID" },
+                { key: "provider", label: "Provider" },
+                { key: "name", label: "Name" },
+                { key: "status", label: "Status" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cmd
+        .command("create")
+        .description("Create a channel")
+        .requiredOption("-p, --provider <provider>", "Channel provider")
+        .requiredOption("-n, --name <name>", "Channel name")
+        .option("--credentials <json>", "Credentials as JSON string")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated");
+        let credentials = {};
+        if (opts.credentials) {
+            try {
+                credentials = JSON.parse(opts.credentials);
+            }
+            catch {
+                return error("Invalid JSON", "--credentials must be valid JSON");
+            }
+        }
+        const client = createClient(token);
+        try {
+            const result = await client.channels.create({
+                provider: opts.provider,
+                name: opts.name,
+                credentials,
+            });
+            if (opts.json)
+                return outJson(result);
+            ok("Channel created");
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cmd
+        .command("delete <id>")
+        .description("Delete a channel")
+        .action(async (id) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated");
+        const client = createClient(token);
+        try {
+            await client.channels.delete(id);
+            ok(`Channel deleted: ${id}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}

package/dist/commands/cron-jobs.d.ts

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

package/dist/commands/cron-jobs.js

@@ -0,0 +1,136 @@
+import { resolveToken } from "../auth.js";
+import { createClient } from "../client.js";
+import { table, json as outJson, ok, error, handleHttp } from "../output.js";
+export function registerCronJobs(program) {
+    const cmd = program.command("cron-jobs").description("Cron job management");
+    cmd
+        .command("ls [spaceId]")
+        .alias("list")
+        .description("List cron jobs")
+        .option("--json", "Output as JSON")
+        .action(async (spaceId, opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated", "Run 'cohub auth login <token>'");
+        const client = createClient(token);
+        try {
+            const result = await client.cronJobs.list(spaceId);
+            if (opts.json)
+                return outJson(result);
+            if (result.jobs.length === 0)
+                return console.log("  (empty)");
+            table(result.jobs, [
+                { key: "id", label: "ID" },
+                { key: "title", label: "Title" },
+                { key: "cronExpression", label: "Schedule" },
+                { key: "enabled", label: "Enabled" },
+                { key: "spaceId", label: "Space" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cmd
+        .command("create")
+        .description("Create a cron job")
+        .requiredOption("-t, --title <title>", "Job title")
+        .requiredOption("--task-type <type>", "Task type")
+        .requiredOption("--cron <expression>", "Cron expression")
+        .option("--payload <json>", "Payload as JSON")
+        .option("--timezone <tz>", "Timezone", "UTC")
+        .option("--space <id>", "Space ID")
+        .option("--session <id>", "Session ID")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated");
+        let payload = {};
+        if (opts.payload) {
+            try {
+                payload = JSON.parse(opts.payload);
+            }
+            catch {
+                return error("Invalid JSON", "--payload must be valid JSON");
+            }
+        }
+        const client = createClient(token);
+        try {
+            const result = await client.cronJobs.create({
+                title: opts.title,
+                taskType: opts.taskType,
+                cronExpression: opts.cron,
+                payload,
+                timezone: opts.timezone,
+                spaceId: opts.space,
+                sessionId: opts.session,
+            });
+            if (opts.json)
+                return outJson(result);
+            ok(`Cron job created: ${result.id}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cmd
+        .command("delete <id>")
+        .description("Delete a cron job")
+        .action(async (id) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated");
+        const client = createClient(token);
+        try {
+            await client.cronJobs.delete(id);
+            ok(`Cron job deleted: ${id}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cmd
+        .command("toggle <id> <on|off>")
+        .description("Enable or disable a cron job")
+        .action(async (id, state) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated");
+        const enabled = state === "on";
+        const client = createClient(token);
+        try {
+            await client.cronJobs.toggle(id, enabled);
+            ok(`Cron job ${enabled ? "enabled" : "disabled"}: ${id}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cmd
+        .command("runs <id>")
+        .description("List cron job runs")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated");
+        const client = createClient(token);
+        try {
+            const result = await client.cronJobs.runs(id);
+            if (opts.json)
+                return outJson(result);
+            if (result.runs.length === 0)
+                return console.log("  (empty)");
+            table(result.runs, [
+                { key: "id", label: "ID" },
+                { key: "status", label: "Status" },
+                { key: "startedAt", label: "Started" },
+                { key: "finishedAt", label: "Finished" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}

package/dist/commands/models.d.ts

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

package/dist/commands/models.js

@@ -0,0 +1,34 @@
+import { resolveToken } from "../auth.js";
+import { createClient } from "../client.js";
+import { table, json as outJson, error, handleHttp } from "../output.js";
+export function registerModels(program) {
+    const cmd = program.command("models").description("Model management");
+    cmd
+        .command("ls")
+        .alias("list")
+        .description("List available models")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated", "Run 'cohub auth login <token>'");
+        const client = createClient(token);
+        try {
+            const catalog = await client.models.list();
+            if (opts.json)
+                return outJson(catalog);
+            // catalog is Record<provider, ModelCatalogEntry[]>
+            for (const [provider, entries] of Object.entries(catalog)) {
+                console.log(`\n  ${provider}`);
+                console.log("  " + "─".repeat(provider.length));
+                table(entries, [
+                    { key: "id", label: "ID" },
+                    { key: "provider", label: "Provider" },
+                ]);
+            }
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}

package/dist/commands/prompts.d.ts

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

package/dist/commands/prompts.js

@@ -0,0 +1,33 @@
+import { resolveToken } from "../auth.js";
+import { createClient } from "../client.js";
+import { table, json as outJson, error, handleHttp } from "../output.js";
+export function registerPrompts(program) {
+    const cmd = program.command("prompts").description("Prompt template management");
+    cmd
+        .command("ls")
+        .alias("list")
+        .description("List prompt templates")
+        .option("--space <id>", "Filter by space")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated", "Run 'cohub auth login <token>'");
+        const client = createClient(token);
+        try {
+            const result = await client.prompts.list({ spaceId: opts.space });
+            if (opts.json)
+                return outJson(result);
+            if (result.prompts.length === 0)
+                return console.log("  (empty)");
+            table(result.prompts, [
+                { key: "name", label: "Name" },
+                { key: "category", label: "Category" },
+                { key: "description", label: "Description" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}

package/dist/commands/session-access.d.ts

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

package/dist/commands/session-access.js

@@ -0,0 +1,72 @@
+import { resolveToken } from "../auth.js";
+import { createClient } from "../client.js";
+import { table, json as outJson, ok, error, handleHttp } from "../output.js";
+export function registerSessionAccess(program) {
+    const cmd = program
+        .command("session-access")
+        .description("Session-level access control");
+    cmd
+        .command("get <id>")
+        .description("Get session access policy")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated", "Run 'cohub auth login <token>'");
+        const client = createClient(token);
+        try {
+            const policy = await client.sessionAccess.get(id);
+            if (opts.json)
+                return outJson(policy);
+            table([policy], [
+                { key: "signed_in_user", label: "Signed-in" },
+                { key: "anonymous_user", label: "Anonymous" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cmd
+        .command("set <id>")
+        .description("Set session anonymous access")
+        .option("--anonymous <role>", "Anonymous role (host|builder|guest|null)")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated");
+        const client = createClient(token);
+        try {
+            const policy = await client.sessionAccess.set(id, {
+                anonymous_user: (opts.anonymous ?? null),
+            });
+            if (opts.json)
+                return outJson(policy);
+            ok("Session access updated");
+            table([policy], [
+                { key: "signed_in_user", label: "Signed-in" },
+                { key: "anonymous_user", label: "Anonymous" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    cmd
+        .command("remove <id>")
+        .description("Remove session access override")
+        .action(async (id) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated");
+        const client = createClient(token);
+        try {
+            await client.sessionAccess.remove(id);
+            ok(`Session access override removed: ${id}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}

package/dist/commands/spaces.d.ts

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