@moikapy/lich 0.3.0

package/dist/gateway-CWPVIU3W.js

@@ -0,0 +1,752 @@
+import {
+  create_agent,
+  logger,
+  sleep
+} from "./chunk-P52U5M3L.js";
+
+// src/gateway/types.ts
+var ERROR_SNIPPET_CHARS = 300;
+function sanitize_agent_error(error) {
+  const raw = error instanceof Error ? error.message : String(error);
+  const flat = raw.replace(/\s+/g, " ").trim();
+  return `agent error: ${flat.slice(0, ERROR_SNIPPET_CHARS) || "unknown"}`;
+}
+function create_idle_adapter(name, reason) {
+  logger.warn(`gateway ${name} adapter idle: ${reason}`);
+  return {
+    name,
+    start: async () => void 0,
+    stop: async () => void 0
+  };
+}
+function open_socket(url) {
+  return new Promise((resolve, reject) => {
+    const ctor = globalThis.WebSocket;
+    if (ctor === void 0) {
+      reject(new Error("runtime does not expose a WebSocket constructor"));
+      return;
+    }
+    const socket = new ctor(url);
+    socket.onopen = () => resolve(socket);
+    socket.onerror = () => reject(new Error(`websocket connect failed: ${url}`));
+  });
+}
+async function run_inbound_message(handle, platform, chat_id, user_id, text) {
+  try {
+    return await handle(platform, chat_id, user_id, text) ?? "";
+  } catch (error) {
+    logger.error(`gateway ${platform} message handling failed`, error);
+    return sanitize_agent_error(error);
+  }
+}
+
+// src/gateway/bus.ts
+var DEFAULT_HISTORY_CAP = 40;
+var DEFAULT_MAX_CONVERSATIONS = 200;
+var GatewayBus = class {
+  config;
+  agent_factory;
+  agent;
+  histories = /* @__PURE__ */ new Map();
+  chains = /* @__PURE__ */ new Map();
+  history_cap;
+  max_conversations;
+  stop_logging;
+  constructor(params, options) {
+    this.config = params.config;
+    this.agent_factory = params.agent_factory;
+    this.history_cap = options?.history_cap ?? DEFAULT_HISTORY_CAP;
+    this.max_conversations = options?.max_conversations ?? DEFAULT_MAX_CONVERSATIONS;
+    if (params.wire_tool_logging === true) {
+      this.wire_tool_logging();
+    }
+  }
+  /** Serializes runs per conversation and resolves to the reply text. */
+  async handle(platform, chat_id, user_id, text) {
+    const key = conversation_key(platform, chat_id);
+    const previous = this.chains.get(key) ?? Promise.resolve();
+    const run = previous.then(() => this.run_once(key, platform, chat_id, user_id, text));
+    this.chains.set(
+      key,
+      run.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+    return run;
+  }
+  /** Unsubscribes the debug tool logger (bus owns no other resources). */
+  stop() {
+    this.stop_logging?.();
+    this.stop_logging = void 0;
+  }
+  async run_once(key, platform, chat_id, user_id, text) {
+    const input = text.startsWith("/start") === true ? "hello" : text;
+    const history = this.history_for(key);
+    const agent = this.ensure_agent();
+    try {
+      const result = await agent.run({ input, history, label: `gw:${platform}:${chat_id}` });
+      this.histories.set(key, cap_history(result.messages, this.history_cap));
+      return final_reply_text(result.outcome.final?.content);
+    } catch (error) {
+      logger.error(`gateway bus run failed for ${key} (user ${user_id})`, error);
+      return sanitize_agent_error(error);
+    }
+  }
+  ensure_agent() {
+    if (this.agent === void 0) {
+      this.agent = this.agent_factory();
+    }
+    return this.agent;
+  }
+  /** Oldest-first eviction keeps the conversation map bounded. */
+  history_for(key) {
+    while (this.histories.size >= this.max_conversations && this.histories.has(key) === false) {
+      const oldest = this.histories.keys().next();
+      if (oldest.done === true) {
+        break;
+      }
+      this.histories.delete(oldest.value);
+    }
+    return this.histories.get(key) ?? [];
+  }
+  /** Logs completed tool calls at debug level for gateway observability. */
+  wire_tool_logging() {
+    const agent = this.agent_factory();
+    this.agent = agent;
+    this.stop_logging = agent.events.on((event) => {
+      if (event.type === "tool_call_end") {
+        logger.debug(`tool ${event.call.name} ${event.result.ok === true ? "ok" : "failed"}`);
+      }
+    });
+  }
+};
+function conversation_key(platform, chat_id) {
+  return `${platform}:${chat_id}`;
+}
+function cap_history(messages, cap) {
+  const overflow = messages.length - cap;
+  if (overflow <= 0) {
+    return messages;
+  }
+  return messages.slice(overflow);
+}
+function final_reply_text(content) {
+  return content === void 0 || content.length === 0 ? void 0 : content;
+}
+
+// src/gateway/discord.ts
+var DISCORD_API = "https://discord.com/api/v10";
+var GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
+var INTENTS = 512 | 32768;
+var heartbeat_timers = /* @__PURE__ */ new WeakMap();
+function create_discord_adapter(params) {
+  const token = process.env.LICH_DISCORD_BOT_TOKEN;
+  if (token === void 0 || token.length === 0) {
+    return create_idle_adapter("discord", "LICH_DISCORD_BOT_TOKEN not set");
+  }
+  let running = false;
+  let socket;
+  return {
+    name: "discord",
+    start: async () => {
+      running = true;
+      void connect_loop(params, token, () => running, (opened) => {
+        socket = opened;
+      });
+    },
+    stop: async () => {
+      running = false;
+      socket?.close();
+      socket = void 0;
+    }
+  };
+}
+async function connect_loop(params, token, keep_running, set_socket) {
+  while (keep_running()) {
+    try {
+      const socket = await open_socket(GATEWAY_URL);
+      set_socket(socket);
+      await socket_session(socket, token, params);
+    } catch (error) {
+      logger.warn("gateway discord connection failed; reconnecting in 5s", error);
+      await new Promise((resolve) => setTimeout(resolve, 5e3));
+    }
+  }
+}
+async function socket_session(socket, token, params) {
+  let heartbeat;
+  const done = new Promise((resolve) => {
+    socket.onclose = () => resolve();
+  });
+  socket.onmessage = (event) => {
+    const payload = parse_payload(event.data);
+    if (payload === void 0) {
+      return;
+    }
+    handle_discord_payload(socket, token, params, payload);
+  };
+  await done;
+  heartbeat = heartbeat_timers.get(socket);
+  if (heartbeat !== void 0) {
+    clearInterval(heartbeat);
+    heartbeat_timers.delete(socket);
+  }
+}
+function handle_discord_payload(socket, token, params, payload) {
+  if (payload.op === 10 && is_hello(payload.d)) {
+    socket.send(JSON.stringify({ op: 2, d: identify_body(token) }));
+    schedule_heartbeat(socket, payload.d.heartbeat_interval);
+    return;
+  }
+  if (payload.t === "MESSAGE_CREATE") {
+    void on_message_create(params, payload.d);
+  }
+}
+function schedule_heartbeat(socket, interval_ms) {
+  const interval = typeof interval_ms === "number" ? interval_ms : 45e3;
+  const timer = setInterval(() => {
+    socket.send(JSON.stringify({ op: 1, d: null }));
+  }, Math.max(1e3, interval - 1e3));
+  heartbeat_timers.set(socket, timer);
+}
+function identify_body(token) {
+  return { token, intents: INTENTS, properties: { os: "linux", browser: "lich", device: "lich" } };
+}
+async function on_message_create(params, data) {
+  const message = normalize_message(data);
+  if (message === void 0) {
+    return;
+  }
+  const reply = await run_inbound_message(
+    params.handle_message,
+    "discord",
+    message.channel_id,
+    message.author_id,
+    message.content
+  );
+  await rest_send_message(message.channel_id, reply);
+}
+async function rest_send_message(channel_id, text) {
+  const token = process.env.LICH_DISCORD_BOT_TOKEN;
+  if (token === void 0 || channel_id === "") {
+    return;
+  }
+  for (const chunk of split_chunks(text, 2e3)) {
+    const response = await fetch(`${DISCORD_API}/channels/${channel_id}/messages`, {
+      method: "POST",
+      headers: { authorization: `Bot ${token}`, "content-type": "application/json" },
+      body: JSON.stringify({ content: chunk }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (response.ok === false) {
+      logger.warn(`gateway discord sendMessage failed with http ${response.status}`);
+    }
+  }
+}
+function normalize_message(data) {
+  if (data === void 0) {
+    return void 0;
+  }
+  const author = data.author;
+  if (typeof author !== "object" || author === null) {
+    return void 0;
+  }
+  const info = author;
+  if (info.bot === true) {
+    return void 0;
+  }
+  const channel_id = typeof data.channel_id === "string" ? data.channel_id : "";
+  const content = strip_mention(typeof data.content === "string" ? data.content : "");
+  return { channel_id, content, author_id: typeof info.id === "string" ? info.id : "" };
+}
+function strip_mention(content) {
+  const bot_id = process.env.LICH_DISCORD_BOT_ID;
+  if (bot_id === void 0) {
+    return content.trim();
+  }
+  const mention = `<@${bot_id}>`;
+  return content.startsWith(mention) === true ? content.slice(mention.length).trim() : content.trim();
+}
+function is_hello(d) {
+  return d !== void 0 && typeof d.heartbeat_interval === "number";
+}
+function parse_payload(data) {
+  if (typeof data !== "string") {
+    return void 0;
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+}
+function split_chunks(text, limit) {
+  const chunks = [];
+  let rest = text;
+  while (rest.length > limit) {
+    chunks.push(rest.slice(0, limit));
+    rest = rest.slice(limit);
+  }
+  if (rest.length > 0) {
+    chunks.push(rest);
+  }
+  return chunks;
+}
+
+// src/gateway/telegram.ts
+var TELEGRAM_MAX_MESSAGE_CHARS = 4096;
+var TELEGRAM_BACKOFF_MS = [2e3, 4e3, 8e3, 16e3, 3e4];
+function create_telegram_adapter(params) {
+  const token = process.env.LICH_TELEGRAM_BOT_TOKEN;
+  if (token === void 0 || token.length === 0) {
+    return create_idle_adapter("telegram", "LICH_TELEGRAM_BOT_TOKEN not set");
+  }
+  let running = false;
+  return {
+    name: "telegram",
+    start: async () => {
+      running = true;
+      void poll_loop(params, token, () => running);
+    },
+    stop: async () => {
+      running = false;
+    }
+  };
+}
+async function poll_loop(params, token, keep_running) {
+  let offset = 0;
+  let backoff_index = 0;
+  while (keep_running()) {
+    try {
+      const updates = await fetch_updates(token, offset);
+      backoff_index = 0;
+      for (const update of updates) {
+        offset = update.update_id !== void 0 ? update.update_id + 1 : offset;
+        void deliver_update(params, token, update);
+      }
+    } catch (error) {
+      logger.warn("gateway telegram poll failed; backing off", error);
+      await sleep(TELEGRAM_BACKOFF_MS[backoff_index] ?? 3e4);
+      backoff_index = Math.min(backoff_index + 1, TELEGRAM_BACKOFF_MS.length - 1);
+    }
+  }
+}
+async function fetch_updates(token, offset) {
+  const url = api_url(token, "getUpdates") + `?timeout=50&offset=${offset}`;
+  const response = await fetch(url, { signal: AbortSignal.timeout(6e4) });
+  if (response.ok === false) {
+    throw new Error(`getUpdates http ${response.status}`);
+  }
+  const body = await response.json();
+  return Array.isArray(body.result) === true ? body.result : [];
+}
+async function deliver_update(params, token, update) {
+  const message = update.message;
+  if (message === void 0 || message.from?.is_bot === true) {
+    return;
+  }
+  const chat_id = message.chat?.id;
+  if (chat_id === void 0) {
+    return;
+  }
+  const text = message.text ?? "media not supported yet";
+  const reply = await run_inbound_message(
+    params.handle_message,
+    "telegram",
+    String(chat_id),
+    String(message.from?.id ?? "unknown"),
+    text
+  );
+  await send_reply(token, String(chat_id), reply);
+}
+async function send_reply(token, chat_id, text) {
+  for (const chunk of split_text(text, TELEGRAM_MAX_MESSAGE_CHARS)) {
+    await post_json(api_url(token, "sendMessage"), { chat_id, text: chunk });
+  }
+}
+async function post_json(url, payload) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (response.ok === false) {
+    logger.warn(`gateway telegram sendMessage failed with http ${response.status}`);
+  }
+}
+function api_url(token, method) {
+  return `https://api.telegram.org/bot${token}/${method}`;
+}
+function split_text(text, limit) {
+  const chunks = [];
+  let rest = text;
+  while (rest.length > limit) {
+    const window = rest.slice(0, limit + 1);
+    const newline = window.lastIndexOf("\n");
+    const space = window.lastIndexOf(" ");
+    const cut = newline > 0 ? newline : space > 0 ? space : limit;
+    chunks.push(rest.slice(0, cut));
+    rest = rest.slice(cut).trimStart();
+  }
+  if (rest.length > 0) {
+    chunks.push(rest);
+  }
+  return chunks;
+}
+
+// src/gateway/twitch.ts
+var TWITCH_IRC_URL = "wss://irc-ws.chat.twitch.tv:443";
+var TWITCH_MESSAGE_CAP = 512;
+function create_twitch_adapter(params) {
+  const twitch = read_twitch_env();
+  if (twitch === void 0) {
+    return create_idle_adapter("twitch", "LICH_TWITCH_OAUTH_TOKEN / NICK not set");
+  }
+  let running = false;
+  let socket;
+  return {
+    name: "twitch",
+    start: async () => {
+      running = true;
+      void irc_loop(params, twitch, () => running, (opened) => {
+        socket = opened;
+      });
+    },
+    stop: async () => {
+      running = false;
+      socket?.close();
+      socket = void 0;
+    }
+  };
+}
+function read_twitch_env() {
+  const raw_token = process.env.LICH_TWITCH_OAUTH_TOKEN;
+  const nick = process.env.LICH_TWITCH_NICK;
+  const channels_env = process.env.LICH_TWITCH_CHANNELS;
+  if (raw_token === void 0 || raw_token.length === 0 || nick === void 0 || nick.length === 0) {
+    return void 0;
+  }
+  const token = raw_token.startsWith("oauth:") === true ? raw_token : `oauth:${raw_token}`;
+  const channels = (channels_env ?? "").split(",").map((channel) => channel.trim().toLowerCase()).filter((channel) => channel.length > 0);
+  if (channels.length === 0) {
+    return void 0;
+  }
+  return { token, nick, channels };
+}
+async function irc_loop(params, twitch, keep_running, set_socket) {
+  while (keep_running()) {
+    try {
+      const socket = await open_socket(TWITCH_IRC_URL);
+      set_socket(socket);
+      await irc_session(params, twitch, socket, keep_running);
+    } catch (error) {
+      logger.warn("gateway twitch connection failed; reconnecting in 5s", error);
+      await new Promise((resolve) => setTimeout(resolve, 5e3));
+    }
+  }
+}
+async function irc_session(params, twitch, socket, keep_running) {
+  const closed = new Promise((resolve) => {
+    socket.onclose = () => resolve();
+  });
+  socket.onmessage = (event) => {
+    for (const line of String(event.data).split("\r\n")) {
+      void handle_irc_line(params, twitch, socket, line);
+    }
+  };
+  socket.send("CAP REQ :twitch.tv/tags twitch.tv/commands");
+  socket.send(`PASS ${twitch.token}`);
+  socket.send(`NICK ${twitch.nick}`);
+  for (const channel of twitch.channels) {
+    socket.send(`JOIN #${channel}`);
+  }
+  await closed;
+}
+async function handle_irc_line(params, twitch, socket, line) {
+  if (line.length === 0) {
+    return;
+  }
+  const parsed = parse_irc_line(line);
+  if (parsed.kind === "ping") {
+    socket.send("PONG :tmi.twitch.tv");
+    return;
+  }
+  if (parsed.kind !== "privmsg" || parsed.user === twitch.nick) {
+    return;
+  }
+  const reply = await run_inbound_message(
+    params.handle_message,
+    "twitch",
+    parsed.channel,
+    parsed.user,
+    parsed.text
+  );
+  send_twitch_message(socket, parsed.channel, reply);
+}
+function send_twitch_message(socket, channel, text) {
+  for (const chunk of split_chunks2(text, TWITCH_MESSAGE_CAP)) {
+    socket.send(`PRIVMSG #${channel} :${chunk}`);
+  }
+}
+function parse_irc_line(line) {
+  if (line.startsWith("PING") === true) {
+    return { kind: "ping", channel: "", user: "", text: "" };
+  }
+  const privmsg = match_privmsg(line);
+  if (privmsg === void 0) {
+    return { kind: "other", channel: "", user: "", text: "" };
+  }
+  return privmsg;
+}
+function match_privmsg(line) {
+  const without_tags = line.startsWith("@") === true ? line.slice(line.indexOf(" ") + 1) : line;
+  const body = / PRIVMSG #([\w]+) :/.exec(without_tags);
+  if (body === null || body.index < 0) {
+    return void 0;
+  }
+  const prefix = without_tags.slice(0, body.index);
+  const ident = prefix.startsWith(":") === true ? prefix.slice(1) : prefix;
+  const user = ident.slice(ident.lastIndexOf("!") + 1).split("@")[0] ?? "";
+  const channel = body[1] ?? "";
+  const text = without_tags.slice(body.index + body[0].length);
+  return { kind: "privmsg", channel, user, text };
+}
+function split_chunks2(text, limit) {
+  const chunks = [];
+  let rest = text;
+  while (rest.length > limit) {
+    chunks.push(rest.slice(0, limit));
+    rest = rest.slice(limit);
+  }
+  if (rest.length > 0) {
+    chunks.push(rest);
+  }
+  return chunks;
+}
+
+// src/gateway/webhook.ts
+import { createServer } from "http";
+
+// src/gateway/format.ts
+var USAGE_FOOTER_PREFIX = "\n\n_tokens: ";
+function format_agent_reply(text, usage, platform) {
+  if (platform === "webhook") {
+    return JSON.stringify({ reply: text, usage: usage ?? null });
+  }
+  const total_tokens = usage?.total_tokens ?? 0;
+  if (total_tokens > 0) {
+    return `${text}${USAGE_FOOTER_PREFIX}${total_tokens}_`;
+  }
+  return text;
+}
+
+// src/gateway/webhook.ts
+var DEFAULT_GATEWAY_PORT = 8089;
+function create_webhook_adapter(params) {
+  const port = params.port ?? read_port_env() ?? DEFAULT_GATEWAY_PORT;
+  const token = process.env.LICH_GATEWAY_TOKEN;
+  let server;
+  return {
+    name: "webhook",
+    start: async () => {
+      server = createServer((request, response) => {
+        void dispatch_webhook(params, request, response, token);
+      });
+      await listen_on(server, port, (bound) => {
+        params.on_listening?.(bound);
+      });
+    },
+    stop: async () => {
+      await close_server(server);
+      server = void 0;
+    }
+  };
+}
+async function dispatch_webhook(params, request, response, token) {
+  try {
+    if (request.method === "GET" && request.url === "/health") {
+      send_json(response, 200, { status: "ok" });
+      return;
+    }
+    if (request.method !== "POST" || request.url !== "/message") {
+      send_json(response, 404, { error: "not found" });
+      return;
+    }
+    if (token !== void 0 && request.headers["x-lich-token"] !== token) {
+      send_json(response, 401, { error: "unauthorized" });
+      return;
+    }
+    await handle_message_post(params, request, response);
+  } catch (error) {
+    logger.error("gateway webhook request failed", error);
+    if (response.headersSent === false) {
+      send_json(response, 500, { error: "internal error" });
+    }
+  }
+}
+async function handle_message_post(params, request, response) {
+  const body = await read_body(request);
+  const payload = parse_payload2(body);
+  const text = payload.text;
+  if (text === void 0) {
+    send_json(response, 400, { error: "text is required" });
+    return;
+  }
+  const platform = payload.platform ?? "webhook";
+  const chat_id = payload.chat_id ?? "default";
+  const user_id = payload.user_id ?? "anonymous";
+  const reply = await params.handle_message(String(platform), String(chat_id), String(user_id), String(text));
+  respond_json_text(response, 200, format_agent_reply(reply ?? "", void 0, "webhook"));
+}
+function read_body(request) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    request.on("data", (chunk) => {
+      body += chunk.toString("utf8");
+    });
+    request.on("end", () => resolve(body));
+    request.on("error", reject);
+  });
+}
+function parse_payload2(body) {
+  if (body.trim().length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function send_json(response, status, payload) {
+  respond_json_text(response, status, JSON.stringify(payload));
+}
+function respond_json_text(response, status, json_text) {
+  response.statusCode = status;
+  response.setHeader("content-type", "application/json");
+  response.end(json_text);
+}
+function listen_on(server, port, on_listening) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "0.0.0.0", () => {
+      const bound = server.address()?.port ?? port;
+      logger.info(`gateway webhook listening on :${bound}`);
+      on_listening(bound);
+      resolve();
+    });
+  });
+}
+async function close_server(server) {
+  if (server === void 0) {
+    return;
+  }
+  await new Promise((resolve) => {
+    server.close(() => resolve());
+  });
+}
+function read_port_env() {
+  const raw = process.env.LICH_GATEWAY_PORT;
+  if (raw === void 0 || raw.length === 0) {
+    return void 0;
+  }
+  const port = Number(raw);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : void 0;
+}
+
+// src/gateway/runner.ts
+async function run_gateway(config, platforms) {
+  const valid = [];
+  for (const platform of platforms) {
+    if (is_known_platform(platform) === true) {
+      valid.push(platform);
+    } else {
+      process.stderr.write(`lich: unknown gateway platform "${platform}" (skipping)
+`);
+    }
+  }
+  if (valid.length === 0) {
+    process.stderr.write("lich: gateway needs at least one valid platform (webhook|telegram|discord|twitch)\n");
+    return 1;
+  }
+  const bus = new GatewayBus({ config, agent_factory: () => create_agent(config), wire_tool_logging: true });
+  const adapters = build_adapters(config, bus, valid);
+  install_signal_handlers(bus, adapters);
+  logger.info(`gateway starting: platforms=${valid.join(",")}, port=${process.env.LICH_GATEWAY_PORT ?? "8089"}, pid=${process.pid}`);
+  await start_all_adapters(adapters);
+  return await new Promise(() => void 0);
+}
+function is_known_platform(platform) {
+  return platform === "webhook" || platform === "telegram" || platform === "discord" || platform === "twitch";
+}
+function build_adapters(config, bus, platforms) {
+  const params = {
+    config,
+    handle_message: (platform, chat_id, user_id, text) => bus.handle(platform, chat_id, user_id, text),
+    get_agent: () => {
+      throw new Error("get_agent is reserved for future use");
+    },
+    reply_router: () => void 0
+  };
+  const adapters = [];
+  for (const platform of platforms) {
+    const adapter = create_platform_adapter(params, platform);
+    if (adapter !== void 0) {
+      adapters.push(adapter);
+    }
+  }
+  return adapters;
+}
+function create_platform_adapter(params, platform) {
+  switch (platform) {
+    case "webhook":
+      return create_webhook_adapter({ ...params, port: read_webhook_port() });
+    case "telegram":
+      return create_telegram_adapter(params);
+    case "discord":
+      return create_discord_adapter(params);
+    case "twitch":
+      return create_twitch_adapter(params);
+    default:
+      return void 0;
+  }
+}
+function read_webhook_port() {
+  const raw = process.env.LICH_GATEWAY_PORT;
+  if (raw === void 0 || raw.length === 0) {
+    return void 0;
+  }
+  const port = Number(raw);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : void 0;
+}
+async function start_all_adapters(adapters) {
+  for (const adapter of adapters) {
+    try {
+      await adapter.start();
+      logger.info(`gateway adapter started: ${adapter.name}`);
+    } catch (error) {
+      logger.error(`gateway adapter failed to start: ${adapter.name}`, error);
+    }
+  }
+}
+function install_signal_handlers(bus, adapters) {
+  const shutdown = () => {
+    for (const adapter of adapters) {
+      void adapter.stop().catch((error) => logger.warn(`gateway adapter stop failed: ${adapter.name}`, error));
+    }
+    bus.stop();
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}
+export {
+  run_gateway
+};
+//# sourceMappingURL=gateway-CWPVIU3W.js.map