@syengup/friday-channel-next 0.0.35 → 0.0.37

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/sync/account-identity.d.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage } from "node:http";
+export interface PairAccountResult {
+    accountId: string;
+    status: "new" | "existing" | "unknown";
+    suggestedAccountId?: string;
+}
+export declare function getOrCreateAccountId(params: {
+    deviceId: string;
+    claimAccountId?: string;
+    claimConfirmed?: boolean;
+    historyDir?: string;
+}): PairAccountResult;
+export declare function isKnownAccountId(accountId: string, historyDir?: string): boolean;
+export declare function resolveAccountIdFromRequest(req: IncomingMessage): string | null;

package/dist/src/sync/account-identity.js

@@ -0,0 +1,101 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveFridayNextConfig } from "../config.js";
+import { getHostOpenClawConfigSnapshot } from "../host-config.js";
+import { getFridayNextRuntime } from "../runtime.js";
+function currentHistoryDir() {
+    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    return cfg.historyDir;
+}
+function indexPath(historyDir = currentHistoryDir()) {
+    return path.join(historyDir, "accounts", "index.json");
+}
+function normalizeDeviceId(deviceId) {
+    return deviceId.trim().toUpperCase();
+}
+function readIndex(historyDir = currentHistoryDir()) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(indexPath(historyDir), "utf8"));
+        return {
+            accounts: parsed.accounts && typeof parsed.accounts === "object" ? parsed.accounts : {},
+            deviceToAccount: parsed.deviceToAccount && typeof parsed.deviceToAccount === "object" ? parsed.deviceToAccount : {},
+        };
+    }
+    catch {
+        return { accounts: {}, deviceToAccount: {} };
+    }
+}
+function writeIndex(index, historyDir = currentHistoryDir()) {
+    const file = indexPath(historyDir);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(index, null, 2), "utf8");
+}
+function touchAccount(index, accountId, deviceId) {
+    const now = Date.now();
+    const existing = index.accounts[accountId];
+    const entry = existing ?? {
+        accountId,
+        createdAt: now,
+        lastSeenAt: now,
+        deviceIds: [],
+    };
+    entry.lastSeenAt = now;
+    if (deviceId) {
+        const normalized = normalizeDeviceId(deviceId);
+        if (normalized && !entry.deviceIds.includes(normalized)) {
+            entry.deviceIds.push(normalized);
+        }
+        if (normalized)
+            index.deviceToAccount[normalized] = accountId;
+    }
+    index.accounts[accountId] = entry;
+    return entry;
+}
+export function getOrCreateAccountId(params) {
+    const historyDir = params.historyDir ?? currentHistoryDir();
+    const index = readIndex(historyDir);
+    const deviceId = normalizeDeviceId(params.deviceId);
+    const claimed = params.claimAccountId?.trim();
+    if (claimed) {
+        const existed = Boolean(index.accounts[claimed]);
+        if (existed || params.claimConfirmed === true) {
+            touchAccount(index, claimed, deviceId);
+            writeIndex(index, historyDir);
+            return { accountId: claimed, status: existed ? "existing" : "new" };
+        }
+        const suggested = crypto.randomUUID();
+        return { accountId: suggested, status: "unknown", suggestedAccountId: suggested };
+    }
+    const mapped = deviceId ? index.deviceToAccount[deviceId] : undefined;
+    if (mapped && index.accounts[mapped]) {
+        touchAccount(index, mapped, deviceId);
+        writeIndex(index, historyDir);
+        return { accountId: mapped, status: "existing" };
+    }
+    const existingAccounts = Object.values(index.accounts);
+    if (existingAccounts.length === 1) {
+        const accountId = existingAccounts[0].accountId;
+        touchAccount(index, accountId, deviceId);
+        writeIndex(index, historyDir);
+        return { accountId, status: "existing" };
+    }
+    const accountId = crypto.randomUUID();
+    touchAccount(index, accountId, deviceId);
+    writeIndex(index, historyDir);
+    return { accountId, status: "new" };
+}
+export function isKnownAccountId(accountId, historyDir = currentHistoryDir()) {
+    const id = accountId.trim();
+    if (!id)
+        return false;
+    return Boolean(readIndex(historyDir).accounts[id]);
+}
+export function resolveAccountIdFromRequest(req) {
+    const raw = req.headers["x-account-id"];
+    const accountId = Array.isArray(raw) ? raw[0] : raw;
+    if (typeof accountId !== "string" || !accountId.trim())
+        return null;
+    const trimmed = accountId.trim();
+    return isKnownAccountId(trimmed) ? trimmed : null;
+}

