@neta-art/cohub-cli 3.1.6 → 3.3.0

package/README.md

@@ -65,6 +65,9 @@ COHUB_SPACE_ID=<spaceId> cohub spaces get
 cohub spaces create --name "<name>" --description "<description>" --json
 cohub spaces update <spaceId> --slug <space-slug>
 cohub spaces rename <spaceId> "<new name>"
+cohub -s <spaceId> spaces invites create --role builder --days 7
+cohub -s <spaceId> spaces invites ls
+cohub -s <spaceId> spaces invites revoke <code> --yes
 cohub -s <spaceId> run -- git status
 ```
 
@@ -121,6 +124,25 @@ cohub -s <spaceId> spaces sessions rename <sessionId> "<new title>"
 
 Use `spaces prompt --session <sessionId>` to send to a Chat.
 
+## Space turns
+
+List recent turns across all visible Sessions in a Space:
+
+```bash
+cohub -s <spaceId> spaces turns ls
+cohub -s <spaceId> spaces turns ls --author others --limit 50 --json
+cohub -s <spaceId> spaces turns ls --session <sessionId>
+```
+
+Use `pageInfo.nextCursor` with `--cursor` to load older pages. Use a previous
+`snapshotCursor` with `--after` and an explicit `--before` boundary to query
+newer turns:
+
+```bash
+cohub -s <spaceId> spaces turns ls --cursor <nextCursor> --json
+cohub -s <spaceId> spaces turns ls --after <snapshotCursor> --before <snapshotAt> --json
+```
+
 ## Boards
 
 Board commands use the selected Space and support `-h` at every level:

package/dist/commands/space-invitations.d.ts

@@ -0,0 +1,28 @@
+import { type CreateInvitationInput, type CreateInvitationResponse, type SpaceInvitationListResponse } from "@neta-art/cohub";
+import type { Command } from "commander";
+export type SpaceInvitationCreateCliOptions = {
+    role?: string;
+    days?: string;
+    maxUses?: string;
+    json?: boolean;
+};
+type SpaceInvitationCommandClient = {
+    space(spaceId: string): {
+        invitations: {
+            list(): Promise<SpaceInvitationListResponse>;
+            create(input: CreateInvitationInput): Promise<CreateInvitationResponse>;
+            revoke(token: string): Promise<{
+                ok: true;
+            }>;
+        };
+    };
+};
+export declare class InvalidSpaceInvitationCliOptionsError extends Error {
+    readonly detail: string;
+    constructor(message: string, detail: string);
+}
+export declare function parseSpaceInvitationCreateOptions(options: SpaceInvitationCreateCliOptions): Required<Pick<CreateInvitationInput, "role" | "ttlSeconds" | "maxUses">>;
+export declare function registerSpaceInvitations(spacesCommand: Command, dependencies?: {
+    createClient: () => SpaceInvitationCommandClient;
+}): Command;
+export {};

package/dist/commands/space-invitations.js

@@ -0,0 +1,168 @@
+import { buildSpaceInvitePath, } from "@neta-art/cohub";
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, jsonRequested, ok, table, } from "../output.js";
+import { resolveSpace } from "../space.js";
+const SPACE_ROLES = ["host", "builder", "guest"];
+const DEFAULT_DAYS = 7;
+const MAX_DAYS = 30;
+const MAX_USES = 10_000;
+export class InvalidSpaceInvitationCliOptionsError extends Error {
+    detail;
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+        this.name = "InvalidSpaceInvitationCliOptionsError";
+    }
+}
+function parseInteger(value, label, min, max) {
+    if (!/^\d+$/.test(value.trim())) {
+        throw new InvalidSpaceInvitationCliOptionsError(`Invalid ${label}`, `${label} must be an integer from ${min} to ${max}`);
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(parsed) || parsed < min || parsed > max) {
+        throw new InvalidSpaceInvitationCliOptionsError(`Invalid ${label}`, `${label} must be an integer from ${min} to ${max}`);
+    }
+    return parsed;
+}
+export function parseSpaceInvitationCreateOptions(options) {
+    const role = (options.role ?? "builder");
+    if (!SPACE_ROLES.includes(role)) {
+        throw new InvalidSpaceInvitationCliOptionsError("Invalid role", `Use one of: ${SPACE_ROLES.join(", ")}`);
+    }
+    const days = parseInteger(options.days ?? String(DEFAULT_DAYS), "days", 1, MAX_DAYS);
+    const maxUses = parseInteger(options.maxUses ?? "0", "max uses", 0, MAX_USES);
+    return { role, ttlSeconds: days * 24 * 60 * 60, maxUses };
+}
+function invitationUrl(invitation) {
+    const origin = process.env.COHUB_WEB_URL?.replace(/\/+$/, "") ?? "https://cohub.run";
+    return `${origin}${buildSpaceInvitePath({
+        spaceId: invitation.spaceId,
+        ownerUsername: invitation.ownerUsername,
+        spaceSlug: invitation.spaceSlug,
+        inviteCode: invitation.token,
+    })}`;
+}
+async function confirmRevoke(options) {
+    if (options.yes)
+        return;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return error("Confirmation required", "Pass --yes to revoke the invite link.");
+    }
+    process.stdout.write("This invite link will stop working. Continue? [y/N] ");
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+        break;
+    }
+    const answer = Buffer.concat(chunks).toString().trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes")
+        return error("Cancelled");
+}
+export function registerSpaceInvitations(spacesCommand, dependencies = {
+    createClient,
+}) {
+    const invitations = spacesCommand
+        .command("invites")
+        .description("Create and manage space invite links");
+    invitations
+        .command("create")
+        .description("Create an invite link")
+        .option("--role <role>", "Member role: host, builder, or guest", "builder")
+        .option("--days <days>", "Validity in days, from 1 to 30", String(DEFAULT_DAYS))
+        .option("--max-uses <count>", "Usage limit, or 0 for unlimited", "0")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        const spaceId = resolveSpace(spacesCommand);
+        let input;
+        try {
+            input = parseSpaceInvitationCreateOptions(options);
+        }
+        catch (cause) {
+            if (cause instanceof InvalidSpaceInvitationCliOptionsError) {
+                return error(cause.message, cause.detail);
+            }
+            throw cause;
+        }
+        try {
+            const created = await dependencies
+                .createClient()
+                .space(spaceId)
+                .invitations.create(input);
+            const output = {
+                ...created,
+                url: invitationUrl({
+                    ...created,
+                    spaceId: created.spaceId || spaceId,
+                    ownerUsername: created.ownerUsername ?? null,
+                    spaceSlug: created.spaceSlug ?? null,
+                }),
+            };
+            if (jsonRequested(options))
+                return outJson(output);
+            ok(`Invite link created: ${output.url}`);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    invitations
+        .command("ls")
+        .alias("list")
+        .description("List invite links")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        const spaceId = resolveSpace(spacesCommand);
+        try {
+            const result = await dependencies
+                .createClient()
+                .space(spaceId)
+                .invitations.list();
+            const items = result.items.map((item) => ({
+                ...item,
+                url: invitationUrl({
+                    ...result,
+                    token: item.token,
+                    spaceId: result.spaceId || spaceId,
+                    ownerUsername: result.ownerUsername ?? null,
+                    spaceSlug: result.spaceSlug ?? null,
+                }),
+                uses: item.maxUses ? `${item.useCount}/${item.maxUses}` : String(item.useCount),
+            }));
+            if (jsonRequested(options))
+                return outJson({ ...result, items });
+            table(items, [
+                { key: "token", label: "Code" },
+                { key: "role", label: "Role" },
+                { key: "status", label: "Status" },
+                { key: "uses", label: "Uses" },
+                { key: "expiresInSeconds", label: "Expires in" },
+                { key: "url", label: "URL" },
+            ]);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    invitations
+        .command("revoke <code>")
+        .description("Revoke an invite link")
+        .option("-y, --yes", "Confirm revocation")
+        .option("--json", "Output as JSON")
+        .action(async (code, options) => {
+        await confirmRevoke(options);
+        const spaceId = resolveSpace(spacesCommand);
+        try {
+            const result = await dependencies
+                .createClient()
+                .space(spaceId)
+                .invitations.revoke(code);
+            if (jsonRequested(options))
+                return outJson(result);
+            ok("Invite link revoked");
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    return invitations;
+}

package/dist/commands/space-turns.d.ts

@@ -0,0 +1,29 @@
+import type { SpaceTurnListItem, SpaceTurnListOptions, SpaceTurnsResponse } from "@neta-art/cohub";
+import type { Command } from "commander";
+import { type Row } from "../output.js";
+export type SpaceTurnListCliOptions = {
+    author?: string;
+    after?: string;
+    before?: string;
+    cursor?: string;
+    limit?: string;
+    session?: string;
+    json?: boolean;
+};
+type SpaceTurnsCommandClient = {
+    space(spaceId: string): {
+        turns: {
+            list(options: SpaceTurnListOptions): Promise<SpaceTurnsResponse>;
+        };
+    };
+};
+export declare class InvalidSpaceTurnCliOptionsError extends Error {
+    readonly detail: string;
+    constructor(message: string, detail: string);
+}
+export declare function parseSpaceTurnListOptions(options: SpaceTurnListCliOptions): SpaceTurnListOptions;
+export declare function toSpaceTurnRows(turns: SpaceTurnListItem[]): Row[];
+export declare function registerSpaceTurns(spacesCmd: Command, dependencies?: {
+    createClient?: () => SpaceTurnsCommandClient;
+}): Command;
+export {};

package/dist/commands/space-turns.js

@@ -0,0 +1,121 @@
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, jsonRequested, table, } from "../output.js";
+import { resolveSpace } from "../space.js";
+const SPACE_TURN_AUTHORS = ["any", "self", "others"];
+export class InvalidSpaceTurnCliOptionsError extends Error {
+    detail;
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+        this.name = "InvalidSpaceTurnCliOptionsError";
+    }
+}
+function parseAuthor(value) {
+    if (value === undefined)
+        return undefined;
+    if (SPACE_TURN_AUTHORS.includes(value)) {
+        return value;
+    }
+    throw new InvalidSpaceTurnCliOptionsError("Invalid author", `Use one of: ${SPACE_TURN_AUTHORS.join(", ")}`);
+}
+function parseLimit(value) {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value.trim())) {
+        throw new InvalidSpaceTurnCliOptionsError("Invalid limit", "limit must be an integer from 1 to 100");
+    }
+    const limit = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
+        throw new InvalidSpaceTurnCliOptionsError("Invalid limit", "limit must be an integer from 1 to 100");
+    }
+    return limit;
+}
+function parseBefore(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value.trim() || Number.isNaN(new Date(value).getTime())) {
+        throw new InvalidSpaceTurnCliOptionsError("Invalid before", "before must be an ISO 8601 timestamp");
+    }
+    return value;
+}
+export function parseSpaceTurnListOptions(options) {
+    return {
+        author: parseAuthor(options.author),
+        after: options.after,
+        before: parseBefore(options.before),
+        cursor: options.cursor,
+        limit: parseLimit(options.limit),
+        sessionId: options.session,
+    };
+}
+export function toSpaceTurnRows(turns) {
+    return turns.map((turn) => ({
+        createdAt: turn.createdAt,
+        author: turn.authorProfile?.displayName ?? turn.userUuid ?? "system",
+        sessionTitle: turn.session.title ?? "",
+        sessionId: turn.session.id,
+        sequence: turn.sequence,
+        id: turn.id,
+        status: turn.status,
+        userPreview: turn.userPreview ?? "",
+        assistantPreview: turn.assistantPreview ?? "",
+    }));
+}
+export function registerSpaceTurns(spacesCmd, dependencies = {}) {
+    const turnsCmd = spacesCmd
+        .command("turns")
+        .description("Browse turns across the space")
+        .hook("preAction", () => {
+        resolveSpace(spacesCmd);
+    });
+    turnsCmd
+        .command("ls")
+        .alias("list")
+        .description("List recent turns across sessions")
+        .option("--author <any|self|others>", "Filter turns by author")
+        .option("--after <cursor>", "Only turns after a snapshot cursor")
+        .option("--before <timestamp>", "Only turns at or before an ISO 8601 timestamp")
+        .option("--cursor <cursor>", "Older-page cursor from a previous result")
+        .option("--limit <n>", "Page size, from 1 to 100")
+        .option("--session <id>", "Only turns from this session")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        let query;
+        try {
+            query = parseSpaceTurnListOptions(options);
+        }
+        catch (cause) {
+            if (cause instanceof InvalidSpaceTurnCliOptionsError) {
+                return error(cause.message, cause.detail);
+            }
+            throw cause;
+        }
+        const spaceId = resolveSpace(spacesCmd);
+        const client = dependencies.createClient?.() ?? createClient();
+        try {
+            const result = await client.space(spaceId).turns.list(query);
+            if (jsonRequested(options))
+                return outJson(result);
+            if (result.turns.length === 0)
+                return console.log("  No turns found");
+            table(toSpaceTurnRows(result.turns), [
+                { key: "createdAt", label: "Created" },
+                { key: "author", label: "Author" },
+                { key: "sessionTitle", label: "Session" },
+                { key: "sessionId", label: "Session ID" },
+                { key: "sequence", label: "Seq" },
+                { key: "id", label: "Turn ID" },
+                { key: "status", label: "Status" },
+                { key: "userPreview", label: "User" },
+                { key: "assistantPreview", label: "Assistant" },
+            ]);
+            if (result.pageInfo.hasMore && result.pageInfo.nextCursor) {
+                console.log(`\n  More turns available - next cursor: ${result.pageInfo.nextCursor}`);
+            }
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    return turnsCmd;
+}

package/dist/commands/spaces.js

@@ -8,6 +8,8 @@ import { createClient } from "../client.js";
 import { table, json as outJson, jsonRequested, ok, error, handleHttp } from "../output.js";
 import { resolveSpace } from "../space.js";
 import { registerSpaceCommerce } from "./space-commerce.js";
+import { registerSpaceInvitations } from "./space-invitations.js";
+import { registerSpaceTurns } from "./space-turns.js";
 const cliEnv = resolveCohubEnvironment();
 const defaultIdleTtlSeconds = cliEnv === "prod" ? 12 * 60 * 60 : 10 * 60;
 const SPACE_ROLES = ["host", "builder", "guest"];
@@ -376,6 +378,7 @@ export function registerPrompt(program) {
 }
 export function registerSpaces(program) {
     const spacesCmd = program.command("spaces").description("Space management");
+    registerSpaceInvitations(spacesCmd);
     // ── spaces ls ──
     spacesCmd
         .command("ls")
@@ -609,6 +612,8 @@ export function registerSpaces(program) {
     registerFiles(spacesCmd);
     // ── spaces sessions ──
     registerSessions(spacesCmd);
+    // ── spaces turns ──
+    registerSpaceTurns(spacesCmd);
     // ── spaces members ──
     registerMembers(spacesCmd);
     // ── spaces access ──

package/dist/index.js

@@ -50,6 +50,7 @@ Common commands:
   cohub sandbox up ./my-project
   cohub search "release notes"
   cohub -s <space-id> boards inspect <board-id>
+  cohub -s <space-id> spaces turns ls --author others
   cohub -s <space-id> spaces sessions turns ls <session-id>
   cohub -s <space-id> spaces files ls
   cohub -s <space-id> works publish demo --file dist/index.html

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "3.1.6",
+  "version": "3.3.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "Apache-2.0",
@@ -19,7 +19,7 @@
     "commander": "^15.0.0",
     "pixi.js": "^8.19.0",
     "sharp": "^0.35.3",
-    "@neta-art/cohub": "4.3.0"
+    "@neta-art/cohub": "4.5.0"
   },
   "publishConfig": {
     "access": "public"