@cortexkit/anthropic-auth-core 1.23.0 → 2.0.0

package/dist/killswitch.js

@@ -1,132 +0,0 @@
-import { DEFAULT_KILLSWITCH_THRESHOLDS as DEFAULT_THRESHOLDS, normalizeKillswitchThresholds, } from './accounts.js';
-export const KILLSWITCH_COMMAND_NAME = 'claude-killswitch';
-export function parseKillswitchCommandAction(argumentsText) {
-    const parts = argumentsText.trim().split(/\s+/).filter(Boolean);
-    if (parts.length === 0)
-        return { type: 'status' };
-    if (parts.length === 1 && parts[0] === 'on')
-        return { type: 'on' };
-    if (parts.length === 1 && parts[0] === 'off')
-        return { type: 'off' };
-    if (parts[0] === 'set') {
-        const entries = [];
-        for (let i = 1; i < parts.length; i++) {
-            const match = parts[i]?.match(/^([^:]+):(\d+),(\d+)(?:,(\d+))?$/);
-            if (!match)
-                return { type: 'usage' };
-            const [, account, fhStr, sdStr, scopedStr] = match;
-            const scoped = typeof scopedStr === 'string' && scopedStr.length > 0
-                ? Number.parseInt(scopedStr, 10)
-                : undefined;
-            const entry = {
-                account,
-                fh: Number.parseInt(fhStr, 10),
-                sd: Number.parseInt(sdStr, 10),
-            };
-            if (scoped !== undefined)
-                entry.scoped = scoped;
-            entries.push(entry);
-        }
-        if (entries.length === 0)
-            return { type: 'usage' };
-        return { type: 'set', entries };
-    }
-    return { type: 'usage' };
-}
-function buildStatusTable(config, accountIds) {
-    const enabled = config.enabled === true;
-    const lines = [
-        '## Killswitch',
-        '',
-        `Status: **${enabled ? 'ON' : 'OFF'}**`,
-    ];
-    if (enabled) {
-        lines.push('');
-        lines.push('| Account | 5h threshold | 1w threshold | Scoped |');
-        lines.push('| ------- | ------------ | ------------ | ------ |');
-        const mainT = normalizeKillswitchThresholds(config.main);
-        lines.push(`| main | \u2265 ${mainT.five_hour}% | \u2265 ${mainT.seven_day}% | \u2264 ${mainT.scoped}% |`);
-        for (const id of accountIds) {
-            const t = normalizeKillswitchThresholds(config.accounts?.[id] ?? config.main);
-            lines.push(`| ${id} | \u2265 ${t.five_hour}% | \u2265 ${t.seven_day}% | \u2264 ${t.scoped}% |`);
-        }
-    }
-    return lines.join('\n');
-}
-const USAGE_TEXT = [
-    '## Killswitch Commands',
-    '',
-    '```',
-    `/${KILLSWITCH_COMMAND_NAME}              — show status`,
-    `/${KILLSWITCH_COMMAND_NAME} on           — enable with current or default thresholds`,
-    `/${KILLSWITCH_COMMAND_NAME} off          — disable`,
-    `/${KILLSWITCH_COMMAND_NAME} set all:5,10 — set all accounts to 5h≥5%, 1w≥10%`,
-    `/${KILLSWITCH_COMMAND_NAME} set main:3,8,0 — set 5h≥3%, 1w≥8%, scoped≤0%`,
-    `/${KILLSWITCH_COMMAND_NAME} set main:3,8 work-alt:5,10 — per-account`,
-    '```',
-].join('\n');
-export function executeKillswitchCommand(input) {
-    const action = parseKillswitchCommandAction(input.argumentsText);
-    if (action.type === 'status') {
-        const status = buildStatusTable(input.config, input.accountIds);
-        return { text: `${status}\n\n${USAGE_TEXT}` };
-    }
-    if (action.type === 'on') {
-        const updated = {
-            ...input.config,
-            enabled: true,
-            main: input.config.main ?? {
-                five_hour: DEFAULT_THRESHOLDS.five_hour,
-                seven_day: DEFAULT_THRESHOLDS.seven_day,
-            },
-        };
-        const status = buildStatusTable(updated, input.accountIds);
-        return {
-            text: `## Killswitch Enabled\n\n${status}`,
-            updatedConfig: updated,
-        };
-    }
-    if (action.type === 'off') {
-        const updated = { ...input.config, enabled: false };
-        return {
-            text: '## Killswitch Disabled',
-            updatedConfig: updated,
-        };
-    }
-    if (action.type === 'set') {
-        const accounts = { ...(input.config.accounts ?? {}) };
-        const updated = {
-            ...input.config,
-            enabled: true,
-            accounts,
-        };
-        for (const entry of action.entries) {
-            const thresholds = {
-                five_hour: entry.fh,
-                seven_day: entry.sd,
-            };
-            if (entry.scoped !== undefined)
-                thresholds.scoped = entry.scoped;
-            if (entry.account === 'main') {
-                updated.main = thresholds;
-            }
-            else if (entry.account === 'all') {
-                updated.main = thresholds;
-                for (const id of input.accountIds) {
-                    accounts[id] = thresholds;
-                }
-            }
-            else {
-                accounts[entry.account] = thresholds;
-            }
-        }
-        const status = buildStatusTable(updated, input.accountIds);
-        return {
-            text: `## Killswitch Updated\n\n${status}`,
-            updatedConfig: updated,
-        };
-    }
-    // usage
-    const status = buildStatusTable(input.config, input.accountIds);
-    return { text: `${status}\n\n${USAGE_TEXT}` };
-}

