@otto-code/cli 0.8.12 → 0.8.13

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

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import { type SingleResult } from "../../output/index.js";
+import type { HubCredentialStore } from "./credentials.js";
+import type { CliLoginFlow } from "./login-flow.js";
+import { type HubReporter } from "./reporter.js";
+interface HubLoginResult {
+    origin: string;
+    status: "logged_in";
+}
+interface HubLoginDependencies {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    flow: Pick<CliLoginFlow, "authorize">;
+    reporter: HubReporter;
+}
+export declare function runHubLogin(originInput: string | undefined, options: {
+    json?: boolean;
+}, dependencies: HubLoginDependencies): Promise<SingleResult<HubLoginResult>>;
+export declare function addHubLoginCommand(parent: Command, dependencies: HubLoginDependencies): void;
+export {};
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/hub/login.js

@@ -0,0 +1,34 @@
+import { withOutput } from "../../output/index.js";
+import { addJsonOption } from "../../utils/command-options.js";
+import { resolveHubOrigin } from "./authority.js";
+import { reportHubProgress } from "./reporter.js";
+import { addHubResolutionHelp } from "./help.js";
+const schema = {
+    idField: "origin",
+    columns: [
+        { header: "HUB", field: "origin" },
+        { header: "STATUS", field: "status" },
+    ],
+};
+export async function runHubLogin(originInput, options, dependencies) {
+    const origin = resolveHubOrigin({
+        options: { origin: originInput },
+        env: dependencies.env,
+        credentials: dependencies.credentials,
+    });
+    reportHubProgress(dependencies.reporter, options, `Logging in to ${origin}`);
+    const credential = await dependencies.flow.authorize(origin);
+    dependencies.credentials.save({ origin, credential });
+    return { type: "single", data: { origin, status: "logged_in" }, schema };
+}
+export function addHubLoginCommand(parent, dependencies) {
+    addJsonOption(addHubResolutionHelp(parent
+        .command("login")
+        .description("Log in to a Paseo Hub for CLI access")
+        .argument("[origin]", "Paseo Hub origin"))).action(withOutput(async (...args) => {
+        const origin = args[0];
+        const options = args.at(-2);
+        return runHubLogin(origin, options, dependencies);
+    }));
+}
+//# sourceMappingURL=login.js.map

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

@@ -0,0 +1,32 @@
+import type { Command } from "commander";
+import { type SingleResult } from "../../output/index.js";
+import type { HubCredentialStore } from "./credentials.js";
+import type { HubDaemonConnection } from "./daemon-client.js";
+import { type HubReporter } from "./reporter.js";
+interface HubLogoutResult {
+    origin: string | null;
+    status: "logged_out" | "not_logged_in";
+    daemonDisconnected: boolean;
+    warning?: string;
+}
+interface HubLogoutOptions {
+    disconnectDaemon?: boolean;
+    force?: boolean;
+    host?: string;
+    json?: boolean;
+}
+interface HubLogoutDependencies {
+    credentials: HubCredentialStore;
+    daemon: HubDaemonConnection;
+    isInteractive(): boolean;
+    confirmDisconnect(origin: string): Promise<boolean>;
+    reporter: HubReporter;
+}
+export declare function runHubLogout(options: HubLogoutOptions, dependencies: HubLogoutDependencies): Promise<SingleResult<HubLogoutResult>>;
+export declare function addHubLogoutCommand(parent: Command, dependencies: HubLogoutDependencies): void;
+export declare const productionLogoutPrompt: {
+    isInteractive: () => boolean;
+    confirmDisconnect(origin: string): Promise<boolean>;
+};
+export {};
+//# sourceMappingURL=logout.d.ts.map

package/dist/commands/hub/logout.js

