@openai-lite/codex-feishu 0.1.0

package/src/commands/doctor.js

@@ -0,0 +1,126 @@
+import { execFileSync } from "node:child_process";
+import { readTextIfExists } from "../lib/fs_utils.js";
+import {
+  getBridgeConfigPath,
+  getBridgeRpcEndpoint,
+  getCodexConfigPath,
+} from "../lib/paths.js";
+import { callJsonRpc } from "../lib/uds_rpc.js";
+
+function checkCommand(cmd, args = ["--version"]) {
+  try {
+    const output = execFileSync(cmd, args, { encoding: "utf8" }).trim();
+    return { ok: true, output };
+  } catch {
+    return { ok: false, output: "" };
+  }
+}
+
+async function existsNonEmpty(filePath) {
+  const content = await readTextIfExists(filePath);
+  return Boolean(content && content.trim().length > 0);
+}
+
+function mark(ok) {
+  return ok ? "OK " : "ERR";
+}
+
+export async function runDoctor() {
+  const codexCheck = checkCommand("codex");
+  const codexFeishuCheck = checkCommand("codex-feishu");
+  const invokedFromLocalScript = (process.argv[1] || "").includes("codex-feishu");
+  const codexFeishuAvailable = codexFeishuCheck.ok || invokedFromLocalScript;
+  const codexConfigPath = getCodexConfigPath();
+  const bridgeConfigPath = getBridgeConfigPath();
+
+  const codexConfig = (await readTextIfExists(codexConfigPath)) ?? "";
+  const mcpConfigured =
+    codexConfig.includes("[mcp_servers.codex_feishu]") &&
+    codexConfig.includes('command = "codex-feishu"');
+  const bridgeConfigReady = await existsNonEmpty(bridgeConfigPath);
+  const endpoint = getBridgeRpcEndpoint();
+  let daemonRunning = false;
+  let daemonInfo = "not running";
+  let bridgeStatus = null;
+  let recentEvents = [];
+  try {
+    const pong = await callJsonRpc(endpoint, "bridge/ping", {}, { timeoutMs: 800 });
+    daemonRunning = Boolean(pong?.ok);
+    daemonInfo = daemonRunning ? `running (version=${pong?.version || "unknown"})` : "not running";
+    if (daemonRunning) {
+      try {
+        bridgeStatus = await callJsonRpc(endpoint, "bridge/status", {}, { timeoutMs: 1200 });
+      } catch {
+        bridgeStatus = null;
+      }
+      try {
+        const eventsResp = await callJsonRpc(endpoint, "feishu/events/recent", { limit: 80 }, { timeoutMs: 1200 });
+        if (Array.isArray(eventsResp?.items)) {
+          recentEvents = eventsResp.items;
+        }
+      } catch {
+        recentEvents = [];
+      }
+    }
+  } catch {
+    daemonRunning = false;
+  }
+
+  // eslint-disable-next-line no-console
+  console.log("codex-feishu doctor\n");
+  // eslint-disable-next-line no-console
+  console.log(`[${mark(codexCheck.ok)}] codex binary ${codexCheck.ok ? codexCheck.output : "not found"}`);
+  // eslint-disable-next-line no-console
+  console.log(
+    `[${mark(codexFeishuAvailable)}] codex-feishu binary ${
+      codexFeishuCheck.ok
+        ? codexFeishuCheck.output
+        : invokedFromLocalScript
+          ? "running from local script (not on PATH)"
+          : "not found"
+    }`,
+  );
+  // eslint-disable-next-line no-console
+  console.log(`[${mark(mcpConfigured)}] mcp config in ${codexConfigPath}`);
+  // eslint-disable-next-line no-console
+  console.log(`[${mark(bridgeConfigReady)}] bridge config ${bridgeConfigPath}`);
+  // eslint-disable-next-line no-console
+  console.log(`[${mark(daemonRunning)}] daemon rpc ${endpoint} ${daemonInfo}`);
+  if (bridgeStatus) {
+    const feishuRunning = Boolean(bridgeStatus?.feishu?.running);
+    const bindings = Number(bridgeStatus?.bindings ?? 0);
+    const activeThread = bridgeStatus?.active_thread_id ?? "(none)";
+    // eslint-disable-next-line no-console
+    console.log(`[${mark(feishuRunning)}] feishu runtime ${feishuRunning ? "running" : "stopped"}`);
+    // eslint-disable-next-line no-console
+    console.log(`[INFO] bindings=${bindings}, active_thread=${activeThread}`);
+  }
+  if (recentEvents.length > 0) {
+    const inbound = recentEvents.filter((ev) => ev?.source === "feishu" && ev?.type === "feishu_message_inbound");
+    const inboundCount = inbound.length;
+    const groupInboundCount = inbound.filter((ev) => {
+      const t = String(ev?.chat_type ?? "").toLowerCase();
+      return t && t !== "p2p" && t !== "single";
+    }).length;
+    // eslint-disable-next-line no-console
+    console.log(
+      `[INFO] recent inbound events=${inboundCount}, group_inbound=${groupInboundCount} (last ${recentEvents.length} events)`,
+    );
+  }
+
+  const ok =
+    codexCheck.ok &&
+    codexFeishuAvailable &&
+    mcpConfigured &&
+    bridgeConfigReady &&
+    daemonRunning;
+  // eslint-disable-next-line no-console
+  console.log(`\nOverall: ${ok ? "READY" : "NOT READY"}`);
+  if (!ok) {
+    // eslint-disable-next-line no-console
+    console.log("Run: codex-feishu init");
+    // eslint-disable-next-line no-console
+    console.log("Then start daemon: codex-feishu daemon");
+    process.exitCode = 1;
+  }
+}

