@syengup/friday-channel-next 0.0.34 → 0.0.37

package/dist/src/http/handlers/sse.js

@@ -0,0 +1,70 @@
+import { resolveFridayNextConfig } from "../../config.js";
+import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
+import { getFridayNextRuntime } from "../../runtime.js";
+import { sseEmitter } from "../../sse/emitter.js";
+import { extractBearerToken } from "../middleware/auth.js";
+function parseLastEventId(req, url) {
+    const query = Number.parseInt(url.searchParams.get("lastEventId") ?? "", 10);
+    if (Number.isFinite(query))
+        return query;
+    const header = Number.parseInt(req.headers["last-event-id"] ?? "", 10);
+    return Number.isFinite(header) ? header : 0;
+}
+export async function handleSseStream(req, res) {
+    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 deviceId = (url.searchParams.get("deviceId") ?? "").trim();
+    if (!deviceId) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing required query parameter: deviceId" }));
+        return true;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+    res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.flushHeaders();
+    const conn = sseEmitter.addConnection(deviceId, res);
+    const normalized = deviceId.trim().toUpperCase();
+    const lastSeq = sseEmitter.latestSeqForDevice(normalized);
+    sseEmitter.broadcast({
+        type: "connected",
+        data: {
+            deviceId: normalized,
+            serverTime: Date.now(),
+            lastSeq,
+        },
+    }, deviceId, true);
+    const lastEventId = parseLastEventId(req, url);
+    if (lastEventId > 0)
+        sseEmitter.replayBacklog(deviceId, lastEventId);
+    const config = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    const keepalive = setInterval(() => {
+        if (conn.isClosed) {
+            clearInterval(keepalive);
+            return;
+        }
+        conn.sendRaw(": keepalive\n\n");
+    }, config.sseKeepaliveSec * 1000);
+    keepalive.unref();
+    req.on("close", () => {
+        clearInterval(keepalive);
+        sseEmitter.removeConnection(deviceId, conn);
+    });
+    return true;
+}

package/dist/src/http/handlers/status.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function handleStatus(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

package/dist/src/http/handlers/status.js

@@ -0,0 +1,29 @@
+import { getActiveRunIds } from "../../agent/active-runs.js";
+import { sseEmitter } from "../../sse/emitter.js";
+import { extractBearerToken } from "../middleware/auth.js";
+export async function handleStatus(req, res) {
+    if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Method Not Allowed" }));
+        return true;
+    }
+    if (!extractBearerToken(req)) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const activeRuns = getActiveRunIds();
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({
+        ok: true,
+        channel: "friday-next",
+        version: "v2",
+        connections: sseEmitter.getConnectionCount(),
+        activeRuns,
+        activeRunCount: activeRuns.length,
+    }));
+    return true;
+}

package/dist/src/http/handlers/sync.d.ts

@@ -0,0 +1,7 @@
+/**
+ * POST /friday-next/sessions/{sessionKey}/sync
+ *
+ * Bidirectional incremental sync: pull remote messages (primary) + push local messages (offline catch-up).
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function handleSync(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

package/dist/src/http/handlers/sync.js

@@ -0,0 +1,56 @@
+import { extractBearerToken } from "../middleware/auth.js";
+import { readJsonBody } from "../middleware/body.js";
+import { processSync } from "../../sync/message-store.js";
+import { toSessionStoreKey } from "../../session/session-manager.js";
+function extractSessionKey(url, prefix, suffix) {
+    const pathname = new URL(url, "http://localhost").pathname;
+    if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
+        return null;
+    const middle = pathname.slice(prefix.length, pathname.length - suffix.length);
+    return decodeURIComponent(middle) || null;
+}
+export async function handleSync(req, res) {
+    if (req.method !== "POST") {
+        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" }));
+        return true;
+    }
+    const rawKey = extractSessionKey(req.url ?? "/", "/friday-next/sessions/", "/sync");
+    if (!rawKey) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing sessionKey in URL path" }));
+        return true;
+    }
+    const sessionKey = toSessionStoreKey(rawKey);
+    const body = await readJsonBody(req);
+    if (!body) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Invalid JSON body" }));
+        return true;
+    }
+    const deviceId = typeof body.deviceId === "string" ? body.deviceId.trim() : "";
+    if (!deviceId) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing required field: deviceId" }));
+        return true;
+    }
+    const syncSeq = typeof body.syncSeq === "number" ? Math.floor(body.syncSeq) : 0;
+    const lastServerId = typeof body.lastServerId === "string" ? body.lastServerId : undefined;
+    const messages = Array.isArray(body.messages) ? body.messages : [];
+    const result = processSync({ sessionKey, deviceId, syncSeq, lastServerId, messages });
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(result));
+    return true;
+}

package/dist/src/http/middleware/auth.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bearer token authentication middleware for Friday HTTP routes.
+ *
+ * Validates that the bearer token matches the gateway's configured auth token.
+ * This ensures plugin HTTP endpoints use the same token as gateway WS connections.
+ */
+import type { IncomingMessage } from "node:http";
+/**
+ * Extract and validate bearer token from Authorization header.
+ * Returns the token only if it matches the gateway's configured auth token.
+ * Returns null if token is missing, malformed, or doesn't match.
+ */
+export declare function extractBearerToken(req: IncomingMessage): string | null;

