@zhafron/opencode-kiro-auth 1.1.0 → 1.1.2

package/dist/kiro/oauth-idc.js

@@ -2,64 +2,74 @@ import { KIRO_AUTH_SERVICE, KIRO_CONSTANTS, buildUrl, normalizeRegion } from '..
 export async function authorizeKiroIDC(region) {
     const effectiveRegion = normalizeRegion(region);
     const ssoOIDCEndpoint = buildUrl(KIRO_AUTH_SERVICE.SSO_OIDC_ENDPOINT, effectiveRegion);
-    const registerResponse = await fetch(`${ssoOIDCEndpoint}/client/register`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'User-Agent': KIRO_CONSTANTS.USER_AGENT
-        },
-        body: JSON.stringify({
-            clientName: 'Kiro IDE',
-            clientType: 'public',
-            scopes: KIRO_AUTH_SERVICE.SCOPES,
-            grantTypes: ['urn:ietf:params:oauth:grant-type:device_code', 'refresh_token']
-        })
-    });
-    if (!registerResponse.ok) {
-        const errorText = await registerResponse.text().catch(() => '');
-        throw new Error(`Client registration failed: ${registerResponse.status} ${errorText}`);
-    }
-    const registerData = await registerResponse.json();
-    const { clientId, clientSecret } = registerData;
-    if (!clientId || !clientSecret) {
-        throw new Error('Client registration response missing clientId or clientSecret');
-    }
-    const deviceAuthResponse = await fetch(`${ssoOIDCEndpoint}/device_authorization`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'User-Agent': KIRO_CONSTANTS.USER_AGENT
-        },
-        body: JSON.stringify({
+    try {
+        const registerResponse = await fetch(`${ssoOIDCEndpoint}/client/register`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': KIRO_CONSTANTS.USER_AGENT
+            },
+            body: JSON.stringify({
+                clientName: 'Kiro IDE',
+                clientType: 'public',
+                scopes: KIRO_AUTH_SERVICE.SCOPES,
+                grantTypes: ['urn:ietf:params:oauth:grant-type:device_code', 'refresh_token']
+            })
+        });
+        if (!registerResponse.ok) {
+            const errorText = await registerResponse.text().catch(() => '');
+            const error = new Error(`Client registration failed: ${registerResponse.status} ${errorText}`);
+            throw error;
+        }
+        const registerData = await registerResponse.json();
+        const { clientId, clientSecret } = registerData;
+        if (!clientId || !clientSecret) {
+            const error = new Error('Client registration response missing clientId or clientSecret');
+            throw error;
+        }
+        const deviceAuthResponse = await fetch(`${ssoOIDCEndpoint}/device_authorization`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': KIRO_CONSTANTS.USER_AGENT
+            },
+            body: JSON.stringify({
+                clientId,
+                clientSecret,
+                startUrl: KIRO_AUTH_SERVICE.BUILDER_ID_START_URL
+            })
+        });
+        if (!deviceAuthResponse.ok) {
+            const errorText = await deviceAuthResponse.text().catch(() => '');
+            const error = new Error(`Device authorization failed: ${deviceAuthResponse.status} ${errorText}`);
+            throw error;
+        }
+        const deviceAuthData = await deviceAuthResponse.json();
+        const { verificationUri, verificationUriComplete, userCode, deviceCode, interval = 5, expiresIn = 600 } = deviceAuthData;
+        if (!deviceCode || !userCode || !verificationUri || !verificationUriComplete) {
+            const error = new Error('Device authorization response missing required fields');
+            throw error;
+        }
+        return {
+            verificationUrl: verificationUri,
+            verificationUriComplete,
+            userCode,
+            deviceCode,
             clientId,
             clientSecret,
-            startUrl: KIRO_AUTH_SERVICE.BUILDER_ID_START_URL
-        })
-    });
-    if (!deviceAuthResponse.ok) {
-        const errorText = await deviceAuthResponse.text().catch(() => '');
-        throw new Error(`Device authorization failed: ${deviceAuthResponse.status} ${errorText}`);
+            interval,
+            expiresIn,
+            region: effectiveRegion
+        };
     }
