@kervnet/opencode-kiro-auth 1.5.1

package/dist/plugin/storage/migrations.js

@@ -0,0 +1,109 @@
+export function runMigrations(db) {
+    migrateToUniqueRefreshToken(db);
+    migrateRealEmailColumn(db);
+    migrateUsageTable(db);
+}
+function migrateToUniqueRefreshToken(db) {
+    const hasIndex = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_refresh_token_unique'")
+        .get();
+    if (hasIndex)
+        return;
+    db.run('BEGIN TRANSACTION');
+    try {
+        const duplicates = db
+            .prepare(`
+        SELECT refresh_token, COUNT(*) as count 
+        FROM accounts 
+        GROUP BY refresh_token 
+        HAVING count > 1
+      `)
+            .all();
+        for (const dup of duplicates) {
+            const accounts = db
+                .prepare('SELECT * FROM accounts WHERE refresh_token = ? ORDER BY last_used DESC, expires_at DESC')
+                .all(dup.refresh_token);
+            if (accounts.length > 1) {
+                const keep = accounts[0];
+                const remove = accounts.slice(1);
+                const mergedUsedCount = Math.max(...accounts.map((a) => a.used_count || 0));
+                const mergedLimitCount = Math.max(...accounts.map((a) => a.limit_count || 0));
+                const mergedLastUsed = Math.max(...accounts.map((a) => a.last_used || 0));
+                const mergedFailCount = Math.max(...accounts.map((a) => a.fail_count || 0));
+                db.prepare(`
+            UPDATE accounts SET 
+              used_count = ?, 
+              limit_count = ?, 
+              last_used = ?,
+              fail_count = ?
+            WHERE id = ?
+          `).run(mergedUsedCount, mergedLimitCount, mergedLastUsed, mergedFailCount, keep.id);
+                for (const acc of remove) {
+                    db.prepare('DELETE FROM accounts WHERE id = ?').run(acc.id);
+                }
+            }
+        }
+        db.run('CREATE UNIQUE INDEX idx_refresh_token_unique ON accounts(refresh_token)');
+        db.run('COMMIT');
+    }
+    catch (e) {
+        db.run('ROLLBACK');
+        throw e;
+    }
+}
+function migrateRealEmailColumn(db) {
+    const columns = db.prepare('PRAGMA table_info(accounts)').all();
+    const names = new Set(columns.map((c) => c.name));
+    if (names.has('real_email')) {
+        db.run('BEGIN TRANSACTION');
+        try {
+            db.run("UPDATE accounts SET email = real_email WHERE real_email IS NOT NULL AND real_email != '' AND email LIKE 'builder-id@aws.amazon.com%'");
+            db.run(`
+          CREATE TABLE accounts_new (
+            id TEXT PRIMARY KEY, email TEXT NOT NULL, auth_method TEXT NOT NULL,
+            region TEXT NOT NULL, client_id TEXT, client_secret TEXT, profile_arn TEXT,
+            refresh_token TEXT NOT NULL, access_token TEXT NOT NULL, expires_at INTEGER NOT NULL,
+            rate_limit_reset INTEGER DEFAULT 0, is_healthy INTEGER DEFAULT 1, unhealthy_reason TEXT,
+            recovery_time INTEGER, fail_count INTEGER DEFAULT 0, last_used INTEGER DEFAULT 0,
+            used_count INTEGER DEFAULT 0, limit_count INTEGER DEFAULT 0, last_sync INTEGER DEFAULT 0
+          )
+        `);
+            db.run(`
+          INSERT INTO accounts_new (id, email, auth_method, region, client_id, client_secret, profile_arn, refresh_token, access_token, expires_at, rate_limit_reset, is_healthy, unhealthy_reason, recovery_time, fail_count, last_used, used_count, limit_count, last_sync)
+          SELECT id, email, auth_method, region, client_id, client_secret, profile_arn, refresh_token, access_token, expires_at, COALESCE(rate_limit_reset, 0), COALESCE(is_healthy, 1), unhealthy_reason, recovery_time, COALESCE(fail_count, 0), COALESCE(last_used, 0), 0, 0, 0 FROM accounts
+        `);
+            db.run('DROP TABLE accounts');
+            db.run('ALTER TABLE accounts_new RENAME TO accounts');
+            db.run('COMMIT');
+        }
+        catch (e) {
+            db.run('ROLLBACK');
+        }
+    }
+    else {
+        const needed = {
+            fail_count: 'INTEGER DEFAULT 0',
+            used_count: 'INTEGER DEFAULT 0',
+            limit_count: 'INTEGER DEFAULT 0',
+            last_sync: 'INTEGER DEFAULT 0'
+        };
+        for (const [n, d] of Object.entries(needed)) {
+            if (!names.has(n))
+                db.run(`ALTER TABLE accounts ADD COLUMN ${n} ${d}`);
+        }
+    }
+}
+function migrateUsageTable(db) {
+    const hasUsageTable = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='usage'")
+        .get();
+    if (hasUsageTable) {
+        db.run(`
+        UPDATE accounts SET 
+          used_count = COALESCE((SELECT used_count FROM usage WHERE usage.account_id = accounts.id), used_count),
+          limit_count = COALESCE((SELECT limit_count FROM usage WHERE usage.account_id = accounts.id), limit_count),
+          last_sync = COALESCE((SELECT last_sync FROM usage WHERE usage.account_id = accounts.id), last_sync)
+      `);
+        db.run('DROP TABLE usage');
+    }
+}

