harborloop 0.3.0 → 0.4.0-rc.0

package/dist/api.js

@@ -1,409 +0,0 @@
-export class ApiError extends Error {
-    kind;
-    status;
-    body;
-    constructor(kind, message, status = null, body = null) {
-        super(message);
-        this.kind = kind;
-        this.status = status;
-        this.body = body;
-        this.name = 'ApiError';
-    }
-}
-function classify(status) {
-    if (status === 401)
-        return 'unauthorized';
-    if (status === 403)
-        return 'forbidden';
-    if (status === 402)
-        return 'payment_required';
-    if (status === 404)
-        return 'not_found';
-    if (status === 429)
-        return 'rate_limited';
-    if (status >= 500)
-        return 'server';
-    return 'shape';
-}
-const DEFAULT_TIMEOUT_MS = 15_000;
-export async function apiRequest(url, opts = {}) {
-    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    let response;
-    try {
-        response = await fetchImpl(url, {
-            method: opts.method ?? 'GET',
-            headers: {
-                ...(opts.body === undefined ? {} : { 'Content-Type': 'application/json' }),
-                ...(opts.bearer ? { Authorization: `Bearer ${opts.bearer}` } : {}),
-            },
-            body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
-            signal: controller.signal,
-        });
-    }
-    catch (err) {
-        throw new ApiError('network', `Could not reach ${url}: ${err.message}`);
-    }
-    finally {
-        clearTimeout(timer);
-    }
-    const text = await response.text().catch(() => '');
-    if (!response.ok) {
-        const detail = extractError(text) ?? `${response.status} from ${url}`;
-        throw new ApiError(classify(response.status), response.status === 429 ? `${detail}${describeRetryAfter(response.headers)}` : detail, response.status, parseJsonOrNull(text));
-    }
-    if (text.trim() === '')
-        return undefined;
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        throw new ApiError('shape', `Non-JSON response from ${url}`, response.status);
-    }
-}
-export function describeRetryAfter(headers, now = Date.now()) {
-    const seconds = retryAfterSeconds(headers, now);
-    if (seconds === null || seconds <= 0)
-        return '';
-    const minutes = Math.ceil(seconds / 60);
-    const wait = minutes <= 1 ? 'about a minute' : `about ${minutes} minutes`;
-    return ` — try again in ${wait}.`;
-}
-function retryAfterSeconds(headers, now) {
-    const retryAfter = headers.get('retry-after');
-    if (retryAfter !== null && retryAfter.trim() !== '') {
-        const asSeconds = Number(retryAfter);
-        if (Number.isFinite(asSeconds))
-            return asSeconds;
-        const asDate = Date.parse(retryAfter);
-        if (!Number.isNaN(asDate))
-            return (asDate - now) / 1000;
-    }
-    const reset = headers.get('ratelimit-reset');
-    if (reset !== null && reset.trim() !== '') {
-        const asSeconds = Number(reset);
-        if (Number.isFinite(asSeconds))
-            return asSeconds;
-    }
-    return null;
-}
-function parseJsonOrNull(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-function extractError(text) {
-    try {
-        const body = JSON.parse(text);
-        const headline = typeof body.error === 'string'
-            ? body.error
-            : typeof body.message === 'string'
-                ? body.message
-                : null;
-        const fields = fieldErrors(body.details?.errors);
-        if (headline !== null && fields !== null)
-            return `${headline}: ${fields}`;
-        return headline ?? fields;
-    }
-    catch {
-    }
-    return null;
-}
-function fieldErrors(errors) {
-    if (!Array.isArray(errors) || errors.length === 0)
-        return null;
-    const parts = errors.flatMap((entry) => {
-        if (entry === null || typeof entry !== 'object')
-            return [];
-        const { field, message } = entry;
-        if (typeof message !== 'string' || message === '')
-            return [];
-        return [typeof field === 'string' && field !== '' ? `${field} — ${message}` : message];
-    });
-    return parts.length === 0 ? null : parts.join('; ');
-}
-function unwrap(body, what) {
-    if (body !== null && typeof body === 'object' && !Array.isArray(body) && 'data' in body) {
-        return body.data;
-    }
-    if (Array.isArray(body) || (body !== null && typeof body === 'object')) {
-        return body;
-    }
-    throw new ApiError('shape', `Unexpected ${what} response shape`);
-}
-export async function exchangeAuthCode(apiUrl, code, codeVerifier, fetchImpl) {
-    const body = await apiRequest(`${apiUrl}/auth/desktop-token-exchange`, { method: 'POST', body: { code, codeVerifier }, fetchImpl });
-    if (typeof body?.token !== 'string' || body.token === '') {
-        throw new ApiError('shape', 'Token exchange returned no token');
-    }
-    return body.token;
-}
-export async function refreshRunnerToken(apiUrl, runnerToken, fetchImpl) {
-    const body = await apiRequest(`${apiUrl}/auth/runner-token/refresh`, { method: 'POST', bearer: runnerToken, fetchImpl });
-    if (typeof body?.token !== 'string' || body.token === '') {
-        throw new ApiError('shape', 'Refresh returned no token');
-    }
-    return body.token;
-}
-export async function fetchCurrentUser(apiUrl, runnerToken, fetchImpl) {
-    const body = await apiRequest(`${apiUrl}/users/me`, {
-        bearer: runnerToken,
-        fetchImpl,
-    });
-    const user = unwrap(body, 'user');
-    const preferences = user.preferences !== null && typeof user.preferences === 'object'
-        ? user.preferences
-        : {};
-    const last = preferences.lastWorkspaceId;
-    return {
-        id: typeof user.id === 'string' ? user.id : '',
-        email: typeof user.email === 'string' ? user.email : '',
-        name: typeof user.name === 'string' ? user.name : '',
-        lastWorkspaceId: typeof last === 'string' && last !== '' ? last : null,
-    };
-}
-export async function listWorkspaces(apiUrl, runnerToken, fetchImpl) {
-    const body = await apiRequest(`${apiUrl}/workspaces`, {
-        bearer: runnerToken,
-        fetchImpl,
-    });
-    const rows = unwrap(body, 'workspaces');
-    if (!Array.isArray(rows))
-        throw new ApiError('shape', 'Workspaces is not a list');
-    return rows.flatMap((row) => {
-        if (row === null || typeof row !== 'object')
-            return [];
-        const obj = row;
-        const ws = (obj.workspace ?? obj);
-        if (typeof ws.id !== 'string')
-            return [];
-        return [{ id: ws.id, name: typeof ws.name === 'string' ? ws.name : ws.id }];
-    });
-}
-export async function mintMcpToken(apiUrl, runnerToken, workspaceId, provider, fetchImpl) {
-    const body = await apiRequest(`${apiUrl}/workspaces/${workspaceId}/context/setup/token`, { method: 'POST', body: { provider }, bearer: runnerToken, fetchImpl });
-    const data = unwrap(body, 'mint');
-    if (typeof data.token !== 'string')
-        throw new ApiError('shape', 'Mint returned no token');
-    return {
-        token: data.token,
-        expiresIn: typeof data.expiresIn === 'string' ? data.expiresIn : 'unknown',
-        connectionId: typeof data.connectionId === 'string' ? data.connectionId : '',
-    };
-}
-function toBinding(row) {
-    if (row === null || typeof row !== 'object')
-        return [];
-    const obj = row;
-    if (typeof obj.originUrl !== 'string')
-        return [];
-    const project = obj.project;
-    return [
-        {
-            id: typeof obj.id === 'string' ? obj.id : '',
-            originUrl: obj.originUrl,
-            displayName: typeof obj.displayName === 'string' ? obj.displayName : null,
-            projectId: typeof obj.projectId === 'string' ? obj.projectId : null,
-            projectName: project && typeof project.name === 'string' ? project.name : null,
-        },
-    ];
-}
-export async function listRepoBindings(apiUrl, runnerToken, workspaceId, fetchImpl) {
-    const body = await apiRequest(`${apiUrl}/workspaces/${workspaceId}/context/repo-bindings`, { bearer: runnerToken, fetchImpl });
-    const rows = unwrap(body, 'repo-bindings');
-    if (!Array.isArray(rows))
-        return [];
-    return rows.flatMap(toBinding);
-}
-export async function createRepoBinding(apiUrl, runnerToken, workspaceId, input, fetchImpl) {
-    const body = await apiRequest(`${apiUrl}/workspaces/${workspaceId}/context/repo-bindings`, { method: 'POST', body: input, bearer: runnerToken, fetchImpl });
-    const data = unwrap(body, 'repo-binding');
-    const parsed = toBinding(data);
-    if (parsed.length === 0)
-        throw new ApiError('shape', 'Binding response had no originUrl');
-    return parsed[0];
-}
-export async function listProjects(apiUrl, runnerToken, workspaceId, fetchImpl) {
-    const body = await apiRequest(`${apiUrl}/workspaces/${workspaceId}/projects`, { bearer: runnerToken, fetchImpl });
-    const rows = unwrap(body, 'projects');
-    if (!Array.isArray(rows))
-        return [];
-    return rows.flatMap((row) => {
-        if (row === null || typeof row !== 'object')
-            return [];
-        const obj = row;
-        if (typeof obj.id !== 'string')
-            return [];
-        return [{ id: obj.id, name: typeof obj.name === 'string' ? obj.name : obj.id }];
-    });
-}
-function requireNumber(source, block, field) {
-    const value = source[field];
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        throw new ApiError('shape', `loop-metrics: ${block}.${field} is ${describeType(value)}`);
-    }
-    return value;
-}
-function requireBlock(data, name) {
-    const block = data[name];
-    if (block === null || typeof block !== 'object' || Array.isArray(block)) {
-        throw new ApiError('shape', `loop-metrics: ${name} is ${describeType(block)}`);
-    }
-    return block;
-}
-function describeType(value) {
-    if (value === undefined)
-        return 'missing';
-    if (value === null)
-        return 'null';
-    return Array.isArray(value) ? 'a list' : `a ${typeof value}`;
-}
-function optionalNumber(source, field) {
-    const value = source[field];
-    return typeof value === 'number' && Number.isFinite(value) ? value : null;
-}
-export function parseLoopMetrics(data) {
-    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
-        throw new ApiError('shape', `loop-metrics: response is ${describeType(data)}`);
-    }
-    const root = data;
-    const recall = requireBlock(root, 'recall');
-    const fit = requireBlock(root, 'fit');
-    const attribution = requireBlock(root, 'attribution');
-    const contributed = requireBlock(root, 'contributed');
-    const projectId = root.projectId;
-    const corpus = readCorpus(root.corpus);
-    const spend = readSpend(root.spend);
-    const byTransport = readTransports(root.byTransport);
-    return {
-        windowDays: requireNumber(root, 'loop-metrics', 'windowDays'),
-        projectId: typeof projectId === 'string' ? projectId : null,
-        recall: {
-            sessions: requireNumber(recall, 'recall', 'sessions'),
-            served: requireNumber(recall, 'recall', 'served'),
-        },
-        fit: {
-            servedAtoms: requireNumber(fit, 'fit', 'servedAtoms'),
-            citedAtoms: requireNumber(fit, 'fit', 'citedAtoms'),
-            avgBundle: optionalNumber(fit, 'avgBundle'),
-        },
-        attribution: {
-            recalls: requireNumber(attribution, 'attribution', 'recalls'),
-            keyed: requireNumber(attribution, 'attribution', 'keyed'),
-        },
-        contributed: {
-            total: requireNumber(contributed, 'contributed', 'total'),
-            approved: requireNumber(contributed, 'contributed', 'approved'),
-            pending: requireNumber(contributed, 'contributed', 'pending'),
-        },
-        ...(corpus ? { corpus } : {}),
-        ...(spend ? { spend } : {}),
-        ...(byTransport ? { byTransport } : {}),
-    };
-}
-function readTransports(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const rows = [];
-    for (const entry of value) {
-        if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) {
-            return undefined;
-        }
-        const block = entry;
-        const { transport, label } = block;
-        const attribution = block.attribution;
-        if (typeof transport !== 'string' ||
-            typeof label !== 'string' ||
-            attribution === null ||
-            typeof attribution !== 'object' ||
-            Array.isArray(attribution)) {
-            return undefined;
-        }
-        const pair = attribution;
-        const recalls = optionalNumber(pair, 'recalls');
-        const keyed = optionalNumber(pair, 'keyed');
-        if (recalls === null || keyed === null)
-            return undefined;
-        rows.push({
-            transport,
-            label,
-            recalls,
-            keyed,
-            clients: Array.isArray(block.clients)
-                ? block.clients
-                    .map((client) => client !== null && typeof client === 'object'
-                    ? client.surface
-                    : undefined)
-                    .filter((surface) => typeof surface === 'string')
-                : [],
-        });
-    }
-    return rows;
-}
-function readCorpus(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const block = value;
-    const admitted = optionalNumber(block, 'admitted');
-    const retired = optionalNumber(block, 'retired');
-    const liveAtoms = optionalNumber(block, 'liveAtoms');
-    if (admitted === null || retired === null || liveAtoms === null)
-        return undefined;
-    const causes = Array.isArray(block.retiredByCause)
-        ? block.retiredByCause.flatMap((row) => {
-            if (row === null || typeof row !== 'object')
-                return [];
-            const { cause, count } = row;
-            if (typeof cause !== 'string' || typeof count !== 'number')
-                return [];
-            return [{ cause, count }];
-        })
-        : undefined;
-    return {
-        admitted,
-        retired,
-        liveAtoms,
-        ...(causes ? { retiredByCause: causes } : {}),
-        ledgerEmpty: block.ledgerEmpty === true,
-    };
-}
-function readSpend(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const block = value;
-    const writeSpendCents = optionalNumber(block, 'writeSpendCents');
-    const writeSpendUsd = optionalNumber(block, 'writeSpendUsd');
-    const spendRows = optionalNumber(block, 'spendRows');
-    const citedAtoms = optionalNumber(block, 'citedAtoms');
-    if (writeSpendCents === null ||
-        writeSpendUsd === null ||
-        spendRows === null ||
-        citedAtoms === null) {
-        return undefined;
-    }
-    return {
-        writeSpendCents,
-        writeSpendUsd,
-        spendRows,
-        unpricedRows: optionalNumber(block, 'unpricedRows') ?? 0,
-        citedAtoms,
-        costPerCitedAtomUsd: optionalNumber(block, 'costPerCitedAtomUsd'),
-    };
-}
-export async function fetchLoopMetrics(apiUrl, mcpToken, params = {}, fetchImpl) {
-    const query = new URLSearchParams();
-    if (params.originUrl)
-        query.set('originUrl', params.originUrl);
-    if (params.windowDays)
-        query.set('windowDays', String(params.windowDays));
-    const suffix = query.toString() === '' ? '' : `?${query.toString()}`;
-    const body = await apiRequest(`${apiUrl}/context/loop-metrics${suffix}`, {
-        bearer: mcpToken,
-        fetchImpl,
-    });
-    return parseLoopMetrics(unwrap(body, 'loop-metrics'));
-}