package/src/commands/inbound.js

@@ -0,0 +1,27 @@
+import { getBridgeRpcEndpoint } from "../lib/paths.js";
+import { callJsonRpc } from "../lib/uds_rpc.js";
+
+export async function runInbound(flags) {
+  const chatId = flags["chat-id"] || flags.chat;
+  const userId = flags["user-id"] || flags.user || null;
+  const text = flags.text;
+  if (!chatId || !text) {
+    throw new Error("usage: codex-feishu inbound --chat-id <chat_id> --text <message> [--user-id <id>]");
+  }
+
+  const endpoint = getBridgeRpcEndpoint();
+  const result = await callJsonRpc(
+    endpoint,
+    "feishu/inbound_text",
+    {
+      chat_id: chatId,
+      user_id: userId,
+      text,
+    },
+    { timeoutMs: 30_000 },
+  );
+
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify(result, null, 2));
+}
+

package/src/commands/init.js

@@ -0,0 +1,224 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { ensureDir, readJsonIfExists, readTextIfExists, writeText } from "../lib/fs_utils.js";
+import { getBridgeConfigPath, getBridgeHome, getCodexConfigPath, getPromptsDir } from "../lib/paths.js";
+
+const CODEX_FEISHU_MARK_BEGIN = "# BEGIN codex-feishu";
+const CODEX_FEISHU_MARK_END = "# END codex-feishu";
+
+const MCP_BLOCK = `${CODEX_FEISHU_MARK_BEGIN}
+[mcp_servers.codex_feishu]
+command = "codex-feishu"
+args = ["mcp"]
+${CODEX_FEISHU_MARK_END}
+`;
+
+function buildBridgeConfig(flags, existing = {}) {
+  return {
+    version: 1,
+    app_id: flags["app-id"] || process.env.FEISHU_APP_ID || existing.app_id || "",
+    app_secret: flags["app-secret"] || process.env.FEISHU_APP_SECRET || existing.app_secret || "",
+    bot_open_id: flags["bot-open-id"] || process.env.FEISHU_BOT_OPEN_ID || existing.bot_open_id || "",
+    encrypt_key: flags["encrypt-key"] || process.env.FEISHU_ENCRYPT_KEY || existing.encrypt_key || "",
+    verify_token: flags["verify-token"] || process.env.FEISHU_VERIFY_TOKEN || existing.verify_token || "",
+    codex_bin:
+      flags["codex-bin"] ||
+      process.env.CODEX_FEISHU_CODEX_BIN ||
+      process.env.CODEX_BIN ||
+      existing.codex_bin ||
+      "",
+    event_mode: "long_connection",
+  };
+}
+
+async function readJsonSafe(response) {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+function formatReason(prefix, code, msg, status) {
+  if (typeof code === "number" || typeof code === "string") {
+    return `${prefix} code=${code}${msg ? ` msg=${msg}` : ""}`;
+  }
+  if (status) {
+    return `${prefix} http=${status}`;
+  }
+  return prefix;
+}
+
+async function tryFetchBotOpenId(appId, appSecret) {
+  try {
+    const authResp = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ app_id: appId, app_secret: appSecret }),
+      signal: AbortSignal.timeout(6000),
+    });
+    const authJson = await readJsonSafe(authResp);
+    if (!authResp.ok) {
+      return {
+        ok: false,
+        reason: formatReason("tenant_access_token failed", authJson?.code, authJson?.msg, authResp.status),
+      };
+    }
+    if (!authJson || authJson.code !== 0 || !authJson.tenant_access_token) {
+      return {
+        ok: false,
+        reason: formatReason(
+          "tenant_access_token invalid response",
+          authJson?.code,
+          authJson?.msg,
+          authResp.status,
+        ),
+      };
+    }
+
+    const botResp = await fetch("https://open.feishu.cn/open-apis/bot/v3/info/", {
+      method: "GET",
+      headers: { authorization: `Bearer ${authJson.tenant_access_token}` },
+      signal: AbortSignal.timeout(6000),
+    });
+    const botJson = await readJsonSafe(botResp);
+    if (!botResp.ok) {
+      return {
+        ok: false,
+        reason: formatReason("bot_info failed", botJson?.code, botJson?.msg, botResp.status),
+      };
+    }
+    if (!botJson || botJson.code !== 0) {
+      return {
+        ok: false,
+        reason: formatReason("bot_info invalid response", botJson?.code, botJson?.msg, botResp.status),
+      };
+    }
+    const botOpenId = botJson?.bot?.open_id || botJson?.data?.bot?.open_id || "";
+    if (!botOpenId) {
+      return {
+        ok: false,
+        reason: "bot_info success but open_id is empty (enable bot ability and publish app first)",
+      };
+    }
+    return { ok: true, botOpenId };
+  } catch (error) {
+    return {
+      ok: false,
+      reason: `auto detect request failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+async function ensureCodexConfigHasMcpBlock() {
+  const configPath = getCodexConfigPath();
+  const configDir = path.dirname(configPath);
+  await ensureDir(configDir);
+  const current = (await readTextIfExists(configPath)) ?? "";
+  if (current.includes(CODEX_FEISHU_MARK_BEGIN)) {
+    return { updated: false, configPath };
+  }
+  const joiner = current.endsWith("\n") || current.length === 0 ? "" : "\n";
+  await writeText(configPath, `${current}${joiner}\n${MCP_BLOCK}`);
+  return { updated: true, configPath };
+}
+
+async function cleanupLegacyPromptFiles() {
+  const promptsDir = getPromptsDir();
+  await ensureDir(promptsDir);
+
+  const promptFq = path.join(promptsDir, "fq.md");
+  const promptLegacy = path.join(promptsDir, "feishu-qrcode.md");
+  try {
+    await fs.unlink(promptFq);
+  } catch (err) {
+    if (!err || err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  try {
+    await fs.unlink(promptLegacy);
+  } catch (err) {
+    if (!err || err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  return { promptsDir, removed: [promptFq, promptLegacy] };
+}
+
+async function writeBridgeConfig(bridgeConfig) {
+  const bridgeHome = getBridgeHome();
+  const bridgeConfigPath = getBridgeConfigPath();
+  await ensureDir(bridgeHome);
+  await writeText(`${bridgeConfigPath}`, `${JSON.stringify(bridgeConfig, null, 2)}\n`);
+  return { bridgeConfigPath, bridgeConfig };
+}
+
+export async function runInit(flags, options = {}) {
+  const existingBridgeConfig = (await readJsonIfExists(getBridgeConfigPath())) ?? {};
+  const bridgeConfig = buildBridgeConfig(flags, existingBridgeConfig);
+  const hasManualBotOpenId =
+    Boolean(flags["bot-open-id"] && flags["bot-open-id"].trim()) ||
+    Boolean(process.env.FEISHU_BOT_OPEN_ID && process.env.FEISHU_BOT_OPEN_ID.trim());
+  let autoDetectBotOpenIdResult = null;
+  if (!bridgeConfig.bot_open_id && !hasManualBotOpenId && bridgeConfig.app_id && bridgeConfig.app_secret) {
+    autoDetectBotOpenIdResult = await tryFetchBotOpenId(bridgeConfig.app_id, bridgeConfig.app_secret);
+    if (autoDetectBotOpenIdResult.ok) {
+      bridgeConfig.bot_open_id = autoDetectBotOpenIdResult.botOpenId;
+    }
+  }
+
+  const { updated, configPath } = await ensureCodexConfigHasMcpBlock();
+  await cleanupLegacyPromptFiles();
+  const { bridgeConfigPath } = await writeBridgeConfig(bridgeConfig);
+
+  // eslint-disable-next-line no-console
+  console.log("codex-feishu init completed");
+  // eslint-disable-next-line no-console
+  console.log(`- Codex config: ${configPath}${updated ? " (updated)" : " (already configured)"}`);
+  // eslint-disable-next-line no-console
+  console.log(`- Bridge config: ${bridgeConfigPath}`);
+  // eslint-disable-next-line no-console
+  console.log(`- codex_bin: ${bridgeConfig.codex_bin ? bridgeConfig.codex_bin : "(default: codex in PATH)"}`);
+
+  if (!bridgeConfig.app_id || !bridgeConfig.app_secret) {
+    // eslint-disable-next-line no-console
+    console.log(
+      "- Missing app_id/app_secret. Set FEISHU_APP_ID and FEISHU_APP_SECRET, then re-run init.",
+    );
+  }
+  if (!bridgeConfig.bot_open_id) {
+    // eslint-disable-next-line no-console
+    console.log(
+      "- Optional bot_open_id is empty. QR will encode /bind CODE instead of opening bot chat directly.",
+    );
+    if (autoDetectBotOpenIdResult && !autoDetectBotOpenIdResult.ok) {
+      // eslint-disable-next-line no-console
+      console.log(`- bot_open_id auto-detect failed: ${autoDetectBotOpenIdResult.reason}`);
+      // eslint-disable-next-line no-console
+      console.log(
+        "- Degraded gracefully: binding and chat sync still work; one-tap open-chat QR is disabled.",
+      );
+      // eslint-disable-next-line no-console
+      console.log("- To set manually: codex-feishu init --app-id <...> --app-secret <...> --bot-open-id <...>");
+    }
+  }
+
+  // eslint-disable-next-line no-console
+  console.log("\nNext:");
+  if (options.startDaemon) {
+    // eslint-disable-next-line no-console
+    console.log("1) Daemon will be restarted in background (see Daemon section below).");
+    // eslint-disable-next-line no-console
+    console.log("2) Start Codex normally: codex");
+    // eslint-disable-next-line no-console
+    console.log("3) Bind info will be printed automatically below (or refresh with: codex-feishu qrcode).");
+  } else {
+    // eslint-disable-next-line no-console
+    console.log("1) Start daemon: codex-feishu daemon");
+    // eslint-disable-next-line no-console
+    console.log("2) Start Codex normally: codex");
+    // eslint-disable-next-line no-console
+    console.log("3) Get bind info: codex-feishu qrcode");
+  }
+}

package/src/commands/mcp.js

@@ -0,0 +1,295 @@
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+import { getBridgeRpcEndpoint } from "../lib/paths.js";
+import { callJsonRpc } from "../lib/uds_rpc.js";
+
+const TOOLS = [
+  {
+    name: "feishu_qrcode",
+    description: "Generate a Feishu binding QR code for codex-feishu.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        purpose: {
+          type: "string",
+          description: "Optional reason for QR code generation.",
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "feishu_status",
+    description: "Get codex-feishu bridge status.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "feishu_new_thread",
+    description: "Create/switch to a new synced conversation thread on Feishu side.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Optional thread title",
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+];
+
+function out(msg) {
+  process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+
+function ok(id, result) {
+  out({ jsonrpc: "2.0", id, result });
+}
+
+function err(id, code, message) {
+  out({
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code,
+      message,
+    },
+  });
+}
+
+function toolText(text) {
+  return {
+    content: [{ type: "text", text }],
+    isError: false,
+  };
+}
+
+function formatInShanghai(value) {
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime())) {
+    return "";
+  }
+  const parts = new Intl.DateTimeFormat("zh-CN", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false,
+  }).formatToParts(date);
+  const read = (type) => parts.find((item) => item.type === type)?.value ?? "";
+  const y = read("year");
+  const mon = read("month");
+  const d = read("day");
+  const h = read("hour");
+  const min = read("minute");
+  const s = read("second");
+  if (!y || !mon || !d || !h || !min || !s) {
+    return "";
+  }
+  return `${y}-${mon}-${d} ${h}:${min}:${s}`;
+}
+
+async function renderAsciiQr(value) {
+  try {
+    const mod = await import("qrcode");
+    const QRCode = mod?.default ?? mod;
+    if (!QRCode || typeof QRCode.toString !== "function") {
+      throw new Error("qrcode.toString unavailable");
+    }
+    return await QRCode.toString(value, { type: "terminal", small: true, margin: 1 });
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.error(`[codex-feishu] qr render failed: ${err?.message ?? String(err)}`);
+    return null;
+  }
+}
+
+async function maybeAutostartDaemon() {
+  const auto = process.env.CODEX_FEISHU_AUTOSTART ?? "true";
+  if (auto === "0" || auto.toLowerCase() === "false") {
+    return false;
+  }
+
+  const trySpawn = (cmd, args) =>
+    new Promise((resolve) => {
+      const child = spawn(cmd, args, {
+        detached: true,
+        stdio: "ignore",
+      });
+      child.once("error", () => resolve(false));
+      child.once("spawn", () => {
+        child.unref();
+        resolve(true);
+      });
+    });
+
+  const fromPath = await trySpawn("codex-feishu", ["daemon"]);
+  if (!fromPath) {
+    const currentEntry = process.argv[1];
+    if (currentEntry) {
+      const fromCurrentNode = await trySpawn(process.execPath, [currentEntry, "daemon"]);
+      if (fromCurrentNode) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, 500);
+        });
+        return true;
+      }
+    }
+    return false;
+  }
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 500);
+  });
+  return true;
+}
+
+async function callDaemon(method, params) {
+  const endpoint = getBridgeRpcEndpoint();
+  try {
+    return await callJsonRpc(endpoint, method, params, { timeoutMs: 4000 });
+  } catch (firstErr) {
+    await maybeAutostartDaemon();
+    try {
+      return await callJsonRpc(endpoint, method, params, { timeoutMs: 6000 });
+    } catch (secondErr) {
+      throw new Error(
+        `daemon unavailable. Start it with \`codex-feishu daemon\`. Last error: ${secondErr.message}`,
+      );
+    }
+  }
+}
+
+async function handleToolCall(id, params) {
+  const toolName = params?.name;
+  const args = params?.arguments ?? {};
+
+  if (toolName === "feishu_qrcode") {
+    const result = await callDaemon("feishu/qrcode", {
+      purpose: args.purpose ?? null,
+      cwd_hint: process.cwd(),
+    });
+    const asciiQr = await renderAsciiQr(result.qr_text);
+    const expireAtShanghai = formatInShanghai(result.expires_at);
+    const text = [
+      "飞书绑定码已生成。",
+      result.reused ? "- note: 本次复用了最近一次未过期绑定码（避免重复调用生成新码）" : "",
+      `- code: ${result.code}`,
+      `- expire_at(上海): ${expireAtShanghai || "unknown"}`,
+      `- qrcode_mode: ${result.qrcode_mode ?? "unknown"}`,
+      `- qr_payload: ${result.qr_text}`,
+      result.open_chat_link ? `- open_chat_link: ${result.open_chat_link}` : "",
+      `- 在飞书里发送: ${result.bind_command_hint}`,
+      result.open_chat_link
+        ? "\n可扫码二维码(内容是 打开机器人聊天页；进入后仍需发送 /bind 命令)。"
+        : "\n可扫码二维码(内容是 /bind 命令)。",
+      "如二维码显示被截断，请直接使用上面的 open_chat_link 或 /bind 指令。",
+      asciiQr ? `\n\`\`\`\n${asciiQr}\n\`\`\`` : "",
+      asciiQr ? "" : "\n二维码渲染失败：请先执行 `npm install` 后重启 codex/codex-feishu。",
+    ].join("\n");
+    ok(id, toolText(text));
+    return;
+  }
+
+  if (toolName === "feishu_status") {
+    const status = await callDaemon("feishu/status", {});
+    const text = [
+      "codex-feishu 状态：",
+      `- app_server_running: ${status.app_server?.running ? "yes" : "no"}`,
+      `- app_server_initialized: ${status.app_server?.initialized ? "yes" : "no"}`,
+      `- feishu_enabled: ${status.feishu?.enabled ? "yes" : "no"}`,
+      `- feishu_running: ${status.feishu?.running ? "yes" : "no"}`,
+      `- feishu_last_error: ${status.feishu?.last_error ?? "none"}`,
+      `- active_thread_id: ${status.active_thread_id ?? "none"}`,
+      `- bindings: ${status.bindings}`,
+      `- pending_bind_codes: ${status.pending_bind_codes}`,
+      `- pending_requests: ${status.pending?.count ?? 0}`,
+      `- latest_event: ${status.latest_event?.type || status.latest_event?.method || "none"}`,
+    ].join("\n");
+    ok(id, toolText(text));
+    return;
+  }
+
+  if (toolName === "feishu_new_thread") {
+    const created = await callDaemon("feishu/new_thread", {
+      title: args.title ?? null,
+    });
+    ok(id, toolText(`已创建并切换到新线程: ${created.thread_id}`));
+    return;
+  }
+
+  err(id, -32601, `unknown tool: ${toolName}`);
+}
+
+async function handleRequest(msg) {
+  const { id, method, params } = msg;
+  if (method === "initialize") {
+    ok(id, {
+      protocolVersion: "2024-11-05",
+      serverInfo: {
+        name: "codex-feishu",
+        version: "0.1.0",
+      },
+      capabilities: {
+        tools: {},
+      },
+    });
+    return;
+  }
+
+  if (method === "tools/list") {
+    ok(id, { tools: TOOLS });
+    return;
+  }
+
+  if (method === "tools/call") {
+    try {
+      await handleToolCall(id, params);
+    } catch (toolErr) {
+      ok(
+        id,
+        {
+          content: [{ type: "text", text: toolErr.message }],
+          isError: true,
+        },
+      );
+    }
+    return;
+  }
+
+  if (method === "notifications/initialized") {
+    return;
+  }
+
+  if (id !== undefined) {
+    err(id, -32601, `method not found: ${method}`);
+  }
+}
+
+export async function runMcp() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity,
+  });
+
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    await handleRequest(msg);
+  }
+}