@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/agent/send.js

@@ -0,0 +1,187 @@
+import { collectMultiple } from "../../utils/command-options.js";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { readFile } from "node:fs/promises";
+import { extname, resolve } from "node:path";
+/** Schema for agent send output */
+export const agentSendSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId", width: 12 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "MESSAGE", field: "message", width: 40 },
+    ],
+};
+export function addSendOptions(cmd) {
+    return cmd
+        .description("Send a message/task to an existing agent")
+        .argument("<id>", "Agent ID (or prefix)")
+        .argument("[prompt]", "The message to send")
+        .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");
+}
+/**
+ * Read image files and convert them to base64 data URIs
+ */
+async function readImageFiles(imagePaths) {
+    return Promise.all(imagePaths.map(async (path) => {
+        try {
+            const buffer = await readFile(path);
+            const ext = extname(path).toLowerCase();
+            let mimeType = "image/jpeg";
+            switch (ext) {
+                case ".png":
+                    mimeType = "image/png";
+                    break;
+                case ".jpg":
+                case ".jpeg":
+                    mimeType = "image/jpeg";
+                    break;
+                case ".gif":
+                    mimeType = "image/gif";
+                    break;
+                case ".webp":
+                    mimeType = "image/webp";
+                    break;
+                default:
+                    mimeType = "image/jpeg";
+            }
+            return { data: buffer.toString("base64"), mimeType };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw {
+                code: "IMAGE_READ_ERROR",
+                message: `Failed to read image file: ${path}`,
+                details: message,
+            };
+        }
+    }));
+}
+async function resolvePromptInput(options) {
+    const promptText = options.promptArgument?.trim();
+    const promptOptionText = options.promptOption?.trim();
+    const promptFilePath = options.promptFile?.trim();
+    const providedSourceCount = [promptText, promptOptionText, promptFilePath].filter(Boolean).length;
+    if (providedSourceCount > 1) {
+        const error = {
+            code: "CONFLICTING_PROMPT_INPUT",
+            message: "Provide exactly one of prompt argument, --prompt, or --prompt-file",
+        };
+        throw error;
+    }
+    if (promptText) {
+        return options.promptArgument;
+    }
+    if (promptOptionText) {
+        return options.promptOption;
+    }
+    if (!promptFilePath) {
+        const error = {
+            code: "MISSING_PROMPT",
+            message: "A prompt is required",
+            details: "Usage: paseo agent send [options] <id> [prompt] | --prompt <text> | --prompt-file <path>",
+        };
+        throw error;
+    }
+    try {
+        return await readFile(resolve(promptFilePath), "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "PROMPT_FILE_READ_ERROR",
+            message: `Failed to read prompt file: ${promptFilePath}`,
+            details: message,
+        };
+        throw error;
+    }
+}
+function buildSendResult(agentIdArg, state) {
+    const agentId = state.final?.id ?? agentIdArg;
+    if (state.status === "timeout") {
+        return { agentId, status: "timeout", message: "Timed out waiting for agent to finish" };
+    }
+    if (state.status === "permission") {
+        return { agentId, status: "permission", message: "Agent is waiting for permission" };
+    }
+    if (state.status === "error") {
+        return {
+            agentId,
+            status: "error",
+            message: state.error ?? "Agent finished with error",
+        };
+    }
+    return { agentId, status: "completed", message: "Agent completed processing the message" };
+}
+export async function runSendCommand(agentIdArg, prompt, 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: paseo agent send [options] <id> [prompt]",
+        };
+        throw error;
+    }
+    const promptInput = await resolvePromptInput({
+        promptArgument: prompt,
+        promptOption: options.prompt,
+        promptFile: options.promptFile,
+    });
+    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: paseo daemon start",
+        };
+        throw error;
+    }
+    try {
+        // 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 });
+        // If --no-wait, return immediately
+        if (options.wait === false) {
+            await client.close();
+            return {
+                type: "single",
+                data: {
+                    agentId: agentIdArg,
+                    status: "sent",
+                    message: "Message sent, not waiting for completion",
+                },
+                schema: agentSendSchema,
+            };
+        }
+        const state = await client.waitForFinish(agentIdArg, 600000); // 10 minute timeout
+        await client.close();
+        return {
+            type: "single",
+            data: buildSendResult(agentIdArg, state),
+            schema: agentSendSchema,
+        };
+    }
+    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: "SEND_FAILED",
+            message: `Failed to send message: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=send.js.map

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

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+/** Result type for agent stop command */
+export interface StopResult {
+    stoppedCount: number;
+    agentIds: string[];
+}
+/** Schema for stop command output */
+export declare const stopSchema: OutputSchema<StopResult>;
+export declare function addStopOptions(cmd: Command): Command;
+export interface AgentStopOptions extends CommandOptions {
+    all?: boolean;
+    cwd?: string;
+}
+export type AgentStopResult = SingleResult<StopResult>;
+export declare function runStopCommand(id: string | undefined, options: AgentStopOptions, _command: Command): Promise<AgentStopResult>;
+//# sourceMappingURL=stop.d.ts.map

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: paseo 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: paseo 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 `paseo 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,51 @@
+import type { Command } from "commander";
+import type { AgentProviderNotice } from "@camerontaylor/paseo-protocol/agent-types";
+import type { AgentSnapshotPayload } from "@camerontaylor/paseo-protocol/messages";
+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;
+    thinkingOptionId: string | null;
+    noticeType: AgentProviderNotice["type"] | null;
+    notice: string | null;
+}
+/** Schema for update command output */
+export declare const updateSchema: OutputSchema<AgentUpdateResult>;
+export interface AgentUpdateOptions extends CommandOptions {
+    name?: string;
+    label?: string[];
+    thinking?: string;
+    host?: string;
+}
+export type AgentUpdateCommandResult = SingleResult<AgentUpdateResult>;
+export interface AgentMetadataChanges {
+    name?: string;
+    labels?: Record<string, string>;
+}
+interface AgentUpdateServerInfo {
+    features?: {
+        agentThinkingUpdate?: boolean;
+    };
+}
+export interface AgentUpdateClient {
+    getLastServerInfoMessage(): AgentUpdateServerInfo | null;
+    updateAgent(agentId: string, updates: AgentMetadataChanges): Promise<void>;
+    setAgentThinkingOption(agentId: string, thinkingOptionId: string): Promise<AgentProviderNotice | null>;
+}
+export type AgentChanges = {
+    type: "metadata";
+    updates: AgentMetadataChanges;
+} | {
+    type: "thinking";
+    thinkingOptionId: string;
+};
+export interface AppliedAgentChanges {
+    notice: AgentProviderNotice | null;
+}
+export declare function toAgentUpdateResult(agent: Pick<AgentSnapshotPayload, "id" | "title" | "labels" | "effectiveThinkingOptionId">, appliedChanges: AppliedAgentChanges): AgentUpdateResult;
+export declare function applyAgentChanges(client: AgentUpdateClient, agentId: string, changes: AgentChanges): Promise<AppliedAgentChanges>;
+export declare function runUpdateCommand(agentIdArg: string, options: AgentUpdateOptions, _command: Command): Promise<AgentUpdateCommandResult>;
+export {};
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/agent/update.js

