refactor: dedupe pending pairing request flow and add reuse tests

src/infra/device-pairing.test.ts

@@ -33,6 +33,28 @@ function requireToken(token: string | undefined): string {
 }
 
 describe("device pairing tokens", () => {
+  test("reuses existing pending requests for the same device", async () => {
+    const baseDir = await mkdtemp(join(tmpdir(), "openclaw-device-pairing-"));
+    const first = await requestDevicePairing(
+      {
+        deviceId: "device-1",
+        publicKey: "public-key-1",
+      },
+      baseDir,
+    );
+    const second = await requestDevicePairing(
+      {
+        deviceId: "device-1",
+        publicKey: "public-key-1",
+      },
+      baseDir,
+    );
+
+    expect(first.created).toBe(true);
+    expect(second.created).toBe(false);
+    expect(second.request.requestId).toBe(first.request.requestId);
+  });
+
   test("generates base64url device tokens with 256-bit entropy output length", async () => {
     const baseDir = await mkdtemp(join(tmpdir(), "openclaw-device-pairing-"));
     await setupPairedOperatorDevice(baseDir, ["operator.admin"]);

src/infra/device-pairing.ts

@@ -5,6 +5,7 @@ import {
   pruneExpiredPending,
   readJsonFile,
   resolvePairingPaths,
+  upsertPendingPairingRequest,
   writeJsonAtomic,
 } from "./pairing-files.js";
 import { generatePairingToken, verifyPairingToken } from "./pairing-token.js";
@@ -226,12 +227,12 @@ export async function requestDevicePairing(
     if (!deviceId) {
       throw new Error("deviceId required");
     }
-    const existing = Object.values(state.pendingById).find((p) => p.deviceId === deviceId);
+
-    if (existing) {
+    return await upsertPendingPairingRequest({
-      return { status: "pending", request: existing, created: false };
+      pendingById: state.pendingById,
-    }
+      isExisting: (pending) => pending.deviceId === deviceId,
-    const isRepair = Boolean(state.pairedByDeviceId[deviceId]);
+      isRepair: Boolean(state.pairedByDeviceId[deviceId]),
-    const request: DevicePairingPendingRequest = {
+      createRequest: (isRepair) => ({
         requestId: randomUUID(),
         deviceId,
         publicKey: req.publicKey,
@@ -246,10 +247,9 @@ export async function requestDevicePairing(
         silent: req.silent,
         isRepair,
         ts: Date.now(),
-    };
+      }),
-    state.pendingById[request.requestId] = request;
+      persist: async () => await persistState(state, baseDir),
-    await persistState(state, baseDir);
+    });
-    return { status: "pending", request, created: true };
   });
 }
 

src/infra/node-pairing.test.ts

@@ -28,6 +28,28 @@ async function setupPairedNode(baseDir: string): Promise<string> {
 }
 
 describe("node pairing tokens", () => {
+  test("reuses existing pending requests for the same node", async () => {
+    const baseDir = await mkdtemp(join(tmpdir(), "openclaw-node-pairing-"));
+    const first = await requestNodePairing(
+      {
+        nodeId: "node-1",
+        platform: "darwin",
+      },
+      baseDir,
+    );
+    const second = await requestNodePairing(
+      {
+        nodeId: "node-1",
+        platform: "darwin",
+      },
+      baseDir,
+    );
+
+    expect(first.created).toBe(true);
+    expect(second.created).toBe(false);
+    expect(second.request.requestId).toBe(first.request.requestId);
+  });
+
   test("generates base64url node tokens with 256-bit entropy output length", async () => {
     const baseDir = await mkdtemp(join(tmpdir(), "openclaw-node-pairing-"));
     const token = await setupPairedNode(baseDir);

src/infra/node-pairing.ts

@@ -4,6 +4,7 @@ import {
   pruneExpiredPending,
   readJsonFile,
   resolvePairingPaths,
+  upsertPendingPairingRequest,
   writeJsonAtomic,
 } from "./pairing-files.js";
 import { generatePairingToken, verifyPairingToken } from "./pairing-token.js";
@@ -123,13 +124,11 @@ export async function requestNodePairing(
       throw new Error("nodeId required");
     }
 
-    const existing = Object.values(state.pendingById).find((p) => p.nodeId === nodeId);
+    return await upsertPendingPairingRequest({
-    if (existing) {
+      pendingById: state.pendingById,
-      return { status: "pending", request: existing, created: false };
+      isExisting: (pending) => pending.nodeId === nodeId,
-    }
+      isRepair: Boolean(state.pairedByNodeId[nodeId]),
-
+      createRequest: (isRepair) => ({
-    const isRepair = Boolean(state.pairedByNodeId[nodeId]);
-    const request: NodePairingPendingRequest = {
         requestId: randomUUID(),
         nodeId,
         displayName: req.displayName,
@@ -146,10 +145,9 @@ export async function requestNodePairing(
         silent: req.silent,
         isRepair,
         ts: Date.now(),
-    };
+      }),
-    state.pendingById[request.requestId] = request;
+      persist: async () => await persistState(state, baseDir),
-    await persistState(state, baseDir);
+    });
-    return { status: "pending", request, created: true };
   });
 }
 

src/infra/pairing-files.ts

@@ -24,3 +24,27 @@ export function pruneExpiredPending<T extends { ts: number }>(
     }
   }
 }
+
+export type PendingPairingRequestResult<TPending> = {
+  status: "pending";
+  request: TPending;
+  created: boolean;
+};
+
+export async function upsertPendingPairingRequest<TPending extends { requestId: string }>(params: {
+  pendingById: Record<string, TPending>;
+  isExisting: (pending: TPending) => boolean;
+  createRequest: (isRepair: boolean) => TPending;
+  isRepair: boolean;
+  persist: () => Promise<void>;
+}): Promise<PendingPairingRequestResult<TPending>> {
+  const existing = Object.values(params.pendingById).find(params.isExisting);
+  if (existing) {
+    return { status: "pending", request: existing, created: false };
+  }
+
+  const request = params.createRequest(params.isRepair);
+  params.pendingById[request.requestId] = request;
+  await params.persist();
+  return { status: "pending", request, created: true };
+}