@axiom-lattice/cli-a2a 0.1.1

package/dist/index.js

@@ -0,0 +1,942 @@
+"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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClaudeExecutor: () => ClaudeExecutor,
+  CodexExecutor: () => CodexExecutor,
+  LogLevel: () => LogLevel,
+  OpenCodeExecutor: () => OpenCodeExecutor,
+  createA2AServer: () => createA2AServer,
+  createClaudeExecutor: () => createClaudeExecutor,
+  createCodexExecutor: () => createCodexExecutor,
+  createExecutor: () => createExecutor,
+  createOpenCodeExecutor: () => createOpenCodeExecutor,
+  getExecutor: () => getExecutor,
+  loadConfigFile: () => loadConfigFile,
+  logger: () => logger,
+  registerExecutor: () => registerExecutor,
+  resolveConfig: () => resolveConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/logger.ts
+var 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 || {});
+var 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");
+    }
+  }
+};
+var logger = new Logger("cli-a2a");
+
+// src/config/loader.ts
+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
+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/executors/index.ts
+var import_sdk = require("@a2a-js/sdk");
+var import_uuid = require("uuid");
+var registry = /* @__PURE__ */ new Map();
+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);
+}
+
+// src/server/index.ts
+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/executors/opencode/client.ts
+var import_node_child_process = require("child_process");
+var log4 = logger.child("opencode:client");
+var 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((resolve2, 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) {
+          resolve2(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
+var import_uuid2 = require("uuid");
+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);
+}
+
+// src/executors/opencode/executor.ts
+var log5 = logger.child("opencode:executor");
+var 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");
+  }
+};
+function createOpenCodeExecutor(config) {
+  return new OpenCodeExecutor(config);
+}
+
+// src/executors/codex/client.ts
+var import_node_child_process2 = require("child_process");
+var log6 = logger.child("codex:client");
+var 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((resolve2, 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) {
+          resolve2(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 log7 = logger.child("codex:executor");
+var 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");
+  }
+};
+function createCodexExecutor(config) {
+  return new CodexExecutor(config);
+}
+
+// src/executors/claude/client.ts
+var import_node_child_process3 = require("child_process");
+var log8 = logger.child("claude:client");
+var 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((resolve2, 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) {
+          resolve2(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 log9 = logger.child("claude:executor");
+var 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");
+  }
+};
+function createClaudeExecutor(config) {
+  return new ClaudeExecutor(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClaudeExecutor,
+  CodexExecutor,
+  LogLevel,
+  OpenCodeExecutor,
+  createA2AServer,
+  createClaudeExecutor,
+  createCodexExecutor,
+  createExecutor,
+  createOpenCodeExecutor,
+  getExecutor,
+  loadConfigFile,
+  logger,
+  registerExecutor,
+  resolveConfig
+});
+//# sourceMappingURL=index.js.map