@otto-code/cli 0.5.0

package/dist/commands/agent/stop.js

@@ -0,0 +1,115 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { isSameOrDescendantPath } from "../../utils/paths.js";
+/** Schema for stop command output */
+export const stopSchema = {
+    // For quiet mode, output the stopped agent IDs (one per line)
+    idField: (item) => item.agentIds.join("\n"),
+    columns: [{ header: "INTERRUPTED", field: "stoppedCount" }],
+};
+export function addStopOptions(cmd) {
+    return cmd
+        .description("Interrupt an agent if it is running (no-op for idle agents)")
+        .argument("[id]", "Agent ID (or prefix) - optional if --all or --cwd specified")
+        .option("--all", "Stop all agents")
+        .option("--cwd <path>", "Stop all agents in directory");
+}
+export async function runStopCommand(id, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments - need either an id, --all, or --cwd
+    if (!id && !options.all && !options.cwd) {
+        const error = {
+            code: "MISSING_ARGUMENT",
+            message: "Agent ID required unless --all or --cwd is specified",
+            details: "Usage: otto agent stop <id> | --all | --cwd <path>",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const fetchPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+        let agents = fetchPayload.entries.map((entry) => entry.agent);
+        const stoppedIds = [];
+        if (options.all) {
+            // Stop all agents (not archived)
+            agents = agents.filter((a) => !a.archivedAt);
+        }
+        else if (options.cwd) {
+            // Stop agents in directory
+            agents = agents.filter((a) => {
+                if (a.archivedAt)
+                    return false;
+                return isSameOrDescendantPath(options.cwd, a.cwd);
+            });
+        }
+        else if (id) {
+            // Stop specific agent
+            const fetchResult = await client.fetchAgent({ agentId: id });
+            if (!fetchResult) {
+                const error = {
+                    code: "AGENT_NOT_FOUND",
+                    message: `No agent found matching: ${id}`,
+                    details: "Use `otto ls` to list available agents",
+                };
+                throw error;
+            }
+            agents = [fetchResult.agent];
+        }
+        // Interrupt each running agent. Idle agents are a no-op.
+        const stopResults = await Promise.all(agents.map(async (agent) => {
+            if (agent.status !== "running")
+                return { ok: true, id: agent.id, stopped: false };
+            try {
+                await client.cancelAgent(agent.id);
+                return { ok: true, id: agent.id, stopped: true };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { ok: false, id: agent.id, message };
+            }
+        }));
+        for (const result of stopResults) {
+            if (!result.ok) {
+                console.error(`Warning: Failed to stop agent ${result.id.slice(0, 7)}: ${result.message}`);
+                continue;
+            }
+            if (result.stopped) {
+                stoppedIds.push(result.id);
+            }
+        }
+        await client.close();
+        return {
+            type: "single",
+            data: {
+                stoppedCount: stoppedIds.length,
+                agentIds: stoppedIds,
+            },
+            schema: stopSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw if it's already a CommandError
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "STOP_AGENT_FAILED",
+            message: `Failed to stop agent(s): ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=stop.js.map

package/dist/commands/agent/update.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+/** Result type for agent update command */
+export interface AgentUpdateResult {
+    agentId: string;
+    name: string | null;
+    labels: string;
+}
+/** Schema for update command output */
+export declare const updateSchema: OutputSchema<AgentUpdateResult>;
+export interface AgentUpdateOptions extends CommandOptions {
+    name?: string;
+    label?: string[];
+    host?: string;
+}
+export type AgentUpdateCommandResult = SingleResult<AgentUpdateResult>;
+export declare function runUpdateCommand(agentIdArg: string, options: AgentUpdateOptions, _command: Command): Promise<AgentUpdateCommandResult>;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/agent/update.js

@@ -0,0 +1,139 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Schema for update command output */
+export const updateSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId" },
+        { header: "NAME", field: "name" },
+        { header: "LABELS", field: "labels" },
+    ],
+};
+function parseLabelOptions(labels) {
+    const parsed = {};
+    if (!labels) {
+        return parsed;
+    }
+    for (const rawLabel of labels) {
+        for (const segment of rawLabel.split(",")) {
+            const label = segment.trim();
+            if (!label) {
+                continue;
+            }
+            const eqIndex = label.indexOf("=");
+            if (eqIndex === -1) {
+                const error = {
+                    code: "INVALID_LABEL",
+                    message: `Invalid label format: ${label}`,
+                    details: "Labels must be in key=value format",
+                };
+                throw error;
+            }
+            const key = label.slice(0, eqIndex).trim();
+            const value = label.slice(eqIndex + 1);
+            if (!key) {
+                const error = {
+                    code: "INVALID_LABEL",
+                    message: `Invalid label format: ${label}`,
+                    details: "Labels must include a non-empty key in key=value format",
+                };
+                throw error;
+            }
+            parsed[key] = value;
+        }
+    }
+    return parsed;
+}
+function formatLabels(labels) {
+    const entries = Object.entries(labels);
+    if (entries.length === 0) {
+        return "-";
+    }
+    return entries.map(([key, value]) => `${key}=${value}`).join(",");
+}
+export async function runUpdateCommand(agentIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!agentIdArg || agentIdArg.trim().length === 0) {
+        const error = {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required",
+            details: "Usage: otto agent update <id> [--name <name>] [--label <key=value>]",
+        };
+        throw error;
+    }
+    const name = options.name?.trim();
+    if (options.name !== undefined && !name) {
+        const error = {
+            code: "INVALID_NAME",
+            message: "Name cannot be empty",
+            details: "Use --name <name> with a non-empty value",
+        };
+        throw error;
+    }
+    const labels = parseLabelOptions(options.label);
+    if (!name && Object.keys(labels).length === 0) {
+        const error = {
+            code: "NO_CHANGES_PROVIDED",
+            message: "Nothing to update",
+            details: "Provide at least one of: --name <name>, --label <key=value>",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const fetchResult = await client.fetchAgent({ agentId: agentIdArg });
+        if (!fetchResult) {
+            const error = {
+                code: "AGENT_NOT_FOUND",
+                message: `Agent not found: ${agentIdArg}`,
+                details: 'Use "otto ls" to list available agents',
+            };
+            throw error;
+        }
+        const agentId = fetchResult.agent.id;
+        await client.updateAgent(agentId, {
+            ...(name ? { name } : {}),
+            ...(Object.keys(labels).length > 0 ? { labels } : {}),
+        });
+        const updatedResult = await client.fetchAgent({ agentId });
+        if (!updatedResult) {
+            throw new Error(`Agent not found after update: ${agentId}`);
+        }
+        await client.close();
+        return {
+            type: "single",
+            data: {
+                agentId,
+                name: updatedResult.agent.title,
+                labels: formatLabels(updatedResult.agent.labels),
+            },
+            schema: updateSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "UPDATE_FAILED",
+            message: `Failed to update agent: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=update.js.map

package/dist/commands/agent/wait.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+/** Result type for agent wait command */
+export interface AgentWaitResult {
+    agentId: string;
+    status: "idle" | "timeout" | "permission" | "error";
+    message: string;
+}
+/** Schema for agent wait output */
+export declare const agentWaitSchema: OutputSchema<AgentWaitResult>;
+export interface AgentWaitOptions extends CommandOptions {
+    timeout?: string;
+    host?: string;
+}
+export declare function addWaitOptions(cmd: Command): Command;
+export declare function runWaitCommand(agentIdArg: string, options: AgentWaitOptions, _command: Command): Promise<SingleResult<AgentWaitResult>>;
+//# sourceMappingURL=wait.d.ts.map

package/dist/commands/agent/wait.js

@@ -0,0 +1,158 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { fetchAgentTimelineItems, formatAgentActivityTranscript } from "./logs.js";
+import { parseDuration } from "../../utils/duration.js";
+/** Schema for agent wait output */
+export const agentWaitSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId", width: 12 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "MESSAGE", field: "message", width: 40 },
+    ],
+};
+const WAIT_ACTIVITY_PREVIEW_COUNT = 5;
+const WAIT_ACTIVITY_PREVIEW_TIMEOUT_MS = 2000;
+function appendRecentActivity(message, transcript) {
+    if (!transcript || transcript.trim().length === 0) {
+        return message;
+    }
+    return `${message}\nLast ${WAIT_ACTIVITY_PREVIEW_COUNT} activity items:\n${transcript}`;
+}
+async function getRecentActivityTranscript(client, agentId) {
+    try {
+        const timelineItems = await fetchAgentTimelineItems(client, agentId, {
+            timeoutMs: WAIT_ACTIVITY_PREVIEW_TIMEOUT_MS,
+        });
+        return formatAgentActivityTranscript(timelineItems, WAIT_ACTIVITY_PREVIEW_COUNT);
+    }
+    catch {
+        return null;
+    }
+}
+function parseWaitTimeout(timeout) {
+    if (!timeout)
+        return { timeoutMs: 0, timeoutLabel: null };
+    try {
+        const ms = parseDuration(timeout);
+        if (ms <= 0) {
+            throw new Error("Timeout must be positive");
+        }
+        const timeoutSeconds = Math.floor(ms / 1000);
+        return {
+            timeoutMs: ms,
+            timeoutLabel: `${timeoutSeconds} second${timeoutSeconds === 1 ? "" : "s"}`,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw {
+            code: "INVALID_TIMEOUT",
+            message: "Invalid timeout value",
+            details: message,
+        };
+    }
+}
+function buildWaitResult(args) {
+    const { state, resolvedAgentId, recentActivity, timeoutLabel } = args;
+    if (state.status === "timeout") {
+        const timeoutMessage = timeoutLabel
+            ? `Agent did not finish within ${timeoutLabel}. Run \`otto wait ${resolvedAgentId}\` again to keep waiting.`
+            : `Agent wait timed out. Run \`otto wait ${resolvedAgentId}\` again to keep waiting.`;
+        return {
+            agentId: resolvedAgentId,
+            status: "timeout",
+            message: appendRecentActivity(timeoutMessage, recentActivity),
+        };
+    }
+    if (state.status === "permission") {
+        const permission = state.final?.pendingPermissions?.[0];
+        return {
+            agentId: resolvedAgentId,
+            status: "permission",
+            message: permission
+                ? `Agent is waiting for permission: ${permission.kind}`
+                : "Agent is waiting for permission",
+        };
+    }
+    if (state.status === "error") {
+        return {
+            agentId: resolvedAgentId,
+            status: "error",
+            message: state.error ?? "Agent finished with error",
+        };
+    }
+    return {
+        agentId: resolvedAgentId,
+        status: "idle",
+        message: appendRecentActivity("Agent is idle.", recentActivity),
+    };
+}
+export function addWaitOptions(cmd) {
+    return cmd
+        .description("Wait for an agent to become idle")
+        .argument("<id>", "Agent ID (or prefix)")
+        .option("--timeout <seconds>", "Maximum wait time (default: no limit)");
+}
+export async function runWaitCommand(agentIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    if (!agentIdArg || agentIdArg.trim().length === 0) {
+        throw {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required",
+            details: "Usage: otto agent wait <id>",
+        };
+    }
+    const { timeoutMs, timeoutLabel } = parseWaitTimeout(options.timeout);
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        try {
+            const state = await client.waitForFinish(agentIdArg, timeoutMs);
+            const resolvedAgentId = state.final?.id ?? agentIdArg;
+            const recentActivity = state.status === "timeout" || state.status === "idle"
+                ? await getRecentActivityTranscript(client, resolvedAgentId)
+                : null;
+            await client.close();
+            return {
+                type: "single",
+                data: buildWaitResult({ state, resolvedAgentId, recentActivity, timeoutLabel }),
+                schema: agentWaitSchema,
+            };
+        }
+        catch (waitErr) {
+            await client.close().catch(() => { });
+            const waitMessage = waitErr instanceof Error ? waitErr.message : String(waitErr);
+            // Other errors
+            const error = {
+                code: "WAIT_FAILED",
+                message: `Failed to wait for agent: ${waitMessage}`,
+            };
+            throw error;
+        }
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "WAIT_FAILED",
+            message: `Failed to wait for agent: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=wait.js.map

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,20 @@
+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

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

package/dist/commands/chat/index.js

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,28 @@
+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