vibe-usage-cli 0.0.0-stage → 0.1.1

package/build/providers/claude.js

@@ -0,0 +1,218 @@
+import os from 'node:os';
+import path from 'node:path';
+import { ProviderError } from "../core/errors.js";
+import { asArray, isFile, isObject, readJson, samePath } from "../core/files.js";
+import { normalizeWindow, safeEmail, safePlan, safeText } from "../core/model.js";
+import { accountId, DEFAULT_ACCOUNT_KEY, durationLabel, MINUTES, PROFILE_DIRS } from "../shared/catalog.js";
+import { readClaudeKeychain } from "./claude-keychain.js";
+import { getJson as defaultGetJson, isExpired, QUOTA_ENDPOINTS, readCredentialFile, USER_AGENT } from "./common.js";
+import { defaultProfileDir, isRegularFile, profileAccountId, profileFolders, profileLabel, shortHash } from "./profiles.js";
+// Required by the OAuth usage endpoint.
+const OAUTH_BETA = 'oauth-2025-04-20';
+// Fixed windows the usage endpoint reports at top level; Opus/Sonnet are per-model scopes.
+const USAGE_WINDOWS = {
+    five_hour: { minutes: MINUTES.FIVE_HOURS, required: true },
+    seven_day: { minutes: MINUTES.WEEK, required: true },
+    seven_day_opus: { minutes: MINUTES.WEEK, scope: 'Opus' },
+    seven_day_sonnet: { minutes: MINUTES.WEEK, scope: 'Sonnet' }
+};
+// `limits[].kind` values that duplicate a top-level window when they carry no model scope.
+const CANONICAL_LIMIT_KINDS = { session: 'five_hour', weekly_all: 'seven_day' };
+const LIMIT_KIND_MINUTES = { session: MINUTES.FIVE_HOURS };
+const WEEKLY_KIND_PREFIX = 'weekly';
+function limitPeriod(kind) {
+    if (kind.startsWith(WEEKLY_KIND_PREFIX))
+        return durationLabel(MINUTES.WEEK);
+    const minutes = LIMIT_KIND_MINUTES[kind];
+    return minutes ? durationLabel(minutes) : { label: kind.replaceAll('_', ' ') };
+}
+// A limit's model scope: the model's display name or id, or a plain scope string.
+function limitScope(record) {
+    if (typeof record.scope === 'string')
+        return { scope: safeText(record.scope), modelId: undefined };
+    const model = isObject(record.scope) && isObject(record.scope.model) ? record.scope.model : {};
+    return { scope: safeText(model.display_name) || safeText(model.id), modelId: model.id };
+}
+export function parseClaudeUsage(usage) {
+    if (!isObject(usage))
+        throw new ProviderError('invalid_response');
+    const windows = [];
+    const limits = asArray(usage.limits).filter(isObject);
+    const listed = new Set(limits.map(record => CANONICAL_LIMIT_KINDS[safeText(record.kind)]).filter(Boolean));
+    for (const [id, spec] of Object.entries(USAGE_WINDOWS)) {
+        const value = usage[id];
+        const reported = isObject(value) ? value : undefined;
+        // Reported as null and absent from the limits too: the plan has no such limit (no weekly one,
+        // say), which is not a limit of unknown size.
+        const none = value === null && limits.length > 0 && !listed.has(id);
+        if ((!spec.required && !reported) || none)
+            continue;
+        windows.push(normalizeWindow({
+            id,
+            ...durationLabel(spec.minutes),
+            usedPercent: reported?.utilization,
+            resetsAt: reported?.resets_at,
+            ...(spec.scope ? { scope: spec.scope } : {})
+        }));
+    }
+    for (const record of limits) {
+        const kind = safeText(record.kind, 'unknown');
+        const { scope, modelId } = limitScope(record);
+        const canonicalId = scope ? undefined : CANONICAL_LIMIT_KINDS[kind];
+        const identity = [record.id, modelId, scope, record.window, record.period].find((value) => (typeof value === 'string' || typeof value === 'number') && Boolean(value));
+        const window = normalizeWindow({
+            id: canonicalId ?? `limit:${kind}:${shortHash(String(identity ?? 'general'))}`,
+            ...limitPeriod(kind),
+            usedPercent: record.percent,
+            resetsAt: record.resets_at,
+            ...(scope ? { scope } : {}),
+            active: record.is_active
+        });
+        const canonical = canonicalId ? windows.find(w => w.id === canonicalId) : undefined;
+        if (!canonical)
+            windows.push(window);
+        else if (canonical.usedPercent === null && window.usedPercent !== null)
+            Object.assign(canonical, window);
+        else if (typeof record.is_active === 'boolean')
+            canonical.active = record.is_active;
+    }
+    return { windows };
+}
+const SECONDARY_PROFILE_DIR = `${PROFILE_DIRS.claude}-secondary`;
+export const DEFAULT_ACCOUNT_ID = accountId('claude', DEFAULT_ACCOUNT_KEY);
+const SECONDARY_ACCOUNT_ID = accountId('claude', 'secondary');
+// Model name Claude Code records on messages it generated itself (API errors, limit notices).
+export const SYNTHETIC_MODEL = '<synthetic>';
+// What Claude Code keeps in a profile folder (and in a project's own `.claude` folder).
+export const CLAUDE_FILES = {
+    credentials: '.credentials.json',
+    settings: 'settings.json',
+    localSettings: 'settings.local.json',
+    // The state file, which records the signed-in account.
+    state: '.claude.json',
+    // One folder of session transcripts per project.
+    projects: 'projects',
+    // The running processes, each listing itself (see claude-processes.ts).
+    sessions: 'sessions'
+};
+// The section of Claude Code's credentials (file or Keychain item) that holds its sign-in.
+export const claudeOAuthSection = (credentials) => isObject(credentials) && isObject(credentials.claudeAiOauth) ? credentials.claudeAiOauth : null;
+// The OAuth section of a credentials document, when it holds an access token.
+function oauthCredentials(credentials) {
+    const oauth = claudeOAuthSection(credentials);
+    if (!oauth || typeof oauth.accessToken !== 'string' || !oauth.accessToken.trim())
+        return null;
+    return { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt, subscriptionType: oauth.subscriptionType };
+}
+// The account a Claude profile folder holds. Any folder but the default one is explicit: Claude
+// Code then runs with CLAUDE_CONFIG_DIR set, which selects a different Keychain item on macOS.
+export function claudeProfile(configDir, home) {
+    const resolved = path.resolve(configDir);
+    const configDirExplicit = resolved !== path.resolve(defaultProfileDir('claude', home));
+    const isSecondary = path.basename(configDir) === SECONDARY_PROFILE_DIR;
+    const id = !configDirExplicit ? DEFAULT_ACCOUNT_ID : isSecondary ? SECONDARY_ACCOUNT_ID : profileAccountId('claude', resolved);
+    const naming = !configDirExplicit
+        ? { labelKey: 'accountA' }
+        : isSecondary
+            ? { labelKey: 'accountB' }
+            : { label: profileLabel('claude', resolved) };
+    return {
+        id,
+        providerId: 'claude',
+        ...naming,
+        configDir: resolved,
+        configDirExplicit,
+        primary: !configDirExplicit,
+        enabled: true
+    };
+}
+// A profile counts when it holds a signed-in credentials file. On macOS credentials live in
+// the Keychain, so a configured profile (settings.json present) counts as well.
+export async function isSignedInProfile(root, platform = process.platform) {
+    if (platform === 'darwin' && (await isFile(path.join(root, CLAUDE_FILES.settings))))
+        return true;
+    const file = path.join(root, CLAUDE_FILES.credentials);
+    if (!(await isRegularFile(file)))
+        return false;
+    return oauthCredentials(await readCredentialFile(file).catch(() => null)) !== null;
+}
+// Default first, then the secondary profile, then the rest by id.
+const PROFILE_RANK = { [DEFAULT_ACCOUNT_ID]: 0, [SECONDARY_ACCOUNT_ID]: 1 };
+const rank = (account) => PROFILE_RANK[account.id] ?? 2;
+export async function discoverClaudeAccounts({ home = os.homedir(), platform = process.platform } = {}) {
+    const accounts = [];
+    for (const root of await profileFolders('claude', home)) {
+        if (await isSignedInProfile(root, platform))
+            accounts.push(claudeProfile(root, home));
+    }
+    // The default profile always exists on macOS (its Keychain entry may hold the sign-in),
+    // and is the fallback everywhere when nothing was found.
+    if (!accounts.some(a => a.id === DEFAULT_ACCOUNT_ID) && (platform === 'darwin' || !accounts.length))
+        accounts.push(claudeProfile(defaultProfileDir('claude', home), home));
+    accounts.sort((a, b) => rank(a) - rank(b) || a.id.localeCompare(b.id));
+    const [first] = accounts;
+    if (first && !accounts.some(a => a.primary))
+        first.primary = true;
+    return accounts;
+}
+export async function readClaudeCredentials(account, options) {
+    const { platform = process.platform, home = os.homedir() } = options;
+    const configDir = account.configDir ?? defaultProfileDir('claude', home);
+    if (platform === 'darwin') {
+        const configDirExplicit = account.configDirExplicit ?? account.id !== DEFAULT_ACCOUNT_ID;
+        const stored = await readClaudeKeychain({
+            configDir,
+            configDirExplicit,
+            platform,
+            ...(options.runProcess ? { runProcess: options.runProcess } : {})
+        }).catch(() => null);
+        // Without a usable token in the Keychain, the credentials file is the documented fallback.
+        if (stored && oauthCredentials(stored))
+            return stored;
+    }
+    try {
+        return await readCredentialFile(path.join(configDir, CLAUDE_FILES.credentials));
+    }
+    catch (error) {
+        if (platform !== 'darwin' || !(error instanceof ProviderError) || error.code !== 'auth_missing')
+            throw error;
+        const isDefaultDir = samePath(configDir, defaultProfileDir('claude', home));
+        throw new ProviderError(isDefaultDir ? 'keychain_unavailable' : 'unsupported_profile');
+    }
+}
+// The default profile keeps its state file in the home folder; any other in the profile folder.
+export function claudeStateFile(account, home = os.homedir()) {
+    const explicit = account.configDirExplicit ?? account.id !== DEFAULT_ACCOUNT_ID;
+    return path.join(explicit && account.configDir ? account.configDir : home, CLAUDE_FILES.state);
+}
+async function readSignedInEmail(account, { home = os.homedir() }) {
+    const state = await readJson(claudeStateFile(account, home));
+    return safeEmail(isObject(state) && isObject(state.oauthAccount) ? state.oauthAccount.emailAddress : undefined);
+}
+export function createClaudeProvider(options = {}) {
+    const getJson = options.getJson ?? defaultGetJson;
+    const readCredentials = options.readCredentials ?? ((account) => readClaudeCredentials(account, options));
+    return {
+        id: 'claude',
+        discover: () => discoverClaudeAccounts(options),
+        async fetch(account) {
+            const oauth = oauthCredentials(await readCredentials(account));
+            if (!oauth)
+                throw new ProviderError('auth_missing');
+            if (isExpired(oauth.expiresAt, options.clock))
+                throw new ProviderError('auth_expired');
+            const usage = await getJson(QUOTA_ENDPOINTS.claude, {
+                headers: {
+                    Authorization: `Bearer ${oauth.accessToken}`,
+                    'anthropic-beta': OAUTH_BETA,
+                    'User-Agent': USER_AGENT,
+                    Accept: 'application/json'
+                }
+            });
+            const result = parseClaudeUsage(usage);
+            const plan = safePlan(oauth.subscriptionType);
+            const signedInAs = await readSignedInEmail(account, options);
+            return { ...result, ...(plan ? { plan } : {}), ...(signedInAs ? { signedInAs } : {}) };
+        }
+    };
+}

