@townco/cli 0.1.82 → 0.1.83

package/dist/commands/batch-wrapper.d.ts

@@ -0,0 +1,26 @@
+declare const _default: {
+    def: import("@optique/core").Parser<{
+        readonly command: "batch";
+        readonly name: string;
+        readonly queries: readonly string[];
+        readonly file: string | undefined;
+        readonly concurrency: number | undefined;
+        readonly port: number | undefined;
+    }, ["matched", string] | ["parsing", {
+        readonly command: "batch";
+        readonly name: import("@optique/core").ValueParserResult<string> | undefined;
+        readonly queries: readonly (import("@optique/core").ValueParserResult<string> | undefined)[];
+        readonly file: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
+        readonly concurrency: [import("@optique/core").ValueParserResult<number> | undefined] | undefined;
+        readonly port: [import("@optique/core").ValueParserResult<number> | undefined] | undefined;
+    }] | undefined>;
+    impl: (def: {
+        readonly command: "batch";
+        readonly name: string;
+        readonly queries: readonly string[];
+        readonly file: string | undefined;
+        readonly concurrency: number | undefined;
+        readonly port: number | undefined;
+    }) => unknown;
+};
+export default _default;

package/dist/commands/batch-wrapper.js

@@ -0,0 +1,35 @@
+import { argument, command, constant, message, multiple, object, option, optional, string, } from "@optique/core";
+import { integer } from "@optique/core/valueparser";
+import { createCommand } from "@/lib/command";
+import { batchCommand } from "./batch";
+export default createCommand({
+    def: command("batch", object({
+        command: constant("batch"),
+        name: argument(string({ metavar: "NAME" })),
+        queries: multiple(argument(string({ metavar: "QUERY" }))),
+        file: optional(option("-f", "--file", string())),
+        concurrency: optional(option("-c", "--concurrency", integer())),
+        port: optional(option("-p", "--port", integer())),
+    }), {
+        brief: message `Run multiple queries in parallel against an agent.`,
+        description: message `Run multiple queries in parallel, each in its own session. Queries can be provided as arguments or loaded from a file.`,
+    }),
+    impl: async ({ name, queries, file, concurrency, port }) => {
+        const options = {
+            name,
+        };
+        if (queries.length > 0) {
+            options.queries = [...queries]; // Convert readonly array to mutable
+        }
+        if (file !== null && file !== undefined) {
+            options.file = file;
+        }
+        if (concurrency !== null && concurrency !== undefined) {
+            options.concurrency = concurrency;
+        }
+        if (port !== null && port !== undefined) {
+            options.port = port;
+        }
+        await batchCommand(options);
+    },
+});

package/dist/commands/batch.js

