@syengup/friday-channel-next 0.0.35 → 0.0.38

package/dist/src/http/handlers/nodes-approve.js

@@ -0,0 +1,146 @@
+import { exec } from "node:child_process";
+import { readJsonBody } from "../middleware/body.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { createFridayNextLogger } from "../../logging.js";
+const EXEC_ENV = process.platform === "win32"
+    ? process.env
+    : { ...process.env, PATH: `/opt/homebrew/bin:/usr/local/bin:/home/linuxbrew/.linuxbrew/bin:${process.env.PATH ?? ""}` };
+function execAsync(command, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = exec(command, { encoding: "utf-8", timeout: timeoutMs, maxBuffer: 1024 * 1024, env: EXEC_ENV }, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve({ stdout, stderr });
+            }
+        });
+        child.stdout?.on("data", () => { });
+        child.stderr?.on("data", () => { });
+    });
+}
+export async function handleNodesApprove(req, res) {
+    const log = createFridayNextLogger("nodes-approve");
+    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: bearer token mismatch" }));
+        return true;
+    }
+    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 rawNodeId = typeof body.nodeId === "string" ? body.nodeId : "";
+    if (!rawNodeId.trim()) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing required field: nodeId" }));
+        return true;
+    }
+    const normalizedNodeId = rawNodeId.trim().toUpperCase();
+    let listStdout;
+    try {
+        const result = await execAsync("openclaw nodes list --json", 15000);
+        listStdout = result.stdout;
+    }
+    catch (err) {
+        const stderr = err?.stderr?.trim();
+        log.error(`nodes list failed: ${err instanceof Error ? err.message : String(err)}`);
+        res.statusCode = 502;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Failed to list nodes from gateway", detail: stderr || undefined }));
+        return true;
+    }
+    let listData;
+    try {
+        listData = JSON.parse(listStdout);
+    }
+    catch {
+        log.error(`nodes list returned invalid JSON: ${listStdout.slice(0, 200)}`);
+        res.statusCode = 502;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unexpected response from gateway node list" }));
+        return true;
+    }
+    const pending = listData.pending ?? [];
+    const pendingMatch = pending.find((entry) => entry.nodeId.trim().toUpperCase() === normalizedNodeId);
+    if (pendingMatch) {
+        const requestId = pendingMatch.requestId;
+        log.info(`approving nodeId=${normalizedNodeId} requestId=${requestId}`);
+        let approveStdout;
+        try {
+            const result = await execAsync(`openclaw nodes approve ${requestId} --json`, 15000);
+            approveStdout = result.stdout;
+        }
+        catch (err) {
+            const stderr = err?.stderr?.trim();
+            log.error(`nodes approve failed: ${err instanceof Error ? err.message : String(err)}`);
+            res.statusCode = 502;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                error: "Node approval command failed",
+                detail: stderr || (err instanceof Error ? err.message : "Unknown error"),
+            }));
+            return true;
+        }
+        let approveData;
+        try {
+            approveData = JSON.parse(approveStdout);
+        }
+        catch {
+            log.error(`nodes approve returned non-JSON: ${approveStdout.slice(0, 200)}`);
+            res.statusCode = 502;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Unexpected response from node approval" }));
+            return true;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({
+            ok: true,
+            nodeId: normalizedNodeId,
+            requestId: approveData.requestId,
+            approvedAtMs: approveData.node?.approvedAtMs,
+        }));
+        return true;
+    }
+    // Not in pending — check if already paired with non-empty caps/commands
+    const paired = listData.paired ?? [];
+    const pairedMatch = paired.find((entry) => entry.nodeId.trim().toUpperCase() === normalizedNodeId);
+    if (pairedMatch) {
+        const caps = pairedMatch.caps ?? [];
+        const commands = pairedMatch.commands ?? [];
+        if (caps.length > 0 || commands.length > 0) {
+            log.info(`nodeId=${normalizedNodeId} already paired with caps=${caps.length} commands=${commands.length}`);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                ok: true,
+                nodeId: normalizedNodeId,
+                alreadyApproved: true,
+                approvedAtMs: pairedMatch.approvedAtMs,
+                caps,
+                commands,
+            }));
+            return true;
+        }
+    }
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({
+        error: "No pending node found for this nodeId",
+        nodeId: normalizedNodeId,
+    }));
+    return true;
+}

