@getpaseo/cli 0.3.1 → 0.4.0-beta.2

package/dist/commands/hub/hub-client/internal/problem.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { HubCommandError } from "../../error.js";
+const issuePathSchema = z.union([z.string(), z.array(z.union([z.string(), z.number()]))]);
+const fieldIssueSchema = z.object({
+    field: z.string().optional(),
+    path: issuePathSchema.optional(),
+    message: z.string(),
+});
+const problemSchema = z.object({
+    type: z.string().optional(),
+    title: z.string().optional(),
+    status: z.number().int().optional(),
+    detail: z.string().optional(),
+    instance: z.string().optional(),
+    errors: z
+        .union([z.array(fieldIssueSchema), z.record(z.string(), z.array(z.string()))])
+        .optional(),
+    issues: z.array(fieldIssueSchema).optional(),
+});
+export async function hubRequestFailure(response, failureMessage, apiKey) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().includes("application/problem+json")) {
+        return new HubCommandError("HUB_REQUEST_FAILED", `${failureMessage} with HTTP ${response.status}.`);
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        return new HubCommandError("HUB_INVALID_RESPONSE", `Hub returned malformed problem details for HTTP ${response.status}.`);
+    }
+    const parsed = problemSchema.safeParse(body);
+    if (!parsed.success ||
+        (parsed.data.status !== undefined && parsed.data.status !== response.status)) {
+        return new HubCommandError("HUB_INVALID_RESPONSE", `Hub returned nonconforming problem details for HTTP ${response.status}.`);
+    }
+    const title = parsed.data.title ?? `${failureMessage} with HTTP ${response.status}`;
+    const message = parsed.data.detail === undefined ? title : `${title}: ${parsed.data.detail}`;
+    const details = formatFieldIssues(parsed.data.errors, parsed.data.issues);
+    const code = response.status === 422 ? "HUB_VALIDATION_FAILED" : "HUB_REQUEST_FAILED";
+    return new HubCommandError(code, redactSecret(message, apiKey), details === undefined ? undefined : redactSecret(details, apiKey));
+}
+function formatFieldIssues(errors, issues) {
+    const fieldIssues = Array.isArray(errors) ? errors : issues;
+    if (fieldIssues !== undefined) {
+        const lines = fieldIssues.map((issue) => {
+            const field = issue.field ?? formatIssuePath(issue.path);
+            return field === undefined ? issue.message : `${field}: ${issue.message}`;
+        });
+        return lines.length === 0 ? undefined : lines.join("\n");
+    }
+    if (errors === undefined)
+        return undefined;
+    const lines = Object.entries(errors).flatMap(([field, messages]) => messages.map((message) => `${field}: ${message}`));
+    return lines.length === 0 ? undefined : lines.join("\n");
+}
+function formatIssuePath(path) {
+    if (path === undefined || typeof path === "string")
+        return path;
+    let formatted = "";
+    for (const segment of path) {
+        if (typeof segment === "number")
+            formatted += `[${segment}]`;
+        else
+            formatted += formatted.length === 0 ? segment : `.${segment}`;
+    }
+    return formatted || undefined;
+}
+function redactSecret(value, secret) {
+    return secret === undefined ? value : value.split(secret).join("[redacted]");
+}
+//# sourceMappingURL=problem.js.map

package/dist/commands/hub/hub-client/internal/transport.d.ts

@@ -0,0 +1,15 @@
+import type { z } from "zod";
+interface HubRequest<T> {
+    origin: string;
+    path: string;
+    method: "GET" | "POST";
+    apiKey?: string;
+    body?: unknown;
+    successStatus: number;
+    schema: z.ZodType<T>;
+    timeoutMilliseconds?: number;
+    failureMessage: string;
+}
+export declare function requestHub<T>(input: HubRequest<T>): Promise<T>;
+export {};
+//# sourceMappingURL=transport.d.ts.map

package/dist/commands/hub/hub-client/internal/transport.js

