@gguf/pigbot 0.0.1 → 0.0.3

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

@@ -0,0 +1,204 @@
+import crypto from "node:crypto";
+import { createBrowserControlContext, startBrowserControlServiceFromConfig, } from "../../browser/control-service.js";
+import { createBrowserRouteDispatcher } from "../../browser/routes/dispatcher.js";
+import { loadConfig } from "../../config/config.js";
+import { saveMediaBuffer } from "../../media/store.js";
+import { isNodeCommandAllowed, resolveNodeCommandAllowlist } from "../node-command-policy.js";
+import { ErrorCodes, errorShape } from "../protocol/index.js";
+import { safeParseJson } from "./nodes.helpers.js";
+function isBrowserNode(node) {
+    const caps = Array.isArray(node.caps) ? node.caps : [];
+    const commands = Array.isArray(node.commands) ? node.commands : [];
+    return caps.includes("browser") || commands.includes("browser.proxy");
+}
+function normalizeNodeKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "");
+}
+function resolveBrowserNode(nodes, query) {
+    const q = query.trim();
+    if (!q)
+        return null;
+    const qNorm = normalizeNodeKey(q);
+    const matches = nodes.filter((node) => {
+        if (node.nodeId === q)
+            return true;
+        if (typeof node.remoteIp === "string" && node.remoteIp === q)
+            return true;
+        const name = typeof node.displayName === "string" ? node.displayName : "";
+        if (name && normalizeNodeKey(name) === qNorm)
+            return true;
+        if (q.length >= 6 && node.nodeId.startsWith(q))
+            return true;
+        return false;
+    });
+    if (matches.length === 1)
+        return matches[0] ?? null;
+    if (matches.length === 0)
+        return null;
+    throw new Error(`ambiguous node: ${q} (matches: ${matches
+        .map((node) => node.displayName || node.remoteIp || node.nodeId)
+        .join(", ")})`);
+}
+function resolveBrowserNodeTarget(params) {
+    const policy = params.cfg.gateway?.nodes?.browser;
+    const mode = policy?.mode ?? "auto";
+    if (mode === "off")
+        return null;
+    const browserNodes = params.nodes.filter((node) => isBrowserNode(node));
+    if (browserNodes.length === 0) {
+        if (policy?.node?.trim()) {
+            throw new Error("No connected browser-capable nodes.");
+        }
+        return null;
+    }
+    const requested = policy?.node?.trim() || "";
+    if (requested) {
+        const resolved = resolveBrowserNode(browserNodes, requested);
+        if (!resolved) {
+            throw new Error(`Configured browser node not connected: ${requested}`);
+        }
+        return resolved;
+    }
+    if (mode === "manual")
+        return null;
+    if (browserNodes.length === 1)
+        return browserNodes[0] ?? null;
+    return null;
+}
+async function persistProxyFiles(files) {
+    if (!files || files.length === 0)
+        return new Map();
+    const mapping = new Map();
+    for (const file of files) {
+        const buffer = Buffer.from(file.base64, "base64");
+        const saved = await saveMediaBuffer(buffer, file.mimeType, "browser", buffer.byteLength);
+        mapping.set(file.path, saved.path);
+    }
+    return mapping;
+}
+function applyProxyPaths(result, mapping) {
+    if (!result || typeof result !== "object")
+        return;
+    const obj = result;
+    if (typeof obj.path === "string" && mapping.has(obj.path)) {
+        obj.path = mapping.get(obj.path);
+    }
+    if (typeof obj.imagePath === "string" && mapping.has(obj.imagePath)) {
+        obj.imagePath = mapping.get(obj.imagePath);
+    }
+    const download = obj.download;
+    if (download && typeof download === "object") {
+        const d = download;
+        if (typeof d.path === "string" && mapping.has(d.path)) {
+            d.path = mapping.get(d.path);
+        }
+    }
+}
+export const browserHandlers = {
+    "browser.request": async ({ params, respond, context }) => {
+        const typed = params;
+        const methodRaw = typeof typed.method === "string" ? typed.method.trim().toUpperCase() : "";
+        const path = typeof typed.path === "string" ? typed.path.trim() : "";
+        const query = typed.query && typeof typed.query === "object" ? typed.query : undefined;
+        const body = typed.body;
+        const timeoutMs = typeof typed.timeoutMs === "number" && Number.isFinite(typed.timeoutMs)
+            ? Math.max(1, Math.floor(typed.timeoutMs))
+            : undefined;
+        if (!methodRaw || !path) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "method and path are required"));
+            return;
+        }
+        if (methodRaw !== "GET" && methodRaw !== "POST" && methodRaw !== "DELETE") {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "method must be GET, POST, or DELETE"));
+            return;
+        }
+        const cfg = loadConfig();
+        let nodeTarget = null;
+        try {
+            nodeTarget = resolveBrowserNodeTarget({
+                cfg,
+                nodes: context.nodeRegistry.listConnected(),
+            });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+            return;
+        }
+        if (nodeTarget) {
+            const allowlist = resolveNodeCommandAllowlist(cfg, nodeTarget);
+            const allowed = isNodeCommandAllowed({
+                command: "browser.proxy",
+                declaredCommands: nodeTarget.commands,
+                allowlist,
+            });
+            if (!allowed.ok) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "node command not allowed", {
+                    details: { reason: allowed.reason, command: "browser.proxy" },
+                }));
+                return;
+            }
+            const proxyParams = {
+                method: methodRaw,
+                path,
+                query,
+                body,
+                timeoutMs,
+                profile: typeof query?.profile === "string" ? query.profile : undefined,
+            };
+            const res = await context.nodeRegistry.invoke({
+                nodeId: nodeTarget.nodeId,
+                command: "browser.proxy",
+                params: proxyParams,
+                timeoutMs,
+                idempotencyKey: crypto.randomUUID(),
+            });
+            if (!res.ok) {
+                respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, res.error?.message ?? "node invoke failed", {
+                    details: { nodeError: res.error ?? null },
+                }));
+                return;
+            }
+            const payload = res.payloadJSON ? safeParseJson(res.payloadJSON) : res.payload;
+            const proxy = payload && typeof payload === "object" ? payload : null;
+            if (!proxy || !("result" in proxy)) {
+                respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "browser proxy failed"));
+                return;
+            }
+            const mapping = await persistProxyFiles(proxy.files);
+            applyProxyPaths(proxy.result, mapping);
+            respond(true, proxy.result);
+            return;
+        }
+        const ready = await startBrowserControlServiceFromConfig();
+        if (!ready) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "browser control is disabled"));
+            return;
+        }
+        let dispatcher;
+        try {
+            dispatcher = createBrowserRouteDispatcher(createBrowserControlContext());
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+            return;
+        }
+        const result = await dispatcher.dispatch({
+            method: methodRaw,
+            path,
+            query,
+            body,
+        });
+        if (result.status >= 400) {
+            const message = result.body && typeof result.body === "object" && "error" in result.body
+                ? String(result.body.error)
+                : `browser request failed (${result.status})`;
+            const code = result.status >= 500 ? ErrorCodes.UNAVAILABLE : ErrorCodes.INVALID_REQUEST;
+            respond(false, undefined, errorShape(code, message, { details: result.body }));
+            return;
+        }
+        respond(true, result.body);
+    },
+};

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

