import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

import { afterEach, describe, expect, it, vi } from "vitest";

import { beginAppRegistration, pollAppRegistration } from "./app-registration.js";

const { fetchWithSsrFGuardMock } = vi.hoisted(() => ({

fetchWithSsrFGuardMock: vi.fn(),

}));

vi.mock("openclaw/plugin-sdk/ssrf-runtime", () => ({

fetchWithSsrFGuard: fetchWithSsrFGuardMock,

}));

function mockFeishuJson(payload: unknown) {

fetchWithSsrFGuardMock.mockResolvedValueOnce({

response: new Response(JSON.stringify(payload), { status: 200 }),

release: async () => {},

});

}

describe("Feishu app registration", () => {

afterEach(() => {

vi.useRealTimers();

vi.restoreAllMocks();

fetchWithSsrFGuardMock.mockReset();

});

it("defaults unsafe begin polling lifetimes from provider responses", async () => {

mockFeishuJson({

device_code: "device-code",

verification_uri_complete: "https://accounts.feishu.cn/verify?x=1",

user_code: "user-code",

interval: Number.POSITIVE_INFINITY,

expire_in: Number.POSITIVE_INFINITY,

});

await expect(beginAppRegistration()).resolves.toMatchObject({

deviceCode: "device-code",

userCode: "user-code",

interval: 5,

expireIn: 600,

});

});

it("clamps unsafe poll sleeps from provider intervals", async () => {

vi.useFakeTimers();

const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");

fetchWithSsrFGuardMock.mockRejectedValueOnce(new Error("transient"));

const poll = pollAppRegistration({

deviceCode: "device-code",

interval: 10_000_000,

expireIn: 10_000_000,

});

await vi.advanceTimersByTimeAsync(0);

expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);

await vi.advanceTimersByTimeAsync(MAX_TIMER_TIMEOUT_MS);

await expect(poll).resolves.toEqual({ status: "timeout" });

});

});

import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";

/**

* Feishu app registration via OAuth device-code flow.

*

const REGISTRATION_PATH = "/oauth/v1/app/registration";

const REQUEST_TIMEOUT_MS = 10_000;

const DEFAULT_REGISTRATION_POLL_INTERVAL_SECONDS = 5;

const DEFAULT_REGISTRATION_EXPIRE_SECONDS = 600;

// ---------------------------------------------------------------------------

// Types

deviceCode: res.device_code,

qrUrl: qrUrl.toString(),

userCode: res.user_code,

interval: res.interval || 5,

expireIn: res.expire_in || 600,

interval:

finiteSecondsToTimerSafeMilliseconds(res.interval) === undefined

? DEFAULT_REGISTRATION_POLL_INTERVAL_SECONDS

: res.interval,

expireIn:

finiteSecondsToTimerSafeMilliseconds(res.expire_in) === undefined

? DEFAULT_REGISTRATION_EXPIRE_SECONDS

: res.expire_in,

};

}

let domain: FeishuDomain = initialDomain;

let domainSwitched = false;

const deadline = Date.now() + expireIn * 1000;

const expireInMs =

finiteSecondsToTimerSafeMilliseconds(expireIn) ??

finiteSecondsToTimerSafeMilliseconds(DEFAULT_REGISTRATION_EXPIRE_SECONDS) ??

REQUEST_TIMEOUT_MS;

const deadline = Date.now() + expireInMs;

while (Date.now() < deadline) {

if (abortSignal?.aborted) {

});

} catch {

// Transient network error — keep polling.

await sleep(currentInterval * 1000);

await sleepRegistrationPollInterval(currentInterval);

continue;

}

}

}

await sleep(currentInterval * 1000);

await sleepRegistrationPollInterval(currentInterval);

}

return { status: "timeout" };

function sleep(ms: number): Promise<void> {

return new Promise((resolve) => setTimeout(resolve, ms));

}

function sleepRegistrationPollInterval(intervalSeconds: number): Promise<void> {

const intervalMs =

finiteSecondsToTimerSafeMilliseconds(intervalSeconds) ??

finiteSecondsToTimerSafeMilliseconds(DEFAULT_REGISTRATION_POLL_INTERVAL_SECONDS) ??

REQUEST_TIMEOUT_MS;

return sleep(intervalMs);

}