@zhafron/opencode-kiro-auth 1.5.0 → 1.5.1

package/README.md

@@ -102,8 +102,8 @@ The plugin supports extensive configuration options. Edit `~/.config/opencode/ki
   "default_region": "us-east-1",
   "rate_limit_retry_delay_ms": 5000,
   "rate_limit_max_retries": 3,
-  "max_request_iterations": 100,
-  "request_timeout_ms": 300000,
+  "max_request_iterations": 20,
+  "request_timeout_ms": 120000,
   "token_expiry_buffer_ms": 120000,
   "usage_sync_max_retries": 3,
   "auth_server_port_start": 19847,

package/dist/core/account/account-selector.d.ts

@@ -12,10 +12,14 @@ export declare class AccountSelector {
     private syncFromKiroCli;
     private repository;
     private triedEmptySync;
+    private circuitBreakerTrips;
+    private lastCircuitBreakerReset;
     constructor(accountManager: AccountManager, config: AccountSelectorConfig, syncFromKiroCli: () => Promise<void>, repository: AccountRepository);
     selectHealthyAccount(showToast: ToastFunction): Promise<ManagedAccount | null>;
     private handleEmptyAccounts;
     private formatUsageMessage;
+    private checkCircuitBreaker;
+    private resetCircuitBreaker;
     private sleep;
 }
 export {};

package/dist/core/account/account-selector.js

@@ -4,6 +4,8 @@ export class AccountSelector {
     syncFromKiroCli;
     repository;
     triedEmptySync = false;
+    circuitBreakerTrips = 0;
+    lastCircuitBreakerReset = Date.now();
     constructor(accountManager, config, syncFromKiroCli, repository) {
         this.accountManager = accountManager;
         this.config = config;
@@ -11,6 +13,7 @@ export class AccountSelector {
         this.repository = repository;
     }
     async selectHealthyAccount(showToast) {
+        this.checkCircuitBreaker();
         let count = this.accountManager.getAccountCount();
         if (count === 0 && this.config.auto_sync_kiro_cli && !this.triedEmptySync) {
             this.triedEmptySync = true;
@@ -22,6 +25,7 @@ export class AccountSelector {
         }
         let acc = this.accountManager.getCurrentOrNext();
         if (!acc) {
+            this.circuitBreakerTrips++;
             const wait = this.accountManager.getMinWaitTime();
             if (wait > 0 && wait < 30000) {
                 if (this.accountManager.shouldShowToast()) {
@@ -32,6 +36,7 @@ export class AccountSelector {
             }
             throw new Error('All accounts are unhealthy or rate-limited');
         }
+        this.resetCircuitBreaker();
         if (this.accountManager.shouldShowToast()) {
             showToast(`Using ${acc.email} (${this.accountManager.getAccounts().indexOf(acc) + 1}/${count})`, 'info');
         }
@@ -58,6 +63,21 @@ export class AccountSelector {
         }
         return `Usage (${email}): ${usedCount}`;
     }
+    checkCircuitBreaker() {
+        if (Date.now() - this.lastCircuitBreakerReset > 60000) {
+            this.circuitBreakerTrips = 0;
+            this.lastCircuitBreakerReset = Date.now();
+        }
+        if (this.circuitBreakerTrips >= 10) {
+            throw new Error('Circuit breaker tripped: Too many consecutive failures selecting accounts');
+        }
+    }
+    resetCircuitBreaker() {
+        if (this.circuitBreakerTrips > 0) {
+            this.circuitBreakerTrips = 0;
+            this.lastCircuitBreakerReset = Date.now();
+        }
+    }
     sleep(ms) {
         return new Promise((r) => setTimeout(r, ms));
     }

package/dist/core/auth/idc-auth-method.js

@@ -39,33 +39,39 @@ export class IdcAuthMethod {
     async handleMultipleLogin(region, resolve) {
         const accounts = [];
         let startFresh = true;
-        const existingAccounts = await this.repository.findAll();
-        const idcAccs = existingAccounts.filter((a) => a.authMethod === 'idc');
-        if (idcAccs.length > 0) {
+        while (true) {
+            const existingAccounts = await this.repository.findAll();
+            const idcAccs = existingAccounts.filter((a) => a.authMethod === 'idc');
+            if (idcAccs.length === 0) {
+                break;
+            }
             const existingAccountsList = idcAccs.map((acc, idx) => ({
                 email: acc.email,
                 index: idx
             }));
             const mode = await promptLoginMode(existingAccountsList);
             if (mode === 'delete') {
-                const deleteIndex = await promptDeleteAccount(existingAccountsList);
-                if (deleteIndex !== null && idcAccs[deleteIndex]) {
-                    const accToDelete = idcAccs[deleteIndex];
-                    await this.repository.delete(accToDelete.id);
-                    console.log(`\n[Success] Deleted: ${accToDelete.email}\n`);
+                const deleteIndices = await promptDeleteAccount(existingAccountsList);
+                if (deleteIndices !== null && deleteIndices.length > 0) {
+                    for (const idx of deleteIndices) {
+                        const accToDelete = idcAccs[idx];
+                        if (accToDelete) {
+                            await this.repository.delete(accToDelete.id);
+                            console.log(`[Success] Deleted: ${accToDelete.email}`);
+                        }
+                    }
+                    console.log(`\n[Success] Deleted ${deleteIndices.length} account(s)\n`);
                 }
-                const finalAccounts = await this.repository.findAll();
-                return resolve({
-                    url: '',
-                    instructions: `Complete (${finalAccounts.length} accounts).`,
-                    method: 'auto',
-                    callback: async () => ({
-                        type: 'success',
-                        key: finalAccounts[0]?.accessToken || ''
-                    })
-                });
+                continue;
+            }
+            if (mode === 'add') {
+                startFresh = false;
+                break;
+            }
+            if (mode === 'fresh') {
+                startFresh = true;
+                break;
             }
-            startFresh = mode === 'fresh';
         }
         while (true) {
             try {

package/dist/core/request/error-handler.d.ts

@@ -8,6 +8,7 @@ interface RequestContext {
 }
 interface ErrorHandlerConfig {
     rate_limit_max_retries: number;
+    rate_limit_retry_delay_ms: number;
 }
 export declare class ErrorHandler {
     private config;

package/dist/core/request/error-handler.js

@@ -94,7 +94,7 @@ export class ErrorHandler {
     }
     async handleNetworkError(error, context, showToast) {
         if (this.isNetworkError(error) && context.retry < this.config.rate_limit_max_retries) {
-            const d = 5000 * Math.pow(2, context.retry);
+            const d = this.config.rate_limit_retry_delay_ms * Math.pow(2, context.retry);
             showToast(`Network error. Retrying in ${Math.ceil(d / 1000)}s...`, 'warning');
             await this.sleep(d);
             return {

package/dist/core/request/request-handler.d.ts

@@ -21,5 +21,7 @@ export declare class RequestHandler {
     private logRequest;
     private logResponse;
     private logError;
+    private allAccountsPermanentlyUnhealthy;
+    private sleep;
 }
 export {};

package/dist/core/request/request-handler.js

@@ -28,7 +28,7 @@ export class RequestHandler {
         this.errorHandler = new ErrorHandler(config, accountManager, repository);
         this.responseHandler = new ResponseHandler();
         this.usageTracker = new UsageTracker(config, accountManager, repository);
-        this.retryStrategy = new RetryStrategy(config, config.max_request_iterations, config.request_timeout_ms);
+        this.retryStrategy = new RetryStrategy(config);
     }
     async handle(input, init, showToast) {
         const url = typeof input === 'string' ? input : input.url;
@@ -44,20 +44,29 @@ export class RequestHandler {
         const budget = body.providerOptions?.thinkingConfig?.thinkingBudget || 20000;
         let reductionFactor = 1.0;
         let retry = 0;
+        let consecutiveNullAccounts = 0;
         const retryContext = this.retryStrategy.createContext();
         while (true) {
             const check = this.retryStrategy.shouldContinue(retryContext);
             if (!check.canContinue) {
                 throw new Error(check.error);
             }
+            if (this.allAccountsPermanentlyUnhealthy()) {
+                throw new Error('All accounts are permanently unhealthy (quota exceeded or suspended)');
+            }
             let acc = await this.accountSelector.selectHealthyAccount(showToast);
             if (!acc) {
+                consecutiveNullAccounts++;
+                const backoffDelay = Math.min(1000 * Math.pow(2, consecutiveNullAccounts - 1), 10000);
+                await this.sleep(backoffDelay);
                 continue;
             }
+            consecutiveNullAccounts = 0;
             const auth = this.accountManager.toAuthDetails(acc);
             const tokenResult = await this.tokenRefresher.refreshIfNeeded(acc, auth, showToast);
             if (tokenResult.shouldContinue) {
                 acc = tokenResult.account;
+                await this.sleep(500);
                 continue;
             }
             const prep = this.prepareRequest(url, init?.body, model, auth, think, budget, reductionFactor);
@@ -177,4 +186,14 @@ export class RequestHandler {
             }, rData, logger.getTimestamp());
         }
     }
+    allAccountsPermanentlyUnhealthy() {
+        const accounts = this.accountManager.getAccounts();
+        if (accounts.length === 0) {
+            return false;
+        }
+        return accounts.every((acc) => !acc.isHealthy && isPermanentError(acc.unhealthyReason));
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
 }

package/dist/core/request/retry-strategy.d.ts

@@ -8,9 +8,7 @@ interface RetryContext {
 }
 export declare class RetryStrategy {
     private config;
-    private maxIterations;
-    private timeoutMs;
-    constructor(config: RetryConfig, maxIterations: number, timeoutMs: number);
+    constructor(config: RetryConfig);
     shouldContinue(context: RetryContext): {
         canContinue: boolean;
         error?: string;

package/dist/core/request/retry-strategy.js

@@ -1,21 +1,17 @@
 export class RetryStrategy {
     config;
-    maxIterations;
-    timeoutMs;
-    constructor(config, maxIterations, timeoutMs) {
+    constructor(config) {
         this.config = config;
-        this.maxIterations = maxIterations;
-        this.timeoutMs = timeoutMs;
     }
     shouldContinue(context) {
         context.iterations++;
-        if (context.iterations > this.maxIterations) {
+        if (context.iterations > this.config.max_request_iterations) {
             return {
                 canContinue: false,
-                error: `Exceeded max iterations (${this.maxIterations})`
+                error: `Exceeded max iterations (${this.config.max_request_iterations})`
             };
         }
-        if (Date.now() - context.startTime > this.timeoutMs) {
+        if (Date.now() - context.startTime > this.config.request_timeout_ms) {
             return {
                 canContinue: false,
                 error: 'Request timeout'

package/dist/plugin/cli.d.ts

@@ -1,5 +1,5 @@
 export declare function promptAddAnotherAccount(currentCount: number): Promise<boolean>;
-export declare function promptDeleteAccount(accounts: ExistingAccountInfo[]): Promise<number | null>;
+export declare function promptDeleteAccount(accounts: ExistingAccountInfo[]): Promise<number[] | null>;
 export type LoginMode = 'add' | 'fresh' | 'delete';
 export interface ExistingAccountInfo {
     email?: string;

package/dist/plugin/cli.js

@@ -14,7 +14,7 @@ export async function promptAddAnotherAccount(currentCount) {
 export async function promptDeleteAccount(accounts) {
     const rl = createInterface({ input, output });
     try {
-        console.log(`\nSelect account to delete:`);
+        console.log(`\nSelect account(s) to delete:`);
         for (const acc of accounts) {
             const label = acc.email || `Account ${acc.index + 1}`;
             console.log(`  ${acc.index + 1}. ${label}`);
@@ -22,22 +22,51 @@ export async function promptDeleteAccount(accounts) {
         console.log(`  0. Cancel`);
         console.log('');
         while (true) {
-            const answer = await rl.question('Enter account number: ');
-            const num = parseInt(answer.trim(), 10);
-            if (num === 0) {
+            const answer = await rl.question('Enter account number(s) (e.g., 1,2,3 or 1): ');
+            const trimmed = answer.trim();
+            if (trimmed === '0') {
                 return null;
             }
-            if (num >= 1 && num <= accounts.length) {
-                const selected = accounts[num - 1];
-                const label = selected?.email || `Account ${num}`;
-                const confirm = await rl.question(`Delete "${label}"? (y/n): `);
-                const normalized = confirm.trim().toLowerCase();
-                if (normalized === 'y' || normalized === 'yes') {
-                    return selected?.index ?? null;
+            const parts = trimmed.split(',').map((s) => s.trim());
+            const numbers = [];
+            let invalid = false;
+            for (const part of parts) {
+                const num = parseInt(part, 10);
+                if (isNaN(num) || num < 1 || num > accounts.length) {
+                    invalid = true;
+                    break;
                 }
-                return null;
+                if (!numbers.includes(num)) {
+                    numbers.push(num);
+                }
+            }
+            if (invalid) {
+                console.log(`Please enter valid numbers between 1 and ${accounts.length}, separated by commas`);
+                continue;
+            }
+            if (numbers.length === 0) {
+                console.log(`Please enter at least one account number`);
+                continue;
+            }
+            const indices = numbers.map((n) => n - 1);
+            const selectedAccounts = indices
+                .map((i) => accounts[i])
+                .filter((acc) => acc !== undefined);
+            if (selectedAccounts.length === 0) {
+                console.log(`No valid accounts selected`);
+                continue;
+            }
+            console.log(`\nYou are about to delete ${selectedAccounts.length} account(s):`);
+            for (const acc of selectedAccounts) {
+                const label = acc.email || `Account ${acc.index + 1}`;
+                console.log(`  - ${label}`);
+            }
+            const confirm = await rl.question(`\nConfirm deletion? (y/n): `);
+            const normalized = confirm.trim().toLowerCase();
+            if (normalized === 'y' || normalized === 'yes') {
+                return selectedAccounts.map((acc) => acc.index);
             }
-            console.log(`Please enter a number between 0 and ${accounts.length}`);
+            return null;
         }
     }
     finally {

package/dist/plugin/config/schema.js

@@ -7,8 +7,8 @@ export const KiroConfigSchema = z.object({
     default_region: RegionSchema.default('us-east-1'),
     rate_limit_retry_delay_ms: z.number().min(1000).max(60000).default(5000),
     rate_limit_max_retries: z.number().min(0).max(10).default(3),
-    max_request_iterations: z.number().min(10).max(1000).default(100),
-    request_timeout_ms: z.number().min(60000).max(600000).default(300000),
+    max_request_iterations: z.number().min(5).max(1000).default(20),
+    request_timeout_ms: z.number().min(30000).max(600000).default(120000),
     token_expiry_buffer_ms: z.number().min(30000).max(300000).default(120000),
     usage_sync_max_retries: z.number().min(0).max(5).default(3),
     auth_server_port_start: z.number().min(1024).max(65535).default(19847),
@@ -22,8 +22,8 @@ export const DEFAULT_CONFIG = {
     default_region: 'us-east-1',
     rate_limit_retry_delay_ms: 5000,
     rate_limit_max_retries: 3,
-    max_request_iterations: 100,
-    request_timeout_ms: 300000,
+    max_request_iterations: 20,
+    request_timeout_ms: 120000,
     token_expiry_buffer_ms: 120000,
     usage_sync_max_retries: 3,
     auth_server_port_start: 19847,

package/package.json

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