package/dist/src/http/middleware/auth.js

@@ -0,0 +1,29 @@
+/**
+ * Bearer token authentication middleware for Friday HTTP routes.
+ *
+ * Validates that the bearer token matches the gateway's configured auth token.
+ * This ensures plugin HTTP endpoints use the same token as gateway WS connections.
+ */
+import { resolveFridayNextConfig } from "../../config.js";
+import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
+import { getFridayNextRuntime } from "../../runtime.js";
+/**
+ * Extract and validate bearer token from Authorization header.
+ * Returns the token only if it matches the gateway's configured auth token.
+ * Returns null if token is missing, malformed, or doesn't match.
+ */
+export function extractBearerToken(req) {
+    const auth = req.headers.authorization;
+    if (!auth || typeof auth !== "string")
+        return null;
+    const parts = auth.trim().split(/\s+/);
+    if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer")
+        return null;
+    const token = parts[1];
+    // Validate token matches the gateway's configured auth token.
+    const cfg = getHostOpenClawConfigSnapshot(getFridayNextRuntime().config);
+    const runtimeConfig = resolveFridayNextConfig(cfg);
+    if (!runtimeConfig.authToken || token !== runtimeConfig.authToken)
+        return null;
+    return token;
+}

package/dist/src/http/middleware/body.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage } from "node:http";
+export declare function readJsonBody(req: IncomingMessage, maxBytes?: number): Promise<Record<string, unknown> | null>;

package/dist/src/http/middleware/body.js

@@ -0,0 +1,24 @@
+export async function readJsonBody(req, maxBytes = 2 * 1024 * 1024) {
+    return await new Promise((resolve) => {
+        const chunks = [];
+        let total = 0;
+        req.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > maxBytes) {
+                resolve(null);
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+            }
+            catch {
+                resolve(null);
+            }
+        });
+        req.on("error", () => resolve(null));
+    });
+}

package/dist/src/http/middleware/cors.d.ts

@@ -0,0 +1,2 @@
+import type { ServerResponse } from "node:http";
+export declare function applyCorsHeaders(res: ServerResponse): void;

package/dist/src/http/middleware/cors.js

@@ -0,0 +1,11 @@
+import { resolveFridayNextConfig } from "../../config.js";
+import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
+import { getFridayNextRuntime } from "../../runtime.js";
+export function applyCorsHeaders(res) {
+    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    if (!cfg.corsEnabled)
+        return;
+    res.setHeader("Access-Control-Allow-Origin", cfg.corsAllowOrigin || "*");
+    res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, Last-Event-ID");
+    res.setHeader("Access-Control-Allow-Methods", "GET,POST,DELETE,OPTIONS");
+}

package/dist/src/http/server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * HTTP server registration for the Friday channel.
+ *
+ * Registers routes on the gateway HTTP server under the /friday-next/ path prefix.
+ * Routes are registered via the plugin API's registerHttpRoute method.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function registerFridayNextHttpRoutes(api: {
+    logger: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+    };
+    registerHttpRoute: (route: {
+        path: string;
+        handler: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+        auth: string;
+        match: string;
+    }) => void;
+}): void;

package/dist/src/http/server.js

