@zhafron/opencode-kiro-auth 1.0.0

package/dist/src/plugin/streaming.js

@@ -0,0 +1,444 @@
+import { parseBracketToolCalls, parseEventLine } from './response';
+const THINKING_START_TAG = '<thinking>';
+const THINKING_END_TAG = '</thinking>';
+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()
+    };
+    yield {
+        type: 'message_start',
+        message: {
+            id: conversationId,
+            type: 'message',
+            role: 'assistant',
+            model: model,
+            usage: {
+                input_tokens: 0,
+                output_tokens: 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 0
+            },
+            content: []
+        }
+    };
+    if (!response.body) {
+        throw new Error('Response body is null');
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let rawBuffer = '';
+    let totalContent = '';
+    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;
+                    if (!thinkingRequested) {
+                        yield* createTextDeltaEvents(event.data, streamState);
+                        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) {
+                        yield ev;
+                    }
+                }
+                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) {
+                yield* createThinkingDeltaEvents(streamState.buffer, streamState);
+                streamState.buffer = '';
+                yield* createThinkingDeltaEvents('', streamState);
+                yield* stopBlock(streamState.thinkingBlockIndex, streamState);
+            }
+            else if (!streamState.thinkingExtracted) {
+                yield* createTextDeltaEvents(streamState.buffer, streamState);
+                streamState.buffer = '';
+            }
+            else {
+                yield* createTextDeltaEvents(streamState.buffer, streamState);
+                streamState.buffer = '';
+            }
+        }
+        yield* stopBlock(streamState.textBlockIndex, streamState);
+        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;
+                yield {
+                    type: 'content_block_start',
+                    index: blockIndex,
+                    content_block: {
+                        type: 'tool_use',
+                        id: tc.toolUseId,
+                        name: tc.name,
+                        input: {}
+                    }
+                };
+                let inputJson;
+                try {
+                    const parsed = JSON.parse(tc.input);
+                    inputJson = JSON.stringify(parsed);
+                }
+                catch (e) {
+                    inputJson = tc.input;
+                }
+                yield {
+                    type: 'content_block_delta',
+                    index: blockIndex,
+                    delta: {
+                        type: 'input_json_delta',
+                        partial_json: inputJson
+                    }
+                };
+                yield { type: 'content_block_stop', index: blockIndex };
+            }
+        }
+        outputTokens = estimateTokens(totalContent);
+        if (contextUsagePercentage !== null && contextUsagePercentage > 0) {
+            const totalTokens = Math.round(200000 * contextUsagePercentage / 100);
+            inputTokens = Math.max(0, totalTokens - outputTokens);
+        }
+        yield {
+            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
+            }
+        };
+        yield { type: 'message_stop' };
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+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/src/plugin/token.d.ts

@@ -0,0 +1,8 @@
+import type { KiroAuthDetails, KiroAuthMethod, KiroRegion } from './types';
+export declare function buildRefreshUrl(region: KiroRegion, authMethod: KiroAuthMethod): string;
+export declare function parseRefreshResponse(response: any, authMethod: KiroAuthMethod): {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+};
+export declare function refreshAccessToken(auth: KiroAuthDetails): Promise<KiroAuthDetails>;

package/dist/src/plugin/token.js

