@gguf/pigbot 0.0.1 → 0.0.2

package/dist/infra/outbound/target-resolver.js

@@ -59,7 +59,11 @@ export function formatTargetDisplay(params) {
         return trimmedTarget;
     if (trimmedTarget.startsWith("#") || trimmedTarget.startsWith("@"))
         return trimmedTarget;
-    const withoutPrefix = trimmedTarget.replace(/^telegram:/i, "");
+    const channelPrefix = `${params.channel}:`;
+    const withoutProvider = trimmedTarget.toLowerCase().startsWith(channelPrefix)
+        ? trimmedTarget.slice(channelPrefix.length)
+        : trimmedTarget;
+    const withoutPrefix = withoutProvider.replace(/^telegram:/i, "");
     if (/^channel:/i.test(withoutPrefix)) {
         return `#${withoutPrefix.replace(/^channel:/i, "")}`;
     }
@@ -80,7 +84,7 @@ function preserveTargetCase(channel, raw, normalized) {
         return `user:${trimmed.slice(1).trim()}`;
     return trimmed;
 }
-function detectTargetKind(raw, preferred) {
+function detectTargetKind(channel, raw, preferred) {
     if (preferred)
         return preferred;
     const trimmed = raw.trim();
@@ -88,8 +92,11 @@ function detectTargetKind(raw, preferred) {
         return "group";
     if (trimmed.startsWith("@") || /^<@!?/.test(trimmed) || /^user:/i.test(trimmed))
         return "user";
-    if (trimmed.startsWith("#") || /^channel:/i.test(trimmed)) {
+    if (trimmed.startsWith("#") || /^channel:/i.test(trimmed))
         return "group";
+    // For some channels (e.g., BlueBubbles/iMessage), bare phone numbers are almost always DM targets.
+    if ((channel === "bluebubbles" || channel === "imessage") && /^\+?\d{6,}$/.test(trimmed)) {
+        return "user";
     }
     return "group";
 }
@@ -211,7 +218,7 @@ export async function resolveMessagingTarget(params) {
     const plugin = getChannelPlugin(params.channel);
     const providerLabel = plugin?.meta?.label ?? params.channel;
     const hint = plugin?.messaging?.targetResolver?.hint;
-    const kind = detectTargetKind(raw, params.preferredKind);
+    const kind = detectTargetKind(params.channel, raw, params.preferredKind);
     const normalized = normalizeTargetForProvider(params.channel, raw) ?? raw;
     const looksLikeTargetId = () => {
         const trimmed = raw.trim();
@@ -224,8 +231,13 @@ export async function resolveMessagingTarget(params) {
             return true;
         if (/^[@#]/.test(trimmed))
             return true;
-        if (/^\+?\d{6,}$/.test(trimmed))
+        if (/^\+?\d{6,}$/.test(trimmed)) {
+            // BlueBubbles/iMessage phone numbers should usually resolve via the directory to a DM chat,
+            // otherwise the provider may pick an existing group containing that handle.
+            if (params.channel === "bluebubbles" || params.channel === "imessage")
+                return false;
             return true;
+        }
         if (trimmed.includes("@thread"))
             return true;
         if (/^(conversation|user):/i.test(trimmed))
@@ -289,6 +301,21 @@ export async function resolveMessagingTarget(params) {
             candidates: match.entries,
         };
     }
+    // For iMessage-style channels, allow sending directly to the normalized handle
+    // even if the directory doesn't contain an entry yet.
+    if ((params.channel === "bluebubbles" || params.channel === "imessage") &&
+        /^\+?\d{6,}$/.test(query)) {
+        const directTarget = preserveTargetCase(params.channel, raw, normalized);
+        return {
+            ok: true,
+            target: {
+                to: directTarget,
+                kind,
+                display: stripTargetPrefixes(raw),
+                source: "normalized",
+            },
+        };
+    }
     return {
         ok: false,
         error: unknownTargetError(providerLabel, raw, hint),
@@ -296,14 +323,26 @@ export async function resolveMessagingTarget(params) {
 }
 export async function lookupDirectoryDisplay(params) {
     const normalized = normalizeTargetForProvider(params.channel, params.targetId) ?? params.targetId;
-    const candidates = await getDirectoryEntries({
-        cfg: params.cfg,
-        channel: params.channel,
-        accountId: params.accountId,
-        kind: "group",
-        runtime: params.runtime,
-        preferLiveOnMiss: false,
-    });
-    const entry = candidates.find((candidate) => normalizeDirectoryEntryId(params.channel, candidate) === normalized);
+    // Targets can resolve to either peers (DMs) or groups. Try both.
+    const [groups, users] = await Promise.all([
+        getDirectoryEntries({
+            cfg: params.cfg,
+            channel: params.channel,
+            accountId: params.accountId,
+            kind: "group",
+            runtime: params.runtime,
+            preferLiveOnMiss: false,
+        }),
+        getDirectoryEntries({
+            cfg: params.cfg,
+            channel: params.channel,
+            accountId: params.accountId,
+            kind: "user",
+            runtime: params.runtime,
+            preferLiveOnMiss: false,
+        }),
+    ]);
+    const findMatch = (candidates) => candidates.find((candidate) => normalizeDirectoryEntryId(params.channel, candidate) === normalized);
+    const entry = findMatch(groups) ?? findMatch(users);
     return entry?.name ?? entry?.handle ?? undefined;
 }

package/dist/infra/outbound/targets.js

@@ -55,7 +55,7 @@ export function resolveOutboundTarget(params) {
     if (params.channel === INTERNAL_MESSAGE_CHANNEL) {
         return {
             ok: false,
-            error: new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("pigbot agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`),
+            error: new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("moltbot agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`),
         };
     }
     const plugin = getChannelPlugin(params.channel);

package/dist/infra/path-env.js

@@ -42,20 +42,20 @@ function candidateBinDirs(opts) {
     const homeDir = opts.homeDir ?? os.homedir();
     const platform = opts.platform ?? process.platform;
     const candidates = [];
-    // Bundled macOS app: `pigbot` lives next to the executable (process.execPath).
+    // Bundled macOS app: `moltbot` lives next to the executable (process.execPath).
     try {
         const execDir = path.dirname(execPath);
-        const siblingPigbot = path.join(execDir, "pigbot");
-        if (isExecutable(siblingPigbot))
+        const siblingMoltbot = path.join(execDir, "moltbot");
+        if (isExecutable(siblingMoltbot))
             candidates.push(execDir);
     }
     catch {
         // ignore
     }
-    // Project-local installs (best effort): if a `node_modules/.bin/pigbot` exists near cwd,
+    // Project-local installs (best effort): if a `node_modules/.bin/moltbot` exists near cwd,
     // include it. This helps when running under launchd or other minimal PATH environments.
     const localBinDir = path.join(cwd, "node_modules", ".bin");
-    if (isExecutable(path.join(localBinDir, "pigbot")))
+    if (isExecutable(path.join(localBinDir, "moltbot")))
         candidates.push(localBinDir);
     const miseDataDir = process.env.MISE_DATA_DIR ?? path.join(homeDir, ".local", "share", "mise");
     const miseShims = path.join(miseDataDir, "shims");
@@ -76,13 +76,13 @@ function candidateBinDirs(opts) {
     return candidates.filter(isDirectory);
 }
 /**
- * Best-effort PATH bootstrap so skills that require the `pigbot` CLI can run
+ * Best-effort PATH bootstrap so skills that require the `moltbot` CLI can run
  * under launchd/minimal environments (and inside the macOS app bundle).
  */
-export function ensurePigbotCliOnPath(opts = {}) {
-    if (isTruthyEnvValue(process.env.PIGBOT_PATH_BOOTSTRAPPED))
+export function ensureMoltbotCliOnPath(opts = {}) {
+    if (isTruthyEnvValue(process.env.CLAWDBOT_PATH_BOOTSTRAPPED))
         return;
-    process.env.PIGBOT_PATH_BOOTSTRAPPED = "1";
+    process.env.CLAWDBOT_PATH_BOOTSTRAPPED = "1";
     const existing = opts.pathEnv ?? process.env.PATH ?? "";
     const prepend = candidateBinDirs(opts);
     if (prepend.length === 0)

package/dist/infra/ports-format.js

@@ -1,7 +1,7 @@
 import { formatCliCommand } from "../cli/command-format.js";
 export function classifyPortListener(listener, port) {
     const raw = `${listener.commandLine ?? ""} ${listener.command ?? ""}`.trim().toLowerCase();
-    if (raw.includes("pigbot"))
+    if (raw.includes("moltbot"))
         return "gateway";
     if (raw.includes("ssh")) {
         const portToken = String(port);
@@ -18,7 +18,7 @@ export function buildPortHints(listeners, port) {
     const kinds = new Set(listeners.map((listener) => classifyPortListener(listener, port)));
     const hints = [];
     if (kinds.has("gateway")) {
-        hints.push(`Gateway already running locally. Stop it (${formatCliCommand("pigbot gateway stop")}) or use a different port.`);
+        hints.push(`Gateway already running locally. Stop it (${formatCliCommand("moltbot gateway stop")}) or use a different port.`);
     }
     if (kinds.has("ssh")) {
         hints.push("SSH tunnel already bound to this port. Close the tunnel or use a different local port in -L.");

package/dist/infra/ports.js

@@ -52,8 +52,8 @@ export async function handlePortError(err, port, context, runtime = defaultRunti
         if (details) {
             runtime.error(info("Port listener details:"));
             runtime.error(details);
-            if (/pigbot|src\/index\.ts|dist\/index\.js/.test(details)) {
-                runtime.error(warn("It looks like another pigbot instance is already running. Stop it or pick a different port."));
+            if (/moltbot|src\/index\.ts|dist\/index\.js/.test(details)) {
+                runtime.error(warn("It looks like another moltbot instance is already running. Stop it or pick a different port."));
             }
         }
         runtime.error(info("Resolve by stopping the process using the port or passing --port <free-port>."));

package/dist/infra/provider-usage.auth.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { CLAUDE_CLI_PROFILE_ID, ensureAuthProfileStore, listProfilesForProvider, resolveApiKeyForProfile, resolveAuthProfileOrder, } from "../agents/auth-profiles.js";
+import { ensureAuthProfileStore, listProfilesForProvider, resolveApiKeyForProfile, resolveAuthProfileOrder, } from "../agents/auth-profiles.js";
 import { getCustomProviderApiKey, resolveEnvApiKey } from "../agents/model-auth.js";
 import { normalizeProviderId } from "../agents/model-selection.js";
 import { loadConfig } from "../config/config.js";
@@ -89,9 +89,7 @@ async function resolveOAuthToken(params) {
         store,
         provider: params.provider,
     });
-    // Claude Code CLI creds are the only Anthropic tokens that reliably include the
-    // `user:profile` scope required for the OAuth usage endpoint.
-    const candidates = params.provider === "anthropic" ? [CLAUDE_CLI_PROFILE_ID, ...order] : order;
+    const candidates = order;
     const deduped = [];
     for (const entry of candidates) {
         if (!deduped.includes(entry))

package/dist/infra/provider-usage.fetch.claude.js

@@ -62,7 +62,7 @@ export async function fetchClaudeUsage(token, timeoutMs, fetchFn) {
     const res = await fetchJson("https://api.anthropic.com/api/oauth/usage", {
         headers: {
             Authorization: `Bearer ${token}`,
-            "User-Agent": "pigbot",
+            "User-Agent": "moltbot",
             Accept: "application/json",
             "anthropic-version": "2023-06-01",
             "anthropic-beta": "oauth-2025-04-20",

package/dist/infra/provider-usage.fetch.minimax.js

@@ -260,7 +260,7 @@ export async function fetchMinimaxUsage(apiKey, timeoutMs, fetchFn) {
         headers: {
             Authorization: `Bearer ${apiKey}`,
             "Content-Type": "application/json",
-            "MM-API-Source": "Pigbot",
+            "MM-API-Source": "Moltbot",
         },
     }, timeoutMs, fetchFn);
     if (!res.ok) {

package/dist/infra/restart-sentinel.js

@@ -4,7 +4,7 @@ import { formatCliCommand } from "../cli/command-format.js";
 import { resolveStateDir } from "../config/paths.js";
 const SENTINEL_FILENAME = "restart-sentinel.json";
 export function formatDoctorNonInteractiveHint(env = process.env) {
-    return `Run: ${formatCliCommand("pigbot doctor --non-interactive", env)}`;
+    return `Run: ${formatCliCommand("moltbot doctor --non-interactive", env)}`;
 }
 export function resolveRestartSentinelPath(env = process.env) {
     return path.join(resolveStateDir(env), SENTINEL_FILENAME);

package/dist/infra/restart.js

@@ -71,14 +71,14 @@ function normalizeSystemdUnit(raw, profile) {
     }
     return unit.endsWith(".service") ? unit : `${unit}.service`;
 }
-export function triggerPigbotRestart() {
+export function triggerMoltbotRestart() {
     if (process.env.VITEST || process.env.NODE_ENV === "test") {
         return { ok: true, method: "supervisor", detail: "test mode" };
     }
     const tried = [];
     if (process.platform !== "darwin") {
         if (process.platform === "linux") {
-            const unit = normalizeSystemdUnit(process.env.PIGBOT_SYSTEMD_UNIT, process.env.PIGBOT_PROFILE);
+            const unit = normalizeSystemdUnit(process.env.CLAWDBOT_SYSTEMD_UNIT, process.env.CLAWDBOT_PROFILE);
             const userArgs = ["--user", "restart", unit];
             tried.push(`systemctl ${userArgs.join(" ")}`);
             const userRestart = spawnSync("systemctl", userArgs, {
@@ -109,8 +109,8 @@ export function triggerPigbotRestart() {
             detail: "unsupported platform restart",
         };
     }
-    const label = process.env.PIGBOT_LAUNCHD_LABEL ||
-        resolveGatewayLaunchAgentLabel(process.env.PIGBOT_PROFILE);
+    const label = process.env.CLAWDBOT_LAUNCHD_LABEL ||
+        resolveGatewayLaunchAgentLabel(process.env.CLAWDBOT_PROFILE);
     const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
     const target = uid !== undefined ? `gui/${uid}/${label}` : label;
     const args = ["kickstart", "-k", target];

package/dist/infra/retry-policy.js

@@ -53,10 +53,13 @@ export function createTelegramRetryRunner(params) {
         ...params.configRetry,
         ...params.retry,
     });
+    const shouldRetry = params.shouldRetry
+        ? (err) => params.shouldRetry?.(err) || TELEGRAM_RETRY_RE.test(formatErrorMessage(err))
+        : (err) => TELEGRAM_RETRY_RE.test(formatErrorMessage(err));
     return (fn, label) => retryAsync(fn, {
         ...retryConfig,
         label,
-        shouldRetry: (err) => TELEGRAM_RETRY_RE.test(formatErrorMessage(err)),
+        shouldRetry,
         retryAfterMs: getTelegramRetryAfterMs,
         onRetry: params.verbose
             ? (info) => {

package/dist/infra/runtime-guard.js

@@ -50,11 +50,11 @@ export function assertSupportedRuntime(runtime = defaultRuntime, details = detec
     const runtimeLabel = details.kind === "unknown" ? "unknown runtime" : `${details.kind} ${versionLabel}`;
     const execLabel = details.execPath ?? "unknown";
     runtime.error([
-        "pigbot requires Node >=22.0.0.",
+        "moltbot requires Node >=22.0.0.",
         `Detected: ${runtimeLabel} (exec: ${execLabel}).`,
         `PATH searched: ${details.pathEnv}`,
         "Install Node: https://nodejs.org/en/download",
-        "Upgrade Node and re-run pigbot.",
+        "Upgrade Node and re-run moltbot.",
     ].join("\n"));
     runtime.exit(1);
 }

package/dist/infra/shell-env.js

@@ -53,7 +53,7 @@ export function loadShellEnvFallback(opts) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.warn(`[pigbot] shell env fallback failed: ${msg}`);
+        logger.warn(`[moltbot] shell env fallback failed: ${msg}`);
         lastAppliedKeys = [];
         return { ok: false, error: msg, applied: [] };
     }
@@ -72,13 +72,13 @@ export function loadShellEnvFallback(opts) {
     return { ok: true, applied };
 }
 export function shouldEnableShellEnvFallback(env) {
-    return isTruthyEnvValue(env.PIGBOT_LOAD_SHELL_ENV);
+    return isTruthyEnvValue(env.CLAWDBOT_LOAD_SHELL_ENV);
 }
 export function shouldDeferShellEnvFallback(env) {
-    return isTruthyEnvValue(env.PIGBOT_DEFER_SHELL_ENV_FALLBACK);
+    return isTruthyEnvValue(env.CLAWDBOT_DEFER_SHELL_ENV_FALLBACK);
 }
 export function resolveShellEnvFallbackTimeoutMs(env) {
-    const raw = env.PIGBOT_SHELL_ENV_TIMEOUT_MS?.trim();
+    const raw = env.CLAWDBOT_SHELL_ENV_TIMEOUT_MS?.trim();
     if (!raw)
         return DEFAULT_TIMEOUT_MS;
     const parsed = Number.parseInt(raw, 10);

package/dist/infra/skills-remote.js

@@ -139,11 +139,11 @@ function listWorkspaceDirs(cfg) {
 function collectRequiredBins(entries, targetPlatform) {
     const bins = new Set();
     for (const entry of entries) {
-        const os = entry.pigbot?.os ?? [];
+        const os = entry.metadata?.os ?? [];
         if (os.length > 0 && !os.includes(targetPlatform))
             continue;
-        const required = entry.pigbot?.requires?.bins ?? [];
-        const anyBins = entry.pigbot?.requires?.anyBins ?? [];
+        const required = entry.metadata?.requires?.bins ?? [];
+        const anyBins = entry.metadata?.requires?.anyBins ?? [];
         for (const bin of required) {
             if (bin.trim())
                 bins.add(bin.trim());

package/dist/infra/state-migrations.js

@@ -466,7 +466,7 @@ export async function autoMigrateLegacyState(params) {
     }
     autoMigrateChecked = true;
     const env = params.env ?? process.env;
-    if (env.PIGBOT_AGENT_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim()) {
+    if (env.CLAWDBOT_AGENT_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim()) {
         return { migrated: false, skipped: true, changes: [], warnings: [] };
     }
     const detected = await detectLegacyStateMigrations({

package/dist/infra/system-presence.js

@@ -33,7 +33,7 @@ function resolvePrimaryIPv4() {
 function initSelfPresence() {
     const host = os.hostname();
     const ip = resolvePrimaryIPv4() ?? undefined;
-    const version = process.env.PIGBOT_VERSION ?? process.env.npm_package_version ?? "unknown";
+    const version = process.env.CLAWDBOT_VERSION ?? process.env.npm_package_version ?? "unknown";
     const modelIdentifier = (() => {
         const p = os.platform();
         if (p === "darwin") {

package/dist/infra/tailscale.js

@@ -173,6 +173,7 @@ export async function ensureTailscaledInstalled(exec = runExec, prompt = promptY
     logVerbose("Installing tailscaled via Homebrew…");
     await exec("brew", ["install", "tailscale"]);
 }
+const whoisCache = new Map();
 function extractExecErrorText(err) {
     const errOutput = err;
     const stdout = typeof errOutput.stdout === "string" ? errOutput.stdout : "";
@@ -262,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 PIGBOT. You can keep running the web gateway without it: \`${formatCliCommand("pigbot gateway")}\``));
+        runtime.error(info(`Tip: Funnel is optional for Moltbot. You can keep running the web gateway without it: \`${formatCliCommand("moltbot gateway")}\``));
         if (shouldLogVerbose()) {
             const rich = isRich();
             if (stdout.trim()) {
@@ -304,3 +305,64 @@ export async function disableTailscaleFunnel(exec = runExec) {
         timeoutMs: 15_000,
     });
 }
+function getString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function parseWhoisIdentity(payload) {
+    const userProfile = readRecord(payload.UserProfile) ?? readRecord(payload.userProfile) ?? readRecord(payload.User);
+    const login = getString(userProfile?.LoginName) ??
+        getString(userProfile?.Login) ??
+        getString(userProfile?.login) ??
+        getString(payload.LoginName) ??
+        getString(payload.login);
+    if (!login)
+        return null;
+    const name = getString(userProfile?.DisplayName) ??
+        getString(userProfile?.Name) ??
+        getString(userProfile?.displayName) ??
+        getString(payload.DisplayName) ??
+        getString(payload.name);
+    return { login, name };
+}
+function readCachedWhois(ip, now) {
+    const cached = whoisCache.get(ip);
+    if (!cached)
+        return undefined;
+    if (cached.expiresAt <= now) {
+        whoisCache.delete(ip);
+        return undefined;
+    }
+    return cached.value;
+}
+function writeCachedWhois(ip, value, ttlMs) {
+    whoisCache.set(ip, { value, expiresAt: Date.now() + ttlMs });
+}
+export async function readTailscaleWhoisIdentity(ip, exec = runExec, opts) {
+    const normalized = ip.trim();
+    if (!normalized)
+        return null;
+    const now = Date.now();
+    const cached = readCachedWhois(normalized, now);
+    if (cached !== undefined)
+        return cached;
+    const cacheTtlMs = opts?.cacheTtlMs ?? 60_000;
+    const errorTtlMs = opts?.errorTtlMs ?? 5_000;
+    try {
+        const tailscaleBin = await getTailscaleBinary();
+        const { stdout } = await exec(tailscaleBin, ["whois", "--json", normalized], {
+            timeoutMs: opts?.timeoutMs ?? 5_000,
+            maxBuffer: 200_000,
+        });
+        const parsed = stdout ? parsePossiblyNoisyJsonObject(stdout) : {};
+        const identity = parseWhoisIdentity(parsed);
+        writeCachedWhois(normalized, identity, cacheTtlMs);
+        return identity;
+    }
+    catch {
+        writeCachedWhois(normalized, null, errorTtlMs);
+        return null;
+    }
+}

package/dist/infra/tls/gateway.js

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

package/dist/infra/unhandled-rejections.js

@@ -1,6 +1,81 @@
 import process from "node:process";
 import { 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;
+}
+// Network error codes that indicate transient failures (shouldn't crash the gateway)
+const TRANSIENT_NETWORK_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+    "ECONNABORTED",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EAI_AGAIN",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "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;
+}
+/**
+ * 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.
+ */
+export function isTransientNetworkError(err) {
+    if (!err)
+        return false;
+    // Check the error itself
+    const code = getErrorCode(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
+    const cause = getErrorCause(err);
+    if (cause && cause !== err) {
+        return isTransientNetworkError(cause);
+    }
+    // AggregateError may wrap multiple causes
+    if (err instanceof AggregateError && err.errors?.length) {
+        return err.errors.some((e) => isTransientNetworkError(e));
+    }
+    return false;
+}
 export function registerUnhandledRejectionHandler(handler) {
     handlers.add(handler);
     return () => {
@@ -14,7 +89,7 @@ export function isUnhandledRejectionHandled(reason) {
                 return true;
         }
         catch (err) {
-            console.error("[pigbot] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+            console.error("[moltbot] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
         }
     }
     return false;
@@ -23,7 +98,19 @@ export function installUnhandledRejectionHandler() {
     process.on("unhandledRejection", (reason, _promise) => {
         if (isUnhandledRejectionHandled(reason))
             return;
-        console.error("[pigbot] Unhandled promise rejection:", formatUncaughtError(reason));
+        // 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));
+            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));
+            return;
+        }
+        console.error("[moltbot] Unhandled promise rejection:", formatUncaughtError(reason));
         process.exit(1);
     });
 }

package/dist/infra/update-check.js

@@ -68,9 +68,7 @@ export async function checkGitUpdateStatus(params) {
     const tag = tagRes && tagRes.code === 0 ? tagRes.stdout.trim() : null;
     const upstreamRes = await runCommandWithTimeout(["git", "-C", root, "rev-parse", "--abbrev-ref", "@{upstream}"], { timeoutMs }).catch(() => null);
     const upstream = upstreamRes && upstreamRes.code === 0 ? upstreamRes.stdout.trim() : null;
-    const dirtyRes = await runCommandWithTimeout(["git", "-C", root, "status", "--porcelain"], {
-        timeoutMs,
-    }).catch(() => null);
+    const dirtyRes = await runCommandWithTimeout(["git", "-C", root, "status", "--porcelain", "--", ":!dist/control-ui/"], { timeoutMs }).catch(() => null);
     const dirty = dirtyRes && dirtyRes.code === 0 ? dirtyRes.stdout.trim().length > 0 : null;
     const fetchOk = params.fetch
         ? await runCommandWithTimeout(["git", "-C", root, "fetch", "--quiet", "--prune"], { timeoutMs })
@@ -216,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/pigbot/${encodeURIComponent(tag)}`, timeoutMs);
+        const res = await fetchWithTimeout(`https://registry.npmjs.org/moltbot/${encodeURIComponent(tag)}`, timeoutMs);
         if (!res.ok) {
             return { tag, version: null, error: `HTTP ${res.status}` };
         }

package/dist/infra/update-global.js

@@ -36,7 +36,7 @@ export async function resolveGlobalPackageRoot(manager, runCommand, timeoutMs) {
     const root = await resolveGlobalRoot(manager, runCommand, timeoutMs);
     if (!root)
         return null;
-    return path.join(root, "pigbot");
+    return path.join(root, "moltbot");
 }
 export async function detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs) {
     const pkgReal = await tryRealpath(pkgRoot);
@@ -52,13 +52,13 @@ export async function detectGlobalInstallManagerForRoot(runCommand, pkgRoot, tim
         if (!globalRoot)
             continue;
         const globalReal = await tryRealpath(globalRoot);
-        const expected = path.join(globalReal, "pigbot");
+        const expected = path.join(globalReal, "moltbot");
         if (path.resolve(expected) === path.resolve(pkgReal))
             return manager;
     }
     const bunGlobalRoot = resolveBunGlobalRoot();
     const bunGlobalReal = await tryRealpath(bunGlobalRoot);
-    const bunExpected = path.join(bunGlobalReal, "pigbot");
+    const bunExpected = path.join(bunGlobalReal, "moltbot");
     if (path.resolve(bunExpected) === path.resolve(pkgReal))
         return "bun";
     return null;
@@ -68,11 +68,11 @@ export async function detectGlobalInstallManagerByPresence(runCommand, timeoutMs
         const root = await resolveGlobalRoot(manager, runCommand, timeoutMs);
         if (!root)
             continue;
-        if (await pathExists(path.join(root, "pigbot")))
+        if (await pathExists(path.join(root, "moltbot")))
             return manager;
     }
     const bunRoot = resolveBunGlobalRoot();
-    if (await pathExists(path.join(bunRoot, "pigbot")))
+    if (await pathExists(path.join(bunRoot, "moltbot")))
         return "bun";
     return null;
 }