@syengup/friday-channel-next 0.0.1

package/src/config.ts

@@ -0,0 +1,64 @@
+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;
+};
+
+function asObject(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function asString(value: unknown, fallback: string): string {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+
+function asNumber(value: unknown, fallback: number, min: number, max: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(value)));
+}
+
+function asBool(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+export function resolveFridayNextConfig(cfg: unknown): FridayNextConfig {
+  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") as FridayNextLogLevel,
+    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/src/e2e/attachments-inbound.e2e.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+
+describe("e2e attachments inbound", () => {
+  let historyDir = "";
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    setMockRuntime({ historyDir, authToken: "test-token" });
+    mockDispatchScript().deliverFinal({ text: "ok" }).install();
+  });
+  afterEach(() => {
+    resetMockDispatch();
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("multipart 上传 + 下载 + range", async () => {
+    const app = createAppSimulator({ token: "test-token" });
+    const up = await app.uploadFiles([
+      { name: "file", filename: "a.txt", contentType: "text/plain", content: "hello world" },
+    ]);
+    expect(up.status).toBe(200);
+    const url = String(up.body.files?.[0]?.url ?? "");
+    expect(url.startsWith("/friday-next/files/")).toBe(true);
+
+    const full = await app.downloadFile(url);
+    expect(full.status).toBe(200);
+    expect(full.body.toString("utf-8")).toBe("hello world");
+
+    const ranged = await app.downloadFile(url, { range: "bytes=0-4" });
+    expect(ranged.status).toBe(206);
+    expect(ranged.body.toString("utf-8")).toBe("hello");
+  });
+
+  it("空上传与非法编码报错", async () => {
+    const app = createAppSimulator({ token: "test-token" });
+    const empty = await app.uploadFiles([]);
+    expect(empty.status).toBe(400);
+    const bad = await app.downloadFile("/friday-next/files/%");
+    expect(bad.status).toBe(400);
+  });
+});

package/src/e2e/attachments-outbound.e2e.test.ts

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+
+describe("e2e attachments outbound", () => {
+  let historyDir = "";
+  let mediaFile = "";
+
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    mediaFile = path.join(historyDir, "voice.mp3");
+    fs.writeFileSync(mediaFile, "audio-bytes");
+    setMockRuntime({ historyDir, authToken: "test-token" });
+  });
+
+  afterEach(() => {
+    resetMockDispatch();
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("block/final deliver 含可解析的媒体 URL", async () => {
+    mockDispatchScript()
+      .lifecycle("start")
+      .block("one", [mediaFile], true)
+      .deliverFinal({ text: "done", mediaUrls: [mediaFile], audioAsVoice: true })
+      .lifecycle("end")
+      .install();
+
+    const app = createAppSimulator({ token: "test-token" });
+    await app.connectSSE();
+    await app.sendMessage({ text: "play", sessionKey: "s1" });
+    const frames = await app.waitForSse((f) => f.filter((x) => x.event === "deliver").length >= 2);
+
+    const delivers = frames.filter((x) => x.event === "deliver");
+    expect(delivers.length).toBeGreaterThanOrEqual(1);
+    const urls = (delivers[delivers.length - 1]?.data?.payload as { mediaUrls?: string[] })?.mediaUrls ?? [];
+    expect(urls.some((u) => u.includes("/friday-next/files/"))).toBe(true);
+    app.disconnectSSE();
+  });
+});

package/src/e2e/cancel-reconnect-errors.e2e.test.ts

@@ -0,0 +1,56 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+
+describe("e2e cancel reconnect errors", () => {
+  let historyDir = "";
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    setMockRuntime({ historyDir, authToken: "test-token", sseBacklogPerDevice: 20 });
+  });
+  afterEach(() => {
+    resetMockDispatch();
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("cancel 缺 runId 与 200 cancel", async () => {
+    mockDispatchScript().lifecycle("start").partial("a").deliverFinal({ text: "a" }).lifecycle("end").install();
+    const app = createAppSimulator({ token: "test-token" });
+    await app.connectSSE();
+    const sent = await app.sendMessage({ text: "go", sessionKey: "c1" });
+    const runId = String(sent.body.runId ?? "");
+    expect(runId.length).toBeGreaterThan(0);
+    await app.waitForSse((f) => f.some((x) => x.event === "deliver"));
+    const bad = await app.rawRequest({
+      method: "POST",
+      path: "/friday-next/cancel",
+      headers: { "content-type": "application/json" },
+      body: "{}",
+    });
+    expect(bad.status).toBe(400);
+    const ok = await app.cancel(runId);
+    expect(ok.status).toBe(200);
+    app.disconnectSSE();
+  });
+
+  it("Last-Event-ID replay 与多 device 隔离", async () => {
+    mockDispatchScript().lifecycle("start").partial("h").partial("hi").deliverFinal({ text: "hi" }).lifecycle("end").install();
+    const appA = createAppSimulator({ token: "test-token", deviceId: "A" });
+    await appA.connectSSE();
+    await appA.sendMessage({ text: "one", sessionKey: "r1" });
+    const framesA = await appA.waitForSse((f) => f.some((x) => x.event === "deliver"));
+    const maxId = Math.max(...framesA.map((x) => x.id ?? 0));
+    appA.disconnectSSE();
+    await appA.connectSSE({ deviceId: "A", lastEventId: Math.max(1, maxId - 1) });
+    const replayed = appA.getSseFrames().filter((x) => (x.id ?? 0) > Math.max(1, maxId - 1));
+    expect(replayed.length).toBeGreaterThan(0);
+
+    const appB = createAppSimulator({ token: "test-token", deviceId: "B" });
+    await appB.connectSSE();
+    const framesB = appB.getSseFrames();
+    expect(framesB[0]?.id).toBe(1);
+    appA.disconnectSSE();
+    appB.disconnectSSE();
+  });
+});

package/src/e2e/connect-and-connected.e2e.test.ts

@@ -0,0 +1,44 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+
+describe("e2e connect and connected", () => {
+  let historyDir = "";
+
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    setMockRuntime({ historyDir, authToken: "test-token" });
+  });
+
+  afterEach(() => {
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("无 Bearer 返回 401", async () => {
+    const app = createAppSimulator({ token: "" });
+    const res = await app.rawRequest({
+      method: "GET",
+      path: "/friday-next/events?deviceId=dev-a",
+      headers: {},
+    });
+    expect(res.status).toBe(401);
+    expect(res.body).toContain("Unauthorized");
+  });
+
+  it("正确 Bearer 返回 SSE 头与 connected 首帧", async () => {
+    const app = createAppSimulator({ token: "test-token" });
+    const sseRes = await app.connectSSE({ deviceId: "dev-a" });
+    expect(sseRes.statusCode).toBe(200);
+    expect(sseRes.getHeader("content-type")).toContain("text/event-stream");
+    expect(sseRes.getHeader("x-accel-buffering")).toBe("no");
+    expect(sseRes.getHeader("cache-control")).toContain("no-cache");
+
+    const frames = await app.waitForSse((f) => f.some((x) => x.event === "connected"));
+    const connected = frames.find((x) => x.event === "connected");
+    expect(connected).toBeTruthy();
+    expect(connected?.data?.deviceId).toBe("DEV-A");
+    expect(typeof connected?.data?.lastSeq).toBe("number");
+    expect(typeof connected?.data?.serverTime).toBe("number");
+    app.disconnectSSE();
+  });
+});

package/src/e2e/offline-replay.e2e.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+
+describe("e2e offline SSE replay", () => {
+  let historyDir = "";
+
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    setMockRuntime({ historyDir, authToken: "test-token", sseBacklogPerDevice: 50 });
+  });
+
+  afterEach(() => {
+    resetMockDispatch();
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("断开后产生的事件在 Last-Event-ID 重连后回放", async () => {
+    mockDispatchScript().lifecycle("start").partial("x").deliverFinal({ text: "x" }).lifecycle("end").install();
+
+    const app = createAppSimulator({ token: "test-token", deviceId: "replay-dev" });
+    await app.connectSSE({ deviceId: "replay-dev" });
+    await app.sendMessage({ text: "first", sessionKey: "r1", deviceId: "replay-dev" });
+    await app.waitForSse((f) => f.some((x) => x.event === "deliver"));
+    const framesA = app.getSseFrames();
+    const maxId = Math.max(...framesA.map((x) => x.id ?? 0));
+    app.disconnectSSE();
+
+    resetMockDispatch();
+    mockDispatchScript().lifecycle("start").partial("y").deliverFinal({ text: "y" }).lifecycle("end").install();
+    await app.sendMessage({ text: "again", sessionKey: "r1", deviceId: "replay-dev" });
+    await new Promise((r) => setTimeout(r, 80));
+
+    await app.connectSSE({ deviceId: "replay-dev", lastEventId: maxId });
+    const framesB = await app.waitForSse(
+      (f) => f.some((x) => (x.id ?? 0) > maxId && x.event === "deliver"),
+      3000,
+    );
+    expect(framesB.some((x) => (x.id ?? 0) > maxId)).toBe(true);
+    app.disconnectSSE();
+  });
+});

package/src/e2e/send-text.e2e.test.ts

@@ -0,0 +1,73 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+
+describe("e2e send text", () => {
+  let historyDir = "";
+
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    setMockRuntime({ historyDir, authToken: "test-token" });
+  });
+
+  afterEach(() => {
+    resetMockDispatch();
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("202 与 agent + deliver SSE", async () => {
+    mockDispatchScript()
+      .lifecycle("start")
+      .reasoning("think")
+      .partial("Hello world")
+      .deliverFinal({ text: "Hello world" })
+      .lifecycle("end")
+      .install();
+
+    const app = createAppSimulator({ token: "test-token", deviceId: "dev-a" });
+    await app.connectSSE();
+    const sent = await app.sendMessage({ text: "hi", sessionKey: "s1" });
+    expect(sent.status).toBe(202);
+    expect(sent.body.accepted).toBe(true);
+    expect(sent.body.deviceId).toBe("DEV-A");
+    expect(typeof sent.body.runId).toBe("string");
+
+    const frames = await app.waitForSse((f) => f.some((x) => x.event === "deliver"));
+    const events = frames.map((x) => x.event);
+    expect(events).toContain("agent");
+    expect(events).toContain("deliver");
+    app.disconnectSSE();
+  });
+
+  it("assistant 流式事件可达", async () => {
+    mockDispatchScript().lifecycle("start").partial("abXdef").deliverFinal({ text: "abXdef" }).lifecycle("end").install();
+    const app = createAppSimulator({ token: "test-token" });
+    await app.connectSSE();
+    await app.sendMessage({ text: "hi", sessionKey: "s1" });
+    const frames = await app.waitForSse((f) => f.some((x) => x.event === "agent"));
+    const agent = frames.filter((x) => x.event === "agent");
+    expect(agent.length).toBeGreaterThan(0);
+    app.disconnectSSE();
+  });
+
+  it("缺少必要字段返回 400", async () => {
+    const app = createAppSimulator({ token: "test-token" });
+    const badText = await app.sendMessage({ text: "", sessionKey: "s1" });
+    expect(badText.status).toBe(400);
+    const badDevice = await app.rawRequest({
+      method: "POST",
+      path: "/friday-next/messages",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ text: "hi", sessionKey: "s1" }),
+    });
+    expect(badDevice.status).toBe(400);
+    const badSession = await app.rawRequest({
+      method: "POST",
+      path: "/friday-next/messages",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ text: "hi", deviceId: "A" }),
+    });
+    expect(badSession.status).toBe(400);
+  });
+});