@@ -183,7 +183,7 @@ export async function batchCommand(options) {
             try {
                 process.kill(-agentProcess.pid, "SIGINT");
             }
-            catch (e) {
+            catch (_e) {
                 // Process may already be dead
             }
         }
@@ -191,7 +191,7 @@ export async function batchCommand(options) {
             try {
                 process.kill(-debuggerProcess.pid, "SIGKILL");
             }
-            catch (e) {
+            catch (_e) {
                 // Process may already be dead
             }
         }

package/dist/commands/create-wrapper.d.ts

@@ -0,0 +1,29 @@
+declare const _default: {
+    def: import("@optique/core").Parser<{
+        readonly command: "create";
+        readonly name: string | undefined;
+        readonly model: string | undefined;
+        readonly tools: readonly string[];
+        readonly systemPrompt: string | undefined;
+        readonly init: string | undefined;
+        readonly claude: true | undefined;
+    }, ["matched", string] | ["parsing", {
+        readonly command: "create";
+        readonly name: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
+        readonly model: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
+        readonly tools: readonly (import("@optique/core").ValueParserResult<string> | undefined)[];
+        readonly systemPrompt: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
+        readonly init: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
+        readonly claude: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
+    }] | undefined>;
+    impl: (def: {
+        readonly command: "create";
+        readonly name: string | undefined;
+        readonly model: string | undefined;
+        readonly tools: readonly string[];
+        readonly systemPrompt: string | undefined;
+        readonly init: string | undefined;
+        readonly claude: true | undefined;
+    }) => unknown;
+};
+export default _default;

package/dist/commands/create-wrapper.js

@@ -0,0 +1,92 @@
+import { join } from "node:path";
+import { command, constant, flag, message, multiple, object, option, optional, string, } from "@optique/core";
+import { initForClaudeCode } from "@townco/agent/scaffold";
+import { isInsideTownProject } from "@townco/agent/storage";
+import inquirer from "inquirer";
+import { createCommand } from "@/lib/command";
+import { createCommand as createAgentCommand } from "./create";
+import { createProjectCommand } from "./create-project";
+export default createCommand({
+    def: command("create", object({
+        command: constant("create"),
+        name: optional(option("-n", "--name", string())),
+        model: optional(option("-m", "--model", string())),
+        tools: multiple(option("-t", "--tool", string())),
+        systemPrompt: optional(option("-p", "--prompt", string())),
+        init: optional(option("--init", string())),
+        claude: optional(flag("--claude")),
+    }), {
+        brief: message `Create a new agent or project (with --init <path>). Use --claude to add Claude Code integration.`,
+    }),
+    impl: async ({ name, model, tools, systemPrompt, init, claude }) => {
+        // Handle --claude flag (initialize .claude in existing project)
+        if (claude === true) {
+            if (init !== null && init !== undefined) {
+                console.error("Error: --claude flag is redundant with --init (projects include .claude by default)");
+                process.exit(1);
+            }
+            // Check if we're in a Town project
+            const projectRoot = await isInsideTownProject();
+            if (projectRoot === null) {
+                console.error("Error: Not inside a Town project. Use 'town create --init <path>' to create a new project.");
+                process.exit(1);
+            }
+            // Initialize .claude directory only
+            await initForClaudeCode(projectRoot);
+            console.log("\n✓ Claude Code workspace initialized successfully!");
+            return;
+        }
+        // Check if --init flag is present for project scaffolding
+        if (init !== null && init !== undefined) {
+            // Project mode - scaffold a standalone project
+            await createProjectCommand({
+                path: init,
+            });
+        }
+        else {
+            // Check if we're inside a Town project
+            const projectRoot = await isInsideTownProject();
+            if (projectRoot === null) {
+                // Not in a project - prompt user to initialize
+                const answer = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "initProject",
+                        message: "Not inside a Town project. Initialize project in current directory?",
+                        default: true,
+                    },
+                ]);
+                if (answer.initProject) {
+                    // Initialize project first
+                    await createProjectCommand({ path: process.cwd() });
+                    // Then create agent
+                    await createAgentCommand({
+                        ...(name !== undefined && { name }),
+                        ...(model !== undefined && { model }),
+                        ...(tools.length > 0 && { tools }),
+                        ...(systemPrompt !== undefined && { systemPrompt }),
+                        agentsDir: join(process.cwd(), "agents"),
+                    });
+                }
+                else {
+                    // User declined
+                    console.log("\nPlease run 'town create' inside a project directory, or run:\n" +
+                        "  town create --init <path>\n" +
+                        "to create a project.");
+                    process.exit(1);
+                }
+            }
+            else {
+                // Agent mode - create agent in existing project
+                // Create command starts a long-running Ink session
+                await createAgentCommand({
+                    ...(name !== undefined && { name }),
+                    ...(model !== undefined && { model }),
+                    ...(tools.length > 0 && { tools }),
+                    ...(systemPrompt !== undefined && { systemPrompt }),
+                    agentsDir: join(projectRoot, "agents"),
+                });
+            }
+        }
+    },
+});

package/dist/commands/create.js

@@ -1,10 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { scaffoldAgent } from "@townco/agent/scaffold";
-import { InputBox, MultiSelect, SingleSelect } from "@townco/ui/tui";
+import { MultiSelect, SingleSelect } from "@townco/ui/tui";
 import { Box, render, Text, useInput } from "ink";
 import TextInput from "ink-text-input";
 import { useEffect, useState } from "react";
