@web-auto/webauto 0.1.16 → 0.1.17

package/apps/desktop-console/dist/main/index.mjs

@@ -919,6 +919,9 @@ import path5 from "node:path";
 import { promises as fs3 } from "node:fs";
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 7716;
+var DEFAULT_SNAPSHOT_TIMEOUT_MS = 12e3;
+var DEFAULT_ACTION_TIMEOUT_MS = 12e3;
+var DEFAULT_WAIT_PROBE_TIMEOUT_MS = 3e3;
 function normalizePathForPlatform(raw, platform = process.platform) {
   const input = String(raw || "").trim();
   const isWinPath = platform === "win32" || /^[A-Za-z]:[\\/]/.test(input);
@@ -994,6 +997,21 @@ function toActionError(input, error, extra = {}) {
   };
   return payload;
 }
+async function withTimeout(promise, timeoutMs, label) {
+  const ms = readInt(timeoutMs, 0);
+  if (ms <= 0) return promise;
+  let timer = null;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label}_timeout:${ms}`)), ms);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 async function writeControlFile(host, port) {
   const payload = {
     pid: process.pid,
@@ -1386,7 +1404,11 @@ var UiCliBridge = class {
     let snapshot;
     if (includeSnapshot) {
       try {
-        snapshot = await win2.webContents.executeJavaScript(buildSnapshotScript(), true);
+        snapshot = await withTimeout(
+          win2.webContents.executeJavaScript(buildSnapshotScript(), true),
+          readInt(process.env.WEBAUTO_UI_CLI_SNAPSHOT_TIMEOUT_MS, DEFAULT_SNAPSHOT_TIMEOUT_MS),
+          "snapshot"
+        );
       } catch (err) {
         return {
           ok: false,
@@ -1418,7 +1440,12 @@ var UiCliBridge = class {
     const win2 = this.options.getWindow();
     if (!isUiReady(win2)) return toActionError(input, "window_not_ready");
     try {
-      const out = await win2.webContents.executeJavaScript(buildActionScript(input), true);
+      const timeoutMs = readInt(input?.timeoutMs, readInt(process.env.WEBAUTO_UI_CLI_ACTION_TIMEOUT_MS, DEFAULT_ACTION_TIMEOUT_MS));
+      const out = await withTimeout(
+        win2.webContents.executeJavaScript(buildActionScript(input), true),
+        timeoutMs,
+        "action"
+      );
       return out && typeof out === "object" ? out : toActionError(input, "empty_result");
     } catch (err) {
       return toActionError(input, err?.message || String(err), { details: err?.stack || null });
@@ -1449,7 +1476,11 @@ var UiCliBridge = class {
           const disabled = Boolean(el && 'disabled' in el && el.disabled === true);
           return { exists: Boolean(el), visible, text, value, disabled };
         })()`;
-        const state = await win2.webContents.executeJavaScript(checkScript, true);
+        const state = await withTimeout(
+          win2.webContents.executeJavaScript(checkScript, true),
+          readInt(process.env.WEBAUTO_UI_CLI_WAIT_PROBE_TIMEOUT_MS, DEFAULT_WAIT_PROBE_TIMEOUT_MS),
+          "wait_probe"
+        );
         const exists = Boolean(state?.exists);
         const visible = Boolean(state?.visible);
         const text = String(state?.text || "");

package/apps/desktop-console/entry/ui-cli.mjs

@@ -11,6 +11,13 @@ const APP_ROOT = path.resolve(__dirname, '..');
 const ROOT = path.resolve(APP_ROOT, '..', '..');
 const DEFAULT_HOST = process.env.WEBAUTO_UI_CLI_HOST || '127.0.0.1';
 const DEFAULT_PORT = Number(process.env.WEBAUTO_UI_CLI_PORT || 7716);
