@gguf/pigbot 0.0.1 → 0.0.3

package/dist/commands/status.command.js

@@ -271,7 +271,7 @@ export async function statusCommand(opts, runtime) {
             Value: `${summary.sessions.count} active · default ${defaults.model ?? "unknown"}${defaultCtx} · ${storeLabel}`,
         },
     ];
-    runtime.log(theme.heading("Pigbot status"));
+    runtime.log(theme.heading("Moltbot status"));
     runtime.log("");
     runtime.log(theme.heading("Overview"));
     runtime.log(renderTable({
@@ -318,8 +318,8 @@ export async function statusCommand(opts, runtime) {
             runtime.log(theme.muted(`… +${sorted.length - shown.length} more`));
         }
     }
-    runtime.log(theme.muted(`Full report: ${formatCliCommand("pigbot security audit")}`));
-    runtime.log(theme.muted(`Deep probe: ${formatCliCommand("pigbot security audit --deep")}`));
+    runtime.log(theme.muted(`Full report: ${formatCliCommand("moltbot security audit")}`));
+    runtime.log(theme.muted(`Deep probe: ${formatCliCommand("moltbot security audit --deep")}`));
     runtime.log("");
     runtime.log(theme.heading("Channels"));
     const channelIssuesByChannel = (() => {
@@ -456,8 +456,8 @@ export async function statusCommand(opts, runtime) {
         }
     }
     runtime.log("");
-    runtime.log("FAQ: https://docs.clawd.bot/faq");
-    runtime.log("Troubleshooting: https://docs.clawd.bot/troubleshooting");
+    runtime.log("FAQ: https://docs.molt.bot/faq");
+    runtime.log("Troubleshooting: https://docs.molt.bot/troubleshooting");
     runtime.log("");
     const updateHint = formatUpdateAvailableHint(update);
     if (updateHint) {
@@ -465,12 +465,12 @@ export async function statusCommand(opts, runtime) {
         runtime.log("");
     }
     runtime.log("Next steps:");
-    runtime.log(`  Need to share?      ${formatCliCommand("pigbot status --all")}`);
-    runtime.log(`  Need to debug live? ${formatCliCommand("pigbot logs --follow")}`);
+    runtime.log(`  Need to share?      ${formatCliCommand("moltbot status --all")}`);
+    runtime.log(`  Need to debug live? ${formatCliCommand("moltbot logs --follow")}`);
     if (gatewayReachable) {
-        runtime.log(`  Need to test channels? ${formatCliCommand("pigbot status --deep")}`);
+        runtime.log(`  Need to test channels? ${formatCliCommand("moltbot status --deep")}`);
     }
     else {
-        runtime.log(`  Fix reachability first: ${formatCliCommand("pigbot gateway probe")}`);
+        runtime.log(`  Fix reachability first: ${formatCliCommand("moltbot gateway probe")}`);
     }
 }

package/dist/commands/status.gateway-probe.js

@@ -7,9 +7,9 @@ export function resolveGatewayProbeAuth(cfg) {
         ? typeof remote?.token === "string" && remote.token.trim().length > 0
             ? remote.token.trim()
             : undefined
-        : process.env.PIGBOT_GATEWAY_TOKEN?.trim() ||
+        : process.env.CLAWDBOT_GATEWAY_TOKEN?.trim() ||
             (typeof authToken === "string" && authToken.trim().length > 0 ? authToken.trim() : undefined);
-    const password = process.env.PIGBOT_GATEWAY_PASSWORD?.trim() ||
+    const password = process.env.CLAWDBOT_GATEWAY_PASSWORD?.trim() ||
         (isRemoteMode
             ? typeof remote?.password === "string" && remote.password.trim().length > 0
                 ? remote.password.trim()

package/dist/commands/status.scan.js

@@ -86,8 +86,8 @@ export async function scanStatus(opts, _runtime) {
         progress.setLabel("Summarizing channels…");
         const channels = await buildChannelsTable(cfg, {
             // Show token previews in regular status; keep `status --all` redacted.
-            // Set `PIGBOT_SHOW_SECRETS=0` to force redaction.
-            showSecrets: process.env.PIGBOT_SHOW_SECRETS?.trim() !== "0",
+            // Set `CLAWDBOT_SHOW_SECRETS=0` to force redaction.
+            showSecrets: process.env.CLAWDBOT_SHOW_SECRETS?.trim() !== "0",
         });
         progress.tick();
         progress.setLabel("Checking memory…");

package/dist/commands/status.update.js

@@ -1,9 +1,9 @@
-import { resolvePigbotPackageRoot } from "../infra/pigbot-root.js";
+import { resolveMoltbotPackageRoot } from "../infra/moltbot-root.js";
 import { checkUpdateStatus, compareSemverStrings, } from "../infra/update-check.js";
 import { formatCliCommand } from "../cli/command-format.js";
 import { VERSION } from "../version.js";
 export async function getUpdateCheckResult(params) {
-    const root = await resolvePigbotPackageRoot({
+    const root = await resolveMoltbotPackageRoot({
         moduleUrl: import.meta.url,
         argv1: process.argv[1],
         cwd: process.cwd(),
@@ -43,7 +43,7 @@ export function formatUpdateAvailableHint(update) {
         details.push(`npm ${availability.latestVersion}`);
     }
     const suffix = details.length > 0 ? ` (${details.join(" · ")})` : "";
-    return `Update available${suffix}. Run: ${formatCliCommand("pigbot update")}`;
+    return `Update available${suffix}. Run: ${formatCliCommand("moltbot update")}`;
 }
 export function formatUpdateOneLiner(update) {
     const parts = [];

package/dist/commands/uninstall.js

@@ -59,9 +59,9 @@ async function stopAndUninstallService(runtime) {
 async function removeMacApp(runtime, dryRun) {
     if (process.platform !== "darwin")
         return;
-    await removePath("/Applications/Pigbot.app", runtime, {
+    await removePath("/Applications/Moltbot.app", runtime, {
         dryRun,
-        label: "/Applications/Pigbot.app",
+        label: "/Applications/Moltbot.app",
     });
 }
 export async function uninstallCommand(runtime, opts) {
@@ -86,12 +86,12 @@ export async function uninstallCommand(runtime, opts) {
                     label: "Gateway service",
                     hint: "launchd / systemd / schtasks",
                 },
-                { value: "state", label: "State + config", hint: "~/.pigbot" },
+                { value: "state", label: "State + config", hint: "~/.clawdbot" },
                 { value: "workspace", label: "Workspace", hint: "agent files" },
                 {
                     value: "app",
                     label: "macOS app",
-                    hint: "/Applications/Pigbot.app",
+                    hint: "/Applications/Moltbot.app",
                 },
             ],
             initialValues: ["service", "state", "workspace"],

package/dist/compat/legacy-names.js

@@ -0,0 +1,6 @@
+export const LEGACY_PROJECT_NAME = "clawdbot";
+export const LEGACY_MANIFEST_KEY = LEGACY_PROJECT_NAME;
+export const LEGACY_PLUGIN_MANIFEST_FILENAME = `${LEGACY_PROJECT_NAME}.plugin.json`;
+export const LEGACY_CANVAS_HANDLER_NAME = `${LEGACY_PROJECT_NAME}CanvasA2UIAction`;
+export const LEGACY_MACOS_APP_SOURCES_DIR = "apps/macos/Sources/Clawdbot";
+export const MACOS_APP_SOURCES_DIR = "apps/macos/Sources/Moltbot";

package/dist/config/config.js

@@ -4,4 +4,4 @@ export * from "./paths.js";
 export * from "./runtime-overrides.js";
 export * from "./types.js";
 export { validateConfigObject, validateConfigObjectWithPlugins } from "./validation.js";
-export { PigbotSchema } from "./zod-schema.js";
+export { MoltbotSchema } from "./zod-schema.js";

package/dist/config/env-vars.js

@@ -0,0 +1,21 @@
+export function collectConfigEnvVars(cfg) {
+    const envConfig = cfg?.env;
+    if (!envConfig)
+        return {};
+    const entries = {};
+    if (envConfig.vars) {
+        for (const [key, value] of Object.entries(envConfig.vars)) {
+            if (!value)
+                continue;
+            entries[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(envConfig)) {
+        if (key === "shellEnv" || key === "vars")
+            continue;
+        if (typeof value !== "string" || !value.trim())
+            continue;
+        entries[key] = value;
+    }
+    return entries;
+}

package/dist/config/group-policy.js

@@ -1,4 +1,55 @@
 import { normalizeAccountId } from "../routing/session-key.js";
+function normalizeSenderKey(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return "";
+    const withoutAt = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+    return withoutAt.toLowerCase();
+}
+export function resolveToolsBySender(params) {
+    const toolsBySender = params.toolsBySender;
+    if (!toolsBySender)
+        return undefined;
+    const entries = Object.entries(toolsBySender);
+    if (entries.length === 0)
+        return undefined;
+    const normalized = new Map();
+    let wildcard;
+    for (const [rawKey, policy] of entries) {
+        if (!policy)
+            continue;
+        const key = normalizeSenderKey(rawKey);
+        if (!key)
+            continue;
+        if (key === "*") {
+            wildcard = policy;
+            continue;
+        }
+        if (!normalized.has(key)) {
+            normalized.set(key, policy);
+        }
+    }
+    const candidates = [];
+    const pushCandidate = (value) => {
+        const trimmed = value?.trim();
+        if (!trimmed)
+            return;
+        candidates.push(trimmed);
+    };
+    pushCandidate(params.senderId);
+    pushCandidate(params.senderE164);
+    pushCandidate(params.senderUsername);
+    pushCandidate(params.senderName);
+    for (const candidate of candidates) {
+        const key = normalizeSenderKey(candidate);
+        if (!key)
+            continue;
+        const match = normalized.get(key);
+        if (match)
+            return match;
+    }
+    return wildcard;
+}
 function resolveChannelGroups(cfg, channel, accountId) {
     const normalizedAccountId = normalizeAccountId(accountId);
     const channelConfig = cfg.channels?.[channel];
@@ -46,8 +97,26 @@ export function resolveChannelGroupRequireMention(params) {
 }
 export function resolveChannelGroupToolsPolicy(params) {
     const { groupConfig, defaultConfig } = resolveChannelGroupPolicy(params);
+    const groupSenderPolicy = resolveToolsBySender({
+        toolsBySender: groupConfig?.toolsBySender,
+        senderId: params.senderId,
+        senderName: params.senderName,
+        senderUsername: params.senderUsername,
+        senderE164: params.senderE164,
+    });
+    if (groupSenderPolicy)
+        return groupSenderPolicy;
     if (groupConfig?.tools)
         return groupConfig.tools;
+    const defaultSenderPolicy = resolveToolsBySender({
+        toolsBySender: defaultConfig?.toolsBySender,
+        senderId: params.senderId,
+        senderName: params.senderName,
+        senderUsername: params.senderUsername,
+        senderE164: params.senderE164,
+    });
+    if (defaultSenderPolicy)
+        return defaultSenderPolicy;
     if (defaultConfig?.tools)
         return defaultConfig.tools;
     return undefined;

package/dist/config/io.js

@@ -8,13 +8,14 @@ import { DuplicateAgentDirError, findDuplicateAgentDirs } from "./agent-dirs.js"
 import { applyCompactionDefaults, applyContextPruningDefaults, applyAgentDefaults, applyLoggingDefaults, applyMessageDefaults, applyModelDefaults, applySessionDefaults, applyTalkApiKey, } from "./defaults.js";
 import { VERSION } from "../version.js";
 import { MissingEnvVarError, resolveConfigEnvVars } from "./env-substitution.js";
+import { collectConfigEnvVars } from "./env-vars.js";
 import { ConfigIncludeError, resolveConfigIncludes } from "./includes.js";
 import { findLegacyConfigIssues } from "./legacy.js";
 import { normalizeConfigPaths } from "./normalize-paths.js";
-import { resolveConfigPath, resolveStateDir } from "./paths.js";
+import { resolveConfigPath, resolveDefaultConfigCandidates, resolveStateDir } from "./paths.js";
 import { applyConfigOverrides } from "./runtime-overrides.js";
 import { validateConfigObjectWithPlugins } from "./validation.js";
-import { comparePigbotVersions } from "./version.js";
+import { compareMoltbotVersions } from "./version.js";
 // Re-export for backwards compatibility
 export { CircularIncludeError, ConfigIncludeError } from "./includes.js";
 export { MissingEnvVarError } from "./env-substitution.js";
@@ -33,8 +34,8 @@ const SHELL_ENV_EXPECTED_KEYS = [
     "DISCORD_BOT_TOKEN",
     "SLACK_BOT_TOKEN",
     "SLACK_APP_TOKEN",
-    "PIGBOT_GATEWAY_TOKEN",
-    "PIGBOT_GATEWAY_PASSWORD",
+    "CLAWDBOT_GATEWAY_TOKEN",
+    "CLAWDBOT_GATEWAY_PASSWORD",
 ];
 const CONFIG_BACKUP_COUNT = 5;
 const loggedInvalidConfigs = new Set();
@@ -102,32 +103,15 @@ function warnIfConfigFromFuture(cfg, logger) {
     const touched = cfg.meta?.lastTouchedVersion;
     if (!touched)
         return;
-    const cmp = comparePigbotVersions(VERSION, touched);
+    const cmp = compareMoltbotVersions(VERSION, touched);
     if (cmp === null)
         return;
     if (cmp < 0) {
-        logger.warn(`Config was last written by a newer Pigbot (${touched}); current version is ${VERSION}.`);
+        logger.warn(`Config was last written by a newer Moltbot (${touched}); current version is ${VERSION}.`);
     }
 }
 function applyConfigEnv(cfg, env) {
-    const envConfig = cfg.env;
-    if (!envConfig)
-        return;
-    const entries = {};
-    if (envConfig.vars) {
-        for (const [key, value] of Object.entries(envConfig.vars)) {
-            if (!value)
-                continue;
-            entries[key] = value;
-        }
-    }
-    for (const [key, value] of Object.entries(envConfig)) {
-        if (key === "shellEnv" || key === "vars")
-            continue;
-        if (typeof value !== "string" || !value.trim())
-            continue;
-        entries[key] = value;
-    }
+    const entries = collectConfigEnvVars(cfg);
     for (const [key, value] of Object.entries(entries)) {
         if (env[key]?.trim())
             continue;
@@ -159,7 +143,11 @@ export function parseConfigJson5(raw, json5 = JSON5) {
 }
 export function createConfigIO(overrides = {}) {
     const deps = normalizeDeps(overrides);
-    const configPath = resolveConfigPathForDeps(deps);
+    const requestedConfigPath = resolveConfigPathForDeps(deps);
+    const candidatePaths = deps.configPath
+        ? [requestedConfigPath]
+        : resolveDefaultConfigCandidates(deps.env, deps.homedir);
+    const configPath = candidatePaths.find((candidate) => deps.fs.existsSync(candidate)) ?? requestedConfigPath;
     function loadConfig() {
         try {
             if (!deps.fs.existsSync(configPath)) {
@@ -181,6 +169,10 @@ export function createConfigIO(overrides = {}) {
                 readFile: (p) => deps.fs.readFileSync(p, "utf-8"),
                 parseJson: (raw) => deps.json5.parse(raw),
             });
+            // Apply config.env to process.env BEFORE substitution so ${VAR} can reference config-defined vars
+            if (resolved && typeof resolved === "object" && "env" in resolved) {
+                applyConfigEnv(resolved, deps.env);
+            }
             // Substitute ${VAR} env var references
             const substituted = resolveConfigEnvVars(resolved, deps.env);
             const resolvedConfig = substituted;
@@ -312,6 +304,10 @@ export function createConfigIO(overrides = {}) {
                     legacyIssues: [],
                 };
             }
+            // Apply config.env to process.env BEFORE substitution so ${VAR} can reference config-defined vars
+            if (resolved && typeof resolved === "object" && "env" in resolved) {
+                applyConfigEnv(resolved, deps.env);
+            }
             // Substitute ${VAR} env var references
             let substituted;
             try {
@@ -440,12 +436,12 @@ export function createConfigIO(overrides = {}) {
     };
 }
 // NOTE: These wrappers intentionally do *not* cache the resolved config path at
-// module scope. `PIGBOT_CONFIG_PATH` (and friends) are expected to work even
+// module scope. `CLAWDBOT_CONFIG_PATH` (and friends) are expected to work even
 // when set after the module has been imported (tests, one-off scripts, etc.).
 const DEFAULT_CONFIG_CACHE_MS = 200;
 let configCache = null;
 function resolveConfigCacheMs(env) {
-    const raw = env.PIGBOT_CONFIG_CACHE_MS?.trim();
+    const raw = env.CLAWDBOT_CONFIG_CACHE_MS?.trim();
     if (raw === "" || raw === "0")
         return 0;
     if (!raw)
@@ -456,7 +452,7 @@ function resolveConfigCacheMs(env) {
     return Math.max(0, parsed);
 }
 function shouldUseConfigCache(env) {
-    if (env.PIGBOT_DISABLE_CONFIG_CACHE?.trim())
+    if (env.CLAWDBOT_DISABLE_CONFIG_CACHE?.trim())
         return false;
     return resolveConfigCacheMs(env) > 0;
 }

package/dist/config/legacy.migrations.part-3.js

@@ -1,4 +1,6 @@
 import { ensureAgentEntry, ensureRecord, getAgentsList, getRecord, isRecord, mergeMissing, resolveDefaultAgentIdFromRaw, } from "./legacy.shared.js";
+// NOTE: tools.alsoAllow was introduced after legacy migrations; no legacy migration needed.
+// tools.alsoAllow legacy migration intentionally omitted (field not shipped in prod).
 export const LEGACY_CONFIG_MIGRATIONS_PART_3 = [
     {
         id: "auth.anthropic-claude-cli-mode-oauth",
@@ -17,6 +19,7 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_3 = [
             changes.push('Updated auth.profiles["anthropic:claude-cli"].mode → "oauth".');
         },
     },
+    // tools.alsoAllow migration removed (field not shipped in prod; enforce via schema instead).
     {
         id: "tools.bash->tools.exec",
         describe: "Move tools.bash to tools.exec",

package/dist/config/logging.js

@@ -1,10 +1,10 @@
 import { displayPath } from "../utils.js";
-import { CONFIG_PATH_PIGBOT } from "./paths.js";
-export function formatConfigPath(path = CONFIG_PATH_PIGBOT) {
+import { CONFIG_PATH } from "./paths.js";
+export function formatConfigPath(path = CONFIG_PATH) {
     return displayPath(path);
 }
 export function logConfigUpdated(runtime, opts = {}) {
-    const path = formatConfigPath(opts.path ?? CONFIG_PATH_PIGBOT);
+    const path = formatConfigPath(opts.path ?? CONFIG_PATH);
     const suffix = opts.suffix ? ` ${opts.suffix}` : "";
     runtime.log(`Updated ${path}${suffix}`);
 }

package/dist/config/paths.js

@@ -1,26 +1,35 @@
 import os from "node:os";
 import path from "node:path";
 /**
- * Nix mode detection: When PIGBOT_NIX_MODE=1, the gateway is running under Nix.
+ * Nix mode detection: When CLAWDBOT_NIX_MODE=1, the gateway is running under Nix.
  * In this mode:
  * - No auto-install flows should be attempted
  * - Missing dependencies should produce actionable Nix-specific error messages
  * - Config is managed externally (read-only from Nix perspective)
  */
 export function resolveIsNixMode(env = process.env) {
-    return env.PIGBOT_NIX_MODE === "1";
+    return env.CLAWDBOT_NIX_MODE === "1";
 }
 export const isNixMode = resolveIsNixMode();
+const LEGACY_STATE_DIRNAME = ".clawdbot";
+const NEW_STATE_DIRNAME = ".moltbot";
+const CONFIG_FILENAME = "moltbot.json";
+function legacyStateDir(homedir = os.homedir) {
+    return path.join(homedir(), LEGACY_STATE_DIRNAME);
+}
+function newStateDir(homedir = os.homedir) {
+    return path.join(homedir(), NEW_STATE_DIRNAME);
+}
 /**
  * State directory for mutable data (sessions, logs, caches).
- * Can be overridden via PIGBOT_STATE_DIR environment variable.
- * Default: ~/.pigbot
+ * Can be overridden via MOLTBOT_STATE_DIR (preferred) or CLAWDBOT_STATE_DIR (legacy).
+ * Default: ~/.clawdbot (legacy default for compatibility)
  */
 export function resolveStateDir(env = process.env, homedir = os.homedir) {
-    const override = env.PIGBOT_STATE_DIR?.trim();
+    const override = env.MOLTBOT_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
     if (override)
         return resolveUserPath(override);
-    return path.join(homedir(), ".pigbot");
+    return legacyStateDir(homedir);
 }
 function resolveUserPath(input) {
     const trimmed = input.trim();
@@ -32,31 +41,62 @@ function resolveUserPath(input) {
     }
     return path.resolve(trimmed);
 }
-export const STATE_DIR_PIGBOT = resolveStateDir();
+export const STATE_DIR = resolveStateDir();
 /**
  * Config file path (JSON5).
- * Can be overridden via PIGBOT_CONFIG_PATH environment variable.
- * Default: ~/.pigbot/pigbot.json (or $PIGBOT_STATE_DIR/pigbot.json)
+ * Can be overridden via MOLTBOT_CONFIG_PATH (preferred) or CLAWDBOT_CONFIG_PATH (legacy).
+ * Default: ~/.clawdbot/moltbot.json (or $*_STATE_DIR/moltbot.json)
  */
 export function resolveConfigPath(env = process.env, stateDir = resolveStateDir(env, os.homedir)) {
-    const override = env.PIGBOT_CONFIG_PATH?.trim();
+    const override = env.MOLTBOT_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim();
     if (override)
         return resolveUserPath(override);
-    return path.join(stateDir, "pigbot.json");
+    return path.join(stateDir, CONFIG_FILENAME);
+}
+export const CONFIG_PATH = resolveConfigPath();
+/**
+ * Resolve default config path candidates across new + legacy locations.
+ * Order: explicit config path → state-dir-derived paths → new default → legacy default.
+ */
+export function resolveDefaultConfigCandidates(env = process.env, homedir = os.homedir) {
+    const explicit = env.MOLTBOT_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim();
+    if (explicit)
+        return [resolveUserPath(explicit)];
+    const candidates = [];
+    const moltbotStateDir = env.MOLTBOT_STATE_DIR?.trim();
+    if (moltbotStateDir) {
+        candidates.push(path.join(resolveUserPath(moltbotStateDir), CONFIG_FILENAME));
+    }
+    const legacyStateDirOverride = env.CLAWDBOT_STATE_DIR?.trim();
+    if (legacyStateDirOverride) {
+        candidates.push(path.join(resolveUserPath(legacyStateDirOverride), CONFIG_FILENAME));
+    }
+    candidates.push(path.join(newStateDir(homedir), CONFIG_FILENAME));
+    candidates.push(path.join(legacyStateDir(homedir), CONFIG_FILENAME));
+    return candidates;
 }
-export const CONFIG_PATH_PIGBOT = resolveConfigPath();
 export const DEFAULT_GATEWAY_PORT = 18789;
+/**
+ * Gateway lock directory (ephemeral).
+ * Default: os.tmpdir()/moltbot-<uid> (uid suffix when available).
+ */
+export function resolveGatewayLockDir(tmpdir = os.tmpdir) {
+    const base = tmpdir();
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    const suffix = uid != null ? `moltbot-${uid}` : "moltbot";
+    return path.join(base, suffix);
+}
 const OAUTH_FILENAME = "oauth.json";
 /**
  * OAuth credentials storage directory.
  *
  * Precedence:
- * - `PIGBOT_OAUTH_DIR` (explicit override)
- * - `PIGBOT_STATE_DIR/credentials` (canonical server/default)
- * - `~/.pigbot/credentials` (legacy default)
+ * - `CLAWDBOT_OAUTH_DIR` (explicit override)
+ * - `$*_STATE_DIR/credentials` (canonical server/default)
+ * - `~/.clawdbot/credentials` (legacy default)
  */
 export function resolveOAuthDir(env = process.env, stateDir = resolveStateDir(env, os.homedir)) {
-    const override = env.PIGBOT_OAUTH_DIR?.trim();
+    const override = env.CLAWDBOT_OAUTH_DIR?.trim();
     if (override)
         return resolveUserPath(override);
     return path.join(stateDir, "credentials");
@@ -65,7 +105,7 @@ export function resolveOAuthPath(env = process.env, stateDir = resolveStateDir(e
     return path.join(resolveOAuthDir(env, stateDir), OAUTH_FILENAME);
 }
 export function resolveGatewayPort(cfg, env = process.env) {
-    const envRaw = env.PIGBOT_GATEWAY_PORT?.trim();
+    const envRaw = env.CLAWDBOT_GATEWAY_PORT?.trim();
     if (envRaw) {
         const parsed = Number.parseInt(envRaw, 10);
         if (Number.isFinite(parsed) && parsed > 0)