@web-auto/camo 0.1.12 → 0.1.14

package/README.md

@@ -459,7 +459,11 @@ Condition types:
 ### Environment Variables
 
 - `WEBAUTO_BROWSER_URL` - Browser service URL (default: `http://127.0.0.1:7704`)
-- `WEBAUTO_REPO_ROOT` - WebAuto repository root (optional)
+- `WEBAUTO_INSTALL_DIR` - `@web-auto/webauto` 安装目录（可选，首次安装兜底）
+- `WEBAUTO_REPO_ROOT` - WebAuto repository root (optional, dev mode)
+- `WEBAUTO_DATA_ROOT` / `WEBAUTO_HOME` - 用户数据目录（Windows 默认 `D:/webauto`，无 D 盘回退 `~/.webauto`）
+- `WEBAUTO_PROFILE_ROOT` - Profile 目录覆盖（默认 `<data-root>/profiles`）
+- `WEBAUTO_ROOT` - 兼容旧变量（当值不是 `webauto/.webauto` 目录时会自动补 `.webauto`）
 - `WEBAUTO_CONTAINER_ROOT` - User container root override (default: `~/.webauto/container-lib`)
 - `CAMO_PROGRESS_EVENTS_FILE` - Optional progress event JSONL path override
 - `CAMO_PROGRESS_WS_HOST` / `CAMO_PROGRESS_WS_PORT` - Progress websocket daemon bind address (default: `127.0.0.1:7788`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/camo",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Camoufox Browser CLI - Cross-platform browser automation",
   "type": "module",
   "bin": {

package/src/autoscript/xhs-unified-template.mjs

@@ -31,12 +31,15 @@ function splitCsv(value) {
     .filter(Boolean);
 }
 
-function pickCloseDependency(options) {
-  if (options.doReply || options.doLikes) return 'comment_match_gate';
-  if (options.matchGateEnabled) return 'comment_match_gate';
-  if (options.commentsHarvestEnabled) return 'comments_harvest';
-  if (options.detailHarvestEnabled) return 'detail_harvest';
-  return 'open_first_detail';
+function pickCloseDependencies(options) {
+  const deps = [];
+  if (options.doLikes) deps.push('comment_like');
+  if (options.doReply) deps.push('comment_reply');
+  if (deps.length > 0) return deps;
+  if (options.matchGateEnabled) return ['comment_match_gate'];
+  if (options.commentsHarvestEnabled) return ['comments_harvest'];
+  if (options.detailHarvestEnabled) return ['detail_harvest'];
+  return ['open_first_detail'];
 }
 
 function buildOpenFirstDetailScript(maxNotes, keyword) {
@@ -486,7 +489,7 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
   const detailHarvestEnabled = doHomepage || doImages || doComments || doLikes || doReply || doOcr;
   const commentsHarvestEnabled = doComments || doLikes || doReply;
   const matchGateEnabled = doLikes || doReply;
-  const closeDependsOn = pickCloseDependency({
+  const closeDependsOn = pickCloseDependencies({
     doReply,
     doLikes,
     matchGateEnabled,
@@ -793,7 +796,7 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
         action: 'xhs_close_detail',
         params: {},
         trigger: 'detail_modal.exist',
-        dependsOn: [closeDependsOn],
+        dependsOn: closeDependsOn,
         once: false,
         oncePerAppear: true,
         pacing: { operationMinIntervalMs: 2500, eventCooldownMs: 1300, jitterMs: 180 },

package/src/container/subscription-registry.mjs

@@ -1,12 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import os from 'node:os';
 import { findRepoRootCandidate } from '../utils/browser-service.mjs';
+import { CONFIG_DIR } from '../utils/config.mjs';
 
 const CONTAINER_ROOT_ENV = process.env.WEBAUTO_CONTAINER_ROOT || process.env.ROUTECODEX_CONTAINER_ROOT;
 
-export const USER_CONTAINER_ROOT = CONTAINER_ROOT_ENV || path.join(os.homedir(), '.webauto', 'container-lib');
-export const SUBSCRIPTION_ROOT = path.join(os.homedir(), '.webauto', 'container-subscriptions');
+export const USER_CONTAINER_ROOT = CONTAINER_ROOT_ENV || path.join(CONFIG_DIR, 'container-lib');
+export const SUBSCRIPTION_ROOT = path.join(CONFIG_DIR, 'container-subscriptions');
 export const SUBSCRIPTION_SETS_DIR = path.join(SUBSCRIPTION_ROOT, 'sets');
 export const SUBSCRIPTION_INDEX_FILE = path.join(SUBSCRIPTION_ROOT, 'index.json');
 export const SUBSCRIPTION_TARGETS_FILE = path.join(SUBSCRIPTION_ROOT, 'targets.json');

package/src/core/browser.mjs

@@ -5,10 +5,7 @@
 import { spawn, execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import os from 'node:os';
-
-const CONFIG_DIR = path.join(os.homedir(), '.webauto');
-const PROFILES_DIR = path.join(CONFIG_DIR, 'profiles');
+import { PROFILES_DIR } from '../utils/config.mjs';
 
 // Active browser instances registry (in-memory)
 const activeBrowsers = new Map();
@@ -267,4 +264,3 @@ export async function getCurrentPage(profileId) {
 export function getActiveBrowser(profileId) {
   return activeBrowsers.get(profileId) || null;
 }
-

package/src/lifecycle/lock.mjs

@@ -5,9 +5,9 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import os from 'node:os';
+import { CONFIG_DIR } from '../utils/config.mjs';
 
-const LOCK_DIR = path.join(os.homedir(), '.webauto', 'locks');
+const LOCK_DIR = path.join(CONFIG_DIR, 'locks');
 
 function ensureLockDir() {
   if (!fs.existsSync(LOCK_DIR)) {

package/src/lifecycle/session-registry.mjs

@@ -5,10 +5,10 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import os from 'node:os';
 import crypto from 'node:crypto';
+import { CONFIG_DIR } from '../utils/config.mjs';
 
-const SESSION_DIR = path.join(os.homedir(), '.webauto', 'sessions');
+const SESSION_DIR = path.join(CONFIG_DIR, 'sessions');
 
 function ensureSessionDir() {
   if (!fs.existsSync(SESSION_DIR)) {

package/src/lifecycle/session-watchdog.mjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { callAPI } from '../utils/browser-service.mjs';
+import { CONFIG_DIR } from '../utils/config.mjs';
 import { releaseLock } from './lock.mjs';
 import { getSessionInfo, markSessionClosed } from './session-registry.mjs';
 
-const WATCHDOG_DIR = path.join(os.homedir(), '.webauto', 'run', 'camo-watchdogs');
+const WATCHDOG_DIR = path.join(CONFIG_DIR, 'run', 'camo-watchdogs');
 const DEFAULT_HEADLESS_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 
 function ensureWatchdogDir() {

package/src/utils/browser-service.mjs

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
-import { execSync } from 'node:child_process';
+import { execSync, spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 import { BROWSER_SERVICE_URL, loadConfig, setRepoRoot } from './config.mjs';
 import { touchSessionActivity } from '../lifecycle/session-registry.mjs';
 
+const require = createRequire(import.meta.url);
+
 function shouldTrackSessionActivity(action, payload) {
   const profileId = String(payload?.profileId || '').trim();
   if (!profileId) return false;
@@ -304,12 +308,18 @@ export function ensureCamoufox() {
 }
 
 const START_SCRIPT_REL = path.join('runtime', 'infra', 'utils', 'scripts', 'service', 'start-browser-service.mjs');
+const CONTROLLER_SERVER_REL = path.join('services', 'controller', 'src', 'server.mjs');
 
 function hasStartScript(root) {
   if (!root) return false;
   return fs.existsSync(path.join(root, START_SCRIPT_REL));
 }
 
+function hasControllerServer(root) {
+  if (!root) return false;
+  return fs.existsSync(path.join(root, CONTROLLER_SERVER_REL));
+}
+
 function walkUpForRepoRoot(startDir) {
   if (!startDir) return null;
   let cursor = path.resolve(startDir);
@@ -356,6 +366,27 @@ function scanCommonRepoRoots() {
   return null;
 }
 
+function scanCommonInstallRoots() {
+  const home = os.homedir();
+  const appData = String(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'));
+  const npmPrefix = String(process.env.npm_config_prefix || '').trim();
+  const nodeModuleRoots = [
+    path.join(appData, 'npm', 'node_modules'),
+    path.join(home, 'AppData', 'Roaming', 'npm', 'node_modules'),
+    npmPrefix ? path.join(npmPrefix, 'node_modules') : '',
+    npmPrefix ? path.join(npmPrefix, 'lib', 'node_modules') : '',
+    '/usr/local/lib/node_modules',
+    '/usr/lib/node_modules',
+    path.join(home, '.npm-global', 'lib', 'node_modules'),
+  ].filter(Boolean);
+
+  for (const root of nodeModuleRoots) {
+    const candidate = path.join(root, '@web-auto', 'webauto');
+    if (hasControllerServer(candidate)) return candidate;
+  }
+  return null;
+}
+
 export function findRepoRootCandidate() {
   const cfg = loadConfig();
   const candidates = [
@@ -404,21 +435,69 @@ export function findRepoRootCandidate() {
   return null;
 }
 
+export function findInstallRootCandidate() {
+  const cfg = loadConfig();
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  const siblingInScopedNodeModules = path.resolve(currentDir, '..', '..', '..', 'webauto');
+  const candidates = [
+    process.env.WEBAUTO_INSTALL_DIR,
+    process.env.WEBAUTO_PACKAGE_ROOT,
+    process.env.WEBAUTO_REPO_ROOT,
+    cfg.repoRoot,
+    siblingInScopedNodeModules,
+    process.cwd(),
+  ].filter(Boolean);
+
+  try {
+    const pkgPath = require.resolve('@web-auto/webauto/package.json');
+    candidates.push(path.dirname(pkgPath));
+  } catch {
+    // ignore resolution failures in npx-only environments
+  }
+
+  const seen = new Set();
+  for (const raw of candidates) {
+    const resolved = path.resolve(String(raw));
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    if (hasControllerServer(resolved)) return resolved;
+  }
+
+  return scanCommonInstallRoots();
+}
+
 export async function ensureBrowserService() {
   if (await checkBrowserService()) return;
 
   const repoRoot = findRepoRootCandidate();
-  if (!repoRoot) {
-    throw new Error(
-      `Cannot locate browser-service start script (${START_SCRIPT_REL}). ` +
-      'Run from webauto repo once or set WEBAUTO_REPO_ROOT=/path/to/webauto.',
-    );
+  if (repoRoot) {
+    const scriptPath = path.join(repoRoot, START_SCRIPT_REL);
+    console.log('Starting browser-service daemon...');
+    execSync(`node "${scriptPath}"`, { stdio: 'inherit', cwd: repoRoot });
+  } else {
+    const installRoot = findInstallRootCandidate();
+    if (!installRoot) {
+      throw new Error(
+        `Cannot locate browser-service launcher (${START_SCRIPT_REL} or ${CONTROLLER_SERVER_REL}). ` +
+        'Set WEBAUTO_INSTALL_DIR=<@web-auto/webauto install dir> or WEBAUTO_REPO_ROOT=<repo root>.',
+      );
+    }
+    const scriptPath = path.join(installRoot, CONTROLLER_SERVER_REL);
+    const env = {
+      ...process.env,
+      WEBAUTO_REPO_ROOT: String(process.env.WEBAUTO_REPO_ROOT || '').trim() || installRoot,
+    };
+    const child = spawn(process.execPath, [scriptPath], {
+      cwd: installRoot,
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      env,
+    });
+    child.unref();
+    console.log(`Starting browser-service daemon (packaged webauto, pid=${child.pid || 'unknown'})...`);
   }
 
-  const scriptPath = path.join(repoRoot, START_SCRIPT_REL);
-  console.log('Starting browser-service daemon...');
-  execSync(`node "${scriptPath}"`, { stdio: 'inherit', cwd: repoRoot });
-
   for (let i = 0; i < 20; i += 1) {
     await new Promise((r) => setTimeout(r, 400));
     if (await checkBrowserService()) {

package/src/utils/config.mjs

@@ -3,8 +3,63 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 
-export const CONFIG_DIR = path.join(os.homedir(), '.webauto');
-export const PROFILES_DIR = path.join(CONFIG_DIR, 'profiles');
+function hasDrive(letter) {
+  if (process.platform !== 'win32') return false;
+  try {
+    return fs.existsSync(`${String(letter || '').replace(/[^A-Za-z]/g, '').toUpperCase()}:\\`);
+  } catch {
+    return false;
+  }
+}
+
+function normalizePathForPlatform(input, platform = process.platform) {
+  const raw = String(input || '').trim();
+  const isWinPath = platform === 'win32' || /^[A-Za-z]:[\\/]/.test(raw);
+  const pathApi = isWinPath ? path.win32 : path;
+  return isWinPath ? pathApi.normalize(raw) : path.resolve(raw);
+}
+
+function normalizeLegacyWebautoRoot(input, platform = process.platform) {
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const resolved = normalizePathForPlatform(input, platform);
+  const base = pathApi.basename(resolved).toLowerCase();
+  if (base === '.webauto' || base === 'webauto') return resolved;
+  return pathApi.join(resolved, '.webauto');
+}
+
+export function resolveWebautoRoot(options = {}) {
+  const env = options.env || process.env;
+  const platform = String(options.platform || process.platform);
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const homeDir = String(options.homeDir || os.homedir());
+  const explicitDataRoot = String(env.WEBAUTO_DATA_ROOT || env.WEBAUTO_HOME || '').trim();
+  if (explicitDataRoot) return normalizePathForPlatform(explicitDataRoot, platform);
+
+  const legacyRoot = String(env.WEBAUTO_ROOT || env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot(legacyRoot, platform);
+
+  const dDriveExists = typeof options.hasDDrive === 'boolean'
+    ? options.hasDDrive
+    : hasDrive('D');
+  if (platform === 'win32') {
+    return dDriveExists ? 'D:\\webauto' : pathApi.join(homeDir, '.webauto');
+  }
+  return pathApi.join(homeDir, '.webauto');
+}
+
+export function resolveProfilesDir(options = {}) {
+  const env = options.env || process.env;
+  const platform = String(options.platform || process.platform);
+  const explicitProfileRoot = String(env.WEBAUTO_PROFILE_ROOT || '').trim();
+  if (explicitProfileRoot) {
+    return normalizePathForPlatform(explicitProfileRoot, platform);
+  }
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  return pathApi.join(resolveWebautoRoot(options), 'profiles');
+}
+
+export const CONFIG_DIR = resolveWebautoRoot();
+export const PROFILES_DIR = resolveProfilesDir();
 export const CONFIG_FILE = path.join(CONFIG_DIR, 'camo-cli.json');
 export const PROFILE_META_FILE = 'camo-profile.json';
 export const BROWSER_SERVICE_URL = process.env.WEBAUTO_BROWSER_URL || 'http://127.0.0.1:7704';

package/src/utils/help.mjs

@@ -173,7 +173,11 @@ PROGRESS EVENTS:
 
 ENV:
   WEBAUTO_BROWSER_URL                       Default: http://127.0.0.1:7704
-  WEBAUTO_REPO_ROOT                         Optional explicit webauto repo root
+  WEBAUTO_INSTALL_DIR                       Optional @web-auto/webauto install dir
+  WEBAUTO_REPO_ROOT                         Optional webauto repo root (dev mode)
+  WEBAUTO_DATA_ROOT / WEBAUTO_HOME         Optional data root (Windows default D:\\webauto)
+  WEBAUTO_PROFILE_ROOT                      Optional profile dir override
+  WEBAUTO_ROOT                              Legacy data root (auto-appends .webauto if needed)
   CAMO_PROGRESS_EVENTS_FILE                 Optional path override for progress jsonl
   CAMO_PROGRESS_WS_HOST / CAMO_PROGRESS_WS_PORT   Progress daemon host/port (defaults: 127.0.0.1:7788)
 `);