@townco/cli 0.1.113 → 0.1.115

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

@@ -7,6 +7,7 @@ declare const _default: {
         readonly systemPrompt: string | undefined;
         readonly init: string | undefined;
         readonly claude: true | undefined;
+        readonly yes: true | undefined;
     }, ["matched", string] | ["parsing", {
         readonly command: "create";
         readonly name: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
@@ -15,6 +16,7 @@ declare const _default: {
         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;
+        readonly yes: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
     }] | undefined>;
     impl: (def: {
         readonly command: "create";
@@ -24,6 +26,7 @@ declare const _default: {
         readonly systemPrompt: string | undefined;
         readonly init: string | undefined;
         readonly claude: true | undefined;
+        readonly yes: true | undefined;
     }) => unknown;
 };
 export default _default;

package/dist/commands/create-wrapper.js

@@ -15,10 +15,11 @@ export default createCommand({
         systemPrompt: optional(option("-p", "--prompt", string())),
         init: optional(option("--init", string())),
         claude: optional(flag("--claude")),
+        yes: optional(flag("-y", "--yes")),
     }), {
-        brief: message `Create a new agent or project (with --init <path>). Use --claude to add Claude Code integration.`,
+        brief: message `Create a new agent or project (with --init <path>). Use --claude to add Claude Code integration. Use -y/--yes to skip confirmation prompts.`,
     }),
