@web-auto/webauto 0.1.18 → 0.1.19

package/apps/webauto/entry/lib/schedule-store.mjs

@@ -130,6 +130,25 @@ function parseIsoTs(value) {
   return Number.isFinite(ts) ? ts : null;
 }
 
+function parsePid(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return Math.floor(n);
+}
+
+function isPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = String(error?.code || '').toUpperCase();
+    if (code === 'ESRCH') return false;
+    // EPERM/UNKNOWN should be treated as alive to avoid false reclamation.
+    return true;
+  }
+}
+
 function buildLeasePayload({ ownerId, runToken = null, leaseMs, meta = {}, nowMs = Date.now() }) {
   const ttl = Math.max(1_000, Math.floor(Number(leaseMs) || DEFAULT_TASK_LEASE_MS));
   const iso = new Date(nowMs).toISOString();
@@ -148,6 +167,14 @@ function isLeaseExpired(payload, nowMs = Date.now()) {
   return !Number.isFinite(expiryTs) || expiryTs <= nowMs;
 }
 
+function isLeaseStale(payload, nowMs = Date.now()) {
+  if (!payload || typeof payload !== 'object') return true;
+  if (isLeaseExpired(payload, nowMs)) return true;
+  const pid = parsePid(payload?.pid);
+  if (!pid) return false;
+  return !isPidAlive(pid);
+}
+
 function safeUnlink(filePath) {
   try {
     fs.unlinkSync(filePath);
@@ -209,7 +236,7 @@ function acquireLease(filePath, { ownerId, runToken = null, leaseMs, meta = {},
     return { ok: true, acquired: false, renewed: true, lease: renewed };
   }
 
-  if (!isLeaseExpired(existing, nowMs)) {
+  if (!isLeaseStale(existing, nowMs)) {
     return { ok: false, reason: 'busy', lease: existing };
   }
 
@@ -250,7 +277,7 @@ function listActiveLeases(rootDir, nowMs = Date.now()) {
     if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
     const fullPath = path.join(rootDir, entry.name);
     const payload = readLease(fullPath);
-    if (!payload || isLeaseExpired(payload, nowMs)) {
+    if (!payload || isLeaseStale(payload, nowMs)) {
       safeUnlink(fullPath);
       continue;
     }

package/apps/webauto/entry/lib/session-init.mjs

@@ -0,0 +1,227 @@
+import { runCamo } from './camo-cli.mjs';
+
+const START_WINDOW_MIN_WIDTH = 960;
+const START_WINDOW_MIN_HEIGHT = 700;
+const START_WINDOW_MAX_RESERVE = 240;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function toNumber(value, fallback = 0) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback;
+}
+
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+function extractResult(payload) {
+  if (payload && typeof payload === 'object') {
+    if (Object.prototype.hasOwnProperty.call(payload, 'result')) return payload.result;
+    if (Object.prototype.hasOwnProperty.call(payload, 'data')) return payload.data;
+  }
+  return payload || {};
+}
+
+async function callBrowserApi(action, args = {}) {
+  const { callAPI } = await import('../../../../modules/camo-runtime/src/utils/browser-service.mjs');
+  return callAPI(action, args);
+}
+
+async function resolveStartWindow(profileOptions = {}) {
+  try {
+    const displayPayload = await callBrowserApi('system:display', {});
+    return computeStartWindowSize(extractResult(displayPayload), profileOptions);
+  } catch {
+    return computeStartWindowSize(null, profileOptions);
+  }
+}
+
+export function computeStartWindowSize(metrics, options = {}) {
+  const display = metrics?.metrics || metrics || {};
+  const reserveFromEnv = toNumber(process.env.WEBAUTO_WINDOW_VERTICAL_RESERVE, 0);
+  const reserve = clamp(
+    toNumber(options.reservePx, reserveFromEnv),
+    0,
+    START_WINDOW_MAX_RESERVE,
+  );
+  const workWidth = toNumber(display.workWidth, 0);
+  const workHeight = toNumber(display.workHeight, 0);
+  const width = toNumber(display.width, 0);
+  const height = toNumber(display.height, 0);
+  const baseW = Math.floor(workWidth > 0 ? workWidth : width);
+  const baseH = Math.floor(workHeight > 0 ? workHeight : height);
+  if (baseW <= 0 || baseH <= 0) {
+    return {
+      width: 1920,
+      height: 1000,
+      reservePx: reserve,
+      source: 'fallback',
+    };
+  }
+  return {
+    width: Math.max(START_WINDOW_MIN_WIDTH, baseW),
+    height: Math.max(START_WINDOW_MIN_HEIGHT, baseH - reserve),
+    reservePx: reserve,
+    source: workWidth > 0 || workHeight > 0 ? 'workArea' : 'screen',
+  };
+}
+
+export function computeTargetViewportFromWindowMetrics(measured) {
+  const innerWidth = Math.max(320, toNumber(measured?.innerWidth, 0));
+  const innerHeight = Math.max(240, toNumber(measured?.innerHeight, 0));
+  const outerWidth = Math.max(320, toNumber(measured?.outerWidth, innerWidth));
+  const outerHeight = Math.max(240, toNumber(measured?.outerHeight, innerHeight));
+  const rawDeltaW = Math.max(0, outerWidth - innerWidth);
+  const rawDeltaH = Math.max(0, outerHeight - innerHeight);
+  const frameW = rawDeltaW > 400 ? 16 : Math.min(rawDeltaW, 120);
+  const frameH = rawDeltaH > 400 ? 88 : Math.min(rawDeltaH, 180);
+  return {
+    width: Math.max(320, outerWidth - frameW),
+    height: Math.max(240, outerHeight - frameH),
+    frameW,
+    frameH,
+  };
+}
+
+async function probeWindowMetrics(profileId) {
+  const measured = await callBrowserApi('evaluate', {
+    profileId,
+    script: '({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, outerWidth: window.outerWidth, outerHeight: window.outerHeight })',
+  });
+  return extractResult(measured);
+}
+
+export async function applyNearFullWindow(profileId, options = {}) {
+  const id = String(profileId || '').trim();
+  if (!id) {
+    return { ok: false, error: 'missing_profile_id' };
+  }
+  try {
+    const startWindow = await resolveStartWindow(options);
+    await callBrowserApi('window:resize', {
+      profileId: id,
+      width: startWindow.width,
+      height: startWindow.height,
+    });
+
+    let targetViewport = {
+      width: startWindow.width,
+      height: startWindow.height,
+      frameW: 0,
+      frameH: 0,
+    };
+    const attempts = Math.max(1, Math.min(4, Math.floor(toNumber(options.attempts, 2))));
+    for (let i = 0; i < attempts; i += 1) {
+      const measured = await probeWindowMetrics(id).catch(() => ({}));
+      targetViewport = computeTargetViewportFromWindowMetrics(measured);
+      await callBrowserApi('page:setViewport', {
+        profileId: id,
+        width: targetViewport.width,
+        height: targetViewport.height,
+      });
+      if (i + 1 < attempts) {
+        await sleep(Math.max(80, toNumber(options.settleMs, 180)));
+      }
+    }
+    return {
+      ok: true,
+      profileId: id,
+      startWindow,
+      targetViewport,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      profileId: id,
+      error: error?.message || String(error),
+    };
+  }
+}
+
+export async function ensureSessionInitialized(profileId, options = {}) {
+  const id = String(profileId || '').trim();
+  if (!id) {
+    return { ok: false, error: 'missing_profile_id' };
+  }
+  const headless = options.headless === true;
+  const url = String(options.url || '').trim();
+  const rootDir = String(options.rootDir || process.cwd()).trim();
+  const timeoutMs = Math.max(1000, Math.floor(toNumber(options.timeoutMs, 60000)));
+  const restartSession = options.restartSession !== false;
+  let stopRet = null;
+  if (restartSession) {
+    stopRet = runCamo(['stop', id], {
+      rootDir,
+      timeoutMs: Math.max(3000, Math.min(timeoutMs, 15000)),
+    });
+  }
+  const startWindow = headless
+    ? {
+      width: 1920,
+      height: 1000,
+      reservePx: 0,
+      source: 'headless-default',
+    }
+    : await resolveStartWindow({ reservePx: options.reservePx });
+  const startArgs = [
+    'start',
+    id,
+  ];
+  if (headless) {
+    startArgs.push('--headless');
+  } else {
+    startArgs.push(
+      '--width',
+      String(startWindow.width),
+      '--height',
+      String(startWindow.height),
+    );
+  }
+  if (url) startArgs.push('--url', url);
+  const startRet = runCamo(startArgs, {
+    rootDir,
+    timeoutMs,
+  });
+  if (!startRet?.ok) {
+    return {
+      ok: false,
+      profileId: id,
+      error: startRet?.stderr || startRet?.stdout || 'camo start failed',
+      stop: stopRet,
+      start: startRet,
+      startWindow,
+    };
+  }
+  let gotoRet = null;
+  if (url) {
+    gotoRet = runCamo(['goto', id, url], {
+      rootDir,
+      timeoutMs,
+    });
+  }
+  const windowInit = headless
+    ? {
+      ok: true,
+      profileId: id,
+      skipped: true,
+      reason: 'headless_mode',
+    }
+    : await applyNearFullWindow(id, {
+      settleMs: options.settleMs,
+      attempts: options.attempts,
+      reservePx: options.reservePx,
+    });
+  return {
+    ok: true,
+    profileId: id,
+    headless,
+    stop: stopRet,
+    startWindow,
+    start: startRet,
+    goto: gotoRet,
+    windowInit,
+  };
+}

package/apps/webauto/entry/lib/upgrade-check.mjs

@@ -0,0 +1,269 @@
+/**
+ * upgrade-check.mjs
+ * 
+ * 检查 npm 包是否有新版本，提示用户升级
+ */
+
+import { spawn } from 'child_process';
+import https from 'https';
+import { createInterface } from 'readline';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const NPM_REGISTRY = 'https://registry.npmjs.org';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '../../../..');
+
+/**
+ * 从 package.json 获取当前版本
+ * @param {string} [pkgPath] - 自定义 package.json 路径
+ * @returns {string|null}
+ */
+function getLocalVersion(pkgPath) {
+  try {
+    // 优先使用传入路径
+    if (pkgPath && fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      return pkg.version || null;
+    }
+    
+    // 尝试从已知位置查找
+    const candidates = [
+      path.join(REPO_ROOT, 'package.json'),           // 开发模式
+      path.join(__dirname, '..', '..', '..', 'package.json'), // 相对位置
+      path.join(__dirname, 'package.json'),           // 模块自身
+    ];
+    
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        const pkg = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+        if (pkg.name === '@web-auto/webauto' && pkg.version) {
+          return pkg.version;
+        }
+      }
+    }
+    
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 从 npm registry 获取最新版本
+ * @param {string} packageName
+ * @returns {Promise<string|null>}
+ */
+function getLatestVersion(packageName) {
+  return new Promise((resolve) => {
+    const url = `${NPM_REGISTRY}/${packageName}/latest`;
+    
+    https.get(url, { timeout: 10000 }, (res) => {
+      let data = '';
+      
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          resolve(json.version || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    }).on('error', () => {
+      resolve(null);
+    }).on('timeout', () => {
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * 比较版本号
+ * @param {string} v1
+ * @param {string} v2
+ * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+  
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  
+  return 0;
+}
+
+/**
+ * 询问用户是否升级
+ * @param {string} current
+ * @param {string} latest
+ * @returns {Promise<boolean>}
+ */
+async function askUserConfirmation(current, latest) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  
+  return new Promise((resolve) => {
+    rl.question(
+      `\n📦 发现新版本！\n   当前版本: ${current}\n   最新版本: ${latest}\n\n是否升级？(y/n): `,
+      (answer) => {
+        rl.close();
+        const normalized = answer.trim().toLowerCase();
+        resolve(normalized === 'y' || normalized === 'yes');
+      },
+    );
+  });
+}
+
+/**
+ * 执行 npm update
+ * @param {string} packageName
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+async function runNpmUpdate(packageName) {
+  return new Promise((resolve) => {
+    console.log(`\n⏳ 正在更新 ${packageName}...`);
+    
+    const child = spawn('npm', ['install', '-g', packageName], {
+      stdio: 'inherit',
+    });
+    
+    child.on('error', (err) => {
+      resolve({ ok: false, error: err.message });
+    });
+    
+    child.on('close', (code) => {
+      if (code === 0) {
+        console.log(`\n✅ ${packageName} 已更新到最新版本`);
+        resolve({ ok: true });
+      } else {
+        resolve({ ok: false, error: `npm install exited with code ${code}` });
+      }
+    });
+  });
+}
+
+/**
+ * 检查并提示升级
+ * @param {string} packageName - 包名
+ * @param {{autoUpdate?: boolean, silent?: boolean, pkgPath?: string}} options
+ * @returns {Promise<{ok: boolean, versionInfo?: any, error?: string, userDeclined?: boolean, updated?: boolean}>}
+ */
+export async function checkAndPromptUpgrade(packageName, options = {}) {
+  const { autoUpdate = false, silent = false, pkgPath } = options;
+  
+  // 获取当前版本
+  const current = getLocalVersion(pkgPath);
+  if (!current) {
+    return {
+      ok: false,
+      error: `无法获取 ${packageName} 的当前版本`,
+    };
+  }
+  
+  // 获取最新版本
+  const latest = await getLatestVersion(packageName);
+  if (!latest) {
+    return {
+      ok: false,
+      error: `无法从 npm registry 获取最新版本`,
+      versionInfo: { current, latest: current, needsUpdate: false },
+    };
+  }
+  
+  const needsUpdate = compareVersions(current, latest) < 0;
+  
+  const versionInfo = { current, latest, needsUpdate };
+  
+  // 无需更新
+  if (!needsUpdate) {
+    if (!silent) {
+      console.log(`✓ ${packageName} 已是最新版本 (${current})`);
+    }
+    return { ok: true, versionInfo };
+  }
+  
+  // 需要更新
+  if (!silent) {
+    console.log(`\n┌${'─'.repeat(50)}┐`);
+    console.log(`│ 📦 ${packageName} 有新版本可用`.padEnd(50) + '│');
+    console.log(`│ 当前: ${current}`.padEnd(50) + '│');
+    console.log(`│ 最新: ${latest}`.padEnd(50) + '│');
+    console.log(`└${'─'.repeat(50)}┘`);
+  }
+  
+  // 自动更新模式
+  if (autoUpdate) {
+    const result = await runNpmUpdate(packageName);
+    return {
+      ok: result.ok,
+      versionInfo,
+      updated: result.ok,
+      error: result.error,
+    };
+  }
+  
+  // 交互式确认
+  if (process.stdin.isTTY) {
+    const confirmed = await askUserConfirmation(current, latest);
+    
+    if (confirmed) {
+      const result = await runNpmUpdate(packageName);
+      return {
+        ok: result.ok,
+        versionInfo,
+        updated: result.ok,
+        error: result.error,
+      };
+    } else {
+      return {
+        ok: true,
+        versionInfo,
+        userDeclined: true,
+      };
+    }
+  }
+  
+  // 非 TTY 环境，仅提示
+  return {
+    ok: true,
+    versionInfo,
+    userDeclined: true,
+  };
+}
+
+/**
+ * CLI 入口
+ */
+export async function main() {
+  const packageName = '@web-auto/webauto';
+  const result = await checkAndPromptUpgrade(packageName);
+  
+  if (result.error) {
+    console.error(`❌ 检查更新失败: ${result.error}`);
+    process.exit(1);
+  }
+  
+  if (result.userDeclined) {
+    console.log('\n💡 稍后可以运行 `npm install -g @web-auto/webauto` 手动更新');
+  }
+  
+  process.exit(0);
+}
+
+// 直接运行时执行
+if (process.argv[1]?.includes('upgrade-check.mjs')) {
+  main().catch(console.error);
+}

package/apps/webauto/entry/lib/xhs-unified-blocks.mjs

@@ -0,0 +1,160 @@
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+export function sleepMs(ms) {
+  const waitMs = Math.max(0, Number(ms) || 0);
+  if (waitMs <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, waitMs));
+}
+
+export function formatRunLabel() {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+export function parseBool(value, fallback = false) {
+  if (value === undefined || value === null || value === '') return fallback;
+  if (typeof value === 'boolean') return value;
+  const text = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(text)) return true;
+  if (['0', 'false', 'no', 'off'].includes(text)) return false;
+  return fallback;
+}
+
+export function parseIntFlag(value, fallback, min = 1) {
+  if (value === undefined || value === null || value === '') return fallback;
+  const num = Number(value);
+  if (!Number.isFinite(num)) return fallback;
+  return Math.max(min, Math.floor(num));
+}
+
+export function parseNonNegativeInt(value, fallback = 0) {
+  if (value === undefined || value === null || value === '') return fallback;
+  const num = Number(value);
+  if (!Number.isFinite(num)) return fallback;
+  return Math.max(0, Math.floor(num));
+}
+
+export function pickRandomInt(min, max) {
+  const floorMin = Math.max(0, Math.floor(Number(min) || 0));
+  const floorMax = Math.max(floorMin, Math.floor(Number(max) || 0));
+  if (floorMax <= floorMin) return floorMin;
+  return floorMin + Math.floor(Math.random() * (floorMax - floorMin + 1));
+}
+
+export function sanitizeForPath(name, fallback = 'unknown') {
+  const text = String(name || '').trim();
+  if (!text) return fallback;
+  const cleaned = text.replace(/[\\/:"*?<>|]+/g, '_').trim();
+  return cleaned || fallback;
+}
+
+function parseLastJson(stdout = '') {
+  const text = String(stdout || '').trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    // fall through
+  }
+  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i];
+    if (!line.startsWith('{') && !line.startsWith('[')) continue;
+    try {
+      return JSON.parse(line);
+    } catch {
+      // ignore
+    }
+  }
+  return null;
+}
+
+function runWebautoCli(args, options = {}) {
+  const rootDir = String(options.rootDir || process.cwd()).trim() || process.cwd();
+  const timeoutMs = Math.max(1000, Number(options.timeoutMs) || 120000);
+  const scriptPath = path.join(rootDir, 'bin', 'webauto.mjs');
+  const ret = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: rootDir,
+    env: { ...process.env, ...(options.env || {}) },
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    windowsHide: true,
+  });
+  const stdout = String(ret.stdout || '').trim();
+  const stderr = String(ret.stderr || '').trim();
+  return {
+    ok: ret.status === 0,
+    code: ret.status,
+    stdout,
+    stderr,
+    json: parseLastJson(stdout),
+  };
+}
+
+export async function resetTaskServices(argv, options = {}) {
+  const enabled = parseBool(argv['service-reset'], true);
+  const rootDir = String(options.rootDir || process.cwd()).trim() || process.cwd();
+  const debugActionLogPath = String(options.debugActionLogPath || '').trim();
+  if (!enabled) {
+    return {
+      ok: true,
+      skipped: true,
+      reason: 'service_reset_disabled',
+      actionLogPath: null,
+    };
+  }
+  const envName = String(argv.env || 'prod').trim() || 'prod';
+  const debugMode = envName === 'debug';
+  const actionLogPath = debugMode
+    ? (debugActionLogPath || path.join(os.homedir(), '.webauto', 'logs', `input-actions-${Date.now()}.jsonl`))
+    : null;
+  const serviceEnv = debugMode
+    ? {
+      WEBAUTO_DEBUG_ACTION_JSONL: '1',
+      WEBAUTO_DEBUG_ACTION_LOG_PATH: actionLogPath,
+    }
+    : {};
+
+  const stopRet = runWebautoCli(['ui', 'cli', 'stop', '--json'], {
+    rootDir,
+    timeoutMs: 120000,
+    env: serviceEnv,
+  });
+  const startRet = runWebautoCli(['ui', 'cli', 'start', '--json'], {
+    rootDir,
+    timeoutMs: 240000,
+    env: serviceEnv,
+  });
+  if (!startRet.ok) {
+    throw new Error(`ui cli start failed: ${startRet.stderr || startRet.stdout || 'unknown error'}`);
+  }
+
+  let statusRet = null;
+  let ready = false;
+  for (let attempt = 1; attempt <= 8; attempt += 1) {
+    statusRet = runWebautoCli(['ui', 'cli', 'status', '--json'], {
+      rootDir,
+      timeoutMs: 60000,
+      env: serviceEnv,
+    });
+    ready = Boolean(statusRet?.ok && statusRet?.json?.ready === true);
+    if (ready) break;
+    await sleepMs(600);
+  }
+  if (!ready) {
+    throw new Error(`ui cli status not ready after restart: ${statusRet?.stderr || statusRet?.stdout || 'unknown error'}`);
+  }
+  return {
+    ok: true,
+    skipped: false,
+    actionLogPath,
+    stop: stopRet,
+    start: startRet,
+    status: statusRet,
+  };
+}