@basegrid_tech/mcp 0.16.2 → 0.17.0

package/dist/index.js

@@ -136,6 +136,8 @@ var MANAGED_WORKTREE_MARKERS = [
 
 // ../server/src/basegrid-paths-fs.ts
 function getDataDir() {
+  const override = process.env.BASEGRID_DATA_DIR?.trim();
+  if (override) return override;
   return path.join(os.homedir(), BASEGRID_DIR_NAME);
 }
 function getDbPath() {
@@ -1688,6 +1690,7 @@ var DEFAULTS_KEYS_MAP = {
   rowHeight: true,
   defaultAgent: true,
   defaultSessionView: true,
+  collapseAgentSteps: true,
   notifications: true,
   hasSeenOnboarding: true,
   widgetEnabled: true,
@@ -1702,7 +1705,6 @@ var DEFAULTS_KEYS_MAP = {
   activeWorkspace: true,
   webAccessEnabled: true,
   mobileAccessEnabled: true,
-  networkAccessEnabled: true,
   proxy: true,
   proxySource: true,
   showHeadlessAgents: true,
@@ -3941,6 +3943,404 @@ function registerAskUserQuestionTool(server) {
   );
 }
 
+// src/tools/emulator.ts
+import { z as z8 } from "zod";
+var TARGET_FIELDS = {
+  device: V.shortText.optional().describe("Device serial (e.g. emulator-5554) or AVD name. Defaults to the active device."),
+  worktree_path: V.absolutePath.optional().describe("Worktree path whose active device to use when `device` is omitted")
+};
+function target(args) {
+  return { device: args.device, worktreePath: args.worktree_path };
+}
+function cameraSource(args) {
+  if (args.source === "webcam") {
+    return { kind: "webcam", name: args.webcam_name };
+  }
+  if (args.source === "file") {
+    if (!args.file_path) {
+      throw new Error('file_path is required when source is "file"');
+    }
+    return { kind: "file", path: args.file_path };
+  }
+  return { kind: "placeholder" };
+}
+function text(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+function ok(message) {
+  return { content: [{ type: "text", text: message }] };
+}
+function failure(err) {
+  return {
+    content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+    isError: true
+  };
+}
+function registerEmulatorTools(server) {
+  server.tool(
+    "emulator_devices",
+    "List Android emulators/AVDs and connected devices, plus SDK availability. Run this first to get a device serial.",
+    {},
+    async () => {
+      try {
+        const availability = await rpcCall("emulator:availability");
+        return text(availability);
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_attach",
+    "Boot the device/AVD if needed and make it the active emulator for a worktree. Later commands can then omit `device`.",
+    {
+      device: V.shortText.describe("Device serial or AVD name"),
+      worktree_path: V.absolutePath.optional().describe("Worktree this device becomes active for")
+    },
+    async (args) => {
+      try {
+        const active = await rpcCall("emulator:attach", {
+          device: args.device,
+          worktreePath: args.worktree_path
+        });
+        return text(active);
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_screenshot",
+    "Capture the current device screen as a PNG image.",
+    TARGET_FIELDS,
+    async (args) => {
+      try {
+        const shot = await rpcCall("emulator:screenshot", target(args));
+        return {
+          content: [{ type: "image", data: shot.data, mimeType: shot.mimeType }]
+        };
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_ax",
+    "Dump the accessibility tree (uiautomator). Use element bounds to compute a tap point: x=(left+right)/2/screenWidth, y=(top+bottom)/2/screenHeight.",
+    TARGET_FIELDS,
+    async (args) => {
+      try {
+        return text(await rpcCall("emulator:ax", target(args)));
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_tap",
+    "Tap at normalized coordinates (0..1, top-left origin). Preferred over swipe for single taps.",
+    {
+      x: z8.number().min(0).max(1).describe("Normalized X (0..1)"),
+      y: z8.number().min(0).max(1).describe("Normalized Y (0..1)"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        await rpcCall("emulator:tap", { ...target(args), x: args.x, y: args.y });
+        return ok(`Tapped at ${args.x.toFixed(3)}, ${args.y.toFixed(3)}`);
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_swipe",
+    "Swipe from one normalized point to another (0..1). adb approximates the path by its endpoints, so this fits scroll/swipe, not true multi-touch paths.",
+    {
+      from_x: z8.number().min(0).max(1).describe("Start X (0..1)"),
+      from_y: z8.number().min(0).max(1).describe("Start Y (0..1)"),
+      to_x: z8.number().min(0).max(1).describe("End X (0..1)"),
+      to_y: z8.number().min(0).max(1).describe("End Y (0..1)"),
+      duration_ms: z8.number().int().min(50).max(1e4).optional().describe("Swipe duration in ms (default 300)"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        await rpcCall("emulator:gesture", {
+          ...target(args),
+          points: [
+            { x: args.from_x, y: args.from_y },
+            { x: args.to_x, y: args.to_y, delayMs: args.duration_ms }
+          ]
+        });
+        return ok("Swipe sent");
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_type",
+    'Type text into the focused field. US ASCII only; newlines are not supported \u2014 send button "enter" instead.',
+    {
+      text: z8.string().min(1).max(2e3).describe("Text to type"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        await rpcCall("emulator:type", { ...target(args), text: args.text });
+        return ok("Text typed");
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_button",
+    "Press a hardware/system button.",
+    {
+      name: z8.enum([
+        "home",
+        "back",
+        "recents",
+        "power",
+        "volume_up",
+        "volume_down",
+        "enter",
+        "tab",
+        "delete",
+        "escape",
+        "menu",
+        "search"
+      ]).describe("Button name"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        await rpcCall("emulator:button", { ...target(args), name: args.name });
+        return ok(`Pressed ${args.name}`);
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_rotate",
+    "Rotate the device. Disables auto-rotate and sets a fixed orientation.",
+    {
+      orientation: z8.enum(["portrait", "portrait_upside_down", "landscape_left", "landscape_right"]).describe("Target orientation"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        await rpcCall("emulator:rotate", { ...target(args), orientation: args.orientation });
+        return ok(`Rotated to ${args.orientation}`);
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_install",
+    "Install an APK onto the device.",
+    {
+      apk_path: V.absolutePath.describe("Absolute path to the .apk file"),
+      reinstall: z8.boolean().optional().describe("Reinstall over an existing app (adb install -r)"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        await rpcCall("emulator:install", {
+          ...target(args),
+          apkPath: args.apk_path,
+          reinstall: args.reinstall
+        });
+        return ok(`Installed ${args.apk_path}`);
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_launch",
+    "Launch an app by package name. Without `activity` the default LAUNCHER activity is used.",
+    {
+      package_name: V.shortText.describe("Application id, e.g. com.acme.app"),
+      activity: V.shortText.optional().describe("Activity name, e.g. .MainActivity"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        await rpcCall("emulator:launch", {
+          ...target(args),
+          packageName: args.package_name,
+          activity: args.activity
+        });
+        return ok(`Launched ${args.package_name}`);
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_permissions",
+    "Grant or revoke a runtime permission, or reset all runtime grants on the device.",
+    {
+      op: z8.enum(["grant", "revoke", "reset"]).describe("Operation"),
+      package_name: V.shortText.describe("Application id, e.g. com.acme.app"),
+      permission: V.shortText.optional().describe("Permission, e.g. android.permission.CAMERA (required for grant/revoke)"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        await rpcCall("emulator:permissions", {
+          ...target(args),
+          op: args.op,
+          packageName: args.package_name,
+          permission: args.permission
+        });
+        return ok(`Permission ${args.op} done`);
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_logcat",
+    "Capture a one-shot logcat dump from the device.",
+    {
+      lines: z8.number().int().min(1).max(5e3).optional().describe("Tail size (default: all)"),
+      filters: z8.array(V.shortText).max(20).optional().describe('logcat filterspec tokens, e.g. ["MyTag:D", "*:S"]'),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        return text(
+          await rpcCall("emulator:logcat", {
+            ...target(args),
+            lines: args.lines,
+            filters: args.filters
+          })
+        );
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_exec",
+    "Run an arbitrary adb shell command on the device and return its stdout.",
+    {
+      command: z8.string().min(1).max(2e3).describe('Shell command, e.g. "getprop ro.build.version.sdk"'),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        return text(
+          await rpcCall("emulator:exec", { ...target(args), command: args.command })
+        );
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_camera",
+    "iOS only. Inject a synthetic camera feed into an app and launch it. Source: placeholder (animated test pattern), webcam (host camera), or file (image/video). Calling it again hot-swaps the feed without relaunching.",
+    {
+      bundle_id: V.shortText.describe("App bundle id, e.g. com.acme.MyApp"),
+      source: z8.enum(["placeholder", "webcam", "file"]).describe("Feed source (default: placeholder)").optional(),
+      webcam_name: V.shortText.optional().describe('Host camera name when source is "webcam"'),
+      file_path: V.absolutePath.optional().describe('Image or video path when source is "file"'),
+      mirror: z8.enum(["on", "off", "auto"]).optional().describe("Preview mirroring (default: auto)"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        return text(
+          await rpcCall("emulator:camera", {
+            ...target(args),
+            bundleId: args.bundle_id,
+            source: cameraSource(args),
+            mirror: args.mirror
+          })
+        );
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_camera_switch",
+    "iOS only. Hot-swap the injected camera feed on a device where injection is already running.",
+    {
+      source: z8.enum(["placeholder", "webcam", "file"]).describe("New feed source"),
+      webcam_name: V.shortText.optional().describe('Host camera name when source is "webcam"'),
+      file_path: V.absolutePath.optional().describe('Image or video path when source is "file"'),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        return text(
+          await rpcCall("emulator:cameraSwitch", {
+            ...target(args),
+            source: cameraSource(args)
+          })
+        );
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_debug_overlay",
+    "iOS only. Toggle a CoreAnimation debug render flag \u2014 useful for spotting blended layers, offscreen rendering, or misaligned images.",
+    {
+      overlay: z8.enum(["blended", "copies", "misaligned", "offscreen", "slow-animations"]).describe("Debug flag"),
+      on: z8.boolean().describe("Enable or disable"),
+      ...TARGET_FIELDS
+    },
+    async (args) => {
+      try {
+        return text(
+          await rpcCall("emulator:debugOverlay", {
+            ...target(args),
+            overlay: args.overlay,
+            on: args.on
+          })
+        );
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_memory_warning",
+    "iOS only. Simulate a memory warning on the device to test how the app releases resources.",
+    TARGET_FIELDS,
+    async (args) => {
+      try {
+        return text(await rpcCall("emulator:memoryWarning", target(args)));
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+  server.tool(
+    "emulator_shutdown",
+    "Power off the emulator (adb emu kill). A physical device cannot be shut down this way.",
+    TARGET_FIELDS,
+    async (args) => {
+      try {
+        await rpcCall("emulator:shutdown", target(args));
+        return ok("Device shut down");
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+}
+
 // src/server.ts
 function createMcpServer(version) {
   const server = new McpServer({ name: "basegrid", version }, { capabilities: { tools: {} } });
@@ -3951,6 +4351,7 @@ function createMcpServer(version) {
   registerWorkflowTools(server);
   registerWorkspaceTools(server);
   registerAskUserQuestionTool(server);
+  registerEmulatorTools(server);
   return server;
 }
 
@@ -3963,7 +4364,7 @@ console.warn = (...args) => _origError("[mcp:warn]", ...args);
 console.error = (...args) => _origError("[mcp:error]", ...args);
 async function main() {
   configManager.init();
-  const version = true ? "0.16.2" : createRequire(import.meta.url)("../package.json").version;
+  const version = true ? "0.17.0" : createRequire(import.meta.url)("../package.json").version;
   const server = createMcpServer(version);
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basegrid_tech/mcp",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "BaseGrid MCP server — task management, git, and workflow tools for AI coding agents",
   "type": "module",
   "license": "MIT",
@@ -42,8 +42,8 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@basegrid/server": "0.16.2",
-    "@basegrid/shared": "0.16.2",
+    "@basegrid/server": "0.17.0",
+    "@basegrid/shared": "0.17.0",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "^6.0.3"