ddchat 0.4.1 → 0.4.3

package/src/dedupe.js

@@ -1,44 +1,44 @@
-const DEFAULT_TTL_MS = 48 * 60 * 60 * 1000;
-const DEFAULT_GC_INTERVAL_MS = 60 * 1000;
-const DEFAULT_GC_CHECK_INTERVAL = 1000;
-export class DdchatDedupeStore {
-    gcIntervalMs;
-    gcCheckInterval;
-    seen = new Map();
-    ttlMs;
-    lastGcAt = 0;
-    checksSinceGc = 0;
-    constructor(ttlMs = DEFAULT_TTL_MS, gcIntervalMs = DEFAULT_GC_INTERVAL_MS, gcCheckInterval = DEFAULT_GC_CHECK_INTERVAL) {
-        this.gcIntervalMs = gcIntervalMs;
-        this.gcCheckInterval = gcCheckInterval;
-        this.ttlMs = ttlMs;
-    }
-    isDuplicate(accountId, messageId) {
-        const key = `${accountId}:${messageId}`;
-        const now = Date.now();
-        this.gcIfNeeded(now);
-        const expiresAt = this.seen.get(key);
-        if (expiresAt && expiresAt > now) {
-            return true;
-        }
-        this.seen.set(key, now + this.ttlMs);
-        return false;
-    }
-    gcIfNeeded(now) {
-        this.checksSinceGc += 1;
-        if (now - this.lastGcAt < this.gcIntervalMs &&
-            this.checksSinceGc < this.gcCheckInterval) {
-            return;
-        }
-        this.lastGcAt = now;
-        this.checksSinceGc = 0;
-        this.gc(now);
-    }
-    gc(now) {
-        for (const [key, expiresAt] of this.seen.entries()) {
-            if (expiresAt <= now) {
-                this.seen.delete(key);
-            }
-        }
-    }
-}
+const DEFAULT_TTL_MS = 48 * 60 * 60 * 1000;
+const DEFAULT_GC_INTERVAL_MS = 60 * 1000;
+const DEFAULT_GC_CHECK_INTERVAL = 1000;
+export class DdchatDedupeStore {
+    gcIntervalMs;
+    gcCheckInterval;
+    seen = new Map();
+    ttlMs;
+    lastGcAt = 0;
+    checksSinceGc = 0;
+    constructor(ttlMs = DEFAULT_TTL_MS, gcIntervalMs = DEFAULT_GC_INTERVAL_MS, gcCheckInterval = DEFAULT_GC_CHECK_INTERVAL) {
+        this.gcIntervalMs = gcIntervalMs;
+        this.gcCheckInterval = gcCheckInterval;
+        this.ttlMs = ttlMs;
+    }
+    isDuplicate(accountId, messageId) {
+        const key = `${accountId}:${messageId}`;
+        const now = Date.now();
+        this.gcIfNeeded(now);
+        const expiresAt = this.seen.get(key);
+        if (expiresAt && expiresAt > now) {
+            return true;
+        }
+        this.seen.set(key, now + this.ttlMs);
+        return false;
+    }
+    gcIfNeeded(now) {
+        this.checksSinceGc += 1;
+        if (now - this.lastGcAt < this.gcIntervalMs &&
+            this.checksSinceGc < this.gcCheckInterval) {
+            return;
+        }
+        this.lastGcAt = now;
+        this.checksSinceGc = 0;
+        this.gc(now);
+    }
+    gc(now) {
+        for (const [key, expiresAt] of this.seen.entries()) {
+            if (expiresAt <= now) {
+                this.seen.delete(key);
+            }
+        }
+    }
+}

package/src/gateway.js

