mobile-debug-mcp 0.24.6 → 0.24.8

package/dist/server/tool-handlers.js

@@ -4,9 +4,11 @@ import { ToolsObserve } from '../observe/index.js';
 import { classifyActionOutcome } from '../interact/classify.js';
 import { ToolsNetwork } from '../network/index.js';
 import { getSystemStatus } from '../system/index.js';
-import { buildActionExecutionResult, captureActionFingerprint, inferGenericFailure, inferScrollFailure, wrapResponse, wrapToolError } from './common.js';
+import { buildActionExecutionResult, captureActionFingerprint, getArrayArg, getBooleanArg, getNumberArg, getObjectArg, getStringArg, inferGenericFailure, inferScrollFailure, requireBooleanArg, requireNumberArg, requireObjectArg, requireStringArg, wrapResponse, wrapToolError } from './common.js';
 async function handleStartApp(args) {
-    const { platform, appId, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const appId = requireStringArg(args, 'appId');
+    const deviceId = getStringArg(args, 'deviceId');
     const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
     ToolsNetwork.notifyActionStart();
     const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId));
@@ -29,13 +31,17 @@ async function handleStartApp(args) {
     }));
 }
 async function handleTerminateApp(args) {
-    const { platform, appId, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const appId = requireStringArg(args, 'appId');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await (platform === 'android' ? new AndroidManage().terminateApp(appId, deviceId) : new iOSManage().terminateApp(appId, deviceId));
     const response = { device: res.device, appTerminated: res.appTerminated };
     return wrapResponse(response);
 }
 async function handleRestartApp(args) {
-    const { platform, appId, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const appId = requireStringArg(args, 'appId');
+    const deviceId = getStringArg(args, 'deviceId');
     const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
     ToolsNetwork.notifyActionStart();
     const res = await (platform === 'android' ? new AndroidManage().restartApp(appId, deviceId) : new iOSManage().restartApp(appId, deviceId));
@@ -59,13 +65,18 @@ async function handleRestartApp(args) {
     }));
 }
 async function handleResetAppData(args) {
-    const { platform, appId, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const appId = requireStringArg(args, 'appId');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await (platform === 'android' ? new AndroidManage().resetAppData(appId, deviceId) : new iOSManage().resetAppData(appId, deviceId));
     const response = { device: res.device, dataCleared: res.dataCleared };
     return wrapResponse(response);
 }
 async function handleInstallApp(args) {
-    const { platform, projectType, appPath, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const projectType = requireStringArg(args, 'projectType');
+    const appPath = requireStringArg(args, 'appPath');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsManage.installAppHandler({ platform, appPath, deviceId, projectType });
     const response = {
         device: res.device,
@@ -76,12 +87,19 @@ async function handleInstallApp(args) {
     return wrapResponse(response);
 }
 async function handleBuildApp(args) {
-    const { platform, projectType, projectPath, variant } = args;
+    const platform = requireStringArg(args, 'platform');
+    const projectType = requireStringArg(args, 'projectType');
+    const projectPath = requireStringArg(args, 'projectPath');
+    const variant = getStringArg(args, 'variant');
     const res = await ToolsManage.buildAppHandler({ platform, projectPath, variant, projectType });
     return wrapResponse(res);
 }
 async function handleBuildAndInstall(args) {
-    const { platform, projectType, projectPath, deviceId, timeout } = args;
+    const platform = requireStringArg(args, 'platform');
+    const projectType = requireStringArg(args, 'projectType');
+    const projectPath = requireStringArg(args, 'projectPath');
+    const deviceId = getStringArg(args, 'deviceId');
+    const timeout = getNumberArg(args, 'timeout');
     const res = await ToolsManage.buildAndInstallHandler({ platform, projectPath, deviceId, timeout, projectType });
     return {
         content: [
@@ -91,7 +109,16 @@ async function handleBuildAndInstall(args) {
     };
 }
 async function handleGetLogs(args) {
-    const { platform, appId, deviceId, pid, tag, level, contains, since_seconds, limit, lines } = args;
+    const platform = requireStringArg(args, 'platform');
+    const appId = getStringArg(args, 'appId');
+    const deviceId = getStringArg(args, 'deviceId');
+    const pid = getNumberArg(args, 'pid');
+    const tag = getStringArg(args, 'tag');
+    const level = getStringArg(args, 'level');
+    const contains = getStringArg(args, 'contains');
+    const since_seconds = getNumberArg(args, 'since_seconds');
+    const limit = getNumberArg(args, 'limit');
+    const lines = getNumberArg(args, 'lines');
     const res = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, pid, tag, level, contains, since_seconds, limit, lines });
     const filtered = !!(pid || tag || level || contains || since_seconds || appId);
     return {
@@ -102,7 +129,8 @@ async function handleGetLogs(args) {
     };
 }
 async function handleListDevices(args) {
-    const { platform, appId } = args;
+    const platform = getStringArg(args, 'platform');
+    const appId = getStringArg(args, 'appId');
     const res = await ToolsManage.listDevicesHandler({ platform, appId });
     return wrapResponse(res);
 }
@@ -111,7 +139,8 @@ async function handleGetSystemStatus() {
     return wrapResponse(result);
 }
 async function handleCaptureScreenshot(args) {
-    const { platform, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsObserve.captureScreenshotHandler({ platform, deviceId });
     const mime = res.screenshot_mime || 'image/png';
     const content = [
@@ -125,52 +154,86 @@ async function handleCaptureScreenshot(args) {
     return { content };
 }
 async function handleCaptureDebugSnapshot(args) {
-    const { reason, includeLogs, logLines, platform, appId, deviceId, sessionId } = args;
+    const reason = getStringArg(args, 'reason');
+    const includeLogs = getBooleanArg(args, 'includeLogs');
+    const logLines = getNumberArg(args, 'logLines');
+    const platform = getStringArg(args, 'platform');
+    const appId = getStringArg(args, 'appId');
+    const deviceId = getStringArg(args, 'deviceId');
+    const sessionId = getStringArg(args, 'sessionId');
     const res = await ToolsObserve.captureDebugSnapshotHandler({ reason, includeLogs, logLines, platform, appId, deviceId, sessionId });
     return wrapResponse(res);
 }
 async function handleGetUITree(args) {
-    const { platform, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsObserve.getUITreeHandler({ platform, deviceId });
     return wrapResponse(res);
 }
 async function handleGetCurrentScreen(args) {
-    const { deviceId } = args;
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsObserve.getCurrentScreenHandler({ deviceId });
     return wrapResponse(res);
 }
 async function handleGetScreenFingerprint(args) {
-    const { platform, deviceId } = args;
+    const platform = getStringArg(args, 'platform');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId });
     return wrapResponse(res);
 }
 async function handleWaitForScreenChange(args) {
-    const { platform, previousFingerprint, timeoutMs, pollIntervalMs, deviceId } = args;
+    const platform = getStringArg(args, 'platform');
+    const previousFingerprint = requireStringArg(args, 'previousFingerprint');
+    const timeoutMs = getNumberArg(args, 'timeoutMs');
+    const pollIntervalMs = getNumberArg(args, 'pollIntervalMs');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsInteract.waitForScreenChangeHandler({ platform, previousFingerprint, timeoutMs, pollIntervalMs, deviceId });
     return wrapResponse(res);
 }
 async function handleExpectScreen(args) {
-    const { platform, fingerprint, screen, deviceId } = args;
+    const platform = getStringArg(args, 'platform');
+    const fingerprint = getStringArg(args, 'fingerprint');
+    const screen = getStringArg(args, 'screen');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsInteract.expectScreenHandler({ platform, fingerprint, screen, deviceId });
     return wrapResponse(res);
 }
 async function handleExpectElementVisible(args) {
-    const { selector, element_id, timeout_ms, poll_interval_ms, platform, deviceId } = args;
+    const selector = requireObjectArg(args, 'selector');
+    const element_id = getStringArg(args, 'element_id');
+    const timeout_ms = getNumberArg(args, 'timeout_ms');
+    const poll_interval_ms = getNumberArg(args, 'poll_interval_ms');
+    const platform = getStringArg(args, 'platform');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsInteract.expectElementVisibleHandler({ selector, element_id, timeout_ms, poll_interval_ms, platform, deviceId });
     return wrapResponse(res);
 }
 async function handleWaitForUI(args) {
-    const { selector, condition = 'exists', timeout_ms = 60000, poll_interval_ms = 300, match, retry, platform, deviceId } = args;
+    const selector = getObjectArg(args, 'selector');
+    const condition = getStringArg(args, 'condition') ?? 'exists';
+    const timeout_ms = getNumberArg(args, 'timeout_ms') ?? 60000;
+    const poll_interval_ms = getNumberArg(args, 'poll_interval_ms') ?? 300;
+    const match = getObjectArg(args, 'match');
+    const retry = getObjectArg(args, 'retry');
+    const platform = getStringArg(args, 'platform');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsInteract.waitForUIHandler({ selector, condition, timeout_ms, poll_interval_ms, match, retry, platform, deviceId });
     return wrapResponse(res);
 }
 async function handleFindElement(args) {
-    const { query, exact = false, timeoutMs = 3000, platform, deviceId } = args;
+    const query = requireStringArg(args, 'query');
+    const exact = getBooleanArg(args, 'exact') ?? false;
+    const timeoutMs = getNumberArg(args, 'timeoutMs') ?? 3000;
+    const platform = getStringArg(args, 'platform');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsInteract.findElementHandler({ query, exact, timeoutMs, platform, deviceId });
     return wrapResponse(res);
 }
 async function handleTap(args) {
-    const { platform, x, y, deviceId } = args;
+    const platform = getStringArg(args, 'platform');
+    const x = requireNumberArg(args, 'x');
+    const y = requireNumberArg(args, 'y');
+    const deviceId = getStringArg(args, 'deviceId');
     const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
     ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.tapHandler({ platform, x, y, deviceId });
@@ -185,13 +248,19 @@ async function handleTap(args) {
     }));
 }
 async function handleTapElement(args) {
-    const { elementId } = args;
+    const elementId = requireStringArg(args, 'elementId');
     ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.tapElementHandler({ elementId });
     return wrapResponse(res);
 }
 async function handleSwipe(args) {
-    const { platform = 'android', x1, y1, x2, y2, duration, deviceId } = args;
+    const platform = getStringArg(args, 'platform') ?? 'android';
+    const x1 = requireNumberArg(args, 'x1');
+    const y1 = requireNumberArg(args, 'y1');
+    const x2 = requireNumberArg(args, 'x2');
+    const y2 = requireNumberArg(args, 'y2');
+    const duration = requireNumberArg(args, 'duration');
+    const deviceId = getStringArg(args, 'deviceId');
     const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
     ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.swipeHandler({ platform, x1, y1, x2, y2, duration, deviceId });
@@ -206,14 +275,19 @@ async function handleSwipe(args) {
     }));
 }
 async function handleScrollToElement(args) {
-    const { platform, selector, direction, maxScrolls, scrollAmount, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const selector = requireObjectArg(args, 'selector');
+    const direction = getStringArg(args, 'direction');
+    const maxScrolls = getNumberArg(args, 'maxScrolls');
+    const scrollAmount = getNumberArg(args, 'scrollAmount');
+    const deviceId = getStringArg(args, 'deviceId');
     const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
     ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.scrollToElementHandler({ platform, selector, direction, maxScrolls, scrollAmount, deviceId });
     const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId);
     return wrapResponse(buildActionExecutionResult({
         actionType: 'scroll_to_element',
-        selector,
+        selector: selector ?? null,
         resolved: res?.success && res?.element ? {
             elementId: null,
             text: res.element.text ?? null,
@@ -230,7 +304,8 @@ async function handleScrollToElement(args) {
     }));
 }
 async function handleTypeText(args) {
-    const { text, deviceId } = args;
+    const text = requireStringArg(args, 'text');
+    const deviceId = getStringArg(args, 'deviceId');
     const uiFingerprintBefore = await captureActionFingerprint('android', deviceId);
     ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.typeTextHandler({ text, deviceId });
@@ -245,7 +320,7 @@ async function handleTypeText(args) {
     }));
 }
 async function handlePressBack(args) {
-    const { deviceId } = args;
+    const deviceId = getStringArg(args, 'deviceId');
     const uiFingerprintBefore = await captureActionFingerprint('android', deviceId);
     ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.pressBackHandler({ deviceId });
@@ -260,24 +335,35 @@ async function handlePressBack(args) {
     }));
 }
 async function handleStartLogStream(args) {
-    const { platform, packageName, level, sessionId, deviceId } = args;
+    const platform = getStringArg(args, 'platform') ?? 'android';
+    const packageName = requireStringArg(args, 'packageName');
+    const level = getStringArg(args, 'level') ?? 'error';
+    const sessionId = getStringArg(args, 'sessionId');
+    const deviceId = getStringArg(args, 'deviceId');
     const res = await ToolsObserve.startLogStreamHandler({ platform, packageName, level, sessionId, deviceId });
     return wrapResponse(res);
 }
 async function handleReadLogStream(args) {
-    const { platform, sessionId, limit, since } = args;
+    const platform = getStringArg(args, 'platform');
+    const sessionId = getStringArg(args, 'sessionId');
+    const limit = getNumberArg(args, 'limit');
+    const since = getStringArg(args, 'since');
     const res = await ToolsObserve.readLogStreamHandler({ platform, sessionId, limit, since });
     return wrapResponse(res);
 }
 async function handleStopLogStream(args) {
-    const { platform, sessionId } = args;
+    const platform = getStringArg(args, 'platform');
+    const sessionId = getStringArg(args, 'sessionId');
     const res = await ToolsObserve.stopLogStreamHandler({ platform, sessionId });
     return wrapResponse(res);
 }
 function handleClassifyActionOutcome(args) {
-    const { uiChanged, expectedElementVisible, networkRequests, hasLogErrors } = args;
+    const uiChanged = requireBooleanArg(args, 'uiChanged');
+    const expectedElementVisible = getBooleanArg(args, 'expectedElementVisible');
+    const networkRequests = getArrayArg(args, 'networkRequests');
+    const hasLogErrors = getBooleanArg(args, 'hasLogErrors');
     const result = classifyActionOutcome({
-        uiChanged: Boolean(uiChanged),
+        uiChanged,
         expectedElementVisible: expectedElementVisible ?? null,
         networkRequests: networkRequests ?? null,
         hasLogErrors: hasLogErrors ?? null
@@ -285,7 +371,8 @@ function handleClassifyActionOutcome(args) {
     return Promise.resolve(wrapResponse(result));
 }
 async function handleGetNetworkActivity(args) {
-    const { platform, deviceId } = args;
+    const platform = requireStringArg(args, 'platform');
+    const deviceId = getStringArg(args, 'deviceId');
     const result = await ToolsNetwork.getNetworkActivity({ platform, deviceId });
     return wrapResponse(result);
 }

package/dist/server-core.js

@@ -6,7 +6,7 @@ import { handleToolCall } from './server/tool-handlers.js';
 export { wrapResponse, toolDefinitions, handleToolCall };
 export const serverInfo = {
     name: 'mobile-debug-mcp',
-    version: '0.7.0'
+    version: '0.24.8'
 };
 export function createServer() {
     const server = new Server(serverInfo, {

package/dist/utils/android/utils.js

@@ -57,23 +57,36 @@ export function ensureAdbAvailable() {
         return { adbCmd: adb, ok: false, error: String(err) };
     }
 }
+function mergeEnv(overrides) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value === 'string')
+            env[key] = value;
+    }
+    for (const [key, value] of Object.entries(overrides || {})) {
+        if (typeof value === 'string')
+            env[key] = value;
+    }
+    return env;
+}
 /**
  * Prepare Gradle execution options for building an Android project.
  * Returns execCmd (wrapper or gradle), base gradleArgs array, and spawn options including env.
  */
-export async function prepareGradle(projectPath) {
+export async function prepareGradle(projectPath, envOverrides = {}) {
+    const env = mergeEnv(envOverrides);
     const gradlewPath = path.join(projectPath, 'gradlew');
     const gradleCmd = existsSync(gradlewPath) ? './gradlew' : 'gradle';
     const execCmd = existsSync(gradlewPath) ? gradlewPath : gradleCmd;
     // Start with a default task; callers may append/override via env flags
-    const gradleArgs = [process.env.MCP_GRADLE_TASK || 'assembleDebug'];
+    const gradleArgs = [env.MCP_GRADLE_TASK || 'assembleDebug'];
     // Respect generic MCP_BUILD_JOBS and Android-specific MCP_GRADLE_WORKERS
-    const workers = process.env.MCP_GRADLE_WORKERS || process.env.MCP_BUILD_JOBS;
+    const workers = env.MCP_GRADLE_WORKERS || env.MCP_BUILD_JOBS;
     if (workers) {
         gradleArgs.push(`--max-workers=${workers}`);
     }
     // Respect gradle cache env: default enabled; set MCP_GRADLE_CACHE=0 to disable
-    if (process.env.MCP_GRADLE_CACHE === '0') {
+    if (env.MCP_GRADLE_CACHE === '0') {
         gradleArgs.push('-Dorg.gradle.caching=false');
     }
     const detectedJavaHome = await detectJavaHome().catch(() => undefined);
@@ -85,7 +98,6 @@ export async function prepareGradle(projectPath) {
     catch {
         gradleCheck = { gradleJavaHome: undefined, gradleValid: false, filesChecked: [], issues: [] };
     }
-    const env = Object.assign({}, process.env);
     // Ensure child processes can find Android platform-tools (adb, etc.) by
     // prepending the platform-tools directory to PATH for spawned processes.
     const adbPath = resolveAdbCmd();

package/dist/utils/cli/idb/check-idb.js

@@ -24,7 +24,7 @@ async function runInstaller() {
         // prefer invoking the TS script via npx/tsx to ensure environment
         const runner = which('npx') ? 'npx' : which('tsx') ? 'tsx' : null;
         if (runner) {
-            const args = runner === 'npx' ? ['tsx', './src/cli/idb/install-idb.ts'] : ['./src/cli/idb/install-idb.ts'];
+            const args = runner === 'npx' ? ['tsx', './src/utils/cli/idb/install-idb.ts'] : ['./src/utils/cli/idb/install-idb.ts'];
             const res = spawnSync(runner, args, { stdio: 'inherit' });
             return typeof res.status === 'number' ? res.status === 0 : false;
         }

package/docs/CHANGELOG.md

@@ -2,8 +2,16 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
-## [0.24.6]
-- minor changes
+## [0.24.8]
+- Improved slider interaction
+
+## [0.24.7]
+- Aligned runtime metadata with the published package version.
+- Fixed stale CLI helper paths in npm scripts and the `idb` healthcheck helper.
+- Simplified ESLint configuration by keeping the flat config and removing legacy config files.
+- Updated CI to use the current automated device test runner.
+- Tightened server handler argument parsing and added contract coverage for version and required-argument error responses.
+- Scoped temporary build environment overrides to the duration of each build helper call and added regression coverage for env restoration.
 
 ## [0.24.5]
 - Improved snapshots
@@ -27,7 +35,7 @@ All notable changes to the **Mobile Debug MCP** project will be documented in th
 
 ## [0.23.0]
 - Added network monitoring
-- Added 
+- Added action-outcome classification tooling for backend-driven flows without visible UI changes.
 
 ## [0.22.0]
 - Added a portable `test-authoring` skill package and documented the repository's vendor-neutral skill format
@@ -38,14 +46,14 @@ All notable changes to the **Mobile Debug MCP** project will be documented in th
 - Fixed incorrect timeout
 
 ## [0.21.4]
-- updated `wait_for_ui` with better contract and observability
-- update `get_logs` to get better output
+- Updated `wait_for_ui` with better contract and observability
+- Updated `get_logs` to return more useful structured output
 
 ## [0.21.3]
 - Added structured logs
 
 ## [0.21.2]
-- Fixed screenshots not working, imnproved tool
+- Fixed screenshots not working and improved the tool output
 
 ## [0.21.1]
 - Removed wait_for_element and renamed observe_until to wait_for_ui (obsolete references removed)
@@ -54,7 +62,7 @@ All notable changes to the **Mobile Debug MCP** project will be documented in th
 - Added `wait_for_ui` as a tool for agents to wait for things like API requests
 
 ## [0.20.1]
-- Fixes gradle home issue for android
+- Fixed Gradle home handling for Android
 
 ## [0.20.0]
 - Added `get_system_status` tool and refactored system health checks into `src/system`.
@@ -63,8 +71,8 @@ All notable changes to the **Mobile Debug MCP** project will be documented in th
 
 
 ## [0.19.2]
-- Added healthcheck improvments
-- Added skills 
+- Added healthcheck improvements
+- Added reusable agent skills
 
 ## [0.19.1]
 
@@ -113,7 +121,7 @@ All notable changes to the **Mobile Debug MCP** project will be documented in th
 ## [0.12.1]
 - Improve iOS build/install reliability: project auto-scan, explicit simulator destination, configurable watchdog timeout (MCP_XCODEBUILD_TIMEOUT) and retries (MCP_XCODEBUILD_RETRIES), and DerivedData fallback for locating .app artifacts.
 - Make install_app capable of building iOS projects before installing so agents can autonomously fix, build, install and validate apps.
-- Migrate CLI scripts into typed src/cli/* modules and update npm scripts; fix ESM import paths and lint issues.
+- Migrate CLI scripts into typed source modules and update npm scripts; fix ESM import paths and lint issues.
 - Add preflight checks and idb resolution helpers (getIdbCmd, isIDBInstalled) and add idb_companion health checks.
 - Capture build stdout/stderr into build-results/ for easier diagnostics and surfaced suggestions when KMP frameworks are missing.
 - Add device test runner under test/device and gate device-dependent tests behind RUN_DEVICE_TESTS.

package/eslint.config.js

@@ -3,7 +3,6 @@ import tsPlugin from '@typescript-eslint/eslint-plugin'
 import unusedImports from 'eslint-plugin-unused-imports'
 
 export default [
-  // Files/directories to ignore
   {
     ignores: [
       'dist/',
@@ -11,55 +10,11 @@ export default [
       '.git/',
       '.vscode/',
       'coverage/',
-      '.env',
+      '.env'
     ]
   },
-  // Apply rules to JS/TS source
   {
-    files: ['src/**/*.ts', 'src/**/*.js'],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: 2020,
-        sourceType: 'module',
-        project: './tsconfig.json'
-      }
-    },
-    plugins: {
-      '@typescript-eslint': tsPlugin,
-      'unused-imports': unusedImports
-    },
-    rules: {
-      // Use plugin to error on unused imports and provide autofix where possible
-      'unused-imports/no-unused-imports': 'error',
-      'unused-imports/no-unused-vars': ['error', { vars: 'all', args: 'after-used', ignoreRestSiblings: true }],
-      // Disable the default TS rule to avoid duplicate warnings
-      '@typescript-eslint/no-unused-vars': 'off'
-    }
-  },
-  // Apply lighter rules to test files (no project reference to avoid TS project parsing)
-  {
-    files: ['test/**/*.ts', 'test/**/*.js'],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: 2020,
-        sourceType: 'module'
-      }
-    },
-    plugins: {
-      '@typescript-eslint': tsPlugin,
-      'unused-imports': unusedImports
-    },
-    rules: {
-      'unused-imports/no-unused-imports': 'error',
-      'unused-imports/no-unused-vars': ['error', { vars: 'all', args: 'after-used', ignoreRestSiblings: true }],
-      '@typescript-eslint/no-unused-vars': 'off'
-    }
-  },
-  // Apply rules to CLI tooling
-  {
-    files: ['src/cli/**/*.ts', 'src/cli/**/*.js'],
+    files: ['src/**/*.ts', 'src/**/*.js', 'test/**/*.ts', 'test/**/*.js'],
     languageOptions: {
       parser: tsParser,
       parserOptions: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.24.6",
+  "version": "0.24.8",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {
@@ -10,15 +10,16 @@
     "build": "tsc",
     "start": "node ./dist/server.js",
     "prepare": "npm run build",
-    "healthcheck": "tsx ./src/cli/idb/check-idb.ts",
-    "install-idb": "tsx ./src/cli/idb/install-idb.ts",
-    "preflight-ios": "tsx ./src/cli/ios/preflight-ios.ts",
+    "healthcheck": "tsx ./src/utils/cli/idb/check-idb.ts",
+    "install-idb": "tsx ./src/utils/cli/idb/install-idb.ts",
+    "preflight-ios": "tsx ./src/utils/cli/ios/preflight-ios.ts",
     "test:unit": "tsx test/unit/index.ts",
     "test:integration": "npm run test:device",
     "test:device": "npm run build && tsx test/device/index.ts",
     "test": "npm run test:unit",
-    "lint": "eslint --ext .ts,.js src test --quiet",
-    "lint:fix": "eslint --ext .ts,.js src test --fix"
+    "lint": "eslint src test --quiet",
+    "lint:fix": "eslint src test --fix",
+    "verify": "npm run lint && npm run build && npm run test:unit"
   },
 
   "engines": {