@sunerpy/opencode-kiro-auth 0.14.2 → 0.15.1

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

@@ -1,6 +1,7 @@
 import { RegionSchema } from '../../plugin/config/schema.js';
 import { isRefreshTokenDead } from '../../plugin/health.js';
 import * as logger from '../../plugin/logger.js';
+import { PLUGIN_VERSION } from '../../version.js';
 import { IdcAuthMethod } from './idc-auth-method.js';
 import { isInteractiveTty, ttyConfirm, ttySelect } from './tty-menu.js';
 export class AuthHandler {
@@ -91,7 +92,7 @@ export class AuthHandler {
         }
         const currentAccounts = this.accountManager.getAccounts?.() ?? [];
         const usageSummary = this.buildUsageSummary(currentAccounts);
-        const firstLabelBase = 'Add account · AWS Builder ID / IAM Identity Center';
+        const firstLabelBase = `Add account · AWS Builder ID / IAM Identity Center · plugin v${PLUGIN_VERSION}`;
         const firstLabel = usageSummary ? `${firstLabelBase}  ${usageSummary}` : firstLabelBase;
         const idcMethod = new IdcAuthMethod(this.config, this.repository, this.accountManager);
         const configStartUrl = this.config.idc_start_url;

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

@@ -14,6 +14,7 @@ import { RetryStrategy } from './retry-strategy.js';
 import { SdkEventStreamIterationError, UpstreamUnexpectedError } from './stream-error.js';
 const KIRO_API_PATTERN = /^(https?:\/\/)?q\.[a-z0-9-]+\.amazonaws\.com/;
 const REAUTH_FAILURE_COOLDOWN_MS = 60000;
+const MAX_STREAM_ATTEMPTS = 3;
 function describeError(error, depth = 0) {
     if (!(error instanceof Error))
         return String(error);
@@ -182,6 +183,18 @@ export class RequestHandler {
                     continue;
                 }
                 const sdkPrep = this.prepareSdkRequest(init?.body, model, auth, think, budget, showToast);
+                const streamAttempt = streamFailureCount + 1;
+                const streamLogDetails = (details = {}) => ({
+                    conversationId: sdkPrep.conversationId,
+                    model,
+                    effectiveModel: sdkPrep.effectiveModel,
+                    region: sdkPrep.region,
+                    account: acc.email,
+                    accountId: acc.id,
+                    streamAttempt,
+                    maxStreamAttempts: MAX_STREAM_ATTEMPTS,
+                    ...details
+                });
                 if (this.config.enable_log_effort_debug) {
                     try {
                         logger.log('[effort-debug] request effort resolution', {
@@ -231,6 +244,7 @@ export class RequestHandler {
                     if (this.config.sdk_response_timeout_enabled) {
                         const messageContext = sdkPrep.conversationState.currentMessage?.userInputMessage?.userInputMessageContext;
                         beginUpstreamWait('SDK response', this.config.sdk_response_timeout_ms, {
+                            conversationId: sdkPrep.conversationId,
                             model,
                             effectiveModel: sdkPrep.effectiveModel,
                             effort: sdkPrep.effort,
@@ -261,6 +275,7 @@ export class RequestHandler {
                             if (!this.config.stream_event_timeout_enabled)
                                 return;
                             beginUpstreamWait('stream event', this.config.request_timeout_ms, {
+                                conversationId: sdkPrep.conversationId,
                                 model,
                                 effectiveModel: sdkPrep.effectiveModel,
                                 region: sdkPrep.region,
@@ -268,20 +283,32 @@ export class RequestHandler {
                             });
                         },
                         onUpstreamWaitEnd: endUpstreamWait,
-                        onIterationError: (error, afterCompletionMetadata) => logger.warn('Kiro SDK event stream iteration failed', {
-                            model,
-                            effectiveModel: sdkPrep.effectiveModel,
-                            region: sdkPrep.region,
-                            platform: process.platform,
-                            afterCompletionMetadata,
-                            recovered: afterCompletionMetadata,
-                            error: describeError(error)
-                        }),
+                        onIterationError: (error, afterCompletionMetadata) => {
+                            if (!afterCompletionMetadata)
+                                return;
+                            logger.log('Kiro SDK event stream closed after completion metadata', streamLogDetails({
+                                outcome: 'ignored_after_completion_metadata',
+                                platform: process.platform,
+                                afterCompletionMetadata,
+                                error: describeError(error)
+                            }));
+                        },
                         onComplete: completeRequest,
                         onTerminal: cleanupRequest,
                         onCancel: (reason) => requestController.abort(reason),
-                        mapError: (error) => new UpstreamUnexpectedError(error, true)
+                        mapError: (error) => {
+                            logger.error('Kiro SDK event stream iteration failed', streamLogDetails({
+                                outcome: 'terminated_after_output',
+                                platform: process.platform,
+                                emittedOutput: true,
+                                error: describeError(error)
+                            }));
+                            return new UpstreamUnexpectedError(error, true);
+                        }
                     });
+                    if (streamFailureCount > 0) {
+                        logger.log('Kiro SDK event stream retry recovered', streamLogDetails({ outcome: 'recovered', attempts: streamAttempt }));
+                    }
                     if (sdkPrep.streaming) {
                         responseOwnsLifecycle = true;
                     }
@@ -296,9 +323,17 @@ export class RequestHandler {
                     if (e instanceof SdkEventStreamIterationError) {
                         streamFailureCount++;
                         const streamError = new UpstreamUnexpectedError(e, false);
-                        if (streamFailureCount >= 3)
+                        if (streamFailureCount >= MAX_STREAM_ATTEMPTS) {
+                            logger.error('Kiro SDK event stream iteration failed', streamLogDetails({
+                                outcome: 'exhausted',
+                                platform: process.platform,
+                                attempts: streamFailureCount,
+                                error: describeError(e)
+                            }));
                             return streamError.toResponse();
-                        await this.sleep(this.getStreamRetryDelay(streamFailureCount), signal);
+                        }
+                        const delayMs = this.getStreamRetryDelay(streamFailureCount);
+                        await this.sleep(delayMs, signal);
                         if (streamFailureCount === 1) {
                             forcedStreamAccount = acc;
                         }
@@ -306,6 +341,14 @@ export class RequestHandler {
                             forcedStreamAccount =
                                 (await this.accountSelector.selectAlternativeAccount(new Set([acc.id]))) ?? acc;
                         }
+                        logger.warn('Kiro SDK event stream iteration failed', streamLogDetails({
+                            outcome: 'retrying',
+                            platform: process.platform,
+                            nextAttempt: streamFailureCount + 1,
+                            delayMs,
+                            nextAccount: forcedStreamAccount.email,
+                            error: describeError(e)
+                        }));
                         continue;
                     }
                     if (sendResolved)

package/dist/plugin/storage/locked-operations.js

@@ -15,14 +15,12 @@ const DATABASE_LOCK_MIN_BACKOFF_MS = 25;
 const DATABASE_LOCK_MAX_BACKOFF_MS = 250;
 const REFRESH_LOCK_OPTIONS = {
     stale: 15000,
-    retries: {
-        retries: 10,
-        minTimeout: 100,
-        maxTimeout: 1000,
-        factor: 2
-    },
+    retries: 0,
     realpath: false
 };
+const REFRESH_LOCK_DEADLINE_MS = 15000;
+const REFRESH_LOCK_MIN_BACKOFF_MS = 25;
+const REFRESH_LOCK_MAX_BACKOFF_MS = 250;
 const KEEP_ALIVE_LOCK_OPTIONS = {
     stale: 120000,
     retries: 0,
@@ -36,8 +34,8 @@ function blockingBackoff(ms) {
 function isLockContention(e) {
     return typeof e === 'object' && e !== null && 'code' in e && e.code === 'ELOCKED';
 }
-function asyncBackoff(attempt, remainingMs) {
-    const ceiling = Math.min(DATABASE_LOCK_MIN_BACKOFF_MS * 2 ** Math.min(attempt, 4), DATABASE_LOCK_MAX_BACKOFF_MS, remainingMs);
+function asyncBackoff(attempt, remainingMs, minBackoffMs, maxBackoffMs) {
+    const ceiling = Math.min(minBackoffMs * 2 ** Math.min(attempt, 4), maxBackoffMs, remainingMs);
     const floor = Math.max(1, Math.floor(ceiling / 2));
     const delay = floor + Math.floor(Math.random() * (ceiling - floor + 1));
     return new Promise((resolve) => setTimeout(resolve, delay));
@@ -55,7 +53,24 @@ async function acquireDatabaseLock(dbPath) {
             const remainingMs = deadline - Date.now();
             if (!isLockContention(e) || remainingMs <= 0)
                 throw e;
-            await asyncBackoff(attempt++, remainingMs);
+            await asyncBackoff(attempt++, remainingMs, DATABASE_LOCK_MIN_BACKOFF_MS, DATABASE_LOCK_MAX_BACKOFF_MS);
+        }
+    }
+}
+async function acquireRefreshLock(lockPath) {
+    // A deadline avoids fixed retry-count starvation; jitter keeps contenders
+    // from repeatedly attempting the atomic mkdir in lockstep.
+    const deadline = Date.now() + REFRESH_LOCK_DEADLINE_MS;
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await lockfile.lock(lockPath, REFRESH_LOCK_OPTIONS);
+        }
+        catch (e) {
+            const remainingMs = deadline - Date.now();
+            if (!isLockContention(e) || remainingMs <= 0)
+                throw e;
+            await asyncBackoff(attempt++, remainingMs, REFRESH_LOCK_MIN_BACKOFF_MS, REFRESH_LOCK_MAX_BACKOFF_MS);
         }
     }
 }
@@ -121,7 +136,7 @@ export async function withRefreshLock(accountId, fn) {
     }
     let release = null;
     try {
-        release = await lockfile.lock(lockPath, REFRESH_LOCK_OPTIONS);
+        release = await acquireRefreshLock(lockPath);
         return await fn();
     }
     finally {

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_VERSION: string;

package/dist/version.js

@@ -0,0 +1,14 @@
+import { readFileSync } from 'node:fs';
+function readPluginVersion() {
+    try {
+        const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        if (typeof packageJson.version === 'string' && packageJson.version.trim()) {
+            return packageJson.version;
+        }
+    }
+    catch {
+        // Keep authentication available if package metadata cannot be read.
+    }
+    return 'unknown';
+}
+export const PLUGIN_VERSION = readPluginVersion();

package/package.json

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