android-midscene-automation 0.1.0

package/server/model-call-usage-importer.ts

@@ -0,0 +1,108 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { appPath } from './paths';
+import { saveModelUsageRecord } from './model-usage-repository';
+
+type MidsceneModelConfig = {
+  provider?: string;
+  name?: string;
+  family?: string;
+};
+
+type ModelCallUsage = {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_tokens?: number;
+  time_cost?: number;
+  model_name?: string;
+  response_model_name?: string;
+  model_description?: string;
+};
+
+type ModelCallRecord = {
+  timestamp?: string;
+  type?: string;
+  modelFamily?: string;
+  provider?: string;
+  final?: {
+    usage?: ModelCallUsage;
+    timeCost?: number;
+  };
+};
+
+function modelRequestDir() {
+  return appPath('midscene_run', 'model-requests');
+}
+
+function numberValue(value: unknown) {
+  return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : undefined;
+}
+
+function listModelRequestFilesSince(sinceMs: number) {
+  const dir = modelRequestDir();
+  if (!fs.existsSync(dir)) return [];
+
+  return fs
+    .readdirSync(dir)
+    .filter((name) => name.endsWith('.jsonl'))
+    .map((name) => path.join(dir, name))
+    .filter((filePath) => {
+      const stat = fs.statSync(filePath);
+      return stat.mtimeMs >= sinceMs - 1_000;
+    });
+}
+
+function recordsFromFile(filePath: string) {
+  return fs
+    .readFileSync(filePath, 'utf8')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .flatMap((line) => {
+      try {
+        return [JSON.parse(line) as ModelCallRecord];
+      } catch {
+        return [];
+      }
+    });
+}
+
+export function importMidsceneModelUsage(input: {
+  sinceMs: number;
+  model: MidsceneModelConfig;
+  success: boolean;
+}) {
+  let imported = 0;
+  const files = listModelRequestFilesSince(input.sinceMs);
+
+  for (const filePath of files) {
+    for (const record of recordsFromFile(filePath)) {
+      if (record.type !== 'response') continue;
+      const usage = record.final?.usage;
+      if (!usage) continue;
+
+      const promptTokens = numberValue(usage.prompt_tokens);
+      const completionTokens = numberValue(usage.completion_tokens);
+      const totalTokens = numberValue(usage.total_tokens) ?? numberValue((promptTokens || 0) + (completionTokens || 0));
+
+      saveModelUsageRecord({
+        modelKey: 'midscene',
+        provider: input.model.provider || (record.provider === 'codex-app-server' ? 'codex' : 'custom'),
+        modelName: usage.model_name || usage.response_model_name || input.model.name || '',
+        family: input.model.family || record.modelFamily || '',
+        success: input.success,
+        durationMs: numberValue(usage.time_cost) ?? numberValue(record.final?.timeCost) ?? 0,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        createdAt: record.timestamp,
+      });
+      imported += 1;
+    }
+  }
+
+  return {
+    imported,
+    files,
+  };
+}

package/server/model-tester.ts

