clawdbot 2026.1.4-1

package/dist/infra/system-presence.js

@@ -0,0 +1,216 @@
+import { spawnSync } from "node:child_process";
+import os from "node:os";
+const entries = new Map();
+const TTL_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_ENTRIES = 200;
+function normalizePresenceKey(key) {
+    if (!key)
+        return undefined;
+    const trimmed = key.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.toLowerCase();
+}
+function resolvePrimaryIPv4() {
+    const nets = os.networkInterfaces();
+    const prefer = ["en0", "eth0"];
+    const pick = (names) => {
+        for (const name of names) {
+            const list = nets[name];
+            const entry = list?.find((n) => n.family === "IPv4" && !n.internal);
+            if (entry?.address)
+                return entry.address;
+        }
+        for (const list of Object.values(nets)) {
+            const entry = list?.find((n) => n.family === "IPv4" && !n.internal);
+            if (entry?.address)
+                return entry.address;
+        }
+        return undefined;
+    };
+    return pick(prefer) ?? os.hostname();
+}
+function initSelfPresence() {
+    const host = os.hostname();
+    const ip = resolvePrimaryIPv4() ?? undefined;
+    const version = process.env.CLAWDBOT_VERSION ??
+        process.env.npm_package_version ??
+        "unknown";
+    const modelIdentifier = (() => {
+        const p = os.platform();
+        if (p === "darwin") {
+            const res = spawnSync("sysctl", ["-n", "hw.model"], {
+                encoding: "utf-8",
+            });
+            const out = typeof res.stdout === "string" ? res.stdout.trim() : "";
+            return out.length > 0 ? out : undefined;
+        }
+        return os.arch();
+    })();
+    const macOSVersion = () => {
+        const res = spawnSync("sw_vers", ["-productVersion"], {
+            encoding: "utf-8",
+        });
+        const out = typeof res.stdout === "string" ? res.stdout.trim() : "";
+        return out.length > 0 ? out : os.release();
+    };
+    const platform = (() => {
+        const p = os.platform();
+        const rel = os.release();
+        if (p === "darwin")
+            return `macos ${macOSVersion()}`;
+        if (p === "win32")
+            return `windows ${rel}`;
+        return `${p} ${rel}`;
+    })();
+    const deviceFamily = (() => {
+        const p = os.platform();
+        if (p === "darwin")
+            return "Mac";
+        if (p === "win32")
+            return "Windows";
+        if (p === "linux")
+            return "Linux";
+        return p;
+    })();
+    const text = `Gateway: ${host}${ip ? ` (${ip})` : ""} · app ${version} · mode gateway · reason self`;
+    const selfEntry = {
+        host,
+        ip,
+        version,
+        platform,
+        deviceFamily,
+        modelIdentifier,
+        mode: "gateway",
+        reason: "self",
+        text,
+        ts: Date.now(),
+    };
+    const key = host.toLowerCase();
+    entries.set(key, selfEntry);
+}
+function ensureSelfPresence() {
+    // If the map was somehow cleared (e.g., hot reload or a new worker spawn that
+    // skipped module evaluation), re-seed with a local entry so UIs always show
+    // at least the current gateway.
+    if (entries.size === 0) {
+        initSelfPresence();
+    }
+}
+function touchSelfPresence() {
+    const host = os.hostname();
+    const key = host.toLowerCase();
+    const existing = entries.get(key);
+    if (existing) {
+        entries.set(key, { ...existing, ts: Date.now() });
+    }
+    else {
+        initSelfPresence();
+    }
+}
+initSelfPresence();
+function parsePresence(text) {
+    const trimmed = text.trim();
+    const pattern = /Node:\s*([^ (]+)\s*\(([^)]+)\)\s*·\s*app\s*([^·]+?)\s*·\s*last input\s*([0-9]+)s ago\s*·\s*mode\s*([^·]+?)\s*·\s*reason\s*(.+)$/i;
+    const match = trimmed.match(pattern);
+    if (!match) {
+        return { text: trimmed, ts: Date.now() };
+    }
+    const [, host, ip, version, lastInputStr, mode, reasonRaw] = match;
+    const lastInputSeconds = Number.parseInt(lastInputStr, 10);
+    const reason = reasonRaw.trim();
+    return {
+        host: host.trim(),
+        ip: ip.trim(),
+        version: version.trim(),
+        lastInputSeconds: Number.isFinite(lastInputSeconds)
+            ? lastInputSeconds
+            : undefined,
+        mode: mode.trim(),
+        reason,
+        text: trimmed,
+        ts: Date.now(),
+    };
+}
+export function updateSystemPresence(payload) {
+    ensureSelfPresence();
+    const parsed = parsePresence(payload.text);
+    const key = normalizePresenceKey(payload.instanceId) ||
+        normalizePresenceKey(parsed.instanceId) ||
+        normalizePresenceKey(parsed.host) ||
+        parsed.ip ||
+        parsed.text.slice(0, 64) ||
+        os.hostname().toLowerCase();
+    const hadExisting = entries.has(key);
+    const existing = entries.get(key) ?? {};
+    const merged = {
+        ...existing,
+        ...parsed,
+        host: payload.host ?? parsed.host ?? existing.host,
+        ip: payload.ip ?? parsed.ip ?? existing.ip,
+        version: payload.version ?? parsed.version ?? existing.version,
+        platform: payload.platform ?? existing.platform,
+        deviceFamily: payload.deviceFamily ?? existing.deviceFamily,
+        modelIdentifier: payload.modelIdentifier ?? existing.modelIdentifier,
+        mode: payload.mode ?? parsed.mode ?? existing.mode,
+        lastInputSeconds: payload.lastInputSeconds ??
+            parsed.lastInputSeconds ??
+            existing.lastInputSeconds,
+        reason: payload.reason ?? parsed.reason ?? existing.reason,
+        instanceId: payload.instanceId ?? parsed.instanceId ?? existing.instanceId,
+        text: payload.text || parsed.text || existing.text,
+        ts: Date.now(),
+    };
+    entries.set(key, merged);
+    const trackKeys = ["host", "ip", "version", "mode", "reason"];
+    const changes = {};
+    const changedKeys = [];
+    for (const k of trackKeys) {
+        const prev = existing[k];
+        const next = merged[k];
+        if (prev !== next) {
+            changes[k] = next;
+            changedKeys.push(k);
+        }
+    }
+    return {
+        key,
+        previous: hadExisting ? existing : undefined,
+        next: merged,
+        changes,
+        changedKeys,
+    };
+}
+export function upsertPresence(key, presence) {
+    ensureSelfPresence();
+    const normalizedKey = normalizePresenceKey(key) ?? os.hostname().toLowerCase();
+    const existing = entries.get(normalizedKey) ?? {};
+    const merged = {
+        ...existing,
+        ...presence,
+        ts: Date.now(),
+        text: presence.text ||
+            existing.text ||
+            `Node: ${presence.host ?? existing.host ?? "unknown"} · mode ${presence.mode ?? existing.mode ?? "unknown"}`,
+    };
+    entries.set(normalizedKey, merged);
+}
+export function listSystemPresence() {
+    ensureSelfPresence();
+    // prune expired
+    const now = Date.now();
+    for (const [k, v] of entries) {
+        if (now - v.ts > TTL_MS)
+            entries.delete(k);
+    }
+    // enforce max size (LRU by ts)
+    if (entries.size > MAX_ENTRIES) {
+        const sorted = [...entries.entries()].sort((a, b) => a[1].ts - b[1].ts);
+        const toDrop = entries.size - MAX_ENTRIES;
+        for (let i = 0; i < toDrop; i++) {
+            entries.delete(sorted[i][0]);
+        }
+    }
+    touchSelfPresence();
+    return [...entries.values()].sort((a, b) => b.ts - a.ts);
+}

