mobile-debug-mcp 0.4.0 → 0.6.0

package/dist/android.js

@@ -1,44 +1,316 @@
-import { exec } from "child_process";
+import { spawn } from "child_process";
+import { XMLParser } from "fast-xml-parser";
 const ADB = process.env.ADB_PATH || "adb";
-export function startAndroidApp(pkg) {
+// Helper to construct ADB args with optional device ID
+function getAdbArgs(args, deviceId) {
+    if (deviceId) {
+        return ['-s', deviceId, ...args];
+    }
+    return args;
+}
+function execAdb(args, deviceId, options = {}) {
+    const adbArgs = getAdbArgs(args, deviceId);
     return new Promise((resolve, reject) => {
-        exec(`${ADB} shell monkey -p ${pkg} -c android.intent.category.LAUNCHER 1`, (err, stdout, stderr) => {
-            if (err)
-                reject(stderr);
-            else
-                resolve(stdout);
+        // Use spawn instead of execFile for better stream control and to avoid potential buffering hangs
+        const child = spawn(ADB, adbArgs, options);
+        let stdout = '';
+        let stderr = '';
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+        }
+        let timeoutMs = 2000;
+        if (args.includes('logcat')) {
+            timeoutMs = 10000;
+        }
+        else if (args.includes('uiautomator') && args.includes('dump')) {
+            timeoutMs = 20000; // UI dump can be slow
+        }
+        const timeout = setTimeout(() => {
+            child.kill();
+            reject(new Error(`ADB command timed out after ${timeoutMs}ms: ${args.join(' ')}`));
+        }, timeoutMs);
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            if (code !== 0) {
+                // If there's an actual error (non-zero exit code), reject
+                reject(new Error(stderr.trim() || `Command failed with code ${code}`));
+            }
+            else {
+                // If exit code is 0, resolve with stdout
+                resolve(stdout.trim());
+            }
+        });
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
         });
     });
 }
