@neta-art/cohub-cli 6.4.0 → 6.5.0

package/README.md

@@ -133,8 +133,14 @@ List recent turns across all visible Sessions in a Space:
 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>
+cohub -s <spaceId> spaces turns intermediate <sessionId> <turnId>
+cohub -s <spaceId> spaces turns intermediate <sessionId> <turnId> --json
 ```
 
+When `--session` is provided, the CLI uses the same full turn endpoint as the
+Web session view. Intermediate messages are read from the turn's CDN archive;
+`--json` returns the archive without reducing its content blocks.
+
 Use `pageInfo.nextCursor` with `--cursor` to load older pages. Use a previous
 `snapshotCursor` with `--after` and an explicit `--before` boundary to query
 newer turns:

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

@@ -1,4 +1,4 @@
-import type { SpaceTurnListItem, SpaceTurnListOptions, SpaceTurnsResponse } from "@neta-art/cohub";
+import type { SpaceTurnListItem, SpaceTurnListOptions, SpaceTurnsResponse, SessionTurnRecord, TurnIntermediateMessagesFile } from "@neta-art/cohub";
 import type { Command } from "commander";
 import { type Row } from "../output.js";
 export type SpaceTurnListCliOptions = {
@@ -9,12 +9,30 @@ export type SpaceTurnListCliOptions = {
     limit?: string;
     session?: string;
     json?: boolean;
+    direction?: "older" | "newer";
 };
 type SpaceTurnsCommandClient = {
     space(spaceId: string): {
         turns: {
             list(options: SpaceTurnListOptions): Promise<SpaceTurnsResponse>;
         };
+        session(sessionId: string): {
+            turns: {
+                listPaginated(options?: {
+                    cursor?: number;
+                    limit?: number;
+                    direction?: "older" | "newer";
+                }): Promise<{
+                    session: unknown;
+                    turns: SessionTurnRecord[];
+                    hasMore: boolean;
+                    nextCursor: number | undefined;
+                }>;
+                intermediate: {
+                    get(turnId: string): Promise<TurnIntermediateMessagesFile | null>;
+                };
+            };
+        };
     };
 };
 export declare class InvalidSpaceTurnCliOptionsError extends Error {
@@ -22,6 +40,8 @@ export declare class InvalidSpaceTurnCliOptionsError extends Error {
     constructor(message: string, detail: string);
 }
 export declare function parseSpaceTurnListOptions(options: SpaceTurnListCliOptions): SpaceTurnListOptions;
+export declare function parseSessionTurnCursor(value: string | undefined): number | undefined;
+export declare function validateSpaceTurnListMode(options: SpaceTurnListCliOptions): void;
 export declare function toSpaceTurnRows(turns: SpaceTurnListItem[]): Row[];
 export declare function registerSpaceTurns(spacesCmd: Command, dependencies?: {
     createClient?: () => SpaceTurnsCommandClient;

package/dist/commands/space-turns.js

@@ -48,6 +48,23 @@ export function parseSpaceTurnListOptions(options) {
         sessionId: options.session,
     };
 }
+export function parseSessionTurnCursor(value) {
+    if (value === undefined)
+        return undefined;
+    const cursor = Number(value);
+    if (!Number.isSafeInteger(cursor) || cursor < 1) {
+        throw new InvalidSpaceTurnCliOptionsError("Invalid cursor", "Session cursor must be a positive turn sequence");
+    }
+    return cursor;
+}
+export function validateSpaceTurnListMode(options) {
+    if (!options.session && options.direction !== undefined) {
+        throw new InvalidSpaceTurnCliOptionsError("Invalid direction", "--direction only applies with --session");
+    }
+    if (options.session && (options.author || options.after || options.before)) {
+        throw new InvalidSpaceTurnCliOptionsError("Invalid session turn options", "--session uses the Session turns API; omit --author, --after, and --before");
+    }
+}
 export function toSpaceTurnRows(turns) {
     return turns.map((turn) => ({
         createdAt: turn.createdAt,
@@ -71,13 +88,14 @@ export function registerSpaceTurns(spacesCmd, dependencies = {}) {
     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")
+        .description("List turns in the space, or full turns from one session")
+        .option("--author <any|self|others>", "Filter space turns by author")
+        .option("--after <cursor>", "Start after a previous snapshot cursor")
+        .option("--before <timestamp>", "End at an ISO 8601 timestamp")
+        .option("--cursor <cursor>", "Page cursor; with --session, use a turn sequence")
+        .option("--limit <n>", "Maximum turns per page, 1-100")
+        .option("--session <id>", "Use the full turn list for this session")
+        .option("--direction <older|newer>", "Session page direction; use with --session")
         .option("--json", "Output as JSON")
         .action(async (options) => {
         let query;
@@ -93,6 +111,45 @@ export function registerSpaceTurns(spacesCmd, dependencies = {}) {
         const spaceId = resolveSpace(spacesCmd);
         const client = dependencies.createClient?.() ?? createClient();
         try {
+            try {
+                validateSpaceTurnListMode(options);
+            }
+            catch (cause) {
+                if (cause instanceof InvalidSpaceTurnCliOptionsError)
+                    return error(cause.message, cause.detail);
+                throw cause;
+            }
+            if (options.session) {
+                let sessionCursor;
+                try {
+                    sessionCursor = parseSessionTurnCursor(options.cursor);
+                }
+                catch (cause) {
+                    if (cause instanceof InvalidSpaceTurnCliOptionsError)
+                        return error(cause.message, cause.detail);
+                    throw cause;
+                }
+                const result = await client.space(spaceId).session(options.session).turns.listPaginated({
+                    cursor: sessionCursor,
+                    limit: query.limit,
+                    direction: options.direction,
+                });
+                if (jsonRequested(options))
+                    return outJson(result);
+                if (result.turns.length === 0)
+                    return console.log("  No turns found");
+                table(result.turns, [
+                    { key: "sequence", label: "Seq" },
+                    { key: "id", label: "Turn ID" },
+                    { key: "status", label: "Status" },
+                    { key: "userText", label: "User" },
+                    { key: "assistantText", label: "Assistant" },
+                    { key: "updatedAt", label: "Updated" },
+                ]);
+                if (result.hasMore)
+                    console.log(`\n  More turns available - next cursor: ${result.nextCursor}`);
+                return;
+            }
             const result = await client.space(spaceId).turns.list(query);
             if (jsonRequested(options))
                 return outJson(result);
@@ -117,5 +174,32 @@ export function registerSpaceTurns(spacesCmd, dependencies = {}) {
             handleHttp(cause);
         }
     });
+    turnsCmd
+        .command("intermediate <sessionId> <turnId>")
+        .description("Read persisted intermediate messages from the CDN archive")
+        .option("--json", "Output as JSON")
+        .action(async (sessionId, turnId, options) => {
+        const spaceId = resolveSpace(spacesCmd);
+        const client = dependencies.createClient?.() ?? createClient();
+        try {
+            const archive = await client.space(spaceId).session(sessionId).turns.intermediate.get(turnId);
+            if (jsonRequested(options))
+                return outJson(archive);
+            if (!archive)
+                return console.log("  No intermediate messages found");
+            console.log(`Turn ${archive.turnId}`);
+            console.log(`  ${archive.summary.messageCount} intermediate messages · ${archive.summary.toolCallCount} tool calls`);
+            for (const [index, message] of archive.messages.entries()) {
+                console.log(`\n${index + 1}. ${message.role}${message.provider ? ` · ${message.provider}/${message.model ?? ""}` : ""}`);
+                if (message.text)
+                    console.log(message.text);
+                if (message.toolCallsObjectKey)
+                    console.log("  Tool calls: available");
+            }
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
     return turnsCmd;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "6.4.0",
+  "version": "6.5.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.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.7.0"
+    "@neta-art/cohub": "8.8.0"
   },
   "publishConfig": {
     "access": "public"