@@ -0,0 +1,104 @@
+import { execFile } from 'node:child_process';
+import OpenAI from 'openai';
+
+type ModelInput = {
+  provider?: 'custom' | 'codex';
+  baseUrl: string;
+  apiKey: string;
+  name: string;
+  family?: string;
+};
+
+const CODEX_MODEL_NAMES = new Set([
+  'gpt-5.4',
+  'gpt-5.5',
+  'gpt-5.6-sol',
+  'gpt-5.6-terra',
+  'gpt-5.6-luna',
+]);
+
+type ModelUsage = {
+  promptTokens?: number;
+  completionTokens?: number;
+  totalTokens?: number;
+};
+
+type ModelTestResult = {
+  ok: boolean;
+  content: string;
+  durationMs: number;
+  usage?: ModelUsage;
+};
+
+function execCodex(args: string[]) {
+  return new Promise<string>((resolve, reject) => {
+    execFile('codex', args, { timeout: 10_000 }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error((stderr || error.message).trim()));
+        return;
+      }
+      resolve((stdout || stderr).trim());
+    });
+  });
+}
+
+async function testCodexConnection(input: ModelInput): Promise<ModelTestResult> {
+  const startedAt = Date.now();
+  if (input.baseUrl !== 'codex://app-server' || !input.name || input.family !== 'gpt-5') {
+    throw new Error('Codex 配置不完整，请使用 codex://app-server、gpt-5 family 和支持的 GPT-5 模型');
+  }
+
+  if (!CODEX_MODEL_NAMES.has(input.name)) {
+    throw new Error(`Codex 模型不在当前支持列表：${Array.from(CODEX_MODEL_NAMES).join('、')}`);
+  }
+
+  const loginStatus = await execCodex(['login', 'status']);
+  await execCodex(['app-server', '--help']);
+
+  return {
+    ok: true,
+    content: `Codex 可用：${loginStatus || '已登录'}；app-server 可用；模型 ${input.name}/${input.family}`,
+    durationMs: Date.now() - startedAt,
+  };
+}
+
+export async function testModelConnection(input: ModelInput): Promise<ModelTestResult> {
+  if (input.provider === 'codex' || input.baseUrl === 'codex://app-server') {
+    return testCodexConnection(input);
+  }
+
+  if (!input.baseUrl || !input.apiKey || !input.name) {
+    throw new Error('模型配置不完整');
+  }
+
+  const startedAt = Date.now();
+  const client = new OpenAI({
+    apiKey: input.apiKey,
+    baseURL: input.baseUrl,
+  });
+
+  const result = await client.chat.completions.create({
+    model: input.name,
+    temperature: 0,
+    messages: [
+      {
+        role: 'user',
+        content: 'Reply with OK only.',
+      },
+    ],
+  });
+
+  const content = result.choices[0]?.message?.content?.trim() || '';
+  const usage: ModelUsage = {
+    promptTokens: result.usage?.prompt_tokens,
+    completionTokens: result.usage?.completion_tokens,
+    totalTokens: result.usage?.total_tokens,
+  };
+
+  return {
+    ok: true,
+    content,
+    durationMs: Date.now() - startedAt,
+    usage,
+  };
+}

package/server/model-usage-repository.ts

@@ -0,0 +1,131 @@
+import {
+  createId,
+  querySql,
+  runSql,
+  sqlNullableString,
+  sqlString,
+} from './storage/sqlite';
+
+export type ModelUsageRecord = {
+  id: string;
+  modelKey: 'midscene' | 'scriptOptimizer';
+  provider: string;
+  modelName: string;
+  family: string;
+  success: boolean;
+  durationMs: number;
+  promptTokens?: number;
+  completionTokens?: number;
+  totalTokens?: number;
+  errorMessage?: string;
+  createdAt: string;
+};
+
+type ModelUsageRow = {
+  id: string;
+  model_key: 'midscene' | 'scriptOptimizer';
+  provider: string;
+  model_name: string;
+  family: string | null;
+  success: 0 | 1;
+  duration_ms: number;
+  prompt_tokens: number | null;
+  completion_tokens: number | null;
+  total_tokens: number | null;
+  error_message: string | null;
+  created_at: string;
+};
+
+let initialized = false;
+
+function sqlNullableNumber(value: number | null | undefined) {
+  return typeof value === 'number' && Number.isFinite(value) ? String(Math.max(0, Math.floor(value))) : 'NULL';
+}
+
+function rowToRecord(row: ModelUsageRow): ModelUsageRecord {
+  return {
+    id: row.id,
+    modelKey: row.model_key,
+    provider: row.provider,
+    modelName: row.model_name,
+    family: row.family || '',
+    success: row.success === 1,
+    durationMs: row.duration_ms,
+    promptTokens: row.prompt_tokens ?? undefined,
+    completionTokens: row.completion_tokens ?? undefined,
+    totalTokens: row.total_tokens ?? undefined,
+    errorMessage: row.error_message || undefined,
+    createdAt: row.created_at,
+  };
+}
+
+export function initModelUsageRepository() {
+  if (initialized) return;
+  initialized = true;
+  runSql(`
+    PRAGMA journal_mode = WAL;
+    CREATE TABLE IF NOT EXISTS model_usage_records (
+      id TEXT PRIMARY KEY,
+      model_key TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      model_name TEXT NOT NULL,
+      family TEXT NULL,
+      success INTEGER NOT NULL,
+      duration_ms INTEGER NOT NULL,
+      prompt_tokens INTEGER NULL,
+      completion_tokens INTEGER NULL,
+      total_tokens INTEGER NULL,
+      error_message TEXT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_model_usage_records_created_at ON model_usage_records(created_at DESC);
+  `);
+}
+
+export function saveModelUsageRecord(input: Omit<ModelUsageRecord, 'id' | 'createdAt'> & { createdAt?: string }) {
+  initModelUsageRepository();
+  const id = createId('usage');
+  const createdAt = input.createdAt || new Date().toISOString();
+  runSql(`
+    INSERT INTO model_usage_records (
+      id,
+      model_key,
+      provider,
+      model_name,
+      family,
+      success,
+      duration_ms,
+      prompt_tokens,
+      completion_tokens,
+      total_tokens,
+      error_message,
+      created_at
+    )
+    VALUES (
+      ${sqlString(id)},
+      ${sqlString(input.modelKey)},
+      ${sqlString(input.provider || 'custom')},
+      ${sqlString(input.modelName || '')},
+      ${sqlNullableString(input.family)},
+      ${input.success ? 1 : 0},
+      ${sqlNullableNumber(input.durationMs)},
+      ${sqlNullableNumber(input.promptTokens)},
+      ${sqlNullableNumber(input.completionTokens)},
+      ${sqlNullableNumber(input.totalTokens)},
+      ${sqlNullableString(input.errorMessage)},
+      ${sqlString(createdAt)}
+    );
+  `);
+  return listModelUsageRecords(1)[0];
+}
+
+export function listModelUsageRecords(limit = 50) {
+  initModelUsageRepository();
+  const boundedLimit = Math.max(1, Math.min(200, Math.floor(limit)));
+  return querySql<ModelUsageRow>(`
+    SELECT *
+    FROM model_usage_records
+    ORDER BY datetime(created_at) DESC
+    LIMIT ${boundedLimit};
+  `).map(rowToRecord).reverse();
+}

