@gguf/pigbot 0.0.6 → 0.0.7

package/dist/infra/tailscale.js

@@ -263,7 +263,7 @@ export async function ensureFunnel(port, exec = runExec, runtime = defaultRuntim
             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 Moltbot. You can keep running the web gateway without it: \`${formatCliCommand("moltbot gateway")}\``));
+        runtime.error(info(`Tip: Funnel is optional for OpenClaw. You can keep running the web gateway without it: \`${formatCliCommand("openclaw gateway")}\``));
         if (shouldLogVerbose()) {
             const rich = isRich();
             if (stdout.trim()) {

package/dist/infra/tls/gateway.js

@@ -36,7 +36,7 @@ async function generateSelfSignedCert(params) {
         "-out",
         params.certPath,
         "-subj",
-        "/CN=moltbot-gateway",
+        "/CN=openclaw-gateway",
     ]);
     await fs.chmod(params.keyPath, 0o600).catch(() => { });
     await fs.chmod(params.certPath, 0o600).catch(() => { });

package/dist/infra/unhandled-rejections.js

@@ -1,22 +1,14 @@
 import process from "node:process";
-import { formatUncaughtError } from "./errors.js";
+import { extractErrorCode, formatUncaughtError } from "./errors.js";
 const handlers = new Set();
-/**
- * Checks if an error is an AbortError.
- * These are typically intentional cancellations (e.g., during shutdown) and shouldn't crash.
- */
-export function isAbortError(err) {
-    if (!err || typeof err !== "object")
-        return false;
-    const name = "name" in err ? String(err.name) : "";
-    if (name === "AbortError")
-        return true;
-    // Check for "This operation was aborted" message from Node's undici
-    const message = "message" in err && typeof err.message === "string" ? err.message : "";
-    if (message === "This operation was aborted")
-        return true;
-    return false;
-}
+const FATAL_ERROR_CODES = new Set([
+    "ERR_OUT_OF_MEMORY",
+    "ERR_SCRIPT_EXECUTION_TIMEOUT",
+    "ERR_WORKER_OUT_OF_MEMORY",
+    "ERR_WORKER_UNCAUGHT_EXCEPTION",
+    "ERR_WORKER_INITIALIZATION_FAILED",
+]);
+const CONFIG_ERROR_CODES = new Set(["INVALID_CONFIG", "MISSING_API_KEY", "MISSING_CREDENTIALS"]);
 // Network error codes that indicate transient failures (shouldn't crash the gateway)
 const TRANSIENT_NETWORK_CODES = new Set([
     "ECONNRESET",
@@ -30,21 +22,47 @@ const TRANSIENT_NETWORK_CODES = new Set([
     "ENETUNREACH",
     "EAI_AGAIN",
     "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_DNS_RESOLVE_FAILED",
+    "UND_ERR_CONNECT",
     "UND_ERR_SOCKET",
     "UND_ERR_HEADERS_TIMEOUT",
     "UND_ERR_BODY_TIMEOUT",
 ]);
-function getErrorCode(err) {
-    if (!err || typeof err !== "object")
-        return undefined;
-    const code = err.code;
-    return typeof code === "string" ? code : undefined;
-}
 function getErrorCause(err) {
     if (!err || typeof err !== "object")
         return undefined;
     return err.cause;
 }
+function extractErrorCodeWithCause(err) {
+    const direct = extractErrorCode(err);
+    if (direct)
+        return direct;
+    return extractErrorCode(getErrorCause(err));
+}
+/**
+ * Checks if an error is an AbortError.
+ * These are typically intentional cancellations (e.g., during shutdown) and shouldn't crash.
+ */
+export function isAbortError(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    const name = "name" in err ? String(err.name) : "";
+    if (name === "AbortError")
+        return true;
+    // Check for "This operation was aborted" message from Node's undici
+    const message = "message" in err && typeof err.message === "string" ? err.message : "";
+    if (message === "This operation was aborted")
+        return true;
+    return false;
+}
+function isFatalError(err) {
+    const code = extractErrorCodeWithCause(err);
+    return code !== undefined && FATAL_ERROR_CODES.has(code);
+}
+function isConfigError(err) {
+    const code = extractErrorCodeWithCause(err);
+    return code !== undefined && CONFIG_ERROR_CODES.has(code);
+}
 /**
  * Checks if an error is a transient network error that shouldn't crash the gateway.
  * These are typically temporary connectivity issues that will resolve on their own.
@@ -52,17 +70,14 @@ function getErrorCause(err) {
 export function isTransientNetworkError(err) {
     if (!err)
         return false;
-    // Check the error itself
-    const code = getErrorCode(err);
+    const code = extractErrorCodeWithCause(err);
     if (code && TRANSIENT_NETWORK_CODES.has(code))
         return true;
     // "fetch failed" TypeError from undici (Node's native fetch)
     if (err instanceof TypeError && err.message === "fetch failed") {
         const cause = getErrorCause(err);
-        // The cause often contains the actual network error
         if (cause)
             return isTransientNetworkError(cause);
-        // Even without a cause, "fetch failed" is typically a network issue
         return true;
     }
     // Check the cause chain recursively
@@ -89,7 +104,7 @@ export function isUnhandledRejectionHandled(reason) {
                 return true;
         }
         catch (err) {
-            console.error("[moltbot] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+            console.error("[openclaw] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
         }
     }
     return false;
@@ -101,16 +116,24 @@ export function installUnhandledRejectionHandler() {
         // AbortError is typically an intentional cancellation (e.g., during shutdown)
         // Log it but don't crash - these are expected during graceful shutdown
         if (isAbortError(reason)) {
-            console.warn("[moltbot] Suppressed AbortError:", formatUncaughtError(reason));
+            console.warn("[openclaw] Suppressed AbortError:", formatUncaughtError(reason));
+            return;
+        }
+        if (isFatalError(reason)) {
+            console.error("[openclaw] FATAL unhandled rejection:", formatUncaughtError(reason));
+            process.exit(1);
+            return;
+        }
+        if (isConfigError(reason)) {
+            console.error("[openclaw] CONFIGURATION ERROR - requires fix:", formatUncaughtError(reason));
+            process.exit(1);
             return;
         }
-        // Transient network errors (fetch failed, connection reset, etc.) shouldn't crash
-        // These are temporary connectivity issues that will resolve on their own
         if (isTransientNetworkError(reason)) {
-            console.error("[moltbot] Network error (non-fatal):", formatUncaughtError(reason));
+            console.warn("[openclaw] Non-fatal unhandled rejection (continuing):", formatUncaughtError(reason));
             return;
         }
-        console.error("[moltbot] Unhandled promise rejection:", formatUncaughtError(reason));
+        console.error("[openclaw] Unhandled promise rejection:", formatUncaughtError(reason));
         process.exit(1);
     });
 }

package/dist/infra/update-check.js

@@ -214,7 +214,7 @@ export async function fetchNpmTagVersion(params) {
     const timeoutMs = params?.timeoutMs ?? 3500;
     const tag = params.tag;
     try {
-        const res = await fetchWithTimeout(`https://registry.npmjs.org/moltbot/${encodeURIComponent(tag)}`, timeoutMs);
+        const res = await fetchWithTimeout(`https://registry.npmjs.org/openclaw/${encodeURIComponent(tag)}`, timeoutMs);
         if (!res.ok) {
             return { tag, version: null, error: `HTTP ${res.status}` };
         }

package/dist/infra/update-global.js

@@ -1,6 +1,8 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+const PRIMARY_PACKAGE_NAME = "openclaw";
+const ALL_PACKAGE_NAMES = [PRIMARY_PACKAGE_NAME];
 async function pathExists(targetPath) {
     try {
         await fs.access(targetPath);
@@ -36,7 +38,7 @@ export async function resolveGlobalPackageRoot(manager, runCommand, timeoutMs) {
     const root = await resolveGlobalRoot(manager, runCommand, timeoutMs);
     if (!root)
         return null;
-    return path.join(root, "moltbot");
+    return path.join(root, PRIMARY_PACKAGE_NAME);
 }
 export async function detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs) {
     const pkgReal = await tryRealpath(pkgRoot);
@@ -52,15 +54,19 @@ export async function detectGlobalInstallManagerForRoot(runCommand, pkgRoot, tim
         if (!globalRoot)
             continue;
         const globalReal = await tryRealpath(globalRoot);
-        const expected = path.join(globalReal, "moltbot");
-        if (path.resolve(expected) === path.resolve(pkgReal))
-            return manager;
+        for (const name of ALL_PACKAGE_NAMES) {
+            const expected = path.join(globalReal, name);
+            if (path.resolve(expected) === path.resolve(pkgReal))
+                return manager;
+        }
     }
     const bunGlobalRoot = resolveBunGlobalRoot();
     const bunGlobalReal = await tryRealpath(bunGlobalRoot);
-    const bunExpected = path.join(bunGlobalReal, "moltbot");
-    if (path.resolve(bunExpected) === path.resolve(pkgReal))
-        return "bun";
+    for (const name of ALL_PACKAGE_NAMES) {
+        const bunExpected = path.join(bunGlobalReal, name);
+        if (path.resolve(bunExpected) === path.resolve(pkgReal))
+            return "bun";
+    }
     return null;
 }
 export async function detectGlobalInstallManagerByPresence(runCommand, timeoutMs) {
@@ -68,12 +74,16 @@ export async function detectGlobalInstallManagerByPresence(runCommand, timeoutMs
         const root = await resolveGlobalRoot(manager, runCommand, timeoutMs);
         if (!root)
             continue;
-        if (await pathExists(path.join(root, "moltbot")))
-            return manager;
+        for (const name of ALL_PACKAGE_NAMES) {
+            if (await pathExists(path.join(root, name)))
+                return manager;
+        }
     }
     const bunRoot = resolveBunGlobalRoot();
-    if (await pathExists(path.join(bunRoot, "moltbot")))
-        return "bun";
+    for (const name of ALL_PACKAGE_NAMES) {
+        if (await pathExists(path.join(bunRoot, name)))
+            return "bun";
+    }
     return null;
 }
 export function globalInstallArgs(manager, spec) {

package/dist/infra/update-runner.js

@@ -10,8 +10,8 @@ const DEFAULT_TIMEOUT_MS = 20 * 60_000;
 const MAX_LOG_CHARS = 8000;
 const PREFLIGHT_MAX_COMMITS = 10;
 const START_DIRS = ["cwd", "argv1", "process"];
-const DEFAULT_PACKAGE_NAME = "moltbot";
-const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME, "moltbot"]);
+const DEFAULT_PACKAGE_NAME = "openclaw";
+const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME]);
 function normalizeDir(value) {
     if (!value)
         return null;
@@ -212,8 +212,8 @@ function normalizeTag(tag) {
     const trimmed = tag?.trim();
     if (!trimmed)
         return "latest";
-    if (trimmed.startsWith("moltbot@"))
-        return trimmed.slice("moltbot@".length);
+    if (trimmed.startsWith("openclaw@"))
+        return trimmed.slice("openclaw@".length);
     if (trimmed.startsWith(`${DEFAULT_PACKAGE_NAME}@`)) {
         return trimmed.slice(`${DEFAULT_PACKAGE_NAME}@`.length);
     }
@@ -257,7 +257,7 @@ export async function runGatewayUpdate(opts = {}) {
             status: "error",
             mode: "unknown",
             root: gitRoot,
-            reason: "not-moltbot-root",
+            reason: "not-openclaw-root",
             steps: [],
             durationMs: Date.now() - startedAt,
         };
@@ -370,7 +370,7 @@ export async function runGatewayUpdate(opts = {}) {
                 };
             }
             const manager = await detectPackageManager(gitRoot);
-            const preflightRoot = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-update-preflight-"));
+            const preflightRoot = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-update-preflight-"));
             const worktreeDir = path.join(preflightRoot, "worktree");
             const worktreeStep = await runStep(step("preflight worktree", ["git", "-C", gitRoot, "worktree", "add", "--detach", worktreeDir, upstreamSha], gitRoot));
             steps.push(worktreeStep);
@@ -508,7 +508,7 @@ export async function runGatewayUpdate(opts = {}) {
         // (ui:build regenerates assets with new hashes, which would block future updates)
         const restoreUiStep = await runStep(step("restore control-ui", ["git", "-C", gitRoot, "checkout", "--", "dist/control-ui/"], gitRoot));
         steps.push(restoreUiStep);
-        const doctorStep = await runStep(step("moltbot doctor", managerScriptArgs(manager, "moltbot", ["doctor", "--non-interactive"]), gitRoot, { CLAWDBOT_UPDATE_IN_PROGRESS: "1" }));
+        const doctorStep = await runStep(step("openclaw doctor", managerScriptArgs(manager, "openclaw", ["doctor", "--non-interactive"]), gitRoot, { OPENCLAW_UPDATE_IN_PROGRESS: "1" }));
         steps.push(doctorStep);
         const failedStep = steps.find((s) => s.exitCode !== 0);
         const afterShaStep = await runStep(step("git rev-parse HEAD (after)", ["git", "-C", gitRoot, "rev-parse", "HEAD"], gitRoot));

package/dist/infra/update-startup.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveStateDir } from "../config/paths.js";
-import { resolveMoltbotPackageRoot } from "./moltbot-root.js";
+import { resolveOpenClawPackageRoot } from "./openclaw-root.js";
 import { compareSemverStrings, resolveNpmChannelTag, checkUpdateStatus } from "./update-check.js";
 import { normalizeUpdateChannel, DEFAULT_PACKAGE_CHANNEL } from "./update-channels.js";
 import { VERSION } from "../version.js";
@@ -44,7 +44,7 @@ export async function runGatewayUpdateCheck(params) {
         if (now - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS)
             return;
     }
-    const root = await resolveMoltbotPackageRoot({
+    const root = await resolveOpenClawPackageRoot({
         moduleUrl: import.meta.url,
         argv1: process.argv[1],
         cwd: process.cwd(),
@@ -74,7 +74,7 @@ export async function runGatewayUpdateCheck(params) {
     if (cmp != null && cmp < 0) {
         const shouldNotify = state.lastNotifiedVersion !== resolved.version || state.lastNotifiedTag !== tag;
         if (shouldNotify) {
-            params.log.info(`update available (${tag}): v${resolved.version} (current v${VERSION}). Run: ${formatCliCommand("moltbot update")}`);
+            params.log.info(`update available (${tag}): v${resolved.version} (current v${VERSION}). Run: ${formatCliCommand("openclaw update")}`);
             nextState.lastNotifiedVersion = resolved.version;
             nextState.lastNotifiedTag = tag;
         }

package/dist/infra/voicewake.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveStateDir } from "../config/paths.js";
-const DEFAULT_TRIGGERS = ["clawd", "claude", "computer"];
+const DEFAULT_TRIGGERS = ["openclaw", "claude", "computer"];
 function resolvePath(baseDir) {
     const root = baseDir ?? resolveStateDir();
     return path.join(root, "settings", "voicewake.json");

package/dist/infra/warnings.js

@@ -1,4 +1,4 @@
-const warningFilterKey = Symbol.for("moltbot.warning-filter");
+const warningFilterKey = Symbol.for("openclaw.warning-filter");
 function shouldIgnoreWarning(warning) {
     if (warning.code === "DEP0040" && warning.message?.includes("punycode")) {
         return true;

package/dist/infra/widearea-dns.js

@@ -2,10 +2,22 @@ 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 = "moltbot.internal.";
-export const WIDE_AREA_ZONE_FILENAME = "moltbot.internal.db";
-export function getWideAreaZonePath() {
-    return path.join(CONFIG_DIR, "dns", WIDE_AREA_ZONE_FILENAME);
+export function normalizeWideAreaDomain(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.endsWith(".") ? trimmed : `${trimmed}.`;
+}
+export function resolveWideAreaDiscoveryDomain(params) {
+    const env = params?.env ?? process.env;
+    const candidate = params?.configDomain ?? env.OPENCLAW_WIDE_AREA_DOMAIN ?? null;
+    return normalizeWideAreaDomain(candidate);
+}
+function zoneFilenameForDomain(domain) {
+    return `${domain.replace(/\.$/, "")}.db`;
+}
+export function getWideAreaZonePath(domain) {
+    return path.join(CONFIG_DIR, "dns", zoneFilenameForDomain(domain));
 }
 function dnsLabel(raw, fallback) {
     const normalized = raw
@@ -45,7 +57,7 @@ function extractSerial(zoneText) {
     return Number.isFinite(parsed) ? parsed : null;
 }
 function extractContentHash(zoneText) {
-    const match = zoneText.match(/^\s*;\s*moltbot-content-hash:\s*(\S+)\s*$/m);
+    const match = zoneText.match(/^\s*;\s*openclaw-content-hash:\s*(\S+)\s*$/m);
     return match?.[1] ?? null;
 }
 function computeContentHash(body) {
@@ -58,9 +70,10 @@ function computeContentHash(body) {
     return (h >>> 0).toString(16).padStart(8, "0");
 }
 function renderZone(opts) {
-    const hostname = os.hostname().split(".")[0] ?? "moltbot";
-    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "moltbot");
-    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "moltbot-gw");
+    const hostname = os.hostname().split(".")[0] ?? "openclaw";
+    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "openclaw");
+    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "openclaw-gw");
+    const domain = normalizeWideAreaDomain(opts.domain) ?? "local.";
     const txt = [
         `displayName=${opts.displayName.trim() || hostname}`,
         `role=gateway`,
@@ -83,7 +96,7 @@ function renderZone(opts) {
         txt.push(`cliPath=${opts.cliPath.trim()}`);
     }
     const records = [];
-    records.push(`$ORIGIN ${WIDE_AREA_DISCOVERY_DOMAIN}`);
+    records.push(`$ORIGIN ${domain}`);
     records.push(`$TTL 60`);
     const soaLine = `@ IN SOA ns1 hostmaster ${opts.serial} 7200 3600 1209600 60`;
     records.push(soaLine);
@@ -93,21 +106,25 @@ function renderZone(opts) {
     if (opts.tailnetIPv6) {
         records.push(`${hostLabel} IN AAAA ${opts.tailnetIPv6}`);
     }
-    records.push(`_moltbot-gw._tcp IN PTR ${instanceLabel}._moltbot-gw._tcp`);
-    records.push(`${instanceLabel}._moltbot-gw._tcp IN SRV 0 0 ${opts.gatewayPort} ${hostLabel}`);
-    records.push(`${instanceLabel}._moltbot-gw._tcp IN TXT ${txt.map(txtQuote).join(" ")}`);
+    records.push(`_openclaw-gw._tcp IN PTR ${instanceLabel}._openclaw-gw._tcp`);
+    records.push(`${instanceLabel}._openclaw-gw._tcp IN SRV 0 0 ${opts.gatewayPort} ${hostLabel}`);
+    records.push(`${instanceLabel}._openclaw-gw._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 `; moltbot-content-hash: ${contentHash}\n${contentBody}`;
+    return `; openclaw-content-hash: ${contentHash}\n${contentBody}`;
 }
 export function renderWideAreaGatewayZoneText(opts) {
     return renderZone(opts);
 }
 export async function writeWideAreaGatewayZone(opts) {
-    const zonePath = getWideAreaZonePath();
+    const domain = normalizeWideAreaDomain(opts.domain);
+    if (!domain) {
+        throw new Error("wide-area discovery domain is required");
+    }
+    const zonePath = getWideAreaZonePath(domain);
     await ensureDir(path.dirname(zonePath));
     const existing = (() => {
         try {

package/dist/logging/logger.js

@@ -7,9 +7,9 @@ import { readLoggingConfig } from "./config.js";
 import { loggingState } from "./state.js";
 // Pin to /tmp so mac Debug UI and docs match; os.tmpdir() can be a per-user
 // randomized path on macOS which made the “Open log” button a no-op.
-export const DEFAULT_LOG_DIR = "/tmp/moltbot";
-export const DEFAULT_LOG_FILE = path.join(DEFAULT_LOG_DIR, "moltbot.log"); // legacy single-file path
-const LOG_PREFIX = "moltbot";
+export const DEFAULT_LOG_DIR = "/tmp/openclaw";
+export const DEFAULT_LOG_FILE = path.join(DEFAULT_LOG_DIR, "openclaw.log"); // legacy single-file path
+const LOG_PREFIX = "openclaw";
 const LOG_SUFFIX = ".log";
 const MAX_LOG_AGE_MS = 24 * 60 * 60 * 1000; // 24h
 const requireConfig = createRequire(import.meta.url);
@@ -61,7 +61,7 @@ function buildLogger(settings) {
         pruneOldRollingLogs(path.dirname(settings.file));
     }
     const logger = new TsLogger({
-        name: "moltbot",
+        name: "openclaw",
         minLevel: levelToMinLevel(settings.level),
         type: "hidden", // no ansi formatting
     });

package/dist/macos/gateway-daemon.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import process from "node:process";
-const BUNDLED_VERSION = (typeof __CLAWDBOT_VERSION__ === "string" && __CLAWDBOT_VERSION__) ||
-    process.env.CLAWDBOT_BUNDLED_VERSION ||
+const BUNDLED_VERSION = (typeof __OPENCLAW_VERSION__ === "string" && __OPENCLAW_VERSION__) ||
+    process.env.OPENCLAW_BUNDLED_VERSION ||
     "0.0.0";
 function argValue(args, flag) {
     const idx = args.indexOf(flag);
@@ -16,7 +16,7 @@ function hasFlag(args, flag) {
 const args = process.argv.slice(2);
 async function main() {
     if (hasFlag(args, "--version") || hasFlag(args, "-v")) {
-        // Match `moltbot --version` behavior for Swift env/version checks.
+        // Match `openclaw --version` behavior for Swift env/version checks.
         // Keep output a single line.
         console.log(BUNDLED_VERSION);
         process.exit(0);
@@ -47,6 +47,7 @@ async function main() {
     setGatewayWsLogStyle(wsLogStyle);
     const cfg = loadConfig();
     const portRaw = argValue(args, "--port") ??
+        process.env.OPENCLAW_GATEWAY_PORT ??
         process.env.CLAWDBOT_GATEWAY_PORT ??
         (typeof cfg.gateway?.port === "number" ? String(cfg.gateway.port) : "") ??
         "18789";
@@ -56,6 +57,7 @@ async function main() {
         process.exit(1);
     }
     const bindRaw = argValue(args, "--bind") ??
+        process.env.OPENCLAW_GATEWAY_BIND ??
         process.env.CLAWDBOT_GATEWAY_BIND ??
         cfg.gateway?.bind ??
         "loopback";
@@ -71,8 +73,9 @@ async function main() {
         process.exit(1);
     }
     const token = argValue(args, "--token");
-    if (token)
-        process.env.CLAWDBOT_GATEWAY_TOKEN = token;
+    if (token) {
+        process.env.OPENCLAW_GATEWAY_TOKEN = token;
+    }
     let server = null;
     let lock = null;
     let shuttingDown = false;
@@ -173,6 +176,6 @@ async function main() {
     }
 }
 void main().catch((err) => {
-    console.error("[moltbot] Gateway daemon failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+    console.error("[openclaw] Gateway daemon failed:", err instanceof Error ? (err.stack ?? err.message) : err);
     process.exit(1);
 });

package/dist/macos/relay-smoke.js

@@ -13,7 +13,7 @@ export function parseRelaySmokeTest(args, env) {
         return "qr";
     // Back-compat: only run env-based smoke mode when no CLI args are present,
     // to avoid surprising early-exit when users set env vars globally.
-    if (args.length === 0 && (env.CLAWDBOT_SMOKE_QR === "1" || env.CLAWDBOT_SMOKE === "qr")) {
+    if (args.length === 0 && (env.OPENCLAW_SMOKE_QR === "1" || env.OPENCLAW_SMOKE === "qr")) {
         return "qr";
     }
     return null;

package/dist/macos/relay.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import process from "node:process";
-const BUNDLED_VERSION = (typeof __CLAWDBOT_VERSION__ === "string" && __CLAWDBOT_VERSION__) ||
-    process.env.CLAWDBOT_BUNDLED_VERSION ||
+const BUNDLED_VERSION = (typeof __OPENCLAW_VERSION__ === "string" && __OPENCLAW_VERSION__) ||
+    process.env.OPENCLAW_BUNDLED_VERSION ||
     "0.0.0";
 function hasFlag(args, flag) {
     return args.includes(flag);
@@ -37,8 +37,8 @@ async function main() {
     await patchBunLongForProtobuf();
     const { loadDotEnv } = await import("../infra/dotenv.js");
     loadDotEnv({ quiet: true });
-    const { ensureMoltbotCliOnPath } = await import("../infra/path-env.js");
-    ensureMoltbotCliOnPath();
+    const { ensureOpenClawCliOnPath } = await import("../infra/path-env.js");
+    ensureOpenClawCliOnPath();
     const { enableConsoleCapture } = await import("../logging.js");
     enableConsoleCapture();
     const { assertSupportedRuntime } = await import("../infra/runtime-guard.js");
@@ -49,12 +49,12 @@ async function main() {
     const program = buildProgram();
     installUnhandledRejectionHandler();
     process.on("uncaughtException", (error) => {
-        console.error("[moltbot] Uncaught exception:", formatUncaughtError(error));
+        console.error("[openclaw] Uncaught exception:", formatUncaughtError(error));
         process.exit(1);
     });
     await program.parseAsync(process.argv);
 }
 void main().catch((err) => {
-    console.error("[moltbot] Relay failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+    console.error("[openclaw] Relay failed:", err instanceof Error ? (err.stack ?? err.message) : err);
     process.exit(1);
 });

package/dist/media/host.js

@@ -18,7 +18,7 @@ export async function ensureMediaHosted(source, opts = {}) {
     const needsServerStart = await isPortFree(port);
     if (needsServerStart && !opts.startServer) {
         await fs.rm(saved.path).catch(() => { });
-        throw new Error(`Media hosting requires the webhook/Funnel server. Start \`${formatCliCommand("moltbot webhook")}\`/\`${formatCliCommand("moltbot up")}\` or re-run with --serve-media.`);
+        throw new Error(`Media hosting requires the webhook/Funnel server. Start \`${formatCliCommand("openclaw webhook")}\`/\`${formatCliCommand("openclaw up")}\` or re-run with --serve-media.`);
     }
     if (needsServerStart && opts.startServer) {
         if (!mediaServer) {

package/dist/media/image-ops.js

@@ -6,8 +6,8 @@ function isBun() {
     return typeof process.versions.bun === "string";
 }
 function prefersSips() {
-    return (process.env.CLAWDBOT_IMAGE_BACKEND === "sips" ||
-        (process.env.CLAWDBOT_IMAGE_BACKEND !== "sharp" && isBun() && process.platform === "darwin"));
+    return (process.env.OPENCLAW_IMAGE_BACKEND === "sips" ||
+        (process.env.OPENCLAW_IMAGE_BACKEND !== "sharp" && isBun() && process.platform === "darwin"));
 }
 async function loadSharp() {
     const mod = (await import("sharp"));
@@ -91,7 +91,7 @@ function readJpegExifOrientation(buffer) {
     return null;
 }
 async function withTempDir(fn) {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-img-"));
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-img-"));
     try {
         return await fn(dir);
     }

package/dist/media/input-files.js

@@ -78,7 +78,7 @@ export async function fetchWithGuard(params) {
             try {
                 const response = await fetch(parsedUrl, {
                     signal: controller.signal,
-                    headers: { "User-Agent": "Moltbot-Gateway/1.0" },
+                    headers: { "User-Agent": "OpenClaw-Gateway/1.0" },
                     redirect: "manual",
                     dispatcher,
                 });

package/dist/media/mime.js

@@ -11,7 +11,10 @@ const EXT_BY_MIME = {
     "image/gif": ".gif",
     "audio/ogg": ".ogg",
     "audio/mpeg": ".mp3",
+    "audio/x-m4a": ".m4a",
+    "audio/mp4": ".m4a",
     "video/mp4": ".mp4",
+    "video/quicktime": ".mov",
     "application/pdf": ".pdf",
     "application/json": ".json",
     "application/zip": ".zip",