@jaralabs/codex-bridge 0.2.0 → 0.4.0

package/lib/server.mjs

@@ -1,190 +1,309 @@
 #!/usr/bin/env node
-// codex-bridge: OpenAI-compatible HTTP server that reuses a local ChatGPT
-// Business/Team/Plus session by shelling out to `codex exec --json`.
-// Default port: 11434. Endpoints:
-//   GET  /v1/models            -> { object:"list", data:[...] }
-//   POST /v1/chat/completions  -> OpenAI-style streaming or JSON response
+// codex-bridge: OpenAI-compatible HTTP server that talks to ChatGPT
+// Business/Team/Plus via the OpenAI Responses API directly.
 //
-// Auth: reads ~/.codex/auth.json (refreshes access_token via OpenAI's
-// refresh_token grant when expired). The token is only used so the
-// shell session stays authenticated; codex CLI handles the actual call.
+// Endpoints:
+//   GET  /v1/health           -> { ok, ...metrics }
+//   GET  /v1/models           -> { object:"list", data:[...] }
+//   POST /v1/chat/completions -> OpenAI-style streaming or JSON response
+//   GET  /v1/tools            -> list registered MCP tools
+//   POST /v1/tools            -> register a list of tools
+//   DELETE /v1/tools          -> clear registry
+//
+// Auth lives in lib/auth.mjs. Upstream resilience (retry, circuit
+// breaker, metrics) lives in lib/resilience.mjs. Boot-time capability
+// probing lives in lib/capabilities.mjs.
 
 import http from "node:http";
