dexto 1.6.12 → 1.6.13

package/dist/cli/commands/setup.js

@@ -2,7 +2,7 @@
 import chalk from 'chalk';
 import { z } from 'zod';
 import open from 'open';
-import { acceptsAnyModel, getDefaultModelForProvider, getCuratedModelsForProvider, getReasoningProfile, getSupportedModels, LLM_PROVIDERS, LLM_REGISTRY, logger, isValidProviderModel, supportsCustomModels, requiresApiKey, resolveApiKeyForProvider, } from '@dexto/core';
+import { acceptsAnyModel, CodexAppServerClient, createCodexBaseURL, getDefaultModelForProvider, getCodexAuthModeLabel, getCodexProviderDisplayName, getCuratedModelsForProvider, getReasoningProfile, getSupportedModels, isCodexBaseURL, LLM_PROVIDERS, LLM_REGISTRY, logger, parseCodexBaseURL, isValidProviderModel, supportsCustomModels, requiresApiKey, resolveApiKeyForProvider, } from '@dexto/core';
 import { createInitialPreferences, saveGlobalPreferences, loadGlobalPreferences, getGlobalPreferencesPath, updateGlobalPreferences, setActiveModel, isDextoAuthEnabled, loadCustomModels, saveCustomModel, deleteCustomModel, globalPreferencesExist, } from '@dexto/agent-management';
 import { interactiveApiKeySetup, hasApiKeyConfigured } from '../utils/api-key-setup.js';
 import { selectProvider, getProviderDisplayName, getProviderEnvVar, providerRequiresBaseURL, getDefaultModel, } from '../utils/provider-setup.js';
@@ -408,6 +408,218 @@ async function handleQuickStart(options = { onCancel: 'exit' }) {
         return 'completed';
     }
 }
