@sunerpy/opencode-kiro-auth 0.13.5 → 0.13.7

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

@@ -75,12 +75,26 @@ export class RequestHandler {
         else
             inboundSignal?.addEventListener('abort', abortFromInbound, { once: true });
         let timeout;
-        const beginUpstreamWait = (phase, timeoutMs) => {
+        const beginUpstreamWait = (phase, timeoutMs, details = {}) => {
             if (requestController.signal.aborted)
                 return;
             if (timeout)
                 clearDeadlineTimeout(timeout);
-            timeout = setDeadlineTimeout(() => requestController.abort(new DOMException(`Kiro request timed out waiting for ${phase}`, 'TimeoutError')), timeoutMs);
+            if (timeoutMs <= 0) {
+                timeout = undefined;
+                return;
+            }
+            const startedAt = Date.now();
+            timeout = setDeadlineTimeout(() => {
+                logger.warn('Kiro upstream wait timed out', {
+                    phase,
+                    configuredTimeoutMs: timeoutMs,
+                    elapsedMs: Date.now() - startedAt,
+                    platform: process.platform,
+                    ...details
+                });
+                requestController.abort(new DOMException(`Kiro request timed out waiting for ${phase}`, 'TimeoutError'));
+            }, timeoutMs);
         };
         const endUpstreamWait = () => {
             if (!timeout)
@@ -201,7 +215,17 @@ export class RequestHandler {
                         await this.usageTracker.syncUsage(acc, auth, isCurrentAttempt);
                     };
                     let sdkResponse;
-                    beginUpstreamWait('SDK response', this.config.sdk_response_timeout_ms);
+                    if (this.config.sdk_response_timeout_enabled) {
+                        const messageContext = sdkPrep.conversationState.currentMessage?.userInputMessage?.userInputMessageContext;
+                        beginUpstreamWait('SDK response', this.config.sdk_response_timeout_ms, {
+                            model,
+                            effectiveModel: sdkPrep.effectiveModel,
+                            effort: sdkPrep.effort,
+                            region: sdkPrep.region,
+                            historyLength: sdkPrep.conversationState.history?.length ?? 0,
+                            toolCount: messageContext?.tools?.length ?? 0
+                        });
+                    }
                     try {
                         sdkResponse = await client.send(command, { abortSignal: signal });
                     }
@@ -214,7 +238,11 @@ export class RequestHandler {
                     }
                     const response = await this.responseHandler.handleSdkSuccess(sdkResponse, model, sdkPrep.conversationId, sdkPrep.streaming, {
                         signal,
-                        onUpstreamWaitStart: () => beginUpstreamWait('stream event', this.config.request_timeout_ms),
+                        onUpstreamWaitStart: () => beginUpstreamWait('stream event', this.config.request_timeout_ms, {
+                            model,
+                            effectiveModel: sdkPrep.effectiveModel,
+                            region: sdkPrep.region
+                        }),
                         onUpstreamWaitEnd: endUpstreamWait,
                         onComplete: completeRequest,
                         onTerminal: cleanupRequest,

package/dist/plugin/config/loader.js

@@ -135,6 +135,7 @@ function applyEnvOverrides(config) {
         rate_limit_retry_delay_ms: parseNumberEnv(env.KIRO_RATE_LIMIT_RETRY_DELAY_MS, config.rate_limit_retry_delay_ms),
         rate_limit_max_retries: parseNumberEnv(env.KIRO_RATE_LIMIT_MAX_RETRIES, config.rate_limit_max_retries),
         max_request_iterations: parseNumberEnv(env.KIRO_MAX_REQUEST_ITERATIONS, config.max_request_iterations),
+        sdk_response_timeout_enabled: parseBooleanEnv(env.KIRO_SDK_RESPONSE_TIMEOUT_ENABLED, config.sdk_response_timeout_enabled),
         sdk_response_timeout_ms: parseNumberEnv(env.KIRO_SDK_RESPONSE_TIMEOUT_MS, config.sdk_response_timeout_ms),
         request_timeout_ms: parseNumberEnv(env.KIRO_REQUEST_TIMEOUT_MS, config.request_timeout_ms),
         token_expiry_buffer_ms: parseNumberEnv(env.KIRO_TOKEN_EXPIRY_BUFFER_MS, config.token_expiry_buffer_ms),

package/dist/plugin/config/schema.d.ts

@@ -55,10 +55,15 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
     rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
     max_request_iterations: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Opt into a fixed deadline while waiting for client.send() to return.
+     * Disabled by default because a pending request is ambiguous: Kiro may
+     * still be performing a valid long-running generation.
+     */
+    sdk_response_timeout_enabled: z.ZodDefault<z.ZodBoolean>;
     /**
      * Maximum wait for client.send() to return the initial SDK response.
-     * High-effort models can legitimately take several minutes before the
-     * event stream becomes available.
+     * Only used when sdk_response_timeout_enabled is true.
      */
     sdk_response_timeout_ms: z.ZodDefault<z.ZodNumber>;
     /**
@@ -113,6 +118,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: number;
     rate_limit_max_retries: number;
     max_request_iterations: number;
+    sdk_response_timeout_enabled: boolean;
     sdk_response_timeout_ms: number;
     request_timeout_ms: number;
     token_expiry_buffer_ms: number;
@@ -147,6 +153,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms?: number | undefined;
     rate_limit_max_retries?: number | undefined;
     max_request_iterations?: number | undefined;
+    sdk_response_timeout_enabled?: boolean | undefined;
     sdk_response_timeout_ms?: number | undefined;
     request_timeout_ms?: number | undefined;
     token_expiry_buffer_ms?: number | undefined;

package/dist/plugin/config/schema.js

@@ -87,10 +87,15 @@ export const KiroConfigSchema = z.object({
     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(5).max(1000).default(20),
+    /**
+     * Opt into a fixed deadline while waiting for client.send() to return.
+     * Disabled by default because a pending request is ambiguous: Kiro may
+     * still be performing a valid long-running generation.
+     */
+    sdk_response_timeout_enabled: z.boolean().default(false),
     /**
      * Maximum wait for client.send() to return the initial SDK response.
-     * High-effort models can legitimately take several minutes before the
-     * event stream becomes available.
+     * Only used when sdk_response_timeout_enabled is true.
      */
     sdk_response_timeout_ms: z.number().min(30000).max(600000).default(300000),
     /**
@@ -146,6 +151,7 @@ export const DEFAULT_CONFIG = {
     rate_limit_retry_delay_ms: 5000,
     rate_limit_max_retries: 3,
     max_request_iterations: 20,
+    sdk_response_timeout_enabled: false,
     sdk_response_timeout_ms: 300000,
     request_timeout_ms: 120000,
     token_expiry_buffer_ms: 300000,

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

@@ -5,16 +5,14 @@ import lockfile from 'proper-lockfile';
 import { isPermanentError } from '../health.js';
 import { getKeepAliveLockPath, getRefreshLockPath } from '../paths.js';
 export { getKeepAliveLockPath, getRefreshLockPath } from '../paths.js';
-const LOCK_OPTIONS = {
+const DATABASE_LOCK_OPTIONS = {
     stale: 10000,
-    retries: {
-        retries: 5,
-        minTimeout: 100,
-        maxTimeout: 1000,
-        factor: 2
-    },
+    retries: 0,
     realpath: false
 };
+const DATABASE_LOCK_DEADLINE_MS = 10000;
+const DATABASE_LOCK_MIN_BACKOFF_MS = 25;
+const DATABASE_LOCK_MAX_BACKOFF_MS = 250;
 const REFRESH_LOCK_OPTIONS = {
     stale: 15000,
     retries: {
@@ -38,6 +36,29 @@ 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);
+    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));
+}
+async function acquireDatabaseLock(dbPath) {
+    // A deadline avoids fixed retry-count starvation; jitter keeps contenders
+    // from repeatedly attempting the atomic mkdir in lockstep.
+    const deadline = Date.now() + DATABASE_LOCK_DEADLINE_MS;
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await lockfile.lock(dbPath, DATABASE_LOCK_OPTIONS);
+        }
+        catch (e) {
+            const remainingMs = deadline - Date.now();
+            if (!isLockContention(e) || remainingMs <= 0)
+                throw e;
+            await asyncBackoff(attempt++, remainingMs);
+        }
+    }
+}
 export function withDatabaseLockSync(dbPath, fn) {
     if (!existsSync(dbPath)) {
         mkdirSync(dirname(dbPath), { recursive: true });
@@ -73,13 +94,12 @@ export function withDatabaseLockSync(dbPath, fn) {
 }
 export async function withDatabaseLock(dbPath, fn) {
     if (!existsSync(dbPath)) {
-        const dir = dbPath.substring(0, dbPath.lastIndexOf('/'));
-        await fs.mkdir(dir, { recursive: true });
+        await fs.mkdir(dirname(dbPath), { recursive: true });
         await fs.writeFile(dbPath, '');
     }
     let release = null;
     try {
-        release = await lockfile.lock(dbPath, LOCK_OPTIONS);
+        release = await acquireDatabaseLock(dbPath);
         return await fn();
     }
     finally {

package/package.json

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