@@ -0,0 +1,71 @@
+import { confirm, isCancel } from "@clack/prompts";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { withHubDaemon } from "./daemon-client.js";
+import { reportHubProgress } from "./reporter.js";
+const schema = {
+    idField: "status",
+    columns: [
+        { header: "HUB", field: "origin" },
+        { header: "STATUS", field: "status" },
+        { header: "DAEMON DISCONNECTED", field: "daemonDisconnected" },
+        { header: "WARNING", field: "warning" },
+    ],
+};
+export async function runHubLogout(options, dependencies) {
+    const active = dependencies.credentials.active();
+    if (active === null) {
+        return logoutResult({ origin: null, status: "not_logged_in", daemonDisconnected: false });
+    }
+    reportHubProgress(dependencies.reporter, options, `Logging out of ${active.origin}`);
+    const mayPrompt = options.json !== true && dependencies.isInteractive();
+    let daemonStatus = null;
+    const shouldInspectDaemon = options.disconnectDaemon === true || mayPrompt;
+    if (shouldInspectDaemon) {
+        daemonStatus = await withHubDaemon(dependencies.daemon, options.host, async (daemon) => daemon.getHubStatus().then((response) => response.status));
+    }
+    const sameHub = daemonStatus?.hubOrigin === active.origin;
+    let shouldDisconnect = options.disconnectDaemon === true && sameHub;
+    if (options.disconnectDaemon !== true && mayPrompt && sameHub) {
+        shouldDisconnect = await dependencies.confirmDisconnect(active.origin);
+    }
+    if (!shouldDisconnect) {
+        dependencies.credentials.logoutActive();
+        return logoutResult({ origin: active.origin, status: "logged_out", daemonDisconnected: false });
+    }
+    reportHubProgress(dependencies.reporter, options, `Disconnecting this daemon from ${active.origin}`);
+    const disconnect = await withHubDaemon(dependencies.daemon, options.host, async (daemon) => {
+        return daemon.disconnectHub(options.force ?? false);
+    });
+    dependencies.credentials.logoutActive();
+    return logoutResult({
+        origin: active.origin,
+        status: "logged_out",
+        daemonDisconnected: disconnect.status.state === "not_connected",
+        ...(disconnect.warning ? { warning: disconnect.warning } : {}),
+    });
+}
+export function addHubLogoutCommand(parent, dependencies) {
+    addJsonAndDaemonHostOptions(parent
+        .command("logout")
+        .description("Remove the active stored Hub CLI login")
+        .option("--disconnect-daemon", "Also disconnect a daemon related to the same Hub")
+        .option("--force", "Remove daemon authority without notifying the Hub")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return runHubLogout(options, dependencies);
+    }));
+}
+export const productionLogoutPrompt = {
+    isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    async confirmDisconnect(origin) {
+        const answer = await confirm({
+            message: `Disconnect this daemon from ${origin}?`,
+            initialValue: false,
+        });
+        return !isCancel(answer) && answer;
+    },
+};
+function logoutResult(data) {
+    return { type: "single", data, schema };
+}
+//# sourceMappingURL=logout.js.map

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

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

package/dist/commands/hub/origin.js

