@syengup/friday-channel-next 0.0.35 → 0.0.38

package/dist/src/sse/emitter.js

@@ -0,0 +1,219 @@
+import { createFridayNextLogger } from "../logging.js";
+import { fridaySseOfflineQueue } from "./offline-queue.js";
+const logger = createFridayNextLogger("sse", "info");
+export class SseConnection {
+    deviceId;
+    res;
+    closed = false;
+    pending = [];
+    flushTimer = null;
+    waitingDrain = false;
+    constructor(deviceId, res) {
+        this.deviceId = deviceId;
+        this.res = res;
+        this.res.on("drain", () => {
+            this.waitingDrain = false;
+            this.scheduleFlush();
+        });
+        this.res.on("error", () => this.close());
+    }
+    send(entry, flushNow) {
+        if (this.closed)
+            return;
+        const normalized = "id" in entry && "event" in entry ? entry : { id: Date.now(), event: entry };
+        const payload = JSON.stringify(normalized.event.data);
+        this.pending.push(`id: ${normalized.id}\nevent: ${normalized.event.type}\ndata: ${payload}\n\n`);
+        if (flushNow) {
+            if (this.flushTimer)
+                clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+            this.flush();
+            return;
+        }
+        this.scheduleFlush();
+    }
+    sendRaw(line) {
+        if (this.closed)
+            return;
+        const ok = this.res.write(line);
+        if (ok === false)
+            this.waitingDrain = true;
+    }
+    scheduleFlush() {
+        if (this.waitingDrain || this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.flush();
+        }, 16);
+    }
+    flush() {
+        if (this.closed || this.waitingDrain || this.pending.length === 0)
+            return;
+        const data = this.pending.join("");
+        this.pending = [];
+        const ok = this.res.write(data);
+        if (ok === false)
+            this.waitingDrain = true;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.flushTimer)
+            clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+        this.pending = [];
+        try {
+            this.res.end();
+        }
+        catch {
+            // ignore
+        }
+    }
+    get isClosed() {
+        return this.closed;
+    }
+}
+class SseEmitterRegistry {
+    connections = new Map();
+    runEmitter = new Map();
+    lastRunIdByDevice = new Map();
+    eventSeqByDevice = new Map();
+    backlogLimit = 200;
+    getConnectionCount() {
+        return this.connections.size;
+    }
+    setBacklogLimit(limit) {
+        this.backlogLimit = Math.max(0, Math.floor(limit));
+    }
+    getBacklogLimit() {
+        return this.backlogLimit;
+    }
+    /** Last persisted / assigned SSE id for device (for `connected.lastSeq`). */
+    latestSeqForDevice(deviceId) {
+        const key = deviceId.trim().toUpperCase();
+        const disk = fridaySseOfflineQueue.latestId(key);
+        const mem = this.eventSeqByDevice.get(key) ?? 0;
+        return Math.max(disk, mem);
+    }
+    addConnection(deviceId, res) {
+        const normalized = deviceId.trim().toUpperCase();
+        const existing = this.connections.get(normalized);
+        if (existing && !existing.isClosed) {
+            existing.close();
+            for (const set of this.runEmitter.values()) {
+                set.delete(normalized);
+            }
+        }
+        const conn = new SseConnection(normalized, res);
+        this.connections.set(normalized, conn);
+        logger.info(`connect ${normalized} total=${this.connections.size}`);
+        return conn;
+    }
+    /**
+     * @param expectedConn When provided, only removes if this connection is still the active one
+     * (avoids stale `req.close` after a reconnect replaced the map entry).
+     */
+    removeConnection(deviceId, expectedConn) {
+        const normalized = deviceId.trim().toUpperCase();
+        const current = this.connections.get(normalized);
+        if (expectedConn !== undefined && current !== expectedConn) {
+            return;
+        }
+        current?.close();
+        this.connections.delete(normalized);
+        for (const set of this.runEmitter.values())
+            set.delete(normalized);
+        logger.info(`disconnect ${normalized} total=${this.connections.size}`);
+    }
+    getConnection(deviceId) {
+        return this.connections.get(deviceId.trim().toUpperCase());
+    }
+    nextEntry(deviceId, event) {
+        const key = deviceId.trim().toUpperCase();
+        const diskMax = fridaySseOfflineQueue.latestId(key);
+        const memMax = this.eventSeqByDevice.get(key) ?? 0;
+        const last = Math.max(memMax, diskMax);
+        const id = last + 1;
+        this.eventSeqByDevice.set(key, id);
+        fridaySseOfflineQueue.append(key, id, event.type, event.data, this.backlogLimit);
+        return { id, event };
+    }
+    replayBacklog(deviceId, afterEventId) {
+        const key = deviceId.trim().toUpperCase();
+        const conn = this.connections.get(key);
+        if (!conn)
+            return 0;
+        const entries = fridaySseOfflineQueue.readAfter(key, afterEventId);
+        let count = 0;
+        for (const e of entries) {
+            conn.send({ id: e.id, event: { type: e.event, data: e.data } }, true);
+            count += 1;
+        }
+        return count;
+    }
+    broadcast(event, deviceId, flushNow) {
+        if (deviceId) {
+            const key = deviceId.trim().toUpperCase();
+            const entry = this.nextEntry(key, event);
+            this.connections.get(key)?.send(entry, flushNow);
+            return;
+        }
+        for (const conn of this.connections.values()) {
+            const entry = this.nextEntry(conn.deviceId, event);
+            conn.send(entry, flushNow);
+        }
+    }
+    trackDeviceForRun(deviceId, runId) {
+        const key = deviceId.trim().toUpperCase();
+        const set = this.runEmitter.get(runId) ?? new Set();
+        set.add(key);
+        this.runEmitter.set(runId, set);
+        this.lastRunIdByDevice.set(key, runId);
+    }
+    untrackRun(runId) {
+        this.runEmitter.delete(runId);
+    }
+    hasTrackedDevices(runId) {
+        return (this.runEmitter.get(runId)?.size ?? 0) > 0;
+    }
+    getDeviceIdByRunId(runId) {
+        const first = this.runEmitter.get(runId)?.values().next().value;
+        return typeof first === "string" ? first : null;
+    }
+    getSoleConnectedDeviceId() {
+        if (this.connections.size !== 1)
+            return null;
+        return this.connections.keys().next().value ?? null;
+    }
+    getLastRunIdForDevice(deviceId) {
+        return this.lastRunIdByDevice.get(deviceId.trim().toUpperCase()) ?? null;
+    }
+    broadcastToRun(runId, event, flushNow) {
+        const direct = typeof event.data.deviceId === "string" ? event.data.deviceId : "";
+        if (direct.trim()) {
+            this.broadcast(event, direct, flushNow);
+            return;
+        }
+        const set = this.runEmitter.get(runId);
+        if (!set || set.size === 0)
+            return;
+        for (const deviceId of set)
+            this.broadcast(event, deviceId, flushNow);
+    }
+    broadcastToolEvent(deviceId, runId, event, flushNow) {
+        this.trackDeviceForRun(deviceId, runId);
+        this.broadcastToRun(runId, event, flushNow ?? true);
+    }
+    /** Vitest / e2e: drop connections and in-memory seq maps (does not delete disk queue files). */
+    resetForTest() {
+        for (const c of this.connections.values())
+            c.close();
+        this.connections.clear();
+        this.runEmitter.clear();
+        this.lastRunIdByDevice.clear();
+        this.eventSeqByDevice.clear();
+    }
+}
+export const sseEmitter = new SseEmitterRegistry();