package/dist/logger.js

@@ -1,288 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { CUSTODY_HANDLE_PATTERN } from './constants.js';
-const LEVEL_ORDER = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    debug: 3,
-    trace: 4,
-};
-const VALID_LEVELS = new Set(Object.keys(LEVEL_ORDER));
-function parseLogLevel(value) {
-    if (!value)
-        return null;
-    const normalized = value.trim().toLowerCase();
-    return VALID_LEVELS.has(normalized) ? normalized : null;
-}
-const envLevel = parseLogLevel(process.env.OPENCODE_ANTHROPIC_AUTH_LOG_LEVEL);
-let currentLevel = envLevel ?? 'info';
-export function setLogLevel(level) {
-    currentLevel = level;
-}
-export function getLogLevel() {
-    return currentLevel;
-}
-export { parseLogLevel };
-// -- Emission control ------------------------------------------------------
-export function shouldEmit(level) {
-    return LEVEL_ORDER[level] <= LEVEL_ORDER[currentLevel];
-}
-// -- File path -------------------------------------------------------------
-const LOG_FILE = process.env.OPENCODE_ANTHROPIC_AUTH_LOG_FILE ??
-    path.join(os.tmpdir(), 'opencode-anthropic-auth.log');
-export function getLogFilePath() {
-    return LOG_FILE;
-}
-// -- Rotation --------------------------------------------------------------
-const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5 MB
-const MAX_GENERATIONS = 3;
-function rotateLogFile() {
-    try {
-        if (!fs.existsSync(LOG_FILE))
-            return;
-        const stat = fs.statSync(LOG_FILE);
-        if (stat.size < MAX_FILE_SIZE)
-            return;
-    }
-    catch {
-        return;
-    }
-    try {
-        for (let i = MAX_GENERATIONS; i >= 1; i--) {
-            const oldPath = i === 1 ? LOG_FILE : `${LOG_FILE}.${i - 1}`;
-            const newPath = `${LOG_FILE}.${i}`;
-            try {
-                if (i === MAX_GENERATIONS) {
-                    try {
-                        fs.unlinkSync(newPath);
-                    }
-                    catch {
-                        // .3 might not exist
-                    }
-                }
-                if (fs.existsSync(oldPath)) {
-                    fs.renameSync(oldPath, newPath);
-                }
-            }
-            catch {
-                // Rotation best-effort — never throw
-            }
-        }
-    }
-    catch {
-        // Rotation must never throw
-    }
-}
-// -- Redaction ------------------------------------------------------------
-export const SECRET_KEY_EXACT = /^(authorization|x-api-key|cookie|set-cookie|refresh|access|token|handle)$/i;
-export function isSecretKey(key) {
-    if (SECRET_KEY_EXACT.test(key))
-        return true;
-    const k = key.toLowerCase().replace(/[-_]/g, '');
-    if (k.includes('apikey'))
-        return true;
-    if (k.endsWith('secret') || k.endsWith('password'))
-        return true;
-    if (k.endsWith('token') && !k.endsWith('tokens'))
-        return true;
-    return false;
-}
-const REDACT_VALUE_PATTERNS = [
-    /Bearer\s+\S+/,
-    /sk-[A-Za-z0-9-]+/,
-    /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/,
-    CUSTODY_HANDLE_PATTERN,
-];
-function isRedactableValue(value) {
-    if (typeof value !== 'string')
-        return false;
-    return REDACT_VALUE_PATTERNS.some((pattern) => pattern.test(value));
-}
-export function redactPayload(payload) {
-    if (payload == null || Object.keys(payload).length === 0)
-        return undefined;
-    const seen = new WeakSet();
-    function walk(value) {
-        if (value == null || typeof value !== 'object') {
-            if (isRedactableValue(value))
-                return '***REDACTED***';
-            return value;
-        }
-        if (seen.has(value))
-            return '[Circular]';
-        seen.add(value);
-        try {
-            if (Array.isArray(value))
-                return value.map(walk);
-            const obj = value;
-            const result = {};
-            for (const [key, entry] of Object.entries(obj)) {
-                if (isSecretKey(key)) {
-                    result[key] = '***REDACTED***';
-                    continue;
-                }
-                result[key] = walk(entry);
-            }
-            return result;
-        }
-        finally {
-            seen.delete(value);
-        }
-    }
-    return walk(payload);
-}
-// -- Line formatting ------------------------------------------------------
-export function formatLogLine(level, channel, message, payload) {
-    const now = new Date().toISOString();
-    const levelUpper = level.toUpperCase().padEnd(5);
-    const channelSegment = channel ? ` [${channel}]` : '';
-    const payloadJson = (() => {
-        try {
-            const redacted = redactPayload(payload);
-            const withPid = redacted
-                ? { ...redacted, pid: process.pid }
-                : { pid: process.pid };
-            return ` ${JSON.stringify(withPid)}`;
-        }
-        catch {
-            return ` {"pid":${process.pid},"payload":"[unserializable]"}`;
-        }
-    })();
-    return `[${now}] ${levelUpper}${channelSegment} ${message}${payloadJson}`;
-}
-let testSink = null;
-export function __setLogTestSink(sink) {
-    testSink = sink;
-}
-// -- Leveled API ----------------------------------------------------------
-function emit(level, channel, message, payload) {
-    if (!shouldEmit(level))
-        return;
-    if (testSink) {
-        try {
-            testSink({ level, channel, message, payload: redactPayload(payload) });
-        }
-        catch {
-            // Sink must never throw into production.
-        }
-    }
-    if (isTestEnv)
-        return;
-    try {
-        const line = `${formatLogLine(level, channel, message, payload)}\n`;
-        buffer.push(line);
-        if (buffer.length >= BUFFER_SIZE_LIMIT) {
-            flush();
-        }
-        else {
-            scheduleFlush();
-        }
-    }
-    catch {
-        // Logging must never throw.
-    }
-}
-export const logger = {
-    error(channel, message, payload) {
-        emit('error', channel, message, payload);
-    },
-    warn(channel, message, payload) {
-        emit('warn', channel, message, payload);
-    },
-    info(channel, message, payload) {
-        emit('info', channel, message, payload);
-    },
-    debug(channel, message, payload) {
-        emit('debug', channel, message, payload);
-    },
-    trace(channel, message, payload) {
-        emit('trace', channel, message, payload);
-    },
-};
-// -- Buffered writes ------------------------------------------------------
-const isTestEnv = process.env.NODE_ENV === 'test';
-const FLUSH_INTERVAL_MS = 500;
-const BUFFER_SIZE_LIMIT = 50;
-let buffer = [];
-let flushTimer = null;
-function flush() {
-    if (flushTimer) {
-        clearTimeout(flushTimer);
-        flushTimer = null;
-    }
-    if (buffer.length === 0)
-        return;
-    const data = buffer.join('');
-    buffer = [];
-    try {
-        rotateLogFile();
-        fs.appendFileSync(LOG_FILE, data);
-    }
-    catch {
-        // Logging must never throw.
-    }
-}
-function scheduleFlush() {
-    if (flushTimer)
-        return;
-    flushTimer = setTimeout(() => {
-        flushTimer = null;
-        flush();
-    }, FLUSH_INTERVAL_MS);
-}
-// -- Back-compat shims ----------------------------------------------------
-const CHANNEL_REGEX = /^\[([\w-]+)\]\s*/;
-export function log(message, data) {
-    if (!shouldEmit('debug'))
-        return;
-    if (isTestEnv)
-        return;
-    try {
-        let channel = '';
-        let msg = message;
-        const match = message.match(CHANNEL_REGEX);
-        if (match) {
-            channel = match[1] ?? '';
-            msg = message.slice(match[0].length);
-        }
-        let payload;
-        if (data != null) {
-            if (data instanceof Error) {
-                payload = {
-                    error: `${data.message}${data.stack ? `\n${data.stack}` : ''}`,
-                };
-            }
-            else if (typeof data === 'object') {
-                payload = data;
-            }
-        }
-        emit('debug', channel, msg, payload);
-    }
-    catch {
-        // Logging must never throw.
-    }
-}
-export function relayLog(message, data) {
-    if (!shouldEmit('debug'))
-        return;
-    if (isTestEnv)
-        return;
-    try {
-        let payload;
-        if (data != null) {
-            if (typeof data === 'object' && !(data instanceof Error)) {
-                payload = data;
-            }
-        }
-        emit('debug', 'relay', message, payload);
-    }
-    catch {
-        // Logging must never throw.
-    }
-}
-// -- Exit flush -----------------------------------------------------------
-if (!isTestEnv) {
-    process.on('exit', flush);
-}

