replicant-mcp 1.0.0

package/dist/tools/adb-logcat.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { CACHE_TTLS } from "../types/index.js";
+export const adbLogcatInputSchema = z.object({
+    lines: z.number().optional().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(),
+});
+export async function handleAdbLogcatTool(input, context) {
+    const deviceId = context.deviceState.requireCurrentDevice().id;
+    // Build filter string
+    let filter = "";
+    if (input.rawFilter) {
+        filter = input.rawFilter;
+    }
+    else if (input.tags || input.level) {
+        const levelMap = {
+            verbose: "V",
+            debug: "D",
+            info: "I",
+            warn: "W",
+            error: "E",
+        };
+        const levelChar = input.level ? levelMap[input.level] : "V";
+        if (input.tags) {
+            filter = input.tags.map((tag) => `${tag}:${levelChar}`).join(" ") + " *:S";
+        }
+        else {
+            filter = `*:${levelChar}`;
+        }
+    }
+    const output = await context.adb.logcat(deviceId, {
+        lines: input.lines,
+        filter: filter || undefined,
+    });
+    // Cache the full output and return a summary
+    const logId = context.cache.generateId("logcat");
+    context.cache.set(logId, { output, deviceId, filter }, "logcat", CACHE_TTLS.UI_TREE);
+    // Parse log lines
+    const lines = output.split("\n").filter(Boolean);
+    const errorCount = lines.filter((l) => l.includes(" E ")).length;
+    const warnCount = lines.filter((l) => l.includes(" W ")).length;
+    return {
+        logId,
+        summary: {
+            lineCount: lines.length,
+            errorCount,
+            warnCount,
+        },
+        preview: lines.slice(0, 20).join("\n"),
+        deviceId,
+    };
+}
+export const adbLogcatToolDefinition = {
+    name: "adb-logcat",
+    description: "Read device logs. Returns summary with logId for full output.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            lines: { type: "number", description: "Number of lines (default: 100)" },
+            package: { type: "string", description: "Filter by package name" },
+            tags: { type: "array", items: { type: "string" }, description: "Filter by log tags" },
+            level: { type: "string", enum: ["verbose", "debug", "info", "warn", "error"] },
+            rawFilter: { type: "string", description: "Raw logcat filter string" },
+            since: { type: "string", description: "Time filter (e.g., '5m' or ISO timestamp)" },
+        },
+    },
+};

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { ServerContext } from "../server.js";
+export declare const adbShellInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+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;
+                description: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};

package/dist/tools/adb-shell.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export const adbShellInputSchema = z.object({
+    command: z.string(),
+    timeout: z.number().optional(),
+});
+export async function handleAdbShellTool(input, context) {
+    const deviceId = context.deviceState.requireCurrentDevice().id;
+    const result = await context.adb.shell(deviceId, input.command, input.timeout);
+    return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        deviceId,
+    };
+}
+export const adbShellToolDefinition = {
+    name: "adb-shell",
+    description: "Execute shell commands with safety guards. Dangerous commands are blocked.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            command: { type: "string", description: "Shell command to execute" },
+            timeout: { type: "number", description: "Timeout in ms (default: 30s, max: 120s)" },
+        },
+        required: ["command"],
+    },
+};

package/dist/tools/cache.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { CacheManager } from "../services/index.js";
+export declare const cacheInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        clear: "clear";
+        "get-stats": "get-stats";
+        "get-config": "get-config";
+        "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>;
+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[];
+    };
+};

package/dist/tools/cache.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+export const cacheInputSchema = z.object({
+    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(),
+    }).optional(),
+});
+export async function handleCacheTool(input, cache) {
+    switch (input.operation) {
+        case "get-stats":
+            return { stats: cache.getStats() };
+        case "clear":
+            if (input.key) {
+                cache.clear(input.key);
+                return { cleared: input.key };
+            }
+            else {
+                cache.clearAll();
+                return { cleared: "all" };
+            }
+        case "get-config":
+            return { config: cache.getConfig() };
+        case "set-config":
+            if (input.config) {
+                cache.setConfig(input.config);
+            }
+            return { config: cache.getConfig() };
+        default:
+            throw new Error(`Unknown operation: ${input.operation}`);
+    }
+}
+export const cacheToolDefinition = {
+    name: "cache",
+    description: "Manage the cache. Operations: get-stats, clear, get-config, set-config. See rtfm for details.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            operation: {
+                type: "string",
+                enum: ["get-stats", "clear", "get-config", "set-config"],
+            },
+            key: { type: "string", description: "Specific cache key to clear" },
+            config: {
+                type: "object",
+                properties: {
+                    maxEntries: { type: "number" },
+                    maxEntrySizeBytes: { type: "number" },
+                    defaultTtlMs: { type: "number" },
+                },
+            },
+        },
+        required: ["operation"],
+    },
+};

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

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { ServerContext } from "../server.js";
+export declare const emulatorDeviceInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        kill: "kill";
+        list: "list";
+        create: "create";
+        start: "start";
+        wipe: "wipe";
+        "snapshot-save": "snapshot-save";
+        "snapshot-load": "snapshot-load";
+        "snapshot-list": "snapshot-list";
+        "snapshot-delete": "snapshot-delete";
+    }>;
+    avdName: z.ZodOptional<z.ZodString>;
+    device: z.ZodOptional<z.ZodString>;
+    systemImage: z.ZodOptional<z.ZodString>;
+    snapshotName: z.ZodOptional<z.ZodString>;
+    emulatorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+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;
+                description: string;
+            };
+            device: {
+                type: string;
+                description: string;
+            };
+            systemImage: {
+                type: string;
+                description: string;
+            };
+            snapshotName: {
+                type: string;
+                description: string;
+            };
+            emulatorId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};