package/dist/src/sse/offline-queue.d.ts

@@ -0,0 +1,26 @@
+export type PersistedSseEntry = {
+    id: number;
+    event: string;
+    data: Record<string, unknown>;
+};
+export declare function setOfflineQueueBaseDirForTest(dir: string | null): void;
+export declare function resolveFridayNextEventsQueueDir(): string;
+/**
+ * Per-device JSONL persistence for SSE replay.
+ * `overrideBaseDir` is for tests; production uses `resolveFridayNextEventsQueueDir()`.
+ */
+export declare class FridaySseOfflineQueue {
+    private readonly overrideBaseDir;
+    constructor(overrideBaseDir?: string | null);
+    private baseDir;
+    private devicePath;
+    private ensureDir;
+    /** Highest id in file (full scan; ok for bounded backlog). */
+    scanMaxId(deviceId: string): number;
+    latestId(deviceId: string): number;
+    append(deviceId: string, id: number, event: string, data: Record<string, unknown>, backlogLimit: number): void;
+    readAfter(deviceId: string, afterId: number): PersistedSseEntry[];
+    truncateKeepLastN(deviceId: string, keep: number): void;
+}
+/** Shared queue: base directory follows `setOfflineQueueBaseDirForTest` / config. */
+export declare const fridaySseOfflineQueue: FridaySseOfflineQueue;