package/dist/infra/tailnet.js

@@ -0,0 +1,46 @@
+import os from "node:os";
+function isTailnetIPv4(address) {
+    const parts = address.split(".");
+    if (parts.length !== 4)
+        return false;
+    const octets = parts.map((p) => Number.parseInt(p, 10));
+    if (octets.some((n) => !Number.isFinite(n) || n < 0 || n > 255))
+        return false;
+    // Tailscale IPv4 range: 100.64.0.0/10
+    // https://tailscale.com/kb/1015/100.x-addresses
+    const [a, b] = octets;
+    return a === 100 && b >= 64 && b <= 127;
+}
+function isTailnetIPv6(address) {
+    // Tailscale IPv6 ULA prefix: fd7a:115c:a1e0::/48
+    // (stable across tailnets; nodes get per-device suffixes)
+    const normalized = address.trim().toLowerCase();
+    return normalized.startsWith("fd7a:115c:a1e0:");
+}
+export function listTailnetAddresses() {
+    const ipv4 = [];
+    const ipv6 = [];
+    const ifaces = os.networkInterfaces();
+    for (const entries of Object.values(ifaces)) {
+        if (!entries)
+            continue;
+        for (const e of entries) {
+            if (!e || e.internal)
+                continue;
+            const address = e.address?.trim();
+            if (!address)
+                continue;
+            if (isTailnetIPv4(address))
+                ipv4.push(address);
+            if (isTailnetIPv6(address))
+                ipv6.push(address);
+        }
+    }
+    return { ipv4: [...new Set(ipv4)], ipv6: [...new Set(ipv6)] };
+}
+export function pickPrimaryTailnetIPv4() {
+    return listTailnetAddresses().ipv4[0];
+}
+export function pickPrimaryTailnetIPv6() {
+    return listTailnetAddresses().ipv6[0];
+}