package/dist/tools/emulator-device.js

@@ -0,0 +1,132 @@
+import { z } from "zod";
+export const emulatorDeviceInputSchema = z.object({
+    operation: z.enum([
+        "list",
+        "create",
+        "start",
+        "kill",
+        "wipe",
+        "snapshot-save",
+        "snapshot-load",
+        "snapshot-list",
+        "snapshot-delete",
+    ]),
+    avdName: z.string().optional(),
+    device: z.string().optional(),
+    systemImage: z.string().optional(),
+    snapshotName: z.string().optional(),
+    emulatorId: z.string().optional(),
+});
+export async function handleEmulatorDeviceTool(input, context) {
+    switch (input.operation) {
+        case "list": {
+            const result = await context.emulator.list();
+            return {
+                available: result.available,
+                running: result.running,
+            };
+        }
+        case "create": {
+            if (!input.avdName || !input.device || !input.systemImage) {
+                throw new Error("avdName, device, and systemImage are required for create");
+            }
+            await context.emulator.create(input.avdName, input.device, input.systemImage);
+            return { created: input.avdName };
+        }
+        case "start": {
+            if (!input.avdName) {
+                throw new Error("avdName is required for start");
+            }
+            const emulatorId = await context.emulator.start(input.avdName);
+            // Auto-select the started emulator
+            const devices = await context.adb.getDevices();
+            const device = devices.find((d) => d.id === emulatorId);
+            if (device) {
+                context.deviceState.setCurrentDevice(device);
+            }
+            return { started: input.avdName, emulatorId, autoSelected: true };
+        }
+        case "kill": {
+            const emulatorId = input.emulatorId || context.deviceState.getCurrentDevice()?.id;
+            if (!emulatorId) {
+                throw new Error("emulatorId is required or select an emulator first");
+            }
+            await context.emulator.kill(emulatorId);
+            // Clear device selection if it was the killed emulator
+            if (context.deviceState.getCurrentDevice()?.id === emulatorId) {
+                context.deviceState.clearCurrentDevice();
+            }
+            return { killed: emulatorId };
+        }
+        case "wipe": {
+            if (!input.avdName) {
+                throw new Error("avdName is required for wipe");
+            }
+            await context.emulator.wipe(input.avdName);
+            return { wiped: input.avdName };
+        }
+        case "snapshot-save": {
+            const emulatorId = input.emulatorId || context.deviceState.getCurrentDevice()?.id;
+            if (!emulatorId || !input.snapshotName) {
+                throw new Error("emulatorId and snapshotName are required for snapshot-save");
+            }
+            await context.emulator.snapshotSave(emulatorId, input.snapshotName);
+            return { saved: input.snapshotName, emulatorId };
+        }
+        case "snapshot-load": {
+            const emulatorId = input.emulatorId || context.deviceState.getCurrentDevice()?.id;
+            if (!emulatorId || !input.snapshotName) {
+                throw new Error("emulatorId and snapshotName are required for snapshot-load");
+            }
+            await context.emulator.snapshotLoad(emulatorId, input.snapshotName);
+            return { loaded: input.snapshotName, emulatorId };
+        }
+        case "snapshot-list": {
+            const emulatorId = input.emulatorId || context.deviceState.getCurrentDevice()?.id;
+            if (!emulatorId) {
+                throw new Error("emulatorId is required for snapshot-list");
+            }
+            const snapshots = await context.emulator.snapshotList(emulatorId);
+            return { snapshots, emulatorId };
+        }
+        case "snapshot-delete": {
+            const emulatorId = input.emulatorId || context.deviceState.getCurrentDevice()?.id;
+            if (!emulatorId || !input.snapshotName) {
+                throw new Error("emulatorId and snapshotName are required for snapshot-delete");
+            }
+            await context.emulator.snapshotDelete(emulatorId, input.snapshotName);
+            return { deleted: input.snapshotName, emulatorId };
+        }
+        default:
+            throw new Error(`Unknown operation: ${input.operation}`);
+    }
+}
+export const emulatorDeviceToolDefinition = {
+    name: "emulator-device",
+    description: "Manage Android emulators. Operations: list, create, start, kill, wipe, snapshot-*",
+    inputSchema: {
+        type: "object",
+        properties: {
+            operation: {
+                type: "string",
+                enum: [
+                    "list",
+                    "create",
+                    "start",
+                    "kill",
+                    "wipe",
+                    "snapshot-save",
+                    "snapshot-load",
+                    "snapshot-list",
+                    "snapshot-delete",
+                ],
+            },
+            avdName: { type: "string", description: "AVD name" },
+            device: { type: "string", description: "Device profile (e.g., 'pixel_7')" },
+            systemImage: { type: "string", description: "System image" },
+            snapshotName: { type: "string", description: "Snapshot name" },
+            emulatorId: { type: "string", description: "Running emulator ID" },
+        },
+        required: ["operation"],
+    },
+};

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { ServerContext } from "../server.js";
+export declare const gradleBuildInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        assembleDebug: "assembleDebug";
+        assembleRelease: "assembleRelease";
+        bundle: "bundle";
+    }>;
+    module: z.ZodOptional<z.ZodString>;
+    flavor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+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;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};