-export function getAndroidLogs(pkg, lines = 200) {
-    return new Promise((resolve, reject) => {
-        exec(`${ADB} shell pidof -s ${pkg}`, (pidErr, pidStdout, pidStderr) => {
-            if (pidErr || !pidStdout.trim()) {
-                reject(pidStderr || "App process not running");
-                return;
-            }
-            const pid = pidStdout.trim();
-            exec(`${ADB} logcat -d --pid=${pid} -t ${lines} -v threadtime`, (err, stdout, stderr) => {
-                if (err)
-                    reject(stderr || err.message);
-                else
-                    resolve(stdout);
+function parseBounds(bounds) {
+    const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+    if (match) {
+        return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3]), parseInt(match[4])];
+    }
+    return [0, 0, 0, 0];
+}
+async function getScreenResolution(deviceId) {
+    try {
+        const output = await execAdb(['shell', 'wm', 'size'], deviceId);
+        const match = output.match(/Physical size: (\d+)x(\d+)/);
+        if (match) {
+            return { width: parseInt(match[1]), height: parseInt(match[2]) };
+        }
+    }
+    catch (e) {
+        // ignore
+    }
+    return { width: 0, height: 0 };
+}
+function traverseNode(node, elements, parentIndex = -1) {
+    if (!node)
+        return -1;
+    let currentIndex = -1;
+    // Check if it's a valid node with attributes we care about
+    if (node['@_class']) {
+        const element = {
+            text: node['@_text'] || null,
+            contentDescription: node['@_content-desc'] || null,
+            type: node['@_class'] || 'unknown',
+            resourceId: node['@_resource-id'] || null,
+            clickable: node['@_clickable'] === 'true',
+            enabled: node['@_enabled'] === 'true',
+            visible: true, // uiautomator dump typically includes visible elements
+            bounds: parseBounds(node['@_bounds'] || '[0,0][0,0]')
+        };
+        if (parentIndex !== -1) {
+            element.parentId = parentIndex;
+        }
+        elements.push(element);
+        currentIndex = elements.length - 1;
+    }
+    // If current node was skipped (no class), children inherit parentIndex
+    // If current node was added, children use currentIndex
+    const nextParentIndex = currentIndex !== -1 ? currentIndex : parentIndex;
+    const childrenIndices = [];
+    // Traverse children
+    if (node.node) {
+        if (Array.isArray(node.node)) {
+            node.node.forEach((child) => {
+                const childIndex = traverseNode(child, elements, nextParentIndex);
+                if (childIndex !== -1)
+                    childrenIndices.push(childIndex);
             });
+        }
+        else {
+            const childIndex = traverseNode(node.node, elements, nextParentIndex);
+            if (childIndex !== -1)
+                childrenIndices.push(childIndex);
+        }
+    }
+    // Update current element with children if it was added
+    if (currentIndex !== -1 && childrenIndices.length > 0) {
+        elements[currentIndex].children = childrenIndices;
+    }
+    return currentIndex;
+}
+export async function getAndroidUITree(deviceId) {
+    const metadata = await getAndroidDeviceMetadata("", deviceId);
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+    try {
+        // Get screen resolution first
+        const resolution = await getScreenResolution(deviceId);
+        if (resolution.width === 0 && resolution.height === 0) {
+            throw new Error("Failed to get screen resolution. Is the device connected and authorized?");
+        }
+        // Dump UI hierarchy
+        // We suppress stderr because uiautomator dump sometimes outputs "UI hierchary dumped to: /sdcard/ui.xml" to stdout/stderr
+        await execAdb(['shell', 'uiautomator', 'dump', '/sdcard/ui.xml'], deviceId);
+        // Read the file
+        const xmlContent = await execAdb(['shell', 'cat', '/sdcard/ui.xml'], deviceId);
+        if (!xmlContent || xmlContent.trim().length === 0) {
+            throw new Error("Failed to read UI XML. File is empty.");
+        }
+        if (xmlContent.includes("ERROR:")) {
+            throw new Error(`UI Automator dump failed: ${xmlContent}`);
+        }
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_"
         });
-    });
+        const result = parser.parse(xmlContent);
+        const elements = [];
+        // The root is usually hierarchy -> node
+        if (result.hierarchy && result.hierarchy.node) {
+            // If the root is an array (unlikely for root, but good to be safe) or single object
+            if (Array.isArray(result.hierarchy.node)) {
+                result.hierarchy.node.forEach((n) => traverseNode(n, elements));
+            }
+            else {
+                traverseNode(result.hierarchy.node, elements);
+            }
+        }
+        return {
+            device: deviceInfo,
+            screen: "",
+            resolution,
+            elements
+        };
+    }
+    catch (e) {
+        const adbPath = process.env.ADB_PATH || "adb";
+        const errorMessage = `Failed to get UI tree. ADB Path: '${adbPath}'. Error: ${e instanceof Error ? e.message : String(e)}`;
+        console.error(errorMessage);
+        return {
+            device: deviceInfo,
+            screen: "",
+            resolution: { width: 0, height: 0 },
+            elements: [],
+            error: errorMessage
+        };
+    }
 }