-import { openInEditor } from "../lib/editor-utils";
 const AVAILABLE_MODELS = [
     {
         label: "Claude Sonnet 4.5",
@@ -65,7 +64,11 @@ function NameInput({ nameInput, setNameInput, onSubmit }) {
             process.exit(0);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Enter agent name:" }) }), _jsxs(Box, { children: [_jsxs(Text, { children: [">", " "] }), _jsx(TextInput, { value: nameInput, onChange: setNameInput, onSubmit: onSubmit })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Continue \u2022 Esc: Cancel" }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [
+            _jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Enter agent name:" }) }), _jsxs(Box, { children: [
+                    _jsxs(Text, { children: [">", " "] }), _jsx(TextInput, { value: nameInput, onChange: setNameInput, onSubmit: onSubmit })
+                ] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Continue \u2022 Esc: Cancel" }) })
+        ] }));
 }
 function CreateApp({ name: initialName, model: initialModel, tools: initialTools, systemPrompt: initialSystemPrompt, overwrite = false, agentsDir, }) {
     // Determine the starting stage based on what's provided
@@ -164,7 +167,8 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
     }
     // Model selection stage
     if (stage === "model") {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Select model for agent: ", agentDef.name] }) }), _jsx(SingleSelect, { options: AVAILABLE_MODELS, selected: agentDef.model || null, onChange: (model) => setAgentDef({ ...agentDef, model }), onSubmit: (model) => {
+        return (_jsxs(Box, { flexDirection: "column", children: [
+                _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Select model for agent: ", agentDef.name] }) }), _jsx(SingleSelect, { options: AVAILABLE_MODELS, selected: agentDef.model || null, onChange: (model) => setAgentDef({ ...agentDef, model }), onSubmit: (model) => {
                         setAgentDef({ ...agentDef, model });
                         if (isEditingFromReview) {
                             setIsEditingFromReview(false);
@@ -180,24 +184,33 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
                         else {
                             setStage("name");
                         }
-                    } })] }));
+                    } })
+            ] }));
     }
     // Tools selection stage
     if (stage === "tools") {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Select tools for agent: ", agentDef.name] }) }), _jsx(MultiSelect, { options: AVAILABLE_TOOLS, selected: agentDef.tools || [], onChange: (tools) => setAgentDef({ ...agentDef, tools }), onSubmit: () => {
+        return (_jsxs(Box, { flexDirection: "column", children: [
+                _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Select tools for agent: ", agentDef.name] }) }), _jsx(MultiSelect, { options: AVAILABLE_TOOLS, selected: agentDef.tools || [], onChange: (tools) => setAgentDef({ ...agentDef, tools }), onSubmit: () => {
                         // If editing from review, just go back to review
                         if (isEditingFromReview) {
                             setIsEditingFromReview(false);
                         }
                         // Go directly to review stage
                         setStage("review");
-                    }, onCancel: () => setStage("model") })] }));
+                    }, onCancel: () => setStage("model") })
+            ] }));
     }
     // Review stage
     if (stage === "review") {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Review Agent Configuration:" }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Name: " }), agentDef.name] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Model: " }), agentDef.model] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Tools: " }), agentDef.tools && agentDef.tools.length > 0
+        return (_jsxs(Box, { flexDirection: "column", children: [
+                _jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Review Agent Configuration:" }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+                        _jsxs(Text, { children: [
+                                _jsx(Text, { bold: true, children: "Name: " }), agentDef.name] }), _jsxs(Text, { children: [
+                                _jsx(Text, { bold: true, children: "Model: " }), agentDef.model] }), _jsxs(Text, { children: [
+                                _jsx(Text, { bold: true, children: "Tools: " }), agentDef.tools && agentDef.tools.length > 0
                                     ? agentDef.tools.join(", ")
-                                    : "none"] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, children: "System Prompt:" }) }), _jsx(Box, { paddingLeft: 2, flexDirection: "column", children: agentDef.systemPrompt?.split("\n").map((line) => (_jsx(Text, { dimColor: true, children: line || " " }, line))) })] }), _jsx(SingleSelect, { options: [
+                                    : "none"] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, children: "System Prompt:" }) }), _jsx(Box, { paddingLeft: 2, flexDirection: "column", children: agentDef.systemPrompt?.split("\n").map((line) => (_jsx(Text, { dimColor: true, children: line || " " }, line))) })
+                    ] }), _jsx(SingleSelect, { options: [
                         {
                             label: "Looks good, continue",
                             value: "continue",
@@ -233,7 +246,8 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
                             setIsEditingFromReview(true);
                             setStage(value);
                         }
-                    }, onCancel: () => setStage("tools") })] }));
+                    }, onCancel: () => setStage("tools") })
+            ] }));
     }
     // Done stage
     if (stage === "done") {
@@ -241,11 +255,23 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
             return (_jsx(Box, { flexDirection: "column", children: _jsxs(Text, { children: ["\u23F3 Creating agent ", agentDef.name, "..."] }) }));
         }
         if (scaffoldStatus === "error") {
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u2717 Error creating agent package" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: scaffoldError }) })] }));
+            return (_jsxs(Box, { flexDirection: "column", children: [
+                    _jsx(Text, { color: "red", children: "\u2717 Error creating agent package" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: scaffoldError }) })
+                ] }));
         }
         if (scaffoldStatus === "done") {
             const modelLabel = agentDef.model?.replace("claude-", "") || "";
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Agent created successfully!" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: "green", children: "\u25CF" }), " ", _jsx(Text, { bold: true, children: agentDef.name })] }), _jsxs(Text, { dimColor: true, children: [" Model: ", modelLabel] }), agentDef.tools && agentDef.tools.length > 0 && (_jsxs(Text, { dimColor: true, children: [" Tools: ", agentDef.tools.join(", ")] })), _jsxs(Text, { dimColor: true, children: [" Path: ", agentPath] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Run agent: town run ", agentDef.name] }), _jsxs(Text, { dimColor: true, children: ["With GUI: town run ", agentDef.name, " --gui"] })] })] }));
+            return (_jsxs(Box, { flexDirection: "column", children: [
+                    _jsx(Text, { bold: true, children: "Agent created successfully!" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+                            _jsxs(Text, { children: [
+                                    _jsx(Text, { color: "green", children: "\u25CF" }),
+                                    " ",
+                                    _jsx(Text, { bold: true, children: agentDef.name })
+                                ] }), _jsxs(Text, { dimColor: true, children: [" Model: ", modelLabel] }), agentDef.tools && agentDef.tools.length > 0 && (_jsxs(Text, { dimColor: true, children: [" Tools: ", agentDef.tools.join(", ")] })), _jsxs(Text, { dimColor: true, children: [" Path: ", agentPath] })
+                        ] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+                            _jsxs(Text, { dimColor: true, children: ["Run agent: town run ", agentDef.name] }), _jsxs(Text, { dimColor: true, children: ["With GUI: town run ", agentDef.name, " --gui"] })
+                        ] })
+                ] }));
         }
     }
     return null;