@@ -0,0 +1,27 @@
+import { HubCommandError } from "./error.js";
+export function normalizeHubOrigin(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw invalidHubOrigin();
+    }
+    if (!["http:", "https:"].includes(url.protocol) ||
+        (url.protocol === "http:" && !isLoopbackHostname(url.hostname)) ||
+        url.username ||
+        url.password ||
+        url.pathname !== "/" ||
+        url.search ||
+        url.hash) {
+        throw invalidHubOrigin();
+    }
+    return url.origin;
+}
+function isLoopbackHostname(hostname) {
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function invalidHubOrigin() {
+    return new HubCommandError("HUB_INVALID_ORIGIN", "Hub URL must be an HTTPS origin without credentials, path, query, or hash. HTTP is allowed only for localhost, 127.0.0.1, or [::1].");
+}
+//# sourceMappingURL=origin.js.map

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

@@ -0,0 +1,24 @@
+import type { Command } from "commander";
+import { type SingleResult } from "../../output/index.js";
+import type { HubHttpClient, HubProject } from "./hub-client/index.js";
+import type { HubCredentialStore } from "./credentials.js";
+import { type HubReporter } from "./reporter.js";
+interface HubProjectsResult {
+    origin: string;
+    projects: HubProject[];
+}
+export interface HubProjectsOptions {
+    hub?: string;
+    apiKey?: string;
+    json?: boolean;
+}
+interface HubProjectsDependencies {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: Pick<HubHttpClient, "listProjects">;
+    reporter: HubReporter;
+}
+export declare function runHubProjects(options: HubProjectsOptions, dependencies: HubProjectsDependencies): Promise<SingleResult<HubProjectsResult>>;
+export declare function addHubProjectsCommand(parent: Command, dependencies: HubProjectsDependencies): void;
+export {};
+//# sourceMappingURL=projects.d.ts.map

package/dist/commands/hub/projects.js

@@ -0,0 +1,49 @@
+import { render, withOutput } from "../../output/index.js";
+import { addJsonOption } from "../../utils/command-options.js";
+import { resolveHubCredential, resolveHubOrigin } from "./authority.js";
+import { reportHubProgress } from "./reporter.js";
+import { addHubResolutionHelp } from "./help.js";
+const projectSchema = {
+    idField: "id",
+    columns: [
+        { header: "SLUG", field: "slug" },
+        { header: "NAME", field: "name" },
+        { header: "ID", field: "id" },
+        { header: "HUB", field: "origin" },
+    ],
+};
+const schema = {
+    idField: "origin",
+    columns: [
+        { header: "HUB", field: "origin" },
+        { header: "PROJECTS", field: (result) => result.projects.length },
+    ],
+    renderHuman(result, options) {
+        const results = result.type === "single" ? [result.data] : result.data;
+        const data = results.flatMap((entry) => entry.projects.map((project) => ({ ...project, origin: entry.origin })));
+        return render({ type: "list", data, schema: projectSchema }, options);
+    },
+};
+export async function runHubProjects(options, dependencies) {
+    const resolution = {
+        options: { origin: options.hub, apiKey: options.apiKey },
+        env: dependencies.env,
+        credentials: dependencies.credentials,
+    };
+    const origin = resolveHubOrigin(resolution);
+    reportHubProgress(dependencies.reporter, options, `Listing projects from ${origin}`);
+    const credential = resolveHubCredential({ ...resolution, origin });
+    const projects = await dependencies.hub.listProjects(origin, credential);
+    return { type: "single", data: { origin, projects }, schema };
+}
+export function addHubProjectsCommand(parent, dependencies) {
+    addJsonOption(addHubResolutionHelp(parent
+        .command("projects")
+        .description("List projects for the authenticated Hub organization")
+        .option("--hub <origin>", "Paseo Hub origin")
+        .option("--api-key <secret>", "Organization API key"))).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return runHubProjects(options, dependencies);
+    }));
+}
+//# sourceMappingURL=projects.js.map

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

@@ -0,0 +1,10 @@
+export interface HubReporter {
+    progress(message: string): void;
+}
+export declare const processHubReporter: HubReporter;
+interface HubReportOptions {
+    json?: boolean;
+}
+export declare function reportHubProgress(reporter: HubReporter, options: HubReportOptions, message: string): void;
+export {};
+//# sourceMappingURL=reporter.d.ts.map

package/dist/commands/hub/reporter.js

@@ -0,0 +1,11 @@
+export const processHubReporter = {
+    progress(message) {
+        process.stderr.write(`${message}\n`);
+    },
+};
+export function reportHubProgress(reporter, options, message) {
+    if (options.json === true)
+        return;
+    reporter.progress(message);
+}
+//# sourceMappingURL=reporter.js.map

package/dist/commands/hub/status-output.d.ts

