@iaforged/context-code 1.3.5 → 1.3.7

package/dist/src/core/plugins/settingsCore.js

@@ -0,0 +1,43 @@
+export function resolveInitialPluginRoute(parsedCommand) {
+    switch (parsedCommand.type) {
+        case 'help':
+            return { type: 'help' };
+        case 'validate':
+            return { type: 'validate', path: parsedCommand.path };
+        case 'install':
+            if (parsedCommand.marketplace) {
+                return {
+                    type: 'browse-marketplace',
+                    targetMarketplace: parsedCommand.marketplace,
+                    targetPlugin: parsedCommand.plugin,
+                };
+            }
+            if (parsedCommand.plugin) {
+                return { type: 'discover-plugins', targetPlugin: parsedCommand.plugin };
+            }
+            return { type: 'discover-plugins' };
+        case 'manage':
+            return { type: 'manage-plugins' };
+        case 'uninstall':
+            return { type: 'manage-plugins', targetPlugin: parsedCommand.plugin, action: 'uninstall' };
+        case 'enable':
+            return { type: 'manage-plugins', targetPlugin: parsedCommand.plugin, action: 'enable' };
+        case 'disable':
+            return { type: 'manage-plugins', targetPlugin: parsedCommand.plugin, action: 'disable' };
+        case 'marketplace':
+            if (parsedCommand.action === 'list')
+                return { type: 'marketplace-list' };
+            if (parsedCommand.action === 'add')
+                return { type: 'add-marketplace', initialValue: parsedCommand.target };
+            if (parsedCommand.action === 'remove') {
+                return { type: 'manage-marketplaces', targetMarketplace: parsedCommand.target, action: 'remove' };
+            }
+            if (parsedCommand.action === 'update') {
+                return { type: 'manage-marketplaces', targetMarketplace: parsedCommand.target, action: 'update' };
+            }
+            return { type: 'marketplace-menu' };
+        case 'menu':
+        default:
+            return { type: 'discover-plugins' };
+    }
+}

package/dist/src/core/plugins/thinkbackCore.js

@@ -0,0 +1,65 @@
+import { join } from 'node:path';
+const INTERNAL_MARKETPLACE_NAME = 'context-code-marketplace';
+const INTERNAL_MARKETPLACE_REPO = 'anthropics/context-code-marketplace';
+const OFFICIAL_MARKETPLACE_NAME = 'claude-plugin-directory';
+const OFFICIAL_MARKETPLACE_REPO = 'anthropics/context-plugins-official';
+export const THINKBACK_SKILL_NAME = 'thinkback';
+export function getThinkbackMarketplaceName(userType = 'external') {
+    return userType === 'ant' ? INTERNAL_MARKETPLACE_NAME : OFFICIAL_MARKETPLACE_NAME;
+}
+export function getThinkbackMarketplaceRepo(userType = 'external') {
+    return userType === 'ant' ? INTERNAL_MARKETPLACE_REPO : OFFICIAL_MARKETPLACE_REPO;
+}
+export function getThinkbackPluginId(userType = 'external') {
+    return `thinkback@${getThinkbackMarketplaceName(userType)}`;
+}
+export function isThinkbackPluginRef(plugin, pluginId) {
+    return plugin.name === 'thinkback' || plugin.source?.includes(pluginId) === true;
+}
+export function resolveThinkbackSkillDir(enabledPlugins, pluginId) {
+    const thinkbackPlugin = enabledPlugins.find((p) => isThinkbackPluginRef(p, pluginId));
+    if (!thinkbackPlugin) {
+        return null;
+    }
+    return join(thinkbackPlugin.path, 'skills', THINKBACK_SKILL_NAME);
+}
+export function resolveThinkbackPlayerPaths(skillDir) {
+    return {
+        dataPath: join(skillDir, 'year_in_review.js'),
+        playerPath: join(skillDir, 'player.js'),
+        htmlPath: join(skillDir, 'year_in_review.html'),
+    };
+}
+export function resolveThinkbackOpenCommand(platform) {
+    if (platform === 'macos') {
+        return 'open';
+    }
+    if (platform === 'windows') {
+        return 'start';
+    }
+    return 'xdg-open';
+}
+export function resolveThinkbackInstallActions(state) {
+    if (!state.marketplaceInstalled) {
+        return {
+            installMarketplace: true,
+            refreshMarketplace: false,
+            installPlugin: true,
+            enablePlugin: false,
+        };
+    }
+    if (!state.pluginInstalled) {
+        return {
+            installMarketplace: false,
+            refreshMarketplace: true,
+            installPlugin: true,
+            enablePlugin: false,
+        };
+    }
+    return {
+        installMarketplace: false,
+        refreshMarketplace: false,
+        installPlugin: false,
+        enablePlugin: state.pluginDisabled,
+    };
+}