package/src/e2e/slash-commands.e2e.test.ts

@@ -0,0 +1,33 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+
+describe("e2e slash commands", () => {
+  let historyDir = "";
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    setMockRuntime({ historyDir, authToken: "test-token" });
+    mockDispatchScript().deliverFinal({ text: "ok" }).lifecycle("end").complete().install();
+  });
+  afterEach(() => {
+    resetMockDispatch();
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("/new /reset 透传为 202", async () => {
+    const app = createAppSimulator({ token: "test-token" });
+    const a = await app.sendMessage({ text: "/new", sessionKey: "sk1" });
+    expect(a.status).toBe(202);
+    const b = await app.sendMessage({ text: "/reset", sessionKey: "sk1" });
+    expect(b.status).toBe(202);
+  });
+
+  it("/stop 与非法斜杠路径可接受", async () => {
+    const app = createAppSimulator({ token: "test-token" });
+    const stop = await app.sendMessage({ text: "/stop", sessionKey: "sk2" });
+    expect(stop.status).toBe(202);
+    const illegal = await app.sendMessage({ text: "/???", sessionKey: "sk2" });
+    expect(illegal.status).toBe(202);
+  });
+});

package/src/e2e/status-cors-auth.e2e.test.ts

@@ -0,0 +1,41 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+import { registerFridayNextHttpRoutes } from "../http/server.js";
+
+describe("e2e status cors auth", () => {
+  let historyDir = "";
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+  });
+  afterEach(() => {
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("status 返回标准字段", async () => {
+    setMockRuntime({ historyDir, authToken: "test-token" });
+    const app = createAppSimulator({ token: "test-token" });
+    const status = await app.status();
+    expect(status.status).toBe(200);
+    expect(status.body.channel).toBe("friday-next");
+    expect(status.body.version).toBe("v2");
+  });
+
+  it("CORS 预检", async () => {
+    setMockRuntime({ historyDir, authToken: "test-token", corsEnabled: true, allowOrigin: "https://app.example" });
+    const app = createAppSimulator({ token: "test-token" });
+    const res = await app.options("/friday-next/events", "https://app.example");
+    expect(res.status).toBe(204);
+    expect(res.headers["access-control-allow-origin"]).toBe("https://app.example");
+  });
+
+  it("authToken 为空时警告", () => {
+    setMockRuntime({ historyDir, authToken: "" });
+    const warn = vi.fn();
+    registerFridayNextHttpRoutes({
+      logger: { info: vi.fn(), warn, error: vi.fn(), debug: vi.fn() },
+      registerHttpRoute: vi.fn(),
+    } as never);
+    expect(warn).toHaveBeenCalled();
+  });
+});