-export async function getAndroidCrash(pkg, lines = 200) {
+function getDeviceInfo(deviceId, metadata = {}) {
+    return {
+        platform: 'android',
+        id: deviceId || 'default',
+        osVersion: metadata.osVersion || '',
+        model: metadata.model || '',
+        simulator: metadata.simulator || false
+    };
+}
+export async function getAndroidDeviceMetadata(appId, deviceId) {
     try {
-        const logs = await getAndroidLogs(pkg, lines);
-        const crashLines = logs
-            .split('\n')
-            .filter(line => line.includes('FATAL EXCEPTION'));
-        if (crashLines.length === 0) {
-            return "No crashes found.";
+        // Run these in parallel to avoid sequential timeouts
+        const [osVersion, model, simOutput] = await Promise.all([
+            execAdb(['shell', 'getprop', 'ro.build.version.release'], deviceId).catch(() => ''),
+            execAdb(['shell', 'getprop', 'ro.product.model'], deviceId).catch(() => ''),
+            execAdb(['shell', 'getprop', 'ro.kernel.qemu'], deviceId).catch(() => '0')
+        ]);
+        const simulator = simOutput === '1';
+        return { platform: 'android', id: deviceId || 'default', osVersion, model, simulator };
+    }
+    catch (e) {
+        return { platform: 'android', id: deviceId || 'default', osVersion: '', model: '', simulator: false };
+    }
+}
+export async function startAndroidApp(appId, deviceId) {
+    const metadata = await getAndroidDeviceMetadata(appId, deviceId);
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+    await execAdb(['shell', 'monkey', '-p', appId, '-c', 'android.intent.category.LAUNCHER', '1'], deviceId);
+    return { device: deviceInfo, appStarted: true, launchTimeMs: 1000 };
+}
+export async function terminateAndroidApp(appId, deviceId) {
+    const metadata = await getAndroidDeviceMetadata(appId, deviceId);
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+    await execAdb(['shell', 'am', 'force-stop', appId], deviceId);
+    return { device: deviceInfo, appTerminated: true };
+}
+export async function restartAndroidApp(appId, deviceId) {
+    await terminateAndroidApp(appId, deviceId);
+    const startResult = await startAndroidApp(appId, deviceId);
+    return {
+        device: startResult.device,
+        appRestarted: startResult.appStarted,
+        launchTimeMs: startResult.launchTimeMs
+    };
+}
+export async function resetAndroidAppData(appId, deviceId) {
+    const metadata = await getAndroidDeviceMetadata(appId, deviceId);
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+    const output = await execAdb(['shell', 'pm', 'clear', appId], deviceId);
+    return { device: deviceInfo, dataCleared: output === 'Success' };
+}
+export async function getAndroidLogs(appId, lines = 200, deviceId) {
+    const metadata = await getAndroidDeviceMetadata(appId || "", deviceId);
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+    try {
+        // We'll skip PID lookup for now to avoid potential hangs with 'pidof' on some emulators
+        // and rely on robust string matching against the log line.
+        // Get logs
+        const stdout = await execAdb(['logcat', '-d', '-t', lines.toString(), '-v', 'threadtime'], deviceId);
+        const allLogs = stdout.split('\n');
+        let filteredLogs = allLogs;
+        if (appId) {
+            // Filter by checking if the line contains the appId string.
+            const matchingLogs = allLogs.filter(line => line.includes(appId));
+            if (matchingLogs.length > 0) {
+                filteredLogs = matchingLogs;
+            }
+            else {
+                // Fallback: if no logs match the appId, return the raw logs (last N lines)
+                // This matches the behavior of the "working" version provided by the user,
+                // ensuring they at least see system activity if the app is silent or crashing early.
+                filteredLogs = allLogs;
+            }
         }
-        return crashLines.join('\n');
+        return { device: deviceInfo, logs: filteredLogs, logCount: filteredLogs.length };
     }
-    catch (error) {
-        return `Error retrieving crash logs: ${error}`;
+    catch (e) {
+        console.error("Error fetching logs:", e);
+        return { device: deviceInfo, logs: [], logCount: 0 };
     }
 }
+export async function captureAndroidScreen(deviceId) {
+    const metadata = await getAndroidDeviceMetadata("", deviceId);
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+    return new Promise((resolve, reject) => {
+        const adbArgs = getAdbArgs(['exec-out', 'screencap', '-p'], deviceId);
+        // Using spawn for screencap as well to ensure consistent process handling
+        const child = spawn(ADB, adbArgs);
+        const chunks = [];
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            chunks.push(Buffer.from(chunk));
+        });
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        const timeout = setTimeout(() => {
+            child.kill();
+            reject(new Error(`ADB screencap timed out after 10s`));
+        }, 10000);
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            if (code !== 0) {
+                reject(new Error(stderr.trim() || `Screencap failed with code ${code}`));
+                return;
+            }
+            const screenshotBuffer = Buffer.concat(chunks);
+            const screenshotBase64 = screenshotBuffer.toString('base64');
+            // Get resolution
+            execAdb(['shell', 'wm', 'size'], deviceId)
+                .then(sizeStdout => {
+                let width = 0;
+                let height = 0;
+                const match = sizeStdout.match(/Physical size: (\d+)x(\d+)/);
+                if (match) {
+                    width = parseInt(match[1], 10);
+                    height = parseInt(match[2], 10);
+                }
+                resolve({
+                    device: deviceInfo,
+                    screenshot: screenshotBase64,
+                    resolution: { width, height }
+                });
+            })
+                .catch(() => {
+                resolve({
+                    device: deviceInfo,
+                    screenshot: screenshotBase64,
+                    resolution: { width: 0, height: 0 }
+                });
+            });
+        });
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}

package/dist/ios/interact.js

@@ -0,0 +1,65 @@
+import { promises as fs } from "fs";
+import { execCommand, getIOSDeviceMetadata, validateBundleId } from "./utils.js";
+export class iOSInteract {
+    async startApp(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        // Simulate launch time and appStarted for demonstration
+        return {
+            device,
+            appStarted: !!result.output,
+            launchTimeMs: 1000,
+        };
+    }
+    async terminateApp(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        await execCommand(['simctl', 'terminate', deviceId, bundleId], deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        return {
+            device,
+            appTerminated: true
+        };
+    }
+    async restartApp(bundleId, deviceId = "booted") {
+        // terminateApp already validates bundleId
+        await this.terminateApp(bundleId, deviceId);
+        const startResult = await this.startApp(bundleId, deviceId);
+        return {
+            device: startResult.device,
+            appRestarted: startResult.appStarted,
+            launchTimeMs: startResult.launchTimeMs
+        };
+    }
+    async resetAppData(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        await this.terminateApp(bundleId, deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        // Get data container path
+        const containerResult = await execCommand(['simctl', 'get_app_container', deviceId, bundleId, 'data'], deviceId);
+        const dataPath = containerResult.output.trim();
+        if (!dataPath) {
+            throw new Error(`Could not find data container for ${bundleId}`);
+        }
+        // Clear contents of Library and Documents
+        try {
+            const libraryPath = `${dataPath}/Library`;
+            const documentsPath = `${dataPath}/Documents`;
+            const tmpPath = `${dataPath}/tmp`;
+            await fs.rm(libraryPath, { recursive: true, force: true }).catch(() => { });
+            await fs.rm(documentsPath, { recursive: true, force: true }).catch(() => { });
+            await fs.rm(tmpPath, { recursive: true, force: true }).catch(() => { });
+            // Re-create empty directories as they are expected by apps
+            await fs.mkdir(libraryPath, { recursive: true }).catch(() => { });
+            await fs.mkdir(documentsPath, { recursive: true }).catch(() => { });
+            await fs.mkdir(tmpPath, { recursive: true }).catch(() => { });
+            return {
+                device,
+                dataCleared: true
+            };
+        }
+        catch (err) {
+            throw new Error(`Failed to clear data for ${bundleId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/ios/observe.js

@@ -0,0 +1,219 @@
+import { spawn } from "child_process";
+import { promises as fs } from "fs";
+import { execCommand, getIOSDeviceMetadata, validateBundleId, IDB } from "./utils.js";
+// --- Helper Functions Specific to Observe ---
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+function parseIDBFrame(frame) {
+    if (!frame)
+        return [0, 0, 0, 0];
+    const x = Number(frame.x || 0);
+    const y = Number(frame.y || 0);
+    const w = Number(frame.width || frame.w || 0);
+    const h = Number(frame.height || frame.h || 0);
+    return [Math.round(x), Math.round(y), Math.round(x + w), Math.round(y + h)];
+}
+function getCenter(bounds) {
+    const [x1, y1, x2, y2] = bounds;
+    return [Math.floor((x1 + x2) / 2), Math.floor((y1 + y2) / 2)];
+}
+function traverseIDBNode(node, elements, parentIndex = -1, depth = 0) {
+    if (!node)
+        return -1;
+    let currentIndex = -1;
+    // Prefer standard keys, fallback to alternatives
+    const type = node.AXElementType || node.type || "unknown";
+    const label = node.AXLabel || node.label || null;
+    const value = node.AXValue || null;
+    const frame = node.AXFrame || node.frame;
+    const traits = node.AXTraits || [];
+    const clickable = traits.includes("UIAccessibilityTraitButton") || type === "Button" || type === "Cell"; // Cells are often clickable
+    // Filtering Logic:
+    // Keep if clickable OR has visible text/label OR has value
+    // Also keep 'Window' or 'Application' types as they define the root structure often, though usually depth 0
+    const isUseful = clickable || (label && label.length > 0) || (value && value.length > 0) || type === "Application" || type === "Window";
+    if (isUseful) {
+        const bounds = parseIDBFrame(frame);
+        const element = {
+            text: label,
+            contentDescription: value,
+            type: type,
+            resourceId: node.AXUniqueId || null,
+            clickable: clickable,
+            enabled: true, // idb usually returns enabled elements
+            visible: true,
+            bounds: bounds,
+            center: getCenter(bounds),
+            depth: depth
+        };
+        if (parentIndex !== -1) {
+            element.parentId = parentIndex;
+        }
+        elements.push(element);
+        currentIndex = elements.length - 1;
+    }
+    // If current node was skipped, children inherit parentIndex and depth (flattening)
+    // If current node was added, children use currentIndex and depth + 1
+    const nextParentIndex = currentIndex !== -1 ? currentIndex : parentIndex;
+    const nextDepth = currentIndex !== -1 ? depth + 1 : depth;
+    const childrenIndices = [];
+    if (node.children && Array.isArray(node.children)) {
+        for (const child of node.children) {
+            const childIndex = traverseIDBNode(child, elements, nextParentIndex, nextDepth);
+            if (childIndex !== -1) {
+                childrenIndices.push(childIndex);
+            }
+        }
+    }
+    if (currentIndex !== -1 && childrenIndices.length > 0) {
+        elements[currentIndex].children = childrenIndices;
+    }
+    return currentIndex;
+}
+// Check if IDB is installed
+async function isIDBInstalled() {
+    return new Promise((resolve) => {
+        // Check if 'idb' is in path by trying to run it
+        const child = spawn(IDB, ['--version']);
+        child.on('error', () => resolve(false));
+        child.on('close', (code) => resolve(code === 0));
+    });
+}
+export class iOSObserve {
+    async getDeviceMetadata(deviceId = "booted") {
+        return getIOSDeviceMetadata(deviceId);
+    }
+    async getLogs(appId, deviceId = "booted") {
+        // If appId is provided, use predicate filtering
+        // Note: execFile passes args directly, so we don't need shell escaping for the predicate string itself,
+        // but we do need to construct the predicate correctly for log show.
+        const args = ['simctl', 'spawn', deviceId, 'log', 'show', '--style', 'syslog', '--last', '1m'];
+        if (appId) {
+            validateBundleId(appId);
+            args.push('--predicate', `subsystem contains "${appId}" or process == "${appId}"`);
+        }
+        const result = await execCommand(args, deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        const logs = result.output ? result.output.split('\n') : [];
+        return {
+            device,
+            logs,
+            logCount: logs.length,
+        };
+    }
+    async captureScreenshot(deviceId = "booted") {
+        const device = await getIOSDeviceMetadata(deviceId);
+        const tmpFile = `/tmp/mcp-ios-screenshot-${Date.now()}.png`;
+        try {
+            // 1. Capture screenshot to temp file
+            await execCommand(['simctl', 'io', deviceId, 'screenshot', tmpFile], deviceId);
+            // 2. Read file as base64
+            const buffer = await fs.readFile(tmpFile);
+            const base64 = buffer.toString('base64');
+            // 3. Clean up
+            await fs.rm(tmpFile).catch(() => { });
+            return {
+                device,
+                screenshot: base64,
+                // Default resolution since we can't easily parse it without extra libs
+                // Clients will read the real dimensions from the PNG header anyway
+                resolution: { width: 0, height: 0 },
+            };
+        }
+        catch (err) {
+            // Ensure cleanup happens even on error
+            await fs.rm(tmpFile).catch(() => { });
+            throw new Error(`Failed to capture screenshot: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async getUITree(deviceId = "booted") {
+        const device = await getIOSDeviceMetadata(deviceId);
+        // idb is required
+        const idbExists = await isIDBInstalled();
+        if (!idbExists) {
+            return {
+                device,
+                screen: "",
+                resolution: { width: 0, height: 0 },
+                elements: [],
+                error: "iOS UI tree retrieval requires 'idb' (iOS Device Bridge). Please install it via Homebrew: `brew tap facebook/fb && brew install idb-companion` and `pip3 install fb-idb`."
+            };
+        }
+        // Resolve UDID if needed
+        const targetUdid = (device.id && device.id !== 'booted') ? device.id : undefined;
+        // Retry Logic
+        let jsonContent = null;
+        let attempts = 0;
+        const maxAttempts = 3;
+        while (attempts < maxAttempts) {
+            attempts++;
+            try {
+                // Stabilization delay
+                await delay(300 + (attempts * 100));
+                const args = ['ui', 'describe', '--json'];
+                if (targetUdid) {
+                    args.push('--udid', targetUdid);
+                }
+                const output = await new Promise((resolve, reject) => {
+                    const child = spawn(IDB, args);
+                    let stdout = '';
+                    let stderr = '';
+                    child.stdout.on('data', (data) => stdout += data.toString());
+                    child.stderr.on('data', (data) => stderr += data.toString());
+                    child.on('error', (err) => reject(new Error(`Failed to execute idb: ${err.message}`)));
+                    child.on('close', (code) => {
+                        if (code !== 0) {
+                            reject(new Error(`idb failed (code ${code}): ${stderr.trim()}`));
+                        }
+                        else {
+                            resolve(stdout);
+                        }
+                    });
+                });
+                if (output && output.trim().length > 0) {
+                    jsonContent = JSON.parse(output);
+                    break; // Success
+                }
+            }
+            catch (err) {
+                console.error(`Attempt ${attempts} failed: ${err}`);
+            }
+            if (attempts === maxAttempts) {
+                return {
+                    device,
+                    screen: "",
+                    resolution: { width: 0, height: 0 },
+                    elements: [],
+                    error: `Failed to retrieve valid UI dump after ${maxAttempts} attempts.`
+                };
+            }
+        }
+        try {
+            const elements = [];
+            const root = jsonContent;
+            traverseIDBNode(root, elements);
+            // Infer resolution from root element if possible (usually the Window/Application frame)
+            let width = 0;
+            let height = 0;
+            if (elements.length > 0) {
+                const rootBounds = elements[0].bounds;
+                width = rootBounds[2] - rootBounds[0];
+                height = rootBounds[3] - rootBounds[1];
+            }
+            return {
+                device,
+                screen: "",
+                resolution: { width, height },
+                elements
+            };
+        }
+        catch (e) {
+            return {
+                device,
+                screen: "",
+                resolution: { width: 0, height: 0 },
+                elements: [],
+                error: `Failed to parse idb output: ${e instanceof Error ? e.message : String(e)}`
+            };
+        }
+    }
+}