package/dist/src/core/plugins/thinkbackIndexCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/thinkbackIndexCliAdapter.impl.js';

package/dist/src/core/plugins/thinkbackIndexCore.js

@@ -0,0 +1,3 @@
+export function isThinkbackEnabledCore(checkFeatureGate) {
+    return checkFeatureGate('tengu_thinkback');
+}

package/dist/src/core/plugins/thinkbackPlayCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/thinkbackPlayCliAdapter.impl.js';

package/dist/src/core/plugins/thinkbackPlayCore.js

@@ -0,0 +1,21 @@
+import { join } from 'path';
+const INTERNAL_MARKETPLACE_NAME = 'claude-code-marketplace';
+const SKILL_NAME = 'thinkback';
+export function getThinkbackPlayPluginId(userType, officialMarketplaceName) {
+    const marketplaceName = userType === 'ant' ? INTERNAL_MARKETPLACE_NAME : officialMarketplaceName;
+    return `thinkback@${marketplaceName}`;
+}
+export function resolveThinkbackSkillDirFromPlugins(plugins, pluginId) {
+    const installations = plugins[pluginId];
+    if (!installations || installations.length === 0)
+        return null;
+    const firstInstall = installations[0];
+    if (!firstInstall?.installPath)
+        return null;
+    return join(firstInstall.installPath, 'skills', SKILL_NAME);
+}
+export function resolveThinkbackNotInstalledMessage(pluginId) {
+    return pluginId.includes('thinkback@')
+        ? 'Thinkback plugin not installed. Run /think-back first to install it.'
+        : 'Thinkback plugin installation path not found.';
+}

package/dist/src/core/plugins/validateCore.js

@@ -0,0 +1,38 @@
+import figures from 'figures';
+export const PLUGIN_VALIDATE_USAGE = 'Usage: /plugin validate <path>\n\n' +
+    'Validate a plugin or marketplace manifest file or directory.\n\n' +
+    'Examples:\n' +
+    '  /plugin validate .claude-plugin/plugin.json\n' +
+    '  /plugin validate /path/to/plugin-directory\n' +
+    '  /plugin validate .\n\n' +
+    'When given a directory, automatically validates .claude-plugin/marketplace.json\n' +
+    'or .claude-plugin/plugin.json (prefers marketplace if both exist).\n\n' +
+    'Or from the command line:\n' +
+    '  claude plugin validate <path>';
+export function formatValidateManifestResultCore(result, plural) {
+    let output = '';
+    output += `Validating ${result.fileType} manifest: ${result.filePath}\n\n`;
+    if (result.errors.length > 0) {
+        output += `${figures.cross} Found ${result.errors.length} ${plural(result.errors.length, 'error')}:\n\n`;
+        result.errors.forEach(error => {
+            output += `  ${figures.pointer} ${error.path}: ${error.message}\n`;
+        });
+        output += '\n';
+    }
+    if (result.warnings.length > 0) {
+        output += `${figures.warning} Found ${result.warnings.length} ${plural(result.warnings.length, 'warning')}:\n\n`;
+        result.warnings.forEach(warning => {
+            output += `  ${figures.pointer} ${warning.path}: ${warning.message}\n`;
+        });
+        output += '\n';
+    }
+    if (result.success) {
+        output +=
+            result.warnings.length > 0
+                ? `${figures.tick} Validation passed with warnings\n`
+                : `${figures.tick} Validation passed\n`;
+        return { output, exitCode: 0 };
+    }
+    output += `${figures.cross} Validation failed\n`;
+    return { output, exitCode: 1 };
+}

