@hera-al/browser-server 1.0.0

package/dist/core/chrome.js

@@ -0,0 +1,257 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import WebSocket from "ws";
+import { ensurePortAvailable } from "../utils.js";
+import { getDataDir } from "../data-dir.js";
+import { appendCdpPath } from "./cdp.helpers.js";
+import { getHeadersWithAuth, normalizeCdpWsUrl } from "./cdp.js";
+import { resolveBrowserExecutableForPlatform, } from "./chrome.executables.js";
+import { decorateOpenClawProfile, ensureProfileCleanExit, isProfileDecorated, } from "./chrome.profile-decoration.js";
+import { DEFAULT_OPENCLAW_BROWSER_COLOR, } from "./constants.js";
+import { createLogger } from "../logger.js";
+const log = createLogger("Browser:Chrome");
+export { findChromeExecutableLinux, findChromeExecutableMac, findChromeExecutableWindows, resolveBrowserExecutableForPlatform, } from "./chrome.executables.js";
+export { decorateOpenClawProfile, ensureProfileCleanExit, isProfileDecorated, } from "./chrome.profile-decoration.js";
+function exists(filePath) {
+    try {
+        return fs.existsSync(filePath);
+    }
+    catch {
+        return false;
+    }
+}
+function resolveBrowserExecutable(resolved) {
+    return resolveBrowserExecutableForPlatform(resolved, process.platform);
+}
+export function resolveUserDataDir(profileName = "default") {
+    return path.join(getDataDir(), "browser", profileName, "user-data");
+}
+function cdpUrlForPort(cdpPort) {
+    return `http://127.0.0.1:${cdpPort}`;
+}
+export async function isChromeReachable(cdpUrl, timeoutMs = 500) {
+    const version = await fetchChromeVersion(cdpUrl, timeoutMs);
+    return Boolean(version);
+}
+async function fetchChromeVersion(cdpUrl, timeoutMs = 500) {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const versionUrl = appendCdpPath(cdpUrl, "/json/version");
+        const res = await fetch(versionUrl, {
+            signal: ctrl.signal,
+            headers: getHeadersWithAuth(versionUrl),
+        });
+        if (!res.ok) {
+            return null;
+        }
+        const data = (await res.json());
+        if (!data || typeof data !== "object") {
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+export async function getChromeWebSocketUrl(cdpUrl, timeoutMs = 500) {
+    const version = await fetchChromeVersion(cdpUrl, timeoutMs);
+    const wsUrl = String(version?.webSocketDebuggerUrl ?? "").trim();
+    if (!wsUrl) {
+        return null;
+    }
+    return normalizeCdpWsUrl(wsUrl, cdpUrl);
+}
+async function canOpenWebSocket(wsUrl, timeoutMs = 800) {
+    return await new Promise((resolve) => {
+        const headers = getHeadersWithAuth(wsUrl);
+        const ws = new WebSocket(wsUrl, {
+            handshakeTimeout: timeoutMs,
+            ...(Object.keys(headers).length ? { headers } : {}),
+        });
+        const timer = setTimeout(() => {
+            try {
+                ws.terminate();
+            }
+            catch {
+                // ignore
+            }
+            resolve(false);
+        }, Math.max(50, timeoutMs + 25));
+        ws.once("open", () => {
+            clearTimeout(timer);
+            try {
+                ws.close();
+            }
+            catch {
+                // ignore
+            }
+            resolve(true);
+        });
+        ws.once("error", () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+    });
+}
+export async function isChromeCdpReady(cdpUrl, timeoutMs = 500, handshakeTimeoutMs = 800) {
+    const wsUrl = await getChromeWebSocketUrl(cdpUrl, timeoutMs);
+    if (!wsUrl) {
+        return false;
+    }
+    return await canOpenWebSocket(wsUrl, handshakeTimeoutMs);
+}
+export async function launchChrome(resolved, profile) {
+    if (!profile.cdpIsLoopback) {
+        throw new Error(`Profile "${profile.name}" is remote; cannot launch local Chrome.`);
+    }
+    await ensurePortAvailable(profile.cdpPort);
+    const exe = resolveBrowserExecutable(resolved);
+    if (!exe) {
+        throw new Error("No supported browser found (Chrome/Brave/Edge/Chromium on macOS, Linux, or Windows).");
+    }
+    const userDataDir = resolveUserDataDir(profile.name);
+    fs.mkdirSync(userDataDir, { recursive: true });
+    const needsDecorate = !isProfileDecorated(userDataDir, profile.name, (profile.color ?? DEFAULT_OPENCLAW_BROWSER_COLOR).toUpperCase());
+    const spawnOnce = () => {
+        const args = [
+            `--remote-debugging-port=${profile.cdpPort}`,
+            `--user-data-dir=${userDataDir}`,
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--disable-sync",
+            "--disable-background-networking",
+            "--disable-component-update",
+            "--disable-features=Translate,MediaRouter",
+            "--disable-session-crashed-bubble",
+            "--hide-crash-restore-bubble",
+            "--password-store=basic",
+        ];
+        if (resolved.headless) {
+            args.push("--headless=new");
+            args.push("--disable-gpu");
+        }
+        if (resolved.noSandbox) {
+            args.push("--no-sandbox");
+            args.push("--disable-setuid-sandbox");
+        }
+        if (process.platform === "linux") {
+            args.push("--disable-dev-shm-usage");
+        }
+        args.push("about:blank");
+        return spawn(exe.path, args, {
+            stdio: "pipe",
+            env: {
+                ...process.env,
+                HOME: os.homedir(),
+            },
+        });
+    };
+    const startedAt = Date.now();
+    const localStatePath = path.join(userDataDir, "Local State");
+    const preferencesPath = path.join(userDataDir, "Default", "Preferences");
+    const needsBootstrap = !exists(localStatePath) || !exists(preferencesPath);
+    if (needsBootstrap) {
+        const bootstrap = spawnOnce();
+        const deadline = Date.now() + 10_000;
+        while (Date.now() < deadline) {
+            if (exists(localStatePath) && exists(preferencesPath)) {
+                break;
+            }
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        try {
+            bootstrap.kill("SIGTERM");
+        }
+        catch {
+            // ignore
+        }
+        const exitDeadline = Date.now() + 5000;
+        while (Date.now() < exitDeadline) {
+            if (bootstrap.exitCode != null) {
+                break;
+            }
+            await new Promise((r) => setTimeout(r, 50));
+        }
+    }
+    if (needsDecorate) {
+        try {
+            decorateOpenClawProfile(userDataDir, {
+                name: profile.name,
+                color: profile.color,
+            });
+            log.info(`Browser profile decorated (${profile.color})`);
+        }
+        catch (err) {
+            log.warn(`Browser profile decoration failed: ${String(err)}`);
+        }
+    }
+    try {
+        ensureProfileCleanExit(userDataDir);
+    }
+    catch (err) {
+        log.warn(`Browser clean-exit prefs failed: ${String(err)}`);
+    }
+    const proc = spawnOnce();
+    const readyDeadline = Date.now() + 15_000;
+    while (Date.now() < readyDeadline) {
+        if (await isChromeReachable(profile.cdpUrl, 500)) {
+            break;
+        }
+        await new Promise((r) => setTimeout(r, 200));
+    }
+    if (!(await isChromeReachable(profile.cdpUrl, 500))) {
+        try {
+            proc.kill("SIGKILL");
+        }
+        catch {
+            // ignore
+        }
+        throw new Error(`Failed to start Chrome CDP on port ${profile.cdpPort} for profile "${profile.name}".`);
+    }
+    const pid = proc.pid ?? -1;
+    log.info(`Browser started (${exe.kind}) profile "${profile.name}" on 127.0.0.1:${profile.cdpPort} (pid ${pid})`);
+    return {
+        pid,
+        exe,
+        userDataDir,
+        cdpPort: profile.cdpPort,
+        startedAt,
+        proc,
+    };
+}
+export async function stopChrome(running, timeoutMs = 2500) {
+    const proc = running.proc;
+    if (proc.killed) {
+        return;
+    }
+    try {
+        proc.kill("SIGTERM");
+    }
+    catch {
+        // ignore
+    }
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (!proc.exitCode && proc.killed) {
+            break;
+        }
+        if (!(await isChromeReachable(cdpUrlForPort(running.cdpPort), 200))) {
+            return;
+        }
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    try {
+        proc.kill("SIGKILL");
+    }
+    catch {
+        // ignore
+    }
+}
+//# sourceMappingURL=chrome.js.map

package/dist/core/chrome.profile-decoration.d.ts

@@ -0,0 +1,11 @@
+export declare function isProfileDecorated(userDataDir: string, desiredName: string, desiredColorHex: string): boolean;
+/**
+ * Best-effort profile decoration (name + lobster-orange). Chrome preference keys
+ * vary by version; we keep this conservative and idempotent.
+ */
+export declare function decorateOpenClawProfile(userDataDir: string, opts?: {
+    name?: string;
+    color?: string;
+}): void;
+export declare function ensureProfileCleanExit(userDataDir: string): void;
+//# sourceMappingURL=chrome.profile-decoration.d.ts.map

package/dist/core/chrome.profile-decoration.js

@@ -0,0 +1,148 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_OPENCLAW_BROWSER_COLOR, DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME, } from "./constants.js";
+function decoratedMarkerPath(userDataDir) {
+    return path.join(userDataDir, ".openclaw-profile-decorated");
+}
+function safeReadJson(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function safeWriteJson(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+function setDeep(obj, keys, value) {
+    let node = obj;
+    for (const key of keys.slice(0, -1)) {
+        const next = node[key];
+        if (typeof next !== "object" || next === null || Array.isArray(next)) {
+            node[key] = {};
+        }
+        node = node[key];
+    }
+    node[keys[keys.length - 1] ?? ""] = value;
+}
+function parseHexRgbToSignedArgbInt(hex) {
+    const cleaned = hex.trim().replace(/^#/, "");
+    if (!/^[0-9a-fA-F]{6}$/.test(cleaned)) {
+        return null;
+    }
+    const rgb = Number.parseInt(cleaned, 16);
+    const argbUnsigned = (0xff << 24) | rgb;
+    // Chrome stores colors as signed 32-bit ints (SkColor).
+    return argbUnsigned > 0x7fffffff ? argbUnsigned - 0x1_0000_0000 : argbUnsigned;
+}
+export function isProfileDecorated(userDataDir, desiredName, desiredColorHex) {
+    const desiredColorInt = parseHexRgbToSignedArgbInt(desiredColorHex);
+    const localStatePath = path.join(userDataDir, "Local State");
+    const preferencesPath = path.join(userDataDir, "Default", "Preferences");
+    const localState = safeReadJson(localStatePath);
+    const profile = localState?.profile;
+    const infoCache = typeof profile === "object" && profile !== null && !Array.isArray(profile)
+        ? profile.info_cache
+        : null;
+    const info = typeof infoCache === "object" &&
+        infoCache !== null &&
+        !Array.isArray(infoCache) &&
+        typeof infoCache.Default === "object" &&
+        infoCache.Default !== null &&
+        !Array.isArray(infoCache.Default)
+        ? infoCache.Default
+        : null;
+    const prefs = safeReadJson(preferencesPath);
+    const browserTheme = (() => {
+        const browser = prefs?.browser;
+        const theme = typeof browser === "object" && browser !== null && !Array.isArray(browser)
+            ? browser.theme
+            : null;
+        return typeof theme === "object" && theme !== null && !Array.isArray(theme)
+            ? theme
+            : null;
+    })();
+    const autogeneratedTheme = (() => {
+        const autogenerated = prefs?.autogenerated;
+        const theme = typeof autogenerated === "object" && autogenerated !== null && !Array.isArray(autogenerated)
+            ? autogenerated.theme
+            : null;
+        return typeof theme === "object" && theme !== null && !Array.isArray(theme)
+            ? theme
+            : null;
+    })();
+    const nameOk = typeof info?.name === "string" ? info.name === desiredName : true;
+    if (desiredColorInt == null) {
+        // If the user provided a non-#RRGGBB value, we can only do best-effort.
+        return nameOk;
+    }
+    const localSeedOk = typeof info?.profile_color_seed === "number"
+        ? info.profile_color_seed === desiredColorInt
+        : false;
+    const prefOk = (typeof browserTheme?.user_color2 === "number" &&
+        browserTheme.user_color2 === desiredColorInt) ||
+        (typeof autogeneratedTheme?.color === "number" && autogeneratedTheme.color === desiredColorInt);
+    return nameOk && localSeedOk && prefOk;
+}
+/**
+ * Best-effort profile decoration (name + lobster-orange). Chrome preference keys
+ * vary by version; we keep this conservative and idempotent.
+ */
+export function decorateOpenClawProfile(userDataDir, opts) {
+    const desiredName = opts?.name ?? DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME;
+    const desiredColor = (opts?.color ?? DEFAULT_OPENCLAW_BROWSER_COLOR).toUpperCase();
+    const desiredColorInt = parseHexRgbToSignedArgbInt(desiredColor);
+    const localStatePath = path.join(userDataDir, "Local State");
+    const preferencesPath = path.join(userDataDir, "Default", "Preferences");
+    const localState = safeReadJson(localStatePath) ?? {};
+    // Common-ish shape: profile.info_cache.Default
+    setDeep(localState, ["profile", "info_cache", "Default", "name"], desiredName);
+    setDeep(localState, ["profile", "info_cache", "Default", "shortcut_name"], desiredName);
+    setDeep(localState, ["profile", "info_cache", "Default", "user_name"], desiredName);
+    // Color keys are best-effort (Chrome changes these frequently).
+    setDeep(localState, ["profile", "info_cache", "Default", "profile_color"], desiredColor);
+    setDeep(localState, ["profile", "info_cache", "Default", "user_color"], desiredColor);
+    if (desiredColorInt != null) {
+        // These are the fields Chrome actually uses for profile/avatar tinting.
+        setDeep(localState, ["profile", "info_cache", "Default", "profile_color_seed"], desiredColorInt);
+        setDeep(localState, ["profile", "info_cache", "Default", "profile_highlight_color"], desiredColorInt);
+        setDeep(localState, ["profile", "info_cache", "Default", "default_avatar_fill_color"], desiredColorInt);
+        setDeep(localState, ["profile", "info_cache", "Default", "default_avatar_stroke_color"], desiredColorInt);
+    }
+    safeWriteJson(localStatePath, localState);
+    const prefs = safeReadJson(preferencesPath) ?? {};
+    setDeep(prefs, ["profile", "name"], desiredName);
+    setDeep(prefs, ["profile", "profile_color"], desiredColor);
+    setDeep(prefs, ["profile", "user_color"], desiredColor);
+    if (desiredColorInt != null) {
+        // Chrome refresh stores the autogenerated theme in these prefs (SkColor ints).
+        setDeep(prefs, ["autogenerated", "theme", "color"], desiredColorInt);
+        // User-selected browser theme color (pref name: browser.theme.user_color2).
+        setDeep(prefs, ["browser", "theme", "user_color2"], desiredColorInt);
+    }
+    safeWriteJson(preferencesPath, prefs);
+    try {
+        fs.writeFileSync(decoratedMarkerPath(userDataDir), `${Date.now()}\n`, "utf-8");
+    }
+    catch {
+        // ignore
+    }
+}
+export function ensureProfileCleanExit(userDataDir) {
+    const preferencesPath = path.join(userDataDir, "Default", "Preferences");
+    const prefs = safeReadJson(preferencesPath) ?? {};
+    setDeep(prefs, ["exit_type"], "Normal");
+    setDeep(prefs, ["exited_cleanly"], true);
+    safeWriteJson(preferencesPath, prefs);
+}
+//# sourceMappingURL=chrome.profile-decoration.js.map

package/dist/core/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_OPENCLAW_BROWSER_ENABLED = true;
+export declare const DEFAULT_BROWSER_EVALUATE_ENABLED = true;
+export declare const DEFAULT_OPENCLAW_BROWSER_COLOR = "#FF4500";
+export declare const DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME = "openclaw";
+export declare const DEFAULT_BROWSER_DEFAULT_PROFILE_NAME = "chrome";
+export declare const DEFAULT_AI_SNAPSHOT_MAX_CHARS = 80000;
+export declare const DEFAULT_AI_SNAPSHOT_EFFICIENT_MAX_CHARS = 10000;
+export declare const DEFAULT_AI_SNAPSHOT_EFFICIENT_DEPTH = 6;
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.js

@@ -0,0 +1,9 @@
+export const DEFAULT_OPENCLAW_BROWSER_ENABLED = true;
+export const DEFAULT_BROWSER_EVALUATE_ENABLED = true;
+export const DEFAULT_OPENCLAW_BROWSER_COLOR = "#FF4500";
+export const DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME = "openclaw";
+export const DEFAULT_BROWSER_DEFAULT_PROFILE_NAME = "chrome";
+export const DEFAULT_AI_SNAPSHOT_MAX_CHARS = 80_000;
+export const DEFAULT_AI_SNAPSHOT_EFFICIENT_MAX_CHARS = 10_000;
+export const DEFAULT_AI_SNAPSHOT_EFFICIENT_DEPTH = 6;
+//# sourceMappingURL=constants.js.map

package/dist/core/profiles.d.ts

@@ -0,0 +1,31 @@
+/**
+ * CDP port allocation for browser profiles.
+ *
+ * Default port range: 18800-18899 (100 profiles max)
+ * Ports are allocated once at profile creation and persisted in config.
+ * Multi-instance: callers may pass an explicit range to avoid collisions.
+ *
+ * Reserved ports (do not use for CDP):
+ *   18789 - Gateway WebSocket
+ *   18790 - Bridge
+ *   18791 - Browser control server
+ *   18792-18799 - Reserved for future one-off services (canvas at 18793)
+ */
+export declare const CDP_PORT_RANGE_START = 18800;
+export declare const CDP_PORT_RANGE_END = 18899;
+export declare const PROFILE_NAME_REGEX: RegExp;
+export declare function isValidProfileName(name: string): boolean;
+export declare function allocateCdpPort(usedPorts: Set<number>, range?: {
+    start: number;
+    end: number;
+}): number | null;
+export declare function getUsedPorts(profiles: Record<string, {
+    cdpPort?: number;
+    cdpUrl?: string;
+}> | undefined): Set<number>;
+export declare const PROFILE_COLORS: string[];
+export declare function allocateColor(usedColors: Set<string>): string;
+export declare function getUsedColors(profiles: Record<string, {
+    color: string;
+}> | undefined): Set<string>;
+//# sourceMappingURL=profiles.d.ts.map

package/dist/core/profiles.js

@@ -0,0 +1,99 @@
+/**
+ * CDP port allocation for browser profiles.
+ *
+ * Default port range: 18800-18899 (100 profiles max)
+ * Ports are allocated once at profile creation and persisted in config.
+ * Multi-instance: callers may pass an explicit range to avoid collisions.
+ *
+ * Reserved ports (do not use for CDP):
+ *   18789 - Gateway WebSocket
+ *   18790 - Bridge
+ *   18791 - Browser control server
+ *   18792-18799 - Reserved for future one-off services (canvas at 18793)
+ */
+export const CDP_PORT_RANGE_START = 18800;
+export const CDP_PORT_RANGE_END = 18899;
+export const PROFILE_NAME_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+export function isValidProfileName(name) {
+    if (!name || name.length > 64) {
+        return false;
+    }
+    return PROFILE_NAME_REGEX.test(name);
+}
+export function allocateCdpPort(usedPorts, range) {
+    const start = range?.start ?? CDP_PORT_RANGE_START;
+    const end = range?.end ?? CDP_PORT_RANGE_END;
+    if (!Number.isFinite(start) || !Number.isFinite(end) || start <= 0 || end <= 0) {
+        return null;
+    }
+    if (start > end) {
+        return null;
+    }
+    for (let port = start; port <= end; port++) {
+        if (!usedPorts.has(port)) {
+            return port;
+        }
+    }
+    return null;
+}
+export function getUsedPorts(profiles) {
+    if (!profiles) {
+        return new Set();
+    }
+    const used = new Set();
+    for (const profile of Object.values(profiles)) {
+        if (typeof profile.cdpPort === "number") {
+            used.add(profile.cdpPort);
+            continue;
+        }
+        const rawUrl = profile.cdpUrl?.trim();
+        if (!rawUrl) {
+            continue;
+        }
+        try {
+            const parsed = new URL(rawUrl);
+            const port = parsed.port && Number.parseInt(parsed.port, 10) > 0
+                ? Number.parseInt(parsed.port, 10)
+                : parsed.protocol === "https:"
+                    ? 443
+                    : 80;
+            if (!Number.isNaN(port) && port > 0 && port <= 65535) {
+                used.add(port);
+            }
+        }
+        catch {
+            // ignore invalid URLs
+        }
+    }
+    return used;
+}
+export const PROFILE_COLORS = [
+    "#FF4500", // Orange-red (openclaw default)
+    "#0066CC", // Blue
+    "#00AA00", // Green
+    "#9933FF", // Purple
+    "#FF6699", // Pink
+    "#00CCCC", // Cyan
+    "#FF9900", // Orange
+    "#6666FF", // Indigo
+    "#CC3366", // Magenta
+    "#339966", // Teal
+];
+export function allocateColor(usedColors) {
+    // Find first unused color from palette
+    for (const color of PROFILE_COLORS) {
+        if (!usedColors.has(color.toUpperCase())) {
+            return color;
+        }
+    }
+    // All colors used, cycle based on count
+    const index = usedColors.size % PROFILE_COLORS.length;
+    return PROFILE_COLORS[index] ?? PROFILE_COLORS[0];
+}
+export function getUsedColors(profiles) {
+    if (!profiles) {
+        return new Set();
+    }
+    return new Set(Object.values(profiles).map((p) => p.color.toUpperCase()));
+}
+//# sourceMappingURL=profiles.js.map

package/dist/core/target-id.d.ts

@@ -0,0 +1,12 @@
+export type TargetIdResolution = {
+    ok: true;
+    targetId: string;
+} | {
+    ok: false;
+    reason: "not_found" | "ambiguous";
+    matches?: string[];
+};
+export declare function resolveTargetIdFromTabs(input: string, tabs: Array<{
+    targetId: string;
+}>): TargetIdResolution;
+//# sourceMappingURL=target-id.d.ts.map

package/dist/core/target-id.js

@@ -0,0 +1,21 @@
+export function resolveTargetIdFromTabs(input, tabs) {
+    const needle = input.trim();
+    if (!needle) {
+        return { ok: false, reason: "not_found" };
+    }
+    const exact = tabs.find((t) => t.targetId === needle);
+    if (exact) {
+        return { ok: true, targetId: exact.targetId };
+    }
+    const lower = needle.toLowerCase();
+    const matches = tabs.map((t) => t.targetId).filter((id) => id.toLowerCase().startsWith(lower));
+    const only = matches.length === 1 ? matches[0] : undefined;
+    if (only) {
+        return { ok: true, targetId: only };
+    }
+    if (matches.length === 0) {
+        return { ok: false, reason: "not_found" };
+    }
+    return { ok: false, reason: "ambiguous", matches };
+}
+//# sourceMappingURL=target-id.js.map

package/dist/data-dir.d.ts

@@ -0,0 +1,2 @@
+export declare function getDataDir(): string;
+//# sourceMappingURL=data-dir.d.ts.map

package/dist/data-dir.js

@@ -0,0 +1,6 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+export function getDataDir() {
+    return join(process.env.GMAB_PATH ?? join(homedir(), "gmab"), "data");
+}
+//# sourceMappingURL=data-dir.js.map

package/dist/logger.d.ts

@@ -0,0 +1,16 @@
+type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function setLogLevel(level: LogLevel): void;
+export declare function getLogLevel(): LogLevel;
+/** Initialize file logging. Call once at startup. */
+export declare function initLogFile(dir: string): void;
+/** Returns the logs directory path (empty string if not initialized). */
+export declare function getLogsDir(): string;
+export declare function createLogger(tag: string): {
+    debug: (msg: string, ...args: unknown[]) => void;
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+};
+export type Logger = ReturnType<typeof createLogger>;
+export {};
+//# sourceMappingURL=logger.d.ts.map