@code-yeongyu/senpi-ai 2026.10.30-2 → 2026.10.31-2

package/dist/auth/oauth/anthropic-callback-listener.js

@@ -1,138 +0,0 @@
-/**
- * Loopback callback listener for the Anthropic OAuth flow.
- *
- * The OAuth client accepts any `localhost` port on the `/callback` path (the
- * Claude Code CLI itself binds a random port per login), so the listener
- * prefers the historical port 53692 and falls back to an ephemeral port when
- * another login - in this process or in another one - still holds it. With a
- * fixed port, a second login on the same machine sent its browser redirect to
- * the OTHER process's listener, which could only answer "State mismatch".
- *
- * NOTE: Node-only (http.createServer); reached through the lazy OAuth loader.
- */
-import { oauthErrorHtml, oauthSuccessHtml } from "../../utils/oauth-page.js";
-import { formatErrorDetails } from "./error-details.js";
-export const PREFERRED_CALLBACK_PORT = 53692;
-export const CALLBACK_PATH = "/callback";
-const BIND_FAILURE_CODES = new Set(["EACCES", "EADDRINUSE", "EPERM"]);
-export function callbackRedirectUri(port) {
-    return `http://localhost:${port}${CALLBACK_PATH}`;
-}
-function respondHtml(res, status, html) {
-    res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
-    res.end(html);
-}
-/**
- * A callback whose `state` belongs to another login. Either a different
- * session's login could not bind its own port and is waiting for a pasted
- * redirect URL, or this tab belongs to an attempt that no longer exists.
- */
-function foreignLoginHtml(requestUrl) {
-    return oauthErrorHtml("This browser login belongs to a different session of this app, or to an earlier login attempt.", [
-        "If a session is still waiting for this login (it shows a prompt to paste the redirect URL), copy the full address from the browser's address bar and paste it there.",
-        "Otherwise this attempt is stale: close this tab and run the login again from the session that needs it.",
-        "",
-        requestUrl,
-    ].join("\n"));
-}
-function handleCallback(req, res, port, expectedState, settle) {
-    try {
-        const url = new URL(req.url ?? "", `http://localhost:${port}`);
-        if (url.pathname !== CALLBACK_PATH) {
-            respondHtml(res, 404, oauthErrorHtml("Callback route not found."));
-            return;
-        }
-        const code = url.searchParams.get("code");
-        const state = url.searchParams.get("state");
-        const error = url.searchParams.get("error");
-        if (error) {
-            respondHtml(res, 400, oauthErrorHtml("Anthropic authentication did not complete.", `Error: ${error}`));
-            return;
-        }
-        if (!code || !state) {
-            respondHtml(res, 400, oauthErrorHtml("Missing code or state parameter."));
-            return;
-        }
-        if (state !== expectedState) {
-            respondHtml(res, 400, foreignLoginHtml(url.toString()));
-            return;
-        }
-        respondHtml(res, 200, oauthSuccessHtml("Anthropic authentication completed. You can close this window."));
-        settle({ code, state });
-    }
-    catch {
-        res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
-        res.end("Internal error");
-    }
-}
-function errorCode(error) {
-    const code = error?.code;
-    return typeof code === "string" ? code : undefined;
-}
-function boundPort(server) {
-    const address = server.address();
-    return typeof address === "object" && address !== null ? address.port : undefined;
-}
-function closeServer(server) {
-    return new Promise((resolve) => {
-        server.close(() => resolve());
-        // Keep-alive connections from the browser would otherwise delay the close
-        // callback until they idle out.
-        server.closeAllConnections?.();
-    });
-}
-function bind(apis, port, host, expectedState, settle) {
-    return new Promise((resolve, reject) => {
-        const server = apis.createServer((req, res) => {
-            handleCallback(req, res, boundPort(server) ?? port, expectedState, settle);
-        });
-        server.on("error", reject);
-        server.listen(port, host, () => resolve(server));
-    });
-}
-/**
- * Binds the preferred port, then an ephemeral one; when neither can be bound
- * the login continues in manual mode with the registered preferred-port
- * redirect URI, so a pasted redirect URL still exchanges.
- */
-export async function startCallbackListener(apis, expectedState, host) {
-    let settled = false;
-    let settle;
-    const waitForCodePromise = new Promise((resolve) => {
-        settle = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(value);
-        };
-    });
-    let lastBindFailure;
-    for (const port of [PREFERRED_CALLBACK_PORT, 0]) {
-        try {
-            const server = await bind(apis, port, host, expectedState, settle);
-            const actualPort = boundPort(server) ?? port;
-            return {
-                port: actualPort,
-                redirectUri: callbackRedirectUri(actualPort),
-                waitForCode: () => waitForCodePromise,
-                cancelWait: () => settle(null),
-                close: () => closeServer(server),
-            };
-        }
-        catch (error) {
-            const code = errorCode(error);
-            if (code === undefined || !BIND_FAILURE_CODES.has(code)) {
-                throw new Error(`Could not open OAuth callback listener at ${host}:${port}: ${formatErrorDetails(error)}`);
-            }
-            lastBindFailure = code;
-        }
-    }
-    return {
-        redirectUri: callbackRedirectUri(PREFERRED_CALLBACK_PORT),
-        callbackUnavailable: { code: lastBindFailure ?? "EADDRINUSE" },
-        waitForCode: async () => null,
-        cancelWait: () => { },
-        close: async () => { },
-    };
-}
-//# sourceMappingURL=anthropic-callback-listener.js.map

