@valni/cli-darwin-x64 0.0.0-stage → 0.1.2

package/runtime/extensions/switchboard-local/extensions/local/store.ts

@@ -0,0 +1,82 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { managedDir, stateFile } from "./paths.ts";
+
+export interface State {
+	mlxPort?: number;
+	mlxPid?: number;
+	ggufPort?: number;
+	ggufPid?: number;
+	ggufBuild?: string;
+	ggufAccelerator?: string;
+	mlxOwners?: number[];
+	ggufOwners?: number[];
+}
+
+export type OwnerKey = "mlxOwners" | "ggufOwners";
+
+export function isAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function claimOwnership(key: OwnerKey, pid: number): void {
+	const owners = (readState()[key] ?? []).filter(isAlive);
+	if (!owners.includes(pid)) owners.push(pid);
+	updateState({ [key]: owners } as Partial<State>);
+}
+
+export function releaseOwnership(key: OwnerKey, pid: number): number[] {
+	const remaining = (readState()[key] ?? []).filter((owner) => owner !== pid && isAlive(owner));
+	updateState({ [key]: remaining } as Partial<State>);
+	return remaining;
+}
+
+export function readState(): State {
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(stateFile(), "utf8"));
+		if (typeof parsed !== "object" || parsed === null) return {};
+		return parsed as State;
+	} catch {
+		return {};
+	}
+}
+
+export function writeState(next: State): void {
+	mkdirSync(managedDir(), { recursive: true });
+	writeFileSync(stateFile(), `${JSON.stringify(next, null, "\t")}\n`, "utf8");
+}
+
+export function updateState(patch: Partial<State>): State {
+	const next = { ...readState(), ...patch };
+	writeState(next);
+	return next;
+}
+
+export async function freePort(): Promise<number> {
+	return await new Promise((resolve, reject) => {
+		const server = createServer();
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			if (address === null || typeof address === "string") {
+				server.close(() => reject(new Error("could not reserve a local port")));
+				return;
+			}
+			const { port } = address;
+			server.close(() => resolve(port));
+		});
+	});
+}
+
+export async function portIsFree(port: number): Promise<boolean> {
+	return await new Promise((resolve) => {
+		const server = createServer();
+		server.once("error", () => resolve(false));
+		server.listen(port, "127.0.0.1", () => server.close(() => resolve(true)));
+	});
+}

package/runtime/extensions/switchboard-local/extensions/local/ui.ts

