@otto-code/cli 0.6.6 → 0.7.0

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

@@ -9,7 +9,27 @@ export declare const deleteSchema: OutputSchema<DeleteResult>;
 export interface AgentDeleteOptions extends CommandOptions {
     all?: boolean;
     cwd?: string;
+    archived?: boolean;
+    includeArchived?: boolean;
 }
 export type AgentDeleteResult = SingleResult<DeleteResult>;
+/** Which side of the archive line a bulk delete is allowed to touch. */
+export type AgentDeleteScope = "active" | "archived" | "both";
+/**
+ * Bulk delete used to filter `!a.archivedAt` unconditionally, so the one command
+ * that could clear the archive deliberately skipped exactly the rows a user most
+ * wants gone. The flags open it up without moving anyone's muscle memory: bare
+ * `--all` / `--cwd` still mean active-only.
+ *
+ * Both flags at once is contradictory ("only archived" and "also archived"), so
+ * it is refused rather than guessed — this command is irreversible.
+ */
+export declare function resolveAgentDeleteScope(options: {
+    archived?: boolean;
+    includeArchived?: boolean;
+}): AgentDeleteScope;
+export declare function matchesAgentDeleteScope(agent: {
+    archivedAt?: Date | string | null;
+}, scope: AgentDeleteScope): boolean;
 export declare function runDeleteCommand(id: string | undefined, options: AgentDeleteOptions, _command: Command): Promise<AgentDeleteResult>;
 //# sourceMappingURL=delete.d.ts.map

package/dist/commands/agent/delete.js

@@ -2,15 +2,50 @@ import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import { isSameOrDescendantPath } from "../../utils/paths.js";
 export function addDeleteOptions(cmd) {
     return cmd
-        .description("Delete an agent (interrupt if running, then hard-delete)")
+        .description("Delete an agent (interrupt if running, then hard-delete). Removes Otto's record only - the agent provider's own transcript is left on disk.")
         .argument("[id]", "Agent ID (or prefix) - optional if --all or --cwd specified")
         .option("--all", "Delete all agents")
-        .option("--cwd <path>", "Delete all agents in directory");
+        .option("--cwd <path>", "Delete all agents in directory")
+        .option("--archived", "Only archived agents (use with --all or --cwd)")
+        .option("--include-archived", "Include archived agents (use with --all or --cwd)");
 }
 export const deleteSchema = {
     idField: (item) => item.agentIds.join("\n"),
     columns: [{ header: "DELETED", field: "deletedCount" }],
 };
