@syengup/friday-channel-next 0.0.34 → 0.0.37

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/pair.d.ts

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

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

@@ -0,0 +1,39 @@
+import { getOrCreateAccountId } from "../../sync/account-identity.js";
+import { getInstallationId } from "../../sync/installation-id.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { readJsonBody } from "../middleware/body.js";
+export async function handlePair(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;
+    }
+    if (!extractBearerToken(req)) {
+        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 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 claimAccountId = typeof body?.claimAccountId === "string" ? body.claimAccountId.trim() : undefined;
+    const claim = body?.claim && typeof body.claim === "object" && !Array.isArray(body.claim)
+        ? body.claim
+        : {};
+    const result = getOrCreateAccountId({
+        deviceId,
+        claimAccountId,
+        claimConfirmed: claim.confirmed === true,
+    });
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true, installationId: getInstallationId(), ...result }));
+    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-list.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GET /friday-next/sessions?deviceId=...
+ *
+ * List sessions. If deviceId is provided, filters by device.
+ * If deviceId is omitted, returns all sessions (for app reinstall recovery when deviceId changed).
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function handleSessionsList(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

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

@@ -0,0 +1,24 @@
+import { extractBearerToken } from "../middleware/auth.js";
+import { listSessions, listAllSessionsList } from "../../sync/message-store.js";
+export async function handleSessionsList(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" }));
+        return true;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const deviceId = url.searchParams.get("deviceId")?.trim();
+    const sessions = deviceId ? listSessions(deviceId) : listAllSessionsList();
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ sessions }));
+    return true;
+}

package/dist/src/http/handlers/sessions-messages-get.d.ts

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

package/dist/src/http/handlers/sessions-messages-get.js

@@ -0,0 +1,55 @@
+import { resolveAccountIdFromRequest } from "../../sync/account-identity.js";
+import { getTranscriptStore } from "../../sync/transcript-store.js";
+import { extractBearerToken } from "../middleware/auth.js";
+function sessionKeyFromPath(pathname) {
+    const prefix = "/friday-next/sessions/";
+    const suffix = "/messages";
+    if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
+        return "";
+    return decodeURIComponent(pathname.slice(prefix.length, -suffix.length));
+}
+export async function handleSessionMessagesGet(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 accountId = resolveAccountIdFromRequest(req);
+    if (!accountId) {
+        res.statusCode = 403;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unknown or missing X-Account-Id" }));
+        return true;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const sessionKey = sessionKeyFromPath(url.pathname);
+    if (!sessionKey) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing session key in path" }));
+        return true;
+    }
+    if (!sessionKey.includes(`friday:account:${accountId}:`) && !sessionKey.includes(`friday%3Aaccount%3A${accountId}%3A`)) {
+        const legacyAllowed = sessionKey.startsWith("friday:direct:") || sessionKey.startsWith("agent:main:friday:direct:");
+        if (!legacyAllowed) {
+            res.statusCode = 403;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Session does not belong to account" }));
+            return true;
+        }
+    }
+    const since = Number.parseInt(url.searchParams.get("since") ?? "0", 10);
+    const limit = Number.parseInt(url.searchParams.get("limit") ?? "200", 10);
+    const events = getTranscriptStore().readSince(accountId, sessionKey, Number.isFinite(since) ? since : 0, limit);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true, events, nextSince: events.at(-1)?.seq ?? since }));
+    return true;
+}

package/dist/src/http/handlers/sessions-messages-post.d.ts

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

package/dist/src/http/handlers/sessions-messages-post.js

@@ -0,0 +1,92 @@
+import { resolveAccountIdFromRequest } from "../../sync/account-identity.js";
+import { getTranscriptStore } from "../../sync/transcript-store.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { readJsonBody } from "../middleware/body.js";
+const allowedKinds = new Set([
+    "user_message",
+    "assistant_message",
+    "thought_event",
+    "tool_event",
+    "outbound_text",
+    "outbound_media",
+    "sync_upsert",
+]);
+function sessionKeyFromPath(pathname) {
+    const prefix = "/friday-next/sessions/";
+    const suffix = "/messages";
+    if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
+        return "";
+    return decodeURIComponent(pathname.slice(prefix.length, -suffix.length));
+}
+function parseEvent(raw, accountId) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const kind = typeof obj.kind === "string" && allowedKinds.has(obj.kind)
+        ? obj.kind
+        : null;
+    if (!kind)
+        return null;
+    const payload = obj.payload && typeof obj.payload === "object" && !Array.isArray(obj.payload)
+        ? obj.payload
+        : null;
+    if (!payload)
+        return null;
+    return {
+        eventId: typeof obj.eventId === "string" ? obj.eventId.trim() : undefined,
+        clientId: typeof obj.clientId === "string" && obj.clientId.trim() ? obj.clientId.trim() : accountId,
+        kind,
+        payload,
+        ts: typeof obj.ts === "number" ? obj.ts : undefined,
+        lamportTs: typeof obj.lamportTs === "number" ? obj.lamportTs : undefined,
+    };
+}
+export async function handleSessionMessagesPost(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;
+    }
+    if (!extractBearerToken(req)) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const accountId = resolveAccountIdFromRequest(req);
+    if (!accountId) {
+        res.statusCode = 403;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unknown or missing X-Account-Id" }));
+        return true;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const sessionKey = sessionKeyFromPath(url.pathname);
+    if (!sessionKey) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing session key in path" }));
+        return true;
+    }
+    if (!sessionKey.includes(`friday:account:${accountId}:`) && !sessionKey.startsWith("friday:direct:")) {
+        res.statusCode = 403;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Session does not belong to account" }));
+        return true;
+    }
+    const body = await readJsonBody(req, 8 * 1024 * 1024);
+    const rawEvents = Array.isArray(body?.events) ? body.events : [];
+    const events = rawEvents.map((e) => parseEvent(e, accountId)).filter((e) => e !== null);
+    if (events.length !== rawEvents.length) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Invalid transcript event batch" }));
+        return true;
+    }
+    const appended = getTranscriptStore().appendEvents(accountId, sessionKey, events);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true, appended: appended.length, events: appended }));
+    return true;
+}

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

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

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

