@jskit-ai/jskit-cli 0.2.74 → 0.2.76

package/src/server/commandHandlers/mobile.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { spawn } from "node:child_process";
-import { readFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import {
   createColorFormatter,
   writeWrappedLines
@@ -23,6 +23,10 @@ import {
 } from "./mobileShellSupport.js";
 const CAPACITOR_RUNTIME_PACKAGE_ID = "@jskit-ai/mobile-capacitor";
 const MOBILE_NOTES_RELATIVE_PATH = path.join(".jskit", "mobile-capacitor.md");
+const MANAGED_MOBILE_FILE_RELATIVE_PATHS = Object.freeze([
+  "capacitor.config.json",
+  MOBILE_NOTES_RELATIVE_PATH
+]);
 
 async function collectManagedMobileFileDriftIssues({
   ctx,
@@ -34,12 +38,7 @@ async function collectManagedMobileFileDriftIssues({
     path: pathModule,
     normalizeRelativePath
   } = ctx;
-  const managedRelativePaths = [
-    "capacitor.config.json",
-    MOBILE_NOTES_RELATIVE_PATH
-  ];
-
-  for (const relativePath of managedRelativePaths) {
+  for (const relativePath of MANAGED_MOBILE_FILE_RELATIVE_PATHS) {
     const absolutePath = pathModule.join(appRoot, relativePath);
     if (!(await fileExists(absolutePath))) {
       continue;
@@ -60,70 +59,59 @@ async function collectManagedMobileFileDriftIssues({
     }
     if (currentContent !== expectedContent) {
       issues.push(
-        `${normalizeRelativePath(appRoot, absolutePath)} is stale and no longer matches config.mobile. Re-run jskit mobile sync android to refresh managed mobile-shell files.`
+        `${normalizeRelativePath(appRoot, absolutePath)} is stale and no longer matches config.mobile. Re-run jskit mobile android sync to refresh managed mobile-shell files.`
       );
     }
   }
 }
 
-async function collectMissingInstalledDependencyNames(ctx, appRoot = "", packageJson = {}) {
-  const {
-    fileExists,
-    path: pathModule
-  } = ctx;
-  const sections = [
-    packageJson?.dependencies,
-    packageJson?.devDependencies,
-    packageJson?.optionalDependencies
-  ];
-  const missing = [];
-  const seen = new Set();
-
-  for (const section of sections) {
-    if (!section || typeof section !== "object" || Array.isArray(section)) {
-      continue;
-    }
-
-    for (const packageName of Object.keys(section).sort((left, right) => left.localeCompare(right))) {
-      const normalizedPackageName = String(packageName || "").trim();
-      if (!normalizedPackageName || seen.has(normalizedPackageName)) {
-        continue;
-      }
-      seen.add(normalizedPackageName);
-
-      const packageJsonPath = pathModule.join(
-        appRoot,
-        "node_modules",
-        ...normalizedPackageName.split("/"),
-        "package.json"
+function renderAndroidMobileCommandList(lines, color) {
+  for (const entry of listMobileCommandDefinitions()) {
+    if (entry.name === "dev") {
+      lines.push(
+        `     - ${color.item(entry.name)}: Shortcut to run ${color.emphasis("sync")}, ${color.emphasis("tunnel")}, ${color.emphasis("run")} in this order`
       );
-      if (!(await fileExists(packageJsonPath))) {
-        missing.push(normalizedPackageName);
-      }
+      continue;
     }
+    lines.push(`     - ${color.item(entry.name)}: ${entry.summary}`);
   }
-
-  return missing;
 }
 
-function renderMobileHelp(stream, definition = null) {
+function renderMobileHelp(stream, definition = null, platform = "") {
   const color = createColorFormatter(stream);
   const lines = [];
 
-  if (!definition) {
+  if (!definition && !platform) {
     lines.push(`Command: ${color.emphasis("mobile")}`);
     lines.push("");
     lines.push(color.heading("1) Minimal use"));
-    lines.push("   jskit mobile <subcommand>");
+    lines.push("   jskit mobile <platform> <subcommand>");
     lines.push("");
-    lines.push(color.heading("2) Subcommands"));
-    for (const entry of listMobileCommandDefinitions()) {
-      lines.push(`   - ${color.item(entry.name)}: ${entry.summary}`);
-    }
+    lines.push(color.heading("2) Platforms"));
+    lines.push(`   - ${color.item("android")}`);
+    renderAndroidMobileCommandList(lines, color);
     lines.push("");
     lines.push(color.heading("3) Notes"));
     lines.push("   - Mobile helpers are for the Stage 1 Android Capacitor shell flow.");
-    lines.push("   - Use jskit mobile <subcommand> help for subcommand-specific usage.");
+    lines.push("   - Use jskit mobile <platform> help for platform-specific usage.");
+    writeWrappedLines({
+      stdout: stream,
+      lines
+    });
+    return;
+  }
+
+  if (!definition) {
+    lines.push(`Mobile platform: ${color.emphasis(platform)}`);
+    lines.push("");
+    lines.push(color.heading("1) Minimal use"));
+    lines.push(`   jskit mobile ${platform} <subcommand>`);
+    lines.push("");
+    lines.push(color.heading("2) Subcommands"));
+    renderAndroidMobileCommandList(lines, color);
+    lines.push("");
+    lines.push(color.heading("3) Notes"));
+    lines.push(`   - Use jskit mobile ${platform} <subcommand> help for subcommand-specific usage.`);
     writeWrappedLines({
       stdout: stream,
       lines
@@ -256,7 +244,7 @@ function resolveAdbReversePort({
   const port = Number(parsedUrl.port || "");
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
     throw createCliError(
-      `config.mobile.apiBaseUrl "${apiBaseUrl}" must include an explicit port so jskit mobile tunnel android can infer adb reverse.`
+      `config.mobile.apiBaseUrl "${apiBaseUrl}" must include an explicit port so jskit mobile android tunnel can infer adb reverse.`
     );
   }
 
@@ -337,7 +325,7 @@ async function resolveAndroidDeviceTarget({
     appRoot
   });
   if (devices.length < 1) {
-    throw ctx.createCliError(`No Android devices are visible to adb. Run jskit mobile devices android before ${commandLabel}.`);
+    throw ctx.createCliError(`No Android devices are visible to adb. Run jskit mobile android devices before ${commandLabel}.`);
   }
 
   const normalizedExplicitTarget = String(explicitTarget || "").trim();
@@ -346,7 +334,7 @@ async function resolveAndroidDeviceTarget({
     : devices[0];
 
   if (!selectedDevice) {
-    throw ctx.createCliError(`Android device "${normalizedExplicitTarget}" is not visible to adb. Run jskit mobile devices android first.`);
+    throw ctx.createCliError(`Android device "${normalizedExplicitTarget}" is not visible to adb. Run jskit mobile android devices first.`);
   }
   if (selectedDevice.state !== "device") {
     throw ctx.createCliError(`Android device "${selectedDevice.serial}" is currently "${selectedDevice.state}", not ready for ${commandLabel}.`);
@@ -400,9 +388,13 @@ async function runLocalBinary(binaryName, args = [], {
 
     child.on("error", (error) => {
       if (error?.code === "ENOENT") {
+        const installHint =
+          binaryName === "cap"
+            ? ` Run npm install after adding ${CAPACITOR_RUNTIME_PACKAGE_ID}, then rerun this command.`
+            : "";
         reject(
           createCliError(
-            `Could not find local "${binaryName}" in node_modules/.bin. Re-run jskit mobile add capacitor after npm install succeeds.`
+            `Could not find local "${binaryName}" in node_modules/.bin.${installHint}`
           )
         );
         return;
@@ -422,122 +414,93 @@ async function runLocalBinary(binaryName, args = [], {
   });
 }
 
-async function runMobileAppInstall({
+function hasPackageDependency(packageJson = {}, packageId = "") {
+  const sections = [
+    packageJson?.dependencies,
+    packageJson?.devDependencies,
+    packageJson?.optionalDependencies
+  ];
+  return sections.some((section) => (
+    section &&
+    typeof section === "object" &&
+    !Array.isArray(section) &&
+    Object.prototype.hasOwnProperty.call(section, packageId)
+  ));
+}
+
+async function readJsonFileForMobileCommand(filePath = "", label = "", createCliError) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch (error) {
+    const message = String(error?.message || error || "unknown error");
+    throw createCliError(`Could not read ${label}: ${message}`);
+  }
+}
+
+async function assertMobileRuntimePackageInstalled({
   ctx,
-  appRoot,
-  stdout,
-  stderr,
-  dryRun = false,
-  devlinks = false
+  appRoot
 } = {}) {
   const {
     path: pathModule,
-    loadAppPackageJson
+    createCliError
   } = ctx;
-  const { packageJson } = await loadAppPackageJson(appRoot);
-  const packageScripts = packageJson?.scripts && typeof packageJson.scripts === "object" ? packageJson.scripts : {};
-
-  await runLocalBinary("npm", ["install"], {
-    appRoot,
-    stderr,
-    stdout,
-    pathModule,
-    createCliError: ctx.createCliError,
-    dryRun
-  });
+  const packageJsonPath = pathModule.join(appRoot, "package.json");
+  const lockPath = pathModule.join(appRoot, ".jskit", "lock.json");
+  const packageJson = await readJsonFileForMobileCommand(packageJsonPath, "package.json", createCliError);
+  const lock = await readJsonFileForMobileCommand(lockPath, ".jskit/lock.json", createCliError);
+  const hasDependency = hasPackageDependency(packageJson, CAPACITOR_RUNTIME_PACKAGE_ID);
+  const hasLockRecord = Boolean(lock?.installedPackages?.[CAPACITOR_RUNTIME_PACKAGE_ID]);
 
-  if (devlinks === true && Object.prototype.hasOwnProperty.call(packageScripts, "devlinks")) {
-    await runLocalBinary("npm", ["run", "--if-present", "devlinks"], {
-      appRoot,
-      stderr,
-      stdout,
-      pathModule,
-      createCliError: ctx.createCliError,
-      dryRun
-    });
+  if (!hasDependency || !hasLockRecord) {
+    throw createCliError(
+      `Mobile Capacitor runtime package is not installed for this app. Run jskit add package ${CAPACITOR_RUNTIME_PACKAGE_ID} first.`
+    );
   }
 }
 
 async function refreshManagedMobileFiles({
   ctx,
-  commandAdd,
   appRoot,
   options = {},
-  stdout,
-  stderr
+  stdout
 } = {}) {
   const {
-    path: pathModule
+    fileExists,
+    path: pathModule,
+    normalizeRelativePath,
+    createCliError
   } = ctx;
-  const packageJsonPath = pathModule.join(appRoot, "package.json");
-  const packageJsonBefore = await readFile(packageJsonPath, "utf8");
-  let capturedStdout = "";
-  await commandAdd({
-    positional: ["package", CAPACITOR_RUNTIME_PACKAGE_ID],
-    options: {
-      ...options,
-      forceReapplyTarget: true,
-      runNpmInstall: false,
-      inlineOptions: {}
-    },
-    cwd: appRoot,
-    io: {
-      stdout: {
-        write(chunk) {
-          capturedStdout += String(chunk || "");
-        }
-      },
-      stderr
-    }
-  });
-  const packageJsonAfter = await readFile(packageJsonPath, "utf8");
-  const parsedPackageJsonAfter = JSON.parse(packageJsonAfter);
-  const missingInstalledDependencies = await collectMissingInstalledDependencyNames(ctx, appRoot, parsedPackageJsonAfter);
 
-  if (!/Touched files \(0\):/u.test(capturedStdout)) {
-    stdout.write(capturedStdout);
-  }
+  for (const relativePath of MANAGED_MOBILE_FILE_RELATIVE_PATHS) {
+    const absolutePath = pathModule.join(appRoot, relativePath);
+    if (!(await fileExists(absolutePath))) {
+      throw createCliError(
+        `Managed mobile file is missing: ${normalizeRelativePath(appRoot, absolutePath)}. Run jskit add package ${CAPACITOR_RUNTIME_PACKAGE_ID} first.`
+      );
+    }
 
-  if (
-    options?.dryRun !== true &&
-    (packageJsonAfter !== packageJsonBefore || missingInstalledDependencies.length > 0)
-  ) {
-    await runMobileAppInstall({
-      ctx,
+    const currentSource = await readFile(absolutePath, "utf8");
+    const nextSource = await renderManagedMobileFile({
       appRoot,
-      stdout,
-      stderr,
-      dryRun: false,
-      devlinks: options?.devlinks === true
+      relativeTargetPath: relativePath
     });
-  }
-}
+    if (nextSource === currentSource) {
+      continue;
+    }
 
-async function runMobileAddCapacitorCommand({
-  commandAdd,
-  appRoot,
-  options = {},
-  stdout,
-  stderr
-}) {
-  return await commandAdd({
-    positional: ["package", CAPACITOR_RUNTIME_PACKAGE_ID],
-    options: {
-      ...options,
-      runNpmInstall: true,
-      inlineOptions: {}
-    },
-    cwd: appRoot,
-    io: {
-      stdout,
-      stderr
+    if (options?.dryRun === true) {
+      stdout?.write(`[dry-run] refresh ${normalizeRelativePath(appRoot, absolutePath)}\n`);
+      continue;
     }
-  });
+
+    await writeFile(absolutePath, nextSource, "utf8");
+    stdout?.write(`[mobile] Refreshed ${normalizeRelativePath(appRoot, absolutePath)}.\n`);
+  }
 }
 
 async function runMobileSyncAndroidCommand({
   ctx,
-  commandAdd,
   appRoot,
   options = {},
   stdout,
@@ -547,19 +510,20 @@ async function runMobileSyncAndroidCommand({
     path: pathModule
   } = ctx;
 
-  await refreshManagedMobileFiles({
+  await assertMobileRuntimePackageInstalled({
     ctx,
-    commandAdd,
-    appRoot,
-    options,
-    stdout,
-    stderr
+    appRoot
   });
-
   await assertCapacitorShellInstalled({
     ctx,
     appRoot
   });
+  await refreshManagedMobileFiles({
+    ctx,
+    appRoot,
+    options,
+    stdout
+  });
   await ensureAndroidNativeShellIdentity({
     ctx,
     appRoot,
@@ -600,7 +564,6 @@ async function runMobileSyncAndroidCommand({
 
 async function runMobileRunAndroidCommand({
   ctx,
-  commandAdd,
   appRoot,
   options = {},
   stdout,
@@ -625,26 +588,26 @@ async function runMobileRunAndroidCommand({
   if (mobileConfig.assetMode === "bundled") {
     await runMobileSyncAndroidCommand({
       ctx,
-      commandAdd,
       appRoot,
       options,
       stdout,
       stderr
     });
   } else {
-    await refreshManagedMobileFiles({
+    await assertMobileRuntimePackageInstalled({
       ctx,
-      commandAdd,
-      appRoot,
-      options,
-      stdout,
-      stderr
+      appRoot
     });
-
     await assertCapacitorShellInstalled({
       ctx,
       appRoot
     });
+    await refreshManagedMobileFiles({
+      ctx,
+      appRoot,
+      options,
+      stdout
+    });
     await ensureAndroidNativeShellIdentity({
       ctx,
       appRoot,
@@ -715,7 +678,6 @@ async function runCapRunAndroidCommand({
 
 async function runMobileBuildAndroidCommand({
   ctx,
-  commandAdd,
   appRoot,
   options = {},
   stdout,
@@ -738,13 +700,12 @@ async function runMobileBuildAndroidCommand({
 
   if (mobileConfig.assetMode !== "bundled") {
     throw createCliError(
-      'jskit mobile build android requires config.mobile.assetMode="bundled" so the release shell does not depend on a live dev server.'
+      'jskit mobile android build requires config.mobile.assetMode="bundled" so the release shell does not depend on a live dev server.'
     );
   }
 
   await runMobileSyncAndroidCommand({
     ctx,
-    commandAdd,
     appRoot,
     options,
     stdout,
@@ -906,9 +867,6 @@ async function runMobileTunnelAndroidCommand({
 }) {
   const inlineOptions = normalizeInlineOptions(options);
   const target = String(inlineOptions.target || "").trim();
-  if (!target) {
-    throw ctx.createCliError("jskit mobile tunnel android requires --target <device-id>.");
-  }
 
   const mobileConfig = await resolveInstalledMobileConfigForCommand({
     appRoot,
@@ -960,9 +918,6 @@ async function runMobileRestartAndroidCommand({
 }) {
   const inlineOptions = normalizeInlineOptions(options);
   const target = String(inlineOptions.target || "").trim();
-  if (!target) {
-    throw ctx.createCliError("jskit mobile restart android requires --target <device-id>.");
-  }
 
   const mobileConfig = await resolveInstalledMobileConfigForCommand({
     appRoot,
@@ -1004,7 +959,6 @@ async function runMobileRestartAndroidCommand({
 
 async function runMobileDevAndroidCommand({
   ctx,
-  commandAdd,
   appRoot,
   options = {},
   stdout,
@@ -1020,30 +974,17 @@ async function runMobileDevAndroidCommand({
 
   stdout.write(`[mobile] Using Android device: ${selectedDevice.serial}\n`);
   stdout.write("[mobile] Building and syncing the Android shell:\n");
-  stdout.write("[mobile]   npx jskit mobile sync android\n");
+  stdout.write("[mobile]   npx jskit mobile android sync\n");
   await runMobileSyncAndroidCommand({
     ctx,
-    commandAdd,
     appRoot,
     options,
     stdout,
     stderr
   });
 
-  stdout.write(`[mobile] Installing and launching the app on ${selectedDevice.serial}:\n`);
-  stdout.write(`[mobile]   npx jskit mobile run android --target ${selectedDevice.serial}\n`);
-  await runCapRunAndroidCommand({
-    ctx,
-    appRoot,
-    pathModule: ctx.path,
-    target: selectedDevice.serial,
-    stdout,
-    stderr,
-    dryRun: false
-  });
-
   stdout.write(`[mobile] Creating the adb reverse tunnel on ${selectedDevice.serial}:\n`);
-  stdout.write(`[mobile]   npx jskit mobile tunnel android --target ${selectedDevice.serial}\n`);
+  stdout.write(`[mobile]   npx jskit mobile android tunnel --target ${selectedDevice.serial}\n`);
   await runMobileTunnelAndroidCommand({
     ctx,
     appRoot,
@@ -1056,23 +997,32 @@ async function runMobileDevAndroidCommand({
     stderr
   });
 
+  stdout.write(`[mobile] Installing and launching the app on ${selectedDevice.serial}:\n`);
+  stdout.write(`[mobile]   npx jskit mobile android run --target ${selectedDevice.serial}\n`);
+  await runCapRunAndroidCommand({
+    ctx,
+    appRoot,
+    pathModule: ctx.path,
+    target: selectedDevice.serial,
+    stdout,
+    stderr,
+    dryRun: false
+  });
+
   return 0;
 }
 
-function createMobileCommands(ctx = {}, { commandAdd } = {}) {
+function createMobileCommands(ctx = {}) {
   const {
     createCliError,
     resolveAppRootFromCwd
   } = ctx;
 
-  if (typeof commandAdd !== "function") {
-    throw new TypeError("createMobileCommands requires commandAdd().");
-  }
-
   async function commandMobile({ positional = [], options = {}, cwd = "", stdout, stderr }) {
     const firstToken = String(positional[0] || "").trim();
     const secondToken = String(positional[1] || "").trim();
-    const remainingPositionals = positional.slice(2);
+    const thirdToken = String(positional[2] || "").trim();
+    const remainingPositionals = positional.slice(3);
 
     if (!firstToken) {
       renderMobileHelp(stdout);
@@ -1080,19 +1030,31 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     }
 
     if (firstToken === "help") {
-      renderMobileHelp(stdout, resolveMobileCommandDefinition(secondToken));
+      renderMobileHelp(stdout);
       return 0;
     }
 
-    const definition = resolveMobileCommandDefinition(firstToken);
-    if (!definition) {
-      throw createCliError(`Unknown mobile subcommand: ${firstToken}.`, {
+    const platform = firstToken;
+    if (platform !== "android") {
+      throw createCliError(`Unknown mobile platform: ${platform}.`, {
         renderUsage: () => renderMobileHelp(stderr)
       });
     }
 
-    if (secondToken === "help") {
-      renderMobileHelp(stdout, definition);
+    if (!secondToken || secondToken === "help") {
+      renderMobileHelp(stdout, null, platform);
+      return 0;
+    }
+
+    const definition = resolveMobileCommandDefinition(secondToken);
+    if (!definition) {
+      throw createCliError(`Unknown mobile ${platform} subcommand: ${secondToken}.`, {
+        renderUsage: () => renderMobileHelp(stderr, null, platform)
+      });
+    }
+
+    if (thirdToken === "help") {
+      renderMobileHelp(stdout, definition, platform);
       return 0;
     }
 
@@ -1102,14 +1064,14 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     const unknownInlineOptionNames = inlineOptionNames.filter((optionName) => !supportedOptionNames.has(optionName));
     if (unknownInlineOptionNames.length > 0) {
       throw createCliError(
-        `Unknown option${unknownInlineOptionNames.length === 1 ? "" : "s"} for jskit mobile ${definition.name}: ${unknownInlineOptionNames.map((optionName) => `--${optionName}`).join(", ")}.`,
+        `Unknown option${unknownInlineOptionNames.length === 1 ? "" : "s"} for jskit mobile ${platform} ${definition.name}: ${unknownInlineOptionNames.map((optionName) => `--${optionName}`).join(", ")}.`,
         {
           renderUsage: () => renderMobileHelp(stderr, definition)
         }
       );
     }
     if (options?.dryRun === true && !supportedOptionNames.has("dry-run")) {
-      throw createCliError(`Unknown option for jskit mobile ${definition.name}: --dry-run.`, {
+      throw createCliError(`Unknown option for jskit mobile ${platform} ${definition.name}: --dry-run.`, {
         renderUsage: () => renderMobileHelp(stderr, definition)
       });
     }
@@ -1117,13 +1079,8 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     const appRoot = await resolveAppRootFromCwd(cwd);
 
     if (definition.name === "devices") {
-      if (secondToken !== "android") {
-        throw createCliError(`jskit mobile devices currently supports only "android".`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-      if (remainingPositionals.length > 0) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile devices: ${remainingPositionals.join(" ")}`, {
+      if (thirdToken || remainingPositionals.length > 0) {
+        throw createCliError(`Unexpected positional arguments for jskit mobile ${platform} devices: ${[thirdToken, ...remainingPositionals].filter(Boolean).join(" ")}`, {
           renderUsage: () => renderMobileHelp(stderr, definition)
         });
       }
@@ -1137,20 +1094,14 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     }
 
     if (definition.name === "dev") {
-      if (secondToken !== "android") {
-        throw createCliError(`jskit mobile dev currently supports only "android".`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-      if (remainingPositionals.length > 0) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile dev: ${remainingPositionals.join(" ")}`, {
+      if (thirdToken || remainingPositionals.length > 0) {
+        throw createCliError(`Unexpected positional arguments for jskit mobile ${platform} dev: ${[thirdToken, ...remainingPositionals].filter(Boolean).join(" ")}`, {
           renderUsage: () => renderMobileHelp(stderr, definition)
         });
       }
 
       return runMobileDevAndroidCommand({
         ctx,
-        commandAdd,
         appRoot,
         options,
         stdout,
@@ -1159,13 +1110,8 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     }
 
     if (definition.name === "tunnel") {
-      if (secondToken !== "android") {
-        throw createCliError(`jskit mobile tunnel currently supports only "android".`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-      if (remainingPositionals.length > 0) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile tunnel: ${remainingPositionals.join(" ")}`, {
+      if (thirdToken || remainingPositionals.length > 0) {
+        throw createCliError(`Unexpected positional arguments for jskit mobile ${platform} tunnel: ${[thirdToken, ...remainingPositionals].filter(Boolean).join(" ")}`, {
           renderUsage: () => renderMobileHelp(stderr, definition)
         });
       }
@@ -1180,13 +1126,8 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     }
 
     if (definition.name === "restart") {
-      if (secondToken !== "android") {
-        throw createCliError(`jskit mobile restart currently supports only "android".`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-      if (remainingPositionals.length > 0) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile restart: ${remainingPositionals.join(" ")}`, {
+      if (thirdToken || remainingPositionals.length > 0) {
+        throw createCliError(`Unexpected positional arguments for jskit mobile ${platform} restart: ${[thirdToken, ...remainingPositionals].filter(Boolean).join(" ")}`, {
           renderUsage: () => renderMobileHelp(stderr, definition)
         });
       }
@@ -1200,43 +1141,15 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
       });
     }
 
-    if (definition.name === "add") {
-      if (secondToken !== "capacitor") {
-        throw createCliError(`jskit mobile add currently supports only "capacitor".`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-      if (remainingPositionals.length > 0) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile add: ${remainingPositionals.join(" ")}`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-
-      return runMobileAddCapacitorCommand({
-        ctx,
-        commandAdd,
-        appRoot,
-        options,
-        stdout,
-        stderr
-      });
-    }
-
     if (definition.name === "sync") {
-      if (secondToken !== "android") {
-        throw createCliError(`jskit mobile sync currently supports only "android".`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-      if (remainingPositionals.length > 0) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile sync: ${remainingPositionals.join(" ")}`, {
+      if (thirdToken || remainingPositionals.length > 0) {
+        throw createCliError(`Unexpected positional arguments for jskit mobile ${platform} sync: ${[thirdToken, ...remainingPositionals].filter(Boolean).join(" ")}`, {
           renderUsage: () => renderMobileHelp(stderr, definition)
         });
       }
 
       return runMobileSyncAndroidCommand({
         ctx,
-        commandAdd,
         appRoot,
         options,
         stdout,
@@ -1245,20 +1158,14 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     }
 
     if (definition.name === "run") {
-      if (secondToken !== "android") {
-        throw createCliError(`jskit mobile run currently supports only "android".`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-      if (remainingPositionals.length > 0) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile run: ${remainingPositionals.join(" ")}`, {
+      if (thirdToken || remainingPositionals.length > 0) {
+        throw createCliError(`Unexpected positional arguments for jskit mobile ${platform} run: ${[thirdToken, ...remainingPositionals].filter(Boolean).join(" ")}`, {
           renderUsage: () => renderMobileHelp(stderr, definition)
         });
       }
 
       return runMobileRunAndroidCommand({
         ctx,
-        commandAdd,
         appRoot,
         options,
         stdout,
@@ -1267,20 +1174,14 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     }
 
     if (definition.name === "build") {
-      if (secondToken !== "android") {
-        throw createCliError(`jskit mobile build currently supports only "android".`, {
-          renderUsage: () => renderMobileHelp(stderr, definition)
-        });
-      }
-      if (remainingPositionals.length > 0) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile build: ${remainingPositionals.join(" ")}`, {
+      if (thirdToken || remainingPositionals.length > 0) {
+        throw createCliError(`Unexpected positional arguments for jskit mobile ${platform} build: ${[thirdToken, ...remainingPositionals].filter(Boolean).join(" ")}`, {
           renderUsage: () => renderMobileHelp(stderr, definition)
         });
       }
 
       return runMobileBuildAndroidCommand({
         ctx,
-        commandAdd,
         appRoot,
         options,
         stdout,
@@ -1289,8 +1190,8 @@ function createMobileCommands(ctx = {}, { commandAdd } = {}) {
     }
 
     if (definition.name === "doctor") {
-      if (secondToken) {
-        throw createCliError(`Unexpected positional arguments for jskit mobile doctor: ${[secondToken, ...remainingPositionals].join(" ")}`, {
+      if (thirdToken || remainingPositionals.length > 0) {
+        throw createCliError(`Unexpected positional arguments for jskit mobile ${platform} doctor: ${[thirdToken, ...remainingPositionals].filter(Boolean).join(" ")}`, {
           renderUsage: () => renderMobileHelp(stderr, definition)
         });
       }