@@ -0,0 +1,87 @@
+/**
+ * HTTP server registration for the Friday channel.
+ *
+ * Registers routes on the gateway HTTP server under the /friday-next/ path prefix.
+ * Routes are registered via the plugin API's registerHttpRoute method.
+ */
+import { handleMessages } from "./handlers/messages.js";
+import { handleSseStream } from "./handlers/sse.js";
+import { handleFilesUpload } from "./handlers/files-upload.js";
+import { handleFilesDownload } from "./handlers/files-download.js";
+import { handleCancel } from "./handlers/cancel.js";
+import { handleDeviceApprove } from "./handlers/device-approve.js";
+import { handleNodesApprove } from "./handlers/nodes-approve.js";
+import { handleSessionsDelete } from "./handlers/sessions-delete.js";
+import { handleSessionsSettings } from "./handlers/sessions-settings.js";
+import { handleModelsList } from "./handlers/models-list.js";
+import { handleStatus } from "./handlers/status.js";
+import { applyCorsHeaders } from "./middleware/cors.js";
+import { resolveFridayNextConfig } from "../config.js";
+import { getHostOpenClawConfigSnapshot } from "../host-config.js";
+import { getFridayNextRuntime } from "../runtime.js";
+import { sseEmitter } from "../sse/emitter.js";
+/** Route matcher - returns the matched handler or null. */
+async function handleFridayNextRoute(req, res) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const pathname = url.pathname;
+    applyCorsHeaders(res);
+    if (req.method === "OPTIONS") {
+        res.statusCode = 204;
+        res.end();
+        return true;
+    }
+    // Route: GET /friday-next/events?deviceId=...
+    if (req.method === "GET" && pathname === "/friday-next/events") {
+        return await handleSseStream(req, res);
+    }
+    // Route: POST /friday-next/messages
+    if (req.method === "POST" && pathname === "/friday-next/messages") {
+        return await handleMessages(req, res);
+    }
+    // Route: POST /friday-next/files (multipart upload)
+    if (req.method === "POST" && pathname === "/friday-next/files") {
+        return await handleFilesUpload(req, res);
+    }
+    // Route: GET /friday-next/files/:id (download)
+    if (req.method === "GET" && pathname.startsWith("/friday-next/files/")) {
+        return await handleFilesDownload(req, res);
+    }
+    if (req.method === "POST" && pathname === "/friday-next/cancel") {
+        return await handleCancel(req, res);
+    }
+    if (req.method === "POST" && pathname === "/friday-next/device-approve") {
+        return await handleDeviceApprove(req, res);
+    }
+    if (req.method === "POST" && pathname === "/friday-next/nodes-approve") {
+        return await handleNodesApprove(req, res);
+    }
+    if (req.method === "DELETE" && pathname === "/friday-next/sessions") {
+        return await handleSessionsDelete(req, res);
+    }
+    if ((req.method === "PUT" || req.method === "GET") && pathname === "/friday-next/sessions/settings") {
+        return await handleSessionsSettings(req, res);
+    }
+    if (req.method === "GET" && pathname === "/friday-next/models") {
+        return await handleModelsList(req, res);
+    }
+    if (req.method === "GET" && pathname === "/friday-next/status") {
+        return await handleStatus(req, res);
+    }
+    // Not found
+    return false;
+}
+export function registerFridayNextHttpRoutes(api) {
+    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    sseEmitter.setBacklogLimit(cfg.sseBacklogPerDevice);
+    if (!cfg.authToken) {
+        api.logger.warn("friday-next authToken not configured; all requests will 401");
+    }
+    // Plugin handles its own auth via extractBearerToken()
+    api.registerHttpRoute({
+        path: "/friday-next",
+        handler: handleFridayNextRoute,
+        auth: "plugin",
+        match: "prefix",
+    });
+    api.logger.info("Friday Next channel HTTP routes registered at /friday-next/*");
+}

package/dist/src/logging.d.ts

@@ -0,0 +1,7 @@
+import type { FridayNextLogLevel } from "./config.js";
+export declare function createFridayNextLogger(scope: string, level?: FridayNextLogLevel): {
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+};

package/dist/src/logging.js

@@ -0,0 +1,28 @@
+const levelOrder = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+export function createFridayNextLogger(scope, level = "info") {
+    const base = `[friday-next:${scope}]`;
+    const enabled = (current) => levelOrder[current] >= levelOrder[level];
+    return {
+        debug: (message) => {
+            if (enabled("debug"))
+                console.debug(`${base} ${message}`);
+        },
+        info: (message) => {
+            if (enabled("info"))
+                console.info(`${base} ${message}`);
+        },
+        warn: (message) => {
+            if (enabled("warn"))
+                console.warn(`${base} ${message}`);
+        },
+        error: (message) => {
+            if (enabled("error"))
+                console.error(`${base} ${message}`);
+        },
+    };
+}

package/dist/src/push/apns.d.ts

