@axiom-lattice/cli-a2a 0.1.1

package/dist/cli.js

@@ -0,0 +1,1562 @@
+#!/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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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/logger.ts
+var LogLevel, Logger, logger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+      LogLevel2[LogLevel2["DEBUG"] = 10] = "DEBUG";
+      LogLevel2[LogLevel2["INFO"] = 20] = "INFO";
+      LogLevel2[LogLevel2["WARN"] = 30] = "WARN";
+      LogLevel2[LogLevel2["ERROR"] = 40] = "ERROR";
+      return LogLevel2;
+    })(LogLevel || {});
+    Logger = class _Logger {
+      constructor(name) {
+        this.level = 20 /* INFO */;
+        this.name = name;
+      }
+      setLevel(level) {
+        this.level = level;
+      }
+      child(name) {
+        const childLogger = new _Logger(`${this.name}:${name}`);
+        childLogger.level = this.level;
+        return childLogger;
+      }
+      debug(msg, ctx) {
+        this.log(10 /* DEBUG */, msg, ctx);
+      }
+      info(msg, ctx) {
+        this.log(20 /* INFO */, msg, ctx);
+      }
+      warn(msg, ctx) {
+        this.log(30 /* WARN */, msg, ctx);
+      }
+      error(msg, ctx) {
+        this.log(40 /* ERROR */, msg, ctx);
+      }
+      log(level, msg, ctx) {
+        if (level < this.level) return;
+        const entry = {
+          level,
+          msg,
+          ctx: { name: this.name, ...ctx },
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const output = process.env.NODE_ENV === "production" ? JSON.stringify(entry) : `${entry.ts} [${LogLevel[entry.level]}] ${entry.ctx.name}: ${msg}${ctx && Object.keys(ctx).length > 1 ? " " + JSON.stringify(ctx) : ""}`;
+        if (level >= 30 /* WARN */) {
+          process.stderr.write(output + "\n");
+        } else {
+          process.stdout.write(output + "\n");
+        }
+      }
+    };
+    logger = new Logger("cli-a2a");
+  }
+});
+
+// src/executors/index.ts
+var executors_exports = {};
+__export(executors_exports, {
+  TaskState: () => import_sdk.TaskState,
+  createExecutor: () => createExecutor,
+  getExecutor: () => getExecutor,
+  registerExecutor: () => registerExecutor,
+  uuidv4: () => import_uuid.v4
+});
+function registerExecutor(provider, factory) {
+  registry.set(provider, factory);
+}
+function getExecutor(provider) {
+  return registry.get(provider);
+}
+function createExecutor(config) {
+  const factory = registry.get(config.provider);
+  if (!factory) {
+    const available = Array.from(registry.keys()).join(", ");
+    throw new Error(`Unknown provider: ${config.provider}. Available: ${available}`);
+  }
+  return factory(config);
+}
+var import_sdk, import_uuid, registry;
+var init_executors = __esm({
+  "src/executors/index.ts"() {
+    "use strict";
+    import_sdk = require("@a2a-js/sdk");
+    import_uuid = require("uuid");
+    registry = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/executors/opencode/client.ts
+var import_node_child_process, log4, OpenCodeClient;
+var init_client = __esm({
+  "src/executors/opencode/client.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    init_logger();
+    log4 = logger.child("opencode:client");
+    OpenCodeClient = class {
+      constructor(config) {
+        this.config = config;
+        this.currentChild = null;
+      }
+      /** Abort the currently running child process (if any). */
+      abort() {
+        if (this.currentChild) {
+          this.currentChild.kill("SIGTERM");
+          setTimeout(() => {
+            if (this.currentChild?.exitCode === null) {
+              this.currentChild.kill("SIGKILL");
+            }
+          }, 5e3);
+          this.currentChild = null;
+        }
+      }
+      /**
+       * Execute a prompt via the OpenCode CLI and return the response text.
+       */
+      async execute(prompt) {
+        const cliPath = this.config.cliPath || "opencode";
+        const timeout = this.config.timeout ?? 6e5;
+        const MAX_PROMPT = 1e5;
+        if (prompt.length > MAX_PROMPT) {
+          throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages or use a provider with HTTP API transport.`);
+        }
+        const env = {
+          PATH: process.env.PATH ?? "",
+          HOME: process.env.HOME ?? ""
+        };
+        for (const key of ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy"]) {
+          if (process.env[key]) env[key] = process.env[key];
+        }
+        for (const key of ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "OPENCODE_SERVER_PASSWORD", "OPENCODE_SERVER_USERNAME"]) {
+          if (process.env[key]) env[key] = process.env[key];
+        }
+        const args = ["run", prompt];
+        if (this.config.model) {
+          args.push("--model", this.config.model);
+        }
+        if (this.config.agent) {
+          args.push("--agent", this.config.agent);
+        }
+        if (this.config.attachUrl) {
+          args.push("--attach", this.config.attachUrl);
+        }
+        args.push("--format", "default");
+        args.push("--dangerously-skip-permissions");
+        log4.info("Spawning opencode", { cliPath, workdir: this.config.workdir, model: this.config.model });
+        return new Promise((resolve3, reject) => {
+          const child = (0, import_node_child_process.spawn)(cliPath, args, {
+            cwd: this.config.workdir || process.cwd(),
+            env,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          this.currentChild = child;
+          let stdout = "";
+          let stderr = "";
+          const MAX_OUTPUT = 1e7;
+          const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            const forceTimer = setTimeout(() => {
+              if (child.exitCode === null) child.kill("SIGKILL");
+            }, 5e3);
+            child.on("close", () => clearTimeout(forceTimer));
+            reject(new Error(`OpenCode execution timed out after ${timeout}ms`));
+          }, timeout);
+          child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+            if (stdout.length > MAX_OUTPUT) {
+              child.kill("SIGTERM");
+              setTimeout(() => {
+                if (child.exitCode === null) child.kill("SIGKILL");
+              }, 5e3);
+            }
+          });
+          child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+            log4.debug("OpenCode stderr", { text: chunk.toString().trim() });
+          });
+          child.on("close", (code) => {
+            clearTimeout(timer);
+            this.currentChild = null;
+            if (code === 0) {
+              resolve3(stdout.trim());
+            } else {
+              const errMsg = stderr.trim() || stdout.trim() || `OpenCode exited with code ${code}`;
+              log4.warn("OpenCode non-zero exit", { code, stderr: errMsg });
+              reject(new Error(errMsg));
+            }
+          });
+          child.on("error", (err) => {
+            clearTimeout(timer);
+            log4.error("OpenCode spawn failed", { error: err.message });
+            reject(new Error(`Failed to start opencode: ${err.message}. Is it installed?`));
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/executors/events.ts
+function publishTask(bus, taskId, contextId) {
+  bus.publish({
+    kind: "task",
+    taskId,
+    contextId
+  });
+}
+function publishStatus(bus, taskId, contextId, state, messageText, final) {
+  const event = {
+    kind: "task-status-update",
+    taskId,
+    contextId,
+    status: {
+      state,
+      message: messageText ? { role: "agent", parts: [{ kind: "text", text: messageText }] } : void 0
+    },
+    final: final ?? false
+  };
+  bus.publish(event);
+}
+function publishFinalArtifact(bus, taskId, contextId, text) {
+  const artifactId = (0, import_uuid2.v4)();
+  const event = {
+    kind: "task-artifact-update",
+    taskId,
+    contextId,
+    artifact: {
+      artifactId,
+      parts: [{ kind: "text", text }]
+    },
+    lastChunk: true
+  };
+  bus.publish(event);
+}
+var import_uuid2;
+var init_events = __esm({
+  "src/executors/events.ts"() {
+    "use strict";
+    import_uuid2 = require("uuid");
+  }
+});
+
+// src/executors/opencode/executor.ts
+var executor_exports = {};
+__export(executor_exports, {
+  OpenCodeExecutor: () => OpenCodeExecutor,
+  createOpenCodeExecutor: () => createOpenCodeExecutor
+});
+function createOpenCodeExecutor(config) {
+  return new OpenCodeExecutor(config);
+}
+var log5, OpenCodeExecutor;
+var init_executor = __esm({
+  "src/executors/opencode/executor.ts"() {
+    "use strict";
+    init_logger();
+    init_client();
+    init_events();
+    log5 = logger.child("opencode:executor");
+    OpenCodeExecutor = class {
+      constructor(config) {
+        this.client = null;
+        this.initialized = false;
+        this.config = config;
+      }
+      async initialize() {
+        if (this.initialized) return;
+        const oc = this.config.opencode;
+        this.client = new OpenCodeClient({
+          cliPath: "opencode",
+          workdir: oc.projectDirectory || process.cwd(),
+          model: oc.model || void 0,
+          agent: oc.agent || void 0,
+          attachUrl: oc.baseUrl || void 0,
+          timeout: this.config.timeouts.prompt ?? 6e5
+        });
+        this.initialized = true;
+        log5.info("Executor initialized", { workdir: oc.projectDirectory, model: oc.model });
+      }
+      async shutdown() {
+        this.client = null;
+        this.initialized = false;
+        log5.info("Executor shut down");
+      }
+      async execute(ctx, bus) {
+        const { taskId, contextId, userMessage, task } = ctx;
+        await this.initialize();
+        try {
+          if (!task) {
+            publishTask(bus, taskId, contextId);
+            publishStatus(bus, taskId, contextId, "submitted");
+          }
+          publishStatus(bus, taskId, contextId, "working", "Processing request...");
+          const promptText = this.extractText(userMessage);
+          log5.info("Sending prompt to OpenCode", { taskId, len: promptText.length });
+          const response = await this.client.execute(promptText);
+          const finalText = response || "No response from OpenCode.";
+          publishFinalArtifact(bus, taskId, contextId, finalText);
+          publishStatus(bus, taskId, contextId, "completed", void 0, true);
+          bus.finished();
+          log5.info("Task completed", { taskId, len: finalText.length });
+        } catch (error) {
+          const msg = error.message ?? String(error);
+          log5.error("Execution failed", { taskId, error: msg });
+          publishStatus(bus, taskId, contextId, "failed", `Error: ${msg}`, true);
+          bus.finished();
+        }
+      }
+      async cancelTask(taskId, bus) {
+        log5.info("Cancel requested for OpenCode task", { taskId });
+        this.client?.abort();
+        publishStatus(bus, taskId, "", "canceled", "OpenCode task cancelled", true);
+        bus.finished();
+      }
+      extractText(message) {
+        return message.parts.filter((p) => {
+          const part = p;
+          const text = part.text;
+          return text !== void 0 && text !== null;
+        }).map((p) => p.text).join("\n");
+      }
+    };
+  }
+});
+
+// src/executors/codex/client.ts
+var import_node_child_process2, log6, CodexClient;
+var init_client2 = __esm({
+  "src/executors/codex/client.ts"() {
+    "use strict";
+    import_node_child_process2 = require("child_process");
+    init_logger();
+    log6 = logger.child("codex:client");
+    CodexClient = class {
+      constructor(config) {
+        this.config = config;
+        this.currentChild = null;
+      }
+      abort() {
+        if (this.currentChild) {
+          this.currentChild.kill("SIGTERM");
+          setTimeout(() => {
+            if (this.currentChild?.exitCode === null) {
+              this.currentChild.kill("SIGKILL");
+            }
+          }, 5e3);
+          this.currentChild = null;
+        }
+      }
+      /**
+       * Execute a prompt via the Codex CLI and return the response text.
+       */
+      async execute(prompt) {
+        const cliPath = this.config.cliPath || "codex";
+        const timeout = this.config.timeout ?? 3e5;
+        const MAX_PROMPT = 1e5;
+        if (prompt.length > MAX_PROMPT) {
+          throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
+        }
+        const env = {
+          PATH: process.env.PATH ?? "",
+          HOME: process.env.HOME ?? ""
+        };
+        for (const key of ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy"]) {
+          if (process.env[key]) env[key] = process.env[key];
+        }
+        if (this.config.apiKey) {
+          env["OPENAI_API_KEY"] = this.config.apiKey;
+        }
+        const args = [];
+        if (this.config.model) {
+          args.push("--model", this.config.model);
+        }
+        args.push(prompt);
+        log6.info("Spawning codex", { cliPath, workdir: this.config.workdir, model: this.config.model });
+        return new Promise((resolve3, reject) => {
+          const child = (0, import_node_child_process2.spawn)(cliPath, args, {
+            cwd: this.config.workdir || process.cwd(),
+            env,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          this.currentChild = child;
+          let stdout = "";
+          let stderr = "";
+          const MAX_OUTPUT = 1e7;
+          const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            const forceTimer = setTimeout(() => {
+              if (child.exitCode === null) child.kill("SIGKILL");
+            }, 5e3);
+            child.on("close", () => clearTimeout(forceTimer));
+            reject(new Error(`Codex execution timed out after ${timeout}ms`));
+          }, timeout);
+          child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+            if (stdout.length > MAX_OUTPUT) {
+              child.kill("SIGTERM");
+              setTimeout(() => {
+                if (child.exitCode === null) child.kill("SIGKILL");
+              }, 5e3);
+            }
+          });
+          child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+            log6.debug("Codex stderr", { text: chunk.toString().trim() });
+          });
+          child.on("close", (code) => {
+            clearTimeout(timer);
+            this.currentChild = null;
+            if (code === 0) {
+              resolve3(stdout.trim());
+            } else {
+              const errMsg = stderr.trim() || stdout.trim() || `Codex exited with code ${code}`;
+              log6.warn("Codex non-zero exit", { code, stderr: errMsg });
+              reject(new Error(errMsg));
+            }
+          });
+          child.on("error", (err) => {
+            clearTimeout(timer);
+            log6.error("Codex spawn failed", { error: err.message });
+            reject(new Error(`Failed to start codex: ${err.message}. Is it installed? (npm i -g @openai/codex)`));
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/executors/codex/executor.ts
+var executor_exports2 = {};
+__export(executor_exports2, {
+  CodexExecutor: () => CodexExecutor,
+  createCodexExecutor: () => createCodexExecutor
+});
+function createCodexExecutor(config) {
+  return new CodexExecutor(config);
+}
+var log7, CodexExecutor;
+var init_executor2 = __esm({
+  "src/executors/codex/executor.ts"() {
+    "use strict";
+    init_logger();
+    init_client2();
+    init_events();
+    log7 = logger.child("codex:executor");
+    CodexExecutor = class {
+      constructor(config) {
+        this.client = null;
+        this.initialized = false;
+        this.config = config;
+      }
+      async initialize() {
+        if (this.initialized) return;
+        const cx = this.config.codex;
+        this.client = new CodexClient({
+          cliPath: cx.cliPath,
+          workdir: cx.workdir,
+          model: cx.model || void 0,
+          apiKey: cx.apiKey || void 0,
+          timeout: this.config.timeouts.prompt ?? 6e5
+        });
+        this.initialized = true;
+        log7.info("Executor initialized", { cliPath: cx.cliPath, workdir: cx.workdir });
+      }
+      async shutdown() {
+        this.client = null;
+        this.initialized = false;
+        log7.info("Executor shut down");
+      }
+      async execute(ctx, bus) {
+        const { taskId, contextId, userMessage, task } = ctx;
+        await this.initialize();
+        try {
+          if (!task) {
+            publishTask(bus, taskId, contextId);
+            publishStatus(bus, taskId, contextId, "submitted");
+          }
+          publishStatus(bus, taskId, contextId, "working", "Processing request...");
+          const promptText = this.extractText(userMessage);
+          log7.info("Sending prompt to Codex", { taskId, len: promptText.length });
+          const response = await this.client.execute(promptText);
+          const finalText = response || "No response from Codex.";
+          publishFinalArtifact(bus, taskId, contextId, finalText);
+          publishStatus(bus, taskId, contextId, "completed", void 0, true);
+          bus.finished();
+          log7.info("Task completed", { taskId, len: finalText.length });
+        } catch (error) {
+          const msg = error.message ?? String(error);
+          log7.error("Execution failed", { taskId, error: msg });
+          publishStatus(bus, taskId, contextId, "failed", `Error: ${msg}`, true);
+          bus.finished();
+        }
+      }
+      async cancelTask(taskId, bus) {
+        log7.info("Cancel requested for Codex task", { taskId });
+        this.client?.abort();
+        publishStatus(bus, taskId, "", "canceled", "Codex task cancelled", true);
+        bus.finished();
+      }
+      // ── Helpers ─────────────────────────────────────────────────────────────
+      extractText(message) {
+        return message.parts.filter((p) => {
+          const part = p;
+          const text = part.text;
+          return text !== void 0 && text !== null;
+        }).map((p) => p.text).join("\n");
+      }
+    };
+  }
+});
+
+// src/executors/claude/client.ts
+var import_node_child_process3, log8, ClaudeClient;
+var init_client3 = __esm({
+  "src/executors/claude/client.ts"() {
+    "use strict";
+    import_node_child_process3 = require("child_process");
+    init_logger();
+    log8 = logger.child("claude:client");
+    ClaudeClient = class {
+      constructor(config) {
+        this.config = config;
+        this.currentChild = null;
+      }
+      abort() {
+        if (this.currentChild) {
+          this.currentChild.kill("SIGTERM");
+          setTimeout(() => {
+            if (this.currentChild?.exitCode === null) {
+              this.currentChild.kill("SIGKILL");
+            }
+          }, 5e3);
+          this.currentChild = null;
+        }
+      }
+      /**
+       * Execute a prompt via the Claude Code CLI and return the response text.
+       */
+      async execute(prompt) {
+        const cliPath = this.config.cliPath || "claude";
+        const timeout = this.config.timeout ?? 3e5;
+        const MAX_PROMPT = 1e5;
+        if (prompt.length > MAX_PROMPT) {
+          throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
+        }
+        const env = {
+          PATH: process.env.PATH ?? "",
+          HOME: process.env.HOME ?? ""
+        };
+        for (const key of ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy"]) {
+          if (process.env[key]) env[key] = process.env[key];
+        }
+        if (this.config.apiKey) {
+          env["ANTHROPIC_API_KEY"] = this.config.apiKey;
+        }
+        const args = ["-p"];
+        if (this.config.model) {
+          args.push("--model", this.config.model);
+        }
+        args.push(prompt);
+        log8.info("Spawning claude", { cliPath, workdir: this.config.workdir, model: this.config.model });
+        return new Promise((resolve3, reject) => {
+          const child = (0, import_node_child_process3.spawn)(cliPath, args, {
+            cwd: this.config.workdir || process.cwd(),
+            env,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          this.currentChild = child;
+          let stdout = "";
+          let stderr = "";
+          const MAX_OUTPUT = 1e7;
+          const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            const forceTimer = setTimeout(() => {
+              if (child.exitCode === null) child.kill("SIGKILL");
+            }, 5e3);
+            child.on("close", () => clearTimeout(forceTimer));
+            reject(new Error(`Claude Code execution timed out after ${timeout}ms`));
+          }, timeout);
+          child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+            if (stdout.length > MAX_OUTPUT) {
+              child.kill("SIGTERM");
+              setTimeout(() => {
+                if (child.exitCode === null) child.kill("SIGKILL");
+              }, 5e3);
+            }
+          });
+          child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+            log8.debug("Claude stderr", { text: chunk.toString().trim() });
+          });
+          child.on("close", (code) => {
+            clearTimeout(timer);
+            this.currentChild = null;
+            if (code === 0) {
+              resolve3(stdout.trim());
+            } else {
+              const errMsg = stderr.trim() || stdout.trim() || `Claude Code exited with code ${code}`;
+              log8.warn("Claude non-zero exit", { code, stderr: errMsg });
+              reject(new Error(errMsg));
+            }
+          });
+          child.on("error", (err) => {
+            clearTimeout(timer);
+            log8.error("Claude spawn failed", { error: err.message });
+            reject(new Error(`Failed to start claude: ${err.message}. Install: npm i -g @anthropic-ai/claude-code`));
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/executors/claude/executor.ts
+var executor_exports3 = {};
+__export(executor_exports3, {
+  ClaudeExecutor: () => ClaudeExecutor,
+  createClaudeExecutor: () => createClaudeExecutor
+});
+function createClaudeExecutor(config) {
+  return new ClaudeExecutor(config);
+}
+var log9, ClaudeExecutor;
+var init_executor3 = __esm({
+  "src/executors/claude/executor.ts"() {
+    "use strict";
+    init_logger();
+    init_client3();
+    init_events();
+    log9 = logger.child("claude:executor");
+    ClaudeExecutor = class {
+      constructor(config) {
+        this.client = null;
+        this.initialized = false;
+        this.config = config;
+      }
+      async initialize() {
+        if (this.initialized) return;
+        const cc = this.config.claude;
+        this.client = new ClaudeClient({
+          cliPath: cc.cliPath,
+          workdir: cc.workdir,
+          model: cc.model || void 0,
+          apiKey: cc.apiKey || void 0,
+          timeout: this.config.timeouts.prompt ?? 6e5
+        });
+        this.initialized = true;
+        log9.info("Executor initialized", { cliPath: cc.cliPath, workdir: cc.workdir });
+      }
+      async shutdown() {
+        this.client = null;
+        this.initialized = false;
+        log9.info("Executor shut down");
+      }
+      async execute(ctx, bus) {
+        const { taskId, contextId, userMessage, task } = ctx;
+        await this.initialize();
+        try {
+          if (!task) {
+            publishTask(bus, taskId, contextId);
+            publishStatus(bus, taskId, contextId, "submitted");
+          }
+          publishStatus(bus, taskId, contextId, "working", "Processing request...");
+          const promptText = this.extractText(userMessage);
+          log9.info("Sending prompt to Claude Code", { taskId, len: promptText.length });
+          const response = await this.client.execute(promptText);
+          const finalText = response || "No response from Claude Code.";
+          publishFinalArtifact(bus, taskId, contextId, finalText);
+          publishStatus(bus, taskId, contextId, "completed", void 0, true);
+          bus.finished();
+          log9.info("Task completed", { taskId, len: finalText.length });
+        } catch (error) {
+          const msg = error.message ?? String(error);
+          log9.error("Execution failed", { taskId, error: msg });
+          publishStatus(bus, taskId, contextId, "failed", `Error: ${msg}`, true);
+          bus.finished();
+        }
+      }
+      async cancelTask(taskId, bus) {
+        log9.info("Cancel requested for Claude Code task", { taskId });
+        this.client?.abort();
+        publishStatus(bus, taskId, "", "canceled", "Claude Code task cancelled", true);
+        bus.finished();
+      }
+      extractText(message) {
+        return message.parts.filter((p) => {
+          const part = p;
+          const text = part.text;
+          return text !== void 0 && text !== null;
+        }).map((p) => p.text).join("\n");
+      }
+    };
+  }
+});
+
+// src/bridge.ts
+var bridge_exports = {};
+__export(bridge_exports, {
+  BridgeClient: () => BridgeClient
+});
+var import_node_net, import_node_crypto, log10, SimpleWs, BridgeClient;
+var init_bridge = __esm({
+  "src/bridge.ts"() {
+    "use strict";
+    import_node_net = require("net");
+    import_node_crypto = require("crypto");
+    init_logger();
+    log10 = logger.child("bridge");
+    SimpleWs = class {
+      constructor() {
+        this.socket = null;
+        this.buffer = Buffer.alloc(0);
+        this.handshaking = true;
+        this.httpBuffer = "";
+      }
+      connect(urlStr, apiKey) {
+        const url = new URL(urlStr);
+        const host = url.hostname;
+        const port = parseInt(url.port) || (url.protocol === "wss:" ? 443 : 80);
+        const path = url.pathname + url.search;
+        const key = (0, import_node_crypto.randomBytes)(16).toString("base64");
+        const req = (0, import_node_net.connect)({ host, port }, () => {
+          const headers = [
+            `GET ${path} HTTP/1.1`,
+            `Host: ${host}:${port}`,
+            "Upgrade: websocket",
+            "Connection: Upgrade",
+            `Sec-WebSocket-Key: ${key}`,
+            "Sec-WebSocket-Version: 13",
+            `x-api-key: ${apiKey}`,
+            "",
+            ""
+          ].join("\r\n");
+          if (this.socket) {
+            this.socket.write(headers);
+          }
+        });
+        this.socket = req;
+        req.on("data", (chunk) => {
+          this.buffer = Buffer.concat([this.buffer, chunk]);
+          if (this.handshaking) {
+            this.httpBuffer += chunk.toString();
+            const headerEnd = this.httpBuffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1) return;
+            const header = this.httpBuffer.substring(0, headerEnd);
+            const statusLine = header.split("\r\n")[0] || "";
+            if (!statusLine.startsWith("HTTP/1.1 101")) {
+              const bodyStart = headerEnd + 4;
+              const bodyText = this.httpBuffer.substring(bodyStart).trim();
+              const errMsg = statusLine ? `WebSocket upgrade rejected: ${statusLine}` : "WebSocket upgrade failed: no status line";
+              this.onerror?.(new Error(errMsg + (bodyText ? ` (${bodyText.slice(0, 200)})` : "")));
+              this.socket?.destroy();
+              this.socket = null;
+              return;
+            }
+            this.handshaking = false;
+            const remaining = this.buffer.subarray(headerEnd + 4);
+            this.buffer = remaining;
+            this.httpBuffer = "";
+            if (this.onopen) this.onopen();
+            if (remaining.length === 0) return;
+          }
+          while (this.buffer.length >= 2) {
+            const opcode = this.buffer[0] & 15;
+            const masked = (this.buffer[1] & 128) !== 0;
+            let offset = 2;
+            let payloadLen = this.buffer[1] & 127;
+            if (payloadLen === 126) {
+              if (this.buffer.length < 4) break;
+              payloadLen = this.buffer.readUInt16BE(2);
+              offset = 4;
+            } else if (payloadLen === 127) {
+              if (this.buffer.length < 10) break;
+              const hi = this.buffer.readUInt32BE(2);
+              const lo = this.buffer.readUInt32BE(6);
+              payloadLen = hi * 4294967296 + lo;
+              offset = 10;
+            }
+            if (this.buffer.length < offset + payloadLen) break;
+            const payload = this.buffer.subarray(offset, offset + payloadLen);
+            this.buffer = this.buffer.subarray(offset + payloadLen);
+            if (masked) {
+              const mask = payload.subarray(0, 4);
+              const data = payload.subarray(4);
+              for (let i = 0; i < data.length; i++) {
+                data[i] ^= mask[i % 4];
+              }
+              if (opcode === 1) {
+                this.onmessage?.(data.toString());
+              }
+            } else {
+              if (opcode === 1) {
+                this.onmessage?.(payload.toString());
+              } else if (opcode === 8) {
+                this.onclose?.(1e3);
+                return;
+              } else if (opcode === 9) {
+                const pong = Buffer.from([138, 0]);
+                this.socket?.write(pong);
+              }
+            }
+          }
+        });
+        req.on("error", (err) => {
+          this.onerror?.(err);
+        });
+        req.on("close", () => {
+          this.onclose?.(1006);
+        });
+      }
+      send(data) {
+        if (!this.socket) return;
+        const payload = Buffer.from(data, "utf-8");
+        const len = payload.length;
+        const maskKey = (0, import_node_crypto.randomBytes)(4);
+        const masked = Buffer.alloc(len);
+        for (let i = 0; i < len; i++) {
+          masked[i] = payload[i] ^ maskKey[i % 4];
+        }
+        let header;
+        if (len < 126) {
+          header = Buffer.alloc(6);
+          header[0] = 129;
+          header[1] = 128 | len;
+          maskKey.copy(header, 2);
+        } else if (len < 65536) {
+          header = Buffer.alloc(8);
+          header[0] = 129;
+          header[1] = 128 | 126;
+          header.writeUInt16BE(len, 2);
+          maskKey.copy(header, 4);
+        } else {
+          header = Buffer.alloc(14);
+          header[0] = 129;
+          header[1] = 128 | 127;
+          header.writeUInt32BE(0, 2);
+          header.writeUInt32BE(len, 6);
+          maskKey.copy(header, 10);
+        }
+        this.socket.write(Buffer.concat([header, masked]));
+      }
+      close() {
+        if (!this.socket) return;
+        const frame = Buffer.from([136, 0]);
+        this.socket.write(frame);
+        this.socket.destroy();
+        this.socket = null;
+      }
+    };
+    BridgeClient = class {
+      constructor(config) {
+        this.config = config;
+        this.ws = null;
+        this.running = false;
+        this.reconnectTimer = null;
+      }
+      /**
+       * Start the bridge — connect WebSocket and begin serving proxy requests.
+       * Returns a promise that resolves when connected. Reconnects on disconnect.
+       */
+      async start() {
+        this.running = true;
+        return new Promise((resolve3, reject) => {
+          this.ws = new SimpleWs();
+          let firstConnect = true;
+          this.ws.onopen = () => {
+            log10.info("Bridge connected");
+            this.ws.send(JSON.stringify({
+              type: "agent:register",
+              agentId: this.config.agentId,
+              agentCard: this.config.agentCard
+            }));
+          };
+          this.ws.onmessage = async (raw) => {
+            let msg;
+            try {
+              msg = JSON.parse(raw);
+            } catch {
+              return;
+            }
+            if (msg.type === "agent:registered") {
+              log10.info("Agent registered via bridge", { agentId: this.config.agentId });
+              if (firstConnect) {
+                firstConnect = false;
+                resolve3();
+              }
+              return;
+            }
+            if (msg.type === "http:request") {
+              this.handleHttpRequest(msg);
+            }
+          };
+          this.ws.onclose = () => {
+            log10.warn("Bridge disconnected, reconnecting...");
+            if (this.running) {
+              this.reconnectTimer = setTimeout(
+                () => this.start().catch(() => {
+                }),
+                this.config.reconnectDelay ?? 5e3
+              );
+            }
+          };
+          this.ws.onerror = (err) => {
+            log10.error("Bridge error", { error: err.message });
+            if (firstConnect) {
+              firstConnect = false;
+              reject(err);
+            }
+          };
+          log10.info("Connecting bridge", { url: this.config.bridgeUrl });
+          this.ws.connect(this.config.bridgeUrl, this.config.apiKey);
+        });
+      }
+      /**
+       * Stop the bridge.
+       */
+      stop() {
+        this.running = false;
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = null;
+        }
+        this.ws?.close();
+        this.ws = null;
+        log10.info("Bridge stopped");
+      }
+      // ── Internal ────────────────────────────────────────────────────────────
+      async handleHttpRequest(msg) {
+        const requestId = msg.requestId;
+        const method = msg.method ?? "GET";
+        const path = msg.path ?? "/";
+        const headers = msg.headers ?? {};
+        const body = msg.body ?? "";
+        const url = `${this.config.localBaseUrl}${path}`;
+        try {
+          const fetchHeaders = { ...headers };
+          const fetchOpts = {
+            method,
+            headers: fetchHeaders,
+            signal: AbortSignal.timeout(3e5)
+          };
+          if (body && method !== "GET") {
+            fetchOpts.body = body;
+          }
+          const resp = await fetch(url, fetchOpts);
+          const responseBody = await resp.text();
+          const responseHeaders = {};
+          resp.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+          });
+          this.ws?.send(JSON.stringify({
+            type: "http:response",
+            requestId,
+            status: resp.status,
+            headers: responseHeaders,
+            body: responseBody
+          }));
+        } catch (err) {
+          log10.error("Proxy request failed", { url, error: err.message });
+          this.ws?.send(JSON.stringify({
+            type: "http:error",
+            requestId,
+            message: err.message
+          }));
+        }
+      }
+    };
+  }
+});
+
+// src/cli.ts
+var import_node_util = require("util");
+var import_node_path2 = require("path");
+
+// src/config/loader.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/config/defaults.ts
+function withDefaults(partial, defaults) {
+  const result = { ...defaults };
+  for (const key of Object.keys(partial)) {
+    const val = partial[key];
+    if (val !== void 0 && val !== null) {
+      if (typeof val === "object" && !Array.isArray(val) && typeof defaults[key] === "object" && !Array.isArray(defaults[key])) {
+        result[key] = {
+          ...defaults[key],
+          ...val
+        };
+      } else {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+var DEFAULTS = Object.freeze({
+  provider: "opencode",
+  agentCard: {
+    name: "CLI A2A Agent",
+    description: "A multi-provider A2A agent driven by local CLI coding tools.",
+    protocolVersion: "0.3.0",
+    version: "0.1.0",
+    skills: [],
+    defaultInputModes: ["text"],
+    defaultOutputModes: ["text"],
+    streaming: true,
+    pushNotifications: false
+  },
+  server: {
+    port: 3e3,
+    hostname: "0.0.0.0",
+    advertiseHost: "localhost",
+    advertiseProtocol: "http"
+  },
+  session: {
+    titlePrefix: "A2A Session",
+    reuseByContext: true,
+    ttl: 36e5,
+    cleanupInterval: 3e5
+  },
+  features: {
+    autoApprovePermissions: true,
+    autoAnswerQuestions: true,
+    streamArtifactChunks: false,
+    enablePollingFallback: true
+  },
+  timeouts: {
+    prompt: 6e5,
+    pollingInterval: 2e3,
+    healthCheck: 3e4
+  },
+  logging: {
+    level: "info"
+  },
+  opencode: {
+    baseUrl: "http://localhost:4096",
+    projectDirectory: "",
+    model: "",
+    agent: "",
+    systemPrompt: "",
+    systemPromptMode: "append",
+    contextFile: "context.md",
+    contextPrompt: ""
+  },
+  codex: {
+    cliPath: "codex",
+    workdir: process.cwd(),
+    model: "",
+    apiKey: ""
+  },
+  claude: {
+    cliPath: "claude",
+    workdir: process.cwd(),
+    model: "",
+    apiKey: ""
+  },
+  configDir: void 0
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+});
+function resolveDefaults(overrides) {
+  return withDefaults(overrides, DEFAULTS);
+}
+
+// src/config/loader.ts
+init_logger();
+var log = logger.child("config");
+function loadConfigFile(filePath) {
+  const absPath = (0, import_node_path.resolve)(filePath);
+  if (!(0, import_node_fs.existsSync)(absPath)) {
+    throw new Error(`Config file not found: ${absPath}`);
+  }
+  try {
+    const raw = (0, import_node_fs.readFileSync)(absPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof SyntaxError ? `Invalid JSON in config file: ${err.message}` : `Failed to read config file: ${err.message}`;
+    throw new Error(msg);
+  }
+}
+function loadEnvOverrides() {
+  const overrides = {
+    opencode: {},
+    codex: {},
+    claude: {}
+  };
+  if (process.env.OPENCODE_URL) overrides.opencode.baseUrl = process.env.OPENCODE_URL;
+  if (process.env.OPENCODE_DIRECTORY) overrides.opencode.projectDirectory = process.env.OPENCODE_DIRECTORY;
+  if (process.env.OPENCODE_MODEL) overrides.opencode.model = process.env.OPENCODE_MODEL;
+  if (process.env.OPENCODE_AGENT) overrides.opencode.agent = process.env.OPENCODE_AGENT;
+  if (process.env.OPENCODE_SYSTEM_PROMPT) overrides.opencode.systemPrompt = process.env.OPENCODE_SYSTEM_PROMPT;
+  if (process.env.OPENAI_API_KEY) overrides.codex.apiKey = process.env.OPENAI_API_KEY;
+  if (process.env.CODEX_MODEL) overrides.codex.model = process.env.CODEX_MODEL;
+  if (process.env.ANTHROPIC_API_KEY) overrides.claude.apiKey = process.env.ANTHROPIC_API_KEY;
+  if (process.env.CLAUDE_MODEL) overrides.claude.model = process.env.CLAUDE_MODEL;
+  return overrides;
+}
+function resolveConfig(configPath, cliOverrides) {
+  let fileConfig = {};
+  if (configPath) {
+    fileConfig = loadConfigFile(configPath);
+    log.info("Loaded config file", { path: configPath });
+  }
+  const envOverrides = loadEnvOverrides();
+  const cliConfig = cliOverrides ?? {};
+  const cloned = structuredClone(resolveDefaults(fileConfig));
+  const base = cloned;
+  mergeOverrides(base, envOverrides);
+  mergeOverrides(base, cliConfig);
+  if (configPath) {
+    base.configDir = (0, import_node_path.dirname)((0, import_node_path.resolve)(configPath));
+  }
+  return base;
+}
+function mergeOverrides(target, source) {
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (srcVal !== void 0 && srcVal !== null && typeof srcVal === "object" && !Array.isArray(srcVal) && tgtVal !== void 0 && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
+      if (Object.keys(srcVal).length > 0) {
+        mergeOverrides(tgtVal, srcVal);
+      }
+    } else if (srcVal !== void 0 && srcVal !== null) {
+      target[key] = srcVal;
+    }
+  }
+}
+
+// src/server/index.ts
+var import_express = __toESM(require("express"));
+var import_sdk2 = require("@a2a-js/sdk");
+var import_server = require("@a2a-js/sdk/server");
+var import_express2 = require("@a2a-js/sdk/server/express");
+
+// src/server/agent-card.ts
+init_logger();
+var log2 = logger.child("agent-card");
+function buildAgentCard(config) {
+  const { agentCard, server } = config;
+  const proto = server.advertiseProtocol ?? "http";
+  const host = server.advertiseHost ?? "localhost";
+  const port = server.port ?? 3e3;
+  const baseUrl = `${proto}://${host}:${port}`;
+  const skills = (agentCard.skills ?? []).map((s) => ({
+    id: s.id,
+    name: s.name,
+    description: s.description,
+    tags: s.tags ?? [],
+    examples: s.examples ?? []
+  }));
+  const card = {
+    name: agentCard.name,
+    description: agentCard.description,
+    protocolVersion: agentCard.protocolVersion ?? "0.3.0",
+    version: agentCard.version ?? "1.0.0",
+    url: `${baseUrl}/a2a/jsonrpc`,
+    // Default input/output modes (A2A v1.0 normalized names)
+    defaultInputModes: agentCard.defaultInputModes ?? ["text"],
+    defaultOutputModes: agentCard.defaultOutputModes ?? ["text"],
+    skills,
+    capabilities: {
+      streaming: agentCard.streaming ?? true,
+      pushNotifications: agentCard.pushNotifications ?? false
+    },
+    // Additional interfaces advertised to orchestrators
+    additionalInterfaces: [
+      { transport: "JSONRPC", url: `${baseUrl}/a2a/jsonrpc` },
+      { transport: "REST", url: `${baseUrl}/a2a/rest` }
+    ]
+  };
+  log2.info("Agent card built", { name: card.name, url: card.url, skills: card.skills?.length ?? 0 });
+  return card;
+}
+
+// src/server/index.ts
+init_executors();
+init_logger();
+var log3 = logger.child("server");
+async function createA2AServer(config) {
+  const srv = config.server;
+  const port = srv.port ?? 3e3;
+  const hostname = srv.hostname ?? "0.0.0.0";
+  const advertiseHost = srv.advertiseHost ?? "localhost";
+  const advertiseProto = srv.advertiseProtocol ?? "http";
+  const executor = createExecutor(config);
+  await executor.initialize();
+  const agentCard = buildAgentCard(config);
+  const taskStore = new import_server.InMemoryTaskStore();
+  const requestHandler = new import_server.DefaultRequestHandler(agentCard, taskStore, executor);
+  const app = (0, import_express.default)();
+  app.use((_req, res, next) => {
+    res.setHeader("A2A-Version", "0.3");
+    next();
+  });
+  app.get("/health", (_req, res) => {
+    res.json({ status: "healthy", agent: agentCard.name, provider: config.provider });
+  });
+  const serveAgentCard = (req, res) => {
+    const host = req.headers.host || `${advertiseHost}:${port}`;
+    const proto = req.headers["x-forwarded-proto"] || advertiseProto;
+    const dynamicBase = `${proto}://${host}`;
+    res.json({
+      ...agentCard,
+      url: `${dynamicBase}/a2a/jsonrpc`,
+      additionalInterfaces: [
+        { transport: "JSONRPC", url: `${dynamicBase}/a2a/jsonrpc` },
+        { transport: "REST", url: `${dynamicBase}/a2a/rest` }
+      ]
+    });
+  };
+  app.get(`/${import_sdk2.AGENT_CARD_PATH}`, serveAgentCard);
+  app.get("/.well-known/agent.json", serveAgentCard);
+  app.get("/.well-known/agent-json", serveAgentCard);
+  app.use("/a2a/jsonrpc", (0, import_express2.jsonRpcHandler)({ requestHandler, userBuilder: import_express2.UserBuilder.noAuthentication }));
+  app.use("/a2a/rest", (0, import_express2.restHandler)({ requestHandler, userBuilder: import_express2.UserBuilder.noAuthentication }));
+  const httpServer = app.listen(port, hostname, () => {
+    log3.info("A2A server started", { bind: hostname, port, proto: advertiseProto });
+    const banner = [
+      "",
+      "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
+      `\u2551       CLI A2A Gateway \u2014 ${config.provider.padEnd(28)}\u2551`,
+      "\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563",
+      `\u2551  Agent:         ${agentCard.name}`,
+      `\u2551  Bind:          ${hostname}:${port}`,
+      `\u2551  Agent Card:    ${advertiseProto}://${advertiseHost}:${port}/${import_sdk2.AGENT_CARD_PATH}`,
+      `\u2551  JSON-RPC:      ${advertiseProto}://${advertiseHost}:${port}/a2a/jsonrpc`,
+      `\u2551  REST:          ${advertiseProto}://${advertiseHost}:${port}/a2a/rest`,
+      `\u2551  Health:        ${advertiseProto}://${advertiseHost}:${port}/health`,
+      "\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563",
+      "\u2551  Ready. Press Ctrl+C to stop.                               \u2551",
+      "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+    ].join("\n");
+    console.log(banner);
+  });
+  return {
+    app,
+    server: httpServer,
+    async shutdown() {
+      httpServer.close();
+      await executor.shutdown();
+      log3.info("Server shut down");
+    }
+  };
+}
+
+// src/cli.ts
+init_logger();
+var log11 = logger.child("cli");
+var PKG_VERSION = "0.1.0";
+function printUsage() {
+  console.log(`
+Usage: cli-a2a [options]
+
+Options:
+  --provider <name>            Provider: opencode | codex | claude
+  --config, -c <path>          Path to agent JSON config file
+  --port, -p <number>          A2A server port (default: 3000)
+  --hostname <addr>            Bind address (default: 0.0.0.0)
+  --advertise-host <host>      Hostname for agent card URLs
+  --agent-name <name>          Agent display name
+  --agent-description <desc>   Agent description
+  --log-level <level>          debug | info | warn | error (default: info)
+
+Gateway Registration:
+  --register-url <url>         Gateway URL to register this agent with
+  --register-key <key>         API key for gateway authentication
+  --unregister-on-shutdown     Remove agent from gateway on exit
+
+Bridge (NAT traversal):
+  --bridge-url <url>           Gateway WebSocket bridge (ws://gateway:8080/api/a2a/bridge)
+  --bridge-key <key>           API key for bridge authentication
+
+OpenCode Options:
+  --opencode-url <url>         OpenCode server URL (default: http://localhost:4096)
+  --directory, -d <path>       Project directory
+  --model, -m <provider/model> LLM model (e.g. anthropic/claude-sonnet-4)
+  --agent <name>               OpenCode agent preset
+
+Codex Options:
+  --codex-model <model>        Codex model ID
+  --codex-api-key <key>        OpenAI API key
+
+Claude Options:
+  --claude-model <model>       Claude Code model ID
+  --claude-api-key <key>       Anthropic API key
+
+  --help, -h                   Show this help
+  --version, -v                Show version
+
+Examples:
+  npx @axiom-lattice/cli-a2a --provider opencode
+  npx @axiom-lattice/cli-a2a --provider opencode --port 3001 --opencode-url http://localhost:4096
+  npx @axiom-lattice/cli-a2a --config ./my-agent.json
+  npx @axiom-lattice/cli-a2a --provider opencode --model anthropic/claude-sonnet-4
+  npx @axiom-lattice/cli-a2a --provider opencode --register-url http://gateway:8080 --register-key sk-xxx --unregister-on-shutdown
+  npx @axiom-lattice/cli-a2a --provider opencode --bridge-url ws://gateway:8080/api/a2a/bridge --bridge-key sk-xxx
+`);
+}
+function parseCliArgs() {
+  const { values } = (0, import_node_util.parseArgs)({
+    options: {
+      provider: { type: "string" },
+      config: { type: "string", short: "c" },
+      port: { type: "string", short: "p" },
+      hostname: { type: "string" },
+      "advertise-host": { type: "string" },
+      "agent-name": { type: "string" },
+      "agent-description": { type: "string" },
+      "opencode-url": { type: "string" },
+      directory: { type: "string", short: "d" },
+      model: { type: "string", short: "m" },
+      agent: { type: "string" },
+      "codex-model": { type: "string" },
+      "codex-api-key": { type: "string" },
+      "claude-model": { type: "string" },
+      "claude-api-key": { type: "string" },
+      "log-level": { type: "string" },
+      "register-url": { type: "string" },
+      "register-key": { type: "string" },
+      "unregister-on-shutdown": { type: "boolean" },
+      "bridge-url": { type: "string" },
+      "bridge-key": { type: "string" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    },
+    strict: false
+  });
+  if (values.help) {
+    printUsage();
+    process.exit(0);
+  }
+  if (values.version) {
+    console.log(PKG_VERSION);
+    process.exit(0);
+  }
+  const overrides = {};
+  if (values.provider) {
+    overrides.provider = values.provider;
+  }
+  if (values.port || values.hostname || values["advertise-host"]) {
+    overrides.server = {};
+    if (values.port) overrides.server.port = parseInt(values.port, 10);
+    if (values.hostname) overrides.server.hostname = values.hostname;
+    if (values["advertise-host"]) overrides.server.advertiseHost = values["advertise-host"];
+  }
+  const agentCardOverrides = {};
+  if (values["agent-name"]) agentCardOverrides.name = values["agent-name"];
+  if (values["agent-description"]) agentCardOverrides.description = values["agent-description"];
+  if (Object.keys(agentCardOverrides).length > 0) {
+    overrides.agentCard = agentCardOverrides;
+  }
+  const hasOpenCode = !!(values["opencode-url"] || values.directory || values.model || values.agent);
+  if (hasOpenCode) {
+    overrides.opencode = {};
+    if (values["opencode-url"]) overrides.opencode.baseUrl = values["opencode-url"];
+    if (values.directory) overrides.opencode.projectDirectory = values.directory;
+    if (values.model) overrides.opencode.model = values.model;
+    if (values.agent) overrides.opencode.agent = values.agent;
+  }
+  const hasCodex = !!(values["codex-model"] || values["codex-api-key"]);
+  if (hasCodex) {
+    overrides.codex = {};
+    if (values["codex-model"]) overrides.codex.model = values["codex-model"];
+    if (values["codex-api-key"]) overrides.codex.apiKey = values["codex-api-key"];
+  }
+  const hasClaude = !!(values["claude-model"] || values["claude-api-key"]);
+  if (hasClaude) {
+    overrides.claude = {};
+    if (values["claude-model"]) overrides.claude.model = values["claude-model"];
+    if (values["claude-api-key"]) overrides.claude.apiKey = values["claude-api-key"];
+  }
+  if (values["log-level"]) {
+    overrides.logging = { level: values["log-level"] };
+  }
+  const configPath = values.config;
+  const registerUrl = values["register-url"];
+  const registerKey = values["register-key"];
+  const unregisterOnShutdown = values["unregister-on-shutdown"] ?? false;
+  const bridgeUrl = values["bridge-url"];
+  const bridgeKey = values["bridge-key"];
+  return { configPath, overrides, registerUrl, registerKey, unregisterOnShutdown, bridgeUrl, bridgeKey };
+}
+async function registerWithGateway(registerUrl, registerKey, config, agentCardUrl) {
+  const body = {
+    name: config.agentCard.name,
+    description: config.agentCard.description,
+    graphDefinition: {
+      type: "a2a_remote",
+      key: `a2a-${config.provider}-${config.agentCard.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`,
+      name: config.agentCard.name,
+      description: config.agentCard.description,
+      prompt: config.agentCard.description,
+      agentCardUrl,
+      timeout: config.timeouts.prompt
+    }
+  };
+  try {
+    const url = registerUrl.replace(/\/$/, "") + "/api/assistants";
+    log11.info("Registering with gateway", { url, agentCardUrl });
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${registerKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      log11.error("Gateway registration failed", { status: resp.status, body: text });
+      return null;
+    }
+    const result = await resp.json();
+    const assistantId = result.data?.id ?? body.graphDefinition.key;
+    log11.info("Registered with gateway", { assistantId, agentCardUrl });
+    console.log(`Registered as agent: ${assistantId}`);
+    console.log(`Agent card:        ${agentCardUrl}`);
+    return { assistantId, agentCardUrl };
+  } catch (err) {
+    log11.error("Gateway registration error", { error: err.message });
+    return null;
+  }
+}
+async function unregisterFromGateway(registerUrl, registerKey, assistantId) {
+  try {
+    const url = `${registerUrl.replace(/\/$/, "")}/api/assistants/${assistantId}`;
+    log11.info("Unregistering from gateway", { assistantId });
+    const resp = await fetch(url, {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${registerKey}`
+      }
+    });
+    if (!resp.ok && resp.status !== 404) {
+      log11.warn("Gateway unregistration failed", { status: resp.status });
+    } else {
+      log11.info("Unregistered from gateway", { assistantId });
+    }
+  } catch (err) {
+    log11.warn("Gateway unregistration error", { error: err.message });
+  }
+}
+async function main() {
+  const { configPath, overrides, registerUrl, registerKey, unregisterOnShutdown, bridgeUrl, bridgeKey } = parseCliArgs();
+  const config = resolveConfig(configPath, overrides);
+  if (configPath) {
+    config.configDir = (0, import_node_path2.dirname)((0, import_node_path2.resolve)(configPath));
+  }
+  const levelStr = config.logging.level ?? "info";
+  const levelMap = {
+    debug: 10 /* DEBUG */,
+    info: 20 /* INFO */,
+    warn: 30 /* WARN */,
+    error: 40 /* ERROR */
+  };
+  logger.setLevel(levelMap[levelStr] ?? 20 /* INFO */);
+  if (!configPath) {
+    log11.info("No --config provided \u2014 running with defaults + CLI args.");
+  }
+  log11.info("Starting CLI A2A Gateway", {
+    provider: config.provider,
+    config: configPath ?? "(defaults)",
+    agent: config.agentCard.name,
+    port: config.server?.port
+  });
+  const { registerExecutor: registerExecutor2 } = await Promise.resolve().then(() => (init_executors(), executors_exports));
+  const { createOpenCodeExecutor: createOpenCodeExecutor2 } = await Promise.resolve().then(() => (init_executor(), executor_exports));
+  const { createCodexExecutor: createCodexExecutor2 } = await Promise.resolve().then(() => (init_executor2(), executor_exports2));
+  const { createClaudeExecutor: createClaudeExecutor2 } = await Promise.resolve().then(() => (init_executor3(), executor_exports3));
+  registerExecutor2("opencode", createOpenCodeExecutor2);
+  registerExecutor2("codex", createCodexExecutor2);
+  registerExecutor2("claude", createClaudeExecutor2);
+  const server = await createA2AServer(config);
+  const listenPort = config.server?.port ?? 3e3;
+  const agentId = `a2a-${config.provider}-${listenPort}`;
+  let bridgeClient = null;
+  if (bridgeUrl && bridgeKey) {
+    const { BridgeClient: BridgeClient2 } = await Promise.resolve().then(() => (init_bridge(), bridge_exports));
+    const agentCardUrl = `${config.server?.advertiseProtocol ?? "http"}://${config.server?.advertiseHost ?? "localhost"}:${listenPort}/.well-known/agent-card.json`;
+    bridgeClient = new BridgeClient2({
+      bridgeUrl: bridgeUrl.replace(/^http/, "ws"),
+      apiKey: bridgeKey,
+      agentId,
+      agentCard: {
+        name: config.agentCard.name,
+        description: config.agentCard.description,
+        url: agentCardUrl
+      },
+      localBaseUrl: `http://localhost:${listenPort}`
+    });
+    bridgeClient.start().then(() => {
+      log11.info("Bridge connected \u2014 agent reachable via gateway proxy");
+      console.log(`Bridge: ws://gateway \u2192 localhost:${listenPort}`);
+    }).catch((err) => {
+      log11.error("Bridge connection failed", { error: err.message });
+    });
+  }
+  let registeredAssistantId = null;
+  if (registerUrl && registerKey) {
+    const agentCardUrl = bridgeUrl ? `${registerUrl.replace(/\/$/, "")}/api/a2a/bridge/proxy/${agentId}/.well-known/agent-card.json` : `${config.server?.advertiseProtocol ?? "http"}://${config.server?.advertiseHost ?? "localhost"}:${listenPort}/.well-known/agent-card.json`;
+    const reg = await registerWithGateway(
+      registerUrl,
+      registerKey,
+      config,
+      agentCardUrl
+    );
+    if (reg) {
+      registeredAssistantId = reg.assistantId;
+    }
+  }
+  const shutdown = async (signal) => {
+    log11.info(`${signal} received, shutting down...`);
+    bridgeClient?.stop();
+    if (registeredAssistantId && registerUrl && registerKey && unregisterOnShutdown) {
+      await unregisterFromGateway(registerUrl, registerKey, registeredAssistantId);
+    }
+    await server.shutdown();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+main().catch((err) => {
+  log11.error("Fatal error", { error: err.message, stack: err.stack });
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map