@syengup/friday-channel-next 0.0.45 → 0.1.1

package/src/http/handlers/health.ts

@@ -0,0 +1,289 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { listDevicePairing, approveDevicePairing } from "openclaw/plugin-sdk/device-bootstrap";
+import { extractBearerToken } from "../middleware/auth.js";
+import { loadNodePairingModule } from "../../agent/node-pairing-bridge.js";
+import { createFridayNextLogger } from "../../logging.js";
+
+const REQUIRED_NODE_CAPS = ["location", "canvas"];
+const REQUIRED_NODE_COMMANDS = [
+  "location.get",
+  "canvas.present",
+  "canvas.hide",
+  "canvas.navigate",
+  "canvas.eval",
+  "canvas.snapshot",
+  "canvas.a2ui.push",
+  "canvas.a2ui.pushJSONL",
+  "canvas.a2ui.reset",
+];
+
+export interface HealthComponentStatus {
+  status: "ok" | "degraded" | "failed" | "pending" | "not_found";
+  detail: string;
+  [key: string]: unknown;
+}
+
+interface RepairAction {
+  component: string;
+  action: string;
+  result: "ok" | "failed";
+  detail: string;
+}
+
+export interface HealthCheckResult {
+  ok: boolean;
+  timestamp: number;
+  deviceId: string;
+  nodeDeviceId: string;
+  devicePairing?: HealthComponentStatus;
+  nodePairing?: HealthComponentStatus;
+  repairActions?: RepairAction[];
+}
+
+export async function handleHealth(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
+  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();
+  const nodeDeviceId = (url.searchParams.get("nodeDeviceId") ?? "").trim();
+  const selfHeal = (url.searchParams.get("selfHeal") ?? "").toLowerCase() === "true";
+
+  const result: HealthCheckResult = {
+    ok: true,
+    timestamp: Date.now(),
+    deviceId,
+    nodeDeviceId,
+  };
+
+  const log = createFridayNextLogger("health");
+
+  if (deviceId) {
+    result.devicePairing = await checkDevicePairing(deviceId, selfHeal, result, log);
+  }
+
+  if (nodeDeviceId) {
+    result.nodePairing = await checkNodePairing(nodeDeviceId, selfHeal, result, log);
+  }
+
+  const statuses = [
+    result.devicePairing?.status,
+    result.nodePairing?.status,
+  ].filter(Boolean);
+  result.ok = statuses.length === 0 || statuses.every((s) => s === "ok" || s === "pending");
+
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(result));
+  return true;
+}
+
+async function checkDevicePairing(
+  deviceId: string,
+  selfHeal: boolean,
+  result: HealthCheckResult,
+  log: ReturnType<typeof createFridayNextLogger>,
+): Promise<HealthComponentStatus> {
+  const normalizedDeviceId = deviceId.trim().toUpperCase();
+
+  let pairing;
+  try {
+    pairing = await listDevicePairing();
+  } catch (err) {
+    log.error(`listDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+    return {
+      status: "failed",
+      detail: `listDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`,
+      devicePaired: false,
+    };
+  }
+
+  const pairedDevice = (pairing?.paired ?? []).find(
+    (entry) => entry.deviceId?.trim().toUpperCase() === normalizedDeviceId,
+  );
+  if (pairedDevice) {
+    const approvedScopes: string[] = (pairedDevice as any).approvedScopes ?? [];
+    const tokens: Record<string, { revokedAtMs?: number }> = (pairedDevice as any).tokens ?? {};
+    const hasValidToken = Object.values(tokens).some((t: any) => !t.revokedAtMs);
+
+    if (approvedScopes.length === 0 || !hasValidToken) {
+      const issues: string[] = [];
+      if (approvedScopes.length === 0) issues.push("no approved scopes");
+      if (!hasValidToken) issues.push("all tokens revoked");
+      return {
+        status: "degraded",
+        detail: `Device paired but degraded: ${issues.join(", ")}`,
+        devicePaired: true,
+        approvedScopesEmpty: approvedScopes.length === 0,
+        tokensRevoked: !hasValidToken,
+      };
+    }
+
+    return { status: "ok", detail: "Device paired and healthy", devicePaired: true };
+  }
+
+  const pendingDevice = (pairing?.pending ?? []).find(
+    (entry) => entry.deviceId?.trim().toUpperCase() === normalizedDeviceId,
+  );
+  if (pendingDevice && selfHeal) {
+    try {
+      const approved = await approveDevicePairing(pendingDevice.requestId);
+      const succeeded = approved && approved.status === "approved";
+      (result.repairActions ??= []).push({
+        component: "devicePairing",
+        action: "approveDevicePairing",
+        result: succeeded ? "ok" : "failed",
+        detail: succeeded
+          ? `Auto-approved device ${normalizedDeviceId}`
+          : `approveDevicePairing returned status=${(approved as any)?.status ?? "null"}`,
+      });
+      if (succeeded) {
+        log.info(`Auto-approved device ${normalizedDeviceId}`);
+        return { status: "ok", detail: "Device was pending, auto-approved", devicePaired: true };
+      }
+    } catch (err) {
+      log.error(`approveDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+      (result.repairActions ??= []).push({
+        component: "devicePairing",
+        action: "approveDevicePairing",
+        result: "failed",
+        detail: err instanceof Error ? err.message : String(err),
+      });
+    }
+    return {
+      status: "degraded",
+      detail: "Device pending but auto-approve failed",
+      devicePaired: false,
+    };
+  }
+
+  if (pendingDevice) {
+    return { status: "pending", detail: "Device is pending approval", devicePaired: false };
+  }
+
+  return { status: "not_found", detail: `Device ${normalizedDeviceId} not registered`, devicePaired: false };
+}
+
+async function checkNodePairing(
+  nodeDeviceId: string,
+  selfHeal: boolean,
+  result: HealthCheckResult,
+  log: ReturnType<typeof createFridayNextLogger>,
+): Promise<HealthComponentStatus> {
+  const normalizedNodeId = nodeDeviceId.trim().toUpperCase();
+
+  let listData, listNodePairing, approveNodePairing;
+  try {
+    ({ listNodePairing, approveNodePairing } = await loadNodePairingModule());
+  } catch (err) {
+    log.error(`loadNodePairingModule failed: ${err instanceof Error ? err.message : String(err)}`);
+    return {
+      status: "failed",
+      detail: `loadNodePairingModule failed: ${err instanceof Error ? err.message : String(err)}`,
+      nodePaired: false,
+    };
+  }
+
+  try {
+    listData = await listNodePairing();
+  } catch (err) {
+    log.error(`listNodePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+    return {
+      status: "failed",
+      detail: `listNodePairing failed: ${err instanceof Error ? err.message : String(err)}`,
+      nodePaired: false,
+    };
+  }
+
+  const pairedNodes: Array<{ nodeId: string; caps?: string[]; commands?: string[] }> = listData?.paired ?? [];
+  const pairedMatch = pairedNodes.find(
+    (entry) => entry.nodeId?.trim().toUpperCase() === normalizedNodeId,
+  );
+
+  if (pairedMatch) {
+    const caps = pairedMatch.caps ?? [];
+    const commands = pairedMatch.commands ?? [];
+    const hasRequiredCaps = REQUIRED_NODE_CAPS.every((c) => caps.includes(c));
+    const hasRequiredCommands = REQUIRED_NODE_COMMANDS.every((c) => commands.includes(c));
+    const capsValid = caps.length > 0 && hasRequiredCaps;
+    const commandsValid = commands.length > 0 && hasRequiredCommands;
+
+    if (capsValid && commandsValid) {
+      return {
+        status: "ok",
+        detail: `Node paired with ${caps.length} caps, ${commands.length} commands`,
+        nodePaired: true,
+        capsCount: caps.length,
+        commandsCount: commands.length,
+        capsValid: true,
+        commandsValid: true,
+      };
+    }
+
+    return {
+      status: "degraded",
+      detail: `Node paired but caps/commands incomplete: caps=${caps.length} (valid=${capsValid}), commands=${commands.length} (valid=${commandsValid})`,
+      nodePaired: true,
+      capsCount: caps.length,
+      commandsCount: commands.length,
+      capsValid,
+      commandsValid,
+    };
+  }
+
+  const pendingNodes: Array<{ nodeId: string; requestId: string }> = listData?.pending ?? [];
+  const pendingMatch = pendingNodes.find(
+    (entry) => entry.nodeId?.trim().toUpperCase() === normalizedNodeId,
+  );
+
+  if (pendingMatch && selfHeal) {
+    try {
+      const callerScopes = ["operator.admin", "operator.pairing", "operator.read", "operator.write"];
+      const approved = await approveNodePairing(pendingMatch.requestId, { callerScopes });
+      const succeeded = approved != null && !("status" in approved && (approved as any).status === "forbidden") && "requestId" in approved;
+      (result.repairActions ??= []).push({
+        component: "nodePairing",
+        action: "approveNodePairing",
+        result: succeeded ? "ok" : "failed",
+        detail: succeeded
+          ? `Auto-approved node ${normalizedNodeId}`
+          : `approveNodePairing returned status=${(approved as any)?.status ?? "null"}`,
+      });
+      if (succeeded) {
+        log.info(`Auto-approved node ${normalizedNodeId}`);
+        return { status: "ok", detail: "Node was pending, auto-approved", nodePaired: true };
+      }
+    } catch (err) {
+      log.error(`approveNodePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+      (result.repairActions ??= []).push({
+        component: "nodePairing",
+        action: "approveNodePairing",
+        result: "failed",
+        detail: err instanceof Error ? err.message : String(err),
+      });
+    }
+    return {
+      status: "degraded",
+      detail: "Node pending but auto-approve failed",
+      nodePaired: false,
+    };
+  }
+
+  if (pendingMatch) {
+    return { status: "pending", detail: "Node is pending approval", nodePaired: false };
+  }
+
+  return { status: "not_found", detail: `Node ${normalizedNodeId} not registered`, nodePaired: false };
+}

