@syengup/friday-channel-next 0.1.3 → 0.1.5

package/dist/src/friday-session.js

@@ -420,38 +420,43 @@ export function forwardAgentEventRaw(evt) {
             }, ended.deviceId);
         }
     }
-    // Build sessionUsage: llm_output hook (primary, no race) → store read (fallback).
-    if (isTerminalLifecycle) {
-        const llmUsage = consumeRunUsage(evt.runId);
-        const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
-        const hasRealTokens = llmUsage?.tokens && Object.keys(llmUsage.tokens).length > 1;
-        if (hasRealTokens) {
-            const usage = mergeUsage(llmUsage, memUsage);
+    // Build sessionUsage: store (cumulative session totals) → llm_output (per-run fallback).
+    if (isTerminalLifecycle && getFridayAgentForwardRuntime()) {
+        // Defer to let store write complete, then read cumulative totals.
+        // llm_output data is per-run; store is cumulative across rounds.
+        setTimeout(() => {
+            let data = outgoingData;
+            const storeUsage = tryReadSessionUsageFromStore(sk);
+            const llmUsage = consumeRunUsage(evt.runId);
+            const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
+            let usage;
+            if (storeUsage) {
+                // Store provides cumulative session totals. Supplement with
+                // fresher model/provider from llm_output when available.
+                usage = storeUsage;
+                if (llmUsage?.modelId)
+                    usage.modelId = llmUsage.modelId;
+                if (llmUsage?.modelProvider)
+                    usage.modelProvider = llmUsage.modelProvider;
+            }
+            else {
+                // First message in session — store not yet written, fall back
+                // to per-run llm_output + RunMetadata.
+                usage = mergeUsage(llmUsage, memUsage);
+            }
             if (usage) {
-                outgoingData = { ...outgoingData, sessionUsage: usage };
+                data = { ...outgoingData, sessionUsage: usage };
             }
-        }
-        else if (getFridayAgentForwardRuntime()) {
-            // llm_output hook fires async ~20ms after lifecycle.end.
-            // Wait 100ms then re-check before falling back to store read.
-            setTimeout(() => {
-                let data = outgoingData;
-                const retryLlm = consumeRunUsage(evt.runId);
-                const usage = mergeUsage(retryLlm, memUsage) ?? tryReadSessionUsageFromStore(sk);
-                if (usage) {
-                    data = { ...outgoingData, sessionUsage: usage };
-                }
-                completeAgentEventForward({
-                    evt,
-                    sk,
-                    deviceIdRaw,
-                    outgoingData: data,
-                    isTerminalLifecycle: true,
-                    subagentMeta,
-                });
-            }, 100);
-            return;
-        }
+            completeAgentEventForward({
+                evt,
+                sk,
+                deviceIdRaw,
+                outgoingData: data,
+                isTerminalLifecycle: true,
+                subagentMeta,
+            });
+        }, 100);
+        return;
     }
     completeAgentEventForward({
         evt,

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

@@ -45,6 +45,20 @@ export async function handleDeviceApprove(req, res) {
     }
     const match = pairing.pending.find((entry) => entry.deviceId.trim().toUpperCase() === normalizedDeviceId);
     if (!match) {
+        // Gateway may have already auto-approved the device (e.g. mode="local").
+        // Check the paired list before returning 404.
+        const pairedDevice = (pairing.paired ?? []).find((entry) => entry.deviceId.trim().toUpperCase() === normalizedDeviceId);
+        if (pairedDevice) {
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                ok: true,
+                deviceId: normalizedDeviceId,
+                alreadyApproved: true,
+                approvedAtMs: pairedDevice.approvedAtMs,
+            }));
+            return true;
+        }
         res.statusCode = 404;
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify({

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

@@ -7,5 +7,5 @@ export function applyCorsHeaders(res) {
         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");
+    res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
 }

package/dist/src/http/server.js

@@ -11,7 +11,6 @@ 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";
@@ -56,9 +55,6 @@ async function handleFridayNextRoute(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);
     }

package/dist/src/session/session-manager.d.ts

@@ -4,13 +4,6 @@ export declare function splitModelRef(modelRef: string): {
 };
 export declare function toSessionStoreKey(rawSessionKey: string): string;
 export declare function ensureSessionLevels(sessionKey: string, reasoningLevel: string, thinkingLevel: string, historyDir?: string): void;
-export declare function resolveSessionsDir(historyDir?: string): string;
-export interface DeleteSessionResult {
-    sessionKey: string;
-    sessionId?: string;
-    transcriptDeleted?: boolean;
-}
-export declare function deleteFridaySession(sessionKey: string, historyDir?: string): DeleteSessionResult;
 export interface FridaySessionSettings {
     reasoningLevel?: string;
     thinkingLevel?: string;

package/dist/src/session/session-manager.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import os from "node:os";
-import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 const FRIDAY_AGENT_ID = "main";
 const SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 function deriveOpenClawBaseDir(historyDir) {
@@ -96,43 +96,6 @@ function upsertSessionEntry(data, fileKey, sessionKey) {
 export function ensureSessionLevels(sessionKey, reasoningLevel, thinkingLevel, historyDir) {
     setSessionSettings(sessionKey, { reasoningLevel, thinkingLevel }, historyDir);
 }
-export function resolveSessionsDir(historyDir) {
-    const base = deriveOpenClawBaseDir(historyDir);
-    return join(base, "agents/main/sessions");
-}
-export function deleteFridaySession(sessionKey, historyDir) {
-    const result = { sessionKey };
-    const sessionsFile = resolveSessionsFilePath(historyDir);
-    const data = readSessionsData(sessionsFile);
-    if (!data)
-        return result;
-    const fileKey = toSessionStoreKey(sessionKey);
-    const entry = data[fileKey];
-    if (!entry)
-        return result;
-    const sessionId = typeof entry["sessionId"] === "string" ? entry["sessionId"] : undefined;
-    const sessionFilePath = typeof entry["sessionFile"] === "string" ? entry["sessionFile"] : undefined;
-    result.sessionId = sessionId;
-    if (sessionFilePath) {
-        try {
-            unlinkSync(sessionFilePath);
-            result.transcriptDeleted = true;
-        }
-        catch { /* gone already */ }
-    }
-    if (sessionId) {
-        const dir = resolveSessionsDir(historyDir);
-        for (const suffix of [".trajectory.jsonl", ".trajectory-path.json"]) {
-            try {
-                unlinkSync(join(dir, `${sessionId}${suffix}`));
-            }
-            catch { /* optional */ }
-        }
-    }
-    delete data[fileKey];
-    writeSessionsData(sessionsFile, data);
-    return result;
-}
 export function setSessionSettings(sessionKey, settings, historyDir) {
     try {
         const sessionsFile = resolveSessionsFilePath(historyDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",

package/src/friday-session.forward-agent.test.ts

@@ -200,8 +200,20 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect("reasoningPrefixChars" in (payload.data as object)).toBe(false);
   });
 
-  it("builds sessionUsage from llm_output accumulated usage on lifecycle end", () => {
-    // Simulate llm_output hook accumulating usage across API calls.
+  it("builds sessionUsage from store (cumulative) with llm_output fallback", async () => {
+    // No store entry — falls back to llm_output per-run data.
+    setFridayAgentForwardRuntime({
+      runtime: {
+        config: { current: () => ({ session: {} }) },
+        agent: {
+          session: {
+            resolveStorePath: () => "/tmp/sessions.json",
+            loadSessionStore: vi.fn(() => ({})),
+          },
+        },
+      },
+    } as never);
+
     accumulateRunUsage(runId, { input: 100, output: 50, cacheRead: 10, total: 150 }, "my-model", "openai");
     accumulateRunUsage(runId, { input: 30, output: 10, cacheRead: 0, total: 40 }, "my-model", "openai");
 
@@ -213,15 +225,18 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
       data: { phase: "end" },
     });
 
-    // Lifecycle events are synchronous now (no file I/O wait).
+    // Deferred 100ms — not broadcast yet.
+    expect(sseEmitter.broadcastToRun).not.toHaveBeenCalled();
+    await new Promise<void>((resolve) => setTimeout(resolve, 150));
+
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
     expect(forwarded.stream).toBe("lifecycle");
     const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
     expect(sessionUsage).toBeDefined();
+    // llm_output fallback — per-run totals.
     expect(sessionUsage.modelId).toBe("my-model");
     expect(sessionUsage.modelProvider).toBe("openai");
-    // Accumulated totals across both API calls.
     expect((sessionUsage.tokens as Record<string, unknown>).input).toBe(130);
     expect((sessionUsage.tokens as Record<string, unknown>).output).toBe(60);
     expect((sessionUsage.tokens as Record<string, unknown>).cacheRead).toBe(10);
@@ -229,50 +244,63 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect((sessionUsage.tokens as Record<string, unknown>).totalFresh).toBe(true);
   });
 
-  it("merges llm_output usage with RunMetadata for sessionUsage on lifecycle end", () => {
-    // Simulate llm_output hook.
-    accumulateRunUsage(runId, { input: 500, output: 100, cacheRead: 200, cacheWrite: 0, total: 800 }, "llm-model", "llm-provider");
-
-    // Send an agent event that populates RunMetadata (model, context window).
-    forwardAgentEventRaw({
-      runId,
-      seq: 1,
-      stream: "assistant",
-      sessionKey,
-      data: {
-        model: "agent-model",
-        provider: "agent-provider",
-        usage: { input: 999, total: 999 },
-        contextWindow: 100000,
+  it("prefers store cumulative totals over llm_output per-run data", async () => {
+    const storeKey = toSessionStoreKey(sessionKey);
+    setFridayAgentForwardRuntime({
+      runtime: {
+        config: { current: () => ({ session: {} }) },
+        agent: {
+          session: {
+            resolveStorePath: () => "/tmp/sessions.json",
+            loadSessionStore: vi.fn(() => ({
+              [storeKey]: {
+                model: "store-model",
+                modelProvider: "old-provider",
+                inputTokens: 5000,
+                outputTokens: 2000,
+                totalTokens: 99999,
+                totalTokensFresh: true,
+                contextTokens: 128000,
+                estimatedCostUsd: 0.05,
+                cacheRead: 100,
+                cacheWrite: 50,
+              },
+            })),
+          },
+        },
       },
-    });
+    } as never);
+
+    // llm_output has fresher model/provider but per-run (smaller) tokens.
+    accumulateRunUsage(runId, { input: 500, output: 100, cacheRead: 200, total: 800 }, "llm-model", "llm-provider");
 
     forwardAgentEventRaw({
       runId,
-      seq: 2,
+      seq: 1,
       stream: "lifecycle",
       sessionKey,
       data: { phase: "end" },
     });
 
-    // Assistant (1st) + lifecycle.end (2nd, synchronous).
-    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(2);
-    const lifecycleCall = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1];
-    const lifecycleData = (lifecycleCall[1] as { data: { data: Record<string, unknown> } }).data.data;
-    const sessionUsage = lifecycleData.sessionUsage as Record<string, unknown> | undefined;
+    expect(sseEmitter.broadcastToRun).not.toHaveBeenCalled();
+    await new Promise<void>((resolve) => setTimeout(resolve, 150));
+
+    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
+    const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
     expect(sessionUsage).toBeDefined();
-    // llm_output tokens win (authoritative per-API-call data).
-    expect(sessionUsage!.modelId).toBe("llm-model");
-    expect(sessionUsage!.modelProvider).toBe("llm-provider");
-    expect((sessionUsage!.tokens as Record<string, unknown>).input).toBe(500);
-    expect((sessionUsage!.tokens as Record<string, unknown>).output).toBe(100);
-    expect((sessionUsage!.tokens as Record<string, unknown>).cacheRead).toBe(200);
-    expect((sessionUsage!.tokens as Record<string, unknown>).total).toBe(800);
-    // Context from RunMetadata (not available from llm_output).
-    expect((sessionUsage!.context as Record<string, unknown>).windowMax).toBe(100000);
+    // Store cumulative totals win.
+    expect((sessionUsage.tokens as Record<string, unknown>).input).toBe(5000);
+    expect((sessionUsage.tokens as Record<string, unknown>).output).toBe(2000);
+    expect((sessionUsage.tokens as Record<string, unknown>).total).toBe(99999);
+    // Model/provider from llm_output (fresher) override store.
+    expect(sessionUsage.modelId).toBe("llm-model");
+    expect(sessionUsage.modelProvider).toBe("llm-provider");
+    expect(sessionUsage.estimatedCostUsd).toBe(0.05);
+    expect((sessionUsage.context as Record<string, unknown>).windowMax).toBe(128000);
   });
 
-  it("falls back to store read when llm_output has no data (deferred)", async () => {
+  it("uses store cumulative totals when llm_output has no data", async () => {
     const storeKey = toSessionStoreKey(sessionKey);
     const store: Record<string, Record<string, unknown>> = {
       [storeKey]: {

package/src/friday-session.ts

@@ -483,38 +483,40 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
     }
   }
 
-  // Build sessionUsage: llm_output hook (primary, no race) → store read (fallback).
-  if (isTerminalLifecycle) {
-    const llmUsage = consumeRunUsage(evt.runId);
-    const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
-    const hasRealTokens = llmUsage?.tokens && Object.keys(llmUsage.tokens).length > 1;
-
-    if (hasRealTokens) {
-      const usage = mergeUsage(llmUsage, memUsage);
+  // Build sessionUsage: store (cumulative session totals) → llm_output (per-run fallback).
+  if (isTerminalLifecycle && getFridayAgentForwardRuntime()) {
+    // Defer to let store write complete, then read cumulative totals.
+    // llm_output data is per-run; store is cumulative across rounds.
+    setTimeout(() => {
+      let data = outgoingData;
+      const storeUsage = tryReadSessionUsageFromStore(sk);
+      const llmUsage = consumeRunUsage(evt.runId);
+      const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
+      let usage: FridaySessionUsagePayload | undefined;
+      if (storeUsage) {
+        // Store provides cumulative session totals. Supplement with
+        // fresher model/provider from llm_output when available.
+        usage = storeUsage;
+        if (llmUsage?.modelId) usage.modelId = llmUsage.modelId;
+        if (llmUsage?.modelProvider) usage.modelProvider = llmUsage.modelProvider;
+      } else {
+        // First message in session — store not yet written, fall back
+        // to per-run llm_output + RunMetadata.
+        usage = mergeUsage(llmUsage, memUsage);
+      }
       if (usage) {
-        outgoingData = { ...outgoingData, sessionUsage: usage };
+        data = { ...outgoingData, sessionUsage: usage };
       }
-    } else if (getFridayAgentForwardRuntime()) {
-      // llm_output hook fires async ~20ms after lifecycle.end.
-      // Wait 100ms then re-check before falling back to store read.
-      setTimeout(() => {
-        let data = outgoingData;
-        const retryLlm = consumeRunUsage(evt.runId);
-        const usage = mergeUsage(retryLlm, memUsage) ?? tryReadSessionUsageFromStore(sk);
-        if (usage) {
-          data = { ...outgoingData, sessionUsage: usage };
-        }
-        completeAgentEventForward({
-          evt,
-          sk,
-          deviceIdRaw,
-          outgoingData: data,
-          isTerminalLifecycle: true,
-          subagentMeta,
-        });
-      }, 100);
-      return;
-    }
+      completeAgentEventForward({
+        evt,
+        sk,
+        deviceIdRaw,
+        outgoingData: data,
+        isTerminalLifecycle: true,
+        subagentMeta,
+      });
+    }, 100);
+    return;
   }
 
   completeAgentEventForward({

package/src/http/handlers/device-approve.ts

@@ -59,6 +59,23 @@ export async function handleDeviceApprove(
   );
 
   if (!match) {
+    // Gateway may have already auto-approved the device (e.g. mode="local").
+    // Check the paired list before returning 404.
+    const pairedDevice = (pairing.paired ?? []).find(
+      (entry) => entry.deviceId.trim().toUpperCase() === normalizedDeviceId,
+    );
+    if (pairedDevice) {
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({
+        ok: true,
+        deviceId: normalizedDeviceId,
+        alreadyApproved: true,
+        approvedAtMs: (pairedDevice as any).approvedAtMs,
+      }));
+      return true;
+    }
+
     res.statusCode = 404;
     res.setHeader("Content-Type", "application/json");
     res.end(JSON.stringify({

package/src/http/middleware/cors.ts

@@ -8,5 +8,5 @@ export function applyCorsHeaders(res: ServerResponse): void {
   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");
+  res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
 }

package/src/http/server.ts

@@ -13,7 +13,6 @@ 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";
@@ -70,10 +69,6 @@ async function handleFridayNextRoute(
     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);
   }

package/src/session/session-manager.ts

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import os from "node:os";
-import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 
 const FRIDAY_AGENT_ID = "main";
 const SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
@@ -111,50 +111,6 @@ export function ensureSessionLevels(
   setSessionSettings(sessionKey, { reasoningLevel, thinkingLevel }, historyDir);
 }
 
-export function resolveSessionsDir(historyDir?: string): string {
-  const base = deriveOpenClawBaseDir(historyDir);
-  return join(base, "agents/main/sessions");
-}
-
-export interface DeleteSessionResult {
-  sessionKey: string;
-  sessionId?: string;
-  transcriptDeleted?: boolean;
-}
-
-export function deleteFridaySession(
-  sessionKey: string,
-  historyDir?: string,
-): DeleteSessionResult {
-  const result: DeleteSessionResult = { sessionKey };
-  const sessionsFile = resolveSessionsFilePath(historyDir);
-  const data = readSessionsData(sessionsFile);
-  if (!data) return result;
-
-  const fileKey = toSessionStoreKey(sessionKey);
-  const entry = data[fileKey];
-  if (!entry) return result;
-
-  const sessionId = typeof entry["sessionId"] === "string" ? entry["sessionId"] : undefined;
-  const sessionFilePath = typeof entry["sessionFile"] === "string" ? entry["sessionFile"] : undefined;
-  result.sessionId = sessionId;
-
-  if (sessionFilePath) {
-    try { unlinkSync(sessionFilePath); result.transcriptDeleted = true; } catch { /* gone already */ }
-  }
-
-  if (sessionId) {
-    const dir = resolveSessionsDir(historyDir);
-    for (const suffix of [".trajectory.jsonl", ".trajectory-path.json"]) {
-      try { unlinkSync(join(dir, `${sessionId}${suffix}`)); } catch { /* optional */ }
-    }
-  }
-
-  delete data[fileKey];
-  writeSessionsData(sessionsFile, data);
-  return result;
-}
-
 export interface FridaySessionSettings {
   reasoningLevel?: string;
   thinkingLevel?: string;

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

@@ -1,59 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-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: string): Promise<string[]> {
-  const storeKey = toSessionStoreKey(sessionKey);
-  const cancelled: string[] = [];
-  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: IncomingMessage,
-  res: ServerResponse,
-): Promise<boolean> {
-  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;
-}