+/**
+ * Bulk delete used to filter `!a.archivedAt` unconditionally, so the one command
+ * that could clear the archive deliberately skipped exactly the rows a user most
+ * wants gone. The flags open it up without moving anyone's muscle memory: bare
+ * `--all` / `--cwd` still mean active-only.
+ *
+ * Both flags at once is contradictory ("only archived" and "also archived"), so
+ * it is refused rather than guessed — this command is irreversible.
+ */
+export function resolveAgentDeleteScope(options) {
+    if (options.archived && options.includeArchived) {
+        const error = {
+            code: "CONFLICTING_OPTIONS",
+            message: "--archived and --include-archived cannot be combined",
+            details: "--archived deletes only archived agents; --include-archived deletes both",
+        };
+        throw error;
+    }
+    if (options.archived) {
+        return "archived";
+    }
+    if (options.includeArchived) {
+        return "both";
+    }
+    return "active";
+}
+export function matchesAgentDeleteScope(agent, scope) {
+    if (scope === "both") {
+        return true;
+    }
+    const isArchived = agent.archivedAt != null && agent.archivedAt !== "";
+    return scope === "archived" ? isArchived : !isArchived;
+}
 export async function runDeleteCommand(id, options, _command) {
     const host = getDaemonHost({ host: options.host });
     if (!id && !options.all && !options.cwd) {
@@ -21,6 +56,9 @@ export async function runDeleteCommand(id, options, _command) {
         };
         throw error;
     }
+    // Resolved before connecting: a contradictory flag pair should fail fast, not
+    // after opening a socket.
+    const scope = resolveAgentDeleteScope(options);
     let client;
     try {
         client = await connectToDaemon({ host: options.host });
@@ -39,14 +77,10 @@ export async function runDeleteCommand(id, options, _command) {
         let agents = fetchPayload.entries.map((entry) => entry.agent);
         const deletedIds = [];
         if (options.all) {
-            agents = agents.filter((a) => !a.archivedAt);
+            agents = agents.filter((a) => matchesAgentDeleteScope(a, scope));
         }
         else if (options.cwd) {
-            agents = agents.filter((a) => {
-                if (a.archivedAt)
-                    return false;
-                return isSameOrDescendantPath(options.cwd, a.cwd);
-            });
+            agents = agents.filter((a) => matchesAgentDeleteScope(a, scope) && isSameOrDescendantPath(options.cwd, a.cwd));
         }
         else if (id) {
             const fetchResult = await client.fetchAgent({ agentId: id });

package/dist/commands/agent/run.js

@@ -6,7 +6,7 @@ import { resolve } from "node:path";
 import { lookup } from "mime-types";
 import { parseDuration } from "../../utils/duration.js";
 import { collectMultiple } from "../../utils/command-options.js";
-import { resolveProviderAndModel } from "../../utils/provider-model.js";
+import { assertNoConflictingModelInputs, resolveProviderAndModel, } from "../../utils/provider-model.js";
 export { resolveProviderAndModel } from "../../utils/provider-model.js";
 export function addRunOptions(cmd) {
     return cmd
@@ -210,6 +210,10 @@ function structuredRunSchema(output) {
     };
 }
 function validateRunOptions(prompt, options, outputSchema) {
+    // Before anything opens a socket: a contradictory command line should say so, not report that
+    // the daemon is unreachable. Full provider/model resolution still happens after connecting,
+    // because it needs the host.
+    assertNoConflictingModelInputs(options.provider, options.model);
     if (!prompt || prompt.trim().length === 0) {
         throw {
             code: "MISSING_PROMPT",

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

@@ -13,6 +13,7 @@ export interface AgentSendOptions extends CommandOptions {
     image?: string[];
     prompt?: string;
     promptFile?: string;
+    queue?: boolean;
 }
 export declare function addSendOptions(cmd: Command): Command;
 export declare function runSendCommand(agentIdArg: string, prompt: string | undefined, options: AgentSendOptions, _command: Command): Promise<SingleResult<AgentSendResult>>;

package/dist/commands/agent/send.js

@@ -19,7 +19,8 @@ export function addSendOptions(cmd) {
         .option("--prompt <text>", "Provide the message inline as a flag")
         .option("--prompt-file <path>", "Read the message from a UTF-8 text file")
         .option("--image <path>", "Attach image(s) to the message", collectMultiple, [])
-        .option("--no-wait", "Return immediately without waiting for completion");
+        .option("--no-wait", "Return immediately without waiting for completion")
+        .option("--queue", "If the agent is busy, run this after its current turn instead of interrupting it");
 }
 /**
  * Read image files and convert them to base64 data URIs
@@ -148,7 +149,24 @@ export async function runSendCommand(agentIdArg, prompt, options, _command) {
         // Read image files if provided
         const images = options.image && options.image.length > 0 ? await readImageFiles(options.image) : undefined;
         // Send the message
-        await client.sendAgentMessage(agentIdArg, promptInput, { images });
+        const dispatch = await client.sendAgentMessage(agentIdArg, promptInput, {
+            images,
+            ...(options.queue ? { delivery: "queue" } : {}),
+        });
+        // A queued message has no run to wait for yet — it starts when the current
+        // turn ends, so report it and return rather than blocking on --wait.
+        if (dispatch.queued) {
+            await client.close();
+            return {
+                type: "single",
+                data: {
+                    agentId: agentIdArg,
+                    status: "sent",
+                    message: "Agent is busy; message queued to run as its next turn",
+                },
+                schema: agentSendSchema,
+            };
+        }
         // If --no-wait, return immediately
         if (options.wait === false) {
             await client.close();

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

@@ -7,5 +7,18 @@ export interface ResolvedProviderModel {
     provider: string;
     model: string | undefined;
 }
+/**
+ * The one provider/model check that needs no daemon: `--provider a/b --model c` is contradictory
+ * on its face.
+ *
+ * Callers run this **before** connecting. Full resolution happens after a connection because it
+ * consults the host (personalities, defaults), so leaving this check there meant a plainly
+ * malformed command line reported "Cannot connect to daemon" instead of the real problem — and
+ * only on machines without a daemon running, which is why it read as a CI-only failure.
+ *
+ * Silent when either input is absent or they agree; `resolveProviderAndModel` still repeats the
+ * check for callers that reach it directly.
+ */
+export declare function assertNoConflictingModelInputs(provider?: string, model?: string): void;
 export declare function resolveProviderAndModel(options: ResolveProviderAndModelOptions): ResolvedProviderModel;
 //# sourceMappingURL=provider-model.d.ts.map

package/dist/utils/provider-model.js

@@ -1,3 +1,36 @@
+/**
+ * The one provider/model check that needs no daemon: `--provider a/b --model c` is contradictory
+ * on its face.
+ *
+ * Callers run this **before** connecting. Full resolution happens after a connection because it
+ * consults the host (personalities, defaults), so leaving this check there meant a plainly
+ * malformed command line reported "Cannot connect to daemon" instead of the real problem — and
+ * only on machines without a daemon running, which is why it read as a CI-only failure.
+ *
+ * Silent when either input is absent or they agree; `resolveProviderAndModel` still repeats the
+ * check for callers that reach it directly.
+ */
+export function assertNoConflictingModelInputs(provider, model) {
+    const providerInput = provider?.trim();
+    const modelInput = model?.trim();
+    if (!providerInput || !modelInput) {
+        return;
+    }
+    const slashIndex = providerInput.indexOf("/");
+    if (slashIndex === -1) {
+        return;
+    }
+    const modelFromProvider = providerInput.slice(slashIndex + 1).trim();
+    if (!modelFromProvider || modelFromProvider === modelInput) {
+        return;
+    }
+    const error = {
+        code: "CONFLICTING_MODEL_OPTIONS",
+        message: "Conflicting model values provided",
+        details: `--provider specifies model ${modelFromProvider}, but --model specifies ${modelInput}`,
+    };
+    throw error;
+}
 export function resolveProviderAndModel(options) {
     const providerInput = options.provider?.trim() || options.defaultProvider;
     const modelInput = options.model?.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/cli",
-  "version": "0.6.6",
+  "version": "0.7.0",
   "description": "Otto CLI - control your AI coding agents from the command line",
   "license": "AGPL-3.0-or-later",
   "bin": {
@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@otto-code/client": "0.6.6",
-    "@otto-code/protocol": "0.6.6",
-    "@otto-code/server": "0.6.6",
+    "@otto-code/client": "0.7.0",
+    "@otto-code/protocol": "0.7.0",
+    "@otto-code/server": "0.7.0",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",