-    const deviceAuthData = await deviceAuthResponse.json();
-    const { verificationUri, verificationUriComplete, userCode, deviceCode, interval = 5, expiresIn = 600 } = deviceAuthData;
-    if (!deviceCode || !userCode || !verificationUri || !verificationUriComplete) {
-        throw new Error('Device authorization response missing required fields');
+    catch (error) {
+        throw error;
     }
-    return {
-        verificationUrl: verificationUri,
-        verificationUriComplete,
-        userCode,
-        deviceCode,
-        clientId,
-        clientSecret,
-        interval,
-        expiresIn,
-        region: effectiveRegion
-    };
 }
 export async function pollKiroIDCToken(clientId, clientSecret, deviceCode, interval, expiresIn, region) {
     if (!clientId || !clientSecret || !deviceCode) {
-        throw new Error('Missing required parameters for token polling');
+        const error = new Error('Missing required parameters for token polling');
+        throw error;
     }
     const effectiveRegion = normalizeRegion(region);
     const ssoOIDCEndpoint = buildUrl(KIRO_AUTH_SERVICE.SSO_OIDC_ENDPOINT, effectiveRegion);
@@ -94,12 +104,15 @@ export async function pollKiroIDCToken(clientId, clientSecret, deviceCode, inter
                     continue;
                 }
                 if (errorType === 'expired_token') {
-                    throw new Error('Device code has expired. Please restart the authorization process.');
+                    const error = new Error('Device code has expired. Please restart the authorization process.');
+                    throw error;
                 }
                 if (errorType === 'access_denied') {
-                    throw new Error('Authorization was denied by the user.');
+                    const error = new Error('Authorization was denied by the user.');
+                    throw error;
                 }
-                throw new Error(`Token polling failed: ${errorType} - ${tokenData.error_description || ''}`);
+                const error = new Error(`Token polling failed: ${errorType} - ${tokenData.error_description || ''}`);
+                throw error;
             }
             if (tokenData.accessToken && tokenData.refreshToken) {
                 const expiresInSeconds = tokenData.expiresIn || 3600;
@@ -116,7 +129,8 @@ export async function pollKiroIDCToken(clientId, clientSecret, deviceCode, inter
                 };
             }
             if (!tokenResponse.ok) {
-                throw new Error(`Token request failed with status: ${tokenResponse.status}`);
+                const error = new Error(`Token request failed with status: ${tokenResponse.status}`);
+                throw error;
             }
         }
         catch (error) {
@@ -127,9 +141,11 @@ export async function pollKiroIDCToken(clientId, clientSecret, deviceCode, inter
                 throw error;
             }
             if (attempts >= maxAttempts) {
-                throw new Error(`Token polling failed after ${attempts} attempts: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                const finalError = new Error(`Token polling failed after ${attempts} attempts: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                throw finalError;
             }
         }
     }
-    throw new Error('Token polling timed out. Authorization may have expired.');
+    const timeoutError = new Error('Token polling timed out. Authorization may have expired.');
+    throw timeoutError;
 }

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

@@ -15,6 +15,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
     rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
     usage_tracking_enabled: z.ZodDefault<z.ZodBoolean>;
+    enable_log_api_request: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     session_recovery: boolean;
     auto_resume: boolean;
@@ -26,6 +27,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: number;
     rate_limit_max_retries: number;
     usage_tracking_enabled: boolean;
+    enable_log_api_request: boolean;
     $schema?: string | undefined;
 }, {
     $schema?: string | undefined;
@@ -39,6 +41,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms?: number | undefined;
     rate_limit_max_retries?: number | undefined;
     usage_tracking_enabled?: boolean | undefined;
+    enable_log_api_request?: boolean | undefined;
 }>;
 export type KiroConfig = z.infer<typeof KiroConfigSchema>;
 export declare const DEFAULT_CONFIG: KiroConfig;

