@syengup/friday-channel-next 0.0.35 → 0.0.38

package/dist/src/channel-actions.js

@@ -0,0 +1,101 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { sseEmitter } from "./sse/emitter.js";
+import { guessMimeType } from "./http/handlers/files.js";
+const DISCOVERY = {
+    actions: ["send", "channel-info", "channel-list"],
+    capabilities: ["text", "media"],
+};
+const CHANNEL_INFO_RESPONSE = {
+    ok: true,
+    channels: [{ id: "friday-next", name: "Friday Next", transport: "http+sse" }],
+};
+export function describeMessageActions() {
+    return DISCOVERY;
+}
+function pickString(params, keys) {
+    for (const k of keys) {
+        const v = params[k];
+        if (typeof v === "string" && v.trim())
+            return v.trim();
+    }
+    return "";
+}
+async function readMediaFile(mediaPath, ctx) {
+    if (ctx.mediaReadFile) {
+        try {
+            const buffer = await ctx.mediaReadFile(mediaPath);
+            if (buffer?.length) {
+                return { buffer, mimeType: guessMimeType(mediaPath) };
+            }
+        }
+        catch { /* fall through */ }
+    }
+    try {
+        const buffer = fs.readFileSync(mediaPath);
+        return { buffer, mimeType: guessMimeType(mediaPath) };
+    }
+    catch {
+        return null;
+    }
+}
+async function handleSend(ctx) {
+    const to = pickString(ctx.params, ["to", "target"]).toUpperCase();
+    const text = pickString(ctx.params, ["message", "text", "content"]);
+    const mediaPath = pickString(ctx.params, ["media", "path", "filePath", "fileUrl"]);
+    const caption = pickString(ctx.params, ["caption"]);
+    if (!to) {
+        return { ok: false, error: "Missing required param: to" };
+    }
+    const runId = crypto.randomUUID();
+    const sessionKey = ctx.sessionKey ?? undefined;
+    // Send text via SSE outbound
+    if (text) {
+        sseEmitter.broadcast({
+            type: "outbound",
+            data: {
+                op: "text",
+                ts: Date.now(),
+                runId,
+                deviceId: to,
+                sessionKey,
+                ctx: { text, to },
+            },
+        }, to, true);
+    }
+    // Send media via SSE outbound
+    if (mediaPath) {
+        const result = await readMediaFile(mediaPath, ctx);
+        if (result) {
+            const { saveMediaBuffer } = await import("openclaw/plugin-sdk/media-store");
+            const saved = await saveMediaBuffer(result.buffer, result.mimeType, "inbound");
+            if (saved.id) {
+                const publicUrl = `/friday-next/files/${encodeURIComponent(saved.id)}`;
+                sseEmitter.broadcast({
+                    type: "outbound",
+                    data: {
+                        op: "media",
+                        ts: Date.now(),
+                        runId,
+                        deviceId: to,
+                        sessionKey,
+                        audioAsVoice: false,
+                        caption: caption || text,
+                        mediaUrl: publicUrl,
+                        ctx: { to, text: caption || text, originalMediaUrl: mediaPath },
+                    },
+                }, to, true);
+            }
+        }
+    }
+    return { ok: true, runId, to };
+}
+export async function handleMessageAction(ctx) {
+    if (ctx.action === "channel-info" || ctx.action === "channel-list") {
+        return CHANNEL_INFO_RESPONSE;
+    }
+    if (ctx.action === "send") {
+        return handleSend(ctx);
+    }
+    return null;
+}

package/dist/src/channel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Friday Next Channel Plugin Definition.
+ *
+ * HTTP/SSE bridge for the Friday app; outbound sendText/sendMedia are forwarded as `outbound` SSE events.
+ */
+export declare const fridayNextChannelPlugin: any;

package/dist/src/channel.js