package/dist/auth/oauth/anthropic.d.ts

@@ -1,13 +0,0 @@
-/**
- * Anthropic OAuth flow (Claude Pro/Max)
- *
- * NOTE: This module uses Node.js http.createServer for the OAuth callback server.
- * It is only intended for CLI use, not browser environments.
- */
-import type { OAuthAuth } from "../types.ts";
-import { type CallbackListenerApis } from "./anthropic-callback-listener.ts";
-export declare function __setAnthropicOAuthNodeApisForTests(apis: NodeApis | null): void;
-type NodeApis = CallbackListenerApis;
-export declare const anthropicOAuth: OAuthAuth;
-export {};
-//# sourceMappingURL=anthropic.d.ts.map

package/dist/auth/oauth/anthropic.js

@@ -1,285 +0,0 @@
-/**
- * Anthropic OAuth flow (Claude Pro/Max)
- *
- * NOTE: This module uses Node.js http.createServer for the OAuth callback server.
- * It is only intended for CLI use, not browser environments.
- */
-import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
-import { getProviderEnvValue } from "../../utils/provider-env.js";
-import { PREFERRED_CALLBACK_PORT, startCallbackListener, } from "./anthropic-callback-listener.js";
-import { parseAuthorizationInput } from "./authorization-input.js";
-import { formatErrorDetails } from "./error-details.js";
-import { generatePKCE } from "./pkce.js";
-export function __setAnthropicOAuthNodeApisForTests(apis) {
-    nodeApis = apis;
-    nodeApisPromise = null;
-}
-let nodeApis = null;
-let nodeApisPromise = null;
-const decode = (s) => atob(s);
-const CLIENT_ID = decode("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
-const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
-const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
-const CALLBACK_HOST = getProviderEnvValue("PI_OAUTH_CALLBACK_HOST") || "127.0.0.1";
-/**
- * A login nobody finishes must not keep its listener (and its manual prompt)
- * alive forever: the stale listener would answer a later login's browser
- * redirect on this machine with "State mismatch".
- */
-const LOGIN_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
-/** Anthropic page that shows the authorization code to copy (browser on another machine). */
-const COPY_CODE_REDIRECT_URI = "https://platform.claude.com/oauth/code/callback";
-const ANTHROPIC_BROWSER_LOGIN_METHOD = "browser";
-const ANTHROPIC_COPY_CODE_LOGIN_METHOD = "copy_code";
-const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
-async function getNodeApis() {
-    if (nodeApis)
-        return nodeApis;
-    if (!nodeApisPromise) {
-        if (typeof process === "undefined" || (!process.versions?.node && !process.versions?.bun)) {
-            throw new Error("Anthropic OAuth is only available in Node.js environments");
-        }
-        nodeApisPromise = import("node:http").then((httpModule) => ({
-            createServer: httpModule.createServer,
-        }));
-    }
-    nodeApis = await nodeApisPromise;
-    return nodeApis;
-}
-async function postJson(url, body, signal) {
-    const response = await fetch(url, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Accept: "application/json",
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]),
-    });
-    const responseBody = await response.text();
-    if (!response.ok) {
-        throw new OAuthTokenEndpointError(`HTTP request failed. status=${response.status}; url=${url}; body=${responseBody}`, response.status);
-    }
-    return responseBody;
-}
-async function exchangeAuthorizationCode(code, state, verifier, redirectUri, signal) {
-    let responseBody;
-    try {
-        responseBody = await postJson(TOKEN_URL, {
-            grant_type: "authorization_code",
-            client_id: CLIENT_ID,
-            code,
-            state,
-            redirect_uri: redirectUri,
-            code_verifier: verifier,
-        }, signal);
-    }
-    catch (error) {
-        throw new Error(`Token exchange request failed. url=${TOKEN_URL}; redirect_uri=${redirectUri}; response_type=authorization_code; details=${formatErrorDetails(error)}`, { cause: error });
-    }
-    let tokenData;
-    try {
-        tokenData = JSON.parse(responseBody);
-    }
-    catch (error) {
-        throw new Error(`Token exchange returned invalid JSON. url=${TOKEN_URL}; body=${responseBody}; details=${formatErrorDetails(error)}`);
-    }
-    return {
-        type: "oauth",
-        refresh: tokenData.refresh_token,
-        access: tokenData.access_token,
-        expires: Date.now() + tokenData.expires_in * 1000 - 5 * 60 * 1000,
-    };
-}
-async function loginAnthropic(interaction) {
-    const { verifier, challenge } = await generatePKCE();
-    const listener = await startCallbackListener(await getNodeApis(), verifier, CALLBACK_HOST);
-    const manualAbort = new AbortController();
-    let timedOut = false;
-    // Cancelling the login must release BOTH waits: the callback listener and the
-    // manual prompt. In manual-only mode (no callback port could be bound) the
-    // prompt is the only thing keeping the login alive, so leaving it open would
-    // hang cleanup.
-    const releaseWaits = () => {
-        listener.cancelWait();
-        manualAbort.abort();
-    };
-    interaction.signal.addEventListener("abort", releaseWaits, { once: true });
-    if (interaction.signal.aborted)
-        releaseWaits();
-    const idleTimer = setTimeout(() => {
-        timedOut = true;
-        releaseWaits();
-    }, LOGIN_IDLE_TIMEOUT_MS);
-    idleTimer.unref?.();
-    let code;
-    let state;
-    let manualInput;
-    let manualError;
-    try {
-        const authParams = new URLSearchParams({
-            code: "true",
-            client_id: CLIENT_ID,
-            response_type: "code",
-            redirect_uri: listener.redirectUri,
-            scope: SCOPES,
-            code_challenge: challenge,
-            code_challenge_method: "S256",
-            state: verifier,
-        });
-        interaction.notify({
-            type: "auth_url",
-            url: `${AUTHORIZE_URL}?${authParams.toString()}`,
-            instructions: listener.callbackUnavailable
-                ? `No local OAuth callback port could be opened (port ${PREFERRED_CALLBACK_PORT} and an ephemeral port both failed: ${listener.callbackUnavailable.code}). Complete login in your browser, then copy the final redirect URL from the address bar and paste it here.`
-                : "Complete login in your browser. If the browser is on another machine, paste the final redirect URL here.",
-        });
-        const manualPromise = interaction
-            .prompt({
-            type: "manual_code",
-            message: "Complete login in your browser, or paste the authorization code / redirect URL here:",
-            placeholder: listener.redirectUri,
-            signal: manualAbort.signal,
-        })
-            .then((input) => {
-            manualInput = input;
-            listener.cancelWait();
-        })
-            .catch((error) => {
-            manualError = error instanceof Error ? error : new Error(String(error));
-            listener.cancelWait();
-        });
-        const result = await listener.waitForCode();
-        if (timedOut)
-            throw new Error(loginTimedOutMessage());
-        if (manualError)
-            throw manualError;
-        if (result?.code) {
-            code = result.code;
-            state = result.state;
-        }
-        else if (manualInput) {
-            const parsed = parseAuthorizationInput(manualInput);
-            if (parsed.state && parsed.state !== verifier)
-                throw new Error("OAuth state mismatch");
-            code = parsed.code;
-            state = parsed.state ?? verifier;
-        }
-        if (!code) {
-            await manualPromise;
-            if (timedOut)
-                throw new Error(loginTimedOutMessage());
-            if (manualError)
-                throw manualError;
-            if (manualInput) {
-                const parsed = parseAuthorizationInput(manualInput);
-                if (parsed.state && parsed.state !== verifier)
-                    throw new Error("OAuth state mismatch");
-                code = parsed.code;
-                state = parsed.state ?? verifier;
-            }
-        }
-        if (!code)
-            throw new Error("Missing authorization code");
-        if (!state)
-            throw new Error("Missing OAuth state");
-        interaction.notify({ type: "progress", message: "Exchanging authorization code for tokens..." });
-        return await exchangeAuthorizationCode(code, state, verifier, listener.redirectUri, interaction.signal);
-    }
-    finally {
-        clearTimeout(idleTimer);
-        interaction.signal.removeEventListener("abort", releaseWaits);
-        manualAbort.abort();
-        await listener.close();
-    }
-}
-function loginTimedOutMessage() {
-    const minutes = Math.round(LOGIN_IDLE_TIMEOUT_MS / 60_000);
-    return `Anthropic login timed out after ${minutes} minutes without a browser callback or a pasted redirect URL. Run the login again.`;
-}
-async function loginAnthropicCopyCode(interaction) {
-    const { verifier, challenge } = await generatePKCE();
-    const authParams = new URLSearchParams({
-        code: "true",
-        client_id: CLIENT_ID,
-        response_type: "code",
-        redirect_uri: COPY_CODE_REDIRECT_URI,
-        scope: SCOPES,
-        code_challenge: challenge,
-        code_challenge_method: "S256",
-        state: verifier,
-    });
-    interaction.notify({
-        type: "auth_url",
-        url: `${AUTHORIZE_URL}?${authParams.toString()}`,
-        instructions: "Complete login in your browser, then copy the code Anthropic shows and paste it here.",
-    });
-    const input = await interaction.prompt({
-        type: "manual_code",
-        message: "Paste the code Anthropic shows after you sign in:",
-        placeholder: "code#state",
-        signal: interaction.signal,
-    });
-    const parsed = parseAuthorizationInput(input);
-    if (parsed.state && parsed.state !== verifier)
-        throw new Error("OAuth state mismatch");
-    if (!parsed.code)
-        throw new Error("Missing authorization code");
-    interaction.notify({ type: "progress", message: "Exchanging authorization code for tokens..." });
-    return await exchangeAuthorizationCode(parsed.code, parsed.state ?? verifier, verifier, COPY_CODE_REDIRECT_URI, interaction.signal);
-}
-/**
- * Refresh Anthropic OAuth token
- */
-async function refreshAnthropicToken(refreshToken, signal) {
-    let responseBody;
-    try {
-        responseBody = await postJson(TOKEN_URL, {
-            grant_type: "refresh_token",
-            client_id: CLIENT_ID,
-            refresh_token: refreshToken,
-        }, signal);
-    }
-    catch (error) {
-        throw new Error(`Anthropic token refresh request failed. url=${TOKEN_URL}; details=${formatErrorDetails(error)}`, { cause: error });
-    }
-    let data;
-    try {
-        data = JSON.parse(responseBody);
-    }
-    catch (error) {
-        throw new Error(`Anthropic token refresh returned invalid JSON. url=${TOKEN_URL}; body=${responseBody}; details=${formatErrorDetails(error)}`);
-    }
-    return {
-        type: "oauth",
-        refresh: data.refresh_token,
-        access: data.access_token,
-        expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000,
-    };
-}
-export const anthropicOAuth = {
-    name: "Anthropic (Claude Pro/Max)",
-    isSubscription: true,
-    async login(interaction) {
-        const method = await interaction.prompt({
-            type: "select",
-            message: "Select Anthropic login method:",
-            options: [
-                { id: ANTHROPIC_BROWSER_LOGIN_METHOD, label: "Browser login (default)" },
-                { id: ANTHROPIC_COPY_CODE_LOGIN_METHOD, label: "Copy code login (headless)" },
-            ],
-        });
-        if (method === ANTHROPIC_COPY_CODE_LOGIN_METHOD) {
-            return loginAnthropicCopyCode(interaction);
-        }
-        if (method !== ANTHROPIC_BROWSER_LOGIN_METHOD) {
-            throw new Error(`Unknown Anthropic login method: ${method}`);
-        }
-        return loginAnthropic(interaction);
-    },
-    refresh: (credential, signal) => refreshAnthropicToken(credential.refresh, signal),
-    async toAuth(credential) {
-        return { apiKey: credential.access };
-    },
-};
-//# sourceMappingURL=anthropic.js.map

