@syengup/friday-channel-next 0.0.1

package/src/test-support/app-simulator.ts

@@ -0,0 +1,243 @@
+import { EventEmitter } from "node:events";
+import { Readable, Writable } from "node:stream";
+import { registerFridayNextHttpRoutes } from "../http/server.js";
+
+type Headers = Record<string, string>;
+
+export type SseFrame = {
+  id?: number;
+  event?: string;
+  data?: Record<string, unknown>;
+  raw: string;
+};
+
+class MockReq extends Readable {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+
+  constructor(method: string, url: string, headers: Record<string, string>, body?: Buffer) {
+    super();
+    this.method = method;
+    this.url = url;
+    this.headers = headers;
+    if (body && body.length > 0) this.push(body);
+    this.push(null);
+  }
+
+  _read(): void {
+    // no-op
+  }
+}
+
+class MockRes extends Writable {
+  statusCode = 200;
+  headers: Record<string, string> = {};
+  body = Buffer.alloc(0);
+  writes: string[] = [];
+  headersSent = false;
+
+  _write(chunk: Buffer | string, _enc: BufferEncoding, cb: (err?: Error | null) => void): void {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    this.writes.push(buf.toString("utf-8"));
+    this.body = Buffer.concat([this.body, buf]);
+    cb();
+  }
+
+  setHeader(name: string, value: string): void {
+    this.headers[name.toLowerCase()] = String(value);
+  }
+
+  getHeader(name: string): string | undefined {
+    return this.headers[name.toLowerCase()];
+  }
+
+  flushHeaders(): void {
+    this.headersSent = true;
+  }
+
+  end(chunk?: Buffer | string): this {
+    if (chunk) {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      this.writes.push(buf.toString("utf-8"));
+      this.body = Buffer.concat([this.body, buf]);
+    }
+    this.emit("finish");
+    return this;
+  }
+}
+
+function createRouteHarness() {
+  let routeHandler: ((req: Readable & { method?: string; url?: string }, res: Writable) => Promise<boolean>) | null = null;
+  const fakeApi = {
+    logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
+    registerHttpRoute(route: { handler: (req: never, res: never) => Promise<boolean> }) {
+      routeHandler = route.handler as never;
+    },
+  };
+  registerFridayNextHttpRoutes(fakeApi as never);
+  if (!routeHandler) throw new Error("route handler not registered");
+  return routeHandler;
+}
+
+function parseSseFrames(rawChunks: string[]): SseFrame[] {
+  const frames: SseFrame[] = [];
+  const joined = rawChunks.join("");
+  for (const raw of joined.split("\n\n")) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith(":")) continue;
+    const frame: SseFrame = { raw };
+    for (const line of trimmed.split("\n")) {
+      if (line.startsWith("id:")) frame.id = Number.parseInt(line.slice(3).trim(), 10);
+      if (line.startsWith("event:")) frame.event = line.slice(6).trim();
+      if (line.startsWith("data:")) {
+        const text = line.slice(5).trim();
+        try {
+          frame.data = JSON.parse(text) as Record<string, unknown>;
+        } catch {
+          frame.data = { raw: text };
+        }
+      }
+    }
+    frames.push(frame);
+  }
+  return frames;
+}
+
+function jsonBody(res: MockRes): Record<string, unknown> {
+  const text = res.body.toString("utf-8");
+  if (!text) return {};
+  return JSON.parse(text) as Record<string, unknown>;
+}
+
+export async function waitFor(
+  predicate: () => boolean,
+  timeoutMs = 2000,
+  tickMs = 10,
+): Promise<void> {
+  const start = Date.now();
+  while (!predicate()) {
+    if (Date.now() - start > timeoutMs) throw new Error("waitFor timeout");
+    await new Promise((r) => setTimeout(r, tickMs));
+  }
+}
+
+export function createAppSimulator(opts?: { deviceId?: string; token?: string }) {
+  const routeHandler = createRouteHarness();
+  const token = opts?.token ?? "test-token";
+  const deviceId = opts?.deviceId ?? "DEV-A";
+
+  let sseReq: (Readable & EventEmitter) | null = null;
+  let sseRes: MockRes | null = null;
+
+  const request = async (arg: {
+    method: string;
+    path: string;
+    headers?: Headers;
+    body?: Buffer | string;
+  }): Promise<MockRes> => {
+    const headers = {
+      authorization: `Bearer ${token}`,
+      ...(arg.headers ?? {}),
+    };
+    const body = typeof arg.body === "string" ? Buffer.from(arg.body) : arg.body;
+    const req = new MockReq(arg.method, arg.path, headers, body);
+    const res = new MockRes();
+    await routeHandler(req as never, res as never);
+    return res;
+  };
+
+  return {
+    async connectSSE(arg?: { deviceId?: string; lastEventId?: number; token?: string }) {
+      const did = (arg?.deviceId ?? deviceId).trim();
+      const headers: Headers = { authorization: `Bearer ${arg?.token ?? token}` };
+      const q = new URLSearchParams({ deviceId: did });
+      if (arg?.lastEventId != null && arg.lastEventId > 0) {
+        q.set("lastEventId", String(arg.lastEventId));
+        headers["last-event-id"] = String(arg.lastEventId);
+      }
+      sseReq = new MockReq("GET", `/friday-next/events?${q.toString()}`, headers);
+      sseRes = new MockRes();
+      await routeHandler(sseReq as never, sseRes as never);
+      return sseRes;
+    },
+    disconnectSSE() {
+      sseReq?.emit("close");
+      sseReq = null;
+      sseRes = null;
+    },
+    getSseFrames(): SseFrame[] {
+      return parseSseFrames(sseRes?.writes ?? []);
+    },
+    async waitForSse(predicate: (frames: SseFrame[]) => boolean, timeoutMs = 2000) {
+      await waitFor(() => predicate(parseSseFrames(sseRes?.writes ?? [])), timeoutMs);
+      return parseSseFrames(sseRes?.writes ?? []);
+    },
+    async sendMessage(arg: {
+      text?: string;
+      deviceId?: string;
+      sessionKey?: string;
+      attachments?: string[];
+    }) {
+      const payload = {
+        deviceId: arg.deviceId ?? deviceId,
+        text: arg.text ?? "",
+        sessionKey: arg.sessionKey ?? "s1",
+        attachments: arg.attachments ?? [],
+      };
+      const res = await request({
+        method: "POST",
+        path: "/friday-next/messages",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+      return { status: res.statusCode, body: jsonBody(res) };
+    },
+    async uploadFiles(parts: Array<{ name: string; filename: string; contentType: string; content: string | Buffer }>) {
+      const boundary = "----friday-next-e2e-boundary";
+      const chunks: Buffer[] = [];
+      for (const part of parts) {
+        const head =
+          `--${boundary}\r\n` +
+          `Content-Disposition: form-data; name="${part.name}"; filename="${part.filename}"\r\n` +
+          `Content-Type: ${part.contentType}\r\n\r\n`;
+        chunks.push(Buffer.from(head));
+        chunks.push(Buffer.isBuffer(part.content) ? part.content : Buffer.from(part.content));
+        chunks.push(Buffer.from("\r\n"));
+      }
+      chunks.push(Buffer.from(`--${boundary}--\r\n`));
+      const res = await request({
+        method: "POST",
+        path: "/friday-next/files",
+        headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
+        body: Buffer.concat(chunks),
+      });
+      return { status: res.statusCode, body: jsonBody(res) };
+    },
+    async downloadFile(url: string, headers?: Headers) {
+      const res = await request({ method: "GET", path: url, headers });
+      return { status: res.statusCode, body: res.body, headers: res.headers };
+    },
+    async cancel(runId: string) {
+      const res = await request({
+        method: "POST",
+        path: "/friday-next/cancel",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ runId }),
+      });
+      return { status: res.statusCode, body: jsonBody(res) };
+    },
+    async status() {
+      const res = await request({ method: "GET", path: "/friday-next/status" });
+      return { status: res.statusCode, body: jsonBody(res), headers: res.headers };
+    },
+    async options(path: string, origin = "https://example.com") {
+      const res = await request({ method: "OPTIONS", path, headers: { origin } });
+      return { status: res.statusCode, headers: res.headers };
+    },
+    async rawRequest(arg: { method: string; path: string; headers?: Headers; body?: string | Buffer }) {
+      const res = await request(arg);
+      return { status: res.statusCode, body: res.body.toString("utf-8"), headers: res.headers };
+    },
+  };
+}

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

