ddchat 0.1.0 → 0.2.0

package/src/gateway.ts

@@ -1,237 +1,237 @@
-import { DDCHAT_PLUGIN_WS_BASE_URL } from "./constants.js";
-import { processDdchatInboundWithChannelRuntime } from "./inbound.js";
-import { setDdchatWsRuntime } from "./runtime.js";
-import type { DdchatResolvedAccount } from "./types.js";
-
-function createReconnectDelayMs(attempt: number): number {
-  const base = [1000, 2000, 5000, 10000, 30000][Math.min(attempt, 4)] ?? 30000;
-  const jitter = Math.floor(Math.random() * 300);
-  return base + jitter;
-}
-
-export const ddchatGateway = {
-  startAccount: async (ctx) => {
-    ctx.log?.info?.(
-      `[ddchat:${ctx.accountId}] start mode=${ctx.account.connectionMode} heartbeat=${ctx.account.heartbeatSec}s stream=${ctx.account.streamingMode}`,
-    );
-
-    if (ctx.account.connectionMode === "webhook") {
-      setDdchatWsRuntime({ connected: false, send: undefined });
-      ctx.setStatus({
-        accountId: ctx.accountId,
-        running: true,
-        connected: true,
-        reconnectAttempts: 0,
-        heartbeatSec: ctx.account.heartbeatSec,
-        inboundMode: "webhook",
-      });
-      await new Promise<void>((resolve) => {
-        const timer = setInterval(() => {
-          if (ctx.abortSignal.aborted) {
-            clearInterval(timer);
-            resolve();
-          }
-        }, 1000);
-      });
-      return;
-    }
-
-    const wsUrl = ctx.account.wsUrl?.trim() || DDCHAT_PLUGIN_WS_BASE_URL;
-
-    const token = ctx.account.token?.trim();
-    if (!token) {
-      throw new Error(`ddchat[${ctx.accountId}] missing token (set via channels add --token or config)`);
-    }
-
-    const resolvedWsUrl = appendDdchatAuthQuery(wsUrl, token);
-
-    let attempts = 0;
-    while (!ctx.abortSignal.aborted) {
-      attempts += 1;
-      const reconnectDelay = createReconnectDelayMs(attempts);
-      try {
-        await runWsSession({ ctx, wsUrl: resolvedWsUrl, wsUrlForLog: redactDdchatWsUrl(resolvedWsUrl), attempts });
-        if (ctx.abortSignal.aborted) {
-          break;
-        }
-      } catch (error) {
-        ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws session failed: ${String(error)}`);
-      }
-      if (ctx.abortSignal.aborted) {
-        break;
-      }
-      ctx.log?.warn?.(`[ddchat:${ctx.accountId}] reconnecting in ${reconnectDelay}ms`);
-      await new Promise<void>((resolve) => setTimeout(resolve, reconnectDelay));
-    }
-  },
-  stopAccount: async (ctx) => {
-    setDdchatWsRuntime({ connected: false, send: undefined });
-    ctx.setStatus({
-      accountId: ctx.accountId,
-      running: false,
-      connected: false,
-    });
-    ctx.log?.info?.(`[ddchat:${ctx.accountId}] stopped`);
-  },
-};
-
-function appendDdchatAuthQuery(wsUrl: string, token: string): string {
-  try {
-    const url = new URL(wsUrl);
-    url.searchParams.set("token", token);
-    return url.toString();
-  } catch {
-    const hasQuery = wsUrl.includes("?");
-    const sep = hasQuery ? "&" : "?";
-    return `${wsUrl}${sep}token=${encodeURIComponent(token)}`;
-  }
-}
-
-function redactDdchatWsUrl(wsUrl: string): string {
-  try {
-    const url = new URL(wsUrl);
-    if (url.searchParams.has("token")) {
-      url.searchParams.set("token", "(redacted)");
-    }
-    return url.toString();
-  } catch {
-    return wsUrl.replace(/([?&]token=)[^&]*/i, "$1(redacted)");
-  }
-}
-
-async function runWsSession(params: {
-  ctx: {
-    accountId: string;
-    account: DdchatResolvedAccount;
-    cfg: Record<string, unknown>;
-    channelRuntime?: {
-      reply: Record<string, unknown>;
-      routing: Record<string, unknown>;
-      media: Record<string, unknown>;
-    };
-    abortSignal: AbortSignal;
-    setStatus: (next: Record<string, unknown>) => void;
-    log?: { info?: (m: string) => void; warn?: (m: string) => void; error?: (m: string) => void };
-  };
-  wsUrl: string;
-  wsUrlForLog: string;
-  attempts: number;
-}): Promise<void> {
-  const { ctx, wsUrl, wsUrlForLog, attempts } = params;
-  await new Promise<void>((resolve, reject) => {
-    const WebSocketCtor = (
-      globalThis as unknown as {
-        WebSocket?: new (url: string) => {
-          readyState: number;
-          send: (data: string) => void;
-          close: () => void;
-          addEventListener: (name: string, fn: (...args: never[]) => void) => void;
-        };
-      }
-    ).WebSocket;
-    if (!WebSocketCtor) {
-      reject(new Error("WebSocket is not available in this runtime"));
-      return;
-    }
-    const ws = new WebSocketCtor(wsUrl);
-    let heartbeatTimer: ReturnType<typeof setInterval> | undefined;
-    let settled = false;
-    const finish = (fn: () => void) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-      }
-      setDdchatWsRuntime({ connected: false, send: undefined });
-      fn();
-    };
-
-    ws.addEventListener("open", () => {
-      ctx.log?.info?.(`[ddchat:${ctx.accountId}] ws connected -> ${wsUrlForLog}`);
-      setDdchatWsRuntime({
-        connected: true,
-        send: (payload) => {
-          if (ws.readyState !== WebSocket.OPEN) {
-            return false;
-          }
-          ws.send(JSON.stringify(payload));
-          return true;
-        },
-      });
-      ctx.setStatus({
-        accountId: ctx.accountId,
-        running: true,
-        connected: true,
-        reconnectAttempts: attempts - 1,
-        heartbeatSec: ctx.account.heartbeatSec,
-        inboundMode: "ws",
-        wsUrl: wsUrlForLog,
-      });
-      heartbeatTimer = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify({ type: "ping", ts: Date.now(), from: "plugin" }));
-        }
-      }, Math.max(1000, ctx.account.heartbeatSec * 1000));
-    });
-
-    ws.addEventListener("message", async (event) => {
-      try {
-        const raw = typeof event.data === "string" ? event.data : String(event.data);
-        const message = JSON.parse(raw) as Record<string, unknown>;
-        if (message.type === "ping") {
-          ws.send(JSON.stringify({ type: "pong", ts: Date.now(), from: "plugin" }));
-          return;
-        }
-        if (message.type !== "inbound_message") {
-          return;
-        }
-        if (!ctx.channelRuntime) {
-          throw new Error("channelRuntime unavailable in gateway context");
-        }
-        const result = await processDdchatInboundWithChannelRuntime({
-          channelRuntime: ctx.channelRuntime as never,
-          cfg: ctx.cfg as never,
-          body: message,
-          fallbackAccountId: ctx.accountId,
-          source: "ws",
-          logInfo: (msg) => ctx.log?.info?.(msg),
-        });
-        if (ws.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify({ type: "ack", ok: true, from: "plugin", result }));
-        }
-      } catch (error) {
-        ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws message handling failed: ${String(error)}`);
-      }
-    });
-
-    ws.addEventListener("error", (event) => {
-      ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws error: ${String((event as Event).type)}`);
-    });
-
-    ws.addEventListener("close", () => {
-      finish(resolve);
-    });
-
-    if (ctx.abortSignal.aborted) {
-      try {
-        ws.close();
-      } catch {}
-      finish(resolve);
-      return;
-    }
-    ctx.abortSignal.addEventListener(
-      "abort",
-      () => {
-        try {
-          ws.close();
-        } catch (error) {
-          reject(error);
-        }
-        finish(resolve);
-      },
-      { once: true },
-    );
-  });
-}
+import { DDCHAT_PLUGIN_WS_BASE_URL } from "./constants.js";
+import { processDdchatInboundWithChannelRuntime } from "./inbound.js";
+import { setDdchatWsRuntime } from "./runtime.js";
+import type { DdchatResolvedAccount } from "./types.js";
+
+function createReconnectDelayMs(attempt: number): number {
+  const base = [1000, 2000, 5000, 10000, 30000][Math.min(attempt, 4)] ?? 30000;
+  const jitter = Math.floor(Math.random() * 300);
+  return base + jitter;
+}
+
+export const ddchatGateway = {
+  startAccount: async (ctx) => {
+    ctx.log?.info?.(
+      `[ddchat:${ctx.accountId}] start mode=${ctx.account.connectionMode} heartbeat=${ctx.account.heartbeatSec}s stream=${ctx.account.streamingMode}`,
+    );
+
+    if (ctx.account.connectionMode === "webhook") {
+      setDdchatWsRuntime({ connected: false, send: undefined });
+      ctx.setStatus({
+        accountId: ctx.accountId,
+        running: true,
+        connected: true,
+        reconnectAttempts: 0,
+        heartbeatSec: ctx.account.heartbeatSec,
+        inboundMode: "webhook",
+      });
+      await new Promise<void>((resolve) => {
+        const timer = setInterval(() => {
+          if (ctx.abortSignal.aborted) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 1000);
+      });
+      return;
+    }
+
+    const wsUrl = ctx.account.wsUrl?.trim() || DDCHAT_PLUGIN_WS_BASE_URL;
+
+    const token = ctx.account.token?.trim();
+    if (!token) {
+      throw new Error(`ddchat[${ctx.accountId}] missing token (set via channels add --token or config)`);
+    }
+
+    const resolvedWsUrl = appendDdchatAuthQuery(wsUrl, token);
+
+    let attempts = 0;
+    while (!ctx.abortSignal.aborted) {
+      attempts += 1;
+      const reconnectDelay = createReconnectDelayMs(attempts);
+      try {
+        await runWsSession({ ctx, wsUrl: resolvedWsUrl, wsUrlForLog: redactDdchatWsUrl(resolvedWsUrl), attempts });
+        if (ctx.abortSignal.aborted) {
+          break;
+        }
+      } catch (error) {
+        ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws session failed: ${String(error)}`);
+      }
+      if (ctx.abortSignal.aborted) {
+        break;
+      }
+      ctx.log?.warn?.(`[ddchat:${ctx.accountId}] reconnecting in ${reconnectDelay}ms`);
+      await new Promise<void>((resolve) => setTimeout(resolve, reconnectDelay));
+    }
+  },
+  stopAccount: async (ctx) => {
+    setDdchatWsRuntime({ connected: false, send: undefined });
+    ctx.setStatus({
+      accountId: ctx.accountId,
+      running: false,
+      connected: false,
+    });
+    ctx.log?.info?.(`[ddchat:${ctx.accountId}] stopped`);
+  },
+};
+
+function appendDdchatAuthQuery(wsUrl: string, token: string): string {
+  try {
+    const url = new URL(wsUrl);
+    url.searchParams.set("token", token);
+    return url.toString();
+  } catch {
+    const hasQuery = wsUrl.includes("?");
+    const sep = hasQuery ? "&" : "?";
+    return `${wsUrl}${sep}token=${encodeURIComponent(token)}`;
+  }
+}
+
+function redactDdchatWsUrl(wsUrl: string): string {
+  try {
+    const url = new URL(wsUrl);
+    if (url.searchParams.has("token")) {
+      url.searchParams.set("token", "(redacted)");
+    }
+    return url.toString();
+  } catch {
+    return wsUrl.replace(/([?&]token=)[^&]*/i, "$1(redacted)");
+  }
+}
+
+async function runWsSession(params: {
+  ctx: {
+    accountId: string;
+    account: DdchatResolvedAccount;
+    cfg: Record<string, unknown>;
+    channelRuntime?: {
+      reply: Record<string, unknown>;
+      routing: Record<string, unknown>;
+      media: Record<string, unknown>;
+    };
+    abortSignal: AbortSignal;
+    setStatus: (next: Record<string, unknown>) => void;
+    log?: { info?: (m: string) => void; warn?: (m: string) => void; error?: (m: string) => void };
+  };
+  wsUrl: string;
+  wsUrlForLog: string;
+  attempts: number;
+}): Promise<void> {
+  const { ctx, wsUrl, wsUrlForLog, attempts } = params;
+  await new Promise<void>((resolve, reject) => {
+    const WebSocketCtor = (
+      globalThis as unknown as {
+        WebSocket?: new (url: string) => {
+          readyState: number;
+          send: (data: string) => void;
+          close: () => void;
+          addEventListener: (name: string, fn: (...args: never[]) => void) => void;
+        };
+      }
+    ).WebSocket;
+    if (!WebSocketCtor) {
+      reject(new Error("WebSocket is not available in this runtime"));
+      return;
+    }
+    const ws = new WebSocketCtor(wsUrl);
+    let heartbeatTimer: ReturnType<typeof setInterval> | undefined;
+    let settled = false;
+    const finish = (fn: () => void) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+      }
+      setDdchatWsRuntime({ connected: false, send: undefined });
+      fn();
+    };
+
+    ws.addEventListener("open", () => {
+      ctx.log?.info?.(`[ddchat:${ctx.accountId}] ws connected -> ${wsUrlForLog}`);
+      setDdchatWsRuntime({
+        connected: true,
+        send: (payload) => {
+          if (ws.readyState !== WebSocket.OPEN) {
+            return false;
+          }
+          ws.send(JSON.stringify(payload));
+          return true;
+        },
+      });
+      ctx.setStatus({
+        accountId: ctx.accountId,
+        running: true,
+        connected: true,
+        reconnectAttempts: attempts - 1,
+        heartbeatSec: ctx.account.heartbeatSec,
+        inboundMode: "ws",
+        wsUrl: wsUrlForLog,
+      });
+      heartbeatTimer = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "ping", ts: Date.now(), from: "plugin" }));
+        }
+      }, Math.max(1000, ctx.account.heartbeatSec * 1000));
+    });
+
+    ws.addEventListener("message", async (event) => {
+      try {
+        const raw = typeof event.data === "string" ? event.data : String(event.data);
+        const message = JSON.parse(raw) as Record<string, unknown>;
+        if (message.type === "ping") {
+          ws.send(JSON.stringify({ type: "pong", ts: Date.now(), from: "plugin" }));
+          return;
+        }
+        if (message.type !== "inbound_message") {
+          return;
+        }
+        if (!ctx.channelRuntime) {
+          throw new Error("channelRuntime unavailable in gateway context");
+        }
+        const result = await processDdchatInboundWithChannelRuntime({
+          channelRuntime: ctx.channelRuntime as never,
+          cfg: ctx.cfg as never,
+          body: message,
+          fallbackAccountId: ctx.accountId,
+          source: "ws",
+          logInfo: (msg) => ctx.log?.info?.(msg),
+        });
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "ack", ok: true, from: "plugin", result }));
+        }
+      } catch (error) {
+        ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws message handling failed: ${String(error)}`);
+      }
+    });
+
+    ws.addEventListener("error", (event) => {
+      ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws error: ${String((event as Event).type)}`);
+    });
+
+    ws.addEventListener("close", () => {
+      finish(resolve);
+    });
+
+    if (ctx.abortSignal.aborted) {
+      try {
+        ws.close();
+      } catch {}
+      finish(resolve);
+      return;
+    }
+    ctx.abortSignal.addEventListener(
+      "abort",
+      () => {
+        try {
+          ws.close();
+        } catch (error) {
+          reject(error);
+        }
+        finish(resolve);
+      },
+      { once: true },
+    );
+  });
+}