package/dist/auth/oauth/authorization-input.d.ts

@@ -1,6 +0,0 @@
-/** Parses a pasted redirect URL, `code#state` pair, query string, or bare code. */
-export declare function parseAuthorizationInput(input: string): {
-    code?: string;
-    state?: string;
-};
-//# sourceMappingURL=authorization-input.d.ts.map

package/dist/auth/oauth/authorization-input.js

@@ -1,29 +0,0 @@
-/** Parses a pasted redirect URL, `code#state` pair, query string, or bare code. */
-export function parseAuthorizationInput(input) {
-    const value = input.trim();
-    if (!value)
-        return {};
-    try {
-        const url = new URL(value);
-        return {
-            code: url.searchParams.get("code") ?? undefined,
-            state: url.searchParams.get("state") ?? undefined,
-        };
-    }
-    catch {
-        // not a URL
-    }
-    if (value.includes("#")) {
-        const [code, state] = value.split("#", 2);
-        return { code, state };
-    }
-    if (value.includes("code=")) {
-        const params = new URLSearchParams(value);
-        return {
-            code: params.get("code") ?? undefined,
-            state: params.get("state") ?? undefined,
-        };
-    }
-    return { code: value };
-}
-//# sourceMappingURL=authorization-input.js.map

package/dist/auth/oauth/error-details.d.ts

