@syengup/friday-channel-next 0.1.13 → 0.1.14

package/src/history/read-transcript.ts

@@ -0,0 +1,136 @@
+/**
+ * Reads a session's transcript directly from disk via the forward runtime's
+ * session store (`sessions.json` → entry.sessionFile → the `.jsonl` transcript).
+ *
+ * We do NOT use `runtime.subagent.getSessionMessages` here: that dispatches the
+ * gateway `sessions.get` method which is only valid inside a gateway request
+ * scope and returns empty when called from a plugin HTTP route. Reading the
+ * transcript file mirrors how `history-sessions.ts` reads `sessions.json`.
+ *
+ * Each transcript line is `{type, id, parentId, timestamp, message:{role,content,...}}`.
+ * We surface message records (in file order) with an `__openclaw` envelope
+ * matching the gateway's own `sessions.get` output, so `normalize-message.ts`
+ * can consume either source identically.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { getFridayAgentForwardRuntime } from "../agent-forward-runtime.js";
+import { agentIdFromSessionKey, toSessionStoreKey } from "../session/session-manager.js";
+
+function entryString(entry: unknown, key: string): string | undefined {
+  if (!entry || typeof entry !== "object") return undefined;
+  const v = (entry as Record<string, unknown>)[key];
+  return typeof v === "string" && v.trim() ? v : undefined;
+}
+
+/**
+ * Resolves the store entry for a session key, tolerating case differences
+ * (the app's key carries an upper-case deviceId; `sessions.json` stores it
+ * lower-cased).
+ */
+function resolveEntry(store: Record<string, unknown>, sessionKey: string): unknown {
+  if (store[sessionKey]) return store[sessionKey];
+  const canonical = toSessionStoreKey(sessionKey);
+  if (store[canonical]) return store[canonical];
+  const target = canonical.toLowerCase();
+  for (const [k, v] of Object.entries(store)) {
+    if (k.toLowerCase() === target) return v;
+  }
+  return undefined;
+}
+
+export function resolveTranscriptPath(
+  entry: unknown,
+  storePath: string,
+): string | undefined {
+  const sessionFile = entryString(entry, "sessionFile");
+  if (sessionFile) {
+    return path.isAbsolute(sessionFile)
+      ? sessionFile
+      : path.join(path.dirname(storePath), sessionFile);
+  }
+  const sessionId = entryString(entry, "sessionId");
+  if (sessionId) {
+    return path.join(path.dirname(storePath), `${sessionId}.jsonl`);
+  }
+  return undefined;
+}
+
+/** Resolves the real server-side session id for a session key, or undefined. */
+export function resolveSessionId(sessionKey: string): string | undefined {
+  const rt = getFridayAgentForwardRuntime();
+  if (!rt) return undefined;
+  const agentId = agentIdFromSessionKey(sessionKey);
+  try {
+    const store = rt.loadSessionStore(rt.resolveStorePath(undefined, { agentId })) ?? {};
+    return entryString(resolveEntry(store, sessionKey), "sessionId");
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Returns raw transcript message objects (newest tail up to `limit`), each with
+ * an `__openclaw: { id, seq, recordTimestampMs }` envelope. Empty on any failure.
+ */
+export function readSessionTranscriptRawMessages(sessionKey: string, limit: number): unknown[] {
+  const rt = getFridayAgentForwardRuntime();
+  if (!rt) return [];
+
+  const agentId = agentIdFromSessionKey(sessionKey);
+  let storePath: string;
+  let store: Record<string, unknown>;
+  try {
+    storePath = rt.resolveStorePath(undefined, { agentId });
+    store = rt.loadSessionStore(storePath) ?? {};
+  } catch {
+    return [];
+  }
+
+  const entry = resolveEntry(store, sessionKey);
+  if (!entry) return [];
+  const filePath = resolveTranscriptPath(entry, storePath);
+  if (!filePath) return [];
+
+  let content: string;
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+
+  const raw: unknown[] = [];
+  let seq = 0;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let rec: Record<string, unknown>;
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      rec = parsed as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    if (rec.type === "session" || !rec.message || typeof rec.message !== "object") continue;
+    seq += 1;
+    const tsRaw = rec.timestamp;
+    const ts =
+      typeof tsRaw === "string"
+        ? Date.parse(tsRaw)
+        : typeof tsRaw === "number"
+          ? tsRaw
+          : Number.NaN;
+    raw.push({
+      ...(rec.message as Record<string, unknown>),
+      __openclaw: {
+        ...(typeof rec.id === "string" ? { id: rec.id } : {}),
+        seq,
+        ...(Number.isFinite(ts) ? { recordTimestampMs: ts } : {}),
+      },
+    });
+  }
+
+  return limit > 0 && raw.length > limit ? raw.slice(raw.length - limit) : raw;
+}

package/src/http/handlers/files.ts

@@ -1,7 +1,7 @@
 /**
  * File manager for Friday Next channel attachments.
  *
- * Files are copied under the plugin root `attachments/` and served at
+ * Files are copied under `~/.openclaw/friday-next/attachments/` and served at
  * GET /friday-next/files/{token} so the app can use stable gateway URLs after restarts.
  */
 
@@ -11,14 +11,30 @@ import os from "node:os";
 import { createFridayNextLogger } from "../../logging.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveFridayNextConfig } from "../../config.js";
+import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
+import { getFridayNextRuntime } from "../../runtime.js";
 
-function getPluginRootDir(): string {
-  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+/** Test-only override for the attachments base directory. */
+let testAttachmentsDir: string | null = null;
+
+export function setAttachmentsDirForTest(dir: string | null): void {
+  testAttachmentsDir = dir;
+}
+
+/** Resolve `<historyDir>/../attachments`, mirroring the offline-queue layout. */
+function resolveAttachmentsDir(): string {
+  try {
+    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    return path.join(path.dirname(cfg.historyDir), "attachments");
+  } catch {
+    return path.join(os.homedir(), ".openclaw", "friday-next", "attachments");
+  }
 }
 
-/** Plugin-root `attachments/` directory; created on first use. */
+/** `~/.openclaw/friday-next/attachments/` directory; created on first use. */
 export function getAttachmentsDir(): string {
-  const dir = path.join(getPluginRootDir(), "attachments");
+  const dir = testAttachmentsDir ?? resolveAttachmentsDir();
   try {
     fs.mkdirSync(dir, { recursive: true });
   } catch {

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

@@ -0,0 +1,144 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { handleHistoryMessages } from "./history-messages.js";
+import { setFridayNextRuntime } from "../../runtime.js";
+import {
+  setFridayAgentForwardRuntime,
+  resetFridayAgentForwardRuntimeForTest,
+} from "../../agent-forward-runtime.js";
+
+class MockRes extends EventEmitter {
+  statusCode = 0;
+  headers: Record<string, string> = {};
+  body = "";
+  setHeader(name: string, value: string): void {
+    this.headers[name.toLowerCase()] = value;
+  }
+  end(body?: string): void {
+    if (body) this.body += body;
+  }
+}
+
+function makeReq(path: string, headers: Record<string, string> = {}, method = "GET"): any {
+  return { method, url: path, headers };
+}
+
+const AUTH = { authorization: "Bearer test-token" };
+const CFG = {
+  channels: { "friday-next": { authToken: "test-token", pathPrefix: "/friday-next" } },
+  gateway: { auth: { token: "test-token" } },
+};
+
+let tmpDir = "";
+
+/** Auth config + optional subagent fallback. */
+function setRuntime(getSessionMessages?: (params: { sessionKey: string; limit?: number }) => Promise<{ messages?: unknown[] }>): void {
+  setFridayNextRuntime({
+    config: { loadConfig: () => CFG },
+    logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
+    ...(getSessionMessages ? { subagent: { getSessionMessages } } : {}),
+  } as never);
+}
+
+/** Forward runtime: store keyed by full session key → entry with a sessionFile. */
+function setForward(store: Record<string, unknown>): void {
+  setFridayAgentForwardRuntime({
+    runtime: {
+      agent: {
+        session: {
+          resolveStorePath: (_s?: string, opts?: { agentId?: string }) =>
+            path.join(tmpDir, `${opts?.agentId ?? "main"}-sessions.json`),
+          loadSessionStore: () => store,
+        },
+      },
+      config: { current: () => CFG },
+    },
+  } as any);
+}
+
+function writeTranscript(name: string, lines: unknown[]): string {
+  const file = path.join(tmpDir, name);
+  fs.writeFileSync(file, lines.map((l) => JSON.stringify(l)).join("\n") + "\n", "utf-8");
+  return file;
+}
+
+describe("handleHistoryMessages", () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "friday-hist-"));
+    setRuntime();
+  });
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it("rejects non-GET with 405", async () => {
+    const res = new MockRes();
+    await handleHistoryMessages(makeReq("/friday-next/history/messages", AUTH, "POST"), res as any);
+    expect(res.statusCode).toBe(405);
+  });
+
+  it("rejects missing token with 401", async () => {
+    const res = new MockRes();
+    await handleHistoryMessages(makeReq("/friday-next/history/messages"), res as any);
+    expect(res.statusCode).toBe(401);
+  });
+
+  it("400s when sessionKey is missing", async () => {
+    const res = new MockRes();
+    await handleHistoryMessages(makeReq("/friday-next/history/messages", AUTH), res as any);
+    expect(res.statusCode).toBe(400);
+  });
+
+  it("reads the transcript file from disk including user + assistant messages", async () => {
+    const file = writeTranscript("sess.jsonl", [
+      { type: "session", version: 1, sessionId: "s" },
+      { type: "message", id: "u1", timestamp: "2026-01-01T00:00:00.000Z", message: { role: "user", content: "hi there" } },
+      { type: "message", id: "a1", timestamp: "2026-01-01T00:00:01.000Z", message: { role: "assistant", content: [{ type: "text", text: "hello" }], model: "openai/gpt-4" } },
+    ]);
+    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);
+    expect(body.messages.map((m: any) => m.role)).toEqual(["user", "assistant"]);
+    expect(body.messages[0].text).toBe("hi there");
+    expect(body.messages[1].text).toBe("hello");
+  });
+
+  it("resolves the entry case-insensitively (app upper-cases deviceId)", async () => {
+    const file = writeTranscript("fd.jsonl", [
+      { type: "message", id: "u1", message: { role: "user", content: "from app" } },
+    ]);
+    // Store keyed lower-case (as sessions.json persists it).
+    setForward({ "agent:main:friday:direct:abcd-1234:9": { sessionId: "x", sessionFile: file } });
+
+    const res = new MockRes();
+    await handleHistoryMessages(
+      makeReq("/friday-next/history/messages?sessionKey=agent:main:friday:direct:ABCD-1234:9", AUTH),
+      res as any,
+    );
+    const body = JSON.parse(res.body);
+    expect(body.messages.map((m: any) => m.role)).toEqual(["user"]);
+    expect(body.messages[0].text).toBe("from app");
+  });
+
+  it("falls back to getSessionMessages when the transcript is not on disk", async () => {
+    setForward({}); // no entry → disk read yields nothing
+    setRuntime(async () => ({
+      messages: [{ role: "assistant", content: "fallback", __openclaw: { id: "a1", seq: 1 } }],
+    }));
+    const res = new MockRes();
+    await handleHistoryMessages(makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH), res as any);
+    const body = JSON.parse(res.body);
+    expect(body.messages.map((m: any) => m.id)).toEqual(["a1"]);
+  });
+});

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

