@otto-code/cli 0.5.0

package/dist/utils/client.js

@@ -0,0 +1,330 @@
+import { existsSync, readFileSync } from "node:fs";
+import { loadConfig, resolveOttoHome } from "@otto-code/server";
+import { buildDaemonWebSocketUrl, buildRelayWebSocketUrl, normalizeHostPort, parseConnectionUri, shouldUseTlsForDefaultHostedRelay, } from "@otto-code/protocol/daemon-endpoints";
+import { parseConnectionOfferFromUrl, } from "@otto-code/protocol/connection-offer";
+import { DaemonClient } from "@otto-code/client/internal/daemon-client";
+import path from "node:path";
+import { WebSocket } from "ws";
+import { getOrCreateCliClientId } from "./client-id.js";
+import { resolveCliVersion } from "../version.js";
+const DEFAULT_HOST = "localhost:6868";
+const DEFAULT_TIMEOUT = 15000;
+const PID_FILENAME = "otto.pid";
+/**
+ * Get the daemon host from environment or options
+ */
+export function getDaemonHost(options) {
+    return resolveDaemonHostCandidates(options)[0] ?? DEFAULT_HOST;
+}
+export function normalizeDaemonHost(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (trimmed.startsWith("tcp://")) {
+        try {
+            const parsed = parseConnectionUri(trimmed);
+            const endpoint = normalizeHostPort(parsed.isIpv6 ? `[${parsed.host}]:${parsed.port}` : `${parsed.host}:${parsed.port}`);
+            const query = new URLSearchParams();
+            if (parsed.useTls) {
+                query.set("ssl", "true");
+            }
+            if (parsed.password) {
+                query.set("password", parsed.password);
+            }
+            const queryString = query.toString();
+            const suffix = queryString ? `?${queryString}` : "";
+            return `tcp://${endpoint}${suffix}`;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (trimmed.startsWith("unix://") ||
+        trimmed.startsWith("pipe://") ||
+        trimmed.startsWith("\\\\.\\pipe\\")) {
+        return trimmed.startsWith("\\\\.\\pipe\\") ? `pipe://${trimmed}` : trimmed;
+    }
+    if (trimmed.startsWith("/") || trimmed.startsWith("~")) {
+        return `unix://${trimmed}`;
+    }
+    // Windows absolute paths (e.g. C:\Users\foo) are filesystem paths, not TCP or IPC targets.
+    if (/^[A-Za-z]:[/\\]/.test(trimmed)) {
+        return null;
+    }
+    if (/^\d+$/.test(trimmed)) {
+        return `127.0.0.1:${trimmed}`;
+    }
+    return trimmed.includes(":") ? trimmed : null;
+}
+export function resolveDefaultDaemonHost(env = process.env) {
+    return resolveDefaultDaemonHosts(env)[0] ?? DEFAULT_HOST;
+}
+function isIpcDaemonHost(host) {
+    return host !== null && (host.startsWith("unix://") || host.startsWith("pipe://"));
+}
+function isTcpDaemonHost(host) {
+    return host !== null && !isIpcDaemonHost(host);
+}
+function readPidSocketTarget(ottoHome) {
+    const pidPath = path.join(ottoHome, PID_FILENAME);
+    if (!existsSync(pidPath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(pidPath, "utf-8"));
+        if (typeof parsed.listen === "string")
+            return parsed.listen;
+        if (typeof parsed.sockPath === "string")
+            return parsed.sockPath;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfiguredIpcDaemonHost(env, ottoHome) {
+    const directEnvHost = normalizeDaemonHost(env.OTTO_LISTEN ?? "");
+    if (isIpcDaemonHost(directEnvHost)) {
+        return directEnvHost;
+    }
+    const pidHost = normalizeDaemonHost(readPidSocketTarget(ottoHome) ?? "");
+    if (isIpcDaemonHost(pidHost)) {
+        return pidHost;
+    }
+    const config = loadConfig(ottoHome, { env });
+    const configuredHost = normalizeDaemonHost(config.listen);
+    return isIpcDaemonHost(configuredHost) ? configuredHost : null;
+}
+function resolveConfiguredTcpDaemonHost(env, ottoHome) {
+    const configuredHost = normalizeDaemonHost(loadConfig(ottoHome, { env }).listen);
+    if (!isTcpDaemonHost(configuredHost)) {
+        return null;
+    }
+    return configuredHost === "127.0.0.1:6868" ? null : configuredHost;
+}
+export function resolveDefaultDaemonHosts(env = process.env) {
+    const ottoHome = resolveOttoHome(env);
+    const candidates = [];
+    const configuredIpcHost = resolveConfiguredIpcDaemonHost(env, ottoHome);
+    if (configuredIpcHost) {
+        candidates.push(configuredIpcHost);
+    }
+    const configuredTcpHost = resolveConfiguredTcpDaemonHost(env, ottoHome);
+    if (configuredTcpHost) {
+        candidates.push(configuredTcpHost);
+    }
+    candidates.push(DEFAULT_HOST);
+    return Array.from(new Set(candidates));
+}
+function resolveDaemonHostCandidates(options) {
+    const explicitHost = options?.host ?? process.env.OTTO_HOST;
+    if (explicitHost) {
+        return [explicitHost];
+    }
+    return resolveDefaultDaemonHosts();
+}
+function stripIpcPrefix(trimmed) {
+    if (trimmed.startsWith("unix://"))
+        return trimmed.slice("unix://".length).trim();
+    if (trimmed.startsWith("pipe://"))
+        return trimmed.slice("pipe://".length).trim();
+    return trimmed;
+}
+export function resolveDaemonTarget(host) {
+    const trimmed = host.trim();
+    if (trimmed.startsWith("unix://") ||
+        trimmed.startsWith("pipe://") ||
+        trimmed.startsWith("\\\\.\\pipe\\")) {
+        const socketPath = stripIpcPrefix(trimmed);
+        if (!socketPath) {
+            throw new Error("Invalid IPC daemon target: missing socket path");
+        }
+        const isUnixSocket = trimmed.startsWith("unix://");
+        return {
+            type: "ipc",
+            url: isUnixSocket ? `ws+unix://${socketPath}:/ws` : "ws://localhost/ws",
+            socketPath,
+        };
+    }
+    if (trimmed.startsWith("tcp://")) {
+        const parsed = parseConnectionUri(trimmed);
+        const endpoint = normalizeHostPort(parsed.isIpv6 ? `[${parsed.host}]:${parsed.port}` : `${parsed.host}:${parsed.port}`);
+        return {
+            type: "tcp",
+            url: buildDaemonWebSocketUrl(endpoint, { useTls: parsed.useTls }),
+        };
+    }
+    return {
+        type: "tcp",
+        url: `ws://${trimmed}/ws`,
+    };
+}
+export function resolveDaemonPassword(host) {
+    const trimmed = host.trim();
+    if (trimmed.startsWith("tcp://")) {
+        const fromUri = parseConnectionUri(trimmed).password;
+        if (fromUri)
+            return fromUri;
+    }
+    const fromEnv = process.env.OTTO_PASSWORD;
+    return fromEnv && fromEnv.length > 0 ? fromEnv : undefined;
+}
+/**
+ * Create a WebSocket factory that works in Node.js
+ */
+function createNodeWebSocketFactory() {
+    return (url, options) => {
+        return new WebSocket(url, options?.protocols, {
+            headers: options?.headers,
+            ...(options?.socketPath ? { socketPath: options.socketPath } : {}),
+        });
+    };
+}
+/**
+ * Create and connect a daemon client
+ * Returns the connected client or throws if connection fails
+ */
+async function tryConnectHost(host, password, clientId, timeout, nodeWebSocketFactory) {
+    const target = resolveDaemonTarget(host);
+    const client = new DaemonClient({
+        url: target.url,
+        clientId,
+        clientType: "cli",
+        appVersion: resolveCliVersion(),
+        password,
+        connectTimeoutMs: timeout,
+        webSocketFactory: (url, config) => nodeWebSocketFactory(url, {
+            headers: config?.headers,
+            protocols: config?.protocols,
+            ...(target.type === "ipc" ? { socketPath: target.socketPath } : {}),
+        }),
+        reconnect: { enabled: false },
+    });
+    try {
+        await client.connect();
+        return { client };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        return { error };
+    }
+}
+async function connectViaRelayOffer(offer, clientId, timeout, nodeWebSocketFactory) {
+    const url = buildRelayWebSocketUrl({
+        endpoint: offer.relay.endpoint,
+        serverId: offer.serverId,
+        role: "client",
+        useTls: offer.relay.useTls ?? shouldUseTlsForDefaultHostedRelay(offer.relay.endpoint),
+    });
+    const client = new DaemonClient({
+        url,
+        clientId,
+        clientType: "cli",
+        appVersion: resolveCliVersion(),
+        connectTimeoutMs: timeout,
+        webSocketFactory: (target, config) => nodeWebSocketFactory(target, { headers: config?.headers, protocols: config?.protocols }),
+        e2ee: { enabled: true, daemonPublicKeyB64: offer.daemonPublicKeyB64 },
+        reconnect: { enabled: false },
+    });
+    try {
+        await client.connect();
+        return client;
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        const message = error instanceof Error ? error.message : String(error);
+        const lastError = client.lastError ? ` (${client.lastError})` : "";
+        throw new Error(`Failed to connect via relay offer: ${message}${lastError}`, { cause: error });
+    }
+}
+function parseHostOfferOrNull(host) {
+    if (!host)
+        return null;
+    try {
+        return parseConnectionOfferFromUrl(host);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid pairing offer URL: ${message}`, { cause: error });
+    }
+}
+export async function connectToDaemon(options) {
+    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+    const clientId = await getOrCreateCliClientId();
+    const nodeWebSocketFactory = createNodeWebSocketFactory();
+    const explicitHost = options?.host ?? process.env.OTTO_HOST;
+    const offer = parseHostOfferOrNull(explicitHost);
+    if (offer) {
+        return connectViaRelayOffer(offer, clientId, timeout, nodeWebSocketFactory);
+    }
+    const hosts = resolveDaemonHostCandidates(options);
+    async function tryNext(index, lastError) {
+        if (index >= hosts.length) {
+            if (lastError instanceof Error)
+                throw lastError;
+            throw new Error(`Unable to connect to Otto daemon via ${hosts.join(", ")}`);
+        }
+        const host = hosts[index];
+        const password = resolveDaemonPassword(host);
+        const result = await tryConnectHost(host, password, clientId, timeout, nodeWebSocketFactory);
+        if ("client" in result) {
+            return result.client;
+        }
+        return tryNext(index + 1, result.error);
+    }
+    return tryNext(0, null);
+}
+/**
+ * Try to connect to the daemon, returns null if connection fails
+ */
+export async function tryConnectToDaemon(options) {
+    try {
+        return await connectToDaemon(options);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve an agent ID from a partial ID or name.
+ * Supports:
+ * - Full ID match
+ * - Prefix match (first N characters)
+ * - Title/name match (case-insensitive)
+ *
+ * Returns the full agent ID if found, null otherwise.
+ */
+export function resolveAgentId(idOrName, agents) {
+    if (!idOrName || agents.length === 0) {
+        return null;
+    }
+    const query = idOrName.toLowerCase();
+    // Try exact ID match first
+    const exactMatch = agents.find((a) => a.id === idOrName);
+    if (exactMatch) {
+        return exactMatch.id;
+    }
+    // Try ID prefix match
+    const prefixMatches = agents.filter((a) => a.id.toLowerCase().startsWith(query));
+    if (prefixMatches.length === 1 && prefixMatches[0]) {
+        return prefixMatches[0].id;
+    }
+    // Try title/name match (case-insensitive)
+    const titleMatches = agents.filter((a) => a.title?.toLowerCase() === query);
+    if (titleMatches.length === 1 && titleMatches[0]) {
+        return titleMatches[0].id;
+    }
+    // Try partial title match
+    const partialTitleMatches = agents.filter((a) => a.title?.toLowerCase().includes(query));
+    if (partialTitleMatches.length === 1 && partialTitleMatches[0]) {
+        return partialTitleMatches[0].id;
+    }
+    // If we have multiple prefix matches and no unique title match, return first prefix match
+    const firstPrefixMatch = prefixMatches[0];
+    if (firstPrefixMatch) {
+        return firstPrefixMatch.id;
+    }
+    return null;
+}
+//# sourceMappingURL=client.js.map

package/dist/utils/command-options.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+export declare function collectMultiple(value: string, previous: string[]): string[];
+export declare function addJsonOption<T extends Command>(command: T): T;
+export declare function addDaemonHostOption<T extends Command>(command: T): T;
+export declare function addJsonAndDaemonHostOptions<T extends Command>(command: T): T;
+//# sourceMappingURL=command-options.d.ts.map

package/dist/utils/command-options.js

@@ -0,0 +1,17 @@
+const JSON_OPTION_DESCRIPTION = "Output in JSON format";
+const DAEMON_HOST_OPTION_DESCRIPTION = "Daemon host target: host:port or tcp://host:port?ssl=true&password=secret (default: local socket/pipe, then localhost:6868)";
+export function collectMultiple(value, previous) {
+    return previous.concat([value]);
+}
+export function addJsonOption(command) {
+    command.option("--json", JSON_OPTION_DESCRIPTION);
+    return command;
+}
+export function addDaemonHostOption(command) {
+    command.option("--host <host>", DAEMON_HOST_OPTION_DESCRIPTION);
+    return command;
+}
+export function addJsonAndDaemonHostOptions(command) {
+    return addDaemonHostOption(addJsonOption(command));
+}
+//# sourceMappingURL=command-options.js.map

package/dist/utils/duration.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parse duration string to milliseconds.
+ * Supports formats like: 5m, 30s, 1h, 2h30m, 90, etc.
+ * If no unit is specified, assumes seconds.
+ */
+export declare function parseDuration(input: string): number;
+//# sourceMappingURL=duration.d.ts.map

package/dist/utils/duration.js

@@ -0,0 +1,38 @@
+/**
+ * Parse duration string to milliseconds.
+ * Supports formats like: 5m, 30s, 1h, 2h30m, 90, etc.
+ * If no unit is specified, assumes seconds.
+ */
+export function parseDuration(input) {
+    const trimmed = input.trim();
+    // If it's just a number, treat as seconds
+    if (/^\d+$/.test(trimmed)) {
+        return parseInt(trimmed, 10) * 1000;
+    }
+    // Parse duration with units
+    let totalMs = 0;
+    const regex = /(\d+)([smh])/g;
+    let match;
+    let hasMatch = false;
+    while ((match = regex.exec(trimmed)) !== null) {
+        hasMatch = true;
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        switch (unit) {
+            case "s":
+                totalMs += value * 1000;
+                break;
+            case "m":
+                totalMs += value * 60 * 1000;
+                break;
+            case "h":
+                totalMs += value * 60 * 60 * 1000;
+                break;
+        }
+    }
+    if (!hasMatch) {
+        throw new Error(`Invalid duration format: ${input}. Use formats like: 5m, 30s, 1h, 2h30m`);
+    }
+    return totalMs;
+}
+//# sourceMappingURL=duration.js.map

package/dist/utils/errors.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert unknown thrown values into a user-safe error string.
+ */
+export declare function getErrorMessage(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.js

@@ -0,0 +1,10 @@
+/**
+ * Convert unknown thrown values into a user-safe error string.
+ */
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+//# sourceMappingURL=errors.js.map

package/dist/utils/paths.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Path utilities for cwd filtering in agent commands.
+ */
+/**
+ * Check if `candidatePath` is the same directory as `basePath` or a descendant of it.
+ *
+ * Handles both Unix (/) and Windows (\) path separators, including mixed separators.
+ * This is important because agent cwd paths come from the agent's OS (could be Windows)
+ * while the CLI filter path comes from the user (could also be Windows or Unix).
+ */
+export declare function isSameOrDescendantPath(basePath: string, candidatePath: string): boolean;
+//# sourceMappingURL=paths.d.ts.map

package/dist/utils/paths.js

@@ -0,0 +1,22 @@
+/**
+ * Path utilities for cwd filtering in agent commands.
+ */
+/**
+ * Check if `candidatePath` is the same directory as `basePath` or a descendant of it.
+ *
+ * Handles both Unix (/) and Windows (\) path separators, including mixed separators.
+ * This is important because agent cwd paths come from the agent's OS (could be Windows)
+ * while the CLI filter path comes from the user (could also be Windows or Unix).
+ */
+export function isSameOrDescendantPath(basePath, candidatePath) {
+    // Normalize both paths: replace all backslashes with forward slashes, strip trailing separator
+    let normalizedBase = basePath.replace(/\\/g, "/").replace(/\/$/, "");
+    let normalizedCandidate = candidatePath.replace(/\\/g, "/").replace(/\/$/, "");
+    // Windows paths are case-insensitive — detect by drive letter prefix (e.g. "C:/")
+    if (/^[a-zA-Z]:\//.test(normalizedBase) || /^[a-zA-Z]:\//.test(normalizedCandidate)) {
+        normalizedBase = normalizedBase.toLowerCase();
+        normalizedCandidate = normalizedCandidate.toLowerCase();
+    }
+    return (normalizedCandidate === normalizedBase || normalizedCandidate.startsWith(normalizedBase + "/"));
+}
+//# sourceMappingURL=paths.js.map

package/dist/utils/provider-model.d.ts

@@ -0,0 +1,11 @@
+export interface ResolveProviderAndModelOptions {
+    provider?: string;
+    model?: string;
+    defaultProvider?: string;
+}
+export interface ResolvedProviderModel {
+    provider: string;
+    model: string | undefined;
+}
+export declare function resolveProviderAndModel(options: ResolveProviderAndModelOptions): ResolvedProviderModel;
+//# sourceMappingURL=provider-model.d.ts.map

package/dist/utils/provider-model.js

@@ -0,0 +1,49 @@
+export function resolveProviderAndModel(options) {
+    const providerInput = options.provider?.trim() || options.defaultProvider;
+    const modelInput = options.model?.trim();
+    if (!providerInput) {
+        const error = {
+            code: "MISSING_PROVIDER",
+            message: "Provider is required",
+            details: "Pass --provider <provider> or --provider <provider>/<model>. Use `otto provider ls` to see providers and `otto provider models <provider>` to see models.",
+        };
+        throw error;
+    }
+    if (options.model !== undefined && !modelInput) {
+        const error = {
+            code: "INVALID_MODEL",
+            message: "--model cannot be empty",
+        };
+        throw error;
+    }
+    const slashIndex = providerInput.indexOf("/");
+    if (slashIndex === -1) {
+        return {
+            provider: providerInput,
+            model: modelInput,
+        };
+    }
+    const provider = providerInput.slice(0, slashIndex).trim();
+    const modelFromProvider = providerInput.slice(slashIndex + 1).trim();
+    if (!provider || !modelFromProvider) {
+        const error = {
+            code: "INVALID_PROVIDER",
+            message: "Invalid --provider value",
+            details: "Use --provider <provider> or --provider <provider>/<model>",
+        };
+        throw error;
+    }
+    if (modelInput && modelInput !== modelFromProvider) {
+        const error = {
+            code: "CONFLICTING_MODEL_OPTIONS",
+            message: "Conflicting model values provided",
+            details: `--provider specifies model ${modelFromProvider}, but --model specifies ${modelInput}`,
+        };
+        throw error;
+    }
+    return {
+        provider,
+        model: modelInput ?? modelFromProvider,
+    };
+}
+//# sourceMappingURL=provider-model.js.map

package/dist/utils/timeline.d.ts

@@ -0,0 +1,11 @@
+import type { DaemonClient } from "@otto-code/client/internal/daemon-client";
+import type { AgentTimelineItem } from "@otto-code/protocol/agent-types";
+export declare const LIVE_HISTORY_FETCH_TIMEOUT_MS = 2000;
+interface FetchProjectedTimelineItemsInput {
+    client: DaemonClient;
+    agentId: string;
+    timeoutMs?: number;
+}
+export declare function fetchProjectedTimelineItems(input: FetchProjectedTimelineItemsInput): Promise<AgentTimelineItem[]>;
+export {};
+//# sourceMappingURL=timeline.d.ts.map

package/dist/utils/timeline.js

@@ -0,0 +1,11 @@
+export const LIVE_HISTORY_FETCH_TIMEOUT_MS = 2000;
+export async function fetchProjectedTimelineItems(input) {
+    const timeline = await input.client.fetchAgentTimeline(input.agentId, {
+        direction: "tail",
+        limit: 0,
+        projection: "projected",
+        timeout: input.timeoutMs,
+    });
+    return timeline.entries.map((entry) => entry.item);
+}
+//# sourceMappingURL=timeline.js.map

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveCliVersion(): string;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -0,0 +1,10 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export function resolveCliVersion() {
+    const packageJson = require("../package.json");
+    if (typeof packageJson.version === "string" && packageJson.version.trim().length > 0) {
+        return packageJson.version.trim();
+    }
+    throw new Error("Unable to resolve @otto-code/cli version from package.json.");
+}
+//# sourceMappingURL=version.js.map

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@otto-code/cli",
+  "version": "0.5.0",
+  "description": "Otto CLI - control your AI coding agents from the command line",
+  "bin": {
+    "otto": "bin/otto"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "node ../../scripts/clean-package-dist.mjs",
+    "build": "tsc -p tsconfig.json --incremental false",
+    "build:clean": "npm run clean && npm run build",
+    "prepack": "npm run build:clean",
+    "typecheck": "tsgo --noEmit",
+    "test": "npm run test:local",
+    "test:local": "tsx tests/run-all.ts",
+    "test:e2e": "npm run test:local",
+    "test:e2e:lifecycle": "npx tsx tests/e2e/agent-lifecycle.test.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.0",
+    "@otto-code/client": "0.5.0",
+    "@otto-code/protocol": "0.5.0",
+    "@otto-code/server": "0.5.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "mime-types": "^2.1.35",
+    "tree-kill": "^1.2.2",
+    "ws": "^8.14.2",
+    "yaml": "^2.8.4"
+  },
+  "devDependencies": {
+    "@types/mime-types": "^3.0.1",
+    "@types/ws": "^8.5.8",
+    "tsx": "^4.6.0",
+    "typescript": "^5.2.2",
+    "vitest": "^4.1.6",
+    "zx": "^8.8.5"
+  }
+}