aws-runtime-bridge 1.0.0

package/dist/adapter/OpencodeSdkAdapter.js

@@ -0,0 +1,622 @@
+/**
+ * OpenCode SDK Adapter
+ *
+ * 主干流程：
+ * 1. spawn `opencode serve --port <port>` 进程（使用 shell: true）
+ * 2. 创建 SDK 客户端连接到该端口
+ * 3. 通过 client.session.create() 创建 OpenCode 会话
+ * 4. 订阅 SSE 事件流并映射到统一 ProviderEvent
+ * 5. 通过 client.session.prompt() 发送用户消息
+ *
+ * 参考：spectrai-community/src/main/adapter/OpenCodeSdkAdapter.ts
+ */
+import { spawn } from 'child_process';
+import { EventEmitter } from 'node:events';
+import * as fs from 'fs';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import { createOpencodeClient, } from '@opencode-ai/sdk';
+import { getToolActionInfo } from './types.js';
+// ============ 可执行文件查找 ============
+/**
+ * 查找 opencode 可执行文件
+ * 优先级：用户配置的绝对路径 > Windows Volta exe > npm 全局目录 > 回退到 'opencode'
+ */
+function findOpenCodeExecutable(configCommand) {
+    if (configCommand && path.isAbsolute(configCommand) && fs.existsSync(configCommand)) {
+        return configCommand;
+    }
+    const fallback = configCommand?.trim() || 'opencode';
+    if (process.platform === 'win32') {
+        const home = process.env.USERPROFILE || process.env.HOME || os.homedir();
+        const localAppData = process.env.LOCALAPPDATA || '';
+        // 1. Volta 安装的 opencode.exe（优先，不需要 shell）
+        const voltaExeDirs = [
+            path.join(localAppData, 'Volta', 'tools', 'shared', 'opencode-ai', 'node_modules', 'opencode-windows-x64', 'bin'),
+            path.join(localAppData, 'Volta', 'tools', 'shared', 'opencode-ai', 'node_modules', 'opencode-windows-x64-baseline', 'bin'),
+        ];
+        for (const dir of voltaExeDirs) {
+            const exePath = path.join(dir, 'opencode.exe');
+            if (fs.existsSync(exePath)) {
+                console.log(`[OpencodeSdkAdapter] Found opencode.exe: ${exePath}`);
+                return exePath;
+            }
+        }
+        // 2. npm 全局安装的 opencode.cmd
+        const npmGlobalDirs = [
+            path.join(home, 'AppData', 'Roaming', 'npm'),
+            path.join(home, 'AppData', 'Local', 'Volta', 'bin'),
+        ];
+        for (const dir of npmGlobalDirs) {
+            for (const name of ['opencode.cmd', 'opencode.exe', 'opencode']) {
+                const candidate = path.join(dir, name);
+                if (fs.existsSync(candidate)) {
+                    console.log(`[OpencodeSdkAdapter] Found ${name}: ${candidate}`);
+                    return candidate;
+                }
+            }
+        }
+    }
+    return fallback;
+}
+// ============ 端口检测 ============
+async function findAvailablePort(startPort = 14096) {
+    for (let port = startPort; port < startPort + 100; port++) {
+        const available = await new Promise((resolve) => {
+            const server = net.createServer();
+            server.once('error', () => resolve(false));
+            server.once('listening', () => {
+                server.close(() => resolve(true));
+            });
+            server.listen(port, '127.0.0.1');
+        });
+        if (available)
+            return port;
+    }
+    throw new Error(`No available port found in range ${startPort}–${startPort + 99}`);
+}
+// ============ Adapter ============
+export class OpencodeSdkAdapter extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.providerId = 'opencode';
+        this.displayName = 'OpenCode';
+        this.sessions = new Map();
+    }
+    async startSession(sessionId, config) {
+        console.log(`[OpencodeSdkAdapter] ★★★ 启动 OpenCode SDK 会话 ★★★ sessionId="${sessionId}", workingDirectory="${config.workingDirectory}"`);
+        const session = {
+            adapterSession: {
+                sessionId,
+                status: 'starting',
+                messages: [],
+                createdAt: new Date().toISOString(),
+                totalUsage: { inputTokens: 0, outputTokens: 0 },
+            },
+            config,
+            sseActive: false,
+            pendingPermissions: new Map(),
+            emittedToolStarts: new Set(),
+            workingDirectory: config.workingDirectory,
+            userMessageIds: new Set(),
+            currentAssistantText: '',
+            seenTextPartIds: new Set(),
+        };
+        this.sessions.set(sessionId, session);
+        this.emit('status-change', sessionId, 'starting');
+        try {
+            // 步骤 1：找空闲端口
+            const port = await findAvailablePort();
+            session.port = port;
+            console.log(`[OpencodeSdkAdapter] ★★★ 使用端口 ★★★ port=${port}`);
+            // 步骤 2：启动 opencode serve 进程
+            const openCodeCommand = findOpenCodeExecutable(config.command);
+            console.log(`[OpencodeSdkAdapter] ★★★ 启动命令 ★★★ command="${openCodeCommand}"`);
+            // ★ 关键：Windows 上 .cmd 必须使用 shell: true
+            const useShell = openCodeCommand.endsWith('.cmd') ||
+                openCodeCommand.endsWith('.CMD') ||
+                (process.platform === 'win32' && !path.isAbsolute(openCodeCommand));
+            console.log(`[OpencodeSdkAdapter] shell=${useShell}`);
+            const env = { ...process.env, ...config.envOverrides };
+            const proc = spawn(openCodeCommand, ['serve', '--port', String(port)], {
+                cwd: config.workingDirectory,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env,
+                shell: useShell,
+            });
+            session.serverProcess = proc;
+            proc.stdout?.on('data', (d) => {
+                console.debug(`[OpencodeSdkAdapter] serve stdout: ${d.toString().slice(0, 200)}`);
+            });
+            proc.stderr?.on('data', (d) => {
+                console.debug(`[OpencodeSdkAdapter] serve stderr: ${d.toString().slice(0, 200)}`);
+            });
+            proc.on('error', (err) => {
+                console.error(`[OpencodeSdkAdapter] Server process error:`, err);
+                if (session.adapterSession.status !== 'terminated') {
+                    session.adapterSession.status = 'error';
+                    this.emit('status-change', sessionId, 'error');
+                    this.emitEvent({
+                        type: 'error',
+                        sessionId,
+                        timestamp: new Date().toISOString(),
+                        data: { text: `OpenCode server error: ${err.message}` },
+                    });
+                }
+            });
+            proc.on('exit', (code) => {
+                console.log(`[OpencodeSdkAdapter] Server exited with code ${code}`);
+                session.sseActive = false;
+            });
+            // 步骤 3：创建 SDK 客户端
+            const client = createOpencodeClient({
+                baseUrl: `http://127.0.0.1:${port}`,
+            });
+            session.client = client;
+            // 步骤 4：等待服务器就绪
+            await this.waitForServer(client, config.workingDirectory, 10_000, port);
+            console.log(`[OpencodeSdkAdapter] ★★★ OpenCode server ready ★★★ port=${port}`);
+            // 步骤 5：创建 OpenCode 会话
+            const createResult = await client.session.create({
+                body: { title: `aws-bridge-${sessionId.slice(0, 8)}` },
+                query: { directory: config.workingDirectory },
+            });
+            const ocSession = createResult.data;
+            if (!ocSession?.id) {
+                throw new Error('OpenCode session.create() did not return an ID');
+            }
+            session.opencodeSessionId = ocSession.id;
+            session.adapterSession.providerSessionId = ocSession.id;
+            console.log(`[OpencodeSdkAdapter] ★★★ OpenCode 会话创建成功 ★★★ sessionId="${ocSession.id}"`);
+            // 步骤 6：后台启动 SSE 事件订阅循环
+            this.startSseLoop(sessionId, session);
+            session.adapterSession.status = 'waiting_input';
+            this.emit('status-change', sessionId, 'waiting_input');
+            // 步骤 7：发送初始 Prompt
+            if (config.initialPrompt) {
+                await this.sendMessage(sessionId, config.initialPrompt);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[OpencodeSdkAdapter] startSession failed:`, err);
+            session.adapterSession.status = 'error';
+            this.emit('status-change', sessionId, 'error');
+            this.emitEvent({
+                type: 'error',
+                sessionId,
+                timestamp: new Date().toISOString(),
+                data: { text: `OpenCode start failed: ${msg}` },
+            });
+            throw err;
+        }
+    }
+    async sendMessage(sessionId, message) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found`);
+        if (!session.client || !session.opencodeSessionId) {
+            throw new Error(`Session ${sessionId} not ready`);
+        }
+        const userMsg = {
+            id: uuidv4(),
+            sessionId,
+            role: 'user',
+            content: message,
+            timestamp: new Date().toISOString(),
+        };
+        session.adapterSession.messages.push(userMsg);
+        this.emit('conversation-message', sessionId, userMsg);
+        session.adapterSession.status = 'thinking';
+        this.emit('status-change', sessionId, 'thinking');
+        this.stopIdleDetection(sessionId);
+        try {
+            await session.client.session.prompt({
+                path: { id: session.opencodeSessionId },
+                body: {
+                    parts: [{ type: 'text', text: message }],
+                },
+                query: { directory: session.workingDirectory },
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.emitEvent({
+                type: 'error',
+                sessionId,
+                timestamp: new Date().toISOString(),
+                data: { text: msg },
+            });
+        }
+    }
+    async sendConfirmation(sessionId, accept) {
+        const session = this.sessions.get(sessionId);
+        if (!session?.client || !session.opencodeSessionId)
+            return;
+        const response = accept ? 'once' : 'reject';
+        const ocId = session.opencodeSessionId;
+        for (const [permissionId] of session.pendingPermissions) {
+            try {
+                await session.client.postSessionIdPermissionsPermissionId({
+                    path: { id: ocId, permissionID: permissionId },
+                    body: { response },
+                    query: { directory: session.workingDirectory },
+                });
+            }
+            catch (err) {
+                console.warn(`[OpencodeSdkAdapter] Permission response failed:`, err);
+            }
+        }
+        session.pendingPermissions.clear();
+    }
+    async sendQuestionAnswer(_sessionId, _answers) {
+        // OpenCode 的 AskUserQuestion 通过 permission 机制处理
+    }
+    setIdleCommands(sessionId, commands) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.idleCommands = commands;
+        }
+    }
+    async abortCurrentTurn(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session?.client || !session.opencodeSessionId)
+            return;
+        try {
+            await session.client.session.abort({
+                path: { id: session.opencodeSessionId },
+                query: { directory: session.workingDirectory },
+            });
+        }
+        catch (err) {
+            console.warn(`[OpencodeSdkAdapter] Abort failed:`, err);
+        }
+    }
+    async terminateSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        this.stopIdleDetection(sessionId);
+        session.sseActive = false;
+        session.sseAbortController?.abort();
+        if (session.serverProcess) {
+            try {
+                session.serverProcess.kill();
+            }
+            catch {
+                // ignore
+            }
+        }
+        session.adapterSession.status = 'terminated';
+        this.emit('status-change', sessionId, 'terminated');
+        this.emitEvent({
+            type: 'session_complete',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { exitCode: 0 },
+        });
+        this.sessions.delete(sessionId);
+    }
+    getConversation(sessionId) {
+        return this.sessions.get(sessionId)?.adapterSession.messages ?? [];
+    }
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    getProviderSessionId(sessionId) {
+        return this.sessions.get(sessionId)?.opencodeSessionId;
+    }
+    getSessionStatus(sessionId) {
+        return this.sessions.get(sessionId)?.adapterSession.status;
+    }
+    getSessionPid(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return undefined;
+        // OpenCode SDK 模式下 serverProcess 是 spawn 出来的子进程
+        return session.serverProcess?.pid;
+    }
+    cleanup() {
+        for (const [id] of this.sessions) {
+            try {
+                this.terminateSession(id);
+            }
+            catch {
+                // ignore
+            }
+        }
+        this.sessions.clear();
+    }
+    // ============ 私有方法 ============
+    async waitForServer(client, directory, timeoutMs, port) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            try {
+                const result = await client.session.list({ query: { directory } });
+                if (result.data !== undefined)
+                    return;
+            }
+            catch {
+                // 服务器尚未就绪
+            }
+            await new Promise((r) => setTimeout(r, 300));
+        }
+        throw new Error(`OpenCode server (port ${port}) did not start within ${timeoutMs}ms`);
+    }
+    startSseLoop(sessionId, session) {
+        session.sseActive = true;
+        const ac = new AbortController();
+        session.sseAbortController = ac;
+        this.runSseLoop(sessionId, session, ac).catch((err) => {
+            if (!ac.signal.aborted) {
+                console.error(`[OpencodeSdkAdapter] SSE loop error:`, err);
+            }
+        });
+    }
+    async runSseLoop(sessionId, session, ac) {
+        if (!session.client)
+            return;
+        try {
+            const sseResult = await session.client.event.subscribe({
+                query: { directory: session.workingDirectory },
+                signal: ac.signal,
+            });
+            for await (const event of sseResult.stream) {
+                if (!session.sseActive || ac.signal.aborted)
+                    break;
+                this.handleOpenCodeEvent(sessionId, session, event);
+            }
+        }
+        catch (err) {
+            if (ac.signal.aborted)
+                return;
+            console.error(`[OpencodeSdkAdapter] SSE stream ended:`, err);
+        }
+    }
+    handleOpenCodeEvent(sessionId, session, event) {
+        const ts = new Date().toISOString();
+        const ocId = session.opencodeSessionId;
+        switch (event.type) {
+            case 'message.updated': {
+                const msg = event.properties.info;
+                if (msg.sessionID !== ocId)
+                    break;
+                if (msg.role === 'user') {
+                    session.userMessageIds.add(msg.id);
+                }
+                else if (msg.role === 'assistant') {
+                    const tokens = msg.tokens;
+                    if (tokens) {
+                        session.adapterSession.totalUsage.inputTokens = Math.max(session.adapterSession.totalUsage.inputTokens, tokens.input);
+                        session.adapterSession.totalUsage.outputTokens = Math.max(session.adapterSession.totalUsage.outputTokens, tokens.output);
+                    }
+                }
+                break;
+            }
+            case 'message.part.updated': {
+                const { part, delta } = event.properties;
+                if (part.sessionID !== ocId)
+                    break;
+                if (session.userMessageIds.has(part.messageID))
+                    break;
+                this.handlePartUpdate(sessionId, session, part, delta, ts);
+                break;
+            }
+            case 'session.idle': {
+                if (event.properties.sessionID !== ocId)
+                    break;
+                if (session.currentAssistantText) {
+                    const assistantMsg = {
+                        id: uuidv4(),
+                        sessionId,
+                        role: 'assistant',
+                        content: session.currentAssistantText,
+                        timestamp: ts,
+                    };
+                    session.adapterSession.messages.push(assistantMsg);
+                    session.currentAssistantText = '';
+                }
+                session.seenTextPartIds.clear();
+                this.emitEvent({
+                    type: 'turn_complete',
+                    sessionId,
+                    timestamp: ts,
+                    data: { usage: session.adapterSession.totalUsage },
+                });
+                session.adapterSession.status = 'waiting_input';
+                this.emit('status-change', sessionId, 'waiting_input');
+                this.startIdleDetection(sessionId);
+                break;
+            }
+            case 'permission.updated': {
+                const perm = event.properties;
+                if (perm.sessionID !== ocId)
+                    break;
+                const permId = perm.id;
+                session.pendingPermissions.set(permId, perm);
+                if (session.config.autoAccept && session.client && ocId) {
+                    session.client
+                        .postSessionIdPermissionsPermissionId({
+                        path: { id: ocId, permissionID: permId },
+                        body: { response: 'once' },
+                        query: { directory: session.workingDirectory },
+                    })
+                        .then(() => {
+                        session.pendingPermissions.delete(permId);
+                    })
+                        .catch((err) => {
+                        console.warn(`[OpencodeSdkAdapter] Auto-accept permission failed:`, err);
+                    });
+                }
+                else {
+                    this.emitEvent({
+                        type: 'permission_request',
+                        sessionId,
+                        timestamp: ts,
+                        data: {
+                            permissionPrompt: perm.title,
+                            toolName: perm.type,
+                        },
+                    });
+                }
+                break;
+            }
+            case 'session.error': {
+                const { sessionID, error } = event.properties;
+                if (sessionID && sessionID !== ocId)
+                    break;
+                let errMsg = 'OpenCode session error';
+                if (error) {
+                    const data = error.data;
+                    if (typeof data?.message === 'string') {
+                        errMsg = `${error.name}: ${data.message}`;
+                    }
+                    else {
+                        errMsg = error.name;
+                    }
+                }
+                this.emitEvent({
+                    type: 'error',
+                    sessionId,
+                    timestamp: ts,
+                    data: { text: errMsg },
+                });
+                break;
+            }
+        }
+    }
+    handlePartUpdate(sessionId, session, part, delta, ts) {
+        switch (part.type) {
+            case 'text': {
+                let text;
+                if (delta !== undefined) {
+                    text = delta;
+                    session.seenTextPartIds.add(part.id);
+                }
+                else if (!session.seenTextPartIds.has(part.id)) {
+                    text = part.text;
+                    if (text)
+                        session.seenTextPartIds.add(part.id);
+                }
+                else {
+                    break;
+                }
+                if (!text)
+                    break;
+                session.currentAssistantText += text;
+                this.emitEvent({
+                    type: 'text_delta',
+                    sessionId,
+                    timestamp: ts,
+                    data: { text },
+                });
+                break;
+            }
+            case 'reasoning': {
+                const text = delta ?? part.text;
+                if (!text)
+                    break;
+                this.emitEvent({
+                    type: 'thinking',
+                    sessionId,
+                    timestamp: ts,
+                    data: { text },
+                });
+                break;
+            }
+            case 'tool': {
+                const toolUseId = part.callID;
+                const toolName = part.tool;
+                const state = part.state;
+                const toolInput = state.input;
+                // 从 ToolPart.metadata 中提取 MCP server 信息（注意：metadata 在 part 上，不在 state 上）
+                const metadata = part.metadata;
+                // 调试日志：查看 metadata 内容
+                if (metadata && Object.keys(metadata).length > 0) {
+                    console.log(`[OpencodeSdkAdapter] Tool "${toolName}" metadata:`, JSON.stringify(metadata));
+                }
+                const emitToolStart = () => {
+                    if (session.emittedToolStarts.has(toolUseId))
+                        return;
+                    session.emittedToolStarts.add(toolUseId);
+                    const actionInfo = getToolActionInfo(toolName, toolInput, metadata);
+                    this.emitEvent({
+                        type: 'tool_use_start',
+                        sessionId,
+                        timestamp: ts,
+                        data: { toolName, toolInput, toolUseId, ...actionInfo },
+                    });
+                    session.adapterSession.messages.push({
+                        id: uuidv4(),
+                        sessionId,
+                        role: 'tool_use',
+                        content: `${toolName}: ${JSON.stringify(toolInput).slice(0, 100)}`,
+                        timestamp: ts,
+                        toolName,
+                        toolInput,
+                        toolUseId,
+                    });
+                };
+                if (state.status === 'running') {
+                    emitToolStart();
+                    const actionInfo = getToolActionInfo(toolName, toolInput, metadata);
+                    this.emit('status-change', sessionId, 'tool_using', actionInfo);
+                }
+                else if (state.status === 'completed') {
+                    emitToolStart();
+                    const output = state.output;
+                    this.emitEvent({
+                        type: 'tool_use_end',
+                        sessionId,
+                        timestamp: ts,
+                        data: { toolName, toolResult: output, isError: false, toolUseId },
+                    });
+                    session.emittedToolStarts.delete(toolUseId);
+                }
+                else if (state.status === 'error') {
+                    emitToolStart();
+                    const errorStr = state.error;
+                    this.emitEvent({
+                        type: 'tool_use_end',
+                        sessionId,
+                        timestamp: ts,
+                        data: { toolName, toolResult: errorStr, isError: true, toolUseId },
+                    });
+                    session.emittedToolStarts.delete(toolUseId);
+                }
+                break;
+            }
+        }
+    }
+    emitEvent(event) {
+        this.emit('event', event);
+    }
+    startIdleDetection(sessionId) {
+        this.stopIdleDetection(sessionId);
+        const session = this.sessions.get(sessionId);
+        if (!session?.idleCommands?.idleInputCommand)
+            return;
+        const timer = setInterval(() => {
+            this.checkIdleState(sessionId);
+        }, 500);
+        session.idleTimer = timer;
+    }
+    stopIdleDetection(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session?.idleTimer) {
+            clearInterval(session.idleTimer);
+            session.idleTimer = undefined;
+        }
+    }
+    checkIdleState(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.adapterSession.status !== 'waiting_input')
+            return;
+        if (!session.idleCommands?.idleInputCommand)
+            return;
+        void this.sendMessage(sessionId, session.idleCommands.idleInputCommand);
+        this.stopIdleDetection(sessionId);
+    }
+}

