codehere 1.0.1 → 1.0.2

package/dist/infrastructure/context/github-api.js

@@ -1,110 +0,0 @@
-/**
- * Minimal GitHub REST layer for the integration — reads an issue and turns it
- * into a task prompt. Uses the OAuth token persisted by github-device-flow via
- * oauth-store ('github'). HTTP is injectable so tests run without network.
- *
- * This is the "issues -> tasks" piece of Track 2: fetch the issue, format a
- * prompt; the existing POST /api/task does the actual spawn (one proven path).
- */
-const defaultGet = async (url, headers) => {
-    const res = await fetch(url, { headers });
-    return { status: res.status, json: () => res.json() };
-};
-/** Accepts an issue URL, "owner/repo#123", or "owner/repo" (number then optional). */
-export function parseRepoRef(input) {
-    const s = (input || '').trim();
-    const url = s.match(/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/i);
-    if (url)
-        return { owner: url[1], repo: url[2], number: Number(url[3]) };
-    const hash = s.match(/^([^/\s]+)\/([^/\s#]+)#(\d+)$/);
-    if (hash)
-        return { owner: hash[1], repo: hash[2], number: Number(hash[3]) };
-    const plain = s.match(/^([^/\s]+)\/([^/\s#]+)$/);
-    if (plain)
-        return { owner: plain[1], repo: plain[2] };
-    return undefined;
-}
-export async function fetchIssue(token, owner, repo, number, http = defaultGet) {
-    const res = await http(`https://api.github.com/repos/${owner}/${repo}/issues/${number}`, {
-        Authorization: `Bearer ${token}`,
-        Accept: 'application/vnd.github+json',
-        'User-Agent': 'codehere',
-    });
-    if (res.status === 404)
-        throw new Error(`github issue not found: ${owner}/${repo}#${number}`);
-    if (res.status === 401 || res.status === 403)
-        throw new Error('github auth failed or token lacks repo scope');
-    if (res.status >= 400)
-        throw new Error(`github api error ${res.status}`);
-    const d = (await res.json());
-    return {
-        number: Number(d.number ?? number),
-        title: String(d.title ?? ''),
-        body: typeof d.body === 'string' ? d.body : '',
-        htmlUrl: String(d.html_url ?? ''),
-        state: String(d.state ?? 'open'),
-    };
-}
-/** List open issues for a repo so the user can PICK one instead of typing
- *  "owner/repo#123" from memory. Filters out pull requests (the issues endpoint
- *  returns PRs too — they carry a `pull_request` field). */
-export async function listIssues(token, owner, repo, http = defaultGet) {
-    const res = await http(`https://api.github.com/repos/${owner}/${repo}/issues?state=open&per_page=50`, {
-        Authorization: `Bearer ${token}`,
-        Accept: 'application/vnd.github+json',
-        'User-Agent': 'codehere',
-    });
-    if (res.status === 404)
-        throw new Error(`github repo not found: ${owner}/${repo}`);
-    if (res.status === 401 || res.status === 403)
-        throw new Error('github auth failed or token lacks repo scope');
-    if (res.status >= 400)
-        throw new Error(`github api error ${res.status}`);
-    const arr = (await res.json());
-    return (Array.isArray(arr) ? arr : [])
-        .filter((d) => !d.pull_request)
-        .map((d) => ({
-        number: Number(d.number ?? 0),
-        title: String(d.title ?? ''),
-        body: typeof d.body === 'string' ? d.body : '',
-        htmlUrl: String(d.html_url ?? ''),
-        state: String(d.state ?? 'open'),
-    }));
-}
-/** Format an issue as a task prompt an agent can act on. */
-export function issueToTaskPrompt(issue) {
-    const body = issue.body && issue.body.trim() ? `\n\n${issue.body.trim()}` : '';
-    return `Work on GitHub issue #${issue.number}: ${issue.title}${body}\n\nIssue: ${issue.htmlUrl}`;
-}
-/** Pull the issue ref out of a task prompt built by issueToTaskPrompt (the
- *  "Issue: <url>" line), so a finished task knows which issue to report back to. */
-export function issueRefFromText(text) {
-    const m = (text || '').match(/github\.com\/[^\s)]+\/issues\/\d+/i);
-    if (!m)
-        return undefined;
-    const ref = parseRepoRef(m[0]);
-    return ref && ref.number !== undefined ? { owner: ref.owner, repo: ref.repo, number: ref.number } : undefined;
-}
-const defaultSend = async (url, method, headers, body) => {
-    const res = await fetch(url, { method, headers, body });
-    return { status: res.status, json: () => res.json() };
-};
-/** Post the agent's result back onto the issue as a comment. Non-destructive —
- *  closes the issue -> task -> result loop without touching any branches. */
-export async function commentOnIssue(token, owner, repo, number, body, http = defaultSend) {
-    const res = await http(`https://api.github.com/repos/${owner}/${repo}/issues/${number}/comments`, 'POST', {
-        Authorization: `Bearer ${token}`,
-        Accept: 'application/vnd.github+json',
-        'Content-Type': 'application/json',
-        'User-Agent': 'codehere',
-    }, JSON.stringify({ body }));
-    if (res.status === 401 || res.status === 403)
-        throw new Error('github auth failed or token lacks repo scope');
-    if (res.status === 404)
-        throw new Error('github issue not found (or no access)');
-    if (res.status >= 400)
-        throw new Error(`github comment failed: ${res.status}`);
-    const d = (await res.json());
-    return { htmlUrl: String(d.html_url ?? '') };
-}
-//# sourceMappingURL=github-api.js.map

package/dist/infrastructure/context/github-device-flow.js

@@ -1,65 +0,0 @@
-const DEVICE_CODE_URL = 'https://github.com/login/device/code';
-const TOKEN_URL = 'https://github.com/login/oauth/access_token';
-const DEFAULT_SCOPE = 'repo read:org';
-const GRANT = 'urn:ietf:params:oauth:grant-type:device_code';
-/** The public client_id of codehere's registered GitHub OAuth App. This is a
- *  PUBLIC value (device flow needs no secret), so it ships as the default — the
- *  same way the `gh` CLI bundles its own. Set this once the OAuth App with Device
- *  Flow enabled is registered; until then GitHub connect stays inert and the UI
- *  shows the "configure your own" fallback. CODEHERE_GITHUB_CLIENT_ID overrides
- *  it (for users who prefer their own app). */
-const BUNDLED_GITHUB_CLIENT_ID = '';
-export function githubClientId() {
-    const env = (process.env.CODEHERE_GITHUB_CLIENT_ID || '').trim();
-    if (env)
-        return env;
-    const bundled = BUNDLED_GITHUB_CLIENT_ID.trim();
-    return bundled || undefined;
-}
-const defaultHttp = async (url, body) => {
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-    });
-    return (await res.json());
-};
-/** Step 1: ask GitHub for a device + user code. The user enters userCode at
- *  verificationUri to approve; we then poll for the token. */
-export async function requestDeviceCode(clientId, scope = DEFAULT_SCOPE, http = defaultHttp) {
-    const d = await http(DEVICE_CODE_URL, { client_id: clientId, scope });
-    if (!d.device_code) {
-        throw new Error('github device-code request failed' + (d.error ? `: ${String(d.error)}` : ''));
-    }
-    return {
-        deviceCode: String(d.device_code),
-        userCode: String(d.user_code ?? ''),
-        verificationUri: String(d.verification_uri ?? 'https://github.com/login/device'),
-        intervalSec: Number(d.interval ?? 5),
-        expiresInSec: Number(d.expires_in ?? 900),
-    };
-}
-/** Step 2: poll once for the token. Caller repeats at `intervalSec` until it
- *  resolves to connected or error (RFC 8628: authorization_pending = keep going,
- *  slow_down = back off). */
-export async function pollForToken(clientId, deviceCode, http = defaultHttp) {
-    const d = await http(TOKEN_URL, { client_id: clientId, device_code: deviceCode, grant_type: GRANT });
-    if (d.access_token) {
-        return {
-            status: 'connected',
-            token: {
-                provider: 'github',
-                accessToken: String(d.access_token),
-                expiresAt: null, // GitHub OAuth App tokens don't expire unless revoked
-                scope: d.scope ? String(d.scope) : null,
-            },
-        };
-    }
-    const err = String(d.error ?? 'unknown');
-    if (err === 'authorization_pending')
-        return { status: 'pending' };
-    if (err === 'slow_down')
-        return { status: 'slow_down', intervalSec: Number(d.interval ?? 10) };
-    return { status: 'error', error: err };
-}
-//# sourceMappingURL=github-device-flow.js.map

package/dist/infrastructure/context/oauth-flow.js

@@ -1,207 +0,0 @@
-/**
- * OAuth 2.0 + PKCE flow for context-source providers (v0.8 S2.5).
- *
- * Provider-agnostic state machine that handles the four steps of the
- * code-grant flow with PKCE (RFC 7636) so we don't need a client secret on
- * the user's machine:
- *
- *   1. begin(provider)          · build authorize URL · stash state + verifier
- *   2. (browser) user approves  · provider redirects to our callback
- *   3. complete(code, state)    · exchange code for {access_token, refresh_token, user}
- *   4. refresh(refresh_token)   · swap for a fresh access_token
- *
- * Tokens persist in ~/.codehere/context-sources.json (the same file manual
- * configs use). User can revoke from the provider's web UI any time; our
- * disconnect command just deletes the local config.
- *
- * Provider client IDs come from env vars (CODEHERE_LINEAR_CLIENT_ID,
- * CODEHERE_FIGMA_CLIENT_ID) so binaries can ship without secrets baked in.
- * The codehere app registrations are public client IDs · PKCE removes the
- * need for a client secret on the user's machine. Anyone running codehere
- * locally uses the same `codehere-local` app at each provider, no per-user
- * registration needed.
- *
- * IMPORTANT · this module is pure logic. All I/O (httpPost, filesystem,
- * clock) is injected. The daemon's HTTP route at /oauth/callback supplies
- * the production wiring (registry-bootstrap.ts) and tests use mocks.
- */
-import { createHash, randomBytes } from 'crypto';
-const DEFAULT_REDIRECT = 'http://127.0.0.1:3773/oauth/callback';
-export const PROVIDERS = {
-    linear: {
-        id: 'linear',
-        label: 'Linear',
-        authorizeUrl: 'https://linear.app/oauth/authorize',
-        tokenUrl: 'https://api.linear.app/oauth/token',
-        scopes: ['read'],
-        clientIdEnv: 'CODEHERE_LINEAR_CLIENT_ID',
-        redirectUri: DEFAULT_REDIRECT,
-        tokenPostMode: 'form',
-        userInfoUrl: 'https://api.linear.app/graphql', // POST { query: '{ viewer { name email } }' }
-    },
-    figma: {
-        id: 'figma',
-        label: 'Figma',
-        authorizeUrl: 'https://www.figma.com/oauth',
-        tokenUrl: 'https://api.figma.com/v1/oauth/token',
-        scopes: ['file_read'],
-        clientIdEnv: 'CODEHERE_FIGMA_CLIENT_ID',
-        redirectUri: DEFAULT_REDIRECT,
-        tokenPostMode: 'form',
-        userInfoUrl: 'https://api.figma.com/v1/me',
-    },
-};
-export function listProviders() {
-    return Object.values(PROVIDERS);
-}
-export function getProvider(id) {
-    return PROVIDERS[id];
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* PKCE helpers                                                              */
-/* ──────────────────────────────────────────────────────────────────────── */
-function base64UrlEncode(buf) {
-    return buf.toString('base64').replace(/=+$/, '').replace(/\+/g, '-').replace(/\//g, '_');
-}
-/** Random 43-128 char string · we pick 64 bytes (86 chars after b64url). */
-export function generateCodeVerifier() {
-    return base64UrlEncode(randomBytes(64));
-}
-export function deriveCodeChallenge(verifier) {
-    return base64UrlEncode(createHash('sha256').update(verifier).digest());
-}
-/** Opaque CSRF defense · returned by provider unchanged · we verify on callback. */
-export function generateState() {
-    return base64UrlEncode(randomBytes(24));
-}
-export function begin(provider, ctx) {
-    if (!ctx.clientId) {
-        return { kind: 'not_registered', provider: provider.id, envVar: provider.clientIdEnv };
-    }
-    const codeVerifier = ctx.rng?.verifier() ?? generateCodeVerifier();
-    const codeChallenge = deriveCodeChallenge(codeVerifier);
-    const state = ctx.rng?.state() ?? generateState();
-    const startedAt = ctx.now ? ctx.now() : Date.now();
-    const params = new URLSearchParams({
-        response_type: 'code',
-        client_id: ctx.clientId,
-        redirect_uri: provider.redirectUri,
-        scope: provider.scopes.join(' '),
-        state,
-        code_challenge: codeChallenge,
-        code_challenge_method: 'S256',
-    });
-    return {
-        authorizeUrl: `${provider.authorizeUrl}?${params.toString()}`,
-        pending: { provider: provider.id, state, codeVerifier, startedAt },
-    };
-}
-export async function complete(code, state, ctx) {
-    const pending = ctx.pending.get(state);
-    if (!pending) {
-        return { kind: 'state_unknown', detail: `no pending flow for state '${state.slice(0, 8)}...'` };
-    }
-    ctx.pending.delete(state); // single-use
-    const provider = getProvider(pending.provider);
-    if (!provider) {
-        return { kind: 'state_unknown', detail: `unknown provider '${pending.provider}'` };
-    }
-    const maxAge = ctx.maxAgeMs ?? 10 * 60 * 1000;
-    const now = ctx.now ? ctx.now() : Date.now();
-    if (now - pending.startedAt > maxAge) {
-        return { kind: 'state_expired', detail: `pending flow older than ${Math.round(maxAge / 1000)}s` };
-    }
-    if (!ctx.clientId) {
-        return { kind: 'not_registered', detail: provider.clientIdEnv };
-    }
-    const params = new URLSearchParams({
-        grant_type: 'authorization_code',
-        code,
-        redirect_uri: provider.redirectUri,
-        client_id: ctx.clientId,
-        code_verifier: pending.codeVerifier,
-    });
-    const headers = {
-        'Content-Type': 'application/x-www-form-urlencoded',
-        Accept: 'application/json',
-    };
-    const res = await ctx.httpPost(provider.tokenUrl, params.toString(), headers);
-    if (res.status !== 200) {
-        return {
-            kind: 'provider_error',
-            detail: `${provider.label} token endpoint returned ${res.status}: ${res.body.slice(0, 200)}`,
-        };
-    }
-    let payload;
-    try {
-        payload = JSON.parse(res.body);
-    }
-    catch (err) {
-        return {
-            kind: 'parse_error',
-            detail: `token response not JSON: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    if (!payload.access_token) {
-        return { kind: 'parse_error', detail: 'token response missing access_token' };
-    }
-    const token = {
-        provider: provider.id,
-        accessToken: payload.access_token,
-        refreshToken: payload.refresh_token,
-        expiresAt: typeof payload.expires_in === 'number' ? now + payload.expires_in * 1000 : null,
-        scope: payload.scope ?? provider.scopes.join(' '),
-    };
-    // Best-effort user-info fetch · failure here doesn't undo the connect
-    if (ctx.fetchUserInfo && provider.userInfoUrl) {
-        try {
-            const u = await ctx.fetchUserInfo(token.accessToken, provider.userInfoUrl);
-            if (u) {
-                const label = u.email || u.name;
-                if (label)
-                    token.userLabel = label;
-            }
-        }
-        catch {
-            // ignore · token is valid, user label is decoration
-        }
-    }
-    return token;
-}
-export async function refresh(provider, refreshToken, ctx) {
-    if (!ctx.clientId)
-        return { kind: 'not_registered', detail: provider.clientIdEnv };
-    const params = new URLSearchParams({
-        grant_type: 'refresh_token',
-        refresh_token: refreshToken,
-        client_id: ctx.clientId,
-    });
-    const res = await ctx.httpPost(provider.tokenUrl, params.toString(), {
-        'Content-Type': 'application/x-www-form-urlencoded',
-        Accept: 'application/json',
-    });
-    if (res.status !== 200) {
-        return { kind: 'provider_error', detail: `${provider.label} refresh returned ${res.status}` };
-    }
-    let payload;
-    try {
-        payload = JSON.parse(res.body);
-    }
-    catch (err) {
-        return {
-            kind: 'parse_error',
-            detail: `refresh response not JSON: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    if (!payload.access_token)
-        return { kind: 'parse_error', detail: 'refresh missing access_token' };
-    const now = ctx.now ? ctx.now() : Date.now();
-    return {
-        provider: provider.id,
-        accessToken: payload.access_token,
-        refreshToken: payload.refresh_token ?? refreshToken,
-        expiresAt: typeof payload.expires_in === 'number' ? now + payload.expires_in * 1000 : null,
-        scope: payload.scope ?? null,
-    };
-}
-//# sourceMappingURL=oauth-flow.js.map

package/dist/infrastructure/context/oauth-store.js

@@ -1,122 +0,0 @@
-/**
- * OAuth token storage · v0.8 S2.5.
- *
- * Persists OAuth tokens to ~/.codehere/context-sources.json next to manual
- * configs. File shape evolved · backward-compatible:
- *
- *   {
- *     "linear": {
- *       "apiKey": "...",                  // manual mode · still supported
- *       "oauth": {                        // OAuth mode · NEW
- *         "accessToken": "...",
- *         "refreshToken": "...",
- *         "expiresAt": 1700000000000,
- *         "scope": "read",
- *         "userLabel": "ega@example.com",
- *         "connectedAt": 1700000000000
- *       }
- *     },
- *     "figma": { ... }
- *   }
- *
- * The linear-source / figma-source adapters read EITHER apiKey OR
- * oauth.accessToken (in S3 we'll merge them under one access path; for now
- * S2.5 just lands the storage shape so the OAuth flow has somewhere to put
- * the token).
- *
- * File permissions · 0600 on write so a multi-user machine can't read each
- * other's tokens.
- */
-import { chmodSync, existsSync, mkdirSync, readFileSync } from 'fs';
-import { writeFileAtomic } from '../storage/atomic-write.js';
-import { homedir } from 'os';
-import { dirname, join } from 'path';
-function configPath() {
-    const home = process.env.CODEHERE_HOME || homedir();
-    return join(home, '.codehere', 'context-sources.json');
-}
-export function readAllConfig(path) {
-    const target = path ?? configPath();
-    if (!existsSync(target))
-        return {};
-    try {
-        const raw = readFileSync(target, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed !== 'object' || parsed === null)
-            return {};
-        return parsed;
-    }
-    catch {
-        return {};
-    }
-}
-function writeAllConfig(cfg, path) {
-    const target = path ?? configPath();
-    mkdirSync(dirname(target), { recursive: true });
-    // mode on the TEMP file, so the credentials are never briefly world-readable
-    // the way write-then-chmod leaves them. The chmod below stays as belt-and-braces.
-    writeFileAtomic(target, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
-    try {
-        chmodSync(target, 0o600);
-    }
-    catch {
-        // chmod can fail on FATs · the local-first promise still holds; we just
-        // can't enforce 0600. Real-world users on macOS/Linux always succeed.
-    }
-}
-/** Persist a freshly-minted OAuth token for the given provider. */
-export function saveToken(token, path) {
-    const cfg = readAllConfig(path);
-    const existing = cfg[token.provider] ?? {};
-    cfg[token.provider] = {
-        ...existing,
-        oauth: {
-            accessToken: token.accessToken,
-            refreshToken: token.refreshToken,
-            expiresAt: token.expiresAt,
-            scope: token.scope,
-            userLabel: token.userLabel,
-            connectedAt: Date.now(),
-        },
-    };
-    writeAllConfig(cfg, path);
-}
-/** Disconnect · drops only the oauth subtree, preserves any manual apiKey. */
-export function clearToken(providerId, path) {
-    const cfg = readAllConfig(path);
-    const entry = cfg[providerId];
-    if (!entry || !entry.oauth)
-        return false;
-    delete entry.oauth;
-    // If the entry is now empty (no manual apiKey either), drop the whole row.
-    const isEmpty = Object.keys(entry).filter((k) => k !== 'oauth').length === 0;
-    if (isEmpty)
-        delete cfg[providerId];
-    writeAllConfig(cfg, path);
-    return true;
-}
-/** Read the persisted OAuth token for a provider (undefined if not connected). */
-export function loadToken(providerId, path) {
-    const cfg = readAllConfig(path);
-    return cfg[providerId]?.oauth;
-}
-export function connectionStatus(providerId, path) {
-    const cfg = readAllConfig(path);
-    const entry = cfg[providerId];
-    if (!entry)
-        return { status: 'disconnected' };
-    if (entry.oauth?.accessToken) {
-        const exp = entry.oauth.expiresAt;
-        const expired = typeof exp === 'number' && exp < Date.now();
-        return {
-            status: expired ? 'expired' : 'connected',
-            userLabel: entry.oauth.userLabel,
-            connectedAt: entry.oauth.connectedAt,
-            expiresAt: exp,
-        };
-    }
-    if (entry.apiKey || entry.token)
-        return { status: 'manual' };
-    return { status: 'disconnected' };
-}
-//# sourceMappingURL=oauth-store.js.map

package/dist/infrastructure/context/registry-bootstrap.js

@@ -1,95 +0,0 @@
-/**
- * Registry bootstrap · v0.8 S2.
- *
- * Builds the default ContextSourceRegistry at daemon startup with our 1st-
- * party adapters (Linear, Figma), loads adapter config from
- * `~/.codehere/context-sources.json`, and provides a default
- * ContextSourceFetchContext that wraps node's fetch() for the network path
- * and the audit chain for telemetry.
- *
- * This file is the ONLY place where context-sources touch process.env, the
- * filesystem, and global fetch · everything else is pure code + injected
- * primitives. Makes tests trivial and the security boundary explicit.
- */
-import { existsSync, readFileSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { createRegistry, register, } from './context-source.js';
-import { linearSource } from './adapters/linear-source.js';
-import { figmaSource } from './adapters/figma-source.js';
-import { drawioSource } from './adapters/drawio-source.js';
-import { githubIssueSource } from './adapters/github-issue-source.js';
-/** Built once per daemon · in-memory · re-read from disk on demand via `reload`. */
-let cached = null;
-export function getDefaultRegistry() {
-    if (cached)
-        return cached;
-    const reg = createRegistry();
-    register(reg, linearSource);
-    register(reg, figmaSource);
-    register(reg, drawioSource);
-    register(reg, githubIssueSource);
-    cached = reg;
-    return reg;
-}
-/**
- * Resolve config path · respects CODEHERE_HOME env so tests can isolate.
- * File format: a JSON object keyed by adapter id, e.g.
- *   { "linear": { "apiKey": "..." }, "figma": { "token": "..." } }
- */
-function configPath() {
-    const home = process.env.CODEHERE_HOME || homedir();
-    return join(home, '.codehere', 'context-sources.json');
-}
-function loadConfig() {
-    const path = configPath();
-    if (!existsSync(path))
-        return {};
-    try {
-        const raw = readFileSync(path, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed !== 'object' || parsed === null)
-            return {};
-        return parsed;
-    }
-    catch {
-        return {};
-    }
-}
-/**
- * Real-network FetchContext · used by the daemon at runtime. Tests inject
- * a fake context so this code path never runs in CI.
- */
-export function createDefaultFetchContext(opts) {
-    const config = opts.configOverride ?? loadConfig();
-    return {
-        config,
-        async httpGet(target, headers) {
-            const r = await fetch(target, { method: 'GET', headers: headers ?? {} });
-            const body = await r.text();
-            const hOut = {};
-            r.headers.forEach((v, k) => {
-                hOut[k.toLowerCase()] = v;
-            });
-            return { status: r.status, body, headers: hOut };
-        },
-        emitAuditLine: opts.emitAuditLine,
-        now: () => Date.now(),
-    };
-}
-export function createDefaultFetchContextWithPost(opts) {
-    const base = createDefaultFetchContext(opts);
-    return {
-        ...base,
-        async httpPost(target, body, headers) {
-            const r = await fetch(target, { method: 'POST', headers: headers ?? {}, body });
-            const text = await r.text();
-            const hOut = {};
-            r.headers.forEach((v, k) => {
-                hOut[k.toLowerCase()] = v;
-            });
-            return { status: r.status, body: text, headers: hOut };
-        },
-    };
-}
-//# sourceMappingURL=registry-bootstrap.js.map