package/dist/auth/login.d.ts

@@ -1,14 +0,0 @@
-import type { Endpoints } from '../endpoints.js';
-import { type StoredAuth } from './store.js';
-export interface LoginOptions {
-    readonly noBrowser?: boolean;
-    readonly workspaceId?: string;
-    readonly fetchImpl?: typeof fetch;
-}
-export declare function openBrowser(url: string): void;
-export declare function buildSignInUrl(endpoints: Endpoints, challenge: string, state: string, redirectUri: string | null): string;
-export interface LoginResult {
-    readonly auth: StoredAuth;
-    readonly reused: boolean;
-}
-export declare function login(endpoints: Endpoints, opts?: LoginOptions): Promise<LoginResult>;

package/dist/auth/login.js

@@ -1,158 +0,0 @@
-import { execFile } from 'node:child_process';
-import { createInterface } from 'node:readline/promises';
-import { ApiError, exchangeAuthCode, listWorkspaces } from '../api.js';
-import { startLoopbackListener } from './loopback.js';
-import { createPkcePair, createState } from './pkce.js';
-import { isExpired, readAuth, writeAuth } from './store.js';
-export function openBrowser(url) {
-    const [cmd, args] = process.platform === 'darwin'
-        ? ['open', [url]]
-        : process.platform === 'win32'
-            ? ['cmd', ['/c', 'start', '', url]]
-            : ['xdg-open', [url]];
-    const child = execFile(cmd, args, () => undefined);
-    child.unref();
-}
-export function buildSignInUrl(endpoints, challenge, state, redirectUri) {
-    const url = new URL('/desktop-auth', endpoints.webUrl);
-    url.searchParams.set('code_challenge', challenge);
-    url.searchParams.set('state', state);
-    url.searchParams.set('client', 'cli');
-    if (redirectUri)
-        url.searchParams.set('redirect_uri', redirectUri);
-    return url.toString();
-}
-async function ask(question) {
-    const rl = createInterface({ input: process.stdin, output: process.stderr });
-    try {
-        const eof = new Promise((resolve) => rl.once('close', () => resolve(null)));
-        const answer = await Promise.race([rl.question(question), eof]);
-        return answer === null ? null : answer.trim();
-    }
-    finally {
-        rl.close();
-    }
-}
-async function pickWorkspace(workspaces, preferred) {
-    if (workspaces.length === 0) {
-        throw new Error('This account is not a member of any workspace. Create one in the webapp first.');
-    }
-    if (preferred) {
-        const match = workspaces.find((w) => w.id === preferred);
-        if (!match) {
-            throw new Error(`Workspace ${preferred} not found. Available: ${workspaces
-                .map((w) => `${w.name} (${w.id})`)
-                .join(', ')}`);
-        }
-        return match;
-    }
-    if (workspaces.length === 1)
-        return workspaces[0];
-    if (!process.stdin.isTTY) {
-        throw new Error(`Several workspaces are available and there is no terminal to ask on. ` +
-            `Re-run with --workspace <id>: ${workspaces
-                .map((w) => `${w.name} (${w.id})`)
-                .join(', ')}`);
-    }
-    workspaces.forEach((w, i) => process.stderr.write(`  ${i + 1}. ${w.name}\n`));
-    const answer = await ask(`Workspace [1-${workspaces.length}]: `);
-    const chosen = workspaces[Number.parseInt(answer ?? '', 10) - 1];
-    if (!chosen) {
-        throw new Error(`No workspace chosen. Re-run with --workspace <id>: ${workspaces
-            .map((w) => `${w.name} (${w.id})`)
-            .join(', ')}`);
-    }
-    return chosen;
-}
-export async function login(endpoints, opts = {}) {
-    const existing = await readAuth();
-    if (existing &&
-        existing.apiUrl === endpoints.apiUrl &&
-        !isExpired(existing.runnerToken)) {
-        if (existing.workspaceId === '') {
-            const resumed = await resolveWorkspace(existing, endpoints, opts);
-            if (resumed)
-                return { auth: resumed, reused: true };
-        }
-        else if (!opts.workspaceId || existing.workspaceId === opts.workspaceId) {
-            return { auth: existing, reused: true };
-        }
-        else {
-            const switched = await resolveWorkspace(existing, endpoints, opts);
-            if (switched)
-                return { auth: switched, reused: true };
-        }
-    }
-    const { verifier, challenge } = createPkcePair();
-    const state = createState();
-    const code = opts.noBrowser
-        ? await runPasteFlow(endpoints, challenge, state)
-        : await runLoopbackFlow(endpoints, challenge, state);
-    const runnerToken = await exchangeAuthCode(endpoints.apiUrl, code, verifier, opts.fetchImpl);
-    const pending = {
-        runnerToken,
-        workspaceId: '',
-        workspaceName: '',
-        apiUrl: endpoints.apiUrl,
-        signedInAt: new Date().toISOString(),
-    };
-    await writeAuth(pending);
-    const auth = await resolveWorkspace(pending, endpoints, opts);
-    if (!auth) {
-        throw new Error('Signed in, but the new credential was rejected when reading your workspaces. ' +
-            'Run `harbor doctor` to see which endpoint it was minted against.');
-    }
-    return { auth, reused: false };
-}
-async function resolveWorkspace(existing, endpoints, opts) {
-    let workspaces;
-    try {
-        workspaces = await listWorkspaces(endpoints.apiUrl, existing.runnerToken, opts.fetchImpl);
-    }
-    catch (err) {
-        if (err instanceof ApiError && (err.kind === 'unauthorized' || err.kind === 'forbidden')) {
-            return null;
-        }
-        throw err;
-    }
-    if (opts.workspaceId && !workspaces.some((w) => w.id === opts.workspaceId)) {
-        throw new Error(`Workspace ${opts.workspaceId} not found. Available: ${workspaces
-            .map((w) => `${w.name} (${w.id})`)
-            .join(', ')}. ` +
-            `If it belongs to another account, run \`harbor logout\` first.`);
-    }
-    const workspace = await pickWorkspace(workspaces, opts.workspaceId);
-    const auth = {
-        ...existing,
-        workspaceId: workspace.id,
-        workspaceName: workspace.name,
-    };
-    await writeAuth(auth);
-    return auth;
-}
-async function runLoopbackFlow(endpoints, challenge, state) {
-    const listener = await startLoopbackListener(state);
-    try {
-        const url = buildSignInUrl(endpoints, challenge, state, listener.redirectUri);
-        process.stderr.write(`Opening ${url}\n`);
-        process.stderr.write('Waiting for the browser…\n');
-        openBrowser(url);
-        const { code } = await listener.result;
-        return code;
-    }
-    finally {
-        listener.close();
-    }
-}
-async function runPasteFlow(endpoints, challenge, state) {
-    if (!process.stdin.isTTY) {
-        throw new Error('harbor login --no-browser needs a terminal to paste the code into. ' +
-            'Run it interactively, or drop --no-browser to use the browser redirect.');
-    }
-    const url = buildSignInUrl(endpoints, challenge, state, null);
-    process.stderr.write(`Open this URL and sign in:\n\n  ${url}\n\n`);
-    const code = await ask('Paste the code from your browser: ');
-    if (code === null || code === '')
-        throw new Error('No code entered.');
-    return code;
-}

