aws-runtime-bridge 1.0.0

package/dist/services/tool-installer.js

@@ -0,0 +1,297 @@
+import os from "node:os";
+import path from "node:path";
+import { access } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const isWindows = process.platform === "win32";
+const TOOL_DEFINITIONS = {
+    claude: {
+        key: "claude",
+        aliases: isWindows ? ["claude.cmd", "claude.exe", "claude"] : ["claude"],
+        versionArgs: ["--version"],
+        installCommands: isWindows
+            ? ["npm install -g @anthropic-ai/claude-code@latest"]
+            : [
+                "curl -fsSL https://claude.ai/install.sh | bash",
+                "npm install -g @anthropic-ai/claude-code@latest",
+            ],
+    },
+    claudecode: {
+        key: "claudecode",
+        aliases: isWindows ? ["claude.cmd", "claude.exe", "claude"] : ["claude"],
+        versionArgs: ["--version"],
+        installCommands: isWindows
+            ? ["npm install -g @anthropic-ai/claude-code@latest"]
+            : [
+                "curl -fsSL https://claude.ai/install.sh | bash",
+                "npm install -g @anthropic-ai/claude-code@latest",
+            ],
+    },
+    opencode: {
+        key: "opencode",
+        aliases: isWindows
+            ? ["opencode.cmd", "opencode.exe", "opencode"]
+            : ["opencode"],
+        versionArgs: ["--version"],
+        installCommands: isWindows
+            ? ["npm install -g opencode-ai@latest"]
+            : [
+                "curl -fsSL https://opencode.ai/install | bash",
+                "npm install -g opencode-ai@latest",
+            ],
+        extraSearchPaths: () => {
+            const home = os.homedir();
+            return [
+                process.env.OPENCODE_INSTALL_DIR || "",
+                process.env.XDG_BIN_DIR || "",
+                path.join(home, "bin"),
+                path.join(home, ".opencode", "bin"),
+                path.join(home, "go", "bin"),
+            ].filter(Boolean);
+        },
+    },
+    codex: {
+        key: "codex",
+        aliases: isWindows ? ["codex.cmd", "codex.exe", "codex"] : ["codex"],
+        versionArgs: ["--version"],
+        installCommands: ["npm install -g @openai/codex@latest"],
+    },
+};
+export const SUPPORTED_INSTALLABLE_TOOLS = Object.freeze(Object.keys(TOOL_DEFINITIONS));
+function parseVersion(output) {
+    const normalized = String(output || "").trim();
+    if (!normalized) {
+        return null;
+    }
+    const match = normalized.match(/(\d+\.\d+\.\d+(?:[-+][\w.-]+)?)/);
+    return match?.[1] || normalized.split(/\s+/)[0] || null;
+}
+function splitPathEntries(rawPath) {
+    return String(rawPath || "")
+        .split(path.delimiter)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function uniquePaths(paths) {
+    return [...new Set(paths.filter(Boolean))];
+}
+function describeExecError(error) {
+    if (!error || typeof error !== "object") {
+        return "unknown detection error";
+    }
+    const code = "code" in error ? String(error.code || "").trim() : "";
+    const errno = "errno" in error ? String(error.errno || "").trim() : "";
+    const message = "message" in error ? String(error.message || "").trim() : "";
+    if (code === "ENOENT") {
+        return "command not found in PATH";
+    }
+    if (code === "EACCES" || code === "EPERM") {
+        return "command found but not executable";
+    }
+    if (code === "ETIMEDOUT") {
+        return "version command timed out";
+    }
+    if (code === "UNKNOWN" && /not recognized|not found/i.test(message)) {
+        return "command not found in PATH";
+    }
+    if (errno === "-4058") {
+        return "command not found in PATH";
+    }
+    if (errno === "-4048" || errno === "-13") {
+        return "command found but not executable";
+    }
+    return message || "command execution failed";
+}
+/**
+ * 在 Windows 上执行命令（处理 .cmd/.bat 文件）
+ * 在 Unix 系统上直接执行
+ */
+async function executeVersionCommand(command, args) {
+    if (isWindows) {
+        // Windows 上需要通过 cmd.exe 执行命令（尤其是 .cmd/.bat 文件）
+        const result = await execFileAsync("cmd.exe", ["/d", "/s", "/c", `${command} ${args.join(" ")}`], { timeout: 20_000 });
+        return { stdout: result.stdout || "", stderr: result.stderr || "" };
+    }
+    const result = await execFileAsync(command, args, { timeout: 20_000 });
+    return { stdout: result.stdout || "", stderr: result.stderr || "" };
+}
+async function resolveExecutableCandidate(definition) {
+    const searchPaths = uniquePaths([
+        ...splitPathEntries(process.env.PATH),
+        ...(definition.extraSearchPaths ? definition.extraSearchPaths() : []),
+        // Windows 上额外搜索 Volta 等常见路径
+        ...(isWindows
+            ? [
+                path.join(process.env.APPDATA || "", "npm"),
+                path.join(process.env.LOCALAPPDATA || "", "Volta", "bin"),
+                path.join(process.env.APPDATA || "", "Volta", "bin"),
+                "C:\\Program Files\\nodejs",
+            ]
+            : [
+                path.join(os.homedir(), ".local", "bin"),
+                "/usr/local/bin",
+                "/usr/bin",
+            ]),
+    ]);
+    let foundCommandPath = null;
+    let executionFailureMessage = null;
+    for (const alias of definition.aliases) {
+        try {
+            const { stdout, stderr } = await executeVersionCommand(alias, definition.versionArgs);
+            const version = parseVersion(`${stdout || ""}\n${stderr || ""}`);
+            if (!version) {
+                return {
+                    executable: alias,
+                    version: null,
+                    error: "command executable but version output unavailable",
+                };
+            }
+            return { executable: alias, version, error: null };
+        }
+        catch (error) {
+            executionFailureMessage = describeExecError(error);
+            if (executionFailureMessage !== "command not found in PATH") {
+                return {
+                    executable: alias,
+                    version: null,
+                    error: executionFailureMessage,
+                };
+            }
+        }
+        for (const dir of searchPaths) {
+            const absolutePath = path.join(dir, alias);
+            try {
+                await access(absolutePath);
+                foundCommandPath = absolutePath;
+                const { stdout, stderr } = await executeVersionCommand(absolutePath, definition.versionArgs);
+                const version = parseVersion(`${stdout || ""}\n${stderr || ""}`);
+                if (!version) {
+                    return {
+                        executable: absolutePath,
+                        version: null,
+                        error: "command executable but version output unavailable",
+                    };
+                }
+                return { executable: absolutePath, version, error: null };
+            }
+            catch (error) {
+                executionFailureMessage = describeExecError(error);
+                if (foundCommandPath) {
+                    return {
+                        executable: foundCommandPath,
+                        version: null,
+                        error: executionFailureMessage,
+                    };
+                }
+            }
+        }
+    }
+    if (foundCommandPath) {
+        return {
+            executable: foundCommandPath,
+            version: null,
+            error: executionFailureMessage || "command found but failed to execute",
+        };
+    }
+    return { executable: null, version: null, error: "command not installed" };
+}
+async function runInstallCommand(command) {
+    if (isWindows) {
+        await execFileAsync("cmd.exe", ["/d", "/s", "/c", command], {
+            timeout: 10 * 60 * 1000,
+        });
+        return;
+    }
+    await execFileAsync("/bin/sh", ["-lc", command], { timeout: 10 * 60 * 1000 });
+}
+/**
+ * 检查单个工具的 CLI 可执行状态，供实例状态展示与初始化前判断使用。
+ */
+export async function detectToolInstallStatus(tool) {
+    const normalizedTool = String(tool || "")
+        .trim()
+        .toLowerCase();
+    const definition = TOOL_DEFINITIONS[normalizedTool];
+    if (!definition) {
+        return {
+            tool: normalizedTool,
+            installed: false,
+            executable: null,
+            version: null,
+            installing: false,
+            error: "unsupported tool",
+        };
+    }
+    const result = await resolveExecutableCandidate(definition);
+    return {
+        tool: normalizedTool,
+        installed: Boolean(result.executable),
+        executable: result.executable,
+        version: result.version,
+        installing: false,
+        error: result.error,
+    };
+}
+/**
+ * 批量检查工具安装状态，统一返回给前端面板和实例状态持久化。
+ */
+export async function detectToolStatuses(tools) {
+    const normalizedTools = [
+        ...new Set((Array.isArray(tools) ? tools : [])
+            .map((item) => String(item || "")
+            .trim()
+            .toLowerCase())
+            .filter(Boolean)),
+    ];
+    const entries = await Promise.all(normalizedTools.map(async (tool) => [tool, await detectToolInstallStatus(tool)]));
+    return Object.fromEntries(entries);
+}
+/**
+ * 根据勾选工具自动安装缺失 CLI，安装后重新检测状态并返回。
+ */
+export async function ensureToolsInstalled(tools) {
+    const initialStatuses = await detectToolStatuses(tools);
+    const nextStatuses = {
+        ...initialStatuses,
+    };
+    for (const tool of Object.keys(initialStatuses)) {
+        const current = initialStatuses[tool];
+        if (current.installed) {
+            continue;
+        }
+        const definition = TOOL_DEFINITIONS[tool];
+        if (!definition) {
+            continue;
+        }
+        let lastError = current.error;
+        for (const command of definition.installCommands) {
+            try {
+                await runInstallCommand(command);
+                const detected = await detectToolInstallStatus(tool);
+                nextStatuses[tool] = detected;
+                if (detected.installed) {
+                    lastError = null;
+                    break;
+                }
+                lastError = detected.error;
+            }
+            catch (error) {
+                lastError =
+                    error instanceof Error
+                        ? error.message
+                        : String(error || "install failed");
+            }
+        }
+        if (!nextStatuses[tool]?.installed) {
+            nextStatuses[tool] = {
+                ...nextStatuses[tool],
+                tool,
+                installed: false,
+                installing: false,
+                error: lastError || "install failed",
+            };
+        }
+    }
+    return nextStatuses;
+}

package/dist/services/tool-installer.test.d.ts

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

package/dist/services/tool-installer.test.d.ts.map

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

package/dist/services/tool-installer.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect } from 'vitest';
+import { detectToolStatuses, detectToolInstallStatus, SUPPORTED_INSTALLABLE_TOOLS } from './tool-installer.js';
+describe('tool installer service', () => {
+    it('returns structured status for supported tools', async () => {
+        const statuses = await detectToolStatuses(['claude', 'opencode', 'codex']);
+        expect(typeof statuses.claude.installed).toBe('boolean');
+        expect(typeof statuses.opencode.installed).toBe('boolean');
+        expect(typeof statuses.codex.installed).toBe('boolean');
+        expect(statuses.claude.tool).toBe('claude');
+        expect(statuses.opencode.tool).toBe('opencode');
+        expect(statuses.codex.tool).toBe('codex');
+    });
+    it('deduplicates repeated tool names', async () => {
+        const statuses = await detectToolStatuses(['claude', 'claude', 'opencode']);
+        expect(Object.keys(statuses).sort()).toEqual(['claude', 'opencode']);
+    });
+    it('returns unsupported status for unknown tool', async () => {
+        const status = await detectToolInstallStatus('unknown-tool');
+        expect(status.installed).toBe(false);
+        expect(status.error).toBe('unsupported tool');
+    });
+    it('uses a precise message when a tool command is missing', async () => {
+        const status = await detectToolInstallStatus('claude');
+        // error can be null (when installed) or string (when not installed)
+        expect(status.error === null || typeof status.error === 'string').toBe(true);
+        if (!status.installed && status.error) {
+            expect(status.error).not.toBe('not installed or not executable');
+        }
+    });
+    it('treats discovered command path as installed even when version is unavailable', async () => {
+        const status = await detectToolInstallStatus('opencode');
+        if (status.executable) {
+            expect(status.installed).toBe(true);
+        }
+    });
+    it('normalizes tool names to lowercase', async () => {
+        const statuses = await detectToolStatuses(['CLAUDE', 'OpenCode']);
+        expect(statuses.claude).toBeDefined();
+        expect(statuses.opencode).toBeDefined();
+    });
+    it('handles empty tool array', async () => {
+        const statuses = await detectToolStatuses([]);
+        expect(statuses).toEqual({});
+    });
+    it('handles null input for detectToolStatuses', async () => {
+        const statuses = await detectToolStatuses(null);
+        expect(statuses).toEqual({});
+    });
+    it('handles undefined input for detectToolStatuses', async () => {
+        const statuses = await detectToolStatuses(undefined);
+        expect(statuses).toEqual({});
+    });
+    it('filters out empty and whitespace tool names', async () => {
+        const statuses = await detectToolStatuses(['claude', '', '  ', 'opencode']);
+        expect(Object.keys(statuses).sort()).toEqual(['claude', 'opencode']);
+    });
+    it('returns correct structure for tool status', async () => {
+        const status = await detectToolInstallStatus('claude');
+        expect(typeof status.tool).toBe('string');
+        expect(typeof status.installed).toBe('boolean');
+        expect(status.executable === null || typeof status.executable === 'string').toBe(true);
+        expect(status.version === null || typeof status.version === 'string').toBe(true);
+        expect(typeof status.installing).toBe('boolean');
+        expect(status.error === null || typeof status.error === 'string').toBe(true);
+    });
+    it('supports claudecode as alias for claude', async () => {
+        const status = await detectToolInstallStatus('claudecode');
+        expect(status.tool).toBe('claudecode');
+        // claudecode shares same detection as claude
+        expect(typeof status.installed).toBe('boolean');
+    });
+    it('supports codex as an installable tool', async () => {
+        expect(SUPPORTED_INSTALLABLE_TOOLS).toContain('codex');
+        const status = await detectToolInstallStatus('codex');
+        expect(status.tool).toBe('codex');
+        expect(typeof status.installed).toBe('boolean');
+        expect(status.error).not.toBe('unsupported tool');
+    });
+    it('detectToolStatuses returns status for all requested tools', async () => {
+        const tools = ['claude', 'opencode', 'unknown-tool'];
+        const statuses = await detectToolStatuses(tools);
+        expect(statuses.claude).toBeDefined();
+        expect(statuses.opencode).toBeDefined();
+        // unknown-tool should also be in results with unsupported status
+        expect(statuses['unknown-tool']).toBeDefined();
+        expect(statuses['unknown-tool'].error).toBe('unsupported tool');
+    });
+    it('handles mixed case tool names', async () => {
+        const statuses = await detectToolStatuses(['Claude', 'OPENCODE', 'ClaudeCode']);
+        expect(statuses.claude).toBeDefined();
+        expect(statuses.opencode).toBeDefined();
+        expect(statuses.claudecode).toBeDefined();
+    });
+    it('sets installing flag to false by default', async () => {
+        const status = await detectToolInstallStatus('claude');
+        expect(status.installing).toBe(false);
+    });
+    it('returns consistent tool name in lowercase', async () => {
+        const status = await detectToolInstallStatus('CLAUDE');
+        expect(status.tool).toBe('claude');
+    });
+});