package/server/operations/repository.ts

@@ -0,0 +1,218 @@
+import {
+  createId,
+  querySql,
+  runSql,
+  sqlJson,
+  sqlNullableString,
+  sqlString,
+} from '../storage/sqlite';
+import type { OperationEventRecord, OperationRecord, OperationStatus } from './types';
+
+type OperationRow = {
+  id: string;
+  kind: 'script_run';
+  status: OperationStatus;
+  script_name: string;
+  device_id: string;
+  session_id: string;
+  request_json: string;
+  result_json: string | null;
+  output: string | null;
+  file_path: string | null;
+  error_message: string | null;
+  created_at: string;
+  started_at: string;
+  finished_at: string | null;
+};
+
+type OperationEventRow = {
+  seq: number;
+  operation_id: string;
+  timestamp: string;
+  event_type: string;
+  message: string | null;
+  data_json: string;
+};
+
+let initialized = false;
+
+function rowToOperation(row: OperationRow): OperationRecord {
+  return {
+    id: row.id,
+    kind: row.kind,
+    status: row.status,
+    scriptName: row.script_name,
+    deviceId: row.device_id,
+    sessionId: row.session_id,
+    request: JSON.parse(row.request_json || '{}') as Record<string, unknown>,
+    result: row.result_json ? JSON.parse(row.result_json) as Record<string, unknown> : null,
+    output: row.output || '',
+    filePath: row.file_path || '',
+    errorMessage: row.error_message || '',
+    createdAt: row.created_at,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at || '',
+  };
+}
+
+function rowToEvent(row: OperationEventRow): OperationEventRecord {
+  return {
+    seq: row.seq,
+    operationId: row.operation_id,
+    timestamp: row.timestamp,
+    eventType: row.event_type,
+    message: row.message || '',
+    data: JSON.parse(row.data_json || '{}') as Record<string, unknown>,
+  };
+}
+
+export function initOperationRepository() {
+  if (initialized) return;
+  initialized = true;
+  runSql(`
+    PRAGMA journal_mode = WAL;
+    CREATE TABLE IF NOT EXISTS operations (
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL,
+      status TEXT NOT NULL,
+      script_name TEXT NOT NULL,
+      device_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      request_json TEXT NOT NULL DEFAULT '{}',
+      result_json TEXT NULL,
+      output TEXT NULL,
+      file_path TEXT NULL,
+      error_message TEXT NULL,
+      created_at TEXT NOT NULL,
+      started_at TEXT NOT NULL,
+      finished_at TEXT NULL
+    );
+    CREATE TABLE IF NOT EXISTS operation_events (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT,
+      operation_id TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      message TEXT NULL,
+      data_json TEXT NOT NULL DEFAULT '{}'
+    );
+    CREATE INDEX IF NOT EXISTS idx_operations_created_at ON operations(created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_operations_device_status ON operations(device_id, status);
+    CREATE INDEX IF NOT EXISTS idx_operation_events_operation_id_seq ON operation_events(operation_id, seq);
+  `);
+}
+
+export function createOperationRecord(input: {
+  scriptName: string;
+  deviceId: string;
+  sessionId: string;
+  request: Record<string, unknown>;
+}) {
+  initOperationRepository();
+  const id = createId('op');
+  const now = new Date().toISOString();
+  runSql(`
+    INSERT INTO operations (
+      id,
+      kind,
+      status,
+      script_name,
+      device_id,
+      session_id,
+      request_json,
+      created_at,
+      started_at
+    )
+    VALUES (
+      ${sqlString(id)},
+      'script_run',
+      'running',
+      ${sqlString(input.scriptName)},
+      ${sqlString(input.deviceId)},
+      ${sqlString(input.sessionId)},
+      ${sqlJson(input.request)},
+      ${sqlString(now)},
+      ${sqlString(now)}
+    );
+  `);
+  return getOperationRecord(id);
+}
+
+export function getOperationRecord(id: string) {
+  initOperationRepository();
+  const row = querySql<OperationRow>(`
+    SELECT *
+    FROM operations
+    WHERE id = ${sqlString(id)}
+    LIMIT 1;
+  `)[0];
+  return row ? rowToOperation(row) : null;
+}
+
+export function listOperationRecords(limit = 30) {
+  initOperationRepository();
+  return querySql<OperationRow>(`
+    SELECT *
+    FROM operations
+    ORDER BY datetime(created_at) DESC
+    LIMIT ${Math.max(1, Math.min(100, Math.floor(limit)))};
+  `).map(rowToOperation);
+}
+
+export function finishOperationRecord(input: {
+  id: string;
+  status: OperationStatus;
+  result?: Record<string, unknown> | null;
+  output?: string;
+  filePath?: string;
+  errorMessage?: string;
+}) {
+  initOperationRepository();
+  const now = new Date().toISOString();
+  runSql(`
+    UPDATE operations
+    SET
+      status = ${sqlString(input.status)},
+      result_json = ${input.result === undefined ? 'result_json' : input.result === null ? 'NULL' : sqlJson(input.result)},
+      output = COALESCE(${input.output !== undefined ? sqlString(input.output) : 'NULL'}, output),
+      file_path = COALESCE(${sqlNullableString(input.filePath)}, file_path),
+      error_message = COALESCE(${sqlNullableString(input.errorMessage)}, error_message),
+      finished_at = ${sqlString(now)}
+    WHERE id = ${sqlString(input.id)};
+  `);
+  return getOperationRecord(input.id);
+}
+
+export function appendOperationEventRecord(input: {
+  operationId: string;
+  eventType: string;
+  message?: string;
+  data?: Record<string, unknown>;
+}) {
+  initOperationRepository();
+  runSql(`
+    INSERT INTO operation_events (
+      operation_id,
+      timestamp,
+      event_type,
+      message,
+      data_json
+    )
+    VALUES (
+      ${sqlString(input.operationId)},
+      ${sqlString(new Date().toISOString())},
+      ${sqlString(input.eventType)},
+      ${sqlNullableString(input.message)},
+      ${sqlJson(input.data || {})}
+    );
+  `);
+}
+
+export function listOperationEventRecords(operationId: string) {
+  initOperationRepository();
+  return querySql<OperationEventRow>(`
+    SELECT *
+    FROM operation_events
+    WHERE operation_id = ${sqlString(operationId)}
+    ORDER BY seq ASC;
+  `).map(rowToEvent);
+}

