@poncho-ai/cli 0.2.0

package/dist/chunk-GBFHLBWT.js

@@ -0,0 +1,881 @@
+// src/index.ts
+import { spawn } from "child_process";
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import {
+  createServer
+} from "http";
+import { dirname, resolve } from "path";
+import { createRequire } from "module";
+import readline from "readline/promises";
+import { fileURLToPath } from "url";
+import {
+  AgentHarness,
+  TelemetryEmitter,
+  createStateStore,
+  loadAgentlConfig
+} from "@agentl/harness";
+import { Command } from "commander";
+import dotenv from "dotenv";
+import YAML from "yaml";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var require2 = createRequire(import.meta.url);
+var writeJson = (response, statusCode, payload) => {
+  response.writeHead(statusCode, { "Content-Type": "application/json" });
+  response.end(JSON.stringify(payload));
+};
+var readRequestBody = async (request) => {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const body = Buffer.concat(chunks).toString("utf8");
+  return body.length > 0 ? JSON.parse(body) : {};
+};
+var sleep = async (ms) => await new Promise((resolveSleep) => {
+  setTimeout(resolveSleep, ms);
+});
+var typeOut = async (text) => {
+  const tokens = text.split(/(\s+)/).filter((token) => token.length > 0);
+  for (const token of tokens) {
+    process.stdout.write(token);
+    await sleep(12);
+  }
+};
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var listenOnAvailablePort = async (server, preferredPort) => await new Promise((resolveListen, rejectListen) => {
+  let currentPort = preferredPort;
+  const tryListen = () => {
+    const onListening = () => {
+      server.off("error", onError);
+      resolveListen(currentPort);
+    };
+    const onError = (error) => {
+      server.off("listening", onListening);
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE") {
+        currentPort += 1;
+        if (currentPort > 65535) {
+          rejectListen(
+            new Error(
+              "No available ports found from the requested port up to 65535."
+            )
+          );
+          return;
+        }
+        setImmediate(tryListen);
+        return;
+      }
+      rejectListen(error);
+    };
+    server.once("listening", onListening);
+    server.once("error", onError);
+    server.listen(currentPort);
+  };
+  tryListen();
+});
+var parseParams = (values) => {
+  const params = {};
+  for (const value of values) {
+    const [key, ...rest] = value.split("=");
+    if (!key) {
+      continue;
+    }
+    params[key] = rest.join("=");
+  }
+  return params;
+};
+var AGENT_TEMPLATE = `---
+name: my-agent
+description: A helpful AgentL assistant
+model:
+  provider: anthropic
+  name: claude-sonnet-4-20250514
+  temperature: 0.2
+limits:
+  maxSteps: 50
+  timeout: 300
+---
+
+# My Agent
+
+You are a helpful assistant built with AgentL.
+
+Working directory: {{runtime.workingDir}}
+Environment: {{runtime.environment}}
+
+## Task Guidance
+
+- Use tools when needed
+- Explain your reasoning clearly
+- Ask clarifying questions when requirements are ambiguous
+`;
+var CONFIG_TEMPLATE = `export default {
+  mcp: [],
+  auth: { required: false },
+  state: { provider: 'memory', ttl: 3600 },
+  telemetry: { enabled: true }
+}
+`;
+var PACKAGE_TEMPLATE = (name) => JSON.stringify(
+  {
+    name,
+    private: true,
+    type: "module",
+    dependencies: {
+      "@agentl/harness": "^0.1.0"
+    }
+  },
+  null,
+  2
+);
+var ENV_TEMPLATE = "ANTHROPIC_API_KEY=sk-ant-...\n";
+var GITIGNORE_TEMPLATE = ".env\nnode_modules\ndist\n";
+var TEST_TEMPLATE = `tests:
+  - name: "Basic sanity"
+    task: "What is 2 + 2?"
+    expect:
+      contains: "4"
+`;
+var SKILL_TEMPLATE = `---
+name: starter-skill
+version: 1.0.0
+description: Starter local skill template
+tools:
+  - starter-echo
+---
+
+# Starter Skill
+
+This is a starter local skill created by \`agentl init\`.
+`;
+var SKILL_TOOL_TEMPLATE = `import { defineTool } from "@agentl/sdk";
+
+export default defineTool({
+  name: "starter-echo",
+  description: "Echoes a message for testing local skill wiring",
+  inputSchema: {
+    type: "object",
+    properties: {
+      message: { type: "string", description: "Message to echo" }
+    },
+    required: ["message"]
+  },
+  async handler(input) {
+    return { echoed: input.message };
+  }
+});
+`;
+var ensureFile = async (path, content) => {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, content, { encoding: "utf8", flag: "wx" });
+};
+var writeConfigFile = async (workingDir, config) => {
+  const serialized = `export default ${JSON.stringify(config, null, 2)}
+`;
+  await writeFile(resolve(workingDir, "agentl.config.js"), serialized, "utf8");
+};
+var extractToken = (request, authConfig) => {
+  if (authConfig.type === "header") {
+    const headerName = (authConfig.headerName ?? "x-agent-api-key").toLowerCase();
+    const raw = request.headers[headerName];
+    return Array.isArray(raw) ? raw[0] ?? "" : raw ?? "";
+  }
+  const authHeader = request.headers.authorization ?? "";
+  if (authHeader.toLowerCase().startsWith("bearer ")) {
+    return authHeader.slice(7).trim();
+  }
+  return "";
+};
+var authorizeRequest = async (request, config) => {
+  const authConfig = config?.auth;
+  if (!authConfig?.required) {
+    return true;
+  }
+  const token = extractToken(request, authConfig);
+  if (!token) {
+    return false;
+  }
+  if (authConfig.validate) {
+    return await authConfig.validate(token, request);
+  }
+  return token === (process.env.AGENT_API_KEY ?? "");
+};
+var initProject = async (projectName, options) => {
+  const baseDir = options?.workingDir ?? process.cwd();
+  const projectDir = resolve(baseDir, projectName);
+  await mkdir(projectDir, { recursive: true });
+  await ensureFile(resolve(projectDir, "AGENT.md"), AGENT_TEMPLATE);
+  await ensureFile(resolve(projectDir, "agentl.config.js"), CONFIG_TEMPLATE);
+  await ensureFile(resolve(projectDir, "package.json"), PACKAGE_TEMPLATE(projectName));
+  await ensureFile(resolve(projectDir, ".env.example"), ENV_TEMPLATE);
+  await ensureFile(resolve(projectDir, ".gitignore"), GITIGNORE_TEMPLATE);
+  await ensureFile(resolve(projectDir, "tests", "basic.yaml"), TEST_TEMPLATE);
+  await ensureFile(resolve(projectDir, "skills", "starter", "SKILL.md"), SKILL_TEMPLATE);
+  await ensureFile(
+    resolve(projectDir, "skills", "starter", "tools", "starter-echo.ts"),
+    SKILL_TOOL_TEMPLATE
+  );
+  process.stdout.write(`Initialized AgentL project at ${projectDir}
+`);
+};
+var formatSseEvent = (event) => `event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`;
+var startDevServer = async (port, options) => {
+  const workingDir = options?.workingDir ?? process.cwd();
+  dotenv.config({ path: resolve(workingDir, ".env") });
+  const config = await loadAgentlConfig(workingDir);
+  const harness = new AgentHarness({ workingDir });
+  await harness.initialize();
+  const telemetry = new TelemetryEmitter(config?.telemetry);
+  const stateStore = createStateStore(config?.state);
+  const server = createServer(async (request, response) => {
+    if (!request.url || !request.method) {
+      writeJson(response, 404, { error: "Not found" });
+      return;
+    }
+    const [pathname] = request.url.split("?");
+    if (pathname === "/health" && request.method === "GET") {
+      writeJson(response, 200, { status: "ok" });
+      return;
+    }
+    if (!await authorizeRequest(request, config)) {
+      writeJson(response, 401, {
+        code: "AUTH_ERROR",
+        message: "Authentication failed"
+      });
+      return;
+    }
+    if (pathname === "/run/sync" && request.method === "POST") {
+      try {
+        const input = await readRequestBody(request);
+        const output = await harness.runToCompletion(input);
+        await stateStore.set({
+          runId: output.runId,
+          messages: output.messages,
+          updatedAt: Date.now()
+        });
+        for (const event of output.events) {
+          await telemetry.emit(event);
+        }
+        writeJson(response, 200, {
+          runId: output.runId,
+          status: output.result.status,
+          result: output.result
+        });
+      } catch (error) {
+        writeJson(response, 500, {
+          code: "RUN_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+      return;
+    }
+    if (pathname === "/run" && request.method === "POST") {
+      response.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      try {
+        const input = await readRequestBody(request);
+        let runId = "";
+        let finalResponse = "";
+        const baseMessages = [
+          ...input.messages ?? [],
+          { role: "user", content: input.task }
+        ];
+        for await (const event of harness.run(input)) {
+          if (event.type === "run:started") {
+            runId = event.runId;
+          }
+          if (event.type === "run:completed") {
+            finalResponse = event.result.response ?? "";
+          }
+          await telemetry.emit(event);
+          response.write(formatSseEvent(event));
+        }
+        if (runId) {
+          await stateStore.set({
+            runId,
+            messages: [...baseMessages, { role: "assistant", content: finalResponse }],
+            updatedAt: Date.now()
+          });
+        }
+      } catch (error) {
+        response.write(
+          formatSseEvent({
+            type: "run:error",
+            runId: "run_unknown",
+            error: {
+              code: "RUN_ERROR",
+              message: error instanceof Error ? error.message : "Unknown error"
+            }
+          })
+        );
+      } finally {
+        response.end();
+      }
+      return;
+    }
+    if (pathname === "/continue" && request.method === "POST") {
+      try {
+        const body = await readRequestBody(request);
+        if (!body.runId || !body.message) {
+          writeJson(response, 400, {
+            code: "VALIDATION_ERROR",
+            message: "Both runId and message are required"
+          });
+          return;
+        }
+        const state = await stateStore.get(body.runId);
+        if (!state) {
+          writeJson(response, 404, {
+            code: "RUN_NOT_FOUND",
+            message: `No conversation found for runId ${body.runId}`
+          });
+          return;
+        }
+        const output = await harness.runToCompletion({
+          task: body.message,
+          parameters: body.parameters,
+          messages: state.messages
+        });
+        await stateStore.set({
+          runId: output.runId,
+          messages: output.messages,
+          updatedAt: Date.now()
+        });
+        for (const event of output.events) {
+          await telemetry.emit(event);
+        }
+        writeJson(response, 200, {
+          runId: output.runId,
+          status: output.result.status,
+          result: output.result
+        });
+      } catch (error) {
+        writeJson(response, 500, {
+          code: "CONTINUE_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+      return;
+    }
+    writeJson(response, 404, { error: "Not found" });
+  });
+  const actualPort = await listenOnAvailablePort(server, port);
+  if (actualPort !== port) {
+    process.stdout.write(
+      `Port ${port} is in use, switched to ${actualPort}.
+`
+    );
+  }
+  process.stdout.write(`AgentL dev server running at http://localhost:${actualPort}
+`);
+  return server;
+};
+var runOnce = async (task, options) => {
+  const workingDir = options.workingDir ?? process.cwd();
+  dotenv.config({ path: resolve(workingDir, ".env") });
+  const config = await loadAgentlConfig(workingDir);
+  const harness = new AgentHarness({ workingDir });
+  const telemetry = new TelemetryEmitter(config?.telemetry);
+  await harness.initialize();
+  const fileBlobs = await Promise.all(
+    options.filePaths.map(async (path) => {
+      const content = await readFile(resolve(workingDir, path), "utf8");
+      return `# File: ${path}
+${content}`;
+    })
+  );
+  const input = {
+    task: fileBlobs.length > 0 ? `${task}
+
+${fileBlobs.join("\n\n")}` : task,
+    parameters: options.params
+  };
+  if (options.json) {
+    const output = await harness.runToCompletion(input);
+    for (const event of output.events) {
+      await telemetry.emit(event);
+    }
+    process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+    return;
+  }
+  for await (const event of harness.run(input)) {
+    await telemetry.emit(event);
+    if (event.type === "model:chunk") {
+      process.stdout.write(event.content);
+    }
+    if (event.type === "run:error") {
+      process.stderr.write(`
+Error: ${event.error.message}
+`);
+    }
+    if (event.type === "run:completed") {
+      process.stdout.write("\n");
+    }
+  }
+};
+var runInteractive = async (workingDir, params) => {
+  dotenv.config({ path: resolve(workingDir, ".env") });
+  const harness = new AgentHarness({ workingDir });
+  await harness.initialize();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const messages = [];
+  process.stdout.write(
+    "Interactive mode. Type 'exit' to quit. Real tool events will appear as [tool:*] lines.\n"
+  );
+  while (true) {
+    const task = await rl.question("> ");
+    if (task.trim().toLowerCase() === "exit") {
+      break;
+    }
+    let responseText = "";
+    let toolEvents = 0;
+    let runFailed = false;
+    let sawChunk = false;
+    let showedThinking = false;
+    for await (const event of harness.run({
+      task,
+      parameters: params,
+      messages
+    })) {
+      if (event.type === "model:request" && !showedThinking) {
+        showedThinking = true;
+        process.stdout.write("assistant> [thinking...]\n");
+      } else if (event.type === "model:chunk") {
+        if (!sawChunk) {
+          sawChunk = true;
+          process.stdout.write("assistant> ");
+        }
+        responseText += event.content;
+        process.stdout.write(event.content);
+      } else if (event.type === "tool:started") {
+        toolEvents += 1;
+        process.stdout.write(`
+[tool:started] ${event.tool}
+`);
+      } else if (event.type === "tool:completed") {
+        process.stdout.write(`[tool:completed] ${event.tool}
+`);
+      } else if (event.type === "tool:error") {
+        process.stdout.write(`[tool:error] ${event.tool}: ${event.error}
+`);
+      } else if (event.type === "run:error") {
+        runFailed = true;
+        process.stdout.write(`
+[run:error] ${event.error.message}
+`);
+      } else if (event.type === "run:completed" && !responseText) {
+        responseText = event.result.response ?? "";
+        if (responseText.length > 0) {
+          if (!sawChunk) {
+            process.stdout.write("assistant> ");
+            await typeOut(responseText);
+          } else {
+            process.stdout.write(responseText);
+          }
+        }
+      }
+    }
+    process.stdout.write("\n");
+    if (!runFailed && toolEvents === 0) {
+      process.stdout.write("[info] no real tool calls were executed this turn.\n");
+      if (FAUX_TOOL_LOG_PATTERN.test(responseText)) {
+        process.stdout.write(
+          "[warning] assistant text described tool execution, but no real tool events occurred.\n"
+        );
+      }
+    }
+    messages.push({ role: "user", content: task });
+    messages.push({ role: "assistant", content: responseText });
+  }
+  rl.close();
+};
+var listTools = async (workingDir) => {
+  dotenv.config({ path: resolve(workingDir, ".env") });
+  const harness = new AgentHarness({ workingDir });
+  await harness.initialize();
+  const tools = harness.listTools();
+  if (tools.length === 0) {
+    process.stdout.write("No tools registered.\n");
+    return;
+  }
+  process.stdout.write("Available tools:\n");
+  for (const tool of tools) {
+    process.stdout.write(`- ${tool.name}: ${tool.description}
+`);
+  }
+};
+var runInstallCommand = async (workingDir, packageNameOrPath) => await new Promise((resolveInstall, rejectInstall) => {
+  const child = spawn("pnpm", ["add", packageNameOrPath], {
+    cwd: workingDir,
+    stdio: "inherit",
+    env: process.env
+  });
+  child.on("exit", (code) => {
+    if (code === 0) {
+      resolveInstall();
+      return;
+    }
+    rejectInstall(new Error(`pnpm add failed with exit code ${code ?? -1}`));
+  });
+});
+var validateSkillPackage = async (workingDir, packageNameOrPath) => {
+  const packageJsonPath = packageNameOrPath.startsWith(".") || packageNameOrPath.startsWith("/") ? resolve(workingDir, packageNameOrPath, "package.json") : require2.resolve(`${packageNameOrPath}/package.json`, {
+    paths: [workingDir]
+  });
+  const skillRoot = resolve(packageJsonPath, "..");
+  const skillManifest = resolve(skillRoot, "SKILL.md");
+  try {
+    await access(skillManifest);
+  } catch {
+    throw new Error(`Skill validation failed: missing SKILL.md in ${skillRoot}`);
+  }
+};
+var addSkill = async (workingDir, packageNameOrPath) => {
+  await runInstallCommand(workingDir, packageNameOrPath);
+  await validateSkillPackage(workingDir, packageNameOrPath);
+  process.stdout.write(`Added skill: ${packageNameOrPath}
+`);
+};
+var runTests = async (workingDir, filePath) => {
+  dotenv.config({ path: resolve(workingDir, ".env") });
+  const testFilePath = filePath ?? resolve(workingDir, "tests", "basic.yaml");
+  const content = await readFile(testFilePath, "utf8");
+  const parsed = YAML.parse(content);
+  const tests = parsed.tests ?? [];
+  const harness = new AgentHarness({ workingDir });
+  await harness.initialize();
+  let passed = 0;
+  let failed = 0;
+  for (const testCase of tests) {
+    try {
+      const output = await harness.runToCompletion({ task: testCase.task });
+      const response = output.result.response ?? "";
+      const events = output.events;
+      const expectation = testCase.expect ?? {};
+      const checks = [];
+      if (expectation.contains) {
+        checks.push(response.includes(expectation.contains));
+      }
+      if (typeof expectation.maxSteps === "number") {
+        checks.push(output.result.steps <= expectation.maxSteps);
+      }
+      if (typeof expectation.maxTokens === "number") {
+        checks.push(
+          output.result.tokens.input + output.result.tokens.output <= expectation.maxTokens
+        );
+      }
+      if (expectation.refusal) {
+        checks.push(
+          response.toLowerCase().includes("can't") || response.toLowerCase().includes("cannot")
+        );
+      }
+      if (expectation.toolCalled) {
+        checks.push(
+          events.some(
+            (event) => event.type === "tool:started" && event.tool === expectation.toolCalled
+          )
+        );
+      }
+      const ok = checks.length === 0 ? output.result.status === "completed" : checks.every(Boolean);
+      if (ok) {
+        passed += 1;
+        process.stdout.write(`PASS ${testCase.name}
+`);
+      } else {
+        failed += 1;
+        process.stdout.write(`FAIL ${testCase.name}
+`);
+      }
+    } catch (error) {
+      failed += 1;
+      process.stdout.write(
+        `FAIL ${testCase.name} (${error instanceof Error ? error.message : "Unknown test error"})
+`
+      );
+    }
+  }
+  process.stdout.write(`
+Test summary: ${passed} passed, ${failed} failed
+`);
+  return { passed, failed };
+};
+var buildTarget = async (workingDir, target) => {
+  const outDir = resolve(workingDir, ".agentl-build", target);
+  await mkdir(outDir, { recursive: true });
+  const serverEntrypoint = `import { startDevServer } from "agentl";
+
+const port = Number.parseInt(process.env.PORT ?? "3000", 10);
+await startDevServer(Number.isNaN(port) ? 3000 : port, { workingDir: process.cwd() });
+`;
+  const runtimePackageJson = JSON.stringify(
+    {
+      name: "agentl-runtime-bundle",
+      private: true,
+      type: "module",
+      scripts: {
+        start: "node server.js"
+      },
+      dependencies: {
+        agentl: "^0.1.0"
+      }
+    },
+    null,
+    2
+  );
+  if (target === "vercel") {
+    await mkdir(resolve(outDir, "api"), { recursive: true });
+    await writeFile(
+      resolve(outDir, "vercel.json"),
+      JSON.stringify(
+        {
+          version: 2,
+          functions: { "api/index.js": { runtime: "nodejs20.x", maxDuration: 60 } },
+          routes: [{ src: "/(.*)", dest: "/api/index.js" }]
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+    await writeFile(
+      resolve(outDir, "api", "index.js"),
+      `import { startDevServer } from "agentl";
+
+let serverPromise;
+export default async function handler(req, res) {
+  if (!serverPromise) {
+    serverPromise = startDevServer(0, { workingDir: process.cwd() });
+  }
+  const server = await serverPromise;
+  server.emit("request", req, res);
+}
+`,
+      "utf8"
+    );
+  } else if (target === "docker") {
+    await writeFile(
+      resolve(outDir, "Dockerfile"),
+      `FROM node:20-slim
+WORKDIR /app
+COPY package.json package.json
+COPY AGENT.md AGENT.md
+COPY agentl.config.js agentl.config.js
+COPY skills skills
+COPY tests tests
+COPY .env.example .env.example
+RUN corepack enable && npm install -g agentl
+COPY server.js server.js
+EXPOSE 3000
+CMD ["node","server.js"]
+`,
+      "utf8"
+    );
+    await writeFile(resolve(outDir, "server.js"), serverEntrypoint, "utf8");
+    await writeFile(resolve(outDir, "package.json"), runtimePackageJson, "utf8");
+  } else if (target === "lambda") {
+    await writeFile(
+      resolve(outDir, "lambda-handler.js"),
+      `import { startDevServer } from "agentl";
+let serverPromise;
+export const handler = async (event = {}) => {
+  if (!serverPromise) {
+    serverPromise = startDevServer(0, { workingDir: process.cwd() });
+  }
+  const body = JSON.stringify({
+    status: "ready",
+    route: event.rawPath ?? event.path ?? "/",
+  });
+  return { statusCode: 200, headers: { "content-type": "application/json" }, body };
+};
+`,
+      "utf8"
+    );
+    await writeFile(resolve(outDir, "package.json"), runtimePackageJson, "utf8");
+  } else if (target === "fly") {
+    await writeFile(
+      resolve(outDir, "fly.toml"),
+      `app = "agentl-app"
+[env]
+  PORT = "3000"
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_start_machines = true
+  auto_stop_machines = "stop"
+  min_machines_running = 0
+`,
+      "utf8"
+    );
+    await writeFile(
+      resolve(outDir, "Dockerfile"),
+      `FROM node:20-slim
+WORKDIR /app
+COPY package.json package.json
+COPY AGENT.md AGENT.md
+COPY agentl.config.js agentl.config.js
+COPY skills skills
+COPY tests tests
+RUN npm install -g agentl
+COPY server.js server.js
+EXPOSE 3000
+CMD ["node","server.js"]
+`,
+      "utf8"
+    );
+    await writeFile(resolve(outDir, "server.js"), serverEntrypoint, "utf8");
+    await writeFile(resolve(outDir, "package.json"), runtimePackageJson, "utf8");
+  } else {
+    throw new Error(`Unsupported build target: ${target}`);
+  }
+  process.stdout.write(`Build artifacts generated at ${outDir}
+`);
+};
+var normalizeMcpName = (entry) => entry.name ?? entry.url ?? `mcp_${Date.now()}`;
+var mcpAdd = async (workingDir, options) => {
+  const config = await loadAgentlConfig(workingDir) ?? { mcp: [] };
+  const mcp = [...config.mcp ?? []];
+  if (!options.url) {
+    throw new Error("Remote MCP only: provide --url for a remote MCP server.");
+  }
+  mcp.push({
+    name: options.name ?? normalizeMcpName({ url: options.url }),
+    url: options.url,
+    env: options.envVars ?? []
+  });
+  await writeConfigFile(workingDir, { ...config, mcp });
+  process.stdout.write("MCP server added.\n");
+};
+var mcpList = async (workingDir) => {
+  const config = await loadAgentlConfig(workingDir);
+  const mcp = config?.mcp ?? [];
+  if (mcp.length === 0) {
+    process.stdout.write("No MCP servers configured.\n");
+    return;
+  }
+  process.stdout.write("Configured MCP servers:\n");
+  for (const entry of mcp) {
+    process.stdout.write(`- ${entry.name ?? entry.url} (remote: ${entry.url})
+`);
+  }
+};
+var mcpRemove = async (workingDir, name) => {
+  const config = await loadAgentlConfig(workingDir) ?? { mcp: [] };
+  const before = config.mcp ?? [];
+  const filtered = before.filter((entry) => normalizeMcpName(entry) !== name);
+  await writeConfigFile(workingDir, { ...config, mcp: filtered });
+  process.stdout.write(`Removed MCP server: ${name}
+`);
+};
+var buildCli = () => {
+  const program = new Command();
+  program.name("agentl").description("CLI for building and running AgentL agents").version("0.1.0");
+  program.command("init").argument("<name>", "project name").description("Scaffold a new AgentL project").action(async (name) => {
+    await initProject(name);
+  });
+  program.command("dev").description("Run local development server").option("--port <port>", "server port", "3000").action(async (options) => {
+    const port = Number.parseInt(options.port, 10);
+    await startDevServer(Number.isNaN(port) ? 3e3 : port);
+  });
+  program.command("run").argument("[task]", "task to run").description("Execute the agent once").option("--param <keyValue>", "parameter key=value", (value, all) => {
+    all.push(value);
+    return all;
+  }, []).option("--file <path>", "include file contents", (value, all) => {
+    all.push(value);
+    return all;
+  }, []).option("--json", "output json", false).option("--interactive", "run in interactive mode", false).action(
+    async (task, options) => {
+      const params = parseParams(options.param);
+      if (options.interactive) {
+        await runInteractive(process.cwd(), params);
+        return;
+      }
+      if (!task) {
+        throw new Error("Task is required unless --interactive is used.");
+      }
+      await runOnce(task, {
+        params,
+        json: options.json,
+        filePaths: options.file
+      });
+    }
+  );
+  program.command("tools").description("List all tools available to the agent").action(async () => {
+    await listTools(process.cwd());
+  });
+  program.command("add").argument("<packageOrPath>", "skill package name/path").description("Add a skill package and validate SKILL.md").action(async (packageOrPath) => {
+    await addSkill(process.cwd(), packageOrPath);
+  });
+  program.command("test").argument("[file]", "test file path (yaml)").description("Run yaml-defined agent tests").action(async (file) => {
+    const testFile = file ? resolve(process.cwd(), file) : void 0;
+    const result = await runTests(process.cwd(), testFile);
+    if (result.failed > 0) {
+      process.exitCode = 1;
+    }
+  });
+  program.command("build").argument("<target>", "vercel|docker|lambda|fly").description("Generate build artifacts for deployment target").action(async (target) => {
+    await buildTarget(process.cwd(), target);
+  });
+  const mcpCommand = program.command("mcp").description("Manage MCP servers");
+  mcpCommand.command("add").requiredOption("--url <url>", "remote MCP url").option("--name <name>", "server name").option("--env <name>", "env variable (repeatable)", (value, all) => {
+    all.push(value);
+    return all;
+  }, []).action(
+    async (options) => {
+      await mcpAdd(process.cwd(), {
+        url: options.url,
+        name: options.name,
+        envVars: options.env
+      });
+    }
+  );
+  mcpCommand.command("list").description("List configured MCP servers").action(async () => {
+    await mcpList(process.cwd());
+  });
+  mcpCommand.command("remove").argument("<name>", "server name").description("Remove an MCP server by name").action(async (name) => {
+    await mcpRemove(process.cwd(), name);
+  });
+  return program;
+};
+var main = async (argv = process.argv) => {
+  try {
+    await buildCli().parseAsync(argv);
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE") {
+      const message = "Port is already in use. Try `agentl dev --port 3001` or stop the process using port 3000.";
+      process.stderr.write(`${message}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    process.stderr.write(`${error instanceof Error ? error.message : "Unknown CLI error"}
+`);
+    process.exitCode = 1;
+  }
+};
+var packageRoot = resolve(__dirname, "..");
+
+export {
+  initProject,
+  startDevServer,
+  runOnce,
+  runInteractive,
+  listTools,
+  addSkill,
+  runTests,
+  buildTarget,
+  mcpAdd,
+  mcpList,
+  mcpRemove,
+  buildCli,
+  main,
+  packageRoot
+};