@@ -1,3 +0,0 @@
-/** Flattens an error (with `code`, `errno`, `cause`, and stack) into one diagnostic line. */
-export declare function formatErrorDetails(error: unknown): string;
-//# sourceMappingURL=error-details.d.ts.map

package/dist/auth/oauth/error-details.js

@@ -1,20 +0,0 @@
-/** Flattens an error (with `code`, `errno`, `cause`, and stack) into one diagnostic line. */
-export function formatErrorDetails(error) {
-    if (error instanceof Error) {
-        const details = [`${error.name}: ${error.message}`];
-        const errorWithCode = error;
-        if (errorWithCode.code)
-            details.push(`code=${errorWithCode.code}`);
-        if (typeof errorWithCode.errno !== "undefined")
-            details.push(`errno=${String(errorWithCode.errno)}`);
-        if (typeof error.cause !== "undefined") {
-            details.push(`cause=${formatErrorDetails(error.cause)}`);
-        }
-        if (error.stack) {
-            details.push(`stack=${error.stack}`);
-        }
-        return details.join("; ");
-    }
-    return String(error);
-}
-//# sourceMappingURL=error-details.js.map

package/dist/utils/claude-code-version-cache.d.ts

@@ -1,12 +0,0 @@
-import { type ClaudeCodeVersionStore } from "./claude-code-version.ts";
-/** Same resolution as the other pi-ai stores: the agent directory the host configured, then the default one. */
-export declare function resolveClaudeCodeVersionCachePath(env?: NodeJS.ProcessEnv): string;
-export declare function createClaudeCodeVersionFileStore(path: string): ClaudeCodeVersionStore;
-export interface InstallClaudeCodeVersionFileStoreOptions {
-    /** Cache file; defaults to `<agent dir>/claude-code-version.json`. */
-    readonly path?: string;
-    /** Serve the cache but never fetch (host offline mode); defaults to `PI_OFFLINE`. */
-    readonly offline?: boolean;
-}
-export declare function installClaudeCodeVersionFileStore(options?: InstallClaudeCodeVersionFileStoreOptions): void;
-//# sourceMappingURL=claude-code-version-cache.d.ts.map