package/dist/commands/deploy.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    def: import("@optique/core").Parser<{
+        readonly command: "deploy";
+        readonly agent: string;
+    }, ["matched", string] | ["parsing", {
+        readonly command: "deploy";
+        readonly agent: import("@optique/core").ValueParserResult<string> | undefined;
+    }] | undefined>;
+    impl: (def: {
+        readonly command: "deploy";
+        readonly agent: string;
+    }) => unknown;
+};
+export default _default;

package/dist/commands/deploy.js

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import afs from "node:fs/promises";
+import { join } from "node:path";
+import { command, constant, message, object, option, string, } from "@optique/core";
+import { isInsideTownProject } from "@townco/agent/storage";
+import { findRoot } from "@townco/core/path";
+import { createTRPCClient, httpLink, httpSubscriptionLink, splitLink, } from "@trpc/client";
+import archiver from "archiver";
+import { EventSource } from "eventsource";
+import walk from "ignore-walk";
+import superjson from "superjson";
+import { getValidCredentials } from "@/lib/auth-fetch";
+import { createCommand } from "@/lib/command";
+const MAX_ARCHIVE_SIZE = 4.5 * 1024 * 1024; // 4.5MB
+export default createCommand({
+    def: command("deploy", object({
+        command: constant("deploy"),
+        agent: option("-a", "--agent", string()),
+    }), {
+        brief: message `Deploy agents.`,
+        description: message `Deploy agents to the Town cloud.`,
+    }),
+    impl: async ({ agent }) => {
+        const projectRoot = await isInsideTownProject();
+        if (!projectRoot)
+            throw new Error("Not inside a Town project");
+        if (!(await afs.exists(join(projectRoot, "agents", agent))))
+            throw new Error(`Agent ${agent} not found`);
+        const { accessToken, shedUrl } = await getValidCredentials();
+        const authHeader = { Authorization: `Bearer ${accessToken}` };
+        const url = `${shedUrl}/api/trpc`;
+        const baseLinkOpts = { url, transformer: superjson };
+        const client = createTRPCClient({
+            links: [
+                splitLink({
+                    condition: (op) => op.type === "subscription",
+                    true: httpSubscriptionLink({
+                        ...baseLinkOpts,
+                        EventSource,
+                        eventSourceOptions: {
+                            fetch: async (url, init) => fetch(url, {
+                                ...init,
+                                headers: { ...init.headers, ...authHeader },
+                            }),
+                        },
+                    }),
+                    false: httpLink({ ...baseLinkOpts, headers: authHeader }),
+                }),
+            ],
+        });
+        console.log("Creating archive...");
+        const root = await findRoot({ rootMarker: "package.json" });
+        const chunks = [];
+        const arc = archiver("tar", { gzip: true });
+        const done = new Promise((ok, err) => {
+            arc.on("data", (chunk) => chunks.push(chunk));
+            arc.on("end", () => {
+                console.log("Archive created");
+                ok(Buffer.concat(chunks));
+            });
+            arc.on("error", err);
+        });
+        (await walk({ path: root, ignoreFiles: [".gitignore"] }))
+            .filter((path) => path.split("/")[0] !== ".git")
+            .reduce((totalSize, path) => {
+            const stats = fs.statSync(path);
+            if (!stats.isFile())
+                return totalSize;
+            const fileSize = fs.statSync(path).size;
+            const newTotal = totalSize + fileSize;
+            if (newTotal > MAX_ARCHIVE_SIZE) {
+                throw new Error(`Archive size limit exceeded: ${(newTotal / 1024 / 1024).toFixed(2)}MB > 4.5MB`);
+            }
+            arc.append(fs.createReadStream(path), { name: path });
+            return newTotal;
+        }, 0);
+        arc.finalize();
+        console.log("Uploading archive...");
+        const { sha256, cached } = await client.uploadArchive.mutate(await done);
+        console.log(`Archive uploaded: ${sha256} (${cached ? "cached" : "new"})`);
+        console.log("Deploying...");
+        client.deploy.subscribe({ sha256, agent, shedUrl }, {
+            onData: ({ status, error }) => console.log(status ? status : error),
+            onError: (err) => console.error(err),
+            onComplete: () => console.log("\n✓ Deployment complete!"),
+        });
+    },
+});

