@syengup/friday-channel-next 0.1.12 → 0.1.14

package/src/http/handlers/messages.ts

@@ -28,7 +28,12 @@ import { resolveFridayNextConfig } from "../../config.js";
 import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
 import { getFridayNextRuntime } from "../../runtime.js";
 import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
-import { setSessionSettings, splitModelRef, toSessionStoreKey } from "../../session/session-manager.js";
+import {
+  agentIdFromSessionKey,
+  setSessionSettings,
+  splitModelRef,
+  toSessionStoreKey,
+} from "../../session/session-manager.js";
 import { sseEmitter } from "../../sse/emitter.js";
 import { extractBearerToken } from "../middleware/auth.js";
 import { readJsonBody } from "../middleware/body.js";
@@ -421,6 +426,10 @@ export async function handleMessages(req: IncomingMessage, res: ServerResponse):
   const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(runtime.config));
 
   // Resolve defaults from the OpenClaw agent config so settings are never left empty.
+  // The target agent comes from the app-supplied sessionKey (`agent:<id>:<rest>`); prefer that
+  // agent's own configured model/thinking over the global defaults so non-main agents are not
+  // silently forced onto the global default model.
+  const targetAgentId = agentIdFromSessionKey(baseSessionKey);
   let defaultModel: string | undefined;
   let defaultThinking: string | undefined;
   try {
@@ -428,13 +437,32 @@ export async function handleMessages(req: IncomingMessage, res: ServerResponse):
     if (forwardRt) {
       const ocCfg = (forwardRt.getConfig() ?? {}) as Record<string, unknown>;
       const agents = ocCfg.agents as Record<string, unknown> | undefined;
+
+      const agentEntry = (agents?.list as Array<Record<string, unknown>> | undefined)?.find(
+        (a) => agentIdFromSessionKey(`agent:${String(a?.id ?? "")}:x`) === targetAgentId,
+      );
+      const agentModel = agentEntry?.model;
+      const perAgentModel =
+        typeof agentModel === "string"
+          ? agentModel
+          : typeof (agentModel as Record<string, unknown> | undefined)?.primary === "string"
+            ? ((agentModel as Record<string, unknown>).primary as string)
+            : undefined;
+      const perAgentThinking =
+        typeof agentEntry?.thinkingDefault === "string"
+          ? (agentEntry.thinkingDefault as string)
+          : undefined;
+
       const agentDefaults = agents?.defaults as Record<string, unknown> | undefined;
       const model = agentDefaults?.model as Record<string, unknown> | undefined;
-      defaultModel = typeof model?.primary === "string" ? (model.primary as string) : undefined;
-      defaultThinking =
+      const globalModel = typeof model?.primary === "string" ? (model.primary as string) : undefined;
+      const globalThinking =
         typeof agentDefaults?.thinkingDefault === "string"
           ? (agentDefaults.thinkingDefault as string)
           : undefined;
+
+      defaultModel = perAgentModel ?? globalModel;
+      defaultThinking = perAgentThinking ?? globalThinking;
     }
   } catch {
     // Config not available (tests) — leave defaults undefined.

package/src/http/server.ts

@@ -16,6 +16,9 @@ import { handleNodesApprove } from "./handlers/nodes-approve.js";
 import { handleSessionsSettings } from "./handlers/sessions-settings.js";
 import { handleModelsList } from "./handlers/models-list.js";
 import { handleAgentsList } from "./handlers/agents-list.js";
+import { handleHistorySessions } from "./handlers/history-sessions.js";
+import { handleHistoryMessages } from "./handlers/history-messages.js";
+import { handleHistorySetTitle } from "./handlers/history-set-title.js";
 import { handleStatus } from "./handlers/status.js";
 import { handleHealth } from "./handlers/health.js";
 import { applyCorsHeaders } from "./middleware/cors.js";
@@ -86,6 +89,21 @@ async function handleFridayNextRoute(
     return await handleStatus(req, res);
   }
 
+  // Route: GET /friday-next/history/sessions (list all sessions across agents)
+  if (req.method === "GET" && pathname === "/friday-next/history/sessions") {
+    return await handleHistorySessions(req, res);
+  }
+
+  // Route: GET /friday-next/history/messages?sessionKey=&agentId=&limit=
+  if (req.method === "GET" && pathname === "/friday-next/history/messages") {
+    return await handleHistoryMessages(req, res);
+  }
+
+  // Route: PUT /friday-next/sessions/title (sync app session name → server displayName)
+  if ((req.method === "PUT" || req.method === "POST") && pathname === "/friday-next/sessions/title") {
+    return await handleHistorySetTitle(req, res);
+  }
+
   // Route: GET /friday-next/health?deviceId=...&nodeDeviceId=...&selfHeal=true
   if (req.method === "GET" && pathname === "/friday-next/health") {
     return await handleHealth(req, res);

package/src/session/session-manager.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  agentIdFromSessionKey,
+  toSessionStoreKey,
+  setSessionSettings,
+  getSessionSettings,
+} from "./session-manager.js";
+
+describe("agentIdFromSessionKey", () => {
+  it("extracts the agent id from a fully-qualified key", () => {
+    expect(agentIdFromSessionKey("agent:operator:friday:direct:abc:1")).toBe("operator");
+    expect(agentIdFromSessionKey("agent:ha-maestro:main")).toBe("ha-maestro");
+  });
+
+  it("falls back to main for bare / legacy keys", () => {
+    expect(agentIdFromSessionKey("main")).toBe("main");
+    expect(agentIdFromSessionKey("friday:direct:dev:1")).toBe("main");
+    expect(agentIdFromSessionKey("")).toBe("main");
+  });
+
+  it("rejects path-unsafe agent ids (no traversal)", () => {
+    expect(agentIdFromSessionKey("agent:../../etc:foo")).toBe("main");
+  });
+});
+
+describe("per-agent session settings file routing", () => {
+  let baseDir: string;
+  let historyDir: string;
+
+  // historyDir must contain a `.openclaw` segment so deriveOpenClawBaseDir resolves the base.
+  function seedSessionsFile(agentId: string): string {
+    const dir = join(baseDir, ".openclaw", "agents", agentId, "sessions");
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, "sessions.json");
+    writeFileSync(file, JSON.stringify({}), "utf-8");
+    return file;
+  }
+
+  function readEntry(agentId: string, fileKey: string): Record<string, unknown> | undefined {
+    const file = join(baseDir, ".openclaw", "agents", agentId, "sessions", "sessions.json");
+    const data = JSON.parse(readFileSync(file, "utf-8")) as Record<string, Record<string, unknown>>;
+    return data[fileKey];
+  }
+
+  beforeEach(() => {
+    baseDir = mkdtempSync(join(tmpdir(), "friday-sm-"));
+    historyDir = join(baseDir, ".openclaw", "friday-next", "history");
+  });
+
+  afterEach(() => {
+    rmSync(baseDir, { recursive: true, force: true });
+  });
+
+  it("writes settings for a non-main agent into agents/<agentId>/sessions", () => {
+    seedSessionsFile("operator");
+    const sessionKey = "agent:operator:friday:direct:dev:1";
+
+    setSessionSettings(sessionKey, { reasoningLevel: "stream", thinkingLevel: "high" }, historyDir);
+
+    const entry = readEntry("operator", toSessionStoreKey(sessionKey));
+    expect(entry?.reasoningLevel).toBe("stream");
+    expect(entry?.thinkingLevel).toBe("high");
+
+    // Round-trips through getSessionSettings from the same per-agent file.
+    const read = getSessionSettings(sessionKey, historyDir);
+    expect(read.reasoningLevel).toBe("stream");
+    expect(read.thinkingLevel).toBe("high");
+  });
+
+  it("does not leak a non-main agent's settings into the main store", () => {
+    seedSessionsFile("operator");
+    seedSessionsFile("main");
+
+    setSessionSettings("agent:operator:s1", { modelRef: "openai/gpt-x" }, historyDir);
+
+    expect(readEntry("operator", "agent:operator:s1")?.modelRef).toBe("openai/gpt-x");
+    expect(getSessionSettings("main", historyDir).modelRef).toBeUndefined();
+  });
+
+  it("still routes bare/main keys to agents/main", () => {
+    seedSessionsFile("main");
+
+    setSessionSettings("main", { thinkingLevel: "low" }, historyDir);
+
+    expect(readEntry("main", "agent:main:main")?.thinkingLevel).toBe("low");
+  });
+});

