farai 0.3.4 → 0.3.6

package/dist/cli/index.js

@@ -8784,8 +8784,8 @@ var init_process_output = __esm(() => {
 
 // src/version.ts
 function resolveFaraiVersion() {
-  if ("0.3.4")
-    return "0.3.4";
+  if ("0.3.6")
+    return "0.3.6";
   try {
     const parsed = JSON.parse(readBoundedFileTextSync(new URL("../package.json", import.meta.url), 1024 * 1024, "package metadata"));
     if (typeof parsed.version === "string" && parsed.version)
@@ -28681,6 +28681,2019 @@ var init_email = __esm(() => {
   emailTools = [emailListTool, emailCreateTool, emailInboxTool, emailReadTool, emailWaitTool];
 });
 
+// src/agent-tools/android/shared.ts
+function shellQuote7(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function adbUnavailable(result) {
+  return result.exitCode === 127 || /adb: not found|command not found/i.test(result.stderr);
+}
+function compactError2(value) {
+  const compact = value.replace(/\s+/g, " ").trim();
+  return compact.slice(0, 400) || "adb command produced no error output";
+}
+async function runAdb(context, argline, timeoutMs, maxBytes = 2000000) {
+  return backend(context).exec(argline, timeoutMs, context.signal, maxBytes);
+}
+function adbEnvPrefix() {
+  const parts = ADB_SERVER_ENV.filter((name) => (process.env[name] ?? "").trim()).map((name) => `${name}=${shellQuote7(process.env[name].trim())}`);
+  return parts.length ? `${parts.join(" ")} ` : "";
+}
+function adbBase() {
+  return `${adbEnvPrefix()}adb`;
+}
+function adbPrefix(serial) {
+  const trimmed = serial?.trim();
+  return trimmed ? `${adbBase()} -s ${shellQuote7(trimmed)}` : adbBase();
+}
+function parseDevices(stdout) {
+  const devices = [];
+  for (const line of stdout.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || /^List of devices/i.test(trimmed))
+      continue;
+    const [serial, state, ...rest] = trimmed.split(/\s+/);
+    if (!serial || !state)
+      continue;
+    const meta = rest.join(" ");
+    const model = /\bmodel:(\S+)/.exec(meta)?.[1];
+    const product = /\bproduct:(\S+)/.exec(meta)?.[1];
+    devices.push({
+      serial,
+      state,
+      ...model ? {
+        model
+      } : {},
+      ...product ? {
+        product
+      } : {}
+    });
+  }
+  return devices;
+}
+async function resolveDevice(context, serial, timeoutMs = 15000) {
+  const provided = serial?.trim();
+  if (provided)
+    return provided;
+  const result = await runAdb(context, `${adbBase()} devices -l`, timeoutMs);
+  if (adbUnavailable(result))
+    throw new Error("adb is not available in the container");
+  const online = parseDevices(result.stdout).filter((device) => device.state === "device");
+  if (online.length === 0)
+    throw new Error("no android device is connected; use android_connect to attach one over tcp/ip");
+  if (online.length > 1)
+    throw new Error(`multiple devices connected (${online.map((device) => device.serial).join(", ")}); pass the serial argument`);
+  return online[0].serial;
+}
+var ADB_SERVER_ENV;
+var init_shared4 = __esm(() => {
+  init_backend();
+  ADB_SERVER_ENV = ["ADB_SERVER_SOCKET", "ANDROID_ADB_SERVER_ADDRESS", "ANDROID_ADB_SERVER_PORT"];
+});
+
+// src/agent-tools/android/device.ts
+var SERIAL_PROP, androidConnectTool, androidDevicesTool, androidShellTool, androidPackagesTool, androidDeviceInfoTool, androidLogcatTool;
+var init_device = __esm(() => {
+  init_renderers();
+  init_shared4();
+  SERIAL_PROP = {
+    type: "string",
+    description: "device serial from android_devices; omit when exactly one device is connected"
+  };
+  androidConnectTool = {
+    name: "android_connect",
+    description: "Attach an android device over adb tcp/ip. Use this first when the device is reachable by wireless debugging, an emulator, or a remote host, since usb passthrough is unavailable inside the container. Provide host:port (default port 5555).",
+    inputSchema: {
+      type: "object",
+      required: ["address"],
+      properties: {
+        address: {
+          type: "string",
+          description: "device address as host or host:port; port defaults to 5555 when omitted"
+        }
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 30000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const raw = asString(args.address, "address").trim();
+      const address = /:\d+$/.test(raw) ? raw : `${raw}:5555`;
+      const result = await runAdb(context, `${adbBase()} connect ${shellQuote7(address)}`, 30000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const text2 = `${result.stdout}${result.stderr}`.trim();
+      const ok = /connected to/i.test(text2) && !/cannot|failed|unable|refused/i.test(text2);
+      return {
+        ok,
+        summary: ok ? `connected to ${address}` : `could not connect to ${address}`,
+        output: text2 || `no output; exit ${result.exitCode}`,
+        metadata: {
+          address,
+          connected: ok
+        }
+      };
+    }
+  };
+  androidDevicesTool = {
+    name: "android_devices",
+    description: "List android devices adb can currently see, with serial, connection state, and model. Use this to pick a serial before other android tools, or to confirm android_connect worked.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 15000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const result = await runAdb(context, `${adbBase()} devices -l`, 15000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const devices = parseDevices(result.stdout);
+      const online = devices.filter((device) => device.state === "device");
+      const output = devices.length ? devices.map((device) => `${device.serial}	${device.state}${device.model ? `	model:${device.model}` : ""}`).join(`
+`) : "no devices";
+      return {
+        ok: true,
+        summary: `${devices.length} device(s), ${online.length} online`,
+        output,
+        metadata: {
+          devices
+        }
+      };
+    }
+  };
+  androidShellTool = {
+    name: "android_shell",
+    description: "Run one shell command on the android device via adb shell. Use purpose-built android tools when they model the task; use this for arbitrary on-device commands, dumpsys, pm, or content queries.",
+    inputSchema: {
+      type: "object",
+      required: ["command"],
+      properties: {
+        command: {
+          type: "string",
+          description: "complete shell command to run inside adb shell on the device"
+        },
+        serial: SERIAL_PROP
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 60000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const command = asString(args.command, "command");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const result = await runAdb(context, `${adbPrefix(serial)} shell ${shellQuote7(command)}`, 60000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const output = `${result.stdout}${result.stderr ? `
+${result.stderr}` : ""}`.trim();
+      return {
+        ok: result.exitCode === 0,
+        summary: result.exitCode === 0 ? `ran on ${serial}` : `command exited ${result.exitCode} on ${serial}`,
+        output: output || "(no output)",
+        metadata: {
+          serial,
+          exitCode: result.exitCode
+        }
+      };
+    }
+  };
+  androidPackagesTool = {
+    name: "android_packages",
+    description: "List installed packages on the device. Use thirdPartyOnly to focus on user-installed apps, and filter to narrow by substring.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filter: {
+          type: "string",
+          description: "case-insensitive substring to match against package names"
+        },
+        thirdPartyOnly: {
+          type: "boolean",
+          description: "list only user-installed apps (pm list packages -3) when true"
+        },
+        serial: SERIAL_PROP
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 30000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const thirdParty = args.thirdPartyOnly === true;
+      const result = await runAdb(context, `${adbPrefix(serial)} shell pm list packages${thirdParty ? " -3" : ""}`, 30000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const filter = typeof args.filter === "string" ? args.filter.trim().toLowerCase() : "";
+      let packages = result.stdout.split(`
+`).map((line) => line.replace(/^package:/, "").trim()).filter(Boolean);
+      if (filter)
+        packages = packages.filter((name) => name.toLowerCase().includes(filter));
+      packages.sort();
+      return {
+        ok: result.exitCode === 0,
+        summary: `${packages.length} package(s)${thirdParty ? " (third-party)" : ""}${filter ? ` matching "${filter}"` : ""}`,
+        output: packages.length ? packages.join(`
+`) : "no packages matched",
+        metadata: {
+          serial,
+          count: packages.length,
+          packages: packages.slice(0, 1000)
+        }
+      };
+    }
+  };
+  androidDeviceInfoTool = {
+    name: "android_device_info",
+    description: "Summarize the target device in one call: android version, sdk, model, cpu abi, and root/su availability. Use this early to shape the methodology for the device.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serial: SERIAL_PROP
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 30000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const props = ["ro.build.version.release", "ro.build.version.sdk", "ro.product.model", "ro.product.manufacturer", "ro.product.cpu.abi", "ro.build.type"];
+      const command = `${adbPrefix(serial)} shell ${shellQuote7(`for p in ${props.join(" ")}; do echo "$p=$(getprop $p)"; done; echo su=$(command -v su || echo none)`)}`;
+      const result = await runAdb(context, command, 30000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const info = {};
+      for (const line of result.stdout.split(`
+`)) {
+        const eq = line.indexOf("=");
+        if (eq > 0)
+          info[line.slice(0, eq).trim()] = line.slice(eq + 1).trim();
+      }
+      return {
+        ok: result.exitCode === 0,
+        summary: `${info["ro.product.manufacturer"] ?? "?"} ${info["ro.product.model"] ?? serial}, android ${info["ro.build.version.release"] ?? "?"} (sdk ${info["ro.build.version.sdk"] ?? "?"})`,
+        output: Object.entries(info).map(([key, value]) => `${key}: ${value}`).join(`
+`) || result.stdout,
+        metadata: {
+          serial,
+          info
+        }
+      };
+    }
+  };
+  androidLogcatTool = {
+    name: "android_logcat",
+    description: "Capture recent logcat output from the device, optionally filtered by tag. Use this to spot leaked tokens, stack traces, and app behavior after an action; it dumps the current buffer and returns.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tag: {
+          type: "string",
+          description: "logcat tag filter; only lines from this tag are returned"
+        },
+        lines: {
+          type: "integer",
+          minimum: 1,
+          maximum: 5000,
+          description: "maximum trailing lines to return (default 200)"
+        },
+        serial: SERIAL_PROP
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 30000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const lines = typeof args.lines === "number" && Number.isInteger(args.lines) ? Math.max(1, Math.min(5000, args.lines)) : 200;
+      const tag = typeof args.tag === "string" && args.tag.trim() ? args.tag.trim() : "";
+      const filter = tag ? ` -s ${shellQuote7(tag)}` : "";
+      const result = await runAdb(context, `${adbPrefix(serial)} logcat -d -t ${lines}${filter}`, 30000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const output = result.stdout.trim();
+      return {
+        ok: result.exitCode === 0,
+        summary: `${output.split(`
+`).filter(Boolean).length} logcat line(s)${tag ? ` for tag ${tag}` : ""}`,
+        output: output || "(empty logcat buffer)",
+        metadata: {
+          serial,
+          tag: tag || null
+        }
+      };
+    }
+  };
+});
+
+// src/agent-tools/android/app.ts
+function sanitizePackage(value) {
+  const clean = value.trim();
+  if (!/^[a-zA-Z][a-zA-Z0-9_.]*$/.test(clean))
+    throw new Error("package must be a valid android package name");
+  return clean;
+}
+function appLifecycleTool(name, verb) {
+  return {
+    name,
+    description: verb === "start" ? "Launch an app by package name using monkey so the default launcher activity starts. Use before ui or dynamic tools that need the app running." : "Force-stop an app by package name. Use to reset app state between tests.",
+    inputSchema: {
+      type: "object",
+      required: ["package"],
+      properties: {
+        package: {
+          type: "string",
+          description: "installed package name to control"
+        },
+        serial: SERIAL_PROP2
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 30000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const pkg = sanitizePackage(asString(args.package, "package"));
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const shell = verb === "start" ? `monkey -p ${shellQuote7(pkg)} -c android.intent.category.LAUNCHER 1` : `am force-stop ${shellQuote7(pkg)}`;
+      const result = await runAdb(context, `${adbPrefix(serial)} shell ${shellQuote7(shell)}`, 30000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const output = `${result.stdout}${result.stderr ? `
+${result.stderr}` : ""}`.trim();
+      const ok = result.exitCode === 0 && !/error|no activities found/i.test(output);
+      return {
+        ok,
+        summary: ok ? `${verb === "start" ? "started" : "stopped"} ${pkg}` : `could not ${verb} ${pkg}`,
+        output: output || "(no output)",
+        metadata: {
+          serial,
+          package: pkg
+        }
+      };
+    }
+  };
+}
+var SERIAL_PROP2, androidApkPullTool, androidInstallTool, androidAppStartTool, androidAppStopTool, androidDeeplinkTool, androidPullFileTool;
+var init_app = __esm(() => {
+  init_renderers();
+  init_shared4();
+  SERIAL_PROP2 = {
+    type: "string",
+    description: "device serial from android_devices; omit when exactly one device is connected"
+  };
+  androidApkPullTool = {
+    name: "android_apk_pull",
+    description: "Pull every apk for an installed package (including split apks) from the device into the workspace for static analysis. Returns the local directory and file list.",
+    inputSchema: {
+      type: "object",
+      required: ["package"],
+      properties: {
+        package: {
+          type: "string",
+          description: "installed package name, e.g. com.example.app"
+        },
+        serial: SERIAL_PROP2
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 120000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const pkg = sanitizePackage(asString(args.package, "package"));
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const pathResult = await runAdb(context, `${adbPrefix(serial)} shell pm path ${shellQuote7(pkg)}`, 30000);
+      if (adbUnavailable(pathResult))
+        throw new Error("adb is not available in the container");
+      const remotes = pathResult.stdout.split(`
+`).map((line) => line.replace(/^package:/, "").trim()).filter(Boolean);
+      if (remotes.length === 0)
+        throw new Error(`package not found on device: ${pkg}`);
+      const destDir = `android/${pkg}`;
+      await runAdb(context, `mkdir -p ${shellQuote7(destDir)}`, 1e4);
+      const pulled = [];
+      const errors = [];
+      for (const remote of remotes) {
+        const local = `${destDir}/${remote.split("/").pop() || "base.apk"}`;
+        const result = await runAdb(context, `${adbPrefix(serial)} pull ${shellQuote7(remote)} ${shellQuote7(local)}`, 90000);
+        if (result.exitCode === 0)
+          pulled.push(local);
+        else
+          errors.push(`${remote}: ${compactError2(result.stderr || result.stdout)}`);
+      }
+      return {
+        ok: pulled.length > 0,
+        summary: pulled.length ? `pulled ${pulled.length} apk(s) for ${pkg} to ${destDir}` : `failed to pull apks for ${pkg}`,
+        output: [...pulled.map((path) => `pulled: ${path}`), ...errors.map((err) => `error: ${err}`)].join(`
+`),
+        metadata: {
+          serial,
+          package: pkg,
+          directory: destDir,
+          files: pulled
+        }
+      };
+    }
+  };
+  androidInstallTool = {
+    name: "android_install",
+    description: "Install an apk on the device with adb install -r. Use for patched or instrumentation builds; the path is a workspace-relative apk file.",
+    inputSchema: {
+      type: "object",
+      required: ["apkPath"],
+      properties: {
+        apkPath: {
+          type: "string",
+          description: "workspace-relative path to the apk file to install"
+        },
+        serial: SERIAL_PROP2
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 120000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const apkPath = asString(args.apkPath, "apkPath").trim();
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const result = await runAdb(context, `${adbPrefix(serial)} install -r ${shellQuote7(apkPath)}`, 120000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const text2 = `${result.stdout}${result.stderr}`.trim();
+      const ok = /success/i.test(text2);
+      return {
+        ok,
+        summary: ok ? `installed ${apkPath} on ${serial}` : `install failed for ${apkPath}`,
+        output: text2 || `exit ${result.exitCode}`,
+        metadata: {
+          serial,
+          apkPath,
+          installed: ok
+        }
+      };
+    }
+  };
+  androidAppStartTool = appLifecycleTool("android_app_start", "start");
+  androidAppStopTool = appLifecycleTool("android_app_stop", "stop");
+  androidDeeplinkTool = {
+    name: "android_deeplink",
+    description: "Fire a deep-link intent (VIEW) on the device to test deep-link and exported-component handling. Optionally scope it to a package to target one app.",
+    inputSchema: {
+      type: "object",
+      required: ["uri"],
+      properties: {
+        uri: {
+          type: "string",
+          description: "deep link uri to open, e.g. myapp://path?arg=1"
+        },
+        package: {
+          type: "string",
+          description: "optional package to constrain the intent to one app"
+        },
+        serial: SERIAL_PROP2
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 30000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const uri = asString(args.uri, "uri").trim();
+      const pkg = typeof args.package === "string" && args.package.trim() ? sanitizePackage(args.package) : "";
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const shell = `am start -a android.intent.action.VIEW -d ${shellQuote7(uri)}${pkg ? ` ${shellQuote7(pkg)}` : ""}`;
+      const result = await runAdb(context, `${adbPrefix(serial)} shell ${shellQuote7(shell)}`, 30000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const output = `${result.stdout}${result.stderr ? `
+${result.stderr}` : ""}`.trim();
+      const ok = result.exitCode === 0 && !/error|exception/i.test(output);
+      return {
+        ok,
+        summary: ok ? `fired deep link ${uri}` : `deep link may have failed: ${uri}`,
+        output: output || "(no output)",
+        metadata: {
+          serial,
+          uri,
+          package: pkg || null
+        }
+      };
+    }
+  };
+  androidPullFileTool = {
+    name: "android_pull_file",
+    description: "Read a file from the device. When package is given, uses run-as <package> to reach app-private files (requires a debuggable app). Returns bounded file contents.",
+    inputSchema: {
+      type: "object",
+      required: ["path"],
+      properties: {
+        path: {
+          type: "string",
+          description: "absolute device path to read, e.g. /data/data/pkg/shared_prefs/x.xml"
+        },
+        package: {
+          type: "string",
+          description: "package to read app-private files via run-as; omit for world-readable paths"
+        },
+        serial: SERIAL_PROP2
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 30000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const path = asString(args.path, "path").trim();
+      const pkg = typeof args.package === "string" && args.package.trim() ? sanitizePackage(args.package) : "";
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const shell = pkg ? `run-as ${shellQuote7(pkg)} cat ${shellQuote7(path)}` : `cat ${shellQuote7(path)}`;
+      const result = await runAdb(context, `${adbPrefix(serial)} shell ${shellQuote7(shell)}`, 30000, 4000000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const ok = result.exitCode === 0 && !/no such file|permission denied|not debuggable|run-as:/i.test(result.stderr);
+      return {
+        ok,
+        summary: ok ? `read ${path}` : `could not read ${path}`,
+        output: ok ? result.stdout : `${result.stdout}${result.stderr}`.trim() || "(no output)",
+        metadata: {
+          serial,
+          path,
+          package: pkg || null
+        }
+      };
+    }
+  };
+});
+
+// src/agent-tools/android/static.ts
+function quoteDir(value) {
+  const clean = value.trim();
+  if (!clean || clean.includes(".."))
+    throw new Error("directory must be a workspace-relative path without ..");
+  return clean;
+}
+async function readManifest(context, dir) {
+  const result = await backend(context).exec(`cat ${shellQuote7(`${dir}/AndroidManifest.xml`)}`, 20000, context.signal, 4000000);
+  if (result.exitCode !== 0)
+    throw new Error(`could not read AndroidManifest.xml in ${dir}; decompile with android_decompile first`);
+  return result.stdout;
+}
+var DANGEROUS_PERMISSIONS, SECRET_PATTERN, androidDecompileTool, androidManifestTool, androidPermissionsTool, androidExportedComponentsTool, androidScanSecretsTool, androidGrepApkTool;
+var init_static = __esm(() => {
+  init_backend();
+  init_renderers();
+  init_shared4();
+  DANGEROUS_PERMISSIONS = new Set(["android.permission.READ_SMS", "android.permission.SEND_SMS", "android.permission.RECEIVE_SMS", "android.permission.READ_CONTACTS", "android.permission.WRITE_CONTACTS", "android.permission.ACCESS_FINE_LOCATION", "android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_BACKGROUND_LOCATION", "android.permission.RECORD_AUDIO", "android.permission.CAMERA", "android.permission.READ_EXTERNAL_STORAGE", "android.permission.WRITE_EXTERNAL_STORAGE", "android.permission.MANAGE_EXTERNAL_STORAGE", "android.permission.READ_PHONE_STATE", "android.permission.READ_CALL_LOG", "android.permission.WRITE_CALL_LOG", "android.permission.REQUEST_INSTALL_PACKAGES", "android.permission.SYSTEM_ALERT_WINDOW", "android.permission.QUERY_ALL_PACKAGES", "android.permission.WRITE_SETTINGS"]);
+  SECRET_PATTERN = ["AKIA[0-9A-Z]{16}", "AIza[0-9A-Za-z_-]{35}", "-----BEGIN [A-Z ]*PRIVATE KEY-----", "eyJ[A-Za-z0-9_-]{10,}\\.[A-Za-z0-9_-]{10,}\\.[A-Za-z0-9_-]{10,}", `(api[_-]?key|secret|passwd|password|token|bearer)["'\\s:=]{1,4}[A-Za-z0-9_.-]{8,}`, "https://[a-z0-9-]+\\.firebaseio\\.com"].join("|");
+  androidDecompileTool = {
+    name: "android_decompile",
+    description: "Decompile an apk with apktool into smali, decoded resources, and a readable AndroidManifest.xml. Returns the output directory to pass to the other android static tools.",
+    inputSchema: {
+      type: "object",
+      required: ["apkPath"],
+      properties: {
+        apkPath: {
+          type: "string",
+          description: "workspace-relative path to the apk to decompile"
+        }
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 240000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const apkPath = asString(args.apkPath, "apkPath").trim();
+      const base = apkPath.split("/").pop()?.replace(/\.apk$/i, "") || "app";
+      const outDir = `android/decompiled/${base}`;
+      const result = await backend(context).exec(`apktool d -f -o ${shellQuote7(outDir)} ${shellQuote7(apkPath)}`, 240000, context.signal, 2000000);
+      if (result.exitCode === 127)
+        throw new Error("apktool is not available in the container");
+      const ok = result.exitCode === 0;
+      return {
+        ok,
+        summary: ok ? `decompiled to ${outDir}` : `apktool failed on ${apkPath}`,
+        output: ok ? `output directory: ${outDir}
+${result.stdout}`.trim() : compactError2(result.stderr || result.stdout),
+        metadata: {
+          apkPath,
+          directory: outDir
+        }
+      };
+    }
+  };
+  androidManifestTool = {
+    name: "android_manifest",
+    description: "Read and summarize AndroidManifest.xml from a decompiled apk directory: package, sdk versions, debuggable/allowBackup flags, and permission and component counts.",
+    inputSchema: {
+      type: "object",
+      required: ["directory"],
+      properties: {
+        directory: {
+          type: "string",
+          description: "decompiled apk directory from android_decompile"
+        }
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 30000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const dir = quoteDir(asString(args.directory, "directory"));
+      const xml = await readManifest(context, dir);
+      const pkg = /package="([^"]+)"/.exec(xml)?.[1] ?? "unknown";
+      const debuggable = /android:debuggable="true"/.test(xml);
+      const allowBackup = !/android:allowBackup="false"/.test(xml);
+      const permissions = [...xml.matchAll(/<uses-permission[^>]*android:name="([^"]+)"/g)].map((match) => match[1]);
+      const counts = {
+        activities: (xml.match(/<activity[\s>]/g) ?? []).length,
+        services: (xml.match(/<service[\s>]/g) ?? []).length,
+        receivers: (xml.match(/<receiver[\s>]/g) ?? []).length,
+        providers: (xml.match(/<provider[\s>]/g) ?? []).length
+      };
+      const output = [`package: ${pkg}`, `debuggable: ${debuggable}`, `allowBackup: ${allowBackup}`, `permissions: ${permissions.length}`, `components: activity=${counts.activities} service=${counts.services} receiver=${counts.receivers} provider=${counts.providers}`].join(`
+`);
+      return {
+        ok: true,
+        summary: `${pkg}${debuggable ? " [debuggable]" : ""}${allowBackup ? " [allowBackup]" : ""}`,
+        output,
+        metadata: {
+          package: pkg,
+          debuggable,
+          allowBackup,
+          permissions,
+          counts
+        }
+      };
+    }
+  };
+  androidPermissionsTool = {
+    name: "android_permissions",
+    description: "List declared permissions from a decompiled apk and flag dangerous ones (sms, contacts, location, storage, install-packages, overlay, etc).",
+    inputSchema: {
+      type: "object",
+      required: ["directory"],
+      properties: {
+        directory: {
+          type: "string",
+          description: "decompiled apk directory from android_decompile"
+        }
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 30000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const dir = quoteDir(asString(args.directory, "directory"));
+      const xml = await readManifest(context, dir);
+      const permissions = [...xml.matchAll(/<uses-permission[^>]*android:name="([^"]+)"/g)].map((match) => match[1]).sort();
+      const dangerous = permissions.filter((name) => DANGEROUS_PERMISSIONS.has(name));
+      const output = permissions.length ? permissions.map((name) => `${dangerous.includes(name) ? "[!] " : "    "}${name}`).join(`
+`) : "no permissions declared";
+      return {
+        ok: true,
+        summary: `${permissions.length} permission(s), ${dangerous.length} dangerous`,
+        output,
+        metadata: {
+          permissions,
+          dangerous
+        }
+      };
+    }
+  };
+  androidExportedComponentsTool = {
+    name: "android_exported_components",
+    description: "List exported components (activity, service, receiver, provider) from a decompiled apk. Exported components are reachable by other apps and are a primary attack surface.",
+    inputSchema: {
+      type: "object",
+      required: ["directory"],
+      properties: {
+        directory: {
+          type: "string",
+          description: "decompiled apk directory from android_decompile"
+        }
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 30000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const dir = quoteDir(asString(args.directory, "directory"));
+      const xml = await readManifest(context, dir);
+      const exported = [];
+      for (const kind of ["activity", "activity-alias", "service", "receiver", "provider"]) {
+        const regex = new RegExp(`<${kind}\\b[^>]*?(?:/>|>[\\s\\S]*?</${kind}>)`, "g");
+        for (const match of xml.matchAll(regex)) {
+          const block = match[0];
+          const name = /android:name="([^"]+)"/.exec(block)?.[1] ?? "(unknown)";
+          const explicitExport = /android:exported="true"/.test(block);
+          const implicitExport = !/android:exported="false"/.test(block) && /<intent-filter/.test(block);
+          if (explicitExport || implicitExport)
+            exported.push({
+              kind,
+              name,
+              explicit: explicitExport
+            });
+        }
+      }
+      const output = exported.length ? exported.map((item) => `${item.kind}	${item.explicit ? "exported=true" : "intent-filter"}	${item.name}`).join(`
+`) : "no exported components found";
+      return {
+        ok: true,
+        summary: `${exported.length} exported component(s)`,
+        output,
+        metadata: {
+          exported
+        }
+      };
+    }
+  };
+  androidScanSecretsTool = {
+    name: "android_scan_secrets",
+    description: "Scan a decompiled apk directory for hardcoded secrets: aws/google api keys, private keys, jwts, and password/token assignments. Matches are candidate leads, not confirmed findings.",
+    inputSchema: {
+      type: "object",
+      required: ["directory"],
+      properties: {
+        directory: {
+          type: "string",
+          description: "decompiled apk directory from android_decompile"
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 1000,
+          description: "maximum matching lines to return (default 200)"
+        }
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 90000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const dir = quoteDir(asString(args.directory, "directory"));
+      const limit = typeof args.limit === "number" && Number.isInteger(args.limit) ? Math.max(1, Math.min(1000, args.limit)) : 200;
+      const command = `grep -rEIn ${shellQuote7(SECRET_PATTERN)} ${shellQuote7(dir)} 2>/dev/null | head -n ${limit}`;
+      const result = await backend(context).exec(command, 90000, context.signal, 2000000);
+      const lines = result.stdout.split(`
+`).map((line) => line.trim()).filter(Boolean);
+      return {
+        ok: true,
+        summary: lines.length ? `${lines.length} secret candidate line(s)` : "no secret candidates matched",
+        output: lines.length ? lines.join(`
+`) : "no matches",
+        metadata: {
+          directory: dir,
+          matches: lines.length,
+          truncated: lines.length >= limit
+        }
+      };
+    }
+  };
+  androidGrepApkTool = {
+    name: "android_grep_apk",
+    description: "Regex-search a decompiled apk directory (smali, resources, assets). Use for urls, class names, string constants, and crypto usage after android_decompile.",
+    inputSchema: {
+      type: "object",
+      required: ["directory", "pattern"],
+      properties: {
+        directory: {
+          type: "string",
+          description: "decompiled apk directory from android_decompile"
+        },
+        pattern: {
+          type: "string",
+          description: "extended regular expression to search for"
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 1000,
+          description: "maximum matching lines to return (default 200)"
+        }
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 90000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const dir = quoteDir(asString(args.directory, "directory"));
+      const pattern = asString(args.pattern, "pattern");
+      const limit = typeof args.limit === "number" && Number.isInteger(args.limit) ? Math.max(1, Math.min(1000, args.limit)) : 200;
+      const command = `grep -rEIn ${shellQuote7(pattern)} ${shellQuote7(dir)} 2>/dev/null | head -n ${limit}`;
+      const result = await backend(context).exec(command, 90000, context.signal, 2000000);
+      const lines = result.stdout.split(`
+`).map((line) => line.trim()).filter(Boolean);
+      return {
+        ok: true,
+        summary: lines.length ? `${lines.length} match(es) for /${pattern}/` : `no matches for /${pattern}/`,
+        output: lines.length ? lines.join(`
+`) : "no matches",
+        metadata: {
+          directory: dir,
+          pattern,
+          matches: lines.length,
+          truncated: lines.length >= limit
+        }
+      };
+    }
+  };
+});
+
+// src/agent-tools/android/ui.ts
+function parseUiNodes(xml) {
+  const nodes = [];
+  for (const match of xml.matchAll(/<node\b([^>]*)>/g)) {
+    const attrs = match[1] ?? "";
+    const bounds = /bounds="\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]"/.exec(attrs);
+    if (!bounds)
+      continue;
+    const x1 = Number(bounds[1]);
+    const y1 = Number(bounds[2]);
+    const x2 = Number(bounds[3]);
+    const y2 = Number(bounds[4]);
+    const attr = (name) => new RegExp(`\\b${name}="([^"]*)"`).exec(attrs)?.[1] ?? "";
+    nodes.push({
+      text: attr("text"),
+      resourceId: attr("resource-id"),
+      contentDesc: attr("content-desc"),
+      className: attr("class"),
+      clickable: attr("clickable") === "true",
+      bounds: [x1, y1, x2, y2],
+      center: [Math.round((x1 + x2) / 2), Math.round((y1 + y2) / 2)]
+    });
+  }
+  return nodes;
+}
+function findUiNode(nodes, selector) {
+  const wantId = selector.resourceId?.trim();
+  const wantText = selector.text?.trim();
+  const wantDesc = selector.contentDesc?.trim();
+  return nodes.find((node) => {
+    if (wantId && !(node.resourceId === wantId || node.resourceId.endsWith(`/${wantId}`)))
+      return false;
+    if (wantText && !(node.text === wantText || node.text.toLowerCase().includes(wantText.toLowerCase())))
+      return false;
+    if (wantDesc && !(node.contentDesc === wantDesc || node.contentDesc.toLowerCase().includes(wantDesc.toLowerCase())))
+      return false;
+    return Boolean(wantId || wantText || wantDesc);
+  });
+}
+async function dumpHierarchy(context, serial) {
+  const remote = "/sdcard/farai_uidump.xml";
+  const dump = await runAdb(context, `${adbPrefix(serial)} shell uiautomator dump ${remote}`, 30000);
+  if (adbUnavailable(dump))
+    throw new Error("adb is not available in the container");
+  const read = await runAdb(context, `${adbPrefix(serial)} shell cat ${remote}`, 20000, 8000000);
+  const xml = read.stdout.trim();
+  if (!xml.includes("<hierarchy") && !xml.includes("<node")) {
+    throw new Error(`could not capture ui hierarchy: ${(dump.stderr || dump.stdout || "no output").trim().slice(0, 200)}`);
+  }
+  return xml;
+}
+function describeNode(node) {
+  const label = node.text || node.contentDesc || node.resourceId || node.className;
+  const parts = [node.resourceId ? `id=${node.resourceId}` : "", node.text ? `text=${JSON.stringify(node.text)}` : "", node.contentDesc ? `desc=${JSON.stringify(node.contentDesc)}` : "", node.clickable ? "clickable" : "", `@${node.center[0]},${node.center[1]}`].filter(Boolean);
+  return `${label} \u2014 ${parts.join(" ")}`;
+}
+var SERIAL_PROP3, androidUiDumpTool, androidUiHierarchyTool, androidScreenshotTool, androidUiTapTool, androidUiTapElementTool, androidUiTypeTool, androidUiSwipeTool, KEYEVENTS, androidUiKeyTool, androidUiWindowSizeTool, androidUiWaitForTool;
+var init_ui = __esm(() => {
+  init_renderers();
+  init_shared4();
+  SERIAL_PROP3 = {
+    type: "string",
+    description: "device serial from android_devices; omit when exactly one device is connected"
+  };
+  androidUiDumpTool = {
+    name: "android_ui_dump",
+    description: "Capture the current screen's ui hierarchy via uiautomator and return interactive elements (text, resource-id, content-desc, clickable, tap center). Use this before android_ui_tap_element to see what is on screen.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        clickableOnly: {
+          type: "boolean",
+          description: "return only clickable elements when true (default true)"
+        },
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 40000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const xml = await dumpHierarchy(context, serial);
+      const all = parseUiNodes(xml);
+      const clickableOnly = args.clickableOnly !== false;
+      const shown = (clickableOnly ? all.filter((node) => node.clickable) : all).filter((node) => node.text || node.contentDesc || node.resourceId);
+      return {
+        ok: true,
+        summary: `${shown.length} element(s) of ${all.length} on screen`,
+        output: shown.length ? shown.map(describeNode).join(`
+`) : "no labeled elements found",
+        metadata: {
+          serial,
+          total: all.length,
+          elements: shown.slice(0, 200)
+        }
+      };
+    }
+  };
+  androidUiHierarchyTool = {
+    name: "android_ui_hierarchy",
+    description: "Return the full raw uiautomator xml hierarchy of the current screen. Use when android_ui_dump omits an element you need to inspect precisely.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 40000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const xml = await dumpHierarchy(context, serial);
+      return {
+        ok: true,
+        summary: `captured ui hierarchy (${xml.length} bytes)`,
+        output: xml,
+        metadata: {
+          serial
+        }
+      };
+    }
+  };
+  androidScreenshotTool = {
+    name: "android_screenshot",
+    description: "Take a screenshot of the current screen and save it as a png in the workspace. Use android's image_view tool afterwards to inspect the saved file.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 40000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const remote = "/sdcard/farai_screen.png";
+      const local = `android/screenshots/${Date.now()}.png`;
+      await runAdb(context, `mkdir -p android/screenshots`, 1e4);
+      const cap = await runAdb(context, `${adbPrefix(serial)} shell screencap -p ${remote}`, 30000);
+      if (adbUnavailable(cap))
+        throw new Error("adb is not available in the container");
+      const pull = await runAdb(context, `${adbPrefix(serial)} pull ${remote} ${shellQuote7(local)}`, 40000);
+      const ok = pull.exitCode === 0;
+      return {
+        ok,
+        summary: ok ? `saved screenshot to ${local}` : "screenshot capture failed",
+        output: ok ? local : `${pull.stderr || pull.stdout}`.trim() || "screencap failed",
+        metadata: {
+          serial,
+          path: ok ? local : null
+        }
+      };
+    }
+  };
+  androidUiTapTool = {
+    name: "android_ui_tap",
+    description: "Tap the screen at absolute pixel coordinates. Use android_ui_tap_element when you can identify the target by id or text instead.",
+    inputSchema: {
+      type: "object",
+      required: ["x", "y"],
+      properties: {
+        x: {
+          type: "integer",
+          minimum: 0,
+          description: "x pixel coordinate"
+        },
+        y: {
+          type: "integer",
+          minimum: 0,
+          description: "y pixel coordinate"
+        },
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 20000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const x = Number(args.x);
+      const y = Number(args.y);
+      if (!Number.isInteger(x) || !Number.isInteger(y))
+        throw new Error("x and y must be integers");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const result = await runAdb(context, `${adbPrefix(serial)} shell input tap ${x} ${y}`, 20000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      return {
+        ok: result.exitCode === 0,
+        summary: `tapped ${x},${y}`,
+        output: result.stdout.trim() || "tapped",
+        metadata: {
+          serial,
+          x,
+          y
+        }
+      };
+    }
+  };
+  androidUiTapElementTool = {
+    name: "android_ui_tap_element",
+    description: "Tap a ui element identified by resource-id, visible text, or content-desc. Dumps the hierarchy, resolves the element center, and taps it. Provide at least one selector.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        resourceId: {
+          type: "string",
+          description: "full or trailing resource-id, e.g. com.app:id/login or login"
+        },
+        text: {
+          type: "string",
+          description: "exact or substring visible text of the element"
+        },
+        contentDesc: {
+          type: "string",
+          description: "exact or substring content-desc of the element"
+        },
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 40000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const selector = {
+        ...typeof args.resourceId === "string" ? {
+          resourceId: args.resourceId
+        } : {},
+        ...typeof args.text === "string" ? {
+          text: args.text
+        } : {},
+        ...typeof args.contentDesc === "string" ? {
+          contentDesc: args.contentDesc
+        } : {}
+      };
+      if (!selector.resourceId && !selector.text && !selector.contentDesc)
+        throw new Error("provide at least one of resourceId, text, or contentDesc");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const xml = await dumpHierarchy(context, serial);
+      const node = findUiNode(parseUiNodes(xml), selector);
+      if (!node)
+        return {
+          ok: false,
+          summary: "no element matched the selector",
+          output: "element not found on the current screen",
+          metadata: {
+            serial,
+            selector
+          }
+        };
+      const [x, y] = node.center;
+      const result = await runAdb(context, `${adbPrefix(serial)} shell input tap ${x} ${y}`, 20000);
+      return {
+        ok: result.exitCode === 0,
+        summary: `tapped ${node.resourceId || node.text || node.contentDesc} @${x},${y}`,
+        output: describeNode(node),
+        metadata: {
+          serial,
+          x,
+          y,
+          node
+        }
+      };
+    }
+  };
+  androidUiTypeTool = {
+    name: "android_ui_type",
+    description: "Type text into the currently focused input field via adb input. Tap the field first with android_ui_tap_element to focus it.",
+    inputSchema: {
+      type: "object",
+      required: ["text"],
+      properties: {
+        text: {
+          type: "string",
+          description: "text to type into the focused field"
+        },
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 20000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const text2 = asString(args.text, "text");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const escaped = text2.replace(/(["\\$`])/g, "\\$1").replace(/ /g, "%s");
+      const result = await runAdb(context, `${adbPrefix(serial)} shell input text ${shellQuote7(escaped)}`, 20000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      return {
+        ok: result.exitCode === 0,
+        summary: `typed ${text2.length} char(s)`,
+        output: result.stdout.trim() || "typed",
+        metadata: {
+          serial
+        }
+      };
+    }
+  };
+  androidUiSwipeTool = {
+    name: "android_ui_swipe",
+    description: "Swipe from one point to another over a duration. Use for scrolling, dismissing, and gesture navigation.",
+    inputSchema: {
+      type: "object",
+      required: ["x1", "y1", "x2", "y2"],
+      properties: {
+        x1: {
+          type: "integer",
+          minimum: 0,
+          description: "start x"
+        },
+        y1: {
+          type: "integer",
+          minimum: 0,
+          description: "start y"
+        },
+        x2: {
+          type: "integer",
+          minimum: 0,
+          description: "end x"
+        },
+        y2: {
+          type: "integer",
+          minimum: 0,
+          description: "end y"
+        },
+        durationMs: {
+          type: "integer",
+          minimum: 50,
+          maximum: 1e4,
+          description: "swipe duration in ms (default 300)"
+        },
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 20000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const coords = ["x1", "y1", "x2", "y2"].map((key) => Number(args[key]));
+      if (coords.some((value) => !Number.isInteger(value)))
+        throw new Error("x1, y1, x2, y2 must be integers");
+      const duration = typeof args.durationMs === "number" && Number.isInteger(args.durationMs) ? Math.max(50, Math.min(1e4, args.durationMs)) : 300;
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const [x1, y1, x2, y2] = coords;
+      const result = await runAdb(context, `${adbPrefix(serial)} shell input swipe ${x1} ${y1} ${x2} ${y2} ${duration}`, 20000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      return {
+        ok: result.exitCode === 0,
+        summary: `swiped ${x1},${y1} -> ${x2},${y2}`,
+        output: result.stdout.trim() || "swiped",
+        metadata: {
+          serial
+        }
+      };
+    }
+  };
+  KEYEVENTS = {
+    back: 4,
+    home: 3,
+    menu: 82,
+    enter: 66,
+    tab: 61,
+    escape: 111,
+    up: 19,
+    down: 20,
+    left: 21,
+    right: 22,
+    delete: 67,
+    search: 84,
+    power: 26,
+    appswitch: 187
+  };
+  androidUiKeyTool = {
+    name: "android_ui_key",
+    description: "Send a keyevent to the device. Accepts a named key (back, home, enter, tab, up, down, delete, ...) or a raw android keycode number.",
+    inputSchema: {
+      type: "object",
+      required: ["key"],
+      properties: {
+        key: {
+          type: "string",
+          description: "named key (back, home, menu, enter, tab, up, down, left, right, delete, search, power, appswitch) or a numeric keycode"
+        },
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 20000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const key = asString(args.key, "key").trim().toLowerCase();
+      const code = KEYEVENTS[key] ?? (/^\d+$/.test(key) ? Number(key) : undefined);
+      if (code === undefined)
+        throw new Error(`unknown key "${key}"; use a named key or a numeric keycode`);
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const result = await runAdb(context, `${adbPrefix(serial)} shell input keyevent ${code}`, 20000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      return {
+        ok: result.exitCode === 0,
+        summary: `sent key ${key} (${code})`,
+        output: result.stdout.trim() || "sent",
+        metadata: {
+          serial,
+          key,
+          code
+        }
+      };
+    }
+  };
+  androidUiWindowSizeTool = {
+    name: "android_ui_window_size",
+    description: "Return the device screen resolution. Use to compute tap and swipe coordinates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 20000,
+    parallel: true,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const result = await runAdb(context, `${adbPrefix(serial)} shell wm size`, 20000);
+      if (adbUnavailable(result))
+        throw new Error("adb is not available in the container");
+      const size = /(\d+)x(\d+)/.exec(result.stdout);
+      return {
+        ok: result.exitCode === 0,
+        summary: size ? `${size[1]}x${size[2]}` : result.stdout.trim(),
+        output: result.stdout.trim() || "(no output)",
+        metadata: {
+          serial,
+          ...size ? {
+            width: Number(size[1]),
+            height: Number(size[2])
+          } : {}
+        }
+      };
+    }
+  };
+  androidUiWaitForTool = {
+    name: "android_ui_wait_for",
+    description: "Poll the ui hierarchy until an element matching a selector appears or the timeout elapses. Use after an action that triggers a screen transition.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        resourceId: {
+          type: "string",
+          description: "resource-id to wait for"
+        },
+        text: {
+          type: "string",
+          description: "visible text to wait for (substring match)"
+        },
+        contentDesc: {
+          type: "string",
+          description: "content-desc to wait for (substring match)"
+        },
+        timeoutSeconds: {
+          type: "integer",
+          minimum: 1,
+          maximum: 120,
+          description: "maximum seconds to wait (default 15)"
+        },
+        serial: SERIAL_PROP3
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 130000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const selector = {
+        ...typeof args.resourceId === "string" ? {
+          resourceId: args.resourceId
+        } : {},
+        ...typeof args.text === "string" ? {
+          text: args.text
+        } : {},
+        ...typeof args.contentDesc === "string" ? {
+          contentDesc: args.contentDesc
+        } : {}
+      };
+      if (!selector.resourceId && !selector.text && !selector.contentDesc)
+        throw new Error("provide at least one of resourceId, text, or contentDesc");
+      const timeoutSeconds = typeof args.timeoutSeconds === "number" && Number.isInteger(args.timeoutSeconds) ? Math.max(1, Math.min(120, args.timeoutSeconds)) : 15;
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const deadline = Date.now() + timeoutSeconds * 1000;
+      let attempts = 0;
+      while (Date.now() < deadline) {
+        if (context.signal?.aborted)
+          throw new Error("wait cancelled");
+        attempts += 1;
+        const node = findUiNode(parseUiNodes(await dumpHierarchy(context, serial)), selector);
+        if (node)
+          return {
+            ok: true,
+            summary: `element appeared after ${attempts} check(s)`,
+            output: describeNode(node),
+            metadata: {
+              serial,
+              node,
+              attempts
+            }
+          };
+        await new Promise((resolve9) => setTimeout(resolve9, 1000));
+      }
+      return {
+        ok: false,
+        summary: `element did not appear within ${timeoutSeconds}s`,
+        output: "timed out waiting for the element",
+        metadata: {
+          serial,
+          selector,
+          attempts
+        }
+      };
+    }
+  };
+});
+
+// src/agent-tools/android/frida.ts
+async function writeAsset(context, relPath, content) {
+  const dir = relPath.includes("/") ? relPath.slice(0, relPath.lastIndexOf("/")) : ".";
+  const b64 = Buffer.from(content, "utf8").toString("base64");
+  const command = `mkdir -p ${shellQuote7(dir)} && printf %s ${shellQuote7(b64)} | base64 -d > ${shellQuote7(relPath)}`;
+  const result = await backend(context).exec(command, 20000, context.signal);
+  if (result.exitCode !== 0)
+    throw new Error(`failed to write ${relPath}: ${compactError2(result.stderr || result.stdout)}`);
+}
+function fridaRunCommand(serial, mode, target, scriptPath, durationSeconds) {
+  return [`${adbEnvPrefix()}python3`, RUNNER_PATH, "--serial", shellQuote7(serial), "--mode", shellQuote7(mode), "--target", shellQuote7(target), "--script", shellQuote7(scriptPath), "--duration", String(durationSeconds)].join(" ");
+}
+function parseFridaMessages(stdout) {
+  const messages = [];
+  let summary;
+  for (const line of stdout.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("FRIDA_DONE ")) {
+      try {
+        summary = JSON.parse(trimmed.slice("FRIDA_DONE ".length));
+      } catch {}
+    } else if (trimmed.startsWith("FRIDA ")) {
+      try {
+        messages.push(JSON.parse(trimmed.slice("FRIDA ".length)));
+      } catch {}
+    }
+  }
+  return {
+    messages,
+    summary
+  };
+}
+async function pipInstallFrida(context, version) {
+  const spec = version ? `frida==${version} frida-tools` : "frida-tools";
+  const install = await backend(context).exec(`pip install --upgrade ${spec} 2>&1`, 360000, context.signal, 2000000);
+  const check = await backend(context).exec("frida --version 2>/dev/null", 15000, context.signal);
+  return {
+    output: install.stdout.trim().split(`
+`).slice(-15).join(`
+`),
+    resolved: check.stdout.trim()
+  };
+}
+var SERIAL_PROP4, DEVICE_SERVER_PATH = "/data/local/tmp/frida-server", ASSET_DIR = ".farai/android", RUNNER_PATH, ABI_MAP, FRIDA_RUNNER = `import sys, json, time, argparse
+try:
+    import frida
+except Exception as exc:
+    print("FRIDA_DONE " + json.dumps({"error": "frida python module missing: %s" % exc}))
+    sys.exit(0)
+
+def emit(obj):
+    print("FRIDA " + json.dumps(obj), flush=True)
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--serial", default="")
+    ap.add_argument("--mode", default="attach")
+    ap.add_argument("--target", required=True)
+    ap.add_argument("--script", required=True)
+    ap.add_argument("--duration", type=float, default=10.0)
+    a = ap.parse_args()
+    collected = []
+    def on_message(message, data):
+        if message.get("type") == "send":
+            payload = message.get("payload")
+            collected.append(payload)
+            emit({"send": payload})
+        elif message.get("type") == "error":
+            desc = message.get("description")
+            collected.append({"__error__": desc})
+            emit({"error": desc})
+    try:
+        device = frida.get_device(a.serial, timeout=5) if a.serial else frida.get_usb_device(timeout=5)
+    except Exception as exc:
+        print("FRIDA_DONE " + json.dumps({"error": "device not reachable by frida: %s" % exc}))
+        return
+    try:
+        with open(a.script) as handle:
+            source = handle.read()
+    except Exception as exc:
+        print("FRIDA_DONE " + json.dumps({"error": "cannot read script: %s" % exc}))
+        return
+    spawned = False
+    pid = None
+    try:
+        if a.mode == "spawn":
+            pid = device.spawn([a.target])
+            spawned = True
+            session = device.attach(pid)
+        else:
+            session = device.attach(a.target)
+    except Exception as exc:
+        print("FRIDA_DONE " + json.dumps({"error": "attach/spawn failed: %s" % exc}))
+        return
+    try:
+        script = session.create_script(source)
+        script.on("message", on_message)
+        script.load()
+        if spawned and pid is not None:
+            device.resume(pid)
+        time.sleep(a.duration)
+    except Exception as exc:
+        collected.append({"__error__": str(exc)})
+    finally:
+        try:
+            session.detach()
+        except Exception:
+            pass
+    print("FRIDA_DONE " + json.dumps({"messages": collected, "spawned": spawned, "target": a.target}))
+
+main()
+`, SSL_BYPASS_JS = `Java.perform(function () {
+  function log(m) { send({ tag: "ssl-bypass", msg: m }); }
+  try {
+    var TMImpl = Java.use("com.android.org.conscrypt.TrustManagerImpl");
+    TMImpl.checkTrustedRecursive.implementation = function () { log("conscrypt checkTrustedRecursive bypassed"); return Java.use("java.util.ArrayList").$new(); };
+  } catch (e) {}
+  try {
+    var TrustManager = Java.registerClass({
+      name: "com.farai.TrustAll",
+      implements: [Java.use("javax.net.ssl.X509TrustManager")],
+      methods: {
+        checkClientTrusted: function () {},
+        checkServerTrusted: function () {},
+        getAcceptedIssuers: function () { return []; }
+      }
+    });
+    var SSLContext = Java.use("javax.net.ssl.SSLContext");
+    SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").implementation = function (km, tm, sr) {
+      log("SSLContext.init overridden with trust-all manager");
+      this.init(km, [TrustManager.$new()], sr);
+    };
+  } catch (e) {}
+  try {
+    var OkHostnameVerifier = Java.use("okhttp3.internal.tls.OkHostnameVerifier");
+    OkHostnameVerifier.verify.overload("java.lang.String", "javax.net.ssl.SSLSession").implementation = function () { log("okhttp OkHostnameVerifier bypassed"); return true; };
+  } catch (e) {}
+  try {
+    var CertPinner = Java.use("okhttp3.CertificatePinner");
+    CertPinner.check.overload("java.lang.String", "java.util.List").implementation = function () { log("okhttp CertificatePinner.check bypassed"); return; };
+  } catch (e) {}
+  log("ssl pinning bypass hooks installed");
+});
+`, ROOT_BYPASS_JS = `Java.perform(function () {
+  function log(m) { send({ tag: "root-bypass", msg: m }); }
+  try {
+    var RootBeer = Java.use("com.scottyab.rootbeer.RootBeer");
+    ["isRooted", "isRootedWithoutBusyBoxCheck", "detectRootManagementApps", "detectPotentiallyDangerousApps", "checkForBinary", "checkForSuBinary", "checkForDangerousProps", "detectTestKeys", "checkSuExists"].forEach(function (m) {
+      try { RootBeer[m].implementation = function () { log("RootBeer." + m + " -> false"); return false; }; } catch (e) {}
+    });
+  } catch (e) {}
+  try {
+    var Runtime = Java.use("java.lang.Runtime");
+    Runtime.exec.overload("java.lang.String").implementation = function (cmd) {
+      if (cmd && (cmd.indexOf("su") !== -1 || cmd.indexOf("which") !== -1 || cmd.indexOf("busybox") !== -1)) { log("blocked Runtime.exec(" + cmd + ")"); throw Java.use("java.io.IOException").$new("blocked"); }
+      return this.exec(cmd);
+    };
+  } catch (e) {}
+  try {
+    var File = Java.use("java.io.File");
+    File.exists.implementation = function () {
+      var path = this.getAbsolutePath();
+      if (path && (path.indexOf("su") !== -1 || path.indexOf("magisk") !== -1 || path.indexOf("supersu") !== -1)) { log("hid file " + path); return false; }
+      return this.exists();
+    };
+  } catch (e) {}
+  log("root detection bypass hooks installed");
+});
+`, BYPASS_SCRIPTS, androidFridaInstallTool, androidFridaStatusTool, androidFridaSetupTool, androidFridaPsTool, androidFridaRunTool, androidFridaBypassTool;
+var init_frida = __esm(() => {
+  init_backend();
+  init_background_result();
+  init_session_manager();
+  init_renderers();
+  init_shared4();
+  SERIAL_PROP4 = {
+    type: "string",
+    description: "device serial from android_devices; omit when exactly one device is connected"
+  };
+  RUNNER_PATH = `${ASSET_DIR}/frida_runner.py`;
+  ABI_MAP = {
+    "arm64-v8a": "arm64",
+    "armeabi-v7a": "arm",
+    x86_64: "x86_64",
+    x86: "x86"
+  };
+  BYPASS_SCRIPTS = {
+    ssl: SSL_BYPASS_JS,
+    root: ROOT_BYPASS_JS
+  };
+  androidFridaInstallTool = {
+    name: "android_frida_install",
+    description: "Install frida-tools in the container, optionally pinned to a version. Frida is intentionally not baked into the image because the python frida module must match the frida-server version, which varies per device and app. Install here first, then run android_frida_setup to provision a matching frida-server.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        version: {
+          type: "string",
+          description: "exact frida version to pin, e.g. 16.5.9; omit to install the latest frida-tools"
+        }
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 360000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const version = typeof args.version === "string" && args.version.trim() ? args.version.trim() : "";
+      if (version && !/^\d+(\.\d+){1,3}$/.test(version))
+        throw new Error("version must look like 16.5.9");
+      const spec = version ? `frida==${version} frida-tools` : "frida-tools";
+      const command = `pip install --upgrade ${spec} 2>&1`;
+      const result = await backend(context).exec(command, 360000, context.signal, 2000000);
+      const installed = await backend(context).exec("frida --version 2>/dev/null", 15000, context.signal);
+      const resolved = installed.stdout.trim();
+      const ok = Boolean(resolved) && (!version || resolved === version);
+      return {
+        ok,
+        summary: ok ? `frida-tools ${resolved} installed` : `frida install did not settle at the requested version${version ? ` (${version})` : ""}`,
+        output: `${result.stdout}`.trim().split(`
+`).slice(-20).join(`
+`) || `exit ${result.exitCode}`,
+        metadata: {
+          requested: version || "latest",
+          installedVersion: resolved || null
+        }
+      };
+    }
+  };
+  androidFridaStatusTool = {
+    name: "android_frida_status",
+    description: "Check whether frida is ready: frida-tools in the container, and frida-server binary, process, and listening port on the device. Run this before other frida tools; if frida-tools is missing run android_frida_install, then android_frida_setup.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serial: SERIAL_PROP4
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 40000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const version = await backend(context).exec("frida --version 2>/dev/null || true", 15000, context.signal);
+      const fridaTools = version.stdout.trim();
+      const binary = await runAdb(context, `${adbPrefix(serial)} shell ls ${DEVICE_SERVER_PATH} 2>/dev/null`, 15000);
+      const proc = await runAdb(context, `${adbPrefix(serial)} shell 'ps -A 2>/dev/null | grep frida-server || ps | grep frida-server'`, 15000);
+      const checks = {
+        fridaToolsVersion: fridaTools || "missing",
+        serverBinary: binary.stdout.includes("frida-server") ? "present" : "missing",
+        serverProcess: /frida-server/.test(proc.stdout) ? "running" : "stopped"
+      };
+      const ready = Boolean(fridaTools) && checks.serverBinary === "present" && checks.serverProcess === "running";
+      return {
+        ok: true,
+        summary: ready ? "frida is ready" : `frida is not ready; run ${fridaTools ? "android_frida_setup" : "android_frida_install then android_frida_setup"}`,
+        output: Object.entries(checks).map(([key, value]) => `${key}: ${value}`).join(`
+`),
+        metadata: {
+          serial,
+          ready,
+          checks
+        }
+      };
+    }
+  };
+  androidFridaSetupTool = {
+    name: "android_frida_setup",
+    description: "One-command frida provisioning: install frida-tools in the container (pinned to version when given), detect the device cpu abi, download the matching frida-server build, push it to /data/local/tmp/frida-server, and start it (needs root via su or adb root). The python frida module and frida-server versions are kept identical. Run android_frida_status afterwards to confirm.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        version: {
+          type: "string",
+          description: "exact frida version to pin for both the python module and frida-server, e.g. 16.5.9; omit to use the latest installed frida-tools"
+        },
+        serial: SERIAL_PROP4
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 500000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const requested = typeof args.version === "string" && args.version.trim() ? args.version.trim() : "";
+      if (requested && !/^\d+(\.\d+){1,3}$/.test(requested))
+        throw new Error("version must look like 16.5.9");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const steps = [];
+      let version = (await backend(context).exec("frida --version 2>/dev/null", 15000, context.signal)).stdout.trim();
+      if (requested || !version) {
+        const install = await pipInstallFrida(context, requested);
+        version = install.resolved;
+        steps.push(`pip install ${requested || "latest"}: ${version ? `frida-tools ${version}` : "failed"}`);
+      } else {
+        steps.push(`frida-tools already present: ${version}`);
+      }
+      if (!version)
+        return {
+          ok: false,
+          summary: "frida-tools install failed",
+          output: steps.join(`
+`),
+          metadata: {
+            serial
+          }
+        };
+      const abiResult = await runAdb(context, `${adbPrefix(serial)} shell getprop ro.product.cpu.abi`, 15000);
+      if (adbUnavailable(abiResult))
+        throw new Error("adb is not available in the container");
+      const abi = abiResult.stdout.trim().replace(/\r/g, "");
+      const arch = ABI_MAP[abi];
+      if (!arch)
+        throw new Error(`unsupported device abi: ${abi || "unknown"} (supported: ${Object.keys(ABI_MAP).join(", ")})`);
+      const url = `https://github.com/frida/frida/releases/download/${version}/frida-server-${version}-android-${arch}.xz`;
+      const download = await backend(context).exec(`curl -fsSL -o /tmp/frida-server.xz ${shellQuote7(url)} && xz -d -f /tmp/frida-server.xz`, 180000, context.signal);
+      steps.push(`download ${arch} ${version}: ${download.exitCode === 0 ? "ok" : `failed (${compactError2(download.stderr || download.stdout)})`}`);
+      if (download.exitCode !== 0) {
+        return {
+          ok: false,
+          summary: `could not download frida-server ${version} for ${arch}`,
+          output: steps.join(`
+`),
+          metadata: {
+            serial,
+            version,
+            arch,
+            url
+          }
+        };
+      }
+      const push = await runAdb(context, `${adbPrefix(serial)} push /tmp/frida-server ${DEVICE_SERVER_PATH} && ${adbPrefix(serial)} shell chmod 755 ${DEVICE_SERVER_PATH}`, 90000);
+      steps.push(`push + chmod: ${push.exitCode === 0 ? "ok" : `failed (${compactError2(push.stderr || push.stdout)})`}`);
+      const start = await runAdb(context, `${adbPrefix(serial)} shell 'su -c "${DEVICE_SERVER_PATH} -D" >/dev/null 2>&1 & echo started' || ${adbPrefix(serial)} shell '${DEVICE_SERVER_PATH} -D >/dev/null 2>&1 & echo started'`, 20000);
+      steps.push(`start: ${/started/.test(start.stdout) ? "attempted (verify with android_frida_status)" : "could not start; device may need root"}`);
+      return {
+        ok: push.exitCode === 0,
+        summary: `frida-server ${version} (${arch}) provisioned; verify with android_frida_status`,
+        output: steps.join(`
+`),
+        metadata: {
+          serial,
+          version,
+          arch
+        }
+      };
+    }
+  };
+  androidFridaPsTool = {
+    name: "android_frida_ps",
+    description: "List processes and applications visible to frida on the device. Use to find the exact process name or pid to attach to.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        applicationsOnly: {
+          type: "boolean",
+          description: "list installed applications (frida-ps -Uai) instead of running processes when true"
+        },
+        serial: SERIAL_PROP4
+      },
+      additionalProperties: false
+    },
+    mutates: false,
+    timeoutMs: 40000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const listFlag = args.applicationsOnly === true ? "-ai" : "-a";
+      const deviceFlag = `-D ${shellQuote7(serial)}`;
+      const result = await backend(context).exec(`${adbEnvPrefix()}frida-ps ${listFlag} ${deviceFlag} 2>&1`, 40000, context.signal);
+      if (/not found|no such/i.test(result.stdout) && result.exitCode !== 0)
+        throw new Error("frida-tools is not installed in the container");
+      return {
+        ok: result.exitCode === 0,
+        summary: result.exitCode === 0 ? "listed frida targets" : "frida-ps failed (is frida-server running?)",
+        output: result.stdout.trim() || "(no output)",
+        metadata: {
+          serial,
+          listFlag
+        }
+      };
+    }
+  };
+  androidFridaRunTool = {
+    name: "android_frida_run",
+    description: "Run a frida javascript script against an app and collect its send() messages. Write the script first with fs_write, then attach to a running process or spawn a package. Use background=true to keep hooks live while you interact with the app, then read output with session_poll.",
+    inputSchema: {
+      type: "object",
+      required: ["scriptPath", "target"],
+      properties: {
+        scriptPath: {
+          type: "string",
+          description: "workspace-relative path to the frida javascript to load"
+        },
+        target: {
+          type: "string",
+          description: "package name to spawn, or process name/pid to attach to"
+        },
+        mode: {
+          type: "string",
+          enum: ["spawn", "attach"],
+          description: "spawn launches the package fresh; attach hooks an already-running process (default attach)"
+        },
+        durationSeconds: {
+          type: "integer",
+          minimum: 1,
+          maximum: 600,
+          description: "how long to keep the session open collecting messages (default 15)"
+        },
+        background: {
+          type: "boolean",
+          description: "run as a persistent background session and return a job id; poll it with session_poll"
+        },
+        serial: SERIAL_PROP4
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 620000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const scriptPath = asString(args.scriptPath, "scriptPath").trim();
+      const target = asString(args.target, "target").trim();
+      const mode = args.mode === "spawn" ? "spawn" : "attach";
+      const durationSeconds = typeof args.durationSeconds === "number" && Number.isInteger(args.durationSeconds) ? Math.max(1, Math.min(600, args.durationSeconds)) : 15;
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      await writeAsset(context, RUNNER_PATH, FRIDA_RUNNER);
+      const command = fridaRunCommand(serial, mode, target, scriptPath, durationSeconds);
+      if (args.background === true) {
+        const started = await sessionManager.start(backend(context), "android_frida_run", command, clampYieldMs(args.background === true ? undefined : 1000), context.signal, {
+          kind: "generic"
+        });
+        return backgroundToolResult("android_frida_run", started, "generic");
+      }
+      const result = await backend(context).exec(command, (durationSeconds + 30) * 1000, context.signal, 4000000);
+      const {
+        messages,
+        summary
+      } = parseFridaMessages(result.stdout);
+      const error = summary && typeof summary.error === "string" ? summary.error : undefined;
+      const output = error ? `frida error: ${error}` : `${messages.length} message(s):
+${messages.map((m) => JSON.stringify(m)).join(`
+`)}`;
+      return {
+        ok: !error,
+        summary: error ? `frida run failed: ${error}` : `collected ${messages.length} message(s) from ${target}`,
+        output: output || "(no messages)",
+        metadata: {
+          serial,
+          target,
+          mode,
+          messages: messages.slice(0, 500),
+          ...summary ? {
+            summary
+          } : {}
+        }
+      };
+    }
+  };
+  androidFridaBypassTool = {
+    name: "android_frida_bypass",
+    description: "Spawn an app with a bundled bypass script attached: ssl for certificate-pinning bypass (to see traffic through the proxy), root for root-detection bypass. Use background=true to keep the bypass active while you drive the app.",
+    inputSchema: {
+      type: "object",
+      required: ["type", "package"],
+      properties: {
+        type: {
+          type: "string",
+          enum: ["ssl", "root"],
+          description: "which bundled bypass to inject"
+        },
+        package: {
+          type: "string",
+          description: "package name to spawn with the bypass attached"
+        },
+        durationSeconds: {
+          type: "integer",
+          minimum: 1,
+          maximum: 600,
+          description: "how long to keep the bypass session open (default 30)"
+        },
+        background: {
+          type: "boolean",
+          description: "run as a persistent background session so hooks stay active; poll with session_poll"
+        },
+        serial: SERIAL_PROP4
+      },
+      additionalProperties: false
+    },
+    mutates: true,
+    timeoutMs: 620000,
+    parallel: false,
+    renderHuman: defaultHumanRenderer,
+    renderModel: defaultModelRenderer,
+    run: async (args, context) => {
+      assertObject(args, "args");
+      const type = asString(args.type, "type");
+      const script = BYPASS_SCRIPTS[type];
+      if (!script)
+        throw new Error(`unknown bypass type: ${type}; use ssl or root`);
+      const pkg = asString(args.package, "package").trim();
+      const durationSeconds = typeof args.durationSeconds === "number" && Number.isInteger(args.durationSeconds) ? Math.max(1, Math.min(600, args.durationSeconds)) : 30;
+      const serial = await resolveDevice(context, typeof args.serial === "string" ? args.serial : undefined);
+      const scriptPath = `${ASSET_DIR}/scripts/bypass_${type}.js`;
+      await writeAsset(context, RUNNER_PATH, FRIDA_RUNNER);
+      await writeAsset(context, scriptPath, script);
+      const command = fridaRunCommand(serial, "spawn", pkg, scriptPath, durationSeconds);
+      if (args.background === true) {
+        const started = await sessionManager.start(backend(context), "android_frida_bypass", command, clampYieldMs(1000), context.signal, {
+          kind: "generic"
+        });
+        return backgroundToolResult("android_frida_bypass", started, "generic");
+      }
+      const result = await backend(context).exec(command, (durationSeconds + 30) * 1000, context.signal, 4000000);
+      const {
+        messages,
+        summary
+      } = parseFridaMessages(result.stdout);
+      const error = summary && typeof summary.error === "string" ? summary.error : undefined;
+      return {
+        ok: !error,
+        summary: error ? `${type} bypass failed: ${error}` : `${type} bypass injected into ${pkg} (${messages.length} hook message(s))`,
+        output: error ? `frida error: ${error}` : messages.map((m) => JSON.stringify(m)).join(`
+`) || "hooks installed (no messages emitted)",
+        metadata: {
+          serial,
+          type,
+          package: pkg,
+          messages: messages.slice(0, 500)
+        }
+      };
+    }
+  };
+});
+
+// src/agent-tools/android/index.ts
+var androidTools;
+var init_android = __esm(() => {
+  init_device();
+  init_app();
+  init_static();
+  init_ui();
+  init_frida();
+  androidTools = [androidConnectTool, androidDevicesTool, androidShellTool, androidPackagesTool, androidDeviceInfoTool, androidLogcatTool, androidApkPullTool, androidInstallTool, androidAppStartTool, androidAppStopTool, androidDeeplinkTool, androidPullFileTool, androidDecompileTool, androidManifestTool, androidPermissionsTool, androidExportedComponentsTool, androidScanSecretsTool, androidGrepApkTool, androidUiDumpTool, androidUiHierarchyTool, androidScreenshotTool, androidUiTapTool, androidUiTapElementTool, androidUiTypeTool, androidUiSwipeTool, androidUiKeyTool, androidUiWindowSizeTool, androidUiWaitForTool, androidFridaInstallTool, androidFridaStatusTool, androidFridaSetupTool, androidFridaPsTool, androidFridaRunTool, androidFridaBypassTool];
+});
+
 // src/agent-tools/registry.ts
 function listToolsForSession(session) {
   const tools = [...baseTools, ...listMcpTools(session)];
@@ -28726,10 +30739,11 @@ var init_registry4 = __esm(() => {
   init_worktree();
   init_proxy();
   init_email();
+  init_android();
   init_mcp_manager();
   init_process_output();
   init_mcp_manager();
-  baseTools = [...shellTools, ...reconTools, ...filesystemTools, ...gitTools, ...knowledgeTools, ...todoTools, ...reportTools, ...codegenTools, ...callbackTools, ...campaignTools, ...outputTools, ...lspTools, ...browserTools, ...kaliTools, ...agentTools, ...webTools, ...mediaTools, ...interactionTools, ...mcpResourceTools, ...worktreeTools, ...proxyTools, ...emailTools];
+  baseTools = [...shellTools, ...reconTools, ...filesystemTools, ...gitTools, ...knowledgeTools, ...todoTools, ...reportTools, ...codegenTools, ...callbackTools, ...campaignTools, ...outputTools, ...lspTools, ...browserTools, ...kaliTools, ...agentTools, ...webTools, ...mediaTools, ...interactionTools, ...mcpResourceTools, ...worktreeTools, ...proxyTools, ...emailTools, ...androidTools];
 });
 
 // src/agent-core/mcp-server-management.ts
@@ -29928,12 +31942,25 @@ var init_tool_guidance = __esm(() => {
 });
 
 // src/agent-core/default-model.ts
-var DEFAULT_MODEL_PROVIDER_ID = "opencode", DEFAULT_MODEL_BASE_URL = "https://opencode.ai/zen/v1", DEFAULT_MODEL_ID = "mimo-v2.5-free", DEFAULT_MODEL_PUBLIC_API_KEY = "public", DEFAULT_CONTEXT_WINDOW = 200000, DEFAULT_MAX_OUTPUT_TOKENS = 4096, DEFAULT_MAX_STEPS, DEFAULT_MAX_TURN_SECONDS;
+var DEFAULT_MODEL_PROVIDER_ID = "openrouter", DEFAULT_MODEL_BASE_URL = "https://openrouter.ai/api/v1", DEFAULT_MODEL_ID = "openrouter/free", DEFAULT_MODEL_PUBLIC_API_KEY = "", DEFAULT_CONTEXT_WINDOW = 200000, DEFAULT_MAX_OUTPUT_TOKENS = 4096, DEFAULT_MAX_STEPS, DEFAULT_MAX_TURN_SECONDS;
 var init_default_model = __esm(() => {
   DEFAULT_MAX_STEPS = Number.POSITIVE_INFINITY;
   DEFAULT_MAX_TURN_SECONDS = Number.POSITIVE_INFINITY;
 });
 
+// src/agent-core/default-source.ts
+function defaultSourceKey() {
+  return Buffer.from(DEFAULT_SOURCE_KEY_B64, "base64").toString("utf8");
+}
+function isDefaultMode() {
+  const config = loadGlobalConfig();
+  return !config.baseUrl && !config.apiKeyEnv;
+}
+var DEFAULT_SOURCE_BASE_URL = "https://openrouter.ai/api/v1", DEFAULT_SOURCE_MODEL = "openrouter/free", DEFAULT_SOURCE_CONTEXT_WINDOW = 200000, DEFAULT_SOURCE_KEY_B64 = "c2stb3ItdjEtODM0NDYyZDI2YWMzODFkMDc5ZWI3N2Q1NTM2YWU0MTc2NWIyMGNhNWFiMzQ1YmEwNTJjNjU4ZTRhOWQ3ZGYzYQ==";
+var init_default_source = __esm(() => {
+  init_global_config();
+});
+
 // src/agent-core/model-registry.ts
 function resolveDefaultModel() {
   return resolveModel({});
@@ -29941,8 +31968,9 @@ function resolveDefaultModel() {
 function resolveModel(input = {}) {
   const config = loadGlobalConfig();
   const baseUrl = input.baseUrl ?? config.baseUrl ?? DEFAULT_MODEL_BASE_URL;
-  const model = input.model ?? config.model ?? DEFAULT_MODEL_ID;
-  const apiKey = input.apiKey ?? (config.apiKeyEnv ? process.env[config.apiKeyEnv] : undefined) ?? (baseUrl === DEFAULT_MODEL_BASE_URL ? DEFAULT_MODEL_PUBLIC_API_KEY : undefined);
+  const isDefault = baseUrl === DEFAULT_MODEL_BASE_URL && !config.baseUrl;
+  const model = input.model ?? config.model ?? (DEFAULT_MODEL_ID || undefined);
+  const apiKey = input.apiKey ?? (config.apiKeyEnv ? process.env[config.apiKeyEnv] : undefined) ?? (isDefault ? defaultSourceKey() : DEFAULT_MODEL_PUBLIC_API_KEY || undefined);
   return {
     baseUrl,
     ...model ? {
@@ -30045,6 +32073,7 @@ var HEURISTIC_MODEL_ID = "heuristic", MODEL_DISCOVERY_TIMEOUT_MS = 4000, MODEL_D
 var init_model_registry = __esm(() => {
   init_global_config();
   init_default_model();
+  init_default_source();
   init_http_response();
   MODEL_DISCOVERY_MAX_BYTES = 8 * 1024 * 1024;
 });
@@ -30394,6 +32423,15 @@ async function resolveModelSelection(workspace, selection) {
 }
 async function resolveDefaultCatalogModel(workspace) {
   const config = loadGlobalConfig();
+  if (isDefaultMode()) {
+    return {
+      baseUrl: DEFAULT_SOURCE_BASE_URL,
+      model: DEFAULT_SOURCE_MODEL,
+      apiKey: defaultSourceKey(),
+      contextWindow: DEFAULT_SOURCE_CONTEXT_WINDOW,
+      name: "default"
+    };
+  }
   const catalog = await buildModelCatalog(workspace);
   const recent = readRecentModelSelections();
   for (const selection of recent) {
@@ -30403,9 +32441,6 @@ async function resolveDefaultCatalogModel(workspace) {
   }
   if (config.model)
     return resolveModelSelection(workspace, config.model);
-  const openCodeDefault = catalog.models.find((model) => model.providerID === DEFAULT_PROVIDER_ID && model.modelID === OPENCODE_DEFAULT_MODEL_ID);
-  if (openCodeDefault)
-    return withSavedModelLimits(modelChoiceToResolved(openCodeDefault), openCodeDefault.id, workspace);
   const first = sortModelChoices(catalog.models).find((model) => model.verified) ?? sortModelChoices(catalog.models)[0];
   if (first)
     return withSavedModelLimits(modelChoiceToResolved(first), first.id, workspace);
@@ -30449,7 +32484,7 @@ function normalizeModelsDevProviderHint(providerID, profile) {
   if (providerID !== DEFAULT_PROVIDER_ID)
     return providerID;
   if (!profile && resolveModel().baseUrl === DEFAULT_MODEL_BASE_URL)
-    return OPENCODE_PROVIDER_ID;
+    return DEFAULT_SOURCE_PROVIDER_ID;
   return;
 }
 function readRecentModelSelections() {
@@ -30461,8 +32496,14 @@ function defaultModelSelection() {
 function displayModelSelection(workspace, selection) {
   if (selection) {
     const profile = loadModelProfiles(workspace).find((candidate) => candidate.name === selection);
-    return profile?.model ?? selection;
-  }
+    if (profile)
+      return profile.model ?? selection;
+    if (isDefaultMode() && selection === DEFAULT_SOURCE_MODEL)
+      return "default";
+    return selection;
+  }
+  if (isDefaultMode())
+    return "default";
   return defaultModelSelection() ?? "auto";
 }
 async function providerDefinitions(workspace, profiles) {
@@ -30490,39 +32531,21 @@ async function providerDefinitions(workspace, profiles) {
   for (const definition of profileDefinitions)
     if (definition)
       definitions2.push(definition);
-  const openCode = modelsDev?.[OPENCODE_PROVIDER_ID];
-  const configuredOpenCode = definitions2.some((provider) => provider.id === DEFAULT_PROVIDER_ID);
-  if (openCode && !configuredOpenCode) {
-    const hasApiKey = openCode.env.some((name) => Boolean(process.env[name]));
-    const freeModels = Object.values(openCode.models).filter((model) => hasApiKey || isFreeModel(model));
-    if (freeModels.length) {
-      definitions2.push({
-        id: DEFAULT_PROVIDER_ID,
-        name: openCode.name,
-        baseUrl: openCode.api,
-        ...openCode.env[0] ? {
-          apiKeyEnv: openCode.env[0]
-        } : {},
-        apiKey: openCode.env.map((name) => process.env[name]).find(Boolean) ?? OPENCODE_PUBLIC_API_KEY,
-        source: "models.dev",
-        catalogModels: freeModels.map((model) => ({
-          id: model.id,
-          ...model.name ? {
-            name: model.name
-          } : {},
-          free: isFreeModel(model),
-          ...model.limit?.context ? {
-            contextWindow: model.limit.context
-          } : {},
-          ...model.limit?.output ? {
-            maxOutputTokens: model.limit.output
-          } : {},
-          ...model.release_date ? {
-            releaseDate: model.release_date
-          } : {}
-        }))
-      });
-    }
+  const configuredDefaultSource = definitions2.some((provider) => provider.id === DEFAULT_PROVIDER_ID);
+  if (isDefaultMode() && !configuredDefaultSource) {
+    definitions2.push({
+      id: DEFAULT_PROVIDER_ID,
+      name: "default",
+      baseUrl: DEFAULT_SOURCE_BASE_URL,
+      apiKey: defaultSourceKey(),
+      source: "models.dev",
+      catalogModels: [{
+        id: DEFAULT_SOURCE_MODEL,
+        name: "default",
+        free: true,
+        contextWindow: DEFAULT_SOURCE_CONTEXT_WINDOW
+      }]
+    });
   }
   return definitions2;
 }
@@ -30938,20 +32961,19 @@ function ensureConcrete(resolved) {
 function modelsDevCachePath() {
   return join18(globalDataDir(), "cache", "models-dev.json");
 }
-var DEFAULT_PROVIDER_ID = "default", OPENCODE_PROVIDER_ID, OPENCODE_DEFAULT_MODEL_ID, OPENCODE_PUBLIC_API_KEY, MODELS_DEV_URL = "https://models.dev/api.json", MODELS_DEV_CACHE_TTL_MS, MODELS_DEV_STALE_TTL_MS, MODELS_DEV_FETCH_TIMEOUT_MS = 4000, MODELS_DEV_MAX_BYTES, RECENT_MODEL_LIMIT = 12, modelsDevRefreshes;
+var DEFAULT_PROVIDER_ID = "default", DEFAULT_SOURCE_PROVIDER_ID, MODELS_DEV_URL = "https://models.dev/api.json", MODELS_DEV_CACHE_TTL_MS, MODELS_DEV_STALE_TTL_MS, MODELS_DEV_FETCH_TIMEOUT_MS = 4000, MODELS_DEV_MAX_BYTES, RECENT_MODEL_LIMIT = 12, modelsDevRefreshes;
 var init_model_catalog = __esm(() => {
   init_default_model();
   init_global_config();
   init_config();
   init_model_registry();
   init_model_profiles();
+  init_default_source();
   init_http_response();
   init_file_read();
   init_atomic_file();
   init_private_path();
-  OPENCODE_PROVIDER_ID = DEFAULT_MODEL_PROVIDER_ID;
-  OPENCODE_DEFAULT_MODEL_ID = DEFAULT_MODEL_ID;
-  OPENCODE_PUBLIC_API_KEY = DEFAULT_MODEL_PUBLIC_API_KEY;
+  DEFAULT_SOURCE_PROVIDER_ID = DEFAULT_MODEL_PROVIDER_ID;
   MODELS_DEV_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   MODELS_DEV_STALE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
   MODELS_DEV_MAX_BYTES = 16 * 1024 * 1024;
@@ -42958,6 +44980,17 @@ var init_runtime = __esm(() => {
 
 // src/branding.ts
 import figlet from "figlet";
+function printBannerOnce() {
+  if (bannerPrinted)
+    return;
+  bannerPrinted = true;
+  console.log(FARAI_BANNER);
+}
+function clearBannerIfShown() {
+  if (!bannerPrinted || !process.stdout.isTTY)
+    return;
+  process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+}
 function renderFaraiBanner() {
   try {
     return figlet.textSync("farai", {
@@ -42967,7 +45000,7 @@ function renderFaraiBanner() {
     return "farai";
   }
 }
-var FARAI_BANNER, FARAI_BANNER_LINES;
+var FARAI_BANNER, FARAI_BANNER_LINES, bannerPrinted = false;
 var init_branding = __esm(() => {
   FARAI_BANNER = renderFaraiBanner();
   FARAI_BANNER_LINES = FARAI_BANNER.split(`
@@ -43812,6 +45845,7 @@ async function runStartupContentPreflight(workspace) {
 }
 async function promptForUpdate(version, knowledge, skills) {
   const contents = [knowledge ? "knowledge" : undefined, skills ? "skills" : undefined].filter(Boolean).join(" + ");
+  printBannerOnce();
   console.log("");
   console.log(`farai content ${version} is available${contents ? ` (${contents})` : ""}`);
   const interfaceHandle = createInterface({
@@ -43866,6 +45900,7 @@ function errorMessage7(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var init_preflight = __esm(() => {
+  init_branding();
   init_config();
   init_updater();
 });
@@ -43903,8 +45938,7 @@ async function runStartupContainerPreflight(workspace) {
   return "continue";
 }
 async function promptForImagePull(exists) {
-  console.log("");
-  console.log(FARAI_BANNER);
+  printBannerOnce();
   console.log("");
   console.log(exists ? "a newer kali container image is available" : "kali container image is not installed");
   const interfaceHandle = createInterface2({
@@ -56064,7 +58098,7 @@ function modelProviderOptions(choices, sessionModel) {
     return {
       id: `model-provider-${providerID}`,
       title: providerID,
-      description: [`${providerChoices.length} models`, freeCount ? `${freeCount} free` : undefined, readyCount ? `${readyCount} ready` : undefined, first?.baseUrl].filter(Boolean).join(" \xB7 "),
+      description: [`${providerChoices.length} models`, freeCount ? `${freeCount} free` : undefined, readyCount ? `${readyCount} ready` : undefined, providerID === "default" ? undefined : first?.baseUrl].filter(Boolean).join(" \xB7 "),
       footer: current ? "current" : "",
       value: {
         kind: "model_provider",
@@ -58179,7 +60213,7 @@ function createComposerController(input) {
     composer.blur();
     try {
       renderer.suspend();
-      const proc = Bun.spawn(["sh", "-lc", `${editor} ${shellQuote7(file)}`], {
+      const proc = Bun.spawn(["sh", "-lc", `${editor} ${shellQuote8(file)}`], {
         stdin: "inherit",
         stdout: "inherit",
         stderr: "inherit"
@@ -58244,7 +60278,7 @@ function createComposerController(input) {
 function normalizeComposerText(text2) {
   return text2.replace(/^\s*\n+/, "").replace(/\n+\s*$/, "").trim();
 }
-function shellQuote7(value) {
+function shellQuote8(value) {
   return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function slashPromptText(rawText, completedTitle, slashName) {
@@ -65963,7 +67997,7 @@ function footerRightItems(backgroundActivities, subagents, browserContexts, queu
     items.push({
       id: "update",
       kind: "update",
-      text: `update ${updateNotice.latestVersion}`
+      text: `update available ${updateNotice.latestVersion}`
     });
   }
   if (contextUsage && contextUsage.tokens >= 0) {
@@ -70452,7 +72486,7 @@ var init_app_shell = __esm(() => {
 function App() {
   return createComponent2(AppShell, {});
 }
-var init_app = __esm(() => {
+var init_app2 = __esm(() => {
   init_solid2();
   init_app_shell();
 });
@@ -70815,7 +72849,7 @@ function formatResumeHint(sessionId, _title, options = {}) {
   const brand = options.styled ? `\x1B[2m${banner}\x1B[22m` : banner;
   const saved = options.styled ? "\x1B[2msession saved\x1B[22m" : "session saved";
   const usage = options.usage ? formatTokenUsage(options.usage) : undefined;
-  return ["", brand, "", saved, `  farai resume ${shellQuote8(sessionId)}`, "", usage, ""].filter((line) => line !== undefined).join(`
+  return ["", brand, "", saved, `  farai resume ${shellQuote9(sessionId)}`, "", usage, ""].filter((line) => line !== undefined).join(`
 `);
 }
 function formatTokenUsage(usage) {
@@ -70840,7 +72874,7 @@ function exitBanner(width) {
 function terminalStylingEnabled() {
   return Boolean(process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb");
 }
-function shellQuote8(value) {
+function shellQuote9(value) {
   return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
 }
 async function launchOpenTui(workspace, sessionId) {
@@ -70875,7 +72909,7 @@ var init_agent_tui = __esm(() => {
   init_solid2();
   init_solid2();
   init_runtime();
-  init_app();
+  init_app2();
   init_runtime2();
   init_store4();
   init_exit();
@@ -74189,6 +76223,7 @@ async function launchTui(workspace, sessionId) {
     process.exitCode = 130;
     return;
   }
+  clearBannerIfShown();
   if (import.meta.path.endsWith(".ts")) {
     const sourceTuiPreload = "@opentui/solid/preload";
     await import(sourceTuiPreload);
@@ -74402,5 +76437,5 @@ Examples:
 `);
 }
 
-//# debugId=32EC65247FDE45AE64756E2164756E21
+//# debugId=80A953E297D3B0EB64756E2164756E21
 //# sourceMappingURL=index.js.map