@syengup/friday-channel-next 0.0.35 → 0.0.37

package/dist/src/sync/message-store.d.ts

@@ -0,0 +1,68 @@
+/** Shape of a ChatMessage as received from / stored for the Friday app. */
+export type StoredChatMessage = Record<string, unknown>;
+export interface StoreUserMessageParams {
+    sessionKey: string;
+    deviceId: string;
+    text: string;
+    attachments: string[];
+    localId?: string;
+    timestampMs?: number;
+    seq?: number;
+    runId: string;
+}
+export interface StoreAssistantMessageParams {
+    sessionKey: string;
+    deviceId: string;
+    message: StoredChatMessage;
+    runId: string;
+}
+export interface SyncResult {
+    idMappings: Record<string, string>;
+    remoteMessages: StoredChatMessage[];
+    latestServerId: string | null;
+    hasMore: boolean;
+    syncSeq: number;
+}
+/** Store a user message and return its serverId. */
+export declare function storeUserMessage(params: StoreUserMessageParams): string;
+/** Store an assistant message assembled by the accumulator. */
+export declare function storeAssistantMessage(params: StoreAssistantMessageParams): string;
+/** Paginated history query. Returns messages BEFORE the given cursor (for loading older messages). */
+export declare function getMessagesBefore(sessionKey: string, beforeServerId: string | undefined, limit: number): {
+    messages: StoredChatMessage[];
+    hasMore: boolean;
+};
+/** Get latest serverId for a session (used as next cursor). */
+export declare function getLatestServerIdForSession(sessionKey: string): string | null;
+/** Process a sync request from a device. Idempotent by (deviceId, syncSeq). */
+export declare function processSync(params: {
+    sessionKey: string;
+    deviceId: string;
+    syncSeq: number;
+    lastServerId: string | undefined;
+    messages: StoredChatMessage[];
+}): SyncResult;
+export interface ImportResult {
+    idMappings: Record<string, string>;
+    imported: number;
+}
+/** Bulk import for first-time migration. Rejects if session already has data. */
+export declare function importMessages(params: {
+    sessionKey: string;
+    deviceId: string;
+    messages: StoredChatMessage[];
+}): ImportResult;
+export interface SessionListItem {
+    sessionKey: string;
+    deviceId: string;
+    title: string;
+    createdAt: string;
+    lastActiveAt: string;
+    messageCount: number;
+    latestServerId: string | null;
+}
+export declare function listSessions(deviceId: string): SessionListItem[];
+export declare function listAllSessionsList(): SessionListItem[];
+export declare class ConflictError extends Error {
+    constructor(message: string);
+}

package/dist/src/sync/message-store.js

