@web-auto/webauto 0.1.1 → 0.1.2

package/dist/modules/camo-backend/src/internal/engine-manager.js

@@ -0,0 +1,258 @@
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+function readNumber(v) {
+    const n = Number(v);
+    return Number.isFinite(n) && n > 0 ? n : null;
+}
+function getDisplayMetrics() {
+    const envWidth = readNumber(process.env.WEBAUTO_SCREEN_WIDTH);
+    const envHeight = readNumber(process.env.WEBAUTO_SCREEN_HEIGHT);
+    if (envWidth && envHeight) {
+        return { width: envWidth, height: envHeight, source: 'env' };
+    }
+    if (os.platform() === 'darwin') {
+        try {
+            const sp = spawnSync('system_profiler', ['SPDisplaysDataType', '-json'], { encoding: 'utf8' });
+            const spJson = sp.status === 0 && sp.stdout ? JSON.parse(sp.stdout) : null;
+            let width = null;
+            let height = null;
+            const displays = spJson?.SPDisplaysDataType;
+            if (Array.isArray(displays) && displays.length > 0) {
+                const first = displays[0];
+                const gpus = first?._items;
+                const maybe = Array.isArray(gpus) && gpus.length > 0 ? gpus[0] : first;
+                const resStr = maybe?.spdisplays_ndrvs?.[0]?._spdisplays_resolution || maybe?._spdisplays_resolution;
+                if (typeof resStr === 'string') {
+                    const m = resStr.match(/(\d+)\s*x\s*(\d+)/i);
+                    if (m) {
+                        width = readNumber(m[1]);
+                        height = readNumber(m[2]);
+                    }
+                }
+            }
+            const osascript = spawnSync('osascript', ['-l', 'JavaScript', '-e',
+                `ObjC.import('AppKit');
+           const s = $.NSScreen.mainScreen;
+           const f = s.frame;
+           const v = s.visibleFrame;
+           JSON.stringify({
+             width: Number(f.size.width),
+             height: Number(f.size.height),
+             workWidth: Number(v.size.width),
+             workHeight: Number(v.size.height)
+           });`
+            ], { encoding: 'utf8' });
+            const vf = osascript.status === 0 && osascript.stdout ? JSON.parse(osascript.stdout.trim()) : null;
+            const finalW = readNumber(vf?.width) || width;
+            const finalH = readNumber(vf?.height) || height;
+            const workWidth = readNumber(vf?.workWidth);
+            const workHeight = readNumber(vf?.workHeight);
+            if (!finalW || !finalH)
+                return null;
+            return {
+                width: finalW,
+                height: finalH,
+                ...(workWidth ? { workWidth } : {}),
+                ...(workHeight ? { workHeight } : {}),
+                source: 'darwin',
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    if (os.platform() !== 'win32')
+        return null;
+    try {
+        const script = [
+            'Add-Type -AssemblyName System.Windows.Forms;',
+            '$screen=[System.Windows.Forms.Screen]::PrimaryScreen;',
+            '$b=$screen.Bounds;',
+            '$w=$screen.WorkingArea;',
+            '$video=Get-CimInstance Win32_VideoController | Select-Object -First 1;',
+            '$nw=$null;$nh=$null;',
+            'if ($video) { $nw=$video.CurrentHorizontalResolution; $nh=$video.CurrentVerticalResolution }',
+            '$o=[pscustomobject]@{width=$b.Width;height=$b.Height;workWidth=$w.Width;workHeight=$w.Height;nativeWidth=$nw;nativeHeight=$nh};',
+            '$o | ConvertTo-Json -Compress',
+        ].join(' ');
+        const res = spawnSync('powershell', ['-NoProfile', '-Command', script], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        if (res.status !== 0 || !res.stdout)
+            return null;
+        const payload = JSON.parse(res.stdout.trim());
+        const nativeWidth = readNumber(payload?.nativeWidth);
+        const nativeHeight = readNumber(payload?.nativeHeight);
+        const width = readNumber(payload?.width) || nativeWidth || null;
+        const height = readNumber(payload?.height) || nativeHeight || null;
+        const workWidth = readNumber(payload?.workWidth);
+        const workHeight = readNumber(payload?.workHeight);
+        if (!width || !height)
+            return null;
+        return {
+            width,
+            height,
+            ...(workWidth ? { workWidth } : {}),
+            ...(workHeight ? { workHeight } : {}),
+            ...(nativeWidth ? { nativeWidth } : {}),
+            ...(nativeHeight ? { nativeHeight } : {}),
+            source: 'win32',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function getDisplayMetricsWithDPR() {
+    const dm = getDisplayMetrics();
+    const base = dm ? { ...dm } : {};
+    const width = Number(base.width) || 0;
+    const height = Number(base.height) || 0;
+    const workWidth = Number(base.workWidth) || width;
+    const workHeight = Number(base.workHeight) || height;
+    let dpr = 1;
+    if (os.platform() === 'darwin') {
+        try {
+            const sp = spawnSync('system_profiler', ['SPDisplaysDataType', '-json'], { encoding: 'utf8' });
+            const spJson = sp.status === 0 && sp.stdout ? JSON.parse(sp.stdout) : null;
+            const displays = spJson?.SPDisplaysDataType;
+            if (Array.isArray(displays) && displays.length > 0) {
+                const first = displays[0];
+                const gpus = first?._items;
+                const maybe = Array.isArray(gpus) && gpus.length > 0 ? gpus[0] : first;
+                const isRetina = maybe?.spdisplays_retina === 'spdisplays_yes' || maybe?.spdisplays_retina === true;
+                if (isRetina)
+                    dpr = 2;
+            }
+        }
+        catch {
+            if (width >= 2560 && height >= 1440)
+                dpr = 2;
+        }
+    }
+    return { width, height, workWidth, workHeight, source: base.source || 'unknown', dpr };
+}
+async function loadCamoufox() {
+    // Prefer dynamic import; fall back to require for NodeNext interop edge cases.
+    try {
+        return await import('camoufox');
+    }
+    catch (err) {
+        const mod = await import('node:module');
+        const require = mod.createRequire(import.meta.url);
+        return require('camoufox');
+    }
+}
+export async function launchEngineContext(opts) {
+    if (opts.engine === 'camoufox') {
+        // Camoufox/Firefox is sensitive to non-integer window placement/size values.
+        // In practice, when the underlying launch path attempts to derive screenY/screenX from floats,
+        // Firefox can crash with: "Invalid type for property window.screenY. Expected int, got number".
+        // Also, we want the window size to reflect the *real* OS work area so later system clicks
+        // have enough usable viewport.
+        // Prefer OS work area (real screen resolution) for window size; fall back to viewport.
+        const dm = getDisplayMetricsWithDPR();
+        // Physical display size from OS
+        const physicalW = Number(dm?.width || 4096);
+        const physicalH = Number(dm?.height || 2304);
+        const workW = Number(dm?.workWidth || physicalW || 4096);
+        const workH = Number(dm?.workHeight || physicalH || 2190);
+        // Use provided viewport as MAXIMUM (e.g., from fingerprint or explicit opt), default to full work area
+        const maxViewportW = Number(opts.viewport?.width || workW);
+        const maxViewportH = Number(opts.viewport?.height || workH);
+        // Target: fill work area, but don't exceed explicit viewport caps if provided
+        const targetW = maxViewportW > 0 ? Math.min(maxViewportW, workW) : workW;
+        const targetH = maxViewportH > 0 ? Math.min(maxViewportH, workH) : workH;
+        // Use targetW/targetH as viewport (even in headless) to match headful size
+        const viewportW = Math.max(1440, Math.floor(Number(targetW) || 4096));
+        const viewportH = Math.max(900, Math.floor(Number(targetH) || 2190));
+        const envHeadlessW = Number(process.env.WEBAUTO_HEADLESS_WIDTH || 0);
+        const envHeadlessH = Number(process.env.WEBAUTO_HEADLESS_HEIGHT || 0);
+        const headlessW = envHeadlessW > 0 ? envHeadlessW : viewportW;
+        const headlessH = envHeadlessH > 0 ? envHeadlessH : viewportH;
+        if (!Number.isFinite(headlessW) || !Number.isFinite(headlessH)) {
+            throw new Error('headless viewport invalid');
+        }
+        const headless = Boolean(opts.headless);
+        // Final window size: maximize to fill work area (leave small margin for chrome/window decorations)
+        const winW = headless ? headlessW : Math.max(1440, Math.floor(workW * 0.95));
+        const winH = headless ? headlessH : Math.max(900, Math.floor(workH - 80));
+        // Ensure integer types for Camoufox
+        const screenW = Math.floor(physicalW) | 0;
+        const screenH = Math.floor(physicalH) | 0;
+        const intWinW = Math.floor(winW) | 0;
+        const intWinH = Math.floor(winH) | 0;
+        // Firefox/Camoufox requires screenX/screenY to be integers; default to 0 to avoid float errors.
+        const camoufox = await loadCamoufox();
+        const Camoufox = camoufox.Camoufox;
+        if (!Camoufox)
+            throw new Error('camoufox_invalid_api');
+        const targetOS = process.platform === 'win32'
+            ? 'windows'
+            : process.platform === 'darwin'
+                ? 'macos'
+                : 'linux';
+        // Build config to force actual display dimensions (without screen constraints to avoid position calc issues)
+        const config = {
+            'screen.width': Math.floor(physicalW),
+            'screen.height': Math.floor(physicalH),
+            'screen.availWidth': Math.floor(workW),
+            'screen.availHeight': Math.floor(workH),
+            'window.screenX': 0,
+            'window.screenY': 0,
+        };
+        // Force tabs to open in same window (not new windows)
+        const firefox_user_prefs = {
+            // Force all new windows (including script popups) to open as tabs
+            'browser.link.open_newwindow': 3,
+            'browser.link.open_newwindow.restriction': 0,
+            'browser.link.open_newwindow.override.external': -1,
+            // Make sure tab strip is visible and no single-window mode
+            'browser.tabs.loadInBackground': false,
+            'browser.tabs.loadDivertedInBackground': false,
+            'browser.tabs.closeWindowWithLastTab': false,
+            'browser.tabs.warnOnClose': false,
+            'browser.tabs.tabMinWidth': 50,
+        };
+        const result = await Camoufox({
+            headless,
+            os: targetOS,
+            window: [intWinW, intWinH],
+            viewport: { width: headless ? headlessW : viewportW, height: headless ? headlessH : viewportH },
+            firefox_user_prefs,
+            config,
+            data_dir: opts.profileDir,
+            humanize: true,
+            iKnowWhatImDoing: true,
+            locale: 'zh-CN',
+            fonts: [
+                'PingFang SC',
+                'Hiragino Sans GB',
+                'STHeiti',
+                'Microsoft YaHei',
+                'SimHei',
+                'SimSun',
+                'Microsoft JhengHei',
+                'Noto Sans CJK SC',
+                'Source Han Sans SC',
+                'Arial Unicode MS',
+                'Helvetica',
+                'Arial',
+                'Sans-Serif',
+            ],
+            custom_fonts_only: false,
+        });
+        if (result && typeof result.pages === 'function') {
+            // Already a BrowserContext
+            return result;
+        }
+        if (result && typeof result.newContext === 'function') {
+            // Browser -> create a new context
+            return (await result.newContext());
+        }
+        throw new Error('camoufox_invalid_response');
+    }
+    throw new Error('chromium_removed');
+}
+//# sourceMappingURL=engine-manager.js.map

package/dist/modules/camo-backend/src/internal/fingerprint.js

@@ -0,0 +1,203 @@
+/**
+ * 浏览器指纹管理器
+ * 提供稳定的指纹生成、应用和管理功能
+ */
+import { randomBytes } from 'crypto';
+import { writeFile, readFile, mkdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+function resolveFingerprintDir() {
+    const envDir = String(process.env.WEBAUTO_PATHS_FINGERPRINTS || '').trim();
+    if (envDir)
+        return envDir;
+    const portableRoot = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
+    if (portableRoot)
+        return join(portableRoot, '.webauto', 'fingerprints');
+    return join(homedir(), '.webauto', 'fingerprints');
+}
+const PLATFORM_FINGERPRINTS = {
+    windows: [
+        {
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+            platform: 'Win32',
+            osVersion: '10.0',
+        },
+        {
+            userAgent: 'Mozilla/5.0 (Windows NT 11.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+            platform: 'Win32',
+            osVersion: '11.0',
+        },
+    ],
+    macos: [
+        {
+            userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+            platform: 'MacIntel',
+            osVersion: '10.15.7',
+        },
+        {
+            userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_6_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+            platform: 'MacIntel',
+            osVersion: '14.6.1',
+        },
+    ],
+};
+export function generateFingerprint(profileId = 'default', options = {}) {
+    const { platform = null, seed = null } = options;
+    const hash = randomBytes(16).toString('hex');
+    let base;
+    if (platform === 'windows') {
+        base = PLATFORM_FINGERPRINTS.windows[hash.charCodeAt(0) % PLATFORM_FINGERPRINTS.windows.length];
+    }
+    else if (platform === 'macos') {
+        base = PLATFORM_FINGERPRINTS.macos[hash.charCodeAt(0) % PLATFORM_FINGERPRINTS.macos.length];
+    }
+    else {
+        const useWindows = hash.charCodeAt(0) % 2 === 0;
+        const pool = useWindows ? PLATFORM_FINGERPRINTS.windows : PLATFORM_FINGERPRINTS.macos;
+        base = pool[hash.charCodeAt(1) % pool.length];
+    }
+    return {
+        profileId,
+        userAgent: base.userAgent,
+        platform: base.platform,
+        osVersion: base.osVersion,
+        languages: ['zh-CN', 'zh', 'en-US', 'en'],
+        language: 'zh-CN',
+        hardwareConcurrency: [4, 6, 8, 12, 16][hash.charCodeAt(1) % 5],
+        deviceMemory: [4, 8, 16, 32][hash.charCodeAt(2) % 4],
+        viewport: {
+            width: [1366, 1440, 1536, 1920][hash.charCodeAt(3) % 4],
+            height: [768, 900, 864, 1080][hash.charCodeAt(4) % 4],
+        },
+        timezoneId: 'Asia/Shanghai',
+        maxTouchPoints: 0,
+        vendor: 'Google Inc.',
+        renderer: 'ANGLE (NVIDIA, NVIDIA GeForce, D3D11)',
+        originalPlatform: platform || (base.platform === 'Win32' ? 'windows' : 'macos'),
+        // 增加一个随机噪声用于区分 profile
+        fingerprintSalt: hash.slice(0, 8),
+    };
+}
+export async function applyFingerprint(context, fingerprint) {
+    if (!context || !fingerprint)
+        return;
+    try {
+        // 设置User-Agent
+        if (fingerprint.userAgent) {
+            await context.addInitScript(`
+                Object.defineProperty(navigator, 'userAgent', {
+                    get: () => '${fingerprint.userAgent}',
+                    configurable: true
+                });
+                Object.defineProperty(navigator, 'platform', {
+                    get: () => '${fingerprint.platform}',
+                    configurable: true
+                });
+                Object.defineProperty(navigator, 'osVersion', {
+                    get: () => '${fingerprint.osVersion || ''}',
+                    configurable: true
+                });
+            `);
+        }
+        if (fingerprint.vendor) {
+            await context.addInitScript(`
+                Object.defineProperty(navigator, 'vendor', {
+                    get: () => '${fingerprint.vendor}',
+                    configurable: true
+                });
+            `);
+        }
+        // 设置语言
+        if (fingerprint.languages && fingerprint.language) {
+            await context.addInitScript(`
+                Object.defineProperty(navigator, 'language', {
+                    get: () => '${fingerprint.language}',
+                    configurable: true
+                });
+
+                Object.defineProperty(navigator, 'languages', {
+                    get: () => ${JSON.stringify(fingerprint.languages)},
+                    configurable: true
+                });
+            `);
+        }
+        // 设置硬件信息
+        if (fingerprint.hardwareConcurrency) {
+            await context.addInitScript(`
+                Object.defineProperty(navigator, 'hardwareConcurrency', {
+                    get: () => ${fingerprint.hardwareConcurrency},
+                    configurable: true
+                });
+            `);
+        }
+        // 设置设备内存
+        if (fingerprint.deviceMemory) {
+            await context.addInitScript(`
+                Object.defineProperty(navigator, 'deviceMemory', {
+                    get: () => ${fingerprint.deviceMemory},
+                    configurable: true
+                });
+            `);
+        }
+        // 设置视口 (Camoufox 已在启动时应用，无需重新设置)
+        // if (fingerprint.viewport) {
+        //     await context.setViewportSize?.(fingerprint.viewport);
+        // }
+        // 设置时区
+        if (fingerprint.timezoneId) {
+            context.timezoneId = fingerprint.timezoneId;
+        }
+        // 移除webdriver标识
+        await context.addInitScript(`
+            Object.defineProperty(navigator, 'webdriver', {
+                get: () => undefined,
+                configurable: true
+            });
+
+            delete navigator.__proto__.webdriver;
+        `);
+    }
+    catch (error) {
+        console.warn('Failed to apply some fingerprint properties:', error?.message || error);
+    }
+}
+export async function loadFingerprint(fingerprintPath) {
+    try {
+        const data = await readFile(fingerprintPath, 'utf8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveFingerprint(fingerprintPath, fingerprint) {
+    try {
+        await mkdir(dirname(fingerprintPath), { recursive: true });
+        await writeFile(fingerprintPath, JSON.stringify(fingerprint, null, 2));
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to save fingerprint:', error);
+        return false;
+    }
+}
+export function getFingerprintPath(profileId) {
+    return join(resolveFingerprintDir(), `${profileId}.json`);
+}
+export async function generateAndSaveFingerprint(profileId, options = {}) {
+    const fingerprint = generateFingerprint(profileId, options);
+    const path = getFingerprintPath(profileId);
+    await saveFingerprint(path, fingerprint);
+    return { fingerprint, path };
+}
+export async function loadOrGenerateFingerprint(profileId, options = {}) {
+    const path = getFingerprintPath(profileId);
+    let fingerprint = await loadFingerprint(path);
+    if (!fingerprint) {
+        fingerprint = generateFingerprint(profileId, options);
+        await saveFingerprint(path, fingerprint);
+    }
+    return fingerprint;
+}
+export const FINGERPRINT_DIR = resolveFingerprintDir();
+//# sourceMappingURL=fingerprint.js.map

package/dist/modules/camo-backend/src/internal/pageRuntime.js

@@ -0,0 +1,29 @@
+import { injectRuntimeBundle } from './runtimeInjector.js';
+const injectedPages = new WeakSet();
+export async function ensurePageRuntime(page, forceReinject = false) {
+    if (!page) {
+        throw new Error('page is required');
+    }
+    // 强制重新注入或首次注入
+    if (forceReinject || !injectedPages.has(page)) {
+        await injectRuntimeBundle({ page });
+        injectedPages.add(page);
+    }
+    try {
+        await page.waitForFunction(() => Boolean(window.__webautoRuntime && window.__webautoRuntime.ready), {
+            timeout: 4000,
+        });
+    }
+    catch (err) {
+        // Runtime is best-effort for system-level mouse/keyboard commands.
+        // If injection readiness times out (common on slow/heavy pages), we must not block
+        // low-level commands like mouse:click/mouse:wheel.
+        // Higher-level operations (containers:match, overlay highlight) will handle their own retries.
+        return;
+    }
+}
+export async function evalPageRuntime(page, fn) {
+    await ensurePageRuntime(page);
+    return page.evaluate(fn);
+}
+//# sourceMappingURL=pageRuntime.js.map

package/dist/modules/camo-backend/src/internal/runtimeInjector.js

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+let resolvedRuntimePath = null;
+function resolveRuntime() {
+    if (resolvedRuntimePath)
+        return resolvedRuntimePath;
+    const base = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.join(process.cwd(), 'modules/camo-backend/src/internal/page-runtime/runtime.js'),
+        path.join(base, 'page-runtime/runtime.js'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            resolvedRuntimePath = candidate;
+            break;
+        }
+    }
+    if (!resolvedRuntimePath) {
+        throw new Error('Runtime script not found');
+    }
+    return resolvedRuntimePath;
+}
+export async function injectRuntimeBundle({ page }) {
+    const runtimePath = resolveRuntime();
+    console.log(`[runtimeInjector] injecting runtime from ${runtimePath}`);
+    await page.addInitScript({ path: runtimePath });
+    await page.addScriptTag({ path: runtimePath });
+}
+//# sourceMappingURL=runtimeInjector.js.map

package/dist/modules/camo-backend/src/internal/state-bus.js

@@ -0,0 +1,46 @@
+class LocalStateBus {
+    state = new Map();
+    subscribers = new Map();
+    setState(key, payload) {
+        this.state.set(key, { ...payload, lastUpdate: Date.now() });
+        this.publish(`state:${key}`, this.state.get(key));
+    }
+    getState(key) {
+        if (key)
+            return this.state.get(key);
+        return Object.fromEntries(this.state);
+    }
+    publish(event, payload) {
+        const listeners = this.subscribers.get(event) || [];
+        for (const listener of listeners) {
+            try {
+                listener(payload);
+            }
+            catch {
+                // Keep runtime event pipeline resilient.
+            }
+        }
+    }
+    subscribe(event, listener) {
+        const current = this.subscribers.get(event) || [];
+        current.push(listener);
+        this.subscribers.set(event, current);
+        return () => {
+            const next = (this.subscribers.get(event) || []).filter((fn) => fn !== listener);
+            if (next.length === 0) {
+                this.subscribers.delete(event);
+            }
+            else {
+                this.subscribers.set(event, next);
+            }
+        };
+    }
+}
+let stateBus = null;
+export function getStateBus() {
+    if (!stateBus)
+        stateBus = new LocalStateBus();
+    return stateBus;
+}
+export { LocalStateBus };
+//# sourceMappingURL=state-bus.js.map

package/dist/modules/camo-backend/src/internal/storage-paths.js

@@ -0,0 +1,36 @@
+import os from 'os';
+import path from 'path';
+function resolveHomeDir() {
+    const envHome = process.platform === 'win32'
+        ? String(process.env.USERPROFILE || '').trim()
+        : String(process.env.HOME || '').trim();
+    return envHome || os.homedir();
+}
+function resolvePortableRoot() {
+    return String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
+}
+function resolveDataRoot() {
+    const portableRoot = resolvePortableRoot();
+    if (portableRoot)
+        return path.join(portableRoot, '.webauto');
+    return path.join(resolveHomeDir(), '.webauto');
+}
+export function resolveProfilesRoot() {
+    const envRoot = String(process.env.WEBAUTO_PATHS_PROFILES || '').trim();
+    if (envRoot)
+        return envRoot;
+    return path.join(resolveDataRoot(), 'profiles');
+}
+export function resolveCookiesRoot() {
+    const envRoot = String(process.env.WEBAUTO_PATHS_COOKIES || '').trim();
+    if (envRoot)
+        return envRoot;
+    return path.join(resolveDataRoot(), 'cookies');
+}
+export function resolveLocksRoot() {
+    const envRoot = String(process.env.WEBAUTO_PATHS_LOCKS || '').trim();
+    if (envRoot)
+        return envRoot;
+    return path.join(resolveDataRoot(), 'locks');
+}
+//# sourceMappingURL=storage-paths.js.map