@@ -223,6 +223,11 @@ export const chatHandlers = {
                     : undefined,
         }))
             .filter((a) => a.content) ?? [];
+        const rawMessage = p.message.trim();
+        if (!rawMessage && normalizedAttachments.length === 0) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "message or attachment required"));
+            return;
+        }
         let parsedMessage = p.message;
         let parsedImages = [];
         if (normalizedAttachments.length > 0) {

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

@@ -1,12 +1,12 @@
 import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agents/agent-scope.js";
-import { CONFIG_PATH_PIGBOT, loadConfig, parseConfigJson5, readConfigFileSnapshot, resolveConfigSnapshotHash, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.js";
+import { CONFIG_PATH, loadConfig, parseConfigJson5, readConfigFileSnapshot, resolveConfigSnapshotHash, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.js";
 import { applyLegacyMigrations } from "../../config/legacy.js";
 import { applyMergePatch } from "../../config/merge-patch.js";
 import { buildConfigSchema } from "../../config/schema.js";
 import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
 import { formatDoctorNonInteractiveHint, writeRestartSentinel, } from "../../infra/restart-sentinel.js";
 import { listChannelPlugins } from "../../channels/plugins/index.js";
-import { loadPigbotPlugins } from "../../plugins/loader.js";
+import { loadMoltbotPlugins } from "../../plugins/loader.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateConfigApplyParams, validateConfigGetParams, validateConfigPatchParams, validateConfigSchemaParams, validateConfigSetParams, } from "../protocol/index.js";
 function resolveBaseHash(params) {
     const raw = params?.baseHash;
@@ -50,7 +50,7 @@ export const configHandlers = {
         }
         const cfg = loadConfig();
         const workspaceDir = resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg));
-        const pluginRegistry = loadPigbotPlugins({
+        const pluginRegistry = loadMoltbotPlugins({
             config: cfg,
             workspaceDir,
             logger: {
@@ -107,7 +107,7 @@ export const configHandlers = {
         await writeConfigFile(validated.config);
         respond(true, {
             ok: true,
-            path: CONFIG_PATH_PIGBOT,
+            path: CONFIG_PATH,
             config: validated.config,
         }, undefined);
     },
@@ -170,7 +170,7 @@ export const configHandlers = {
             doctorHint: formatDoctorNonInteractiveHint(),
             stats: {
                 mode: "config.patch",
-                root: CONFIG_PATH_PIGBOT,
+                root: CONFIG_PATH,
             },
         };
         let sentinelPath = null;
@@ -186,7 +186,7 @@ export const configHandlers = {
         });
         respond(true, {
             ok: true,
-            path: CONFIG_PATH_PIGBOT,
+            path: CONFIG_PATH,
             config: validated.config,
             restart,
             sentinel: {
@@ -241,7 +241,7 @@ export const configHandlers = {
             doctorHint: formatDoctorNonInteractiveHint(),
             stats: {
                 mode: "config.apply",
-                root: CONFIG_PATH_PIGBOT,
+                root: CONFIG_PATH,
             },
         };
         let sentinelPath = null;
@@ -257,7 +257,7 @@ export const configHandlers = {
         });
         respond(true, {
             ok: true,
-            path: CONFIG_PATH_PIGBOT,
+            path: CONFIG_PATH,
             config: validated.config,
             restart,
             sentinel: {

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

@@ -6,7 +6,7 @@ const DEFAULT_LIMIT = 500;
 const DEFAULT_MAX_BYTES = 250_000;
 const MAX_LIMIT = 5000;
 const MAX_BYTES = 1_000_000;
-const ROLLING_LOG_RE = /^pigbot-\d{4}-\d{2}-\d{2}\.log$/;
+const ROLLING_LOG_RE = /^moltbot-\d{4}-\d{2}-\d{2}\.log$/;
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }

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

@@ -21,9 +21,9 @@ function listWorkspaceDirs(cfg) {
 function collectSkillBins(entries) {
     const bins = new Set();
     for (const entry of entries) {
-        const required = entry.pigbot?.requires?.bins ?? [];
-        const anyBins = entry.pigbot?.requires?.anyBins ?? [];
-        const install = entry.pigbot?.install ?? [];
+        const required = entry.metadata?.requires?.bins ?? [];
+        const anyBins = entry.metadata?.requires?.anyBins ?? [];
+        const install = entry.metadata?.install ?? [];
         for (const bin of required) {
             const trimmed = bin.trim();
             if (trimmed)

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

@@ -1,4 +1,4 @@
-import { resolvePigbotPackageRoot } from "../../infra/pigbot-root.js";
+import { resolveMoltbotPackageRoot } from "../../infra/moltbot-root.js";
 import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
 import { formatDoctorNonInteractiveHint, writeRestartSentinel, } from "../../infra/restart-sentinel.js";
 import { runGatewayUpdate } from "../../infra/update-runner.js";
@@ -25,7 +25,7 @@ export const updateHandlers = {
             : undefined;
         let result;
         try {
-            const root = (await resolvePigbotPackageRoot({
+            const root = (await resolveMoltbotPackageRoot({
                 moduleUrl: import.meta.url,
                 argv1: process.argv[1],
                 cwd: process.cwd(),

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

@@ -76,6 +76,7 @@ const BASE_METHODS = [
     "agent",
     "agent.identity.get",
     "agent.wait",
+    "browser.request",
     // WebChat WebSocket-native chat methods
     "chat.history",
     "chat.abort",

package/dist/gateway/server-methods.js

@@ -1,6 +1,7 @@
 import { ErrorCodes, errorShape } from "./protocol/index.js";
 import { agentHandlers } from "./server-methods/agent.js";
 import { agentsHandlers } from "./server-methods/agents.js";
+import { browserHandlers } from "./server-methods/browser.js";
 import { channelsHandlers } from "./server-methods/channels.js";
 import { chatHandlers } from "./server-methods/chat.js";
 import { configHandlers } from "./server-methods/config.js";
@@ -83,6 +84,7 @@ const WRITE_METHODS = new Set([
     "node.invoke",
     "chat.send",
     "chat.abort",
+    "browser.request",
 ]);
 function authorizeGatewayMethod(method, client) {
     if (!client?.connect)
@@ -168,6 +170,7 @@ export const coreGatewayHandlers = {
     ...usageHandlers,
     ...agentHandlers,
     ...agentsHandlers,
+    ...browserHandlers,
 };
 export async function handleGatewayRequest(opts) {
     const { req, respond, client, isWebchatConnect, context } = opts;

package/dist/gateway/server-plugins.js

@@ -1,6 +1,6 @@
-import { loadPigbotPlugins } from "../plugins/loader.js";
+import { loadMoltbotPlugins } from "../plugins/loader.js";
 export function loadGatewayPlugins(params) {
-    const pluginRegistry = loadPigbotPlugins({
+    const pluginRegistry = loadMoltbotPlugins({
         config: params.cfg,
         workspaceDir: params.workspaceDir,
         logger: {

package/dist/gateway/server-reload-handlers.js

@@ -48,7 +48,7 @@ export function createGatewayReloadHandlers(params) {
         }
         if (plan.restartGmailWatcher) {
             await stopGmailWatcher().catch(() => { });
-            if (!isTruthyEnvValue(process.env.PIGBOT_SKIP_GMAIL_WATCHER)) {
+            if (!isTruthyEnvValue(process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
                 try {
                     const gmailResult = await startGmailWatcher(nextConfig);
                     if (gmailResult.started) {
@@ -65,13 +65,13 @@ export function createGatewayReloadHandlers(params) {
                 }
             }
             else {
-                params.logHooks.info("skipping gmail watcher restart (PIGBOT_SKIP_GMAIL_WATCHER=1)");
+                params.logHooks.info("skipping gmail watcher restart (CLAWDBOT_SKIP_GMAIL_WATCHER=1)");
             }
         }
         if (plan.restartChannels.size > 0) {
-            if (isTruthyEnvValue(process.env.PIGBOT_SKIP_CHANNELS) ||
-                isTruthyEnvValue(process.env.PIGBOT_SKIP_PROVIDERS)) {
-                params.logChannels.info("skipping channel reload (PIGBOT_SKIP_CHANNELS=1 or PIGBOT_SKIP_PROVIDERS=1)");
+            if (isTruthyEnvValue(process.env.CLAWDBOT_SKIP_CHANNELS) ||
+                isTruthyEnvValue(process.env.CLAWDBOT_SKIP_PROVIDERS)) {
+                params.logChannels.info("skipping channel reload (CLAWDBOT_SKIP_CHANNELS=1 or CLAWDBOT_SKIP_PROVIDERS=1)");
             }
             else {
                 const restartChannel = async (name) => {

package/dist/gateway/server-restart-sentinel.js

@@ -21,10 +21,14 @@ export async function scheduleRestartSentinelWake(params) {
         enqueueSystemEvent(message, { sessionKey: mainSessionKey });
         return;
     }
-    const threadMarker = ":thread:";
-    const threadIndex = sessionKey.lastIndexOf(threadMarker);
-    const baseSessionKey = threadIndex === -1 ? sessionKey : sessionKey.slice(0, threadIndex);
-    const threadIdRaw = threadIndex === -1 ? undefined : sessionKey.slice(threadIndex + threadMarker.length);
+    // Extract topic/thread ID from sessionKey (supports both :topic: and :thread:)
+    // Telegram uses :topic:, other platforms use :thread:
+    const topicIndex = sessionKey.lastIndexOf(":topic:");
+    const threadIndex = sessionKey.lastIndexOf(":thread:");
+    const markerIndex = Math.max(topicIndex, threadIndex);
+    const marker = topicIndex > threadIndex ? ":topic:" : ":thread:";
+    const baseSessionKey = markerIndex === -1 ? sessionKey : sessionKey.slice(0, markerIndex);
+    const threadIdRaw = markerIndex === -1 ? undefined : sessionKey.slice(markerIndex + marker.length);
     const sessionThreadId = threadIdRaw?.trim() || undefined;
     const { cfg, entry } = loadSessionEntry(sessionKey);
     const parsedTarget = resolveAnnounceTargetFromKey(baseSessionKey);
@@ -32,7 +36,7 @@ export async function scheduleRestartSentinelWake(params) {
     // Handles race condition where store wasn't flushed before restart
     const sentinelContext = payload.deliveryContext;
     let sessionDeliveryContext = deliveryContextFromSession(entry);
-    if (!sessionDeliveryContext && threadIndex !== -1 && baseSessionKey) {
+    if (!sessionDeliveryContext && markerIndex !== -1 && baseSessionKey) {
         const { entry: baseEntry } = loadSessionEntry(baseSessionKey);
         sessionDeliveryContext = deliveryContextFromSession(baseEntry);
     }
@@ -56,6 +60,7 @@ export async function scheduleRestartSentinelWake(params) {
         return;
     }
     const threadId = payload.threadId ??
+        parsedTarget?.threadId ?? // From resolveAnnounceTargetFromKey (extracts :topic:N)
         sessionThreadId ??
         (origin?.threadId != null ? String(origin.threadId) : undefined);
     try {

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

@@ -32,17 +32,20 @@ export async function resolveGatewayRuntimeConfig(params) {
         tailscaleMode,
     });
     const authMode = resolvedAuth.mode;
+    const hasToken = typeof resolvedAuth.token === "string" && resolvedAuth.token.trim().length > 0;
+    const hasPassword = typeof resolvedAuth.password === "string" && resolvedAuth.password.trim().length > 0;
+    const hasSharedSecret = (authMode === "token" && hasToken) || (authMode === "password" && hasPassword);
     const hooksConfig = resolveHooksConfig(params.cfg);
-    const canvasHostEnabled = process.env.PIGBOT_SKIP_CANVAS_HOST !== "1" && params.cfg.canvasHost?.enabled !== false;
+    const canvasHostEnabled = process.env.CLAWDBOT_SKIP_CANVAS_HOST !== "1" && params.cfg.canvasHost?.enabled !== false;
     assertGatewayAuthConfigured(resolvedAuth);
     if (tailscaleMode === "funnel" && authMode !== "password") {
-        throw new Error("tailscale funnel requires gateway auth mode=password (set gateway.auth.password or PIGBOT_GATEWAY_PASSWORD)");
+        throw new Error("tailscale funnel requires gateway auth mode=password (set gateway.auth.password or CLAWDBOT_GATEWAY_PASSWORD)");
     }
     if (tailscaleMode !== "off" && !isLoopbackHost(bindHost)) {
         throw new Error("tailscale serve/funnel requires gateway bind=loopback (127.0.0.1)");
     }
-    if (!isLoopbackHost(bindHost) && authMode === "none") {
-        throw new Error(`refusing to bind gateway to ${bindHost}:${params.port} without auth (set gateway.auth.token or PIGBOT_GATEWAY_TOKEN, or pass --token)`);
+    if (!isLoopbackHost(bindHost) && !hasSharedSecret) {
+        throw new Error(`refusing to bind gateway to ${bindHost}:${params.port} without auth (set gateway.auth.token/password, or set CLAWDBOT_GATEWAY_TOKEN/CLAWDBOT_GATEWAY_PASSWORD)`);
     }
     return {
         bindHost,

package/dist/gateway/server-startup.js

@@ -18,7 +18,7 @@ export async function startGatewaySidecars(params) {
         params.logBrowser.error(`server failed to start: ${String(err)}`);
     }
     // Start Gmail watcher if configured (hooks.gmail.account).
-    if (!isTruthyEnvValue(process.env.PIGBOT_SKIP_GMAIL_WATCHER)) {
+    if (!isTruthyEnvValue(process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
         try {
             const gmailResult = await startGmailWatcher(params.cfg);
             if (gmailResult.started) {
@@ -75,9 +75,9 @@ export async function startGatewaySidecars(params) {
         params.logHooks.error(`failed to load hooks: ${String(err)}`);
     }
     // Launch configured channels so gateway replies via the surface the message came from.
-    // Tests can opt out via PIGBOT_SKIP_CHANNELS (or legacy PIGBOT_SKIP_PROVIDERS).
-    const skipChannels = isTruthyEnvValue(process.env.PIGBOT_SKIP_CHANNELS) ||
-        isTruthyEnvValue(process.env.PIGBOT_SKIP_PROVIDERS);
+    // Tests can opt out via CLAWDBOT_SKIP_CHANNELS (or legacy CLAWDBOT_SKIP_PROVIDERS).
+    const skipChannels = isTruthyEnvValue(process.env.CLAWDBOT_SKIP_CHANNELS) ||
+        isTruthyEnvValue(process.env.CLAWDBOT_SKIP_PROVIDERS);
     if (!skipChannels) {
         try {
             await params.startChannels();
@@ -87,7 +87,7 @@ export async function startGatewaySidecars(params) {
         }
     }
     else {
-        params.logChannels.info("skipping channel start (PIGBOT_SKIP_CHANNELS=1 or PIGBOT_SKIP_PROVIDERS=1)");
+        params.logChannels.info("skipping channel start (CLAWDBOT_SKIP_CHANNELS=1 or CLAWDBOT_SKIP_PROVIDERS=1)");
     }
     if (params.cfg.hooks?.internal?.enabled) {
         setTimeout(() => {

package/dist/gateway/server.impl.js

@@ -4,14 +4,15 @@ import { registerSkillsChangeListener } from "../agents/skills/refresh.js";
 import { listChannelPlugins } from "../channels/plugins/index.js";
 import { createDefaultDeps } from "../cli/deps.js";
 import { formatCliCommand } from "../cli/command-format.js";
-import { CONFIG_PATH_PIGBOT, isNixMode, loadConfig, migrateLegacyConfig, readConfigFileSnapshot, writeConfigFile, } from "../config/config.js";
+import { CONFIG_PATH, isNixMode, loadConfig, migrateLegacyConfig, readConfigFileSnapshot, writeConfigFile, } from "../config/config.js";
 import { isDiagnosticsEnabled } from "../infra/diagnostic-events.js";
+import { logAcceptedEnvOption } from "../infra/env.js";
 import { applyPluginAutoEnable } from "../config/plugin-auto-enable.js";
 import { clearAgentRunContext, onAgentEvent } from "../infra/agent-events.js";
 import { onHeartbeatEvent } from "../infra/heartbeat-events.js";
 import { startHeartbeatRunner } from "../infra/heartbeat-runner.js";
 import { getMachineDisplayName } from "../infra/machine-name.js";
-import { ensurePigbotCliOnPath } from "../infra/path-env.js";
+import { ensureMoltbotCliOnPath } from "../infra/path-env.js";
 import { primeRemoteSkillsCache, refreshRemoteBinsForConnectedNodes, setSkillsRemoteRegistry, } from "../infra/skills-remote.js";
 import { scheduleGatewayUpdateCheck } from "../infra/update-startup.js";
 import { setGatewaySigusr1RestartPolicy } from "../infra/restart.js";
@@ -49,7 +50,7 @@ import { loadGatewayTlsRuntime } from "./server/tls.js";
 import { createWizardSessionTracker } from "./server-wizard-sessions.js";
 import { attachGatewayWsHandlers } from "./server-ws-runtime.js";
 export { __resetModelCatalogCacheForTest } from "./server-model-catalog.js";
-ensurePigbotCliOnPath();
+ensureMoltbotCliOnPath();
 const log = createSubsystemLogger("gateway");
 const logCanvas = log.child("canvas");
 const logDiscovery = log.child("discovery");
@@ -65,7 +66,15 @@ const logWsControl = log.child("ws");
 const canvasRuntime = runtimeForLogger(logCanvas);
 export async function startGatewayServer(port = 18789, opts = {}) {
     // Ensure all default port derivations (browser/canvas) see the actual runtime port.
-    process.env.PIGBOT_GATEWAY_PORT = String(port);
+    process.env.CLAWDBOT_GATEWAY_PORT = String(port);
+    logAcceptedEnvOption({
+        key: "CLAWDBOT_RAW_STREAM",
+        description: "raw stream logging enabled",
+    });
+    logAcceptedEnvOption({
+        key: "CLAWDBOT_RAW_STREAM_PATH",
+        description: "raw stream log path override",
+    });
     let configSnapshot = await readConfigFileSnapshot();
     if (configSnapshot.legacyIssues.length > 0) {
         if (isNixMode) {
@@ -73,7 +82,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
         }
         const { config: migrated, changes } = migrateLegacyConfig(configSnapshot.parsed);
         if (!migrated) {
-            throw new Error(`Legacy config entries detected but auto-migration failed. Run "${formatCliCommand("pigbot doctor")}" to migrate.`);
+            throw new Error(`Legacy config entries detected but auto-migration failed. Run "${formatCliCommand("moltbot doctor")}" to migrate.`);
         }
         await writeConfigFile(migrated);
         if (changes.length > 0) {
@@ -89,7 +98,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
                 .map((issue) => `${issue.path || "<root>"}: ${issue.message}`)
                 .join("\n")
             : "Unknown validation issue.";
-        throw new Error(`Invalid config at ${configSnapshot.path}.\n${issues}\nRun "${formatCliCommand("pigbot doctor")}" to repair, then retry.`);
+        throw new Error(`Invalid config at ${configSnapshot.path}.\n${issues}\nRun "${formatCliCommand("moltbot doctor")}" to repair, then retry.`);
     }
     const autoEnable = applyPluginAutoEnable({ config: configSnapshot.config, env: process.env });
     if (autoEnable.changes.length > 0) {
@@ -208,6 +217,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
             : undefined,
         wideAreaDiscoveryEnabled: cfgAtStart.discovery?.wideArea?.enabled === true,
         tailscaleMode,
+        mdnsMode: cfgAtStart.discovery?.mdns?.mode,
         logDiscovery,
     });
     bonjourStop = discovery.bonjourStop;
@@ -384,7 +394,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
             warn: (msg) => logReload.warn(msg),
             error: (msg) => logReload.error(msg),
         },
-        watchPath: CONFIG_PATH_PIGBOT,
+        watchPath: CONFIG_PATH,
     });
     const close = createGatewayCloseHandler({
         bonjourStop,

package/dist/gateway/session-utils.fs.js

@@ -36,7 +36,7 @@ export function resolveSessionTranscriptCandidates(sessionId, storePath, session
     if (agentId) {
         candidates.push(resolveSessionTranscriptPath(sessionId, agentId));
     }
-    candidates.push(path.join(os.homedir(), ".pigbot", "sessions", `${sessionId}.jsonl`));
+    candidates.push(path.join(os.homedir(), ".clawdbot", "sessions", `${sessionId}.jsonl`));
     return candidates;
 }
 export function archiveFileOnDisk(filePath, reason) {

package/dist/gateway/session-utils.js

@@ -304,6 +304,25 @@ export function resolveGatewaySessionStoreTarget(params) {
         storeKeys: Array.from(storeKeys),
     };
 }
+// Merge with existing entry based on latest timestamp to ensure data consistency and avoid overwriting with less complete data.
+function mergeSessionEntryIntoCombined(params) {
+    const { combined, entry, agentId, canonicalKey } = params;
+    const existing = combined[canonicalKey];
+    if (existing && (existing.updatedAt ?? 0) > (entry.updatedAt ?? 0)) {
+        combined[canonicalKey] = {
+            ...entry,
+            ...existing,
+            spawnedBy: canonicalizeSpawnedByForAgent(agentId, existing.spawnedBy ?? entry.spawnedBy),
+        };
+    }
+    else {
+        combined[canonicalKey] = {
+            ...existing,
+            ...entry,
+            spawnedBy: canonicalizeSpawnedByForAgent(agentId, entry.spawnedBy ?? existing?.spawnedBy),
+        };
+    }
+}
 export function loadCombinedSessionStoreForGateway(cfg) {
     const storeConfig = cfg.session?.store;
     if (storeConfig && !isStorePathTemplate(storeConfig)) {
@@ -313,10 +332,12 @@ export function loadCombinedSessionStoreForGateway(cfg) {
         const combined = {};
         for (const [key, entry] of Object.entries(store)) {
             const canonicalKey = canonicalizeSessionKeyForAgent(defaultAgentId, key);
-            combined[canonicalKey] = {
-                ...entry,
-                spawnedBy: canonicalizeSpawnedByForAgent(defaultAgentId, entry.spawnedBy),
-            };
+            mergeSessionEntryIntoCombined({
+                combined,
+                entry,
+                agentId: defaultAgentId,
+                canonicalKey,
+            });
         }
         return { storePath, store: combined };
     }
@@ -327,13 +348,12 @@ export function loadCombinedSessionStoreForGateway(cfg) {
         const store = loadSessionStore(storePath);
         for (const [key, entry] of Object.entries(store)) {
             const canonicalKey = canonicalizeSessionKeyForAgent(agentId, key);
-            // Merge with existing entry if present (avoid overwriting with less complete data)
-            const existing = combined[canonicalKey];
-            combined[canonicalKey] = {
-                ...existing,
-                ...entry,
-                spawnedBy: canonicalizeSpawnedByForAgent(agentId, entry.spawnedBy ?? existing?.spawnedBy),
-            };
+            mergeSessionEntryIntoCombined({
+                combined,
+                entry,
+                agentId,
+                canonicalKey,
+            });
         }
     }
     const storePath = typeof storeConfig === "string" && storeConfig.trim() ? storeConfig.trim() : "(multiple)";