@zhafron/opencode-kiro-auth 1.2.4 → 1.2.6

package/README.md

@@ -3,7 +3,7 @@
 [![npm downloads](https://img.shields.io/npm/dm/@zhafron/opencode-kiro-auth)](https://www.npmjs.com/package/@zhafron/opencode-kiro-auth)
 [![license](https://img.shields.io/npm/l/@zhafron/opencode-kiro-auth)](https://www.npmjs.com/package/@zhafron/opencode-kiro-auth)
 
-OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to the latest Claude 3.5/4.5 models with substantial trial quotas.
+OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude Sonnet and Haiku models with substantial trial quotas.
 
 ## Features
 
@@ -26,30 +26,15 @@ Add the plugin to your `opencode.json` or `opencode.jsonc`:
   "provider": {
     "kiro": {
       "models": {
-        "claude-opus-4-5": {
-          "name": "Claude Opus 4.5",
-          "limit": { "context": 200000, "output": 64000 },
-          "modalities": { "input": ["text", "image"], "output": ["text"] }
-        },
-        "claude-opus-4-5-thinking": {
-          "name": "Claude Opus 4.5 Thinking",
-          "limit": { "context": 200000, "output": 64000 },
-          "modalities": { "input": ["text", "image"], "output": ["text"] },
-          "variants": {
-            "low": { "thinkingConfig": { "thinkingBudget": 8192 } },
-            "medium": { "thinkingConfig": { "thinkingBudget": 16384 } },
-            "max": { "thinkingConfig": { "thinkingBudget": 32768 } }
-          }
-        },
         "claude-sonnet-4-5": {
           "name": "Claude Sonnet 4.5",
           "limit": { "context": 200000, "output": 64000 },
-          "modalities": { "input": ["text", "image"], "output": ["text"] }
+          "modalities": { "input": ["text", "image", "pdf"], "output": ["text"] }
         },
         "claude-sonnet-4-5-thinking": {
           "name": "Claude Sonnet 4.5 Thinking",
           "limit": { "context": 200000, "output": 64000 },
-          "modalities": { "input": ["text", "image"], "output": ["text"] },
+          "modalities": { "input": ["text", "image", "pdf"], "output": ["text"] },
           "variants": {
             "low": { "thinkingConfig": { "thinkingBudget": 8192 } },
             "medium": { "thinkingConfig": { "thinkingBudget": 16384 } },

package/dist/constants.js

@@ -40,9 +40,6 @@ export const KIRO_CONSTANTS = {
     ORIGIN_AI_EDITOR: 'AI_EDITOR'
 };
 export const MODEL_MAPPING = {
-    'claude-opus-4-5': 'claude-opus-4.5',
-    'claude-opus-4-5-thinking': 'claude-opus-4.5',
-    'claude-opus-4-5-20251101': 'claude-opus-4.5',
     'claude-haiku-4-5': 'claude-haiku-4.5',
     'claude-sonnet-4-5': 'CLAUDE_SONNET_4_5_20250929_V1_0',
     'claude-sonnet-4-5-thinking': 'CLAUDE_SONNET_4_5_20250929_V1_0',

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';
@@ -56,7 +57,7 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                         if (!KIRO_API_PATTERN.test(url))
                             return fetch(input, init);
                         const body = init?.body ? JSON.parse(init.body) : {};
-                        const model = extractModel(url) || body.model || 'claude-opus-4-5';
+                        const model = extractModel(url) || body.model || 'claude-sonnet-4-5';
                         const think = model.endsWith('-thinking') || !!body.providerOptions?.thinkingConfig;
                         const budget = body.providerOptions?.thinkingConfig?.thinkingBudget || 20000;
                         let retry = 0;
@@ -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.4",
+  "version": "1.2.6",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",