-import { spawn } from "node:child_process";
-import { readFileSync, existsSync, statSync, readdirSync } from "node:fs";
-import { homedir, userInfo } from "node:os";
-import { join, dirname } from "node:path";
+import { existsSync, readFileSync, appendFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { getAuth, refreshAccessToken } from "./auth.mjs";
+import {
+  registerTool,
+  registerTools,
+  listTools,
+  clearTools,
+  renderToolsSystemBlock,
+} from "./tools-registry.mjs";
+import {
+  withResilience,
+  metrics as resilienceMetrics,
+} from "./resilience.mjs";
+import { probeCapabilities } from "./capabilities.mjs";
 
 const PORT = Number(process.env.PORT || 11434);
 const HOST = process.env.HOST || "127.0.0.1";
-const CODEX_HOME =
-  process.env.CODEX_HOME || join(homedir(), ".codex");
-const AUTH_PATH = join(CODEX_HOME, "auth.json");
+const CODEX_HOME = process.env.CODEX_HOME || join(homedir(), ".codex");
 const MODELS_CACHE = join(CODEX_HOME, "models_cache.json");
+const CHATGPT_BASE = "https://chatgpt.com/backend-api/codex";
+const LOG_PATH = process.env.CODEX_BRIDGE_LOG || "/tmp/codex-bridge.log";
 
-const codexBin = (() => {
-  const fromEnv = process.env.CODEX_BIN;
-  if (fromEnv) return fromEnv;
-  try {
-    const which = spawn("which", ["codex"], { stdio: ["ignore", "pipe", "ignore"] });
-    const out = [];
-    which.stdout.on("data", (c) => out.push(c));
-    which.on("close", () => process.stdout.write(""));
-    // Note: ignored; we instead use the env-default path lookup below.
-  } catch {}
-  return "codex";
-})();
-
-// ---- Logging (JSONL to stderr AND to LOG_FILE if set) ----
-const LOG_FILE = process.env.CODEX_BRIDGE_LOG || "";
-function writeLog(line) {
-  try { process.stderr.write(line + "\n"); } catch {}
-  if (LOG_FILE) {
-    try {
-      appendFileSync(LOG_FILE, line + "\n");
-    } catch {}
-  }
-}
 function log(level, msg, extra) {
-  const line = JSON.stringify({ t: new Date().toISOString(), level, msg, ...extra });
-  writeLog(line);
+  const line = JSON.stringify({ t: new Date().toISOString(), level, msg, ...(extra || {}) });
+  try { appendFileSync(LOG_PATH, line + "\n"); } catch {}
+  if (process.env.CODEX_BRIDGE_VERBOSE) {
+    process.stderr.write(line + "\n");
+  }
 }
 
-import { appendFileSync } from "node:fs";
-process.on("SIGPIPE", () => {});
-
-// ---- Auth handling ----
-let authCache = null;
-function loadAuth() {
-  if (!existsSync(AUTH_PATH)) {
-    throw new Error(`codex-bridge: no auth.json at ${AUTH_PATH}. Run 'codex login' first.`);
+// ---- models ----
+function listModels() {
+  if (!existsSync(MODELS_CACHE)) {
+    return { object: "list", data: [] };
   }
-  const raw = JSON.parse(readFileSync(AUTH_PATH, "utf8"));
-  if (raw.auth_mode !== "chatgpt") {
-    throw new Error(`codex-bridge: auth mode is '${raw.auth_mode}', need 'chatgpt'.`);
+  try {
+    const cache = JSON.parse(readFileSync(MODELS_CACHE, "utf8"));
+    if (!Array.isArray(cache.models)) return { object: "list", data: [] };
+    const data = cache.models
+      .filter((m) => ["list", "default", null, undefined].includes(m.visibility ?? null))
+      .filter((m) => m.supported_in_api !== false)
+      .map((m) => ({ id: m.slug, object: "model", created: 0, owned_by: "openai-chatgpt" }));
+    return { object: "list", data };
+  } catch (e) {
+    log("warn", "listModels failed", { err: String(e) });
+    return { object: "list", data: [] };
   }
-  if (!raw.tokens?.access_token) throw new Error("codex-bridge: missing tokens.");
-  return raw;
 }
-function getAuth() {
-  if (!authCache) authCache = loadAuth();
-  return authCache;
+
+// ---- OpenAI Chat Completions <-> Responses API translation ----
+
+function chatToolsToResponsesTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) return undefined;
+  return tools
+    .map((t) => {
+      const fn = t.function || t;
+      if (!fn?.name) return null;
+      return {
+        type: "function",
+        name: fn.name,
+        description: fn.description || "",
+        parameters: fn.parameters || { type: "object", properties: {} },
+        strict: false,
+      };
+    })
+    .filter(Boolean);
 }
-// Token refresh is delegated to codex itself; we just rely on the CLI.
 
-// ---- Models listing ----
-function listModels() {
-  const slugId = (s) => ({
-    id: s,
-    object: "model",
-    created: 0,
-    owned_by: "openai-chatgpt",
-  });
-  let slugs = [];
-  if (existsSync(MODELS_CACHE)) {
-    try {
-      const cache = JSON.parse(readFileSync(MODELS_CACHE, "utf8"));
-      if (Array.isArray(cache.models)) {
-        slugs = cache.models
-          .filter((m) => m.visibility === "list" || m.visibility == null)
-          .map((m) => m.slug)
-          .filter(Boolean);
+function chatMessagesToResponsesInput(messages) {
+  let instructions = "";
+  const input = [];
+  for (const m of messages) {
+    if (!m || !m.role) continue;
+    const role = m.role;
+    if (role === "system" || role === "developer") {
+      const txt = textOf(m.content);
+      if (txt) instructions = (instructions ? instructions + "\n\n" : "") + txt;
+      continue;
+    }
+    if (role === "user") {
+      const txt = textOf(m.content);
+      if (txt) input.push({ type: "message", role: "user", content: [{ type: "input_text", text: txt }] });
+      continue;
+    }
+    if (role === "assistant") {
+      if (Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+        for (const tc of m.tool_calls) {
+          const name = tc.function?.name || tc.name;
+          const args = typeof tc.function?.arguments === "string"
+            ? tc.function.arguments
+            : (typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments ?? {}));
+          input.push({ type: "function_call", call_id: tc.id, name, arguments: args });
+        }
       }
-    } catch (e) {
-      log("warn", "models_cache.json parse failed", { err: String(e) });
+      const txt = textOf(m.content);
+      if (txt) {
+        input.push({ type: "message", role: "assistant", content: [{ type: "output_text", text: txt }] });
+      }
+      continue;
+    }
+    if (role === "tool") {
+      const callId = m.tool_call_id || m.call_id;
+      const out = textOf(m.content);
+      if (callId) {
+        input.push({ type: "function_call_output", call_id: callId, output: out });
+      }
+      continue;
     }
   }
-  if (slugs.length === 0) {
-    slugs = ["gpt-6.1-sol", "gpt-6-sol", "gpt-6-luna", "gpt-6-astra"];
-  }
-  return { object: "list", data: slugs.map(slugId) };
+  return { instructions, input };
 }
 
-// ---- codex exec runner ----
-function runCodex({ model, prompt, signal }) {
-  return new Promise((resolve, reject) => {
-    // Ensure auth is fresh enough for codex exec by reading the file (codex
-    // itself will refresh via its internal logic on the next call).
-    getAuth();
-    const args = [
-      "exec",
-      "--json",
-      "--skip-git-repo-check",
-      "-m", model,
-      prompt,
-    ];
-    const child = spawn(codexBin, args, {
-      env: {
-        ...process.env,
-        CODEX_HOME,
-        NO_COLOR: "1",
-        TERM: "dumb",
-      },
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    let stdout = "";
-    let stderr = "";
-    let aborted = false;
-    const onAbort = () => {
-      aborted = true;
-      try { child.kill("SIGTERM"); } catch {}
-    };
-    if (signal) signal.addEventListener("abort", onAbort, { once: true });
-    child.stdout.on("data", (c) => (stdout += c.toString()));
-    child.stderr.on("data", (c) => (stderr += c.toString()));
-    child.on("error", (e) => reject(e));
-    child.on("close", (code) => {
-      if (signal) signal.removeEventListener("abort", onAbort);
-      if (aborted) return reject(new Error("aborted"));
-      if (code !== 0) {
-        return reject(
-          new Error(`codex exec exited ${code}: ${stderr.slice(0, 400)}`),
-        );
-      }
-      // Parse the last item.completed agent_message + usage.
-      let lastText = "";
-      let usage = null;
-      for (const line of stdout.split("\n")) {
-        const l = line.trim();
-        if (!l.startsWith("{")) continue;
-        let evt;
-        try { evt = JSON.parse(l); } catch { continue; }
-        if (evt.type === "item.completed" && evt.item?.type === "agent_message") {
-          lastText = evt.item.text ?? lastText;
-        }
-        if (evt.type === "turn.completed") {
-          usage = evt.usage ?? null;
-        }
-      }
-      resolve({ text: lastText, usage, stderr });
-    });
-  });
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => {
+        if (typeof p === "string") return p;
+        if (!p) return "";
+        if (p.type === "text" || p.type === "input_text" || p.type === "output_text") return p.text || "";
+        if (p.type === "image_url" && p.image_url?.url) return `[image: ${p.image_url.url.slice(0, 60)}]`;
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n");
+  }
+  if (content && typeof content === "object") return JSON.stringify(content);
+  return "";
 }
 
-// ---- OpenAI shape helpers ----
 function now() { return Math.floor(Date.now() / 1000); }
 function genId(prefix) {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
+
 function toUsage(u) {
   if (!u) return { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-  const input = u.input_tokens ?? 0;
-  const output = u.output_tokens ?? 0;
   return {
-    prompt_tokens: input,
-    completion_tokens: output,
-    total_tokens: input + output,
+    prompt_tokens: u.input_tokens ?? 0,
+    completion_tokens: u.output_tokens ?? 0,
+    total_tokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0),
+  };
+}
+
+// ---- HTTP client to ChatGPT ----
+async function callResponses({ model, instructions, input, tools, signal }) {
+  const auth = await getAuth();
+  const url = `${CHATGPT_BASE}/responses`;
+  const body = {
+    model,
+    store: false,
+    stream: true,
+    instructions: instructions || undefined,
+    input,
+    tool_choice: "auto",
+    parallel_tool_calls: true,
+    prompt_cache_key: `codex-bridge-${Date.now()}`,
+  };
+  if (tools && tools.length > 0) body.tools = tools;
+
+  const headers = {
+    authorization: `Bearer ${auth.access_token}`,
+    "content-type": "application/json",
+    accept: "text/event-stream",
+    "OpenAI-Beta": "responses=experimental",
+    "chatgpt-account-id": auth.account_id || "",
+  };
+
+  log("info", "responses.request", {
+    model,
+    instructionsLen: (instructions || "").length,
+    inputItems: input.length,
+    tools: (tools || []).length,
+  });
+
+  const doFetch = async () => {
+    let res;
+    try {
+      res = await fetch(url, { method: "POST", headers, body: JSON.stringify(body), signal });
+    } catch (e) {
+      const err = new Error(`fetch failed: ${e?.message || e}`);
+      err.code = "fetch_failed";
+      err.status = 0;
+      throw err;
+    }
+    if (res.status === 401 && auth.refresh_token) {
+      log("info", "responses.401 refreshing token");
+      const refreshed = await refreshAccessToken(auth.refresh_token);
+      headers.authorization = `Bearer ${refreshed.access_token}`;
+      res = await fetch(url, { method: "POST", headers, body: JSON.stringify(body), signal });
+    }
+    if (!res.ok) {
+      const text = await res.text();
+      const err = new Error(`chatgpt ${res.status}: ${text.slice(0, 400)}`);
+      err.status = res.status;
+      throw err;
+    }
+    return res;
   };
+
+  return withResilience("responses", doFetch, { signal });
 }
-function renderTemplate(tmpl, vars) {
-  if (typeof tmpl === "string") return tmpl.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "");
-  // Multimodal array: replace text parts with {{key}} expansion.
-  return tmpl
-    .map((part) =>
-      part?.type === "text"
-        ? { ...part, text: part.text.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "") }
-        : part,
-    );
+
+// Parse SSE stream from Responses API.
+async function readSse(res) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder("utf8");
+  let buf = "";
+  let text = "";
+  const toolCalls = new Map();
+  let usage = null;
+  let currentItem = null;
+
+  function ensureCall(id, name) {
+    if (!toolCalls.has(id)) toolCalls.set(id, { id, name: name || "", arguments: "" });
+    return toolCalls.get(id);
+  }
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) !== -1) {
+      const block = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      let event = "";
+      let data = "";
+      for (const line of block.split("\n")) {
+        if (line.startsWith("event: ")) event = line.slice(7).trim();
+        else if (line.startsWith("data:")) data += (data ? "\n" : "") + line.slice(5).trim();
+      }
+      if (!data) continue;
+      if (data === "[DONE]") continue;
+      let json;
+      try { json = JSON.parse(data); } catch { continue; }
+      const t = json.type || event;
+      switch (t) {
+        case "response.output_item.added": {
+          const item = json.item || {};
+          currentItem = { type: item.type, id: item.id, call_id: item.call_id, name: item.name, content_index: 0 };
+          if (item.type === "function_call") {
+            ensureCall(item.call_id, item.name);
+          }
+          break;
+        }
+        case "response.function_call_arguments.delta": {
+          const id = json.call_id || currentItem?.call_id;
+          if (id) {
+            const call = ensureCall(id, currentItem?.name || json.name);
+            call.arguments += json.delta || "";
+          }
+          break;
+        }
+        case "response.function_call_arguments.done": {
+          const id = json.call_id || currentItem?.call_id;
+          if (id && typeof json.arguments === "string") {
+            const call = ensureCall(id, currentItem?.name || json.name);
+            call.arguments = json.arguments;
+          }
+          break;
+        }
+        case "response.output_text.delta": {
+          text += json.delta || "";
+          break;
+        }
+        case "response.completed": {
+          const r = json.response || {};
+          if (r.usage) usage = r.usage;
+          if (!text && Array.isArray(r.output)) {
+            for (const item of r.output) {
+              if (item.type === "message") {
+                for (const part of item.content || []) {
+                  if (part.type === "output_text" && part.text) text += part.text;
+                }
+              }
+            }
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  return { text, toolCalls: Array.from(toolCalls.values()), usage };
 }
 
 // ---- HTTP server ----
@@ -194,9 +313,33 @@ const server = http.createServer(async (req, res) => {
     if (req.method === "GET" && url.pathname === "/healthz") {
       return json(res, 200, { ok: true, port: PORT });
     }
+    if (req.method === "GET" && url.pathname === "/v1/health") {
+      return json(res, 200, {
+        ok: true,
+        port: PORT,
+        uptime: process.uptime(),
+        ...resilienceMetrics(),
+      });
+    }
     if (req.method === "GET" && url.pathname === "/v1/models") {
       return json(res, 200, listModels());
     }
+    if (req.method === "GET" && url.pathname === "/v1/tools") {
+      return json(res, 200, { object: "list", data: listTools() });
+    }
+    if (req.method === "POST" && url.pathname === "/v1/tools") {
+      const body = await readBody(req);
+      let payload;
+      try { payload = JSON.parse(body); } catch { return json(res, 400, { error: { message: "invalid JSON" } }); }
+      if (Array.isArray(payload)) registerTools(payload);
+      else if (Array.isArray(payload?.tools)) registerTools(payload.tools);
+      else return json(res, 400, { error: { message: "expected array or { tools: [...] }" } });
+      return json(res, 200, { object: "list", data: listTools(), count: listTools().length });
+    }
+    if (req.method === "DELETE" && url.pathname === "/v1/tools") {
+      clearTools();
+      return json(res, 200, { object: "list", data: [], count: 0 });
+    }
     if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
       const body = await readBody(req);
       let payload;
@@ -249,99 +392,127 @@ async function handleChatCompletions(payload, req, res) {
     temperature,
     top_p,
     max_tokens,
+    tools,
   } = payload || {};
   if (!model) return json(res, 400, { error: { message: "model is required" } });
   if (!Array.isArray(messages) || messages.length === 0) {
     return json(res, 400, { error: { message: "messages[] required" } });
   }
 
-  // Build prompt: concatenate system/user/assistant turns.
-  const parts = [];
-  let lastRole = null;
-  for (const m of messages) {
-    if (!m || !m.role) continue;
-    let text = "";
-    if (typeof m.content === "string") text = m.content;
-    else if (Array.isArray(m.content)) {
-      text = m.content
-        .filter((p) => p?.type === "text")
-        .map((p) => p.text || "")
-        .join("\n");
-    } else if (m.content) text = String(m.content);
-    if (!text && m.role !== lastRole) parts.push("");
-    if (text) {
-      const tag = m.role.toUpperCase();
-      parts.push(`${tag}: ${text}`);
+  const ac = new AbortController();
+  req.on("close", () => ac.abort());
+
+  const responsesTools = chatToolsToResponsesTools(tools);
+  let { instructions, input } = chatMessagesToResponsesInput(messages);
+  if (!(responsesTools && responsesTools.length > 0)) {
+    const block = renderToolsSystemBlock();
+    if (block) {
+      instructions = instructions ? `${instructions}\n\n${block}` : block;
     }
-    lastRole = m.role;
   }
-  parts.push("ASSISTANT:");
-  const prompt = parts.filter(Boolean).join("\n\n");
 
-  const ac = new AbortController();
-  req.on("close", () => ac.abort());
+  log("info", "chat.completions", { model, stream, msgs: messages.length, toolCount: (tools || []).length });
 
-  log("info", "chat.completions", { model, stream, msgs: messages.length });
   let result;
   try {
-    result = await runCodex({ model, prompt, signal: ac.signal });
+    const upstream = await callResponses({
+      model,
+      instructions,
+      input,
+      tools: responsesTools,
+      signal: ac.signal,
+    });
+    result = await readSse(upstream);
   } catch (e) {
-    return json(res, 502, { error: { message: String(e.message || e), type: "codex_error" } });
+    const status = e?.status || 502;
+    const body = {
+      error: {
+        message: String(e.message || e),
+        type: e?.code || "upstream_error",
+      },
+    };
+    if (status === 503 && e?.code === "circuit_open") {
+      return json(res, 503, { ...body, error: { ...body.error, message: "bridge: circuit open, upstream unavailable" } });
+    }
+    return json(res, status === 401 ? 502 : status, body);
   }
 
   const id = genId("chatcmpl");
   const created = now();
   const usage = toUsage(result.usage);
+  const hasToolCalls = result.toolCalls && result.toolCalls.length > 0;
+  const finishReason = hasToolCalls ? "tool_calls" : "stop";
+  const message = { role: "assistant", content: result.text || "" };
+  if (hasToolCalls) {
+    message.tool_calls = result.toolCalls.map((c, i) => ({
+      index: i,
+      id: c.id,
+      function: { name: c.name, arguments: c.arguments || "" },
+    }));
+  }
 
   if (stream) {
     startSse(res);
-    // First chunk: role.
     sse(res, null, {
-      id, object: "chat.completion.chunk", created,
-      model, choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
+      id, object: "chat.completion.chunk", created, model,
+      choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
     });
-    // Content chunk (codex exec doesn't stream per-token; emit as one).
     if (result.text) {
       sse(res, null, {
-        id, object: "chat.completion.chunk", created,
-        model,
-        choices: [{
-          index: 0,
-          delta: { content: result.text },
-          finish_reason: null,
-        }],
+        id, object: "chat.completion.chunk", created, model,
+        choices: [{ index: 0, delta: { content: result.text }, finish_reason: null }],
       });
     }
-    // Final chunk with finish_reason + usage.
-    sse(res, null, {
-      id, object: "chat.completion.chunk", created, model,
-      choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
-    });
+    if (hasToolCalls) {
+      for (let i = 0; i < result.toolCalls.length; i++) {
+        const c = result.toolCalls[i];
+        sse(res, null, {
+          id, object: "chat.completion.chunk", created, model,
+          choices: [{
+            index: 0,
+            delta: {
+              tool_calls: [{
+                index: i,
+                id: c.id,
+                function: { name: c.name, arguments: c.arguments || "" },
+              }],
+            },
+            finish_reason: null,
+          }],
+        });
+      }
+    }
     sse(res, null, {
       id, object: "chat.completion.chunk", created, model,
-      choices: [],
-      usage,
+      choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
     });
+    sse(res, null, { id, object: "chat.completion.chunk", created, model, choices: [], usage });
     res.write("data: [DONE]\n\n");
-    res.end();
-    return;
+    return res.end();
   }
 
   return json(res, 200, {
     id, object: "chat.completion", created, model,
-    choices: [{
-      index: 0,
-      message: { role: "assistant", content: result.text },
-      finish_reason: "stop",
-      logprobs: null,
-    }],
+    choices: [{ index: 0, message, finish_reason: finishReason, logprobs: null }],
     usage,
   });
 }
 
-server.listen(PORT, HOST, () => {
-  log("info", "listening", { url: `http://${HOST}:${PORT}`, codex_home: CODEX_HOME });
-});
+// ---- boot ----
+async function boot() {
+  try {
+    const caps = await probeCapabilities({ log: (level, msg, extra) => log(level, msg, extra) });
+    log("info", "capabilities", { ok: caps.ok, resolvedModel: caps.resolvedModel, events: caps.events, latencyMs: caps.latencyMs });
+  } catch (e) {
+    log("warn", "probe failed; starting anyway", { err: String(e) });
+  }
+  server.listen(PORT, HOST, () => {
+    log("info", "listening", { url: `http://${HOST}:${PORT}`, codex_home: CODEX_HOME });
+    process.stderr.write(`codex-bridge listening on http://${HOST}:${PORT}\n`);
+  });
+}
 
 process.on("SIGTERM", () => server.close(() => process.exit(0)));
 process.on("SIGINT", () => server.close(() => process.exit(0)));
+
+boot();