@syengup/friday-channel-next 0.0.1

package/src/agent/media-bridge.ts

@@ -0,0 +1,23 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+
+export async function saveInboundMediaBuffer(
+  buffer: Buffer,
+  mimeType: string,
+): Promise<{ id: string; path: string }> {
+  try {
+    const sdk = await import("openclaw/plugin-sdk/media-store");
+    const saved = await sdk.saveMediaBuffer(buffer, mimeType, "inbound");
+    if (saved?.id && saved?.path) return { id: saved.id, path: saved.path };
+  } catch {
+    // fallback for tests or stripped runtime
+  }
+  const id = crypto.randomUUID();
+  const dir = path.join(os.tmpdir(), "friday-next-media");
+  fs.mkdirSync(dir, { recursive: true });
+  const p = path.join(dir, id);
+  fs.writeFileSync(p, buffer);
+  return { id, path: p };
+}

package/src/agent-forward-runtime.ts

@@ -0,0 +1,30 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
+
+export type FridayAgentForwardRuntime = {
+  resolveStorePath: (store?: string, opts?: { agentId?: string }) => string;
+  loadSessionStore: (
+    path: string,
+    options?: { skipCache?: boolean; maintenanceConfig?: unknown; clone?: boolean },
+  ) => Record<string, unknown>;
+  getConfig: () => unknown;
+};
+
+let forwardRuntime: FridayAgentForwardRuntime | null = null;
+
+/** Called from `registerFull` so terminal lifecycle forwards can read `sessions.json` after persist. */
+export function setFridayAgentForwardRuntime(api: OpenClawPluginApi): void {
+  forwardRuntime = {
+    resolveStorePath: api.runtime.agent.session.resolveStorePath,
+    loadSessionStore: api.runtime.agent.session.loadSessionStore,
+    getConfig: () => api.runtime.config.current(),
+  };
+}
+
+export function getFridayAgentForwardRuntime(): FridayAgentForwardRuntime | null {
+  return forwardRuntime;
+}
+
+/** Vitest-only */
+export function resetFridayAgentForwardRuntimeForTest(): void {
+  forwardRuntime = null;
+}

package/src/agent-run-context-bridge.ts

@@ -0,0 +1,32 @@
+/**
+ * Read OpenClaw agent run context (sessionKey, …) from the same global singleton
+ * as `src/infra/agent-events.ts` (`Symbol.for("openclaw.agentEvents.state")`).
+ *
+ * When a run is hidden from Control UI, `emitAgentEvent` strips `sessionKey` from
+ * the listener payload, but `runContextById` still holds it — we need that for
+ * Friday SSE and tool hooks without importing the `openclaw` package from this folder.
+ */
+
+const AGENT_EVENT_STATE_KEY = Symbol.for("openclaw.agentEvents.state");
+
+export type OpenClawAgentRunContextBridge = {
+  sessionKey?: string;
+  isControlUiVisible?: boolean;
+};
+
+type AgentEventStateLike = {
+  runContextById: Map<string, OpenClawAgentRunContextBridge>;
+};
+
+function getAgentEventState(): AgentEventStateLike | undefined {
+  const raw = (globalThis as Record<PropertyKey, unknown>)[AGENT_EVENT_STATE_KEY];
+  if (!raw || typeof raw !== "object") return undefined;
+  const runContextById = (raw as { runContextById?: unknown }).runContextById;
+  if (!(runContextById instanceof Map)) return undefined;
+  return { runContextById };
+}
+
+export function getOpenClawAgentRunContext(runId: string): OpenClawAgentRunContextBridge | undefined {
+  if (!runId) return undefined;
+  return getAgentEventState()?.runContextById.get(runId);
+}

package/src/channel-actions.ts

