aws-runtime-bridge 1.0.0

package/dist/routes/terminal.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import { SDK_PROVIDER_DEFINITIONS } from '../adapter/SdkProviderSpi.js';
+import { AWS_MCP_SERVER_NAME } from '../services/aws-client-agent-mcp.js';
+import { resolveSdkProviderId } from './terminal.js';
+describe('terminal route validation', () => {
+    it('requires agentId and workspacePath for start', () => {
+        const validateStartRequest = (body) => {
+            if (!body.agentId || !body.workspacePath)
+                return { valid: false, error: 'agentId and workspacePath are required' };
+            return { valid: true };
+        };
+        expect(validateStartRequest({}).valid).toBe(false);
+        expect(validateStartRequest({ agentId: 'agent-1', workspacePath: '/path' }).valid).toBe(true);
+    });
+    it('uses default command when not provided', () => {
+        const resolveCommand = (command) => command || 'claude';
+        expect(resolveCommand(undefined)).toBe('claude');
+        expect(resolveCommand('custom-cli')).toBe('custom-cli');
+    });
+    it('requires sessionId and input for input', () => {
+        const validateInputRequest = (body) => {
+            if (!body.sessionId || body.input === undefined || body.input === null) {
+                return { valid: false, error: 'sessionId and input are required' };
+            }
+            return { valid: true };
+        };
+        expect(validateInputRequest({}).valid).toBe(false);
+        expect(validateInputRequest({ sessionId: 'session-1', input: 'ls' }).valid).toBe(true);
+    });
+    it('requires sessionId, cols, and rows for resize', () => {
+        const validateResizeRequest = (body) => {
+            if (!body.sessionId || !body.cols || !body.rows)
+                return { valid: false, error: 'sessionId, cols, rows are required' };
+            return { valid: true };
+        };
+        expect(validateResizeRequest({}).valid).toBe(false);
+        expect(validateResizeRequest({ sessionId: 'session-1', cols: 120, rows: 30 }).valid).toBe(true);
+    });
+    it('requires sessionId for stop', () => {
+        const validateStopRequest = (body) => {
+            if (!body.sessionId)
+                return { valid: false, error: 'sessionId is required' };
+            return { valid: true };
+        };
+        expect(validateStopRequest({}).valid).toBe(false);
+        expect(validateStopRequest({ sessionId: 'session-1' }).valid).toBe(true);
+    });
+});
+describe('terminal configuration', () => {
+    it('selects correct shell for platform', () => {
+        const getShellConfig = (platform) => {
+            if (platform === 'win32')
+                return { shell: 'powershell.exe', args: ['-NoLogo'] };
+            return { shell: 'bash', args: [] };
+        };
+        expect(getShellConfig('win32').shell).toBe('powershell.exe');
+        expect(getShellConfig('linux').shell).toBe('bash');
+    });
+    it('builds correct terminal environment', () => {
+        const buildTerminalEnv = (agentId, baseEnv) => ({
+            ...baseEnv,
+            AWS_AGENT_ID: agentId,
+        });
+        const env = buildTerminalEnv('agent-123', { PATH: '/usr/bin' });
+        expect(env.AWS_AGENT_ID).toBe('agent-123');
+    });
+    it('uses aws-mcp as the default injected MCP server name', () => {
+        expect(AWS_MCP_SERVER_NAME).toBe('aws-mcp');
+    });
+});
+describe('resolveSdkProviderId', () => {
+    it('exposes codex through the SDK provider SPI', () => {
+        expect(SDK_PROVIDER_DEFINITIONS.map((definition) => definition.runtimeMode)).toContain('codex');
+        expect(SDK_PROVIDER_DEFINITIONS.find((definition) => definition.runtimeMode === 'codex')).toMatchObject({
+            providerId: 'codex',
+            defaultCommand: 'codex',
+        });
+    });
+    it('resolves codex commands to codex provider', () => {
+        expect(resolveSdkProviderId('codex')).toBe('codex');
+        expect(resolveSdkProviderId('npx codex --model gpt-5-codex')).toBe('codex');
+    });
+    it('resolves opencode commands to opencode provider', () => {
+        expect(resolveSdkProviderId('opencode')).toBe('opencode');
+    });
+    it('falls back to claude-code for claude or unknown commands', () => {
+        expect(resolveSdkProviderId('claude')).toBe('claude-code');
+        expect(resolveSdkProviderId('custom-binary')).toBe('claude-code');
+        expect(resolveSdkProviderId(undefined)).toBe('claude-code');
+    });
+});

