android-midscene-automation 0.1.0

package/server/device-locks/service.ts

@@ -0,0 +1,72 @@
+import {
+  findActiveDeviceLockRecord,
+  insertDeviceLockRecord,
+  listActiveDeviceLockRecords,
+  refreshDeviceLockRecord,
+  releaseDeviceLockRecord,
+} from './repository';
+import { DeviceLockConflictError, type DeviceLockOwnerType } from './types';
+
+const DEFAULT_LOCK_TTL_MS = 15 * 60 * 1000;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function addMs(timestamp: string, ms: number) {
+  return new Date(new Date(timestamp).getTime() + ms).toISOString();
+}
+
+// 设备锁是脚本执行的并发保护：同一台手机同一时间只允许一个 owner 操作。
+export function acquireDeviceLock(input: {
+  deviceId: string;
+  ownerType: DeviceLockOwnerType;
+  ownerId: string;
+  ttlMs?: number;
+  metadata?: Record<string, unknown>;
+}) {
+  if (!input.deviceId) {
+    throw new Error('设备 ID 不能为空');
+  }
+
+  const now = nowIso();
+  const expiresAt = addMs(now, input.ttlMs || DEFAULT_LOCK_TTL_MS);
+  const active = findActiveDeviceLockRecord(input.deviceId, now);
+
+  if (active && active.ownerId !== input.ownerId) {
+    throw new DeviceLockConflictError(active);
+  }
+
+  if (active) {
+    refreshDeviceLockRecord({ lockId: active.id, expiresAt });
+    return { ...active, expiresAt };
+  }
+
+  const id = insertDeviceLockRecord({
+    deviceId: input.deviceId,
+    ownerType: input.ownerType,
+    ownerId: input.ownerId,
+    metadata: input.metadata || {},
+    acquiredAt: now,
+    expiresAt,
+  });
+
+  return {
+    id,
+    deviceId: input.deviceId,
+    ownerType: input.ownerType,
+    ownerId: input.ownerId,
+    metadata: input.metadata || {},
+    acquiredAt: now,
+    expiresAt,
+    releasedAt: '',
+  };
+}
+
+export function releaseDeviceLock(ownerId: string) {
+  releaseDeviceLockRecord(ownerId, nowIso());
+}
+
+export function listActiveDeviceLocks() {
+  return listActiveDeviceLockRecords(nowIso());
+}

package/server/device-locks/types.ts

@@ -0,0 +1,22 @@
+export type DeviceLockOwnerType = 'script_run' | 'manual_action' | 'preview';
+
+export type DeviceLockRecord = {
+  id: string;
+  deviceId: string;
+  ownerType: DeviceLockOwnerType;
+  ownerId: string;
+  metadata: Record<string, unknown>;
+  acquiredAt: string;
+  expiresAt: string;
+  releasedAt: string;
+};
+
+export class DeviceLockConflictError extends Error {
+  readonly conflict: DeviceLockRecord;
+
+  constructor(conflict: DeviceLockRecord) {
+    super(`设备 ${conflict.deviceId} 正在被 ${conflict.ownerType} 占用`);
+    this.name = 'DeviceLockConflictError';
+    this.conflict = conflict;
+  }
+}

package/server/device-sessions/repository.ts