package/dist/src/sync/archive.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage } from "node:http";
+import { type TranscriptEventInput } from "./transcript-store.js";
+export declare function accountIdFromSessionKey(sessionKey: string): string | null;
+export declare function resolveArchiveAccountId(req: IncomingMessage | null, sessionKey: string): string | null;
+export declare function archiveTranscriptEvent(params: {
+    accountId: string | null | undefined;
+    sessionKey: string | null | undefined;
+    event: TranscriptEventInput;
+}): void;

package/dist/src/sync/archive.js

@@ -0,0 +1,25 @@
+import { resolveAccountIdFromRequest } from "./account-identity.js";
+import { getTranscriptStore } from "./transcript-store.js";
+export function accountIdFromSessionKey(sessionKey) {
+    const trimmed = sessionKey.trim();
+    const rawMatch = trimmed.match(/^friday:account:([^:]+):/i);
+    if (rawMatch?.[1])
+        return rawMatch[1];
+    const storeMatch = trimmed.match(/^agent:main:friday:account:([^:]+):/i);
+    return storeMatch?.[1] ?? null;
+}
+export function resolveArchiveAccountId(req, sessionKey) {
+    return (req ? resolveAccountIdFromRequest(req) : null) ?? accountIdFromSessionKey(sessionKey);
+}
+export function archiveTranscriptEvent(params) {
+    const accountId = params.accountId?.trim();
+    const sessionKey = params.sessionKey?.trim();
+    if (!accountId || !sessionKey)
+        return;
+    try {
+        getTranscriptStore().appendEvent(accountId, sessionKey, params.event);
+    }
+    catch (err) {
+        console.error(`[Friday-SYNC] archive failed: ${String(err)}`);
+    }
+}

package/dist/src/sync/database.d.ts

@@ -0,0 +1,66 @@
+import Database from "better-sqlite3";
+/** ULID-like server ID: time-sortable (monotonic within same ms), globally unique. */
+export declare function generateServerId(): string;
+export type SyncMessageRecord = {
+    server_id: string;
+    session_key: string;
+    local_id: string | null;
+    sender_type: "user" | "assistant";
+    sender_name: string;
+    content: string;
+    timestamp_ms: number;
+    seq: number;
+    status: string;
+    is_from_current_user: number;
+    message_json: string;
+    run_id: string | null;
+    created_at: string;
+};
+export type SyncSessionRecord = {
+    session_key: string;
+    device_id: string;
+    title: string;
+    created_at: string;
+    last_active_at: string;
+    message_count: number;
+    latest_msg_id: string | null;
+};
+export type SyncStateRecord = {
+    device_id: string;
+    last_sync_seq: number;
+    updated_at: string;
+};
+export declare function resolveSyncDbPath(): string;
+export declare function initDatabase(dbPath?: string): void;
+/** Test-only: initialize with an in-memory database. */
+export declare function initMemoryDatabase(): void;
+export declare function getDatabase(): Database.Database;
+export declare function closeDatabase(): void;
+export interface InsertMessageParams {
+    serverId: string;
+    sessionKey: string;
+    deviceId?: string;
+    localId?: string | null;
+    senderType: "user" | "assistant";
+    senderName: string;
+    content: string;
+    timestampMs: number;
+    seq: number;
+    status: string;
+    isFromCurrentUser: boolean;
+    messageJson: string;
+    runId?: string | null;
+}
+export declare function insertMessage(params: InsertMessageParams): void;
+export declare function getMessagesAfterCursor(sessionKey: string, afterServerId: string, limit: number): string[];
+export declare function getLatestServerId(sessionKey: string): string | null;
+export declare function getMessagesBeforeCursor(sessionKey: string, beforeServerId: string, limit: number): string[];
+export declare function getLastMessageJson(sessionKey: string): string | null;
+export declare function getLastSyncSeq(deviceId: string): number;
+export declare function setLastSyncSeq(deviceId: string, seq: number): void;
+export declare function sessionExists(sessionKey: string): boolean;
+export declare function getSessionMessageCount(sessionKey: string): number;
+export declare function listSessionsByDevice(deviceId: string): SyncSessionRecord[];
+export declare function listAllSessions(): SyncSessionRecord[];
+export declare function findServerIdByRunAndSender(runId: string, senderType: string): string | null;
+export declare function deleteSessionFromDb(sessionKey: string): void;