package/src/session/session-manager.ts

@@ -4,6 +4,8 @@ import { readFileSync, writeFileSync } from "node:fs";
 
 const FRIDAY_AGENT_ID = "main";
 const SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
+/** Path/shell-safe agent id (mirrors OpenClaw's `normalizeAgentId`). Anything else falls back to `main`. */
+const SAFE_AGENT_ID_RE = /^[a-z0-9][a-z0-9_-]*$/;
 
 function deriveOpenClawBaseDir(historyDir?: string): string {
   if (historyDir) {
@@ -41,6 +43,17 @@ export function toSessionStoreKey(rawSessionKey: string): string {
   return `agent:${FRIDAY_AGENT_ID}:${lowered}`;
 }
 
+/**
+ * Extract the agent id from a (possibly raw) session key. The downstream app now owns the
+ * full `agent:<id>:<rest>` key, so non-`main` agents must read/write their own session store
+ * directory. `agent:<id>:<rest>` → `<id>`; bare/legacy keys (or an unsafe id) → `main`.
+ */
+export function agentIdFromSessionKey(rawSessionKey: string): string {
+  const canonical = toSessionStoreKey(rawSessionKey);
+  const id = canonical.match(/^agent:([^:]+):/)?.[1];
+  return id && SAFE_AGENT_ID_RE.test(id) ? id : FRIDAY_AGENT_ID;
+}
+
 function toSafeSessionId(raw: string): string {
   const s = raw.trim();
   if (SESSION_ID_RE.test(s)) return s;
@@ -57,8 +70,8 @@ function sessionIdForSessionsFile(fileKey: string, rawSessionKey: string): strin
   const candidates = [rawSessionKey.trim(), fileKey.trim()];
   for (const c of candidates) {
     if (SESSION_ID_RE.test(c)) return c;
-    if (c.startsWith(`agent:${FRIDAY_AGENT_ID}:`)) {
-      const tail = c.slice(`agent:${FRIDAY_AGENT_ID}:`.length);
+    const tail = c.match(/^agent:[^:]+:(.+)$/)?.[1];
+    if (tail) {
       if (SESSION_ID_RE.test(tail)) return tail;
       return toSafeSessionId(tail);
     }
@@ -66,9 +79,9 @@ function sessionIdForSessionsFile(fileKey: string, rawSessionKey: string): strin
   return toSafeSessionId(rawSessionKey || fileKey);
 }
 
-function resolveSessionsFilePath(historyDir?: string): string {
+function resolveSessionsFilePath(historyDir: string | undefined, agentId: string): string {
   const base = deriveOpenClawBaseDir(historyDir);
-  return join(base, "agents/main/sessions/sessions.json");
+  return join(base, "agents", agentId, "sessions", "sessions.json");
 }
 
 function readSessionsData(path: string): Record<string, Record<string, unknown>> | null {
@@ -125,11 +138,11 @@ export function setSessionSettings(
   historyDir?: string,
 ): FridaySessionSettings {
   try {
-    const sessionsFile = resolveSessionsFilePath(historyDir);
+    const fileKey = toSessionStoreKey(sessionKey);
+    const sessionsFile = resolveSessionsFilePath(historyDir, agentIdFromSessionKey(fileKey));
     const data = readSessionsData(sessionsFile);
     if (!data) return {};
 
-    const fileKey = toSessionStoreKey(sessionKey);
     upsertSessionEntry(data, fileKey, sessionKey);
 
     const fieldKeys: (keyof FridaySessionSettings)[] = [
@@ -172,11 +185,11 @@ export function getSessionSettings(
   historyDir?: string,
 ): FridaySessionSettings {
   try {
-    const sessionsFile = resolveSessionsFilePath(historyDir);
+    const fileKey = toSessionStoreKey(sessionKey);
+    const sessionsFile = resolveSessionsFilePath(historyDir, agentIdFromSessionKey(fileKey));
     const data = readSessionsData(sessionsFile);
     if (!data) return {};
 
-    const fileKey = toSessionStoreKey(sessionKey);
     const entry = data[fileKey];
     if (!entry) return {};
     return readSettingsFromEntry(entry);

package/src/test-support/mock-runtime.ts

@@ -3,6 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { setFridayNextRuntime } from "../runtime.js";
 import { setOfflineQueueBaseDirForTest } from "../sse/offline-queue.js";
+import { setAttachmentsDirForTest } from "../http/handlers/files.js";
 import { sseEmitter } from "../sse/emitter.js";
 import { resetActiveRunsForTest } from "../agent/active-runs.js";
 import { resetRunMetadataForTest } from "../run-metadata.js";
@@ -36,6 +37,7 @@ export function setMockRuntime(opts: MockRuntimeOptions = {}): void {
   resetSubagentRegistryForTest();
   const historyDir = opts.historyDir ?? createTempHistoryDir();
   setOfflineQueueBaseDirForTest(path.join(historyDir, "events-queue"));
+  setAttachmentsDirForTest(path.join(historyDir, "attachments"));
   const cfg = {
     gateway: {
       auth: {