package/src/http/server.ts

@@ -17,6 +17,7 @@ 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 { handleHealth } from "./handlers/health.js";
 import { applyCorsHeaders } from "./middleware/cors.js";
 import { resolveFridayNextConfig } from "../config.js";
 import { getHostOpenClawConfigSnapshot } from "../host-config.js";
@@ -85,6 +86,11 @@ async function handleFridayNextRoute(
     return await handleStatus(req, res);
   }
 
+  // Route: GET /friday-next/health?deviceId=...&nodeDeviceId=...&selfHeal=true
+  if (req.method === "GET" && pathname === "/friday-next/health") {
+    return await handleHealth(req, res);
+  }
+
   // Not found
   return false;
 }

package/src/run-metadata.ts

@@ -6,11 +6,17 @@ type RunRoute = {
 
 export type RunMetadata = {
   modelName?: string;
+  modelProvider?: 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;
+  /** Detailed token breakdown captured from agent event usage (current run, not stale store read). */
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
 };
 
 const runRouteById = new Map<string, RunRoute>();
@@ -142,6 +148,12 @@ export function ingestAgentEventMetadata(runId: string, data: Record<string, unk
     undefined;
   if (modelName) next.modelName = modelName;
 
+  const modelProvider =
+    (typeof data.modelProvider === "string" && data.modelProvider.trim()) ||
+    (typeof data.provider === "string" && data.provider.trim()) ||
+    undefined;
+  if (modelProvider) next.modelProvider = modelProvider;
+
   const usage = recordValue(data.usage);
   const totalTokens =
     finiteNumber(data.totalTokens) ??
@@ -153,6 +165,16 @@ export function ingestAgentEventMetadata(runId: string, data: Record<string, unk
     next.totalTokens = Math.floor(totalTokens);
   }
 
+  const usageForTokens = usage ?? data;
+  const input = pickInputTokens(usageForTokens);
+  if (typeof input === "number" && input >= 0) next.inputTokens = Math.floor(input);
+  const output = pickOutputTokens(usageForTokens);
+  if (typeof output === "number" && output >= 0) next.outputTokens = Math.floor(output);
+  const cacheRead = pickCacheRead(usageForTokens);
+  if (typeof cacheRead === "number" && cacheRead >= 0) next.cacheReadTokens = Math.floor(cacheRead);
+  const cacheWrite = pickCacheWrite(usageForTokens);
+  if (typeof cacheWrite === "number" && cacheWrite >= 0) next.cacheWriteTokens = Math.floor(cacheWrite);
+
   const usageForContext = usage ?? data;
   const ctxUsed = contextTokensFromUsageRecord(usageForContext);
   if (typeof ctxUsed === "number" && ctxUsed > 0) {
@@ -171,9 +193,14 @@ export function ingestAgentEventMetadata(runId: string, data: Record<string, unk
 
   if (
     next.modelName ||
+    next.modelProvider ||
     typeof next.totalTokens === "number" ||
     typeof next.contextTokensUsed === "number" ||
-    typeof next.contextWindowMax === "number"
+    typeof next.contextWindowMax === "number" ||
+    typeof next.inputTokens === "number" ||
+    typeof next.outputTokens === "number" ||
+    typeof next.cacheReadTokens === "number" ||
+    typeof next.cacheWriteTokens === "number"
   ) {
     setRunMetadata(runId, next);
   }