rnxsim 0.1.365 → 0.1.366

package/dist-lib/mcp.cjs

@@ -0,0 +1,673 @@
+/*! rnx v0.1.366 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  McpToolInputError: () => McpToolInputError,
+  PER_SIM_MCP_TOOL_DEFINITIONS: () => PER_SIM_MCP_TOOL_DEFINITIONS,
+  createPerSimMcpTools: () => createPerSimMcpTools,
+  parsePerformStep: () => parsePerformStep,
+  parseResetOptions: () => parseResetOptions,
+  parseScreenshotOptions: () => parseScreenshotOptions,
+  parseStateOptions: () => parseStateOptions,
+  registerPerSimMcpTools: () => registerPerSimMcpTools
+});
+module.exports = __toCommonJS(mcp_exports);
+var McpToolInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "McpToolInputError";
+  }
+};
+function strictObject(properties, required = []) {
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+}
+function stepSchema(type, properties = {}, required = []) {
+  return strictObject(
+    {
+      type: { type: "string", const: type },
+      ...properties
+    },
+    ["type", ...required]
+  );
+}
+var coordinateSchema = { type: "number" };
+var pointerIdSchema = { type: "integer", minimum: 0 };
+var millisecondsSchema = { type: "integer", minimum: 0 };
+var nonEmptyStringSchema = { type: "string", minLength: 1 };
+var performStepSchema = {
+  oneOf: [
+    stepSchema(
+      "touchDown",
+      { x: coordinateSchema, y: coordinateSchema, pointerId: pointerIdSchema },
+      ["x", "y"]
+    ),
+    stepSchema(
+      "touchMove",
+      { x: coordinateSchema, y: coordinateSchema, pointerId: pointerIdSchema },
+      ["x", "y"]
+    ),
+    stepSchema(
+      "touchUp",
+      { x: coordinateSchema, y: coordinateSchema, pointerId: pointerIdSchema },
+      ["x", "y"]
+    ),
+    stepSchema("touchCancel", { pointerId: pointerIdSchema }),
+    stepSchema("tap", { x: coordinateSchema, y: coordinateSchema }, ["x", "y"]),
+    stepSchema("tapId", { id: nonEmptyStringSchema }, ["id"]),
+    stepSchema("tapText", { text: nonEmptyStringSchema }, ["text"]),
+    stepSchema(
+      "doubleTap",
+      { x: coordinateSchema, y: coordinateSchema, gapMs: millisecondsSchema },
+      ["x", "y"]
+    ),
+    stepSchema(
+      "longPress",
+      {
+        x: coordinateSchema,
+        y: coordinateSchema,
+        durationMs: millisecondsSchema
+      },
+      ["x", "y"]
+    ),
+    stepSchema(
+      "drag",
+      {
+        fromX: coordinateSchema,
+        fromY: coordinateSchema,
+        toX: coordinateSchema,
+        toY: coordinateSchema,
+        steps: { type: "integer", minimum: 1 },
+        stepMs: millisecondsSchema
+      },
+      ["fromX", "fromY", "toX", "toY"]
+    ),
+    stepSchema(
+      "pinch",
+      {
+        fromX1: coordinateSchema,
+        fromY1: coordinateSchema,
+        fromX2: coordinateSchema,
+        fromY2: coordinateSchema,
+        toX1: coordinateSchema,
+        toY1: coordinateSchema,
+        toX2: coordinateSchema,
+        toY2: coordinateSchema,
+        steps: { type: "integer", minimum: 1 },
+        stepMs: millisecondsSchema
+      },
+      ["fromX1", "fromY1", "fromX2", "fromY2", "toX1", "toY1", "toX2", "toY2"]
+    ),
+    stepSchema(
+      "scroll",
+      {
+        id: nonEmptyStringSchema,
+        x: coordinateSchema,
+        y: coordinateSchema,
+        animated: { type: "boolean" }
+      },
+      ["id"]
+    ),
+    stepSchema("type", { text: { type: "string" } }, ["text"]),
+    stepSchema("key", { key: nonEmptyStringSchema }, ["key"]),
+    stepSchema("dismissKeyboard"),
+    stepSchema("wait", { ms: millisecondsSchema }, ["ms"]),
+    stepSchema(
+      "waitFor",
+      { testID: nonEmptyStringSchema, timeoutMs: millisecondsSchema },
+      ["testID"]
+    ),
+    stepSchema("waitFor", { id: nonEmptyStringSchema, timeoutMs: millisecondsSchema }, [
+      "id"
+    ])
+  ]
+};
+var PER_SIM_MCP_TOOL_DEFINITIONS = {
+  state: {
+    name: "state",
+    description: "Capture the current app screenshot and UI tree in one call, with optional route, error, depth, and layer controls.",
+    inputSchema: strictObject({
+      screenshot: {
+        type: "boolean",
+        default: true,
+        description: "include the composed PNG screenshot"
+      },
+      tree: {
+        type: "boolean",
+        default: true,
+        description: "include the current UI tree"
+      },
+      route: { type: "boolean", description: "include route and navigation state" },
+      errors: { type: "boolean", description: "include recent runtime errors" },
+      depth: { type: "integer", minimum: 0, description: "maximum tree depth" },
+      layers: {
+        type: "string",
+        enum: ["full", "tenant", "shell"],
+        description: "screenshot layers to compose"
+      },
+      errorLimit: {
+        type: "integer",
+        minimum: 0,
+        description: "maximum recent error entries"
+      }
+    })
+  },
+  perform: {
+    name: "perform",
+    description: "Execute an ordered interaction batch inside the current app so gesture timing does not depend on MCP round trips.",
+    inputSchema: strictObject(
+      {
+        steps: { type: "array", items: performStepSchema, minItems: 1 },
+        stopOnError: {
+          type: "boolean",
+          description: "stop before starting the next step after a failure"
+        },
+        timeoutMs: {
+          type: "integer",
+          minimum: 1,
+          description: "batch progress deadline checked between steps"
+        }
+      },
+      ["steps"]
+    )
+  },
+  reset: {
+    name: "reset",
+    description: "Clear data or full simulated install state for the current app and optionally relaunch it.",
+    inputSchema: strictObject({
+      strategy: {
+        type: "string",
+        enum: ["data", "full"],
+        default: "data",
+        description: "data clears app storage; full also clears install-scoped state"
+      },
+      relaunch: {
+        type: "boolean",
+        default: true,
+        description: "relaunch the app after clearing state"
+      }
+    })
+  },
+  screenshot: {
+    name: "screenshot",
+    description: "Capture a PNG screenshot of the current app.",
+    inputSchema: strictObject({
+      layers: {
+        type: "string",
+        enum: ["full", "tenant", "shell"],
+        description: "screenshot layers to compose"
+      },
+      crop: strictObject(
+        {
+          x: coordinateSchema,
+          y: coordinateSchema,
+          w: { type: "number", minimum: 0 },
+          h: { type: "number", minimum: 0 }
+        },
+        ["x", "y", "w", "h"]
+      )
+    })
+  },
+  logs: {
+    name: "logs",
+    description: "Read filtered app console logs and the recent merged runtime error buffer from the current app.",
+    inputSchema: strictObject({
+      limit: {
+        type: "integer",
+        minimum: 1,
+        default: 50,
+        description: "maximum filtered log entries"
+      },
+      levels: {
+        type: "array",
+        items: { type: "string", enum: ["log", "info", "warn", "error", "debug"] },
+        minItems: 1,
+        uniqueItems: true,
+        description: "console levels to include"
+      },
+      filter: {
+        type: "string",
+        minLength: 1,
+        description: "case-insensitive message substring"
+      },
+      includeInternal: {
+        type: "boolean",
+        default: false,
+        description: "include RNX engine-internal log entries"
+      },
+      errorLimit: {
+        type: "integer",
+        minimum: 1,
+        default: 20,
+        description: "maximum merged runtime error entries"
+      }
+    })
+  }
+};
+var PER_SIM_MCP_TOOL_ORDER = [
+  "state",
+  "perform",
+  "reset",
+  "screenshot",
+  "logs"
+];
+function validationFailure(path, expectation) {
+  throw new McpToolInputError(`${path} ${expectation}`);
+}
+function validateMcpInput(value, schema, path) {
+  if (schema.oneOf) {
+    let matches = 0;
+    for (const candidate of schema.oneOf) {
+      try {
+        validateMcpInput(value, candidate, path);
+        matches++;
+      } catch (error) {
+        if (!(error instanceof McpToolInputError)) throw error;
+      }
+    }
+    if (matches !== 1) validationFailure(path, "must match exactly one allowed shape");
+    return;
+  }
+  if (schema.const !== void 0 && value !== schema.const) {
+    validationFailure(path, `must equal ${JSON.stringify(schema.const)}`);
+  }
+  if (schema.enum && !schema.enum.some((candidate) => candidate === value)) {
+    validationFailure(path, `must be one of ${schema.enum.join(", ")}`);
+  }
+  if (schema.type === "object") {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      validationFailure(path, "must be an object");
+    }
+    const properties = schema.properties ?? {};
+    for (const required of schema.required ?? []) {
+      if (!Object.prototype.hasOwnProperty.call(value, required)) {
+        validationFailure(`${path}.${required}`, "is required");
+      }
+    }
+    for (const [key, child] of Object.entries(value)) {
+      const propertySchema = properties[key];
+      if (!propertySchema) {
+        if (schema.additionalProperties === false) {
+          validationFailure(`${path}.${key}`, "is not allowed");
+        }
+        continue;
+      }
+      validateMcpInput(child, propertySchema, `${path}.${key}`);
+    }
+    return;
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(value)) validationFailure(path, "must be an array");
+    if (schema.minItems !== void 0 && value.length < schema.minItems) {
+      validationFailure(path, `must contain at least ${schema.minItems} item(s)`);
+    }
+    if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+      validationFailure(path, `must contain at most ${schema.maxItems} item(s)`);
+    }
+    if (schema.uniqueItems && new Set(value.map((entry) => JSON.stringify(entry))).size !== value.length) {
+      validationFailure(path, "must contain unique items");
+    }
+    const itemSchema = schema.items;
+    if (itemSchema) {
+      value.forEach(
+        (entry, index) => validateMcpInput(entry, itemSchema, `${path}[${index}]`)
+      );
+    }
+    return;
+  }
+  if (schema.type === "string") {
+    if (typeof value !== "string") validationFailure(path, "must be a string");
+    if (schema.minLength !== void 0 && value.length < schema.minLength) {
+      validationFailure(path, `must contain at least ${schema.minLength} character(s)`);
+    }
+    return;
+  }
+  if (schema.type === "number" || schema.type === "integer") {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      validationFailure(path, "must be a finite number");
+    }
+    if (schema.type === "integer" && !Number.isInteger(value)) {
+      validationFailure(path, "must be an integer");
+    }
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      validationFailure(path, `must be at least ${schema.minimum}`);
+    }
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      validationFailure(path, `must be at most ${schema.maximum}`);
+    }
+    return;
+  }
+  if (schema.type === "boolean" && typeof value !== "boolean") {
+    validationFailure(path, "must be a boolean");
+  }
+}
+function isRecordValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function recordValue(value, path) {
+  if (!isRecordValue(value)) {
+    validationFailure(path, "must be an object");
+  }
+  return value;
+}
+function stringValue(value, path) {
+  if (typeof value !== "string") validationFailure(path, "must be a string");
+  return value;
+}
+function numberValue(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    validationFailure(path, "must be a finite number");
+  }
+  return value;
+}
+function booleanValue(value, path) {
+  if (typeof value !== "boolean") validationFailure(path, "must be a boolean");
+  return value;
+}
+function optionalNumber(record, key, path) {
+  return record[key] === void 0 ? void 0 : numberValue(record[key], `${path}.${key}`);
+}
+function optionalBoolean(record, key, path) {
+  return record[key] === void 0 ? void 0 : booleanValue(record[key], `${path}.${key}`);
+}
+function parsePerformStep(value, index) {
+  const path = `perform.steps[${index}]`;
+  const step = recordValue(value, path);
+  const type = stringValue(step.type, `${path}.type`);
+  switch (type) {
+    case "touchDown":
+    case "touchMove":
+    case "touchUp": {
+      const pointerId = optionalNumber(step, "pointerId", path);
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...pointerId === void 0 ? {} : { pointerId }
+      };
+    }
+    case "touchCancel": {
+      const pointerId = optionalNumber(step, "pointerId", path);
+      return { type, ...pointerId === void 0 ? {} : { pointerId } };
+    }
+    case "tap":
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`)
+      };
+    case "tapId":
+      return { type, id: stringValue(step.id, `${path}.id`) };
+    case "tapText":
+      return { type, text: stringValue(step.text, `${path}.text`) };
+    case "doubleTap": {
+      const gapMs = optionalNumber(step, "gapMs", path);
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...gapMs === void 0 ? {} : { gapMs }
+      };
+    }
+    case "longPress": {
+      const durationMs = optionalNumber(step, "durationMs", path);
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...durationMs === void 0 ? {} : { durationMs }
+      };
+    }
+    case "drag": {
+      const steps = optionalNumber(step, "steps", path);
+      const stepMs = optionalNumber(step, "stepMs", path);
+      return {
+        type,
+        fromX: numberValue(step.fromX, `${path}.fromX`),
+        fromY: numberValue(step.fromY, `${path}.fromY`),
+        toX: numberValue(step.toX, `${path}.toX`),
+        toY: numberValue(step.toY, `${path}.toY`),
+        ...steps === void 0 ? {} : { steps },
+        ...stepMs === void 0 ? {} : { stepMs }
+      };
+    }
+    case "pinch": {
+      const steps = optionalNumber(step, "steps", path);
+      const stepMs = optionalNumber(step, "stepMs", path);
+      return {
+        type,
+        fromX1: numberValue(step.fromX1, `${path}.fromX1`),
+        fromY1: numberValue(step.fromY1, `${path}.fromY1`),
+        fromX2: numberValue(step.fromX2, `${path}.fromX2`),
+        fromY2: numberValue(step.fromY2, `${path}.fromY2`),
+        toX1: numberValue(step.toX1, `${path}.toX1`),
+        toY1: numberValue(step.toY1, `${path}.toY1`),
+        toX2: numberValue(step.toX2, `${path}.toX2`),
+        toY2: numberValue(step.toY2, `${path}.toY2`),
+        ...steps === void 0 ? {} : { steps },
+        ...stepMs === void 0 ? {} : { stepMs }
+      };
+    }
+    case "scroll": {
+      const x = optionalNumber(step, "x", path);
+      const y = optionalNumber(step, "y", path);
+      const animated = optionalBoolean(step, "animated", path);
+      return {
+        type,
+        id: stringValue(step.id, `${path}.id`),
+        ...x === void 0 ? {} : { x },
+        ...y === void 0 ? {} : { y },
+        ...animated === void 0 ? {} : { animated }
+      };
+    }
+    case "type":
+      return { type, text: stringValue(step.text, `${path}.text`) };
+    case "key":
+      return { type, key: stringValue(step.key, `${path}.key`) };
+    case "dismissKeyboard":
+      return { type };
+    case "wait":
+      return { type, ms: numberValue(step.ms, `${path}.ms`) };
+    case "waitFor": {
+      const timeoutMs = optionalNumber(step, "timeoutMs", path);
+      const selector = step.testID === void 0 ? { id: stringValue(step.id, `${path}.id`) } : { testID: stringValue(step.testID, `${path}.testID`) };
+      return {
+        type,
+        ...selector,
+        ...timeoutMs === void 0 ? {} : { timeoutMs }
+      };
+    }
+    default:
+      return validationFailure(`${path}.type`, "is not a supported perform step");
+  }
+}
+function parseStateOptions(value) {
+  const input = recordValue(value, "state");
+  const route = optionalBoolean(input, "route", "state");
+  const errors = optionalBoolean(input, "errors", "state");
+  const depth = optionalNumber(input, "depth", "state");
+  const errorLimit = optionalNumber(input, "errorLimit", "state");
+  const layers = input.layers === void 0 ? void 0 : stringValue(input.layers, "state.layers");
+  if (layers !== void 0 && layers !== "full" && layers !== "tenant" && layers !== "shell") {
+    return validationFailure("state.layers", "must be full, tenant, or shell");
+  }
+  return {
+    screenshot: optionalBoolean(input, "screenshot", "state") ?? true,
+    tree: optionalBoolean(input, "tree", "state") ?? true,
+    ...route === void 0 ? {} : { route },
+    ...errors === void 0 ? {} : { errors },
+    ...depth === void 0 ? {} : { depth },
+    ...layers === void 0 ? {} : { layers },
+    ...errorLimit === void 0 ? {} : { errorLimit }
+  };
+}
+function parsePerformInput(value) {
+  const input = recordValue(value, "perform");
+  if (!Array.isArray(input.steps)) validationFailure("perform.steps", "must be an array");
+  const stopOnError = optionalBoolean(input, "stopOnError", "perform");
+  const timeoutMs = optionalNumber(input, "timeoutMs", "perform");
+  const hasOptions = stopOnError !== void 0 || timeoutMs !== void 0;
+  return {
+    steps: input.steps.map(parsePerformStep),
+    ...hasOptions ? {
+      options: {
+        ...stopOnError === void 0 ? {} : { stopOnError },
+        ...timeoutMs === void 0 ? {} : { timeoutMs }
+      }
+    } : {}
+  };
+}
+function parseLogLevel(value, path) {
+  const level = stringValue(value, path);
+  if (level !== "log" && level !== "info" && level !== "warn" && level !== "error" && level !== "debug") {
+    return validationFailure(path, "must be log, info, warn, error, or debug");
+  }
+  return level;
+}
+function parseLogsInput(value) {
+  const input = recordValue(value, "logs");
+  const levels = input.levels;
+  if (levels !== void 0 && !Array.isArray(levels)) {
+    validationFailure("logs.levels", "must be an array");
+  }
+  const levelSet = levels ? new Set(levels.map((level, index) => parseLogLevel(level, `logs.levels[${index}]`))) : null;
+  const filter = input.filter === void 0 ? null : stringValue(input.filter, "logs.filter");
+  return {
+    filterOptions: {
+      level: levelSet,
+      filter,
+      showInternal: optionalBoolean(input, "includeInternal", "logs") ?? false
+    },
+    limit: optionalNumber(input, "limit", "logs") ?? 50,
+    errorLimit: optionalNumber(input, "errorLimit", "logs") ?? 20
+  };
+}
+function parseResetOptions(value) {
+  const input = recordValue(value, "reset");
+  const strategy = input.strategy === void 0 ? "data" : stringValue(input.strategy, "reset.strategy");
+  if (strategy !== "data" && strategy !== "full") {
+    return validationFailure("reset.strategy", "must be data or full");
+  }
+  return {
+    strategy,
+    relaunch: optionalBoolean(input, "relaunch", "reset") ?? true
+  };
+}
+function parseScreenshotOptions(value) {
+  const input = recordValue(value, "screenshot");
+  const layers = input.layers === void 0 ? void 0 : stringValue(input.layers, "screenshot.layers");
+  if (layers !== void 0 && layers !== "full" && layers !== "tenant" && layers !== "shell") {
+    return validationFailure("screenshot.layers", "must be full, tenant, or shell");
+  }
+  const crop = input.crop === void 0 ? void 0 : recordValue(input.crop, "screenshot.crop");
+  return {
+    ...layers === void 0 ? {} : { layers },
+    ...crop === void 0 ? {} : {
+      crop: {
+        x: numberValue(crop.x, "screenshot.crop.x"),
+        y: numberValue(crop.y, "screenshot.crop.y"),
+        w: numberValue(crop.w, "screenshot.crop.w"),
+        h: numberValue(crop.h, "screenshot.crop.h")
+      }
+    }
+  };
+}
+function stableJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new Error("MCP result contains a non-finite number");
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(stableJsonValue);
+  if (typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = stableJsonValue(Reflect.get(value, key));
+    }
+    return sorted;
+  }
+  throw new Error(`MCP result contains unsupported ${typeof value} value`);
+}
+function textResult(value) {
+  const text = JSON.stringify(stableJsonValue(value));
+  if (text === void 0) throw new Error("MCP result did not serialize to JSON");
+  return { content: [{ type: "text", text }] };
+}
+function createPerSimMcpHandlers(sim) {
+  return {
+    state: async (input) => sim.state(parseStateOptions(input)),
+    perform: async (input) => {
+      const parsed = parsePerformInput(input);
+      return sim.perform(parsed.steps, parsed.options);
+    },
+    reset: async (input) => sim.reset(parseResetOptions(input)),
+    screenshot: async (input) => {
+      const result = await sim.screenshot(parseScreenshotOptions(input));
+      return { dataUrl: result.dataUrl };
+    },
+    logs: async (input) => {
+      const parsed = parseLogsInput(input);
+      const [logs, recentErrors] = await Promise.all([
+        sim.logs(parsed.filterOptions),
+        sim.errors(parsed.errorLimit)
+      ]);
+      return { logs: logs.slice(-parsed.limit), recentErrors };
+    }
+  };
+}
+function createPerSimMcpTools(sim) {
+  const handlers = createPerSimMcpHandlers(sim);
+  return PER_SIM_MCP_TOOL_ORDER.map((name) => {
+    const definition = PER_SIM_MCP_TOOL_DEFINITIONS[name];
+    return {
+      ...definition,
+      async execute(input) {
+        validateMcpInput(input, definition.inputSchema, name);
+        return textResult(await handlers[name](input));
+      }
+    };
+  });
+}
+function registerPerSimMcpTools(server, sim) {
+  const tools = createPerSimMcpTools(sim);
+  for (const tool of tools) server.registerTool(tool);
+  return tools;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  McpToolInputError,
+  PER_SIM_MCP_TOOL_DEFINITIONS,
+  createPerSimMcpTools,
+  parsePerformStep,
+  parseResetOptions,
+  parseScreenshotOptions,
+  parseStateOptions,
+  registerPerSimMcpTools
+});