@zhafron/opencode-kiro-auth 1.4.11 → 1.5.1

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>;

package/dist/plugin/{streaming.js → streaming/stream-transformer.js}

@@ -1,6 +1,9 @@
-import { parseBracketToolCalls, parseEventLine } from './response';
-const THINKING_START_TAG = '<thinking>';
-const THINKING_END_TAG = '</thinking>';
+import { parseBracketToolCalls } from '../../infrastructure/transformers/tool-call-parser.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 = {
@@ -243,268 +246,3 @@ export async function* transformKiroStream(response, model, conversationId) {
         reader.releaseLock();
     }
 }
-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;
-}
-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 };
-}
-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 [];
-}
-function stopBlock(index, streamState) {
-    if (index == null)
-        return [];
-    if (streamState.stoppedBlocks.has(index))
-        return [];
-    streamState.stoppedBlocks.add(index);
-    return [{ type: 'content_block_stop', index }];
-}
-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;
-}
-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;
-}
-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;
-}
-export function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}

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`;
+}