import { readFile, writeFile } from "node:fs/promises";

import { mkdir, readFile, writeFile } from "node:fs/promises";

import { afterAll, beforeAll, describe, expect, test } from "vitest";

import { PAIRING_SETUP_BOOTSTRAP_PROFILE } from "../shared/device-bootstrap-profile.js";

import { createSuiteTempRootTracker } from "../test-helpers/temp-dir.js";

expect(second.request.requestId).toBe(first.request.requestId);

});

test("recovers when pairing state files were written as arrays", async () => {

const baseDir = await makeDevicePairingDir();

const paths = resolvePairingPaths(baseDir, "devices");

await mkdir(paths.dir, { recursive: true });

await writeFile(paths.pendingPath, "[]", "utf8");

await writeFile(paths.pairedPath, "[]", "utf8");

const pending = await requestDevicePairing(

{

deviceId: "device-array-state",

publicKey: "public-key-array-state",

role: "operator",

scopes: ["operator.read"],

},

baseDir,

);

const approved = await approveDevicePairing(

pending.request.requestId,

{ callerScopes: ["operator.read"] },

baseDir,

);

expect(approved).toEqual(

expect.objectContaining({

status: "approved",

device: expect.objectContaining({ deviceId: "device-array-state" }),

}),

);

expect(Array.isArray(JSON.parse(await readFile(paths.pendingPath, "utf8")))).toBe(false);

expect(JSON.parse(await readFile(paths.pairedPath, "utf8"))).toEqual(

expect.objectContaining({

"device-array-state": expect.objectContaining({ deviceId: "device-array-state" }),

}),

);

});

test("re-requesting with identical params preserves the original ts to prevent queue-jumping", async () => {

// Regression: refreshPendingDevicePairingRequest must not bump ts to Date.now().

// An attacker who reconnects with the same key/role/scopes could otherwise