@web-auto/webauto 0.1.1 → 0.1.2

package/dist/modules/camo-runtime/src/utils/browser-service.mjs

@@ -0,0 +1,423 @@
+#!/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 { BROWSER_SERVICE_URL, loadConfig, setRepoRoot } from './config.mjs';
+export async function callAPI(action, payload = {}) {
+    const r = await fetch(`${BROWSER_SERVICE_URL}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action, args: payload }),
+    });
+    let body;
+    try {
+        body = await r.json();
+    }
+    catch {
+        const text = await r.text();
+        throw new Error(`HTTP ${r.status}: ${text}`);
+    }
+    if (!r.ok)
+        throw new Error(body?.error || `HTTP ${r.status}`);
+    return body;
+}
+export async function getSessionByProfile(profileId) {
+    const status = await callAPI('getStatus', {});
+    const activeSession = status?.sessions?.find((s) => s.profileId === profileId) || null;
+    if (activeSession) {
+        return activeSession;
+    }
+    if (!profileId) {
+        return null;
+    }
+    // Some browser-service builds do not populate getStatus.sessions reliably.
+    // Fallback to page:list so runtime can still attach to an active profile tab set.
+    try {
+        const pagePayload = await callAPI('page:list', { profileId });
+        const pages = Array.isArray(pagePayload?.pages)
+            ? pagePayload.pages
+            : Array.isArray(pagePayload?.data?.pages)
+                ? pagePayload.data.pages
+                : [];
+        if (!pages.length)
+            return null;
+        const activeIndex = Number(pagePayload?.activeIndex ?? pagePayload?.data?.activeIndex);
+        const activePage = Number.isFinite(activeIndex)
+            ? pages.find((page) => Number(page?.index) === activeIndex)
+            : (pages.find((page) => page?.active) || pages[0]);
+        return {
+            profileId,
+            session_id: profileId,
+            sessionId: profileId,
+            current_url: activePage?.url || null,
+            recoveredFromPages: true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function buildDomSnapshotScript(maxDepth, maxChildren) {
+    return `(() => {
+    const MAX_DEPTH = ${maxDepth};
+    const MAX_CHILDREN = ${maxChildren};
+    const viewportWidth = Number(window.innerWidth || 0);
+    const viewportHeight = Number(window.innerHeight || 0);
+
+    const normalizeRect = (rect) => {
+      if (!rect) return null;
+      const left = Number(rect.left ?? rect.x ?? 0);
+      const top = Number(rect.top ?? rect.y ?? 0);
+      const width = Number(rect.width ?? 0);
+      const height = Number(rect.height ?? 0);
+      return {
+        left,
+        top,
+        right: left + width,
+        bottom: top + height,
+        x: left,
+        y: top,
+        width,
+        height,
+      };
+    };
+
+    const sanitizeClasses = (el) => {
+      const classAttr = typeof el.className === 'string'
+        ? el.className
+        : (el.getAttribute && el.getAttribute('class')) || '';
+      return classAttr.split(/\\s+/).filter(Boolean).slice(0, 24);
+    };
+
+    const collectAttrs = (el) => {
+      if (!el || !el.getAttribute) return null;
+      const keys = [
+        'href',
+        'src',
+        'name',
+        'type',
+        'value',
+        'placeholder',
+        'role',
+        'aria-label',
+        'aria-hidden',
+        'title',
+      ];
+      const attrs = {};
+      for (const key of keys) {
+        const value = el.getAttribute(key);
+        if (value === null || value === undefined || value === '') continue;
+        attrs[key] = String(value).slice(0, 400);
+      }
+      return Object.keys(attrs).length > 0 ? attrs : null;
+    };
+
+    const inViewport = (rect) => {
+      if (!rect) return false;
+      if (rect.width <= 0 || rect.height <= 0) return false;
+      return (
+        rect.right > 0
+        && rect.bottom > 0
+        && rect.left < viewportWidth
+        && rect.top < viewportHeight
+      );
+    };
+
+    const isRendered = (el) => {
+      try {
+        const style = window.getComputedStyle(el);
+        if (!style) return false;
+        if (style.display === 'none') return false;
+        if (style.visibility === 'hidden' || style.visibility === 'collapse') return false;
+        const opacity = Number.parseFloat(String(style.opacity || '1'));
+        if (Number.isFinite(opacity) && opacity <= 0.01) return false;
+        return true;
+      } catch {
+        return false;
+      }
+    };
+
+    const clampPoint = (value, max) => {
+      if (!Number.isFinite(value)) return 0;
+      if (max <= 1) return 0;
+      return Math.max(0, Math.min(max - 1, value));
+    };
+
+    const hitTestVisible = (el, rect) => {
+      if (!rect || viewportWidth <= 0 || viewportHeight <= 0) return false;
+      const samplePoints = [
+        [rect.left + rect.width * 0.5, rect.top + rect.height * 0.5],
+        [rect.left + rect.width * 0.2, rect.top + rect.height * 0.2],
+        [rect.left + rect.width * 0.8, rect.top + rect.height * 0.8],
+      ];
+      for (const [rawX, rawY] of samplePoints) {
+        const x = clampPoint(rawX, viewportWidth);
+        const y = clampPoint(rawY, viewportHeight);
+        const topEl = document.elementFromPoint(x, y);
+        if (!topEl) continue;
+        if (topEl === el) return true;
+        if (el.contains && el.contains(topEl)) return true;
+        if (topEl.contains && topEl.contains(el)) return true;
+      }
+      return false;
+    };
+
+    const collect = (el, depth = 0, path = 'root') => {
+      if (!el || depth > MAX_DEPTH) return null;
+      const classes = sanitizeClasses(el);
+      const rect = normalizeRect(el.getBoundingClientRect ? el.getBoundingClientRect() : null);
+      const tag = String(el.tagName || el.nodeName || '').toLowerCase();
+      const id = el.id || null;
+      const text = typeof el.textContent === 'string'
+        ? el.textContent.replace(/\\s+/g, ' ').trim()
+        : '';
+      const selector = tag
+        ? \`\${tag}\${id ? '#' + id : ''}\${classes.length ? '.' + classes.slice(0, 3).join('.') : ''}\`
+        : null;
+
+      const node = {
+        tag,
+        id,
+        classes,
+        selector,
+        path,
+      };
+      const attrs = collectAttrs(el);
+      if (attrs) node.attrs = attrs;
+      if (attrs && attrs.href) node.href = attrs.href;
+      if (rect) node.rect = rect;
+      if (text) node.textSnippet = text.slice(0, 120);
+      if (rect) {
+        const rendered = isRendered(el);
+        const withinViewport = inViewport(rect);
+        const visible = rendered && withinViewport && hitTestVisible(el, rect);
+        node.visible = visible;
+      } else {
+        node.visible = false;
+      }
+
+      const children = Array.from(el.children || []);
+      if (children.length > 0 && depth < MAX_DEPTH) {
+        node.children = [];
+        const limit = Math.min(children.length, MAX_CHILDREN);
+        for (let i = 0; i < limit; i += 1) {
+          const child = collect(children[i], depth + 1, \`\${path}/\${i}\`);
+          if (child) node.children.push(child);
+        }
+      }
+
+      return node;
+    };
+
+    const root = collect(document.body || document.documentElement, 0, 'root');
+    return {
+      dom_tree: root,
+      viewport: {
+        width: viewportWidth,
+        height: viewportHeight,
+      },
+    };
+  })()`;
+}
+export async function getDomSnapshotByProfile(profileId, options = {}) {
+    const maxDepth = Math.max(1, Math.min(20, Number(options.maxDepth) || 10));
+    const maxChildren = Math.max(1, Math.min(500, Number(options.maxChildren) || 120));
+    const response = await callAPI('evaluate', {
+        profileId,
+        script: buildDomSnapshotScript(maxDepth, maxChildren),
+    });
+    const payload = response?.result || response || {};
+    const tree = payload.dom_tree || null;
+    if (tree && payload.viewport && typeof payload.viewport === 'object') {
+        tree.__viewport = {
+            width: Number(payload.viewport.width) || 0,
+            height: Number(payload.viewport.height) || 0,
+        };
+    }
+    return tree;
+}
+export async function getViewportByProfile(profileId) {
+    const response = await callAPI('evaluate', {
+        profileId,
+        script: `(() => ({ width: Number(window.innerWidth || 0), height: Number(window.innerHeight || 0) }))()`,
+    });
+    const viewport = response?.result || response?.viewport || {};
+    const width = Number(viewport?.width) || 1280;
+    const height = Number(viewport?.height) || 720;
+    return { width, height };
+}
+export async function checkBrowserService() {
+    try {
+        const r = await fetch(`${BROWSER_SERVICE_URL}/health`, { signal: AbortSignal.timeout(2000) });
+        return r.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function hasContainerLibrary(repoRoot) {
+    if (!repoRoot)
+        return false;
+    const root = path.resolve(String(repoRoot));
+    const candidate = path.join(root, 'apps', 'webauto', 'resources', 'container-library');
+    return fs.existsSync(candidate);
+}
+function walkUpForRepoRoot(startDir) {
+    if (!startDir)
+        return null;
+    let cursor = path.resolve(startDir);
+    for (;;) {
+        if (hasContainerLibrary(cursor))
+            return cursor;
+        const parent = path.dirname(cursor);
+        if (parent === cursor)
+            return null;
+        cursor = parent;
+    }
+}
+function scanCommonRepoRoots() {
+    const home = os.homedir();
+    const roots = [
+        path.join(home, 'Documents', 'github'),
+        path.join(home, 'github'),
+        path.join(home, 'code'),
+        path.join(home, 'projects'),
+        path.join('/Volumes', 'extension', 'code'),
+        path.join('C:', 'code'),
+        path.join('D:', 'code'),
+        path.join('C:', 'projects'),
+        path.join('D:', 'projects'),
+        path.join('C:', 'Users', os.userInfo().username, 'code'),
+        path.join('C:', 'Users', os.userInfo().username, 'projects'),
+        path.join('C:', 'Users', os.userInfo().username, 'Documents', 'github'),
+    ].filter(Boolean);
+    for (const root of roots) {
+        if (!fs.existsSync(root))
+            continue;
+        try {
+            const entries = fs.readdirSync(root, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (!entry.name.toLowerCase().includes('webauto'))
+                    continue;
+                const candidate = path.join(root, entry.name);
+                if (hasContainerLibrary(candidate))
+                    return candidate;
+            }
+        }
+        catch {
+            // ignore scanning errors and continue
+        }
+    }
+    return null;
+}
+export function findRepoRootCandidate() {
+    const cfg = loadConfig();
+    const candidates = [
+        process.env.WEBAUTO_REPO_ROOT,
+        process.cwd(),
+        cfg.repoRoot,
+        path.join('/Volumes', 'extension', 'code', 'webauto'),
+        path.join('/Volumes', 'extension', 'code', 'WebAuto'),
+        path.join(os.homedir(), 'Documents', 'github', 'webauto'),
+        path.join(os.homedir(), 'Documents', 'github', 'WebAuto'),
+        path.join(os.homedir(), 'github', 'webauto'),
+        path.join(os.homedir(), 'github', 'WebAuto'),
+        path.join('C:', 'code', 'webauto'),
+        path.join('C:', 'code', 'WebAuto'),
+        path.join('C:', 'Users', os.userInfo().username, 'code', 'webauto'),
+        path.join('C:', 'Users', os.userInfo().username, 'code', 'WebAuto'),
+    ].filter(Boolean);
+    for (const root of candidates) {
+        if (!hasContainerLibrary(root))
+            continue;
+        const resolved = path.resolve(String(root));
+        if (cfg.repoRoot !== resolved) {
+            setRepoRoot(resolved);
+        }
+        return resolved;
+    }
+    const walked = walkUpForRepoRoot(process.cwd());
+    if (walked) {
+        if (cfg.repoRoot !== walked) {
+            setRepoRoot(walked);
+        }
+        return walked;
+    }
+    const scanned = scanCommonRepoRoots();
+    if (scanned) {
+        if (cfg.repoRoot !== scanned) {
+            setRepoRoot(scanned);
+        }
+        return scanned;
+    }
+    return null;
+}
+export function detectCamoufoxPath() {
+    try {
+        const cmd = process.platform === 'win32' ? 'python -m camoufox path' : 'python3 -m camoufox path';
+        const out = execSync(cmd, {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const lines = out.trim().split(/\r?\n/);
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+            const line = lines[i].trim();
+            if (line && (line.startsWith('/') || line.match(/^[A-Z]:\\/)))
+                return line;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function ensureCamoufox() {
+    if (detectCamoufoxPath())
+        return;
+    console.log('Camoufox is not found. Installing...');
+    execSync('npx --yes --package=camoufox camoufox fetch', { stdio: 'inherit' });
+    if (!detectCamoufoxPath()) {
+        throw new Error('Camoufox install finished but executable was not detected');
+    }
+    console.log('Camoufox installed.');
+}
+export async function ensureBrowserService() {
+    if (await checkBrowserService())
+        return;
+    const provider = String(process.env.WEBAUTO_BROWSER_PROVIDER || 'camo').trim().toLowerCase();
+    if (provider === 'none' || provider === 'external') {
+        throw new Error(`Browser backend is not healthy at ${BROWSER_SERVICE_URL} (provider=${provider}). ` +
+            'Start backend manually or set WEBAUTO_BROWSER_PROVIDER=camo.');
+    }
+    if (provider === 'camo') {
+        const repoRoot = findRepoRootCandidate();
+        if (repoRoot) {
+            try {
+                execSync(`npx --yes @web-auto/camo config repo-root ${JSON.stringify(repoRoot)}`, { stdio: 'ignore' });
+            }
+            catch {
+                // best-effort only; init will still try using current config
+            }
+        }
+        try {
+            console.log('Starting browser backend via camo init...');
+            execSync('npx --yes @web-auto/camo init', { stdio: 'inherit' });
+        }
+        catch (error) {
+            throw new Error(`camo init failed: ${error?.message || String(error)}`);
+        }
+        for (let i = 0; i < 20; i += 1) {
+            await new Promise((r) => setTimeout(r, 400));
+            if (await checkBrowserService()) {
+                console.log('Browser backend is ready (provider=camo).');
+                return;
+            }
+        }
+        throw new Error('Browser backend failed to become healthy after camo init');
+    }
+    throw new Error(`Unsupported WEBAUTO_BROWSER_PROVIDER=${provider}; only "camo" is supported.`);
+}
+//# sourceMappingURL=browser-service.mjs.map

package/dist/modules/camo-runtime/src/utils/config.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+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');
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'camo-cli.json');
+export const BROWSER_SERVICE_URL = process.env.WEBAUTO_BROWSER_URL || 'http://127.0.0.1:7704';
+export function ensureDir(p) {
+    if (!fs.existsSync(p))
+        fs.mkdirSync(p, { recursive: true });
+}
+export function readJson(p) {
+    try {
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeJson(p, data) {
+    ensureDir(path.dirname(p));
+    fs.writeFileSync(p, JSON.stringify(data, null, 2));
+}
+export function loadConfig() {
+    const raw = readJson(CONFIG_FILE) || {};
+    return {
+        defaultProfile: typeof raw.defaultProfile === 'string' ? raw.defaultProfile : null,
+        repoRoot: typeof raw.repoRoot === 'string' ? raw.repoRoot : null,
+    };
+}
+export function saveConfig(config) {
+    writeJson(CONFIG_FILE, config);
+}
+export function listProfiles() {
+    if (!fs.existsSync(PROFILES_DIR))
+        return [];
+    return fs.readdirSync(PROFILES_DIR, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+        .filter((name) => !name.includes(':') && !name.includes('/') && !name.startsWith('.'))
+        .sort();
+}
+export function isValidProfileId(profileId) {
+    return typeof profileId === 'string' && /^[a-zA-Z0-9._-]+$/.test(profileId);
+}
+export function createProfile(profileId) {
+    if (!isValidProfileId(profileId)) {
+        throw new Error('Invalid profileId. Use only letters, numbers, dot, underscore, dash.');
+    }
+    const profileDir = path.join(PROFILES_DIR, profileId);
+    if (fs.existsSync(profileDir))
+        throw new Error(`Profile already exists: ${profileId}`);
+    ensureDir(profileDir);
+}
+export function deleteProfile(profileId) {
+    const profileDir = path.join(PROFILES_DIR, profileId);
+    if (!fs.existsSync(profileDir))
+        throw new Error(`Profile not found: ${profileId}`);
+    fs.rmSync(profileDir, { recursive: true, force: true });
+}
+export function setDefaultProfile(profileId) {
+    const cfg = loadConfig();
+    cfg.defaultProfile = profileId;
+    saveConfig(cfg);
+}
+export function setRepoRoot(repoRoot) {
+    const cfg = loadConfig();
+    cfg.repoRoot = repoRoot;
+    saveConfig(cfg);
+}
+export function getDefaultProfile() {
+    return loadConfig().defaultProfile;
+}
+//# sourceMappingURL=config.mjs.map

package/dist/modules/container-registry/src/index.js

@@ -0,0 +1,184 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = resolveProjectRoot(__dirname);
+// 新的外置容器树根目录（开发用）：~/.webauto/container-lib
+const PRIMARY_USER_CONTAINER_ROOT = process.env.WEBAUTO_CONTAINER_ROOT || path.join(os.homedir(), '.webauto', 'container-lib');
+const INDEX_PATH = path.join(PROJECT_ROOT, 'apps/webauto/resources/container-library.index.json');
+function isLegacyContainer(definition) {
+    try {
+        return Boolean(definition?.metadata?.legacy_data);
+    }
+    catch {
+        return false;
+    }
+}
+export class ContainerRegistry {
+    indexCache = null;
+    listSites() {
+        const registry = this.ensureIndex();
+        return Object.entries(registry).map(([key, meta]) => ({
+            key,
+            website: meta.website || '',
+            path: meta.path || '',
+        }));
+    }
+    getContainersForSite(siteKey) {
+        if (!siteKey)
+            return {};
+        const registry = this.ensureIndex();
+        const site = registry[siteKey] || { path: path.join('apps/webauto/resources/container-library', siteKey) };
+        return this.fetchContainersForSite(siteKey, site);
+    }
+    resolveSiteKey(url) {
+        const registry = this.ensureIndex();
+        return this.findSiteKey(url, registry);
+    }
+    async load() {
+        // 兼容异步加载，但当前是同步实现
+        this.ensureIndex();
+        return;
+    }
+    getContainersForUrl(url) {
+        const registry = this.ensureIndex();
+        const siteKey = this.findSiteKey(url, registry);
+        if (!siteKey) {
+            return {};
+        }
+        const site = registry[siteKey] || { path: `apps/webauto/resources/container-library/${siteKey}` };
+        return this.fetchContainersForSite(siteKey, site);
+    }
+    fetchContainersForSite(siteKey, site) {
+        // 不做内存级别缓存，确保用户容器定义变更后，每次调用都能读取到最新文件。
+        // 内部会同时加载内置容器与用户容器目录并合并。
+        return this.loadSiteContainers(siteKey, site?.path);
+    }
+    ensureIndex() {
+        if (this.indexCache) {
+            return this.indexCache;
+        }
+        if (fs.existsSync(INDEX_PATH)) {
+            try {
+                this.indexCache = (JSON.parse(fs.readFileSync(INDEX_PATH, 'utf-8')) || {});
+                return this.indexCache;
+            }
+            catch {
+                // fall through
+            }
+        }
+        this.indexCache = {};
+        return this.indexCache;
+    }
+    loadSiteContainers(siteKey, relativePath) {
+        const containers = {};
+        const builtinPath = path.join(PROJECT_ROOT, relativePath || path.join('apps/webauto/resources/container-library', siteKey));
+        if (fs.existsSync(builtinPath)) {
+            this.walkSite(builtinPath, containers);
+            this.loadLegacyFile(builtinPath, containers);
+        }
+        const userPath = path.join(PRIMARY_USER_CONTAINER_ROOT, siteKey);
+        if (fs.existsSync(userPath)) {
+            this.walkSite(userPath, containers);
+            this.loadLegacyFile(userPath, containers);
+        }
+        return containers;
+    }
+    walkSite(sitePath, output) {
+        const stack = [{ dir: sitePath, parts: [] }];
+        while (stack.length) {
+            const { dir, parts } = stack.pop();
+            let hasContainerFile = false;
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                if (entry.isFile() && entry.name === 'container.json') {
+                    const relParts = parts.length ? parts : [path.basename(dir)];
+                    const containerId = relParts.join('.');
+                    try {
+                        const raw = JSON.parse(fs.readFileSync(path.join(dir, entry.name), 'utf-8'));
+                        if (raw && typeof raw === 'object') {
+                            if (isLegacyContainer(raw)) {
+                                continue;
+                            }
+                            const id = raw.id || containerId;
+                            output[id] = { id, ...raw };
+                        }
+                    }
+                    catch {
+                        // ignore malformed container
+                    }
+                    hasContainerFile = true;
+                }
+                else if (entry.isDirectory()) {
+                    stack.push({ dir: path.join(dir, entry.name), parts: [...parts, entry.name] });
+                }
+            }
+            if (!hasContainerFile && parts.length === 0) {
+                // root dir may not contain direct containers, continue
+                continue;
+            }
+        }
+    }
+    loadLegacyFile(sitePath, output) {
+        const legacyFile = path.join(sitePath, 'containers.json');
+        if (!fs.existsSync(legacyFile)) {
+            return;
+        }
+        try {
+            const raw = JSON.parse(fs.readFileSync(legacyFile, 'utf-8'));
+            const containers = raw?.containers;
+            if (containers && typeof containers === 'object') {
+                for (const [key, value] of Object.entries(containers)) {
+                    if (!output[key] && value && typeof value === 'object') {
+                        if (isLegacyContainer(value)) {
+                            continue;
+                        }
+                        output[key] = { id: key, ...value };
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore legacy parse error
+        }
+    }
+    findSiteKey(url, registry) {
+        let host = '';
+        try {
+            const parsed = new URL(url);
+            host = (parsed.hostname || '').toLowerCase();
+        }
+        catch {
+            return null;
+        }
+        let bestKey = null;
+        let bestLen = -1;
+        for (const [key, value] of Object.entries(registry)) {
+            const domain = (value.website || '').toLowerCase();
+            if (!domain)
+                continue;
+            if (host === domain || host.endsWith(`.${domain}`)) {
+                if (domain.length > bestLen) {
+                    bestKey = key;
+                    bestLen = domain.length;
+                }
+            }
+        }
+        return bestKey;
+    }
+}
+function resolveProjectRoot(startDir) {
+    let current = startDir;
+    const { root } = path.parse(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        if (current === root) {
+            return startDir;
+        }
+        current = path.resolve(current, '..');
+    }
+}
+//# sourceMappingURL=index.js.map