@botbotgo/kit 1.0.106

package/dist/utils/cli/index.js

@@ -0,0 +1,677 @@
+#!/usr/bin/env node
+import { initProject, buildMCPPackage, runMCPServer } from '../../chunk-4OOTCNR7.js';
+import { findAndLoadToolConfig, getToolSourceDescriptors, resolveToolDescriptor, runMCPServerOverStdio, createMCPServerStreamableHttp, createHttpService, resolveSandboxedPath, createRuntimeFromConfig, getDisplayScope } from '../../chunk-JH4ZF3FN.js';
+import '../../chunk-GGFAGLDC.js';
+import '../../chunk-IVL4TBFB.js';
+import '../../chunk-BDUSB6GT.js';
+import { enrichSpecWithCanonicalSchema } from '../../chunk-NTWOVFEY.js';
+import * as path2 from 'path';
+import path2__default from 'path';
+import { realpathSync } from 'fs';
+import { fileURLToPath } from 'url';
+import * as fs from 'fs/promises';
+
+function toPackageName(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function packageJsonTemplate(packageName) {
+  return `{
+  "name": "${packageName}",
+  "version": "0.0.1",
+  "description": "Tools extension for @botbotgo/kit",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsx generate-manifest.ts && tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "pretest": "npm run build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@botbotgo/kit": "latest"
+  },
+  "peerDependencies": {
+    "@botbotgo/kit": "*"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.2",
+    "typescript": "~5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "license": "MIT"
+}
+`;
+}
+function tsconfigTemplate() {
+  return `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/dist/**"]
+}
+`;
+}
+function tsconfigBuildTemplate() {
+  return `{
+  "extends": "./tsconfig.json",
+  "compilerOptions": { "rootDir": ".", "outDir": "dist" },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/dist/**", "**/tsconfig*.json", "**/*.test.ts", "test", "scripts", "generate-manifest.ts"]
+}
+`;
+}
+function generateManifestTemplate() {
+  return `/**
+ * Build step: run framework generateManifest (scan src, emit manifest).
+ * Tool names in the manifest are the exported function names.
+ */
+import { generateManifest } from "@botbotgo/kit/sdk";
+
+generateManifest(process.cwd());
+`;
+}
+function extensionIndexTemplate() {
+  return `import { createExtension } from "@botbotgo/kit/sdk";
+import type { ToolRegistry, ToolAdapter } from "@botbotgo/kit/sdk";
+
+const ext = createExtension({ importMeta: import.meta });
+
+/** Framework contract: extension exports register(registry, options). */
+export function register(
+  registry: ToolRegistry,
+  options?: { only?: string[]; namePrefixes?: string[] },
+): ToolAdapter {
+  return ext.register(registry, options ?? {});
+}
+
+export const getExtensionContext = ext.getContext;
+export const runWithExtensionContext = ext.runWith;
+`;
+}
+function helloWorldTemplate() {
+  return `/**
+ * A simple hello-world tool.
+ * @tool
+ * @effect none
+ */
+export async function helloWorld(_args: Record<string, unknown>) {
+  return {
+    result: { message: "Hello, World!" },
+    evidence: [
+      {
+        type: "tool",
+        ref: "helloWorld",
+        summary: "Hello, World!",
+        createdAt: new Date().toISOString(),
+      },
+    ],
+  };
+}
+`;
+}
+function readmeTemplate(packageName) {
+  return `# ${packageName}
+
+Scaffolded by \`agent-tool init ${packageName}\`.
+
+## Quick start
+
+\`\`\`bash
+npm install
+npm run build
+\`\`\`
+
+Add more tools under \`src/\` (export async functions with \`@tool\` JSDoc), then \`npm run build\` again.
+
+## Use in tool config
+
+In your \`tool.yaml\`:
+
+\`\`\`yaml
+tools:
+  file:./path/to/${packageName}: {}
+\`\`\`
+
+Or publish and use: \`npm:@your-scope/${packageName}\`
+`;
+}
+function templates(packageName) {
+  return {
+    "package.json": packageJsonTemplate(packageName),
+    "tsconfig.json": tsconfigTemplate(),
+    "tsconfig.build.json": tsconfigBuildTemplate(),
+    "generate-manifest.ts": generateManifestTemplate(),
+    "index.ts": extensionIndexTemplate(),
+    "src/helloWorld.ts": helloWorldTemplate(),
+    "README.md": readmeTemplate(packageName)
+  };
+}
+async function initExtension(options) {
+  const parent = path2.resolve(options.parentDir ?? process.cwd());
+  const name = options.extensionName.trim();
+  if (!name) {
+    throw new Error("Extension name is required");
+  }
+  const targetPath = path2.join(parent, name);
+  const baseName = toPackageName(name) || name.replace(/\s/g, "-").toLowerCase();
+  const scopeNorm = options.scope?.trim().replace(/^@/, "") || "";
+  const packageName = scopeNorm ? `@${scopeNorm}/${baseName}` : baseName;
+  const filesCreated = [];
+  const tmpl = templates(packageName);
+  await fs.mkdir(targetPath, { recursive: true });
+  for (const [relPath, content] of Object.entries(tmpl)) {
+    const fullPath = path2.join(targetPath, relPath);
+    await fs.mkdir(path2.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content.trimStart(), "utf8");
+    filesCreated.push(relPath);
+  }
+  return { targetPath, filesCreated };
+}
+
+// src/utils/cli/help.ts
+function printHelp(bin = "agent-tool") {
+  process.stdout.write(`
+Usage: ${bin} <command> [options] [args]
+
+Primary commands:
+  ls                      List all tools (scope, name, description).
+  describe <tool path>    Show tool details (schema, capabilities, etc.).
+  run <tool path> [params] Run a tool. Params: JSON, e.g. '{"path":"README.md"}'
+  start mcp                Start MCP server (default: Streamable HTTP; use --stdio for stdio).
+  start http               Start OpenAPI HTTP server (API + Swagger).
+
+Other commands:
+  init [extension name]   Create extension scaffold (folder + src + hello-world + generate-manifest + index + package.json). With no name: create MCP project in --path. Then: cd <folder> && npm install && npm run build.
+  build                   Scan folder for @tool / SKILL / n8n, generate MCP npm package.
+  serve                   Start the generated MCP server (stdio) for testing.
+  list                    Alias for ls.
+  show <tool>             Alias for describe.
+  help                    Show this help.
+
+Options:
+  --path, -p <path>       For init/build/serve: path (default: cwd).
+  --scope, -s <scope>     For init [extension name]: npm package scope (e.g. wallee \u2192 @wallee/<name>).
+  --out, -o <path>        For build: output directory.
+  --include, -i <glob>    For build: glob for TS files.
+  --include-n8n           For build: include n8n workflow tools.
+  --verbose, -v            Print step logs (config load, cache, tools registered).
+  --stdio                  For start mcp: use stdio transport (default: Streamable HTTP).
+  --port <number>         For start mcp/http: port (default: 3000).
+  --host <string>         For start mcp/http: host (default: 127.0.0.1).
+  --help, -h              Show this help.
+
+Examples:
+  ${bin} ls
+  ${bin} describe core.fs.readText
+  ${bin} run core.fs.readText '{"path":"README.md"}'
+  ${bin} start mcp
+  ${bin} start mcp --stdio
+  ${bin} start http --port 3000
+  ${bin} build --path . --out dist
+  ${bin} init my-extension
+
+For agent run (ReAct + agent.yaml): use your BotBotGo runtime entrypoint or app wrapper
+`);
+}
+
+// src/utils/cli/index.ts
+var DEFAULT_CORE_CONFIG = {
+  sandboxRoot: process.cwd(),
+  enableSandboxValidation: false};
+async function getRuntimeWithTools(pathOpt, verbose = false) {
+  const cwd = process.cwd();
+  const searchDir = path2__default.resolve(cwd, pathOpt ?? ".");
+  const stepLog = verbose ? (msg) => process.stderr.write(`[agent-tool] ${msg}
+`) : void 0;
+  if (stepLog) stepLog(`Loading tool config from ${searchDir}`);
+  const config = findAndLoadToolConfig(searchDir);
+  let sandboxRoot = cwd;
+  if (config.sandboxedPath && typeof config.sandboxedPath === "string" && config.configPath) {
+    sandboxRoot = resolveSandboxedPath(config.configPath, config.sandboxedPath);
+  }
+  if (stepLog) {
+    if (config.configPath) {
+      const n = getToolSourceDescriptors(config).length;
+      stepLog(`Config: ${config.configPath} (${n} tool(s)), sandbox: ${sandboxRoot}`);
+    } else {
+      stepLog("No tool.yaml found");
+    }
+  }
+  const coreConfig = {
+    sandboxRoot,
+    enableSandboxValidation: config.enableSandboxValidation ?? DEFAULT_CORE_CONFIG.enableSandboxValidation,
+    allowedHosts: []
+  };
+  const result = await createRuntimeFromConfig({
+    coreTools: coreConfig,
+    configFilePath: config.configPath,
+    stepLog
+  });
+  if (stepLog) stepLog(`Registered ${result.registry.snapshot().length} tool(s)`);
+  return result;
+}
+function parseToolName(fullName) {
+  const i = fullName.indexOf("/");
+  if (i < 0) return { scope: "", name: fullName };
+  return { scope: fullName.slice(0, i), name: fullName.slice(i + 1) };
+}
+function parseArgv(argv) {
+  const args = argv.slice(2);
+  let command = "help";
+  let startSub = "http";
+  let help = false;
+  let verbose = false;
+  let mcpStdio = false;
+  let pathOpt = "";
+  let extensionName = "";
+  let scope = "";
+  let outDir = "";
+  let include = [];
+  let includeN8n = false;
+  let toolName = "";
+  let toolArgsJson = "{}";
+  let port = 3e3;
+  let host = "127.0.0.1";
+  const commands = [
+    "init",
+    "build",
+    "serve",
+    "list",
+    "ls",
+    "show",
+    "describe",
+    "run",
+    "start",
+    "help"
+  ];
+  const startSubcommands = ["mcp", "http"];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg === "--verbose" || arg === "-v") {
+      verbose = true;
+    } else if (arg === "--stdio") {
+      mcpStdio = true;
+    } else if (arg === "--path" || arg === "-p") {
+      pathOpt = path2__default.resolve(process.cwd(), args[++i] ?? "");
+    } else if (arg === "--out" || arg === "-o") {
+      outDir = path2__default.resolve(process.cwd(), args[++i] ?? "");
+    } else if (arg === "--include" || arg === "-i") {
+      const v = args[++i];
+      if (v) include.push(v);
+    } else if (arg === "--include-n8n") {
+      includeN8n = true;
+    } else if (arg === "--port") {
+      const v = args[++i];
+      if (v !== void 0) port = parseInt(v, 10) || 3e3;
+    } else if (arg === "--host") {
+      const v = args[++i];
+      if (v !== void 0) host = v;
+    } else if (arg === "--scope" || arg === "-s") {
+      scope = args[++i] ?? "";
+    } else if (arg && !arg.startsWith("-") && commands.includes(arg)) {
+      command = arg;
+      const nextArg = args[i + 1];
+      if (command === "init" && nextArg !== void 0 && !nextArg.startsWith("-")) {
+        extensionName = args[++i] ?? "";
+      } else if ((command === "show" || command === "describe") && nextArg !== void 0 && !nextArg.startsWith("-")) {
+        toolName = args[++i] ?? "";
+      } else if (command === "run" && nextArg !== void 0 && !nextArg.startsWith("-")) {
+        toolName = args[++i] ?? "";
+        const runNext = args[i + 1];
+        if (runNext !== void 0 && !runNext.startsWith("-")) {
+          toolArgsJson = args[++i] ?? "{}";
+        }
+      } else if (command === "start" && nextArg !== void 0 && !nextArg.startsWith("-") && startSubcommands.includes(nextArg)) {
+        startSub = args[++i];
+      }
+    }
+  }
+  return { command, startSub, help, verbose, mcpStdio, pathOpt, extensionName, scope, outDir, include, includeN8n, toolName, toolArgsJson, port, host };
+}
+async function cmdInitExtension(extensionName, pathOpt, scope) {
+  try {
+    const parentDir = pathOpt ? path2__default.resolve(process.cwd(), pathOpt) : void 0;
+    const { targetPath, filesCreated } = await initExtension({
+      extensionName,
+      parentDir: parentDir || process.cwd(),
+      scope: scope || void 0
+    });
+    process.stdout.write(
+      `Extension scaffold at ${targetPath}
+Created: ${filesCreated.join(", ")}
+Next: cd ${path2__default.basename(targetPath)} && npm install && npm run build
+`
+    );
+    return 0;
+  } catch (err) {
+    process.stderr.write(`Init extension failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function cmdInit(pathOpt) {
+  try {
+    const { targetPath, filesCreated } = await initProject({ targetPath: pathOpt || void 0 });
+    process.stdout.write(`Initialized project at ${targetPath}
+Created: ${filesCreated.join(", ")}
+Next: npm install && npm run build
+`);
+    return 0;
+  } catch (err) {
+    process.stderr.write(`Init failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function cmdBuild(pathOpt, outDir, include, includeN8n) {
+  try {
+    const result = await buildMCPPackage({
+      projectPath: pathOpt || void 0,
+      outDir: outDir || void 0,
+      include: include.length > 0 ? include : void 0,
+      includeN8n: includeN8n || void 0
+    });
+    process.stdout.write(
+      `Built ${result.toolCount} tool(s) -> ${result.outDir}
+Entry: ${result.entryPath}
+mcp.json: ${result.mcpJsonPath}
+`
+    );
+    return 0;
+  } catch (err) {
+    process.stderr.write(`Build failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function cmdServe(pathOpt) {
+  try {
+    const { process: child } = await runMCPServer({ path: pathOpt || void 0 });
+    child.stdin?.pipe(process.stdin);
+    child.stdout?.pipe(process.stdout);
+    process.stdin?.unref();
+    const exit = new Promise((resolve2) => {
+      child.on("close", (code) => resolve2(code ?? 0));
+    });
+    return exit;
+  } catch (err) {
+    process.stderr.write(`Serve failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+var LS_DESC_MAX = 72;
+function formatLsOutput(specs) {
+  const rows = specs.map((spec) => {
+    const { name } = parseToolName(spec.name);
+    const scope = getDisplayScope(spec.name, spec.kind, spec.version);
+    const desc = (spec.description ?? "").replace(/\n/g, " ").trim().slice(0, LS_DESC_MAX);
+    return { scope, name, description: desc || "(no description)" };
+  });
+  const scopeW = Math.max(6, ...rows.map((r) => r.scope.length));
+  const nameW = Math.max(4, ...rows.map((r) => r.name.length));
+  const sep = `${"\u2500".repeat(scopeW)}\u252C${"\u2500".repeat(nameW)}\u252C${"\u2500".repeat(LS_DESC_MAX + 2)}`;
+  const header = [
+    "SCOPE".padEnd(scopeW),
+    "NAME".padEnd(nameW),
+    "DESCRIPTION"
+  ].join(" \u2502 ");
+  const lines = [
+    header,
+    sep,
+    ...rows.map(
+      (r) => [
+        r.scope.padEnd(scopeW),
+        r.name.padEnd(nameW),
+        r.description
+      ].join(" \u2502 ")
+    )
+  ];
+  return lines.join("\n");
+}
+function formatDescribeOutput(spec) {
+  const { name: localName } = parseToolName(spec.name);
+  const scope = getDisplayScope(spec.name, spec.kind, spec.version);
+  const sections = [];
+  sections.push("\u250C\u2500 Tool");
+  sections.push(`\u2502  name:        ${spec.name}`);
+  sections.push(`\u2502  scope:       ${scope}`);
+  sections.push(`\u2502  localName:   ${localName}`);
+  sections.push(`\u2502  version:     ${spec.version}`);
+  sections.push(`\u2502  kind:        ${spec.kind}`);
+  sections.push("\u251C\u2500 Description");
+  sections.push(`\u2502  ${(spec.description ?? "(none)").replace(/\n/g, "\n\u2502  ")}`);
+  sections.push("\u251C\u2500 Tags");
+  sections.push(`\u2502  ${spec.tags?.length ? spec.tags.join(", ") : "(none)"}`);
+  sections.push("\u251C\u2500 Capabilities");
+  sections.push(`\u2502  ${spec.capabilities.join(", ")}`);
+  if (spec._meta?.hitl?.sideEffect) {
+    sections.push("\u251C\u2500 HITL");
+    sections.push(`\u2502  sideEffect: ${spec._meta.hitl.sideEffect}`);
+  }
+  sections.push("\u251C\u2500 Input schema");
+  sections.push(
+    "\u2502  " + JSON.stringify(spec.inputSchema, null, 2).replace(/\n/g, "\n\u2502  ")
+  );
+  sections.push("\u2514\u2500 Output schema");
+  sections.push(
+    "   " + JSON.stringify(spec.outputSchema, null, 2).replace(/\n/g, "\n   ")
+  );
+  return sections.join("\n");
+}
+async function cmdLs(pathOpt, verbose = false) {
+  try {
+    const { registry } = await getRuntimeWithTools(pathOpt, verbose);
+    const specs = registry.snapshot();
+    if (specs.length === 0) {
+      process.stdout.write("No tools registered.\n");
+      const cwd = process.cwd();
+      const searchDir = path2__default.resolve(cwd, pathOpt ?? ".");
+      const config = findAndLoadToolConfig(searchDir);
+      const hasNpmTools = getToolSourceDescriptors(config).some((t) => typeof t === "string" && t.startsWith("npm:"));
+      if (hasNpmTools) {
+        process.stdout.write(
+          "Tip: Install builtin tools in this directory so 'agent-tool ls' finds them: npm init -y && npm install @botbotgo/kit-builtin\n"
+        );
+      }
+      return 0;
+    }
+    specs.sort((a, b) => a.name.localeCompare(b.name));
+    process.stdout.write(formatLsOutput(specs) + "\n");
+    return 0;
+  } catch (err) {
+    process.stderr.write(`ls failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function cmdDescribe(toolName, pathOpt, verbose = false) {
+  if (!toolName.trim()) {
+    process.stderr.write("Usage: agent-tool describe <tool path>\n");
+    return 1;
+  }
+  try {
+    const { registry } = await getRuntimeWithTools(pathOpt, verbose);
+    const registryName = resolveToolDescriptor(toolName.trim());
+    const spec = registry.get(registryName);
+    if (!spec) {
+      process.stderr.write(`Tool not found: ${toolName}
+`);
+      return 1;
+    }
+    process.stdout.write(formatDescribeOutput(enrichSpecWithCanonicalSchema(spec)) + "\n");
+    return 0;
+  } catch (err) {
+    process.stderr.write(`describe failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+function defaultExecContext() {
+  return {
+    requestId: `cli-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    taskId: `task-${Date.now()}`,
+    permissions: [
+      "read:web",
+      "read:fs",
+      "write:fs",
+      "read:db",
+      "write:db",
+      "network",
+      "workflow",
+      "danger:destructive",
+      "exec"
+    ]
+  };
+}
+async function cmdRun(toolName, toolArgsJson, pathOpt, verbose = false) {
+  if (!toolName.trim()) {
+    process.stderr.write("Usage: agent-tool run <tool path> [<json params>]\n");
+    return 1;
+  }
+  let args = {};
+  if (toolArgsJson.trim()) {
+    try {
+      args = JSON.parse(toolArgsJson);
+    } catch {
+      process.stderr.write(`Invalid JSON for parameters. Example: '{"path":"README.md"}'
+`);
+      return 1;
+    }
+  }
+  try {
+    const { runtime, registry } = await getRuntimeWithTools(pathOpt, verbose);
+    const registryName = resolveToolDescriptor(toolName.trim());
+    if (!registry.get(registryName)) {
+      process.stderr.write(`Tool not found: ${toolName}
+`);
+      return 1;
+    }
+    const ctx = defaultExecContext();
+    const result = await runtime.invoke(
+      { tool: registryName, args, purpose: "cli" },
+      ctx
+    );
+    if (result.ok) {
+      process.stdout.write(JSON.stringify(result.result, null, 2) + "\n");
+      return 0;
+    }
+    process.stderr.write(`Tool error: ${result.error?.kind ?? "unknown"} - ${result.error?.message ?? ""}
+`);
+    return 1;
+  } catch (err) {
+    process.stderr.write(`Run failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function cmdStartMcp(pathOpt, verbose = false, stdio = false, port = 3e3, host = "127.0.0.1") {
+  try {
+    const { runtime } = await getRuntimeWithTools(pathOpt, verbose);
+    if (stdio) {
+      await runMCPServerOverStdio(runtime);
+      return 0;
+    }
+    const streamable = await createMCPServerStreamableHttp(runtime, { port, host, path: "/mcp" });
+    const { url } = await streamable.listen(port, host);
+    process.stdout.write(`MCP Streamable HTTP: ${url}
+`);
+    await new Promise(() => {
+    });
+    return 0;
+  } catch (err) {
+    process.stderr.write(`start mcp failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function cmdStartHttp(port, host, pathOpt, verbose = false) {
+  try {
+    const { runtime } = await getRuntimeWithTools(pathOpt, verbose);
+    const http = await createHttpService(runtime);
+    const { port: actualPort, host: actualHost } = await http.listen({ port, host });
+    const base = `http://${actualHost}:${actualPort}`;
+    process.stdout.write(`API: ${base}/invoke (POST), ${base}/tools (GET)
+`);
+    process.stdout.write(`Swagger UI: ${base}/  (spec: ${base}/openapi.json)
+`);
+    await new Promise(() => {
+    });
+    return 0;
+  } catch (err) {
+    process.stderr.write(`start http failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function main(argv = process.argv) {
+  const { command, startSub, help, verbose, mcpStdio, pathOpt, extensionName, scope, outDir, include, includeN8n, toolName, toolArgsJson, port, host } = parseArgv(argv);
+  if (help || command === "help") {
+    printHelp();
+    return 0;
+  }
+  if (command === "init") {
+    if (extensionName) return cmdInitExtension(extensionName, pathOpt, scope);
+    return cmdInit(pathOpt);
+  }
+  if (command === "build") return cmdBuild(pathOpt, outDir, include, includeN8n);
+  if (command === "serve") return cmdServe(pathOpt);
+  if (command === "ls" || command === "list") return cmdLs(pathOpt, verbose);
+  if (command === "describe" || command === "show") return cmdDescribe(toolName, pathOpt, verbose);
+  if (command === "run") return cmdRun(toolName, toolArgsJson, pathOpt, verbose);
+  if (command === "start") {
+    if (startSub === "mcp") return cmdStartMcp(pathOpt, verbose, mcpStdio, port, host);
+    if (startSub === "http") return cmdStartHttp(port, host, pathOpt, verbose);
+    process.stderr.write("Usage: agent-tool start mcp | agent-tool start http [--port 3000] [--host 127.0.0.1]\n");
+    return 1;
+  }
+  printHelp();
+  return 1;
+}
+async function run(argv) {
+  return main(argv);
+}
+var scriptPath = fileURLToPath(import.meta.url);
+var invokedPath = process.argv[1];
+var isMain = typeof process !== "undefined" && invokedPath !== void 0 && invokedPath === scriptPath;
+if (!isMain && invokedPath) {
+  try {
+    isMain = realpathSync(invokedPath) === realpathSync(scriptPath);
+  } catch {
+  }
+}
+if (isMain) {
+  main().then((code) => process.exit(code)).catch((err) => {
+    process.stderr.write(String(err?.message ?? err) + "\n");
+    process.exit(1);
+  });
+}
+
+export { run };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map