@otto-code/cli 0.5.0

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

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

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

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

@@ -0,0 +1,36 @@
+import type { OutputSchema } from "../../output/index.js";
+export interface ChatRoomRow {
+    name: string;
+    id: string;
+    purpose: string;
+    messages: number;
+    lastMessageAt: string;
+}
+export interface ChatMessageRow {
+    id: string;
+    author: string;
+    authorName: string | null;
+    createdAt: string;
+    replyTo: string;
+    mentionAgentIds: string[];
+    mentionLabels: string[];
+    body: string;
+}
+export declare const chatRoomSchema: OutputSchema<ChatRoomRow>;
+export declare const chatMessageSchema: OutputSchema<ChatMessageRow>;
+export declare function toChatRoomRow(room: {
+    id: string;
+    name: string;
+    purpose: string | null;
+    messageCount: number;
+    lastMessageAt: string | null;
+}): ChatRoomRow;
+export declare function toChatMessageRow(message: {
+    id: string;
+    authorAgentId: string;
+    createdAt: string;
+    replyToMessageId: string | null;
+    mentionAgentIds: string[];
+    body: string;
+}): ChatMessageRow;
+//# sourceMappingURL=schema.d.ts.map

package/dist/commands/chat/schema.js

@@ -0,0 +1,81 @@
+export const chatRoomSchema = {
+    idField: "id",
+    columns: [
+        { header: "NAME", field: "name", width: 22 },
+        { header: "ID", field: "id", width: 36 },
+        { header: "PURPOSE", field: "purpose", width: 30 },
+        { header: "MESSAGES", field: "messages", width: 10, align: "right" },
+        { header: "LAST MESSAGE", field: "lastMessageAt", width: 24 },
+    ],
+};
+export const chatMessageSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 36 },
+        { header: "AUTHOR", field: "author", width: 16 },
+        { header: "AUTHOR NAME", field: (row) => row.authorName ?? "-", width: 20 },
+        { header: "CREATED", field: "createdAt", width: 24 },
+        { header: "REPLY TO", field: "replyTo", width: 36 },
+        { header: "MENTIONS", field: (row) => row.mentionLabels.join(", ") || "-", width: 24 },
+        { header: "MESSAGE", field: "body", width: 60 },
+    ],
+    renderHuman: renderChatTranscript,
+};
+function renderChatTranscript(result, _options) {
+    const data = result.type === "list" ? result.data : [result.data];
+    if (data.length === 0) {
+        return "";
+    }
+    return data.map(renderChatMessageBlock).join("\n\n");
+}
+function renderChatMessageBlock(message) {
+    const authorLabel = message.authorName
+        ? `${message.authorName} (${message.author})`
+        : message.author;
+    const lines = [
+        `┌─ ${authorLabel} ── ${formatTimestamp(message.createdAt)} ── [msg ${message.id}]`,
+    ];
+    if (message.replyTo !== "-") {
+        lines.push(`│  reply-to: msg ${message.replyTo}`);
+    }
+    if (message.mentionLabels.length > 0) {
+        lines.push(`│  mentions: ${message.mentionLabels.join(", ")}`);
+    }
+    lines.push("│");
+    const bodyLines = message.body.split(/\r?\n/);
+    for (const line of bodyLines) {
+        lines.push(`│  ${line}`);
+    }
+    lines.push("│");
+    lines.push("└─");
+    return lines.join("\n");
+}
+function formatTimestamp(input) {
+    const date = new Date(input);
+    if (Number.isNaN(date.getTime())) {
+        return input;
+    }
+    return date.toISOString().replace("T", " ").replace(".000Z", "Z");
+}
+export function toChatRoomRow(room) {
+    return {
+        id: room.id,
+        name: room.name,
+        purpose: room.purpose ?? "-",
+        messages: room.messageCount,
+        lastMessageAt: room.lastMessageAt ?? "-",
+    };
+}
+export function toChatMessageRow(message) {
+    return {
+        id: message.id,
+        author: message.authorAgentId,
+        authorName: null,
+        createdAt: message.createdAt,
+        replyTo: message.replyToMessageId ?? "-",
+        mentionAgentIds: message.mentionAgentIds,
+        mentionLabels: message.mentionAgentIds,
+        body: message.body,
+    };
+}
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,19 @@
+import { connectToDaemon } from "../../utils/client.js";
+import type { CommandError, CommandOptions } from "../../output/index.js";
+import type { ChatMessageRow } from "./schema.js";
+export interface ChatCommandOptions extends CommandOptions {
+    host?: string;
+}
+export declare function connectChatClient(host?: string): Promise<{
+    client: import("@otto-code/client/internal/daemon-client").DaemonClient;
+    daemonHost: string;
+}>;
+export declare function attachAgentNamesToMessages(client: Awaited<ReturnType<typeof connectToDaemon>>, messages: ChatMessageRow[], options?: {
+    timeout?: number;
+    bestEffort?: boolean;
+}): Promise<ChatMessageRow[]>;
+export declare function toChatCommandError(code: string, action: string, err: unknown): CommandError;
+export declare function parseSinceValue(input?: string): string | undefined;
+export declare function parseTimeoutMs(input?: string): number | undefined;
+export declare function resolveChatAuthorAgentId(): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/chat/shared.js