package/dist/plugin/storage/sqlite.d.ts

@@ -0,0 +1,17 @@
+import type { ManagedAccount } from '../types';
+export declare const DB_PATH: string;
+export declare class KiroDatabase {
+    private db;
+    private path;
+    constructor(path?: string);
+    private init;
+    getAccounts(): any[];
+    private upsertAccountInternal;
+    upsertAccount(acc: ManagedAccount): Promise<void>;
+    batchUpsertAccounts(accounts: ManagedAccount[]): Promise<void>;
+    deleteAccount(id: string): Promise<void>;
+    private rowToAccount;
+    close(): void;
+}
+export declare function createDatabase(path?: string): KiroDatabase;
+export declare const kiroDb: KiroDatabase;

package/dist/plugin/storage/sqlite.js

@@ -0,0 +1,134 @@
+import { Database } from 'bun:sqlite';
+import { existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { deduplicateAccounts, mergeAccounts, withDatabaseLock } from './locked-operations';
+import { runMigrations } from './migrations';
+function getBaseDir() {
+    const p = process.platform;
+    if (p === 'win32')
+        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'opencode');
+    return join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'opencode');
+}
+export const DB_PATH = join(getBaseDir(), 'kiro.db');
+export class KiroDatabase {
+    db;
+    path;
+    constructor(path = DB_PATH) {
+        this.path = path;
+        const dir = join(path, '..');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        this.db = new Database(path);
+        this.db.run('PRAGMA busy_timeout = 5000');
+        this.init();
+    }
+    init() {
+        this.db.run('PRAGMA journal_mode = WAL');
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS accounts (
+        id TEXT PRIMARY KEY, email TEXT NOT NULL, auth_method TEXT NOT NULL,
+        region TEXT NOT NULL, client_id TEXT, client_secret TEXT, profile_arn TEXT,
+        refresh_token TEXT NOT NULL, access_token TEXT NOT NULL, expires_at INTEGER NOT NULL,
+        rate_limit_reset INTEGER DEFAULT 0, is_healthy INTEGER DEFAULT 1, unhealthy_reason TEXT,
+        recovery_time INTEGER, fail_count INTEGER DEFAULT 0, last_used INTEGER DEFAULT 0,
+        used_count INTEGER DEFAULT 0, limit_count INTEGER DEFAULT 0, last_sync INTEGER DEFAULT 0
+      )
+    `);
+        runMigrations(this.db);
+    }
+    getAccounts() {
+        return this.db.prepare('SELECT * FROM accounts').all();
+    }
+    upsertAccountInternal(acc) {
+        this.db
+            .prepare(`
+      INSERT INTO accounts (
+        id, email, auth_method, region, client_id, client_secret,
+        profile_arn, refresh_token, access_token, expires_at, rate_limit_reset,
+        is_healthy, unhealthy_reason, recovery_time, fail_count, last_used,
+        used_count, limit_count, last_sync
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(refresh_token) DO UPDATE SET
+        id=excluded.id, email=excluded.email, auth_method=excluded.auth_method,
+        region=excluded.region, client_id=excluded.client_id, client_secret=excluded.client_secret,
+        profile_arn=excluded.profile_arn, access_token=excluded.access_token, expires_at=excluded.expires_at,
+        rate_limit_reset=excluded.rate_limit_reset, is_healthy=excluded.is_healthy,
+        unhealthy_reason=excluded.unhealthy_reason, recovery_time=excluded.recovery_time,
+        fail_count=excluded.fail_count, last_used=excluded.last_used,
+        used_count=excluded.used_count, limit_count=excluded.limit_count, last_sync=excluded.last_sync
+    `)
+            .run(acc.id, acc.email, acc.authMethod, acc.region, acc.clientId || null, acc.clientSecret || null, acc.profileArn || null, acc.refreshToken, acc.accessToken, acc.expiresAt, acc.rateLimitResetTime || 0, acc.isHealthy ? 1 : 0, acc.unhealthyReason || null, acc.recoveryTime || null, acc.failCount || 0, acc.lastUsed || 0, acc.usedCount || 0, acc.limitCount || 0, acc.lastSync || 0);
+    }
+    async upsertAccount(acc) {
+        await withDatabaseLock(this.path, async () => {
+            const existing = this.getAccounts().map(this.rowToAccount);
+            const merged = mergeAccounts(existing, [acc]);
+            const deduplicated = deduplicateAccounts(merged);
+            this.db.run('BEGIN TRANSACTION');
+            try {
+                for (const account of deduplicated) {
+                    this.upsertAccountInternal(account);
+                }
+                this.db.run('COMMIT');
+            }
+            catch (e) {
+                this.db.run('ROLLBACK');
+                throw e;
+            }
+        });
+    }
+    async batchUpsertAccounts(accounts) {
+        await withDatabaseLock(this.path, async () => {
+            const existing = this.getAccounts().map(this.rowToAccount);
+            const merged = mergeAccounts(existing, accounts);
+            const deduplicated = deduplicateAccounts(merged);
+            this.db.run('BEGIN TRANSACTION');
+            try {
+                for (const account of deduplicated) {
+                    this.upsertAccountInternal(account);
+                }
+                this.db.run('COMMIT');
+            }
+            catch (e) {
+                this.db.run('ROLLBACK');
+                throw e;
+            }
+        });
+    }
+    async deleteAccount(id) {
+        await withDatabaseLock(this.path, async () => {
+            this.db.prepare('DELETE FROM accounts WHERE id = ?').run(id);
+        });
+    }
+    rowToAccount(row) {
+        return {
+            id: row.id,
+            email: row.email,
+            authMethod: row.auth_method,
+            region: row.region,
+            clientId: row.client_id,
+            clientSecret: row.client_secret,
+            profileArn: row.profile_arn,
+            refreshToken: row.refresh_token,
+            accessToken: row.access_token,
+            expiresAt: row.expires_at,
+            rateLimitResetTime: row.rate_limit_reset,
+            isHealthy: row.is_healthy === 1,
+            unhealthyReason: row.unhealthy_reason,
+            recoveryTime: row.recovery_time,
+            failCount: row.fail_count,
+            lastUsed: row.last_used,
+            usedCount: row.used_count,
+            limitCount: row.limit_count,
+            lastSync: row.last_sync
+        };
+    }
+    close() {
+        this.db.close();
+    }
+}
+export function createDatabase(path) {
+    return new KiroDatabase(path);
+}
+export const kiroDb = new KiroDatabase();

package/dist/plugin/streaming/index.d.ts

@@ -0,0 +1,2 @@
+export { findRealTag } from './stream-parser.js';
+export { transformKiroStream } from './stream-transformer.js';

package/dist/plugin/streaming/index.js

@@ -0,0 +1,2 @@
+export { findRealTag } from './stream-parser.js';
+export { transformKiroStream } from './stream-transformer.js';

package/dist/plugin/streaming/openai-converter.d.ts

@@ -0,0 +1,2 @@
+import { StreamEvent } from './types.js';
+export declare function convertToOpenAI(event: StreamEvent, id: string, model: string): any;

package/dist/plugin/streaming/openai-converter.js

@@ -0,0 +1,68 @@
+export function convertToOpenAI(event, id, model) {
+    const base = {
+        id,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: []
+    };
+    if (event.type === 'content_block_delta') {
+        if (event.delta.type === 'text_delta') {
+            base.choices.push({
+                index: 0,
+                delta: { content: event.delta.text },
+                finish_reason: null
+            });
+        }
+        else if (event.delta.type === 'thinking_delta') {
+            base.choices.push({
+                index: 0,
+                delta: { reasoning_content: event.delta.thinking },
+                finish_reason: null
+            });
+        }
+        else if (event.delta.type === 'input_json_delta') {
+            base.choices.push({
+                index: 0,
+                delta: {
+                    tool_calls: [
+                        {
+                            index: event.index,
+                            function: { arguments: event.delta.partial_json }
+                        }
+                    ]
+                },
+                finish_reason: null
+            });
+        }
+    }
+    else if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+        base.choices.push({
+            index: 0,
+            delta: {
+                tool_calls: [
+                    {
+                        index: event.index,
+                        id: event.content_block.id,
+                        type: 'function',
+                        function: { name: event.content_block.name, arguments: '' }
+                    }
+                ]
+            },
+            finish_reason: null
+        });
+    }
+    else if (event.type === 'message_delta') {
+        base.choices.push({
+            index: 0,
+            delta: {},
+            finish_reason: event.delta.stop_reason === 'tool_use' ? 'tool_calls' : 'stop'
+        });
+        base.usage = {
+            prompt_tokens: event.usage?.input_tokens || 0,
+            completion_tokens: event.usage?.output_tokens || 0,
+            total_tokens: (event.usage?.input_tokens || 0) + (event.usage?.output_tokens || 0)
+        };
+    }
+    return base;
+}

package/dist/plugin/streaming/stream-parser.d.ts

@@ -0,0 +1,5 @@
+export declare function parseStreamBuffer(buffer: string): {
+    events: any[];
+    remaining: string;
+};
+export declare function findRealTag(buffer: string, tag: string): number;

package/dist/plugin/streaming/stream-parser.js

@@ -0,0 +1,136 @@
+import { parseEventLine } from '../../infrastructure/transformers/event-stream-parser.js';
+export function parseStreamBuffer(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) {
+            remaining = remaining.substring(jsonStart);
+            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) {
+            remaining = '';
+            break;
+        }
+    }
+    if (searchStart > 0 && remaining.length > 0) {
+        remaining = remaining.substring(searchStart);
+    }
+    return { events, remaining };
+}
+export function findRealTag(buffer, tag) {
+    const codeBlockPattern = /```[\s\S]*?```/g;
+    const codeBlocks = [];
+    let match;
+    while ((match = codeBlockPattern.exec(buffer)) !== null) {
+        codeBlocks.push([match.index, match.index + match[0].length]);
+    }
+    let pos = 0;
+    while ((pos = buffer.indexOf(tag, pos)) !== -1) {
+        let inCodeBlock = false;
+        for (const [start, end] of codeBlocks) {
+            if (pos >= start && pos < end) {
+                inCodeBlock = true;
+                break;
+            }
+        }
+        if (!inCodeBlock) {
+            return pos;
+        }
+        pos += tag.length;
+    }
+    return -1;
+}

package/dist/plugin/streaming/stream-state.d.ts

@@ -0,0 +1,5 @@
+import { StreamEvent, StreamState } from './types.js';
+export declare function ensureBlockStart(blockType: 'thinking' | 'text', streamState: StreamState): StreamEvent[];
+export declare function stopBlock(index: number | null, streamState: StreamState): StreamEvent[];
+export declare function createTextDeltaEvents(text: string, streamState: StreamState): StreamEvent[];
+export declare function createThinkingDeltaEvents(thinking: string, streamState: StreamState): StreamEvent[];

package/dist/plugin/streaming/stream-state.js

@@ -0,0 +1,59 @@
+export function ensureBlockStart(blockType, streamState) {
+    if (blockType === 'thinking') {
+        if (streamState.thinkingBlockIndex != null)
+            return [];
+        const idx = streamState.nextBlockIndex++;
+        streamState.thinkingBlockIndex = idx;
+        return [
+            {
+                type: 'content_block_start',
+                index: idx,
+                content_block: { type: 'thinking', thinking: '' }
+            }
+        ];
+    }
+    if (blockType === 'text') {
+        if (streamState.textBlockIndex != null)
+            return [];
+        const idx = streamState.nextBlockIndex++;
+        streamState.textBlockIndex = idx;
+        return [
+            {
+                type: 'content_block_start',
+                index: idx,
+                content_block: { type: 'text', text: '' }
+            }
+        ];
+    }
+    return [];
+}
+export function stopBlock(index, streamState) {
+    if (index == null)
+        return [];
+    if (streamState.stoppedBlocks.has(index))
+        return [];
+    streamState.stoppedBlocks.add(index);
+    return [{ type: 'content_block_stop', index }];
+}
+export function createTextDeltaEvents(text, streamState) {
+    if (!text)
+        return [];
+    const events = [];
+    events.push(...ensureBlockStart('text', streamState));
+    events.push({
+        type: 'content_block_delta',
+        index: streamState.textBlockIndex,
+        delta: { type: 'text_delta', text }
+    });
+    return events;
+}
+export function createThinkingDeltaEvents(thinking, streamState) {
+    const events = [];
+    events.push(...ensureBlockStart('thinking', streamState));
+    events.push({
+        type: 'content_block_delta',
+        index: streamState.thinkingBlockIndex,
+        delta: { type: 'thinking_delta', thinking }
+    });
+    return events;
+}

package/dist/plugin/streaming/stream-transformer.d.ts

@@ -0,0 +1 @@
+export declare function transformKiroStream(response: Response, model: string, conversationId: string): AsyncGenerator<any>;