package/build/providers/codex.d.ts

@@ -0,0 +1,21 @@
+import { type ChildProcess, type SpawnOptions } from 'node:child_process';
+import type { Readable, Writable } from 'node:stream';
+import { type Environment } from '../core/environment.ts';
+import { type BinaryLocation, type Clock } from './common.ts';
+import type { DiscoveredAccount, ParsedQuota, ProviderAdapter } from './types.ts';
+export declare const DEFAULT_ACCOUNT_ID: string;
+export declare const CODEX_SESSIONS_DIR = "sessions";
+export declare function parseCodexRateLimits(response: unknown): ParsedQuota;
+type ServerProcess = Pick<ChildProcess, 'on' | 'once' | 'kill' | 'exitCode' | 'signalCode'> & {
+    stdin: Writable;
+    stdout: Readable;
+};
+export type SpawnAppServer = (binary: string, args: readonly string[], options: SpawnOptions) => ServerProcess;
+export declare function codexProfile(configDir: string, home: string, env?: Environment): DiscoveredAccount;
+export declare const isSignedInCodexHome: (root: string) => Promise<boolean>;
+export interface CodexProviderOptions extends BinaryLocation {
+    clock?: Clock;
+    spawnProcess?: SpawnAppServer;
+}
+export declare function createCodexProvider(options?: CodexProviderOptions): ProviderAdapter;
+export {};