package/dist/src/http/handlers/sessions-delete.d.ts

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

package/dist/src/http/handlers/sessions-delete.js

@@ -0,0 +1,49 @@
+import { deleteFridaySession, toSessionStoreKey } from "../../session/session-manager.js";
+import { getActiveRunIds } from "../../agent/active-runs.js";
+import { abortRun } from "../../agent/abort-run.js";
+import { getRunRoute } from "../../run-metadata.js";
+import { sseEmitter } from "../../sse/emitter.js";
+import { readJsonBody } from "../middleware/body.js";
+import { extractBearerToken } from "../middleware/auth.js";
+async function cancelActiveRunsForSession(sessionKey) {
+    const storeKey = toSessionStoreKey(sessionKey);
+    const cancelled = [];
+    for (const runId of getActiveRunIds()) {
+        const route = getRunRoute(runId);
+        if (route?.sessionKey === storeKey) {
+            await abortRun(runId);
+            sseEmitter.untrackRun(runId);
+            cancelled.push(runId);
+        }
+    }
+    return cancelled;
+}
+export async function handleSessionsDelete(req, res) {
+    if (req.method !== "DELETE") {
+        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 body = await readJsonBody(req);
+    const sessionKey = typeof body?.sessionKey === "string" ? body.sessionKey.trim() : "";
+    if (!sessionKey) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing required field: sessionKey" }));
+        return true;
+    }
+    const cancelledRuns = await cancelActiveRunsForSession(sessionKey);
+    const result = deleteFridaySession(sessionKey);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true, ...result, cancelledRuns }));
+    return true;
+}

package/dist/src/http/handlers/sessions-settings.d.ts

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

package/dist/src/http/handlers/sessions-settings.js

@@ -0,0 +1,71 @@
+import { setSessionSettings, getSessionSettings, splitModelRef, } from "../../session/session-manager.js";
+import { readJsonBody } from "../middleware/body.js";
+import { extractBearerToken } from "../middleware/auth.js";
+const VALID_REASONING = new Set(["on", "off", "stream"]);
+const VALID_THINKING = new Set(["off", "minimal", "low", "medium", "high"]);
+export async function handleSessionsSettings(req, res) {
+    if (req.method !== "PUT" && 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;
+    }
+    if (req.method === "GET") {
+        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 settings = getSessionSettings(sessionKey);
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ ok: true, sessionKey, ...settings }));
+        return true;
+    }
+    // PUT
+    const body = await readJsonBody(req);
+    const sessionKey = typeof body?.sessionKey === "string" ? body.sessionKey.trim() : "";
+    if (!sessionKey) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing required field: sessionKey" }));
+        return true;
+    }
+    const reasoningLevel = typeof body?.reasoningLevel === "string" ? body.reasoningLevel : undefined;
+    const thinkingLevel = typeof body?.thinkingLevel === "string" ? body.thinkingLevel : undefined;
+    const modelRef = typeof body?.modelRef === "string" ? body.modelRef : undefined;
+    const errors = [];
+    if (reasoningLevel !== undefined && !VALID_REASONING.has(reasoningLevel)) {
+        errors.push(`reasoningLevel must be one of: ${[...VALID_REASONING].join(", ")}`);
+    }
+    if (thinkingLevel !== undefined && !VALID_THINKING.has(thinkingLevel)) {
+        errors.push(`thinkingLevel must be one of: ${[...VALID_THINKING].join(", ")}`);
+    }
+    if (errors.length > 0) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: errors.join("; ") }));
+        return true;
+    }
+    const settings = { reasoningLevel, thinkingLevel, modelRef };
+    if (modelRef) {
+        const split = splitModelRef(modelRef);
+        settings["providerOverride"] = split.provider;
+        settings["modelOverride"] = split.modelId;
+    }
+    const result = setSessionSettings(sessionKey, settings);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true, sessionKey, ...result }));
+    return true;
+}

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

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

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/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/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 {};