@@ -0,0 +1,169 @@
+import {
+  createId,
+  querySql,
+  runSql,
+  sqlNullableString,
+  sqlString,
+} from '../storage/sqlite';
+import type { DeviceSessionPatch, DeviceSessionRecord, DeviceSessionStatus } from './types';
+
+type DeviceSessionRow = {
+  id: string;
+  device_id: string;
+  status: DeviceSessionStatus;
+  playground_url: string | null;
+  preview_kind: string | null;
+  session_connected: number;
+  setup_state: string | null;
+  preview_error: string | null;
+  created_at: string;
+  updated_at: string;
+  expires_at: string;
+  idle_expires_at: string;
+};
+
+let initialized = false;
+
+function rowToRecord(row: DeviceSessionRow): DeviceSessionRecord {
+  return {
+    id: row.id,
+    deviceId: row.device_id,
+    status: row.status,
+    playgroundUrl: row.playground_url || '',
+    previewKind: row.preview_kind || '',
+    sessionConnected: row.session_connected === 1,
+    setupState: row.setup_state || '',
+    previewError: row.preview_error || '',
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    expiresAt: row.expires_at,
+    idleExpiresAt: row.idle_expires_at,
+  };
+}
+
+export function initDeviceSessionRepository() {
+  if (initialized) return;
+  initialized = true;
+  runSql(`
+    PRAGMA journal_mode = WAL;
+    CREATE TABLE IF NOT EXISTS device_sessions (
+      id TEXT PRIMARY KEY,
+      device_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      playground_url TEXT NULL,
+      preview_kind TEXT NULL,
+      session_connected INTEGER NOT NULL DEFAULT 0,
+      setup_state TEXT NULL,
+      preview_error TEXT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL,
+      idle_expires_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_device_sessions_device_status
+      ON device_sessions(device_id, status, updated_at DESC);
+  `);
+}
+
+export function listDeviceSessionRecords() {
+  initDeviceSessionRepository();
+  return querySql<DeviceSessionRow>(`
+    SELECT *
+    FROM device_sessions
+    ORDER BY datetime(updated_at) DESC
+    LIMIT 50;
+  `).map(rowToRecord);
+}
+
+export function getActiveDeviceSessionRecord(deviceId: string, now: string) {
+  initDeviceSessionRepository();
+  const row = querySql<DeviceSessionRow>(`
+    SELECT *
+    FROM device_sessions
+    WHERE device_id = ${sqlString(deviceId)}
+      AND status = 'active'
+      AND datetime(expires_at) > datetime(${sqlString(now)})
+      AND datetime(idle_expires_at) > datetime(${sqlString(now)})
+    ORDER BY datetime(updated_at) DESC
+    LIMIT 1;
+  `)[0];
+
+  return row ? rowToRecord(row) : null;
+}
+
+export function expireStaleDeviceSessions(now: string) {
+  initDeviceSessionRepository();
+  runSql(`
+    UPDATE device_sessions
+    SET status = 'expired', updated_at = ${sqlString(now)}
+    WHERE status = 'active'
+      AND (
+        datetime(expires_at) <= datetime(${sqlString(now)})
+        OR datetime(idle_expires_at) <= datetime(${sqlString(now)})
+      );
+  `);
+}
+
+export function createDeviceSessionRecord(input: {
+  deviceId: string;
+  now: string;
+  expiresAt: string;
+  idleExpiresAt: string;
+  patch?: DeviceSessionPatch;
+}) {
+  initDeviceSessionRepository();
+  const id = createId('dsess');
+  runSql(`
+    INSERT INTO device_sessions (
+      id,
+      device_id,
+      status,
+      playground_url,
+      preview_kind,
+      session_connected,
+      setup_state,
+      preview_error,
+      created_at,
+      updated_at,
+      expires_at,
+      idle_expires_at
+    )
+    VALUES (
+      ${sqlString(id)},
+      ${sqlString(input.deviceId)},
+      'active',
+      ${sqlNullableString(input.patch?.playgroundUrl)},
+      ${sqlNullableString(input.patch?.previewKind)},
+      ${input.patch?.sessionConnected ? 1 : 0},
+      ${sqlNullableString(input.patch?.setupState)},
+      ${sqlNullableString(input.patch?.previewError)},
+      ${sqlString(input.now)},
+      ${sqlString(input.now)},
+      ${sqlString(input.expiresAt)},
+      ${sqlString(input.idleExpiresAt)}
+    );
+  `);
+
+  return getActiveDeviceSessionRecord(input.deviceId, input.now);
+}
+
+export function touchDeviceSessionRecord(input: {
+  sessionId: string;
+  now: string;
+  idleExpiresAt: string;
+  patch?: DeviceSessionPatch;
+}) {
+  initDeviceSessionRepository();
+  runSql(`
+    UPDATE device_sessions
+    SET
+      updated_at = ${sqlString(input.now)},
+      idle_expires_at = ${sqlString(input.idleExpiresAt)},
+      playground_url = COALESCE(${sqlNullableString(input.patch?.playgroundUrl)}, playground_url),
+      preview_kind = COALESCE(${sqlNullableString(input.patch?.previewKind)}, preview_kind),
+      session_connected = ${input.patch?.sessionConnected === undefined ? 'session_connected' : input.patch.sessionConnected ? 1 : 0},
+      setup_state = COALESCE(${sqlNullableString(input.patch?.setupState)}, setup_state),
+      preview_error = COALESCE(${sqlNullableString(input.patch?.previewError)}, preview_error)
+    WHERE id = ${sqlString(input.sessionId)};
+  `);
+}

package/server/device-sessions/service.ts

@@ -0,0 +1,59 @@
+import {
+  createDeviceSessionRecord,
+  expireStaleDeviceSessions,
+  getActiveDeviceSessionRecord,
+  listDeviceSessionRecords,
+  touchDeviceSessionRecord,
+} from './repository';
+import type { DeviceSessionPatch } from './types';
+
+const SESSION_TTL_MS = 30 * 60 * 1000;
+const SESSION_IDLE_TTL_MS = 10 * 60 * 1000;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function addMs(timestamp: string, ms: number) {
+  return new Date(new Date(timestamp).getTime() + ms).toISOString();
+}
+
+// 复用同一设备的活动 session；不存在或过期时才创建新 session，避免页面切换导致设备状态丢失。
+export function ensureDeviceSession(input: { deviceId: string; patch?: DeviceSessionPatch }) {
+  if (!input.deviceId) {
+    throw new Error('设备 ID 不能为空');
+  }
+
+  const now = nowIso();
+  expireStaleDeviceSessions(now);
+  const existing = getActiveDeviceSessionRecord(input.deviceId, now);
+  const idleExpiresAt = addMs(now, SESSION_IDLE_TTL_MS);
+
+  if (existing) {
+    touchDeviceSessionRecord({
+      sessionId: existing.id,
+      now,
+      idleExpiresAt,
+      patch: input.patch,
+    });
+    return getActiveDeviceSessionRecord(input.deviceId, now) || existing;
+  }
+
+  const created = createDeviceSessionRecord({
+    deviceId: input.deviceId,
+    now,
+    expiresAt: addMs(now, SESSION_TTL_MS),
+    idleExpiresAt,
+    patch: input.patch,
+  });
+
+  if (!created) {
+    throw new Error('创建设备会话失败');
+  }
+  return created;
+}
+
+export function listDeviceSessions() {
+  expireStaleDeviceSessions(nowIso());
+  return listDeviceSessionRecords();
+}

package/server/device-sessions/types.ts

@@ -0,0 +1,24 @@
+export type DeviceSessionStatus = 'active' | 'expired' | 'closed';
+
+export type DeviceSessionRecord = {
+  id: string;
+  deviceId: string;
+  status: DeviceSessionStatus;
+  playgroundUrl: string;
+  previewKind: string;
+  sessionConnected: boolean;
+  setupState: string;
+  previewError: string;
+  createdAt: string;
+  updatedAt: string;
+  expiresAt: string;
+  idleExpiresAt: string;
+};
+
+export type DeviceSessionPatch = {
+  playgroundUrl?: string;
+  previewKind?: string;
+  sessionConnected?: boolean;
+  setupState?: string;
+  previewError?: string;
+};