@@ -0,0 +1,123 @@
+/**
+ * GET /friday-next/history/messages?sessionKey=&agentId=&limit=
+ *
+ * Returns a session's transcript history as a flat, normalized message stream.
+ * The Friday app groups these into rounds itself (by role transitions) and uses
+ * each message's stable `id` (the upstream transcript entry id) as its sync key.
+ *
+ * Reads via the gateway `sessions.get` method (exposed to plugins as
+ * `runtime.subagent.getSessionMessages`), which already resolves the active
+ * branch and compaction, then normalizes each raw message into a stable DTO.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { getFridayNextRuntime } from "../../runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { normalizeHistoryMessages } from "../../history/normalize-message.js";
+import { readSessionTranscriptRawMessages, resolveSessionId } from "../../history/read-transcript.js";
+import { resolveMediaAttachment } from "./files.js";
+
+const DEFAULT_LIMIT = 200;
+const MAX_LIMIT = 1000;
+
+type SubagentSessionApi = {
+  getSessionMessages?: (params: {
+    sessionKey: string;
+    limit?: number;
+  }) => Promise<{ messages?: unknown[] }>;
+};
+
+function resolveSubagentApi(): SubagentSessionApi | undefined {
+  try {
+    const runtime = getFridayNextRuntime();
+    return (runtime as unknown as { subagent?: SubagentSessionApi }).subagent;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function handleHistoryMessages(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<boolean> {
+  if (req.method !== "GET") {
+    res.statusCode = 405;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ error: "Method Not Allowed" }));
+    return true;
+  }
+
+  const token = extractBearerToken(req);
+  if (!token) {
+    res.statusCode = 401;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+    return true;
+  }
+
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const sessionKey = url.searchParams.get("sessionKey")?.trim();
+  if (!sessionKey) {
+    res.statusCode = 400;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ error: "Missing required query param: sessionKey" }));
+    return true;
+  }
+  const agentId = url.searchParams.get("agentId")?.trim() || undefined;
+  const limitParam = Number(url.searchParams.get("limit"));
+  const limit =
+    Number.isFinite(limitParam) && limitParam > 0
+      ? Math.min(Math.floor(limitParam), MAX_LIMIT)
+      : DEFAULT_LIMIT;
+
+  // Primary path: read the transcript file directly (works from an HTTP route).
+  let rawMessages: unknown[] = readSessionTranscriptRawMessages(sessionKey, limit);
+
+  // Fallback: the request-scoped gateway method (only works in some contexts).
+  if (rawMessages.length === 0) {
+    const sessionApi = resolveSubagentApi();
+    if (sessionApi?.getSessionMessages) {
+      try {
+        const response = await sessionApi.getSessionMessages({ sessionKey, limit });
+        rawMessages = Array.isArray(response?.messages) ? response.messages : [];
+      } catch {
+        // Best-effort: an unreadable/unknown session yields an empty history
+        // rather than an error, so the app degrades gracefully.
+        rawMessages = [];
+      }
+    }
+  }
+
+  const messages = normalizeHistoryMessages(rawMessages);
+
+  // Resolve `MEDIA:<server-path>` references into downloadable attachment URLs
+  // (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];
+    }
+    delete message.mediaPaths;
+  }
+
+  const sessionId = resolveSessionId(sessionKey);
+
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json");
+  res.end(
+    JSON.stringify({
+      ok: true,
+      sessionKey,
+      ...(agentId ? { agentId } : {}),
+      ...(sessionId ? { sessionId } : {}),
+      totalMessages: messages.length,
+      messages,
+    }),
+  );
+  return true;
+}

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

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { handleHistorySessions } from "./history-sessions.js";
+import { setMockRuntime } from "../../test-support/mock-runtime.js";
+import {
+  setFridayAgentForwardRuntime,
+  resetFridayAgentForwardRuntimeForTest,
+} from "../../agent-forward-runtime.js";
+
+class MockRes extends EventEmitter {
+  statusCode = 0;
+  headers: Record<string, string> = {};
+  body = "";
+  setHeader(name: string, value: string): void {
+    this.headers[name.toLowerCase()] = value;
+  }
+  end(body?: string): void {
+    if (body) this.body += body;
+  }
+}
+
+function makeReq(headers: Record<string, string> = {}, method = "GET"): any {
+  return { method, url: "/friday-next/history/sessions", headers };
+}
+
+const AUTH = { authorization: "Bearer test-token" };
+
+let tmpDir = "";
+
+/** Write a non-empty transcript file and return its absolute path. */
+function transcript(name: string): string {
+  const file = path.join(tmpDir, name);
+  fs.writeFileSync(file, `${JSON.stringify({ type: "message", id: "m", message: { role: "user", content: "hi" } })}\n`, "utf-8");
+  return file;
+}
+
+function setForward(config: unknown, storesByAgent: Record<string, Record<string, unknown>>): void {
+  setFridayAgentForwardRuntime({
+    runtime: {
+      agent: {
+        session: {
+          resolveStorePath: (_s?: string, opts?: { agentId?: string }) =>
+            path.join(tmpDir, `${opts?.agentId ?? "main"}.json`),
+          loadSessionStore: (p: string) => {
+            const agentId = path.basename(p, ".json");
+            return storesByAgent[agentId] ?? {};
+          },
+        },
+      },
+      config: { current: () => config },
+    },
+  } as any);
+}
+
+describe("handleHistorySessions", () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "friday-hs-"));
+    setMockRuntime();
+  });
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it("rejects non-GET with 405", async () => {
+    const res = new MockRes();
+    await handleHistorySessions(makeReq(AUTH, "POST"), res as any);
+    expect(res.statusCode).toBe(405);
+  });
+
+  it("rejects missing token with 401", async () => {
+    const res = new MockRes();
+    await handleHistorySessions(makeReq(), res as any);
+    expect(res.statusCode).toBe(401);
+  });
+
+  it("lists live sessions with sessionId + server title, sorted by updatedAt", async () => {
+    setForward(
+      { agents: { list: [{ id: "main" }] } },
+      {
+        main: {
+          "agent:main:main": { sessionId: "s-main", updatedAt: 100, sessionFile: transcript("main.jsonl") },
+          "agent:main:friday:direct:dev:1": {
+            sessionId: "s-fd",
+            updatedAt: 300,
+            displayName: "我的会话",
+            sessionFile: transcript("fd.jsonl"),
+          },
+        },
+      },
+    );
+    const res = new MockRes();
+    await handleHistorySessions(makeReq(AUTH), res as any);
+    const body = JSON.parse(res.body);
+    expect(body.sessions.map((s: any) => s.sessionKey)).toEqual([
+      "agent:main:friday:direct:dev:1",
+      "agent:main:main",
+    ]);
+    const fd = body.sessions[0];
+    expect(fd).toMatchObject({ sessionId: "s-fd", title: "我的会话" });
+  });
+
+  it("filters out archived sessions (transcript file missing)", async () => {
+    setForward(
+      { agents: { list: [{ id: "main" }] } },
+      {
+        main: {
+          "agent:main:live": { sessionId: "a", updatedAt: 1, sessionFile: transcript("live.jsonl") },
+          "agent:main:archived": { sessionId: "b", updatedAt: 2, sessionFile: path.join(tmpDir, "gone.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:live"]);
+  });
+
+  it("filters out internal/system + subagent sessions", async () => {
+    setForward(
+      { agents: { list: [{ id: "main" }] } },
+      {
+        main: {
+          "agent:main:main": { sessionId: "ok", updatedAt: 5, sessionFile: transcript("ok.jsonl") },
+          "agent:main:main:heartbeat": { sessionId: "hb", updatedAt: 4, sessionFile: transcript("hb.jsonl") },
+          "agent:main:cron:abc": { sessionId: "c", updatedAt: 3, sessionFile: transcript("c.jsonl") },
+          "agent:main:subagent:xyz": { sessionId: "sa", updatedAt: 2, sessionFile: transcript("sa.jsonl") },
+          "agent:main:dreaming-narrative-rem-1": { sessionId: "d", updatedAt: 1, sessionFile: transcript("d.jsonl") },
+          "agent:main:child": { sessionId: "ch", updatedAt: 6, spawnedBy: "agent:main:main", sessionFile: transcript("ch.jsonl") },
+          global: { sessionId: "g", updatedAt: 7, sessionFile: transcript("g.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:main"]);
+  });
+});