package/dist/tools/gradle-build.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { CACHE_TTLS } from "../types/index.js";
+export const gradleBuildInputSchema = z.object({
+    operation: z.enum(["assembleDebug", "assembleRelease", "bundle"]),
+    module: z.string().optional(),
+    flavor: z.string().optional(),
+});
+export async function handleGradleBuildTool(input, context) {
+    const { result, fullOutput } = await context.gradle.build(input.operation, input.module, input.flavor);
+    // Cache full output for later retrieval
+    const buildId = context.cache.generateId("build");
+    context.cache.set(buildId, { fullOutput, result, operation: input.operation }, "build", CACHE_TTLS.BUILD_OUTPUT);
+    return {
+        buildId,
+        summary: {
+            success: result.success,
+            duration: result.duration,
+            warnings: result.warnings,
+            errors: result.errors,
+            apkPath: result.apkPath,
+            tasksExecuted: result.tasksExecuted,
+        },
+    };
+}
+export const gradleBuildToolDefinition = {
+    name: "gradle-build",
+    description: "Build an Android application. Returns summary with buildId for full logs.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            operation: {
+                type: "string",
+                enum: ["assembleDebug", "assembleRelease", "bundle"],
+            },
+            module: { type: "string", description: "Module path (e.g., ':app')" },
+            flavor: { type: "string", description: "Product flavor" },
+        },
+        required: ["operation"],
+    },
+};

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

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { ServerContext } from "../server.js";
+export declare const gradleGetDetailsInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    detailType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        tasks: "tasks";
+        logs: "logs";
+        errors: "errors";
+    }>>>;
+}, z.core.$strip>;
+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;
+                description: string;
+            };
+            detailType: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};

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

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { ReplicantError, ErrorCode } from "../types/index.js";
+export const gradleGetDetailsInputSchema = z.object({
+    id: z.string(),
+    detailType: z.enum(["logs", "errors", "tasks", "all"]).optional().default("all"),
+});
+export async function handleGradleGetDetailsTool(input, context) {
+    const entry = context.cache.get(input.id);
+    if (!entry) {
+        throw new ReplicantError(ErrorCode.CACHE_MISS, `No cached data found for id: ${input.id}`, "The cache entry may have expired. Re-run the build/test operation.");
+    }
+    const { fullOutput, result, operation } = entry.data;
+    switch (input.detailType) {
+        case "logs":
+            return {
+                id: input.id,
+                operation,
+                logs: fullOutput,
+            };
+        case "errors": {
+            // Extract error lines
+            const lines = fullOutput.split("\n");
+            const errorLines = lines.filter((line) => line.includes("error:") ||
+                line.includes("Error:") ||
+                line.includes("FAILED") ||
+                line.startsWith("e:"));
+            return {
+                id: input.id,
+                operation,
+                errors: errorLines.join("\n"),
+                errorCount: errorLines.length,
+            };
+        }
+        case "tasks": {
+            // Extract task execution info
+            const lines = fullOutput.split("\n");
+            const taskLines = lines.filter((line) => line.startsWith("> Task"));
+            return {
+                id: input.id,
+                operation,
+                tasks: taskLines.map((line) => {
+                    const match = line.match(/> Task (:\S+)(?:\s+(.+))?/);
+                    return match ? { task: match[1], status: match[2] || "executed" } : null;
+                }).filter(Boolean),
+            };
+        }
+        case "all":
+        default:
+            return {
+                id: input.id,
+                operation,
+                result,
+                fullOutput,
+            };
+    }
+}
+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", description: "Build or test ID from previous operation" },
+            detailType: {
+                type: "string",
+                enum: ["logs", "errors", "tasks", "all"],
+                description: "Type of details to retrieve",
+            },
+        },
+        required: ["id"],
+    },
+};

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { ServerContext } from "../server.js";
+export declare const gradleListInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        tasks: "tasks";
+        modules: "modules";
+        variants: "variants";
+    }>;
+    module: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+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[];
+    };
+};