@@ -0,0 +1,262 @@
+import { generateServerId, insertMessage, getMessagesAfterCursor, getMessagesBeforeCursor, getLatestServerId, getLastSyncSeq, setLastSyncSeq, getSessionMessageCount, listSessionsByDevice, listAllSessions, findServerIdByRunAndSender, } from "./database.js";
+function buildUserMessageJson(params) {
+    const ts = params.timestampMs ?? Date.now();
+    return {
+        id: params.localId ?? "",
+        content: params.text,
+        sender: { user: { name: "You" } },
+        timestamp: new Date(ts).toISOString(),
+        seq: params.seq ?? 0,
+        status: "sent",
+        isFromCurrentUser: true,
+        toolCalls: null,
+        attachment: null,
+        extraAttachments: params.attachments.length > 0 ? params.attachments.map((url) => ({
+            id: "",
+            filename: "",
+            url,
+            isImage: false,
+            localData: null,
+        })) : null,
+        thoughtEvents: null,
+        ttsAttachment: null,
+        commandTerminals: null,
+        isInternalTrace: false,
+        modelName: null,
+        totalTokens: null,
+        contextWindowMax: null,
+        contextTokensUsed: null,
+        runId: params.runId,
+    };
+}
+/** Store a user message and return its serverId. */
+export function storeUserMessage(params) {
+    const serverId = generateServerId();
+    const msg = buildUserMessageJson(params);
+    msg.serverId = serverId;
+    // App-side syncStatus is not stored server-side; the server is always "synced"
+    insertMessage({
+        serverId,
+        sessionKey: params.sessionKey,
+        deviceId: params.deviceId,
+        localId: params.localId ?? null,
+        senderType: "user",
+        senderName: "You",
+        content: params.text,
+        timestampMs: params.timestampMs ?? Date.now(),
+        seq: params.seq ?? 0,
+        status: "sent",
+        isFromCurrentUser: true,
+        messageJson: JSON.stringify(msg),
+        runId: params.runId,
+    });
+    return serverId;
+}
+/** Store an assistant message assembled by the accumulator. */
+export function storeAssistantMessage(params) {
+    const serverId = generateServerId();
+    const msg = { ...params.message };
+    msg.serverId = serverId;
+    msg.isFromCurrentUser = false;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    const sender = msg.sender;
+    const senderName = sender?.assistant?.name ?? "Claude";
+    const ts = typeof msg.timestamp === "string" ? Date.parse(msg.timestamp) : Date.now();
+    const seq = typeof msg.seq === "number" ? msg.seq : 0;
+    insertMessage({
+        serverId,
+        sessionKey: params.sessionKey,
+        deviceId: params.deviceId,
+        localId: null,
+        senderType: "assistant",
+        senderName,
+        content,
+        timestampMs: Number.isFinite(ts) ? ts : Date.now(),
+        seq,
+        status: "sent",
+        isFromCurrentUser: false,
+        messageJson: JSON.stringify(msg),
+        runId: params.runId,
+    });
+    return serverId;
+}
+/** Paginated history query. Returns messages BEFORE the given cursor (for loading older messages). */
+export function getMessagesBefore(sessionKey, beforeServerId, limit) {
+    const effectiveLimit = Math.min(Math.max(limit || 25, 1), 50);
+    const before = beforeServerId ?? "";
+    const jsons = getMessagesBeforeCursor(sessionKey, before, effectiveLimit + 1);
+    const hasMore = jsons.length > effectiveLimit;
+    const slice = jsons.slice(0, effectiveLimit);
+    return {
+        messages: slice.map((j) => JSON.parse(j)),
+        hasMore,
+    };
+}
+/** Get latest serverId for a session (used as next cursor). */
+export function getLatestServerIdForSession(sessionKey) {
+    return getLatestServerId(sessionKey);
+}
+/** Process a sync request from a device. Idempotent by (deviceId, syncSeq). */
+export function processSync(params) {
+    const { sessionKey, deviceId, syncSeq, lastServerId, messages } = params;
+    const did = deviceId.trim().toUpperCase();
+    const idMappings = {};
+    // Idempotency check
+    const lastSeq = getLastSyncSeq(did);
+    if (syncSeq <= lastSeq) {
+        // Duplicate sync request — still return remote messages
+        const after = lastServerId ?? "";
+        const jsons = getMessagesAfterCursor(sessionKey, after, 50);
+        const remoteMessages = jsons.map((j) => JSON.parse(j));
+        return {
+            idMappings: {},
+            remoteMessages,
+            latestServerId: getLatestServerId(sessionKey),
+            hasMore: remoteMessages.length >= 50,
+            syncSeq,
+        };
+    }
+    // Store pushed messages (app's offline messages)
+    for (const msg of messages) {
+        const localId = typeof msg.id === "string" ? msg.id : "";
+        const fromCurrentUser = msg.isFromCurrentUser === true;
+        const msgRunId = typeof msg.runId === "string" ? msg.runId : null;
+        // Dedup: if user message with same run_id already exists (stored by POST /messages handler),
+        // reuse its serverId instead of creating a duplicate.
+        let serverId;
+        let skipInsert = false;
+        if (msgRunId && fromCurrentUser) {
+            const existing = findServerIdByRunAndSender(msgRunId, "user");
+            if (existing) {
+                serverId = existing;
+                skipInsert = true;
+            }
+            else {
+                serverId = generateServerId();
+            }
+        }
+        else {
+            serverId = generateServerId();
+        }
+        idMappings[localId] = serverId;
+        if (!skipInsert) {
+            const content = typeof msg.content === "string" ? msg.content : "";
+            const senderObj = msg.sender;
+            const senderName = fromCurrentUser
+                ? senderObj?.user?.name ?? "You"
+                : senderObj?.assistant?.name ?? "Claude";
+            const ts = typeof msg.timestamp === "string"
+                ? Date.parse(msg.timestamp)
+                : typeof msg.timestamp === "number"
+                    ? msg.timestamp
+                    : Date.now();
+            const seq = typeof msg.seq === "number" ? msg.seq : 0;
+            const status = typeof msg.status === "string" ? msg.status : "sent";
+            const enriched = { ...msg };
+            enriched.serverId = serverId;
+            insertMessage({
+                serverId,
+                sessionKey,
+                deviceId: did,
+                localId: localId || null,
+                senderType: fromCurrentUser ? "user" : "assistant",
+                senderName,
+                content,
+                timestampMs: Number.isFinite(ts) ? ts : Date.now(),
+                seq,
+                status,
+                isFromCurrentUser: fromCurrentUser,
+                messageJson: JSON.stringify(enriched),
+                runId: msgRunId,
+            });
+        }
+    }
+    // Update sync state
+    setLastSyncSeq(did, syncSeq);
+    // Pull remote messages
+    const after = lastServerId ?? "";
+    const jsons = getMessagesAfterCursor(sessionKey, after, 50);
+    const remoteMessages = jsons.map((j) => JSON.parse(j));
+    return {
+        idMappings,
+        remoteMessages,
+        latestServerId: getLatestServerId(sessionKey),
+        hasMore: remoteMessages.length >= 50,
+        syncSeq,
+    };
+}
+/** Bulk import for first-time migration. Rejects if session already has data. */
+export function importMessages(params) {
+    const { sessionKey, deviceId, messages } = params;
+    if (sessionExistsData(sessionKey)) {
+        throw new ConflictError("Session already has data — use POST /sync instead");
+    }
+    const idMappings = {};
+    let imported = 0;
+    for (const msg of messages) {
+        const localId = typeof msg.id === "string" ? msg.id : "";
+        const serverId = generateServerId();
+        idMappings[localId] = serverId;
+        const content = typeof msg.content === "string" ? msg.content : "";
+        const senderObj = msg.sender;
+        const isFromCurrentUser = msg.isFromCurrentUser === true;
+        const senderName = isFromCurrentUser
+            ? senderObj?.user?.name ?? "You"
+            : senderObj?.assistant?.name ?? "Claude";
+        const ts = typeof msg.timestamp === "string"
+            ? Date.parse(msg.timestamp)
+            : typeof msg.timestamp === "number"
+                ? msg.timestamp
+                : Date.now();
+        const seq = typeof msg.seq === "number" ? msg.seq : 0;
+        const status = typeof msg.status === "string" ? msg.status : "sent";
+        const enriched = { ...msg };
+        enriched.serverId = serverId;
+        insertMessage({
+            serverId,
+            sessionKey,
+            deviceId: deviceId.trim().toUpperCase(),
+            localId: localId || null,
+            senderType: isFromCurrentUser ? "user" : "assistant",
+            senderName,
+            content,
+            timestampMs: Number.isFinite(ts) ? ts : Date.now(),
+            seq,
+            status,
+            isFromCurrentUser,
+            messageJson: JSON.stringify(enriched),
+            runId: typeof msg.runId === "string" ? msg.runId : null,
+        });
+        imported += 1;
+    }
+    return { idMappings, imported };
+}
+/** Check if session has any messages in the DB (used by import guard). */
+function sessionExistsData(sessionKey) {
+    return getSessionMessageCount(sessionKey) > 0;
+}
+export function listSessions(deviceId) {
+    const rows = listSessionsByDevice(deviceId);
+    return rows.map(toSessionItem);
+}
+export function listAllSessionsList() {
+    const rows = listAllSessions();
+    return rows.map(toSessionItem);
+}
+function toSessionItem(r) {
+    return {
+        sessionKey: r.session_key,
+        deviceId: r.device_id,
+        title: r.title,
+        createdAt: r.created_at,
+        lastActiveAt: r.last_active_at,
+        messageCount: r.message_count,
+        latestServerId: r.latest_msg_id,
+    };
+}
+export class ConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConflictError";
+    }
+}

