@syengup/friday-channel-next 0.1.8 → 0.1.11

package/dist/src/agent/node-pairing-bridge.js

@@ -29,10 +29,16 @@ function resolveOpenClawDist() {
     const candidates = [
         process.env.OPENCLAW_DIST,
         fromBin,
+        // Windows: standard npm -g locations
         join(process.env.APPDATA ?? "", "npm/node_modules/openclaw/dist"),
+        join(process.env.LOCALAPPDATA ?? "", "npm/node_modules/openclaw/dist"),
+        // Cross-platform: version-manager paths detected from PATH resolution
+        // (nvm/fnm/asdf installs are found by resolveOpenClawDistFromPath via PATH)
         "/opt/homebrew/lib/node_modules/openclaw/dist",
         "/home/linuxbrew/.linuxbrew/lib/node_modules/openclaw/dist",
         "/usr/local/lib/node_modules/openclaw/dist",
+        // Linux: npm -g with prefix=/usr
+        "/usr/lib/node_modules/openclaw/dist",
     ].filter((v) => typeof v === "string" && v.length > 0);
     for (const root of candidates) {
         try {

package/dist/src/config.js

@@ -1,3 +1,4 @@
+import { homedir } from "node:os";
 function asObject(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -28,7 +29,7 @@ export function resolveFridayNextConfig(cfg) {
         pathPrefix: asString(section.pathPrefix, "/friday-next"),
         transport: asString(section.transport, "http+sse"),
         historyLimit: asNumber(section.historyLimit, 25, 1, 200),
-        historyDir: asString(section.historyDir, `${process.env.HOME ?? ""}/.openclaw/friday-next/history`),
+        historyDir: asString(section.historyDir, `${homedir()}/.openclaw/friday-next/history`),
         logLevel: asString(section.logLevel, "info"),
         authToken,
         corsEnabled: asBool(cors.enabled, false),

package/dist/src/http/handlers/agents-list.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface FridayAgentEntry {
+    id: string;
+    name?: string;
+    description?: string;
+    /** Primary model ref (e.g. "openai/gpt-4"); resolved from string or {primary} forms. */
+    model?: string;
+    thinkingDefault?: string;
+    isDefault: boolean;
+    emoji?: string;
+    avatar?: string;
+}
+export declare function handleAgentsList(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

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

@@ -0,0 +1,97 @@
+import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+const DEFAULT_AGENT_ID = "main";
+/** Agent ids already in path/shell-safe form skip the slug rewrite below. */
+const SAFE_AGENT_ID = /^[a-z0-9][a-z0-9_-]*$/;
+/**
+ * Mirror of OpenClaw's `normalizeAgentId` (src/routing/session-key.ts): trim,
+ * lowercase, keep path/shell-safe. Empty → "main".
+ */
+function normalizeAgentId(value) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (!trimmed)
+        return DEFAULT_AGENT_ID;
+    const lowered = trimmed.toLowerCase();
+    if (SAFE_AGENT_ID.test(lowered))
+        return lowered;
+    return (lowered
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64) || DEFAULT_AGENT_ID);
+}
+/** Extract a primary model ref from the `model` field (string or {primary,...}). */
+function resolvePrimaryModel(model) {
+    if (typeof model === "string")
+        return readString(model);
+    if (model && typeof model === "object") {
+        return readString(model.primary);
+    }
+    return undefined;
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+/**
+ * Reads the configured agents directly from the runtime config (same approach as
+ * models-list.ts). When no agents are configured OpenClaw runs an implicit "main"
+ * agent, so we return a single default entry to match that behaviour.
+ */
+function resolveConfiguredAgents() {
+    const rt = getFridayAgentForwardRuntime();
+    if (!rt)
+        return { agents: [], defaultAgentId: DEFAULT_AGENT_ID };
+    const cfg = rt.getConfig();
+    const agents = cfg?.agents;
+    const list = agents?.list;
+    if (!Array.isArray(list) || list.length === 0) {
+        return {
+            agents: [{ id: DEFAULT_AGENT_ID, isDefault: true }],
+            defaultAgentId: DEFAULT_AGENT_ID,
+        };
+    }
+    // Default agent: first entry marked `default: true`, else the first entry.
+    const explicitDefault = list.find((a) => a?.default === true);
+    const defaultAgentId = normalizeAgentId((explicitDefault ?? list[0])?.id);
+    const seen = new Set();
+    const entries = [];
+    for (const agent of list) {
+        if (!agent || typeof agent !== "object")
+            continue;
+        const id = normalizeAgentId(agent.id);
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const identity = agent.identity;
+        entries.push({
+            id,
+            name: readString(agent.name) ?? readString(identity?.name),
+            description: readString(agent.description),
+            model: resolvePrimaryModel(agent.model),
+            thinkingDefault: readString(agent.thinkingDefault),
+            isDefault: id === defaultAgentId,
+            emoji: readString(identity?.emoji),
+            avatar: readString(identity?.avatar) ?? readString(identity?.avatarUrl),
+        });
+    }
+    return { agents: entries, defaultAgentId };
+}
+export async function handleAgentsList(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 { agents, defaultAgentId } = resolveConfiguredAgents();
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true, agents, defaultAgentId }));
+    return true;
+}

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

@@ -15,7 +15,6 @@ export interface HealthCheckResult {
     timestamp: number;
     deviceId: string;
     nodeDeviceId: string;
-    devicePairing?: HealthComponentStatus;
     nodePairing?: HealthComponentStatus;
     repairActions?: RepairAction[];
 }

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

@@ -1,4 +1,3 @@
-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";
@@ -39,95 +38,15 @@ export async function handleHealth(req, res) {
         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");
+    result.ok = !result.nodePairing || (result.nodePairing.status === "ok" || result.nodePairing.status === "pending");
     res.statusCode = 200;
     res.setHeader("Content-Type", "application/json");
     res.end(JSON.stringify(result));
     return true;
 }
-async function checkDevicePairing(deviceId, selfHeal, result, log) {
-    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 = pairedDevice.approvedScopes ?? [];
-        const tokens = pairedDevice.tokens ?? {};
-        const hasValidToken = Object.values(tokens).some((t) => !t.revokedAtMs);
-        if (approvedScopes.length === 0 || !hasValidToken) {
-            const issues = [];
-            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?.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, selfHeal, result, log) {
     const normalizedNodeId = nodeDeviceId.trim().toUpperCase();
     let listData, listNodePairing, approveNodePairing;

package/dist/src/http/server.js

@@ -13,6 +13,7 @@ import { handleDeviceApprove } from "./handlers/device-approve.js";
 import { handleNodesApprove } from "./handlers/nodes-approve.js";
 import { handleSessionsSettings } from "./handlers/sessions-settings.js";
 import { handleModelsList } from "./handlers/models-list.js";
+import { handleAgentsList } from "./handlers/agents-list.js";
 import { handleStatus } from "./handlers/status.js";
 import { handleHealth } from "./handlers/health.js";
 import { applyCorsHeaders } from "./middleware/cors.js";
@@ -61,6 +62,9 @@ async function handleFridayNextRoute(req, res) {
     if (req.method === "GET" && pathname === "/friday-next/models") {
         return await handleModelsList(req, res);
     }
+    if (req.method === "GET" && pathname === "/friday-next/agents") {
+        return await handleAgentsList(req, res);
+    }
     if (req.method === "GET" && pathname === "/friday-next/status") {
         return await handleStatus(req, res);
     }

package/install.js

@@ -14,7 +14,11 @@ function realHome() {
     const h = execSync(`sh -c 'echo ~${sudoUser}'`, { encoding: "utf8" }).trim();
     if (h && !h.startsWith("~") && existsSync(h)) return h;
   } catch {}
-  for (const g of [`/home/${sudoUser}`, `/Users/${sudoUser}`]) {
+  for (const g of [
+    `/home/${sudoUser}`,
+    `/Users/${sudoUser}`,
+    `C:\\Users\\${sudoUser}`,
+  ]) {
     if (existsSync(g)) return g;
   }
   return current;

package/package.json

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

package/src/agent/node-pairing-bridge.ts

@@ -30,10 +30,16 @@ function resolveOpenClawDist(): string {
   const candidates: string[] = [
     process.env.OPENCLAW_DIST,
     fromBin,
+    // Windows: standard npm -g locations
     join(process.env.APPDATA ?? "", "npm/node_modules/openclaw/dist"),
+    join(process.env.LOCALAPPDATA ?? "", "npm/node_modules/openclaw/dist"),
+    // Cross-platform: version-manager paths detected from PATH resolution
+    // (nvm/fnm/asdf installs are found by resolveOpenClawDistFromPath via PATH)
     "/opt/homebrew/lib/node_modules/openclaw/dist",
     "/home/linuxbrew/.linuxbrew/lib/node_modules/openclaw/dist",
     "/usr/local/lib/node_modules/openclaw/dist",
+    // Linux: npm -g with prefix=/usr
+    "/usr/lib/node_modules/openclaw/dist",
   ].filter((v): v is string => typeof v === "string" && v.length > 0);
 
   for (const root of candidates) {

package/src/config.ts

@@ -1,3 +1,5 @@
+import { homedir } from "node:os";
+
 export type FridayNextLogLevel = "debug" | "info" | "warn" | "error";
 
 export type FridayNextConfig = {
@@ -52,7 +54,7 @@ export function resolveFridayNextConfig(cfg: unknown): FridayNextConfig {
     historyLimit: asNumber(section.historyLimit, 25, 1, 200),
     historyDir: asString(
       section.historyDir,
-      `${process.env.HOME ?? ""}/.openclaw/friday-next/history`,
+      `${homedir()}/.openclaw/friday-next/history`,
     ),
     logLevel: asString(section.logLevel, "info") as FridayNextLogLevel,
     authToken,

package/src/e2e/agents-list.e2e.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+import {
+  setFridayAgentForwardRuntime,
+  resetFridayAgentForwardRuntimeForTest,
+} from "../agent-forward-runtime.js";
+
+/**
+ * Inject a fake host config into the forward runtime, which is what
+ * agents-list reads via getFridayAgentForwardRuntime().getConfig().
+ * setMockRuntime only wires the auth/runtime config, not the forward runtime.
+ */
+function setForwardConfig(config: unknown): void {
+  setFridayAgentForwardRuntime({
+    runtime: {
+      agent: { session: { resolveStorePath: () => "", loadSessionStore: () => ({}) } },
+      config: { current: () => config },
+    },
+  } as never);
+}
+
+async function getAgents(app: ReturnType<typeof createAppSimulator>, headers?: Record<string, string>) {
+  const res = await app.rawRequest({ method: "GET", path: "/friday-next/agents", headers });
+  return { status: res.status, body: res.body ? JSON.parse(res.body) : {}, headers: res.headers };
+}
+
+describe("e2e agents list", () => {
+  let historyDir = "";
+
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+  });
+
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+    removeTempHistoryDir(historyDir);
+  });
+
+  it("rejects a bad bearer token with 401", async () => {
+    setMockRuntime({ historyDir, authToken: "test-token" });
+    setForwardConfig({ agents: { list: [{ id: "main" }] } });
+    const app = createAppSimulator({ token: "test-token" });
+
+    const res = await getAgents(app, { authorization: "Bearer wrong-token" });
+    expect(res.status).toBe(401);
+  });
+
+  it("returns an implicit main agent when none are configured", async () => {
+    setMockRuntime({ historyDir, authToken: "test-token" });
+    setForwardConfig({ agents: { defaults: {} } });
+    const app = createAppSimulator({ token: "test-token" });
+
+    const res = await getAgents(app);
+    expect(res.status).toBe(200);
+    expect(res.body.ok).toBe(true);
+    expect(res.body.defaultAgentId).toBe("main");
+    expect(res.body.agents).toEqual([{ id: "main", isDefault: true }]);
+  });
+
+  it("lists configured agents end-to-end with normalized ids and default selection", async () => {
+    setMockRuntime({ historyDir, authToken: "test-token" });
+    setForwardConfig({
+      agents: {
+        list: [
+          { id: "Main", name: "Primary", model: "openai/gpt-4", thinkingDefault: "medium" },
+          {
+            id: "Research Bot",
+            description: "deep research",
+            model: { primary: "anthropic/claude", fallbacks: ["x"] },
+            identity: { emoji: "🔬", avatar: "data:img" },
+            default: true,
+          },
+        ],
+      },
+    });
+    const app = createAppSimulator({ token: "test-token" });
+
+    const res = await getAgents(app);
+    expect(res.status).toBe(200);
+    expect(res.headers["content-type"]).toContain("application/json");
+    expect(res.body.defaultAgentId).toBe("research-bot");
+    expect(res.body.agents).toEqual([
+      {
+        id: "main",
+        name: "Primary",
+        model: "openai/gpt-4",
+        thinkingDefault: "medium",
+        isDefault: false,
+      },
+      {
+        id: "research-bot",
+        description: "deep research",
+        model: "anthropic/claude",
+        isDefault: true,
+        emoji: "🔬",
+        avatar: "data:img",
+      },
+    ]);
+  });
+});

package/src/e2e/auto-approve.integration.test.ts

@@ -291,55 +291,6 @@ describe("e2e two-step auto-approval", () => {
 
   // ── Health endpoint with selfHeal ────────────────────────────────
 
-  it("GET /friday-next/health?selfHeal=true 自动批准 pending device", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: DEVICE_REQUEST_ID, deviceId: FAKE_DEVICE_ID }],
-      paired: [],
-    });
-    mockApproveDevice.mockResolvedValueOnce({
-      status: "approved",
-      requestId: DEVICE_REQUEST_ID,
-      device: { deviceId: FAKE_DEVICE_ID, approvedAtMs: 1700000000000 },
-    });
-
-    const app = createAppSimulator({ token: "test-token" });
-    const res = await app.rawRequest({
-      method: "GET",
-      path: `/friday-next/health?deviceId=${FAKE_DEVICE_ID}&selfHeal=true`,
-    });
-
-    expect(res.status).toBe(200);
-    const body = JSON.parse(res.body);
-    expect(body.ok).toBe(true);
-    expect(body.devicePairing.status).toBe("ok");
-    expect(body.devicePairing.detail).toContain("auto-approved");
-    expect(body.repairActions).toHaveLength(1);
-    expect(body.repairActions[0].component).toBe("devicePairing");
-    expect(body.repairActions[0].result).toBe("ok");
-    expect(mockApproveDevice).toHaveBeenCalledWith(DEVICE_REQUEST_ID);
-  });
-
-  it("GET /friday-next/health 不带 selfHeal 时不自动批准 (只返回 pending)", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: DEVICE_REQUEST_ID, deviceId: FAKE_DEVICE_ID }],
-      paired: [],
-    });
-
-    const app = createAppSimulator({ token: "test-token" });
-    const res = await app.rawRequest({
-      method: "GET",
-      path: `/friday-next/health?deviceId=${FAKE_DEVICE_ID}`,
-    });
-
-    expect(res.status).toBe(200);
-    const body = JSON.parse(res.body);
-    expect(body.devicePairing.status).toBe("pending");
-    expect(body.devicePairing.detail).toContain("pending approval");
-    expect(mockApproveDevice).not.toHaveBeenCalled();
-    // ok 仍为 true，因为 pending 也视为 ok
-    expect(body.ok).toBe(true);
-  });
-
   it("GET /friday-next/health?selfHeal=true 自动批准 pending node", async () => {
     mockListDevices.mockResolvedValue({ pending: [], paired: [] }); // device 不相关
 
@@ -371,19 +322,9 @@ describe("e2e two-step auto-approval", () => {
     expect(body.repairActions[0].result).toBe("ok");
   });
 
-  it("GET /friday-next/health?selfHeal=true 同时自动批准 device 和 node", async () => {
-    // Device is pending
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: DEVICE_REQUEST_ID, deviceId: FAKE_DEVICE_ID }],
-      paired: [],
-    });
-    mockApproveDevice.mockResolvedValueOnce({
-      status: "approved",
-      requestId: DEVICE_REQUEST_ID,
-      device: { deviceId: FAKE_DEVICE_ID, approvedAtMs: 1700000000000 },
-    });
-
-    // Node is pending
+  it("GET /friday-next/health?selfHeal=true 自动批准 pending node (忽略 deviceId)", async () => {
+    // Node is pending (deviceId is ignored — device approval is handled by
+    // the WebSocket hello-ok path, not by the health endpoint)
     const mockListNodePairing = vi.fn().mockResolvedValueOnce({
       pending: [{ requestId: NODE_REQUEST_ID, nodeId: FAKE_DEVICE_ID }],
       paired: [],
@@ -406,10 +347,9 @@ describe("e2e two-step auto-approval", () => {
     expect(res.status).toBe(200);
     const body = JSON.parse(res.body);
     expect(body.ok).toBe(true);
-    expect(body.devicePairing.status).toBe("ok");
+    expect(body.devicePairing).toBeUndefined();
     expect(body.nodePairing.status).toBe("ok");
-    expect(body.repairActions).toHaveLength(2);
-    expect(body.repairActions[0].component).toBe("devicePairing");
-    expect(body.repairActions[1].component).toBe("nodePairing");
+    expect(body.repairActions).toHaveLength(1);
+    expect(body.repairActions[0].component).toBe("nodePairing");
   });
 });

package/src/http/handlers/agents-list.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
+import { handleAgentsList } from "./agents-list.js";
+import { setMockRuntime } from "../../test-support/mock-runtime.js";
+import {
+  setFridayAgentForwardRuntime,
+  resetFridayAgentForwardRuntimeForTest,
+} from "../../agent-forward-runtime.js";
+
+class MockRes extends EventEmitter {
+  statusCode = 0;
+  headers: Record<string, string> = {};
+  body = "";
+  setHeader(name: string, value: string): void {
+    this.headers[name.toLowerCase()] = value;
+  }
+  end(body?: string): void {
+    if (body) this.body += body;
+  }
+}
+
+function makeReq(headers: Record<string, string> = {}, method = "GET"): any {
+  return { method, url: "/friday-next/agents", headers };
+}
+
+const AUTH = { authorization: "Bearer test-token" };
+
+/** Inject a fake config into the forward runtime (handler reads getConfig()). */
+function setConfig(config: unknown): void {
+  setFridayAgentForwardRuntime({
+    runtime: {
+      agent: { session: { resolveStorePath: () => "", loadSessionStore: () => ({}) } },
+      config: { current: () => config },
+    },
+  } as any);
+}
+
+describe("handleAgentsList", () => {
+  beforeEach(() => {
+    setMockRuntime();
+  });
+
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+  });
+
+  it("rejects non-GET methods with 405", async () => {
+    const res = new MockRes();
+    await handleAgentsList(makeReq(AUTH, "POST"), res as any);
+    expect(res.statusCode).toBe(405);
+  });
+
+  it("rejects missing/invalid bearer token with 401", async () => {
+    const res = new MockRes();
+    await handleAgentsList(makeReq(), res as any);
+    expect(res.statusCode).toBe(401);
+  });
+
+  it("returns an implicit main agent when none are configured", async () => {
+    setConfig({ agents: { defaults: {} } });
+    const res = new MockRes();
+    await handleAgentsList(makeReq(AUTH), res as any);
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.ok).toBe(true);
+    expect(body.defaultAgentId).toBe("main");
+    expect(body.agents).toEqual([{ id: "main", isDefault: true }]);
+  });
+
+  it("lists configured agents with normalized ids and resolved fields", async () => {
+    setConfig({
+      agents: {
+        list: [
+          { id: "Main", name: "Primary", model: "openai/gpt-4", thinkingDefault: "medium" },
+          {
+            id: "Research Bot",
+            description: "deep research",
+            model: { primary: "anthropic/claude", fallbacks: ["x"] },
+            identity: { emoji: "🔬", avatar: "data:..." },
+            default: true,
+          },
+        ],
+      },
+    });
+    const res = new MockRes();
+    await handleAgentsList(makeReq(AUTH), res as any);
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.defaultAgentId).toBe("research-bot");
+    expect(body.agents).toEqual([
+      {
+        id: "main",
+        name: "Primary",
+        model: "openai/gpt-4",
+        thinkingDefault: "medium",
+        isDefault: false,
+      },
+      {
+        id: "research-bot",
+        description: "deep research",
+        model: "anthropic/claude",
+        isDefault: true,
+        emoji: "🔬",
+        avatar: "data:...",
+      },
+    ]);
+  });
+
+  it("defaults to the first entry when none is marked default and dedups ids", async () => {
+    setConfig({
+      agents: {
+        list: [
+          { id: "alpha" },
+          { id: "alpha", name: "dup" },
+          { id: "beta" },
+        ],
+      },
+    });
+    const res = new MockRes();
+    await handleAgentsList(makeReq(AUTH), res as any);
+
+    const body = JSON.parse(res.body);
+    expect(body.defaultAgentId).toBe("alpha");
+    expect(body.agents.map((a: { id: string }) => a.id)).toEqual(["alpha", "beta"]);
+    expect(body.agents[0].isDefault).toBe(true);
+  });
+});

