@zooid/core 0.7.0

package/dist/index.js

@@ -0,0 +1,868 @@
+// src/config.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { parse } from "yaml";
+import { isPreset } from "@zooid/acp-client";
+
+// src/env-interpolation.ts
+import dotenvExpand from "dotenv-expand";
+var REF_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::?[-+][^}]*)?\}|\$([A-Za-z_][A-Za-z0-9_]*)/g;
+var EnvInterpolationError = class extends Error {
+};
+var isDenied = (name) => name === "ZOOID_TOKEN" || name.startsWith("ZOOID_");
+function interpolateEnv(parsed, processEnv, scope) {
+  for (const [key, val] of Object.entries(parsed)) {
+    if (isDenied(key)) {
+      throw new EnvInterpolationError(
+        `${scope}.${key}: keys in the ZOOID_* namespace are not allowed`
+      );
+    }
+    if (typeof val !== "string") {
+      throw new EnvInterpolationError(
+        `${scope}.${key}: env values must be strings (got ${typeof val})`
+      );
+    }
+    REF_RE.lastIndex = 0;
+    let m;
+    while ((m = REF_RE.exec(val)) !== null) {
+      const ref = m[1] ?? m[2];
+      if (isDenied(ref)) {
+        throw new EnvInterpolationError(
+          `${scope}.${key}: references to ZOOID_* vars are not allowed (saw \${${ref}})`
+        );
+      }
+    }
+  }
+  const out = {};
+  for (const [key, val] of Object.entries(parsed)) {
+    out[key] = interpolateString(val, processEnv);
+  }
+  return out;
+}
+function interpolateString(value, processEnv) {
+  if (!value.includes("$")) return value;
+  const sentinel = "__zooid_interp_v1__";
+  const env = {};
+  for (const [k, v] of Object.entries(processEnv)) {
+    if (typeof v === "string") env[k] = v;
+  }
+  delete env[sentinel];
+  const result = dotenvExpand.expand({
+    parsed: { [sentinel]: value },
+    processEnv: env
+  });
+  return result.parsed?.[sentinel] ?? "";
+}
+
+// src/config.ts
+var AGENT_NAME_RE = /^[a-z][a-z0-9-]{0,31}$/;
+var MATRIX_USER_ID_RE = /^@[A-Za-z0-9._\-=/+]+:[A-Za-z0-9.\-]+$/;
+var MATRIX_USER_LOCALPART_RE = /^@[a-z0-9._=/+\-]+$/;
+var MATRIX_ROOM_IDENT_RE = /^[#!]/;
+function deriveServerName(userNamespace) {
+  const tail = userNamespace.split(":").slice(1).join(":").replace(/\\?\)?$/, "");
+  if (!tail) throw new Error(`user_namespace missing server_name: ${userNamespace}`);
+  return tail;
+}
+var TRANSPORT_KINDS = ["matrix", "http"];
+function parseAcpBlock(name, raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`agents.${name}.acp: must be a mapping with either preset or command`);
+  }
+  const a = raw;
+  const hasPreset = a.preset !== void 0;
+  const hasCommand = a.command !== void 0;
+  if (hasPreset && hasCommand) {
+    throw new Error(
+      `agents.${name}.acp: specify either preset or command, not both`
+    );
+  }
+  if (!hasPreset && !hasCommand) {
+    throw new Error(
+      `agents.${name}.acp: must specify either preset or command`
+    );
+  }
+  if (hasPreset) {
+    if (typeof a.preset !== "string" || a.preset.length === 0) {
+      throw new Error(`agents.${name}.acp.preset: must be a non-empty string`);
+    }
+    if (!isPreset(a.preset)) {
+      throw new Error(
+        `agents.${name}.acp.preset: unknown preset "${a.preset}"`
+      );
+    }
+    const out = { preset: a.preset };
+    if (a.model !== void 0) {
+      if (typeof a.model !== "string" || a.model.trim().length === 0) {
+        throw new Error(`agents.${name}.acp.model: must be a non-empty string`);
+      }
+      out.model = a.model.trim();
+    }
+    return out;
+  }
+  if (typeof a.command !== "string" || a.command.length === 0) {
+    throw new Error(`agents.${name}.acp.command: must be a non-empty string`);
+  }
+  const args = [];
+  if (a.args !== void 0) {
+    if (!Array.isArray(a.args)) {
+      throw new Error(`agents.${name}.acp.args: must be an array of strings`);
+    }
+    for (const v of a.args) {
+      if (typeof v !== "string") {
+        throw new Error(`agents.${name}.acp.args[]: must be a string`);
+      }
+      args.push(v);
+    }
+  }
+  return { command: a.command, args };
+}
+function parseApprovalTimeout(name, raw) {
+  if (raw === void 0) return 0;
+  if (raw === 0 || raw === "0") return 0;
+  if (typeof raw !== "string") {
+    throw new Error(
+      `agents.${name}.approval_timeout: must be a duration like "1h", "15m", "30s", or 0 to disable (got ${JSON.stringify(raw)})`
+    );
+  }
+  const m = /^(\d+)(s|m|h)$/.exec(raw);
+  if (!m) {
+    throw new Error(
+      `agents.${name}.approval_timeout: "${raw}" is not a valid duration (use "<n>s", "<n>m", or "<n>h")`
+    );
+  }
+  const n = Number(m[1]);
+  switch (m[2]) {
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 6e4;
+    case "h":
+      return n * 60 * 6e4;
+  }
+  throw new Error("unreachable");
+}
+function parseAgentContainer(name, raw, processEnv) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(`agents.${name}.container must be a mapping`);
+  }
+  const r = raw;
+  const out = {};
+  if (r.image !== void 0) {
+    if (typeof r.image !== "string" || r.image.length === 0) {
+      throw new Error(`agents.${name}.container.image must be a non-empty string`);
+    }
+    out.image = r.image;
+  }
+  if (r.env !== void 0 && r.env !== null) {
+    if (typeof r.env !== "object" || Array.isArray(r.env)) {
+      throw new Error(`agents.${name}.container.env must be a mapping`);
+    }
+    const rawEnv = r.env;
+    const stringEnv = {};
+    for (const [k, v] of Object.entries(rawEnv)) {
+      if (typeof v !== "string") {
+        throw new Error(
+          `agents.${name}.container.env.${k}: must be a string (got ${typeof v})`
+        );
+      }
+      stringEnv[k] = v;
+    }
+    out.env = interpolateEnv(stringEnv, processEnv, `agents.${name}.container.env`);
+  }
+  return out;
+}
+function parseZooidContainer(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error("container must be a mapping");
+  }
+  const r = raw;
+  const out = {};
+  if (r.env !== void 0) {
+    throw new Error(
+      "Top-level 'container.env' is not supported (workforce-level env defaults are out of scope; see [ZOD043]). Move env entries to per-agent container.env."
+    );
+  }
+  if (r.image !== void 0) {
+    if (typeof r.image !== "string" || r.image.length === 0) {
+      throw new Error("container.image must be a non-empty string");
+    }
+    out.image = r.image;
+  }
+  return out;
+}
+function parseTransports(raw, processEnv) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("transports: must be a mapping with at least one entry");
+  }
+  const r = raw;
+  const names = Object.keys(r);
+  if (names.length === 0) {
+    throw new Error("transports: at least one transport must be declared");
+  }
+  const out = {};
+  for (const name of names) {
+    out[name] = parseTransport(name, r[name], processEnv);
+  }
+  const matrixEntries = Object.entries(out).filter(
+    (e) => e[1].type === "matrix"
+  );
+  if (matrixEntries.length === 1) {
+    const [, mt] = matrixEntries[0];
+    if (mt.as_token === "__INFER__") {
+      const v = interpolateString("${MATRIX_AS_TOKEN}", processEnv);
+      if (v.length === 0) {
+        throw new Error(
+          "transports.matrix.as_token: env var MATRIX_AS_TOKEN is not set (set it in your shell or .env, or declare as_token explicitly in zooid.yaml)"
+        );
+      }
+      mt.as_token = v;
+    }
+    if (mt.hs_token === "__INFER__") {
+      const v = interpolateString("${MATRIX_HS_TOKEN}", processEnv);
+      if (v.length === 0) {
+        throw new Error(
+          "transports.matrix.hs_token: env var MATRIX_HS_TOKEN is not set (set it in your shell or .env, or declare hs_token explicitly in zooid.yaml)"
+        );
+      }
+      mt.hs_token = v;
+    }
+  } else if (matrixEntries.length > 1) {
+    for (const [tname, mt] of matrixEntries) {
+      if (mt.as_token === "__INFER__" || mt.hs_token === "__INFER__") {
+        throw new Error(
+          `transports.${tname}: as_token / hs_token must be set explicitly when more than one matrix transport is declared (no sensible default env var across multiple transports)`
+        );
+      }
+    }
+  }
+  return out;
+}
+function parseTransport(name, raw, processEnv) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`transports.${name}: must be a mapping`);
+  }
+  const r = raw;
+  const inferredType = r.type ?? (name === "matrix" || name === "http" ? name : void 0);
+  if (inferredType !== "matrix" && inferredType !== "http") {
+    throw new Error(
+      `transports.${name}.type must be "matrix" or "http" (got ${JSON.stringify(r.type)})`
+    );
+  }
+  if (inferredType === "matrix") {
+    if (r.sender_localpart === void 0) r.sender_localpart = "zooid";
+    if (r.user_namespace === void 0 && typeof r.homeserver === "string") {
+      try {
+        const host = new URL(
+          interpolateString(r.homeserver, processEnv)
+        ).hostname;
+        if (host) r.user_namespace = `@.*:${host}`;
+      } catch {
+      }
+    }
+    if (r.as_token === void 0) r.as_token = "__INFER__";
+    if (r.hs_token === void 0) r.hs_token = "__INFER__";
+    const fields = [
+      "homeserver",
+      "as_token",
+      "hs_token",
+      "sender_localpart",
+      "user_namespace"
+    ];
+    for (const f of fields) {
+      if (typeof r[f] !== "string" || r[f].length === 0) {
+        throw new Error(`transports.${name}.${f} must be a non-empty string`);
+      }
+    }
+    const out = {
+      type: "matrix",
+      homeserver: interpolateString(r.homeserver, processEnv),
+      as_token: interpolateString(r.as_token, processEnv),
+      hs_token: interpolateString(r.hs_token, processEnv),
+      sender_localpart: r.sender_localpart,
+      user_namespace: r.user_namespace
+    };
+    if (r.port !== void 0) {
+      if (!Number.isInteger(r.port)) {
+        throw new Error(
+          `transports.${name}.port must be an integer (got ${JSON.stringify(r.port)})`
+        );
+      }
+      out.port = r.port;
+    }
+    if (r.space !== void 0) {
+      if (typeof r.space !== "string" || r.space.length === 0) {
+        throw new Error(
+          `transports.${name}.space must be a non-empty string (got ${JSON.stringify(r.space)})`
+        );
+      }
+      out.space = r.space;
+    }
+    return out;
+  }
+  const port = r.port ?? 8080;
+  if (!Number.isInteger(port)) {
+    throw new Error(`transports.${name}.port must be an integer (got ${JSON.stringify(port)})`);
+  }
+  return { type: "http", port };
+}
+function parseTransportBinding(name, entry, transports) {
+  const present = TRANSPORT_KINDS.filter(
+    (k) => entry[k] !== void 0 && entry[k] !== null
+  );
+  if (present.length === 0) {
+    throw new Error(
+      `agents.${name}: must declare exactly one transport-kind block (e.g. 'matrix:' or 'http:'). Saw none.`
+    );
+  }
+  if (present.length > 1) {
+    throw new Error(
+      `agents.${name}: must declare exactly one transport-kind block. Saw: ${present.join(", ")}. To run "the same agent" on two transports, declare two agents (e.g. ${name}-matrix and ${name}-http).`
+    );
+  }
+  const kind = present[0];
+  const blockRaw = entry[kind];
+  if (typeof blockRaw !== "object" || blockRaw === null || Array.isArray(blockRaw)) {
+    throw new Error(`agents.${name}.${kind}: must be a mapping`);
+  }
+  const block = blockRaw;
+  let refName;
+  if (typeof block.transport === "string" && block.transport.length > 0) {
+    refName = block.transport;
+  } else {
+    const matches = Object.entries(transports).filter(
+      ([, t]) => t.type === kind
+    );
+    if (matches.length === 0) {
+      throw new Error(
+        `agents.${name}.${kind}: no transport of type ${kind} declared (add one under transports:)`
+      );
+    }
+    if (matches.length > 1) {
+      throw new Error(
+        `agents.${name}.${kind}.transport is required when more than one ${kind} transport is declared (saw: ${matches.map(([n]) => n).join(", ")})`
+      );
+    }
+    refName = matches[0][0];
+  }
+  const refTransport = transports[refName];
+  if (!refTransport) {
+    throw new Error(
+      `agents.${name}.${kind}.transport "${refName}" is not declared in transports`
+    );
+  }
+  if (refTransport.type !== kind) {
+    throw new Error(
+      `agents.${name}.${kind} references transport "${refName}" of type: ${refTransport.type}. Block name and referenced transport's type must match.`
+    );
+  }
+  if (kind === "matrix") {
+    if (refTransport.type !== "matrix") {
+      throw new Error(`agents.${name}.matrix: transport must be matrix`);
+    }
+    const serverName = deriveServerName(refTransport.user_namespace);
+    const rawUserId = typeof block.user_id === "string" && block.user_id.length > 0 ? block.user_id : `@${name}`;
+    let userId = rawUserId;
+    if (!userId.includes(":") && MATRIX_USER_LOCALPART_RE.test(userId)) {
+      userId = `${userId}:${serverName}`;
+    }
+    if (!MATRIX_USER_ID_RE.test(userId)) {
+      throw new Error(
+        `agents.${name}.matrix.user_id must look like @localpart:server (got ${JSON.stringify(block.user_id)})`
+      );
+    }
+    if (!Array.isArray(block.rooms) || block.rooms.length === 0) {
+      throw new Error(`agents.${name}.matrix.rooms is required and must be a non-empty array`);
+    }
+    const rooms = [];
+    for (const r of block.rooms) {
+      if (typeof r !== "string" || r.length === 0) {
+        throw new Error(`agents.${name}.matrix.rooms[] must be a non-empty string`);
+      }
+      if (!MATRIX_ROOM_IDENT_RE.test(r)) {
+        throw new Error(
+          `agents.${name}.matrix.rooms[] must start with '#' or '!' (got ${JSON.stringify(r)})`
+        );
+      }
+      rooms.push(r.includes(":") ? r : `${r}:${serverName}`);
+    }
+    let displayName;
+    if (block.display_name !== void 0) {
+      if (typeof block.display_name !== "string") {
+        throw new Error(
+          `agents.${name}.matrix.display_name must be a string (got ${JSON.stringify(block.display_name)})`
+        );
+      }
+      const trimmed = block.display_name.trim();
+      if (trimmed.length === 0) {
+        throw new Error(`agents.${name}.matrix.display_name must be non-empty after trim`);
+      }
+      if (trimmed.length > 256) {
+        throw new Error(`agents.${name}.matrix.display_name must be 256 characters or fewer`);
+      }
+      displayName = trimmed;
+    }
+    const tr = block.trigger ?? "mention";
+    if (tr !== "mention" && tr !== "any") {
+      throw new Error(
+        `agents.${name}.matrix.trigger must be "mention" or "any" (got ${JSON.stringify(tr)})`
+      );
+    }
+    const matrix = {
+      transport: refName,
+      user_id: userId,
+      rooms,
+      trigger: tr
+    };
+    if (displayName !== void 0) matrix.display_name = displayName;
+    return { matrix };
+  }
+  return { http: { transport: refName } };
+}
+function parseAgents(raw, runtime, transports, daemonHooks, processEnv) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("agents: must be a mapping");
+  }
+  const entries = Object.entries(raw);
+  if (entries.length === 0) {
+    throw new Error("agents: must have at least one entry");
+  }
+  const result = {};
+  for (const [name, val] of entries) {
+    if (!AGENT_NAME_RE.test(name)) {
+      throw new Error(`agents.${name}: name must match /^[a-z][a-z0-9-]{0,31}$/`);
+    }
+    if (!val || typeof val !== "object" || Array.isArray(val)) {
+      throw new Error(`agents.${name} must be a mapping`);
+    }
+    const entry = val;
+    let workdir;
+    if (entry.workdir === void 0) {
+      workdir = `./agents/${name}`;
+    } else if (typeof entry.workdir !== "string" || entry.workdir.length === 0) {
+      throw new Error(`agents.${name}.workdir must be a non-empty string`);
+    } else {
+      workdir = entry.workdir;
+    }
+    if (entry.adapter !== void 0) {
+      throw new Error(
+        `agents.${name}: "adapter" is no longer supported; use "acp" \u2014 see epics/003-ZOD025-acp-migration/SPEC.md`
+      );
+    }
+    if (entry.acp === void 0) {
+      throw new Error(`agents.${name}: missing required "acp" block`);
+    }
+    const acp = parseAcpBlock(name, entry.acp);
+    const approval_timeout_ms = parseApprovalTimeout(name, entry.approval_timeout);
+    if (entry.docker !== void 0) {
+      throw new Error(
+        `agents.${name}.docker is no longer supported. Move 'image' to agents.${name}.container.image, and 'forward_env' entries to agents.${name}.container.env with \${VAR} interpolation. See [ZOD043].`
+      );
+    }
+    if (typeof entry.transport === "string") {
+      throw new Error(
+        `agents.${name}.transport (string) is no longer supported at the agent level. Move it inside a transport-kind block, e.g.:
+  matrix:
+    transport: <name>
+    user_id: "@..."
+    rooms: [...]
+See [ZOD043].`
+      );
+    }
+    for (const k of ["matrix_user_id", "rooms", "trigger"]) {
+      if (entry[k] !== void 0) {
+        throw new Error(
+          `agents.${name}.${k} is no longer supported as a flat field. Move it inside a 'matrix:' block on the agent. See [ZOD043].`
+        );
+      }
+    }
+    const agentHooks = {};
+    if (daemonHooks.pre_turn !== void 0) agentHooks.pre_turn = daemonHooks.pre_turn;
+    if (daemonHooks.post_turn !== void 0) agentHooks.post_turn = daemonHooks.post_turn;
+    if (entry.hooks !== void 0 && entry.hooks !== null) {
+      if (typeof entry.hooks !== "object" || Array.isArray(entry.hooks)) {
+        throw new Error(`agents.${name}.hooks must be a mapping`);
+      }
+      const h = entry.hooks;
+      if (Object.prototype.hasOwnProperty.call(h, "pre_turn")) {
+        if (typeof h.pre_turn === "string") agentHooks.pre_turn = h.pre_turn;
+        else delete agentHooks.pre_turn;
+      }
+      if (Object.prototype.hasOwnProperty.call(h, "post_turn")) {
+        if (typeof h.post_turn === "string") agentHooks.post_turn = h.post_turn;
+        else delete agentHooks.post_turn;
+      }
+    }
+    let containerBlock;
+    if (entry.container !== void 0 && entry.container !== null) {
+      if (runtime === "local") {
+        throw new Error(
+          `agents.${name}.container is only valid when runtime is 'docker' or 'podman'. runtime: local spawns agents as host child processes \u2014 there is no container, so 'image' is inert and 'env' would silently lie (the agent inherits the daemon's full process.env regardless).`
+        );
+      }
+      containerBlock = parseAgentContainer(name, entry.container, processEnv);
+    }
+    const binding = parseTransportBinding(name, entry, transports);
+    const agentCfg = {
+      name,
+      workdir,
+      hooks: agentHooks,
+      acp,
+      approval_timeout_ms
+    };
+    if (containerBlock) agentCfg.container = containerBlock;
+    if (binding.matrix) agentCfg.matrix = binding.matrix;
+    if (binding.http) agentCfg.http = binding.http;
+    result[name] = agentCfg;
+  }
+  return result;
+}
+function parseRuntime(raw) {
+  const runtime = raw ?? "docker";
+  if (runtime !== "local" && runtime !== "docker" && runtime !== "podman") {
+    throw new Error(`runtime must be "local", "docker", or "podman" (got "${runtime}")`);
+  }
+  return runtime;
+}
+function zooidHooks(raw) {
+  const out = {};
+  if (raw.hooks && typeof raw.hooks === "object") {
+    const h = raw.hooks;
+    if (typeof h.pre_turn === "string") out.pre_turn = h.pre_turn;
+    if (typeof h.post_turn === "string") out.post_turn = h.post_turn;
+  }
+  return out;
+}
+function loadZooidConfig(yamlText) {
+  const raw = parse(yamlText) ?? {};
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error("zooid.yaml must be a YAML object");
+  }
+  const r = raw;
+  if (r.transport !== void 0) {
+    throw new Error(
+      'zooid.yaml: top-level "transport:" is no longer supported; declare entries under "transports:" instead'
+    );
+  }
+  if (r.matrix !== void 0) {
+    throw new Error(
+      'zooid.yaml: top-level "matrix:" is no longer supported; move it under "transports.<name>: { type: matrix, ... }"'
+    );
+  }
+  if (r.workdir !== void 0) {
+    throw new Error(
+      "top-level workdir is not supported; define agents: { <name>: { workdir: ... } } instead"
+    );
+  }
+  if (r.docker !== void 0) {
+    throw new Error(
+      "Top-level 'docker' block is no longer supported. Move 'image' to top-level 'container.image'. See [ZOD043]."
+    );
+  }
+  if (r.agents === void 0) {
+    throw new Error("agents: is required \u2014 zooid.yaml must define at least one agent");
+  }
+  const runtime = parseRuntime(r.runtime);
+  const processEnv = process.env;
+  const transports = parseTransports(r.transports, processEnv);
+  const hooks = zooidHooks(r);
+  const agents = parseAgents(r.agents, runtime, transports, hooks, processEnv);
+  const cfg = {
+    runtime,
+    transports,
+    agents,
+    hooks
+  };
+  if (r.container !== void 0 && r.container !== null) {
+    if (runtime === "local") {
+      throw new Error(
+        "container is only valid when runtime is 'docker' or 'podman'. runtime: local does not run agents in containers; image is ignored. See [ZOD043]."
+      );
+    }
+    cfg.container = parseZooidContainer(r.container);
+  }
+  return cfg;
+}
+function findTransport(cfg, name) {
+  return cfg.transports[name];
+}
+function findMatrixTransport(cfg) {
+  const matrices = Object.entries(cfg.transports).filter(
+    (e) => e[1].type === "matrix"
+  );
+  if (matrices.length === 0) return null;
+  if (matrices.length > 1) {
+    throw new Error(
+      `findMatrixTransport: multiple matrix transports declared (${matrices.map((m) => m[0]).join(", ")}). Per-agent matrix routing is not supported yet.`
+    );
+  }
+  const [name, transport] = matrices[0];
+  return { name, transport };
+}
+function findHttpTransport(cfg) {
+  const https = Object.entries(cfg.transports).filter(
+    (e) => e[1].type === "http"
+  );
+  if (https.length === 0) return null;
+  if (https.length > 1) {
+    throw new Error(
+      `findHttpTransport: multiple http transports declared (${https.map((h) => h[0]).join(", ")}). Per-agent http routing is not supported yet.`
+    );
+  }
+  const [name, transport] = https[0];
+  return { name, transport };
+}
+function findConfigFile(cwd) {
+  const z = join(cwd, "zooid.yaml");
+  if (existsSync(z)) return { path: z };
+  const legacy = join(cwd, "workforce.yaml");
+  if (existsSync(legacy)) {
+    throw new Error(
+      `workforce.yaml is no longer supported. Rename it to zooid.yaml. See [ZOD045].`
+    );
+  }
+  return null;
+}
+function mergeCliFlags(base, flags) {
+  const runtimeFlag = flags.runtime;
+  if (runtimeFlag !== void 0 && runtimeFlag !== "local" && runtimeFlag !== "docker" && runtimeFlag !== "podman") {
+    throw new Error(`runtime must be "local", "docker", or "podman" (got "${flags.runtime}")`);
+  }
+  const runtime = runtimeFlag ?? base.runtime;
+  const merged = {
+    runtime,
+    transports: base.transports,
+    agents: base.agents,
+    hooks: { ...base.hooks }
+  };
+  if (runtime === "docker" || runtime === "podman") {
+    const image = flags.image ?? base.container?.image;
+    if (image !== void 0) {
+      merged.container = { image };
+    } else if (base.container !== void 0) {
+      merged.container = { ...base.container };
+    }
+  }
+  return merged;
+}
+
+// src/acp-registry.ts
+import { join as join2 } from "path";
+import {
+  AcpClient,
+  resolvePreset
+} from "@zooid/acp-client";
+var AcpAgentRegistry = class {
+  opts;
+  clients = /* @__PURE__ */ new Map();
+  onEvent;
+  onApprovalRequest;
+  constructor(opts) {
+    this.opts = opts;
+    this.onEvent = opts.onEvent ?? (() => {
+    });
+    if (opts.onApprovalRequest) {
+      this.onApprovalRequest = opts.onApprovalRequest;
+    } else if (opts.approvals) {
+      const correlator = opts.approvals;
+      this.onApprovalRequest = async (name, req) => {
+        const cfg = this.opts.agents[name];
+        const handle = correlator.register(name, req.sessionId, req, {
+          timeoutMs: cfg?.approval_timeout_ms ?? 0
+        });
+        this.opts.onApprovalRegistered?.(handle);
+        return handle.decisionPromise;
+      };
+    } else {
+      this.onApprovalRequest = async () => ({ decision: "cancel" });
+    }
+  }
+  hasAgent(name) {
+    return Object.prototype.hasOwnProperty.call(this.opts.agents, name);
+  }
+  hasContextSpawn(name) {
+    return Boolean(this.opts.contextSpawns?.[name]);
+  }
+  resolveSpawnEnv(name) {
+    return this.opts.env?.[name] ?? {};
+  }
+  resolveSpawnImage(name) {
+    return this.opts.image?.[name];
+  }
+  getApprovalTimeoutMs(name) {
+    return this.opts.agents[name]?.approval_timeout_ms ?? 0;
+  }
+  async ensureSession(name, threadId, channelId) {
+    if (!this.hasAgent(name)) throw new Error(`unknown agent: ${name}`);
+    const client = await this.ensureClient(name);
+    return client.ensureSession(threadId, channelId);
+  }
+  endSession(name, threadId) {
+    if (!this.hasAgent(name)) return;
+    const client = this.clients.get(name);
+    client?.endSession(threadId);
+  }
+  async cancelSession(name, sessionId) {
+    if (!this.hasAgent(name)) return;
+    const client = this.clients.get(name);
+    this.opts.approvals?.cancelSession(sessionId);
+    if (!client) return;
+    try {
+      await client.cancel(sessionId);
+    } catch (err) {
+      console.warn(`[acp:${name}] cancel(${sessionId}) failed:`, err);
+    }
+  }
+  async prompt(name, input) {
+    if (!this.hasAgent(name)) throw new Error(`unknown agent: ${name}`);
+    const client = await this.ensureClient(name);
+    return client.prompt(input);
+  }
+  async stopAll() {
+    await Promise.allSettled(
+      [...this.clients.values()].map((c) => c.stop())
+    );
+    this.clients.clear();
+  }
+  async ensureClient(name) {
+    const existing = this.clients.get(name);
+    if (existing) return existing;
+    const cfg = this.opts.agents[name];
+    if (!cfg.acp) throw new Error(`agents.${name}: missing acp block`);
+    const spawn = resolveAcpAgentSpec(cfg.acp);
+    const client = new AcpClient({
+      agent: {
+        id: name,
+        command: spawn.command,
+        args: spawn.args,
+        env: this.opts.env?.[name],
+        cwd: cfg.workdir,
+        image: this.opts.image?.[name]
+      },
+      agentDataDir: this.opts.agentsDir ? join2(this.opts.agentsDir, name) : void 0,
+      runtime: this.opts.runtime,
+      onEvent: (e) => this.onEvent(name, e),
+      onApprovalRequest: (req) => this.onApprovalRequest(name, req),
+      onTap: this.opts.onTap ? (e) => this.opts.onTap(name, e) : void 0,
+      contextSpawn: this.opts.contextSpawns?.[name]
+    });
+    await client.start();
+    this.clients.set(name, client);
+    return client;
+  }
+};
+function resolveAcpAgentSpec(spec) {
+  if ("preset" in spec && spec.preset) {
+    return resolvePreset(spec.preset, { model: spec.model });
+  }
+  if ("command" in spec && spec.command) {
+    return { command: spec.command, args: spec.args ?? [] };
+  }
+  throw new Error("AcpAgentSpec: must specify either preset or command");
+}
+
+// src/approval-correlator.ts
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+var ApprovalCorrelator = class extends EventEmitter {
+  pending = /* @__PURE__ */ new Map();
+  bySession = /* @__PURE__ */ new Map();
+  register(agentName, sessionId, req, opts = {}) {
+    const approvalId = randomUUID();
+    let resolve;
+    const decisionPromise = new Promise((r) => {
+      resolve = r;
+    });
+    const entry = {
+      approvalId,
+      agentName,
+      sessionId,
+      toolCallId: req.toolCallId,
+      toolKind: req.toolKind,
+      toolTitle: req.toolTitle,
+      toolInput: req.toolInput,
+      options: req.options,
+      decisionPromise,
+      resolve
+    };
+    if (opts.timeoutMs && opts.timeoutMs > 0) {
+      entry.timer = setTimeout(() => {
+        if (this.pending.get(approvalId) !== entry) return;
+        entry.resolve({ decision: "cancel" });
+        this.pending.delete(approvalId);
+        this.bySession.get(sessionId)?.delete(approvalId);
+        this.emit("timeout", { approvalId, sessionId, agentName });
+      }, opts.timeoutMs);
+      entry.timer.unref?.();
+    }
+    this.pending.set(approvalId, entry);
+    let set = this.bySession.get(sessionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.bySession.set(sessionId, set);
+    }
+    set.add(approvalId);
+    this.emit("registered", this.toPublic(entry));
+    return this.toPublic(entry);
+  }
+  resolve(sessionId, approvalId, decision) {
+    const entry = this.pending.get(approvalId);
+    if (!entry || entry.sessionId !== sessionId) return false;
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.resolve(decision);
+    this.pending.delete(approvalId);
+    this.bySession.get(sessionId)?.delete(approvalId);
+    return true;
+  }
+  cancelSession(sessionId) {
+    const ids = this.bySession.get(sessionId);
+    if (!ids) return;
+    for (const id of [...ids]) {
+      const entry = this.pending.get(id);
+      if (entry) {
+        if (entry.timer) clearTimeout(entry.timer);
+        entry.resolve({ decision: "cancel" });
+        this.pending.delete(id);
+      }
+    }
+    this.bySession.delete(sessionId);
+  }
+  listPending(sessionId) {
+    const ids = this.bySession.get(sessionId);
+    if (!ids) return [];
+    const out = [];
+    for (const id of ids) {
+      const entry = this.pending.get(id);
+      if (entry) out.push(this.toPublic(entry));
+    }
+    return out;
+  }
+  size() {
+    return this.pending.size;
+  }
+  toPublic(entry) {
+    return {
+      approvalId: entry.approvalId,
+      agentName: entry.agentName,
+      sessionId: entry.sessionId,
+      toolCallId: entry.toolCallId,
+      toolKind: entry.toolKind,
+      toolTitle: entry.toolTitle,
+      toolInput: entry.toolInput,
+      options: entry.options,
+      decisionPromise: entry.decisionPromise
+    };
+  }
+};
+export {
+  AcpAgentRegistry,
+  ApprovalCorrelator,
+  findConfigFile,
+  findHttpTransport,
+  findMatrixTransport,
+  findTransport,
+  loadZooidConfig,
+  mergeCliFlags,
+  resolveAcpAgentSpec
+};
+//# sourceMappingURL=index.js.map