@@ -0,0 +1,248 @@
+/**
+ * Friday Next Channel Plugin Definition.
+ *
+ * HTTP/SSE bridge for the Friday app; outbound sendText/sendMedia are forwarded as `outbound` SSE events.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
+import { createFridayNextLogger } from "./logging.js";
+import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
+import { sseEmitter } from "./sse/emitter.js";
+import { describeMessageActions, handleMessageAction } from "./channel-actions.js";
+import { guessMimeType, resolveMediaAttachment } from "./http/handlers/files.js";
+import { resolveFridayDeviceIdForOutbound, resolveHistorySessionKeyForFridayDevice, } from "./friday-session.js";
+import { getLastFridayInboundAt } from "./friday-inbound-stats.js";
+const logger = createFridayNextLogger("channel");
+const CHANNEL_ID = "friday-next";
+function pickFirstString(source, keys) {
+    for (const key of keys) {
+        const val = source[key];
+        if (typeof val === "string" && val.trim())
+            return val.trim();
+    }
+    return undefined;
+}
+function resolveLocalMediaPath(mediaUrl, localRoots) {
+    if (path.isAbsolute(mediaUrl))
+        return mediaUrl;
+    const roots = localRoots ?? [process.cwd(), "/tmp"];
+    for (const root of roots) {
+        const candidate = path.join(root, mediaUrl);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return path.join(process.cwd(), mediaUrl);
+}
+const fridayConfigAdapter = {
+    listAccountIds: () => ["default"],
+    resolveAccount: () => ({ accountId: "default", enabled: true }),
+    defaultAccountId: () => "default",
+    isConfigured: () => true,
+    unconfiguredReason: () => null,
+    describeAccount: () => ({ accountId: "default", name: "Friday Next Channel", enabled: true }),
+};
+const fridayMeta = {
+    id: CHANNEL_ID,
+    label: "Friday Next",
+    selectionLabel: "Friday Next (Apple App)",
+    docsPath: "/channels/friday-next",
+    blurb: "Apple app channel with HTTP + SSE transparent OpenClaw proxy.",
+};
+const fridayCapabilities = {
+    chatTypes: ["direct"],
+    markdown: true,
+    media: true,
+    reactions: false,
+    edit: false,
+    threads: false,
+    polls: false,
+    typing: false,
+    readReceipts: false,
+};
+const fridayLifecycle = {
+    async onAccountConfigChanged() {
+        // No-op
+    },
+};
+const fridayStatus = {
+    buildAccountSnapshot: async (params) => {
+        const { account, runtime } = params;
+        const accountId = typeof account?.accountId === "string" && account.accountId.trim()
+            ? account.accountId.trim()
+            : "default";
+        const inbound = getLastFridayInboundAt();
+        const connected = sseEmitter.getConnectionCount() > 0;
+        return {
+            accountId,
+            name: typeof account?.name === "string" ? account.name : "Friday Next Channel",
+            enabled: account?.enabled !== false,
+            configured: true,
+            running: true,
+            connected,
+            lastInboundAt: inbound ?? runtime?.lastInboundAt ?? null,
+            mode: "http+sse",
+        };
+    },
+};
+export const fridayNextChannelPlugin = createChatChannelPlugin({
+    base: {
+        id: CHANNEL_ID,
+        meta: fridayMeta,
+        actions: {
+            describeMessageTool: describeMessageActions,
+            handleAction: handleMessageAction,
+        },
+        capabilities: fridayCapabilities,
+        defaults: {
+            queue: { debounceMs: 300 },
+        },
+        config: fridayConfigAdapter,
+        lifecycle: fridayLifecycle,
+        status: fridayStatus,
+        bindings: {
+            compileConfiguredBinding: () => null,
+            matchInboundConversation: () => null,
+            resolveCommandConversation: () => null,
+        },
+        conversationBindings: {
+            supportsCurrentConversationBinding: false,
+        },
+        messaging: {
+            normalizeTarget: (raw) => {
+                const trimmed = raw?.trim() ?? "";
+                return trimmed || "friday-next";
+            },
+            targetResolver: {
+                hint: "Use the deviceId (e.g. your device identifier).",
+                resolveTarget: async (ctx) => {
+                    return { to: ctx.normalized };
+                },
+            },
+            parseExplicitTarget: () => ({ to: "friday-next" }),
+            formatTargetDisplay: ({ display }) => display || "Friday Next",
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        sendText: async (ctx) => {
+            const text = ctx.text ?? "";
+            const rawCtx = ctx;
+            const deviceId = resolveFridayDeviceIdForOutbound(ctx.to, rawCtx);
+            const runIdFromCtx = pickFirstString(rawCtx, [
+                "parentRunId",
+                "requesterRunId",
+                "originRunId",
+                "runId",
+            ]);
+            const runId = runIdFromCtx ?? sseEmitter.getLastRunIdForDevice(deviceId) ?? undefined;
+            const sessionKey = pickFirstString(rawCtx, ["requesterSessionKey", "sessionKey"]) ??
+                resolveHistorySessionKeyForFridayDevice(deviceId);
+            const conn = sseEmitter.getConnection(deviceId);
+            const ts = new Date().toISOString();
+            logger.info(`[SEND_TEXT] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} textLen=${text.length} online=${!!conn}`);
+            if (conn) {
+                sseEmitter.broadcast({
+                    type: "outbound",
+                    data: {
+                        op: "text",
+                        ts: Date.now(),
+                        runId,
+                        deviceId,
+                        sessionKey,
+                        ctx: {
+                            text,
+                            to: ctx.to,
+                            mediaUrl: ctx.mediaUrl,
+                            audioAsVoice: ctx.audioAsVoice,
+                        },
+                    },
+                }, deviceId, true);
+            }
+            return {
+                channel: CHANNEL_ID,
+                messageId: crypto.randomUUID(),
+                timestamp: Date.now(),
+            };
+        },
+        sendMedia: async (ctx) => {
+            const rawCtx = ctx;
+            const deviceId = resolveFridayDeviceIdForOutbound(ctx.to, rawCtx);
+            const mediaUrl = ctx.mediaUrl;
+            const runIdFromCtx = pickFirstString(rawCtx, [
+                "parentRunId",
+                "requesterRunId",
+                "originRunId",
+                "runId",
+            ]);
+            const runId = runIdFromCtx ?? sseEmitter.getLastRunIdForDevice(deviceId) ?? undefined;
+            const sessionKey = pickFirstString(rawCtx, ["requesterSessionKey", "sessionKey"]) ??
+                resolveHistorySessionKeyForFridayDevice(deviceId);
+            const audioAsVoice = ctx.audioAsVoice === true;
+            const caption = ctx.text ?? "";
+            if (!mediaUrl) {
+                return {
+                    channel: CHANNEL_ID,
+                    messageId: crypto.randomUUID(),
+                    timestamp: Date.now(),
+                };
+            }
+            let buffer = null;
+            if (ctx.mediaReadFile) {
+                try {
+                    buffer = await ctx.mediaReadFile(mediaUrl);
+                }
+                catch {
+                    // fall through to fs
+                }
+            }
+            if (!buffer) {
+                try {
+                    const resolvedPath = resolveLocalMediaPath(mediaUrl, ctx.mediaLocalRoots);
+                    buffer = fs.readFileSync(resolvedPath);
+                }
+                catch {
+                    // file not found — skip media
+                }
+            }
+            if (buffer) {
+                const mimeType = guessMimeType(mediaUrl);
+                const saved = await saveMediaBuffer(buffer, mimeType, "inbound");
+                if (saved.id) {
+                    const fileUrl = `/friday-next/files/${encodeURIComponent(saved.id)}`;
+                    const resolved = resolveMediaAttachment(fileUrl);
+                    const publicUrl = resolved ? resolved.url : fileUrl;
+                    const conn = sseEmitter.getConnection(deviceId);
+                    const ts = new Date().toISOString();
+                    logger.info(`[SEND_MEDIA] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} audioAsVoice=${audioAsVoice} url=${publicUrl} online=${!!conn}`);
+                    if (conn) {
+                        sseEmitter.broadcast({
+                            type: "outbound",
+                            data: {
+                                op: "media",
+                                ts: Date.now(),
+                                runId,
+                                deviceId,
+                                sessionKey,
+                                audioAsVoice,
+                                caption,
+                                mediaUrl: publicUrl,
+                                ctx: {
+                                    to: ctx.to,
+                                    text: caption,
+                                    originalMediaUrl: mediaUrl,
+                                },
+                            },
+                        }, deviceId, true);
+                    }
+                }
+            }
+            return {
+                channel: CHANNEL_ID,
+                messageId: crypto.randomUUID(),
+                timestamp: Date.now(),
+            };
+        },
+    },
+});

package/dist/src/collect-message-media-paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Extract filesystem / Friday file URLs from message tool result or params (nested JSON).
+ */
+export declare function collectMediaPathsFromToolResult(raw: unknown, acc?: Set<string>): Set<string>;
+/**
+ * Scan the same tool `text` string that is sent on SSE (often JSON.stringify(result)).
+ * Inner nested JSON uses escaped quotes (\"), so keys like "mediaUrl" may not match
+ * naive JSON walks on the outer value. Unescaped absolute paths still appear verbatim
+ * (e.g. /Users/.../file.md) and are extracted here.
+ */
+export declare function extractLocalPathsFromToolTextBlob(s: string): Set<string>;

