replicant-mcp 1.0.0

package/dist/cli/ui.js

@@ -0,0 +1,218 @@
+import { Command } from "commander";
+import { UiAutomatorAdapter } from "../adapters/index.js";
+import { DeviceStateManager, CacheManager } from "../services/index.js";
+import { formatUiDump } from "./formatter.js";
+import { CACHE_TTLS } from "../types/index.js";
+const adapter = new UiAutomatorAdapter();
+const deviceState = new DeviceStateManager();
+const cache = new CacheManager();
+// Store last find results for tap --index
+let lastFindResults = [];
+export function createUiCommand() {
+    const ui = new Command("ui").description("UI automation and accessibility inspection");
+    // Dump subcommand
+    ui.command("dump")
+        .description("Dump the accessibility tree")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            const tree = await adapter.dump(deviceId);
+            // Cache the dump
+            const cacheId = cache.generateId("ui-dump");
+            cache.set(cacheId, { tree }, "ui-dump", CACHE_TTLS.UI_TREE);
+            if (options.json) {
+                console.log(JSON.stringify({ tree, cacheId }, null, 2));
+            }
+            else {
+                // Convert tree to UiElements for formatting
+                const elements = treeToElements(tree);
+                const screenName = extractScreenName(tree);
+                console.log(formatUiDump({
+                    screenName,
+                    elements,
+                }));
+                console.log(`Cache ID: ${cacheId}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Find subcommand
+    ui.command("find")
+        .description("Find UI elements by selector")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .option("-t, --text <text>", "Exact text match")
+        .option("-c, --contains <text>", "Text contains match")
+        .option("-i, --id <resourceId>", "Resource ID match")
+        .option("--class <className>", "Class name match")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            const selector = {};
+            if (options.text)
+                selector.text = options.text;
+            if (options.contains)
+                selector.textContains = options.contains;
+            if (options.id)
+                selector.resourceId = options.id;
+            if (options.class)
+                selector.className = options.class;
+            // Ensure at least one selector is provided
+            if (Object.keys(selector).length === 0) {
+                console.error("Error: At least one selector option required (--text, --contains, --id, or --class)");
+                process.exit(1);
+            }
+            const results = await adapter.find(deviceId, selector);
+            lastFindResults = results;
+            // Cache the results
+            const cacheId = cache.generateId("ui-find");
+            cache.set(cacheId, { results, selector }, "ui-find", CACHE_TTLS.UI_TREE);
+            if (options.json) {
+                console.log(JSON.stringify({ results, count: results.length, cacheId }, null, 2));
+            }
+            else {
+                if (results.length === 0) {
+                    console.log("No elements found matching selector");
+                }
+                else {
+                    console.log(`Found ${results.length} element(s):`);
+                    results.forEach((node, idx) => {
+                        const desc = node.text || node.contentDesc || node.resourceId || node.className;
+                        console.log(`  [${idx}] ${node.className.split(".").pop()} "${desc}" at (${node.centerX}, ${node.centerY})`);
+                    });
+                    console.log(`\nUse 'ui tap --index <n>' to tap an element`);
+                }
+                console.log(`Cache ID: ${cacheId}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Tap subcommand
+    ui.command("tap")
+        .description("Tap a UI element or coordinates")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .option("-i, --index <index>", "Index from last find results")
+        .option("-x, --x <x>", "X coordinate")
+        .option("-y, --y <y>", "Y coordinate")
+        .action(async (options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            if (options.index !== undefined) {
+                const index = parseInt(options.index, 10);
+                if (lastFindResults.length === 0) {
+                    console.error("Error: No previous find results. Run 'ui find' first.");
+                    process.exit(1);
+                }
+                if (index < 0 || index >= lastFindResults.length) {
+                    console.error(`Error: Index ${index} out of range (0-${lastFindResults.length - 1})`);
+                    process.exit(1);
+                }
+                const element = lastFindResults[index];
+                await adapter.tapElement(deviceId, element);
+                console.log(`Tapped element [${index}] at (${element.centerX}, ${element.centerY})`);
+            }
+            else if (options.x !== undefined && options.y !== undefined) {
+                const x = parseInt(options.x, 10);
+                const y = parseInt(options.y, 10);
+                await adapter.tap(deviceId, x, y);
+                console.log(`Tapped at (${x}, ${y})`);
+            }
+            else {
+                console.error("Error: Provide either --index or both --x and --y");
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Input subcommand
+    ui.command("input <text>")
+        .description("Input text to the focused element")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .action(async (text, options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            await adapter.input(deviceId, text);
+            console.log(`Input text: "${text}"`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Screenshot subcommand
+    ui.command("screenshot [path]")
+        .description("Take a screenshot")
+        .option("-d, --device <deviceId>", "Target device (uses active device if not specified)")
+        .action(async (path, options) => {
+        try {
+            const deviceId = options.device || getDeviceId();
+            const outputPath = path || `screenshot-${Date.now()}.png`;
+            await adapter.screenshot(deviceId, outputPath);
+            console.log(`Screenshot saved: ${outputPath}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    return ui;
+}
+function getDeviceId() {
+    const device = deviceState.requireCurrentDevice();
+    return device.id;
+}
+function extractScreenName(tree) {
+    // Try to find an activity or window name from the tree
+    if (tree.length > 0) {
+        const root = tree[0];
+        // Common patterns for activity names in class names
+        if (root.className.includes("Activity")) {
+            return root.className.split(".").pop() || "Unknown";
+        }
+        if (root.className.includes("DecorView")) {
+            return "Main Window";
+        }
+    }
+    return "Unknown Screen";
+}
+function treeToElements(tree) {
+    const elements = [];
+    let elementIndex = 0;
+    function walk(node) {
+        // Only include interactive or text-containing elements
+        if (node.clickable || node.focusable || node.text || node.contentDesc) {
+            elements.push({
+                index: elementIndex++,
+                type: node.className.split(".").pop() || "Unknown",
+                text: node.text || undefined,
+                hint: node.contentDesc || undefined,
+                focused: node.focusable,
+            });
+        }
+        if (node.children) {
+            for (const child of node.children) {
+                walk(child);
+            }
+        }
+    }
+    for (const node of tree) {
+        walk(node);
+    }
+    return elements;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createGradleCommand, createAdbCommand, createEmulatorCommand, createUiCommand, createCacheCommand, } from "./cli/index.js";
+const program = new Command();
+program
+    .name("replicant")
+    .description("Android development CLI for Claude Code skills")
+    .version("1.0.0");
+program.addCommand(createGradleCommand());
+program.addCommand(createAdbCommand());
+program.addCommand(createEmulatorCommand());
+program.addCommand(createUiCommand());
+program.addCommand(createCacheCommand());
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runServer } from "./server.js";
+runServer().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/dist/parsers/adb-output.d.ts

@@ -0,0 +1,4 @@
+import { Device } from "../types/index.js";
+export declare function parseDeviceList(output: string): Device[];
+export declare function parsePackageList(output: string): string[];
+export declare function parseGetProp(output: string, prop: string): string | undefined;

package/dist/parsers/adb-output.js

@@ -0,0 +1,32 @@
+export function parseDeviceList(output) {
+    const lines = output.split("\n").slice(1); // Skip header
+    const devices = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const [id, statusStr] = trimmed.split(/\s+/);
+        if (!id)
+            continue;
+        const type = id.startsWith("emulator") ? "emulator" : "physical";
+        const status = statusStr === "device" ? "online" : "offline";
+        devices.push({
+            id,
+            type,
+            name: id, // Can be enriched later with getprop
+            status,
+        });
+    }
+    return devices;
+}
+export function parsePackageList(output) {
+    return output
+        .split("\n")
+        .filter((line) => line.startsWith("package:"))
+        .map((line) => line.replace("package:", "").trim());
+}
+export function parseGetProp(output, prop) {
+    const regex = new RegExp(`\\[${prop}\\]:\\s*\\[(.*)\\]`);
+    const match = output.match(regex);
+    return match?.[1];
+}

package/dist/parsers/emulator-output.d.ts

@@ -0,0 +1,9 @@
+export interface AvdInfo {
+    name: string;
+    path?: string;
+    target?: string;
+    skin?: string;
+}
+export declare function parseAvdList(output: string): AvdInfo[];
+export declare function parseEmulatorList(output: string): string[];
+export declare function parseSnapshotList(output: string): string[];

package/dist/parsers/emulator-output.js

@@ -0,0 +1,33 @@
+export function parseAvdList(output) {
+    const avds = [];
+    const blocks = output.split("---------");
+    for (const block of blocks) {
+        const nameMatch = block.match(/Name:\s*(.+)/);
+        if (!nameMatch)
+            continue;
+        const pathMatch = block.match(/Path:\s*(.+)/);
+        const targetMatch = block.match(/Target:\s*(.+)/);
+        const skinMatch = block.match(/Skin:\s*(.+)/);
+        avds.push({
+            name: nameMatch[1].trim(),
+            path: pathMatch?.[1].trim(),
+            target: targetMatch?.[1].trim(),
+            skin: skinMatch?.[1].trim(),
+        });
+    }
+    return avds;
+}
+export function parseEmulatorList(output) {
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("emulator-"));
+}
+export function parseSnapshotList(output) {
+    // Output format: "snapshot_name    size    date"
+    return output
+        .split("\n")
+        .slice(1) // Skip header
+        .map((line) => line.split(/\s+/)[0])
+        .filter(Boolean);
+}

package/dist/parsers/gradle-output.d.ts

@@ -0,0 +1,30 @@
+export interface BuildResult {
+    success: boolean;
+    duration?: string;
+    tasksExecuted?: number;
+    warnings: number;
+    errors: number;
+    failedTask?: string;
+    apkPath?: string;
+}
+export interface TestResult {
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+    duration?: string;
+    failures: Array<{
+        test: string;
+        message: string;
+    }>;
+}
+export declare function parseBuildOutput(output: string): BuildResult;
+export declare function parseTestOutput(output: string): TestResult;
+export declare function parseModuleList(output: string): string[];
+export interface VariantInfo {
+    name: string;
+    buildType: string;
+    flavors: string[];
+}
+export declare function parseVariantList(output: string): VariantInfo[];
+export declare function parseTaskList(output: string): string[];

package/dist/parsers/gradle-output.js

@@ -0,0 +1,80 @@
+export function parseBuildOutput(output) {
+    const success = output.includes("BUILD SUCCESSFUL");
+    const durationMatch = output.match(/BUILD (?:SUCCESSFUL|FAILED) in (\S+)/);
+    const tasksMatch = output.match(/(\d+) actionable tasks/);
+    const failedTaskMatch = output.match(/Task (:\S+) FAILED/);
+    const warnings = (output.match(/^w:/gm) || []).length;
+    const errors = (output.match(/^e:/gm) || []).length;
+    // Try to find APK path
+    const apkMatch = output.match(/(\S+\.apk)/);
+    return {
+        success,
+        duration: durationMatch?.[1],
+        tasksExecuted: tasksMatch ? parseInt(tasksMatch[1], 10) : undefined,
+        warnings,
+        errors,
+        failedTask: failedTaskMatch?.[1],
+        apkPath: apkMatch?.[1],
+    };
+}
+export function parseTestOutput(output) {
+    const summaryMatch = output.match(/(\d+) tests? completed(?:, (\d+) failed)?(?:, (\d+) skipped)?/);
+    const total = summaryMatch ? parseInt(summaryMatch[1], 10) : 0;
+    const failed = summaryMatch?.[2] ? parseInt(summaryMatch[2], 10) : 0;
+    const skipped = summaryMatch?.[3] ? parseInt(summaryMatch[3], 10) : 0;
+    const passed = total - failed - skipped;
+    const durationMatch = output.match(/in (\S+)/);
+    // Extract failure details
+    const failures = [];
+    const failureRegex = /(\S+) > (\S+) FAILED/g;
+    let match;
+    while ((match = failureRegex.exec(output)) !== null) {
+        failures.push({ test: `${match[1]}.${match[2]}`, message: "" });
+    }
+    return {
+        passed,
+        failed,
+        skipped,
+        total,
+        duration: durationMatch?.[1],
+        failures,
+    };
+}
+export function parseModuleList(output) {
+    const modules = [];
+    const regex = /Project '(:\S+)'/g;
+    let match;
+    while ((match = regex.exec(output)) !== null) {
+        modules.push(match[1]);
+    }
+    return modules;
+}
+export function parseVariantList(output) {
+    // This is a simplified parser - actual output varies by project
+    const variants = [];
+    const lines = output.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith(">") || trimmed.startsWith("Task"))
+            continue;
+        // Common pattern: "debug", "release", "freeDebug", "paidRelease"
+        if (/^[a-z]+[A-Z]?[a-z]*$/.test(trimmed)) {
+            const isDebug = trimmed.toLowerCase().includes("debug");
+            const isRelease = trimmed.toLowerCase().includes("release");
+            const buildType = isDebug ? "debug" : isRelease ? "release" : trimmed;
+            const flavorPart = trimmed.replace(/debug|release/gi, "");
+            const flavors = flavorPart ? [flavorPart.toLowerCase()] : [];
+            variants.push({ name: trimmed, buildType, flavors });
+        }
+    }
+    return variants;
+}
+export function parseTaskList(output) {
+    const tasks = [];
+    const regex = /^(\S+) - /gm;
+    let match;
+    while ((match = regex.exec(output)) !== null) {
+        tasks.push(match[1]);
+    }
+    return tasks;
+}

package/dist/parsers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./adb-output.js";
+export * from "./emulator-output.js";
+export * from "./gradle-output.js";
+export * from "./ui-dump.js";

package/dist/parsers/index.js

@@ -0,0 +1,4 @@
+export * from "./adb-output.js";
+export * from "./emulator-output.js";
+export * from "./gradle-output.js";
+export * from "./ui-dump.js";

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

@@ -0,0 +1,27 @@
+export interface Bounds {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface AccessibilityNode {
+    index: number;
+    text: string;
+    resourceId: string;
+    className: string;
+    contentDesc: string;
+    bounds: Bounds;
+    centerX: number;
+    centerY: number;
+    clickable: boolean;
+    focusable: boolean;
+    children?: AccessibilityNode[];
+}
+export declare function parseUiDump(xml: string): AccessibilityNode[];
+export declare function flattenTree(nodes: AccessibilityNode[]): AccessibilityNode[];
+export declare function findElements(nodes: AccessibilityNode[], selector: {
+    resourceId?: string;
+    text?: string;
+    textContains?: string;
+    className?: string;
+}): AccessibilityNode[];

package/dist/parsers/ui-dump.js

@@ -0,0 +1,142 @@
+function parseAttributes(attrStr) {
+    const attrs = {};
+    const attrRegex = /(\w+(?:-\w+)?)="([^"]*)"/g;
+    let match;
+    while ((match = attrRegex.exec(attrStr)) !== null) {
+        attrs[match[1]] = match[2];
+    }
+    return attrs;
+}
+function parseBounds(boundsStr) {
+    const match = boundsStr.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+    if (!match)
+        return { left: 0, top: 0, right: 0, bottom: 0 };
+    return {
+        left: parseInt(match[1], 10),
+        top: parseInt(match[2], 10),
+        right: parseInt(match[3], 10),
+        bottom: parseInt(match[4], 10),
+    };
+}
+function parseNodeFromAttrs(attrs) {
+    const bounds = parseBounds(attrs.bounds || "[0,0][0,0]");
+    return {
+        index: parseInt(attrs.index || "0", 10),
+        text: attrs.text || "",
+        resourceId: attrs["resource-id"] || "",
+        className: attrs.class || "",
+        contentDesc: attrs["content-desc"] || "",
+        bounds,
+        centerX: Math.round((bounds.left + bounds.right) / 2),
+        centerY: Math.round((bounds.top + bounds.bottom) / 2),
+        clickable: attrs.clickable === "true",
+        focusable: attrs.focusable === "true",
+    };
+}
+export function parseUiDump(xml) {
+    const nodes = [];
+    // Find all node elements and build tree structure
+    // Using a simple recursive parser
+    function parseChildren(content) {
+        const children = [];
+        // Match top-level node elements only
+        let depth = 0;
+        let nodeStart = -1;
+        let i = 0;
+        while (i < content.length) {
+            // Check for node opening tag
+            if (content.slice(i, i + 5) === "<node") {
+                if (depth === 0) {
+                    nodeStart = i;
+                }
+                depth++;
+                // Skip to end of opening tag
+                const tagEnd = content.indexOf(">", i);
+                if (tagEnd === -1)
+                    break;
+                // Check if self-closing
+                if (content[tagEnd - 1] === "/") {
+                    depth--;
+                    if (depth === 0 && nodeStart !== -1) {
+                        const nodeXml = content.slice(nodeStart, tagEnd + 1);
+                        const attrMatch = nodeXml.match(/<node\s+([^>]*)/);
+                        if (attrMatch) {
+                            const node = parseNodeFromAttrs(parseAttributes(attrMatch[1]));
+                            children.push(node);
+                        }
+                        nodeStart = -1;
+                    }
+                }
+                i = tagEnd + 1;
+                continue;
+            }
+            // Check for closing tag
+            if (content.slice(i, i + 7) === "</node>") {
+                depth--;
+                if (depth === 0 && nodeStart !== -1) {
+                    const nodeXml = content.slice(nodeStart, i + 7);
+                    // Parse this node's attributes
+                    const attrMatch = nodeXml.match(/<node\s+([^>]*)>/);
+                    if (attrMatch) {
+                        const node = parseNodeFromAttrs(parseAttributes(attrMatch[1]));
+                        // Parse children recursively
+                        const innerStart = nodeXml.indexOf(">") + 1;
+                        const innerEnd = nodeXml.lastIndexOf("</node>");
+                        if (innerEnd > innerStart) {
+                            const innerContent = nodeXml.slice(innerStart, innerEnd);
+                            const childNodes = parseChildren(innerContent);
+                            if (childNodes.length > 0) {
+                                node.children = childNodes;
+                            }
+                        }
+                        children.push(node);
+                    }
+                    nodeStart = -1;
+                }
+                i += 7;
+                continue;
+            }
+            i++;
+        }
+        return children;
+    }
+    // Extract hierarchy content
+    const hierarchyMatch = xml.match(/<hierarchy[^>]*>([\s\S]*)<\/hierarchy>/);
+    if (hierarchyMatch) {
+        return parseChildren(hierarchyMatch[1]);
+    }
+    return nodes;
+}
+export function flattenTree(nodes) {
+    const flat = [];
+    function walk(node) {
+        flat.push(node);
+        if (node.children) {
+            for (const child of node.children) {
+                walk(child);
+            }
+        }
+    }
+    for (const node of nodes) {
+        walk(node);
+    }
+    return flat;
+}
+export function findElements(nodes, selector) {
+    const flat = flattenTree(nodes);
+    return flat.filter((node) => {
+        if (selector.resourceId && !node.resourceId.includes(selector.resourceId)) {
+            return false;
+        }
+        if (selector.text && node.text !== selector.text) {
+            return false;
+        }
+        if (selector.textContains && !node.text.includes(selector.textContains)) {
+            return false;
+        }
+        if (selector.className && !node.className.includes(selector.className)) {
+            return false;
+        }
+        return true;
+    });
+}

package/dist/server.d.ts

@@ -0,0 +1,15 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CacheManager, DeviceStateManager, ProcessRunner } from "./services/index.js";
+import { AdbAdapter, EmulatorAdapter, GradleAdapter, UiAutomatorAdapter } from "./adapters/index.js";
+export interface ServerContext {
+    cache: CacheManager;
+    deviceState: DeviceStateManager;
+    processRunner: ProcessRunner;
+    adb: AdbAdapter;
+    emulator: EmulatorAdapter;
+    gradle: GradleAdapter;
+    ui: UiAutomatorAdapter;
+}
+export declare function createServerContext(): ServerContext;
+export declare function createServer(context: ServerContext): Promise<Server>;
+export declare function runServer(): Promise<void>;