@iqai/adk-cli 0.1.1

package/dist/index.js

@@ -0,0 +1,1040 @@
+#!/usr/bin/env node
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_chalk5 = __toESM(require("chalk"));
+var import_commander = require("commander");
+
+// package.json
+var package_default = {
+  name: "@iqai/adk-cli",
+  version: "0.1.1",
+  description: "CLI tool for creating, running, and testing ADK agents",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    adk: "./dist/index.mjs"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/IQAIcom/adk-ts.git",
+    directory: "packages/adk-cli"
+  },
+  keywords: [
+    "ai",
+    "llm",
+    "agent",
+    "cli",
+    "adk",
+    "typescript"
+  ],
+  author: "IQAI",
+  license: "MIT",
+  dependencies: {
+    "@clack/prompts": "^0.11.0",
+    "@hono/node-server": "^1.18.1",
+    "@iqai/adk": "workspace:*",
+    chalk: "^5.4.1",
+    commander: "^12.1.0",
+    dedent: "^1.6.0",
+    giget: "^2.0.0",
+    hono: "^4.6.13",
+    marked: "^14.1.3",
+    "marked-terminal": "^7.2.1",
+    esbuild: "^0.23.0"
+  },
+  devDependencies: {
+    "@iqai/tsconfig": "workspace:*",
+    "@types/marked-terminal": "^6.1.1",
+    "@types/node": "^20.17.30",
+    tsup: "^8.4.0",
+    typescript: "^5.3.2",
+    vitest: "^3.1.3"
+  },
+  packageManager: "pnpm@9.0.0",
+  engines: {
+    node: ">=22.0"
+  },
+  files: [
+    "dist",
+    "!**/*.test.*",
+    "!**/*.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/commands/new.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_prompts = require("@clack/prompts");
+var import_chalk = __toESM(require("chalk"));
+var import_dedent = __toESM(require("dedent"));
+var import_giget = require("giget");
+var templates = [
+  {
+    value: "simple-agent",
+    label: "\u{1F916} Simple Agent",
+    hint: "Basic agent with chat capabilities",
+    source: "github:IQAIcom/adk-ts/apps/starter-templates/simple-agent"
+  },
+  {
+    value: "discord-bot",
+    label: "\u{1F3AE} Discord Bot",
+    hint: "Agent integrated with Discord",
+    source: "github:IQAIcom/adk-ts/apps/starter-templates/discord-bot"
+  },
+  {
+    value: "telegram-bot",
+    label: "\u{1F4F1} Telegram Bot",
+    hint: "Agent integrated with Telegram",
+    source: "github:IQAIcom/adk-ts/apps/starter-templates/telegram-bot"
+  },
+  {
+    value: "hono-server",
+    label: "\u{1F680} Hono Server",
+    hint: "Web server with agent endpoints",
+    source: "github:IQAIcom/adk-ts/apps/starter-templates/hono-server"
+  },
+  {
+    value: "mcp-starter",
+    label: "\u{1F50C} MCP Integration",
+    hint: "Model Context Protocol server",
+    source: "github:IQAIcom/adk-ts/apps/starter-templates/mcp-starter"
+  }
+];
+var packageManagers = [
+  { name: "npm", command: "npm", args: ["install"], label: "\u{1F4E6} npm" },
+  { name: "pnpm", command: "pnpm", args: ["install"], label: "\u26A1 pnpm" },
+  { name: "yarn", command: "yarn", args: ["install"], label: "\u{1F9F6} yarn" },
+  { name: "bun", command: "bun", args: ["install"], label: "\u{1F35E} bun" }
+];
+async function detectAvailablePackageManagers() {
+  const { spawn } = await import("child_process");
+  const available = [];
+  for (const pm of packageManagers) {
+    try {
+      await new Promise((resolve2, reject) => {
+        const child = spawn(pm.command, ["--version"], {
+          stdio: "pipe"
+        });
+        child.on("close", (code) => {
+          if (code === 0) {
+            available.push(pm);
+          }
+          resolve2();
+        });
+        child.on("error", () => resolve2());
+      });
+    } catch {
+    }
+  }
+  return available.length > 0 ? available : [packageManagers[0]];
+}
+async function createProject(projectName, options) {
+  console.clear();
+  console.log(
+    import_chalk.default.magentaBright(import_dedent.default`
+    ╔══════════════════════════════════════════════════════╗
+    ║                                                      ║
+    ║     █████╗ ██████╗ ██╗  ██╗    ████████╗███████╗     ║
+    ║    ██╔══██╗██╔══██╗██║ ██╔╝    ╚══██╔══╝██╔════╝     ║
+    ║    ███████║██║  ██║█████╔╝        ██║   ███████╗     ║
+    ║    ██╔══██║██║  ██║██╔═██╗        ██║   ╚════██║     ║
+    ║    ██║  ██║██████╔╝██║  ██╗       ██║   ███████║     ║
+    ║    ╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝       ╚═╝   ╚══════╝     ║
+    ║                                                      ║
+    ╚══════════════════════════════════════════════════════╝
+  `)
+  );
+  (0, import_prompts.intro)(import_chalk.default.bgMagenta.bold(" \u2728 Let's build something amazing! "));
+  let finalProjectName = projectName;
+  if (!finalProjectName) {
+    const response = await (0, import_prompts.text)({
+      message: "What is your project name?",
+      placeholder: "my-adk-project",
+      validate: (value) => {
+        if (!value) return "Project name is required";
+        if (value.includes(" ")) return "Project name cannot contain spaces";
+        if ((0, import_node_fs.existsSync)(value)) return `Directory "${value}" already exists`;
+        return void 0;
+      }
+    });
+    if (typeof response === "symbol") {
+      (0, import_prompts.outro)("Operation cancelled");
+      process.exit(0);
+    }
+    finalProjectName = response;
+  }
+  let selectedTemplate = options?.template;
+  if (!selectedTemplate || !templates.find((t) => t.value === selectedTemplate)) {
+    const framework = await (0, import_prompts.select)({
+      message: "Which template would you like to use?",
+      options: templates.map((t) => ({
+        value: t.value,
+        label: t.label,
+        hint: t.hint
+      }))
+    });
+    if (typeof framework === "symbol") {
+      (0, import_prompts.outro)("Operation cancelled");
+      process.exit(0);
+    }
+    selectedTemplate = framework;
+  }
+  const template = templates.find((t) => t.value === selectedTemplate);
+  if (!template) {
+    (0, import_prompts.outro)("Invalid template selected");
+    process.exit(1);
+  }
+  if ((0, import_node_fs.existsSync)(finalProjectName)) {
+    (0, import_prompts.outro)(import_chalk.default.red(`Directory "${finalProjectName}" already exists`));
+    process.exit(1);
+  }
+  const s = (0, import_prompts.spinner)();
+  s.start("Downloading template...");
+  try {
+    await (0, import_giget.downloadTemplate)(template.source, {
+      dir: finalProjectName,
+      registry: "gh"
+    });
+    s.stop("Template downloaded!");
+  } catch (error) {
+    s.stop("Failed to download template");
+    (0, import_prompts.outro)(import_chalk.default.red(`Error: ${error}`));
+    process.exit(1);
+  }
+  const availablePackageManagers = await detectAvailablePackageManagers();
+  let selectedPackageManager;
+  if (availablePackageManagers.length === 1) {
+    selectedPackageManager = availablePackageManagers[0];
+  } else {
+    const packageManagerChoice = await (0, import_prompts.select)({
+      message: "Which package manager would you like to use?",
+      options: availablePackageManagers.map((pm) => ({
+        value: pm.name,
+        label: pm.label
+      }))
+    });
+    if (typeof packageManagerChoice === "symbol") {
+      (0, import_prompts.outro)("Operation cancelled");
+      process.exit(0);
+    }
+    selectedPackageManager = availablePackageManagers.find(
+      (pm) => pm.name === packageManagerChoice
+    );
+  }
+  const shouldInstall = await (0, import_prompts.confirm)({
+    message: "Install dependencies?",
+    initialValue: true
+  });
+  if (typeof shouldInstall === "symbol") {
+    (0, import_prompts.outro)("Operation cancelled");
+    process.exit(0);
+  }
+  if (shouldInstall) {
+    const s2 = (0, import_prompts.spinner)();
+    s2.start(`Installing dependencies with ${selectedPackageManager.name}...`);
+    const { spawn } = await import("child_process");
+    const projectPath = (0, import_node_path.join)(process.cwd(), finalProjectName);
+    try {
+      await new Promise((resolve2, reject) => {
+        const child = spawn(
+          selectedPackageManager.command,
+          selectedPackageManager.args,
+          {
+            cwd: projectPath,
+            stdio: "pipe"
+          }
+        );
+        child.on("close", (code) => {
+          if (code === 0) {
+            resolve2();
+          } else {
+            reject(new Error(`Package installation failed with code ${code}`));
+          }
+        });
+        child.on("error", reject);
+      });
+      s2.stop("Dependencies installed!");
+    } catch (error) {
+      s2.stop("Failed to install dependencies");
+      console.log(
+        import_chalk.default.yellow("\nYou can install dependencies manually by running:")
+      );
+      console.log(
+        import_chalk.default.cyan(
+          `cd ${finalProjectName} && ${selectedPackageManager.command} ${selectedPackageManager.args.join(" ")}`
+        )
+      );
+    }
+  }
+  (0, import_prompts.outro)(
+    import_chalk.default.green(import_dedent.default`
+      🎉 Project created successfully!
+
+      Next steps:
+      ${import_chalk.default.cyan(`cd ${finalProjectName}`)}
+      ${shouldInstall ? "" : import_chalk.default.cyan(`${selectedPackageManager.command} ${selectedPackageManager.args.join(" ")}`)}
+      ${import_chalk.default.cyan("npm run dev")} or ${import_chalk.default.cyan("yarn dev")} or ${import_chalk.default.cyan("pnpm dev")}
+
+      Happy coding! 🚀
+    `)
+  );
+}
+
+// src/commands/run.ts
+var p = __toESM(require("@clack/prompts"));
+var import_prompts2 = require("@clack/prompts");
+var import_chalk3 = __toESM(require("chalk"));
+var import_marked = require("marked");
+var import_marked_terminal = require("marked-terminal");
+
+// src/commands/serve.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/server.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_node_url = require("url");
+var import_node_server = require("@hono/node-server");
+var import_adk = require("@iqai/adk");
+var import_hono = require("hono");
+var import_cors = require("hono/cors");
+var ADKServer = class {
+  agents = /* @__PURE__ */ new Map();
+  loadedAgents = /* @__PURE__ */ new Map();
+  sessionService;
+  app;
+  server;
+  agentsDir;
+  port;
+  host;
+  quiet;
+  constructor(agentsDir, port = 8042, host = "localhost", quiet = false) {
+    this.agentsDir = agentsDir;
+    this.port = port;
+    this.host = host;
+    this.quiet = quiet;
+    this.sessionService = new import_adk.InMemorySessionService();
+    this.app = new import_hono.Hono();
+    this.setupRoutes();
+    this.scanAgents();
+  }
+  setupRoutes() {
+    this.app.use("/*", (0, import_cors.cors)());
+    this.app.get("/health", (c) => c.json({ status: "ok" }));
+    this.app.get("/api/agents", (c) => {
+      const agentsList = Array.from(this.agents.values()).map((agent) => ({
+        path: agent.absolutePath,
+        name: agent.name,
+        directory: agent.absolutePath,
+        relativePath: agent.relativePath
+      }));
+      return c.json({ agents: agentsList });
+    });
+    this.app.post("/api/agents/refresh", (c) => {
+      this.scanAgents();
+      const agentsList = Array.from(this.agents.values()).map((agent) => ({
+        path: agent.absolutePath,
+        name: agent.name,
+        directory: agent.absolutePath,
+        relativePath: agent.relativePath
+      }));
+      return c.json({ agents: agentsList });
+    });
+    this.app.get("/api/agents/:id/messages", async (c) => {
+      const agentPath = decodeURIComponent(c.req.param("id"));
+      const loadedAgent = this.loadedAgents.get(agentPath);
+      if (!loadedAgent) {
+        return c.json({ messages: [] });
+      }
+      try {
+        const session = await this.sessionService.getSession(
+          loadedAgent.appName,
+          loadedAgent.userId,
+          loadedAgent.sessionId
+        );
+        if (!session || !session.events) {
+          return c.json({ messages: [] });
+        }
+        const messages = session.events.map((event, index) => ({
+          id: index + 1,
+          type: event.author === "user" ? "user" : "assistant",
+          content: event.content?.parts?.map(
+            (part) => typeof part === "object" && "text" in part ? part.text : ""
+          ).join("") || "",
+          timestamp: new Date(event.timestamp || Date.now()).toISOString()
+        }));
+        return c.json({ messages });
+      } catch (error) {
+        console.error("Error fetching messages:", error);
+        return c.json({ messages: [] });
+      }
+    });
+    this.app.post("/api/agents/:id/message", async (c) => {
+      const agentPath = decodeURIComponent(c.req.param("id"));
+      const { message } = await c.req.json();
+      const response = await this.sendMessageToAgent(agentPath, message);
+      return c.json({ response });
+    });
+  }
+  scanAgents() {
+    this.agents.clear();
+    const scanDir = !this.agentsDir || !(0, import_node_fs2.existsSync)(this.agentsDir) ? process.cwd() : this.agentsDir;
+    const shouldSkipDirectory = (dirName) => {
+      const skipDirs = [
+        "node_modules",
+        ".git",
+        ".next",
+        "dist",
+        "build",
+        ".turbo",
+        "coverage",
+        ".vscode",
+        ".idea"
+      ];
+      return skipDirs.includes(dirName);
+    };
+    const scanDirectory = (dir) => {
+      if (!(0, import_node_fs2.existsSync)(dir)) return;
+      const items = (0, import_node_fs2.readdirSync)(dir);
+      for (const item of items) {
+        const fullPath = (0, import_node_path2.join)(dir, item);
+        const stat = (0, import_node_fs2.statSync)(fullPath);
+        if (stat.isDirectory()) {
+          if (!shouldSkipDirectory(item)) {
+            scanDirectory(fullPath);
+          }
+        } else if (item === "agent.ts" || item === "agent.js") {
+          const relativePath = (0, import_node_path2.relative)(scanDir, dir);
+          const loadedAgent = this.loadedAgents.get(relativePath);
+          let agentName = relativePath.split("/").pop() || "unknown";
+          if (loadedAgent?.agent?.name) {
+            agentName = loadedAgent.agent.name;
+          } else {
+            try {
+              const agentFilePath = (0, import_node_path2.join)(dir, item);
+              agentName = this.extractAgentNameFromFile(agentFilePath) || agentName;
+            } catch {
+            }
+          }
+          this.agents.set(relativePath, {
+            relativePath,
+            name: agentName,
+            absolutePath: dir,
+            instance: loadedAgent?.agent
+          });
+        }
+      }
+    };
+    scanDirectory(scanDir);
+    if (!this.quiet) {
+      console.log(`\u2705 Agent scan complete. Found ${this.agents.size} agents.`);
+    }
+  }
+  async startAgent(agentPath) {
+    const agent = this.agents.get(agentPath);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentPath}`);
+    }
+    if (this.loadedAgents.has(agentPath)) {
+      return;
+    }
+    try {
+      let agentFilePath = (0, import_node_path2.join)(agent.absolutePath, "agent.js");
+      if (!(0, import_node_fs2.existsSync)(agentFilePath)) {
+        agentFilePath = (0, import_node_path2.join)(agent.absolutePath, "agent.ts");
+      }
+      if (!(0, import_node_fs2.existsSync)(agentFilePath)) {
+        throw new Error(
+          `No agent.js or agent.ts file found in ${agent.absolutePath}`
+        );
+      }
+      let projectRoot = (0, import_node_path2.dirname)(agentFilePath);
+      while (projectRoot !== "/" && projectRoot !== (0, import_node_path2.dirname)(projectRoot)) {
+        if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, "package.json")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, ".env"))) {
+          break;
+        }
+        projectRoot = (0, import_node_path2.dirname)(projectRoot);
+      }
+      const envPath = (0, import_node_path2.join)(projectRoot, ".env");
+      if ((0, import_node_fs2.existsSync)(envPath)) {
+        try {
+          const envContent = (0, import_node_fs2.readFileSync)(envPath, "utf8");
+          const envLines = envContent.split("\n");
+          for (const line of envLines) {
+            const trimmedLine = line.trim();
+            if (trimmedLine && !trimmedLine.startsWith("#")) {
+              const [key, ...valueParts] = trimmedLine.split("=");
+              if (key && valueParts.length > 0) {
+                const value = valueParts.join("=").replace(/^"(.*)"$/, "$1");
+                process.env[key.trim()] = value.trim();
+              }
+            }
+          }
+        } catch (error) {
+          console.warn(
+            `\u26A0\uFE0F Warning: Could not load .env file: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      const agentFileUrl = (0, import_node_url.pathToFileURL)(agentFilePath).href;
+      const agentModule = agentFilePath.endsWith(".ts") ? await this.importTypeScriptFile(agentFilePath) : await import(agentFileUrl);
+      if (!agentModule.agent) {
+        throw new Error(`No 'agent' export found in ${agentFilePath}`);
+      }
+      if (!agentModule.agent || typeof agentModule.agent !== "object" || !agentModule.agent.name) {
+        throw new Error(
+          `Invalid agent export in ${agentFilePath}. Expected an LlmAgent instance with a name property.`
+        );
+      }
+      if (!agentModule.agent.model || !agentModule.agent.instruction) {
+      }
+      const agentBuilder = import_adk.AgentBuilder.create(agentModule.agent.name).withModel(agentModule.agent.model).withDescription(agentModule.agent.description || "").withInstruction(agentModule.agent.instruction || "").withSessionService(this.sessionService, {
+        userId: `user_${agentPath}`,
+        appName: "adk-server"
+      });
+      if (agentModule.agent.tools && Array.isArray(agentModule.agent.tools) && agentModule.agent.tools.length > 0) {
+        agentBuilder.withTools(...agentModule.agent.tools);
+        if (!this.quiet) {
+          const toolNames = agentModule.agent.tools.map((t) => t?.name || "<unnamed>").join(", ");
+          console.log(
+            `\u{1F9E9} Registered tools for agent "${agentModule.agent.name}": [${toolNames}]`
+          );
+        }
+      }
+      const { runner, session } = await agentBuilder.build();
+      const loadedAgent = {
+        agent: agentModule.agent,
+        runner,
+        sessionId: session.id,
+        userId: `user_${agentPath}`,
+        appName: "adk-server"
+      };
+      this.loadedAgents.set(agentPath, loadedAgent);
+      agent.instance = agentModule.agent;
+      agent.name = agentModule.agent.name;
+    } catch (error) {
+      console.error(`\u274C Failed to load agent "${agent.name}":`, error);
+      throw new Error(
+        `Failed to load agent: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async stopAgent(agentPath) {
+    this.loadedAgents.delete(agentPath);
+    const agent = this.agents.get(agentPath);
+    if (agent) {
+      agent.instance = void 0;
+    }
+  }
+  async sendMessageToAgent(agentPath, message) {
+    if (!this.loadedAgents.has(agentPath)) {
+      await this.startAgent(agentPath);
+    }
+    const loadedAgent = this.loadedAgents.get(agentPath);
+    if (!loadedAgent) {
+      throw new Error("Agent failed to start");
+    }
+    try {
+      const response = await loadedAgent.runner.ask(message);
+      return response;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(
+        `Error sending message to agent ${agentPath}:`,
+        errorMessage
+      );
+      throw new Error(`Failed to send message to agent: ${errorMessage}`);
+    }
+  }
+  /**
+   * Import a TypeScript file by compiling it on-demand
+   */
+  async importTypeScriptFile(filePath) {
+    let projectRoot = (0, import_node_path2.dirname)(filePath);
+    while (projectRoot !== "/" && projectRoot !== (0, import_node_path2.dirname)(projectRoot)) {
+      if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, "package.json")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, ".env"))) {
+        break;
+      }
+      projectRoot = (0, import_node_path2.dirname)(projectRoot);
+    }
+    try {
+      const { build } = await import("esbuild");
+      const cacheDir = (0, import_node_path2.join)(projectRoot, ".adk-cache");
+      if (!(0, import_node_fs2.existsSync)(cacheDir)) {
+        (0, import_node_fs2.mkdirSync)(cacheDir, { recursive: true });
+      }
+      const outFile = (0, import_node_path2.join)(cacheDir, `agent-${Date.now()}.mjs`);
+      const plugin = {
+        name: "externalize-bare-imports",
+        setup(build2) {
+          build2.onResolve({ filter: /.*/ }, (args) => {
+            if (args.path.startsWith(".") || args.path.startsWith("/") || args.path.startsWith("..")) {
+              return;
+            }
+            return { path: args.path, external: true };
+          });
+        }
+      };
+      const tsconfigPath = (0, import_node_path2.join)(projectRoot, "tsconfig.json");
+      await build({
+        entryPoints: [filePath],
+        outfile: outFile,
+        bundle: true,
+        format: "esm",
+        platform: "node",
+        target: ["node22"],
+        sourcemap: false,
+        logLevel: "silent",
+        plugins: [plugin],
+        absWorkingDir: projectRoot,
+        // Use tsconfig if present for path aliases
+        ...(0, import_node_fs2.existsSync)(tsconfigPath) ? { tsconfig: tsconfigPath } : {}
+      });
+      const mod = await import(`${(0, import_node_url.pathToFileURL)(outFile).href}?t=${Date.now()}`);
+      let agentExport = mod?.agent;
+      if (!agentExport && mod?.default) {
+        agentExport = mod.default.agent ?? mod.default;
+      }
+      try {
+        (0, import_node_fs2.unlinkSync)(outFile);
+      } catch {
+      }
+      if (agentExport) {
+        if (!this.quiet) {
+          console.log(`\u2705 TS agent imported via esbuild: ${filePath}`);
+        }
+        return { agent: agentExport };
+      }
+    } catch (e) {
+      throw new Error(
+        `Failed to import TS agent via esbuild: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    throw new Error("No 'agent' export found in TypeScript module");
+  }
+  async start() {
+    return new Promise((resolve2, reject) => {
+      this.server = (0, import_node_server.serve)({
+        fetch: this.app.fetch,
+        port: this.port,
+        hostname: this.host
+      });
+      setTimeout(() => {
+        resolve2();
+      }, 100);
+    });
+  }
+  async stop() {
+    return new Promise((resolve2) => {
+      for (const [agentPath] of this.loadedAgents) {
+        this.stopAgent(agentPath);
+      }
+      if (this.server) {
+        this.server.close();
+      }
+      resolve2();
+    });
+  }
+  getPort() {
+    return this.port;
+  }
+  extractAgentNameFromFile(filePath) {
+    try {
+      const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+      const nameMatch = content.match(/name\s*:\s*["']([^"']+)["']/);
+      if (nameMatch?.[1]) {
+        return nameMatch[1];
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/commands/serve.ts
+async function serveCommand(options = {}) {
+  const port = options.port || 8042;
+  const host = options.host || "localhost";
+  const agentsDir = (0, import_node_path3.resolve)(options.dir || ".");
+  if (!(0, import_node_fs3.existsSync)(agentsDir)) {
+    console.error(import_chalk2.default.red(`\u274C Directory not found: ${agentsDir}`));
+    process.exit(1);
+  }
+  if (!options.quiet) {
+    console.log(import_chalk2.default.blue(`\u{1F680} ADK Server starting on http://${host}:${port}`));
+  }
+  const server = new ADKServer(agentsDir, port, host, options.quiet);
+  try {
+    await server.start();
+    if (!options.quiet) {
+      console.log(import_chalk2.default.green("\u2705 Server ready"));
+    }
+    const cleanup = async () => {
+      if (!options.quiet) {
+        console.log(import_chalk2.default.yellow("\n\u{1F6D1} Stopping server..."));
+      }
+      await server.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    return server;
+  } catch (error) {
+    console.error(import_chalk2.default.red("\u274C Failed to start ADK server:"), error);
+    process.exit(1);
+  }
+}
+
+// src/commands/run.ts
+import_marked.marked.use((0, import_marked_terminal.markedTerminal)());
+async function renderMarkdown(text3) {
+  try {
+    const result = await (0, import_marked.marked)(text3);
+    return typeof result === "string" ? result : text3;
+  } catch (error) {
+    return text3;
+  }
+}
+var AgentChatClient = class {
+  apiUrl;
+  selectedAgent = null;
+  constructor(apiUrl) {
+    this.apiUrl = apiUrl;
+  }
+  async connect() {
+    try {
+      const response = await fetch(`${this.apiUrl}/health`);
+      if (!response.ok) {
+        throw new Error("Connection failed");
+      }
+    } catch (error) {
+      throw new Error("\u274C Connection failed");
+    }
+  }
+  async fetchAgents() {
+    try {
+      const response = await fetch(`${this.apiUrl}/api/agents`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (Array.isArray(data)) {
+        return data;
+      }
+      if (data && Array.isArray(data.agents)) {
+        return data.agents;
+      }
+      throw new Error(`Unexpected response format: ${JSON.stringify(data)}`);
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch agents: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async selectAgent() {
+    const agents = await this.fetchAgents();
+    if (agents.length === 0) {
+      throw new Error("No agents found in the current directory");
+    }
+    if (agents.length === 1) {
+      return agents[0];
+    }
+    const selectedAgent = await p.select({
+      message: "Choose an agent to chat with:",
+      options: agents.map((agent) => ({
+        label: agent.name,
+        value: agent,
+        hint: agent.relativePath
+      }))
+    });
+    if (p.isCancel(selectedAgent)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    return selectedAgent;
+  }
+  // No-op: agents are auto-loaded on message; keeping method removed
+  async sendMessage(message) {
+    if (!this.selectedAgent) {
+      throw new Error("No agent selected");
+    }
+    const s = (0, import_prompts2.spinner)();
+    s.start("\u{1F916} Thinking...");
+    try {
+      const response = await fetch(
+        `${this.apiUrl}/api/agents/${encodeURIComponent(this.selectedAgent.relativePath)}/message`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ message })
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        s.stop("\u274C Failed to send message");
+        throw new Error(`Failed to send message: ${errorText}`);
+      }
+      const result = await response.json();
+      s.stop("\u{1F916} Assistant:");
+      if (result.response) {
+        const formattedResponse = await renderMarkdown(result.response);
+        import_prompts2.log.message(formattedResponse.trim());
+      }
+    } catch (error) {
+      import_prompts2.log.error("Failed to send message");
+    }
+  }
+  async startChat() {
+    if (!this.selectedAgent) {
+      throw new Error("Agent not selected");
+    }
+    while (true) {
+      try {
+        const message = await p.text({
+          message: "\u{1F4AC} Message:",
+          placeholder: "Type your message here..."
+        });
+        if (p.isCancel(message)) {
+          break;
+        }
+        if (message.trim()) {
+          await this.sendMessage(message.trim());
+        }
+      } catch (error) {
+        console.error(import_chalk3.default.red("Error in chat:"), error);
+        break;
+      }
+    }
+  }
+  disconnect() {
+  }
+  setSelectedAgent(agent) {
+    this.selectedAgent = agent;
+  }
+};
+async function runAgent(agentPath, options = {}) {
+  const envVerbose = process.env.ADK_VERBOSE;
+  const isVerbose = options.verbose ?? (envVerbose === "1" || envVerbose === "true");
+  if (options.server) {
+    const apiPort = 8042;
+    const host = options.host || "localhost";
+    console.log(import_chalk3.default.blue("\u{1F680} Starting ADK Server..."));
+    const serveOptions = {
+      port: apiPort,
+      dir: process.cwd(),
+      host,
+      quiet: !isVerbose
+    };
+    try {
+      const server = await serveCommand(serveOptions);
+      console.log(import_chalk3.default.cyan("Press Ctrl+C to stop the server"));
+      process.on("SIGINT", async () => {
+        console.log(import_chalk3.default.yellow("\n\u{1F6D1} Stopping server..."));
+        await server.stop();
+        process.exit(0);
+      });
+      return new Promise(() => {
+      });
+    } catch (error) {
+      console.error(import_chalk3.default.red("\u274C Failed to start server"));
+      process.exit(1);
+    }
+  }
+  const apiUrl = `http://${options.host || "localhost"}:8042`;
+  p.intro("\u{1F916} ADK Agent Chat");
+  try {
+    const healthResponse = await fetch(`${apiUrl}/health`).catch(() => null);
+    if (!healthResponse || !healthResponse.ok) {
+      const serverSpinner = (0, import_prompts2.spinner)();
+      serverSpinner.start("\u{1F680} Starting server...");
+      const serveOptions = {
+        port: 8042,
+        // Use new default port
+        dir: process.cwd(),
+        host: options.host || "localhost",
+        quiet: !isVerbose
+      };
+      await serveCommand(serveOptions);
+      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+      serverSpinner.stop("\u2705 Server ready");
+    }
+    const client = new AgentChatClient(apiUrl);
+    await client.connect();
+    const agentSpinner = (0, import_prompts2.spinner)();
+    agentSpinner.start("\u{1F50D} Scanning for agents...");
+    const agents = await client.fetchAgents();
+    let selectedAgent;
+    if (agents.length === 0) {
+      agentSpinner.stop("\u274C No agents found");
+      p.cancel("No agents found in the current directory");
+      process.exit(1);
+    } else if (agents.length === 1) {
+      selectedAgent = agents[0];
+      agentSpinner.stop(`\u{1F916} Found agent: ${selectedAgent.name}`);
+    } else {
+      agentSpinner.stop(`\u{1F916} Found ${agents.length} agents`);
+      const choice = await p.select({
+        message: "Choose an agent to chat with:",
+        options: agents.map((agent) => ({
+          label: agent.name,
+          value: agent,
+          hint: agent.relativePath
+        }))
+      });
+      if (p.isCancel(choice)) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      selectedAgent = choice;
+    }
+    client.setSelectedAgent(selectedAgent);
+    await client.startChat();
+    client.disconnect();
+    p.outro("Chat ended");
+  } catch (error) {
+    p.cancel(
+      `Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/web.ts
+var import_chalk4 = __toESM(require("chalk"));
+async function webCommand(options = {}) {
+  const apiPort = options.port || 8042;
+  const webPort = options.webPort || 3e3;
+  const host = options.host || "localhost";
+  const useLocal = options.local || false;
+  const webUrl = options.webUrl || "https://adk-web.iqai.com";
+  console.log(import_chalk4.default.blue("\u{1F310} Starting ADK Web Interface..."));
+  const serveOptions = {
+    port: apiPort,
+    dir: options.dir,
+    host,
+    quiet: true
+  };
+  await serveCommand(serveOptions);
+  let webAppUrl;
+  if (useLocal) {
+    if (apiPort === 8042) {
+      webAppUrl = `http://${host}:${webPort}`;
+    } else {
+      webAppUrl = `http://${host}:${webPort}?port=${apiPort}`;
+    }
+  } else {
+    if (apiPort === 8042) {
+      webAppUrl = webUrl;
+    } else {
+      webAppUrl = `${webUrl}?port=${apiPort}`;
+    }
+  }
+  console.log(import_chalk4.default.cyan(`\u{1F517} Open this URL in your browser: ${webAppUrl}`));
+  console.log(import_chalk4.default.gray(`   API Server: http://${host}:${apiPort}`));
+  console.log(import_chalk4.default.cyan("Press Ctrl+C to stop the API server"));
+}
+
+// src/index.ts
+import_commander.program.name("adk").description(package_default.description).version(package_default.version);
+import_commander.program.command("new").description("Create a new ADK project").argument("[project-name]", "Name of the project to create").option(
+  "-t, --template <template>",
+  "Template to use (simple-agent, discord-bot, telegram-bot, hono-server, mcp-starter)",
+  "simple-agent"
+).action(async (projectName, options) => {
+  try {
+    await createProject(projectName, options);
+  } catch (error) {
+    console.error(import_chalk5.default.red("Error creating project:"), error);
+    process.exit(1);
+  }
+});
+import_commander.program.command("run").description("Start an interactive chat with an agent").argument(
+  "[agent-path]",
+  "Path to specific agent (optional - will show selector if multiple agents found)"
+).option("-s, --server", "Start ADK server only (without chat interface)").option(
+  "-h, --host <host>",
+  "Host for server (when using --server)",
+  "localhost"
+).action(async (agentPath, options) => {
+  try {
+    await runAgent(agentPath, options);
+  } catch (error) {
+    console.error(import_chalk5.default.red("Error running agent:"), error);
+    process.exit(1);
+  }
+});
+import_commander.program.command("web").description("Start a web interface for testing agents").option("-p, --port <port>", "Port for API server", "8042").option("--web-port <port>", "Port for web app (when using --local)", "3000").option("-h, --host <host>", "Host for servers", "localhost").option(
+  "-d, --dir <directory>",
+  "Directory to scan for agents (default: current directory)",
+  "."
+).option(
+  "--local",
+  "Run local web app instead of opening production URL",
+  false
+).option(
+  "--web-url <url>",
+  "URL of the web application (used when not --local)",
+  "https://adk-web.iqai.com"
+).action(async (options) => {
+  try {
+    await webCommand(options);
+  } catch (error) {
+    console.error(import_chalk5.default.red("Error starting web UI:"), error);
+    process.exit(1);
+  }
+});
+import_commander.program.command("serve").description("Start an API server for agent management").option("-p, --port <port>", "Port for the server", "8042").option("-h, --host <host>", "Host for the server", "localhost").option(
+  "-d, --dir <directory>",
+  "Directory to scan for agents (default: current directory)",
+  "."
+).action(async (options) => {
+  try {
+    await serveCommand(options);
+  } catch (error) {
+    console.error(import_chalk5.default.red("Error starting server:"), error);
+    process.exit(1);
+  }
+});
+import_commander.program.parse();
+//# sourceMappingURL=index.js.map