package/dist/plugin/config/schema.js

@@ -12,7 +12,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),
-    usage_tracking_enabled: z.boolean().default(true)
+    usage_tracking_enabled: z.boolean().default(true),
+    enable_log_api_request: z.boolean().default(false)
 });
 export const DEFAULT_CONFIG = {
     session_recovery: true,
@@ -24,5 +25,6 @@ export const DEFAULT_CONFIG = {
     default_region: 'us-east-1',
     rate_limit_retry_delay_ms: 5000,
     rate_limit_max_retries: 3,
-    usage_tracking_enabled: true
+    usage_tracking_enabled: true,
+    enable_log_api_request: false
 };

package/dist/plugin/logger.d.ts

@@ -2,3 +2,6 @@ export declare function log(message: string, ...args: unknown[]): void;
 export declare function error(message: string, ...args: unknown[]): void;
 export declare function warn(message: string, ...args: unknown[]): void;
 export declare function debug(message: string, ...args: unknown[]): void;
+export declare function logApiRequest(data: any, timestamp: string): void;
+export declare function logApiResponse(data: any, timestamp: string): void;
+export declare function getTimestamp(): string;

package/dist/plugin/logger.js

@@ -1,4 +1,4 @@
-import { appendFileSync, mkdirSync } from 'node:fs';
+import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 const getLogDir = () => {
@@ -19,6 +19,17 @@ const writeToFile = (level, message, ...args) => {
     }
     catch (e) { }
 };
+const writeApiLog = (type, data, timestamp) => {
+    try {
+        const dir = getLogDir();
+        mkdirSync(dir, { recursive: true });
+        const filename = `${timestamp}_${type}.json`;
+        const path = join(dir, filename);
+        const content = JSON.stringify(data, null, 2);
+        writeFileSync(path, content);
+    }
+    catch (e) { }
+};
 export function log(message, ...args) {
     writeToFile('INFO', message, ...args);
 }
@@ -33,3 +44,12 @@ export function debug(message, ...args) {
         writeToFile('DEBUG', message, ...args);
     }
 }
+export function logApiRequest(data, timestamp) {
+    writeApiLog('request', data, timestamp);
+}
+export function logApiResponse(data, timestamp) {
+    writeApiLog('response', data, timestamp);
+}
+export function getTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}

package/dist/plugin/request.js

@@ -81,6 +81,10 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                 uim.images = imgs;
             if (trs.length)
                 uim.userInputMessageContext = { toolResults: deduplicateToolResults(trs) };
+            const prev = history[history.length - 1];
+            if (prev && prev.userInputMessage) {
+                history.push({ assistantResponseMessage: { content: 'Continue' } });
+            }
             history.push({ userInputMessage: uim });
         }
         else if (m.role === 'tool') {
@@ -100,6 +104,10 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                     toolUseId: m.tool_call_id
                 });
             }