@@ -0,0 +1,118 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { parseDuration } from "../../utils/duration.js";
+export async function connectChatClient(host) {
+    const daemonHost = getDaemonHost({ host });
+    try {
+        const client = await connectToDaemon({ host });
+        return { client, daemonHost };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+}
+export async function attachAgentNamesToMessages(client, messages, options = {}) {
+    const agentIds = new Set();
+    for (const message of messages) {
+        agentIds.add(message.author);
+        for (const mentionId of message.mentionAgentIds) {
+            agentIds.add(mentionId);
+        }
+    }
+    if (agentIds.size === 0) {
+        return messages;
+    }
+    let payload;
+    try {
+        payload = await client.fetchAgents({
+            filter: { includeArchived: true },
+            ...(typeof options.timeout === "number" ? { timeout: options.timeout } : {}),
+        });
+    }
+    catch (error) {
+        if (options.bestEffort) {
+            return messages;
+        }
+        throw error;
+    }
+    const agentNames = new Map();
+    for (const entry of payload.entries) {
+        const title = entry.agent.title?.trim();
+        if (title) {
+            agentNames.set(entry.agent.id, title);
+        }
+    }
+    return messages.map((message) => ({
+        ...message,
+        authorName: agentNames.get(message.author) ?? null,
+        mentionLabels: message.mentionAgentIds.map((agentId) => {
+            const name = agentNames.get(agentId);
+            return name ? `${name} (${agentId})` : agentId;
+        }),
+    }));
+}
+export function toChatCommandError(code, action, err) {
+    if (err && typeof err === "object" && "code" in err && "message" in err) {
+        return err;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    const rpcCode = typeof err === "object" && err !== null && "code" in err && typeof err.code === "string"
+        ? err.code
+        : undefined;
+    return {
+        code: rpcCode ?? code,
+        message: `Failed to ${action}: ${message}`,
+    };
+}
+export function parseSinceValue(input) {
+    if (!input) {
+        return undefined;
+    }
+    try {
+        const durationMs = parseDuration(input);
+        return new Date(Date.now() - durationMs).toISOString();
+    }
+    catch {
+        const timestamp = new Date(input);
+        if (Number.isNaN(timestamp.getTime())) {
+            const error = {
+                code: "INVALID_SINCE",
+                message: "Invalid --since value",
+                details: "Use a duration like 10m or an ISO timestamp.",
+            };
+            throw error;
+        }
+        return timestamp.toISOString();
+    }
+}
+export function parseTimeoutMs(input) {
+    if (!input) {
+        return undefined;
+    }
+    try {
+        const timeoutMs = parseDuration(input);
+        if (timeoutMs <= 0) {
+            throw new Error("Timeout must be positive");
+        }
+        return timeoutMs;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "INVALID_TIMEOUT",
+            message: "Invalid timeout value",
+            details: message,
+        };
+        throw error;
+    }
+}
+export function resolveChatAuthorAgentId() {
+    const agentId = process.env.OTTO_AGENT_ID?.trim();
+    return agentId && agentId.length > 0 ? agentId : "manual";
+}
+//# sourceMappingURL=shared.js.map

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

@@ -0,0 +1,9 @@
+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 ChatWaitOptions extends ChatCommandOptions {
+    timeout?: string;
+}
+export declare function runWaitCommand(room: string, options: ChatWaitOptions, _command: Command): Promise<ListResult<ChatMessageRow>>;
+//# sourceMappingURL=wait.d.ts.map

package/dist/commands/chat/wait.js

@@ -0,0 +1,45 @@
+import { attachAgentNamesToMessages, connectChatClient, parseTimeoutMs, toChatCommandError, } from "./shared.js";
+import { chatMessageSchema, toChatMessageRow } from "./schema.js";
+const CHAT_WAIT_PREFLIGHT_TIMEOUT_MS = 2000;
+export async function runWaitCommand(room, options, _command) {
+    const timeoutMs = parseTimeoutMs(options.timeout);
+    const { client } = await connectChatClient(options.host);
+    const deadline = typeof timeoutMs === "number" ? Date.now() + timeoutMs : null;
+    const hasExplicitTimeout = deadline !== null;
+    const remainingTimeoutMs = () => deadline === null ? undefined : Math.max(1, deadline - Date.now());
+    try {
+        const latest = await client.readChatMessages({
+            room,
+            limit: 1,
+            ...(hasExplicitTimeout
+                ? {
+                    timeout: Math.min(remainingTimeoutMs() ?? 1, CHAT_WAIT_PREFLIGHT_TIMEOUT_MS),
+                }
+                : {}),
+        });
+        const afterMessageId = latest.messages[0]?.id;
+        const payload = await client.waitForChatMessages({
+            room,
+            afterMessageId,
+            timeoutMs: remainingTimeoutMs() ?? timeoutMs,
+        });
+        const messages = await attachAgentNamesToMessages(client, payload.messages.map(toChatMessageRow), hasExplicitTimeout
+            ? {
+                timeout: remainingTimeoutMs(),
+                bestEffort: true,
+            }
+            : {});
+        return {
+            type: "list",
+            data: messages,
+            schema: chatMessageSchema,
+        };
+    }
+    catch (err) {
+        throw toChatCommandError("CHAT_WAIT_FAILED", "wait for chat messages", err);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=wait.js.map

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

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

package/dist/commands/daemon/index.js

@@ -0,0 +1,57 @@
+import { Command, Option } from "commander";
+import { startCommand } from "./start.js";
+import { runStatusCommand } from "./status.js";
+import { runStopCommand } from "./stop.js";
+import { runRestartCommand } from "./restart.js";
+import { runSetPasswordCommand } from "./set-password.js";
+import { pairCommand } from "./pair.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonOption } from "../../utils/command-options.js";
+function resolveHostnamesOption(hostnames, allowedHosts) {
+    if (typeof hostnames === "string")
+        return hostnames;
+    if (typeof allowedHosts === "string")
+        return allowedHosts;
+    return undefined;
+}
+export function createDaemonCommand() {
+    const daemon = new Command("daemon").description("Manage the Otto daemon");
+    daemon.addCommand(startCommand());
+    daemon.addCommand(pairCommand());
+    addJsonOption(daemon.command("status").description("Show local daemon status"))
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .action(withOutput(runStatusCommand));
+    addJsonOption(daemon.command("stop").description("Stop the local daemon"))
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .option("--timeout <seconds>", "Wait timeout before failing (default: 15)")
+        .option("--force", "Send SIGKILL if graceful stop times out")
+        .option("--kill-timeout <seconds>", "Wait after SIGKILL before failing (default: 3)")
+        .action(withOutput(runStopCommand));
+    addJsonOption(daemon.command("restart").description("Restart the local daemon"))
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .option("--timeout <seconds>", "Wait timeout before force step (default: 15)")
+        .option("--force", "Send SIGKILL if graceful stop times out")
+        .option("--listen <listen>", "Listen target for restarted daemon (host:port, port, or unix socket)")
+        .option("--port <port>", "Port for restarted daemon listen target")
+        .option("--no-relay", "Disable relay on restarted daemon")
+        .option("--no-mcp", "Disable Agent MCP on restarted daemon")
+        .option("--no-inject-mcp", "Disable auto-injecting the Otto MCP into created agents")
+        .option("--web-ui", "Enable the bundled daemon web UI on restarted daemon")
+        .option("--no-web-ui", "Disable the bundled daemon web UI on restarted daemon")
+        .option("--hostnames <hosts>", 'Daemon hostnames (comma-separated, e.g. "myhost,.example.com" or "true" for any)')
+        .addOption(new Option("--allowed-hosts <hosts>").hideHelp())
+        .action(withOutput((...args) => {
+        const [options, command] = args.slice(-2);
+        return runRestartCommand({
+            ...options,
+            hostnames: resolveHostnamesOption(options.hostnames, options.allowedHosts),
+        }, command);
+    }));
+    addJsonOption(daemon
+        .command("set-password")
+        .description("Prompt for and save a hashed daemon password to config.json"))
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .action(withOutput(runSetPasswordCommand));
+    return daemon;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/daemon/local-daemon.d.ts

@@ -0,0 +1,78 @@
+import { spawnSync, type ChildProcess } from "node:child_process";
+import { spawnProcess } from "@otto-code/server";
+export interface DaemonStartOptions {
+    port?: string;
+    listen?: string;
+    home?: string;
+    foreground?: boolean;
+    relay?: boolean;
+    relayUseTls?: boolean;
+    mcp?: boolean;
+    injectMcp?: boolean;
+    webUi?: boolean;
+    hostnames?: string;
+}
+export interface LocalDaemonPidInfo {
+    pid: number;
+    startedAt?: string;
+    hostname?: string;
+    uid?: number;
+    listen?: string;
+    desktopManaged?: boolean;
+}
+export interface LocalDaemonState {
+    home: string;
+    listen: string;
+    relayEnabled: boolean;
+    relayEndpoint: string;
+    relayUseTls: boolean;
+    relayPublicUseTls: boolean;
+    logPath: string;
+    pidPath: string;
+    pidInfo: LocalDaemonPidInfo | null;
+    running: boolean;
+    stalePidFile: boolean;
+}
+export interface DetachedStartResult {
+    pid: number | null;
+    logPath: string;
+}
+export interface StopLocalDaemonOptions {
+    home?: string;
+    timeoutMs?: number;
+    killTimeoutMs?: number;
+    force?: boolean;
+}
+export interface StopLocalDaemonResult {
+    action: "stopped" | "not_running";
+    home: string;
+    pid: number | null;
+    forced: boolean;
+    usedLifecycleRpc: boolean;
+    reason: "not_running" | "lifecycle_shutdown_rpc" | "owner_pid_signal" | "owner_pid_sigkill";
+    message: string;
+}
+export interface DetachedDaemonProcess extends Pick<ChildProcess, "once" | "pid" | "unref"> {
+}
+export interface ForegroundDaemonProcessResult {
+    status: number | null;
+    error?: Error;
+}
+export interface DaemonLaunchRuntime {
+    resolveRunnerEntry(): string;
+    resolveHome(env: NodeJS.ProcessEnv): string;
+    spawnDetached(command: string, args: string[], options: Parameters<typeof spawnProcess>[2]): DetachedDaemonProcess;
+    spawnForeground(command: string, args: string[], options: Parameters<typeof spawnSync>[2]): ForegroundDaemonProcessResult;
+}
+export declare const DEFAULT_STOP_TIMEOUT_MS = 15000;
+export declare const DEFAULT_KILL_TIMEOUT_MS = 3000;
+export declare function resolveLocalOttoHome(home?: string): string;
+export declare function resolveTcpHostFromListen(listen: string): string | null;
+export declare function resolveLocalDaemonState(options?: {
+    home?: string;
+}): LocalDaemonState;
+export declare function tailDaemonLog(home?: string, lines?: number): string | null;
+export declare function startLocalDaemonDetached(options: DaemonStartOptions, runtime?: DaemonLaunchRuntime): Promise<DetachedStartResult>;
+export declare function startLocalDaemonForeground(options: DaemonStartOptions, runtime?: DaemonLaunchRuntime): number;
+export declare function stopLocalDaemon(options?: StopLocalDaemonOptions): Promise<StopLocalDaemonResult>;
+//# sourceMappingURL=local-daemon.d.ts.map