package/server/operations/service.ts

@@ -0,0 +1,84 @@
+import {
+  appendOperationEventRecord,
+  createOperationRecord,
+  finishOperationRecord,
+  getOperationRecord,
+  listOperationEventRecords,
+  listOperationRecords,
+} from './repository';
+import type { OperationStatus } from './types';
+
+// 创建脚本执行记录；后续日志、步骤事件、最终结果都挂在这个 operation 下。
+export function startScriptRunOperation(input: {
+  scriptName: string;
+  deviceId: string;
+  sessionId: string;
+  request: Record<string, unknown>;
+}) {
+  const operation = createOperationRecord(input);
+  if (!operation) {
+    throw new Error('创建执行记录失败');
+  }
+  appendOperationEventRecord({
+    operationId: operation.id,
+    eventType: 'operation_start',
+    message: `开始执行脚本：${input.scriptName}`,
+    data: {
+      scriptName: input.scriptName,
+      deviceId: input.deviceId,
+      sessionId: input.sessionId,
+    },
+  });
+  return operation;
+}
+
+export function recordOperationEvent(input: {
+  operationId: string;
+  eventType: string;
+  message?: string;
+  data?: Record<string, unknown>;
+}) {
+  appendOperationEventRecord(input);
+}
+
+export function finishScriptRunOperation(input: {
+  operationId: string;
+  status: OperationStatus;
+  result?: Record<string, unknown>;
+  output?: string;
+  filePath?: string;
+  errorMessage?: string;
+}) {
+  recordOperationEvent({
+    operationId: input.operationId,
+    eventType: 'operation_finish',
+    message: input.errorMessage || `执行结束：${input.status}`,
+    data: {
+      status: input.status,
+      filePath: input.filePath,
+    },
+  });
+  return finishOperationRecord({
+    id: input.operationId,
+    status: input.status,
+    result: input.result || null,
+    output: input.output || '',
+    filePath: input.filePath || '',
+    errorMessage: input.errorMessage || '',
+  });
+}
+
+export function listOperations(limit?: number) {
+  return listOperationRecords(limit);
+}
+
+export function getOperationWithEvents(operationId: string) {
+  const operation = getOperationRecord(operationId);
+  if (!operation) {
+    return null;
+  }
+  return {
+    operation,
+    events: listOperationEventRecords(operationId),
+  };
+}

