@11agents/cli 0.1.23 → 0.1.25

package/src/commands/mobile.js

@@ -0,0 +1,695 @@
+import { spawn } from 'node:child_process'
+import { constants } from 'node:fs'
+import { access, copyFile, mkdir, readdir, readFile, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { flag } from '../args.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CLI_ROOT = path.resolve(__dirname, '..', '..')
+const MOBILE_RUNTIME_ROOT = path.join(CLI_ROOT, 'mobile-runtime')
+const MOBILE_PYTHON_ROOT = path.join(MOBILE_RUNTIME_ROOT, 'python')
+const MOBILE_CONFIG_ROOT = path.join(MOBILE_RUNTIME_ROOT, 'configs')
+const MOBILE_DATA_TEMPLATE_ROOT = path.join(MOBILE_RUNTIME_ROOT, 'data-templates')
+const MOBILE_SKILLS_ROOT = path.join(MOBILE_RUNTIME_ROOT, 'skills')
+const MOBILE_SCRIPTS_ROOT = path.join(MOBILE_RUNTIME_ROOT, 'scripts')
+
+const PYTHON_COMMANDS = new Set([
+  'doctor',
+  'list-adb',
+  'ensure-appium',
+  'stop-appium',
+  'list-devices',
+  'init-one-device',
+  'connect',
+  'health',
+  'screenshot',
+  'dump-ui',
+  'tap',
+  'keyevent',
+  'input-text',
+  'launch',
+  'plan-task',
+  'record-publish',
+  'list-publish-records',
+  'update-publish-record',
+  'add-metrics',
+  'collect-metrics',
+  'list-metrics',
+  'collect-tiktok-account-metrics-adb',
+  'list-tiktok-account-metrics',
+  'collect-tiktok-video-metrics-adb',
+  'list-tiktok-video-metrics',
+  'publish-tiktok-adb',
+  'publish-tiktok',
+  'publish-tiktok-appium',
+  'publish-reddit-adb',
+  'publish-reddit',
+  'publish-facebook',
+  'publish-instagram',
+  'publish-x',
+  'publish-xiaohongshu',
+  'copy-xiaohongshu-link',
+])
+
+const SCRIPT_COMMANDS = new Map([
+  ['appium-smoke', 'appium_smoke.py'],
+])
+
+const COMMAND_ALIASES = new Map([
+  ['collect-tiktok-account-metrics', 'collect-tiktok-account-metrics-adb'],
+  ['collect-tiktok-video-metrics', 'collect-tiktok-video-metrics-adb'],
+])
+
+const WRAPPER_FLAG_NAMES = new Set([
+  'mobile-home',
+  'task-id',
+])
+
+const EMPTY_DATA_FILES = [
+  'publish_records.jsonl',
+  'video_metrics.jsonl',
+  'tiktok_account_metrics.jsonl',
+  'tiktok_video_metrics.jsonl',
+]
+
+function usage() {
+  console.log(`11agents mobile
+
+Usage:
+  11agents mobile help
+  11agents mobile setup [--json] [--skip-python] [--skip-npm]
+  11agents mobile doctor [--json]
+  11agents mobile migrate --from <android-group-control-mvp>
+  11agents mobile skills list
+  11agents mobile skills show <skill-name>
+  11agents mobile data collect --platform <x|reddit|instagram|facebook|tiktok|xiaohongshu> [--scope account|video|record] [--record-id <id>] [--device Dxx]
+  11agents mobile <device-control-command> [args...]
+  11agents mobile appium-smoke --udid <adb-serial> [--server http://127.0.0.1:4723]
+
+Examples:
+  11agents mobile list-devices --health --json
+  11agents mobile publish-tiktok --device D03 --video /path/video.mp4 --caption "..." --json
+  11agents mobile collect-tiktok-video-metrics --device D03 --video-order 1 --json
+
+Runtime:
+  Python/device-control code is bundled with @11agents/cli.
+  Mutable runtime state lives in ~/.11agents/mobile by default.
+  Every command writes logs under ~/.11agents/mobile/runs/<task_id>/log.`)
+}
+
+function mobileHome(flags = {}, env = process.env) {
+  return path.resolve(
+    flag(flags, 'mobile-home')
+      || env.ELEVENAGENTS_MOBILE_HOME
+      || path.join(os.homedir(), '.11agents', 'mobile')
+  )
+}
+
+function taskIdFrom(flags = {}, env = process.env, now = new Date()) {
+  const explicit = flag(flags, 'task-id') || env.ELEVENAGENTS_TASK_ID || ''
+  if (explicit) return sanitizeTaskId(explicit)
+  const stamp = now.toISOString().replace(/[-:]/g, '').replace(/\..+$/, '').replace('T', '-')
+  const suffix = Math.random().toString(16).slice(2, 8)
+  return `manual-${stamp}-${suffix}`
+}
+
+function sanitizeTaskId(value) {
+  return String(value || 'manual')
+    .trim()
+    .replace(/[^A-Za-z0-9_.-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 160) || 'manual'
+}
+
+function parseRawArgs(argv) {
+  const positional = []
+  const flags = {}
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (!arg.startsWith('--')) {
+      positional.push(arg)
+      continue
+    }
+    const raw = arg.slice(2)
+    const eq = raw.indexOf('=')
+    if (eq >= 0) {
+      addFlag(flags, raw.slice(0, eq), raw.slice(eq + 1))
+      continue
+    }
+    const key = raw
+    const next = argv[i + 1]
+    if (!next || next.startsWith('--')) {
+      addFlag(flags, key, true)
+      continue
+    }
+    addFlag(flags, key, next)
+    i += 1
+  }
+  return { positional, flags }
+}
+
+function addFlag(flags, key, value) {
+  if (flags[key] === undefined) flags[key] = value
+  else if (Array.isArray(flags[key])) flags[key].push(value)
+  else flags[key] = [flags[key], value]
+}
+
+function stripWrapperFlags(args) {
+  const out = []
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]
+    if (!arg.startsWith('--')) {
+      out.push(arg)
+      continue
+    }
+    const raw = arg.slice(2)
+    const eq = raw.indexOf('=')
+    const key = eq >= 0 ? raw.slice(0, eq) : raw
+    if (!WRAPPER_FLAG_NAMES.has(key)) {
+      out.push(arg)
+      continue
+    }
+    if (eq < 0) {
+      const next = args[i + 1]
+      if (next && !next.startsWith('--')) i += 1
+    }
+  }
+  return out
+}
+
+function venvPython(home, platform = process.platform) {
+  return platform === 'win32'
+    ? path.join(home, '.venv', 'Scripts', 'python.exe')
+    : path.join(home, '.venv', 'bin', 'python')
+}
+
+async function exists(filePath, deps = {}) {
+  const accessFn = deps.access || access
+  try {
+    await accessFn(filePath, constants.F_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function isExecutable(filePath, deps = {}) {
+  const accessFn = deps.access || access
+  try {
+    await accessFn(filePath, constants.X_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function copyDir(source, target, { overwrite = true } = {}) {
+  await mkdir(target, { recursive: true })
+  const entries = await readdir(source, { withFileTypes: true })
+  for (const entry of entries) {
+    const from = path.join(source, entry.name)
+    const to = path.join(target, entry.name)
+    if (entry.isDirectory()) {
+      await copyDir(from, to, { overwrite })
+    } else if (entry.isFile()) {
+      await mkdir(path.dirname(to), { recursive: true })
+      if (!overwrite && await exists(to)) continue
+      await copyFile(from, to)
+    }
+  }
+}
+
+async function writeFileIfMissing(filePath, content) {
+  try {
+    await access(filePath, constants.F_OK)
+  } catch {
+    await mkdir(path.dirname(filePath), { recursive: true })
+    await writeFile(filePath, content)
+  }
+}
+
+async function scaffoldMobileHome(home) {
+  await mkdir(home, { recursive: true })
+  await mkdir(path.join(home, 'data'), { recursive: true })
+  await mkdir(path.join(home, 'artifacts', 'screenshots'), { recursive: true })
+  await mkdir(path.join(home, 'artifacts', 'ui'), { recursive: true })
+  await mkdir(path.join(home, 'runs'), { recursive: true })
+  await copyDir(MOBILE_CONFIG_ROOT, path.join(home, 'configs'), { overwrite: false })
+  await copyDir(MOBILE_SKILLS_ROOT, path.join(home, 'skills'), { overwrite: false })
+
+  await writeFileIfMissing(
+    path.join(home, 'data', 'accounts.csv'),
+    await readFile(path.join(MOBILE_DATA_TEMPLATE_ROOT, 'accounts.example.csv'), 'utf8')
+  )
+  await writeFileIfMissing(
+    path.join(home, 'data', 'devices.csv'),
+    await readFile(path.join(MOBILE_DATA_TEMPLATE_ROOT, 'devices.example.csv'), 'utf8')
+  )
+  for (const filename of EMPTY_DATA_FILES) {
+    await writeFileIfMissing(path.join(home, 'data', filename), '')
+  }
+  await writeFileIfMissing(path.join(home, 'data', 'tasks.jsonl'), '')
+}
+
+function runProcess(command, args, { cwd = process.cwd(), env = process.env, input = '', onStdoutChunk, onStderrChunk } = {}) {
+  return new Promise(resolve => {
+    const child = spawn(command, args, { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.on('data', chunk => {
+      stdout += chunk
+      onStdoutChunk?.(chunk)
+    })
+    child.stderr.on('data', chunk => {
+      stderr += chunk
+      onStderrChunk?.(chunk)
+    })
+    child.on('error', error => {
+      resolve({ code: 127, stdout, stderr: stderr || error.message })
+    })
+    child.on('close', code => {
+      resolve({ code: code ?? 1, stdout, stderr })
+    })
+    child.stdin.end(input)
+  })
+}
+
+async function runAndLog({ command, args, cwd, env, runDir, log, deps = {} }) {
+  const run = deps.runProcess || runProcess
+  await mkdir(runDir, { recursive: true })
+  const stdoutPath = path.join(runDir, 'stdout.log')
+  const stderrPath = path.join(runDir, 'stderr.log')
+  const commandPath = path.join(runDir, 'command.json')
+  await writeFile(commandPath, JSON.stringify({
+    command,
+    args,
+    cwd,
+    started_at: new Date().toISOString(),
+  }, null, 2))
+  await appendLog(log, `command: ${[command, ...args].map(shellQuote).join(' ')}\n`)
+  await appendLog(log, `cwd: ${cwd}\n`)
+  const result = await run(command, args, {
+    cwd,
+    env,
+    onStdoutChunk: chunk => appendFileBestEffort(stdoutPath, chunk),
+    onStderrChunk: chunk => appendFileBestEffort(stderrPath, chunk),
+  })
+  await writeFile(stdoutPath, result.stdout || '')
+  await writeFile(stderrPath, result.stderr || '')
+  await appendLog(log, `exit_code: ${result.code}\n`)
+  if (result.stdout) await appendLog(log, `stdout:\n${result.stdout}\n`)
+  if (result.stderr) await appendLog(log, `stderr:\n${result.stderr}\n`)
+  return result
+}
+
+async function appendFileBestEffort(filePath, chunk) {
+  try {
+    await mkdir(path.dirname(filePath), { recursive: true })
+    await writeFile(filePath, chunk, { flag: 'a' })
+  } catch {}
+}
+
+async function appendLog(logPath, text) {
+  await mkdir(path.dirname(logPath), { recursive: true })
+  await writeFile(logPath, text, { flag: 'a' })
+}
+
+function shellQuote(value) {
+  const text = String(value)
+  if (/^[A-Za-z0-9_./:=@-]+$/.test(text)) return text
+  return JSON.stringify(text)
+}
+
+function pythonEnv(home, env = process.env) {
+  const appiumBin = path.join(home, 'node_modules', '.bin', process.platform === 'win32' ? 'appium.cmd' : 'appium')
+  return {
+    ...env,
+    PYTHONPATH: [
+      path.join(MOBILE_PYTHON_ROOT, 'src'),
+      env.PYTHONPATH || '',
+    ].filter(Boolean).join(path.delimiter),
+    APPIUM_BIN: env.APPIUM_BIN || appiumBin,
+    APPIUM_HOME: env.APPIUM_HOME || path.join(home, 'appium'),
+    ELEVENAGENTS_MOBILE_HOME: home,
+  }
+}
+
+async function mobileDoctor(flags = {}, deps = {}) {
+  const home = mobileHome(flags, deps.env || process.env)
+  const python = venvPython(home, deps.platform || process.platform)
+  const checks = {
+    mobile_home: home,
+    bundled_python_runtime: await exists(path.join(MOBILE_PYTHON_ROOT, 'src', 'device_control', 'cli.py'), deps),
+    runtime_configs: await exists(MOBILE_CONFIG_ROOT, deps),
+    bundled_skills: await exists(path.join(MOBILE_SKILLS_ROOT, 'android-group-control-cli', 'SKILL.md'), deps),
+    home_exists: await exists(home, deps),
+    venv_python: await isExecutable(python, deps),
+    data_devices_csv: await exists(path.join(home, 'data', 'devices.csv'), deps),
+    publish_policy: await exists(path.join(home, 'configs', 'publish_policy.json'), deps),
+    appium_bin: await isExecutable(path.join(home, 'node_modules', '.bin', process.platform === 'win32' ? 'appium.cmd' : 'appium'), deps),
+    appium_home: await exists(path.join(home, 'appium'), deps),
+  }
+  const ok = checks.bundled_python_runtime && checks.runtime_configs && checks.bundled_skills && checks.home_exists && checks.venv_python
+  const result = {
+    ok,
+    status: ok ? 'ready' : 'needs_setup',
+    setup_command: '11agents mobile setup',
+    checks,
+  }
+  if (flags.json) {
+    ;(deps.log || console.log)(JSON.stringify(result, null, 2))
+  } else {
+    ;(deps.log || console.log)([
+      `status=${result.status}`,
+      `mobile_home=${home}`,
+      `setup_command=${result.setup_command}`,
+    ].join('\n'))
+  }
+  return result
+}
+
+async function mobileSetup(flags = {}, deps = {}) {
+  const env = deps.env || process.env
+  const home = mobileHome(flags, env)
+  await scaffoldMobileHome(home)
+  const python = venvPython(home, deps.platform || process.platform)
+  const run = deps.runProcess || runProcess
+  const steps = []
+
+  if (!flags['skip-python']) {
+    if (!await exists(python, deps)) {
+      const venvResult = await run(env.PYTHON || env.PYTHON3 || 'python3', ['-m', 'venv', path.join(home, '.venv')], { cwd: home, env })
+      steps.push({ step: 'python venv', code: venvResult.code, stderr: venvResult.stderr })
+      if (venvResult.code !== 0) throw new Error(`python venv failed: ${venvResult.stderr || venvResult.stdout}`)
+    }
+    const pipResult = await run(python, ['-m', 'pip', 'install', '-U', 'pip'], { cwd: home, env: pythonEnv(home, env) })
+    steps.push({ step: 'pip upgrade', code: pipResult.code, stderr: pipResult.stderr })
+    if (pipResult.code !== 0) throw new Error(`pip upgrade failed: ${pipResult.stderr || pipResult.stdout}`)
+    const installResult = await run(python, ['-m', 'pip', 'install', '-e', `${MOBILE_PYTHON_ROOT}[appium]`], { cwd: home, env: pythonEnv(home, env) })
+    steps.push({ step: 'mobile python install', code: installResult.code, stderr: installResult.stderr })
+    if (installResult.code !== 0) throw new Error(`mobile runtime install failed: ${installResult.stderr || installResult.stdout}`)
+  }
+
+  if (!flags['skip-npm']) {
+    await writeFileIfMissing(path.join(home, 'package.json'), JSON.stringify({
+      private: true,
+      name: 'elevenagents-mobile-runtime-local',
+      version: '0.0.0',
+      dependencies: {
+        appium: '^3.4.2',
+        'appium-uiautomator2-driver': '^7.5.2',
+      },
+    }, null, 2))
+    const npmResult = await run(env.NPM || 'npm', ['install', '--prefix', home], { cwd: home, env })
+    steps.push({ step: 'appium npm install', code: npmResult.code, stderr: npmResult.stderr })
+    if (npmResult.code !== 0) throw new Error(`appium npm install failed: ${npmResult.stderr || npmResult.stdout}`)
+    const appiumCli = path.join(home, 'node_modules', '.bin', process.platform === 'win32' ? 'appium.cmd' : 'appium')
+    const appiumHome = path.join(home, 'appium')
+    await mkdir(appiumHome, { recursive: true })
+    const appiumEnv = { ...env, APPIUM_HOME: env.APPIUM_HOME || appiumHome }
+    const driverResult = await run(appiumCli, ['driver', 'install', 'uiautomator2'], { cwd: home, env: appiumEnv })
+    steps.push({ step: 'appium uiautomator2 driver', code: driverResult.code, stderr: driverResult.stderr })
+    if (driverResult.code !== 0 && !/already installed|already exists/i.test(`${driverResult.stdout}\n${driverResult.stderr}`)) {
+      throw new Error(`appium uiautomator2 driver install failed: ${driverResult.stderr || driverResult.stdout}`)
+    }
+  }
+
+  const result = {
+    ok: true,
+    status: 'ready',
+    mobile_home: home,
+    python,
+    steps,
+  }
+  ;(deps.log || console.log)(flags.json ? JSON.stringify(result, null, 2) : `mobile runtime ready: ${home}`)
+  return result
+}
+
+async function mobileMigrate(flags = {}, deps = {}) {
+  const from = path.resolve(flag(flags, 'from') || '')
+  if (!from) throw new Error('mobile migrate requires --from <android-group-control-mvp>')
+  if (!await exists(path.join(from, 'src', 'device_control', 'cli.py'), deps)) {
+    throw new Error(`not an android group-control checkout: ${from}`)
+  }
+  const home = mobileHome(flags, deps.env || process.env)
+  await scaffoldMobileHome(home)
+  await copyDir(path.join(from, 'configs'), path.join(home, 'configs'), { overwrite: true })
+  await mkdir(path.join(home, 'data'), { recursive: true })
+  for (const filename of [
+    'accounts.csv',
+    'devices.csv',
+    'publish_records.jsonl',
+    'video_metrics.jsonl',
+    'tiktok_account_metrics.jsonl',
+    'tiktok_video_metrics.jsonl',
+    'tasks.jsonl',
+  ]) {
+    const source = path.join(from, 'data', filename)
+    if (await exists(source, deps)) await copyFile(source, path.join(home, 'data', filename))
+  }
+  const result = { ok: true, migrated_from: from, mobile_home: home }
+  ;(deps.log || console.log)(flags.json ? JSON.stringify(result, null, 2) : `migrated mobile runtime data to ${home}`)
+  return result
+}
+
+async function mobileSkills(argv = [], deps = {}) {
+  const { positional } = parseRawArgs(argv)
+  const [subcommand, name] = positional
+  if (!subcommand || subcommand === 'list') {
+    const entries = await readdir(MOBILE_SKILLS_ROOT, { withFileTypes: true })
+    const names = entries.filter(entry => entry.isDirectory()).map(entry => entry.name).sort()
+    ;(deps.log || console.log)(names.join('\n'))
+    return names
+  }
+  if (subcommand === 'show') {
+    if (!name) throw new Error('mobile skills show requires a skill name')
+    const filePath = path.join(MOBILE_SKILLS_ROOT, name, 'SKILL.md')
+    if (!await exists(filePath, deps)) throw new Error(`mobile skill not found: ${name}`)
+    const text = await readFile(filePath, 'utf8')
+    ;(deps.log || console.log)(text)
+    return text
+  }
+  throw new Error(`unsupported mobile skills command: ${subcommand}`)
+}
+
+async function ensureRunnable(home, deps = {}) {
+  await scaffoldMobileHome(home)
+  const python = venvPython(home, deps.platform || process.platform)
+  if (!await exists(python, deps)) {
+    throw new Error(`mobile runtime is not set up. Run: 11agents mobile setup`)
+  }
+  return python
+}
+
+function normalizePythonCommand(command) {
+  return COMMAND_ALIASES.get(command) || command
+}
+
+function buildRunContext(rawArgs, deps = {}) {
+  const { flags } = parseRawArgs(rawArgs)
+  const env = deps.env || process.env
+  const home = mobileHome(flags, env)
+  const taskId = taskIdFrom(flags, env)
+  const runDir = path.join(home, 'runs', taskId)
+  return {
+    flags,
+    home,
+    taskId,
+    runDir,
+    logPath: path.join(runDir, 'log'),
+  }
+}
+
+async function dispatchPython(rawArgs, deps = {}) {
+  const command = normalizePythonCommand(rawArgs[0] || '')
+  if (!PYTHON_COMMANDS.has(command)) throw new Error(`unsupported mobile command: ${rawArgs[0] || ''}`)
+  const context = buildRunContext(rawArgs, deps)
+  const python = await ensureRunnable(context.home, deps)
+  const childArgs = ['-m', 'device_control.cli', command, ...stripWrapperFlags(rawArgs.slice(1))]
+  const env = pythonEnv(context.home, deps.env || process.env)
+  env.ELEVENAGENTS_MOBILE_RUN_DIR = context.runDir
+  env.ELEVENAGENTS_TASK_ID = context.taskId
+  const result = await runAndLog({
+    command: python,
+    args: childArgs,
+    cwd: context.home,
+    env,
+    runDir: context.runDir,
+    log: context.logPath,
+    deps,
+  })
+  const parsed = parseJsonResult(result.stdout)
+  await writeFile(path.join(context.runDir, 'result.json'), JSON.stringify({
+    status: result.code === 0 ? 'ok' : 'failed',
+    exit_code: result.code,
+    parsed,
+  }, null, 2))
+  if (result.stdout) process.stdout.write(result.stdout)
+  if (result.stderr) process.stderr.write(result.stderr)
+  if (result.code !== 0) process.exitCode = result.code
+  return { ...result, task_id: context.taskId, run_dir: context.runDir, parsed }
+}
+
+async function dispatchScript(rawArgs, deps = {}) {
+  const command = rawArgs[0] || ''
+  const scriptName = SCRIPT_COMMANDS.get(command)
+  if (!scriptName) throw new Error(`unsupported mobile command: ${command}`)
+  const context = buildRunContext(rawArgs, deps)
+  const python = await ensureRunnable(context.home, deps)
+  const scriptPath = path.join(MOBILE_SCRIPTS_ROOT, scriptName)
+  const env = pythonEnv(context.home, deps.env || process.env)
+  env.ELEVENAGENTS_MOBILE_RUN_DIR = context.runDir
+  env.ELEVENAGENTS_TASK_ID = context.taskId
+  const result = await runAndLog({
+    command: python,
+    args: [scriptPath, ...stripWrapperFlags(rawArgs.slice(1))],
+    cwd: context.home,
+    env,
+    runDir: context.runDir,
+    log: context.logPath,
+    deps,
+  })
+  await writeFile(path.join(context.runDir, 'result.json'), JSON.stringify({
+    status: result.code === 0 ? 'ok' : 'failed',
+    exit_code: result.code,
+  }, null, 2))
+  if (result.stdout) process.stdout.write(result.stdout)
+  if (result.stderr) process.stderr.write(result.stderr)
+  if (result.code !== 0) process.exitCode = result.code
+  return { ...result, task_id: context.taskId, run_dir: context.runDir }
+}
+
+function parseJsonResult(text) {
+  const rows = []
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    try {
+      rows.push(JSON.parse(trimmed))
+    } catch {}
+  }
+  return rows.length ? rows : null
+}
+
+function removeFlags(args, names) {
+  const out = []
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]
+    if (!arg.startsWith('--')) {
+      out.push(arg)
+      continue
+    }
+    const raw = arg.slice(2)
+    const eq = raw.indexOf('=')
+    const key = eq >= 0 ? raw.slice(0, eq) : raw
+    if (!names.has(key)) {
+      out.push(arg)
+      continue
+    }
+    if (eq < 0) {
+      const next = args[i + 1]
+      if (next && !next.startsWith('--')) i += 1
+    }
+  }
+  return out
+}
+
+function dataCollectCommand(args) {
+  const { flags } = parseRawArgs(args)
+  const platform = String(flag(flags, 'platform') || '').toLowerCase()
+  const scope = String(flag(flags, 'scope') || flag(flags, 'kind') || '').toLowerCase()
+  const pass = removeFlags(args, new Set(['platform', 'scope', 'kind']))
+  if (!platform) throw new Error('mobile data collect requires --platform')
+  if (platform === 'tiktok' || platform === 'tk') {
+    if (scope === 'account') return ['collect-tiktok-account-metrics-adb', ...pass]
+    if (scope === 'video' || flags['video-order'] || flags.device) return ['collect-tiktok-video-metrics-adb', ...pass]
+    return ['collect-metrics', '--platform', 'tiktok', ...pass]
+  }
+  if (platform === 'reddit' || platform === 'instagram') {
+    return ['collect-metrics', '--platform', platform, ...pass]
+  }
+  if (platform === 'xiaohongshu' && flags['copy-link']) {
+    return ['copy-xiaohongshu-link', ...removeFlags(pass, new Set(['copy-link']))]
+  }
+  return null
+}
+
+async function mobileDataCollect(args, deps = {}) {
+  const command = dataCollectCommand(args)
+  if (command) return dispatchPython(command, deps)
+  const { flags } = parseRawArgs(args)
+  const context = buildRunContext(args, deps)
+  await scaffoldMobileHome(context.home)
+  await mkdir(context.runDir, { recursive: true })
+  const platform = String(flag(flags, 'platform') || '').toLowerCase()
+  const recordId = String(flag(flags, 'record-id') || '')
+  const result = {
+    platform,
+    record_id: recordId,
+    status: 'missing_access',
+    reason: `No automatic mobile data collector is bundled for platform=${platform}. Use platform API/export or manual values, then append with 11agents mobile add-metrics.`,
+    run_dir: context.runDir,
+  }
+  await writeFile(path.join(context.runDir, 'result.json'), JSON.stringify(result, null, 2))
+  await appendLog(context.logPath, `${JSON.stringify(result)}\n`)
+  ;(deps.log || console.log)(JSON.stringify(result, null, 2))
+  return { code: 0, stdout: JSON.stringify(result), stderr: '', parsed: [result] }
+}
+
+export async function runMobile(argv = [], deps = {}) {
+  const { flags } = parseRawArgs(argv)
+  const { positional } = parseRawArgs(argv)
+  const [command, subcommand] = positional
+  if (!argv.length || command === 'help') {
+    usage()
+    return null
+  }
+  if (command === 'setup') return mobileSetup(flags, deps)
+  if (command === 'doctor') return mobileDoctor(flags, deps)
+  if (command === 'migrate') return mobileMigrate(flags, deps)
+  if (command === 'skills') return mobileSkills(restAndFlagsAfter(argv, 1), deps)
+  if (command === 'data' && subcommand === 'collect') return mobileDataCollect(restAndFlagsAfter(argv, 2), deps)
+  if (command === 'groupctl') {
+    if (!subcommand) throw new Error('mobile groupctl requires a command')
+    return dispatchPython([subcommand, ...restAndFlagsAfter(argv, 2)], deps)
+  }
+  if (SCRIPT_COMMANDS.has(command)) return dispatchScript([command, ...restAndFlagsAfter(argv, 1)], deps)
+  return dispatchPython([command, ...restAndFlagsAfter(argv, 1)], deps)
+}
+
+function restAndFlagsAfter(argv, positionalCount) {
+  const out = []
+  let seen = 0
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg.startsWith('--')) {
+      out.push(arg)
+      const raw = arg.slice(2)
+      if (!raw.includes('=')) {
+        const next = argv[i + 1]
+        if (next && !next.startsWith('--')) {
+          out.push(next)
+          i += 1
+        }
+      }
+      continue
+    }
+    if (seen < positionalCount) {
+      seen += 1
+      continue
+    }
+    out.push(arg)
+  }
+  return out
+}
+
+export const mobileInternals = {
+  dataCollectCommand,
+  mobileHome,
+  parseRawArgs,
+  stripWrapperFlags,
+  taskIdFrom,
+  venvPython,
+}