package/dist/src/sync/push-store.d.ts

@@ -0,0 +1,5 @@
+import type { StoredChatMessage } from "./translate.js";
+export declare function setPushStoreBaseDir(dir: string | null): void;
+export declare function appendPushMessage(sessionKey: string, msg: StoredChatMessage): string;
+export declare function readPushMessages(sessionKey: string): StoredChatMessage[];
+export declare function deletePushMessages(sessionKey: string): void;

package/dist/src/sync/push-store.js

@@ -0,0 +1,54 @@
+/**
+ * Minimal JSONL store for offline push messages (app-sent when server was unreachable).
+ * These are merged into sync pull responses alongside OpenClaw transcript messages.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { generateStandaloneServerId } from "./translate.js";
+let baseDir = null;
+export function setPushStoreBaseDir(dir) {
+    baseDir = dir;
+}
+function resolveBaseDir() {
+    if (baseDir)
+        return baseDir;
+    return join(homedir(), ".openclaw", "friday-next", "sync-push");
+}
+function pushFilePath(sessionKey) {
+    const safe = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return join(resolveBaseDir(), `${safe}.jsonl`);
+}
+export function appendPushMessage(sessionKey, msg) {
+    const serverId = generateStandaloneServerId();
+    const enriched = { ...msg, serverId };
+    const file = pushFilePath(sessionKey);
+    mkdirSync(dirname(file), { recursive: true });
+    appendFileSync(file, JSON.stringify(enriched) + "\n", "utf-8");
+    return serverId;
+}
+export function readPushMessages(sessionKey) {
+    const file = pushFilePath(sessionKey);
+    if (!existsSync(file))
+        return [];
+    const msgs = [];
+    const raw = readFileSync(file, "utf-8");
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            msgs.push(JSON.parse(line));
+        }
+        catch {
+            // skip corrupt
+        }
+    }
+    return msgs;
+}
+export function deletePushMessages(sessionKey) {
+    const file = pushFilePath(sessionKey);
+    try {
+        unlinkSync(file);
+    }
+    catch { /* gone */ }
+}

