replicant-mcp 1.6.3 → 1.6.4

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

@@ -2,40 +2,20 @@ import { z } from "zod";
 import { ServerContext } from "../server.js";
 export declare const adbShellInputSchema: z.ZodObject<{
     command: z.ZodString;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    maxChars: z.ZodOptional<z.ZodNumber>;
-    summaryOnly: z.ZodOptional<z.ZodBoolean>;
-    previewChars: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+    timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+    maxChars: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+    summaryOnly: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+    previewChars: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strict>;
 export type AdbShellInput = z.infer<typeof adbShellInputSchema>;
 export declare function handleAdbShellTool(input: AdbShellInput, context: ServerContext): Promise<Record<string, unknown>>;
 export declare const adbShellToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            command: {
-                type: string;
-            };
-            timeout: {
-                type: string;
-                description: string;
-            };
-            maxChars: {
-                type: string;
-                description: string;
-            };
-            summaryOnly: {
-                type: string;
-                description: string;
-            };
-            previewChars: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/adb-shell.js

@@ -1,10 +1,14 @@
 import { z } from "zod";
-export const adbShellInputSchema = z.object({
+import { booleanInput, numberInput, toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const adbShellInputSchema = toolSchema({
     command: z.string(),
-    timeout: z.number().optional(),
-    maxChars: z.number().min(1).optional(),
-    summaryOnly: z.boolean().optional(),
-    previewChars: z.number().min(1).optional(),
+    timeout: numberInput().optional().describe("ms, default: 30000, max: 120000"),
+    maxChars: numberInput({ min: 1 }).optional().describe("Truncate output to N chars"),
+    summaryOnly: booleanInput().optional().describe("Compact preview only"),
+    previewChars: numberInput({ min: 1 })
+        .optional()
+        .describe("Preview length (default: 200)"),
 });
 export async function handleAdbShellTool(input, context) {
     const device = await context.deviceState.ensureDevice(context.adb);
@@ -44,17 +48,7 @@ export async function handleAdbShellTool(input, context) {
 export const adbShellToolDefinition = {
     name: "adb-shell",
     description: "Execute shell commands with safety guards.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            command: { type: "string" },
-            timeout: { type: "number", description: "ms, default: 30000, max: 120000" },
-            maxChars: { type: "number", description: "Truncate output to N chars" },
-            summaryOnly: { type: "boolean", description: "Compact preview only" },
-            previewChars: { type: "number", description: "Preview length (default: 200)" },
-        },
-        required: ["command"],
-    },
+    inputSchema: toMcpJsonSchema(adbShellInputSchema),
     annotations: {
         readOnlyHint: false,
         destructiveHint: true,

package/dist/tools/cache.d.ts

@@ -8,44 +8,21 @@ export declare const cacheInputSchema: z.ZodObject<{
         "set-config": "set-config";
     }>;
     key: z.ZodOptional<z.ZodString>;
-    config: z.ZodOptional<z.ZodObject<{
-        maxEntries: z.ZodOptional<z.ZodNumber>;
-        maxEntrySizeBytes: z.ZodOptional<z.ZodNumber>;
-        defaultTtlMs: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    config: z.ZodOptional<z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodObject<{
+        maxEntries: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+        maxEntrySizeBytes: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+        defaultTtlMs: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
 export type CacheInput = z.infer<typeof cacheInputSchema>;
 export declare function handleCacheTool(input: CacheInput, cache: CacheManager): Promise<Record<string, unknown>>;
 export declare const cacheToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            operation: {
-                type: string;
-                enum: string[];
-            };
-            key: {
-                type: string;
-                description: string;
-            };
-            config: {
-                type: string;
-                properties: {
-                    maxEntries: {
-                        type: string;
-                    };
-                    maxEntrySizeBytes: {
-                        type: string;
-                    };
-                    defaultTtlMs: {
-                        type: string;
-                    };
-                };
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/cache.js

@@ -1,12 +1,14 @@
 import { z } from "zod";
 import { ReplicantError, ErrorCode } from "../types/index.js";
-export const cacheInputSchema = z.object({
+import { jsonObjectInput, numberInput, toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const cacheInputSchema = toolSchema({
     operation: z.enum(["get-stats", "clear", "get-config", "set-config"]),
-    key: z.string().optional(),
-    config: z.object({
-        maxEntries: z.number().optional(),
-        maxEntrySizeBytes: z.number().optional(),
-        defaultTtlMs: z.number().optional(),
+    key: z.string().optional().describe("Key to clear (optional)"),
+    config: jsonObjectInput({
+        maxEntries: numberInput().optional(),
+        maxEntrySizeBytes: numberInput().optional(),
+        defaultTtlMs: numberInput().optional(),
     }).optional(),
 });
 export async function handleCacheTool(input, cache) {
@@ -36,25 +38,7 @@ export async function handleCacheTool(input, cache) {
 export const cacheToolDefinition = {
     name: "cache",
     description: "Manage the cache. See rtfm for details.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: ["get-stats", "clear", "get-config", "set-config"],
-            },
-            key: { type: "string", description: "Key to clear (optional)" },
-            config: {
-                type: "object",
-                properties: {
-                    maxEntries: { type: "number" },
-                    maxEntrySizeBytes: { type: "number" },
-                    defaultTtlMs: { type: "number" },
-                },
-            },
-        },
-        required: ["operation"],
-    },
+    inputSchema: toMcpJsonSchema(cacheInputSchema),
     annotations: {
         readOnlyHint: false,
         destructiveHint: true,

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

@@ -17,37 +17,16 @@ export declare const emulatorDeviceInputSchema: z.ZodObject<{
     systemImage: z.ZodOptional<z.ZodString>;
     snapshotName: z.ZodOptional<z.ZodString>;
     emulatorId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type EmulatorDeviceInput = z.infer<typeof emulatorDeviceInputSchema>;
 export declare function handleEmulatorDeviceTool(input: EmulatorDeviceInput, context: ServerContext): Promise<Record<string, unknown>>;
 export declare const emulatorDeviceToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            operation: {
-                type: string;
-                enum: string[];
-            };
-            avdName: {
-                type: string;
-            };
-            device: {
-                type: string;
-                description: string;
-            };
-            systemImage: {
-                type: string;
-            };
-            snapshotName: {
-                type: string;
-            };
-            emulatorId: {
-                type: string;
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/emulator-device.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { ReplicantError, ErrorCode } from "../types/index.js";
-export const emulatorDeviceInputSchema = z.object({
+import { toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const emulatorDeviceInputSchema = toolSchema({
     operation: z.enum([
         "list",
         "create",
@@ -13,7 +15,7 @@ export const emulatorDeviceInputSchema = z.object({
         "snapshot-delete",
     ]),
     avdName: z.string().optional(),
-    device: z.string().optional(),
+    device: z.string().optional().describe("e.g., 'pixel_7'"),
     systemImage: z.string().optional(),
     snapshotName: z.string().optional(),
     emulatorId: z.string().optional(),
@@ -116,31 +118,7 @@ export async function handleEmulatorDeviceTool(input, context) {
 export const emulatorDeviceToolDefinition = {
     name: "emulator-device",
     description: "Manage Android emulators.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: [
-                    "list",
-                    "create",
-                    "start",
-                    "kill",
-                    "wipe",
-                    "snapshot-save",
-                    "snapshot-load",
-                    "snapshot-list",
-                    "snapshot-delete",
-                ],
-            },
-            avdName: { type: "string" },
-            device: { type: "string", description: "e.g., 'pixel_7'" },
-            systemImage: { type: "string" },
-            snapshotName: { type: "string" },
-            emulatorId: { type: "string" },
-        },
-        required: ["operation"],
-    },
+    inputSchema: toMcpJsonSchema(emulatorDeviceInputSchema),
     annotations: {
         readOnlyHint: false,
         destructiveHint: true,

package/dist/tools/gradle-build.d.ts

@@ -8,28 +8,16 @@ export declare const gradleBuildInputSchema: z.ZodObject<{
     }>;
     module: z.ZodOptional<z.ZodString>;
     flavor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type GradleBuildInput = z.infer<typeof gradleBuildInputSchema>;
 export declare function handleGradleBuildTool(input: GradleBuildInput, context: ServerContext): Promise<Record<string, unknown>>;
 export declare const gradleBuildToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            operation: {
-                type: string;
-                enum: string[];
-            };
-            module: {
-                type: string;
-                description: string;
-            };
-            flavor: {
-                type: string;
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/gradle-build.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { CACHE_TTLS } from "../types/index.js";
-export const gradleBuildInputSchema = z.object({
+import { toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const gradleBuildInputSchema = toolSchema({
     operation: z.enum(["assembleDebug", "assembleRelease", "bundle"]),
-    module: z.string().optional(),
+    module: z.string().optional().describe("e.g., ':app'"),
     flavor: z.string().optional(),
 });
 export async function handleGradleBuildTool(input, context) {
@@ -24,18 +26,7 @@ export async function handleGradleBuildTool(input, context) {
 export const gradleBuildToolDefinition = {
     name: "gradle-build",
     description: "Build. Returns summary with buildId.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: ["assembleDebug", "assembleRelease", "bundle"],
-            },
-            module: { type: "string", description: "e.g., ':app'" },
-            flavor: { type: "string" },
-        },
-        required: ["operation"],
-    },
+    inputSchema: toMcpJsonSchema(gradleBuildInputSchema),
     annotations: {
         readOnlyHint: false,
         destructiveHint: false,

package/dist/tools/gradle-get-details.d.ts

@@ -8,39 +8,19 @@ export declare const gradleGetDetailsInputSchema: z.ZodObject<{
         tasks: "tasks";
         logs: "logs";
     }>>>;
-    maxChars: z.ZodOptional<z.ZodNumber>;
-    summaryOnly: z.ZodOptional<z.ZodBoolean>;
-    previewChars: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+    maxChars: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+    summaryOnly: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+    previewChars: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | number, unknown>, z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strict>;
 export type GradleGetDetailsInput = z.infer<typeof gradleGetDetailsInputSchema>;
 export declare function handleGradleGetDetailsTool(input: GradleGetDetailsInput, context: ServerContext): Promise<Record<string, unknown>>;
 export declare const gradleGetDetailsToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            id: {
-                type: string;
-            };
-            detailType: {
-                type: string;
-                enum: string[];
-            };
-            maxChars: {
-                type: string;
-                description: string;
-            };
-            summaryOnly: {
-                type: string;
-                description: string;
-            };
-            previewChars: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/gradle-get-details.js

@@ -1,11 +1,17 @@
 import { z } from "zod";
 import { ReplicantError, ErrorCode } from "../types/index.js";
-export const gradleGetDetailsInputSchema = z.object({
+import { booleanInput, numberInput, toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const gradleGetDetailsInputSchema = toolSchema({
     id: z.string(),
     detailType: z.enum(["logs", "errors", "tasks", "all"]).optional().default("all"),
-    maxChars: z.number().min(1).optional(),
-    summaryOnly: z.boolean().optional(),
-    previewChars: z.number().min(1).optional(),
+    maxChars: numberInput({ min: 1 }).optional().describe("Truncate to N chars"),
+    summaryOnly: booleanInput()
+        .optional()
+        .describe("Return compact summary payload for logs/tasks/all detail types (ignored for errors)"),
+    previewChars: numberInput({ min: 1 })
+        .optional()
+        .describe("For summaryOnly with detailType logs/all: preview length in characters (default: 400)"),
 });
 function truncateText(text, maxChars) {
     if (!maxChars || text.length <= maxChars) {
@@ -136,29 +142,7 @@ export async function handleGradleGetDetailsTool(input, context) {
 export const gradleGetDetailsToolDefinition = {
     name: "gradle-get-details",
     description: "Fetch full output for a previous build/test by ID.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            id: { type: "string" },
-            detailType: {
-                type: "string",
-                enum: ["logs", "errors", "tasks", "all"],
-            },
-            maxChars: {
-                type: "number",
-                description: "Truncate to N chars",
-            },
-            summaryOnly: {
-                type: "boolean",
-                description: "Return compact summary payload for logs/tasks/all detail types (ignored for errors)",
-            },
-            previewChars: {
-                type: "number",
-                description: "For summaryOnly with detailType logs/all: preview length in characters (default: 400)",
-            },
-        },
-        required: ["id"],
-    },
+    inputSchema: toMcpJsonSchema(gradleGetDetailsInputSchema),
     annotations: {
         readOnlyHint: true,
         destructiveHint: false,

package/dist/tools/gradle-list.d.ts

@@ -7,25 +7,16 @@ export declare const gradleListInputSchema: z.ZodObject<{
         variants: "variants";
     }>;
     module: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type GradleListInput = z.infer<typeof gradleListInputSchema>;
 export declare function handleGradleListTool(input: GradleListInput, context: ServerContext): Promise<Record<string, unknown>>;
 export declare const gradleListToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            operation: {
-                type: string;
-                enum: string[];
-            };
-            module: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/gradle-list.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { CACHE_TTLS, ReplicantError, ErrorCode } from "../types/index.js";
-export const gradleListInputSchema = z.object({
+import { toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const gradleListInputSchema = toolSchema({
     operation: z.enum(["variants", "modules", "tasks"]),
-    module: z.string().optional(),
+    module: z.string().optional().describe("e.g., ':app'"),
 });
 export async function handleGradleListTool(input, context) {
     switch (input.operation) {
@@ -39,17 +41,7 @@ export async function handleGradleListTool(input, context) {
 export const gradleListToolDefinition = {
     name: "gradle-list",
     description: "Introspect project structure.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: ["variants", "modules", "tasks"],
-            },
-            module: { type: "string", description: "e.g., ':app'" },
-        },
-        required: ["operation"],
-    },
+    inputSchema: toMcpJsonSchema(gradleListInputSchema),
     annotations: {
         readOnlyHint: true,
         destructiveHint: false,

package/dist/tools/gradle-test.d.ts

@@ -12,7 +12,7 @@ export declare const gradleTestInputSchema: z.ZodObject<{
     module: z.ZodOptional<z.ZodString>;
     filter: z.ZodOptional<z.ZodString>;
     taskName: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type GradleTestInput = z.infer<typeof gradleTestInputSchema>;
 /**
  * Convert gradle TestResult into BaselineTestResult[] for baseline storage/comparison.
@@ -24,25 +24,9 @@ export declare const gradleTestToolDefinition: {
     name: string;
     description: string;
     inputSchema: {
-        type: string;
-        properties: {
-            operation: {
-                type: string;
-                enum: string[];
-            };
-            module: {
-                type: string;
-            };
-            filter: {
-                type: string;
-                description: string;
-            };
-            taskName: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
     };
     annotations: {
         readOnlyHint: boolean;

package/dist/tools/gradle-test.js

@@ -1,11 +1,16 @@
 import { z } from "zod";
 import { CACHE_TTLS } from "../types/index.js";
 import { saveBaseline, loadBaseline, clearBaseline, compareResults, } from "../services/test-baseline.js";
-export const gradleTestInputSchema = z.object({
+import { toolSchema } from "../schemas/inputs.js";
+import { toMcpJsonSchema } from "../schemas/derive.js";
+export const gradleTestInputSchema = toolSchema({
     operation: z.enum(["unitTest", "connectedTest", "saveBaseline", "clearBaseline"]),
     module: z.string().optional(),
-    filter: z.string().optional(),
-    taskName: z.string().optional().describe("Task name for baseline operations. Defaults to operation name."),
+    filter: z.string().optional().describe("e.g., '*LoginTest*'"),
+    taskName: z
+        .string()
+        .optional()
+        .describe("Task name for baseline operations. Defaults to operation name."),
 });
 /**
  * Convert gradle TestResult into BaselineTestResult[] for baseline storage/comparison.
@@ -82,22 +87,7 @@ export async function handleGradleTestTool(input, context) {
 export const gradleTestToolDefinition = {
     name: "gradle-test",
     description: "Run tests. Returns summary with testId. With baseline, auto-detects regressions.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: ["unitTest", "connectedTest", "saveBaseline", "clearBaseline"],
-            },
-            module: { type: "string" },
-            filter: { type: "string", description: "e.g., '*LoginTest*'" },
-            taskName: {
-                type: "string",
-                description: "Task name for baseline operations. Defaults to operation name.",
-            },
-        },
-        required: ["operation"],
-    },
+    inputSchema: toMcpJsonSchema(gradleTestInputSchema),
     annotations: {
         readOnlyHint: false,
         destructiveHint: true,