package/src/e2e/tool-lifecycle.e2e.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+
+describe("e2e tool lifecycle", () => {
+  let historyDir = "";
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    setMockRuntime({ historyDir, authToken: "test-token" });
+  });
+  afterEach(() => {
+    resetMockDispatch();
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("agent tool 流 + deliver 可达", async () => {
+    mockDispatchScript()
+      .lifecycle("start")
+      .toolStart(
+        "browser",
+        { action: "goto", url: "https://a.com" },
+        { meta: "navigate url=https://a.com", displayEmoji: "🌐", displayLabel: "Browser" },
+      )
+      .toolEnd("browser", { ok: true })
+      .toolError("exec", { message: "failed" })
+      .deliverFinal({ text: "done" })
+      .lifecycle("end")
+      .install();
+    const app = createAppSimulator({ token: "test-token" });
+    await app.connectSSE();
+    await app.sendMessage({ text: "run tools", sessionKey: "tool-sk" });
+    const frames = await app.waitForSse((f) => f.some((x) => x.event === "deliver"));
+    const agents = frames.filter((x) => x.event === "agent");
+    expect(agents.some((x) => (x.data?.stream as string) === "tool")).toBe(true);
+    const toolStart = agents.find(
+      (x) =>
+        (x.data?.stream as string) === "tool" &&
+        (x.data?.data as Record<string, unknown> | undefined)?.phase === "start",
+    );
+    const toolStartData = toolStart?.data?.data as Record<string, unknown> | undefined;
+    expect(toolStartData?.args).toEqual({ action: "goto", url: "https://a.com" });
+    expect(toolStartData?.meta).toBe("navigate url=https://a.com");
+    expect(toolStartData?.displayEmoji).toBe("🌐");
+    expect(toolStartData?.displayLabel).toBe("Browser");
+    expect(frames.some((x) => x.event === "deliver")).toBe(true);
+    app.disconnectSSE();
+  });
+});

package/src/friday-inbound-stats.ts

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