package/dist/routes/yml.d.ts

@@ -0,0 +1,7 @@
+/**
+ * YAML 配置文件 API 路由
+ *
+ * 提供 YAML 配置文件的读取和写入功能
+ */
+export declare const ymlRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=yml.d.ts.map

package/dist/routes/yml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yml.d.ts","sourceRoot":"","sources":["../../src/routes/yml.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiBH,eAAO,MAAM,SAAS,4CAAW,CAAC"}

package/dist/routes/yml.js

@@ -0,0 +1,223 @@
+/**
+ * YAML 配置文件 API 路由
+ *
+ * 提供 YAML 配置文件的读取和写入功能
+ */
+import { Router } from 'express';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { validateToken } from '../middleware/auth.js';
+import { createLogger } from '../utils/logger.js';
+import { resolveWorkspaceFilePath } from '../utils/path-utils.js';
+import { loadYmlWithUpwardSearch, extractAgentConfigOrTemplate, generateEmptyTemplate, autoFillPathInYml } from '../utils/yaml-utils.js';
+const log = createLogger('yml-routes');
+export const ymlRouter = Router();
+/**
+ * 读取 YAML 配置文件
+ * POST /runtime/read-yml
+ */
+ymlRouter.post('/read-yml', validateToken, async (req, res) => {
+    const { workspacePath, ymlPath } = req.body || {};
+    try {
+        const { normalizedWorkspace, resolvedTarget } = resolveWorkspaceFilePath(workspacePath, ymlPath, 'vibe-coding/my.yml');
+        const providedPathStr = ymlPath ? String(ymlPath).trim() || 'vibe-coding/my.yml' : 'vibe-coding/my.yml';
+        if (path.isAbsolute(providedPathStr)) {
+            let content = '';
+            let exists = true;
+            try {
+                content = await fs.readFile(resolvedTarget, 'utf-8');
+            }
+            catch (err) {
+                const error = err;
+                if (error?.code === 'ENOENT') {
+                    exists = false;
+                }
+                else {
+                    throw err;
+                }
+            }
+            // 计算工作目录相对于配置文件所属目录（项目根目录）的相对路径
+            const configFileDir = path.dirname(resolvedTarget);
+            const projectRootDir = path.dirname(configFileDir);
+            let workspaceRelativeToProject = path.relative(projectRootDir, normalizedWorkspace);
+            if (workspaceRelativeToProject === '') {
+                workspaceRelativeToProject = '.';
+            }
+            let displayContent;
+            let isTemplate = false;
+            let projectFromSibling = null;
+            if (exists && content) {
+                const result = extractAgentConfigOrTemplate(content, workspaceRelativeToProject);
+                displayContent = result.content;
+                isTemplate = result.isTemplate;
+                projectFromSibling = result.projectFromSibling;
+            }
+            else {
+                displayContent = generateEmptyTemplate(workspaceRelativeToProject);
+                isTemplate = true;
+            }
+            res.json({
+                ok: true,
+                workspacePath: normalizedWorkspace,
+                filePath: resolvedTarget,
+                exists,
+                content: displayContent,
+                fullContent: exists ? content : null,
+                foundInParent: false,
+                isTemplate,
+                projectFromSibling,
+            });
+            return;
+        }
+        // 相对路径：向上查找配置文件
+        const loadResult = await loadYmlWithUpwardSearch(normalizedWorkspace, providedPathStr);
+        log.info(`loadResult.content length: ${loadResult.content?.length || 0}`);
+        const configFileDir = path.dirname(loadResult.resolvedPath);
+        const projectRootDir = path.dirname(configFileDir);
+        let workspaceRelativeToProject = path.relative(projectRootDir, normalizedWorkspace);
+        if (workspaceRelativeToProject === '') {
+            workspaceRelativeToProject = '.';
+        }
+        let displayContent;
+        let isTemplate = false;
+        let projectFromSibling = null;
+        if (loadResult.content !== null) {
+            const result = extractAgentConfigOrTemplate(loadResult.content, workspaceRelativeToProject);
+            displayContent = result.content;
+            isTemplate = result.isTemplate;
+            projectFromSibling = result.projectFromSibling;
+        }
+        else {
+            displayContent = generateEmptyTemplate(workspaceRelativeToProject);
+            isTemplate = true;
+        }
+        log.info(`returning fullContent length: ${loadResult.content?.length || 0}`);
+        res.json({
+            ok: true,
+            workspacePath: normalizedWorkspace,
+            filePath: loadResult.resolvedPath,
+            exists: loadResult.content !== null,
+            content: displayContent,
+            fullContent: loadResult.content,
+            foundInParent: loadResult.foundInParent,
+            matchedAgentPath: loadResult.matchedAgentPath,
+            isTemplate,
+            projectFromSibling,
+        });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'read yml failed' });
+    }
+});
+/**
+ * 加载完整的 YAML 文件内容
+ * POST /runtime/load-yml
+ */
+ymlRouter.post('/load-yml', validateToken, async (req, res) => {
+    const { workspacePath, ymlPath } = req.body || {};
+    try {
+        const { normalizedWorkspace, resolvedTarget } = resolveWorkspaceFilePath(workspacePath, ymlPath, 'vibe-coding/my.yml');
+        const providedPathStr = ymlPath ? String(ymlPath).trim() || 'vibe-coding/my.yml' : 'vibe-coding/my.yml';
+        if (path.isAbsolute(providedPathStr)) {
+            let content = null;
+            let exists = true;
+            try {
+                content = await fs.readFile(resolvedTarget, 'utf-8');
+                log.info(`绝对路径读取成功: ${resolvedTarget}, 内容长度: ${content.length}`);
+            }
+            catch (err) {
+                const error = err;
+                if (error?.code === 'ENOENT') {
+                    exists = false;
+                    log.info(`绝对路径文件不存在: ${resolvedTarget}`);
+                }
+                else {
+                    throw err;
+                }
+            }
+            res.json({
+                ok: true,
+                workspacePath: normalizedWorkspace,
+                filePath: resolvedTarget,
+                exists,
+                content: exists ? content : null,
+            });
+            return;
+        }
+        const loadResult = await loadYmlWithUpwardSearch(normalizedWorkspace, providedPathStr);
+        log.info(`向上查找结果: filePath=${loadResult.resolvedPath}, exists=${loadResult.content !== null}, contentLength=${loadResult.content?.length || 0}`);
+        res.json({
+            ok: true,
+            workspacePath: normalizedWorkspace,
+            filePath: loadResult.resolvedPath,
+            exists: loadResult.content !== null,
+            content: loadResult.content,
+            foundInParent: loadResult.foundInParent,
+        });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'load yml failed' });
+    }
+});
+/**
+ * 写入 YAML 配置文件
+ * POST /runtime/write-yml
+ */
+ymlRouter.post('/write-yml', validateToken, async (req, res) => {
+    const { workspacePath, ymlPath, content } = req.body || {};
+    if (!content || !String(content).trim()) {
+        res.status(400).json({ error: 'content is required' });
+        return;
+    }
+    try {
+        const { normalizedWorkspace, resolvedTarget: absoluteOrDefaultTarget } = resolveWorkspaceFilePath(workspacePath, ymlPath, 'vibe-coding/my.yml');
+        const providedPathStr = ymlPath ? String(ymlPath).trim() || 'vibe-coding/my.yml' : 'vibe-coding/my.yml';
+        if (path.isAbsolute(providedPathStr)) {
+            const resolvedTarget = absoluteOrDefaultTarget;
+            const configFileDir = path.dirname(resolvedTarget);
+            const projectRootDir = path.dirname(configFileDir);
+            let workspaceRelativeToProject = path.relative(projectRootDir, normalizedWorkspace);
+            if (workspaceRelativeToProject === '') {
+                workspaceRelativeToProject = '.';
+            }
+            const processedContent = autoFillPathInYml(String(content), workspaceRelativeToProject);
+            const targetDir = path.dirname(resolvedTarget);
+            await fs.mkdir(targetDir, { recursive: true });
+            await fs.writeFile(resolvedTarget, processedContent, 'utf-8');
+            res.json({
+                ok: true,
+                workspacePath: normalizedWorkspace,
+                filePath: resolvedTarget,
+                foundInParent: false,
+            });
+            return;
+        }
+        const loadResult = await loadYmlWithUpwardSearch(normalizedWorkspace, providedPathStr);
+        const initialTarget = path.resolve(normalizedWorkspace, providedPathStr);
+        const resolvedTarget = loadResult.content !== null ? loadResult.resolvedPath : initialTarget;
+        const configFileDir = path.dirname(resolvedTarget);
+        const projectRootDir = path.dirname(configFileDir);
+        let workspaceRelativeToProject = path.relative(projectRootDir, normalizedWorkspace);
+        if (workspaceRelativeToProject === '') {
+            workspaceRelativeToProject = '.';
+        }
+        const processedContent = autoFillPathInYml(String(content), workspaceRelativeToProject);
+        const targetDir = path.dirname(resolvedTarget);
+        await fs.mkdir(targetDir, { recursive: true });
+        await fs.writeFile(resolvedTarget, processedContent, 'utf-8');
+        res.json({
+            ok: true,
+            workspacePath: normalizedWorkspace,
+            filePath: resolvedTarget,
+            foundInParent: loadResult.foundInParent,
+            matchedAgentPath: loadResult.matchedAgentPath,
+            originalTarget: initialTarget !== resolvedTarget ? initialTarget : undefined,
+        });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'write yml failed' });
+    }
+});

