@syengup/friday-channel-next 0.1.8 → 0.1.9

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/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/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.9",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",
@@ -12,15 +12,6 @@
     "tsconfig.json",
     "openclaw.plugin.json"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "pnpm build",
-    "test": "npm run test:unit && npm run test:e2e",
-    "test:unit": "vitest run",
-    "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "test:smoke": "node scripts/e2e-smoke.mjs",
-    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
-  },
   "bin": {
     "friday-channel-next": "install.js"
   },
@@ -66,5 +57,13 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.5",
     "zod": "^4.3.6"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:smoke": "node scripts/e2e-smoke.mjs",
+    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
   }
-}
+}

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/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/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,