package/dist/adapter/OpencodeSdkAdapter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=OpencodeSdkAdapter.test.d.ts.map

package/dist/adapter/OpencodeSdkAdapter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpencodeSdkAdapter.test.d.ts","sourceRoot":"","sources":["../../src/adapter/OpencodeSdkAdapter.test.ts"],"names":[],"mappings":""}

package/dist/adapter/OpencodeSdkAdapter.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { OpencodeSdkAdapter } from './OpencodeSdkAdapter.js';
+describe('OpencodeSdkAdapter', () => {
+    it('should expose opencode provider identity', () => {
+        const adapter = new OpencodeSdkAdapter();
+        expect(adapter.providerId).toBe('opencode');
+        expect(adapter.displayName).toBe('OpenCode');
+    });
+    it('should start with no active sessions', () => {
+        const adapter = new OpencodeSdkAdapter();
+        expect(adapter.hasSession('missing-session')).toBe(false);
+        expect(adapter.getSessionStatus('missing-session')).toBeUndefined();
+    });
+});

package/dist/adapter/SdkProviderSpi.d.ts

@@ -0,0 +1,15 @@
+import type { AdapterRegistry } from './AdapterRegistry.js';
+import type { BaseProviderAdapter } from './types.js';
+export interface SdkProviderDefinition {
+    runtimeMode: string;
+    providerId: string;
+    displayName: string;
+    defaultCommand: string;
+    commandMatchers: string[];
+    createAdapter: () => BaseProviderAdapter;
+}
+export declare const SDK_PROVIDER_DEFINITIONS: SdkProviderDefinition[];
+export declare function resolveSdkProviderByCommand(command?: string): SdkProviderDefinition;
+export declare function resolveSdkProviderIdByCommand(command?: string): string;
+export declare function registerSdkProviders(registry: AdapterRegistry, wireAdapterEvents: (adapter: BaseProviderAdapter, definition: SdkProviderDefinition) => void): void;
+//# sourceMappingURL=SdkProviderSpi.d.ts.map

package/dist/adapter/SdkProviderSpi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdkProviderSpi.d.ts","sourceRoot":"","sources":["../../src/adapter/SdkProviderSpi.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,mBAAmB,CAAC;CAC1C;AAED,eAAO,MAAM,wBAAwB,EAAE,qBAAqB,EAyB3D,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,qBAAqB,CAOnF;AAED,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,EACzB,iBAAiB,EAAE,CAAC,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,qBAAqB,KAAK,IAAI,GAC3F,IAAI,CASN"}