@@ -0,0 +1,181 @@
+import { __setMockFridayDispatchForTests, __resetMockFridayDispatchForTests } from "../agent/dispatch-bridge.js";
+import { forwardAgentEventRaw } from "../friday-session.js";
+
+type DispatchArg = Parameters<typeof __setMockFridayDispatchForTests>[0] extends (arg: infer A) => unknown
+  ? A
+  : never;
+
+type DispatchCallbacks = NonNullable<DispatchArg["dispatcherOptions"]>;
+
+type ScriptStep = (args: DispatchArg, callbacks: DispatchCallbacks) => Promise<void> | void;
+
+function runIdFromArgs(args: DispatchArg): string {
+  return (args as { replyOptions?: { runId?: string } })?.replyOptions?.runId ?? "mock-run";
+}
+
+function sessionKeyFromArgs(args: DispatchArg): string {
+  return (args as { ctx?: { SessionKey?: string } })?.ctx?.SessionKey ?? "";
+}
+
+export class MockDispatchScript {
+  private readonly steps: ScriptStep[] = [];
+
+  lifecycle(phase: "start" | "end" | "error"): this {
+    this.steps.push((args, _callbacks) => {
+      const runId = runIdFromArgs(args);
+      const sessionKey = sessionKeyFromArgs(args);
+      forwardAgentEventRaw({
+        runId,
+        seq: 1,
+        ts: Date.now(),
+        stream: "lifecycle",
+        data: { phase },
+        sessionKey,
+      });
+    });
+    return this;
+  }
+
+  reasoning(text: string): this {
+    this.steps.push((args, _callbacks) => {
+      const runId = runIdFromArgs(args);
+      const sessionKey = sessionKeyFromArgs(args);
+      forwardAgentEventRaw({
+        runId,
+        seq: 1,
+        ts: Date.now(),
+        stream: "thinking",
+        data: { phase: "delta", text },
+        sessionKey,
+      });
+    });
+    return this;
+  }
+
+  reasoningEnd(): this {
+    return this;
+  }
+
+  partial(text: string): this {
+    this.steps.push((args, _callbacks) => {
+      const runId = runIdFromArgs(args);
+      const sessionKey = sessionKeyFromArgs(args);
+      forwardAgentEventRaw({
+        runId,
+        seq: 1,
+        ts: Date.now(),
+        stream: "assistant",
+        data: { phase: "delta", text },
+        sessionKey,
+      });
+    });
+    return this;
+  }
+
+  toolStart(
+    name: string,
+    toolArgs: unknown,
+    options?: { meta?: string; displayEmoji?: string; displayLabel?: string },
+  ): this {
+    this.steps.push((dispatchArgs, _callbacks) => {
+      const runId = runIdFromArgs(dispatchArgs);
+      const sessionKey = sessionKeyFromArgs(dispatchArgs);
+      forwardAgentEventRaw({
+        runId,
+        seq: 1,
+        ts: Date.now(),
+        stream: "tool",
+        data: {
+          phase: "start",
+          name,
+          args: toolArgs,
+          ...(options?.meta ? { meta: options.meta } : {}),
+          ...(options?.displayEmoji ? { displayEmoji: options.displayEmoji } : {}),
+          ...(options?.displayLabel ? { displayLabel: options.displayLabel } : {}),
+        },
+        sessionKey,
+      });
+    });
+    return this;
+  }
+
+  toolEnd(name: string, result: unknown): this {
+    this.steps.push((args, _callbacks) => {
+      const runId = runIdFromArgs(args);
+      const sessionKey = sessionKeyFromArgs(args);
+      forwardAgentEventRaw({
+        runId,
+        seq: 1,
+        ts: Date.now(),
+        stream: "tool",
+        data: { phase: "end", name, result },
+        sessionKey,
+      });
+    });
+    return this;
+  }
+
+  toolError(name: string, error: unknown): this {
+    this.steps.push((args, _callbacks) => {
+      const runId = runIdFromArgs(args);
+      const sessionKey = sessionKeyFromArgs(args);
+      forwardAgentEventRaw({
+        runId,
+        seq: 1,
+        ts: Date.now(),
+        stream: "tool",
+        data: { phase: "error", name, error },
+        sessionKey,
+      });
+    });
+    return this;
+  }
+
+  block(text: string, mediaUrls: string[] = [], audioAsVoice = false): this {
+    this.steps.push(async (_args, callbacks) => {
+      await callbacks.deliver?.({ text, mediaUrls, audioAsVoice } as never, { kind: "block" } as never);
+    });
+    return this;
+  }
+
+  deliverFinal(payload: { text: string; mediaUrls?: string[]; audioAsVoice?: boolean; isError?: boolean }): this {
+    this.steps.push(async (_args, callbacks) => {
+      await callbacks.deliver?.(payload as never, { kind: "final" } as never);
+    });
+    return this;
+  }
+
+  throwError(error: string): this {
+    this.steps.push((_args, callbacks) => {
+      callbacks.onError?.(new Error(error));
+    });
+    return this;
+  }
+
+  complete(): this {
+    return this;
+  }
+
+  install(): { restore: () => void; calls: DispatchArg[] } {
+    const calls: DispatchArg[] = [];
+    __setMockFridayDispatchForTests(async (args) => {
+      calls.push(args as DispatchArg);
+      const callbacks = (args.dispatcherOptions ?? {}) as DispatchCallbacks;
+      for (const step of this.steps) {
+        await step(args as DispatchArg, callbacks);
+      }
+    });
+    return {
+      restore: () => __resetMockFridayDispatchForTests(),
+      calls,
+    };
+  }
+}
+
+export function mockDispatchScript(): MockDispatchScript {
+  return new MockDispatchScript();
+}
+
+export function resetMockDispatch(): void {
+  __resetMockFridayDispatchForTests();
+}

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

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { setFridayNextRuntime } from "../runtime.js";
+import { setOfflineQueueBaseDirForTest } from "../sse/offline-queue.js";
+import { sseEmitter } from "../sse/emitter.js";
+import { resetActiveRunsForTest } from "../agent/active-runs.js";
+import { resetRunMetadataForTest } from "../run-metadata.js";
+
+export type MockRuntimeOptions = {
+  authToken?: string;
+  corsEnabled?: boolean;
+  allowOrigin?: string;
+  historyDir?: string;
+  sseKeepaliveSec?: number;
+  sseBacklogPerDevice?: number;
+};
+
+export function createTempHistoryDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "friday-next-e2e-"));
+}
+
+export function removeTempHistoryDir(dir: string): void {
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+}
+
+export function setMockRuntime(opts: MockRuntimeOptions = {}): void {
+  sseEmitter.resetForTest();
+  resetActiveRunsForTest();
+  resetRunMetadataForTest();
+  const historyDir = opts.historyDir ?? createTempHistoryDir();
+  setOfflineQueueBaseDirForTest(path.join(historyDir, "events-queue"));
+  const cfg = {
+    gateway: {
+      auth: {
+        token: opts.authToken ?? "test-token",
+      },
+    },
+    channels: {
+      "friday-next": {
+        enabled: true,
+        transport: "http+sse",
+        pathPrefix: "/friday-next",
+        historyLimit: 25,
+        historyDir,
+        logLevel: "info",
+        authToken: opts.authToken ?? "test-token",
+        cors: {
+          enabled: opts.corsEnabled ?? false,
+          allowOrigin: opts.allowOrigin ?? "*",
+        },
+        sse: {
+          keepaliveSec: opts.sseKeepaliveSec ?? 30,
+          backlogPerDevice: opts.sseBacklogPerDevice ?? 200,
+        },
+      },
+    },
+  };
+  setFridayNextRuntime({
+    config: {
+      loadConfig: () => cfg,
+    },
+    logger: {
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      debug: () => {},
+    },
+  } as never);
+}