@@ -0,0 +1,30 @@
+import { HubCommandError } from "../../error.js";
+import { hubRequestFailure } from "./problem.js";
+export async function requestHub(input) {
+    const signal = AbortSignal.timeout(input.timeoutMilliseconds ?? 15000);
+    let response;
+    try {
+        response = await fetch(`${input.origin}${input.path}`, {
+            method: input.method,
+            headers: {
+                ...(input.apiKey === undefined ? {} : { authorization: `Bearer ${input.apiKey}` }),
+                ...(input.body === undefined ? {} : { "content-type": "application/json" }),
+            },
+            ...(input.body === undefined ? {} : { body: JSON.stringify(input.body) }),
+            signal,
+        });
+    }
+    catch {
+        throw new HubCommandError("HUB_NETWORK_ERROR", `Could not reach Paseo Hub at ${input.origin}. Check the Hub URL and network connection.`);
+    }
+    if (response.status !== input.successStatus) {
+        throw await hubRequestFailure(response, input.failureMessage, input.apiKey);
+    }
+    try {
+        return input.schema.parse(await response.json());
+    }
+    catch {
+        throw new HubCommandError("HUB_INVALID_RESPONSE", "Hub returned a malformed response.");
+    }
+}
+//# sourceMappingURL=transport.js.map

package/dist/commands/hub/index.d.ts

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { HubHttpClient } from "./client.js";
+import { HubHttpClient } from "./hub-client/index.js";
 import { type HubCredentialStore } from "./credentials.js";
 import { type HubDaemonConnection } from "./daemon-client.js";
 import { type CliLoginFlow } from "./login-flow.js";

package/dist/commands/hub/index.js

@@ -1,7 +1,7 @@
 import { Command } from "commander";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
-import { HubHttpClient } from "./client.js";
+import { HubHttpClient } from "./hub-client/index.js";
 import { addHubConnectCommand } from "./connect.js";
 import { PrivateHubCredentialStore } from "./credentials.js";
 import { productionHubDaemonConnection, withHubDaemon, } from "./daemon-client.js";

package/dist/commands/hub/login-flow.d.ts

@@ -1,4 +1,4 @@
-import type { HubHttpClient } from "./client.js";
+import type { HubHttpClient } from "./hub-client/index.js";
 export interface LoginWaiter {
     wait(milliseconds: number): Promise<void>;
     now(): number;

package/dist/commands/hub/projects.d.ts

@@ -1,6 +1,6 @@
 import type { Command } from "commander";
 import { type SingleResult } from "../../output/index.js";
-import type { HubHttpClient, HubProject } from "./client.js";
+import type { HubHttpClient, HubProject } from "./hub-client/index.js";
 import type { HubCredentialStore } from "./credentials.js";
 import { type HubReporter } from "./reporter.js";
 interface HubProjectsResult {

package/dist/commands/provider/diagnostic.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+export interface ProviderDiagnosticResult {
+    provider: string;
+    diagnostic: string;
+}
+export declare const providerDiagnosticSchema: OutputSchema<ProviderDiagnosticResult>;
+export interface ProviderDiagnosticOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runDiagnosticCommand(provider: string, options: ProviderDiagnosticOptions, _command: Command): Promise<SingleResult<ProviderDiagnosticResult>>;
+//# sourceMappingURL=diagnostic.d.ts.map

package/dist/commands/provider/diagnostic.js

@@ -0,0 +1,31 @@
+import { connectToDaemon } from "../../utils/client.js";
+export const providerDiagnosticSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider" },
+        { header: "DIAGNOSTIC", field: "diagnostic" },
+    ],
+    renderHuman(result) {
+        if (result.type === "single")
+            return result.data.diagnostic;
+        return result.data.map((entry) => entry.diagnostic).join("\n\n");
+    },
+};
+export async function runDiagnosticCommand(provider, options, _command) {
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const result = await client.getProviderDiagnostic(provider.trim().toLowerCase());
+        return {
+            type: "single",
+            data: {
+                provider: result.provider,
+                diagnostic: result.diagnostic,
+            },
+            schema: providerDiagnosticSchema,
+        };
+    }
+    finally {
+        await client.close();
+    }
+}
+//# sourceMappingURL=diagnostic.js.map

package/dist/commands/provider/index.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { runLsCommand } from "./ls.js";
 import { runModelsCommand } from "./models.js";