package/dist/src/sync/session-key.d.ts

@@ -0,0 +1,12 @@
+/** Parse Friday app session keys for transcript storage. */
+export type ParsedFridaySession = {
+    /** Raw app session key (verbatim from client). */
+    sessionKey: string;
+    /** Account id when present in key, else undefined (caller supplies from header). */
+    accountIdFromKey?: string;
+    /** Stable file id for JSONL (session uuid or legacy tail). */
+    sessionFileId: string;
+};
+export declare function sessionFileIdFromKey(sessionKey: string): string;
+export declare function parseFridaySessionKey(sessionKey: string): ParsedFridaySession;
+export declare function sessionBelongsToAccount(sessionKey: string, accountId: string): boolean;

package/dist/src/sync/session-key.js

@@ -0,0 +1,47 @@
+/** Parse Friday app session keys for transcript storage. */
+const ACCOUNT_SESSION_RE = /^friday:account:([^:]+):([^:]+)$/i;
+const DIRECT_SESSION_RE = /^friday:direct:[^:]+:([^:]+)$/i;
+export function sessionFileIdFromKey(sessionKey) {
+    const raw = sessionKey.trim();
+    const mAccount = raw.match(ACCOUNT_SESSION_RE);
+    if (mAccount?.[2])
+        return sanitizeSessionFileId(mAccount[2]);
+    const mDirect = raw.match(DIRECT_SESSION_RE);
+    if (mDirect?.[1])
+        return sanitizeSessionFileId(mDirect[1]);
+    return sanitizeSessionFileId(raw);
+}
+export function parseFridaySessionKey(sessionKey) {
+    const raw = sessionKey.trim();
+    const mAccount = raw.match(ACCOUNT_SESSION_RE);
+    if (mAccount?.[1] && mAccount[2]) {
+        return {
+            sessionKey: raw,
+            accountIdFromKey: mAccount[1],
+            sessionFileId: sanitizeSessionFileId(mAccount[2]),
+        };
+    }
+    const mDirect = raw.match(DIRECT_SESSION_RE);
+    if (mDirect?.[1]) {
+        return {
+            sessionKey: raw,
+            sessionFileId: sanitizeSessionFileId(mDirect[1]),
+        };
+    }
+    return {
+        sessionKey: raw,
+        sessionFileId: sanitizeSessionFileId(raw),
+    };
+}
+function sanitizeSessionFileId(id) {
+    const s = id.trim();
+    if (!s)
+        return "session";
+    return s.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 128);
+}
+export function sessionBelongsToAccount(sessionKey, accountId) {
+    const parsed = parseFridaySessionKey(sessionKey);
+    if (!parsed.accountIdFromKey)
+        return true;
+    return parsed.accountIdFromKey.toLowerCase() === accountId.trim().toLowerCase();
+}

package/dist/src/sync/sync-state.d.ts

@@ -0,0 +1,5 @@
+export declare function setSyncStatePath(path: string): void;
+export declare function getLastSyncSeq(deviceId: string): number;
+export declare function setLastSyncSeq(deviceId: string, seq: number): void;
+/** Vitest-only: reset in-memory cache and path. */
+export declare function resetSyncStateForTest(): void;

package/dist/src/sync/sync-state.js

