@web-auto/webauto 0.1.8 → 0.1.11

package/runtime/infra/utils/scripts/service/start-browser-service.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { execSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { setTimeout as wait } from 'node:timers/promises';
+
+function resolveWebautoRoot() {
+  const explicitHome = String(process.env.WEBAUTO_HOME || '').trim();
+  if (explicitHome) return path.resolve(explicitHome);
+
+  const legacyRoot = String(process.env.WEBAUTO_ROOT || process.env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) {
+    const normalized = path.resolve(legacyRoot);
+    const base = path.basename(normalized).toLowerCase();
+    if (base === '.webauto' || base === 'webauto') return normalized;
+    return path.join(normalized, '.webauto');
+  }
+
+  if (process.platform === 'win32') {
+    try {
+      if (fs.existsSync('D:\\')) return 'D:\\webauto';
+    } catch {
+      // ignore probing errors
+    }
+  }
+  return path.join(os.homedir(), '.webauto');
+}
+
+const RUN_DIR = path.join(resolveWebautoRoot(), 'run');
+const PID_FILE = path.join(RUN_DIR, 'browser-service.pid');
+const DEFAULT_HOST = process.env.WEBAUTO_BROWSER_HOST || '127.0.0.1';
+const DEFAULT_PORT = Number(process.env.WEBAUTO_BROWSER_PORT || 7704);
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function health(host = DEFAULT_HOST, port = DEFAULT_PORT) {
+  try {
+    const res = await fetch(`http://${host}:${port}/health`);
+    if (!res.ok) return false;
+    const body = await res.json().catch(() => ({}));
+    return Boolean(body?.ok ?? true);
+  } catch {
+    return false;
+  }
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const hostIdx = args.findIndex((item) => item === '--host');
+  const portIdx = args.findIndex((item) => item === '--port');
+  const host = hostIdx >= 0 && args[hostIdx + 1] ? String(args[hostIdx + 1]) : DEFAULT_HOST;
+  const port = portIdx >= 0 && args[portIdx + 1] ? Number(args[portIdx + 1]) : DEFAULT_PORT;
+  return {
+    host,
+    port: Number.isFinite(port) && port > 0 ? port : DEFAULT_PORT,
+  };
+}
+
+function latestMtimeMs(targetPath) {
+  if (!fs.existsSync(targetPath)) return 0;
+  const stat = fs.statSync(targetPath);
+  if (stat.isFile()) return Number(stat.mtimeMs || 0);
+  if (!stat.isDirectory()) return 0;
+  let latest = Number(stat.mtimeMs || 0);
+  const stack = [targetPath];
+  while (stack.length) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      let entryStat;
+      try {
+        entryStat = fs.statSync(full);
+      } catch {
+        continue;
+      }
+      const mtime = Number(entryStat.mtimeMs || 0);
+      if (mtime > latest) latest = mtime;
+      if (entryStat.isDirectory()) stack.push(full);
+    }
+  }
+  return latest;
+}
+
+function shouldRebuild(distEntry) {
+  if (!fs.existsSync(distEntry)) return true;
+  if (String(process.env.WEBAUTO_SKIP_BUILD_CHECK || '') === '1') return false;
+  if (!fs.existsSync(path.resolve('tsconfig.services.json'))) return false;
+  const distMtime = Number(fs.statSync(distEntry).mtimeMs || 0);
+  const watchRoots = [
+    path.resolve('modules/camo-backend/src'),
+    path.resolve('modules/logging/src'),
+  ];
+  const latestSourceMtime = Math.max(...watchRoots.map((root) => latestMtimeMs(root)));
+  return latestSourceMtime > distMtime;
+}
+
+function ensureBuild() {
+  const distEntry = path.resolve('dist/modules/camo-backend/src/index.js');
+  if (!shouldRebuild(distEntry)) return distEntry;
+  console.log('[browser-service] backend entry missing/stale, running npm run -s build:services');
+  execSync('npm run -s build:services', { stdio: 'inherit' });
+  if (!fs.existsSync(distEntry)) {
+    throw new Error(`backend entry missing after build: ${distEntry}`);
+  }
+  return distEntry;
+}
+
+async function main() {
+  const { host, port } = parseArgs();
+  fs.mkdirSync(RUN_DIR, { recursive: true });
+
+  if (await health(host, port)) {
+    console.log(`Browser service already healthy on http://${host}:${port}`);
+    return;
+  }
+
+  if (fs.existsSync(PID_FILE)) {
+    try {
+      const oldPid = Number(fs.readFileSync(PID_FILE, 'utf8'));
+      if (oldPid && isAlive(oldPid)) {
+        console.log(`Browser service already running (pid=${oldPid}).`);
+        return;
+      }
+    } catch {
+      // stale pid file will be overwritten
+    }
+  }
+
+  const entry = ensureBuild();
+  const child = spawn(process.execPath, [entry], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      BROWSER_SERVICE_HOST: host,
+      BROWSER_SERVICE_PORT: String(port),
+      WEBAUTO_BROWSER_HOST: host,
+      WEBAUTO_BROWSER_PORT: String(port),
+    },
+  });
+  child.unref();
+  fs.writeFileSync(PID_FILE, String(child.pid));
+
+  for (let i = 0; i < 30; i += 1) {
+    if (await health(host, port)) {
+      console.log(`Browser service started (pid=${child.pid}) on http://${host}:${port}`);
+      return;
+    }
+    await wait(300);
+  }
+
+  throw new Error('browser service did not become healthy in time');
+}
+
+main().catch((err) => {
+  console.error(`[browser-service] start failed: ${err?.message || String(err)}`);
+  process.exit(1);
+});