package/dist/utils/claude-code-version-cache.js

@@ -1,60 +0,0 @@
-/**
- * Node entry point for the Claude Code version cache.
- *
- * `claude-code-version.ts` is browser-safe and keeps no state on disk. Hosts with a filesystem
- * call `installClaudeCodeVersionFileStore()` once at startup so the resolved version survives
- * process restarts and one lookup per six hours serves every session on the machine.
- */
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { installClaudeCodeVersionStore, } from "./claude-code-version.js";
-const CACHE_FILE = "claude-code-version.json";
-/** Same resolution as the other pi-ai stores: the agent directory the host configured, then the default one. */
-export function resolveClaudeCodeVersionCachePath(env = process.env) {
-    const agentDir = env.SENPI_CODING_AGENT_DIR ?? env.CODING_AGENT_DIR ?? `${(env.HOME ?? ".").replace(/\/$/, "")}/.senpi/agent`;
-    return `${agentDir.replace(/\/$/, "")}/${CACHE_FILE}`;
-}
-function isCachedVersion(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        typeof value.version === "string" &&
-        typeof value.checkedAt === "number");
-}
-export function createClaudeCodeVersionFileStore(path) {
-    let savingEnabled = true;
-    return {
-        load: () => {
-            let parsed;
-            try {
-                parsed = JSON.parse(readFileSync(path, "utf8"));
-            }
-            catch {
-                // No file on first run, and a truncated or hand-edited one is the same situation
-                // for a cache: the bundled floor is the documented fallback.
-                return undefined;
-            }
-            return isCachedVersion(parsed) ? parsed : undefined;
-        },
-        save: (record) => {
-            if (!savingEnabled)
-                return;
-            try {
-                mkdirSync(dirname(path), { recursive: true });
-                const temporaryPath = `${path}.${process.pid}.tmp`;
-                writeFileSync(temporaryPath, `${JSON.stringify(record)}\n`);
-                renameSync(temporaryPath, path);
-            }
-            catch {
-                // A read-only agent directory must not fail the live request, and one failure
-                // disables saving so a broken path cannot cost a write per refresh.
-                savingEnabled = false;
-            }
-        },
-    };
-}
-export function installClaudeCodeVersionFileStore(options = {}) {
-    const env = process.env;
-    const offline = options.offline ?? (env.PI_OFFLINE !== undefined && env.PI_OFFLINE !== "" && env.PI_OFFLINE !== "0");
-    installClaudeCodeVersionStore(createClaudeCodeVersionFileStore(options.path ?? resolveClaudeCodeVersionCachePath(env)), { offline });
-}
-//# sourceMappingURL=claude-code-version-cache.js.map