@@ -0,0 +1,60 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { LocalEngine, Progress } from "./engine.ts";
+import { chooseEngine } from "./engines/select.ts";
+import { displayName } from "./provider.ts";
+
+const STATUS_KEY = "switchboard-local";
+const ADD_LABEL = "Add a model…";
+const CLOSE_LABEL = "Close";
+
+function bar(fraction: number): string {
+	const filled = Math.round(fraction * 20);
+	return `${"█".repeat(filled)}${"░".repeat(20 - filled)} ${Math.round(fraction * 100)}%`;
+}
+
+function render(progress: Progress): string {
+	return progress.fraction === undefined ? progress.label : `${progress.label}  ${bar(progress.fraction)}`;
+}
+
+async function describe(engine: LocalEngine): Promise<string> {
+	if (!engine.supported()) return `${engine.label}: not available here`;
+	if (!engine.isInstalled()) return `${engine.label}: not installed`;
+	if (!engine.isRunning()) return `${engine.label}: installed`;
+	const models = await engine.listModels().catch(() => []);
+	return `${engine.label}: ${models.length} ready`;
+}
+
+export async function statusLine(engines: readonly LocalEngine[]): Promise<string> {
+	return (await Promise.all(engines.map(describe))).join(" · ");
+}
+
+export async function addModel(
+	engines: readonly LocalEngine[],
+	ctx: ExtensionCommandContext,
+	input: string,
+): Promise<void> {
+	const onProgress = (progress: Progress) => ctx.ui.setStatus(STATUS_KEY, render(progress));
+	try {
+		const { engine, reference } = await chooseEngine(engines, input);
+		await engine.ensureReady(onProgress);
+		await engine.addModel(reference, onProgress);
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		ctx.ui.notify(`${displayName(reference)} is ready on ${engine.label}. Pick it with /model.`, "info");
+	} catch (error) {
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+	}
+}
+
+export async function showMenu(engines: readonly LocalEngine[], ctx: ExtensionCommandContext): Promise<void> {
+	const usable = engines.filter((engine) => engine.supported());
+	if (usable.length === 0) {
+		ctx.ui.notify(engines.map((engine) => engine.unsupportedReason()).join(" "), "warning");
+		return;
+	}
+	const choice = await ctx.ui.select(`Switchboard Local — ${await statusLine(engines)}`, [ADD_LABEL, CLOSE_LABEL]);
+	if (choice !== ADD_LABEL) return;
+	const entry = await ctx.ui.input("Hugging Face model", "unsloth/Qwen3-30B-A3B-Instruct-GGUF:Q4_K_M");
+	if (!entry || !entry.trim()) return;
+	await addModel(engines, ctx, entry);
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard/dist/apiTypes.js

@@ -0,0 +1,74 @@
+import * as wire from "./wire.js";
+export const MICRO_CENTS_PER_USD = 100_000_000;
+export function usdFromMicroCents(microCents) {
+    return microCents / MICRO_CENTS_PER_USD;
+}
+export const UsageRecord = {
+    fromWire(value) {
+        const fields = wire.mapping(value, "usage_record");
+        return {
+            id: wire.integer(fields, "id", "usage_record"),
+            at: wire.integer(fields, "at", "usage_record"),
+            end_user_id: wire.optionalString(fields, "end_user_id", "usage_record"),
+            model_id: wire.string(fields, "model_id", "usage_record"),
+            provider_id: wire.string(fields, "provider_id", "usage_record"),
+            prompt_tokens: wire.integer(fields, "prompt_tokens", "usage_record"),
+            completion_tokens: wire.integer(fields, "completion_tokens", "usage_record"),
+            cache_creation_tokens: wire.integer(fields, "cache_creation_tokens", "usage_record"),
+            cache_read_tokens: wire.integer(fields, "cache_read_tokens", "usage_record"),
+            reasoning_tokens: wire.integer(fields, "reasoning_tokens", "usage_record"),
+            cost_micro_cents: wire.integer(fields, "cost_micro_cents", "usage_record"),
+        };
+    },
+};
+export const UsagePage = {
+    fromWire(value) {
+        const fields = wire.mapping(value, "usage_page");
+        return {
+            company_id: wire.string(fields, "company_id", "usage_page"),
+            records: wire.array(fields, "records", "usage_page").map((item) => UsageRecord.fromWire(item)),
+            next_before_at: wire.optionalInteger(fields, "next_before_at", "usage_page"),
+            next_before_id: wire.optionalInteger(fields, "next_before_id", "usage_page"),
+        };
+    },
+};
+export const PickerModel = {
+    fromWire(value) {
+        const fields = wire.mapping(value, "picker_model");
+        return {
+            id: wire.string(fields, "id", "picker_model"),
+            display_name: wire.string(fields, "display_name", "picker_model"),
+            context_window: wire.integer(fields, "context_window", "picker_model"),
+            max_output_tokens: wire.optionalInteger(fields, "max_output_tokens", "picker_model"),
+            input_formats: wire.stringArray(fields, "input_formats", "picker_model"),
+            capabilities: wire.stringArray(fields, "capabilities", "picker_model"),
+            wire_format: wire.string(fields, "wire_format", "picker_model"),
+        };
+    },
+};
+export const ModelsPage = {
+    fromWire(value) {
+        const fields = wire.mapping(value, "models_page");
+        return {
+            models: wire.array(fields, "models", "models_page").map((item) => PickerModel.fromWire(item)),
+        };
+    },
+};
+export const BalancePage = {
+    fromWire(value) {
+        const fields = wire.mapping(value, "balance_page");
+        return {
+            company_id: wire.string(fields, "company_id", "balance_page"),
+            balance_micro_cents: wire.integer(fields, "balance_micro_cents", "balance_page"),
+        };
+    },
+};
+export const ErrorEnvelope = {
+    fromWire(value) {
+        const fields = wire.mapping(value, "error_envelope");
+        return {
+            code: wire.string(fields, "code", "error_envelope"),
+            error: wire.string(fields, "error", "error_envelope"),
+        };
+    },
+};

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard/dist/client.js

@@ -0,0 +1,292 @@
+import { ModelsPage, UsagePage } from "./apiTypes.js";
+import { DecodingFailedError, EncodingFailedError, MissingAPIKeyError, ServerError, StreamError, SwitchboardError, TransportError, serverErrorFor, } from "./errors.js";
+import * as native from "./native.js";
+export const DEFAULT_BASE_URL = "https://switchboard.valni.app";
+export const DEFAULT_TIMEOUT_MILLISECONDS = 600_000;
+const INFERENCE_PATH = "/v1/switchboard/inference";
+const MODELS_PATH = "/v1/models";
+const USAGE_PATH = "/v1/switchboard/usage";
+const MAX_ERROR_BODY_BYTES = 64 * 1024;
+const SSE_DATA_PREFIX = "data:";
+const RESPONSES_FAILED_CODE = "response.failed";
+const RESPONSES_FAILED_DEFAULT_MESSAGE = "The response failed";
+const RESPONSES_ERROR_CODE = "error";
+function encodeRouterBody(router) {
+    let encoded;
+    try {
+        encoded = JSON.stringify(router.toWire());
+    }
+    catch (error) {
+        throw new EncodingFailedError(error);
+    }
+    if (encoded === undefined) {
+        throw new EncodingFailedError(new TypeError("router body is not JSON-encodable"));
+    }
+    return encoded;
+}
+function decodeJson(payload, decode) {
+    try {
+        return decode(JSON.parse(payload));
+    }
+    catch (error) {
+        throw new DecodingFailedError(error);
+    }
+}
+function responseDecoderFor(body) {
+    if (body instanceof native.AnthropicMessagesRequest)
+        return native.AnthropicMessageResponse.fromWire;
+    if (body instanceof native.OpenAIChatRequest)
+        return native.OpenAIChatResponse.fromWire;
+    if (body instanceof native.OpenAIResponsesRequest)
+        return native.OpenAIResponsesResponse.fromWire;
+    throw new EncodingFailedError(new TypeError("unsupported router body type"));
+}
+function streamEventParserFor(body) {
+    if (body instanceof native.AnthropicMessagesRequest)
+        return native.AnthropicStream.parse;
+    if (body instanceof native.OpenAIChatRequest)
+        return native.OpenAIChatChunk.fromWire;
+    if (body instanceof native.OpenAIResponsesRequest)
+        return native.OpenAIResponsesStream.parse;
+    throw new EncodingFailedError(new TypeError("unsupported router body type"));
+}
+function streamErrorFromEvent(event) {
+    if (event instanceof native.AnthropicStream.Error) {
+        return new StreamError(event.error_type, event.message);
+    }
+    if (event instanceof native.OpenAIResponsesStream.ResponseFailed) {
+        const errorWire = event.response["error"];
+        const message = errorWire !== null && typeof errorWire === "object" && !Array.isArray(errorWire)
+            ? errorWire["message"]
+            : null;
+        return new StreamError(RESPONSES_FAILED_CODE, typeof message === "string" ? message : RESPONSES_FAILED_DEFAULT_MESSAGE);
+    }
+    if (event instanceof native.OpenAIResponsesStream.Error) {
+        return new StreamError(RESPONSES_ERROR_CODE, event.message);
+    }
+    return null;
+}
+function decodeErrorEnvelope(bodyText) {
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const envelope = parsed;
+    const code = envelope["code"];
+    const message = envelope["error"];
+    if (typeof code !== "string" || typeof message !== "string")
+        return null;
+    const optionalStrings = {};
+    for (const key of ["model", "provider", "fault", "requestId"]) {
+        const value = envelope[key];
+        if (value !== null && value !== undefined && typeof value !== "string")
+            return null;
+        optionalStrings[key] = typeof value === "string" ? value : null;
+    }
+    const optionalIntegers = {};
+    for (const key of ["spentMicros", "capMicros", "retryAfterSeconds"]) {
+        const value = envelope[key];
+        if (value !== null && value !== undefined && (typeof value !== "number" || !Number.isInteger(value)))
+            return null;
+        optionalIntegers[key] = typeof value === "number" ? value : null;
+    }
+    return {
+        code,
+        message,
+        context: {
+            model: optionalStrings["model"] ?? null,
+            provider: optionalStrings["provider"] ?? null,
+            fault: optionalStrings["fault"] ?? null,
+            requestId: optionalStrings["requestId"] ?? null,
+            spentMicros: optionalIntegers["spentMicros"] ?? null,
+            capMicros: optionalIntegers["capMicros"] ?? null,
+            retryAfterSeconds: optionalIntegers["retryAfterSeconds"] ?? null,
+        },
+    };
+}
+function serverErrorFromBody(status, bodyText) {
+    if (bodyText.length === 0) {
+        return new ServerError(status, null, "Empty response body", null);
+    }
+    const envelope = decodeErrorEnvelope(bodyText);
+    if (envelope !== null) {
+        return serverErrorFor(status, envelope.code, envelope.message, envelope.context);
+    }
+    return new ServerError(status, null, bodyText, null);
+}
+async function collectBoundedBody(response) {
+    const body = response.body;
+    if (body === null)
+        return "";
+    const reader = body.getReader();
+    const collected = [];
+    let total = 0;
+    while (total < MAX_ERROR_BODY_BYTES) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        const remaining = MAX_ERROR_BODY_BYTES - total;
+        const chunk = value.byteLength > remaining ? value.subarray(0, remaining) : value;
+        collected.push(chunk);
+        total += chunk.byteLength;
+    }
+    await reader.cancel().catch(() => undefined);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of collected) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(merged);
+}
+function ssePayload(line) {
+    if (!line.startsWith(SSE_DATA_PREFIX))
+        return null;
+    const payload = line.slice(SSE_DATA_PREFIX.length).trim();
+    if (payload.length === 0 || payload === native.DONE_SENTINEL)
+        return null;
+    return payload;
+}
+function isSuccess(status) {
+    return status >= 200 && status < 300;
+}
+async function* sseLines(body) {
+    const decoder = new TextDecoder();
+    let buffered = "";
+    for await (const chunk of body) {
+        buffered += decoder.decode(chunk, { stream: true });
+        const lines = buffered.split(/\r\n|\r|\n/);
+        buffered = lines.pop() ?? "";
+        yield* lines;
+    }
+    buffered += decoder.decode();
+    if (buffered.length > 0) {
+        yield buffered;
+    }
+}
+export class Client {
+    apiKey;
+    baseUrl;
+    timeoutMilliseconds;
+    fetchImplementation;
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.timeoutMilliseconds = options.timeoutMilliseconds ?? DEFAULT_TIMEOUT_MILLISECONDS;
+        this.fetchImplementation = options.fetch ?? globalThis.fetch.bind(globalThis);
+    }
+    async inference(router) {
+        const decode = responseDecoderFor(router.kind);
+        const bodyText = await this.post(INFERENCE_PATH, encodeRouterBody(router));
+        return decodeJson(bodyText, decode);
+    }
+    async inferenceResponse(router) {
+        const body = encodeRouterBody(router);
+        let response;
+        try {
+            response = await this.fetchImplementation(`${this.baseUrl}${INFERENCE_PATH}`, {
+                method: "POST",
+                headers: this.postHeaders(),
+                body,
+                signal: AbortSignal.timeout(this.timeoutMilliseconds),
+            });
+        }
+        catch (error) {
+            throw new TransportError(error);
+        }
+        if (!isSuccess(response.status)) {
+            throw serverErrorFromBody(response.status, await collectBoundedBody(response));
+        }
+        return response;
+    }
+    async *streamInference(router) {
+        const streamingRouter = router.streaming();
+        const parse = streamEventParserFor(streamingRouter.kind);
+        const response = await this.inferenceResponse(streamingRouter);
+        if (response.body === null) {
+            throw new TransportError(new Error("Response body is missing"));
+        }
+        try {
+            for await (const line of sseLines(response.body)) {
+                const payload = ssePayload(line);
+                if (payload === null)
+                    continue;
+                const event = decodeJson(payload, parse);
+                if (event === null)
+                    continue;
+                const streamError = streamErrorFromEvent(event);
+                if (streamError !== null)
+                    throw streamError;
+                yield event;
+            }
+        }
+        catch (error) {
+            if (error instanceof SwitchboardError)
+                throw error;
+            throw new TransportError(error);
+        }
+    }
+    async models() {
+        const bodyText = await this.get(MODELS_PATH);
+        return decodeJson(bodyText, (value) => ModelsPage.fromWire(value).models);
+    }
+    async usage(query = {}) {
+        const parameters = new URLSearchParams();
+        if (query.limit !== undefined)
+            parameters.set("limit", String(query.limit));
+        if (query.beforeAt !== undefined)
+            parameters.set("before_at", String(query.beforeAt));
+        if (query.beforeId !== undefined)
+            parameters.set("before_id", String(query.beforeId));
+        if (query.since !== undefined)
+            parameters.set("since", String(query.since));
+        if (query.until !== undefined)
+            parameters.set("until", String(query.until));
+        if (query.userId !== undefined)
+            parameters.set("user_id", query.userId);
+        const queryText = parameters.size > 0 ? `?${parameters.toString()}` : "";
+        const bodyText = await this.get(`${USAGE_PATH}${queryText}`);
+        return decodeJson(bodyText, UsagePage.fromWire);
+    }
+    async get(path) {
+        return this.request(path, { method: "GET", headers: this.getHeaders() });
+    }
+    async post(path, body) {
+        return this.request(path, { method: "POST", headers: this.postHeaders(), body });
+    }
+    async request(path, init) {
+        let response;
+        try {
+            response = await this.fetchImplementation(`${this.baseUrl}${path}`, {
+                ...init,
+                signal: AbortSignal.timeout(this.timeoutMilliseconds),
+            });
+        }
+        catch (error) {
+            throw new TransportError(error);
+        }
+        if (!isSuccess(response.status)) {
+            throw serverErrorFromBody(response.status, await collectBoundedBody(response));
+        }
+        try {
+            return await response.text();
+        }
+        catch (error) {
+            throw new TransportError(error);
+        }
+    }
+    getHeaders() {
+        if (this.apiKey.length === 0) {
+            throw new MissingAPIKeyError();
+        }
+        return { Authorization: `Bearer ${this.apiKey}` };
+    }
+    postHeaders() {
+        return { ...this.getHeaders(), "Content-Type": "application/json" };
+    }
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard/dist/deviceAuth.js