package/dist/infra/tailscale.js

@@ -0,0 +1,149 @@
+import { existsSync } from "node:fs";
+import chalk from "chalk";
+import { promptYesNo } from "../cli/prompt.js";
+import { danger, info, logVerbose, shouldLogVerbose, warn, } from "../globals.js";
+import { runExec } from "../process/exec.js";
+import { defaultRuntime } from "../runtime.js";
+import { ensureBinary } from "./binaries.js";
+export async function getTailnetHostname(exec = runExec) {
+    // Derive tailnet hostname (or IP fallback) from tailscale status JSON.
+    const candidates = [
+        "tailscale",
+        "/Applications/Tailscale.app/Contents/MacOS/Tailscale",
+    ];
+    let lastError;
+    for (const candidate of candidates) {
+        if (candidate.startsWith("/") && !existsSync(candidate))
+            continue;
+        try {
+            const { stdout } = await exec(candidate, ["status", "--json"]);
+            const parsed = stdout
+                ? JSON.parse(stdout)
+                : {};
+            const self = typeof parsed.Self === "object" && parsed.Self !== null
+                ? parsed.Self
+                : undefined;
+            const dns = typeof self?.DNSName === "string"
+                ? self.DNSName
+                : undefined;
+            const ips = Array.isArray(self?.TailscaleIPs)
+                ? self.TailscaleIPs
+                : [];
+            if (dns && dns.length > 0)
+                return dns.replace(/\.$/, "");
+            if (ips.length > 0)
+                return ips[0];
+            throw new Error("Could not determine Tailscale DNS or IP");
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    throw lastError ?? new Error("Could not determine Tailscale DNS or IP");
+}
+export async function ensureGoInstalled(exec = runExec, prompt = promptYesNo, runtime = defaultRuntime) {
+    // Ensure Go toolchain is present; offer Homebrew install if missing.
+    const hasGo = await exec("go", ["version"]).then(() => true, () => false);
+    if (hasGo)
+        return;
+    const install = await prompt("Go is not installed. Install via Homebrew (brew install go)?", true);
+    if (!install) {
+        runtime.error("Go is required to build tailscaled from source. Aborting.");
+        runtime.exit(1);
+    }
+    logVerbose("Installing Go via Homebrew…");
+    await exec("brew", ["install", "go"]);
+}
+export async function ensureTailscaledInstalled(exec = runExec, prompt = promptYesNo, runtime = defaultRuntime) {
+    // Ensure tailscaled binary exists; install via Homebrew tailscale if missing.
+    const hasTailscaled = await exec("tailscaled", ["--version"]).then(() => true, () => false);
+    if (hasTailscaled)
+        return;
+    const install = await prompt("tailscaled not found. Install via Homebrew (tailscale package)?", true);
+    if (!install) {
+        runtime.error("tailscaled is required for user-space funnel. Aborting.");
+        runtime.exit(1);
+    }
+    logVerbose("Installing tailscaled via Homebrew…");
+    await exec("brew", ["install", "tailscale"]);
+}
+export async function ensureFunnel(port, exec = runExec, runtime = defaultRuntime, prompt = promptYesNo) {
+    // Ensure Funnel is enabled and publish the webhook port.
+    try {
+        const statusOut = (await exec("tailscale", ["funnel", "status", "--json"])).stdout.trim();
+        const parsed = statusOut
+            ? JSON.parse(statusOut)
+            : {};
+        if (!parsed || Object.keys(parsed).length === 0) {
+            runtime.error(danger("Tailscale Funnel is not enabled on this tailnet/device."));
+            runtime.error(info("Enable in admin console: https://login.tailscale.com/admin (see https://tailscale.com/kb/1223/funnel)"));
+            runtime.error(info("macOS user-space tailscaled docs: https://github.com/tailscale/tailscale/wiki/Tailscaled-on-macOS"));
+            const proceed = await prompt("Attempt local setup with user-space tailscaled?", true);
+            if (!proceed)
+                runtime.exit(1);
+            await ensureBinary("brew", exec, runtime);
+            await ensureGoInstalled(exec, prompt, runtime);
+            await ensureTailscaledInstalled(exec, prompt, runtime);
+        }
+        logVerbose(`Enabling funnel on port ${port}…`);
+        const { stdout } = await exec("tailscale", ["funnel", "--yes", "--bg", `${port}`], {
+            maxBuffer: 200_000,
+            timeoutMs: 15_000,
+        });
+        if (stdout.trim())
+            console.log(stdout.trim());
+    }
+    catch (err) {
+        const errOutput = err;
+        const stdout = typeof errOutput.stdout === "string" ? errOutput.stdout : "";
+        const stderr = typeof errOutput.stderr === "string" ? errOutput.stderr : "";
+        if (stdout.includes("Funnel is not enabled")) {
+            console.error(danger("Funnel is not enabled on this tailnet/device."));
+            const linkMatch = stdout.match(/https?:\/\/\S+/);
+            if (linkMatch) {
+                console.error(info(`Enable it here: ${linkMatch[0]}`));
+            }
+            else {
+                console.error(info("Enable in admin console: https://login.tailscale.com/admin (see https://tailscale.com/kb/1223/funnel)"));
+            }
+        }
+        if (stderr.includes("client version") ||
+            stdout.includes("client version")) {
+            console.error(warn("Tailscale client/server version mismatch detected; try updating tailscale/tailscaled."));
+        }
+        runtime.error("Failed to enable Tailscale Funnel. Is it allowed on your tailnet?");
+        runtime.error(info("Tip: Funnel is optional for CLAWDBOT. You can keep running the web gateway without it: `pnpm clawdbot gateway`"));
+        if (shouldLogVerbose()) {
+            if (stdout.trim())
+                runtime.error(chalk.gray(`stdout: ${stdout.trim()}`));
+            if (stderr.trim())
+                runtime.error(chalk.gray(`stderr: ${stderr.trim()}`));
+            runtime.error(err);
+        }
+        runtime.exit(1);
+    }
+}
+export async function enableTailscaleServe(port, exec = runExec) {
+    await exec("tailscale", ["serve", "--bg", "--yes", `${port}`], {
+        maxBuffer: 200_000,
+        timeoutMs: 15_000,
+    });
+}
+export async function disableTailscaleServe(exec = runExec) {
+    await exec("tailscale", ["serve", "reset"], {
+        maxBuffer: 200_000,
+        timeoutMs: 15_000,
+    });
+}
+export async function enableTailscaleFunnel(port, exec = runExec) {
+    await exec("tailscale", ["funnel", "--bg", "--yes", `${port}`], {
+        maxBuffer: 200_000,
+        timeoutMs: 15_000,
+    });
+}
+export async function disableTailscaleFunnel(exec = runExec) {
+    await exec("tailscale", ["funnel", "reset"], {
+        maxBuffer: 200_000,
+        timeoutMs: 15_000,
+    });
+}

package/dist/infra/voicewake.js

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_TRIGGERS = ["clawd", "claude", "computer"];
+function defaultBaseDir() {
+    return path.join(os.homedir(), ".clawdbot");
+}
+function resolvePath(baseDir) {
+    const root = baseDir ?? defaultBaseDir();
+    return path.join(root, "settings", "voicewake.json");
+}
+function sanitizeTriggers(triggers) {
+    const cleaned = (triggers ?? [])
+        .map((w) => (typeof w === "string" ? w.trim() : ""))
+        .filter((w) => w.length > 0);
+    return cleaned.length > 0 ? cleaned : DEFAULT_TRIGGERS;
+}
+async function readJSON(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeJSONAtomic(filePath, value) {
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    const tmp = `${filePath}.${randomUUID()}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(value, null, 2), "utf8");
+    await fs.rename(tmp, filePath);
+}
+let lock = Promise.resolve();
+async function withLock(fn) {
+    const prev = lock;
+    let release;
+    lock = new Promise((resolve) => {
+        release = resolve;
+    });
+    await prev;
+    try {
+        return await fn();
+    }
+    finally {
+        release?.();
+    }
+}
+export function defaultVoiceWakeTriggers() {
+    return [...DEFAULT_TRIGGERS];
+}
+export async function loadVoiceWakeConfig(baseDir) {
+    const filePath = resolvePath(baseDir);
+    const existing = await readJSON(filePath);
+    if (!existing) {
+        return { triggers: defaultVoiceWakeTriggers(), updatedAtMs: 0 };
+    }
+    return {
+        triggers: sanitizeTriggers(existing.triggers),
+        updatedAtMs: typeof existing.updatedAtMs === "number" && existing.updatedAtMs > 0
+            ? existing.updatedAtMs
+            : 0,
+    };
+}
+export async function setVoiceWakeTriggers(triggers, baseDir) {
+    const sanitized = sanitizeTriggers(triggers);
+    const filePath = resolvePath(baseDir);
+    return await withLock(async () => {
+        const next = {
+            triggers: sanitized,
+            updatedAtMs: Date.now(),
+        };
+        await writeJSONAtomic(filePath, next);
+        return next;
+    });
+}

package/dist/infra/widearea-dns.js

@@ -0,0 +1,123 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CONFIG_DIR, ensureDir } from "../utils.js";
+export const WIDE_AREA_DISCOVERY_DOMAIN = "clawdbot.internal.";
+export const WIDE_AREA_ZONE_FILENAME = "clawdbot.internal.db";
+export function getWideAreaZonePath() {
+    return path.join(CONFIG_DIR, "dns", WIDE_AREA_ZONE_FILENAME);
+}
+function dnsLabel(raw, fallback) {
+    const normalized = raw
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+    const out = normalized.length > 0 ? normalized : fallback;
+    return out.length <= 63 ? out : out.slice(0, 63);
+}
+function txtQuote(value) {
+    const escaped = value
+        .replaceAll("\\", "\\\\")
+        .replaceAll('"', '\\"')
+        .replaceAll("\n", "\\n");
+    return `"${escaped}"`;
+}
+function formatYyyyMmDd(date) {
+    const y = date.getUTCFullYear();
+    const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const d = String(date.getUTCDate()).padStart(2, "0");
+    return `${y}${m}${d}`;
+}
+function nextSerial(existingSerial, now) {
+    const today = formatYyyyMmDd(now);
+    const base = Number.parseInt(`${today}01`, 10);
+    if (!existingSerial || !Number.isFinite(existingSerial))
+        return base;
+    const existing = String(existingSerial);
+    if (existing.startsWith(today))
+        return existingSerial + 1;
+    return base;
+}
+function extractSerial(zoneText) {
+    const match = zoneText.match(/^\s*@\s+IN\s+SOA\s+\S+\s+\S+\s+(\d+)\s+/m);
+    if (!match)
+        return null;
+    const parsed = Number.parseInt(match[1], 10);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function extractContentHash(zoneText) {
+    const match = zoneText.match(/^\s*;\s*clawdbot-content-hash:\s*(\S+)\s*$/m);
+    return match?.[1] ?? null;
+}
+function computeContentHash(body) {
+    // Cheap stable hash; avoids importing crypto (and keeps deterministic across runtimes).
+    let h = 2166136261;
+    for (let i = 0; i < body.length; i++) {
+        h ^= body.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return (h >>> 0).toString(16).padStart(8, "0");
+}
+function renderZone(opts) {
+    const hostname = os.hostname().split(".")[0] ?? "clawdbot";
+    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "clawdbot");
+    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-bridge`, "clawdbot-bridge");
+    const txt = [
+        `displayName=${opts.displayName.trim() || hostname}`,
+        `transport=bridge`,
+        `bridgePort=${opts.bridgePort}`,
+    ];
+    if (opts.tailnetDns?.trim()) {
+        txt.push(`tailnetDns=${opts.tailnetDns.trim()}`);
+    }
+    const records = [];
+    records.push(`$ORIGIN ${WIDE_AREA_DISCOVERY_DOMAIN}`);
+    records.push(`$TTL 60`);
+    const soaLine = `@ IN SOA ns1 hostmaster ${opts.serial} 7200 3600 1209600 60`;
+    records.push(soaLine);
+    records.push(`@ IN NS ns1`);
+    records.push(`ns1 IN A ${opts.tailnetIPv4}`);
+    records.push(`${hostLabel} IN A ${opts.tailnetIPv4}`);
+    if (opts.tailnetIPv6) {
+        records.push(`${hostLabel} IN AAAA ${opts.tailnetIPv6}`);
+    }
+    records.push(`_clawdbot-bridge._tcp IN PTR ${instanceLabel}._clawdbot-bridge._tcp`);
+    records.push(`${instanceLabel}._clawdbot-bridge._tcp IN SRV 0 0 ${opts.bridgePort} ${hostLabel}`);
+    records.push(`${instanceLabel}._clawdbot-bridge._tcp IN TXT ${txt.map(txtQuote).join(" ")}`);
+    const contentBody = `${records.join("\n")}\n`;
+    const hashBody = `${records
+        .map((line) => line === soaLine
+        ? `@ IN SOA ns1 hostmaster SERIAL 7200 3600 1209600 60`
+        : line)
+        .join("\n")}\n`;
+    const contentHash = computeContentHash(hashBody);
+    return `; clawdbot-content-hash: ${contentHash}\n${contentBody}`;
+}
+export function renderWideAreaBridgeZoneText(opts) {
+    return renderZone(opts);
+}
+export async function writeWideAreaBridgeZone(opts) {
+    const zonePath = getWideAreaZonePath();
+    await ensureDir(path.dirname(zonePath));
+    const existing = (() => {
+        try {
+            return fs.readFileSync(zonePath, "utf-8");
+        }
+        catch {
+            return null;
+        }
+    })();
+    const nextNoSerial = renderWideAreaBridgeZoneText({ ...opts, serial: 0 });
+    const nextHash = extractContentHash(nextNoSerial);
+    const existingHash = existing ? extractContentHash(existing) : null;
+    if (existing && nextHash && existingHash === nextHash) {
+        return { zonePath, changed: false };
+    }
+    const existingSerial = existing ? extractSerial(existing) : null;
+    const serial = nextSerial(existingSerial, new Date());
+    const next = renderWideAreaBridgeZoneText({ ...opts, serial });
+    fs.writeFileSync(zonePath, next, "utf-8");
+    return { zonePath, changed: true };
+}

package/dist/infra/ws.js

@@ -0,0 +1,13 @@
+import { Buffer } from "node:buffer";
+export function rawDataToString(data, encoding = "utf8") {
+    if (typeof data === "string")
+        return data;
+    if (Buffer.isBuffer(data))
+        return data.toString(encoding);
+    if (Array.isArray(data))
+        return Buffer.concat(data).toString(encoding);
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data).toString(encoding);
+    }
+    return Buffer.from(String(data)).toString(encoding);
+}