@@ -0,0 +1,130 @@
+import { KiroTokenRefreshError } from './errors';
+import { decodeRefreshToken, encodeRefreshToken } from './accounts';
+const SOCIAL_REFRESH_URL_TEMPLATE = 'https://prod.{{region}}.auth.desktop.kiro.dev/refreshToken';
+const IDC_REFRESH_URL_TEMPLATE = 'https://oidc.{{region}}.amazonaws.com/token';
+export function buildRefreshUrl(region, authMethod) {
+    const template = authMethod === 'social' ? SOCIAL_REFRESH_URL_TEMPLATE : IDC_REFRESH_URL_TEMPLATE;
+    return template.replace('{{region}}', region);
+}
+export function parseRefreshResponse(response, authMethod) {
+    if (authMethod === 'social') {
+        if (!response.accessToken) {
+            throw new KiroTokenRefreshError('Invalid refresh response: Missing accessToken');
+        }
+        const expiresIn = response.expiresIn || 3600;
+        const expiresAt = Date.now() + (expiresIn * 1000);
+        return {
+            accessToken: response.accessToken,
+            refreshToken: response.refreshToken,
+            expiresAt,
+        };
+    }
+    else {
+        if (!response.accessToken && !response.access_token) {
+            throw new KiroTokenRefreshError('Invalid refresh response: Missing access_token');
+        }
+        const accessToken = response.accessToken || response.access_token;
+        const refreshToken = response.refreshToken || response.refresh_token;
+        const expiresIn = response.expiresIn || response.expires_in || 3600;
+        const expiresAt = Date.now() + (expiresIn * 1000);
+        return {
+            accessToken,
+            refreshToken,
+            expiresAt,
+        };
+    }
+}
+async function refreshSocialToken(refreshUrl, refreshToken) {
+    const response = await fetch(refreshUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            refreshToken,
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => 'Unknown error');
+        let errorData = {};
+        try {
+            errorData = JSON.parse(errorText);
+        }
+        catch {
+            errorData = { message: errorText };
+        }
+        const errorCode = errorData.error || errorData.code || `HTTP_${response.status}`;
+        const errorMessage = errorData.message || errorData.error_description || errorText;
+        throw new KiroTokenRefreshError(`Social token refresh failed: ${errorMessage}`, errorCode, new Error(errorText));
+    }
+    return response.json();
+}
+async function refreshIdcToken(refreshUrl, refreshToken, clientId, clientSecret) {
+    const params = new URLSearchParams();
+    params.append('grant_type', 'refresh_token');
+    params.append('refresh_token', refreshToken);
+    params.append('client_id', clientId);
+    params.append('client_secret', clientSecret);
+    const response = await fetch(refreshUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: params.toString(),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => 'Unknown error');
+        let errorData = {};
+        try {
+            errorData = JSON.parse(errorText);
+        }
+        catch {
+            errorData = { message: errorText };
+        }
+        const errorCode = errorData.error || errorData.code || `HTTP_${response.status}`;
+        const errorMessage = errorData.message || errorData.error_description || errorText;
+        throw new KiroTokenRefreshError(`IDC token refresh failed: ${errorMessage}`, errorCode, new Error(errorText));
+    }
+    return response.json();
+}
+export async function refreshAccessToken(auth) {
+    const refreshUrl = buildRefreshUrl(auth.region, auth.authMethod);
+    const parts = decodeRefreshToken(auth.refresh);
+    try {
+        let responseData;
+        if (auth.authMethod === 'social') {
+            responseData = await refreshSocialToken(refreshUrl, parts.refreshToken);
+        }
+        else {
+            if (!parts.clientId || !parts.clientSecret) {
+                throw new KiroTokenRefreshError('IDC token refresh requires clientId and clientSecret', 'MISSING_CREDENTIALS');
+            }
+            responseData = await refreshIdcToken(refreshUrl, parts.refreshToken, parts.clientId, parts.clientSecret);
+        }
+        const parsed = parseRefreshResponse(responseData, auth.authMethod);
+        const updatedParts = {
+            refreshToken: parsed.refreshToken || parts.refreshToken,
+            profileArn: responseData.profileArn || parts.profileArn,
+            clientId: parts.clientId,
+            clientSecret: parts.clientSecret,
+            authMethod: auth.authMethod,
+        };
+        return {
+            refresh: encodeRefreshToken(updatedParts),
+            access: parsed.accessToken,
+            expires: parsed.expiresAt,
+            authMethod: auth.authMethod,
+            region: auth.region,
+            profileArn: responseData.profileArn || auth.profileArn,
+            clientId: auth.clientId,
+            clientSecret: auth.clientSecret,
+            email: auth.email,
+        };
+    }
+    catch (error) {
+        if (error instanceof KiroTokenRefreshError) {
+            throw error;
+        }
+        throw new KiroTokenRefreshError(`Token refresh failed: ${error instanceof Error ? error.message : String(error)}`, 'UNKNOWN_ERROR', error instanceof Error ? error : undefined);
+    }
+}