package/dist/auth/loopback.d.ts

@@ -1,11 +0,0 @@
-export interface LoopbackResult {
-    readonly code: string;
-}
-export interface LoopbackListener {
-    readonly redirectUri: string;
-    readonly result: Promise<LoopbackResult>;
-    close(): void;
-}
-export declare function startLoopbackListener(expectedState: string, opts?: {
-    readonly timeoutMs?: number;
-}): Promise<LoopbackListener>;

package/dist/auth/loopback.js

@@ -1,87 +0,0 @@
-import { createServer } from 'node:http';
-import { statesMatch } from './pkce.js';
-const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
-function respond(res, status, body) {
-    res.writeHead(status, {
-        'Content-Type': 'text/html; charset=utf-8',
-        'Cache-Control': 'no-store',
-        'Referrer-Policy': 'no-referrer',
-    });
-    res.end(body);
-}
-function page(title, detail) {
-    return `<!doctype html><meta charset="utf-8"><title>${title}</title>
-<style>
-  :root { color-scheme: light dark }
-  body { font: 15px/1.6 ui-sans-serif, system-ui, sans-serif; display: grid;
-         place-items: center; min-height: 100vh; margin: 0; padding: 2rem }
-  main { max-width: 30rem; text-align: center }
-  h1 { font-size: 1.25rem; margin: 0 0 .5rem }
-  p { margin: 0; opacity: .75 }
-</style>
-<main><h1>${title}</h1><p>${detail}</p></main>`;
-}
-export async function startLoopbackListener(expectedState, opts = {}) {
-    let settle = () => undefined;
-    let fail = () => undefined;
-    const result = new Promise((resolve, reject) => {
-        settle = resolve;
-        fail = reject;
-    });
-    const server = createServer((req, res) => {
-        const url = new URL(req.url ?? '/', 'http://127.0.0.1');
-        if (url.pathname !== '/callback') {
-            respond(res, 404, page('Not found', 'This page is not part of sign-in.'));
-            return;
-        }
-        const code = url.searchParams.get('code') ?? '';
-        const state = url.searchParams.get('state') ?? '';
-        const error = url.searchParams.get('error');
-        if (error) {
-            respond(res, 400, page('Sign-in failed', escapeHtml(error)));
-            fail(new Error(`Sign-in failed: ${error}`));
-            return;
-        }
-        if (!statesMatch(expectedState, state)) {
-            respond(res, 400, page('Sign-in failed', 'This request did not match the pending sign-in.'));
-            return;
-        }
-        if (code === '') {
-            respond(res, 400, page('Sign-in failed', 'No authorization code was returned.'));
-            fail(new Error('No authorization code was returned'));
-            return;
-        }
-        respond(res, 200, page('You are signed in', 'You can close this tab and return to your terminal.'));
-        settle({ code });
-    });
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', resolve);
-    });
-    const timer = setTimeout(() => {
-        fail(new Error('Timed out waiting for the browser to complete sign-in.'));
-    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    timer.unref?.();
-    const { port } = server.address();
-    let closed = false;
-    const close = () => {
-        if (closed)
-            return;
-        closed = true;
-        clearTimeout(timer);
-        server.close();
-        server.closeAllConnections?.();
-    };
-    return {
-        redirectUri: `http://127.0.0.1:${port}/callback`,
-        result: result.finally(close),
-        close,
-    };
-}
-function escapeHtml(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}

package/dist/auth/pkce.d.ts

@@ -1,7 +0,0 @@
-export interface PkcePair {
-    readonly verifier: string;
-    readonly challenge: string;
-}
-export declare function createPkcePair(): PkcePair;
-export declare function createState(): string;
-export declare function statesMatch(expected: string, received: string): boolean;