@@ -0,0 +1,129 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { sseEmitter } from "./sse/emitter.js";
+import { guessMimeType } from "./http/handlers/files.js";
+
+type MessageActionCtx = {
+  action: string;
+  params: Record<string, unknown>;
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  sessionKey?: string | null;
+  requesterSenderId?: string | null;
+};
+
+const DISCOVERY = {
+  actions: ["send", "channel-info", "channel-list"] as const,
+  capabilities: ["text", "media"] as const,
+};
+
+const CHANNEL_INFO_RESPONSE = {
+  ok: true as const,
+  channels: [{ id: "friday-next", name: "Friday Next", transport: "http+sse" }],
+};
+
+export function describeMessageActions() {
+  return DISCOVERY;
+}
+
+function pickString(params: Record<string, unknown>, keys: string[]): string {
+  for (const k of keys) {
+    const v = params[k];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return "";
+}
+
+async function readMediaFile(
+  mediaPath: string,
+  ctx: MessageActionCtx,
+): Promise<{ buffer: Buffer; mimeType: string } | null> {
+  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: MessageActionCtx): Promise<unknown> {
+  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: MessageActionCtx): Promise<unknown> {
+  if (ctx.action === "channel-info" || ctx.action === "channel-list") {
+    return CHANNEL_INFO_RESPONSE;
+  }
+  if (ctx.action === "send") {
+    return handleSend(ctx);
+  }
+  return null;
+}

package/src/channel.ts

@@ -0,0 +1,284 @@
+/**
+ * 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 type { ChannelAccountSnapshot } from "openclaw/plugin-sdk/status-helpers";
+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 CHANNEL_ID = "friday-next" as const;
+
+function pickFirstString(source: Record<string, unknown>, keys: string[]): string | undefined {
+  for (const key of keys) {
+    const val = source[key];
+    if (typeof val === "string" && val.trim()) return val.trim();
+  }
+  return undefined;
+}
+
+function resolveLocalMediaPath(mediaUrl: string, localRoots?: string[]): string {
+  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"] as const,
+  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: {
+    account: { accountId?: string; name?: string; enabled?: boolean };
+    runtime?: ChannelAccountSnapshot;
+  }): Promise<ChannelAccountSnapshot> => {
+    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: string) => {
+        const trimmed = raw?.trim() ?? "";
+        return trimmed || "friday-next";
+      },
+      targetResolver: {
+        hint: "Use the deviceId (e.g. your device identifier).",
+        resolveTarget: async (ctx: any) => {
+          return { to: ctx.normalized };
+        },
+      },
+      parseExplicitTarget: () => ({ to: "friday-next" }),
+      formatTargetDisplay: ({ display }: any) => display || "Friday Next",
+    },
+  },
+  outbound: {
+    deliveryMode: "direct" as const,
+    sendText: async (ctx: any) => {
+        const text = ctx.text ?? "";
+        const rawCtx = ctx as unknown as Record<string, unknown>;
+        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();
+        console.error(
+          `[Friday-OUT] [${ts}] [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: any) => {
+        const rawCtx = ctx as unknown as Record<string, unknown>;
+        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: Buffer | null = 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();
+            console.error(
+              `[Friday-OUT] [${ts}] [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/src/collect-message-media-paths.ts

@@ -0,0 +1,132 @@
+/**
+ * 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: string): boolean {
+  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: unknown, acc?: Set<string>): Set<string> {
+  const out = acc ?? new Set<string>();
+  const add = (s: string) => {
+    const t = s.trim();
+    if (t.length > 0) out.add(t);
+  };
+  const visit = (v: unknown): void => {
+    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 as Record<string, unknown>;
+    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: string): Set<string> {
+  const out = new Set<string>();
+  const add = (raw: string) => {
+    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/src/config.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { resolveFridayNextConfig } from "./config.js";
+
+describe("resolveFridayNextConfig", () => {
+  it("uses defaults", () => {
+    const cfg = resolveFridayNextConfig({});
+    expect(cfg.channelId).toBe("friday-next");
+    expect(cfg.pathPrefix).toBe("/friday-next");
+    expect(cfg.sseKeepaliveSec).toBe(30);
+  });
+
+  it("prefers gateway auth token over channel token", () => {
+    const cfg = resolveFridayNextConfig({
+      gateway: { auth: { token: "g1" } },
+      channels: { "friday-next": { authToken: "c1" } },
+    });
+    expect(cfg.authToken).toBe("g1");
+  });
+
+  it("clamps numeric settings to schema bounds", () => {
+    const cfg = resolveFridayNextConfig({
+      channels: {
+        "friday-next": {
+          historyLimit: 9999,
+          sse: { keepaliveSec: 1, backlogPerDevice: -2 },
+        },
+      },
+    });
+    expect(cfg.historyLimit).toBe(200);
+    expect(cfg.sseKeepaliveSec).toBe(5);
+    expect(cfg.sseBacklogPerDevice).toBe(0);
+  });
+});