package/dist/src/core/providers/advisorCliAdapter.js

@@ -0,0 +1,4 @@
+export { canUserConfigureAdvisor, isValidAdvisorModel, modelSupportsAdvisor, } from '../../utils/advisor.js';
+export { getDefaultMainLoopModelSetting, normalizeModelStringForAPI, parseUserSpecifiedModel, } from '../../utils/model/model.js';
+export { validateModel } from '../../utils/model/validateModel.js';
+export { updateSettingsForSource } from '../../utils/settings/settings.js';

package/dist/src/core/providers/costCliAdapter.js

@@ -0,0 +1,3 @@
+export * from './legacy/costCliAdapter.impl.js';
+// Auto-completed re-exports
+export { isConsumerSubscriber } from '../../utils/auth.js';

package/dist/src/core/providers/effortCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/effortCliAdapter.impl.js';

package/dist/src/core/providers/effortIndexCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/effortIndexCliAdapter.impl.js';

package/dist/src/core/providers/legacy/cliAdapter.impl.js

@@ -0,0 +1,72 @@
+import { getSecureStorage } from '../../../utils/secureStorage/index.js';
+import { getVisibleProvider, VISIBLE_PROVIDERS, } from '../../../utils/model/providerCatalog.js';
+import { getActiveProviderProfile, getLastUsedProviderProfile, getProviderProfile, isProfiledProvider, listProviderProfiles, setActiveProfileForProvider, } from '../../../utils/model/providerProfiles.js';
+import { switchProviderPreference } from '../../../utils/model/providerSwitch.js';
+import { hasStoredProviderApiKey, hasStoredProviderOAuthTokens, } from '../../../utils/auth.js';
+export const cliCredentialProvider = async (provider, profileId) => {
+    const storage = getSecureStorage().read() ?? {};
+    const profile = getProviderProfile(profileId);
+    // Prefer profile-scoped credentials, then provider-level, then env.
+    const profileApiKey = storage.providerProfileApiKeys?.[profileId];
+    if (profileApiKey?.trim()) {
+        return { kind: 'api-key', token: profileApiKey.trim() };
+    }
+    const profileOauth = storage.providerProfileOauth?.[profileId]?.accessToken;
+    if (profileOauth?.trim()) {
+        return { kind: 'oauth', token: profileOauth.trim() };
+    }
+    const providerApiKey = storage.providerApiKeys?.[provider];
+    if (providerApiKey?.trim()) {
+        return { kind: 'api-key', token: providerApiKey.trim() };
+    }
+    const envKey = process.env[`${String(provider).toUpperCase().replace(/-/g, '_')}_API_KEY`];
+    if (envKey?.trim()) {
+        return { kind: 'api-key', token: envKey.trim() };
+    }
+    return { kind: 'none', token: null, baseUrl: profile?.baseUrl };
+};
+function normalizeProviderInput(rawProvider) {
+    if (!rawProvider) {
+        return undefined;
+    }
+    switch (rawProvider.trim().toLowerCase()) {
+        case 'z.ai':
+        case 'z-ai':
+            return 'zai';
+        case 'open-router':
+            return 'openrouter';
+        case 'ollama-cloud':
+        case 'ollama_cloud':
+        case 'ollamacloud':
+            return 'ollama-cloud';
+        case 'gemini':
+        case 'gemini-api-key':
+        case 'google-ai':
+        case 'google-ai-studio':
+            return 'gemini-api';
+        case 'gemini-google':
+        case 'google':
+        case 'google-oauth':
+            return 'gemini-google';
+        default:
+            return rawProvider.trim().toLowerCase();
+    }
+}
+export const cliProviderRuntime = {
+    listVisibleProviders: () => VISIBLE_PROVIDERS,
+    normalizeProviderInput,
+    getVisibleProviderLabel: (provider) => getVisibleProvider(provider).label,
+    listProviderProfiles: () => listProviderProfiles(),
+    getActiveProviderProfile: () => getActiveProviderProfile(),
+    getLastUsedProviderProfile: (provider) => getLastUsedProviderProfile(provider),
+    isProfiledProvider: (provider) => isProfiledProvider(provider),
+    setActiveProfileForProvider: (provider, profileName) => setActiveProfileForProvider(provider, profileName),
+    switchProviderPreference: (input) => switchProviderPreference({
+        currentModel: input.currentModel,
+        currentProvider: input.currentProvider,
+        targetProvider: input.targetProvider,
+        targetProfileName: input.targetProfileName,
+    }),
+    hasStoredProviderOAuthTokens,
+    hasStoredProviderApiKey: (provider, profileId) => hasStoredProviderApiKey(provider, profileId),
+};