@@ -0,0 +1,13 @@
+import type { ListResult } from "../../output/index.js";
+import type { HubStatus } from "./daemon-client.js";
+export interface HubRow {
+    state: string;
+    daemonId: string | null;
+    hub: string | null;
+    scopes: string;
+    connectedAt: string | null;
+    error: string | null;
+    warning?: string;
+}
+export declare function hubStatusResult(status: HubStatus, warning?: string, reportedHubOrigin?: string | null): ListResult<HubRow>;
+//# sourceMappingURL=status-output.d.ts.map

package/dist/commands/hub/status-output.js

@@ -0,0 +1,30 @@
+const schema = {
+    idField: "state",
+    columns: [
+        { header: "STATE", field: "state" },
+        { header: "HUB", field: "hub" },
+        { header: "DAEMON", field: "daemonId" },
+        { header: "SCOPES", field: "scopes" },
+        { header: "CONNECTED", field: "connectedAt" },
+        { header: "ERROR", field: "error" },
+        { header: "WARNING", field: "warning" },
+    ],
+};
+export function hubStatusResult(status, warning, reportedHubOrigin = status.hubOrigin) {
+    return {
+        type: "list",
+        data: [
+            {
+                state: status.state,
+                daemonId: status.daemonId,
+                hub: reportedHubOrigin,
+                scopes: status.scopes.join(", "),
+                connectedAt: status.connectedAt,
+                error: status.lastError,
+                warning,
+            },
+        ],
+        schema,
+    };
+}
+//# sourceMappingURL=status-output.js.map

package/dist/commands/onboard.js

@@ -2,10 +2,11 @@ import { cancel, confirm, intro, isCancel, log, note, outro, spinner } from "@cl
 import { Command, Option } from "commander";
 import { writeFileSync } from "node:fs";
 import path from "node:path";
-import { generateLocalPairingOffer, loadConfig, loadPersistedConfig, } from "@otto-code/server";
+import { loadPersistedConfig } from "@otto-code/server";
 import { resolveLocalOttoHome, resolveLocalDaemonState, resolveTcpHostFromListen, startLocalDaemonDetached, tailDaemonLog, } from "./daemon/local-daemon.js";
 import { tryConnectToDaemon } from "../utils/client.js";
 import { formatPairingInstructions } from "../output/pairing.js";
+import { confirmRelayPairing, printDirectConnectionGuidance, resolveLocalPairingOffer, } from "./daemon/pair.js";
 const DEFAULT_READY_TIMEOUT_MS = 10 * 60 * 1000;
 const READY_PROBE_TIMEOUT_MS = 1200;
 class OnboardCancelledError extends Error {
@@ -29,32 +30,6 @@ function parseTimeoutMs(raw) {
     }
     return Math.ceil(seconds * 1000);
 }