@@ -0,0 +1,135 @@
+import { resolveFridayNextConfig } from "../../config.js";
+import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
+import { getFridayNextRuntime } from "../../runtime.js";
+import { accountExists, requireAccountId } from "../../sync/account-identity.js";
+import { sessionBelongsToAccount } from "../../sync/session-key.js";
+import { readSince, upsertEvents } from "../../sync/transcript-store.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { readJsonBody } from "../middleware/body.js";
+const VALID_KINDS = new Set([
+    "user_message",
+    "assistant_message",
+    "thought_event",
+    "tool_event",
+    "outbound_text",
+    "outbound_media",
+]);
+function decodeSessionKeyFromPath(pathname) {
+    const prefix = "/friday-next/sessions/";
+    if (!pathname.startsWith(prefix))
+        return null;
+    const rest = pathname.slice(prefix.length);
+    const messagesIdx = rest.indexOf("/messages");
+    if (messagesIdx < 0)
+        return null;
+    const encoded = rest.slice(0, messagesIdx);
+    if (!encoded)
+        return null;
+    try {
+        return decodeURIComponent(encoded);
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleSessionsMessages(req, res) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const sessionKey = decodeSessionKeyFromPath(url.pathname);
+    if (!sessionKey)
+        return false;
+    if (!extractBearerToken(req)) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const accountId = requireAccountId(req);
+    if (!accountId) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing or invalid X-Account-Id header" }));
+        return true;
+    }
+    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    if (!accountExists(cfg.historyDir, accountId)) {
+        res.statusCode = 403;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unknown account" }));
+        return true;
+    }
+    if (!sessionBelongsToAccount(sessionKey, accountId)) {
+        res.statusCode = 403;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Session does not belong to account" }));
+        return true;
+    }
+    if (req.method === "GET") {
+        const since = Math.max(0, Number.parseInt(url.searchParams.get("since") ?? "0", 10) || 0);
+        const limit = Math.min(cfg.syncMaxBatchSize, Math.max(1, Number.parseInt(url.searchParams.get("limit") ?? String(cfg.syncMaxBatchSize), 10) || cfg.syncMaxBatchSize));
+        const direction = url.searchParams.get("direction") === "desc" ? "desc" : "asc";
+        const events = readSince({
+            accountId,
+            sessionKey,
+            sinceSeq: since,
+            limit,
+            direction,
+            historyDir: cfg.historyDir,
+        });
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ ok: true, accountId, sessionKey, events }));
+        return true;
+    }
+    if (req.method === "POST") {
+        const body = (await readJsonBody(req));
+        const rawEvents = Array.isArray(body?.events) ? body.events : [];
+        if (rawEvents.length > cfg.syncMaxBatchSize) {
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: `Too many events (max ${cfg.syncMaxBatchSize})` }));
+            return true;
+        }
+        const parsed = rawEvents
+            .map((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                return null;
+            const o = item;
+            const kind = typeof o.kind === "string" ? o.kind : "";
+            if (!VALID_KINDS.has(kind))
+                return null;
+            const clientId = typeof o.clientId === "string" ? o.clientId : accountId;
+            const payload = o.payload && typeof o.payload === "object" && !Array.isArray(o.payload)
+                ? o.payload
+                : {};
+            return {
+                kind: kind,
+                clientId,
+                payload,
+                messageId: typeof o.messageId === "string" ? o.messageId : undefined,
+                lamport: typeof o.lamport === "number" ? o.lamport : undefined,
+                ts: typeof o.ts === "number" ? o.ts : undefined,
+            };
+        })
+            .filter((x) => x !== null);
+        const result = upsertEvents({
+            accountId,
+            sessionKey,
+            events: parsed,
+            historyDir: cfg.historyDir,
+        });
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({
+            ok: true,
+            accountId,
+            sessionKey,
+            applied: result.applied,
+            events: result.events,
+        }));
+        return true;
+    }
+    res.statusCode = 405;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ error: "Method Not Allowed" }));
+    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>;