package/dist/src/core/providers/legacy/costCliAdapter.impl.js

@@ -0,0 +1,3 @@
+import { currentLimits } from '../../../services/claudeAiLimits.js';
+import { isClaudeAISubscriber } from '../../../utils/auth.js';
+export { currentLimits, isClaudeAISubscriber };

package/dist/src/core/providers/legacy/effortCliAdapter.impl.js

@@ -0,0 +1,17 @@
+import { useMainLoopModel } from '../../../hooks/useMainLoopModel.js';
+import { logEvent, } from '../../../services/analytics/index.js';
+import { useAppState, useSetAppState } from '../../../state/AppState.js';
+import { getDisplayedEffortLevel, getEffortEnvOverride, getEffortValueDescription, isEffortLevel, toPersistableEffort, } from '../../../utils/effort.js';
+import { updateSettingsForSource } from '../../../utils/settings/settings.js';
+export const effortCliAdapter = {
+    useMainLoopModel,
+    logEvent,
+    useAppState,
+    useSetAppState,
+    getDisplayedEffortLevel,
+    getEffortEnvOverride,
+    getEffortValueDescription,
+    isEffortLevel,
+    toPersistableEffort,
+    updateSettingsForSource,
+};

package/dist/src/core/providers/legacy/effortIndexCliAdapter.impl.js

@@ -0,0 +1,2 @@
+import { shouldInferenceConfigCommandBeImmediate } from '../../../utils/immediateCommand.js';
+export { shouldInferenceConfigCommandBeImmediate };

package/dist/src/core/providers/legacy/hooks/useMainLoopModel.js

@@ -0,0 +1 @@
+export * from '../../../../hooks/useMainLoopModel.js';

package/dist/src/core/providers/legacy/limitsCliAdapter.impl.js

@@ -0,0 +1,2 @@
+import { fetchAllSnapshots } from '../../../services/limits/registry.js';
+export { fetchAllSnapshots };

package/dist/src/core/providers/legacy/modelCliAdapter.impl.js