+            const prev = history[history.length - 1];
+            if (prev && prev.userInputMessage) {
+                history.push({ assistantResponseMessage: { content: 'Continue' } });
+            }
             history.push({
                 userInputMessage: {
                     content: 'Tool results provided.',

package/dist/plugin/server.js

@@ -1,5 +1,6 @@
 import { createServer } from 'node:http';
 import { getIDCAuthHtml, getSuccessHtml, getErrorHtml } from './auth-page';
+import * as logger from './logger';
 export function startIDCAuthServer(authData, port = 19847) {
     return new Promise((resolve, reject) => {
         let server = null;
@@ -50,11 +51,13 @@ export function startIDCAuthServer(authData, port = 19847) {
                         });
                     setTimeout(cleanup, 2000);
                 }
-                else if (d.error === 'authorization_pending')
+                else if (d.error === 'authorization_pending') {
                     setTimeout(poll, authData.interval * 1000);
+                }
                 else {
                     status.status = 'failed';
                     status.error = d.error_description || d.error;
+                    logger.error(`Auth polling failed: ${status.error}`);
                     if (rejector)
                         rejector(new Error(status.error));
                     setTimeout(cleanup, 2000);
@@ -63,6 +66,7 @@ export function startIDCAuthServer(authData, port = 19847) {
             catch (e) {
                 status.status = 'failed';
                 status.error = e.message;
+                logger.error(`Auth polling error: ${e.message}`, e);
                 if (rejector)
                     rejector(e);
                 setTimeout(cleanup, 2000);
@@ -86,12 +90,14 @@ export function startIDCAuthServer(authData, port = 19847) {
             }
         });
         server.on('error', (e) => {
+            logger.error(`Auth server error on port ${port}`, e);
             cleanup();
             reject(e);
         });
         server.listen(port, '127.0.0.1', () => {
             timeoutId = setTimeout(() => {
                 status.status = 'timeout';
+                logger.warn('Auth timeout waiting for authorization');
                 if (rejector)
                     rejector(new Error('Timeout'));
                 cleanup();

package/dist/plugin/storage.js

@@ -1,15 +1,20 @@
 import { promises as fs } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { randomBytes } from 'node:crypto';
+import { homedir } from 'node:os';
 import lockfile from 'proper-lockfile';
-import { xdgConfig } from 'xdg-basedir';
 import * as logger from './logger';
 const LOCK_OPTIONS = {
     stale: 10000,
     retries: { retries: 5, minTimeout: 100, maxTimeout: 1000, factor: 2 }
 };
 function getBaseDir() {
-    return join(xdgConfig || join(process.env.HOME || '', '.config'), 'opencode');
+    const platform = process.platform;
+    if (platform === 'win32') {
+        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'opencode');
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+    return join(xdgConfig, 'opencode');
 }
 export function getStoragePath() {
     return join(getBaseDir(), 'kiro-accounts.json');
@@ -18,12 +23,24 @@ export function getUsagePath() {
     return join(getBaseDir(), 'kiro-usage.json');
 }
 async function withLock(path, fn) {
-    await fs.mkdir(dirname(path), { recursive: true });
+    try {
+        await fs.mkdir(dirname(path), { recursive: true });
+    }
+    catch (error) {
+        logger.error(`Failed to create directory ${dirname(path)}`, error);
+        throw error;
+    }
     try {
         await fs.access(path);
     }
     catch {
-        await fs.writeFile(path, '{}');
+        try {
+            await fs.writeFile(path, '{}');
+        }
+        catch (error) {
+            logger.error(`Failed to initialize file ${path}`, error);
+            throw error;
+        }
     }
     let release = null;
     try {
@@ -35,8 +52,14 @@ async function withLock(path, fn) {
         throw error;
     }
     finally {
-        if (release)
-            await release();
+        if (release) {
+            try {
+                await release();
+            }
+            catch (error) {
+                logger.warn(`Failed to release lock for ${path}`, error);
+            }
+        }
     }
 }
 export async function loadAccounts() {
@@ -50,11 +73,17 @@ export async function loadAccounts() {
 }
 export async function saveAccounts(storage) {
     const path = getStoragePath();
-    await withLock(path, async () => {
-        const tmp = `${path}.${randomBytes(6).toString('hex')}.tmp`;
-        await fs.writeFile(tmp, JSON.stringify(storage, null, 2));
-        await fs.rename(tmp, path);
-    });
+    try {
+        await withLock(path, async () => {
+            const tmp = `${path}.${randomBytes(6).toString('hex')}.tmp`;
+            await fs.writeFile(tmp, JSON.stringify(storage, null, 2));
+            await fs.rename(tmp, path);
+        });
+    }
+    catch (error) {
+        logger.error(`Failed to save accounts to ${path}`, error);
+        throw error;
+    }
 }
 export async function loadUsage() {
     try {
@@ -67,9 +96,15 @@ export async function loadUsage() {
 }
 export async function saveUsage(storage) {
     const path = getUsagePath();
-    await withLock(path, async () => {
-        const tmp = `${path}.${randomBytes(6).toString('hex')}.tmp`;
-        await fs.writeFile(tmp, JSON.stringify(storage, null, 2));
-        await fs.rename(tmp, path);
-    });
+    try {
+        await withLock(path, async () => {
+            const tmp = `${path}.${randomBytes(6).toString('hex')}.tmp`;
+            await fs.writeFile(tmp, JSON.stringify(storage, null, 2));
+            await fs.rename(tmp, path);
+        });
+    }
+    catch (error) {
+        logger.error(`Failed to save usage to ${path}`, error);
+        throw error;
+    }
 }

package/dist/plugin/token.js

@@ -3,54 +3,64 @@ import { decodeRefreshToken, encodeRefreshToken } from '../kiro/auth';
 export async function refreshAccessToken(auth) {
     const url = `https://oidc.${auth.region}.amazonaws.com/token`;
     const p = decodeRefreshToken(auth.refresh);
-    if (!p.clientId || !p.clientSecret)
+    if (!p.clientId || !p.clientSecret) {
         throw new KiroTokenRefreshError('Missing creds', 'MISSING_CREDENTIALS');
+    }
     const requestBody = {
         refreshToken: p.refreshToken,
         clientId: p.clientId,
         clientSecret: p.clientSecret,
         grantType: 'refresh_token'
     };
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            Accept: 'application/json',
-            'amz-sdk-request': 'attempt=1; max=1',
-            'x-amzn-kiro-agent-mode': 'vibe',
-            Connection: 'close'
-        },
-        body: JSON.stringify(requestBody)
-    });
-    if (!res.ok) {
-        const txt = await res.text();
-        let data = {};
-        try {
-            data = JSON.parse(txt);
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                'amz-sdk-request': 'attempt=1; max=1',
+                'x-amzn-kiro-agent-mode': 'vibe',
+                Connection: 'close'
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (!res.ok) {
+            const txt = await res.text();
+            let data = {};
+            try {
+                data = JSON.parse(txt);
+            }
+            catch {
+                data = { message: txt };
+            }
+            throw new KiroTokenRefreshError(`Refresh failed: ${data.message || data.error_description || txt}`, data.error || `HTTP_${res.status}`);
         }
-        catch {
-            data = { message: txt };
+        const d = await res.json();
+        const acc = d.access_token || d.accessToken;
+        if (!acc) {
+            throw new KiroTokenRefreshError('No access token', 'INVALID_RESPONSE');
         }
-        throw new KiroTokenRefreshError(`Refresh failed: ${data.message || data.error_description || txt}`, data.error || `HTTP_${res.status}`);
+        const upP = {
+            refreshToken: d.refresh_token || d.refreshToken || p.refreshToken,
+            clientId: p.clientId,
+            clientSecret: p.clientSecret,
+            authMethod: 'idc'
+        };
+        return {
+            refresh: encodeRefreshToken(upP),
+            access: acc,
+            expires: Date.now() + (d.expires_in || 3600) * 1000,
+            authMethod: 'idc',
+            region: auth.region,
+            clientId: auth.clientId,
+            clientSecret: auth.clientSecret,
+            email: auth.email
+        };
+    }
+    catch (error) {
+        if (error instanceof KiroTokenRefreshError) {
+            throw error;
+        }
+        throw new KiroTokenRefreshError(`Token refresh failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'NETWORK_ERROR', error instanceof Error ? error : undefined);
     }
-    const d = await res.json();
-    const acc = d.access_token || d.accessToken;
-    if (!acc)
-        throw new KiroTokenRefreshError('No access token', 'INVALID_RESPONSE');
-    const upP = {
-        refreshToken: d.refresh_token || d.refreshToken || p.refreshToken,
-        clientId: p.clientId,
-        clientSecret: p.clientSecret,
-        authMethod: 'idc'
-    };
-    return {
-        refresh: encodeRefreshToken(upP),
-        access: acc,
-        expires: Date.now() + (d.expires_in || 3600) * 1000,
-        authMethod: 'idc',
-        region: auth.region,
-        clientId: auth.clientId,
-        clientSecret: auth.clientSecret,
-        email: auth.email
-    };
 }

package/dist/plugin.js

@@ -72,8 +72,41 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                                 }
                             }
                             const prep = transformToCodeWhisperer(url, init?.body, model, auth, think, budget);
+                            const apiTimestamp = config.enable_log_api_request ? logger.getTimestamp() : null;
+                            if (config.enable_log_api_request && apiTimestamp) {
+                                let parsedBody = null;
+                                if (prep.init.body && typeof prep.init.body === 'string') {
+                                    try {
+                                        parsedBody = JSON.parse(prep.init.body);
+                                    }
+                                    catch (e) {
+                                        parsedBody = prep.init.body;
+                                    }
+                                }
+                                logger.logApiRequest({
+                                    url: prep.url,
+                                    method: prep.init.method,
+                                    headers: prep.init.headers,
+                                    body: parsedBody,
+                                    conversationId: prep.conversationId,
+                                    model: prep.effectiveModel
+                                }, apiTimestamp);
+                            }
                             try {
                                 const res = await fetch(prep.url, prep.init);
+                                if (config.enable_log_api_request && apiTimestamp) {
+                                    const responseHeaders = {};
+                                    res.headers.forEach((value, key) => {
+                                        responseHeaders[key] = value;
+                                    });
+                                    logger.logApiResponse({
+                                        status: res.status,
+                                        statusText: res.statusText,
+                                        headers: responseHeaders,
+                                        conversationId: prep.conversationId,
+                                        model: prep.effectiveModel
+                                    }, apiTimestamp);
+                                }
                                 if (res.ok) {
                                     if (config.usage_tracking_enabled)
                                         fetchUsageLimits(auth)
@@ -155,9 +188,30 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                                     await am.saveToDisk();
                                     continue;
                                 }
+                                if (config.enable_log_api_request && apiTimestamp) {
+                                    const responseHeaders = {};
+                                    res.headers.forEach((value, key) => {
+                                        responseHeaders[key] = value;
+                                    });
+                                    logger.logApiResponse({
+                                        status: res.status,
+                                        statusText: res.statusText,
+                                        headers: responseHeaders,
+                                        error: `Kiro Error: ${res.status}`,
+                                        conversationId: prep.conversationId,
+                                        model: prep.effectiveModel
+                                    }, apiTimestamp);
+                                }
                                 throw new Error(`Kiro Error: ${res.status}`);
                             }
                             catch (e) {
+                                if (config.enable_log_api_request && apiTimestamp) {
+                                    logger.logApiResponse({
+                                        error: String(e),
+                                        conversationId: prep.conversationId,
+                                        model: prep.effectiveModel
+                                    }, apiTimestamp);
+                                }
                                 if (isNetworkError(e) && retry < config.rate_limit_max_retries) {
                                     const delay = 5000 * Math.pow(2, retry);
                                     showToast(`Network error. Retrying in ${Math.ceil(delay / 1000)}s...`, 'warning');
@@ -178,65 +232,78 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                     type: 'oauth',
                     authorize: async () => new Promise(async (resolve) => {
                         const region = config.default_region;
-                        const authData = await authorizeKiroIDC(region);
-                        const { url, waitForAuth } = await startIDCAuthServer(authData);
-                        resolve({
-                            url,
-                            instructions: 'Opening browser...',
-                            method: 'auto',
-                            callback: async () => {
-                                try {
-                                    const res = await waitForAuth();
-                                    const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
-                                    const acc = {
-                                        id: generateAccountId(),
-                                        email: res.email,
-                                        authMethod: 'idc',
-                                        region,
-                                        clientId: res.clientId,
-                                        clientSecret: res.clientSecret,
-                                        refreshToken: res.refreshToken,
-                                        accessToken: res.accessToken,
-                                        expiresAt: res.expiresAt,
-                                        rateLimitResetTime: 0,
-                                        isHealthy: true
-                                    };
+                        try {
+                            const authData = await authorizeKiroIDC(region);
+                            const { url, waitForAuth } = await startIDCAuthServer(authData);
+                            resolve({
+                                url,
+                                instructions: 'Opening browser...',
+                                method: 'auto',
+                                callback: async () => {
                                     try {
-                                        const u = await fetchUsageLimits({
-                                            refresh: encodeRefreshToken({
-                                                refreshToken: res.refreshToken,
-                                                clientId: res.clientId,
-                                                clientSecret: res.clientSecret,
-                                                authMethod: 'idc'
-                                            }),
-                                            access: res.accessToken,
-                                            expires: res.expiresAt,
+                                        const res = await waitForAuth();
+                                        const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                        const acc = {
+                                            id: generateAccountId(),
+                                            email: res.email,
                                             authMethod: 'idc',
                                             region,
                                             clientId: res.clientId,
                                             clientSecret: res.clientSecret,
-                                            email: res.email
-                                        });
-                                        am.updateUsage(acc.id, {
-                                            usedCount: u.usedCount,
-                                            limitCount: u.limitCount,
-                                            realEmail: u.email
-                                        });
+                                            refreshToken: res.refreshToken,
+                                            accessToken: res.accessToken,
+                                            expiresAt: res.expiresAt,
+                                            rateLimitResetTime: 0,
+                                            isHealthy: true
+                                        };
+                                        try {
+                                            const u = await fetchUsageLimits({
+                                                refresh: encodeRefreshToken({
+                                                    refreshToken: res.refreshToken,
+                                                    clientId: res.clientId,
+                                                    clientSecret: res.clientSecret,
+                                                    authMethod: 'idc'
+                                                }),
+                                                access: res.accessToken,
+                                                expires: res.expiresAt,
+                                                authMethod: 'idc',
+                                                region,
+                                                clientId: res.clientId,
+                                                clientSecret: res.clientSecret,
+                                                email: res.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(`Successfully logged in as ${res.email}`, 'success');
+                                        return { type: 'success', key: res.accessToken };
                                     }
                                     catch (e) {
-                                        logger.warn(`Initial usage fetch failed: ${e.message}`);
+                                        logger.error(`Login failed: ${e.message}`, e);
+                                        showToast(`Login failed: ${e.message}`, 'error');
+                                        return { type: 'failed' };
                                     }
-                                    am.addAccount(acc);
-                                    await am.saveToDisk();
-                                    showToast(`Successfully logged in as ${res.email}`, 'success');
-                                    return { type: 'success', key: res.accessToken };
-                                }
-                                catch (e) {
-                                    logger.error(`Login failed: ${e.message}`);
-                                    return { type: 'failed' };
                                 }
-                            }
-                        });
+                            });
+                        }
+                        catch (e) {
+                            logger.error(`Authorization failed: ${e.message}`, e);
+                            showToast(`Authorization failed: ${e.message}`, 'error');
+                            resolve({
+                                url: '',
+                                instructions: 'Authorization failed',
+                                method: 'auto',
+                                callback: async () => ({ type: 'failed' })
+                            });
+                        }
                     })
                 }
             ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhafron/opencode-kiro-auth",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,6 @@
   "dependencies": {
     "@opencode-ai/plugin": "^0.15.30",
     "proper-lockfile": "^4.1.2",
-    "xdg-basedir": "^5.1.0",
     "zod": "^3.24.0"
   },
   "devDependencies": {