@zhafron/opencode-kiro-auth 1.2.5 → 1.2.6

package/dist/plugin/cli.d.ts

@@ -0,0 +1,7 @@
+export declare function promptAddAnotherAccount(currentCount: number): Promise<boolean>;
+export type LoginMode = 'add' | 'fresh';
+export interface ExistingAccountInfo {
+    email?: string;
+    index: number;
+}
+export declare function promptLoginMode(existingAccounts: ExistingAccountInfo[]): Promise<LoginMode>;

package/dist/plugin/cli.js

@@ -0,0 +1,38 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+export async function promptAddAnotherAccount(currentCount) {
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question(`Add another account? (${currentCount} added) (y/n): `);
+        const normalized = answer.trim().toLowerCase();
+        return normalized === 'y' || normalized === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptLoginMode(existingAccounts) {
+    const rl = createInterface({ input, output });
+    try {
+        console.log(`\n${existingAccounts.length} account(s) saved:`);
+        for (const acc of existingAccounts) {
+            const label = acc.email || `Account ${acc.index + 1}`;
+            console.log(`  ${acc.index + 1}. ${label}`);
+        }
+        console.log('');
+        while (true) {
+            const answer = await rl.question('(a)dd new account(s) or (f)resh start? [a/f]: ');
+            const normalized = answer.trim().toLowerCase();
+            if (normalized === 'a' || normalized === 'add') {
+                return 'add';
+            }
+            if (normalized === 'f' || normalized === 'fresh') {
+                return 'fresh';
+            }
+            console.log("Please enter 'a' to add accounts or 'f' to start fresh.");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/plugin.d.ts

@@ -10,7 +10,7 @@ export declare const createKiroPlugin: (id: string) => ({ client, directory }: a
             id: string;
             label: string;
             type: string;
-            authorize: () => Promise<unknown>;
+            authorize: (inputs?: any) => Promise<unknown>;
         }[];
     };
 }>;
@@ -26,7 +26,7 @@ export declare const KiroOAuthPlugin: ({ client, directory }: any) => Promise<{
             id: string;
             label: string;
             type: string;
-            authorize: () => Promise<unknown>;
+            authorize: (inputs?: any) => Promise<unknown>;
         }[];
     };
 }>;

package/dist/plugin.js

@@ -10,6 +10,7 @@ import { fetchUsageLimits, updateAccountQuota } from './plugin/usage';
 import { authorizeKiroIDC } from './kiro/oauth-idc';
 import { startIDCAuthServer } from './plugin/server';
 import { KiroTokenRefreshError } from './plugin/errors';
+import { promptAddAnotherAccount, promptLoginMode } from './plugin/cli';
 import { KIRO_CONSTANTS } from './constants';
 import * as logger from './plugin/logger';
 const KIRO_PROVIDER_ID = 'kiro';
@@ -292,8 +293,131 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                     id: 'idc',
                     label: 'AWS Builder ID (IDC)',
                     type: 'oauth',