package/dist/routes/yml.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * YAML 路由单元测试
+ */
+export {};
+//# sourceMappingURL=yml.test.d.ts.map

package/dist/routes/yml.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yml.test.d.ts","sourceRoot":"","sources":["../../src/routes/yml.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/routes/yml.test.js

@@ -0,0 +1,58 @@
+/**
+ * YAML 路由单元测试
+ */
+import { describe, it, expect } from 'vitest';
+describe('yml route validation', () => {
+    it('requires workspacePath for read', () => {
+        const validateReadRequest = (body) => {
+            const normalizedWorkspace = body.workspacePath ? String(body.workspacePath).trim() : '';
+            if (!normalizedWorkspace)
+                return { valid: false, error: 'workspacePath is required' };
+            return { valid: true };
+        };
+        expect(validateReadRequest({}).valid).toBe(false);
+        expect(validateReadRequest({ workspacePath: '/valid/path' }).valid).toBe(true);
+    });
+    it('requires workspacePath and content for write', () => {
+        const validateWriteRequest = (body) => {
+            const normalizedWorkspace = body.workspacePath ? String(body.workspacePath).trim() : '';
+            if (!normalizedWorkspace)
+                return { valid: false, error: 'workspacePath is required' };
+            if (!body.content || !String(body.content).trim())
+                return { valid: false, error: 'content is required' };
+            return { valid: true };
+        };
+        expect(validateWriteRequest({}).valid).toBe(false);
+        expect(validateWriteRequest({ workspacePath: '/path', content: 'test' }).valid).toBe(true);
+    });
+    it('uses default ymlPath when not provided', () => {
+        const resolveYmlPath = (ymlPath) => {
+            return ymlPath ? String(ymlPath).trim() || 'vibe-coding/my.yml' : 'vibe-coding/my.yml';
+        };
+        expect(resolveYmlPath()).toBe('vibe-coding/my.yml');
+        expect(resolveYmlPath('custom/path.yml')).toBe('custom/path.yml');
+    });
+});
+describe('response building', () => {
+    it('builds correct response for existing file', () => {
+        const response = {
+            ok: true,
+            workspacePath: '/project/workspace',
+            filePath: '/project/vibe-coding/my.yml',
+            exists: true,
+            content: 'agent:\n  - name: test',
+        };
+        expect(response.ok).toBe(true);
+        expect(response.exists).toBe(true);
+    });
+    it('builds correct response for non-existing file', () => {
+        const response = {
+            ok: true,
+            exists: false,
+            fullContent: null,
+            isTemplate: true,
+        };
+        expect(response.exists).toBe(false);
+        expect(response.isTemplate).toBe(true);
+    });
+});