package/dist/commands/login.js

@@ -80,7 +80,7 @@ export async function loginCommand() {
             console.error(`\nLogin failed: ${errorData.error || "Unknown error"}`);
             if (response.status === 401) {
                 console.log("\nPlease check your email and password and try again.");
-                console.log("If you don't have an account, sign up at " + shedUrl);
+                console.log(`If you don't have an account, sign up at ${shedUrl}`);
             }
             process.exit(1);
         }

package/dist/commands/run-wrapper.d.ts

@@ -0,0 +1,32 @@
+declare const _default: {
+    def: import("@optique/core").Parser<{
+        readonly command: "run";
+        readonly name: string;
+        readonly http: true | undefined;
+        readonly gui: true | undefined;
+        readonly cli: true | undefined;
+        readonly prompt: string | undefined;
+        readonly port: number | undefined;
+        readonly noSession: true | undefined;
+    }, ["matched", string] | ["parsing", {
+        readonly command: "run";
+        readonly name: import("@optique/core").ValueParserResult<string> | undefined;
+        readonly http: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
+        readonly gui: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
+        readonly cli: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
+        readonly prompt: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
+        readonly port: [import("@optique/core").ValueParserResult<number> | undefined] | undefined;
+        readonly noSession: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
+    }] | undefined>;
+    impl: (def: {
+        readonly command: "run";
+        readonly name: string;
+        readonly http: true | undefined;
+        readonly gui: true | undefined;
+        readonly cli: true | undefined;
+        readonly prompt: string | undefined;
+        readonly port: number | undefined;
+        readonly noSession: true | undefined;
+    }) => unknown;
+};
+export default _default;

package/dist/commands/run-wrapper.js

@@ -0,0 +1,32 @@
+import { argument, command, constant, flag, message, object, option, optional, string, } from "@optique/core";
+import { integer } from "@optique/core/valueparser";
+import { createCommand } from "@/lib/command";
+import { runCommand } from "./run.js";
+export default createCommand({
+    def: command("run", object({
+        command: constant("run"),
+        name: argument(string({ metavar: "NAME" })),
+        http: optional(flag("--http")),
+        gui: optional(flag("--gui")),
+        cli: optional(flag("--cli")),
+        prompt: optional(argument(string({ metavar: "PROMPT" }))),
+        port: optional(option("-p", "--port", integer())),
+        noSession: optional(flag("--no-session")),
+    }), { brief: message `Run an agent.` }),
+    impl: async ({ name, http, gui, cli, prompt, port, noSession }) => {
+        const options = {
+            name,
+            http: http === true,
+            gui: gui === true,
+            cli: cli === true,
+            noSession: noSession === true,
+        };
+        if (prompt !== null && prompt !== undefined) {
+            options.prompt = prompt;
+        }
+        if (port !== null && port !== undefined) {
+            options.port = port;
+        }
+        await runCommand(options);
+    },
+});