@@ -0,0 +1,26 @@
+import { persistCoreModelForActiveProvider, } from '../modelCore.js';
+import { MODEL_ALIASES } from '../../../utils/model/aliases.js';
+import { checkOpus1mAccess, checkSonnet1mAccess } from '../../../utils/model/check1mAccess.js';
+import { isModelAllowed } from '../../../utils/model/modelAllowlist.js';
+import { isProfiledProvider, setProviderProfileLastModel } from '../../../utils/model/providerProfiles.js';
+import { setStoredLastModelForProvider } from '../../../utils/model/providerProfilesDb.js';
+import { toProviderPreference } from '../../../utils/model/providerSwitch.js';
+import { getAPIProvider } from '../../../utils/model/providers.js';
+import { validateModel } from '../../../utils/model/validateModel.js';
+import { isOpus1mMergeEnabled } from '../../../utils/model/model.js';
+export const cliModelRuntime = {
+    modelAliases: MODEL_ALIASES,
+    getCurrentApiProvider: () => getAPIProvider(),
+    toProviderPreference: provider => toProviderPreference(provider),
+    isProfiledProvider: provider => isProfiledProvider(provider),
+    setProviderProfileLastModel: (provider, model) => setProviderProfileLastModel(provider, model),
+    setStoredLastModelForProvider: (provider, model) => setStoredLastModelForProvider(provider, model),
+    isModelAllowed: model => isModelAllowed(model),
+    checkOpus1mAccess: () => checkOpus1mAccess(),
+    isOpus1mMergeEnabled: () => isOpus1mMergeEnabled(),
+    checkSonnet1mAccess: () => checkSonnet1mAccess(),
+    validateModel: model => validateModel(model),
+};
+export function persistCliModelForActiveProvider(model) {
+    persistCoreModelForActiveProvider(cliModelRuntime, model);
+}

package/dist/src/core/providers/legacy/modelCommandCliAdapter.impl.js

@@ -0,0 +1,18 @@
+import { logEvent, } from '../../../services/analytics/index.js';
+import { isBilledAsExtraUsage } from '../../../utils/extraUsage.js';
+import { useAppState, useSetAppState } from '../../../state/AppState.js';
+import { clearFastModeCooldown, isFastModeAvailable, isFastModeEnabled, isFastModeSupportedByModel, } from '../../../utils/fastMode.js';
+import { getDefaultMainLoopModelSetting, isOpus1mMergeEnabled, renderDefaultModelSetting, } from '../../../utils/model/model.js';
+export const modelCommandFlags = {
+    logEvent,
+    useAppState,
+    useSetAppState,
+    isBilledAsExtraUsage,
+    clearFastModeCooldown,
+    isFastModeAvailable,
+    isFastModeEnabled,
+    isFastModeSupportedByModel,
+    getDefaultMainLoopModelSetting,
+    isOpus1mMergeEnabled,
+    renderDefaultModelSetting,
+};

package/dist/src/core/providers/legacy/modelIndexCliAdapter.impl.js

@@ -0,0 +1,7 @@
+import { shouldInferenceConfigCommandBeImmediate } from '../../../utils/immediateCommand.js';
+import { getMainLoopModel, renderModelName } from '../../../utils/model/model.js';
+export const modelIndexFlags = {
+    shouldInferenceConfigCommandBeImmediate,
+    getMainLoopModel,
+    renderModelName,
+};

package/dist/src/core/providers/legacy/policyCliAdapter.impl.js

@@ -0,0 +1,3 @@
+import { DEFAULT_SCORING_WEIGHTS, parseSelectionPolicy, } from '../../../services/orchestration/policy/index.js';
+import { parseArguments } from '../../../utils/argumentSubstitution.js';
+export { DEFAULT_SCORING_WEIGHTS, parseArguments, parseSelectionPolicy, };

package/dist/src/core/providers/legacy/profileCliAdapter.impl.js