-function toCliOverrides(options) {
-    const cliOverrides = {};
-    if (options.listen) {
-        cliOverrides.listen = options.listen;
-    }
-    else if (options.port) {
-        cliOverrides.listen = `127.0.0.1:${options.port}`;
-    }
-    if (options.relay === false) {
-        cliOverrides.relayEnabled = false;
-    }
-    if (options.hostnames) {
-        const raw = options.hostnames.trim();
-        cliOverrides.hostnames =
-            raw.toLowerCase() === "true"
-                ? true
-                : raw
-                    .split(",")
-                    .map((host) => host.trim())
-                    .filter(Boolean);
-    }
-    if (options.mcp === false) {
-        cliOverrides.mcpEnabled = false;
-    }
-    return cliOverrides;
-}
 function savePersistedConfig(ottoHome, config) {
     const configPath = path.join(ottoHome, "config.json");
     writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
@@ -243,6 +218,7 @@ export function onboardCommand() {
         .option("--listen <listen>", "Listen target (host:port, port, or unix socket path)")
         .option("--port <port>", "Port to listen on (default: 6868)")
         .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .option("--relay", "Enable relay connection without prompting")
         .option("--no-relay", "Disable relay connection")
         .option("--no-mcp", "Disable the Agent MCP HTTP endpoint")
         .option("--hostnames <hosts>", 'Daemon hostnames (comma-separated, e.g. "myhost,.example.com" or "true" for any)')
@@ -371,7 +347,6 @@ export async function runOnboard(options) {
         renderNote(ottoHome, "Otto home");
     }
     const voiceEnabled = await resolveAndPersistVoice(ottoHome, options);
-    const config = loadConfig(ottoHome, { cli: toCliOverrides(options) });
     log.message(voiceEnabled
         ? "Voice features enabled. Local speech models will be downloaded automatically if missing."
         : "Voice features disabled. Local speech models will not be downloaded.");
@@ -381,24 +356,29 @@ export async function runOnboard(options) {
         timeoutMs,
         richUi,
     });
-    if (config.relayEnabled === false) {
-        log.warn("Relay is disabled; pairing offer is unavailable for this daemon.");
+    if (options.relay === false) {
+        log.message("Relay pairing skipped because --no-relay was provided.");
         printNextSteps(null, ottoHome, richUi);
-        if (richUi) {
+        if (richUi)
             outro("Otto daemon is running.");
-        }
         return;
     }
-    const pairing = await generateLocalPairingOffer({
+    let pairing = await resolveLocalPairingOffer({
         ottoHome,
-        relayEnabled: config.relayEnabled,
-        relayEndpoint: config.relayEndpoint,
-        relayPublicEndpoint: config.relayPublicEndpoint,
-        relayUseTls: config.relayUseTls,
-        relayPublicUseTls: config.relayPublicUseTls,
-        appBaseUrl: config.appBaseUrl,
-        includeQr: true,
+        enableRelay: options.relay === true,
     });
+    if (!pairing.relayEnabled) {
+        const shouldEnable = richUi ? await confirmRelayPairing() : false;
+        if (!shouldEnable) {
+            printDirectConnectionGuidance();
+            printNextSteps(null, ottoHome, richUi);
+            if (richUi)
+                outro("Otto daemon is running.");
+            return;
+        }
+        pairing = await resolveLocalPairingOffer({ ottoHome, enableRelay: true });
+        log.success("Relay enabled");
+    }
     if (!pairing.url) {
         log.warn("Relay pairing URL is unavailable for this daemon configuration.");
         printNextSteps(null, ottoHome, richUi);

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/schedule/types.d.ts

@@ -22,10 +22,7 @@ export type ScheduleTarget = {
         model?: string;
         thinkingOptionId?: string;
         title?: string | null;
-        approvalPolicy?: string;
-        sandboxMode?: string;
-        networkAccess?: boolean;
-        webSearch?: boolean;
+        providerOptions?: Record<string, unknown>;
     };
 };
 export interface ScheduleRunRecord {

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: otto 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: otto 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/dist/output/types.d.ts

@@ -58,7 +58,7 @@ export interface ListResult<T> {
     schema: OutputSchema<T>;
 }
 /** Union type for all command results */
-export type AnyCommandResult<T> = SingleResult<T> | ListResult<T>;
+export type AnyCommandResult<T> = T extends unknown ? SingleResult<T> | ListResult<T> : never;
 /** Base interface for command results (deprecated, use SingleResult or ListResult) */
 export type CommandResult<T> = SingleResult<T> | ListResult<T>;
 /** Structured error for command failures */

package/dist/run.js

@@ -13,7 +13,14 @@ export function createCliParseArgv(input) {
         return invocation;
     }
     const nodeArgv = input.nodeArgv ?? ["otto", "otto"];
-    const cliArgv = invocation.argv.length === 0 ? ["onboard"] : invocation.argv;
+    const isOnboardRootFlag = invocation.argv[0] === "--relay" || invocation.argv[0] === "--no-relay";
+    let cliArgv = invocation.argv;
+    if (invocation.argv.length === 0) {
+        cliArgv = ["onboard"];
+    }
+    else if (isOnboardRootFlag) {
+        cliArgv = ["onboard", ...invocation.argv];
+    }
     return [...nodeArgv, ...cliArgv];
 }
 export async function runCli(argv, options = {}) {