import crypto from "node:crypto";

import fsSync from "node:fs";

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

import {

let randomIntSpy: MockInstance<RandomIntSync>;

let nextRandomInt = 0;

beforeAll(async () => {

fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-pairing-"));

beforeAll(() => {

fixtureRoot = fsSync.mkdtempSync(path.join(os.tmpdir(), "openclaw-pairing-"));

});

afterAll(async () => {

afterAll(() => {

if (fixtureRoot) {

await fs.rm(fixtureRoot, { recursive: true, force: true });

fsSync.rmSync(fixtureRoot, { recursive: true, force: true });

}

});

async function withTempStateDir<T>(fn: (stateDir: string) => Promise<T>) {

const dir = path.join(fixtureRoot, `case-${caseId++}`);

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

fsSync.mkdirSync(dir, { recursive: true });

return await withEnvAsync({ OPENCLAW_STATE_DIR: dir }, async () => await fn(dir));

}

async function writeJsonFixture(filePath: string, value: unknown) {

await fs.mkdir(path.dirname(filePath), { recursive: true });

await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");

function writeJsonFixture(filePath: string, value: unknown) {

fsSync.mkdirSync(path.dirname(filePath), { recursive: true });

fsSync.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");

}

function resolvePairingFilePath(stateDir: string, channel: string) {

return path.join(resolveOAuthDir(process.env, stateDir), `${channel}${suffix}-allowFrom.json`);

}

async function clearOAuthFixtures(stateDir: string) {

function clearOAuthFixtures(stateDir: string) {

clearPairingAllowFromReadCacheForTest();

await fs.rm(resolveOAuthDir(process.env, stateDir), { recursive: true, force: true });

fsSync.rmSync(resolveOAuthDir(process.env, stateDir), { recursive: true, force: true });

}

async function writeAllowFromFixture(params: {

allowFrom: string[];

accountId?: string;

}) {

await writeJsonFixture(

resolveAllowFromFilePath(params.stateDir, params.channel, params.accountId),

{

version: 1,

allowFrom: params.allowFrom,

},

);

writeJsonFixture(resolveAllowFromFilePath(params.stateDir, params.channel, params.accountId), {

version: 1,

allowFrom: params.allowFrom,

});

}

async function createTelegramPairingRequest(accountId: string, id = "12345") {

});

expect(created.created).toBe(true);

const filePath = resolvePairingFilePath(stateDir, "demo-pairing-b");

const raw = await fs.readFile(filePath, "utf8");

const raw = fsSync.readFileSync(filePath, "utf8");

const parsed = JSON.parse(raw) as {

requests?: Array<Record<string, unknown>>;

};

const expiredAt = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();

const requests = (parsed.requests ?? []).map((entry) =>

Object.assign({}, entry, { createdAt: expiredAt, lastSeenAt: expiredAt }),

);

await writeJsonFixture(filePath, { version: 1, requests });

writeJsonFixture(filePath, { version: 1, requests });

expect(await listChannelPairingRequests("demo-pairing-b")).toHaveLength(0);

const next = await upsertChannelPairingRequest({

channel: "demo-pairing-b",

expect(listIds).toEqual(["+15550000001", "+15550000002", "+15550000003"]);

const createdAt = new Date().toISOString();

await writeJsonFixture(resolvePairingFilePath(stateDir, "demo-pairing-d"), {

writeJsonFixture(resolvePairingFilePath(stateDir, "demo-pairing-d"), {

version: 1,

requests: ids.map((id, index) => ({

id,

allowFrom: ["1001"],

});

const malformedScopedPath = resolveAllowFromFilePath(stateDir, "telegram", "yy");

await fs.mkdir(path.dirname(malformedScopedPath), { recursive: true });

await fs.writeFile(malformedScopedPath, "{ this is not json\n", "utf8");

fsSync.mkdirSync(path.dirname(malformedScopedPath), { recursive: true });

fsSync.writeFileSync(malformedScopedPath, "{ this is not json\n", "utf8");

},

accountId: "yy",

expected: [],

expected: ["1002", "1001"],

},

] as const) {

await clearOAuthFixtures(stateDir);

clearOAuthFixtures(stateDir);

await setup();

await expectAllowFromReadConsistencyCase({

...(accountId !== undefined ? { accountId } : {}),

secondAccountId: "beta",

});

await clearOAuthFixtures(stateDir);

clearOAuthFixtures(stateDir);

for (const accountId of ["alpha", "beta", "gamma"]) {

const created = await upsertChannelPairingRequest({

channel: "telegram",

readAllowFrom: async () => readChannelAllowFromStoreSync("telegram", process.env, "yy"),

},

]) {

await clearOAuthFixtures(stateDir);

clearOAuthFixtures(stateDir);

await withAllowFromCacheReadSpy({

stateDir,

createReadSpy: variant.createReadSpy,