clawdbot 2026.1.4

package/dist/hooks/gmail.js

@@ -0,0 +1,177 @@
+import { randomBytes } from "node:crypto";
+import { DEFAULT_GATEWAY_PORT, resolveGatewayPort, } from "../config/config.js";
+export const DEFAULT_GMAIL_LABEL = "INBOX";
+export const DEFAULT_GMAIL_TOPIC = "gog-gmail-watch";
+export const DEFAULT_GMAIL_SUBSCRIPTION = "gog-gmail-watch-push";
+export const DEFAULT_GMAIL_SERVE_BIND = "127.0.0.1";
+export const DEFAULT_GMAIL_SERVE_PORT = 8788;
+export const DEFAULT_GMAIL_SERVE_PATH = "/gmail-pubsub";
+export const DEFAULT_GMAIL_MAX_BYTES = 20_000;
+export const DEFAULT_GMAIL_RENEW_MINUTES = 12 * 60;
+export const DEFAULT_HOOKS_PATH = "/hooks";
+export function generateHookToken(bytes = 24) {
+    return randomBytes(bytes).toString("hex");
+}
+export function mergeHookPresets(existing, preset) {
+    const next = new Set((existing ?? []).map((item) => item.trim()).filter(Boolean));
+    next.add(preset);
+    return Array.from(next);
+}
+export function normalizeHooksPath(raw) {
+    const base = raw?.trim() || DEFAULT_HOOKS_PATH;
+    if (base === "/")
+        return DEFAULT_HOOKS_PATH;
+    const withSlash = base.startsWith("/") ? base : `/${base}`;
+    return withSlash.replace(/\/+$/, "");
+}
+export function normalizeServePath(raw) {
+    const base = raw?.trim() || DEFAULT_GMAIL_SERVE_PATH;
+    // Tailscale funnel/serve strips the set-path prefix before proxying.
+    // To accept requests at /<path> externally, gog must listen on "/".
+    if (base === "/")
+        return "/";
+    const withSlash = base.startsWith("/") ? base : `/${base}`;
+    return withSlash.replace(/\/+$/, "");
+}
+export function buildDefaultHookUrl(hooksPath, port = DEFAULT_GATEWAY_PORT) {
+    const basePath = normalizeHooksPath(hooksPath);
+    const baseUrl = `http://127.0.0.1:${port}`;
+    return joinUrl(baseUrl, `${basePath}/gmail`);
+}
+export function resolveGmailHookRuntimeConfig(cfg, overrides) {
+    const hooks = cfg.hooks;
+    const gmail = hooks?.gmail;
+    const hookToken = overrides.hookToken ?? hooks?.token ?? "";
+    if (!hookToken) {
+        return { ok: false, error: "hooks.token missing (needed for gmail hook)" };
+    }
+    const account = overrides.account ?? gmail?.account ?? "";
+    if (!account) {
+        return { ok: false, error: "gmail account required" };
+    }
+    const topic = overrides.topic ?? gmail?.topic ?? "";
+    if (!topic) {
+        return { ok: false, error: "gmail topic required" };
+    }
+    const subscription = overrides.subscription ?? gmail?.subscription ?? DEFAULT_GMAIL_SUBSCRIPTION;
+    const pushToken = overrides.pushToken ?? gmail?.pushToken ?? "";
+    if (!pushToken) {
+        return { ok: false, error: "gmail push token required" };
+    }
+    const hookUrl = overrides.hookUrl ??
+        gmail?.hookUrl ??
+        buildDefaultHookUrl(hooks?.path, resolveGatewayPort(cfg));
+    const includeBody = overrides.includeBody ?? gmail?.includeBody ?? true;
+    const maxBytesRaw = overrides.maxBytes ?? gmail?.maxBytes;
+    const maxBytes = typeof maxBytesRaw === "number" &&
+        Number.isFinite(maxBytesRaw) &&
+        maxBytesRaw > 0
+        ? Math.floor(maxBytesRaw)
+        : DEFAULT_GMAIL_MAX_BYTES;
+    const renewEveryMinutesRaw = overrides.renewEveryMinutes ?? gmail?.renewEveryMinutes;
+    const renewEveryMinutes = typeof renewEveryMinutesRaw === "number" &&
+        Number.isFinite(renewEveryMinutesRaw) &&
+        renewEveryMinutesRaw > 0
+        ? Math.floor(renewEveryMinutesRaw)
+        : DEFAULT_GMAIL_RENEW_MINUTES;
+    const serveBind = overrides.serveBind ?? gmail?.serve?.bind ?? DEFAULT_GMAIL_SERVE_BIND;
+    const servePortRaw = overrides.servePort ?? gmail?.serve?.port;
+    const servePort = typeof servePortRaw === "number" &&
+        Number.isFinite(servePortRaw) &&
+        servePortRaw > 0
+        ? Math.floor(servePortRaw)
+        : DEFAULT_GMAIL_SERVE_PORT;
+    const servePathRaw = overrides.servePath ?? gmail?.serve?.path;
+    const hasExplicitServePath = typeof servePathRaw === "string" && servePathRaw.trim().length > 0;
+    const tailscaleMode = overrides.tailscaleMode ?? gmail?.tailscale?.mode ?? "off";
+    // When exposing the push endpoint via Tailscale, the public path is stripped
+    // before proxying; use "/" internally unless the user set a path explicitly.
+    const servePath = normalizeServePath(tailscaleMode !== "off" && !hasExplicitServePath ? "/" : servePathRaw);
+    const tailscalePathRaw = overrides.tailscalePath ?? gmail?.tailscale?.path;
+    const tailscalePath = normalizeServePath(tailscaleMode !== "off" && !tailscalePathRaw
+        ? hasExplicitServePath
+            ? servePathRaw
+            : DEFAULT_GMAIL_SERVE_PATH
+        : (tailscalePathRaw ?? servePath));
+    return {
+        ok: true,
+        value: {
+            account,
+            label: overrides.label ?? gmail?.label ?? DEFAULT_GMAIL_LABEL,
+            topic,
+            subscription,
+            pushToken,
+            hookToken,
+            hookUrl,
+            includeBody,
+            maxBytes,
+            renewEveryMinutes,
+            serve: {
+                bind: serveBind,
+                port: servePort,
+                path: servePath,
+            },
+            tailscale: {
+                mode: tailscaleMode,
+                path: tailscalePath,
+            },
+        },
+    };
+}
+export function buildGogWatchStartArgs(cfg) {
+    return [
+        "gmail",
+        "watch",
+        "start",
+        "--account",
+        cfg.account,
+        "--label",
+        cfg.label,
+        "--topic",
+        cfg.topic,
+    ];
+}
+export function buildGogWatchServeArgs(cfg) {
+    const args = [
+        "gmail",
+        "watch",
+        "serve",
+        "--account",
+        cfg.account,
+        "--bind",
+        cfg.serve.bind,
+        "--port",
+        String(cfg.serve.port),
+        "--path",
+        cfg.serve.path,
+        "--token",
+        cfg.pushToken,
+        "--hook-url",
+        cfg.hookUrl,
+        "--hook-token",
+        cfg.hookToken,
+    ];
+    if (cfg.includeBody) {
+        args.push("--include-body");
+    }
+    if (cfg.maxBytes > 0) {
+        args.push("--max-bytes", String(cfg.maxBytes));
+    }
+    return args;
+}
+export function buildTopicPath(projectId, topicName) {
+    return `projects/${projectId}/topics/${topicName}`;
+}
+export function parseTopicPath(topic) {
+    const match = topic.trim().match(/^projects\/([^/]+)\/topics\/([^/]+)$/i);
+    if (!match)
+        return null;
+    return { projectId: match[1] ?? "", topicName: match[2] ?? "" };
+}
+function joinUrl(base, path) {
+    const url = new URL(base);
+    const basePath = url.pathname.replace(/\/+$/, "");
+    const extra = path.startsWith("/") ? path : `/${path}`;
+    url.pathname = `${basePath}${extra}`;
+    return url.toString();
+}

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import dotenv from "dotenv";
+import { getReplyFromConfig } from "./auto-reply/reply.js";
+import { applyTemplate } from "./auto-reply/templating.js";
+import { createDefaultDeps } from "./cli/deps.js";
+import { promptYesNo } from "./cli/prompt.js";
+import { waitForever } from "./cli/wait.js";
+import { loadConfig } from "./config/config.js";
+import { deriveSessionKey, loadSessionStore, resolveSessionKey, resolveStorePath, saveSessionStore, } from "./config/sessions.js";
+import { ensureBinary } from "./infra/binaries.js";
+import { normalizeEnv } from "./infra/env.js";
+import { isMainModule } from "./infra/is-main.js";
+import { ensureClawdbotCliOnPath } from "./infra/path-env.js";
+import { describePortOwner, ensurePortAvailable, handlePortError, PortInUseError, } from "./infra/ports.js";
+import { assertSupportedRuntime } from "./infra/runtime-guard.js";
+import { enableConsoleCapture } from "./logging.js";
+import { runCommandWithTimeout, runExec } from "./process/exec.js";
+import { monitorWebProvider } from "./provider-web.js";
+import { assertProvider, normalizeE164, toWhatsappJid } from "./utils.js";
+dotenv.config({ quiet: true });
+normalizeEnv();
+ensureClawdbotCliOnPath();
+// Capture all console output into structured logs while keeping stdout/stderr behavior.
+enableConsoleCapture();
+// Enforce the minimum supported runtime before doing any work.
+assertSupportedRuntime();
+import { buildProgram } from "./cli/program.js";
+const program = buildProgram();
+export { assertProvider, applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebProvider, normalizeE164, PortInUseError, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, toWhatsappJid, waitForever, };
+const isMain = isMainModule({
+    currentFile: fileURLToPath(import.meta.url),
+});
+if (isMain) {
+    // Global error handlers to prevent silent crashes from unhandled rejections/exceptions.
+    // These log the error and exit gracefully instead of crashing without trace.
+    process.on("unhandledRejection", (reason, _promise) => {
+        console.error("[clawdbot] Unhandled promise rejection:", reason instanceof Error ? (reason.stack ?? reason.message) : reason);
+        process.exit(1);
+    });
+    process.on("uncaughtException", (error) => {
+        console.error("[clawdbot] Uncaught exception:", error.stack ?? error.message);
+        process.exit(1);
+    });
+    void program.parseAsync(process.argv).catch((err) => {
+        console.error("[clawdbot] CLI failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+        process.exit(1);
+    });
+}

package/dist/infra/agent-events.js

@@ -0,0 +1,46 @@
+// Keep per-run counters so streams stay strictly monotonic per runId.
+const seqByRun = new Map();
+const listeners = new Set();
+const runContextById = new Map();
+export function registerAgentRunContext(runId, context) {
+    if (!runId)
+        return;
+    const existing = runContextById.get(runId);
+    if (!existing) {
+        runContextById.set(runId, { ...context });
+        return;
+    }
+    if (context.sessionKey && existing.sessionKey !== context.sessionKey) {
+        existing.sessionKey = context.sessionKey;
+    }
+}
+export function getAgentRunContext(runId) {
+    return runContextById.get(runId);
+}
+export function clearAgentRunContext(runId) {
+    runContextById.delete(runId);
+}
+export function resetAgentRunContextForTest() {
+    runContextById.clear();
+}
+export function emitAgentEvent(event) {
+    const nextSeq = (seqByRun.get(event.runId) ?? 0) + 1;
+    seqByRun.set(event.runId, nextSeq);
+    const enriched = {
+        ...event,
+        seq: nextSeq,
+        ts: Date.now(),
+    };
+    for (const listener of listeners) {
+        try {
+            listener(enriched);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function onAgentEvent(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}

package/dist/infra/binaries.js

@@ -0,0 +1,9 @@
+import { runExec } from "../process/exec.js";
+import { defaultRuntime } from "../runtime.js";
+export async function ensureBinary(name, exec = runExec, runtime = defaultRuntime) {
+    // Abort early if a required CLI tool is missing.
+    await exec("which", [name]).catch(() => {
+        runtime.error(`Missing required binary: ${name}. Please install it.`);
+        runtime.exit(1);
+    });
+}

package/dist/infra/bonjour-discovery.js

@@ -0,0 +1,163 @@
+import { runCommandWithTimeout } from "../process/exec.js";
+const DEFAULT_TIMEOUT_MS = 2000;
+function parseIntOrNull(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseTxtTokens(tokens) {
+    const txt = {};
+    for (const token of tokens) {
+        const idx = token.indexOf("=");
+        if (idx <= 0)
+            continue;
+        const key = token.slice(0, idx).trim();
+        const value = token.slice(idx + 1).trim();
+        if (!key)
+            continue;
+        txt[key] = value;
+    }
+    return txt;
+}
+function parseDnsSdBrowse(stdout) {
+    const instances = new Set();
+    for (const raw of stdout.split("\n")) {
+        const line = raw.trim();
+        if (!line || !line.includes("_clawdbot-bridge._tcp"))
+            continue;
+        if (!line.includes("Add"))
+            continue;
+        const match = line.match(/_clawdbot-bridge\._tcp\.?\s+(.+)$/);
+        if (match?.[1]) {
+            instances.add(match[1].trim());
+        }
+    }
+    return Array.from(instances.values());
+}
+function parseDnsSdResolve(stdout, instanceName) {
+    const beacon = { instanceName };
+    let txt = {};
+    for (const raw of stdout.split("\n")) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        if (line.includes("can be reached at")) {
+            const match = line.match(/can be reached at\s+([^\s:]+):(\d+)/i);
+            if (match?.[1]) {
+                beacon.host = match[1].replace(/\.$/, "");
+            }
+            if (match?.[2]) {
+                beacon.port = parseIntOrNull(match[2]);
+            }
+            continue;
+        }
+        if (line.startsWith("txt") || line.includes("txtvers=")) {
+            const tokens = line.split(/\s+/).filter(Boolean);
+            txt = parseTxtTokens(tokens);
+        }
+    }
+    beacon.txt = Object.keys(txt).length ? txt : undefined;
+    if (txt.displayName)
+        beacon.displayName = txt.displayName;
+    if (txt.lanHost)
+        beacon.lanHost = txt.lanHost;
+    if (txt.tailnetDns)
+        beacon.tailnetDns = txt.tailnetDns;
+    if (txt.cliPath)
+        beacon.cliPath = txt.cliPath;
+    beacon.bridgePort = parseIntOrNull(txt.bridgePort);
+    beacon.gatewayPort = parseIntOrNull(txt.gatewayPort);
+    beacon.sshPort = parseIntOrNull(txt.sshPort);
+    if (!beacon.displayName)
+        beacon.displayName = instanceName;
+    return beacon;
+}
+async function discoverViaDnsSd(timeoutMs) {
+    const browse = await runCommandWithTimeout(["dns-sd", "-B", "_clawdbot-bridge._tcp", "local."], { timeoutMs });
+    const instances = parseDnsSdBrowse(browse.stdout);
+    const results = [];
+    for (const instance of instances) {
+        const resolved = await runCommandWithTimeout(["dns-sd", "-L", instance, "_clawdbot-bridge._tcp", "local."], { timeoutMs });
+        const parsed = parseDnsSdResolve(resolved.stdout, instance);
+        if (parsed)
+            results.push(parsed);
+    }
+    return results;
+}
+function parseAvahiBrowse(stdout) {
+    const results = [];
+    let current = null;
+    for (const raw of stdout.split("\n")) {
+        const line = raw.trimEnd();
+        if (!line)
+            continue;
+        if (line.startsWith("=") && line.includes("_clawdbot-bridge._tcp")) {
+            if (current)
+                results.push(current);
+            const marker = " _clawdbot-bridge._tcp";
+            const idx = line.indexOf(marker);
+            const left = idx >= 0 ? line.slice(0, idx).trim() : line;
+            const parts = left.split(/\s+/);
+            const instanceName = parts.length > 3 ? parts.slice(3).join(" ") : left;
+            current = {
+                instanceName,
+                displayName: instanceName,
+            };
+            continue;
+        }
+        if (!current)
+            continue;
+        const trimmed = line.trim();
+        if (trimmed.startsWith("hostname =")) {
+            const match = trimmed.match(/hostname\s*=\s*\[([^\]]+)\]/);
+            if (match?.[1])
+                current.host = match[1];
+            continue;
+        }
+        if (trimmed.startsWith("port =")) {
+            const match = trimmed.match(/port\s*=\s*\[(\d+)\]/);
+            if (match?.[1])
+                current.port = parseIntOrNull(match[1]);
+            continue;
+        }
+        if (trimmed.startsWith("txt =")) {
+            const tokens = Array.from(trimmed.matchAll(/"([^"]*)"/g), (m) => m[1]);
+            const txt = parseTxtTokens(tokens);
+            current.txt = Object.keys(txt).length ? txt : undefined;
+            if (txt.displayName)
+                current.displayName = txt.displayName;
+            if (txt.lanHost)
+                current.lanHost = txt.lanHost;
+            if (txt.tailnetDns)
+                current.tailnetDns = txt.tailnetDns;
+            if (txt.cliPath)
+                current.cliPath = txt.cliPath;
+            current.bridgePort = parseIntOrNull(txt.bridgePort);
+            current.gatewayPort = parseIntOrNull(txt.gatewayPort);
+            current.sshPort = parseIntOrNull(txt.sshPort);
+        }
+    }
+    if (current)
+        results.push(current);
+    return results;
+}
+async function discoverViaAvahi(timeoutMs) {
+    const browse = await runCommandWithTimeout(["avahi-browse", "-rt", "_clawdbot-bridge._tcp"], { timeoutMs });
+    return parseAvahiBrowse(browse.stdout);
+}
+export async function discoverGatewayBeacons(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    try {
+        if (process.platform === "darwin") {
+            return await discoverViaDnsSd(timeoutMs);
+        }
+        if (process.platform === "linux") {
+            return await discoverViaAvahi(timeoutMs);
+        }
+    }
+    catch {
+        return [];
+    }
+    return [];
+}

package/dist/infra/bonjour.js

@@ -0,0 +1,200 @@
+import os from "node:os";
+import { logDebug, logWarn } from "../logger.js";
+import { getLogger } from "../logging.js";
+function isDisabledByEnv() {
+    if (process.env.CLAWDBOT_DISABLE_BONJOUR === "1")
+        return true;
+    if (process.env.NODE_ENV === "test")
+        return true;
+    if (process.env.VITEST)
+        return true;
+    return false;
+}
+function safeServiceName(name) {
+    const trimmed = name.trim();
+    return trimmed.length > 0 ? trimmed : "Clawdbot";
+}
+function prettifyInstanceName(name) {
+    const normalized = name.trim().replace(/\s+/g, " ");
+    return normalized.replace(/\s+\(Clawdbot\)\s*$/i, "").trim() || normalized;
+}
+function formatBonjourError(err) {
+    if (err instanceof Error) {
+        const msg = err.message || String(err);
+        return err.name && err.name !== "Error" ? `${err.name}: ${msg}` : msg;
+    }
+    return String(err);
+}
+function serviceSummary(label, svc) {
+    let fqdn = "unknown";
+    let hostname = "unknown";
+    let port = -1;
+    try {
+        fqdn = svc.getFQDN();
+    }
+    catch {
+        // ignore
+    }
+    try {
+        hostname = svc.getHostname();
+    }
+    catch {
+        // ignore
+    }
+    try {
+        port = svc.getPort();
+    }
+    catch {
+        // ignore
+    }
+    const state = typeof svc.serviceState === "string" ? svc.serviceState : "unknown";
+    return `${label} fqdn=${fqdn} host=${hostname} port=${port} state=${state}`;
+}
+export async function startGatewayBonjourAdvertiser(opts) {
+    if (isDisabledByEnv()) {
+        return { stop: async () => { } };
+    }
+    const { getResponder, Protocol } = await import("@homebridge/ciao");
+    const responder = getResponder();
+    // mDNS service instance names are single DNS labels; dots in hostnames (like
+    // `Mac.localdomain`) can confuse some resolvers/browsers and break discovery.
+    // Keep only the first label and normalize away a trailing `.local`.
+    const hostname = os
+        .hostname()
+        .replace(/\.local$/i, "")
+        .split(".")[0]
+        .trim() || "clawdbot";
+    const instanceName = typeof opts.instanceName === "string" && opts.instanceName.trim()
+        ? opts.instanceName.trim()
+        : `${hostname} (Clawdbot)`;
+    const displayName = prettifyInstanceName(instanceName);
+    const txtBase = {
+        role: "gateway",
+        gatewayPort: String(opts.gatewayPort),
+        lanHost: `${hostname}.local`,
+        displayName,
+    };
+    if (typeof opts.bridgePort === "number" && opts.bridgePort > 0) {
+        txtBase.bridgePort = String(opts.bridgePort);
+    }
+    if (typeof opts.canvasPort === "number" && opts.canvasPort > 0) {
+        txtBase.canvasPort = String(opts.canvasPort);
+    }
+    if (typeof opts.tailnetDns === "string" && opts.tailnetDns.trim()) {
+        txtBase.tailnetDns = opts.tailnetDns.trim();
+    }
+    if (typeof opts.cliPath === "string" && opts.cliPath.trim()) {
+        txtBase.cliPath = opts.cliPath.trim();
+    }
+    const services = [];
+    // Bridge beacon (used by macOS/iOS/Android nodes and the mac app onboarding flow).
+    if (typeof opts.bridgePort === "number" && opts.bridgePort > 0) {
+        const bridge = responder.createService({
+            name: safeServiceName(instanceName),
+            type: "clawdbot-bridge",
+            protocol: "tcp" /* Protocol.TCP */,
+            port: opts.bridgePort,
+            domain: "local",
+            hostname,
+            txt: {
+                ...txtBase,
+                sshPort: String(opts.sshPort ?? 22),
+                transport: "bridge",
+            },
+        });
+        services.push({
+            label: "bridge",
+            svc: bridge,
+        });
+    }
+    logDebug(`bonjour: starting (hostname=${hostname}, instance=${JSON.stringify(safeServiceName(instanceName))}, gatewayPort=${opts.gatewayPort}, bridgePort=${opts.bridgePort ?? 0}, sshPort=${opts.sshPort ?? 22})`);
+    for (const { label, svc } of services) {
+        try {
+            svc.on("name-change", (name) => {
+                const next = typeof name === "string" ? name : String(name);
+                logWarn(`bonjour: ${label} name conflict resolved; newName=${JSON.stringify(next)}`);
+            });
+            svc.on("hostname-change", (nextHostname) => {
+                const next = typeof nextHostname === "string"
+                    ? nextHostname
+                    : String(nextHostname);
+                logWarn(`bonjour: ${label} hostname conflict resolved; newHostname=${JSON.stringify(next)}`);
+            });
+        }
+        catch (err) {
+            logDebug(`bonjour: failed to attach listeners for ${label}: ${String(err)}`);
+        }
+    }
+    // Do not block gateway startup on mDNS probing/announce. Advertising can take
+    // multiple seconds depending on network state; the gateway should come up even
+    // if Bonjour is slow or fails.
+    for (const { label, svc } of services) {
+        try {
+            void svc
+                .advertise()
+                .then(() => {
+                // Keep this out of stdout/stderr (menubar + tests) but capture in the rolling log.
+                getLogger().info(`bonjour: advertised ${serviceSummary(label, svc)}`);
+            })
+                .catch((err) => {
+                logWarn(`bonjour: advertise failed (${serviceSummary(label, svc)}): ${formatBonjourError(err)}`);
+            });
+        }
+        catch (err) {
+            logWarn(`bonjour: advertise threw (${serviceSummary(label, svc)}): ${formatBonjourError(err)}`);
+        }
+    }
+    // Watchdog: if we ever end up in an unannounced state (e.g. after sleep/wake or
+    // interface churn), try to re-advertise instead of requiring a full gateway restart.
+    const lastRepairAttempt = new Map();
+    const watchdog = setInterval(() => {
+        for (const { label, svc } of services) {
+            const stateUnknown = svc.serviceState;
+            if (typeof stateUnknown !== "string")
+                continue;
+            if (stateUnknown === "announced" || stateUnknown === "announcing")
+                continue;
+            let key = label;
+            try {
+                key = `${label}:${svc.getFQDN()}`;
+            }
+            catch {
+                // ignore
+            }
+            const now = Date.now();
+            const last = lastRepairAttempt.get(key) ?? 0;
+            if (now - last < 30_000)
+                continue;
+            lastRepairAttempt.set(key, now);
+            logWarn(`bonjour: watchdog detected non-announced service; attempting re-advertise (${serviceSummary(label, svc)})`);
+            try {
+                void svc.advertise().catch((err) => {
+                    logWarn(`bonjour: watchdog advertise failed (${serviceSummary(label, svc)}): ${formatBonjourError(err)}`);
+                });
+            }
+            catch (err) {
+                logWarn(`bonjour: watchdog advertise threw (${serviceSummary(label, svc)}): ${formatBonjourError(err)}`);
+            }
+        }
+    }, 60_000);
+    watchdog.unref?.();
+    return {
+        stop: async () => {
+            clearInterval(watchdog);
+            for (const { svc } of services) {
+                try {
+                    await svc.destroy();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            try {
+                await responder.shutdown();
+            }
+            catch {
+                /* ignore */
+            }
+        },
+    };
+}