+const readEnvPositiveInt = (name, fallback) => {
+  const n = Number(process.env[name]);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+};
+const DEFAULT_HTTP_TIMEOUT_MS = readEnvPositiveInt('WEBAUTO_UI_CLI_HTTP_TIMEOUT_MS', 25_000);
+const DEFAULT_HTTP_RETRIES = readEnvPositiveInt('WEBAUTO_UI_CLI_HTTP_RETRIES', 1);
+const DEFAULT_START_HEALTH_TIMEOUT_MS = readEnvPositiveInt('WEBAUTO_UI_CLI_START_HEALTH_TIMEOUT_MS', 8_000);
 
 function normalizePathForPlatform(raw, platform = process.platform) {
   const input = String(raw || '').trim();
@@ -121,9 +128,37 @@ function resolveEndpoint() {
 
 async function requestJson(endpoint, pathname, init = {}) {
   const url = `http://${endpoint.host}:${endpoint.port}${pathname}`;
-  const res = await fetch(url, init);
-  const json = await res.json().catch(() => ({}));
-  return { ok: res.ok, status: res.status, json };
+  const timeoutMs = parseIntSafe(init?.timeoutMs, DEFAULT_HTTP_TIMEOUT_MS);
+  const retries = Math.max(0, parseIntSafe(init?.retries, DEFAULT_HTTP_RETRIES));
+  const retryDelayMs = parseIntSafe(init?.retryDelayMs, 300);
+  const requestInit = { ...init };
+  delete requestInit.timeoutMs;
+  delete requestInit.retries;
+  delete requestInit.retryDelayMs;
+
+  let lastErr = null;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetch(url, { ...requestInit, signal: controller.signal });
+      clearTimeout(timeout);
+      const json = await res.json().catch(() => ({}));
+      return { ok: res.ok, status: res.status, json };
+    } catch (err) {
+      clearTimeout(timeout);
+      lastErr = err;
+      if (attempt < retries) {
+        await sleep(retryDelayMs * (attempt + 1));
+        continue;
+      }
+    }
+  }
+
+  const msg = lastErr?.name === 'AbortError'
+    ? `request_timeout:${pathname}:${timeoutMs}`
+    : (lastErr?.message || String(lastErr));
+  throw new Error(msg);
 }
 
 function sleep(ms) {
@@ -134,7 +169,7 @@ async function waitForHealth(endpoint, timeoutMs = 30_000) {
   const started = Date.now();
   while (Date.now() - started <= timeoutMs) {
     try {
-      const ret = await requestJson(endpoint, '/health');
+      const ret = await requestJson(endpoint, '/health', { timeoutMs: 2500, retries: 0 });
       if (ret.ok && ret.json?.ok) return ret.json;
     } catch {
       // keep polling
@@ -145,7 +180,7 @@ async function waitForHealth(endpoint, timeoutMs = 30_000) {
 }
 
 async function startConsoleIfNeeded(endpoint) {
-  const health = await waitForHealth(endpoint, 1500);
+  const health = await waitForHealth(endpoint, 3000);
   if (health) return health;
 
   const uiConsoleScript = path.join(APP_ROOT, 'entry', 'ui-console.mjs');
@@ -186,10 +221,17 @@ function printOutput(payload) {
 }
 
 async function sendAction(endpoint, payload) {
+  const waitBudgetMs = payload?.action === 'wait'
+    ? parseIntSafe(payload?.timeoutMs, 15_000) + 5_000
+    : 0;
+  const timeoutMs = Math.max(DEFAULT_HTTP_TIMEOUT_MS, waitBudgetMs);
+  const retries = payload?.action === 'wait' ? 0 : DEFAULT_HTTP_RETRIES;
   return requestJson(endpoint, '/action', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(payload),
+    timeoutMs,
+    retries,
   });
 }
 
@@ -629,7 +671,8 @@ async function main() {
   }
 
   if (cmd === 'start') {
-    const status = await waitForHealth(endpoint, 1000);
+    const startWaitMs = parseIntSafe(args.timeout, DEFAULT_START_HEALTH_TIMEOUT_MS);
+    const status = await waitForHealth(endpoint, startWaitMs);
     if (!status) throw new Error('ui cli bridge not healthy');
     printOutput({ ok: true, endpoint, status });
     return;
@@ -637,7 +680,10 @@ async function main() {
 
   if (cmd === 'status' || cmd === 'snapshot') {
     const pathName = cmd === 'snapshot' ? '/snapshot' : '/status';
-    const ret = await requestJson(endpoint, pathName);
+    const ret = await requestJson(endpoint, pathName, {
+      timeoutMs: parseIntSafe(args.timeout, DEFAULT_HTTP_TIMEOUT_MS),
+      retries: DEFAULT_HTTP_RETRIES,
+    });
     if (!ret.ok) throw new Error(ret.json?.error || `http_${ret.status}`);
     printOutput(ret.json);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/webauto",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "type": "module",
   "bin": {
     "webauto": "bin/webauto.mjs"