+import { runDiagnosticCommand } from "./diagnostic.js";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
 export function createProviderCommand() {
@@ -11,6 +12,10 @@ export function createProviderCommand() {
         .description("List models for a provider")
         .argument("<provider>", "Provider name (claude, codex, opencode)")
         .option("--thinking", "Include thinking option IDs for each model")).action(withOutput(runModelsCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("diagnostic")
+        .description("Show provider installation, environment, and availability diagnostics")
+        .argument("<provider>", "Provider name")).action(withOutput(runDiagnosticCommand));
     return provider;
 }
 //# sourceMappingURL=index.js.map

package/dist/commands/workspace/index.js

@@ -4,6 +4,7 @@ import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
 import { runArchiveCommand } from "./archive.js";
 import { runCreateCommand } from "./create.js";
 import { runLsCommand } from "./ls.js";
+import { runRenameCommand } from "./rename.js";
 export function createWorkspaceCommand() {
     const workspace = new Command("workspace").description("Manage workspaces");
     addJsonAndDaemonHostOptions(workspace
@@ -21,6 +22,15 @@ export function createWorkspaceCommand() {
         .option("--pr-number <n>", "Pull request or change request number (--mode checkout-pr)")
         .option("--forge <forge>", "Forge for --mode checkout-pr (default: source checkout)")).action(withOutput(runCreateCommand));
     addJsonAndDaemonHostOptions(workspace.command("ls").description("List active workspaces")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(workspace
+        .command("rename")
+        .description("Set a workspace's user-visible title")
+        .argument("<workspace-id>", "Workspace id")
+        .argument("[title]", "New workspace title")
+        .option("--reset", "Clear the title and revert to the branch or directory name")
+        // Commander 12 accepts excess positionals by default, which would rename to
+        // the first word of an unquoted multi-word title and silently drop the rest.
+        .allowExcessArguments(false)).action(withOutput(runRenameCommand));
     addJsonAndDaemonHostOptions(workspace
         .command("archive")
         .description("Archive a workspace and everything it owns")

package/dist/commands/workspace/rename.d.ts

@@ -0,0 +1,22 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+interface WorkspaceRenameResult {
+    workspaceId: string;
+    /** Raw title override; null once it has been reset to the derived name. */
+    title: string | null;
+}
+export interface WorkspaceRenameOptions {
+    host?: string;
+    reset?: boolean;
+}
+/**
+ * Resolve the title to send to the daemon. Null clears the override and
+ * reverts the workspace to its branch- or directory-derived name.
+ */
+export declare function resolveWorkspaceTitle(input: {
+    title?: string;
+    reset?: boolean;
+}): string | null;
+export declare function runRenameCommand(workspaceId: string, titleArg: string | undefined, options: WorkspaceRenameOptions, _command: Command): Promise<SingleResult<WorkspaceRenameResult>>;
+export {};
+//# sourceMappingURL=rename.d.ts.map

package/dist/commands/workspace/rename.js

@@ -0,0 +1,61 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+const workspaceRenameSchema = {
+    idField: "workspaceId",
+    columns: [
+        { header: "WORKSPACE ID", field: "workspaceId", width: 20 },
+        { header: "TITLE", field: "title", width: 30 },
+    ],
+};
+/**
+ * Resolve the title to send to the daemon. Null clears the override and
+ * reverts the workspace to its branch- or directory-derived name.
+ */
+export function resolveWorkspaceTitle(input) {
+    const title = input.title?.trim() ?? "";
+    if (input.reset) {
+        if (input.title !== undefined) {
+            throw {
+                code: "INVALID_OPTIONS",
+                message: "--reset cannot be combined with a title",
+                details: "Pass a title to rename the workspace, or --reset to revert to the derived name",
+            };
+        }
+        return null;
+    }
+    if (title.length === 0) {
+        throw {
+            code: "MISSING_TITLE",
+            message: "Title cannot be empty",
+            details: "Usage: paseo workspace rename <workspace-id> <title> | --reset",
+        };
+    }
+    return title;
+}
+export async function runRenameCommand(workspaceId, titleArg, options, _command) {
+    const title = resolveWorkspaceTitle({ title: titleArg, reset: options.reset });
+    const host = getDaemonHost({ host: options.host });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+    });
+    try {
+        const applied = await client.setWorkspaceTitle(workspaceId, title);
+        return {
+            type: "single",
+            data: { workspaceId, title: applied.title },
+            schema: workspaceRenameSchema,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "WORKSPACE_RENAME_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=rename.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.3.1",
+  "version": "0.4.0-beta.2",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.3.1",
-    "@getpaseo/protocol": "0.3.1",
-    "@getpaseo/server": "0.3.1",
+    "@getpaseo/client": "0.4.0-beta.2",
+    "@getpaseo/protocol": "0.4.0-beta.2",
+    "@getpaseo/server": "0.4.0-beta.2",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",

package/dist/commands/chat/create.d.ts

@@ -1,9 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatRoomRow } from "./schema.js";
-export interface ChatCreateOptions extends ChatCommandOptions {
-    purpose?: string;
-}
-export declare function runCreateCommand(name: string, options: ChatCreateOptions, _command: Command): Promise<SingleResult<ChatRoomRow>>;
-//# sourceMappingURL=create.d.ts.map

package/dist/commands/chat/create.js

@@ -1,23 +0,0 @@
-import { connectChatClient, toChatCommandError } from "./shared.js";
-import { chatRoomSchema, toChatRoomRow } from "./schema.js";
-export async function runCreateCommand(name, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.createChatRoom({
-            name,
-            purpose: options.purpose,
-        });
-        return {
-            type: "single",
-            data: toChatRoomRow(payload.room),
-            schema: chatRoomSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_CREATE_FAILED", "create chat room", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=create.js.map

package/dist/commands/chat/delete.d.ts

@@ -1,6 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatRoomRow } from "./schema.js";
-export declare function runDeleteCommand(room: string, options: ChatCommandOptions, _command: Command): Promise<SingleResult<ChatRoomRow>>;
-//# sourceMappingURL=delete.d.ts.map

package/dist/commands/chat/delete.js

@@ -1,20 +0,0 @@
-import { connectChatClient, toChatCommandError } from "./shared.js";
-import { chatRoomSchema, toChatRoomRow } from "./schema.js";
-export async function runDeleteCommand(room, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.deleteChatRoom({ room });
-        return {
-            type: "single",
-            data: toChatRoomRow(payload.room),
-            schema: chatRoomSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_DELETE_FAILED", "delete chat room", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=delete.js.map

package/dist/commands/chat/index.d.ts

@@ -1,3 +0,0 @@
-import { Command } from "commander";
-export declare function createChatCommand(): Command;
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/chat/index.js

@@ -1,47 +0,0 @@
-import { Command } from "commander";
-import { withOutput } from "../../output/index.js";
-import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
-import { runCreateCommand } from "./create.js";
-import { runLsCommand } from "./ls.js";
-import { runInspectCommand } from "./inspect.js";
-import { runDeleteCommand } from "./delete.js";
-import { runPostCommand } from "./post.js";
-import { runReadCommand } from "./read.js";
-import { runWaitCommand } from "./wait.js";
-export function createChatCommand() {
-    const chat = new Command("chat").description("Manage chat rooms for agent coordination");
-    addJsonAndDaemonHostOptions(chat
-        .command("create")
-        .description("Create a chat room")
-        .argument("<name>", "Room name (must be unique)")
-        .option("--purpose <text>", "Room purpose/description")).action(withOutput(runCreateCommand));
-    addJsonAndDaemonHostOptions(chat.command("ls").description("List chat rooms")).action(withOutput(runLsCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("inspect")
-        .description("Inspect a chat room")
-        .argument("<name-or-id>", "Room name or ID")).action(withOutput(runInspectCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("delete")
-        .description("Delete a chat room")
-        .argument("<name-or-id>", "Room name or ID")).action(withOutput(runDeleteCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("post")
-        .description("Post a chat message")
-        .argument("<name-or-id>", "Room name or ID")
-        .argument("<message>", "Message body")
-        .option("--reply-to <msg-id>", "Reply to a specific message ID")).action(withOutput(runPostCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("read")
-        .description("Read chat messages")
-        .argument("<name-or-id>", "Room name or ID")
-        .option("--limit <n>", "Maximum number of messages to return")
-        .option("--since <duration-or-timestamp>", "Filter by relative duration or ISO timestamp")
-        .option("--agent <agent-id>", "Filter by author agent ID")).action(withOutput(runReadCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("wait")
-        .description("Wait for new chat messages")
-        .argument("<name-or-id>", "Room name or ID")
-        .option("--timeout <duration>", "Maximum wait time")).action(withOutput(runWaitCommand));
-    return chat;
-}
-//# sourceMappingURL=index.js.map

package/dist/commands/chat/inspect.d.ts

@@ -1,6 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatRoomRow } from "./schema.js";
-export declare function runInspectCommand(room: string, options: ChatCommandOptions, _command: Command): Promise<SingleResult<ChatRoomRow>>;
-//# sourceMappingURL=inspect.d.ts.map

package/dist/commands/chat/inspect.js

@@ -1,20 +0,0 @@
-import { connectChatClient, toChatCommandError } from "./shared.js";
-import { chatRoomSchema, toChatRoomRow } from "./schema.js";
-export async function runInspectCommand(room, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.inspectChatRoom({ room });
-        return {
-            type: "single",
-            data: toChatRoomRow(payload.room),
-            schema: chatRoomSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_INSPECT_FAILED", "inspect chat room", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=inspect.js.map

package/dist/commands/chat/ls.d.ts

@@ -1,6 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatRoomRow } from "./schema.js";
-export declare function runLsCommand(options: ChatCommandOptions, _command: Command): Promise<ListResult<ChatRoomRow>>;
-//# sourceMappingURL=ls.d.ts.map

package/dist/commands/chat/ls.js

@@ -1,20 +0,0 @@
-import { connectChatClient, toChatCommandError } from "./shared.js";
-import { chatRoomSchema, toChatRoomRow } from "./schema.js";
-export async function runLsCommand(options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.listChatRooms();
-        return {
-            type: "list",
-            data: payload.rooms.map(toChatRoomRow),
-            schema: chatRoomSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_LIST_FAILED", "list chat rooms", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=ls.js.map

package/dist/commands/chat/post.d.ts

@@ -1,9 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatMessageRow } from "./schema.js";
-export interface ChatPostOptions extends ChatCommandOptions {
-    replyTo?: string;
-}
-export declare function runPostCommand(room: string, body: string, options: ChatPostOptions, _command: Command): Promise<SingleResult<ChatMessageRow>>;
-//# sourceMappingURL=post.d.ts.map

package/dist/commands/chat/post.js

@@ -1,28 +0,0 @@
-import { attachAgentNamesToMessages, connectChatClient, resolveChatAuthorAgentId, toChatCommandError, } from "./shared.js";
-import { chatMessageSchema, toChatMessageRow } from "./schema.js";
-export async function runPostCommand(room, body, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.postChatMessage({
-            room,
-            body,
-            authorAgentId: resolveChatAuthorAgentId(),
-            replyToMessageId: options.replyTo,
-        });
-        const [message] = await attachAgentNamesToMessages(client, [
-            toChatMessageRow(payload.message),
-        ]);
-        return {
-            type: "single",
-            data: message,
-            schema: chatMessageSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_POST_FAILED", "post chat message", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=post.js.map

package/dist/commands/chat/read.d.ts

@@ -1,11 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatMessageRow } from "./schema.js";
-export interface ChatReadOptions extends ChatCommandOptions {
-    limit?: string;
-    since?: string;
-    agent?: string;
-}
-export declare function runReadCommand(room: string, options: ChatReadOptions, _command: Command): Promise<ListResult<ChatMessageRow>>;
-//# sourceMappingURL=read.d.ts.map

package/dist/commands/chat/read.js

@@ -1,40 +0,0 @@
-import { attachAgentNamesToMessages, connectChatClient, parseSinceValue, toChatCommandError, } from "./shared.js";
-import { chatMessageSchema, toChatMessageRow } from "./schema.js";
-function parseLimit(value) {
-    if (!value) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isInteger(parsed) || parsed < 0) {
-        throw {
-            code: "INVALID_LIMIT",
-            message: "Invalid --limit value",
-            details: "Use a non-negative integer.",
-        };
-    }
-    return parsed;
-}
-export async function runReadCommand(room, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.readChatMessages({
-            room,
-            limit: parseLimit(options.limit),
-            since: parseSinceValue(options.since),
-            authorAgentId: options.agent,
-        });
-        const messages = await attachAgentNamesToMessages(client, payload.messages.map(toChatMessageRow));
-        return {
-            type: "list",
-            data: messages,
-            schema: chatMessageSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_READ_FAILED", "read chat messages", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=read.js.map