@@ -0,0 +1,54 @@
+/**
+ * Per-device sync sequence tracking.
+ * Stored in ~/.openclaw/friday-next/sync-state.json
+ */
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname } from "node:path";
+let statePath = null;
+let stateCache = null;
+export function setSyncStatePath(path) {
+    statePath = path;
+    stateCache = null;
+}
+function resolvePath() {
+    if (statePath)
+        return statePath;
+    statePath = `${homedir()}/.openclaw/friday-next/sync-state.json`;
+    return statePath;
+}
+function loadState() {
+    if (stateCache)
+        return stateCache;
+    const path = resolvePath();
+    try {
+        if (existsSync(path)) {
+            stateCache = JSON.parse(readFileSync(path, "utf-8"));
+            return stateCache;
+        }
+    }
+    catch {
+        // corrupted — reset
+    }
+    stateCache = {};
+    return stateCache;
+}
+function saveState() {
+    const path = resolvePath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(stateCache ?? {}, null, 2), "utf-8");
+}
+export function getLastSyncSeq(deviceId) {
+    const state = loadState();
+    return state[deviceId.trim().toUpperCase()] ?? 0;
+}
+export function setLastSyncSeq(deviceId, seq) {
+    const state = loadState();
+    state[deviceId.trim().toUpperCase()] = seq;
+    saveState();
+}
+/** Vitest-only: reset in-memory cache and path. */
+export function resetSyncStateForTest() {
+    statePath = null;
+    stateCache = null;
+}

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

@@ -0,0 +1,13 @@
+import { type TranscriptEventKind } from "./transcript-store.js";
+export declare function resolveAccountIdForArchive(deviceId: string, headerAccountId?: string | null): string | null;
+export declare function archiveTranscriptEvent(params: {
+    deviceId: string;
+    sessionKey: string;
+    accountId?: string | null;
+    kind: TranscriptEventKind;
+    clientId?: string;
+    payload: Record<string, unknown>;
+    messageId?: string;
+    lamport?: number;
+    titleHint?: string;
+}): void;

package/dist/src/sync/transcript-archive.js

@@ -0,0 +1,37 @@
+import { resolveFridayNextConfig } from "../config.js";
+import { getHostOpenClawConfigSnapshot } from "../host-config.js";
+import { getFridayNextRuntime } from "../runtime.js";
+import { pairAccount, resolveAccountIdForDevice } from "./account-identity.js";
+import { appendEvent } from "./transcript-store.js";
+export function resolveAccountIdForArchive(deviceId, headerAccountId) {
+    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    const header = headerAccountId?.trim();
+    if (header)
+        return header;
+    const mapped = resolveAccountIdForDevice(cfg.historyDir, deviceId);
+    if (mapped)
+        return mapped;
+    const paired = pairAccount({ historyDir: cfg.historyDir, deviceId });
+    return paired.accountId;
+}
+export function archiveTranscriptEvent(params) {
+    try {
+        const accountId = params.accountId?.trim() ||
+            resolveAccountIdForArchive(params.deviceId.trim().toUpperCase(), null);
+        if (!accountId)
+            return;
+        appendEvent({
+            accountId,
+            sessionKey: params.sessionKey,
+            kind: params.kind,
+            clientId: params.clientId ?? "server",
+            payload: params.payload,
+            messageId: params.messageId,
+            lamport: params.lamport,
+            titleHint: params.titleHint,
+        });
+    }
+    catch {
+        // best-effort archive
+    }
+}

package/dist/src/sync/transcript-store.d.ts

@@ -0,0 +1,35 @@
+export type TranscriptEventKind = "user_message" | "assistant_message" | "thought_event" | "tool_event" | "outbound_text" | "outbound_media" | "sync_upsert" | "summary";
+export interface TranscriptEventInput {
+    eventId?: string;
+    clientId: string;
+    kind: TranscriptEventKind;
+    payload: Record<string, unknown>;
+    ts?: number;
+    lamportTs?: number;
+}
+export interface StoredTranscriptEvent extends TranscriptEventInput {
+    v: 1;
+    seq: number;
+    ts: number;
+    sessionKey: string;
+}
+export interface TranscriptSessionSummary {
+    sessionKey: string;
+    sessionId: string;
+    title?: string;
+    createdAt: number;
+    lastActiveAt: number;
+    lastSeq: number;
+    messageCount: number;
+}
+export declare function sessionIdFromSessionKey(sessionKey: string, accountId?: string): string;
+export declare class TranscriptStore {
+    private readonly historyDir;
+    constructor(historyDir?: string);
+    appendEvent(accountId: string, sessionKey: string, input: TranscriptEventInput): StoredTranscriptEvent;
+    appendEvents(accountId: string, sessionKey: string, inputs: TranscriptEventInput[]): StoredTranscriptEvent[];
+    readSince(accountId: string, sessionKey: string, sinceSeq?: number, limit?: number): StoredTranscriptEvent[];
+    listSessions(accountId: string): TranscriptSessionSummary[];
+    compact(accountId: string, sessionKey: string, keepLast: number): void;
+}
+export declare function getTranscriptStore(): TranscriptStore;