package/dist/utils/claude-code-version.d.ts

@@ -1,78 +0,0 @@
-/**
- * Claude Code version the Anthropic OAuth `claude-cli/<version>` fingerprint advertises.
- *
- * Anthropic gates new models behind a minimum Claude Code version and answers an older
- * fingerprint with HTTP 400 `claude_code_version_too_old`. A build-time constant goes stale
- * between releases, so the fingerprint is the higher of the bundled floor and the latest
- * published Claude Code release, resolved in the background and cached by the host through
- * `ClaudeCodeVersionStore`. A request never waits on the lookup: it signs with whatever is
- * known at that instant, and a too-old rejection raises the version at once.
- */
-import type { ProviderEnv } from "../types.ts";
-/** Exact `X.Y.Z` pins the fingerprint and skips the network lookup. */
-export declare const CLAUDE_CODE_VERSION_PIN_ENV = "PI_CLAUDE_CODE_VERSION";
-/**
- * Anthropic's native-installer release channel. `stable` lags the npm package during a staged
- * rollout, so `latest` is the channel that matches what a freshly updated Claude Code reports.
- */
-export declare const CLAUDE_RELEASE_CHANNEL_URL = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/latest";
-export declare const CLAUDE_NPM_DIST_TAG_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
-export interface CachedClaudeCodeVersion {
-    readonly version: string;
-    readonly checkedAt: number;
-}
-export interface ClaudeCodeVersionStore {
-    load(): CachedClaudeCodeVersion | undefined;
-    save(record: CachedClaudeCodeVersion): void;
-}
-export interface ClaudeCodeVersionResolverOptions {
-    readonly floor: string;
-    readonly pinned?: string | undefined;
-    /** `null` disables caching and network resolution: the resolver answers the floor or a raised version. */
-    readonly store: ClaudeCodeVersionStore | null;
-    /** Serve the cache but never fetch (host offline mode). */
-    readonly offline?: boolean;
-    readonly fetch?: typeof fetch;
-    readonly now?: () => number;
-    readonly refreshIntervalMs?: number;
-}
-export interface ClaudeCodeVersionResolver {
-    /** Current fingerprint; schedules one background refresh when the cache is stale. */
-    get(): string;
-    /** Refresh now (deduplicated); resolves with the fingerprint afterwards. */
-    refresh(): Promise<string>;
-    /** Adopt `version` at once when it is newer than the current fingerprint; returns the fingerprint. */
-    raise(version: string): string;
-}
-export declare function compareClaudeCodeVersions(a: string, b: string): number;
-/**
- * Latest published Claude Code version: the higher of the native-installer `latest` channel and
- * the npm dist-tag, so one lagging or unavailable source cannot hold the fingerprint back.
- */
-export declare function fetchLatestClaudeCodeVersion(fetchImpl?: typeof fetch): Promise<string | undefined>;
-export declare function requiredClaudeCodeVersionFromError(message: string): string | undefined;
-export declare function isClaudeCodeVersionTooOldError(error: unknown): error is Error & {
-    status: 400;
-};
-export declare function createClaudeCodeVersionResolver(options: ClaudeCodeVersionResolverOptions): ClaudeCodeVersionResolver;
-/**
- * Hosts with a filesystem install their cache here once at startup (see
- * `utils/claude-code-version-cache.ts`); until then, and in browsers, the resolver answers
- * the floor without touching the network.
- */
-export declare function installClaudeCodeVersionStore(store: ClaudeCodeVersionStore | null, options?: {
-    readonly offline?: boolean;
-}): void;
-/**
- * The version the next OAuth request signs with. `floor` is the bundled Claude Code version the
- * caller declares (the `claudeCodeVersion` constant in `api/anthropic-messages.ts`).
- */
-export declare function getClaudeCodeVersion(floor: string, env?: ProviderEnv): string;
-/**
- * After a `claude_code_version_too_old` rejection: adopt the version the error names, or the
- * latest published one, and report the fingerprint to retry with; `undefined` when nothing
- * newer is available (pinned, or already at the required version).
- */
-export declare function recoverClaudeCodeVersion(error: Error, floor: string, advertised: string, env?: ProviderEnv): Promise<string | undefined>;
-export declare function claudeCodeVersionTooOldHint(advertised: string): string;
-//# sourceMappingURL=claude-code-version.d.ts.map