package/dist/services/user-api-key-service.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 用户 API Key 服务
+ *
+ * 从 aws-mcp-server 获取用户的默认 API Key
+ * 用于 SDK 启动时配置 WebSocket 连接认证
+ */
+/**
+ * 获取用户的默认 API Key
+ *
+ * @param userId - 用户 ID（可选，如果不提供则使用当前登录用户）
+ * @returns 默认 API Key 或 null
+ */
+export declare function getUserDefaultApiKey(userId?: string): Promise<string | null>;
+/**
+ * 为 Agent 获取 API Key（用于 WebSocket 连接认证）
+ *
+ * ★ 调用后端 /api/user-api-keys/for-agent 接口
+ * 后端会自动处理以下逻辑：
+ * 1. 查找 Agent 的 ownerUserId
+ * 2. 如果找到，返回该用户的默认 API Key
+ * 3. 如果找不到，返回系统用户的默认 API Key
+ * 4. 确保每个 Agent 都能获取到可用的 API Key
+ *
+ * @param agentId - Agent ID
+ * @returns API Key 或 null
+ */
+export declare function getApiKeyForAgent(agentId: string): Promise<string | null>;
+//# sourceMappingURL=user-api-key-service.d.ts.map

package/dist/services/user-api-key-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-api-key-service.d.ts","sourceRoot":"","sources":["../../src/services/user-api-key-service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8BxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA+BxB"}

