android-midscene-automation 0.2.1 → 0.2.3

package/server/remote-agents/routes.ts

@@ -1,5 +1,8 @@
+import { saveRunHistory } from '../appium-recorder/run-history';
+import type { RunDetail } from '../../src/appium-recorder/run-history';
+import { readBody, requestErrorStatus } from '../request-body';
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { completeRemoteCommand, listRemoteAndroidDevices, pollRemoteCommand, registerRemoteAgent } from './registry';
+import { completeRemoteCommand, makeRemoteDeviceId, listRemoteAndroidDevices, pollRemoteCommand, registerRemoteAgent } from './registry';
 import type { RemoteAgentDevice } from './protocol';
 
 function sendJson(res: ServerResponse, payload: unknown, statusCode = 200) {
@@ -8,17 +11,6 @@ function sendJson(res: ServerResponse, payload: unknown, statusCode = 200) {
   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);
-    });
-  });
-}
 
 export async function handleRemoteAgentRequest(req: IncomingMessage, res: ServerResponse) {
   const requestUrl = new URL(req.url || '/', 'http://localhost');
@@ -39,14 +31,14 @@ export async function handleRemoteAgentRequest(req: IncomingMessage, res: Server
         token?: string;
         devices?: RemoteAgentDevice[];
       }>(req);
-      registerRemoteAgent({
+      const control = registerRemoteAgent({
         agentId: parsed.agentId || '',
         agentName: parsed.agentName,
         version: parsed.version,
         token: parsed.token,
         devices: parsed.devices || [],
       });
-      sendJson(res, { success: true });
+      sendJson(res, { success: true, ...control });
       return true;
     }
 
@@ -75,6 +67,11 @@ export async function handleRemoteAgentRequest(req: IncomingMessage, res: Server
         ok: parsed.ok === true,
         data: parsed.data,
         error: parsed.error,
+      }, command => {
+        const result = parsed.data as { history?: RunDetail } | undefined;
+        if (command.type !== 'replay' || !result?.history) return;
+        const script = command.payload?.script as { id: string };
+        saveRunHistory({ ...result.history, scriptId: script.id, deviceId: makeRemoteDeviceId(parsed.agentId!, command.deviceId) });
       });
       sendJson(res, { success: true });
       return true;
@@ -83,7 +80,7 @@ export async function handleRemoteAgentRequest(req: IncomingMessage, res: Server
     sendJson(res, { message: 'Remote Agent 接口不存在' }, 404);
     return true;
   } catch (error) {
-    sendJson(res, { message: error instanceof Error ? error.message : 'Remote Agent 请求失败' }, 500);
+    sendJson(res, { message: error instanceof Error ? error.message : 'Remote Agent 请求失败' }, requestErrorStatus(error));
     return true;
   }
 }

package/server/request-body.test.ts

@@ -0,0 +1,40 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer, type IncomingMessage } from 'node:http';
+import { PassThrough } from 'node:stream';
+import { readBody, readRawBody, requestErrorStatus } from './request-body';
+
+test('malformed JSON returns 400 and subsequent requests remain healthy', async () => {
+  const server = createServer(async (req, res) => {
+    try { res.end(JSON.stringify(await readBody(req))); }
+    catch (error) { res.statusCode = requestErrorStatus(error); res.end(); }
+  });
+  await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address();
+  assert.ok(address && typeof address === 'object');
+  try {
+    const url = `http://127.0.0.1:${address.port}`;
+    for (const body of ['{', 'null', '[]', '123']) assert.equal((await fetch(url, { method: 'POST', body })).status, 400);
+    const response = await fetch(url, { method: 'POST', body: '{"ok":true}' });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), { ok: true });
+  } finally { server.closeAllConnections(); await new Promise<void>(resolve => server.close(() => resolve())); }
+});
+
+test('body limits cover content-length and streamed chunks; aborts reject without crashing', async () => {
+  for (const useLength of [true, false]) {
+    const stream = new PassThrough();
+    const req = Object.assign(stream, { headers: useLength ? { 'content-length': '9' } : {} }) as unknown as IncomingMessage;
+    const promise = readRawBody(req, 8);
+    const rejected = assert.rejects(promise, error => requestErrorStatus(error) === 413);
+    if (!useLength) { stream.write('1234'); stream.write('56789'); }
+    await rejected;
+    stream.end();
+  }
+  const stream = Object.assign(new PassThrough(), { headers: {} });
+  const rejected = assert.rejects(readRawBody(stream as unknown as IncomingMessage), error => requestErrorStatus(error) === 400);
+  stream.emit('aborted');
+  stream.emit('error', new Error('ECONNRESET'));
+  await rejected;
+  stream.destroy();
+});

package/server/request-body.ts

@@ -0,0 +1,48 @@
+import type { IncomingMessage } from 'node:http';
+
+export class RequestBodyError extends Error {
+  constructor(message: string, readonly statusCode: number) { super(message); }
+}
+
+export function requestErrorStatus(error: unknown, fallback = 500) {
+  return error instanceof RequestBodyError ? error.statusCode : fallback;
+}
+
+export function readRawBody(req: IncomingMessage, limit = 16 * 1024 * 1024): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    let size = 0;
+    const timer = setTimeout(() => fail(new RequestBodyError('请求读取超时', 408)), 30_000);
+    const cleanup = () => {
+      clearTimeout(timer);
+      req.off('data', data); req.off('end', end); req.off('aborted', aborted); req.off('error', fail);
+    };
+    const fail = (error: Error) => {
+      cleanup(); chunks.length = 0;
+      // An aborted socket can emit an error after the aborted event.
+      req.once('error', () => {});
+      req.resume(); reject(error);
+    };
+    const data = (chunk: Buffer | string) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      size += buffer.length;
+      if (size > limit) { fail(new RequestBodyError('请求内容过大', 413)); return; }
+      chunks.push(buffer);
+    };
+    const end = () => { cleanup(); resolve(Buffer.concat(chunks)); };
+    const aborted = () => fail(new RequestBodyError('请求已中断', 400));
+    req.on('data', data); req.once('end', end); req.once('aborted', aborted); req.once('error', fail);
+    if (Number(req.headers['content-length']) > limit) fail(new RequestBodyError('请求内容过大', 413));
+  });
+}
+
+export async function readBody<T>(req: IncomingMessage): Promise<T> {
+  const body = await readRawBody(req);
+  try {
+    const value: unknown = JSON.parse(body.toString('utf8') || '{}');
+    if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error();
+    return value as T;
+  } catch {
+    throw new RequestBodyError('请求必须是有效的 JSON 对象', 400);
+  }
+}