package/dist/src/sse/offline-queue.js

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveFridayNextConfig } from "../config.js";
+import { getHostOpenClawConfigSnapshot } from "../host-config.js";
+import { getFridayNextRuntime } from "../runtime.js";
+/** Test-only override for queue base directory. */
+let testQueueBaseDir = null;
+export function setOfflineQueueBaseDirForTest(dir) {
+    testQueueBaseDir = dir;
+}
+export function resolveFridayNextEventsQueueDir() {
+    if (testQueueBaseDir)
+        return testQueueBaseDir;
+    try {
+        const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+        return path.join(path.dirname(cfg.historyDir), "events-queue");
+    }
+    catch {
+        return path.join(os.homedir(), ".openclaw", "friday-next", "events-queue");
+    }
+}
+/**
+ * Per-device JSONL persistence for SSE replay.
+ * `overrideBaseDir` is for tests; production uses `resolveFridayNextEventsQueueDir()`.
+ */
+export class FridaySseOfflineQueue {
+    overrideBaseDir;
+    constructor(overrideBaseDir = null) {
+        this.overrideBaseDir = overrideBaseDir;
+    }
+    baseDir() {
+        if (this.overrideBaseDir)
+            return this.overrideBaseDir;
+        return resolveFridayNextEventsQueueDir();
+    }
+    devicePath(deviceId) {
+        const key = deviceId.trim().toUpperCase();
+        return path.join(this.baseDir(), `${key}.jsonl`);
+    }
+    ensureDir() {
+        fs.mkdirSync(this.baseDir(), { recursive: true });
+    }
+    /** Highest id in file (full scan; ok for bounded backlog). */
+    scanMaxId(deviceId) {
+        const file = this.devicePath(deviceId);
+        if (!fs.existsSync(file))
+            return 0;
+        let max = 0;
+        const content = fs.readFileSync(file, "utf8");
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const o = JSON.parse(line);
+                if (typeof o.id === "number" && o.id > max)
+                    max = o.id;
+            }
+            catch {
+                /* skip corrupt line */
+            }
+        }
+        return max;
+    }
+    latestId(deviceId) {
+        return this.scanMaxId(deviceId.trim().toUpperCase());
+    }
+    append(deviceId, id, event, data, backlogLimit) {
+        if (event === "connected")
+            return;
+        this.ensureDir();
+        const file = this.devicePath(deviceId);
+        const line = JSON.stringify({ id, event, data }) + "\n";
+        fs.appendFileSync(file, line, "utf8");
+        if (backlogLimit > 0) {
+            this.truncateKeepLastN(deviceId, backlogLimit);
+        }
+    }
+    readAfter(deviceId, afterId) {
+        const file = this.devicePath(deviceId);
+        if (!fs.existsSync(file))
+            return [];
+        const out = [];
+        const content = fs.readFileSync(file, "utf8");
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const o = JSON.parse(line);
+                if (typeof o.id === "number" &&
+                    o.id > afterId &&
+                    typeof o.event === "string" &&
+                    o.data &&
+                    typeof o.data === "object" &&
+                    !Array.isArray(o.data)) {
+                    out.push(o);
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+        out.sort((a, b) => a.id - b.id);
+        return out;
+    }
+    truncateKeepLastN(deviceId, keep) {
+        if (keep <= 0)
+            return;
+        const file = this.devicePath(deviceId);
+        if (!fs.existsSync(file))
+            return;
+        const all = [];
+        const content = fs.readFileSync(file, "utf8");
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const o = JSON.parse(line);
+                if (typeof o.id === "number" && typeof o.event === "string" && o.data && typeof o.data === "object") {
+                    all.push(o);
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+        if (all.length <= keep)
+            return;
+        const slice = all.slice(-keep);
+        fs.writeFileSync(file, slice.map((e) => JSON.stringify(e) + "\n").join(""), "utf8");
+    }
+}
+/** Shared queue: base directory follows `setOfflineQueueBaseDirForTest` / config. */
+export const fridaySseOfflineQueue = new FridaySseOfflineQueue(null);

package/dist/src/vendor/runtime-store.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Vendored from OpenClaw `plugin-sdk/runtime-store` (tiny, no transitive deps).
+ * Keeps friday-next HTTP tests from importing the full gateway graph.
+ */
+type PluginRuntimeStoreKeyOptions = {
+    key: string;
+    errorMessage: string;
+};
+type PluginRuntimeStorePluginOptions = {
+    pluginId: string;
+    errorMessage: string;
+};
+type PluginRuntimeStoreOptions = PluginRuntimeStoreKeyOptions | PluginRuntimeStorePluginOptions;
+export declare function createPluginRuntimeStore<T>(errorMessage: string): {
+    setRuntime: (next: T) => void;
+    clearRuntime: () => void;
+    tryGetRuntime: () => T | null;
+    getRuntime: () => T;
+};
+export declare function createPluginRuntimeStore<T>(options: PluginRuntimeStoreOptions): {
+    setRuntime: (next: T) => void;
+    clearRuntime: () => void;
+    tryGetRuntime: () => T | null;
+    getRuntime: () => T;
+};
+export {};

package/dist/src/vendor/runtime-store.js

@@ -0,0 +1,60 @@
+/**
+ * Vendored from OpenClaw `plugin-sdk/runtime-store` (tiny, no transitive deps).
+ * Keeps friday-next HTTP tests from importing the full gateway graph.
+ */
+const pluginRuntimeStoreRegistryKey = Symbol.for("openclaw.plugin-sdk.runtime-store-registry");
+function getPluginRuntimeStoreRegistry() {
+    const globalRecord = globalThis;
+    globalRecord[pluginRuntimeStoreRegistryKey] ??= new Map();
+    return globalRecord[pluginRuntimeStoreRegistryKey];
+}
+function pluginRuntimeStoreKeyForPluginId(pluginId) {
+    const normalizedPluginId = pluginId.trim();
+    if (!normalizedPluginId) {
+        throw new Error("createPluginRuntimeStore: pluginId must not be empty");
+    }
+    return `plugin-runtime:${normalizedPluginId}`;
+}
+function resolvePluginRuntimeStoreOptions(options) {
+    if (typeof options === "string") {
+        return { key: options, errorMessage: options };
+    }
+    if ("pluginId" in options) {
+        return {
+            key: pluginRuntimeStoreKeyForPluginId(options.pluginId),
+            errorMessage: options.errorMessage,
+        };
+    }
+    return options;
+}
+export function createPluginRuntimeStore(options) {
+    const resolved = resolvePluginRuntimeStoreOptions(options);
+    const slot = typeof options === "string"
+        ? { runtime: null }
+        : (() => {
+            const registry = getPluginRuntimeStoreRegistry();
+            let existingSlot = registry.get(resolved.key);
+            if (!existingSlot) {
+                existingSlot = { runtime: null };
+                registry.set(resolved.key, existingSlot);
+            }
+            return existingSlot;
+        })();
+    return {
+        setRuntime(next) {
+            slot.runtime = next;
+        },
+        clearRuntime() {
+            slot.runtime = null;
+        },
+        tryGetRuntime() {
+            return slot.runtime ?? null;
+        },
+        getRuntime() {
+            if (slot.runtime === null) {
+                throw new Error(resolved.errorMessage);
+            }
+            return slot.runtime;
+        },
+    };
+}

package/index.ts

@@ -23,8 +23,13 @@ export { setFridayNextRuntime } from "./src/runtime.js";
 /** `api.on` returns void — register tool hooks at most once per process. */
 let fridayNextToolHooksRegistered = false;
 let disposeAgentEventListener: (() => void) | null = null;
-/** Avoid duplicate `registerHttpRoute` when gateway re-invokes `registerFull`. */
-let fridayNextPluginHttpRegistered = false;
+/**
+ * Track the last `api` instance on which HTTP routes were registered.
+ * When the health-monitor restarts the plugin, `registerFull` receives a fresh `api` whose
+ * old routes are gone — we must re-register.  A WeakRef lets us distinguish "same api,
+ * re-entered" (skip) from "new api after restart" (re-register).
+ */
+let lastApiRoutesRegistered: WeakRef<OpenClawPluginApi> | null = null;
 
 function deviceIdFromToolContext(ctx: PluginHookToolContext): string | null {
   if (ctx.runId) {
@@ -77,8 +82,9 @@ export default defineChannelPluginEntry({
   setRuntime: setFridayNextRuntime,
   registerFull: (api: OpenClawPluginApi) => {
     setFridayAgentForwardRuntime(api);
-    if (!fridayNextPluginHttpRegistered) {
-      fridayNextPluginHttpRegistered = true;
+    const sameApi = lastApiRoutesRegistered?.deref() === api;
+    if (!sameApi) {
+      lastApiRoutesRegistered = new WeakRef(api);
       registerFridayNextHttpRoutes(api);
     } else {
       const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));

package/package.json

@@ -1,23 +1,16 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.0.35",
+  "version": "0.0.38",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "type": "module",
   "files": [
+    "dist/",
     "index.ts",
     "src/",
     "install.js",
     "tsconfig.json",
     "openclaw.plugin.json"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run test:unit && npm run test:e2e",
-    "test:unit": "vitest run",
-    "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "test:smoke": "node scripts/e2e-smoke.mjs",
-    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
-  },
   "bin": {
     "friday-channel-next": "install.js"
   },
@@ -63,5 +56,13 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.5",
     "zod": "^4.3.6"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:smoke": "node scripts/e2e-smoke.mjs",
+    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
   }
-}
+}