package/dist/services/user-api-key-service.js

@@ -0,0 +1,75 @@
+/**
+ * 用户 API Key 服务
+ *
+ * 从 aws-mcp-server 获取用户的默认 API Key
+ * 用于 SDK 启动时配置 WebSocket 连接认证
+ */
+import axios from "axios";
+import { schedulerBaseUrl, runtimeToken } from "../config.js";
+import { logger } from "../utils/logger.js";
+/**
+ * 获取用户的默认 API Key
+ *
+ * @param userId - 用户 ID（可选，如果不提供则使用当前登录用户）
+ * @returns 默认 API Key 或 null
+ */
+export async function getUserDefaultApiKey(userId) {
+    try {
+        const url = userId
+            ? `${schedulerBaseUrl}/api/user-api-keys/default?userId=${userId}`
+            : `${schedulerBaseUrl}/api/user-api-keys/default`;
+        const response = await axios.get(url, {
+            headers: {
+                "X-Runtime-Token": runtimeToken,
+            },
+            timeout: 5000,
+        });
+        if (response.data && response.data.success && response.data.data) {
+            const apiKey = response.data.data.apiKey;
+            logger.info(`[UserApiKeyService] 获取用户默认 API Key 成功: apiKey=${apiKey}`);
+            return apiKey;
+        }
+        logger.warn("[UserApiKeyService] 获取用户默认 API Key 失败: 响应数据无效");
+        return null;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`[UserApiKeyService] 获取用户默认 API Key 失败: ${errorMessage}`);
+        return null;
+    }
+}
+/**
+ * 为 Agent 获取 API Key（用于 WebSocket 连接认证）
+ *
+ * ★ 调用后端 /api/user-api-keys/for-agent 接口
+ * 后端会自动处理以下逻辑：
+ * 1. 查找 Agent 的 ownerUserId
+ * 2. 如果找到，返回该用户的默认 API Key
+ * 3. 如果找不到，返回系统用户的默认 API Key
+ * 4. 确保每个 Agent 都能获取到可用的 API Key
+ *
+ * @param agentId - Agent ID
+ * @returns API Key 或 null
+ */
+export async function getApiKeyForAgent(agentId) {
+    try {
+        const response = await axios.get(`${schedulerBaseUrl}/api/user-api-keys/for-agent?agentId=${agentId}`, {
+            headers: {
+                "X-Runtime-Token": runtimeToken,
+            },
+            timeout: 5000,
+        });
+        if (response.data && response.data.success && response.data.data) {
+            const apiKey = response.data.data.apiKey;
+            logger.info(`[UserApiKeyService] 获取 Agent ${agentId} 的 API Key 成功: apiKey=${apiKey}`);
+            return apiKey;
+        }
+        logger.warn(`[UserApiKeyService] 获取 Agent ${agentId} 的 API Key 失败: 响应数据无效`);
+        return null;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`[UserApiKeyService] 获取 Agent ${agentId} 的 API Key 失败: ${errorMessage}`);
+        return null;
+    }
+}