package/dist/logging.js

@@ -1,59 +0,0 @@
-// Known limitation: the TUI bundle is a SEPARATE module instance from the loader,
-// so /claude-logging sets the SERVER-side (loader) logger level and persists it
-// (applied on next boot); the TUI-side logger level is only raised via the
-// OPENCODE_ANTHROPIC_AUTH_LOG_LEVEL env override. The command still correctly
-// persists and applies server-side — just note this asymmetry.
-export const CLAUDE_LOGGING_COMMAND_NAME = 'claude-logging';
-export const LOGGING_LEVELS = [
-    'error',
-    'warn',
-    'info',
-    'debug',
-    'trace',
-];
-const LOGGING_USAGE = 'Usage: `/claude-logging`, `/claude-logging error|warn|info|debug|trace`.';
-export function parseLoggingCommandAction(argumentsText) {
-    const tokens = argumentsText.trim().toLowerCase().split(/\s+/).filter(Boolean);
-    if (tokens.length === 0)
-        return { type: 'status' };
-    if (tokens.length === 1 && LOGGING_LEVELS.includes(tokens[0])) {
-        return { type: 'level', level: tokens[0] };
-    }
-    return { type: 'usage' };
-}
-export function buildLoggingStatusSummary(input) {
-    const level = input?.level ?? 'info';
-    return [
-        '## Claude Log Level',
-        '',
-        `Current log level: \`${level}\``,
-        '- Persisted: ~/.config/opencode/anthropic-auth.json',
-        '- Valid levels: error, warn, info, debug, trace',
-        '',
-        LOGGING_USAGE,
-    ].join('\n');
-}
-export function executeLoggingCommand(input) {
-    const action = parseLoggingCommandAction(input.argumentsText);
-    const level = input.level ?? 'info';
-    if (action.type === 'status')
-        return buildLoggingStatusSummary({ level });
-    if (action.type === 'level') {
-        return [
-            '## Claude Log Level Updated',
-            '',
-            `Level set to \`${action.level}\`.`,
-            '',
-            ...buildLoggingStatusSummary({ level: action.level })
-                .split('\n')
-                .slice(2),
-        ].join('\n');
-    }
-    return [
-        '## Claude Log Level Usage',
-        '',
-        LOGGING_USAGE,
-        '',
-        ...buildLoggingStatusSummary({ level }).split('\n').slice(2),
-    ].join('\n');
-}