package/dist/services/agent-process-manager.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Agent Process Manager
+ *
+ * Core lifecycle manager for agent processes on the bridge machine.
+ * Provides comprehensive process management including creation, discovery,
+ * monitoring, termination, and orphan reclamation capabilities.
+ */
+import { type ProcessRecord, type ProcessState, type HealthStatus } from './process-registry.js';
+import { type ProcessInfo, type ProcessHealthStatus } from './process-detector.js';
+/**
+ * Process configuration for starting a new agent process
+ */
+export interface ProcessConfig {
+    agentId: string;
+    sessionId: string;
+    pid: number;
+    mode: 'pty' | 'sdk';
+    workspacePath: string;
+    command: string;
+}
+/**
+ * Discovered process with management status
+ */
+export interface DiscoveredProcess extends ProcessInfo {
+    managementStatus: 'managed' | 'orphan' | 'unknown';
+    sessionId?: string;
+}
+/**
+ * Termination result with escalation level details
+ */
+export interface TerminationResult {
+    success: boolean;
+    agentId: string;
+    pid: number;
+    level: number;
+    terminated: number;
+    failed: number;
+    message: string;
+}
+/**
+ * Reclamation result
+ */
+export interface ReclamationResult {
+    success: boolean;
+    pid: number;
+    action: 'adopted' | 'terminated' | 'failed';
+}
+/**
+ * Agent Process Manager
+ *
+ * Manages the complete lifecycle of agent processes including:
+ * - Creation: Register and verify new processes
+ * - Discovery: Scan for managed, orphan, and unknown processes
+ * - Monitoring: Health checks and heartbeat tracking
+ * - Termination: Graceful stop with escalation strategy
+ * - Orphan Reclamation: Adopt or terminate orphan processes
+ */
+export declare class AgentProcessManager {
+    private static instance;
+    private readonly registry;
+    /**
+     * Private constructor - use getAgentProcessManager() for singleton access
+     */
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): AgentProcessManager;
+    /**
+     * Start a new process and register it in the process registry
+     *
+     * Flow:
+     * 1. Register process with state='creating'
+     * 2. Verify it's running
+     * 3. Update state to 'running'
+     *
+     * @param config - Process configuration
+     * @throws Error if process registration fails or process is not running
+     */
+    startProcess(config: ProcessConfig): Promise<void>;
+    /**
+     * Discover all agent processes on the system
+     *
+     * Scans OS for all agent processes, compares with registry, and returns
+     * a list of discovered processes with their management status.
+     *
+     * @returns Array of discovered processes with management status
+     */
+    discoverAllProcesses(): Promise<DiscoveredProcess[]>;
+    /**
+     * Check health of all registered processes
+     *
+     * Updates heartbeat and health status in registry for each managed process.
+     *
+     * @returns Map of agentId to health status
+     */
+    healthCheckAll(): Promise<Map<string, ProcessHealthStatus>>;
+    /**
+     * Check health of a single process
+     *
+     * @param agentId - Agent ID to check
+     * @returns Health status of the process
+     */
+    healthCheck(agentId: string): Promise<ProcessHealthStatus>;
+    /**
+     * Stop a process with graceful escalation strategy
+     *
+     * Escalation levels:
+     * Level 1: SIGTERM → wait 3s
+     * Level 2: taskkill /T /F (Win) or kill -9 (Unix) → wait 3s
+     * Level 3: terminateProcessTree → wait 5s
+     * Level 4: mark as "unstoppable", return failure
+     *
+     * @param agentId - Agent ID to stop
+     * @returns Termination result with details
+     */
+    stopProcess(agentId: string): Promise<TerminationResult>;
+    /**
+     * Send SIGTERM to a process
+     */
+    private sendSigterm;
+    /**
+     * Send force kill (SIGKILL on Unix, taskkill /F on Windows)
+     */
+    private sendForceKill;
+    /**
+     * Force kill a process immediately using terminateProcessTree
+     *
+     * This bypasses the graceful escalation and uses the most aggressive
+     * termination method immediately.
+     *
+     * @param agentId - Agent ID to force kill
+     * @returns Termination result
+     */
+    forceKill(agentId: string): Promise<TerminationResult>;
+    /**
+     * Reclaim an orphan process by agentId
+     *
+     * Finds an orphan process by agentId, and either:
+     * - Adopts it into the registry (if found and not managed)
+     * - Terminates it (if adoption fails or process is problematic)
+     *
+     * @param agentId - Agent ID to find and reclaim
+     * @returns Reclamation result
+     */
+    reclaimOrphan(agentId: string): Promise<ReclamationResult>;
+    /**
+     * Scan all orphans and attempt to reclaim each
+     *
+     * @returns Array of reclamation results
+     */
+    scanAndReclaimAll(): Promise<Array<{
+        agentId: string;
+        pid: number;
+        action: string;
+    }>>;
+    /**
+     * Mark a process as orphaned in the registry
+     *
+     * @param agentId - Agent ID to mark
+     * @returns Whether the operation succeeded
+     */
+    markOrphaned(agentId: string): Promise<boolean>;
+    /**
+     * Check if a process is managed
+     *
+     * @param agentId - Agent ID to check
+     * @returns Whether the process is managed
+     */
+    isManaged(agentId: string): boolean;
+    /**
+     * Get all managed processes
+     *
+     * @returns Array of all managed process records
+     */
+    getAllManagedProcesses(): ProcessRecord[];
+    /**
+     * Get managed processes by state
+     *
+     * @param state - Process state to filter by
+     * @returns Array of process records matching the state
+     */
+    getManagedProcessesByState(state: ProcessState): ProcessRecord[];
+    /**
+     * Find processes running on the machine that are NOT in registry
+     *
+     * @returns Array of unmanaged process info
+     */
+    getUnmanagedProcesses(): Promise<ProcessInfo[]>;
+    /**
+     * Rebuild the process registry from persisted sessions (e.g. on startup)
+     *
+     * Scans all persisted sessions, checks which processes are still running,
+     * and registers them with appropriate state.
+     *
+     * @param sessions - Array of persisted session data
+     */
+    rebuildRegistry(sessions: Array<{
+        agentId: string;
+        sessionId: string;
+        pid?: number;
+        workspacePath?: string;
+        command?: string;
+        mode?: 'pty' | 'sdk';
+    }>): Promise<void>;
+    /**
+     * Get process statistics
+     *
+     * @returns Statistics for all managed processes
+     */
+    getStats(): Record<ProcessState | 'total', number>;
+    /**
+     * Remove a process from registry
+     *
+     * @param agentId - Agent ID to remove
+     * @returns Whether the operation succeeded
+     */
+    removeProcess(agentId: string): Promise<boolean>;
+    /**
+     * Get a single process record
+     *
+     * @param agentId - Agent ID to get
+     * @returns Process record or undefined
+     */
+    getProcess(agentId: string): ProcessRecord | undefined;
+    /**
+     * Get a process record by PID
+     *
+     * @param pid - Process ID to get
+     * @returns Process record or undefined
+     */
+    getProcessByPid(pid: number): ProcessRecord | undefined;
+}
+/**
+ * Get the AgentProcessManager singleton instance
+ *
+ * @returns AgentProcessManager instance
+ */
+export declare function getAgentProcessManager(): AgentProcessManager;
+export type { ProcessRecord, ProcessState, HealthStatus, ProcessInfo, ProcessHealthStatus };
+//# sourceMappingURL=agent-process-manager.d.ts.map

package/dist/services/agent-process-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-process-manager.d.ts","sourceRoot":"","sources":["../../src/services/agent-process-manager.ts"],"names":[],"mappings":"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"}