@@ -0,0 +1,155 @@
+import { hostname } from "node:os";
+import { DeviceAuthError, TransportError } from "./errors.js";
+import * as wire from "./wire.js";
+export const DEFAULT_AUTH_BASE_URL = "https://api.valni.app";
+const DEVICE_AUTHORIZE_PATH = "/v1/device/authorize";
+const DEVICE_TOKEN_PATH = "/v1/device/token";
+const DEVICE_CODE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+const REFRESH_TOKEN_GRANT = "refresh_token";
+const MILLISECONDS_PER_SECOND = 1000;
+const SLOW_DOWN_EXTRA_SECONDS = 5;
+const ERROR_AUTHORIZATION_PENDING = "authorization_pending";
+const ERROR_SLOW_DOWN = "slow_down";
+const ERROR_ACCESS_DENIED = "access_denied";
+const ERROR_EXPIRED_TOKEN = "expired_token";
+function resolveFetch(options) {
+    return options.fetch ?? globalThis.fetch.bind(globalThis);
+}
+function resolveAuthBaseUrl(options) {
+    return (options.authBaseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/+$/, "");
+}
+function sleep(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new DeviceAuthError("cancelled", "Sign-in cancelled"));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, milliseconds);
+        function onAbort() {
+            clearTimeout(timer);
+            reject(new DeviceAuthError("cancelled", "Sign-in cancelled"));
+        }
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+async function postJson(fetchImplementation, url, body) {
+    try {
+        return await fetchImplementation(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (error) {
+        throw new TransportError(error);
+    }
+}
+async function decodeTokenResponse(response) {
+    let parsed;
+    try {
+        parsed = await response.json();
+    }
+    catch {
+        throw new DeviceAuthError("protocol", `Switchboard sign-in returned an unreadable token response (HTTP ${response.status})`);
+    }
+    const fields = wire.mapping(parsed, "device_token");
+    return {
+        accessToken: wire.optionalString(fields, "access_token", "device_token"),
+        refreshToken: wire.optionalString(fields, "refresh_token", "device_token"),
+        expiresInSeconds: wire.optionalInteger(fields, "expires_in", "device_token"),
+        endUserId: wire.optionalString(fields, "end_user_id", "device_token"),
+        errorCode: wire.optionalString(fields, "error", "device_token"),
+    };
+}
+function toCredentials(token) {
+    if (token.accessToken === null ||
+        token.refreshToken === null ||
+        token.expiresInSeconds === null ||
+        token.endUserId === null) {
+        throw new DeviceAuthError("incomplete_token", "Switchboard sign-in returned an incomplete token response");
+    }
+    return {
+        access: token.accessToken,
+        refresh: token.refreshToken,
+        expires: Date.now() + token.expiresInSeconds * MILLISECONDS_PER_SECOND,
+        endUserId: token.endUserId,
+    };
+}
+export async function deviceLogin(callbacks, options) {
+    const fetchImplementation = resolveFetch(options);
+    const authBaseUrl = resolveAuthBaseUrl(options);
+    const authorizeResponse = await postJson(fetchImplementation, `${authBaseUrl}${DEVICE_AUTHORIZE_PATH}`, {
+        client_id: options.clientId,
+        device_label: options.deviceLabel ?? hostname(),
+    });
+    if (!authorizeResponse.ok) {
+        throw new DeviceAuthError("protocol", `Switchboard device authorization failed (HTTP ${authorizeResponse.status})`);
+    }
+    let authorizationWire;
+    try {
+        authorizationWire = await authorizeResponse.json();
+    }
+    catch {
+        throw new DeviceAuthError("protocol", "Switchboard device authorization returned an unreadable response");
+    }
+    const fields = wire.mapping(authorizationWire, "device_authorization");
+    const deviceCode = wire.string(fields, "device_code", "device_authorization");
+    const userCode = wire.string(fields, "user_code", "device_authorization");
+    const verificationUriComplete = wire.string(fields, "verification_uri_complete", "device_authorization");
+    const expiresInSeconds = wire.integer(fields, "expires_in", "device_authorization");
+    const intervalSeconds = wire.integer(fields, "interval", "device_authorization");
+    callbacks.onDeviceCode({
+        userCode,
+        verificationUri: verificationUriComplete,
+        intervalSeconds,
+        expiresInSeconds,
+    });
+    const deadline = Date.now() + expiresInSeconds * MILLISECONDS_PER_SECOND;
+    let pollIntervalSeconds = intervalSeconds;
+    while (true) {
+        await sleep(pollIntervalSeconds * MILLISECONDS_PER_SECOND, callbacks.signal);
+        if (Date.now() > deadline) {
+            throw new DeviceAuthError("expired_token", "The sign-in code expired. Start the sign-in again.");
+        }
+        const pollResponse = await postJson(fetchImplementation, `${authBaseUrl}${DEVICE_TOKEN_PATH}`, {
+            grant_type: DEVICE_CODE_GRANT,
+            device_code: deviceCode,
+            client_id: options.clientId,
+        });
+        const token = await decodeTokenResponse(pollResponse);
+        if (token.accessToken !== null) {
+            callbacks.onProgress?.("Signed in to Switchboard");
+            return toCredentials(token);
+        }
+        if (token.errorCode === ERROR_AUTHORIZATION_PENDING)
+            continue;
+        if (token.errorCode === ERROR_SLOW_DOWN) {
+            pollIntervalSeconds += SLOW_DOWN_EXTRA_SECONDS;
+            continue;
+        }
+        if (token.errorCode === ERROR_ACCESS_DENIED) {
+            throw new DeviceAuthError("access_denied", "Sign-in was denied in the browser.");
+        }
+        if (token.errorCode === ERROR_EXPIRED_TOKEN) {
+            throw new DeviceAuthError("expired_token", "The sign-in code expired. Start the sign-in again.");
+        }
+        throw new DeviceAuthError("protocol", `Switchboard sign-in failed: ${token.errorCode ?? pollResponse.status}`);
+    }
+}
+export async function deviceRefresh(credentials, options) {
+    const fetchImplementation = resolveFetch(options);
+    const authBaseUrl = resolveAuthBaseUrl(options);
+    const response = await postJson(fetchImplementation, `${authBaseUrl}${DEVICE_TOKEN_PATH}`, {
+        grant_type: REFRESH_TOKEN_GRANT,
+        refresh_token: credentials.refresh,
+        client_id: options.clientId,
+    });
+    const token = await decodeTokenResponse(response);
+    if (token.accessToken === null) {
+        throw new DeviceAuthError("expired_token", "Switchboard session expired. Sign in again.");
+    }
+    return toCredentials(token);
+}