@@ -1,211 +1,211 @@
-import { DDCHAT_PLUGIN_WS_BASE_URL } from "./constants.js";
-import { processDdchatInboundWithChannelRuntime } from "./inbound.js";
-import { clearDdchatWsRuntime, setDdchatWsRuntime } from "./runtime.js";
-function createReconnectDelayMs(attempt) {
-    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") {
-            clearDdchatWsRuntime(ctx.accountId);
-            ctx.setStatus({
-                accountId: ctx.accountId,
-                running: true,
-                connected: true,
-                reconnectAttempts: 0,
-                heartbeatSec: ctx.account.heartbeatSec,
-                inboundMode: "webhook",
-            });
-            await new Promise((resolve) => {
-                if (ctx.abortSignal.aborted) {
-                    resolve();
-                    return;
-                }
-                ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
-            });
-            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((resolve) => setTimeout(resolve, reconnectDelay));
-        }
-    },
-    stopAccount: async (ctx) => {
-        clearDdchatWsRuntime(ctx.accountId);
-        ctx.setStatus({
-            accountId: ctx.accountId,
-            running: false,
-            connected: false,
-        });
-        ctx.log?.info?.(`[ddchat:${ctx.accountId}] stopped`);
-    },
-};
-function appendDdchatAuthQuery(wsUrl, token) {
-    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) {
-    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) {
-    const { ctx, wsUrl, wsUrlForLog, attempts } = params;
-    await new Promise((resolve, reject) => {
-        const WebSocketCtor = globalThis.WebSocket;
-        if (!WebSocketCtor) {
-            reject(new Error("WebSocket is not available in this runtime"));
-            return;
-        }
-        const ws = new WebSocketCtor(wsUrl);
-        let heartbeatTimer;
-        let settled = false;
-        const finish = (fn) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            if (heartbeatTimer) {
-                clearInterval(heartbeatTimer);
-            }
-            clearDdchatWsRuntime(ctx.accountId);
-            fn();
-        };
-        ws.addEventListener("open", () => {
-            ctx.log?.info?.(`[ddchat:${ctx.accountId}] ws connected -> ${wsUrlForLog}`);
-            setDdchatWsRuntime({
-                accountId: ctx.accountId,
-                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: "claw" }));
-                }
-            }, Math.max(1000, ctx.account.heartbeatSec * 1000));
-        });
-        ws.addEventListener("message", async (event) => {
-            let ackContext = { accountId: ctx.accountId };
-            try {
-                const raw = typeof event.data === "string" ? event.data : String(event.data);
-                const message = JSON.parse(raw);
-                ackContext = {
-                    accountId: String(message.accountId ?? ctx.accountId).trim() || ctx.accountId,
-                    messageId: typeof message.messageId === "string" ? message.messageId : undefined,
-                };
-                if (message.type === "ping") {
-                    ws.send(JSON.stringify({ type: "pong", ts: Date.now(), from: "claw" }));
-                    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,
-                    cfg: ctx.cfg,
-                    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: "claw", result }));
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws message handling failed: ${errorMessage}`);
-                if (ws.readyState === WebSocket.OPEN) {
-                    ws.send(JSON.stringify({
-                        type: "ack",
-                        ok: false,
-                        from: "claw",
-                        accountId: ackContext.accountId,
-                        messageId: ackContext.messageId,
-                        error: errorMessage,
-                    }));
-                }
-            }
-        });
-        ws.addEventListener("error", (event) => {
-            ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws error: ${String(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 { clearDdchatWsRuntime, setDdchatWsRuntime } from "./runtime.js";
+function createReconnectDelayMs(attempt) {
+    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") {
+            clearDdchatWsRuntime(ctx.accountId);
+            ctx.setStatus({
+                accountId: ctx.accountId,
+                running: true,
+                connected: true,
+                reconnectAttempts: 0,
+                heartbeatSec: ctx.account.heartbeatSec,
+                inboundMode: "webhook",
+            });
+            await new Promise((resolve) => {
+                if (ctx.abortSignal.aborted) {
+                    resolve();
+                    return;
+                }
+                ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+            });
+            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((resolve) => setTimeout(resolve, reconnectDelay));
+        }
+    },
+    stopAccount: async (ctx) => {
+        clearDdchatWsRuntime(ctx.accountId);
+        ctx.setStatus({
+            accountId: ctx.accountId,
+            running: false,
+            connected: false,
+        });
+        ctx.log?.info?.(`[ddchat:${ctx.accountId}] stopped`);
+    },
+};
+function appendDdchatAuthQuery(wsUrl, token) {
+    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) {
+    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) {
+    const { ctx, wsUrl, wsUrlForLog, attempts } = params;
+    await new Promise((resolve, reject) => {
+        const WebSocketCtor = globalThis.WebSocket;
+        if (!WebSocketCtor) {
+            reject(new Error("WebSocket is not available in this runtime"));
+            return;
+        }
+        const ws = new WebSocketCtor(wsUrl);
+        let heartbeatTimer;
+        let settled = false;
+        const finish = (fn) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (heartbeatTimer) {
+                clearInterval(heartbeatTimer);
+            }
+            clearDdchatWsRuntime(ctx.accountId);
+            fn();
+        };
+        ws.addEventListener("open", () => {
+            ctx.log?.info?.(`[ddchat:${ctx.accountId}] ws connected -> ${wsUrlForLog}`);
+            setDdchatWsRuntime({
+                accountId: ctx.accountId,
+                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: "claw" }));
+                }
+            }, Math.max(1000, ctx.account.heartbeatSec * 1000));
+        });
+        ws.addEventListener("message", async (event) => {
+            let ackContext = { accountId: ctx.accountId };
+            try {
+                const raw = typeof event.data === "string" ? event.data : String(event.data);
+                const message = JSON.parse(raw);
+                ackContext = {
+                    accountId: String(message.accountId ?? ctx.accountId).trim() || ctx.accountId,
+                    messageId: typeof message.messageId === "string" ? message.messageId : undefined,
+                };
+                if (message.type === "ping") {
+                    ws.send(JSON.stringify({ type: "pong", ts: Date.now(), from: "claw" }));
+                    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,
+                    cfg: ctx.cfg,
+                    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: "claw", result }));
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws message handling failed: ${errorMessage}`);
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: "ack",
+                        ok: false,
+                        from: "claw",
+                        accountId: ackContext.accountId,
+                        messageId: ackContext.messageId,
+                        error: errorMessage,
+                    }));
+                }
+            }
+        });
+        ws.addEventListener("error", (event) => {
+            ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws error: ${String(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 });
+    });
+}