package/dist/mid-conversation-output-config.js

@@ -1,89 +0,0 @@
-import { isClaudeFable51Model } from './models.js';
-export const MID_CONVERSATION_OUTPUT_CONFIG_BETA = 'mid-conversation-output-config-2026-07-01';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function normalizeAdaptiveEffort(value) {
-    if (value === 'minimal')
-        return 'low';
-    if (value === 'low' ||
-        value === 'medium' ||
-        value === 'high' ||
-        value === 'xhigh' ||
-        value === 'max') {
-        return value;
-    }
-    return undefined;
-}
-export function usesMidConversationOutputConfig(body) {
-    return isClaudeFable51Model(body.model);
-}
-function compactTransitions(transitions) {
-    const compacted = [];
-    for (const transition of transitions) {
-        if (!Number.isSafeInteger(transition.afterAssistantMessages) ||
-            transition.afterAssistantMessages < 0 ||
-            !normalizeAdaptiveEffort(transition.effort)) {
-            continue;
-        }
-        const normalized = {
-            afterAssistantMessages: transition.afterAssistantMessages,
-            effort: transition.effort,
-        };
-        const previous = compacted.at(-1);
-        if (previous &&
-            previous.afterAssistantMessages === normalized.afterAssistantMessages) {
-            previous.effort = normalized.effort;
-            continue;
-        }
-        if (previous?.effort === normalized.effort)
-            continue;
-        compacted.push(normalized);
-    }
-    return compacted;
-}
-export function applyMidConversationOutputConfig(body, transitions) {
-    if (!usesMidConversationOutputConfig(body) || !Array.isArray(body.messages)) {
-        return { applied: false, inserted: 0 };
-    }
-    const compacted = compactTransitions(transitions);
-    const currentOutputConfig = isRecord(body.output_config)
-        ? body.output_config
-        : {};
-    const baseline = compacted[0]?.effort ??
-        normalizeAdaptiveEffort(currentOutputConfig.effort) ??
-        'high';
-    body.output_config = { ...currentOutputConfig, effort: baseline };
-    if (compacted.length < 2)
-        return { applied: true, inserted: 0 };
-    const messages = body.messages;
-    const transitionsByBoundary = new Map();
-    for (const transition of compacted.slice(1)) {
-        transitionsByBoundary.set(transition.afterAssistantMessages, transition.effort);
-    }
-    let assistantMessages = 0;
-    let activeEffort = baseline;
-    let inserted = 0;
-    const rewritten = [];
-    for (const message of messages) {
-        if (isRecord(message) &&
-            message.role === 'user' &&
-            transitionsByBoundary.has(assistantMessages)) {
-            const effort = transitionsByBoundary.get(assistantMessages);
-            if (effort && effort !== activeEffort) {
-                rewritten.push({
-                    role: 'system',
-                    content: [],
-                    output_config: { effort },
-                });
-                activeEffort = effort;
-                inserted++;
-            }
-        }
-        rewritten.push(message);
-        if (isRecord(message) && message.role === 'assistant')
-            assistantMessages++;
-    }
-    body.messages = rewritten;
-    return { applied: true, inserted };
-}