package/runtime/infra/utils/scripts/service/stop-api.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync, unlinkSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+
+const PID_FILE = process.env.WEBAUTO_API_PID_FILE
+  ? path.resolve(process.env.WEBAUTO_API_PID_FILE)
+  : path.join(os.tmpdir(), 'webauto-api.pid');
+
+function killPid(pid){
+  if (process.platform === 'win32') {
+    try {
+      spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+    } catch {}
+    return;
+  }
+  try { process.kill(pid, 'SIGTERM'); } catch {}
+  setTimeout(() => { try { process.kill(pid, 'SIGKILL'); } catch {} }, 1000);
+}
+
+async function main(){
+  if (!existsSync(PID_FILE)) { console.log('No pid file.'); return; }
+  const pid = Number(readFileSync(PID_FILE,'utf8').trim());
+  if (pid>0) killPid(pid);
+  try { unlinkSync(PID_FILE); } catch {}
+  console.log('API stopped.');
+}
+
+main().catch(e=>{ console.error(e); process.exit(1); });

package/runtime/infra/utils/scripts/service/stop-browser-service.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { setTimeout as wait } from 'node:timers/promises';
+
+const RUN_DIR = path.join(os.homedir(), '.webauto', 'run');
+const PID_FILE = path.join(RUN_DIR, 'browser-service.pid');
+const DEFAULT_PORT = Number(process.env.WEBAUTO_BROWSER_PORT || 7704);
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function killByPort(port) {
+  try {
+    if (process.platform === 'win32') {
+      const out = execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8' });
+      const pids = new Set();
+      out.split(/\r?\n/).forEach((line) => {
+        const match = line.trim().match(/\s(\d+)\s*$/);
+        if (match) pids.add(Number(match[1]));
+      });
+      for (const pid of pids) {
+        try {
+          execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore' });
+        } catch {
+          // ignore
+        }
+      }
+      return pids.size > 0;
+    }
+
+    const out = execSync(`lsof -ti :${port} || true`, { encoding: 'utf8' });
+    const pids = out.split(/\s+/).map((item) => Number(item.trim())).filter(Boolean);
+    for (const pid of pids) {
+      try {
+        process.kill(pid, 'SIGKILL');
+      } catch {
+        // ignore
+      }
+    }
+    return pids.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  if (!fs.existsSync(PID_FILE)) {
+    const killed = killByPort(DEFAULT_PORT);
+    console.log(killed ? `Killed processes on :${DEFAULT_PORT}` : 'No PID file found. Service may not be running.');
+    return;
+  }
+
+  const pid = Number(fs.readFileSync(PID_FILE, 'utf8'));
+  if (!pid) {
+    fs.rmSync(PID_FILE, { force: true });
+    killByPort(DEFAULT_PORT);
+    console.log('Invalid PID file. Performed port cleanup.');
+    return;
+  }
+
+  if (!isAlive(pid)) {
+    fs.rmSync(PID_FILE, { force: true });
+    killByPort(DEFAULT_PORT);
+    console.log(`Process ${pid} is not running. Cleaned stale PID.`);
+    return;
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    // ignore
+  }
+
+  for (let i = 0; i < 15; i += 1) {
+    if (!isAlive(pid)) break;
+    await wait(200);
+  }
+
+  if (isAlive(pid)) {
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // ignore
+    }
+  }
+
+  fs.rmSync(PID_FILE, { force: true });
+  killByPort(DEFAULT_PORT);
+  console.log(`Browser service stopped (pid=${pid}).`);
+}
+
+main().catch((err) => {
+  console.error(`[browser-service] stop failed: ${err?.message || String(err)}`);
+  process.exit(1);
+});