-    impl: async ({ name, model, tools, systemPrompt, init, claude }) => {
+    impl: async ({ name, model, tools, systemPrompt, init, claude, yes }) => {
         // Handle --claude flag (initialize .claude in existing project)
         if (claude === true) {
             if (init !== null && init !== undefined) {
@@ -65,6 +66,7 @@ export default createCommand({
                         ...(model !== undefined && { model }),
                         ...(tools.length > 0 && { tools }),
                         ...(systemPrompt !== undefined && { systemPrompt }),
+                        ...(yes === true && { yes: true }),
                         agentsDir: join(process.cwd(), "agents"),
                     });
                 }
@@ -84,6 +86,7 @@ export default createCommand({
                     ...(model !== undefined && { model }),
                     ...(tools.length > 0 && { tools }),
                     ...(systemPrompt !== undefined && { systemPrompt }),
+                    ...(yes === true && { yes: true }),
                     agentsDir: join(projectRoot, "agents"),
                 });
             }

package/dist/commands/create.d.ts

@@ -4,6 +4,7 @@ interface CreateCommandProps {
     tools?: readonly string[];
     systemPrompt?: string;
     overwrite?: boolean;
+    yes?: boolean;
     agentsDir: string;
 }
 export declare function createCommand(props: CreateCommandProps): Promise<void>;

package/dist/commands/create.js

@@ -70,9 +70,13 @@ function NameInput({ nameInput, setNameInput, 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, }) {
+function CreateApp({ name: initialName, model: initialModel, tools: initialTools, systemPrompt: initialSystemPrompt, overwrite = false, yes = false, agentsDir, }) {
     // Determine the starting stage based on what's provided
     const determineInitialStage = () => {
+        // If --yes flag is set and we have name and model, skip directly to done
+        if (yes && initialName && initialModel) {
+            return "done";
+        }
         if (!initialName)
             return "name";
         if (!initialModel)

package/dist/commands/doctor/checks.d.ts

@@ -0,0 +1,10 @@
+type CheckStatus = "pass" | "fail" | "warn";
+type CheckCategory = "model" | "mcp";
+export interface CheckResult {
+    category: CheckCategory;
+    name: string;
+    status: CheckStatus;
+    message: string;
+    details?: string;
+}
+export {};

package/dist/commands/doctor/checks.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/doctor/index.d.ts

@@ -0,0 +1,18 @@
+import type { AgentDefinition } from "@townco/agent/definition";
+import type { CheckResult } from "./checks";
+import { type Provider } from "./model-checks";
+interface DoctorResult {
+    agent: string;
+    model: string;
+    provider: Provider;
+    checks: CheckResult[];
+    success: boolean;
+    subagents?: DoctorResult[];
+}
+interface DoctorCommandOptions {
+    name: string;
+    json?: boolean;
+}
+export declare function doctorCommand({ name, json }: DoctorCommandOptions): Promise<void>;
+export declare function runDoctorChecks(agentName: string, definition: AgentDefinition, projectRoot: string, visited?: Set<string>): Promise<DoctorResult>;
+export {};

package/dist/commands/doctor/index.js

@@ -0,0 +1,140 @@
+import { join } from "node:path";
+import { checkAllMcpHealth } from "@townco/agent/mcp";
+import { isInsideTownProject } from "@townco/agent/storage";
+import { checkModel } from "./model-checks";
+export async function doctorCommand({ name, json = false, }) {
+    const projectRoot = await isInsideTownProject();
+    if (!projectRoot) {
+        console.error("Not inside a Town project");
+        process.exit(1);
+    }
+    const agentIndexPath = join(projectRoot, "agents", name, "index.ts");
+    try {
+        const agentModule = (await import(agentIndexPath));
+        const definition = agentModule.default;
+        const result = await runDoctorChecks(name, definition, projectRoot);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            printDoctorResult(result);
+        }
+        if (!result.success) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`Could not load agent definition at ${agentIndexPath}`);
+        if (error instanceof Error) {
+            console.error(`  ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+export async function runDoctorChecks(agentName, definition, projectRoot, visited = new Set()) {
+    // Add current agent to visited set for cycle detection
+    visited.add(agentName);
+    const modelString = definition.model;
+    const { provider, checks: modelChecks } = await checkModel(modelString);
+    const mcpResults = await checkAllMcpHealth(definition.mcps ?? []);
+    const mcpChecks = mcpResults.map((r) => {
+        const base = {
+            category: "mcp",
+            name: r.name,
+            status: r.status,
+            message: r.toolCount ? `${r.message} (${r.toolCount} tools)` : r.message,
+        };
+        return r.details ? { ...base, details: r.details } : base;
+    });
+    const checks = [...modelChecks, ...mcpChecks];
+    const subagentResults = await checkSubagents(definition, projectRoot, visited);
+    const ownSuccess = checks.every((c) => c.status !== "fail");
+    const subagentsSuccess = subagentResults.every((s) => s.success);
+    const result = {
+        agent: agentName,
+        model: modelString,
+        provider,
+        checks,
+        success: ownSuccess && subagentsSuccess,
+    };
+    if (subagentResults.length > 0) {
+        result.subagents = subagentResults;
+    }
+    return result;
+}
+const SUBAGENT_TOOL_NAME = "subagent";
+function extractSubagentNames(definition) {
+    const taskTool = definition.tools?.find((t) => typeof t === "object" &&
+        "type" in t &&
+        t.type === "direct" &&
+        "name" in t &&
+        t.name === SUBAGENT_TOOL_NAME);
+    const configs = taskTool
+        ?.subagentConfigs;
+    return configs?.map((c) => c.agentName) ?? [];
+}
+async function checkSubagents(definition, projectRoot, visited) {
+    const subagentNames = extractSubagentNames(definition);
+    const results = [];
+    for (const name of subagentNames) {
+        if (visited.has(name)) {
+            continue;
+        }
+        const subagentPath = join(projectRoot, "agents", name, "index.ts");
+        try {
+            const subagentModule = (await import(subagentPath));
+            const result = await runDoctorChecks(name, subagentModule.default, projectRoot, visited);
+            results.push(result);
+        }
+        catch (error) {
+            results.push({
+                agent: name,
+                model: "unknown",
+                provider: "unknown",
+                checks: [
+                    {
+                        category: "model",
+                        name: "load",
+                        status: "fail",
+                        message: "Could not load subagent",
+                        details: error instanceof Error ? error.message : "Unknown error",
+                    },
+                ],
+                success: false,
+            });
+        }
+    }
+    return results;
+}
+function formatCheckResult(check) {
+    const icon = check.status === "pass" ? "✓" : check.status === "warn" ? "⚠" : "✗";
+    let line = `${icon} ${check.message}`;
+    if (check.details) {
+        line += ` (${check.details})`;
+    }
+    return line;
+}
+function printDoctorResult(result, indent = 0) {
+    const pad = " ".repeat(indent);
+    console.log(`${pad}Model: ${result.model}`);
+    const modelChecks = result.checks.filter((c) => c.category === "model");
+    const mcpChecks = result.checks.filter((c) => c.category === "mcp");
+    for (const check of modelChecks) {
+        console.log(`${pad}${formatCheckResult(check)}`);
+    }
+    if (mcpChecks.length > 0) {
+        console.log("");
+        console.log(`${pad}MCPs:`);
+        for (const check of mcpChecks) {
+            console.log(`${pad}${formatCheckResult(check)}`);
+        }
+    }
+    if (result.subagents && result.subagents.length > 0) {
+        console.log("");
+        console.log(`${pad}Subagents:`);
+        for (const subagent of result.subagents) {
+            console.log(`${pad}  ${subagent.agent}:`);
+            printDoctorResult(subagent, indent + 4);
+        }
+    }
+}

package/dist/commands/doctor/model-checks.d.ts

@@ -0,0 +1,8 @@
+import type { CheckResult } from "./checks";
+export type Provider = "town" | "anthropic" | "vertex" | "gemini" | "unknown";
+interface ModelCheckResult {
+    provider: Provider;
+    checks: CheckResult[];
+}
+export declare function checkModel(modelString: string): Promise<ModelCheckResult>;
+export {};

package/dist/commands/doctor/model-checks.js

@@ -0,0 +1,205 @@
+import { getShedAuth } from "@townco/core/auth";
+const townModelRegexp = /^town-/;
+const vertexModelRegexp = /^vertex-/;
+const geminiModelRegexp = /^gemini-/;
+const anthropicModelRegexp = /^claude-/;
+const FETCH_TIMEOUT_MS = 5000;
+async function fetchWithTimeout(url, options = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...options, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function detectProvider(modelString) {
+    if (townModelRegexp.test(modelString))
+        return "town";
+    if (vertexModelRegexp.test(modelString))
+        return "vertex";
+    if (geminiModelRegexp.test(modelString))
+        return "gemini";
+    if (anthropicModelRegexp.test(modelString))
+        return "anthropic";
+    return "unknown";
+}
+async function checkTownProxiedModel(modelString) {
+    // Remove "town-" prefix to get the underlying model name
+    const actualModel = modelString.slice(5);
+    const shedAuth = await getShedAuth();
+    if (!shedAuth) {
+        return {
+            category: "model",
+            name: "town-auth",
+            status: "fail",
+            message: "Not logged in",
+            details: "Run 'town login' or set SHED_API_KEY",
+        };
+    }
+    try {
+        const response = await fetchWithTimeout(`${shedAuth.shedUrl}/api/anthropic/v1/models/${actualModel}`, {
+            headers: { "x-api-key": shedAuth.accessToken },
+        });
+        if (response.ok) {
+            return {
+                category: "model",
+                name: "town-api",
+                status: "pass",
+                message: "Model API connected successfully",
+            };
+        }
+        return {
+            category: "model",
+            name: "town-api",
+            status: "fail",
+            message: `Model API returned ${response.status}`,
+            details: `Check shed authentication (${shedAuth.shedUrl})`,
+        };
+    }
+    catch {
+        return {
+            category: "model",
+            name: "town-api",
+            status: "fail",
+            message: "Could not connect to shed",
+            details: shedAuth.shedUrl,
+        };
+    }
+}
+async function checkAnthropicModel(modelString) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        return {
+            category: "model",
+            name: "anthropic-api",
+            status: "fail",
+            message: "ANTHROPIC_API_KEY not set",
+        };
+    }
+    try {
+        const response = await fetchWithTimeout(`https://api.anthropic.com/v1/models/${modelString}`, {
+            headers: {
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+        });
+        if (response.ok) {
+            return {
+                category: "model",
+                name: "anthropic-api",
+                status: "pass",
+                message: "Anthropic API connected successfully",
+            };
+        }
+        return {
+            category: "model",
+            name: "anthropic-api",
+            status: "fail",
+            message: `Anthropic API returned ${response.status}`,
+            details: "Check ANTHROPIC_API_KEY",
+        };
+    }
+    catch {
+        return {
+            category: "model",
+            name: "anthropic-api",
+            status: "fail",
+            message: "Could not connect to Anthropic API",
+        };
+    }
+}
+function checkVertexModel() {
+    if (!process.env.VERTEX_CREDENTIALS) {
+        return {
+            category: "model",
+            name: "vertex-credentials",
+            status: "fail",
+            message: "VERTEX_CREDENTIALS not set",
+        };
+    }
+    try {
+        JSON.parse(process.env.VERTEX_CREDENTIALS);
+        return {
+            category: "model",
+            name: "vertex-credentials",
+            status: "pass",
+            message: "VERTEX_CREDENTIALS is valid JSON",
+        };
+    }
+    catch {
+        return {
+            category: "model",
+            name: "vertex-credentials",
+            status: "fail",
+            message: "VERTEX_CREDENTIALS is invalid JSON",
+        };
+    }
+}
+async function checkGeminiModel() {
+    const apiKey = process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+        return {
+            category: "model",
+            name: "gemini-api",
+            status: "fail",
+            message: "GEMINI_API_KEY not set",
+        };
+    }
+    try {
+        const response = await fetchWithTimeout(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
+        if (response.ok) {
+            return {
+                category: "model",
+                name: "gemini-api",
+                status: "pass",
+                message: "Gemini API connected successfully",
+            };
+        }
+        return {
+            category: "model",
+            name: "gemini-api",
+            status: "fail",
+            message: `Gemini API returned ${response.status}`,
+            details: "Check GEMINI_API_KEY",
+        };
+    }
+    catch {
+        return {
+            category: "model",
+            name: "gemini-api",
+            status: "fail",
+            message: "Could not connect to Gemini API",
+        };
+    }
+}
+export async function checkModel(modelString) {
+    const provider = detectProvider(modelString);
+    let checks;
+    switch (provider) {
+        case "town":
+            checks = [await checkTownProxiedModel(modelString)];
+            break;
+        case "anthropic":
+            checks = [await checkAnthropicModel(modelString)];
+            break;
+        case "vertex":
+            checks = [checkVertexModel()];
+            break;
+        case "gemini":
+            checks = [await checkGeminiModel()];
+            break;
+        case "unknown":
+            checks = [
+                {
+                    category: "model",
+                    name: "unknown",
+                    status: "fail",
+                    message: `Unknown model format: ${modelString}`,
+                },
+            ];
+            break;
+    }
+    return { provider, checks };
+}

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

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

package/dist/commands/doctor-wrapper.js

@@ -0,0 +1,17 @@
+import { argument, command, constant, flag, message, object, optional, string, } from "@optique/core";
+import { createCommand } from "../lib/command";
+import { doctorCommand } from "./doctor";
+export default createCommand({
+    def: command("doctor", object({
+        command: constant("doctor"),
+        name: argument(string({ metavar: "NAME" }), {
+            description: message `Name of the agent to diagnose`,
+        }),
+        json: optional(flag("--json", {
+            description: message `Output results as JSON`,
+        })),
+    }), { brief: message `Run diagnostics on an agent.` }),
+    impl: async ({ name, json }) => {
+        await doctorCommand({ name, json: json ?? false });
+    },
+});

package/dist/index.js

@@ -7,6 +7,7 @@ import batchCmd from "./commands/batch-wrapper";
 import { configureCommand } from "./commands/configure";
 import createCmd from "./commands/create-wrapper";
 import deployCmd from "./commands/deploy";
+import doctorCmd from "./commands/doctor-wrapper";
 import { loginCommand } from "./commands/login";
 import runCmd from "./commands/run-wrapper";
 import secretCmd from "./commands/secret";
@@ -14,7 +15,7 @@ import { upgradeCommand } from "./commands/upgrade";
 import { whoamiCommand } from "./commands/whoami";
 const parser = or(batchCmd.def, command("configure", constant("configure"), {
     brief: message `Configure environment variables.`,
-}), command("login", constant("login"), { brief: message `Log in to Town Shed.` }), command("upgrade", constant("upgrade"), {
+}), doctorCmd.def, command("login", constant("login"), { brief: message `Log in to Town Shed.` }), command("upgrade", constant("upgrade"), {
     brief: message `Upgrade dependencies by cleaning and reinstalling.`,
 }), command("whoami", constant("whoami"), {
     brief: message `Show current login status.`,
@@ -35,6 +36,7 @@ const main = async (parser, meta) => await match(run(parser, meta))
     .with({ command: "batch" }, batchCmd.impl)
     .with({ command: "create" }, createCmd.impl)
     .with({ command: "deploy" }, deployCmd.impl)
+    .with({ command: "doctor" }, doctorCmd.impl)
     .with({ command: "run" }, runCmd.impl)
     .with({ command: "secret" }, secretCmd.impl)
     .exhaustive();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.113",
+  "version": "0.1.115",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -15,7 +15,7 @@
     "build": "tsgo"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.105",
+    "@townco/tsconfig": "0.1.107",
     "@types/archiver": "^7.0.0",
     "@types/bun": "^1.3.1",
     "@types/ignore-walk": "^4.0.3",
@@ -24,13 +24,13 @@
   "dependencies": {
     "@optique/core": "^0.6.2",
     "@optique/run": "^0.6.2",
-    "@townco/agent": "0.1.116",
-    "@townco/apiclient": "0.0.28",
-    "@townco/core": "0.0.86",
-    "@townco/debugger": "0.1.64",
-    "@townco/env": "0.1.58",
-    "@townco/secret": "0.1.108",
-    "@townco/ui": "0.1.108",
+    "@townco/agent": "0.1.118",
+    "@townco/apiclient": "0.0.30",
+    "@townco/core": "0.0.88",
+    "@townco/debugger": "0.1.66",
+    "@townco/env": "0.1.60",
+    "@townco/secret": "0.1.110",
+    "@townco/ui": "0.1.110",
     "@trpc/client": "^11.7.2",
     "archiver": "^7.0.1",
     "eventsource": "^4.1.0",