@@ -0,0 +1,210 @@
+import { useMainLoopModel } from '../../../hooks/useMainLoopModel.js';
+import { useSetAppState } from '../../../state/AppState.js';
+import { getAPIProvider } from '../../../utils/model/providers.js';
+import { getSecureStorage } from '../../../utils/secureStorage/index.js';
+import { finalizeProviderProfilesMigration, getProviderProfilesDbPath, getProviderProfilesStorageBackend, getProviderProfilesStorageMode, purgeLegacyProviderStateInConfig, setStoredActiveProviderPreference, } from '../../../utils/model/providerProfilesDb.js';
+import { clearAllProviderProfiles, createProviderProfile, findProviderProfileByName, getActiveProviderProfile, getLastUsedProviderProfile, getProviderProfile, isProfiledProvider, listProviderProfiles, removeProviderProfile, renameProviderProfile, setActiveProviderProfile, setProviderProfileAgentNameByName, setProviderProfileLastModelByName, } from '../../../utils/model/providerProfiles.js';
+import { fetchProviderModels } from '../../../utils/model/providerModels.js';
+import { getLegacyCredentialsFilePath, getSecureStorageDbPath, getSecureStorageKeyPath, hasLegacyCredentialsFile, isSecureStorageEncrypted, } from '../../../utils/secureStorage/sqliteStorage.js';
+import { removeAllProviderScopedCredentials, removeProviderScopedCredentials, renameProviderScopedCredentials, } from '../../../utils/auth.js';
+import { clearAuthRelatedCaches } from '../../../commands/logout/logout.js';
+import { switchProviderPreference } from '../../../utils/model/providerSwitch.js';
+export const cliProfileRuntime = {
+    normalizeProviderInput: rawProvider => normalizeProviderInput(rawProvider),
+    isProfiledProvider: provider => isProfiledProvider(provider),
+    getProviderLabel: provider => getProviderLabel(provider),
+    listProviderProfiles: provider => provider ? listProviderProfiles(provider) : listProviderProfiles(),
+    getProviderProfile: profileId => getProviderProfile(profileId),
+    getActiveProviderProfile: () => getActiveProviderProfile(),
+    getLastUsedProviderProfile: provider => getLastUsedProviderProfile(provider),
+    findProviderProfileByName: (provider, profileName) => findProviderProfileByName(provider, profileName),
+    createProviderProfile: input => createProviderProfile({
+        provider: input.provider,
+        name: input.name,
+    }),
+    renameProviderProfile: (provider, currentName, nextName) => renameProviderProfile(provider, currentName, nextName),
+    removeProviderProfile: (provider, profileName) => removeProviderProfile(provider, profileName),
+    setProviderProfileLastModelByName: (provider, profileName, model) => setProviderProfileLastModelByName(provider, profileName, model),
+    setProviderProfileAgentNameByName: (provider, profileName, agentName) => setProviderProfileAgentNameByName(provider, profileName, agentName),
+    fetchProviderModels: async (provider) => fetchProviderModels(provider),
+};
+function normalizeProviderInput(rawProvider) {
+    if (!rawProvider)
+        return undefined;
+    switch (rawProvider.trim().toLowerCase()) {
+        case 'z.ai':
+        case 'z-ai':
+            return 'zai';
+        case 'open-router':
+            return 'openrouter';
+        case 'ollama-cloud':
+        case 'ollama_cloud':
+        case 'ollamacloud':
+            return 'ollama-cloud';
+        case 'gemini':
+        case 'gemini-api-key':
+        case 'google-ai':
+            return 'gemini-api';
+        case 'gemini-google':
+        case 'google':
+        case 'google-oauth':
+            return 'gemini-google';
+        default:
+            return rawProvider.trim().toLowerCase();
+    }
+}
+function getProviderLabel(provider) {
+    switch (provider) {
+        case 'claude':
+            return 'Context';
+        case 'openai':
+            return 'OpenAI';
+        case 'openrouter':
+            return 'OpenRouter';
+        case 'ollama':
+            return 'Ollama';
+        case 'ollama-cloud':
+            return 'Ollama Cloud';
+        case 'gemini-api':
+            return 'Gemini API';
+        case 'gemini-google':
+            return 'Gemini Google';
+        case 'zai':
+            return 'Z.AI';
+        case 'minimax':
+            return 'MiniMax';
+    }
+}
+export function buildCliProfileMigrationSummaryMessage() {
+    const secureStorage = getSecureStorage();
+    try {
+        finalizeProviderProfilesMigration();
+    }
+    catch {
+        purgeLegacyProviderStateInConfig();
+    }
+    if (secureStorage.name === 'sqlite') {
+        secureStorage.read();
+    }
+    const lines = [
+        'Migracion revisada.',
+        `Persistencia providers: ${getProviderStorageModeLabel()}`,
+        `Provider DB: ${getProviderProfilesDbPath()}`,
+        `Credenciales providers: ${secureStorage.name === 'sqlite' ? 'SQLite (cifrado local)' : secureStorage.name}`,
+    ];
+    if (secureStorage.name === 'sqlite') {
+        lines.push(`Credenciales DB: ${getSecureStorageDbPath()}`);
+        lines.push(`Clave cifrado: ${getSecureStorageKeyPath()}`);
+        lines.push(`Estado cifrado credenciales: ${isSecureStorageEncrypted() ? 'Cifrado activo' : 'Sin payload o pendiente'}`);
+        lines.push(`Legacy credentials file: ${hasLegacyCredentialsFile()
+            ? `Presente (${getLegacyCredentialsFilePath()})`
+            : 'No presente'}`);
+    }
+    return lines.join('\n');
+}
+function getProviderStorageModeLabel() {
+    const backend = getProviderProfilesStorageBackend();
+    const mode = getProviderProfilesStorageMode();
+    if (backend !== 'sqlite')
+        return 'Legacy fallback';
+    return mode === 'sqlite-only' ? 'SQLite-only' : 'SQLite (migracion pendiente)';
+}
+export function reconcileCliActiveProviderProfileState() {
+    const activeProfile = getActiveProviderProfile();
+    if (activeProfile) {
+        setStoredActiveProviderPreference(activeProfile.provider);
+        return;
+    }
+    const fallbackProfile = listProviderProfiles()[0];
+    if (!fallbackProfile) {
+        setStoredActiveProviderPreference(null);
+        return;
+    }
+    setActiveProviderProfile(fallbackProfile.id);
+    setStoredActiveProviderPreference(fallbackProfile.provider);
+}
+export async function removeAllCliProfiles(onDone, context) {
+    try {
+        const removedProfiles = clearAllProviderProfiles();
+        reconcileCliActiveProviderProfileState();
+        await removeAllProviderScopedCredentials();
+        await clearAuthRelatedCaches();
+        context.onChangeAPIKey();
+        onDone(removedProfiles.length > 0
+            ? `Se eliminaron todos los perfiles guardados (${removedProfiles.length}).`
+            : 'No habia perfiles guardados para eliminar.');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onDone(`No se pudieron eliminar todos los perfiles: ${message}`);
+    }
+}
+export async function renameCliProfile(provider, currentName, nextName, context) {
+    try {
+        const renamed = renameProviderProfile(provider, currentName, nextName);
+        if (!renamed) {
+            return { ok: false, message: `No existe el perfil ${provider}/${currentName}.` };
+        }
+        await renameProviderScopedCredentials(renamed.previousId, renamed.profile.id);
+        await clearAuthRelatedCaches();
+        context.onChangeAPIKey();
+        return {
+            ok: true,
+            message: `Perfil renombrado: ${provider}/${currentName} -> ${renamed.profile.name}`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, message: `No se pudo renombrar el perfil: ${message}` };
+    }
+}
+export async function removeCliProfile(provider, profileName, context) {
+    try {
+        const removed = removeProviderProfile(provider, profileName);
+        if (!removed) {
+            return { ok: false, message: `No existe el perfil ${provider}/${profileName}.` };
+        }
+        await removeProviderScopedCredentials(removed.id);
+        reconcileCliActiveProviderProfileState();
+        await clearAuthRelatedCaches();
+        context.onChangeAPIKey();
+        return { ok: true, message: `Perfil eliminado: ${removed.provider}/${removed.name}` };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, message: `No se pudo eliminar el perfil: ${message}` };
+    }
+}
+export function findCliProviderProfileByName(provider, profileName) {
+    return findProviderProfileByName(provider, profileName);
+}
+export function createCliProviderProfile(input) {
+    return createProviderProfile(input);
+}
+export function setCliProviderProfileLastModelByName(provider, profileName, model) {
+    return setProviderProfileLastModelByName(provider, profileName, model);
+}
+export function setCliProviderProfileAgentNameByName(provider, profileName, agentName) {
+    return setProviderProfileAgentNameByName(provider, profileName, agentName);
+}
+export async function switchCliProviderProfilePreference(currentModel, provider, profileName, context) {
+    const restoredModel = switchProviderPreference({
+        currentModel,
+        currentProvider: getAPIProvider(),
+        targetProvider: provider,
+        targetProfileName: profileName,
+    });
+    await clearAuthRelatedCaches();
+    context.onChangeAPIKey();
+    const profile = getLastUsedProviderProfile(provider);
+    return {
+        restoredModel,
+        resolvedProfileName: profile?.name ?? profileName,
+    };
+}
+export function useCliMainLoopModel() {
+    return useMainLoopModel();
+}
+export function useCliSetAppState() {
+    return useSetAppState();
+}