package/server/operations/types.ts

@@ -0,0 +1,27 @@
+export type OperationStatus = 'running' | 'succeeded' | 'failed' | 'cancelled';
+
+export type OperationRecord = {
+  id: string;
+  kind: 'script_run';
+  status: OperationStatus;
+  scriptName: string;
+  deviceId: string;
+  sessionId: string;
+  request: Record<string, unknown>;
+  result: Record<string, unknown> | null;
+  output: string;
+  filePath: string;
+  errorMessage: string;
+  createdAt: string;
+  startedAt: string;
+  finishedAt: string;
+};
+
+export type OperationEventRecord = {
+  seq: number;
+  operationId: string;
+  timestamp: string;
+  eventType: string;
+  message: string;
+  data: Record<string, unknown>;
+};

package/server/paths.ts

@@ -0,0 +1,27 @@
+// App-root based path resolution.
+//
+// The standalone dev server runs with cwd = project root, so historically all
+// runtime files (config.json, .midscene-app, scripts-output, midscene_run,
+// .midscene-generated) were resolved against process.cwd(). When the app runs
+// as a DSH plugin the harness process cwd is NOT the project root and must not
+// be changed (DSH core packages rely on process.cwd()), so every runtime path
+// now resolves through this module. The default root stays process.cwd() so
+// the standalone flow behaves exactly as before.
+import path from 'node:path';
+
+let appRoot = process.cwd();
+
+/** Point all app runtime paths at an explicit root (used by the DSH plugin). */
+export function setAppRoot(root: string) {
+  appRoot = root;
+}
+
+/** The current app root (defaults to process.cwd()). */
+export function getAppRoot() {
+  return appRoot;
+}
+
+/** Resolve one or more segments under the app root. */
+export function appPath(...segments: string[]) {
+  return path.resolve(appRoot, ...segments);
+}