@irsprs/mobwright 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,773 @@
+#!/usr/bin/env node
+
+// src/cli/doctor.ts
+import { exec as execCb } from "child_process";
+import { promisify } from "util";
+import { existsSync } from "fs";
+
+// src/cli/colors.ts
+var enabled = process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+function paint(code, text) {
+  return enabled ? `\x1B[${code}m${text}\x1B[0m` : text;
+}
+var green = (s) => paint(32, s);
+var yellow = (s) => paint(33, s);
+var red = (s) => paint(31, s);
+var dim = (s) => paint(2, s);
+var bold = (s) => paint(1, s);
+
+// src/cli/doctor.ts
+var exec = promisify(execCb);
+async function tryExec(cmd, args = []) {
+  try {
+    const { stdout } = await exec([cmd, ...args].join(" "), { timeout: 5e3 });
+    return stdout.split("\n")[0]?.trim() ?? "";
+  } catch {
+    return null;
+  }
+}
+async function httpProbe(url, timeoutMs = 1500) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(url, { signal: controller.signal });
+    clearTimeout(timer);
+    return res.ok || res.status === 404;
+  } catch {
+    return false;
+  }
+}
+async function checkSystem() {
+  const results = [];
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split(".")[0], 10);
+  results.push({
+    status: major >= 18 ? "ok" : "fail",
+    label: `Node ${nodeVersion}`,
+    detail: major >= 18 ? void 0 : "Node 18.18 or higher required"
+  });
+  const pnpmVersion = await tryExec("pnpm", ["--version"]);
+  if (pnpmVersion) {
+    results.push({ status: "ok", label: `pnpm ${pnpmVersion}` });
+  }
+  return { title: "System", results };
+}
+async function checkAndroid() {
+  const results = [];
+  const androidHome = process.env.ANDROID_HOME;
+  if (!androidHome) {
+    results.push({
+      status: "warn",
+      label: "ANDROID_HOME not set",
+      detail: "Required for Android testing. Set to your Android SDK path."
+    });
+    return { title: "Android", results };
+  }
+  results.push({
+    status: "ok",
+    label: `ANDROID_HOME=${androidHome}`
+  });
+  if (!existsSync(androidHome)) {
+    results.push({
+      status: "fail",
+      label: `Directory does not exist: ${androidHome}`
+    });
+    return { title: "Android", results };
+  }
+  const adb = await tryExec("adb", ["--version"]);
+  results.push({
+    status: adb ? "ok" : "warn",
+    label: "adb",
+    detail: adb ?? "Not in PATH. Add $ANDROID_HOME/platform-tools."
+  });
+  const emulatorHelp = await tryExec("emulator", ["-help-version"]);
+  results.push({
+    status: emulatorHelp !== null ? "ok" : "warn",
+    label: "emulator",
+    detail: emulatorHelp !== null ? void 0 : "Not in PATH. Add $ANDROID_HOME/emulator."
+  });
+  if (adb) {
+    const devices = await tryExec("adb", ["devices"]);
+    const lines = (devices ?? "").split("\n").slice(1).filter((l) => l.includes("	device"));
+    if (lines.length > 0) {
+      results.push({
+        status: "info",
+        label: `${lines.length} emulator${lines.length > 1 ? "s" : ""} booted`
+      });
+    }
+  }
+  return { title: "Android", results };
+}
+async function checkIOS() {
+  const results = [];
+  if (process.platform !== "darwin") {
+    results.push({
+      status: "info",
+      label: "iOS checks skipped (not macOS)"
+    });
+    return { title: "iOS", results };
+  }
+  const xcodeVersion = await tryExec("xcodebuild", ["-version"]);
+  results.push({
+    status: xcodeVersion ? "ok" : "warn",
+    label: xcodeVersion ?? "Xcode not found"
+  });
+  const xcrun = await tryExec("xcrun", ["--version"]);
+  results.push({
+    status: xcrun ? "ok" : "warn",
+    label: xcrun ? "xcrun" : "xcrun not in PATH"
+  });
+  const sims = await tryExec("xcrun", ["simctl", "list", "devices", "booted"]);
+  if (sims) {
+    const lines = sims.split("\n").filter((l) => l.includes("(Booted)"));
+    if (lines.length > 0) {
+      results.push({
+        status: "info",
+        label: `${lines.length} simulator${lines.length > 1 ? "s" : ""} booted`
+      });
+    }
+  }
+  return { title: "iOS", results };
+}
+async function checkAppium() {
+  const results = [];
+  const appiumVersion = await tryExec("appium", ["--version"]);
+  if (!appiumVersion) {
+    results.push({
+      status: "fail",
+      label: "Appium not installed",
+      detail: "npm install -g appium"
+    });
+    return { title: "Appium", results };
+  }
+  results.push({ status: "ok", label: `Appium ${appiumVersion}` });
+  const driverList = await tryExec("appium", ["driver", "list", "--installed"]);
+  if (driverList) {
+    const hasUiAutomator2 = driverList.includes("uiautomator2");
+    const hasXCUITest = driverList.includes("xcuitest");
+    results.push({
+      status: hasUiAutomator2 ? "ok" : "warn",
+      label: "uiautomator2 driver",
+      detail: hasUiAutomator2 ? void 0 : "appium driver install uiautomator2"
+    });
+    if (process.platform === "darwin") {
+      results.push({
+        status: hasXCUITest ? "ok" : "warn",
+        label: "xcuitest driver",
+        detail: hasXCUITest ? void 0 : "appium driver install xcuitest"
+      });
+    }
+  }
+  const port = process.env.MOBWRIGHT_APPIUM_PORT ?? "4723";
+  const reachable = await httpProbe(`http://localhost:${port}/status`);
+  results.push({
+    status: reachable ? "ok" : "warn",
+    label: `Server reachable at localhost:${port}`,
+    detail: reachable ? void 0 : "Start with `appium` in another terminal."
+  });
+  return { title: "Appium", results };
+}
+function checkEnvVars() {
+  const results = [];
+  const required = ["MOBWRIGHT_APP_PATH", "MOBWRIGHT_ANDROID_AVD"];
+  for (const key of required) {
+    const value = process.env[key];
+    results.push({
+      status: value ? "ok" : "warn",
+      label: `${key}${value ? " set" : " not set"}`,
+      detail: value ? void 0 : "Required for Android testing."
+    });
+  }
+  const aiProvider = process.env.MOBWRIGHT_AI_PROVIDER;
+  const aiKey = process.env.MOBWRIGHT_AI_API_KEY;
+  if (!aiProvider || !aiKey) {
+    results.push({
+      status: "warn",
+      label: "MOBWRIGHT_AI_API_KEY not set",
+      detail: "AI features (device.ai) unavailable until set."
+    });
+  } else {
+    results.push({
+      status: "ok",
+      label: `AI provider: ${aiProvider}`
+    });
+  }
+  return { title: "Environment variables", results };
+}
+function symbol(status) {
+  switch (status) {
+    case "ok":
+      return green("\u2714");
+    case "info":
+      return green("\u2713");
+    case "warn":
+      return yellow("\u2717");
+    case "fail":
+      return red("\u2717");
+  }
+}
+function renderSection(section) {
+  console.log("\n" + bold(section.title));
+  for (const r of section.results) {
+    const indent = "  ";
+    console.log(`${indent}${symbol(r.status)} ${r.label}`);
+    if (r.detail) {
+      console.log(`${indent}  ${dim(r.detail)}`);
+    }
+  }
+}
+async function runDoctor() {
+  console.log(bold("\u{1F50D} Mobwright environment check"));
+  const sections = await Promise.all([
+    checkSystem(),
+    checkAndroid(),
+    checkIOS(),
+    checkAppium()
+  ]);
+  sections.push(checkEnvVars());
+  for (const section of sections) {
+    renderSection(section);
+  }
+  const all = sections.flatMap((s) => s.results);
+  const fails = all.filter((r) => r.status === "fail").length;
+  const warns = all.filter((r) => r.status === "warn").length;
+  console.log("");
+  if (fails > 0) {
+    console.log(red(bold(`Result: ${fails} error${fails > 1 ? "s" : ""}, ${warns} warning${warns !== 1 ? "s" : ""}.`)));
+    console.log(dim("Fix errors above before running tests."));
+    return 1;
+  }
+  if (warns > 0) {
+    console.log(yellow(bold(`Result: ${warns} warning${warns > 1 ? "s" : ""}.`)));
+    console.log(dim("Tests should run, but some features may be limited."));
+    return 0;
+  }
+  console.log(green(bold("Result: All checks passed. \u2728")));
+  return 0;
+}
+
+// src/cli/init.ts
+import { mkdir, writeFile, readdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path from "path";
+import { exec as execCb2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/cli/prompt.ts
+import { createInterface } from "readline/promises";
+var rl = null;
+function getInterface() {
+  if (!rl) {
+    rl = createInterface({ input: process.stdin, output: process.stdout });
+  }
+  return rl;
+}
+function closePrompt() {
+  if (rl) {
+    rl.close();
+    rl = null;
+  }
+}
+async function ask(question, defaultValue) {
+  const suffix = defaultValue !== void 0 ? ` (${defaultValue})` : "";
+  const answer = (await getInterface().question(`${question}${suffix}: `)).trim();
+  return answer || defaultValue || "";
+}
+async function confirm(question, defaultYes = true) {
+  const hint = defaultYes ? "Y/n" : "y/N";
+  const answer = (await getInterface().question(`${question} (${hint}): `)).trim().toLowerCase();
+  if (!answer) return defaultYes;
+  return answer === "y" || answer === "yes";
+}
+async function pickOne(question, options, defaultIndex = 0) {
+  console.log(question);
+  options.forEach((opt, idx) => {
+    const marker = idx === defaultIndex ? "\u203A" : " ";
+    console.log(`  ${marker} ${idx + 1}. ${opt}`);
+  });
+  const raw = (await getInterface().question(`Choose (1-${options.length}, default ${defaultIndex + 1}): `)).trim();
+  const choice = raw ? parseInt(raw, 10) - 1 : defaultIndex;
+  if (Number.isNaN(choice) || choice < 0 || choice >= options.length) {
+    return options[defaultIndex];
+  }
+  return options[choice];
+}
+
+// src/cli/templates.ts
+var PACKAGE_JSON = (opts) => JSON.stringify(
+  {
+    name: opts.name,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      test: "mobwright test",
+      "test:android": "mobwright test --project=android",
+      "test:ios": "mobwright test --project=ios",
+      doctor: "mobwright doctor"
+    },
+    devDependencies: {
+      "@playwright/test": "^1.48.0",
+      mobwright: "^0.1.0",
+      dotenv: "^16.4.0",
+      typescript: "^5.4.0"
+    }
+  },
+  null,
+  2
+) + "\n";
+var TSCONFIG = () => JSON.stringify(
+  {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true
+    },
+    include: ["tests/**/*", "playwright.config.ts"]
+  },
+  null,
+  2
+) + "\n";
+var PLAYWRIGHT_CONFIG = (opts) => {
+  const projects = opts.platforms.map(
+    (p) => `    {
+      name: '${p}',
+      testMatch: ['**/shared/**', '**/${p}/**'],
+    },`
+  ).join("\n");
+  return `import { defineConfig } from '@playwright/test';
+import dotenv from 'dotenv';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: path.join(__dirname, '.env') });
+
+export default defineConfig({
+  testDir: './tests',
+  fullyParallel: false,
+  retries: 0,
+  workers: 1,
+  reporter: 'list',
+  timeout: 120_000,
+  projects: [
+${projects}
+  ],
+});
+`;
+};
+var ENV_EXAMPLE = (opts) => {
+  const lines = ["# Mobwright local config \u2014 copy to .env and fill in.", ""];
+  if (opts.platforms.includes("android")) {
+    lines.push(
+      "# Android",
+      "MOBWRIGHT_APP_PATH=/absolute/path/to/your/app.apk",
+      "MOBWRIGHT_ANDROID_AVD=Pixel_6_API_34",
+      "# MOBWRIGHT_ANDROID_APP_PACKAGE=com.example",
+      "# MOBWRIGHT_ANDROID_APP_ACTIVITY=com.example.MainActivity",
+      ""
+    );
+  }
+  if (opts.platforms.includes("ios")) {
+    lines.push(
+      "# iOS",
+      "MOBWRIGHT_IOS_DEVICE=iPhone 15",
+      "MOBWRIGHT_IOS_BUNDLE_ID=com.example.app",
+      "# MOBWRIGHT_IOS_APP_PATH=/absolute/path/to/My.app",
+      "# MOBWRIGHT_IOS_UDID=",
+      ""
+    );
+  }
+  if (opts.aiProvider !== "none") {
+    lines.push(
+      "# AI provider",
+      `MOBWRIGHT_AI_PROVIDER=${opts.aiProvider}`,
+      "MOBWRIGHT_AI_API_KEY=sk-...",
+      ""
+    );
+  } else {
+    lines.push(
+      "# AI provider (optional)",
+      "# MOBWRIGHT_AI_PROVIDER=deepseek",
+      "# MOBWRIGHT_AI_API_KEY=sk-...",
+      ""
+    );
+  }
+  return lines.join("\n");
+};
+var GITIGNORE = () => `node_modules/
+.env
+.env.local
+test-results/
+playwright-report/
+*.log
+.DS_Store
+`;
+var SANITY_SPEC = () => `import { test, expect } from 'mobwright';
+
+test('session boots cleanly', async ({ device }) => {
+  expect(device.browser.sessionId).toBeTruthy();
+  console.log(\`\u2713 \${device.project} session\`);
+});
+
+test('can take a screenshot', async ({ device }) => {
+  const png = await device.screenshot();
+  expect(png.length).toBeGreaterThan(1000);
+});
+`;
+var PLATFORM_EXAMPLE = (platform) => `import { test, expect } from 'mobwright';
+
+test('${platform}: example test', async ({ device }) => {
+  // Replace with a real selector from your app
+  const greeting = device.locator('~welcome');
+
+  // Auto-waits up to 5 seconds for the element to appear
+  await expect(greeting).toBeVisible();
+});
+`;
+var README = (opts) => `# ${opts.name}
+
+Mobile e2e tests powered by [mobwright](https://www.npmjs.com/package/mobwright).
+
+## Setup
+
+1. Copy \`.env.example\` to \`.env\` and fill in your device info:
+   \`\`\`bash
+   cp .env.example .env
+   \`\`\`
+
+2. Verify your environment:
+   \`\`\`bash
+   npx mobwright doctor
+   \`\`\`
+
+3. Boot a device (Android emulator or iOS simulator).
+
+4. Start the Appium server in a separate terminal:
+   \`\`\`bash
+   appium
+   \`\`\`
+
+5. Run the tests:
+   \`\`\`bash
+   npm test                # both platforms
+   npm run test:android    # Android only${opts.platforms.includes("ios") ? `
+   npm run test:ios        # iOS only` : ""}
+   \`\`\`
+
+## Project structure
+
+\`\`\`
+tests/
+\u251C\u2500\u2500 shared/   # Tests that run on both platforms
+${opts.platforms.includes("android") ? "\u251C\u2500\u2500 android/  # Android-only tests\n" : ""}${opts.platforms.includes("ios") ? "\u2514\u2500\u2500 ios/      # iOS-only tests\n" : ""}\`\`\`
+
+## Learn more
+
+- [Mobwright docs](https://github.com/yourname/mobwright)
+- [Playwright test runner](https://playwright.dev/docs/test-intro)
+`;
+
+// src/cli/init.ts
+var exec2 = promisify2(execCb2);
+async function runInit(flags = {}) {
+  console.log(bold("\u{1FA84} Mobwright project setup\n"));
+  try {
+    const dirInput = flags.dir ?? (flags.yes ? "./my-mobile-tests" : await ask("Project directory", "./my-mobile-tests"));
+    const targetDir = path.resolve(dirInput);
+    if (existsSync2(targetDir)) {
+      const contents = await readdir(targetDir);
+      const nonHidden = contents.filter((f) => !f.startsWith("."));
+      if (nonHidden.length > 0 && !flags.force) {
+        console.error(red(`\u2717 Directory ${targetDir} is not empty.`));
+        console.error(dim("  Pass --force to overwrite, or pick another directory."));
+        return 1;
+      }
+    }
+    let platforms;
+    if (flags.platforms) {
+      platforms = parsePlatformsFlag(flags.platforms);
+    } else if (flags.yes) {
+      platforms = ["android", "ios"];
+    } else {
+      const choice = await pickOne(
+        "Which platforms?",
+        ["Both Android and iOS", "Android only", "iOS only"]
+      );
+      platforms = choice === "Android only" ? ["android"] : choice === "iOS only" ? ["ios"] : ["android", "ios"];
+    }
+    const aiProvider = flags.ai ? parseAIFlag(flags.ai) : flags.yes ? "none" : await pickOne(
+      "AI provider (optional)?",
+      ["none", "deepseek", "openai", "anthropic"]
+    );
+    const shouldInstall = flags.skipInstall ? false : flags.yes ? true : await confirm("Install dependencies now?", true);
+    const projectName = path.basename(targetDir).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    const opts = {
+      name: projectName,
+      platforms,
+      aiProvider
+    };
+    console.log("");
+    console.log(`Creating project at ${dim(targetDir)}...`);
+    await mkdir(targetDir, { recursive: true });
+    await writeFiles(targetDir, opts);
+    if (shouldInstall) {
+      console.log("  " + dim("Installing dependencies (this may take a minute)..."));
+      try {
+        await exec2("npm install", { cwd: targetDir });
+        console.log(`  ${green("\u2714")} Dependencies installed`);
+      } catch (err) {
+        console.log(`  ${yellow("\u2717")} Install failed. Run \`npm install\` manually in ${projectName}/.`);
+      }
+    }
+    printNextSteps(projectName, shouldInstall);
+    return 0;
+  } catch (err) {
+    if (err.code === "ERR_USE_AFTER_CLOSE") {
+      console.log("\n" + yellow("Cancelled."));
+      return 130;
+    }
+    console.error(red(`\u2717 ${err.message}`));
+    return 1;
+  } finally {
+    closePrompt();
+  }
+}
+async function writeFiles(targetDir, opts) {
+  const files = [
+    ["package.json", PACKAGE_JSON(opts)],
+    ["tsconfig.json", TSCONFIG()],
+    ["playwright.config.ts", PLAYWRIGHT_CONFIG(opts)],
+    [".env.example", ENV_EXAMPLE(opts)],
+    [".gitignore", GITIGNORE()],
+    ["README.md", README(opts)],
+    ["tests/shared/sanity.spec.ts", SANITY_SPEC()]
+  ];
+  for (const platform of opts.platforms) {
+    files.push([`tests/${platform}/example.spec.ts`, PLATFORM_EXAMPLE(platform)]);
+  }
+  for (const [relPath, content] of files) {
+    const fullPath = path.join(targetDir, relPath);
+    await mkdir(path.dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content, "utf8");
+    console.log(`  ${green("\u2714")} ${relPath}`);
+  }
+}
+function parsePlatformsFlag(value) {
+  const parts = value.split(",").map((p) => p.trim().toLowerCase());
+  const result = [];
+  for (const p of parts) {
+    if (p === "android" || p === "ios") {
+      result.push(p);
+    } else {
+      throw new Error(`Unknown platform: ${p} (use 'android' or 'ios')`);
+    }
+  }
+  if (result.length === 0) {
+    throw new Error("At least one platform required");
+  }
+  return result;
+}
+function parseAIFlag(value) {
+  const v = value.trim().toLowerCase();
+  if (v === "none" || v === "anthropic" || v === "openai" || v === "deepseek") {
+    return v;
+  }
+  throw new Error(`Unknown AI provider: ${value} (use 'none', 'anthropic', 'openai', 'deepseek')`);
+}
+function printNextSteps(projectName, installed) {
+  console.log("");
+  console.log(green(bold("\u2728 Done!")) + " Next steps:\n");
+  console.log(`  ${dim("# enter your new project")}`);
+  console.log(`  cd ${projectName}
+`);
+  if (!installed) {
+    console.log(`  ${dim("# install dependencies")}`);
+    console.log(`  npm install
+`);
+  }
+  console.log(`  ${dim("# configure your devices")}`);
+  console.log(`  cp .env.example .env
+`);
+  console.log(`  ${dim("# verify your environment")}`);
+  console.log(`  npx mobwright doctor
+`);
+  console.log(`  ${dim("# boot a device + run Appium in another terminal, then:")}`);
+  console.log(`  npx playwright test`);
+  console.log("");
+}
+
+// src/cli/test.ts
+import { spawn } from "child_process";
+async function runTest(flags) {
+  console.log(bold("\u{1F3AF} Mobwright \u2014 running tests") + "\n");
+  if (!flags.noPreflight) {
+    const ok = await checkAppium2();
+    if (!ok) {
+      const port = process.env.MOBWRIGHT_APPIUM_PORT ?? "4723";
+      console.error(red("\u2717") + ` Appium server not reachable at http://localhost:${port}.`);
+      console.error(dim("  Start it in another terminal:  ") + bold("appium"));
+      console.error(dim("  Or skip this check:           ") + bold("npx mobwright test --no-preflight"));
+      console.error("");
+      return 1;
+    }
+    console.log(green("\u2714") + " Appium reachable");
+    console.log("");
+  }
+  return await forwardToPlaywright(flags.rest);
+}
+async function checkAppium2() {
+  const port = process.env.MOBWRIGHT_APPIUM_PORT ?? "4723";
+  const url = `http://localhost:${port}/status`;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+    const res = await fetch(url, { signal: controller.signal });
+    clearTimeout(timer);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function forwardToPlaywright(args) {
+  return new Promise((resolve) => {
+    const child = spawn("npx", ["playwright", "test", ...args], {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+      // Windows needs shell=true for npx
+    });
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        resolve(128);
+        return;
+      }
+      resolve(code ?? 0);
+    });
+    child.on("error", (err) => {
+      console.error(red("\u2717") + ` Failed to spawn playwright: ${err.message}`);
+      console.error(dim("  Is @playwright/test installed?"));
+      resolve(1);
+    });
+  });
+}
+
+// src/cli/index.ts
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "doctor": {
+      const exitCode = await runDoctor();
+      process.exit(exitCode);
+    }
+    case "init": {
+      const flags = parseInitFlags(args.slice(1));
+      const exitCode = await runInit(flags);
+      process.exit(exitCode);
+    }
+    case "test": {
+      const flags = parseTestFlags(args.slice(1));
+      const exitCode = await runTest(flags);
+      process.exit(exitCode);
+    }
+    case void 0:
+    case "-h":
+    case "--help":
+    case "help": {
+      printHelp();
+      process.exit(0);
+    }
+    case "-v":
+    case "--version": {
+      console.log("mobwright 0.1.0");
+      process.exit(0);
+    }
+    default: {
+      console.error(`Unknown command: ${command}`);
+      console.error("");
+      printHelp();
+      process.exit(2);
+    }
+  }
+}
+function parseInitFlags(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-y" || arg === "--yes") {
+      flags.yes = true;
+    } else if (arg === "--force") {
+      flags.force = true;
+    } else if (arg === "--skip-install") {
+      flags.skipInstall = true;
+    } else if (arg === "--dir") {
+      flags.dir = args[++i];
+    } else if (arg.startsWith("--dir=")) {
+      flags.dir = arg.slice("--dir=".length);
+    } else if (arg === "--platforms") {
+      flags.platforms = args[++i];
+    } else if (arg.startsWith("--platforms=")) {
+      flags.platforms = arg.slice("--platforms=".length);
+    } else if (arg === "--ai") {
+      flags.ai = args[++i];
+    } else if (arg.startsWith("--ai=")) {
+      flags.ai = arg.slice("--ai=".length);
+    } else if (!arg.startsWith("-") && !flags.dir) {
+      flags.dir = arg;
+    }
+  }
+  return flags;
+}
+function parseTestFlags(args) {
+  const flags = { rest: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--no-preflight") {
+      flags.noPreflight = true;
+    } else {
+      flags.rest.push(arg);
+    }
+  }
+  return flags;
+}
+function printHelp() {
+  console.log(`mobwright \u2014 mobile e2e testing with AI
+
+Usage:
+  mobwright <command> [options]
+
+Commands:
+  init [dir]   Scaffold a new mobwright project
+  test         Run your test suite
+  doctor       Check your environment for required tools and config
+  help         Show this help
+
+init options:
+  --yes, -y           Accept all defaults (no prompts)
+  --dir <path>        Project directory (default: ./my-mobile-tests)
+  --platforms <list>  Comma-separated: android,ios (default: both)
+  --ai <provider>     none, deepseek, openai, anthropic (default: none)
+  --skip-install      Don't run npm install
+  --force             Overwrite non-empty target directory
+
+test options:
+  --no-preflight      Skip Appium reachability check
+  All other args are forwarded to \`playwright test\`.
+
+Examples:
+  mobwright init
+  mobwright test --project=android
+  mobwright test --grep "login" --workers=2
+  mobwright doctor
+
+Docs: https://github.com/yourname/mobwright
+`);
+}
+main().catch((err) => {
+  console.error("Unexpected error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map