@sunerpy/opencode-kiro-auth 0.1.0

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

@@ -0,0 +1,295 @@
+import { parseBracketToolCalls } from '../../infrastructure/transformers/tool-call-parser.js';
+import { getContextWindowSize } from '../models.js';
+import { estimateTokens } from '../response.js';
+import { convertToOpenAI } from './openai-converter.js';
+import { findRealTag, parseStreamBuffer } from './stream-parser.js';
+import { createTextDeltaEvents, createThinkingDeltaEvents, stopBlock } from './stream-state.js';
+import { THINKING_END_TAG, THINKING_START_TAG } from './types.js';
+export async function* transformKiroStream(response, model, conversationId) {
+    const thinkingRequested = true;
+    const streamState = {
+        thinkingRequested,
+        buffer: '',
+        inThinking: false,
+        thinkingExtracted: false,
+        thinkingBlockIndex: null,
+        textBlockIndex: null,
+        nextBlockIndex: 0,
+        stoppedBlocks: new Set()
+    };
+    if (!response.body) {
+        throw new Error('Response body is null');
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let rawBuffer = '';
+    let totalContent = '';
+    let textOnlyContent = '';
+    let outputTokens = 0;
+    let inputTokens = 0;
+    let contextUsagePercentage = null;
+    const toolCalls = [];
+    let currentToolCall = null;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = decoder.decode(value, { stream: true });
+            rawBuffer += chunk;
+            const events = parseStreamBuffer(rawBuffer);
+            rawBuffer = events.remaining;
+            for (const event of events.events) {
+                if (event.type === 'contextUsage' && event.data.contextUsagePercentage) {
+                    contextUsagePercentage = event.data.contextUsagePercentage;
+                }
+                else if (event.type === 'content' && event.data) {
+                    totalContent += event.data;
+                    textOnlyContent += event.data;
+                    if (!thinkingRequested) {
+                        for (const ev of createTextDeltaEvents(event.data, streamState)) {
+                            {
+                                const _c = convertToOpenAI(ev, conversationId, model);
+                                if (_c !== null)
+                                    yield _c;
+                            }
+                        }
+                        continue;
+                    }
+                    streamState.buffer += event.data;
+                    const deltaEvents = [];
+                    while (streamState.buffer.length > 0) {
+                        if (!streamState.inThinking && !streamState.thinkingExtracted) {
+                            const startPos = findRealTag(streamState.buffer, THINKING_START_TAG);
+                            if (startPos !== -1) {
+                                const before = streamState.buffer.slice(0, startPos);
+                                if (before) {
+                                    deltaEvents.push(...createTextDeltaEvents(before, streamState));
+                                }
+                                streamState.buffer = streamState.buffer.slice(startPos + THINKING_START_TAG.length);
+                                streamState.inThinking = true;
+                                continue;
+                            }
+                            const safeLen = Math.max(0, streamState.buffer.length - THINKING_START_TAG.length);
+                            if (safeLen > 0) {
+                                const safeText = streamState.buffer.slice(0, safeLen);
+                                if (safeText) {
+                                    deltaEvents.push(...createTextDeltaEvents(safeText, streamState));
+                                }
+                                streamState.buffer = streamState.buffer.slice(safeLen);
+                            }
+                            break;
+                        }
+                        if (streamState.inThinking) {
+                            const endPos = findRealTag(streamState.buffer, THINKING_END_TAG);
+                            if (endPos !== -1) {
+                                const thinkingPart = streamState.buffer.slice(0, endPos);
+                                if (thinkingPart) {
+                                    deltaEvents.push(...createThinkingDeltaEvents(thinkingPart, streamState));
+                                }
+                                streamState.buffer = streamState.buffer.slice(endPos + THINKING_END_TAG.length);
+                                streamState.inThinking = false;
+                                streamState.thinkingExtracted = true;
+                                deltaEvents.push(...createThinkingDeltaEvents('', streamState));
+                                deltaEvents.push(...stopBlock(streamState.thinkingBlockIndex, streamState));
+                                if (streamState.buffer.startsWith('\n\n')) {
+                                    streamState.buffer = streamState.buffer.slice(2);
+                                }
+                                continue;
+                            }
+                            const safeLen = Math.max(0, streamState.buffer.length - THINKING_END_TAG.length);
+                            if (safeLen > 0) {
+                                const safeThinking = streamState.buffer.slice(0, safeLen);
+                                if (safeThinking) {
+                                    deltaEvents.push(...createThinkingDeltaEvents(safeThinking, streamState));
+                                }
+                                streamState.buffer = streamState.buffer.slice(safeLen);
+                            }
+                            break;
+                        }
+                        if (streamState.thinkingExtracted) {
+                            const rest = streamState.buffer;
+                            streamState.buffer = '';
+                            if (rest) {
+                                deltaEvents.push(...createTextDeltaEvents(rest, streamState));
+                            }
+                            break;
+                        }
+                    }
+                    for (const ev of deltaEvents) {
+                        {
+                            const _c = convertToOpenAI(ev, conversationId, model);
+                            if (_c !== null)
+                                yield _c;
+                        }
+                    }
+                }
+                else if (event.type === 'toolUse') {
+                    const tc = event.data;
+                    if (tc.name) {
+                        totalContent += tc.name;
+                    }
+                    if (tc.input) {
+                        totalContent += tc.input;
+                    }
+                    if (tc.name && tc.toolUseId) {
+                        if (currentToolCall && currentToolCall.toolUseId === tc.toolUseId) {
+                            currentToolCall.input += tc.input || '';
+                        }
+                        else {
+                            if (currentToolCall) {
+                                toolCalls.push(currentToolCall);
+                            }
+                            currentToolCall = {
+                                toolUseId: tc.toolUseId,
+                                name: tc.name,
+                                input: tc.input || ''
+                            };
+                        }
+                        if (tc.stop && currentToolCall) {
+                            toolCalls.push(currentToolCall);
+                            currentToolCall = null;
+                        }
+                    }
+                }
+                else if (event.type === 'toolUseInput') {
+                    if (event.data.input) {
+                        totalContent += event.data.input;
+                    }
+                    if (currentToolCall) {
+                        currentToolCall.input += event.data.input || '';
+                    }
+                }
+                else if (event.type === 'toolUseStop') {
+                    if (currentToolCall && event.data.stop) {
+                        toolCalls.push(currentToolCall);
+                        currentToolCall = null;
+                    }
+                }
+            }
+        }
+        if (currentToolCall) {
+            toolCalls.push(currentToolCall);
+            currentToolCall = null;
+        }
+        if (thinkingRequested && streamState.buffer) {
+            if (streamState.inThinking) {
+                for (const ev of createThinkingDeltaEvents(streamState.buffer, streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                streamState.buffer = '';
+                for (const ev of createThinkingDeltaEvents('', streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+            }
+            else {
+                for (const ev of createTextDeltaEvents(streamState.buffer, streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                streamState.buffer = '';
+            }
+        }
+        for (const ev of stopBlock(streamState.textBlockIndex, streamState)) {
+            const _c = convertToOpenAI(ev, conversationId, model);
+            if (_c !== null)
+                yield _c;
+        }
+        const bracketToolCalls = parseBracketToolCalls(totalContent);
+        if (bracketToolCalls.length > 0) {
+            for (const btc of bracketToolCalls) {
+                toolCalls.push({
+                    toolUseId: btc.toolUseId,
+                    name: btc.name,
+                    input: typeof btc.input === 'string' ? btc.input : JSON.stringify(btc.input)
+                });
+            }
+        }
+        if (toolCalls.length > 0) {
+            const baseIndex = streamState.nextBlockIndex;
+            for (let i = 0; i < toolCalls.length; i++) {
+                const tc = toolCalls[i];
+                if (!tc)
+                    continue;
+                const blockIndex = baseIndex + i;
+                {
+                    const _c = convertToOpenAI({
+                        type: 'content_block_start',
+                        index: blockIndex,
+                        content_block: {
+                            type: 'tool_use',
+                            id: tc.toolUseId,
+                            name: tc.name,
+                            input: {}
+                        }
+                    }, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                let inputJson;
+                try {
+                    const parsed = JSON.parse(tc.input);
+                    inputJson = JSON.stringify(parsed);
+                }
+                catch (e) {
+                    inputJson = tc.input;
+                }
+                {
+                    const _c = convertToOpenAI({
+                        type: 'content_block_delta',
+                        index: blockIndex,
+                        delta: {
+                            type: 'input_json_delta',
+                            partial_json: inputJson
+                        }
+                    }, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                {
+                    const _c = convertToOpenAI({ type: 'content_block_stop', index: blockIndex }, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+            }
+        }
+        outputTokens = estimateTokens(textOnlyContent);
+        if (contextUsagePercentage !== null && contextUsagePercentage > 0) {
+            const contextWindow = getContextWindowSize(model);
+            const totalTokens = Math.round((contextWindow * contextUsagePercentage) / 100);
+            inputTokens = Math.max(0, totalTokens - outputTokens);
+        }
+        {
+            const _c = convertToOpenAI({
+                type: 'message_delta',
+                delta: { stop_reason: toolCalls.length > 0 ? 'tool_use' : 'end_turn' },
+                usage: {
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens,
+                    cache_creation_input_tokens: 0,
+                    cache_read_input_tokens: 0
+                }
+            }, conversationId, model);
+            if (_c !== null)
+                yield _c;
+        }
+        {
+            const _c = convertToOpenAI({ type: 'message_stop' }, conversationId, model);
+            if (_c !== null)
+                yield _c;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

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

@@ -0,0 +1,25 @@
+export interface StreamEvent {
+    type: string;
+    message?: any;
+    content_block?: any;
+    delta?: any;
+    index?: number;
+    usage?: any;
+}
+export interface StreamState {
+    thinkingRequested: boolean;
+    buffer: string;
+    inThinking: boolean;
+    thinkingExtracted: boolean;
+    thinkingBlockIndex: number | null;
+    textBlockIndex: number | null;
+    nextBlockIndex: number;
+    stoppedBlocks: Set<number>;
+}
+export interface ToolCallState {
+    toolUseId: string;
+    name: string;
+    input: string;
+}
+export declare const THINKING_START_TAG = "<thinking>";
+export declare const THINKING_END_TAG = "</thinking>";

package/dist/plugin/streaming/types.js

@@ -0,0 +1,2 @@
+export const THINKING_START_TAG = '<thinking>';
+export const THINKING_END_TAG = '</thinking>';

package/dist/plugin/sync/kiro-cli-parser.d.ts

@@ -0,0 +1,8 @@
+export declare function getCliDbPath(): string;
+export declare function safeJsonParse(value: unknown): any | null;
+export declare function normalizeExpiresAt(input: unknown): number;
+export declare function findClientCredsRecursive(input: unknown): {
+    clientId?: string;
+    clientSecret?: string;
+};
+export declare function makePlaceholderEmail(authMethod: string, region: string, clientId?: string, profileArn?: string): string;

package/dist/plugin/sync/kiro-cli-parser.js

@@ -0,0 +1,72 @@
+import { createHash } from 'node:crypto';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+export function getCliDbPath() {
+    const override = process.env.KIROCLI_DB_PATH;
+    if (override)
+        return override;
+    const p = platform();
+    if (p === 'win32')
+        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'kiro-cli', 'data.sqlite3');
+    if (p === 'darwin')
+        return join(homedir(), 'Library', 'Application Support', 'kiro-cli', 'data.sqlite3');
+    return join(homedir(), '.local', 'share', 'kiro-cli', 'data.sqlite3');
+}
+export function safeJsonParse(value) {
+    if (typeof value !== 'string')
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeExpiresAt(input) {
+    if (typeof input === 'number') {
+        return input < 10_000_000_000 ? input * 1000 : input;
+    }
+    if (typeof input === 'string' && input.trim()) {
+        const t = new Date(input).getTime();
+        if (!Number.isNaN(t) && t > 0)
+            return t;
+        const n = Number(input);
+        if (Number.isFinite(n) && n > 0)
+            return normalizeExpiresAt(n);
+    }
+    return 0;
+}
+export function findClientCredsRecursive(input) {
+    const root = input;
+    if (!root || typeof root !== 'object')
+        return {};
+    const stack = [root];
+    const visited = new Set();
+    while (stack.length) {
+        const cur = stack.pop();
+        if (!cur || typeof cur !== 'object')
+            continue;
+        if (visited.has(cur))
+            continue;
+        visited.add(cur);
+        const clientId = cur.client_id || cur.clientId;
+        const clientSecret = cur.client_secret || cur.clientSecret;
+        if (typeof clientId === 'string' && typeof clientSecret === 'string') {
+            if (clientId && clientSecret)
+                return { clientId, clientSecret };
+        }
+        if (Array.isArray(cur)) {
+            for (const v of cur)
+                stack.push(v);
+            continue;
+        }
+        for (const v of Object.values(cur))
+            stack.push(v);
+    }
+    return {};
+}
+export function makePlaceholderEmail(authMethod, region, clientId, profileArn) {
+    const seed = `${authMethod}:${region}:${clientId || ''}:${profileArn || ''}`;
+    const h = createHash('sha256').update(seed).digest('hex').slice(0, 16);
+    return `${authMethod}-placeholder+${h}@awsapps.local`;
+}

package/dist/plugin/sync/kiro-cli-profile.d.ts

@@ -0,0 +1 @@
+export declare function readActiveProfileArnFromKiroCli(): string | undefined;

package/dist/plugin/sync/kiro-cli-profile.js

@@ -0,0 +1,30 @@
+import Database from 'libsql';
+import { existsSync } from 'node:fs';
+import { getCliDbPath, safeJsonParse } from './kiro-cli-parser.js';
+export function readActiveProfileArnFromKiroCli() {
+    const dbPath = getCliDbPath();
+    if (!existsSync(dbPath))
+        return undefined;
+    let cliDb;
+    try {
+        cliDb = new Database(dbPath, { readonly: true });
+        cliDb.pragma('busy_timeout = 5000');
+        const row = cliDb
+            .prepare('SELECT value FROM state WHERE key = ?')
+            .get('api.codewhisperer.profile');
+        const parsed = safeJsonParse(row?.value);
+        const arn = parsed?.arn || parsed?.profileArn || parsed?.profile_arn;
+        return typeof arn === 'string' && arn.trim() ? arn.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        try {
+            cliDb?.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+}

package/dist/plugin/sync/kiro-cli.d.ts

@@ -0,0 +1,2 @@
+export declare function syncFromKiroCli(): Promise<void>;
+export declare function writeToKiroCli(acc: any): Promise<void>;

package/dist/plugin/sync/kiro-cli.js

@@ -0,0 +1,212 @@
+import Database from 'libsql';
+import { existsSync } from 'node:fs';
+import { extractRegionFromArn, normalizeRegion } from '../../constants.js';
+import { createDeterministicAccountId } from '../accounts.js';
+import * as logger from '../logger.js';
+import { kiroDb } from '../storage/sqlite.js';
+import { fetchUsageLimits } from '../usage.js';
+import { findClientCredsRecursive, getCliDbPath, makePlaceholderEmail, normalizeExpiresAt, safeJsonParse } from './kiro-cli-parser.js';
+import { readActiveProfileArnFromKiroCli } from './kiro-cli-profile.js';
+import { getStaleKiroCliAccountIds, STALE_CLI_ACCOUNT_REASON } from './stale-accounts.js';
+export async function syncFromKiroCli() {
+    const dbPath = getCliDbPath();
+    if (!existsSync(dbPath))
+        return;
+    try {
+        const cliDb = new Database(dbPath, { readonly: true });
+        cliDb.pragma('busy_timeout = 5000');
+        const rows = cliDb.prepare('SELECT key, value FROM auth_kv').all();
+        let activeProfileArn;
+        try {
+            const stateRow = cliDb
+                .prepare('SELECT value FROM state WHERE key = ?')
+                .get('api.codewhisperer.profile');
+            const parsed = safeJsonParse(stateRow?.value);
+            const arn = parsed?.arn || parsed?.profileArn || parsed?.profile_arn;
+            if (typeof arn === 'string' && arn.trim())
+                activeProfileArn = arn.trim();
+        }
+        catch {
+            // Ignore state read failures; token import can proceed.
+        }
+        const deviceRegRow = rows.find((r) => typeof r?.key === 'string' && r.key.includes('device-registration'));
+        const deviceReg = safeJsonParse(deviceRegRow?.value);
+        const regCreds = deviceReg ? findClientCredsRecursive(deviceReg) : {};
+        const syncedAccounts = [];
+        for (const row of rows) {
+            if (row.key.includes(':token')) {
+                const data = safeJsonParse(row.value);
+                if (!data)
+                    continue;
+                const isIdc = row.key.includes('odic');
+                const authMethod = isIdc ? 'idc' : 'desktop';
+                const oidcRegion = normalizeRegion(data.region);
+                let profileArn = data.profile_arn || data.profileArn;
+                if (!profileArn && isIdc)
+                    profileArn = activeProfileArn || readActiveProfileArnFromKiroCli();
+                const serviceRegion = extractRegionFromArn(profileArn) || oidcRegion;
+                const startUrl = typeof data.start_url === 'string'
+                    ? data.start_url
+                    : typeof data.startUrl === 'string'
+                        ? data.startUrl
+                        : undefined;
+                const accessToken = data.access_token || data.accessToken || '';
+                const refreshToken = data.refresh_token || data.refreshToken;
+                if (!refreshToken)
+                    continue;
+                const clientId = data.client_id || data.clientId || (isIdc ? regCreds.clientId : undefined);
+                const clientSecret = data.client_secret || data.clientSecret || (isIdc ? regCreds.clientSecret : undefined);
+                if (authMethod === 'idc' && (!clientId || !clientSecret)) {
+                    logger.warn('Kiro CLI sync: missing IDC device credentials; skipping token import');
+                    continue;
+                }
+                const cliExpiresAt = normalizeExpiresAt(data.expires_at ?? data.expiresAt) || Date.now() + 3600000;
+                let usedCount = 0;
+                let limitCount = 0;
+                let email;
+                let usageOk = false;
+                try {
+                    const authForUsage = {
+                        refresh: '',
+                        access: accessToken,
+                        expires: cliExpiresAt,
+                        authMethod,
+                        region: serviceRegion,
+                        profileArn,
+                        clientId,
+                        clientSecret,
+                        email: ''
+                    };
+                    const u = await fetchUsageLimits(authForUsage);
+                    usedCount = u.usedCount || 0;
+                    limitCount = u.limitCount || 0;
+                    if (typeof u.email === 'string' && u.email) {
+                        email = u.email;
+                        usageOk = true;
+                    }
+                }
+                catch (e) {
+                    logger.warn('Kiro CLI sync: failed to fetch usage/email; falling back', {
+                        authMethod,
+                        serviceRegion,
+                        oidcRegion
+                    });
+                    logger.debug('Kiro CLI sync: usage fetch error', e);
+                }
+                const all = kiroDb.getAccounts();
+                if (!email) {
+                    let existing;
+                    if (profileArn) {
+                        existing = all.find((a) => a.auth_method === authMethod && a.profile_arn === profileArn);
+                    }
+                    if (!existing && authMethod === 'idc' && clientId) {
+                        existing = all.find((a) => a.auth_method === 'idc' && a.client_id === clientId);
+                    }
+                    if (existing && typeof existing.email === 'string' && existing.email) {
+                        email = existing.email;
+                    }
+                    else {
+                        email = makePlaceholderEmail(authMethod, serviceRegion, clientId, profileArn);
+                    }
+                }
+                const resolvedEmail = email || makePlaceholderEmail(authMethod, serviceRegion, clientId, profileArn);
+                const id = createDeterministicAccountId(resolvedEmail, authMethod, clientId, profileArn);
+                const existingById = all.find((a) => a.id === id);
+                if (existingById &&
+                    existingById.is_healthy === 1 &&
+                    existingById.expires_at >= cliExpiresAt &&
+                    existingById.expires_at > Date.now())
+                    continue;
+                if (usageOk) {
+                    const placeholderEmail = makePlaceholderEmail(authMethod, serviceRegion, clientId, profileArn);
+                    const placeholderId = createDeterministicAccountId(placeholderEmail, authMethod, clientId, profileArn);
+                    if (placeholderId !== id) {
+                        const placeholderRow = all.find((a) => a.id === placeholderId);
+                        if (placeholderRow) {
+                            await kiroDb.upsertAccount({
+                                id: placeholderId,
+                                email: placeholderRow.email,
+                                authMethod,
+                                region: placeholderRow.region || serviceRegion,
+                                oidcRegion: placeholderRow.oidc_region || oidcRegion,
+                                clientId,
+                                clientSecret,
+                                profileArn,
+                                refreshToken: placeholderRow.refresh_token || refreshToken,
+                                accessToken: placeholderRow.access_token || accessToken,
+                                expiresAt: placeholderRow.expires_at || cliExpiresAt,
+                                rateLimitResetTime: 0,
+                                isHealthy: false,
+                                failCount: 10,
+                                unhealthyReason: 'Replaced by real email',
+                                recoveryTime: Date.now() + 31536000000,
+                                usedCount: placeholderRow.used_count || 0,
+                                limitCount: placeholderRow.limit_count || 0,
+                                lastSync: Date.now()
+                            });
+                        }
+                    }
+                }
+                await kiroDb.upsertAccount({
+                    id,
+                    email: resolvedEmail,
+                    authMethod,
+                    region: serviceRegion,
+                    oidcRegion,
+                    clientId,
+                    clientSecret,
+                    profileArn,
+                    startUrl,
+                    refreshToken,
+                    accessToken,
+                    expiresAt: cliExpiresAt,
+                    rateLimitResetTime: 0,
+                    isHealthy: true,
+                    failCount: 0,
+                    usedCount,
+                    limitCount,
+                    lastSync: Date.now()
+                });
+                syncedAccounts.push({
+                    id,
+                    email: resolvedEmail,
+                    authMethod,
+                    clientId,
+                    profileArn
+                });
+            }
+        }
+        const staleIds = getStaleKiroCliAccountIds(kiroDb.getAccounts(), syncedAccounts);
+        if (staleIds.length > 0) {
+            await kiroDb.markAccountsUnhealthy(staleIds, STALE_CLI_ACCOUNT_REASON);
+            logger.warn('Kiro CLI sync: deactivated stale cached accounts', { count: staleIds.length });
+        }
+        cliDb.close();
+    }
+    catch (e) {
+        logger.error('Sync failed', e);
+    }
+}
+export async function writeToKiroCli(acc) {
+    const dbPath = getCliDbPath();
+    if (!existsSync(dbPath))
+        return;
+    try {
+        const cliDb = new Database(dbPath);
+        cliDb.pragma('busy_timeout = 5000');
+        const rows = cliDb.prepare('SELECT key, value FROM auth_kv').all();
+        const targetKey = acc.authMethod === 'idc' ? 'kirocli:odic:token' : 'kirocli:social:token';
+        const row = rows.find((r) => r.key === targetKey || r.key.endsWith(targetKey));
+        if (row) {
+            const data = JSON.parse(row.value);
+            data.access_token = acc.accessToken;
+            data.refresh_token = acc.refreshToken;
+            data.expires_at = new Date(acc.expiresAt).toISOString();
+            cliDb.prepare('UPDATE auth_kv SET value = ? WHERE key = ?').run(JSON.stringify(data), row.key);
+        }
+        cliDb.close();
+    }
+    catch (e) {
+        logger.warn('Write back failed', e);
+    }
+}

package/dist/plugin/sync/stale-accounts.d.ts

@@ -0,0 +1,9 @@
+export type SyncedCliAccount = {
+    id: string;
+    email: string;
+    authMethod: 'idc' | 'desktop';
+    clientId?: string;
+    profileArn?: string;
+};
+export declare const STALE_CLI_ACCOUNT_REASON = "InvalidTokenException: Replaced by active Kiro CLI account during sync";
+export declare function getStaleKiroCliAccountIds(accounts: any[], syncedAccounts: SyncedCliAccount[]): string[];