package/dist/services/workspace-files.d.ts

@@ -0,0 +1,85 @@
+/**
+ * 工作区文件服务
+ * 负责在工作区范围内安全地浏览、读取与保存文件。
+ */
+export interface WorkspaceFileItem {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+}
+export interface ListWorkspaceDirectoryResult {
+    currentPath: string;
+    workspacePath: string;
+    items: WorkspaceFileItem[];
+}
+export interface ReadWorkspaceFileResult {
+    workspacePath: string;
+    filePath: string;
+    content: string;
+}
+interface WorkspacePathParams {
+    workspacePath: string;
+    targetPath?: string;
+}
+interface WorkspaceFileParams {
+    workspacePath: string;
+    filePath: string;
+}
+interface WriteWorkspaceFileParams extends WorkspaceFileParams {
+    content: string;
+}
+interface CreateWorkspaceEntryParams extends WorkspacePathParams {
+    entryName: string;
+    isDirectory: boolean;
+}
+interface RenameWorkspaceEntryParams extends WorkspacePathParams {
+    targetPath: string;
+    newName: string;
+}
+interface DeleteWorkspaceEntryParams extends WorkspacePathParams {
+    targetPath: string;
+}
+/**
+ * 列出工作区目录内容。
+ */
+export declare function listWorkspaceDirectory(params: WorkspacePathParams): Promise<ListWorkspaceDirectoryResult>;
+/**
+ * 读取工作区中的文本文件。
+ */
+export declare function readWorkspaceFile(params: WorkspaceFileParams): Promise<ReadWorkspaceFileResult>;
+/**
+ * 将文本内容保存到工作区文件中。
+ */
+export declare function writeWorkspaceFile(params: WriteWorkspaceFileParams): Promise<{
+    ok: true;
+    workspacePath: string;
+    filePath: string;
+}>;
+/**
+ * 在指定工作区目录下创建文件或目录。
+ */
+export declare function createWorkspaceEntry(params: CreateWorkspaceEntryParams): Promise<{
+    ok: true;
+    workspacePath: string;
+    targetPath: string;
+    isDirectory: boolean;
+}>;
+/**
+ * 在工作区内重命名文件或目录，保持目标仍位于原父目录中。
+ */
+export declare function renameWorkspaceEntry(params: RenameWorkspaceEntryParams): Promise<{
+    ok: true;
+    workspacePath: string;
+    sourcePath: string;
+    targetPath: string;
+}>;
+/**
+ * 删除工作区内的文件或目录，并阻止误删工作区根目录。
+ */
+export declare function deleteWorkspaceEntry(params: DeleteWorkspaceEntryParams): Promise<{
+    ok: true;
+    workspacePath: string;
+    targetPath: string;
+}>;
+export {};
+//# sourceMappingURL=workspace-files.d.ts.map

package/dist/services/workspace-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-files.d.ts","sourceRoot":"","sources":["../../src/services/workspace-files.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,4BAA4B;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,iBAAiB,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,mBAAmB;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,mBAAmB;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,wBAAyB,SAAQ,mBAAmB;IAC5D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,0BAA2B,SAAQ,mBAAmB;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,UAAU,0BAA2B,SAAQ,mBAAmB;IAC9D,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,0BAA2B,SAAQ,mBAAmB;IAC9D,UAAU,EAAE,MAAM,CAAC;CACpB;AA+FD;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAoB/G;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAerG;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAWzI;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAAC,CAiCxF;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAkCtF;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAelE"}