replicant-mcp 1.0.0

package/dist/adapters/gradle.js

@@ -0,0 +1,80 @@
+import { ProcessRunner } from "../services/index.js";
+import { ReplicantError, ErrorCode } from "../types/index.js";
+import { parseBuildOutput, parseTestOutput, parseModuleList, parseVariantList, parseTaskList, } from "../parsers/gradle-output.js";
+export class GradleAdapter {
+    runner;
+    projectPath;
+    constructor(runner = new ProcessRunner(), projectPath) {
+        this.runner = runner;
+        this.projectPath = projectPath;
+    }
+    async build(operation, module, flavor) {
+        const task = module ? `${module}:${operation}` : operation;
+        const args = [task];
+        if (flavor) {
+            args.push(`-Pflavor=${flavor}`);
+        }
+        const result = await this.gradle(args, 300000); // 5 min timeout for builds
+        const parsed = parseBuildOutput(result.stdout + result.stderr);
+        if (!parsed.success) {
+            throw new ReplicantError(ErrorCode.BUILD_FAILED, `Build failed: ${parsed.failedTask || "unknown error"}`, "Check gradle-get-details for full error output", { buildResult: parsed });
+        }
+        return { result: parsed, fullOutput: result.stdout + result.stderr };
+    }
+    async test(operation, module, filter) {
+        const taskName = operation === "unitTest" ? "testDebugUnitTest" : "connectedDebugAndroidTest";
+        const task = module ? `${module}:${taskName}` : taskName;
+        const args = [task];
+        if (filter) {
+            args.push("--tests", filter);
+        }
+        const result = await this.gradle(args, 600000); // 10 min timeout for tests
+        const parsed = parseTestOutput(result.stdout + result.stderr);
+        return { result: parsed, fullOutput: result.stdout + result.stderr };
+    }
+    async listModules() {
+        const result = await this.gradle(["projects"]);
+        return parseModuleList(result.stdout);
+    }
+    async listVariants(module) {
+        // Try to get variants - this varies by project setup
+        const task = module ? `${module}:printVariants` : "printVariants";
+        try {
+            const result = await this.gradle([task]);
+            return parseVariantList(result.stdout);
+        }
+        catch {
+            // Fallback: return common defaults
+            return [
+                { name: "debug", buildType: "debug", flavors: [] },
+                { name: "release", buildType: "release", flavors: [] },
+            ];
+        }
+    }
+    async listTasks(module) {
+        const args = module ? [`${module}:tasks`, "--all"] : ["tasks", "--all"];
+        const result = await this.gradle(args);
+        return parseTaskList(result.stdout);
+    }
+    async clean(stopDaemons = false) {
+        await this.gradle(["clean"]);
+        if (stopDaemons) {
+            await this.gradle(["--stop"]);
+        }
+    }
+    async gradle(args, timeoutMs = 120000) {
+        const gradleCmd = process.platform === "win32" ? "gradlew.bat" : "./gradlew";
+        try {
+            return await this.runner.run(gradleCmd, args, {
+                timeoutMs,
+                cwd: this.projectPath,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("ENOENT")) {
+                throw new ReplicantError(ErrorCode.GRADLE_NOT_FOUND, "Gradle wrapper not found", "Ensure you are in an Android project directory with gradlew");
+            }
+            throw error;
+        }
+    }
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,4 @@
+export { AdbAdapter } from "./adb.js";
+export { EmulatorAdapter, type EmulatorListResult } from "./emulator.js";
+export { GradleAdapter } from "./gradle.js";
+export { UiAutomatorAdapter } from "./ui-automator.js";

package/dist/adapters/index.js

@@ -0,0 +1,4 @@
+export { AdbAdapter } from "./adb.js";
+export { EmulatorAdapter } from "./emulator.js";
+export { GradleAdapter } from "./gradle.js";
+export { UiAutomatorAdapter } from "./ui-automator.js";

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

@@ -0,0 +1,23 @@
+import { AdbAdapter } from "./adb.js";
+import { AccessibilityNode } from "../parsers/ui-dump.js";
+export declare class UiAutomatorAdapter {
+    private adb;
+    constructor(adb?: AdbAdapter);
+    dump(deviceId: string): Promise<AccessibilityNode[]>;
+    find(deviceId: string, selector: {
+        resourceId?: string;
+        text?: string;
+        textContains?: string;
+        className?: string;
+    }): Promise<AccessibilityNode[]>;
+    tap(deviceId: string, x: number, y: number): Promise<void>;
+    tapElement(deviceId: string, element: AccessibilityNode): Promise<void>;
+    input(deviceId: string, text: string): Promise<void>;
+    screenshot(deviceId: string, localPath: string): Promise<void>;
+    accessibilityCheck(deviceId: string): Promise<{
+        hasAccessibleElements: boolean;
+        clickableCount: number;
+        textCount: number;
+        totalElements: number;
+    }>;
+}

package/dist/adapters/ui-automator.js

@@ -0,0 +1,53 @@
+import { AdbAdapter } from "./adb.js";
+import { parseUiDump, findElements, flattenTree } from "../parsers/ui-dump.js";
+export class UiAutomatorAdapter {
+    adb;
+    constructor(adb = new AdbAdapter()) {
+        this.adb = adb;
+    }
+    async dump(deviceId) {
+        // Dump UI hierarchy to device
+        await this.adb.shell(deviceId, "uiautomator dump /sdcard/ui-dump.xml");
+        // Pull the dump
+        const result = await this.adb.shell(deviceId, "cat /sdcard/ui-dump.xml");
+        // Clean up
+        await this.adb.shell(deviceId, "rm /sdcard/ui-dump.xml");
+        return parseUiDump(result.stdout);
+    }
+    async find(deviceId, selector) {
+        const tree = await this.dump(deviceId);
+        return findElements(tree, selector);
+    }
+    async tap(deviceId, x, y) {
+        await this.adb.shell(deviceId, `input tap ${x} ${y}`);
+    }
+    async tapElement(deviceId, element) {
+        await this.tap(deviceId, element.centerX, element.centerY);
+    }
+    async input(deviceId, text) {
+        // Escape special characters for shell
+        const escaped = text.replace(/(['"\\$`])/g, "\\$1").replace(/ /g, "%s");
+        await this.adb.shell(deviceId, `input text "${escaped}"`);
+    }
+    async screenshot(deviceId, localPath) {
+        const remotePath = "/sdcard/screenshot.png";
+        await this.adb.shell(deviceId, `screencap -p ${remotePath}`);
+        // Pull to local (using adb pull via shell workaround)
+        // In real implementation, would use adb pull directly
+        const result = await this.adb.shell(deviceId, `base64 ${remotePath}`);
+        // For now, just verify it worked
+        await this.adb.shell(deviceId, `rm ${remotePath}`);
+    }
+    async accessibilityCheck(deviceId) {
+        const tree = await this.dump(deviceId);
+        const flat = flattenTree(tree);
+        const clickableCount = flat.filter((n) => n.clickable).length;
+        const textCount = flat.filter((n) => n.text || n.contentDesc).length;
+        return {
+            hasAccessibleElements: textCount > 0,
+            clickableCount,
+            textCount,
+            totalElements: flat.length,
+        };
+    }
+}

package/dist/cli/adb.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createAdbCommand(): Command;

package/dist/cli/adb.js

@@ -0,0 +1,256 @@
+import { Command } from "commander";
+import { AdbAdapter } from "../adapters/index.js";
+import { DeviceStateManager, CacheManager } from "../services/index.js";
+import { formatDeviceList, formatLogcat } from "./formatter.js";
+import { CACHE_TTLS } from "../types/index.js";
+const adapter = new AdbAdapter();
+const deviceState = new DeviceStateManager();
+const cache = new CacheManager();
+export function createAdbCommand() {
+    const adb = new Command("adb").description("ADB device and app management");
+    // Devices subcommand
+    adb
+        .command("devices")
+        .description("List connected devices")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        try {
+            const devices = await adapter.getDevices();
+            const currentDevice = deviceState.getCurrentDevice();
+            // Auto-select if single device
+            const autoSelected = deviceState.autoSelectIfSingle(devices);
+            const deviceInfos = devices.map((d) => ({
+                id: d.id,
+                name: d.name,
+                state: d.status,
+                selected: currentDevice?.id === d.id || (autoSelected && devices[0].id === d.id),
+            }));
+            if (options.json) {
+                console.log(JSON.stringify({ devices: deviceInfos }, null, 2));
+            }
+            else {
+                console.log(formatDeviceList({ devices: deviceInfos }));
+                if (autoSelected) {
+                    console.log(`\nAuto-selected: ${devices[0].id}`);
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Select subcommand
+    adb
+        .command("select <deviceId>")
+        .description("Set active device for subsequent commands")
+        .action(async (deviceId) => {
+        try {
+            const devices = await adapter.getDevices();
+            const device = devices.find((d) => d.id === deviceId);
+            if (!device) {
+                console.error(`Device not found: ${deviceId}`);
+                console.error("Available devices:");
+                devices.forEach((d) => console.error(`  ${d.id} (${d.name})`));
+                process.exit(1);
+            }
+            deviceState.setCurrentDevice(device);
+            console.log(`Selected device: ${device.id} (${device.name})`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Install subcommand
+    adb
+        .command("install <apkPath>")
+        .description("Install APK on the active device")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .action(async (apkPath, options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            await adapter.install(deviceId, apkPath);
+            console.log(`Installed: ${apkPath}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Launch subcommand
+    adb
+        .command("launch <package>")
+        .description("Launch an app on the active device")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .action(async (packageName, options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            await adapter.launch(deviceId, packageName);
+            console.log(`Launched: ${packageName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Stop subcommand
+    adb
+        .command("stop <package>")
+        .description("Force stop an app on the active device")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .action(async (packageName, options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            await adapter.stop(deviceId, packageName);
+            console.log(`Stopped: ${packageName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Uninstall subcommand
+    adb
+        .command("uninstall <package>")
+        .description("Uninstall an app from the active device")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .action(async (packageName, options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            await adapter.uninstall(deviceId, packageName);
+            console.log(`Uninstalled: ${packageName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Clear subcommand
+    adb
+        .command("clear <package>")
+        .description("Clear app data on the active device")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .action(async (packageName, options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            await adapter.clearData(deviceId, packageName);
+            console.log(`Cleared data: ${packageName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Logcat subcommand
+    adb
+        .command("logcat")
+        .description("Read device logs")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .option("-l, --level <level>", "Log level filter (verbose, debug, info, warn, error)", "info")
+        .option("-n, --lines <count>", "Number of lines to retrieve", "50")
+        .option("-t, --tag <tag>", "Filter by tag")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            // Build filter string
+            let filter = "";
+            if (options.tag) {
+                const levelChar = getLevelChar(options.level);
+                filter = `${options.tag}:${levelChar} *:S`;
+            }
+            else {
+                const levelChar = getLevelChar(options.level);
+                filter = `*:${levelChar}`;
+            }
+            const logs = await adapter.logcat(deviceId, {
+                lines: parseInt(options.lines, 10),
+                filter,
+            });
+            const lines = logs.split("\n").filter((line) => line.trim());
+            const cacheId = cache.generateId("logcat");
+            cache.set(cacheId, { logs, level: options.level }, "logcat", CACHE_TTLS.LOGCAT);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    level: options.level,
+                    count: lines.length,
+                    lines,
+                    cacheId,
+                }, null, 2));
+            }
+            else {
+                console.log(formatLogcat({
+                    level: options.level,
+                    count: lines.length,
+                    lines,
+                    cacheId,
+                }));
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Shell subcommand
+    adb
+        .command("shell <command...>")
+        .description("Run a shell command on the active device")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (commandParts, options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            const command = commandParts.join(" ");
+            const result = await adapter.shell(deviceId, command);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    command,
+                    exitCode: result.exitCode,
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                }, null, 2));
+            }
+            else {
+                if (result.stdout) {
+                    console.log(result.stdout);
+                }
+                if (result.stderr) {
+                    console.error(result.stderr);
+                }
+            }
+            if (result.exitCode !== 0) {
+                process.exit(result.exitCode);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    return adb;
+}
+function getDeviceId() {
+    const device = deviceState.requireCurrentDevice();
+    return device.id;
+}
+function getLevelChar(level) {
+    const levels = {
+        verbose: "V",
+        debug: "D",
+        info: "I",
+        warn: "W",
+        error: "E",
+    };
+    return levels[level.toLowerCase()] || "I";
+}

package/dist/cli/cache.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createCacheCommand(): Command;

package/dist/cli/cache.js

@@ -0,0 +1,115 @@
+import { Command } from "commander";
+import { CacheManager } from "../services/index.js";
+const cache = new CacheManager();
+export function createCacheCommand() {
+    const cacheCmd = new Command("cache").description("Manage output cache");
+    // Stats subcommand
+    cacheCmd
+        .command("stats")
+        .description("Show cache statistics")
+        .option("--json", "Output as JSON")
+        .action((options) => {
+        try {
+            const stats = cache.getStats();
+            if (options.json) {
+                console.log(JSON.stringify(stats, null, 2));
+            }
+            else {
+                console.log("Cache Statistics");
+                console.log("================");
+                console.log(`Entries: ${stats.entryCount}`);
+                console.log(`Total size: ${formatBytes(stats.totalSizeBytes)}`);
+                console.log(`Max entries: ${stats.config.maxEntries}`);
+                console.log(`Default TTL: ${formatMs(stats.config.defaultTtlMs)}`);
+                if (Object.keys(stats.typeBreakdown).length > 0) {
+                    console.log("\nBy type:");
+                    for (const [type, count] of Object.entries(stats.typeBreakdown)) {
+                        console.log(`  ${type}: ${count}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Get subcommand
+    cacheCmd
+        .command("get <cacheId>")
+        .description("Get cached entry by ID")
+        .option("--json", "Output as JSON")
+        .action((cacheId, options) => {
+        try {
+            const entry = cache.get(cacheId);
+            if (!entry) {
+                console.error(`Cache entry not found: ${cacheId}`);
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify({
+                    id: cacheId,
+                    data: entry.data,
+                    metadata: entry.metadata,
+                    expiresAt: entry.expiresAt,
+                }, null, 2));
+            }
+            else {
+                console.log(`Cache ID: ${cacheId}`);
+                console.log(`Type: ${entry.metadata.type}`);
+                console.log(`Created: ${new Date(entry.metadata.createdAt).toISOString()}`);
+                console.log(`Expires: ${new Date(entry.expiresAt).toISOString()}`);
+                console.log(`Size: ${formatBytes(entry.metadata.sizeBytes ?? 0)}`);
+                console.log("\nData:");
+                console.log(JSON.stringify(entry.data, null, 2));
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Clear subcommand
+    cacheCmd
+        .command("clear")
+        .description("Clear all cached data")
+        .option("--json", "Output as JSON")
+        .action((options) => {
+        try {
+            const statsBefore = cache.getStats();
+            const entriesCleared = statsBefore.entryCount;
+            cache.clearAll();
+            if (options.json) {
+                console.log(JSON.stringify({
+                    cleared: true,
+                    entriesCleared,
+                }, null, 2));
+            }
+            else {
+                console.log(`Cleared ${entriesCleared} cache entries`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    return cacheCmd;
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}
+function formatMs(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(0)}s`;
+    return `${(ms / 60000).toFixed(0)}m`;
+}

package/dist/cli/emulator.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createEmulatorCommand(): Command;