package/dist/src/collect-message-media-paths.js

@@ -0,0 +1,143 @@
+/**
+ * Extract filesystem / Friday file URLs from message tool result or params (nested JSON).
+ */
+/** Bare path string when JSON.parse fails (e.g. not JSON); not http(s) URLs. */
+function looksLikeLocalFilePath(v) {
+    const t = v.trim();
+    if (t.length < 2 || /^https?:\/\//i.test(t))
+        return false;
+    const abs = t.startsWith("/") ||
+        t.startsWith("~/") ||
+        t.startsWith("~\\") ||
+        /^file:/i.test(t) ||
+        /^[a-zA-Z]:[\\/]/.test(t);
+    if (!abs)
+        return false;
+    const lastSeg = t.split(/[/\\]/).filter(Boolean).pop() ?? "";
+    return lastSeg.includes(".");
+}
+export function collectMediaPathsFromToolResult(raw, acc) {
+    const out = acc ?? new Set();
+    const add = (s) => {
+        const t = s.trim();
+        if (t.length > 0)
+            out.add(t);
+    };
+    const visit = (v) => {
+        if (v == null)
+            return;
+        if (typeof v === "string") {
+            try {
+                visit(JSON.parse(v));
+            }
+            catch {
+                if (looksLikeLocalFilePath(v))
+                    add(v);
+            }
+            return;
+        }
+        if (typeof v !== "object")
+            return;
+        if (Array.isArray(v)) {
+            for (const x of v)
+                visit(x);
+            return;
+        }
+        const o = v;
+        const mu = o.mediaUrls;
+        if (Array.isArray(mu))
+            for (const x of mu)
+                if (typeof x === "string")
+                    add(x);
+        const m = o.mediaUrl;
+        if (typeof m === "string")
+            add(m);
+        const audioPath = o.audioPath;
+        if (typeof audioPath === "string")
+            add(audioPath);
+        const media = o.media;
+        if (typeof media === "string")
+            add(media);
+        else if (media && typeof media === "object" && !Array.isArray(media))
+            visit(media);
+        const filePath = o.filePath;
+        if (typeof filePath === "string")
+            add(filePath);
+        for (const k of ["details", "result", "content", "text", "body", "message", "arguments", "args"]) {
+            if (o[k] !== undefined)
+                visit(o[k]);
+        }
+        for (const val of Object.values(o)) {
+            if (typeof val !== "string")
+                continue;
+            const s = val.trimStart();
+            if (s.startsWith("{") || s.startsWith("["))
+                visit(val);
+        }
+    };
+    visit(raw);
+    return out;
+}
+/**
+ * Scan the same tool `text` string that is sent on SSE (often JSON.stringify(result)).
+ * Inner nested JSON uses escaped quotes (\"), so keys like "mediaUrl" may not match
+ * naive JSON walks on the outer value. Unescaped absolute paths still appear verbatim
+ * (e.g. /Users/.../file.md) and are extracted here.
+ */
+export function extractLocalPathsFromToolTextBlob(s) {
+    const out = new Set();
+    const add = (raw) => {
+        const t = raw.trim();
+        if (t.length > 0 && looksLikeLocalFilePath(t))
+            out.add(t);
+    };
+    if (!s || s.length < 8)
+        return out;
+    /**
+     * After JSON.stringify(toolResult), nested JSON appears as key\"\":\"value\" in the outer string,
+     * e.g. mediaUrl\":\"/Users/me/file.md\" — not \"mediaUrl\".
+     */
+    for (const m of s.matchAll(/mediaUrl\\":\\"([^"\\]+)\\"/gi)) {
+        add(m[1] ?? "");
+    }
+    for (const m of s.matchAll(/media\\":\\"([^"\\]+)\\"/gi)) {
+        add(m[1] ?? "");
+    }
+    for (const m of s.matchAll(/filePath\\":\\"([^"\\]+)\\"/gi)) {
+        add(m[1] ?? "");
+    }
+    // "mediaUrls":["/a","/b"] → in outer stringify: mediaUrls\":[\"/a\",\"/b\"]
+    for (const m of s.matchAll(/mediaUrls\\":\[((?:\\"[^"\\]+\\",?)+)\]/gi)) {
+        const inner = m[1] ?? "";
+        for (const q of inner.matchAll(/\\"([^"\\]+)\\"/g)) {
+            add(q[1] ?? "");
+        }
+    }
+    // Unescaped JSON fragments (raw object / pretty-print)
+    for (const m of s.matchAll(/"mediaUrl"\s*:\s*"([^"\\]+)"/gi)) {
+        add(m[1] ?? "");
+    }
+    for (const m of s.matchAll(/"mediaUrls"\s*:\s*\[([\s\S]*?)\]/gi)) {
+        const inner = m[1] ?? "";
+        for (const q of inner.matchAll(/"([^"\\]*)"/g)) {
+            add(q[1] ?? "");
+        }
+    }
+    // Verbatim /Users/.../file.ext (stop before quote or backslash — avoids eating JSON commas)
+    for (const m of s.matchAll(/(\/Users\/[^"\\]+\.[A-Za-z0-9]{1,24})/g)) {
+        add(m[1]);
+    }
+    for (const m of s.matchAll(/(\/private\/var\/[^"\\]+\.[A-Za-z0-9]{1,24})/g)) {
+        add(m[1]);
+    }
+    for (const m of s.matchAll(/(\/tmp\/[^"\\]+\.[A-Za-z0-9]{1,24})/g)) {
+        add(m[1]);
+    }
+    for (const m of s.matchAll(/(\/home\/[^"\\]+\.[A-Za-z0-9]{1,24})/g)) {
+        add(m[1]);
+    }
+    for (const m of s.matchAll(/([A-Za-z]:\\[^"\\]+\.[A-Za-z0-9]{1,24})/g)) {
+        add(m[1]);
+    }
+    return out;
+}

package/dist/src/config.d.ts

@@ -0,0 +1,15 @@
+export type FridayNextLogLevel = "debug" | "info" | "warn" | "error";
+export type FridayNextConfig = {
+    channelId: "friday-next";
+    pathPrefix: string;
+    transport: string;
+    historyLimit: number;
+    historyDir: string;
+    logLevel: FridayNextLogLevel;
+    authToken: string;
+    corsEnabled: boolean;
+    corsAllowOrigin: string;
+    sseKeepaliveSec: number;
+    sseBacklogPerDevice: number;
+};
+export declare function resolveFridayNextConfig(cfg: unknown): FridayNextConfig;

package/dist/src/config.js

@@ -0,0 +1,39 @@
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asString(value, fallback) {
+    return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function asNumber(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    return Math.max(min, Math.min(max, Math.floor(value)));
+}
+function asBool(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+export function resolveFridayNextConfig(cfg) {
+    const root = asObject(cfg);
+    const channels = asObject(root.channels);
+    const section = asObject(channels["friday-next"]);
+    const sse = asObject(section.sse);
+    const cors = asObject(section.cors);
+    const authToken = asString(asObject(root.gateway).auth && asObject(asObject(root.gateway).auth).token, "") ||
+        asString(section.authToken, "") ||
+        asString(process.env.FRIDAY_NEXT_AUTH_TOKEN, "");
+    return {
+        channelId: "friday-next",
+        pathPrefix: asString(section.pathPrefix, "/friday-next"),
+        transport: asString(section.transport, "http+sse"),
+        historyLimit: asNumber(section.historyLimit, 25, 1, 200),
+        historyDir: asString(section.historyDir, `${process.env.HOME ?? ""}/.openclaw/friday-next/history`),
+        logLevel: asString(section.logLevel, "info"),
+        authToken,
+        corsEnabled: asBool(cors.enabled, false),
+        corsAllowOrigin: asString(cors.allowOrigin, "*"),
+        sseKeepaliveSec: asNumber(sse.keepaliveSec, 30, 5, 120),
+        sseBacklogPerDevice: asNumber(sse.backlogPerDevice, 200, 0, 1000),
+    };
+}

package/dist/src/friday-inbound-stats.d.ts

@@ -0,0 +1,2 @@
+export declare function touchFridayInbound(): void;
+export declare function getLastFridayInboundAt(): number | null;

package/dist/src/friday-inbound-stats.js

@@ -0,0 +1,8 @@
+/** Last accepted POST /friday-next/messages timestamp for Control UI channel health. */
+let lastInboundAtMs = null;
+export function touchFridayInbound() {
+    lastInboundAtMs = Date.now();
+}
+export function getLastFridayInboundAt() {
+    return lastInboundAtMs;
+}

package/dist/src/friday-session.d.ts

@@ -0,0 +1,40 @@
+/** Vitest-only: clears per-run reasoning text cache used for incremental `delta` rewriting. */
+export declare function resetThinkingStreamAccumStateForTest(): void;
+/** Vitest-only */
+export declare function resetOpenClawRunDeviceMappingForTest(): void;
+/** Parse deviceId from a Friday Next channel sessionKey (friday-{deviceId} or legacy agent:main:friday-*). */
+export declare function deviceIdFromSessionKey(sessionKey: string): string | null;
+export declare function registerFridaySessionDeviceMapping(rawSessionKey: string, deviceId: string): void;
+/** In-process fallback for tool hooks / telemetry (same idea as outbound sole-device). */
+export declare function getLastRegisteredFridayDeviceId(): string | undefined;
+/** Resolve device for gateway `sessionKey` (friday-style or last POST mapping). */
+export declare function resolveFridayDeviceIdForSessionKey(sessionKey: string): string | null;
+/** Tool hooks / core may pass gateway store keys; resolve app's POST sessionKey. */
+export declare function resolveFridayHistorySessionKey(gatewaySessionKey: string): string | undefined;
+/** Resolve latest known app sessionKey by deviceId (from last POST). */
+export declare function latestHistorySessionKeyForDeviceId(deviceId: string): string | undefined;
+/**
+ * Session key hint for outbound delivery when ctx has no `sessionKey` (typical cron).
+ * Uses in-process mapping only (no plugin-side history files).
+ */
+export declare function resolveHistorySessionKeyForFridayDevice(deviceId: string): string | undefined;
+type ForwardAgentEventArgs = {
+    runId: string;
+    seq?: number;
+    ts?: number;
+    stream: string;
+    data: Record<string, unknown>;
+    sessionKey?: string;
+};
+/**
+ * Resolve the real device UUID for Friday outbound (`sendText` / `sendMedia`).
+ */
+export declare function resolveFridayDeviceIdForOutbound(to: string | undefined, rawCtx?: Record<string, unknown>): string;
+/**
+ * Forward global OpenClaw agent events to the Friday SSE connection (transparent).
+ *
+ * Asynchronous follow-up runs still reach the device via `getLastRunIdForDevice` when the parent run
+ * is no longer tracked.
+ */
+export declare function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void;
+export {};