indusagi-coding-agent 0.1.14 → 0.1.21

package/dist/modes/interactive/interactive-mode.js

@@ -37,6 +37,7 @@ import { ExtensionSelectorComponent } from "./components/extension-selector.js";
 import { FooterComponent } from "./components/footer.js";
 import { appKey, editorKey } from "./components/keybinding-hints.js";
 import { LoginDialogComponent } from "./components/login-dialog.js";
+import { AccountSelectorComponent } from "./components/oauth-selector.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
 import { OAuthSelectorComponent } from "./components/oauth-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
@@ -3010,6 +3011,14 @@ export class InteractiveMode {
             const selector = new OAuthSelectorComponent(mode, this.session.modelRegistry.authStorage, async (selection) => {
                 done();
                 if (mode === "login") {
+                    // Check if provider has existing accounts
+                    const accounts = this.session.modelRegistry.authStorage.getAccounts(selection.id);
+                    if (accounts.length >= 1) {
+                        // Show account selector for providers with existing accounts
+                        // This allows switching between accounts or adding new ones
+                        await this.showAccountSelector(selection.id, selection.name, accounts);
+                        return;
+                    }
                     if (selection.kind === "oauth") {
                         await this.showLoginDialog(selection.id);
                         return;
@@ -3048,6 +3057,198 @@ export class InteractiveMode {
             return { component: selector, focus: selector };
         });
     }
+    /**
+     * Show account selector for providers with multiple accounts
+     */
+    async showAccountSelector(providerId, providerName, accounts) {
+        this.showSelector((done) => {
+            const selector = new AccountSelectorComponent(providerName, accounts, (accountId) => {
+                // Select existing account
+                done();
+                this.session.modelRegistry.authStorage.setDefaultAccount(providerId, accountId);
+                this.showStatus(`Switched to account: ${accountId}`);
+            }, () => {
+                // Cancel
+                done();
+                this.ui.requestRender();
+            }, async () => {
+                // Add new account - prompt for account name first
+                done();
+                await this.showNewAccountNameDialog(providerId, providerName);
+            });
+            return { component: selector, focus: selector };
+        });
+    }
+    /**
+     * Prompt for account name, then proceed with OAuth or API key login
+     */
+    async showNewAccountNameDialog(providerId, providerName) {
+        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => {
+            // Completion handled below
+        }, `Add new account for ${providerName}`);
+        // Show dialog in editor container
+        this.editorContainer.clear();
+        this.editorContainer.addChild(dialog);
+        this.ui.setFocus(dialog);
+        this.ui.requestRender();
+        const restoreEditor = () => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        try {
+            // Prompt for account name
+            const accountName = await dialog.showPrompt(`Enter a name for this account (e.g., 'work', 'personal'):`, "my-account");
+            const trimmedName = accountName.trim();
+            if (!trimmedName) {
+                restoreEditor();
+                this.showWarning("Account name cannot be empty.");
+                return;
+            }
+            // Check if account name already exists
+            const existingAccounts = this.session.modelRegistry.authStorage.getAccounts(providerId);
+            if (existingAccounts.some(a => a.accountId === trimmedName || a.credential.accountName === trimmedName)) {
+                restoreEditor();
+                this.showWarning(`Account '${trimmedName}' already exists for ${providerName}.`);
+                return;
+            }
+            restoreEditor();
+            // Determine if OAuth or API key provider
+            const oauthProviders = getOAuthProviders();
+            const isOAuth = oauthProviders.some((p) => p.id === providerId);
+            if (isOAuth) {
+                // Proceed with OAuth login using the account name
+                await this.showLoginDialogWithAccountName(providerId, trimmedName);
+            }
+            else {
+                // For API key providers, prompt for the key
+                await this.showApiKeyInputDialogWithName(providerId, providerName, trimmedName);
+            }
+        }
+        catch (error) {
+            restoreEditor();
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (errorMsg !== "Login cancelled") {
+                this.showError(`Failed to add account: ${errorMsg}`);
+            }
+        }
+    }
+    /**
+     * OAuth login with a specific account name
+     */
+    async showLoginDialogWithAccountName(providerId, accountName) {
+        const providerInfo = getOAuthProviders().find((p) => p.id === providerId);
+        const providerName = providerInfo?.name || providerId;
+        const usesCallbackServer = providerInfo?.usesCallbackServer ?? false;
+        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => {
+            // Completion handled below
+        }, `Login to ${providerName} (${accountName})`);
+        this.editorContainer.clear();
+        this.editorContainer.addChild(dialog);
+        this.ui.setFocus(dialog);
+        this.ui.requestRender();
+        let manualCodeResolve;
+        let manualCodeReject;
+        const manualCodePromise = new Promise((resolve, reject) => {
+            manualCodeResolve = resolve;
+            manualCodeReject = reject;
+        });
+        const restoreEditor = () => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        try {
+            await this.session.modelRegistry.authStorage.login(providerId, {
+                onAuth: (info) => {
+                    dialog.showAuth(info.url, info.instructions);
+                    if (usesCallbackServer) {
+                        dialog
+                            .showManualInput("Paste redirect URL below, or complete login in browser:")
+                            .then((value) => {
+                            if (value && manualCodeResolve) {
+                                manualCodeResolve(value);
+                                manualCodeResolve = undefined;
+                            }
+                        })
+                            .catch(() => {
+                            if (manualCodeReject) {
+                                manualCodeReject(new Error("Login cancelled"));
+                                manualCodeReject = undefined;
+                            }
+                        });
+                    }
+                    else if (providerId === "github-copilot") {
+                        dialog.showWaiting("Waiting for browser authentication...");
+                    }
+                },
+                onPrompt: async (prompt) => {
+                    return dialog.showPrompt(prompt.message, prompt.placeholder);
+                },
+                onProgress: (message) => {
+                    dialog.showProgress(message);
+                },
+                onManualCodeInput: () => manualCodePromise,
+                signal: dialog.signal,
+            }, accountName, // Pass the account name
+            accountName);
+            restoreEditor();
+            this.session.modelRegistry.refresh();
+            await this.updateAvailableProviderCount();
+            this.showStatus(`Logged in to ${providerName} as '${accountName}'. Credentials saved to ${getAuthPath()}`);
+        }
+        catch (error) {
+            restoreEditor();
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (errorMsg !== "Login cancelled") {
+                this.showError(`Failed to login to ${providerName}: ${errorMsg}`);
+            }
+        }
+    }
+    /**
+     * API key input with a specific account name
+     */
+    async showApiKeyInputDialogWithName(providerId, providerName, accountName) {
+        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => { }, `Add API key for ${providerName} (${accountName})`);
+        this.editorContainer.clear();
+        this.editorContainer.addChild(dialog);
+        this.ui.setFocus(dialog);
+        this.ui.requestRender();
+        const restoreEditor = () => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        try {
+            const apiKey = await dialog.showPrompt(`Enter API key for ${providerName} (${accountName}):`, "sk-...");
+            const trimmedKey = apiKey.trim();
+            if (!trimmedKey) {
+                restoreEditor();
+                this.showWarning("API key cannot be empty.");
+                return;
+            }
+            this.session.modelRegistry.authStorage.set(providerId, accountName, {
+                type: "api_key",
+                key: trimmedKey,
+                accountId: accountName,
+                accountName: accountName,
+            });
+            this.session.modelRegistry.refresh();
+            await this.updateAvailableProviderCount();
+            restoreEditor();
+            this.showStatus(`Saved API key for ${providerName}/${accountName}. Credentials saved to ${getAuthPath()}`);
+        }
+        catch (error) {
+            restoreEditor();
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (errorMsg !== "Login cancelled") {
+                this.showError(`Failed to save API key: ${errorMsg}`);
+            }
+        }
+    }
     async showLoginDialog(providerId) {
         const providerInfo = getOAuthProviders().find((p) => p.id === providerId);
         const providerName = providerInfo?.name || providerId;
@@ -3150,7 +3351,7 @@ export class InteractiveMode {
                 this.showWarning("API key cannot be empty.");
                 return;
             }
-            this.session.modelRegistry.authStorage.set(selection.id, { type: "api_key", key: trimmedKey });
+            this.session.modelRegistry.authStorage.set(selection.id, "default", { type: "api_key", key: trimmedKey });
             this.session.modelRegistry.refresh();
             await this.updateAvailableProviderCount();
             restoreEditor();
@@ -3165,6 +3366,69 @@ export class InteractiveMode {
             }
         }
     }