-                    authorize: async () => new Promise(async (resolve) => {
+                    authorize: async (inputs) => new Promise(async (resolve) => {
                         const region = config.default_region;
+                        if (inputs) {
+                            const accounts = [];
+                            let startFresh = true;
+                            const existingAm = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                            if (existingAm.getAccountCount() > 0) {
+                                const existingAccounts = existingAm.getAccounts().map((acc, idx) => ({
+                                    email: acc.realEmail || acc.email,
+                                    index: idx
+                                }));
+                                const loginMode = await promptLoginMode(existingAccounts);
+                                startFresh = loginMode === 'fresh';
+                                console.log(startFresh
+                                    ? '\nStarting fresh - existing accounts will be replaced.\n'
+                                    : '\nAdding to existing accounts.\n');
+                            }
+                            while (true) {
+                                console.log(`\n=== Kiro IDC Auth (Account ${accounts.length + 1}) ===\n`);
+                                const result = await (async () => {
+                                    try {
+                                        const authData = await authorizeKiroIDC(region);
+                                        const { url, waitForAuth } = await startIDCAuthServer(authData, config.auth_server_port_start, config.auth_server_port_range);
+                                        console.log('OAuth URL:\n' + url + '\n');
+                                        openBrowser(url);
+                                        const res = await waitForAuth();
+                                        return res;
+                                    }
+                                    catch (e) {
+                                        return { type: 'failed', error: e.message };
+                                    }
+                                })();
+                                if ('type' in result && result.type === 'failed') {
+                                    if (accounts.length === 0) {
+                                        return resolve({
+                                            url: '',
+                                            instructions: `Authentication failed: ${result.error}`,
+                                            method: 'auto',
+                                            callback: async () => ({ type: 'failed' })
+                                        });
+                                    }
+                                    console.warn(`[opencode-kiro-auth] Skipping failed account ${accounts.length + 1}: ${result.error}`);
+                                    break;
+                                }
+                                const successResult = result;
+                                accounts.push(successResult);
+                                const isFirstAccount = accounts.length === 1;
+                                const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                if (isFirstAccount && startFresh) {
+                                    am.getAccounts().forEach((acc) => am.removeAccount(acc));
+                                }
+                                const acc = {
+                                    id: generateAccountId(),
+                                    email: successResult.email,
+                                    authMethod: 'idc',
+                                    region,
+                                    clientId: successResult.clientId,
+                                    clientSecret: successResult.clientSecret,
+                                    refreshToken: successResult.refreshToken,
+                                    accessToken: successResult.accessToken,
+                                    expiresAt: successResult.expiresAt,
+                                    rateLimitResetTime: 0,
+                                    isHealthy: true
+                                };
+                                try {
+                                    const u = await fetchUsageLimits({
+                                        refresh: encodeRefreshToken({
+                                            refreshToken: successResult.refreshToken,
+                                            clientId: successResult.clientId,
+                                            clientSecret: successResult.clientSecret,
+                                            authMethod: 'idc'
+                                        }),
+                                        access: successResult.accessToken,
+                                        expires: successResult.expiresAt,
+                                        authMethod: 'idc',
+                                        region,
+                                        clientId: successResult.clientId,
+                                        clientSecret: successResult.clientSecret,
+                                        email: successResult.email
+                                    });
+                                    am.updateUsage(acc.id, {
+                                        usedCount: u.usedCount,
+                                        limitCount: u.limitCount,
+                                        realEmail: u.email
+                                    });
+                                }
+                                catch (e) {
+                                    logger.warn(`Initial usage fetch failed: ${e.message}`, e);
+                                }
+                                am.addAccount(acc);
+                                await am.saveToDisk();
+                                showToast(`Account ${accounts.length} authenticated${successResult.email ? ` (${successResult.email})` : ''}`, 'success');
+                                let currentAccountCount = accounts.length;
+                                try {
+                                    const currentStorage = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                    currentAccountCount = currentStorage.getAccountCount();
+                                }
+                                catch { }
+                                const addAnother = await promptAddAnotherAccount(currentAccountCount);
+                                if (!addAnother) {
+                                    break;
+                                }
+                            }
+                            const primary = accounts[0];
+                            if (!primary) {
+                                return resolve({
+                                    url: '',
+                                    instructions: 'Authentication cancelled',
+                                    method: 'auto',
+                                    callback: async () => ({ type: 'failed' })
+                                });
+                            }
+                            let actualAccountCount = accounts.length;
+                            try {
+                                const finalStorage = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                actualAccountCount = finalStorage.getAccountCount();
+                            }
+                            catch { }
+                            return resolve({
+                                url: '',
+                                instructions: `Multi-account setup complete (${actualAccountCount} account(s)).`,
+                                method: 'auto',
+                                callback: async () => ({ type: 'success', key: primary.accessToken })
+                            });
+                        }
                         try {
                             const authData = await authorizeKiroIDC(region);
                             const { url, waitForAuth } = await startIDCAuthServer(authData, config.auth_server_port_start, config.auth_server_port_range);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhafron/opencode-kiro-auth",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",