@gguf/pigbot 0.0.1 → 0.0.2

package/dist/gateway/server/ws-connection/message-handler.js

@@ -7,10 +7,10 @@ import { loadVoiceWakeConfig } from "../../../infra/voicewake.js";
 import { upsertPresence } from "../../../infra/system-presence.js";
 import { rawDataToString } from "../../../infra/ws.js";
 import { isGatewayCliClient, isWebchatClient } from "../../../utils/message-channel.js";
-import { authorizeGatewayConnect } from "../../auth.js";
+import { authorizeGatewayConnect, isLocalDirectRequest } from "../../auth.js";
 import { loadConfig } from "../../../config/config.js";
 import { buildDeviceAuthPayload } from "../../device-auth.js";
-import { isLocalGatewayAddress, resolveGatewayClientIp } from "../../net.js";
+import { isLoopbackAddress, isTrustedProxyAddress, resolveGatewayClientIp } from "../../net.js";
 import { resolveNodeCommandAllowlist } from "../../node-command-policy.js";
 import { ErrorCodes, errorShape, formatValidationErrors, PROTOCOL_VERSION, validateConnectParams, validateRequestFrame, } from "../../protocol/index.js";
 import { GATEWAY_CLIENT_IDS } from "../../protocol/client-info.js";
@@ -21,6 +21,18 @@ import { formatForLog, logWs } from "../../ws-log.js";
 import { truncateCloseReason } from "../close-reason.js";
 import { buildGatewaySnapshot, getHealthCache, getHealthVersion, incrementPresenceVersion, refreshGatewayHealthSnapshot, } from "../health-state.js";
 const DEVICE_SIGNATURE_SKEW_MS = 10 * 60 * 1000;
