android-midscene-automation 0.1.0

package/server/appium-recorder/routes.ts

@@ -0,0 +1,219 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import {
+  deleteAppiumRecordedScript,
+  getAppiumRecordedScript,
+  listAppiumRecordedScripts,
+  saveAppiumRecordedScript,
+  type AppiumRecordedStepRecord,
+} from './repository';
+import { replayAppiumScript } from './appium-runner';
+import { isRemoteDeviceId, sendRemoteCommand } from '../remote-agents/registry';
+
+function sendJson(res: ServerResponse, payload: unknown, statusCode = 200) {
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'application/json; charset=utf-8');
+  res.end(JSON.stringify(payload));
+}
+
+async function readBody<T>(req: IncomingMessage) {
+  let body = '';
+  req.on('data', (chunk) => {
+    body += chunk;
+  });
+  return await new Promise<T>((resolve) => {
+    req.on('end', () => {
+      resolve(JSON.parse(body || '{}') as T);
+    });
+  });
+}
+
+function execFileText(command: string, args: string[] = []) {
+  return new Promise<string>((resolve, reject) => {
+    execFile(command, args, { maxBuffer: 20 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+
+async function dumpWindowHierarchy(deviceId: string) {
+  const localPath = path.join(os.tmpdir(), `midscene-appium-${deviceId.replace(/[^\w.-]/g, '_')}-${Date.now()}.xml`);
+  const remotePath = '/data/local/tmp/midscene_appium_uidump.xml';
+  await execFileText('adb', ['-s', deviceId, 'shell', 'uiautomator', 'dump', remotePath]);
+  await execFileText('adb', ['-s', deviceId, 'pull', remotePath, localPath]);
+  try {
+    return await fs.readFile(localPath, 'utf8');
+  } finally {
+    await fs.unlink(localPath).catch(() => undefined);
+  }
+}
+
+async function getCurrentActivity(deviceId: string) {
+  const output = await execFileText('adb', ['-s', deviceId, 'shell', 'dumpsys', 'activity', 'activities']);
+  const resumedLine = output
+    .split(/\r?\n/)
+    .find((line) => /(?:topResumedActivity|ResumedActivity|mResumedActivity)/.test(line));
+  return resumedLine?.match(/\s([\w.$]+\/[\w.$]+)\s/)?.[1] || '';
+}
+
+async function tapDevice(deviceId: string, x: number, y: number) {
+  await execFileText('adb', [
+    '-s',
+    deviceId,
+    'shell',
+    'input',
+    'tap',
+    String(Math.round(x)),
+    String(Math.round(y)),
+  ]);
+}
+
+async function pressDeviceKey(deviceId: string, keyCode: number) {
+  await execFileText('adb', [
+    '-s',
+    deviceId,
+    'shell',
+    'input',
+    'keyevent',
+    String(Math.round(keyCode)),
+  ]);
+}
+
+export async function handleAppiumRecorderRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  selectedDeviceId: string,
+  allowLocalDevice = true,
+) {
+  const requestUrl = new URL(req.url || '/', 'http://localhost');
+  const pathname = requestUrl.pathname;
+  if (!pathname.startsWith('/api/appium-recorder')) {
+    return false;
+  }
+
+  try {
+    const assertDeviceAllowed = (deviceId: string) => {
+      if (!allowLocalDevice && deviceId && !isRemoteDeviceId(deviceId)) {
+        throw new Error('局域网访问者只能使用远程代理设备');
+      }
+    };
+
+    if (pathname === '/api/appium-recorder/tree' && req.method === 'GET') {
+      const deviceId = requestUrl.searchParams.get('deviceId')?.trim() || selectedDeviceId;
+      if (!deviceId) throw new Error('未检测到可用设备');
+      assertDeviceAllowed(deviceId);
+      if (isRemoteDeviceId(deviceId)) {
+        const data = await sendRemoteCommand(deviceId, 'tree') as { xml?: string; activity?: string; dumpedAt?: string };
+        sendJson(res, {
+          deviceId,
+          xml: data.xml || '',
+          activity: data.activity || '',
+          dumpedAt: data.dumpedAt || new Date().toISOString(),
+        });
+        return true;
+      }
+      const [xml, activity] = await Promise.all([
+        dumpWindowHierarchy(deviceId),
+        getCurrentActivity(deviceId).catch(() => ''),
+      ]);
+      sendJson(res, { deviceId, xml, activity, dumpedAt: new Date().toISOString() });
+      return true;
+    }
+
+    if (pathname === '/api/appium-recorder/tap' && req.method === 'POST') {
+      const parsed = await readBody<{ deviceId?: string; x?: number; y?: number }>(req);
+      const deviceId = parsed.deviceId?.trim() || selectedDeviceId;
+      if (!deviceId) throw new Error('未检测到可用设备');
+      assertDeviceAllowed(deviceId);
+      if (!Number.isFinite(parsed.x) || !Number.isFinite(parsed.y)) throw new Error('点击坐标无效');
+      if (isRemoteDeviceId(deviceId)) {
+        await sendRemoteCommand(deviceId, 'tap', { x: Number(parsed.x), y: Number(parsed.y) });
+        sendJson(res, { success: true });
+        return true;
+      }
+      await tapDevice(deviceId, Number(parsed.x), Number(parsed.y));
+      sendJson(res, { success: true });
+      return true;
+    }
+
+    if (pathname === '/api/appium-recorder/key' && req.method === 'POST') {
+      const parsed = await readBody<{ deviceId?: string; keyCode?: number }>(req);
+      const deviceId = parsed.deviceId?.trim() || selectedDeviceId;
+      const keyCode = Number(parsed.keyCode);
+      if (!deviceId) throw new Error('未检测到可用设备');
+      assertDeviceAllowed(deviceId);
+      if (!Number.isFinite(keyCode)) throw new Error('按键无效');
+      if (isRemoteDeviceId(deviceId)) {
+        await sendRemoteCommand(deviceId, 'key', { keyCode });
+        sendJson(res, { success: true });
+        return true;
+      }
+      await pressDeviceKey(deviceId, keyCode);
+      sendJson(res, { success: true });
+      return true;
+    }
+
+    if (pathname === '/api/appium-recorder/scripts' && req.method === 'GET') {
+      sendJson(res, { scripts: listAppiumRecordedScripts() });
+      return true;
+    }
+
+    if (pathname === '/api/appium-recorder/scripts' && req.method === 'POST') {
+      const parsed = await readBody<{
+        id?: string;
+        name?: string;
+        appPackage?: string;
+        appActivity?: string;
+        deviceId?: string;
+        steps?: AppiumRecordedStepRecord[];
+      }>(req);
+      const script = saveAppiumRecordedScript({
+        id: parsed.id,
+        name: parsed.name || '',
+        appPackage: parsed.appPackage || '',
+        appActivity: parsed.appActivity || '',
+        deviceId: parsed.deviceId || selectedDeviceId,
+        steps: parsed.steps || [],
+      });
+      sendJson(res, { script });
+      return true;
+    }
+
+    const deleteMatch = pathname.match(/^\/api\/appium-recorder\/scripts\/([^/]+)$/);
+    if (deleteMatch && req.method === 'DELETE') {
+      deleteAppiumRecordedScript(decodeURIComponent(deleteMatch[1]));
+      sendJson(res, { success: true });
+      return true;
+    }
+
+    const replayMatch = pathname.match(/^\/api\/appium-recorder\/scripts\/([^/]+)\/replay$/);
+    if (replayMatch && req.method === 'POST') {
+      const parsed = await readBody<{ deviceId?: string }>(req);
+      const script = getAppiumRecordedScript(decodeURIComponent(replayMatch[1]));
+      if (!script) throw new Error('Appium 录制脚本不存在');
+      const deviceId = parsed.deviceId || selectedDeviceId;
+      assertDeviceAllowed(deviceId);
+      if (isRemoteDeviceId(deviceId)) {
+        const result = await sendRemoteCommand(deviceId, 'replay', { script }) as { success?: boolean; output?: string };
+        sendJson(res, result, result.success ? 200 : 500);
+        return true;
+      }
+      const result = await replayAppiumScript(script, deviceId);
+      sendJson(res, result, result.success ? 200 : 500);
+      return true;
+    }
+
+    sendJson(res, { message: 'Appium Recorder 接口不存在' }, 404);
+    return true;
+  } catch (error) {
+    sendJson(res, { message: error instanceof Error ? error.message : 'Appium Recorder 请求失败' }, 500);
+    return true;
+  }
+}

package/server/config-store.ts

@@ -0,0 +1,167 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { appPath } from './paths';
+import type { AppConfig } from './config';
+
+export type AppPresetRecord = {
+  id: string;
+  name: string;
+  packageName: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+type AppPresetRow = {
+  id: string;
+  name: string;
+  package_name: string;
+  created_at: string;
+  updated_at: string;
+};
+
+const dbPath = appPath('.midscene-app', 'script-cache.sqlite');
+const sqliteBin = process.env.SQLITE3_BIN || '/usr/bin/sqlite3';
+let initialized = false;
+
+function createId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function ensureDbDir() {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+}
+
+function sqlString(value: string) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+function runSql(sql: string) {
+  ensureDbDir();
+  execFileSync(sqliteBin, [dbPath], {
+    input: sql,
+    maxBuffer: 20 * 1024 * 1024,
+  });
+}
+
+function querySql<T>(sql: string) {
+  ensureDbDir();
+  const output = execFileSync(sqliteBin, ['-json', dbPath, sql], {
+    encoding: 'utf8',
+    maxBuffer: 20 * 1024 * 1024,
+  });
+  return JSON.parse(output || '[]') as T[];
+}
+
+function rowToAppPreset(row: AppPresetRow): AppPresetRecord {
+  return {
+    id: row.id,
+    name: row.name,
+    packageName: row.package_name,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function initConfigDb() {
+  if (initialized) return;
+  initialized = true;
+  runSql(`
+    PRAGMA journal_mode = WAL;
+    CREATE TABLE IF NOT EXISTS app_config (
+      key TEXT PRIMARY KEY,
+      value_json TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS app_presets (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      package_name TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      UNIQUE(name, package_name)
+    );
+    CREATE INDEX IF NOT EXISTS idx_app_presets_updated_at ON app_presets(updated_at DESC);
+  `);
+}
+
+export function loadModelConfigFromDb() {
+  initConfigDb();
+  const row = querySql<{ value_json: string }>(`
+    SELECT value_json
+    FROM app_config
+    WHERE key = 'model_config'
+    LIMIT 1;
+  `)[0];
+
+  return row ? JSON.parse(row.value_json) as Partial<AppConfig> : null;
+}
+
+export function saveModelConfigToDb(config: AppConfig) {
+  initConfigDb();
+  const now = new Date().toISOString();
+  runSql(`
+    INSERT INTO app_config (key, value_json, updated_at)
+    VALUES ('model_config', ${sqlString(JSON.stringify(config))}, ${sqlString(now)})
+    ON CONFLICT(key) DO UPDATE SET
+      value_json = excluded.value_json,
+      updated_at = excluded.updated_at;
+  `);
+}
+
+export function listAppPresetRecords() {
+  initConfigDb();
+  return querySql<AppPresetRow>(`
+    SELECT id, name, package_name, created_at, updated_at
+    FROM app_presets
+    ORDER BY updated_at DESC;
+  `).map(rowToAppPreset);
+}
+
+export function saveAppPresetRecord(input: { id?: string; name: string; packageName: string }) {
+  initConfigDb();
+  const now = new Date().toISOString();
+  const name = input.name.trim();
+  const packageName = input.packageName.trim();
+
+  if (!name) throw new Error('App 名称不能为空');
+  if (!packageName) throw new Error('App 包名不能为空');
+
+  const existing = querySql<{ id: string }>(`
+    SELECT id
+    FROM app_presets
+    WHERE name = ${sqlString(name)}
+      AND package_name = ${sqlString(packageName)}
+    LIMIT 1;
+  `)[0];
+
+  if (existing && existing.id !== input.id) {
+    throw new Error('已存在相同 App 名称和包名的配置');
+  }
+
+  const id = input.id || createId();
+
+  runSql(`
+    INSERT INTO app_presets (id, name, package_name, created_at, updated_at)
+    VALUES (${sqlString(id)}, ${sqlString(name)}, ${sqlString(packageName)}, ${sqlString(now)}, ${sqlString(now)})
+    ON CONFLICT(id) DO UPDATE SET
+      name = excluded.name,
+      package_name = excluded.package_name,
+      updated_at = excluded.updated_at;
+  `);
+
+  const row = querySql<AppPresetRow>(`
+    SELECT id, name, package_name, created_at, updated_at
+    FROM app_presets
+    WHERE id = ${sqlString(id)}
+    LIMIT 1;
+  `)[0];
+
+  return rowToAppPreset(row);
+}
+
+export function removeAppPresetRecord(id: string) {
+  initConfigDb();
+  runSql(`DELETE FROM app_presets WHERE id = ${sqlString(id)};`);
+  return { success: true };
+}

package/server/config.ts

@@ -0,0 +1,130 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import { appPath } from './paths';
+import { loadModelConfigFromDb, saveModelConfigToDb } from './config-store';
+
+export type AppConfig = {
+  midscene: {
+    model: {
+      provider: 'custom' | 'codex';
+      baseUrl: string;
+      apiKey: string;
+      name: string;
+      family: string;
+    };
+    env: Record<string, string>;
+  };
+  scriptOptimizer: {
+    model: {
+      baseUrl: string;
+      apiKey: string;
+      name: string;
+    };
+  };
+};
+
+let cachedConfig: AppConfig | null = null;
+const configPath = appPath('config.json');
+const legacyConfigPath = appPath('config.yaml');
+
+function defaultConfig(): AppConfig {
+  return {
+    midscene: {
+      model: {
+        provider: 'custom',
+        baseUrl: '',
+        apiKey: '',
+        name: '',
+        family: '',
+      },
+      env: {},
+    },
+    scriptOptimizer: {
+      model: {
+        baseUrl: '',
+        apiKey: '',
+        name: '',
+      },
+    },
+  };
+}
+
+function normalizeEnv(env: unknown): Record<string, string> {
+  if (!env || typeof env !== 'object' || Array.isArray(env)) return {};
+  return Object.fromEntries(
+    Object.entries(env)
+      .filter((entry): entry is [string, string] => typeof entry[1] === 'string' && entry[1] !== ''),
+  );
+}
+
+function normalizeConfig(config: Partial<AppConfig> | null | undefined): AppConfig {
+  const fallback = defaultConfig();
+  return {
+    midscene: {
+      model: {
+        provider: config?.midscene?.model?.provider || (
+          config?.midscene?.model?.baseUrl === 'codex://app-server' ? 'codex' : fallback.midscene.model.provider
+        ),
+        baseUrl: config?.midscene?.model?.baseUrl || fallback.midscene.model.baseUrl,
+        apiKey: config?.midscene?.model?.apiKey || fallback.midscene.model.apiKey,
+        name: config?.midscene?.model?.name || fallback.midscene.model.name,
+        family: config?.midscene?.model?.family || fallback.midscene.model.family,
+      },
+      env: normalizeEnv(config?.midscene?.env),
+    },
+    scriptOptimizer: {
+      model: {
+        baseUrl: config?.scriptOptimizer?.model?.baseUrl || fallback.scriptOptimizer.model.baseUrl,
+        apiKey: config?.scriptOptimizer?.model?.apiKey || fallback.scriptOptimizer.model.apiKey,
+        name: config?.scriptOptimizer?.model?.name || fallback.scriptOptimizer.model.name,
+      },
+    },
+  };
+}
+
+export function loadConfig(): AppConfig {
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+
+  const dbConfig = loadModelConfigFromDb();
+  if (dbConfig) {
+    cachedConfig = normalizeConfig(dbConfig);
+    return cachedConfig;
+  }
+
+  if (fs.existsSync(configPath)) {
+    const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8')) as Partial<AppConfig>;
+    cachedConfig = normalizeConfig(parsed);
+    saveModelConfigToDb(cachedConfig);
+    return cachedConfig;
+  }
+
+  if (fs.existsSync(legacyConfigPath)) {
+    const parsed = YAML.parse(fs.readFileSync(legacyConfigPath, 'utf8')) as Partial<AppConfig>;
+    cachedConfig = normalizeConfig(parsed);
+    saveConfig(cachedConfig);
+    return cachedConfig;
+  }
+
+  cachedConfig = defaultConfig();
+  saveConfig(cachedConfig);
+  return cachedConfig;
+}
+
+export function saveConfig(config: AppConfig) {
+  cachedConfig = normalizeConfig(config);
+  saveModelConfigToDb(cachedConfig);
+}
+
+export function applyMidsceneEnv() {
+  const config = loadConfig();
+  for (const [key, value] of Object.entries(config.midscene.env)) {
+    process.env[key] = value;
+  }
+  process.env.MIDSCENE_MODEL_BASE_URL = config.midscene.model.baseUrl;
+  process.env.MIDSCENE_MODEL_API_KEY = config.midscene.model.apiKey;
+  process.env.MIDSCENE_MODEL_NAME = config.midscene.model.name;
+  process.env.MIDSCENE_MODEL_FAMILY = config.midscene.model.family;
+}

package/server/device-locks/repository.ts

@@ -0,0 +1,147 @@
+import {
+  createId,
+  querySql,
+  runSql,
+  sqlJson,
+  sqlString,
+} from '../storage/sqlite';
+import type { DeviceLockOwnerType, DeviceLockRecord } from './types';
+
+type DeviceLockRow = {
+  id: string;
+  device_id: string;
+  owner_type: DeviceLockOwnerType;
+  owner_id: string;
+  metadata_json: string;
+  acquired_at: string;
+  expires_at: string;
+  released_at: string | null;
+};
+
+let initialized = false;
+
+function rowToRecord(row: DeviceLockRow): DeviceLockRecord {
+  return {
+    id: row.id,
+    deviceId: row.device_id,
+    ownerType: row.owner_type,
+    ownerId: row.owner_id,
+    metadata: JSON.parse(row.metadata_json || '{}') as Record<string, unknown>,
+    acquiredAt: row.acquired_at,
+    expiresAt: row.expires_at,
+    releasedAt: row.released_at || '',
+  };
+}
+
+export function initDeviceLockRepository() {
+  if (initialized) return;
+  initialized = true;
+  runSql(`
+    PRAGMA journal_mode = WAL;
+    CREATE TABLE IF NOT EXISTS device_locks (
+      id TEXT PRIMARY KEY,
+      device_id TEXT NOT NULL,
+      owner_type TEXT NOT NULL,
+      owner_id TEXT NOT NULL,
+      metadata_json TEXT NOT NULL DEFAULT '{}',
+      acquired_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL,
+      released_at TEXT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_device_locks_active
+      ON device_locks(device_id, released_at, expires_at);
+    CREATE INDEX IF NOT EXISTS idx_device_locks_owner
+      ON device_locks(owner_id);
+  `);
+}
+
+export function cleanupExpiredDeviceLocks(now: string) {
+  initDeviceLockRepository();
+  runSql(`
+    UPDATE device_locks
+    SET released_at = ${sqlString(now)}
+    WHERE released_at IS NULL
+      AND datetime(expires_at) <= datetime(${sqlString(now)});
+  `);
+}
+
+export function listActiveDeviceLockRecords(now: string) {
+  initDeviceLockRepository();
+  cleanupExpiredDeviceLocks(now);
+  return querySql<DeviceLockRow>(`
+    SELECT *
+    FROM device_locks
+    WHERE released_at IS NULL
+      AND datetime(expires_at) > datetime(${sqlString(now)})
+    ORDER BY datetime(acquired_at) DESC;
+  `).map(rowToRecord);
+}
+
+export function findActiveDeviceLockRecord(deviceId: string, now: string) {
+  initDeviceLockRepository();
+  cleanupExpiredDeviceLocks(now);
+  const row = querySql<DeviceLockRow>(`
+    SELECT *
+    FROM device_locks
+    WHERE device_id = ${sqlString(deviceId)}
+      AND released_at IS NULL
+      AND datetime(expires_at) > datetime(${sqlString(now)})
+    ORDER BY datetime(acquired_at) DESC
+    LIMIT 1;
+  `)[0];
+
+  return row ? rowToRecord(row) : null;
+}
+
+export function insertDeviceLockRecord(input: {
+  deviceId: string;
+  ownerType: DeviceLockOwnerType;
+  ownerId: string;
+  metadata: Record<string, unknown>;
+  acquiredAt: string;
+  expiresAt: string;
+}) {
+  initDeviceLockRepository();
+  const id = createId('dlock');
+  runSql(`
+    INSERT INTO device_locks (
+      id,
+      device_id,
+      owner_type,
+      owner_id,
+      metadata_json,
+      acquired_at,
+      expires_at
+    )
+    VALUES (
+      ${sqlString(id)},
+      ${sqlString(input.deviceId)},
+      ${sqlString(input.ownerType)},
+      ${sqlString(input.ownerId)},
+      ${sqlJson(input.metadata)},
+      ${sqlString(input.acquiredAt)},
+      ${sqlString(input.expiresAt)}
+    );
+  `);
+  return id;
+}
+
+export function refreshDeviceLockRecord(input: { lockId: string; expiresAt: string }) {
+  initDeviceLockRepository();
+  runSql(`
+    UPDATE device_locks
+    SET expires_at = ${sqlString(input.expiresAt)}
+    WHERE id = ${sqlString(input.lockId)}
+      AND released_at IS NULL;
+  `);
+}
+
+export function releaseDeviceLockRecord(ownerId: string, releasedAt: string) {
+  initDeviceLockRepository();
+  runSql(`
+    UPDATE device_locks
+    SET released_at = ${sqlString(releasedAt)}
+    WHERE owner_id = ${sqlString(ownerId)}
+      AND released_at IS NULL;
+  `);
+}