package/dist/logger.js

@@ -0,0 +1,52 @@
+import { danger, info, logVerboseConsole, success, warn } from "./globals.js";
+import { createSubsystemLogger, getLogger } from "./logging.js";
+import { defaultRuntime } from "./runtime.js";
+const subsystemPrefixRe = /^([a-z][a-z0-9-]{1,20}):\s+(.*)$/i;
+function splitSubsystem(message) {
+    const match = message.match(subsystemPrefixRe);
+    if (!match)
+        return null;
+    const [, subsystem, rest] = match;
+    return { subsystem, rest };
+}
+export function logInfo(message, runtime = defaultRuntime) {
+    const parsed = runtime === defaultRuntime ? splitSubsystem(message) : null;
+    if (parsed) {
+        createSubsystemLogger(parsed.subsystem).info(parsed.rest);
+        return;
+    }
+    runtime.log(info(message));
+    getLogger().info(message);
+}
+export function logWarn(message, runtime = defaultRuntime) {
+    const parsed = runtime === defaultRuntime ? splitSubsystem(message) : null;
+    if (parsed) {
+        createSubsystemLogger(parsed.subsystem).warn(parsed.rest);
+        return;
+    }
+    runtime.log(warn(message));
+    getLogger().warn(message);
+}
+export function logSuccess(message, runtime = defaultRuntime) {
+    const parsed = runtime === defaultRuntime ? splitSubsystem(message) : null;
+    if (parsed) {
+        createSubsystemLogger(parsed.subsystem).info(parsed.rest);
+        return;
+    }
+    runtime.log(success(message));
+    getLogger().info(message);
+}
+export function logError(message, runtime = defaultRuntime) {
+    const parsed = runtime === defaultRuntime ? splitSubsystem(message) : null;
+    if (parsed) {
+        createSubsystemLogger(parsed.subsystem).error(parsed.rest);
+        return;
+    }
+    runtime.error(danger(message));
+    getLogger().error(message);
+}
+export function logDebug(message) {
+    // Always emit to file logger (level-filtered); console only when verbose.
+    getLogger().debug(message);
+    logVerboseConsole(message);
+}