package/runtime/infra/utils/scripts/test-services.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+// 测试脚本：验证服务是否能正常启动
+import { spawn, execSync } from 'node:child_process';
+import { setTimeout as wait } from 'node:timers/promises';
+
+function log(msg){ console.log(`[test-services] ${msg}`); }
+
+async function testHealth(port, name, timeout = 10000) {
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < timeout) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/health`);
+      if (response.ok) {
+        const data = await response.json();
+        log(`✅ ${name} (${port}): 健康检查通过 - ${JSON.stringify(data)}`);
+        return true;
+      }
+    } catch (e) {
+      // 继续等待
+    }
+    await wait(500);
+  }
+  
+  log(`❌ ${name} (${port}): 健康检查失败`);
+  return false;
+}
+
+async function main() {
+  log('🧪 测试服务启动...');
+  
+  // 1. 构建服务
+  try {
+    log('构建服务...');
+    execSync('npm run -s build:services', { stdio: 'inherit' });
+    log('✅ 构建完成');
+  } catch (e) {
+    log('❌ 构建失败');
+    process.exit(1);
+  }
+  
+  // 2. 清理端口
+  const ports = [7704, 7705, 7706];
+  for (const port of ports) {
+    try {
+      execSync(`lsof -ti :${port} | xargs kill -9 || true`, { stdio: 'ignore' });
+    } catch {}
+  }
+  
+  // 3. 测试 Unified API
+  log('测试 Unified API...');
+  const unifiedProc = spawn('node', ['dist/apps/webauto/server.js'], {
+    env: { ...process.env, WEBAUTO_RUNTIME_MODE: 'unified', WEBAUTO_UNIFIED_PORT: '7704' },
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  
+  unifiedProc.stdout.on('data', (data) => {
+    log(`[Unified API] ${data.toString().trim()}`);
+  });
+  
+  unifiedProc.stderr.on('data', (data) => {
+    log(`[Unified API ERROR] ${data.toString().trim()}`);
+  });
+  
+  unifiedProc.on('error', (err) => {
+    log(`❌ Unified API 启动错误: ${err.message}`);
+  });
+  
+  const unifiedOk = await testHealth(7704, 'Unified API', 15000);
+  
+  if (unifiedOk) {
+    // 4. 测试基本 API
+    try {
+      const response = await fetch('http://127.0.0.1:7704/v1/system/state');
+      const data = await response.json();
+      log(`📋 系统状态: ${JSON.stringify(data)}`);
+    } catch (e) {
+      log(`❌ 系统状态获取失败: ${e.message}`);
+    }
+  }
+  
+  // 5. 清理
+  unifiedProc.kill('SIGTERM');
+  await wait(1000);
+  unifiedProc.kill('SIGKILL');
+  
+  log('🧹 测试完成');
+  process.exit(unifiedOk ? 0 : 1);
+}
+
+main().catch(e => {
+  console.error('❌ 测试失败:', e.message);
+  process.exit(1);
+});

package/scripts/bump-version.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const ROOT_PACKAGE = path.join(ROOT, 'package.json');
+const DESKTOP_PACKAGE = path.join(ROOT, 'apps', 'desktop-console', 'package.json');
+const ROOT_LOCK = path.join(ROOT, 'package-lock.json');
+
+function usage(exitCode = 0) {
+  console.log(`Usage:
+  node scripts/bump-version.mjs [patch|minor|major] [--json]
+
+Examples:
+  node scripts/bump-version.mjs
+  node scripts/bump-version.mjs patch
+  node scripts/bump-version.mjs minor --json`);
+  process.exit(exitCode);
+}
+
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, json) {
+  writeFileSync(filePath, `${JSON.stringify(json, null, 2)}\n`, 'utf8');
+}
+
+function bumpSemver(version, kind) {
+  const match = String(version || '').trim().match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  if (!match) {
+    throw new Error(`invalid semver: ${version}`);
+  }
+  let major = Number(match[1]);
+  let minor = Number(match[2]);
+  let patch = Number(match[3]);
+  if (kind === 'major') {
+    major += 1;
+    minor = 0;
+    patch = 0;
+  } else if (kind === 'minor') {
+    minor += 1;
+    patch = 0;
+  } else {
+    patch += 1;
+  }
+  return `${major}.${minor}.${patch}`;
+}
+
+function updatePackageVersion(filePath, nextVersion) {
+  const json = readJson(filePath);
+  const prev = String(json.version || '').trim();
+  if (!prev) throw new Error(`missing version in ${filePath}`);
+  json.version = nextVersion;
+  writeJson(filePath, json);
+  return prev;
+}
+
+function updateRootLockVersion(filePath, nextVersion) {
+  if (!existsSync(filePath)) return false;
+  const lock = readJson(filePath);
+  lock.version = nextVersion;
+  if (lock.packages && lock.packages['']) {
+    lock.packages[''].version = nextVersion;
+  }
+  writeJson(filePath, lock);
+  return true;
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--help') || argv.includes('-h')) usage(0);
+
+  const jsonMode = argv.includes('--json');
+  const kindArg = argv.find((arg) => !arg.startsWith('-')) || 'patch';
+  const kind = String(kindArg || 'patch').trim().toLowerCase();
+  if (!['patch', 'minor', 'major'].includes(kind)) {
+    console.error(`[version] unsupported bump type: ${kind}`);
+    usage(2);
+  }
+
+  const rootPkg = readJson(ROOT_PACKAGE);
+  const prevRootVersion = String(rootPkg.version || '').trim();
+  if (!prevRootVersion) {
+    throw new Error(`missing version in ${ROOT_PACKAGE}`);
+  }
+  const nextVersion = bumpSemver(prevRootVersion, kind);
+
+  const prevDesktopVersion = updatePackageVersion(DESKTOP_PACKAGE, nextVersion);
+  const prevVersion = updatePackageVersion(ROOT_PACKAGE, nextVersion);
+  const lockUpdated = updateRootLockVersion(ROOT_LOCK, nextVersion);
+
+  const result = {
+    ok: true,
+    kind,
+    previous: prevVersion,
+    next: nextVersion,
+    desktopPrevious: prevDesktopVersion,
+    desktopNext: nextVersion,
+    lockUpdated,
+    files: [
+      ROOT_PACKAGE,
+      DESKTOP_PACKAGE,
+      ...(lockUpdated ? [ROOT_LOCK] : []),
+    ],
+  };
+
+  if (jsonMode) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`[version] bump ${kind}: ${prevVersion} -> ${nextVersion}`);
+  console.log(`[version] updated: ${ROOT_PACKAGE}`);
+  console.log(`[version] updated: ${DESKTOP_PACKAGE}`);
+  if (lockUpdated) console.log(`[version] updated: ${ROOT_LOCK}`);
+}
+
+main();

package/services/unified-api/server.ts

@@ -296,11 +296,13 @@ class UnifiedApiServer {
           if (existing) return existing;
           const profileId = String(seed?.profileId || 'unknown').trim() || 'unknown';
           const keyword = String(seed?.keyword || '').trim();
+          const uiTriggerId = String(seed?.uiTriggerId || seed?.triggerId || '').trim();
           const phase = normalizeTaskPhase(seed?.phase);
           return this.taskRegistry.createTask({
             runId: normalizedRunId,
             profileId,
             keyword,
+            uiTriggerId,
             phase,
           });
         };
@@ -311,11 +313,13 @@ class UnifiedApiServer {
           const phase = normalizeTaskPhase(payload?.phase);
           const profileId = String(payload?.profileId || '').trim();
           const keyword = String(payload?.keyword || '').trim();
+          const uiTriggerId = String(payload?.uiTriggerId || payload?.triggerId || '').trim();
           const details = payload?.details && typeof payload.details === 'object' ? payload.details : undefined;
           const patch: any = {};
           if (phase !== 'unknown') patch.phase = phase;
           if (profileId) patch.profileId = profileId;
           if (keyword) patch.keyword = keyword;
+          if (uiTriggerId) patch.uiTriggerId = uiTriggerId;
           if (details) patch.details = details;
           if (Object.keys(patch).length > 0) {
             this.taskRegistry.updateTask(normalizedRunId, patch);

package/services/unified-api/task-state.ts

@@ -37,10 +37,12 @@ export interface TaskState {
   runId: string;
   profileId: string;
   keyword: string;
+  uiTriggerId?: string;
   phase: TaskPhase;
   status: TaskStatus;
   progress: TaskProgress;
   stats: TaskStats;
+  createdAt: number;
   startedAt: number;
   updatedAt: number;
   completedAt?: number;
@@ -71,6 +73,7 @@ class TaskStateRegistry {
     runId: string;
     profileId: string;
     keyword: string;
+    uiTriggerId?: string;
     phase?: TaskPhase;
   }): TaskState {
     const now = Date.now();
@@ -78,6 +81,7 @@ class TaskStateRegistry {
       runId: partial.runId,
       profileId: partial.profileId,
       keyword: partial.keyword,
+      uiTriggerId: partial.uiTriggerId ? String(partial.uiTriggerId).trim() : undefined,
       phase: partial.phase || 'unknown',
       status: 'starting',
       progress: { total: 0, processed: 0, failed: 0 },
@@ -89,6 +93,7 @@ class TaskStateRegistry {
         imagesDownloaded: 0,
         ocrProcessed: 0,
       },
+      createdAt: now,
       startedAt: now,
       updatedAt: now,
       details: {