@@ -0,0 +1,186 @@
+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" },
+        { header: "THINKING", field: "thinkingOptionId" },
+        { header: "NOTICE", field: "notice" },
+    ],
+};
+export function toAgentUpdateResult(agent, appliedChanges) {
+    return {
+        agentId: agent.id,
+        name: agent.title,
+        labels: formatLabels(agent.labels),
+        thinkingOptionId: agent.effectiveThinkingOptionId ?? null,
+        noticeType: appliedChanges.notice?.type ?? null,
+        notice: appliedChanges.notice?.message ?? null,
+    };
+}
+export async function applyAgentChanges(client, agentId, changes) {
+    if (changes.type === "thinking") {
+        // COMPAT(agentThinkingUpdate): added in v0.2.4, remove gate after 2027-01-28.
+        if (client.getLastServerInfoMessage()?.features?.agentThinkingUpdate !== true) {
+            throw {
+                code: "DAEMON_UPDATE_REQUIRED",
+                message: "Update the host to use agent thinking updates.",
+            };
+        }
+        const notice = await client.setAgentThinkingOption(agentId, changes.thinkingOptionId);
+        return { notice };
+    }
+    await client.updateAgent(agentId, changes.updates);
+    return { notice: null };
+}
+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(",");
+}
+function parseAgentChanges(options) {
+    const name = options.name?.trim();
+    if (options.name !== undefined && !name) {
+        throw {
+            code: "INVALID_NAME",
+            message: "Name cannot be empty",
+            details: "Use --name <name> with a non-empty value",
+        };
+    }
+    const labels = parseLabelOptions(options.label);
+    const thinkingOptionId = options.thinking?.trim();
+    if (options.thinking !== undefined && !thinkingOptionId) {
+        throw {
+            code: "INVALID_THINKING_OPTION",
+            message: "--thinking cannot be empty",
+            details: 'Provide a thinking option ID. Use "paseo provider models <provider> --thinking" to list valid IDs.',
+        };
+    }
+    const hasMetadataUpdates = Boolean(name) || Object.keys(labels).length > 0;
+    if (hasMetadataUpdates && thinkingOptionId) {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--thinking cannot be combined with --name or --label",
+            details: "Run separate agent update commands for runtime settings and metadata.",
+        };
+    }
+    if (!hasMetadataUpdates && !thinkingOptionId) {
+        throw {
+            code: "NO_CHANGES_PROVIDED",
+            message: "Nothing to update",
+            details: "Provide at least one of: --name <name>, --label <key=value>, --thinking <id>",
+        };
+    }
+    if (thinkingOptionId) {
+        return { type: "thinking", thinkingOptionId };
+    }
+    return {
+        type: "metadata",
+        updates: {
+            ...(name ? { name } : {}),
+            ...(Object.keys(labels).length > 0 ? { labels } : {}),
+        },
+    };
+}
+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: paseo agent update <id> [--name <name>] [--label <key=value>]",
+        };
+        throw error;
+    }
+    const changes = parseAgentChanges(options);
+    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: paseo 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 "paseo ls" to list available agents',
+            };
+            throw error;
+        }
+        const agentId = fetchResult.agent.id;
+        const appliedChanges = await applyAgentChanges(client, agentId, changes);
+        const updatedResult = await client.fetchAgent({ agentId });
+        if (!updatedResult) {
+            throw new Error(`Agent not found after update: ${agentId}`);
+        }
+        await client.close();
+        return {
+            type: "single",
+            data: toAgentUpdateResult(updatedResult.agent, appliedChanges),
+            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