package/dist/model-remap.js

@@ -1,72 +0,0 @@
-/**
- * Remap canonical Claude model IDs to proxy-compatible names
- * using ANTHROPIC_DEFAULT_*_MODEL env vars.
- *
- * LiteLLM/proxy backends often use shorter model aliases
- * (e.g. `claude-sonnet-4-6` instead of `claude-sonnet-4-20250514`).
- * These proxy-route variables follow the Claude Code convention, except
- * ANTHROPIC_DEFAULT_FABLE_MODEL, which is plugin-specific:
- *
- *   ANTHROPIC_MODEL                  — default for any claude-* model
- *   ANTHROPIC_DEFAULT_SONNET_MODEL   — models matching claude-sonnet-*
- *   ANTHROPIC_DEFAULT_OPUS_MODEL     — models matching claude-opus-*
- *   ANTHROPIC_DEFAULT_HAIKU_MODEL    — models matching claude-haiku-*
- *   ANTHROPIC_DEFAULT_FABLE_MODEL    — models matching claude-fable / claude-mythos
- *
- * Tier-specific vars take precedence over the generic ANTHROPIC_MODEL.
- */
-function getEnv(name) {
-    const value = process.env[name]?.trim();
-    return value || undefined;
-}
-function getModelTier(model) {
-    if (/^claude-sonnet(?:-|$)/.test(model))
-        return 'sonnet';
-    if (/^claude-opus(?:-|$)/.test(model))
-        return 'opus';
-    if (/^claude-haiku(?:-|$)/.test(model))
-        return 'haiku';
-    if (/^claude-(?:fable|mythos)(?:-|$)/.test(model))
-        return 'fable';
-    return null;
-}
-const TIER_ENV_MAP = {
-    sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
-    opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
-    haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
-    fable: 'ANTHROPIC_DEFAULT_FABLE_MODEL',
-};
-/**
- * Resolve a canonical model ID to its proxy-compatible alias.
- * Returns the original model when no env override is configured.
- */
-export function remapModelId(model) {
-    if (typeof model !== 'string' || !model)
-        return model;
-    const tier = getModelTier(model);
-    if (tier) {
-        const tierModel = getEnv(TIER_ENV_MAP[tier]);
-        if (tierModel)
-            return tierModel;
-    }
-    // Generic fallback for any claude-* model
-    if (model.startsWith('claude-')) {
-        const defaultModel = getEnv('ANTHROPIC_MODEL');
-        if (defaultModel)
-            return defaultModel;
-    }
-    return model;
-}
-/**
- * Remap the `model` field in a parsed request body in place.
- * Returns true if the model was changed.
- */
-export function remapRequestBodyModel(parsed) {
-    if (typeof parsed.model !== 'string')
-        return false;
-    const remapped = remapModelId(parsed.model);
-    if (remapped === parsed.model)
-        return false;
-    parsed.model = remapped;
-    return true;
-}