@sunerpy/opencode-kiro-auth 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+export { KiroOAuthPlugin } from './plugin.js';
+export type { KiroConfig } from './plugin/config/index.js';
+export type { KiroAuthMethod, KiroRegion, ManagedAccount } from './plugin/types.js';
+declare const _default: {
+    id: string;
+    server: ({ client, directory }: any) => Promise<{
+        config: (input: any) => Promise<void>;
+        auth: {
+            provider: string;
+            loader: (getAuth: any) => Promise<{
+                apiKey: string;
+                baseURL: string;
+                fetch: (input: any, init?: any) => Promise<Response>;
+            }>;
+            methods: ({
+                type: "oauth";
+                label: string;
+                prompts?: Array<{
+                    type: "text";
+                    key: string;
+                    message: string;
+                    placeholder?: string;
+                    validate?: (value: string) => string | undefined;
+                    condition?: (inputs: Record<string, string>) => boolean;
+                    when?: {
+                        key: string;
+                        op: "eq" | "neq";
+                        value: string;
+                    };
+                } | {
+                    type: "select";
+                    key: string;
+                    message: string;
+                    options: Array<{
+                        label: string;
+                        value: string;
+                        hint?: string;
+                    }>;
+                    condition?: (inputs: Record<string, string>) => boolean;
+                    when?: {
+                        key: string;
+                        op: "eq" | "neq";
+                        value: string;
+                    };
+                }>;
+                authorize(inputs?: Record<string, string>): Promise<import("@opencode-ai/plugin").AuthOAuthResult>;
+            } | {
+                type: "api";
+                label: string;
+                prompts?: Array<{
+                    type: "text";
+                    key: string;
+                    message: string;
+                    placeholder?: string;
+                    validate?: (value: string) => string | undefined;
+                    condition?: (inputs: Record<string, string>) => boolean;
+                    when?: {
+                        key: string;
+                        op: "eq" | "neq";
+                        value: string;
+                    };
+                } | {
+                    type: "select";
+                    key: string;
+                    message: string;
+                    options: Array<{
+                        label: string;
+                        value: string;
+                        hint?: string;
+                    }>;
+                    condition?: (inputs: Record<string, string>) => boolean;
+                    when?: {
+                        key: string;
+                        op: "eq" | "neq";
+                        value: string;
+                    };
+                }>;
+                authorize?(inputs?: Record<string, string>): Promise<{
+                    type: "success";
+                    key: string;
+                    provider?: string;
+                    metadata?: Record<string, string>;
+                } | {
+                    type: "failed";
+                }>;
+            })[];
+        };
+        provider: {
+            id: string;
+            models: (provider: any) => Promise<Record<string, any>>;
+        };
+    }>;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,2 @@
+export { KiroOAuthPlugin } from './plugin.js';
+export default { id: 'kiro-auth', server: (await import('./plugin.js')).KiroOAuthPlugin };

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,66 @@
+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,
+            oidcRegion: r.oidc_region || undefined,
+            clientId: r.client_id,
+            clientSecret: r.client_secret,
+            profileArn: r.profile_arn,
+            startUrl: r.start_url || undefined,
+            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,16 @@
+import type { CodeWhispererMessage } from '../../plugin/types.js';
+/**
+ * Collapse agentic loop sequences in the built history.
+ *
+ * Each agentic iteration gets a fresh conversationId, so the model re-derives its preamble
+ * (intent detection, greeting) every iteration. When replayed for the next user turn, the
+ * model sees duplicate preambles and gets confused.
+ *
+ * Strips text from intermediate ASST(toolUses)→USER(toolResults) pairs, keeping only the
+ * first assistant text and all tool_use/tool_result pairs.
+ */
+export declare function collapseAgenticLoops(history: CodeWhispererMessage[]): CodeWhispererMessage[];
+export declare function buildHistory(msgs: any[], resolved: string): CodeWhispererMessage[];
+export declare function injectSystemPrompt(history: CodeWhispererMessage[], system: string | undefined, resolved: string): 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,226 @@
+import { KIRO_CONSTANTS } from '../../constants.js';
+import { convertImagesToKiroFormat, extractAllImages, extractTextFromParts } from '../../plugin/image-handler.js';
+import { getContentText } from './message-transformer.js';
+import { deduplicateToolResults } from './tool-transformer.js';
+/**
+ * Collapse agentic loop sequences in the built history.
+ *
+ * Each agentic iteration gets a fresh conversationId, so the model re-derives its preamble
+ * (intent detection, greeting) every iteration. When replayed for the next user turn, the
+ * model sees duplicate preambles and gets confused.
+ *
+ * Strips text from intermediate ASST(toolUses)→USER(toolResults) pairs, keeping only the
+ * first assistant text and all tool_use/tool_result pairs.
+ */
+export function collapseAgenticLoops(history) {
+    if (history.length < 4)
+        return history;
+    const result = [];
+    let i = 0;
+    while (i < history.length) {
+        const entry = history[i];
+        if (entry?.assistantResponseMessage?.toolUses &&
+            i + 1 < history.length &&
+            history[i + 1]?.userInputMessage?.userInputMessageContext?.toolResults) {
+            const seqStart = i;
+            let j = i;
+            while (j < history.length) {
+                const asst = history[j];
+                if (!asst?.assistantResponseMessage?.toolUses)
+                    break;
+                const nextUser = j + 1 < history.length ? history[j + 1] : null;
+                if (!nextUser?.userInputMessage?.userInputMessageContext?.toolResults)
+                    break;
+                j += 2;
+            }
+            const seqEnd = j;
+            const pairCount = (seqEnd - seqStart) / 2;
+            if (pairCount > 1) {
+                for (let k = seqStart; k < seqEnd; k += 2) {
+                    const asst = history[k];
+                    const user = history[k + 1];
+                    if (k === seqStart) {
+                        result.push(asst);
+                    }
+                    else {
+                        result.push({
+                            assistantResponseMessage: {
+                                content: '[system: tool calling continues]',
+                                toolUses: asst.assistantResponseMessage.toolUses
+                            }
+                        });
+                    }
+                    result.push(user);
+                }
+            }
+            else {
+                for (let k = seqStart; k < seqEnd; k++) {
+                    result.push(history[k]);
+                }
+            }
+            i = seqEnd;
+        }
+        else {
+            result.push(entry);
+            i++;
+        }
+    }
+    return result;
+}
+export function buildHistory(msgs, resolved) {
+    let history = [];
+    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: getContentText(p.content || p) }],
+                            status: 'success',
+                            toolUseId: p.tool_use_id
+                        });
+                    }
+                }
+                const unifiedImages = extractAllImages(m.content);
+                if (unifiedImages.length > 0) {
+                    const { images, omitted } = convertImagesToKiroFormat(unifiedImages);
+                    uim.images = images;
+                    if (omitted > 0) {
+                        uim.content += `\n\n[${omitted} image(s) omitted due to API limits]`;
+                    }
+                }
+            }
+            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: '[system: conversation continues]' } });
+            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: getContentText(tr) }],
+                        status: 'success',
+                        toolUseId: tr.tool_call_id
+                    });
+            }
+            else {
+                trs.push({
+                    content: [{ text: getContentText(m) }],
+                    status: 'success',
+                    toolUseId: m.tool_call_id
+                });
+            }
+            const prev = history[history.length - 1];
+            if (prev && prev.userInputMessage)
+                history.push({ assistantResponseMessage: { content: '[system: conversation continues]' } });
+            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;
+            }
+            const prevMsg = history[history.length - 1];
+            if (prevMsg && prevMsg.assistantResponseMessage) {
+                // Merge consecutive assistant messages instead of injecting synthetic user turn
+                const prev = prevMsg.assistantResponseMessage;
+                if (arm.content) {
+                    prev.content = prev.content ? `${prev.content}\n\n${arm.content}` : arm.content;
+                }
+                if (arm.toolUses) {
+                    prev.toolUses = [...(prev.toolUses || []), ...arm.toolUses];
+                }
+            }
+            else {
+                history.push({ assistantResponseMessage: arm });
+            }
+        }
+    }
+    return collapseAgenticLoops(history);
+}
+export function injectSystemPrompt(history, system, resolved) {
+    if (!system)
+        return history;
+    const firstUserMsg = history.find((h) => !!h.userInputMessage);
+    if (firstUserMsg && firstUserMsg.userInputMessage) {
+        const oldContent = firstUserMsg.userInputMessage.content || '';
+        firstUserMsg.userInputMessage.content = `${system}\n\n${oldContent}`;
+    }
+    else {
+        history.unshift({
+            userInputMessage: {
+                content: system,
+                modelId: resolved,
+                origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+            }
+        });
+    }
+    return history;
+}
+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,5 @@
+import type { CodeWhispererMessage } from '../../plugin/types.js';
+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;