@syengup/friday-channel-next 0.1.24 → 0.1.26

package/dist/src/http/handlers/history-messages.js

@@ -9,6 +9,7 @@
  * `runtime.subagent.getSessionMessages`), which already resolves the active
  * branch and compaction, then normalizes each raw message into a stable DTO.
  */
+import { fileURLToPath } from "node:url";
 import { getFridayNextRuntime } from "../../runtime.js";
 import { extractBearerToken } from "../middleware/auth.js";
 import { normalizeHistoryMessages } from "../../history/normalize-message.js";
@@ -17,6 +18,28 @@ import { resolveMediaAttachment } from "./files.js";
 import { readSessionUsageSnapshotFromStore } from "../../session-usage-store.js";
 const DEFAULT_LIMIT = 200;
 const MAX_LIMIT = 1000;
+/**
+ * For an `images[].url` produced from a `[media attached: …]` marker: returns the
+ * server-local filesystem path to resolve (`file://…` or a bare absolute path), or
+ * null to leave the image untouched. Already-served `/friday-next/files/…` URLs and
+ * remote `http(s)://` / `data:` URLs are NOT local paths — never feed them to
+ * `resolveMediaAttachment` (it would mis-treat them as paths and break valid URLs).
+ */
+function serverLocalPathForImageUrl(url) {
+    if (url.startsWith("file://")) {
+        try {
+            return fileURLToPath(url);
+        }
+        catch {
+            return url.slice("file://".length);
+        }
+    }
+    if (url.startsWith("/friday-next/files/"))
+        return null;
+    if (url.startsWith("/"))
+        return url;
+    return null;
+}
 function resolveSubagentApi() {
     try {
         const runtime = getFridayNextRuntime();
@@ -75,16 +98,34 @@ export async function handleHistoryMessages(req, res) {
     // (copies the file into the plugin's attachments/ dir — the same mechanism the
     // live deliver path uses), then drop the raw paths from the wire.
     for (const message of messages) {
-        if (!message.mediaPaths?.length)
-            continue;
-        const resolved = message.mediaPaths
-            .map((p) => resolveMediaAttachment(p))
-            .filter((r) => Boolean(r))
-            .map((r) => ({ url: r.url, filename: r.fileName }));
-        if (resolved.length) {
-            message.images = [...(message.images ?? []), ...resolved];
+        if (message.mediaPaths?.length) {
+            const resolved = message.mediaPaths
+                .map((p) => resolveMediaAttachment(p))
+                .filter((r) => Boolean(r))
+                .map((r) => ({ url: r.url, filename: r.fileName }));
+            if (resolved.length) {
+                message.images = [...(message.images ?? []), ...resolved];
+            }
+            delete message.mediaPaths;
+        }
+        // User attachments arrive as `[media attached: file://<server-path>]` markers,
+        // which normalize-message extracts into images[].url as a RAW server-local path.
+        // Unlike MEDIA: paths (resolved above), these were never copied into the file
+        // store, so the app would try to load a path that only exists on the gateway host
+        // and the attachment bubble is lost on history sync. Resolve them the same way.
+        if (message.images?.length) {
+            message.images = message.images.map((img) => {
+                if (!img.url || img.data)
+                    return img;
+                const local = serverLocalPathForImageUrl(img.url);
+                if (!local)
+                    return img;
+                const resolved = resolveMediaAttachment(local);
+                if (!resolved)
+                    return img;
+                return { ...img, url: resolved.url, filename: img.filename ?? resolved.fileName };
+            });
         }
-        delete message.mediaPaths;
     }
     const sessionId = resolveSessionId(sessionKey);
     // Cumulative session-usage snapshot (model + context window/used) read from the

package/dist/src/http/handlers/history-sessions.js

@@ -110,10 +110,14 @@ function readAgentSessions(agentId) {
             continue;
         const entry = rawEntry;
         const canonicalKey = toCanonicalSessionKey(agentId, storeKey);
-        // Drop internal/system sessions and subagent links.
+        // Drop internal/system sessions and subagent links. We key only on
+        // `spawnedBy`/`subagentRole` (plus the `subagent:` prefix in
+        // isInternalSessionKey) — NOT on `parentSessionKey`, which real user
+        // conversations (e.g. webchat sessions branched off another session) also
+        // carry and which would otherwise be wrongly excluded from the sidebar.
         if (isInternalSessionKey(canonicalKey, storeKey))
             continue;
-        if (entry.spawnedBy || entry.subagentRole || entry.parentSessionKey)
+        if (entry.spawnedBy || entry.subagentRole)
             continue;
         // Drop archived/empty sessions (transcript moved away or never written).
         if (!hasLiveTranscript(entry, storePath))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",

package/src/http/handlers/history-messages.test.ts

@@ -170,6 +170,39 @@ describe("handleHistoryMessages", () => {
     expect(body.messages[0].text).toBe("from app");
   });
 
+  it("resolves user [media attached: file://] markers into downloadable /friday-next/files URLs", async () => {
+    // The server-local source the marker points at (only exists on the gateway host).
+    const srcDir = fs.mkdtempSync(path.join(os.tmpdir(), "friday-inbound-"));
+    const srcFile = path.join(srcDir, "ce1ff405-28ad-48b9-b4a7-4f2228d77649.jpg");
+    fs.writeFileSync(srcFile, Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10]));
+    const file = writeTranscript("media.jsonl", [
+      {
+        type: "message",
+        id: "u1",
+        message: {
+          role: "user",
+          content: `你见过这个可乐吗？\n\n[media attached: file://${srcFile}]`,
+        },
+      },
+    ]);
+    setForward({ "agent:main:main": { sessionId: "s", sessionFile: file } });
+
+    const res = new MockRes();
+    await handleHistoryMessages(
+      makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH),
+      res as any,
+    );
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    const userMsg = body.messages.find((m: any) => m.role === "user");
+    expect(userMsg.images?.length).toBe(1);
+    // The raw server-local file:// path must be resolved to a gateway-served URL the
+    // app can actually download — otherwise the attachment bubble is lost on history sync.
+    expect(userMsg.images[0].url.startsWith("file://")).toBe(false);
+    expect(userMsg.images[0].url.startsWith("/friday-next/files/")).toBe(true);
+    fs.rmSync(srcDir, { recursive: true, force: true });
+  });
+
   it("falls back to getSessionMessages when the transcript is not on disk", async () => {
     setForward({}); // no entry → disk read yields nothing
     setRuntime(async () => ({

package/src/http/handlers/history-messages.ts

@@ -11,6 +11,7 @@
  */
 
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { fileURLToPath } from "node:url";
 import { getFridayNextRuntime } from "../../runtime.js";
 import { extractBearerToken } from "../middleware/auth.js";
 import { normalizeHistoryMessages } from "../../history/normalize-message.js";
@@ -28,6 +29,26 @@ type SubagentSessionApi = {
   }) => Promise<{ messages?: unknown[] }>;
 };
 
+/**
+ * For an `images[].url` produced from a `[media attached: …]` marker: returns the
+ * server-local filesystem path to resolve (`file://…` or a bare absolute path), or
+ * null to leave the image untouched. Already-served `/friday-next/files/…` URLs and
+ * remote `http(s)://` / `data:` URLs are NOT local paths — never feed them to
+ * `resolveMediaAttachment` (it would mis-treat them as paths and break valid URLs).
+ */
+function serverLocalPathForImageUrl(url: string): string | null {
+  if (url.startsWith("file://")) {
+    try {
+      return fileURLToPath(url);
+    } catch {
+      return url.slice("file://".length);
+    }
+  }
+  if (url.startsWith("/friday-next/files/")) return null;
+  if (url.startsWith("/")) return url;
+  return null;
+}
+
 function resolveSubagentApi(): SubagentSessionApi | undefined {
   try {
     const runtime = getFridayNextRuntime();
@@ -95,15 +116,32 @@ export async function handleHistoryMessages(
   // (copies the file into the plugin's attachments/ dir — the same mechanism the
   // live deliver path uses), then drop the raw paths from the wire.
   for (const message of messages) {
-    if (!message.mediaPaths?.length) continue;
-    const resolved = message.mediaPaths
-      .map((p) => resolveMediaAttachment(p))
-      .filter((r): r is NonNullable<typeof r> => Boolean(r))
-      .map((r) => ({ url: r.url, filename: r.fileName }));
-    if (resolved.length) {
-      message.images = [...(message.images ?? []), ...resolved];
+    if (message.mediaPaths?.length) {
+      const resolved = message.mediaPaths
+        .map((p) => resolveMediaAttachment(p))
+        .filter((r): r is NonNullable<typeof r> => Boolean(r))
+        .map((r) => ({ url: r.url, filename: r.fileName }));
+      if (resolved.length) {
+        message.images = [...(message.images ?? []), ...resolved];
+      }
+      delete message.mediaPaths;
+    }
+
+    // User attachments arrive as `[media attached: file://<server-path>]` markers,
+    // which normalize-message extracts into images[].url as a RAW server-local path.
+    // Unlike MEDIA: paths (resolved above), these were never copied into the file
+    // store, so the app would try to load a path that only exists on the gateway host
+    // and the attachment bubble is lost on history sync. Resolve them the same way.
+    if (message.images?.length) {
+      message.images = message.images.map((img) => {
+        if (!img.url || img.data) return img;
+        const local = serverLocalPathForImageUrl(img.url);
+        if (!local) return img;
+        const resolved = resolveMediaAttachment(local);
+        if (!resolved) return img;
+        return { ...img, url: resolved.url, filename: img.filename ?? resolved.fileName };
+      });
     }
-    delete message.mediaPaths;
   }
 
   const sessionId = resolveSessionId(sessionKey);

package/src/http/handlers/history-sessions.test.ts

@@ -143,4 +143,34 @@ describe("handleHistorySessions", () => {
     const keys = JSON.parse(res.body).sessions.map((s: any) => s.sessionKey);
     expect(keys).toEqual(["agent:main:main"]);
   });
+
+  it("keeps real conversations that merely carry a parentSessionKey", async () => {
+    setForward(
+      { agents: { list: [{ id: "main" }] } },
+      {
+        main: {
+          // Webchat session branched off another session: has parentSessionKey
+          // but is a genuine user conversation — must be surfaced.
+          "agent:main:dashboard:b91ad945": {
+            sessionId: "wc",
+            updatedAt: 9,
+            parentSessionKey: "agent:main:fridaynext:mq5zn7dp",
+            sessionFile: transcript("wc.jsonl"),
+          },
+          // Real subagent fork (spawnedBy) must still be filtered.
+          "agent:main:fork": {
+            sessionId: "fk",
+            updatedAt: 8,
+            spawnedBy: "agent:main:main",
+            parentSessionKey: "agent:main:main",
+            sessionFile: transcript("fk.jsonl"),
+          },
+        },
+      },
+    );
+    const res = new MockRes();
+    await handleHistorySessions(makeReq(AUTH), res as any);
+    const keys = JSON.parse(res.body).sessions.map((s: any) => s.sessionKey);
+    expect(keys).toEqual(["agent:main:dashboard:b91ad945"]);
+  });
 });

package/src/http/handlers/history-sessions.ts

@@ -125,9 +125,13 @@ function readAgentSessions(agentId: string): FridayHistorySessionSummary[] {
     const entry = rawEntry as Record<string, unknown>;
     const canonicalKey = toCanonicalSessionKey(agentId, storeKey);
 
-    // Drop internal/system sessions and subagent links.
+    // Drop internal/system sessions and subagent links. We key only on
+    // `spawnedBy`/`subagentRole` (plus the `subagent:` prefix in
+    // isInternalSessionKey) — NOT on `parentSessionKey`, which real user
+    // conversations (e.g. webchat sessions branched off another session) also
+    // carry and which would otherwise be wrongly excluded from the sidebar.
     if (isInternalSessionKey(canonicalKey, storeKey)) continue;
-    if (entry.spawnedBy || entry.subagentRole || entry.parentSessionKey) continue;
+    if (entry.spawnedBy || entry.subagentRole) continue;
     // Drop archived/empty sessions (transcript moved away or never written).
     if (!hasLiveTranscript(entry, storePath)) continue;