@zhafron/opencode-kiro-auth 1.2.5 → 1.2.7

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/request.js

@@ -2,10 +2,39 @@ import * as crypto from 'crypto';
 import * as os from 'os';
 import { KIRO_CONSTANTS } from '../constants.js';
 import { resolveKiroModel } from './models.js';
-import * as logger from './logger.js';
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    const half = Math.floor(max / 2);
+    return s.substring(0, half) + '\n... [TRUNCATED] ...\n' + s.substring(s.length - half);
+}
+function sanitizeHistory(history) {
+    const result = [];
+    for (let i = 0; i < history.length; i++) {
+        const m = history[i];
+        if (!m)
+            continue;
+        if (m.assistantResponseMessage?.toolUses) {
+            const next = history[i + 1];
+            if (next?.userInputMessage?.userInputMessageContext?.toolResults) {
+                result.push(m);
+            }
+        }
+        else if (m.userInputMessage?.userInputMessageContext?.toolResults) {
+            const prev = result[result.length - 1];
+            if (prev?.assistantResponseMessage?.toolUses) {
+                result.push(m);
+            }
+        }
+        else {
+            result.push(m);
+        }
+    }
+    return result;
+}
 export function transformToCodeWhisperer(url, body, model, auth, think = false, budget = 20000) {
     const req = typeof body === 'string' ? JSON.parse(body) : body;
-    const { messages, tools, system, conversationId } = req;
+    const { messages, tools, system } = req;
     const convId = crypto.randomUUID();
     if (!messages || messages.length === 0)
         throw new Error('No messages');
@@ -20,7 +49,7 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
     if (lastMsg && lastMsg.role === 'assistant' && getContentText(lastMsg) === '{')
         msgs.pop();
     const cwTools = tools ? convertToolsToCodeWhisperer(tools) : [];
-    const history = [];
+    let history = [];
     let firstUserIndex = -1;
     for (let i = 0; i < msgs.length; i++) {
         if (msgs[i].role === 'user') {
@@ -38,9 +67,8 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                     ...m.content.filter((p) => p.type !== 'text')
                 ];
             }
-            else {
+            else
                 m.content = `${sys}\n\n${oldContent}`;
-            }
         }
         else {
             history.push({
@@ -65,7 +93,7 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                         uim.content += p.text || '';
                     else if (p.type === 'tool_result')
                         trs.push({
-                            content: [{ text: getContentText(p.content || p) }],
+                            content: [{ text: truncate(getContentText(p.content || p), 250000) }],
                             status: 'success',
                             toolUseId: p.tool_use_id
                         });
@@ -83,9 +111,8 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
             if (trs.length)
                 uim.userInputMessageContext = { toolResults: deduplicateToolResults(trs) };
             const prev = history[history.length - 1];
-            if (prev && prev.userInputMessage) {
+            if (prev && prev.userInputMessage)
                 history.push({ assistantResponseMessage: { content: 'Continue' } });
-            }
             history.push({ userInputMessage: uim });
         }
         else if (m.role === 'tool') {
@@ -93,22 +120,21 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
             if (m.tool_results) {
                 for (const tr of m.tool_results)
                     trs.push({
-                        content: [{ text: getContentText(tr) }],
+                        content: [{ text: truncate(getContentText(tr), 250000) }],
                         status: 'success',
                         toolUseId: tr.tool_call_id
                     });
             }
             else {
                 trs.push({
-                    content: [{ text: getContentText(m) }],
+                    content: [{ text: truncate(getContentText(m), 250000) }],
                     status: 'success',
                     toolUseId: m.tool_call_id
                 });
             }
             const prev = history[history.length - 1];
-            if (prev && prev.userInputMessage) {
+            if (prev && prev.userInputMessage)
                 history.push({ assistantResponseMessage: { content: 'Continue' } });
-            }
             history.push({
                 userInputMessage: {
                     content: 'Tool results provided.',
@@ -132,9 +158,8 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                         tus.push({ input: p.input, name: p.name, toolUseId: p.id });
                 }
             }
-            else {
+            else
                 arm.content = getContentText(m);
-            }
             if (m.tool_calls && Array.isArray(m.tool_calls)) {
                 for (const tc of m.tool_calls) {
                     tus.push({
@@ -155,6 +180,19 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
             history.push({ assistantResponseMessage: arm });
         }
     }
+    history = sanitizeHistory(history);
+    let historySize = JSON.stringify(history).length;
+    while (historySize > 850000 && history.length > 2) {
+        history.shift();
+        while (history.length > 0) {
+            const first = history[0];
+            if (first && first.userInputMessage)
+                break;
+            history.shift();
+        }
+        history = sanitizeHistory(history);
+        historySize = JSON.stringify(history).length;
+    }
     const curMsg = msgs[msgs.length - 1];
     if (!curMsg)
         throw new Error('Empty');
@@ -206,14 +244,14 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
             if (curMsg.tool_results) {
                 for (const tr of curMsg.tool_results)
                     curTrs.push({
-                        content: [{ text: getContentText(tr) }],
+                        content: [{ text: truncate(getContentText(tr), 250000) }],
                         status: 'success',
                         toolUseId: tr.tool_call_id
                     });
             }
             else {
                 curTrs.push({
-                    content: [{ text: getContentText(curMsg) }],
+                    content: [{ text: truncate(getContentText(curMsg), 250000) }],
                     status: 'success',
                     toolUseId: curMsg.tool_call_id
                 });
@@ -225,7 +263,7 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                     curContent += p.text || '';
                 else if (p.type === 'tool_result')
                     curTrs.push({
-                        content: [{ text: getContentText(p.content || p) }],
+                        content: [{ text: truncate(getContentText(p.content || p), 250000) }],
                         status: 'success',
                         toolUseId: p.tool_use_id
                     });
@@ -254,10 +292,8 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
             }
         }
     };
-    if (history.length > 0) {
-        ;
+    if (history.length > 0)
         request.conversationState.history = history;
-    }
     const uim = request.conversationState.currentMessage.userInputMessage;
     if (uim) {
         if (curImgs.length)
@@ -277,17 +313,11 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                 const existingToolNames = new Set(existingTools.map((t) => t.toolSpecification?.name).filter(Boolean));
                 const missingToolNames = Array.from(toolNamesInHistory).filter((name) => !existingToolNames.has(name));
                 if (missingToolNames.length > 0) {
-                    logger.log(`[Kiro] Adding ${missingToolNames.length} missing tool definitions: ${missingToolNames.join(', ')}`);
                     const placeholderTools = missingToolNames.map((name) => ({
                         toolSpecification: {
                             name,
                             description: 'Tool',
-                            inputSchema: {
-                                json: {
-                                    type: 'object',
-                                    properties: {}
-                                }
-                            }
+                            inputSchema: { json: { type: 'object', properties: {} } }
                         }
                     }));
                     if (!uim.userInputMessageContext)

package/dist/plugin/response.js

@@ -76,7 +76,7 @@ function parseEventStreamChunk(rawText) {
         };
     });
     if (contextUsagePercentage !== undefined) {
-        const totalTokens = Math.round((172500 * contextUsagePercentage) / 100);
+        const totalTokens = Math.round((200000 * contextUsagePercentage) / 100);
         outputTokens = estimateTokens(content);
         inputTokens = Math.max(0, totalTokens - outputTokens);
     }

package/dist/plugin/streaming.js

@@ -224,7 +224,7 @@ export async function* transformKiroStream(response, model, conversationId) {
         }
         outputTokens = estimateTokens(totalContent);
         if (contextUsagePercentage !== null && contextUsagePercentage > 0) {
-            const totalTokens = Math.round((172500 * contextUsagePercentage) / 100);
+            const totalTokens = Math.round((200000 * contextUsagePercentage) / 100);
             inputTokens = Math.max(0, totalTokens - outputTokens);
         }
         yield convertToOpenAI({

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';
@@ -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.5",
+  "version": "1.2.7",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",