+    /**
+     * Show API key input dialog for adding a new account
+     */
+    async showApiKeyInputDialog(providerId, providerName) {
+        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => {
+            // Completion handled below
+        }, `Add new account for ${providerName}`);
+        // Show dialog in editor container
+        this.editorContainer.clear();
+        this.editorContainer.addChild(dialog);
+        this.ui.setFocus(dialog);
+        this.ui.requestRender();
+        const restoreEditor = () => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        try {
+            // Prompt for account name
+            const accountName = await dialog.showPrompt(`Enter a name for this account (e.g., 'work', 'personal'):`, "my-account");
+            const trimmedName = accountName.trim();
+            if (!trimmedName) {
+                restoreEditor();
+                this.showWarning("Account name cannot be empty.");
+                return;
+            }
+            // Check if account name already exists
+            const existingAccounts = this.session.modelRegistry.authStorage.getAccounts(providerId);
+            if (existingAccounts.some(a => (a.credential.accountName || a.accountId) === trimmedName)) {
+                restoreEditor();
+                this.showWarning(`Account '${trimmedName}' already exists for ${providerName}.`);
+                return;
+            }
+            // Prompt for API key
+            dialog.showProgress(`Enter API key for account '${trimmedName}':`);
+            const apiKey = await dialog.showPrompt(`Enter API key for ${providerName} (${trimmedName}):`, "sk-...");
+            const trimmedKey = apiKey.trim();
+            if (!trimmedKey) {
+                restoreEditor();
+                this.showWarning("API key cannot be empty.");
+                return;
+            }
+            this.session.modelRegistry.authStorage.set(providerId, trimmedName, {
+                type: "api_key",
+                key: trimmedKey,
+                accountId: trimmedName,
+                accountName: trimmedName,
+            });
+            this.session.modelRegistry.refresh();
+            await this.updateAvailableProviderCount();
+            restoreEditor();
+            this.showStatus(`Saved API key for ${providerName}/${trimmedName}. Credentials saved to ${getAuthPath()}`);
+            this.showModelSelector();
+        }
+        catch (error) {
+            restoreEditor();
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (errorMsg !== "Login cancelled") {
+                this.showError(`Failed to save API key for ${providerName}: ${errorMsg}`);
+            }
+        }
+    }
     // =========================================================================
     // Command handlers
     // =========================================================================