package/src/http/handlers/agents-list.ts

@@ -0,0 +1,130 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+
+const DEFAULT_AGENT_ID = "main";
+
+/** Agent ids already in path/shell-safe form skip the slug rewrite below. */
+const SAFE_AGENT_ID = /^[a-z0-9][a-z0-9_-]*$/;
+
+export interface FridayAgentEntry {
+  id: string;
+  name?: string;
+  description?: string;
+  /** Primary model ref (e.g. "openai/gpt-4"); resolved from string or {primary} forms. */
+  model?: string;
+  thinkingDefault?: string;
+  isDefault: boolean;
+  emoji?: string;
+  avatar?: string;
+}
+
+interface ResolvedAgents {
+  agents: FridayAgentEntry[];
+  defaultAgentId: string;
+}
+
+/**
+ * Mirror of OpenClaw's `normalizeAgentId` (src/routing/session-key.ts): trim,
+ * lowercase, keep path/shell-safe. Empty → "main".
+ */
+function normalizeAgentId(value: unknown): string {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (!trimmed) return DEFAULT_AGENT_ID;
+  const lowered = trimmed.toLowerCase();
+  if (SAFE_AGENT_ID.test(lowered)) return lowered;
+  return (
+    lowered
+      .replace(/[^a-z0-9_-]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 64) || DEFAULT_AGENT_ID
+  );
+}
+
+/** Extract a primary model ref from the `model` field (string or {primary,...}). */
+function resolvePrimaryModel(model: unknown): string | undefined {
+  if (typeof model === "string") return readString(model);
+  if (model && typeof model === "object") {
+    return readString((model as Record<string, unknown>).primary);
+  }
+  return undefined;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+/**
+ * Reads the configured agents directly from the runtime config (same approach as
+ * models-list.ts). When no agents are configured OpenClaw runs an implicit "main"
+ * agent, so we return a single default entry to match that behaviour.
+ */
+function resolveConfiguredAgents(): ResolvedAgents {
+  const rt = getFridayAgentForwardRuntime();
+  if (!rt) return { agents: [], defaultAgentId: DEFAULT_AGENT_ID };
+
+  const cfg = rt.getConfig() as Record<string, unknown>;
+  const agents = cfg?.agents as Record<string, unknown> | undefined;
+  const list = agents?.list as Array<Record<string, unknown>> | undefined;
+
+  if (!Array.isArray(list) || list.length === 0) {
+    return {
+      agents: [{ id: DEFAULT_AGENT_ID, isDefault: true }],
+      defaultAgentId: DEFAULT_AGENT_ID,
+    };
+  }
+
+  // Default agent: first entry marked `default: true`, else the first entry.
+  const explicitDefault = list.find((a) => a?.default === true);
+  const defaultAgentId = normalizeAgentId((explicitDefault ?? list[0])?.id);
+
+  const seen = new Set<string>();
+  const entries: FridayAgentEntry[] = [];
+  for (const agent of list) {
+    if (!agent || typeof agent !== "object") continue;
+    const id = normalizeAgentId(agent.id);
+    if (seen.has(id)) continue;
+    seen.add(id);
+
+    const identity = agent.identity as Record<string, unknown> | undefined;
+    entries.push({
+      id,
+      name: readString(agent.name) ?? readString(identity?.name),
+      description: readString(agent.description),
+      model: resolvePrimaryModel(agent.model),
+      thinkingDefault: readString(agent.thinkingDefault),
+      isDefault: id === defaultAgentId,
+      emoji: readString(identity?.emoji),
+      avatar: readString(identity?.avatar) ?? readString(identity?.avatarUrl),
+    });
+  }
+
+  return { agents: entries, defaultAgentId };
+}
+
+export async function handleAgentsList(
+  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 { agents, defaultAgentId } = resolveConfiguredAgents();
+
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify({ ok: true, agents, defaultAgentId }));
+  return true;
+}