+function resolveHostName(hostHeader) {
+    const host = (hostHeader ?? "").trim().toLowerCase();
+    if (!host)
+        return "";
+    if (host.startsWith("[")) {
+        const end = host.indexOf("]");
+        if (end !== -1)
+            return host.slice(1, end);
+    }
+    const [name] = host.split(":");
+    return name ?? "";
+}
 function formatGatewayAuthFailureMessage(params) {
     const { authMode, authProvided, reason, client } = params;
     const isCli = isGatewayCliClient(client);
@@ -54,6 +66,10 @@ function formatGatewayAuthFailureMessage(params) {
             return "unauthorized: tailscale identity missing (use Tailscale Serve auth or gateway token/password)";
         case "tailscale_proxy_missing":
             return "unauthorized: tailscale proxy headers missing (use Tailscale Serve or gateway token/password)";
+        case "tailscale_whois_failed":
+            return "unauthorized: tailscale identity check failed (use Tailscale Serve auth or gateway token/password)";
+        case "tailscale_user_mismatch":
+            return "unauthorized: tailscale identity mismatch (use Tailscale Serve auth or gateway token/password)";
         default:
             break;
     }
@@ -70,7 +86,33 @@ export function attachGatewayWsMessageHandler(params) {
     const configSnapshot = loadConfig();
     const trustedProxies = configSnapshot.gateway?.trustedProxies ?? [];
     const clientIp = resolveGatewayClientIp({ remoteAddr, forwardedFor, realIp, trustedProxies });
-    const isLocalClient = isLocalGatewayAddress(clientIp);
+    // If proxy headers are present but the remote address isn't trusted, don't treat
+    // the connection as local. This prevents auth bypass when running behind a reverse
+    // proxy without proper configuration - the proxy's loopback connection would otherwise
+    // cause all external requests to be treated as trusted local clients.
+    const hasProxyHeaders = Boolean(forwardedFor || realIp);
+    const remoteIsTrustedProxy = isTrustedProxyAddress(remoteAddr, trustedProxies);
+    const hasUntrustedProxyHeaders = hasProxyHeaders && !remoteIsTrustedProxy;
+    const hostName = resolveHostName(requestHost);
+    const hostIsLocal = hostName === "localhost" || hostName === "127.0.0.1" || hostName === "::1";
+    const hostIsTailscaleServe = hostName.endsWith(".ts.net");
+    const hostIsLocalish = hostIsLocal || hostIsTailscaleServe;
+    const isLocalClient = isLocalDirectRequest(upgradeReq, trustedProxies);
+    const reportedClientIp = isLocalClient || hasUntrustedProxyHeaders
+        ? undefined
+        : clientIp && !isLoopbackAddress(clientIp)
+            ? clientIp
+            : undefined;
+    if (hasUntrustedProxyHeaders) {
+        logWsControl.warn("Proxy headers detected from untrusted address. " +
+            "Connection will not be treated as local. " +
+            "Configure gateway.trustedProxies to restore local client detection behind your proxy.");
+    }
+    if (!hostIsLocalish && isLoopbackAddress(remoteAddr) && !hasProxyHeaders) {
+        logWsControl.warn("Loopback connection with non-local Host header. " +
+            "Treating it as remote. If you're behind a reverse proxy, " +
+            "set gateway.trustedProxies and forward X-Forwarded-For/X-Real-IP.");
+    }
     const isWebchatConnect = (p) => isWebchatClient(p?.client);
     socket.on("message", async (data) => {
         if (isClosed())
@@ -193,15 +235,19 @@ export function attachGatewayWsMessageHandler(params) {
                         : [];
                 connectParams.role = role;
                 connectParams.scopes = scopes;
-                const device = connectParams.device;
+                const deviceRaw = connectParams.device;
                 let devicePublicKey = null;
                 const hasTokenAuth = Boolean(connectParams.auth?.token);
                 const hasPasswordAuth = Boolean(connectParams.auth?.password);
+                const hasSharedAuth = hasTokenAuth || hasPasswordAuth;
                 const isControlUi = connectParams.client.id === GATEWAY_CLIENT_IDS.CONTROL_UI;
+                const allowInsecureControlUi = isControlUi && configSnapshot.gateway?.controlUi?.allowInsecureAuth === true;
+                const disableControlUiDeviceAuth = isControlUi && configSnapshot.gateway?.controlUi?.dangerouslyDisableDeviceAuth === true;
+                const allowControlUiBypass = allowInsecureControlUi || disableControlUiDeviceAuth;
+                const device = disableControlUiDeviceAuth ? null : deviceRaw;
                 if (!device) {
-                    const allowInsecureControlUi = isControlUi && configSnapshot.gateway?.controlUi?.allowInsecureAuth === true;
-                    const canSkipDevice = isControlUi && allowInsecureControlUi ? hasTokenAuth || hasPasswordAuth : hasTokenAuth;
-                    if (isControlUi && !allowInsecureControlUi) {
+                    const canSkipDevice = allowControlUiBypass ? hasSharedAuth : hasTokenAuth;
+                    if (isControlUi && !allowControlUiBypass) {
                         const errorMessage = "control ui requires HTTPS or localhost (secure context)";
                         setHandshakeState("failed");
                         setCloseCause("control-ui-insecure-auth", {
@@ -393,7 +439,7 @@ export function attachGatewayWsMessageHandler(params) {
                     trustedProxies,
                 });
                 let authOk = authResult.ok;
-                let authMethod = authResult.method ?? "none";
+                let authMethod = authResult.method ?? (resolvedAuth.mode === "password" ? "password" : "token");
                 if (!authOk && connectParams.auth?.token && device) {
                     const tokenCheck = await verifyDeviceToken({
                         deviceId: device.id,
@@ -439,7 +485,8 @@ export function attachGatewayWsMessageHandler(params) {
                     close(1008, truncateCloseReason(authMessage));
                     return;
                 }
-                if (device && devicePublicKey) {
+                const skipPairing = allowControlUiBypass && hasSharedAuth;
+                if (device && devicePublicKey && !skipPairing) {
                     const requirePairing = async (reason, _paired) => {
                         const pairing = await requestDevicePairing({
                             deviceId: device.id,
@@ -450,7 +497,7 @@ export function attachGatewayWsMessageHandler(params) {
                             clientMode: connectParams.client.mode,
                             role,
                             scopes,
-                            remoteIp: clientIp,
+                            remoteIp: reportedClientIp,
                             silent: isLocalClient,
                         });
                         const context = buildRequestContext();
@@ -532,7 +579,7 @@ export function attachGatewayWsMessageHandler(params) {
                             clientMode: connectParams.client.mode,
                             role,
                             scopes,
-                            remoteIp: clientIp,
+                            remoteIp: reportedClientIp,
                         });
                     }
                 }
@@ -554,9 +601,7 @@ export function attachGatewayWsMessageHandler(params) {
                 const shouldTrackPresence = !isGatewayCliClient(connectParams.client);
                 const clientId = connectParams.client.id;
                 const instanceId = connectParams.client.instanceId;
-                const presenceKey = shouldTrackPresence
-                    ? (connectParams.device?.id ?? instanceId ?? connId)
-                    : undefined;
+                const presenceKey = shouldTrackPresence ? (device?.id ?? instanceId ?? connId) : undefined;
                 logWs("in", "connect", {
                     connId,
                     client: connectParams.client.id,
@@ -573,16 +618,16 @@ export function attachGatewayWsMessageHandler(params) {
                 if (presenceKey) {
                     upsertPresence(presenceKey, {
                         host: connectParams.client.displayName ?? connectParams.client.id ?? os.hostname(),
-                        ip: isLocalClient ? undefined : clientIp,
+                        ip: isLocalClient ? undefined : reportedClientIp,
                         version: connectParams.client.version,
                         platform: connectParams.client.platform,
                         deviceFamily: connectParams.client.deviceFamily,
                         modelIdentifier: connectParams.client.modelIdentifier,
                         mode: connectParams.client.mode,
-                        deviceId: connectParams.device?.id,
+                        deviceId: device?.id,
                         roles: [role],
                         scopes,
-                        instanceId: connectParams.device?.id ?? instanceId,
+                        instanceId: device?.id ?? instanceId,
                         reason: "connect",
                     });
                     incrementPresenceVersion();
@@ -597,7 +642,7 @@ export function attachGatewayWsMessageHandler(params) {
                     type: "hello-ok",
                     protocol: PROTOCOL_VERSION,
                     server: {
-                        version: process.env.PIGBOT_VERSION ?? process.env.npm_package_version ?? "dev",
+                        version: process.env.CLAWDBOT_VERSION ?? process.env.npm_package_version ?? "dev",
                         commit: process.env.GIT_COMMIT,
                         host: os.hostname(),
                         connId,
@@ -630,7 +675,9 @@ export function attachGatewayWsMessageHandler(params) {
                 setHandshakeState("connected");
                 if (role === "node") {
                     const context = buildRequestContext();
-                    const nodeSession = context.nodeRegistry.register(nextClient, { remoteIp: clientIp });
+                    const nodeSession = context.nodeRegistry.register(nextClient, {
+                        remoteIp: reportedClientIp,
+                    });
                     const instanceIdRaw = connectParams.client.instanceId;
                     const instanceId = typeof instanceIdRaw === "string" ? instanceIdRaw.trim() : "";
                     const nodeIdsForPairing = new Set([nodeSession.nodeId]);

package/dist/gateway/server-browser.js

@@ -1,11 +1,22 @@
 import { isTruthyEnvValue } from "../infra/env.js";
 export async function startBrowserControlServerIfEnabled() {
-    if (isTruthyEnvValue(process.env.PIGBOT_SKIP_BROWSER_CONTROL_SERVER))
+    if (isTruthyEnvValue(process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER))
         return null;
     // Lazy import: keeps startup fast, but still bundles for the embedded
     // gateway (bun --compile) via the static specifier path.
-    const override = process.env.PIGBOT_BROWSER_CONTROL_MODULE?.trim();
-    const mod = override ? await import(override) : await import("../browser/server.js");
-    await mod.startBrowserControlServerFromConfig();
-    return { stop: mod.stopBrowserControlServer };
+    const override = process.env.CLAWDBOT_BROWSER_CONTROL_MODULE?.trim();
+    const mod = override ? await import(override) : await import("../browser/control-service.js");
+    const start = typeof mod
+        .startBrowserControlServiceFromConfig === "function"
+        ? mod
+            .startBrowserControlServiceFromConfig
+        : mod
+            .startBrowserControlServerFromConfig;
+    const stop = typeof mod.stopBrowserControlService === "function"
+        ? mod.stopBrowserControlService
+        : mod.stopBrowserControlServer;
+    if (!start)
+        return null;
+    await start();
+    return { stop: stop ?? (async () => { }) };
 }

package/dist/gateway/server-chat.js

@@ -1,7 +1,27 @@
 import { normalizeVerboseLevel } from "../auto-reply/thinking.js";
+import { loadConfig } from "../config/config.js";
 import { getAgentRunContext } from "../infra/agent-events.js";
+import { resolveHeartbeatVisibility } from "../infra/heartbeat-visibility.js";
 import { loadSessionEntry } from "./session-utils.js";
 import { formatForLog } from "./ws-log.js";
+/**
+ * Check if webchat broadcasts should be suppressed for heartbeat runs.
+ * Returns true if the run is a heartbeat and showOk is false.
+ */
+function shouldSuppressHeartbeatBroadcast(runId) {
+    const runContext = getAgentRunContext(runId);
+    if (!runContext?.isHeartbeat)
+        return false;
+    try {
+        const cfg = loadConfig();
+        const visibility = resolveHeartbeatVisibility({ cfg, channel: "webchat" });
+        return !visibility.showOk;
+    }
+    catch {
+        // Default to suppressing if we can't load config
+        return true;
+    }
+}
 export function createChatRunRegistry() {
     const chatRunSessions = new Map();
     const add = (sessionId, entry) => {
@@ -78,7 +98,10 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
                 timestamp: now,
             },
         };
-        broadcast("chat", payload, { dropIfSlow: true });
+        // Suppress webchat broadcast for heartbeat runs when showOk is false
+        if (!shouldSuppressHeartbeatBroadcast(clientRunId)) {
+            broadcast("chat", payload, { dropIfSlow: true });
+        }
         nodeSendToSession(sessionKey, "chat", payload);
     };
     const emitChatFinal = (sessionKey, clientRunId, seq, jobState, error) => {
@@ -99,7 +122,10 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
                     }
                     : undefined,
             };
-            broadcast("chat", payload);
+            // Suppress webchat broadcast for heartbeat runs when showOk is false
+            if (!shouldSuppressHeartbeatBroadcast(clientRunId)) {
+                broadcast("chat", payload);
+            }
             nodeSendToSession(sessionKey, "chat", payload);
             return;
         }

package/dist/gateway/server-constants.js

@@ -16,8 +16,8 @@ export const __setMaxChatHistoryMessagesBytesForTest = (value) => {
 };
 export const DEFAULT_HANDSHAKE_TIMEOUT_MS = 10_000;
 export const getHandshakeTimeoutMs = () => {
-    if (process.env.VITEST && process.env.PIGBOT_TEST_HANDSHAKE_TIMEOUT_MS) {
-        const parsed = Number(process.env.PIGBOT_TEST_HANDSHAKE_TIMEOUT_MS);
+    if (process.env.VITEST && process.env.CLAWDBOT_TEST_HANDSHAKE_TIMEOUT_MS) {
+        const parsed = Number(process.env.CLAWDBOT_TEST_HANDSHAKE_TIMEOUT_MS);
         if (Number.isFinite(parsed) && parsed > 0)
             return parsed;
     }

package/dist/gateway/server-cron.js

@@ -14,7 +14,7 @@ import { defaultRuntime } from "../runtime.js";
 export function buildGatewayCronService(params) {
     const cronLogger = getChildLogger({ module: "cron" });
     const storePath = resolveCronStorePath(params.cfg.cron?.store);
-    const cronEnabled = process.env.PIGBOT_SKIP_CRON !== "1" && params.cfg.cron?.enabled !== false;
+    const cronEnabled = process.env.CLAWDBOT_SKIP_CRON !== "1" && params.cfg.cron?.enabled !== false;
     const resolveCronAgent = (requested) => {
         const runtimeConfig = loadConfig();
         const normalized = typeof requested === "string" && requested.trim() ? normalizeAgentId(requested) : undefined;

package/dist/gateway/server-discovery-runtime.js

@@ -4,32 +4,40 @@ import { WIDE_AREA_DISCOVERY_DOMAIN, writeWideAreaGatewayZone } from "../infra/w
 import { formatBonjourInstanceName, resolveBonjourCliPath, resolveTailnetDnsHint, } from "./server-discovery.js";
 export async function startGatewayDiscovery(params) {
     let bonjourStop = null;
-    const bonjourEnabled = process.env.PIGBOT_DISABLE_BONJOUR !== "1" &&
+    const mdnsMode = params.mdnsMode ?? "minimal";
+    // mDNS can be disabled via config (mdnsMode: off) or env var.
+    const bonjourEnabled = mdnsMode !== "off" &&
+        process.env.CLAWDBOT_DISABLE_BONJOUR !== "1" &&
         process.env.NODE_ENV !== "test" &&
         !process.env.VITEST;
+    const mdnsMinimal = mdnsMode !== "full";
     const tailscaleEnabled = params.tailscaleMode !== "off";
     const needsTailnetDns = bonjourEnabled || params.wideAreaDiscoveryEnabled;
     const tailnetDns = needsTailnetDns
         ? await resolveTailnetDnsHint({ enabled: tailscaleEnabled })
         : undefined;
-    const sshPortEnv = process.env.PIGBOT_SSH_PORT?.trim();
+    const sshPortEnv = mdnsMinimal ? undefined : process.env.CLAWDBOT_SSH_PORT?.trim();
     const sshPortParsed = sshPortEnv ? Number.parseInt(sshPortEnv, 10) : NaN;
     const sshPort = Number.isFinite(sshPortParsed) && sshPortParsed > 0 ? sshPortParsed : undefined;
-    try {
-        const bonjour = await startGatewayBonjourAdvertiser({
-            instanceName: formatBonjourInstanceName(params.machineDisplayName),
-            gatewayPort: params.port,
-            gatewayTlsEnabled: params.gatewayTls?.enabled ?? false,
-            gatewayTlsFingerprintSha256: params.gatewayTls?.fingerprintSha256,
-            canvasPort: params.canvasPort,
-            sshPort,
-            tailnetDns,
-            cliPath: resolveBonjourCliPath(),
-        });
-        bonjourStop = bonjour.stop;
-    }
-    catch (err) {
-        params.logDiscovery.warn(`bonjour advertising failed: ${String(err)}`);
+    const cliPath = mdnsMinimal ? undefined : resolveBonjourCliPath();
+    if (bonjourEnabled) {
+        try {
+            const bonjour = await startGatewayBonjourAdvertiser({
+                instanceName: formatBonjourInstanceName(params.machineDisplayName),
+                gatewayPort: params.port,
+                gatewayTlsEnabled: params.gatewayTls?.enabled ?? false,
+                gatewayTlsFingerprintSha256: params.gatewayTls?.fingerprintSha256,
+                canvasPort: params.canvasPort,
+                sshPort,
+                tailnetDns,
+                cliPath,
+                minimal: mdnsMinimal,
+            });
+            bonjourStop = bonjour.stop;
+        }
+        catch (err) {
+            params.logDiscovery.warn(`bonjour advertising failed: ${String(err)}`);
+        }
     }
     if (params.wideAreaDiscoveryEnabled) {
         const tailnetIPv4 = pickPrimaryTailnetIPv4();

package/dist/gateway/server-discovery.js

@@ -5,14 +5,14 @@ import { runExec } from "../process/exec.js";
 export function formatBonjourInstanceName(displayName) {
     const trimmed = displayName.trim();
     if (!trimmed)
-        return "Pigbot";
-    if (/pigbot/i.test(trimmed))
+        return "Moltbot";
+    if (/moltbot/i.test(trimmed))
         return trimmed;
-    return `${trimmed} (Pigbot)`;
+    return `${trimmed} (Moltbot)`;
 }
 export function resolveBonjourCliPath(opts = {}) {
     const env = opts.env ?? process.env;
-    const envPath = env.PIGBOT_CLI_PATH?.trim();
+    const envPath = env.CLAWDBOT_CLI_PATH?.trim();
     if (envPath)
         return envPath;
     const statSync = opts.statSync ?? fs.statSync;
@@ -26,7 +26,7 @@ export function resolveBonjourCliPath(opts = {}) {
     };
     const execPath = opts.execPath ?? process.execPath;
     const execDir = path.dirname(execPath);
-    const siblingCli = path.join(execDir, "pigbot");
+    const siblingCli = path.join(execDir, "moltbot");
     if (isFile(siblingCli))
         return siblingCli;
     const argv = opts.argv ?? process.argv;
@@ -38,14 +38,14 @@ export function resolveBonjourCliPath(opts = {}) {
     const distCli = path.join(cwd, "dist", "index.js");
     if (isFile(distCli))
         return distCli;
-    const binCli = path.join(cwd, "bin", "pigbot.js");
+    const binCli = path.join(cwd, "bin", "moltbot.js");
     if (isFile(binCli))
         return binCli;
     return undefined;
 }
 export async function resolveTailnetDnsHint(opts) {
     const env = opts?.env ?? process.env;
-    const envRaw = env.PIGBOT_TAILNET_DNS?.trim();
+    const envRaw = env.CLAWDBOT_TAILNET_DNS?.trim();
     const envValue = envRaw && envRaw.length > 0 ? envRaw.replace(/\.$/, "") : "";
     if (envValue)
         return envValue;

package/dist/gateway/server-http.js

@@ -26,13 +26,18 @@ export function createHooksRequestHandler(opts) {
         if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`)) {
             return false;
         }
-        const token = extractHookToken(req, url);
+        const { token, fromQuery } = extractHookToken(req, url);
         if (!token || token !== hooksConfig.token) {
             res.statusCode = 401;
             res.setHeader("Content-Type", "text/plain; charset=utf-8");
             res.end("Unauthorized");
             return true;
         }
+        if (fromQuery) {
+            logHooks.warn("Hook token provided via query parameter is deprecated for security reasons. " +
+                "Tokens in URLs appear in logs, browser history, and referrer headers. " +
+                "Use Authorization: Bearer <token> or X-Moltbot-Token header instead.");
+        }
         if (req.method !== "POST") {
             res.statusCode = 405;
             res.setHeader("Allow", "POST");
@@ -117,6 +122,7 @@ export function createHooksRequestHandler(opts) {
                         model: mapped.action.model,
                         thinking: mapped.action.thinking,
                         timeoutSeconds: mapped.action.timeoutSeconds,
+                        allowUnsafeExternalContent: mapped.action.allowUnsafeExternalContent,
                     });
                     sendJson(res, 202, { ok: true, runId });
                     return true;
@@ -152,15 +158,15 @@ export function createGatewayHttpServer(opts) {
             const trustedProxies = configSnapshot.gateway?.trustedProxies ?? [];
             if (await handleHooksRequest(req, res))
                 return;
-            if (await handleSlackHttpRequest(req, res))
-                return;
-            if (handlePluginRequest && (await handlePluginRequest(req, res)))
-                return;
             if (await handleToolsInvokeHttpRequest(req, res, {
                 auth: resolvedAuth,
                 trustedProxies,
             }))
                 return;
+            if (await handleSlackHttpRequest(req, res))
+                return;
+            if (handlePluginRequest && (await handlePluginRequest(req, res)))
+                return;
             if (openResponsesEnabled) {
                 if (await handleOpenResponsesHttpRequest(req, res, {
                     auth: resolvedAuth,
@@ -198,10 +204,10 @@ export function createGatewayHttpServer(opts) {
             res.setHeader("Content-Type", "text/plain; charset=utf-8");
             res.end("Not Found");
         }
-        catch (err) {
+        catch {
             res.statusCode = 500;
             res.setHeader("Content-Type", "text/plain; charset=utf-8");
-            res.end(String(err));
+            res.end("Internal Server Error");
         }
     }
     return httpServer;

package/dist/gateway/server-methods/agent.js

@@ -155,6 +155,8 @@ export const agentHandlers = {
                 groupId: resolvedGroupId ?? entry?.groupId,
                 groupChannel: resolvedGroupChannel ?? entry?.groupChannel,
                 space: resolvedGroupSpace ?? entry?.space,
+                cliSessionIds: entry?.cliSessionIds,
+                claudeCliSessionId: entry?.claudeCliSessionId,
             };
             sessionEntry = nextEntry;
             const sendPolicy = resolveSendPolicy({