package/src/vendor/runtime-store.ts

@@ -0,0 +1,99 @@
+/**
+ * Vendored from OpenClaw `plugin-sdk/runtime-store` (tiny, no transitive deps).
+ * Keeps friday-next HTTP tests from importing the full gateway graph.
+ */
+
+const pluginRuntimeStoreRegistryKey = Symbol.for("openclaw.plugin-sdk.runtime-store-registry");
+
+type PluginRuntimeStoreRegistry = Map<string, { runtime: unknown }>;
+type PluginRuntimeStoreKeyOptions = {
+  key: string;
+  errorMessage: string;
+};
+type PluginRuntimeStorePluginOptions = {
+  pluginId: string;
+  errorMessage: string;
+};
+type PluginRuntimeStoreOptions = PluginRuntimeStoreKeyOptions | PluginRuntimeStorePluginOptions;
+
+function getPluginRuntimeStoreRegistry(): PluginRuntimeStoreRegistry {
+  const globalRecord = globalThis as typeof globalThis & {
+    [pluginRuntimeStoreRegistryKey]?: PluginRuntimeStoreRegistry;
+  };
+  globalRecord[pluginRuntimeStoreRegistryKey] ??= new Map();
+  return globalRecord[pluginRuntimeStoreRegistryKey];
+}
+
+function pluginRuntimeStoreKeyForPluginId(pluginId: string): string {
+  const normalizedPluginId = pluginId.trim();
+  if (!normalizedPluginId) {
+    throw new Error("createPluginRuntimeStore: pluginId must not be empty");
+  }
+  return `plugin-runtime:${normalizedPluginId}`;
+}
+
+function resolvePluginRuntimeStoreOptions(
+  options: string | PluginRuntimeStoreOptions,
+): PluginRuntimeStoreKeyOptions {
+  if (typeof options === "string") {
+    return { key: options, errorMessage: options };
+  }
+  if ("pluginId" in options) {
+    return {
+      key: pluginRuntimeStoreKeyForPluginId(options.pluginId),
+      errorMessage: options.errorMessage,
+    };
+  }
+  return options;
+}
+
+export function createPluginRuntimeStore<T>(errorMessage: string): {
+  setRuntime: (next: T) => void;
+  clearRuntime: () => void;
+  tryGetRuntime: () => T | null;
+  getRuntime: () => T;
+};
+export function createPluginRuntimeStore<T>(options: PluginRuntimeStoreOptions): {
+  setRuntime: (next: T) => void;
+  clearRuntime: () => void;
+  tryGetRuntime: () => T | null;
+  getRuntime: () => T;
+};
+export function createPluginRuntimeStore<T>(options: string | PluginRuntimeStoreOptions): {
+  setRuntime: (next: T) => void;
+  clearRuntime: () => void;
+  tryGetRuntime: () => T | null;
+  getRuntime: () => T;
+} {
+  const resolved = resolvePluginRuntimeStoreOptions(options);
+  const slot =
+    typeof options === "string"
+      ? { runtime: null as unknown }
+      : (() => {
+          const registry = getPluginRuntimeStoreRegistry();
+          let existingSlot = registry.get(resolved.key);
+          if (!existingSlot) {
+            existingSlot = { runtime: null };
+            registry.set(resolved.key, existingSlot);
+          }
+          return existingSlot;
+        })();
+
+  return {
+    setRuntime(next: T) {
+      slot.runtime = next;
+    },
+    clearRuntime() {
+      slot.runtime = null;
+    },
+    tryGetRuntime() {
+      return (slot.runtime as T | null) ?? null;
+    },
+    getRuntime() {
+      if (slot.runtime === null) {
+        throw new Error(resolved.errorMessage);
+      }
+      return slot.runtime as T;
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "resolveJsonModule": true,
+    "outDir": "dist",
+    "declaration": true,
+    "sourceMap": false,
+    "declarationMap": false
+  },
+  "include": ["index.ts", "src/**/*.ts", "src/**/*.d.ts"],
+  "exclude": ["src/e2e/**", "src/**/*.test.ts", "src/test-support/**", "scripts/**"]
+}