@web-auto/webauto 0.1.17 → 0.1.19

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

@@ -3,7 +3,7 @@ import minimist from 'minimist';
 import { spawn } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -18,6 +18,8 @@ const readEnvPositiveInt = (name, 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);
+const DEFAULT_STATUS_TIMEOUT_MS = readEnvPositiveInt('WEBAUTO_UI_CLI_STATUS_TIMEOUT_MS', 45_000);
+const DEFAULT_ACTION_HTTP_TIMEOUT_MS = readEnvPositiveInt('WEBAUTO_UI_CLI_ACTION_HTTP_TIMEOUT_MS', 40_000);
 
 function normalizePathForPlatform(raw, platform = process.platform) {
   const input = String(raw || '').trim();
@@ -57,7 +59,7 @@ const CONTROL_FILE = path.join(resolveWebautoRoot(), 'run', 'ui-cli.json');
 
 const args = minimist(process.argv.slice(2), {
   boolean: ['help', 'json', 'auto-start', 'build', 'install', 'continue-on-error', 'exact', 'keep-open', 'detailed'],
-  string: ['host', 'port', 'selector', 'value', 'text', 'key', 'tab', 'label', 'state', 'file', 'output', 'timeout', 'interval', 'nth'],
+  string: ['host', 'port', 'selector', 'value', 'text', 'key', 'tab', 'label', 'state', 'file', 'output', 'timeout', 'interval', 'nth', 'reason'],
   alias: { h: 'help' },
   default: { 'auto-start': false, json: false, 'keep-open': false },
 });
@@ -82,6 +84,7 @@ Usage:
   webauto ui cli full-cover [--build] [--install] [--output <report.json>] [--keep-open]
   webauto ui cli run --file <steps.json> [--continue-on-error]
   webauto ui cli stop
+  webauto ui cli restart [--reason <text>] [--timeout <ms>]
 
 Options:
   --host <host>          UI CLI bridge host (default 127.0.0.1)
@@ -107,18 +110,41 @@ function parseIntSafe(input, fallback) {
   return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
 }
 
+function buildUiCliClientMeta(cmd = '') {
+  return {
+    client: 'webauto-ui-cli',
+    cmd: String(cmd || '').trim() || null,
+    pid: process.pid,
+    ppid: process.ppid,
+  };
+}
+
 function readControlFile() {
   try {
     if (!existsSync(CONTROL_FILE)) return null;
     const raw = JSON.parse(readFileSync(CONTROL_FILE, 'utf8'));
     const host = String(raw?.host || '').trim() || DEFAULT_HOST;
     const port = parseIntSafe(raw?.port, DEFAULT_PORT);
-    return { host, port };
+    const pid = parseIntSafe(raw?.pid, 0);
+    return {
+      host,
+      port,
+      pid: pid > 0 ? pid : null,
+      startedAt: String(raw?.startedAt || '').trim() || null,
+    };
   } catch {
     return null;
   }
 }
 
+function removeControlFileIfPresent() {
+  try {
+    rmSync(CONTROL_FILE, { force: true });
+  } catch {
+    // ignore
+  }
+}
+
 function resolveEndpoint() {
   const fromFile = readControlFile();
   const host = String(args.host || fromFile?.host || DEFAULT_HOST).trim();
@@ -165,6 +191,52 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function isProcessAlive(pid) {
+  const targetPid = parseIntSafe(pid, 0);
+  if (targetPid <= 0) return false;
+  try {
+    process.kill(targetPid, 0);
+    return true;
+  } catch (err) {
+    if (err?.code === 'ESRCH') return false;
+    return true;
+  }
+}
+
+async function terminatePid(pid) {
+  const targetPid = parseIntSafe(pid, 0);
+  if (targetPid <= 0) return { ok: false, error: 'invalid_pid' };
+  if (process.platform === 'win32') {
+    return new Promise((resolve) => {
+      const child = spawn('taskkill', ['/PID', String(targetPid), '/T', '/F'], {
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      let stderr = '';
+      child.stderr.on('data', (chunk) => { stderr += String(chunk || ''); });
+      child.on('error', (err) => resolve({ ok: false, error: err?.message || String(err) }));
+      child.on('close', (code) => {
+        if (code === 0) return resolve({ ok: true, pid: targetPid });
+        if (!isProcessAlive(targetPid)) {
+          return resolve({ ok: true, pid: targetPid, alreadyStopped: true });
+        }
+        return resolve({
+          ok: false,
+          pid: targetPid,
+          error: stderr.trim() || `taskkill_exit_${code}`,
+        });
+      });
+    });
+  }
+  try {
+    process.kill(targetPid, 'SIGTERM');
+    return { ok: true, pid: targetPid };
+  } catch (err) {
+    if (err?.code === 'ESRCH') return { ok: true, pid: targetPid, alreadyStopped: true };
+    return { ok: false, pid: targetPid, error: err?.message || String(err) };
+  }
+}
+
 async function waitForHealth(endpoint, timeoutMs = 30_000) {
   const started = Date.now();
   while (Date.now() - started <= timeoutMs) {
@@ -179,9 +251,60 @@ async function waitForHealth(endpoint, timeoutMs = 30_000) {
   return null;
 }
 
+async function waitForHealthDown(endpoint, timeoutMs = 15_000) {
+  const started = Date.now();
+  while (Date.now() - started <= timeoutMs) {
+    try {
+      const ret = await requestJson(endpoint, '/health', { timeoutMs: 1500, retries: 0 });
+      if (!ret.ok || !ret.json?.ok) return true;
+    } catch {
+      return true;
+    }
+    await sleep(300);
+  }
+  return false;
+}
+
+async function probeActionChannel(endpoint, timeoutMs = 6000) {
+  try {
+    const ret = await requestJson(endpoint, '/action', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'probe', selector: 'body', _client: buildUiCliClientMeta('probe') }),
+      timeoutMs,
+      retries: 0,
+    });
+    return ret.ok && Boolean(ret.json?.ok);
+  } catch {
+    return false;
+  }
+}
+
+function resolveKnownPid(statusRet = null) {
+  const fromHealth = parseIntSafe(statusRet?.json?.pid, 0);
+  if (fromHealth > 0) return fromHealth;
+  const fromFile = parseIntSafe(readControlFile()?.pid, 0);
+  if (fromFile > 0) return fromFile;
+  return 0;
+}
+
 async function startConsoleIfNeeded(endpoint) {
   const health = await waitForHealth(endpoint, 3000);
-  if (health) return health;
+  if (health) {
+    const channelReady = await probeActionChannel(endpoint);
+    if (channelReady) return health;
+    const pid = parseIntSafe(health?.pid, 0) || parseIntSafe(readControlFile()?.pid, 0);
+    if (pid > 0) await terminatePid(pid);
+    removeControlFileIfPresent();
+    await sleep(500);
+  } else {
+    const stalePid = parseIntSafe(readControlFile()?.pid, 0);
+    if (stalePid > 0) {
+      await terminatePid(stalePid);
+      removeControlFileIfPresent();
+      await sleep(500);
+    }
+  }
 
   const uiConsoleScript = path.join(APP_ROOT, 'entry', 'ui-console.mjs');
   const runUiConsole = async (extraArgs = []) => {
@@ -205,6 +328,13 @@ async function startConsoleIfNeeded(endpoint) {
 
   const ready = await waitForHealth(endpoint, 45_000);
   if (!ready) throw new Error('ui cli bridge is not ready after start');
+  const readyChannel = await probeActionChannel(endpoint);
+  if (!readyChannel) {
+    const pid = parseIntSafe(ready?.pid, 0);
+    if (pid > 0) await terminatePid(pid);
+    removeControlFileIfPresent();
+    throw new Error('ui cli bridge action channel is not ready after start');
+  }
   return ready;
 }
 
@@ -221,15 +351,20 @@ function printOutput(payload) {
 }
 
 async function sendAction(endpoint, payload) {
-  const waitBudgetMs = payload?.action === 'wait'
+  const actionBudgetMs = payload?.action === 'wait'
     ? parseIntSafe(payload?.timeoutMs, 15_000) + 5_000
-    : 0;
-  const timeoutMs = Math.max(DEFAULT_HTTP_TIMEOUT_MS, waitBudgetMs);
+    : DEFAULT_ACTION_HTTP_TIMEOUT_MS;
+  const timeoutMs = Math.max(DEFAULT_HTTP_TIMEOUT_MS, actionBudgetMs);
   const retries = payload?.action === 'wait' ? 0 : DEFAULT_HTTP_RETRIES;
+  const baseCmd = String(args._[0] || '').trim();
+  const bodyPayload = {
+    ...(payload || {}),
+    _client: buildUiCliClientMeta(baseCmd || payload?.action || ''),
+  };
   return requestJson(endpoint, '/action', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(payload),
+    body: JSON.stringify(bodyPayload),
     timeoutMs,
     retries,
   });
@@ -541,14 +676,15 @@ async function runFullCover(endpoint) {
     await click('#scheduler-dryrun');
     await input('#scheduler-like-keywords', '真牛逼,购买链接');
     await click('#scheduler-save-btn');
-    await wait('#scheduler-list');
-    // Wait for async schedule refresh to render the new task.
-    for (let i = 0; i < 6; i += 1) {
-      const raw = await probeRaw('#scheduler-list', { text: taskName });
-      if (Number(raw?.textMatchedCount || 0) > 0) break;
-      await sleep(500);
-    }
-    await runProbe('scheduler', '#scheduler-list', { text: taskName });
+    await waitForElement('#scheduler-list', 40, 250);
+    await runProbe('scheduler', '#scheduler-list');
+    // Record whether the newly saved task name is visible, but don't fail hard here.
+    // The scheduler list can transiently refresh and reorder under active datasets.
+    const taskNameProbe = await probeRaw('#scheduler-list', { text: taskName });
+    pushStep('scheduler:task_name_visible', Number(taskNameProbe?.textMatchedCount || 0) > 0, {
+      payload: { selector: '#scheduler-list', text: taskName },
+      result: taskNameProbe,
+    });
     await runProbe('scheduler', '#scheduler-list button', { text: '编辑' });
     await runProbe('scheduler', '#scheduler-list button', { text: '执行' });
     await runProbe('scheduler', '#scheduler-list button', { text: '导出' });
@@ -679,9 +815,10 @@ async function main() {
   }
 
   if (cmd === 'status' || cmd === 'snapshot') {
-    const pathName = cmd === 'snapshot' ? '/snapshot' : '/status';
+    const pathName = cmd === 'snapshot' ? '/snapshot' : '/health';
+    const statusTimeoutMs = parseIntSafe(args.timeout, DEFAULT_STATUS_TIMEOUT_MS);
     const ret = await requestJson(endpoint, pathName, {
-      timeoutMs: parseIntSafe(args.timeout, DEFAULT_HTTP_TIMEOUT_MS),
+      timeoutMs: statusTimeoutMs,
       retries: DEFAULT_HTTP_RETRIES,
     });
     if (!ret.ok) throw new Error(ret.json?.error || `http_${ret.status}`);
@@ -690,9 +827,141 @@ async function main() {
   }
 
   if (cmd === 'stop') {
-    const ret = await sendAction(endpoint, { action: 'close_window' });
-    if (!ret.ok) throw new Error(ret.json?.error || `http_${ret.status}`);
-    printOutput(ret.json);
+    let statusRet = null;
+    try {
+      statusRet = await requestJson(endpoint, '/health', {
+        timeoutMs: Math.min(8000, parseIntSafe(args.timeout, DEFAULT_HTTP_TIMEOUT_MS)),
+        retries: 0,
+      });
+    } catch {
+      statusRet = null;
+    }
+    const knownPid = resolveKnownPid(statusRet);
+    const ret = await requestJson(endpoint, '/action', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'close_window', _client: buildUiCliClientMeta('stop') }),
+      timeoutMs: Math.min(8000, parseIntSafe(args.timeout, DEFAULT_ACTION_HTTP_TIMEOUT_MS)),
+      retries: 0,
+    }).catch((error) => ({
+      ok: false,
+      status: 0,
+      json: { ok: false, error: error?.message || String(error) },
+    }));
+    if (ret.ok && ret.json?.ok) {
+      const down = await waitForHealthDown(endpoint, 12_000);
+      if (down) {
+        removeControlFileIfPresent();
+        printOutput(ret.json);
+        return;
+      }
+      if (knownPid > 0) {
+        const killed = await terminatePid(knownPid);
+        if (!killed.ok) {
+          throw new Error(`close_window pending, force-stop failed: ${killed.error || 'unknown_error'}`);
+        }
+        removeControlFileIfPresent();
+        printOutput({
+          ok: true,
+          forced: true,
+          pid: knownPid,
+          reason: 'close_window_timeout',
+        });
+        return;
+      }
+      printOutput(ret.json);
+      return;
+    }
+
+    const actionError = String(ret?.json?.error || `http_${ret?.status || 'request'}`).trim() || 'unknown_error';
+    if (knownPid > 0) {
+      const killed = await terminatePid(knownPid);
+      if (!killed.ok) {
+        throw new Error(`force-stop failed: ${killed.error || 'unknown_error'}`);
+      }
+      removeControlFileIfPresent();
+      printOutput({
+        ok: true,
+        forced: true,
+        pid: knownPid,
+        reason: actionError || 'request_failed',
+      });
+      return;
+    }
+    throw new Error(actionError);
+  }
+
+  if (cmd === 'restart') {
+    let statusRet = null;
+    try {
+      statusRet = await requestJson(endpoint, '/health', {
+        timeoutMs: Math.min(8000, parseIntSafe(args.timeout, DEFAULT_HTTP_TIMEOUT_MS)),
+        retries: 0,
+      });
+    } catch {
+      statusRet = null;
+    }
+    const knownPid = resolveKnownPid(statusRet);
+    const restartReason = String(args.reason || '').trim() || 'ui_cli';
+    const ret = await requestJson(endpoint, '/action', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'restart', reason: restartReason, _client: buildUiCliClientMeta('restart') }),
+      timeoutMs: Math.min(8000, parseIntSafe(args.timeout, DEFAULT_ACTION_HTTP_TIMEOUT_MS)),
+      retries: 0,
+    }).catch((error) => ({
+      ok: false,
+      status: 0,
+      json: { ok: false, error: error?.message || String(error) },
+    }));
+    if (!ret.ok || !ret.json?.ok) {
+      const actionError = String(ret?.json?.error || `http_${ret?.status || 'request'}`).trim() || 'unknown_error';
+      if (knownPid > 0) {
+        await terminatePid(knownPid);
+        removeControlFileIfPresent();
+      }
+      const recovered = await startConsoleIfNeeded(endpoint);
+      printOutput({
+        ok: true,
+        restarting: true,
+        reason: restartReason,
+        recoveredByForceRestart: true,
+        previousPid: knownPid > 0 ? knownPid : null,
+        status: recovered,
+      });
+      return;
+    }
+
+    const transitionBudgetMs = Math.min(15_000, Math.max(2_000, parseIntSafe(args.timeout, 60_000)));
+    const transitionStart = Date.now();
+    while (Date.now() - transitionStart <= transitionBudgetMs) {
+      try {
+        const probe = await requestJson(endpoint, '/health', { timeoutMs: 1500, retries: 0 });
+        const probePid = Number(probe?.json?.pid || 0);
+        if (!probe.ok || !probe.json?.ok) break;
+        if (knownPid > 0 && probePid > 0 && probePid !== knownPid) break;
+      } catch {
+        break;
+      }
+      await sleep(250);
+    }
+
+    const restartWaitMs = parseIntSafe(args.timeout, 90_000);
+    let status = await waitForHealth(endpoint, restartWaitMs);
+    if (!status || (knownPid > 0 && Number(status?.pid || 0) === knownPid)) {
+      if (knownPid > 0) {
+        await terminatePid(knownPid);
+        removeControlFileIfPresent();
+      }
+      status = await startConsoleIfNeeded(endpoint);
+    }
+    printOutput({
+      ok: true,
+      restarting: true,
+      reason: restartReason,
+      previousPid: knownPid > 0 ? knownPid : null,
+      status,
+    });
     return;
   }
 

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

@@ -94,8 +94,17 @@ function checkBuildStatus() {
   return existsSync(DIST_MAIN);
 }
 
-function quotePsSingle(value) {
-  return String(value || '').replace(/'/g, "''");
+function resolveElectronBin() {
+  const distDir = path.join(APP_ROOT, 'node_modules', 'electron', 'dist');
+  const candidates = process.platform === 'win32'
+    ? [path.join(distDir, 'electron.exe')]
+    : (process.platform === 'darwin'
+      ? [
+        path.join(distDir, 'electron'),
+        path.join(distDir, 'Electron.app', 'Contents', 'MacOS', 'Electron'),
+      ]
+      : [path.join(distDir, 'electron')]);
+  return candidates.find((item) => existsSync(item)) || candidates[0];
 }
 
 function sleep(ms) {
@@ -119,6 +128,26 @@ async function waitForCoreServicesHealthy(timeoutMs = 90000) {
   return false;
 }
 
+async function readWindowsSessionId(pid) {
+  const targetPid = Number(pid || 0);
+  if (!Number.isFinite(targetPid) || targetPid <= 0 || process.platform !== 'win32') return null;
+  return new Promise((resolve) => {
+    const child = spawn('wmic', ['process', 'where', `processid=${targetPid}`, 'get', 'SessionId', '/value'], {
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    let stdout = '';
+    child.stdout.on('data', (chunk) => { stdout += String(chunk || ''); });
+    child.on('error', () => resolve(null));
+    child.on('close', () => {
+      const match = stdout.match(/SessionId\s*=\s*(\d+)/i);
+      if (!match) return resolve(null);
+      const sessionId = Number(match[1]);
+      resolve(Number.isFinite(sessionId) ? sessionId : null);
+    });
+  });
+}
+
 function terminateProcessTree(pid) {
   const target = Number(pid || 0);
   if (!Number.isFinite(target) || target <= 0) return;
@@ -174,9 +203,7 @@ async function startConsole(noDaemon = false) {
   if (noDaemon) env.WEBAUTO_NO_DAEMON = '1';
   const detached = !noDaemon;
   const stdio = detached ? 'ignore' : 'inherit';
-  const electronBin = process.platform === 'win32'
-    ? path.join(APP_ROOT, 'node_modules', 'electron', 'dist', 'electron.exe')
-    : path.join(APP_ROOT, 'node_modules', 'electron', 'dist', 'electron');
+  const electronBin = resolveElectronBin();
   if (!existsSync(electronBin)) {
     throw new Error(`electron binary not found: ${electronBin}`);
   }
@@ -184,12 +211,12 @@ async function startConsole(noDaemon = false) {
   const spawnArgs = [DIST_MAIN];
 
   if (process.platform === 'win32' && detached) {
-    const filePath = electronBin;
-    const argList = [DIST_MAIN];
-    const psArgList = argList.map((item) => `'${quotePsSingle(item)}'`).join(',');
-    const psScript = `$p = Start-Process -FilePath '${quotePsSingle(filePath)}' -ArgumentList @(${psArgList}) -WorkingDirectory '${quotePsSingle(APP_ROOT)}' -PassThru; Write-Output $p.Id`;
+    const escaped = (input) => String(input || '').replace(/"/g, '""');
+    const commandLine = [`"${escaped(electronBin)}"`]
+      .concat(spawnArgs.map((arg) => `"${escaped(arg)}"`))
+      .join(' ');
     const pid = await new Promise((resolve, reject) => {
-      const child = spawn('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', psScript], {
+      const child = spawn('wmic', ['process', 'call', 'create', commandLine], {
         cwd: APP_ROOT,
         env,
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -201,12 +228,12 @@ async function startConsole(noDaemon = false) {
       child.stderr.on('data', (chunk) => { stderr += String(chunk || ''); });
       child.on('error', reject);
       child.on('close', (code) => {
-        if (code === 0) {
-          const pid = String(stdout || '').trim().split(/\s+/).pop();
-          resolve(pid || 'unknown');
-        } else {
-          reject(new Error(`Start-Process failed (${code}): ${stderr.trim() || stdout.trim() || 'unknown error'}`));
+        if (code !== 0) {
+          reject(new Error(`wmic create failed (${code}): ${stderr.trim() || stdout.trim() || 'unknown error'}`));
+          return;
         }
+        const match = stdout.match(/ProcessId\s*=\s*(\d+)/i);
+        resolve(match?.[1] || 'unknown');
       });
     });
     const healthy = await waitForCoreServicesHealthy();
@@ -214,7 +241,11 @@ async function startConsole(noDaemon = false) {
       terminateProcessTree(pid);
       throw new Error('desktop console started but core services did not become healthy');
     }
+    const sessionId = await readWindowsSessionId(pid);
     console.log(`[ui-console] Started (PID: ${pid || 'unknown'})`);
+    if (sessionId === 0) {
+      console.warn('[ui-console] started in Session 0 (service/non-interactive). UI bridge is available, but desktop window will not be visible.');
+    }
     return;
   }