package/dist/src/core/providers/legacy/rateLimitOptionsCliAdapter.impl.js

@@ -0,0 +1,14 @@
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../../services/analytics/growthbook.js';
+import { logEvent } from '../../../services/analytics/index.js';
+import { useClaudeAiLimits } from '../../../services/claudeAiLimitsHook.js';
+import { getOauthAccountInfo, getRateLimitTier, getSubscriptionType, } from '../../../utils/auth.js';
+import { hasClaudeAiBillingAccess } from '../../../utils/billing.js';
+export const rateLimitOptionsCliAdapter = {
+    getFeatureValue_CACHED_MAY_BE_STALE,
+    logEvent,
+    useClaudeAiLimits,
+    getOauthAccountInfo,
+    getRateLimitTier,
+    getSubscriptionType,
+    hasClaudeAiBillingAccess,
+};

package/dist/src/core/providers/legacy/state/AppState.js

@@ -0,0 +1 @@
+export * from '../../../../state/AppState.js';

package/dist/src/core/providers/legacy/utils/auth.js

@@ -0,0 +1 @@
+export * from '../../../../utils/auth.js';

package/dist/src/core/providers/legacy/utils/config.js

@@ -0,0 +1 @@
+export * from '../../../../utils/config.js';

package/dist/src/core/providers/legacy/utils/model/providerBaseUrls.js

