@kervnet/opencode-kiro-auth 1.5.1

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

@@ -0,0 +1,61 @@
+import { parseEventStream } from '../../plugin/response';
+import { transformKiroStream } from '../../plugin/streaming/index.js';
+export class ResponseHandler {
+    async handleSuccess(response, model, conversationId, streaming) {
+        if (streaming) {
+            return this.handleStreaming(response, model, conversationId);
+        }
+        return this.handleNonStreaming(response, model, conversationId);
+    }
+    async handleStreaming(response, model, conversationId) {
+        const s = transformKiroStream(response, model, conversationId);
+        return new Response(new ReadableStream({
+            async start(c) {
+                try {
+                    for await (const e of s) {
+                        c.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(e)}\n\n`));
+                    }
+                    c.close();
+                }
+                catch (err) {
+                    c.error(err);
+                }
+            }
+        }), { headers: { 'Content-Type': 'text/event-stream' } });
+    }
+    async handleNonStreaming(response, model, conversationId) {
+        const text = await response.text();
+        const p = parseEventStream(text);
+        const oai = {
+            id: conversationId,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [
+                {
+                    index: 0,
+                    message: { role: 'assistant', content: p.content },
+                    finish_reason: p.stopReason === 'tool_use' ? 'tool_calls' : 'stop'
+                }
+            ],
+            usage: {
+                prompt_tokens: p.inputTokens || 0,
+                completion_tokens: p.outputTokens || 0,
+                total_tokens: (p.inputTokens || 0) + (p.outputTokens || 0)
+            }
+        };
+        if (p.toolCalls.length > 0) {
+            oai.choices[0].message.tool_calls = p.toolCalls.map((tc) => ({
+                id: tc.toolUseId,
+                type: 'function',
+                function: {
+                    name: tc.name,
+                    arguments: typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input)
+                }
+            }));
+        }
+        return new Response(JSON.stringify(oai), {
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+}

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

@@ -0,0 +1,18 @@
+interface RetryConfig {
+    max_request_iterations: number;
+    request_timeout_ms: number;
+}
+interface RetryContext {
+    iterations: number;
+    startTime: number;
+}
+export declare class RetryStrategy {
+    private config;
+    constructor(config: RetryConfig);
+    shouldContinue(context: RetryContext): {
+        canContinue: boolean;
+        error?: string;
+    };
+    createContext(): RetryContext;
+}
+export {};

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

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { KiroOAuthPlugin } from './plugin.js';
+export type { KiroConfig } from './plugin/config/index.js';
+export type { KiroAuthMethod, KiroRegion, ManagedAccount } from './plugin/types.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { KiroOAuthPlugin } from './plugin.js';

package/dist/infrastructure/database/account-cache.d.ts

@@ -0,0 +1,14 @@
+export declare class AccountCache {
+    private cache;
+    private allAccountsCache;
+    private lastUpdate;
+    private ttl;
+    constructor(ttlMs?: number);
+    getAll(): any[] | null;
+    setAll(accounts: any[]): void;
+    get(id: string): any | null;
+    set(id: string, account: any): void;
+    invalidate(id: string): void;
+    invalidateAll(): void;
+    private isExpired;
+}

package/dist/infrastructure/database/account-cache.js

@@ -0,0 +1,44 @@
+export class AccountCache {
+    cache = new Map();
+    allAccountsCache = null;
+    lastUpdate = 0;
+    ttl;
+    constructor(ttlMs = 60000) {
+        this.ttl = ttlMs;
+    }
+    getAll() {
+        if (this.isExpired()) {
+            return null;
+        }
+        return this.allAccountsCache ? [...this.allAccountsCache] : null;
+    }
+    setAll(accounts) {
+        this.allAccountsCache = [...accounts];
+        this.lastUpdate = Date.now();
+        for (const acc of accounts) {
+            this.cache.set(acc.id, acc);
+        }
+    }
+    get(id) {
+        if (this.isExpired()) {
+            return null;
+        }
+        return this.cache.get(id) || null;
+    }
+    set(id, account) {
+        this.cache.set(id, account);
+        this.lastUpdate = Date.now();
+    }
+    invalidate(id) {
+        this.cache.delete(id);
+        this.allAccountsCache = null;
+    }
+    invalidateAll() {
+        this.cache.clear();
+        this.allAccountsCache = null;
+        this.lastUpdate = 0;
+    }
+    isExpired() {
+        return Date.now() - this.lastUpdate > this.ttl;
+    }
+}

package/dist/infrastructure/database/account-repository.d.ts

@@ -0,0 +1,12 @@
+import { AccountCache } from './account-cache.js';
+export declare class AccountRepository {
+    private cache;
+    constructor(cache: AccountCache);
+    findAll(): Promise<any[]>;
+    findById(id: string): Promise<any | null>;
+    save(account: any): Promise<void>;
+    delete(id: string): Promise<void>;
+    findHealthyAccounts(): Promise<any[]>;
+    batchSave(accounts: any[]): Promise<void>;
+    invalidateCache(): void;
+}

package/dist/infrastructure/database/account-repository.js

@@ -0,0 +1,64 @@
+import { kiroDb } from '../../plugin/storage/sqlite.js';
+export class AccountRepository {
+    cache;
+    constructor(cache) {
+        this.cache = cache;
+    }
+    async findAll() {
+        const cached = this.cache.getAll();
+        if (cached) {
+            return cached;
+        }
+        const rows = kiroDb.getAccounts();
+        const accounts = rows.map((r) => ({
+            id: r.id,
+            email: r.email,
+            authMethod: r.auth_method,
+            region: r.region,
+            clientId: r.client_id,
+            clientSecret: r.client_secret,
+            profileArn: r.profile_arn,
+            refreshToken: r.refresh_token,
+            accessToken: r.access_token,
+            expiresAt: r.expires_at,
+            rateLimitResetTime: r.rate_limit_reset,
+            isHealthy: r.is_healthy === 1,
+            unhealthyReason: r.unhealthy_reason,
+            recoveryTime: r.recovery_time,
+            failCount: r.fail_count || 0,
+            lastUsed: r.last_used,
+            usedCount: r.used_count,
+            limitCount: r.limit_count,
+            lastSync: r.last_sync
+        }));
+        this.cache.setAll(accounts);
+        return accounts;
+    }
+    async findById(id) {
+        const cached = this.cache.get(id);
+        if (cached) {
+            return cached;
+        }
+        const accounts = await this.findAll();
+        return accounts.find((a) => a.id === id) || null;
+    }
+    async save(account) {
+        await kiroDb.upsertAccount(account);
+        this.cache.invalidate(account.id);
+    }
+    async delete(id) {
+        await kiroDb.deleteAccount(id);
+        this.cache.invalidate(id);
+    }
+    async findHealthyAccounts() {
+        const all = await this.findAll();
+        return all.filter((a) => a.isHealthy);
+    }
+    async batchSave(accounts) {
+        await kiroDb.batchUpsertAccounts(accounts);
+        this.cache.invalidateAll();
+    }
+    invalidateCache() {
+        this.cache.invalidateAll();
+    }
+}

package/dist/infrastructure/index.d.ts

@@ -0,0 +1,7 @@
+export * from './database/account-cache.js';
+export * from './database/account-repository.js';
+export * from './transformers/event-stream-parser.js';
+export * from './transformers/history-builder.js';
+export * from './transformers/message-transformer.js';
+export * from './transformers/tool-call-parser.js';
+export * from './transformers/tool-transformer.js';

package/dist/infrastructure/index.js

@@ -0,0 +1,7 @@
+export * from './database/account-cache.js';
+export * from './database/account-repository.js';
+export * from './transformers/event-stream-parser.js';
+export * from './transformers/history-builder.js';
+export * from './transformers/message-transformer.js';
+export * from './transformers/tool-call-parser.js';
+export * from './transformers/tool-transformer.js';

package/dist/infrastructure/transformers/event-stream-parser.d.ts

@@ -0,0 +1,7 @@
+interface ParsedEvent {
+    type: string;
+    data: any;
+}
+export declare function parseAwsEventStreamBuffer(buffer: string): ParsedEvent[];
+export declare function parseEventLine(line: string): any | null;
+export {};

package/dist/infrastructure/transformers/event-stream-parser.js

@@ -0,0 +1,115 @@
+export function parseAwsEventStreamBuffer(buffer) {
+    const events = [];
+    let remaining = buffer;
+    let searchStart = 0;
+    while (true) {
+        const contentStart = remaining.indexOf('{"content":', searchStart);
+        const nameStart = remaining.indexOf('{"name":', searchStart);
+        const followupStart = remaining.indexOf('{"followupPrompt":', searchStart);
+        const inputStart = remaining.indexOf('{"input":', searchStart);
+        const stopStart = remaining.indexOf('{"stop":', searchStart);
+        const contextUsageStart = remaining.indexOf('{"contextUsagePercentage":', searchStart);
+        const candidates = [
+            contentStart,
+            nameStart,
+            followupStart,
+            inputStart,
+            stopStart,
+            contextUsageStart
+        ].filter((pos) => pos >= 0);
+        if (candidates.length === 0)
+            break;
+        const jsonStart = Math.min(...candidates);
+        if (jsonStart < 0)
+            break;
+        let braceCount = 0;
+        let jsonEnd = -1;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = jsonStart; i < remaining.length; i++) {
+            const char = remaining[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (!inString) {
+                if (char === '{') {
+                    braceCount++;
+                }
+                else if (char === '}') {
+                    braceCount--;
+                    if (braceCount === 0) {
+                        jsonEnd = i;
+                        break;
+                    }
+                }
+            }
+        }
+        if (jsonEnd < 0) {
+            break;
+        }
+        const jsonStr = remaining.substring(jsonStart, jsonEnd + 1);
+        const parsed = parseEventLine(jsonStr);
+        if (parsed) {
+            if (parsed.content !== undefined && !parsed.followupPrompt) {
+                events.push({ type: 'content', data: parsed.content });
+            }
+            else if (parsed.name && parsed.toolUseId) {
+                events.push({
+                    type: 'toolUse',
+                    data: {
+                        name: parsed.name,
+                        toolUseId: parsed.toolUseId,
+                        input: parsed.input || '',
+                        stop: parsed.stop || false
+                    }
+                });
+            }
+            else if (parsed.input !== undefined && !parsed.name) {
+                events.push({
+                    type: 'toolUseInput',
+                    data: {
+                        input: parsed.input
+                    }
+                });
+            }
+            else if (parsed.stop !== undefined && parsed.contextUsagePercentage === undefined) {
+                events.push({
+                    type: 'toolUseStop',
+                    data: {
+                        stop: parsed.stop
+                    }
+                });
+            }
+            else if (parsed.contextUsagePercentage !== undefined) {
+                events.push({
+                    type: 'contextUsage',
+                    data: {
+                        contextUsagePercentage: parsed.contextUsagePercentage
+                    }
+                });
+            }
+        }
+        searchStart = jsonEnd + 1;
+        if (searchStart >= remaining.length) {
+            break;
+        }
+    }
+    return events;
+}
+export function parseEventLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (e) {
+        return null;
+    }
+}

package/dist/infrastructure/transformers/history-builder.d.ts

@@ -0,0 +1,5 @@
+import type { CodeWhispererMessage } from '../../plugin/types';
+export declare function buildHistory(msgs: any[], resolved: string, system: string | undefined, toolResultLimit: number): CodeWhispererMessage[];
+export declare function truncateHistory(history: CodeWhispererMessage[], historyLimit: number): CodeWhispererMessage[];
+export declare function historyHasToolCalling(history: CodeWhispererMessage[]): boolean;
+export declare function extractToolNamesFromHistory(history: CodeWhispererMessage[]): Set<string>;

package/dist/infrastructure/transformers/history-builder.js

@@ -0,0 +1,171 @@
+import { KIRO_CONSTANTS } from '../../constants.js';
+import { convertImagesToKiroFormat, extractAllImages, extractTextFromParts } from '../../plugin/image-handler.js';
+import { getContentText, sanitizeHistory, truncate } from './message-transformer.js';
+import { deduplicateToolResults } from './tool-transformer.js';
+export function buildHistory(msgs, resolved, system, toolResultLimit) {
+    let history = [];
+    let firstUserIndex = -1;
+    for (let i = 0; i < msgs.length; i++) {
+        if (msgs[i].role === 'user') {
+            firstUserIndex = i;
+            break;
+        }
+    }
+    if (system) {
+        if (firstUserIndex !== -1) {
+            const m = msgs[firstUserIndex];
+            const oldContent = getContentText(m);
+            if (Array.isArray(m.content)) {
+                m.content = [
+                    { type: 'text', text: `${system}\n\n${oldContent}` },
+                    ...m.content.filter((p) => p.type !== 'text')
+                ];
+            }
+            else
+                m.content = `${system}\n\n${oldContent}`;
+        }
+        else {
+            history.push({
+                userInputMessage: {
+                    content: system,
+                    modelId: resolved,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+                }
+            });
+        }
+    }
+    for (let i = 0; i < msgs.length - 1; i++) {
+        const m = msgs[i];
+        if (!m)
+            continue;
+        if (m.role === 'user') {
+            const uim = { content: '', modelId: resolved, origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR };
+            const trs = [];
+            if (Array.isArray(m.content)) {
+                uim.content = extractTextFromParts(m.content);
+                for (const p of m.content) {
+                    if (p.type === 'tool_result') {
+                        trs.push({
+                            content: [{ text: truncate(getContentText(p.content || p), toolResultLimit) }],
+                            status: 'success',
+                            toolUseId: p.tool_use_id
+                        });
+                    }
+                }
+                const unifiedImages = extractAllImages(m.content);
+                if (unifiedImages.length > 0) {
+                    uim.images = convertImagesToKiroFormat(unifiedImages);
+                }
+            }
+            else {
+                uim.content = getContentText(m);
+            }
+            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') {
+            const trs = [];
+            if (m.tool_results) {
+                for (const tr of m.tool_results)
+                    trs.push({
+                        content: [{ text: truncate(getContentText(tr), toolResultLimit) }],
+                        status: 'success',
+                        toolUseId: tr.tool_call_id
+                    });
+            }
+            else {
+                trs.push({
+                    content: [{ text: truncate(getContentText(m), toolResultLimit) }],
+                    status: 'success',
+                    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.',
+                    modelId: resolved,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR,
+                    userInputMessageContext: { toolResults: deduplicateToolResults(trs) }
+                }
+            });
+        }
+        else if (m.role === 'assistant') {
+            const arm = { content: '' };
+            const tus = [];
+            let th = '';
+            if (Array.isArray(m.content)) {
+                for (const p of m.content) {
+                    if (p.type === 'text')
+                        arm.content += p.text || '';
+                    else if (p.type === 'thinking')
+                        th += p.thinking || p.text || '';
+                    else if (p.type === 'tool_use')
+                        tus.push({ input: p.input, name: p.name, toolUseId: p.id });
+                }
+            }
+            else
+                arm.content = getContentText(m);
+            if (m.tool_calls && Array.isArray(m.tool_calls)) {
+                for (const tc of m.tool_calls) {
+                    tus.push({
+                        input: typeof tc.function?.arguments === 'string'
+                            ? JSON.parse(tc.function.arguments)
+                            : tc.function?.arguments,
+                        name: tc.function?.name,
+                        toolUseId: tc.id
+                    });
+                }
+            }
+            if (th)
+                arm.content = arm.content
+                    ? `<thinking>${th}</thinking>\n\n${arm.content}`
+                    : `<thinking>${th}</thinking>`;
+            if (tus.length)
+                arm.toolUses = tus;
+            if (!arm.content && !arm.toolUses) {
+                continue;
+            }
+            history.push({ assistantResponseMessage: arm });
+        }
+    }
+    return history;
+}
+export function truncateHistory(history, historyLimit) {
+    let sanitized = sanitizeHistory(history);
+    let historySize = JSON.stringify(sanitized).length;
+    while (historySize > historyLimit && sanitized.length > 2) {
+        sanitized.shift();
+        while (sanitized.length > 0) {
+            const first = sanitized[0];
+            if (first && first.userInputMessage)
+                break;
+            sanitized.shift();
+        }
+        sanitized = sanitizeHistory(sanitized);
+        historySize = JSON.stringify(sanitized).length;
+    }
+    return sanitized;
+}
+export function historyHasToolCalling(history) {
+    return history.some((h) => h.assistantResponseMessage?.toolUses ||
+        h.userInputMessage?.userInputMessageContext?.toolResults);
+}
+export function extractToolNamesFromHistory(history) {
+    const toolNames = new Set();
+    for (const h of history) {
+        if (h.assistantResponseMessage?.toolUses) {
+            for (const tu of h.assistantResponseMessage.toolUses) {
+                if (tu.name)
+                    toolNames.add(tu.name);
+            }
+        }
+    }
+    return toolNames;
+}

package/dist/infrastructure/transformers/message-transformer.d.ts

@@ -0,0 +1,6 @@
+import type { CodeWhispererMessage } from '../../plugin/types';
+export declare function sanitizeHistory(history: CodeWhispererMessage[]): CodeWhispererMessage[];
+export declare function findOriginalToolCall(msgs: any[], toolUseId: string): any | null;
+export declare function mergeAdjacentMessages(msgs: any[]): any[];
+export declare function getContentText(m: any): string;
+export declare function truncate(s: string, max: number): string;

package/dist/infrastructure/transformers/message-transformer.js

@@ -0,0 +1,102 @@
+export 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);
+        }
+    }
+    if (result.length > 0) {
+        const first = result[0];
+        if (!first ||
+            !first.userInputMessage ||
+            first.userInputMessage.userInputMessageContext?.toolResults) {
+            return [];
+        }
+    }
+    return result;
+}
+export function findOriginalToolCall(msgs, toolUseId) {
+    for (const m of msgs) {
+        if (m.role === 'assistant') {
+            if (m.tool_calls) {
+                for (const tc of m.tool_calls)
+                    if (tc.id === toolUseId)
+                        return tc;
+            }
+            if (Array.isArray(m.content)) {
+                for (const p of m.content)
+                    if (p.type === 'tool_use' && p.id === toolUseId)
+                        return p;
+            }
+        }
+    }
+    return null;
+}
+export function mergeAdjacentMessages(msgs) {
+    const merged = [];
+    for (const m of msgs) {
+        if (!merged.length)
+            merged.push({ ...m });
+        else {
+            const last = merged[merged.length - 1];
+            if (last && m.role === last.role) {
+                if (Array.isArray(last.content) && Array.isArray(m.content))
+                    last.content.push(...m.content);
+                else if (typeof last.content === 'string' && typeof m.content === 'string')
+                    last.content += '\n' + m.content;
+                else if (Array.isArray(last.content) && typeof m.content === 'string')
+                    last.content.push({ type: 'text', text: m.content });
+                else if (typeof last.content === 'string' && Array.isArray(m.content))
+                    last.content = [{ type: 'text', text: last.content }, ...m.content];
+                if (m.tool_calls) {
+                    if (!last.tool_calls)
+                        last.tool_calls = [];
+                    last.tool_calls.push(...m.tool_calls);
+                }
+                if (m.role === 'tool') {
+                    if (!last.tool_results)
+                        last.tool_results = [{ content: last.content, tool_call_id: last.tool_call_id }];
+                    last.tool_results.push({ content: m.content, tool_call_id: m.tool_call_id });
+                }
+            }
+            else
+                merged.push({ ...m });
+        }
+    }
+    return merged;
+}
+export function getContentText(m) {
+    if (!m)
+        return '';
+    if (typeof m === 'string')
+        return m;
+    if (typeof m.content === 'string')
+        return m.content;
+    if (Array.isArray(m.content))
+        return m.content
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text || '')
+            .join('');
+    return m.text || '';
+}
+export 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);
+}