replicant-mcp 1.6.2 → 1.6.4

package/dist/adapters/ui-automator.d.ts

@@ -50,11 +50,6 @@ export declare class UiAutomatorAdapter {
     private scalingState;
     constructor(adb?: AdbAdapter);
     getScalingState(): ScalingState | null;
-    /**
-     * Transforms accessibility tree nodes from device space to image space.
-     * This ensures bounds/coordinates match the scaled screenshot when scaling is active.
-     */
-    private transformTreeToImageSpace;
     dump(deviceId: string): Promise<AccessibilityNode[]>;
     find(deviceId: string, selector: {
         resourceId?: string;
@@ -65,7 +60,12 @@ export declare class UiAutomatorAdapter {
     tap(deviceId: string, x: number, y: number, deviceSpace?: boolean): Promise<void>;
     tapElement(deviceId: string, element: AccessibilityNode): Promise<void>;
     input(deviceId: string, text: string): Promise<void>;
-    scroll(deviceId: string, direction: "up" | "down" | "left" | "right", amount?: number): Promise<void>;
+    scroll(deviceId: string, direction: "up" | "down" | "left" | "right", amount?: number, bounds?: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }): Promise<void>;
     screenshot(deviceId: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
     accessibilityCheck(deviceId: string): Promise<{
         hasAccessibleElements: boolean;

package/dist/adapters/ui-automator.js

@@ -4,7 +4,7 @@ import sharp from "sharp";
 import { AdbAdapter } from "./adb.js";
 import { parseUiDump, findElements, flattenTree } from "../parsers/ui-dump.js";
 import { ReplicantError, ErrorCode } from "../types/index.js";
-import { calculateScaleFactor, toImageSpace, toDeviceSpace, boundsToImageSpace } from "../services/scaling.js";
+import { calculateScaleFactor, toDeviceSpace } from "../services/scaling.js";
 import { getDefaultScreenshotPath } from "../utils/paths.js";
 import { findWithFallbacks } from "./ui-fallback-find.js";
 export class UiAutomatorAdapter {
@@ -17,27 +17,6 @@ export class UiAutomatorAdapter {
     getScalingState() {
         return this.scalingState;
     }
-    /**
-     * Transforms accessibility tree nodes from device space to image space.
-     * This ensures bounds/coordinates match the scaled screenshot when scaling is active.
-     */
-    transformTreeToImageSpace(nodes) {
-        if (!this.scalingState || this.scalingState.scaleFactor === 1.0) {
-            return nodes;
-        }
-        const sf = this.scalingState.scaleFactor;
-        return nodes.map((node) => {
-            const newBounds = boundsToImageSpace(node.bounds, sf);
-            const center = toImageSpace(node.centerX, node.centerY, sf);
-            return {
-                ...node,
-                bounds: newBounds,
-                centerX: center.x,
-                centerY: center.y,
-                children: node.children ? this.transformTreeToImageSpace(node.children) : [],
-            };
-        });
-    }
     async dump(deviceId) {
         // Dump UI hierarchy to device
         await this.adb.shell(deviceId, "uiautomator dump /sdcard/ui-dump.xml");
@@ -45,8 +24,8 @@ export class UiAutomatorAdapter {
         const result = await this.adb.shell(deviceId, "cat /sdcard/ui-dump.xml");
         // Clean up
         await this.adb.shell(deviceId, "rm /sdcard/ui-dump.xml");
-        const tree = parseUiDump(result.stdout);
-        return this.transformTreeToImageSpace(tree);
+        // Coords stay in native uiautomator (device) space — see THE-96.
+        return parseUiDump(result.stdout);
     }
     async find(deviceId, selector) {
         const tree = await this.dump(deviceId);
@@ -72,14 +51,23 @@ export class UiAutomatorAdapter {
         const escaped = text.replace(/(['"\\$`])/g, "\\$1").replace(/ /g, "%s");
         await this.adb.shell(deviceId, `input text "${escaped}"`);
     }
-    async scroll(deviceId, direction, amount = 0.5) {
-        const screen = await this.getScreenMetadata(deviceId);
-        const { width, height } = screen;
-        // Calculate scroll distance based on amount (0-1 representing screen percentage)
+    async scroll(deviceId, direction, amount = 0.5, bounds) {
+        let width, height, centerX, centerY;
+        if (bounds) {
+            width = bounds.right - bounds.left;
+            height = bounds.bottom - bounds.top;
+            centerX = Math.round((bounds.left + bounds.right) / 2);
+            centerY = Math.round((bounds.top + bounds.bottom) / 2);
+        }
+        else {
+            const screen = await this.getScreenMetadata(deviceId);
+            width = screen.width;
+            height = screen.height;
+            centerX = Math.round(width / 2);
+            centerY = Math.round(height / 2);
+        }
+        // Calculate scroll distance based on amount (0-1 representing container percentage)
         const scrollDistance = Math.round((direction === "up" || direction === "down" ? height : width) * amount * 0.8);
-        // Center point of the screen
-        const centerX = Math.round(width / 2);
-        const centerY = Math.round(height / 2);
         // Calculate start and end points based on direction
         // Note: "scroll down" means content moves up, so we swipe up (finger moves from bottom to top)
         let startX, startY, endX, endY;

package/dist/adapters/ui-fallback-find.js

@@ -3,6 +3,40 @@ import { extractText, searchText } from "../services/ocr.js";
 import { matchIconPattern, matchesResourceId } from "../services/icon-patterns.js";
 import { filterIconCandidates, formatBounds, cropCandidateImage } from "../services/visual-candidates.js";
 import { calculateGridCellBounds, calculatePositionCoordinates, createGridOverlay, POSITION_LABELS, } from "../services/grid.js";
+import { boundsToImageSpace, toDeviceSpace } from "../services/scaling.js";
+function ocrToDeviceSpace(elements, scaleFactor) {
+    if (scaleFactor === 1.0)
+        return elements;
+    return elements.map((el) => {
+        const center = toDeviceSpace(el.center.x, el.center.y, scaleFactor);
+        const m = el.bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+        let bounds = el.bounds;
+        if (m) {
+            const x0 = Math.round(parseInt(m[1], 10) * scaleFactor);
+            const y0 = Math.round(parseInt(m[2], 10) * scaleFactor);
+            const x1 = Math.round(parseInt(m[3], 10) * scaleFactor);
+            const y1 = Math.round(parseInt(m[4], 10) * scaleFactor);
+            bounds = `[${x0},${y0}][${x1},${y1}]`;
+        }
+        return { ...el, center, bounds };
+    });
+}
+function gridResultToDeviceSpace(cellBounds, coords, scaleFactor) {
+    if (scaleFactor === 1.0) {
+        return {
+            bounds: `[${cellBounds.x0},${cellBounds.y0}][${cellBounds.x1},${cellBounds.y1}]`,
+            center: coords,
+        };
+    }
+    return {
+        bounds: `[${Math.round(cellBounds.x0 * scaleFactor)},${Math.round(cellBounds.y0 * scaleFactor)}]` +
+            `[${Math.round(cellBounds.x1 * scaleFactor)},${Math.round(cellBounds.y1 * scaleFactor)}]`,
+        center: {
+            x: Math.round(coords.x * scaleFactor),
+            y: Math.round(coords.y * scaleFactor),
+        },
+    };
+}
 function createEarlyStopResult(tier, source) {
     return {
         elements: [],
@@ -20,10 +54,12 @@ export async function findWithFallbacks(deps, deviceId, selector, options = {})
     // Handle Tier 5 grid refinement FIRST (when gridCell and gridPosition are provided)
     if (options.gridCell !== undefined && options.gridPosition !== undefined) {
         let width, height;
+        let gridScaleFactor = 1.0;
         const scalingState = deps.getScalingState();
         if (scalingState && scalingState.scaleFactor !== 1.0) {
             width = scalingState.imageWidth;
             height = scalingState.imageHeight;
+            gridScaleFactor = scalingState.scaleFactor;
         }
         else {
             const screen = await deps.getScreenMetadata(deviceId);
@@ -32,12 +68,13 @@ export async function findWithFallbacks(deps, deviceId, selector, options = {})
         }
         const cellBounds = calculateGridCellBounds(options.gridCell, width, height);
         const coords = calculatePositionCoordinates(options.gridPosition, cellBounds);
+        const deviceCoords = gridResultToDeviceSpace(cellBounds, coords, gridScaleFactor);
         return {
             elements: [
                 {
                     index: 0,
-                    bounds: `[${cellBounds.x0},${cellBounds.y0}][${cellBounds.x1},${cellBounds.y1}]`,
-                    center: coords,
+                    bounds: deviceCoords.bounds,
+                    center: deviceCoords.center,
                 },
             ],
             source: "grid",
@@ -86,12 +123,14 @@ export async function findWithFallbacks(deps, deviceId, selector, options = {})
     if ((selector.text || selector.textContains) && maxTier >= 3) {
         const searchTerm = selector.text || selector.textContains;
         const screenshotResult = await deps.screenshot(deviceId, {});
+        const scalingState = deps.getScalingState();
+        const scaleFactor = scalingState?.scaleFactor ?? 1.0;
         try {
             const ocrResults = await extractText(screenshotResult.path);
             const matches = searchText(ocrResults, searchTerm);
             if (matches.length > 0) {
                 return {
-                    elements: matches,
+                    elements: ocrToDeviceSpace(matches, scaleFactor),
                     source: "ocr",
                     tier: 3,
                     confidence: "high",
@@ -108,11 +147,12 @@ export async function findWithFallbacks(deps, deviceId, selector, options = {})
             const flat = flattenTree(tree);
             const iconCandidates = filterIconCandidates(flat);
             if (iconCandidates.length > 0) {
+                // Crop the screenshot using image-space bounds (dump now returns device-space).
                 const candidates = await Promise.all(iconCandidates.map(async (node, index) => ({
                     index,
                     bounds: formatBounds(node),
                     center: { x: node.centerX, y: node.centerY },
-                    image: await cropCandidateImage(screenshotResult.path, node.bounds),
+                    image: await cropCandidateImage(screenshotResult.path, boundsToImageSpace(node.bounds, scaleFactor)),
                 })));
                 const allUnlabeled = flat.filter((n) => n.clickable && !n.text && !n.contentDesc);
                 return {

package/dist/parsers/ui-dump.d.ts

@@ -15,6 +15,7 @@ export interface AccessibilityNode {
     centerY: number;
     clickable: boolean;
     focusable: boolean;
+    scrollable?: boolean;
     children?: AccessibilityNode[];
 }
 export declare function parseUiDump(xml: string): AccessibilityNode[];

package/dist/parsers/ui-dump.js

@@ -20,7 +20,7 @@ function parseBounds(boundsStr) {
 }
 function parseNodeFromAttrs(attrs) {
     const bounds = parseBounds(attrs.bounds || "[0,0][0,0]");
-    return {
+    const node = {
         index: parseInt(attrs.index || "0", 10),
         text: attrs.text || "",
         resourceId: attrs["resource-id"] || "",
@@ -32,6 +32,35 @@ function parseNodeFromAttrs(attrs) {
         clickable: attrs.clickable === "true",
         focusable: attrs.focusable === "true",
     };
+    if (attrs.scrollable !== undefined) {
+        node.scrollable = attrs.scrollable === "true";
+    }
+    return node;
+}
+function collectDescendantLabels(node) {
+    const labels = [];
+    for (const child of node.children ?? []) {
+        const label = child.text || child.contentDesc;
+        if (label) {
+            // The child's label already represents its subtree (post-order: descendants
+            // were either labelled originally, or rolled up into this child's text).
+            // Recursing would double-count.
+            labels.push(label);
+        }
+        else {
+            labels.push(...collectDescendantLabels(child));
+        }
+    }
+    return labels;
+}
+function propagateChildLabels(node) {
+    for (const child of node.children ?? [])
+        propagateChildLabels(child);
+    if (!node.text && !node.contentDesc && node.children?.length) {
+        const labels = collectDescendantLabels(node);
+        if (labels.length > 0)
+            node.text = labels.join(" ");
+    }
 }
 export function parseUiDump(xml) {
     const nodes = [];
@@ -103,7 +132,10 @@ export function parseUiDump(xml) {
     // Extract hierarchy content
     const hierarchyMatch = xml.match(/<hierarchy[^>]*>([\s\S]*)<\/hierarchy>/);
     if (hierarchyMatch) {
-        return parseChildren(hierarchyMatch[1]);
+        const tree = parseChildren(hierarchyMatch[1]);
+        for (const root of tree)
+            propagateChildLabels(root);
+        return tree;
     }
     return nodes;
 }

package/dist/schemas/derive.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+type McpInputSchema = {
+    type: "object";
+    properties?: Record<string, unknown>;
+    required?: string[];
+};
+export declare function toMcpJsonSchema(schema: z.ZodType): McpInputSchema;
+export {};

package/dist/schemas/derive.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+// Recursively removes $schema and additionalProperties from a JSON schema
+// tree. Strict-mode enforcement happens at the Zod validator; the wire
+// payload stays compact and consistent (top-level and nested alike).
+function stripMeta(node) {
+    if (Array.isArray(node))
+        return node.map(stripMeta);
+    if (node && typeof node === "object") {
+        const entries = Object.entries(node)
+            .filter(([k]) => k !== "$schema" && k !== "additionalProperties")
+            .map(([k, v]) => [k, stripMeta(v)]);
+        return Object.fromEntries(entries);
+    }
+    return node;
+}
+export function toMcpJsonSchema(schema) {
+    const json = z.toJSONSchema(schema);
+    return stripMeta(json);
+}

package/dist/schemas/inputs.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export type NumberOpts = {
+    min?: number;
+    max?: number;
+};
+export declare const numberInput: (opts?: NumberOpts) => z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>;
+export declare const booleanInput: () => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>;
+export declare const jsonObjectInput: <T extends z.ZodRawShape>(shape: T) => z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strict>>;
+export declare const toolSchema: <T extends z.ZodRawShape>(shape: T) => z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strict>;

package/dist/schemas/inputs.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+// Accepts native numbers or numeric strings. Rejects null, booleans, arrays,
+// objects, and other primitives that z.coerce.number() would silently coerce
+// to 0/1/NaN. Use options for bounds since the preprocess wrapper loses
+// .min()/.max() chainability.
+export const numberInput = (opts = {}) => {
+    let base = z.coerce.number().finite();
+    if (opts.min !== undefined)
+        base = base.min(opts.min);
+    if (opts.max !== undefined)
+        base = base.max(opts.max);
+    return z.preprocess((v, ctx) => {
+        if (typeof v === "number" || typeof v === "string")
+            return v;
+        ctx.addIssue({
+            code: "custom",
+            message: `Expected number or numeric string, got ${v === null ? "null" : Array.isArray(v) ? "array" : typeof v}`,
+        });
+        return z.NEVER;
+    }, base);
+};
+// z.coerce.boolean() treats "false" as truthy — manual preprocess avoids the footgun.
+export const booleanInput = () => z.preprocess((v) => {
+    if (typeof v === "boolean")
+        return v;
+    if (v === "true")
+        return true;
+    if (v === "false")
+        return false;
+    return v;
+}, z.boolean());
+// Accepts either a plain object or a JSON-string encoding. Inner object is
+// strict so nested unknown fields are rejected (matches toolSchema).
+export const jsonObjectInput = (shape) => z.preprocess((v) => {
+    if (typeof v !== "string")
+        return v;
+    try {
+        return JSON.parse(v);
+    }
+    catch {
+        return v;
+    }
+}, z.object(shape).strict());
+export const toolSchema = (shape) => z.object(shape).strict();

package/dist/server.js

@@ -6,7 +6,7 @@ import { CacheManager, DeviceStateManager, ProcessRunner, EnvironmentService, Co
 import { AdbAdapter, EmulatorAdapter, GradleAdapter, UiAutomatorAdapter } from "./adapters/index.js";
 import { ReplicantError, ErrorCode } from "./types/index.js";
 import { VERSION } from "./version.js";
-import { cacheInputSchema, cacheToolDefinition, handleCacheTool, rtfmInputSchema, rtfmToolDefinition, handleRtfmTool, adbDeviceInputSchema, adbDeviceToolDefinition, handleAdbDeviceTool, adbAppInputSchema, adbAppToolDefinition, handleAdbAppTool, adbLogcatInputSchema, adbLogcatToolDefinition, handleAdbLogcatTool, adbShellInputSchema, adbShellToolDefinition, handleAdbShellTool, emulatorDeviceInputSchema, emulatorDeviceToolDefinition, handleEmulatorDeviceTool, gradleBuildInputSchema, gradleBuildToolDefinition, handleGradleBuildTool, gradleTestInputSchema, gradleTestToolDefinition, handleGradleTestTool, gradleListInputSchema, gradleListToolDefinition, handleGradleListTool, gradleGetDetailsInputSchema, gradleGetDetailsToolDefinition, handleGradleGetDetailsTool, uiQueryInputSchema, uiQueryToolDefinition, handleUiQueryTool, uiActionInputSchema, uiActionToolDefinition, handleUiActionTool, uiCaptureInputSchema, uiCaptureToolDefinition, handleUiCaptureTool, } from "./tools/index.js";
+import { ALL_TOOL_DEFINITIONS, cacheInputSchema, handleCacheTool, rtfmInputSchema, handleRtfmTool, adbDeviceInputSchema, handleAdbDeviceTool, adbAppInputSchema, handleAdbAppTool, adbLogcatInputSchema, handleAdbLogcatTool, adbShellInputSchema, handleAdbShellTool, emulatorDeviceInputSchema, handleEmulatorDeviceTool, gradleBuildInputSchema, handleGradleBuildTool, gradleTestInputSchema, handleGradleTestTool, gradleListInputSchema, handleGradleListTool, gradleGetDetailsInputSchema, handleGradleGetDetailsTool, uiQueryInputSchema, handleUiQueryTool, uiActionInputSchema, handleUiActionTool, uiCaptureInputSchema, handleUiCaptureTool, } from "./tools/index.js";
 export function createServerContext() {
     const environment = new EnvironmentService();
     const processRunner = new ProcessRunner(environment);
@@ -24,22 +24,7 @@ export function createServerContext() {
         lastFindResults: [],
     };
 }
-const toolDefinitions = [
-    cacheToolDefinition,
-    rtfmToolDefinition,
-    adbDeviceToolDefinition,
-    adbAppToolDefinition,
-    adbLogcatToolDefinition,
-    adbShellToolDefinition,
-    emulatorDeviceToolDefinition,
-    gradleBuildToolDefinition,
-    gradleTestToolDefinition,
-    gradleListToolDefinition,
-    gradleGetDetailsToolDefinition,
-    uiQueryToolDefinition,
-    uiActionToolDefinition,
-    uiCaptureToolDefinition,
-];
+const toolDefinitions = ALL_TOOL_DEFINITIONS;
 async function dispatchToolCall(name, args, context) {
     const rawArgs = args ?? {};
     const parseOrThrow = (toolName, parser) => {
@@ -85,7 +70,7 @@ async function dispatchToolCall(name, args, context) {
         case "ui-query":
             return handleUiQueryTool(parseOrThrow("ui-query", uiQueryInputSchema), context, context.config.getUiConfig());
         case "ui-action":
-            return handleUiActionTool(parseOrThrow("ui-action", uiActionInputSchema), context);
+            return handleUiActionTool(parseOrThrow("ui-action", uiActionInputSchema), context, context.config.getUiConfig());
         case "ui-capture":
             return handleUiCaptureTool(parseOrThrow("ui-capture", uiCaptureInputSchema), context, context.config.getUiConfig());
         default:

package/dist/tools/adb-app.d.ts

@@ -11,43 +11,19 @@ export declare const adbAppInputSchema: z.ZodObject<{
     }>;
     apkPath: z.ZodOptional<z.ZodString>;
     packageName: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
     filter: z.ZodOptional<z.ZodString>;
-    offset: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+    offset: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strict>;
 export type AdbAppInput = z.infer<typeof adbAppInputSchema>;
 export declare function handleAdbAppTool(input: AdbAppInput, context: ServerContext): Promise<Record<string, unknown>>;
 export declare const adbAppToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            operation: {
-                type: string;
-                enum: string[];
-            };
-            apkPath: {
-                type: string;
-                description: string;
-            };
-            packageName: {
-                type: string;
-            };
-            limit: {
-                type: string;
-                description: string;
-            };
-            filter: {
-                type: string;
-                description: string;
-            };
-            offset: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/adb-app.js

@@ -1,12 +1,16 @@
 import { z } from "zod";
 import { CACHE_TTLS, ReplicantError, ErrorCode } from "../types/index.js";
-export const adbAppInputSchema = z.object({
+import { numberInput, toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const adbAppInputSchema = toolSchema({
     operation: z.enum(["install", "uninstall", "launch", "stop", "clear-data", "list"]),
-    apkPath: z.string().optional(),
+    apkPath: z.string().optional().describe("APK path"),
     packageName: z.string().optional(),
-    limit: z.number().min(1).max(100).optional(),
-    filter: z.string().optional(),
-    offset: z.number().min(0).optional(),
+    limit: numberInput({ min: 1, max: 100 })
+        .optional()
+        .describe("Default: 20, max: 100"),
+    filter: z.string().optional().describe("Filter by name (case-insensitive)"),
+    offset: numberInput({ min: 0 }).optional().describe("Pagination offset"),
 });
 async function handleInstall(input, deviceId, context) {
     if (!input.apkPath) {
@@ -85,30 +89,7 @@ export async function handleAdbAppTool(input, context) {
 export const adbAppToolDefinition = {
     name: "adb-app",
     description: "Manage applications.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: ["install", "uninstall", "launch", "stop", "clear-data", "list"],
-            },
-            apkPath: { type: "string", description: "APK path" },
-            packageName: { type: "string" },
-            limit: {
-                type: "number",
-                description: "Default: 20, max: 100",
-            },
-            filter: {
-                type: "string",
-                description: "Filter by name (case-insensitive)",
-            },
-            offset: {
-                type: "number",
-                description: "Pagination offset",
-            },
-        },
-        required: ["operation"],
-    },
+    inputSchema: toMcpJsonSchema(adbAppInputSchema),
     annotations: {
         readOnlyHint: false,
         destructiveHint: true,

package/dist/tools/adb-device.d.ts

@@ -9,24 +9,16 @@ export declare const adbDeviceInputSchema: z.ZodObject<{
         "health-check": "health-check";
     }>;
     deviceId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type AdbDeviceInput = z.infer<typeof adbDeviceInputSchema>;
 export declare function handleAdbDeviceTool(input: AdbDeviceInput, context: ServerContext): Promise<Record<string, unknown>>;
 export declare const adbDeviceToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            operation: {
-                type: string;
-                enum: string[];
-            };
-            deviceId: {
-                type: string;
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/adb-device.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { CACHE_TTLS, ReplicantError, ErrorCode } from "../types/index.js";
-export const adbDeviceInputSchema = z.object({
+import { toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const adbDeviceInputSchema = toolSchema({
     operation: z.enum(["list", "select", "wait", "properties", "health-check"]),
     deviceId: z.string().optional(),
 });
@@ -111,17 +113,7 @@ export async function handleAdbDeviceTool(input, context) {
 export const adbDeviceToolDefinition = {
     name: "adb-device",
     description: "Manage device connections.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: ["list", "select", "wait", "properties", "health-check"],
-            },
-            deviceId: { type: "string" },
-        },
-        required: ["operation"],
-    },
+    inputSchema: toMcpJsonSchema(adbDeviceInputSchema),
     annotations: {
         readOnlyHint: false,
         destructiveHint: false,

package/dist/tools/adb-logcat.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ServerContext } from "../server.js";
 export declare const adbLogcatInputSchema: z.ZodObject<{
-    lines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    lines: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>>;
     package: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     level: z.ZodOptional<z.ZodEnum<{
@@ -13,40 +13,16 @@ export declare const adbLogcatInputSchema: z.ZodObject<{
     }>>;
     rawFilter: z.ZodOptional<z.ZodString>;
     since: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type AdbLogcatInput = z.infer<typeof adbLogcatInputSchema>;
 export declare function handleAdbLogcatTool(input: AdbLogcatInput, context: ServerContext): Promise<Record<string, unknown>>;
 export declare const adbLogcatToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            lines: {
-                type: string;
-                description: string;
-            };
-            package: {
-                type: string;
-            };
-            tags: {
-                type: string;
-                items: {
-                    type: string;
-                };
-            };
-            level: {
-                type: string;
-                enum: string[];
-            };
-            rawFilter: {
-                type: string;
-            };
-            since: {
-                type: string;
-                description: string;
-            };
-        };
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/adb-logcat.js

@@ -1,12 +1,14 @@
 import { z } from "zod";
 import { CACHE_TTLS } from "../types/index.js";
-export const adbLogcatInputSchema = z.object({
-    lines: z.number().optional().default(100),
+import { numberInput, toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const adbLogcatInputSchema = toolSchema({
+    lines: numberInput().optional().default(100).describe("Default: 100"),
     package: z.string().optional(),
     tags: z.array(z.string()).optional(),
     level: z.enum(["verbose", "debug", "info", "warn", "error"]).optional(),
     rawFilter: z.string().optional(),
-    since: z.string().optional(),
+    since: z.string().optional().describe("e.g., '01-20 15:30:00.000'"),
 });
 function buildLogcatFilter(input) {
     if (input.rawFilter)
@@ -55,17 +57,7 @@ export async function handleAdbLogcatTool(input, context) {
 export const adbLogcatToolDefinition = {
     name: "adb-logcat",
     description: "Read device logs. Returns summary with logId.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            lines: { type: "number", description: "Default: 100" },
-            package: { type: "string" },
-            tags: { type: "array", items: { type: "string" } },
-            level: { type: "string", enum: ["verbose", "debug", "info", "warn", "error"] },
-            rawFilter: { type: "string" },
-            since: { type: "string", description: "e.g., '01-20 15:30:00.000'" },
-        },
-    },
+    inputSchema: toMcpJsonSchema(adbLogcatInputSchema),
     annotations: {
         readOnlyHint: true,
         destructiveHint: false,