@@ -0,0 +1 @@
+export * from '../../../../../utils/model/providerBaseUrls.js';

package/dist/src/core/providers/legacy/utils/model/providerCatalog.js

@@ -0,0 +1 @@
+export * from '../../../../../utils/model/providerCatalog.js';

package/dist/src/core/providers/legacy/utils/model/providerProfiles.js

@@ -0,0 +1 @@
+export * from '../../../../../utils/model/providerProfiles.js';

package/dist/src/core/providers/legacy/utils/model/providerProfilesDb.js

@@ -0,0 +1 @@
+export * from '../../../../../utils/model/providerProfilesDb.js';

package/dist/src/core/providers/legacy/utils/model/providerSwitch.js

@@ -0,0 +1 @@
+export * from '../../../../../utils/model/providerSwitch.js';

package/dist/src/core/providers/legacy/utils/model/providers.js

@@ -0,0 +1 @@
+export * from '../../../../../utils/model/providers.js';

package/dist/src/core/providers/legacy/utils/secureStorage/index.js

@@ -0,0 +1 @@
+export * from '../../../../../utils/secureStorage/index.js';

package/dist/src/core/providers/legacy/utils/secureStorage/sqliteStorage.js

@@ -0,0 +1 @@
+export * from '../../../../../utils/secureStorage/sqliteStorage.js';

package/dist/src/core/providers/limitsCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/limitsCliAdapter.impl.js';

package/dist/src/core/providers/modelCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/modelCliAdapter.impl.js';

package/dist/src/core/providers/modelCommandCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/modelCommandCliAdapter.impl.js';