+function getConfiguredProviderDisplayName(provider, baseURL) {
+    if (provider === 'openai-compatible') {
+        const codex = parseCodexBaseURL(baseURL);
+        if (codex) {
+            return getCodexProviderDisplayName(codex.authMode);
+        }
+    }
+    return getProviderDisplayName(provider);
+}
+function isCodexConfigured(provider, baseURL) {
+    return provider === 'openai-compatible' && isCodexBaseURL(baseURL);
+}
+async function ensureCodexChatGPTLogin(client) {
+    const spinner = p.spinner();
+    spinner.start('Starting ChatGPT login with Codex...');
+    const login = await client.startLogin({ type: 'chatgpt' });
+    if (login.type !== 'chatgpt') {
+        spinner.stop('ChatGPT login failed');
+        throw new Error('Codex did not return a ChatGPT login URL');
+    }
+    spinner.stop('ChatGPT login ready');
+    try {
+        await open(login.authUrl);
+        p.log.success('Opened your browser for ChatGPT login');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        p.log.warn(`Could not open browser automatically: ${errorMessage}`);
+    }
+    p.note(`Finish the ChatGPT login in your browser.\n\n${chalk.dim(login.authUrl)}`, 'ChatGPT Login');
+    const waitSpinner = p.spinner();
+    waitSpinner.start('Waiting for ChatGPT login to complete...');
+    const completed = await client.waitForLoginCompleted(login.loginId, {
+        timeoutMs: 5 * 60 * 1000,
+    });
+    if (!completed.success) {
+        waitSpinner.stop('ChatGPT login failed');
+        throw new Error(completed.error ?? 'Codex ChatGPT login failed');
+    }
+    waitSpinner.stop('ChatGPT login complete');
+    return await client.readAccount(true);
+}
+async function ensureCodexChatGPTSession(client) {
+    const current = await client.readAccount(false);
+    if (current.account?.type === 'chatgpt') {
+        return current;
+    }
+    if (current.account) {
+        const currentLabel = 'OpenAI API key';
+        const shouldSwitch = await p.confirm({
+            message: `Codex is currently using ${currentLabel}. Switch to ChatGPT login?`,
+            initialValue: true,
+        });
+        if (p.isCancel(shouldSwitch) || !shouldSwitch) {
+            return null;
+        }
+        await client.logout();
+    }
+    return await ensureCodexChatGPTLogin(client);
+}
+function getCodexModelOptions(models) {
+    const visibleModels = models.filter((model) => !model.hidden);
+    const defaultModel = visibleModels.find((model) => model.isDefault) ?? visibleModels[0] ?? null;
+    if (!defaultModel) {
+        return [];
+    }
+    const secondaryModels = visibleModels
+        .filter((model) => model.model !== defaultModel.model)
+        .slice(0, 9);
+    return [
+        {
+            value: defaultModel.model,
+            label: defaultModel.displayName,
+            hint: `${defaultModel.description || 'Recommended'} (recommended)`,
+        },
+        ...secondaryModels.map((model) => ({
+            value: model.model,
+            label: model.displayName,
+            hint: model.description || model.model,
+        })),
+    ];
+}
+/**
+ * ChatGPT Login setup flow - authenticate with ChatGPT through Codex, choose a model, save preferences
+ *
+ * Config storage:
+ * - provider: 'openai-compatible'
+ * - baseURL: special 'codex://chatgpt' URI resolved at runtime to Codex app-server
+ * - model: model ID returned by Codex model/list
+ */
+async function handleCodexProviderSetup(options = {}) {
+    const exitOnCancel = options.exitOnCancel ?? true;
+    const abort = (message, exitCode = 0) => {
+        p.cancel(message);
+        if (exitOnCancel) {
+            process.exit(exitCode);
+        }
+        return false;
+    };
+    console.log(chalk.cyan('\nChatGPT Login Setup\n'));
+    let client = null;
+    try {
+        client = await CodexAppServerClient.create();
+        const account = await ensureCodexChatGPTSession(client);
+        if (!account || account.account?.type !== 'chatgpt') {
+            return abort('Setup cancelled');
+        }
+        p.log.success(`Codex authenticated with ChatGPT as ${account.account.email} (${account.account.planType})`);
+        const models = await client.listModels();
+        const modelOptions = getCodexModelOptions(models);
+        if (modelOptions.length === 0) {
+            p.log.error('Codex did not return any available models.');
+            return abort('Setup cancelled', 1);
+        }
+        const model = await p.select({
+            message: 'Select a model to start with',
+            options: modelOptions,
+        });
+        if (p.isCancel(model)) {
+            return abort('Setup cancelled');
+        }
+        const selectedModel = model;
+        const provider = 'openai-compatible';
+        const baseURL = createCodexBaseURL('chatgpt');
+        const codexReasoningProfile = getReasoningProfile(provider, selectedModel);
+        let reasoningPreset;
+        if (codexReasoningProfile.capable) {
+            const selectedReasoning = await p.select({
+                message: 'Select reasoning variant',
+                options: getReasoningVariantSelectOptions(codexReasoningProfile.supportedVariants, codexReasoningProfile.defaultVariant),
+                ...(codexReasoningProfile.defaultVariant
+                    ? { initialValue: codexReasoningProfile.defaultVariant }
+                    : {}),
+            });
+            if (p.isCancel(selectedReasoning)) {
+                return abort('Setup cancelled');
+            }
+            if (selectedReasoning !== codexReasoningProfile.defaultVariant) {
+                reasoningPreset = selectedReasoning;
+            }
+        }
+        const defaultMode = await selectDefaultMode();
+        if (defaultMode === null) {
+            return abort('Setup cancelled');
+        }
+        const preferences = createInitialPreferences({
+            provider,
+            model: selectedModel,
+            baseURL,
+            defaultMode,
+            setupCompleted: true,
+            apiKeyPending: false,
+            ...(reasoningPreset ? { reasoning: { variant: reasoningPreset } } : {}),
+        });
+        await saveGlobalPreferences(preferences);
+        capture('dexto_setup', {
+            provider,
+            model: selectedModel,
+            setupMode: 'interactive',
+            setupVariant: 'codex-chatgpt',
+            defaultMode,
+            hasBaseURL: true,
+        });
+        await showSetupComplete(provider, selectedModel, defaultMode, false, {
+            providerLabel: getCodexProviderDisplayName('chatgpt'),
+            authLabel: getCodexAuthModeLabel('chatgpt'),
+            baseURL,
+        });
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        p.log.error(`ChatGPT Login setup failed: ${errorMessage}`);
+        return abort('Setup cancelled', 1);
+    }
+    finally {
+        if (client) {
+            await client.close().catch(() => undefined);
+        }
+    }
+}
+async function handleCodexChatGPTLoginRefresh(options = {}) {
+    const exitOnCancel = options.exitOnCancel ?? true;
+    const abort = (message, exitCode = 0) => {
+        p.cancel(message);
+        if (exitOnCancel) {
+            process.exit(exitCode);
+        }
+        return false;
+    };
+    console.log(chalk.cyan('\nChatGPT Login\n'));
+    let client = null;
+    try {
+        client = await CodexAppServerClient.create();
+        const account = await ensureCodexChatGPTSession(client);
+        if (!account || account.account?.type !== 'chatgpt') {
+            return abort('ChatGPT login cancelled');
+        }
+        p.log.success(`Codex authenticated with ChatGPT as ${account.account.email} (${account.account.planType})`);
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        p.log.error(`ChatGPT Login failed: ${errorMessage}`);
+        return abort('ChatGPT login cancelled', 1);
+    }
+    finally {
+        if (client) {
+            await client.close().catch(() => undefined);
+        }
+    }
+}
 /**
  * Dexto setup flow - login if needed, select model, save preferences
  *
@@ -615,7 +827,7 @@ async function getCreditsBalance() {
  * Users can go back to previous steps to change their selections.
  */
 async function handleInteractiveSetup(_options) {
-    console.log(chalk.cyan('\n🗿 Dexto Nova Setup\n'));
+    console.log(chalk.cyan('\nDexto Setup\n'));
     p.intro(chalk.cyan("Let's configure your AI agent"));
     // Initialize wizard state
     let state = { step: 'setupType' };
@@ -662,12 +874,16 @@ async function wizardStepSetupType(state) {
         });
     }
     options.push({
+        value: 'openai-codex',
+        label: `${chalk.green('●')} ChatGPT Login`,
+        hint: 'Use your ChatGPT account through Codex',
+    }, {
         value: 'quick',
-        label: `${chalk.green('●')} Quick Start`,
+        label: `${chalk.blue('●')} Quick Start`,
         hint: 'Google Gemini (free) - no account needed',
     }, {
         value: 'custom',
-        label: `${chalk.blue('●')} Custom Setup`,
+        label: `${chalk.cyan('●')} Custom Setup`,
         hint: 'Choose your provider (OpenAI, Anthropic, Ollama, etc.)',
     });
     const setupType = await p.select({
@@ -683,6 +899,13 @@ async function wizardStepSetupType(state) {
         await handleDextoProviderSetup();
         return { ...state, step: 'complete', quickStartHandled: true };
     }
+    if (setupType === 'openai-codex') {
+        const completed = await handleCodexProviderSetup({ exitOnCancel: false });
+        if (!completed) {
+            return { ...state, step: 'setupType' };
+        }
+        return { ...state, step: 'complete', quickStartHandled: true };
+    }
     if (setupType === 'quick') {
         // Quick start bypasses the wizard - handle it directly
         const result = await handleQuickStart({ onCancel: 'back' });
@@ -1289,7 +1512,17 @@ async function saveWizardPreferences(state) {
         hasBaseURL: Boolean(state.baseURL),
         apiKeySkipped,
     });
-    await showSetupComplete(provider, model, defaultMode, apiKeySkipped);
+    const codex = parseCodexBaseURL(state.baseURL);
+    const codexSetupOptions = codex && typeof state.baseURL === 'string'
+        ? {
+            providerLabel: getCodexProviderDisplayName(codex.authMode),
+            authLabel: getCodexAuthModeLabel(codex.authMode),
+            baseURL: state.baseURL,
+        }
+        : {};
+    await showSetupComplete(provider, model, defaultMode, apiKeySkipped, {
+        ...codexSetupOptions,
+    });
 }
 /**
  * Non-interactive setup with CLI options
@@ -1352,10 +1585,14 @@ async function showSettingsMenu() {
         }
         // Show current configuration
         if (currentPrefs) {
+            const codex = parseCodexBaseURL(currentPrefs.llm.baseURL);
             const currentConfig = [
-                `Provider: ${chalk.cyan(getProviderDisplayName(currentPrefs.llm.provider))}`,
+                `Provider: ${chalk.cyan(getConfiguredProviderDisplayName(currentPrefs.llm.provider, currentPrefs.llm.baseURL))}`,
                 `Model: ${chalk.cyan(currentPrefs.llm.model)}`,
                 `Default Mode: ${chalk.cyan(currentPrefs.defaults.defaultMode)}`,
+                ...(codex
+                    ? [`Authentication: ${chalk.cyan(getCodexAuthModeLabel(codex.authMode))}`]
+                    : []),
                 ...(currentPrefs.llm.baseURL
                     ? [`Base URL: ${chalk.cyan(currentPrefs.llm.baseURL)}`]
                     : []),
@@ -1370,8 +1607,15 @@ async function showSettingsMenu() {
             ].join('\n');
             p.note(currentConfig, 'Current Configuration');
         }
-        const currentProviderLabel = currentPrefs?.llm.provider ?? 'not set';
+        const currentProviderLabel = currentPrefs
+            ? getConfiguredProviderDisplayName(currentPrefs.llm.provider, currentPrefs.llm.baseURL)
+            : 'not set';
         const currentModelLabel = currentPrefs?.llm.model || 'not set';
+        const currentCodex = currentPrefs ? parseCodexBaseURL(currentPrefs.llm.baseURL) : null;
+        const authActionLabel = currentCodex ? 'Manage ChatGPT login' : 'Update API key';
+        const authActionHint = currentCodex
+            ? 'Verify or reconnect your ChatGPT login for Codex'
+            : 'Re-enter your API key';
         const options = [
             {
                 value: 'model',
@@ -1384,9 +1628,9 @@ async function showSettingsMenu() {
                 hint: `Currently: ${currentPrefs?.defaults.defaultMode || 'web'}`,
             },
             {
-                value: 'apikey',
-                label: 'Update API key',
-                hint: 'Re-enter your API key',
+                value: 'auth',
+                label: authActionLabel,
+                hint: authActionHint,
             },
             {
                 value: 'reset',
@@ -1431,8 +1675,8 @@ async function showSettingsMenu() {
             case 'credits':
                 await openCreditsPage();
                 break;
-            case 'apikey':
-                await updateApiKey(currentPrefs?.llm.provider);
+            case 'auth':
+                await updateApiKey(currentPrefs?.llm.provider, currentPrefs?.llm.baseURL);
                 break;
             case 'reset': {
                 // Reset exits the menu after completion, but returns to menu if cancelled
@@ -1453,25 +1697,37 @@ async function showSettingsMenu() {
 /**
  * Change model setting (includes provider selection)
  */
-async function changeModel(currentProvider) {
+async function changeModel(currentProvider, currentBaseURL) {
     let provider = currentProvider ?? null;
+    if (isCodexConfigured(provider ?? undefined, currentBaseURL)) {
+        const completed = await handleCodexProviderSetup({ exitOnCancel: false });
+        if (!completed) {
+            p.log.warn('Model change cancelled');
+        }
+        return;
+    }
     // If no provider specified, show selection
-    // When Dexto auth is enabled, show Dexto/Other choice first (matching first-time setup flow)
-    if (!provider && isDextoAuthEnabled()) {
+    if (!provider) {
+        const sourceOptions = [];
+        if (isDextoAuthEnabled()) {
+            sourceOptions.push({
+                value: 'dexto-nova',
+                label: `${chalk.magenta('★')} Dexto Nova`,
+                hint: 'All models, one account',
+            });
+        }
+        sourceOptions.push({
+            value: 'openai-codex',
+            label: `${chalk.green('●')} ChatGPT Login`,
+            hint: 'Use your ChatGPT account through Codex',
+        }, {
+            value: 'other',
+            label: `${chalk.blue('●')} Other providers`,
+            hint: 'OpenAI, Anthropic, Gemini, Ollama, etc.',
+        });
         const providerChoice = await p.select({
             message: 'Choose your model source',
-            options: [
-                {
-                    value: 'dexto-nova',
-                    label: `${chalk.magenta('★')} Dexto Nova`,
-                    hint: 'All models, one account',
-                },
-                {
-                    value: 'other',
-                    label: `${chalk.blue('●')} Other providers`,
-                    hint: 'OpenAI, Anthropic, Gemini, Ollama, etc.',
-                },
-            ],
+            options: sourceOptions,
         });
         if (p.isCancel(providerChoice)) {
             p.log.warn('Model change cancelled');
@@ -1485,6 +1741,13 @@ async function changeModel(currentProvider) {
             }
             return;
         }
+        if (providerChoice === 'openai-codex') {
+            const completed = await handleCodexProviderSetup({ exitOnCancel: false });
+            if (!completed) {
+                return;
+            }
+            return;
+        }
         // 'other' - fall through to normal provider selection
     }
     // Get provider if not already set
@@ -1618,15 +1881,22 @@ async function changeDefaultMode() {
     p.log.success(`Default mode changed to ${mode}`);
 }
 /**
- * Update API key for current provider
+ * Update authentication for current provider
  */
-async function updateApiKey(currentProvider) {
+async function updateApiKey(currentProvider, currentBaseURL) {
     const provider = currentProvider || (await selectProvider());
     // Handle cancellation or back from selectProvider
     if (provider === null || provider === '_back') {
         p.log.warn('API key update cancelled');
         return;
     }
+    if (isCodexConfigured(provider, currentBaseURL)) {
+        const completed = await handleCodexChatGPTLoginRefresh({ exitOnCancel: false });
+        if (!completed) {
+            p.log.warn('ChatGPT login update cancelled');
+        }
+        return;
+    }
     // Handle providers that use non-API-key authentication
     if (provider === 'vertex') {
         p.note(`Google Vertex AI uses Application Default Credentials (ADC).\n\n` +
@@ -1907,9 +2177,10 @@ async function promptForBaseURL(provider) {
 /**
  * Show setup complete message
  */
-async function showSetupComplete(provider, model, defaultMode, apiKeySkipped = false) {
+async function showSetupComplete(provider, model, defaultMode, apiKeySkipped = false, options = {}) {
     const modeCommand = defaultMode === 'web' ? 'dexto' : `dexto --mode ${defaultMode}`;
     const isLocalProvider = provider === 'local' || provider === 'ollama';
+    const providerLabel = options.providerLabel ?? getConfiguredProviderDisplayName(provider, options.baseURL);
     if (apiKeySkipped) {
         console.log(chalk.rgb(255, 165, 0)('\n⚠️  Setup complete (API key pending)\n'));
     }
@@ -1918,9 +2189,11 @@ async function showSetupComplete(provider, model, defaultMode, apiKeySkipped = f
     }
     const summary = [
         `${chalk.bold('Configuration:')}`,
-        `  Provider: ${chalk.cyan(getProviderDisplayName(provider))}`,
+        `  Provider: ${chalk.cyan(providerLabel)}`,
         `  Model: ${chalk.cyan(model)}`,
         `  Mode: ${chalk.cyan(defaultMode)}`,
+        ...(options.authLabel ? [`  Authentication: ${chalk.cyan(options.authLabel)}`] : []),
+        ...(options.baseURL ? [`  Base URL: ${chalk.cyan(options.baseURL)}`] : []),
         ...(apiKeySkipped
             ? [
                 `  API Key: ${chalk.rgb(255, 165, 0)('Not configured')}`,

package/dist/cli/commands/uninstall.d.ts

@@ -1,18 +1,15 @@
 import { z } from 'zod';
-declare const UninstallCommandSchema: z.ZodObject<{
-    agents: z.ZodArray<z.ZodString, "many">;
-    all: z.ZodDefault<z.ZodBoolean>;
-    force: z.ZodDefault<z.ZodBoolean>;
+declare const UninstallCliCommandSchema: z.ZodObject<{
+    purge: z.ZodDefault<z.ZodBoolean>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    agents: string[];
-    force: boolean;
-    all: boolean;
+    dryRun: boolean;
+    purge: boolean;
 }, {
-    agents: string[];
-    force?: boolean | undefined;
-    all?: boolean | undefined;
+    dryRun?: boolean | undefined;
+    purge?: boolean | undefined;
 }>;
-export type UninstallCommandOptions = z.output<typeof UninstallCommandSchema>;
-export declare function handleUninstallCommand(agents: string[], options: Partial<UninstallCommandOptions>): Promise<void>;
+export type UninstallCliCommandOptions = z.output<typeof UninstallCliCommandSchema>;
+export declare function handleUninstallCliCommand(options: Partial<UninstallCliCommandOptions>): Promise<void>;
 export {};
 //# sourceMappingURL=uninstall.d.ts.map

package/dist/cli/commands/uninstall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uninstall.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/uninstall.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,QAAA,MAAM,sBAAsB;;;;;;;;;;;;EAMf,CAAC;AAEd,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AA+B9E,wBAAsB,sBAAsB,CACxC,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAC1C,OAAO,CAAC,IAAI,CAAC,CA8Gf"}
+{"version":3,"file":"uninstall.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/uninstall.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,QAAA,MAAM,yBAAyB;;;;;;;;;EAKlB,CAAC;AAEd,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAoDpF,wBAAsB,yBAAyB,CAC3C,OAAO,EAAE,OAAO,CAAC,0BAA0B,CAAC,GAC7C,OAAO,CAAC,IAAI,CAAC,CAgFf"}