@@ -0,0 +1,15 @@
+type DeliverNotificationOpts = {
+    deviceId: string;
+    token: string;
+    summary: string;
+    sessionKey: string;
+    runId: string;
+};
+export declare class FridayPushService {
+    private provider;
+    private apn;
+    private getProvider;
+    sendDeliverNotification(opts: DeliverNotificationOpts): Promise<void>;
+}
+export declare const fridayPush: FridayPushService;
+export {};

package/dist/src/push/apns.js

@@ -0,0 +1,56 @@
+import { resolveFridayNextConfig } from "../config.js";
+import { getHostOpenClawConfigSnapshot } from "../host-config.js";
+import { getFridayNextRuntime } from "../runtime.js";
+export class FridayPushService {
+    provider = null;
+    apn = null;
+    async getProvider() {
+        const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+        const apnsCfg = cfg.push.apns;
+        if (!apnsCfg)
+            return null;
+        if (!this.apn) {
+            try {
+                this.apn = await import("apn");
+            }
+            catch {
+                return null;
+            }
+        }
+        const { keyPath, keyId, teamId, bundleId, production } = apnsCfg;
+        if (!keyPath || !keyId || !teamId)
+            return null;
+        if (!this.provider) {
+            this.provider = new this.apn.Provider({
+                token: {
+                    key: keyPath,
+                    keyId,
+                    teamId,
+                },
+                production,
+            });
+        }
+        return { provider: this.provider, apn: this.apn, bundleId };
+    }
+    async sendDeliverNotification(opts) {
+        const ctx = await this.getProvider();
+        if (!ctx)
+            return;
+        const { provider, apn, bundleId } = ctx;
+        const note = new apn.Notification();
+        note.alert = {
+            title: "Friday",
+            body: opts.summary || "New reply ready",
+        };
+        note.sound = "default";
+        note.mutableContent = 1;
+        note.topic = bundleId;
+        note.payload = {
+            sessionKey: opts.sessionKey,
+            runId: opts.runId,
+            deviceId: opts.deviceId,
+        };
+        await provider.send(note, opts.token);
+    }
+}
+export const fridayPush = new FridayPushService();

package/dist/src/push/device-tokens.d.ts

@@ -0,0 +1,3 @@
+export declare function saveToken(deviceId: string, token: string): void;
+export declare function getToken(deviceId: string): string | null;
+export declare function removeToken(deviceId: string): void;

package/dist/src/push/device-tokens.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function tokensPath() {
+    return path.join(os.homedir(), ".openclaw", "friday-next", "device-tokens.json");
+}
+function loadTokens() {
+    const file = tokensPath();
+    if (!fs.existsSync(file))
+        return {};
+    try {
+        const raw = fs.readFileSync(file, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function saveTokens(tokens) {
+    const file = tokensPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(tokens, null, 2), "utf8");
+}
+export function saveToken(deviceId, token) {
+    const key = deviceId.trim().toUpperCase();
+    const tokens = loadTokens();
+    tokens[key] = { token, updatedAt: Date.now() };
+    saveTokens(tokens);
+}
+export function getToken(deviceId) {
+    const key = deviceId.trim().toUpperCase();
+    return loadTokens()[key]?.token ?? null;
+}
+export function removeToken(deviceId) {
+    const key = deviceId.trim().toUpperCase();
+    const tokens = loadTokens();
+    delete tokens[key];
+    saveTokens(tokens);
+}

package/dist/src/run-metadata.d.ts

@@ -0,0 +1,25 @@
+type RunRoute = {
+    runId: string;
+    deviceId: string;
+    sessionKey: string;
+};
+export type RunMetadata = {
+    modelName?: string;
+    totalTokens?: number;
+    /** Tokens counted toward the model context window (prompt-side: input + cache read + cache write when present). */
+    contextTokensUsed?: number;
+    /** Resolved model context window limit when the runtime exposes it. */
+    contextWindowMax?: number;
+};
+/** Vitest / harness: clears per-run metadata and final-delivered flags (not routes). */
+export declare function resetRunMetadataForTest(): void;
+export declare function registerRunRoute(route: RunRoute): void;
+export declare function getRunRoute(runId: string): RunRoute | undefined;
+export declare function setRunMetadata(runId: string, metadata: RunMetadata): void;
+export declare function getRunMetadata(runId: string): RunMetadata | undefined;
+export declare function markRunFinalDelivered(runId: string): void;
+export declare function hasRunFinalDelivered(runId: string): boolean;
+/** Best-effort prompt-side context footprint from a provider usage object. */
+export declare function contextTokensFromUsageRecord(u: Record<string, unknown>): number | undefined;
+export declare function ingestAgentEventMetadata(runId: string, data: Record<string, unknown>): void;
+export {};