package/src/http/handlers/health.test.ts

@@ -4,16 +4,6 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { setMockRuntime } from "../../test-support/mock-runtime.js";
 import { __setMockNodePairingForTests } from "../../agent/node-pairing-bridge.js";
 
-const { mockListDevices, mockApproveDevice } = vi.hoisted(() => ({
-  mockListDevices: vi.fn(),
-  mockApproveDevice: vi.fn(),
-}));
-
-vi.mock("openclaw/plugin-sdk/device-bootstrap", () => ({
-  listDevicePairing: mockListDevices,
-  approveDevicePairing: mockApproveDevice,
-}));
-
 const { mockListNodePairing, mockApproveNodePairing } = vi.hoisted(() => ({
   mockListNodePairing: vi.fn(),
   mockApproveNodePairing: vi.fn(),
@@ -45,8 +35,6 @@ describe("handleHealth", () => {
   beforeEach(() => {
     setMockRuntime();
     vi.clearAllMocks();
-    mockListDevices.mockResolvedValue({ pending: [], paired: [] });
-    mockApproveDevice.mockResolvedValue({ status: "approved", requestId: REQUEST_ID });
     __setMockNodePairingForTests({
       listNodePairing: mockListNodePairing,
       approveNodePairing: mockApproveNodePairing,
@@ -85,226 +73,6 @@ describe("handleHealth", () => {
     expect(body.repairActions).toBeUndefined();
   });
 
-  // --- selfHeal parameter ---
-
-  it("selfHeal defaults to false (opt-in)", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: REQUEST_ID, deviceId: DEVICE_ID }],
-      paired: [],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    expect((res as unknown as MockRes).statusCode).toBe(200);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.devicePairing.status).toBe("pending");
-    expect(mockApproveDevice).not.toHaveBeenCalled();
-  });
-
-  it("selfHeal=true enables auto-approve", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: REQUEST_ID, deviceId: DEVICE_ID }],
-      paired: [],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}&selfHeal=true`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.devicePairing.status).toBe("ok");
-    expect(body.repairActions).toHaveLength(1);
-    expect(body.repairActions[0].component).toBe("devicePairing");
-    expect(body.repairActions[0].result).toBe("ok");
-  });
-
-  it("selfHeal=True (capital T) is case-insensitive and enables auto-heal", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: REQUEST_ID, deviceId: DEVICE_ID }],
-      paired: [],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}&selfHeal=True`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.devicePairing.status).toBe("ok");
-  });
-
-  it("selfHeal=FALSE is case-insensitive and stays disabled", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: REQUEST_ID, deviceId: DEVICE_ID }],
-      paired: [],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}&selfHeal=FALSE`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.devicePairing.status).toBe("pending");
-    expect(mockApproveDevice).not.toHaveBeenCalled();
-  });
-
-  // --- Device pairing: paired + healthy ---
-
-  it("returns ok when device is paired and healthy", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [],
-      paired: [
-        { deviceId: DEVICE_ID, approvedScopes: ["operator.read"], tokens: { t1: {} } },
-      ],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.ok).toBe(true);
-    expect(body.devicePairing.status).toBe("ok");
-    expect(body.devicePairing.devicePaired).toBe(true);
-  });
-
-  // --- Device pairing: degraded ---
-
-  it("returns degraded when device has no approved scopes", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [],
-      paired: [
-        { deviceId: DEVICE_ID, approvedScopes: [], tokens: { t1: {} } },
-      ],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.ok).toBe(false);
-    expect(body.devicePairing.status).toBe("degraded");
-    expect(body.devicePairing.approvedScopesEmpty).toBe(true);
-  });
-
-  it("returns degraded when all tokens are revoked", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [],
-      paired: [
-        {
-          deviceId: DEVICE_ID,
-          approvedScopes: ["operator.read"],
-          tokens: { t1: { revokedAtMs: 1000 } },
-        },
-      ],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.ok).toBe(false);
-    expect(body.devicePairing.status).toBe("degraded");
-    expect(body.devicePairing.tokensRevoked).toBe(true);
-  });
-
-  // --- Device pairing: pending ---
-
-  it("returns pending when device is pending and selfHeal is false", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: REQUEST_ID, deviceId: DEVICE_ID }],
-      paired: [],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}&selfHeal=false`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.devicePairing.status).toBe("pending");
-    expect(mockApproveDevice).not.toHaveBeenCalled();
-  });
-
-  // --- Device pairing: not_found ---
-
-  it("returns not_found when device is not in paired or pending", async () => {
-    mockListDevices.mockResolvedValueOnce({ pending: [], paired: [] });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.ok).toBe(false);
-    expect(body.devicePairing.status).toBe("not_found");
-  });
-
-  // --- Device pairing: listDevicePairing throws ---
-
-  it("returns failed when listDevicePairing throws", async () => {
-    mockListDevices.mockRejectedValueOnce(new Error("ENOENT"));
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.devicePairing.status).toBe("failed");
-    expect(body.devicePairing.detail).toContain("ENOENT");
-  });
-
-  // --- Device pairing: approveDevicePairing throws during self-heal ---
-
-  it("returns degraded when auto-approve device throws", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [{ requestId: REQUEST_ID, deviceId: DEVICE_ID }],
-      paired: [],
-    });
-    mockApproveDevice.mockRejectedValueOnce(new Error("unknown requestId"));
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}&selfHeal=true`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.devicePairing.status).toBe("degraded");
-    expect(body.repairActions).toHaveLength(1);
-    expect(body.repairActions[0].result).toBe("failed");
-  });
-
-  // --- Device pairing: normalize case-insensitively ---
-
-  it("matches deviceId case-insensitively", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [],
-      paired: [
-        { deviceId: DEVICE_ID.toUpperCase(), approvedScopes: ["operator.read"], tokens: { t1: {} } },
-      ],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID.toLowerCase()}`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.devicePairing.status).toBe("ok");
-  });
-
   // --- Node pairing: paired + healthy ---
 
   it("returns ok when node is paired with required caps and commands", async () => {
@@ -459,15 +227,9 @@ describe("handleHealth", () => {
     expect(body.nodePairing.status).toBe("failed");
   });
 
-  // --- Combined: device + node ---
+  // --- Combined: deviceId + nodeDeviceId ---
 
-  it("checks both device and node and reports overall ok", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [],
-      paired: [
-        { deviceId: DEVICE_ID, approvedScopes: ["operator.read"], tokens: { t1: {} } },
-      ],
-    });
+  it("ignores deviceId and only checks node pairing", async () => {
     mockListNodePairing.mockResolvedValueOnce({
       pending: [],
       paired: [
@@ -486,30 +248,7 @@ describe("handleHealth", () => {
     await handleHealth(req, res);
     const body = JSON.parse((res as unknown as MockRes).body);
     expect(body.ok).toBe(true);
-    expect(body.devicePairing.status).toBe("ok");
+    expect(body.devicePairing).toBeUndefined();
     expect(body.nodePairing.status).toBe("ok");
   });
-
-  it("reports ok=false when device is ok but node is degraded", async () => {
-    mockListDevices.mockResolvedValueOnce({
-      pending: [],
-      paired: [
-        { deviceId: DEVICE_ID, approvedScopes: ["operator.read"], tokens: { t1: {} } },
-      ],
-    });
-    mockListNodePairing.mockResolvedValueOnce({
-      pending: [],
-      paired: [{ nodeId: NODE_ID, caps: [], commands: [] }],
-    });
-
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}&nodeDeviceId=${NODE_ID}`, {
-      authorization: "Bearer test-token",
-    });
-    const res = new MockRes() as unknown as ServerResponse;
-    await handleHealth(req, res);
-    const body = JSON.parse((res as unknown as MockRes).body);
-    expect(body.ok).toBe(false);
-    expect(body.devicePairing.status).toBe("ok");
-    expect(body.nodePairing.status).toBe("degraded");
-  });
 });

package/src/http/handlers/health.ts

@@ -1,5 +1,4 @@
 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";
@@ -35,7 +34,6 @@ export interface HealthCheckResult {
   timestamp: number;
   deviceId: string;
   nodeDeviceId: string;
-  devicePairing?: HealthComponentStatus;
   nodePairing?: HealthComponentStatus;
   repairActions?: RepairAction[];
 }
@@ -70,112 +68,17 @@ export async function handleHealth(req: IncomingMessage, res: ServerResponse): P
 
   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");
+  result.ok = !result.nodePairing || (result.nodePairing.status === "ok" || result.nodePairing.status === "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,

package/src/http/server.ts

@@ -15,6 +15,7 @@ import { handleDeviceApprove } from "./handlers/device-approve.js";
 import { handleNodesApprove } from "./handlers/nodes-approve.js";
 import { handleSessionsSettings } from "./handlers/sessions-settings.js";
 import { handleModelsList } from "./handlers/models-list.js";
+import { handleAgentsList } from "./handlers/agents-list.js";
 import { handleStatus } from "./handlers/status.js";
 import { handleHealth } from "./handlers/health.js";
 import { applyCorsHeaders } from "./middleware/cors.js";
@@ -77,6 +78,10 @@ async function handleFridayNextRoute(
     return await handleModelsList(req, res);
   }
 
+  if (req.method === "GET" && pathname === "/friday-next/agents") {
+    return await handleAgentsList(req, res);
+  }
+
   if (req.method === "GET" && pathname === "/friday-next/status") {
     return await handleStatus(req, res);
   }