package/build/providers/codex.js

@@ -0,0 +1,221 @@
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import { cleanEnvironment } from "../core/environment.js";
+import { ProviderError } from "../core/errors.js";
+import { attemptSync, isObject } from "../core/files.js";
+import { isoFromUnixSeconds, normalizeWindow, safeEmail, safePlan, safeText } from "../core/model.js";
+import { accountId, APP_NAME, APP_SLUG, DEFAULT_ACCOUNT_KEY, durationLabel, PROFILE_ENV } from "../shared/catalog.js";
+import { APP_VERSION, findBinary, isExpired, jwtClaims, MAX_RESPONSE_BYTES, readCredentialFile } from "./common.js";
+import { defaultProfileDir, isRegularFile, profileAccountId, profileFolders, profileLabel } from "./profiles.js";
+export const DEFAULT_ACCOUNT_ID = accountId('codex', DEFAULT_ACCOUNT_KEY);
+const AUTH_FILE = 'auth.json';
+// Where a Codex home keeps its session rollouts, by date.
+export const CODEX_SESSIONS_DIR = 'sessions';
+const RPC_TIMEOUT_MS = 10000;
+const SHUTDOWN_GRACE_MS = 2000;
+// The app server's requests in a read, one after the other (see probeAccount).
+const PROBE_REQUESTS = 3;
+// The default bucket is the account-wide limit; other buckets are model-specific scopes.
+const DEFAULT_BUCKET = 'codex';
+const WINDOW_SLOTS = ['primary', 'secondary'];
+export function parseCodexRateLimits(response) {
+    if (!isObject(response) || !(isObject(response.rateLimitsByLimitId) || isObject(response.rateLimits)))
+        throw new ProviderError('invalid_response');
+    const buckets = isObject(response.rateLimitsByLimitId) ? response.rateLimitsByLimitId : { [DEFAULT_BUCKET]: response.rateLimits };
+    const windows = [];
+    for (const [bucketId, value] of Object.entries(buckets)) {
+        for (const slot of WINDOW_SLOTS) {
+            const raw = isObject(value) ? value[slot] : undefined;
+            if (!isObject(raw))
+                continue;
+            windows.push(normalizeWindow({
+                id: `${bucketId}:${slot}`,
+                ...durationLabel(raw.windowDurationMins),
+                usedPercent: raw.usedPercent,
+                resetsAt: isoFromUnixSeconds(raw.resetsAt),
+                ...(bucketId === DEFAULT_BUCKET ? {} : { scope: safeText(bucketId) })
+            }));
+        }
+    }
+    return windows.length ? { windows } : { windows, status: 'no_limits_reported' };
+}
+const spawnAppServer = (binary, args, options) => spawn(binary, args, { ...options, stdio: ['pipe', 'pipe', 'ignore'] });
+function startAppServer(binary, configDir, spawnProcess) {
+    const child = spawnProcess(binary, ['app-server', '--listen', 'stdio://'], {
+        shell: false,
+        windowsHide: true,
+        env: cleanEnvironment({ [PROFILE_ENV.codex]: configDir }),
+        stdio: ['pipe', 'pipe', 'ignore']
+    });
+    const pending = new Map();
+    let buffer = '';
+    let closed = false;
+    let serial = 0;
+    function rejectAll() {
+        closed = true;
+        for (const item of pending.values())
+            item.reject(new ProviderError('server_closed'));
+        pending.clear();
+    }
+    function receive(line) {
+        let packet;
+        try {
+            packet = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!isObject(packet) || typeof packet.id !== 'number')
+            return;
+        const item = pending.get(packet.id);
+        if (!item)
+            return;
+        pending.delete(packet.id);
+        if (packet.error)
+            item.reject(new ProviderError('rpc_error'));
+        else
+            item.resolve(packet.result);
+    }
+    child.on('error', rejectAll);
+    child.on('close', rejectAll);
+    // Writing to a server that already exited fails with EPIPE; `close` reports that instead.
+    child.stdin.on('error', () => undefined);
+    child.stdout.on('data', (chunk) => {
+        buffer += chunk.toString();
+        if (buffer.length > MAX_RESPONSE_BYTES) {
+            rejectAll();
+            child.kill();
+            return;
+        }
+        for (let newline = buffer.indexOf('\n'); newline !== -1; newline = buffer.indexOf('\n')) {
+            receive(buffer.slice(0, newline));
+            buffer = buffer.slice(newline + 1);
+        }
+    });
+    const send = (message) => {
+        child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`);
+    };
+    return {
+        request: (method, params) => new Promise((resolve, reject) => {
+            if (closed) {
+                reject(new ProviderError('server_closed'));
+                return;
+            }
+            const id = ++serial;
+            const timeout = setTimeout(() => {
+                pending.delete(id);
+                reject(new ProviderError('rpc_timeout'));
+            }, RPC_TIMEOUT_MS);
+            pending.set(id, {
+                resolve: value => {
+                    clearTimeout(timeout);
+                    resolve(value);
+                },
+                reject: error => {
+                    clearTimeout(timeout);
+                    reject(error);
+                }
+            });
+            send({ id, method, ...(params ? { params } : {}) });
+        }),
+        notify: method => {
+            send({ method });
+        },
+        async stop() {
+            child.stdin.end();
+            child.kill();
+            if (child.exitCode === null && child.signalCode === null) {
+                await new Promise(resolve => {
+                    const timer = setTimeout(resolve, SHUTDOWN_GRACE_MS);
+                    child.once('close', () => {
+                        clearTimeout(timer);
+                        resolve();
+                    });
+                });
+            }
+            rejectAll();
+        }
+    };
+}
+async function probeAccount(binary, configDir, spawnProcess) {
+    const server = startAppServer(binary, configDir, spawnProcess);
+    try {
+        await server.request('initialize', {
+            // The app server takes a client name as an identifier with underscores.
+            clientInfo: { name: APP_SLUG.replaceAll('-', '_'), title: APP_NAME, version: APP_VERSION },
+            capabilities: { experimentalApi: false }
+        });
+        server.notify('initialized');
+        const read = await server.request('account/read', { refreshToken: false });
+        const account = isObject(read) ? read.account : undefined;
+        if (!isObject(account))
+            throw new ProviderError('auth_missing');
+        const result = parseCodexRateLimits(await server.request('account/rateLimits/read'));
+        const plan = safePlan(account.planType);
+        return plan ? { ...result, plan } : result;
+    }
+    finally {
+        await server.stop();
+    }
+}
+// The signed-in e-mail from the local auth file, failing fast on a locally expired token. A
+// missing auth file is left to the app server, which reports the signed-out state itself.
+async function readLocalSignIn(configDir, clock) {
+    const auth = await readCredentialFile(path.join(configDir, AUTH_FILE)).catch((error) => {
+        if (error instanceof ProviderError && error.code === 'auth_missing')
+            return null;
+        throw error;
+    });
+    const tokens = isObject(auth?.tokens) ? auth.tokens : {};
+    if (typeof tokens.access_token === 'string') {
+        const { exp } = jwtClaims(tokens.access_token);
+        if (typeof exp === 'number' && isExpired(exp * 1000, clock))
+            throw new ProviderError('auth_expired');
+    }
+    return safeEmail(attemptSync(() => jwtClaims(tokens.id_token).email));
+}
+// The folder plain `codex` uses: CODEX_HOME when set, else `~/.codex`.
+const codexDefaultDir = (home, env = process.env) => env[PROFILE_ENV.codex] ?? defaultProfileDir('codex', home);
+// The account a Codex home folder holds; Codex keeps one sign-in per folder.
+export function codexProfile(configDir, home, env = process.env) {
+    const resolved = path.resolve(configDir);
+    const isDefault = resolved === path.resolve(codexDefaultDir(home, env));
+    return {
+        id: isDefault ? DEFAULT_ACCOUNT_ID : profileAccountId('codex', resolved),
+        providerId: 'codex',
+        ...(isDefault ? { labelKey: 'defaultAccount' } : { label: profileLabel('codex', resolved) }),
+        configDir: resolved,
+        primary: isDefault,
+        enabled: true
+    };
+}
+// Whether a Codex home folder holds a sign-in.
+export const isSignedInCodexHome = (root) => isRegularFile(path.join(root, AUTH_FILE));
+// The default folder always counts: its app server reports a signed-out state itself. Other
+// profile folders count once they hold a sign-in.
+async function discoverCodexAccounts(home, env) {
+    const defaultDir = path.resolve(codexDefaultDir(home, env));
+    const others = [];
+    for (const root of await profileFolders('codex', home)) {
+        if (path.resolve(root) !== defaultDir && (await isSignedInCodexHome(root)))
+            others.push(codexProfile(root, home, env));
+    }
+    return [codexProfile(defaultDir, home, env), ...others.sort((a, b) => a.id.localeCompare(b.id))];
+}
+export function createCodexProvider(options = {}) {
+    const home = options.home ?? os.homedir();
+    const env = options.env ?? process.env;
+    const defaultConfigDir = codexDefaultDir(home, env);
+    return {
+        id: 'codex',
+        fetchTimeoutMs: PROBE_REQUESTS * RPC_TIMEOUT_MS + SHUTDOWN_GRACE_MS,
+        discover: () => discoverCodexAccounts(home, env),
+        async fetch(account) {
+            const configDir = account.configDir ?? defaultConfigDir;
+            const signedInAs = await readLocalSignIn(configDir, options.clock);
+            const result = await probeAccount(await findBinary('codex', options), configDir, options.spawnProcess ?? spawnAppServer);
+            return signedInAs ? { ...result, signedInAs } : result;
+        }
+    };
+}

package/build/providers/common.d.ts

@@ -0,0 +1,63 @@
+import type { ClientRequest, IncomingMessage } from 'node:http';
+import https from 'node:https';
+import { type Environment } from '../core/environment.ts';
+import { ProviderError } from '../core/errors.ts';
+import { type JsonObject } from '../core/files.ts';
+import { type ProviderId } from '../shared/catalog.ts';
+export type Clock = () => number;
+export declare const APP_VERSION: string;
+export declare const USER_AGENT: string;
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const QUOTA_ENDPOINTS: {
+    readonly claude: "https://api.anthropic.com/api/oauth/usage";
+    readonly cursor: "https://cursor.com/api/usage-summary";
+};
+export declare const sha256Prefix: (value: string, length: number) => string;
+export declare function isExpired(epochMs: unknown, clock?: Clock): boolean;
+export declare function jwtClaims(token: unknown): JsonObject;
+export declare function readCredentialFile(file: string): Promise<JsonObject>;
+interface Destroyable {
+    destroy(): void;
+}
+export interface Settle<T> {
+    succeed(value: T): void;
+    fail(error: ProviderError): void;
+    attach<S extends Destroyable>(stream: S): S;
+}
+export declare function settleOnce<T>(resolve: (value: T) => void, reject: (error: ProviderError) => void, timeoutMs: number): Settle<T>;
+export declare function readJsonResponse(response: IncomingMessage, settle: Settle<unknown>, maxBytes?: number): void;
+export type QuotaEndpoint = (typeof QUOTA_ENDPOINTS)[keyof typeof QUOTA_ENDPOINTS];
+type HttpsGet = (url: URL, options: https.RequestOptions, callback: (response: IncomingMessage) => void) => ClientRequest;
+export interface GetJsonOptions {
+    headers?: Readonly<Record<string, string>>;
+    timeoutMs?: number;
+    requestImpl?: HttpsGet;
+}
+export type GetJson = (endpoint: QuotaEndpoint, options?: GetJsonOptions) => Promise<unknown>;
+export declare const getJson: GetJson;
+export declare function unpackedPath(file: string): string;
+export declare function windowsPowerShell(env?: Environment): string;
+export interface BinaryLocation {
+    env?: Environment;
+    home?: string;
+    platform?: NodeJS.Platform;
+}
+export interface DesktopApp {
+    mac: string;
+    windows: readonly string[];
+}
+export declare const TOOL_INSTALLS: Readonly<Record<ProviderId, {
+    binaries: readonly string[];
+    app?: DesktopApp;
+}>>;
+export declare const windowsAppPath: (app: DesktopApp, env: Environment, home: string) => string;
+export declare function findBinary(name: string, { env, home, platform }?: BinaryLocation): Promise<string>;
+export interface RunOptions {
+    env?: Record<string, string>;
+    platform?: NodeJS.Platform;
+    timeoutMs?: number;
+    maxBytes?: number;
+}
+export type RunProcess = (binary: string, args: readonly string[], options?: RunOptions) => Promise<string>;
+export declare const runProcess: RunProcess;
+export {};