@gguf/pigbot 0.0.1 → 0.0.2

package/dist/line/template-messages.js

@@ -0,0 +1,258 @@
+/**
+ * Create a confirm template (yes/no style dialog)
+ */
+export function createConfirmTemplate(text, confirmAction, cancelAction, altText) {
+    const template = {
+        type: "confirm",
+        text: text.slice(0, 240), // LINE limit
+        actions: [confirmAction, cancelAction],
+    };
+    return {
+        type: "template",
+        altText: altText?.slice(0, 400) ?? text.slice(0, 400),
+        template,
+    };
+}
+/**
+ * Create a button template with title, text, and action buttons
+ */
+export function createButtonTemplate(title, text, actions, options) {
+    const hasThumbnail = Boolean(options?.thumbnailImageUrl?.trim());
+    const textLimit = hasThumbnail ? 160 : 60;
+    const template = {
+        type: "buttons",
+        title: title.slice(0, 40), // LINE limit
+        text: text.slice(0, textLimit), // LINE limit (60 if no thumbnail, 160 with thumbnail)
+        actions: actions.slice(0, 4), // LINE limit: max 4 actions
+        thumbnailImageUrl: options?.thumbnailImageUrl,
+        imageAspectRatio: options?.imageAspectRatio ?? "rectangle",
+        imageSize: options?.imageSize ?? "cover",
+        imageBackgroundColor: options?.imageBackgroundColor,
+        defaultAction: options?.defaultAction,
+    };
+    return {
+        type: "template",
+        altText: options?.altText?.slice(0, 400) ?? `${title}: ${text}`.slice(0, 400),
+        template,
+    };
+}
+/**
+ * Create a carousel template with multiple columns
+ */
+export function createTemplateCarousel(columns, options) {
+    const template = {
+        type: "carousel",
+        columns: columns.slice(0, 10), // LINE limit: max 10 columns
+        imageAspectRatio: options?.imageAspectRatio ?? "rectangle",
+        imageSize: options?.imageSize ?? "cover",
+    };
+    return {
+        type: "template",
+        altText: options?.altText?.slice(0, 400) ?? "View carousel",
+        template,
+    };
+}
+/**
+ * Create a carousel column for use with createTemplateCarousel
+ */
+export function createCarouselColumn(params) {
+    return {
+        title: params.title?.slice(0, 40),
+        text: params.text.slice(0, 120), // LINE limit
+        actions: params.actions.slice(0, 3), // LINE limit: max 3 actions per column
+        thumbnailImageUrl: params.thumbnailImageUrl,
+        imageBackgroundColor: params.imageBackgroundColor,
+        defaultAction: params.defaultAction,
+    };
+}
+/**
+ * Create an image carousel template (simpler, image-focused carousel)
+ */
+export function createImageCarousel(columns, altText) {
+    const template = {
+        type: "image_carousel",
+        columns: columns.slice(0, 10), // LINE limit: max 10 columns
+    };
+    return {
+        type: "template",
+        altText: altText?.slice(0, 400) ?? "View images",
+        template,
+    };
+}
+/**
+ * Create an image carousel column for use with createImageCarousel
+ */
+export function createImageCarouselColumn(imageUrl, action) {
+    return {
+        imageUrl,
+        action,
+    };
+}
+// ============================================================================
+// Action Helpers (same as rich-menu but re-exported for convenience)
+// ============================================================================
+/**
+ * Create a message action (sends text when tapped)
+ */
+export function messageAction(label, text) {
+    return {
+        type: "message",
+        label: label.slice(0, 20),
+        text: text ?? label,
+    };
+}
+/**
+ * Create a URI action (opens a URL when tapped)
+ */
+export function uriAction(label, uri) {
+    return {
+        type: "uri",
+        label: label.slice(0, 20),
+        uri,
+    };
+}
+/**
+ * Create a postback action (sends data to webhook when tapped)
+ */
+export function postbackAction(label, data, displayText) {
+    return {
+        type: "postback",
+        label: label.slice(0, 20),
+        data: data.slice(0, 300),
+        displayText: displayText?.slice(0, 300),
+    };
+}
+/**
+ * Create a datetime picker action
+ */
+export function datetimePickerAction(label, data, mode, options) {
+    return {
+        type: "datetimepicker",
+        label: label.slice(0, 20),
+        data: data.slice(0, 300),
+        mode,
+        initial: options?.initial,
+        max: options?.max,
+        min: options?.min,
+    };
+}
+// ============================================================================
+// Convenience Builders
+// ============================================================================
+/**
+ * Create a simple yes/no confirmation dialog
+ */
+export function createYesNoConfirm(question, options) {
+    const yesAction = options?.yesData
+        ? postbackAction(options.yesText ?? "Yes", options.yesData, options.yesText ?? "Yes")
+        : messageAction(options?.yesText ?? "Yes");
+    const noAction = options?.noData
+        ? postbackAction(options.noText ?? "No", options.noData, options.noText ?? "No")
+        : messageAction(options?.noText ?? "No");
+    return createConfirmTemplate(question, yesAction, noAction, options?.altText);
+}
+/**
+ * Create a button menu with simple text buttons
+ */
+export function createButtonMenu(title, text, buttons, options) {
+    const actions = buttons.slice(0, 4).map((btn) => messageAction(btn.label, btn.text));
+    return createButtonTemplate(title, text, actions, {
+        thumbnailImageUrl: options?.thumbnailImageUrl,
+        altText: options?.altText,
+    });
+}
+/**
+ * Create a button menu with URL links
+ */
+export function createLinkMenu(title, text, links, options) {
+    const actions = links.slice(0, 4).map((link) => uriAction(link.label, link.url));
+    return createButtonTemplate(title, text, actions, {
+        thumbnailImageUrl: options?.thumbnailImageUrl,
+        altText: options?.altText,
+    });
+}
+/**
+ * Create a simple product/item carousel
+ */
+export function createProductCarousel(products, altText) {
+    const columns = products.slice(0, 10).map((product) => {
+        const actions = [];
+        // Add main action
+        if (product.actionUrl) {
+            actions.push(uriAction(product.actionLabel ?? "View", product.actionUrl));
+        }
+        else if (product.actionData) {
+            actions.push(postbackAction(product.actionLabel ?? "Select", product.actionData));
+        }
+        else {
+            actions.push(messageAction(product.actionLabel ?? "Select", product.title));
+        }
+        return createCarouselColumn({
+            title: product.title,
+            text: product.price
+                ? `${product.description}\n${product.price}`.slice(0, 120)
+                : product.description,
+            thumbnailImageUrl: product.imageUrl,
+            actions,
+        });
+    });
+    return createTemplateCarousel(columns, { altText });
+}
+/**
+ * Convert a TemplateMessagePayload from ReplyPayload to a LINE TemplateMessage
+ */
+export function buildTemplateMessageFromPayload(payload) {
+    switch (payload.type) {
+        case "confirm": {
+            const confirmAction = payload.confirmData.startsWith("http")
+                ? uriAction(payload.confirmLabel, payload.confirmData)
+                : payload.confirmData.includes("=")
+                    ? postbackAction(payload.confirmLabel, payload.confirmData, payload.confirmLabel)
+                    : messageAction(payload.confirmLabel, payload.confirmData);
+            const cancelAction = payload.cancelData.startsWith("http")
+                ? uriAction(payload.cancelLabel, payload.cancelData)
+                : payload.cancelData.includes("=")
+                    ? postbackAction(payload.cancelLabel, payload.cancelData, payload.cancelLabel)
+                    : messageAction(payload.cancelLabel, payload.cancelData);
+            return createConfirmTemplate(payload.text, confirmAction, cancelAction, payload.altText);
+        }
+        case "buttons": {
+            const actions = payload.actions.slice(0, 4).map((action) => {
+                if (action.type === "uri" && action.uri) {
+                    return uriAction(action.label, action.uri);
+                }
+                if (action.type === "postback" && action.data) {
+                    return postbackAction(action.label, action.data, action.label);
+                }
+                // Default to message action
+                return messageAction(action.label, action.data ?? action.label);
+            });
+            return createButtonTemplate(payload.title, payload.text, actions, {
+                thumbnailImageUrl: payload.thumbnailImageUrl,
+                altText: payload.altText,
+            });
+        }
+        case "carousel": {
+            const columns = payload.columns.slice(0, 10).map((col) => {
+                const colActions = col.actions.slice(0, 3).map((action) => {
+                    if (action.type === "uri" && action.uri) {
+                        return uriAction(action.label, action.uri);
+                    }
+                    if (action.type === "postback" && action.data) {
+                        return postbackAction(action.label, action.data, action.label);
+                    }
+                    return messageAction(action.label, action.data ?? action.label);
+                });
+                return createCarouselColumn({
+                    title: col.title,
+                    text: col.text,
+                    thumbnailImageUrl: col.thumbnailImageUrl,
+                    actions: colActions,
+                });
+            });
+            return createTemplateCarousel(columns, { altText: payload.altText });
+        }
+        default:
+            return null;
+    }
+}

package/dist/line/types.js

@@ -0,0 +1 @@
+export {};

package/dist/line/webhook.js

@@ -0,0 +1,71 @@
+import { logVerbose, danger } from "../globals.js";
+import { validateLineSignature } from "./signature.js";
+function readRawBody(req) {
+    const rawBody = req.rawBody ??
+        (typeof req.body === "string" || Buffer.isBuffer(req.body) ? req.body : null);
+    if (!rawBody)
+        return null;
+    return Buffer.isBuffer(rawBody) ? rawBody.toString("utf-8") : rawBody;
+}
+function parseWebhookBody(req, rawBody) {
+    if (req.body && typeof req.body === "object" && !Buffer.isBuffer(req.body)) {
+        return req.body;
+    }
+    try {
+        return JSON.parse(rawBody);
+    }
+    catch {
+        return null;
+    }
+}
+export function createLineWebhookMiddleware(options) {
+    const { channelSecret, onEvents, runtime } = options;
+    return async (req, res, _next) => {
+        try {
+            const signature = req.headers["x-line-signature"];
+            if (!signature || typeof signature !== "string") {
+                res.status(400).json({ error: "Missing X-Line-Signature header" });
+                return;
+            }
+            const rawBody = readRawBody(req);
+            if (!rawBody) {
+                res.status(400).json({ error: "Missing raw request body for signature verification" });
+                return;
+            }
+            if (!validateLineSignature(rawBody, signature, channelSecret)) {
+                logVerbose("line: webhook signature validation failed");
+                res.status(401).json({ error: "Invalid signature" });
+                return;
+            }
+            const body = parseWebhookBody(req, rawBody);
+            if (!body) {
+                res.status(400).json({ error: "Invalid webhook payload" });
+                return;
+            }
+            // Respond immediately to avoid timeout
+            res.status(200).json({ status: "ok" });
+            // Process events asynchronously
+            if (body.events && body.events.length > 0) {
+                logVerbose(`line: received ${body.events.length} webhook events`);
+                await onEvents(body).catch((err) => {
+                    runtime?.error?.(danger(`line webhook handler failed: ${String(err)}`));
+                });
+            }
+        }
+        catch (err) {
+            runtime?.error?.(danger(`line webhook error: ${String(err)}`));
+            if (!res.headersSent) {
+                res.status(500).json({ error: "Internal server error" });
+            }
+        }
+    };
+}
+export function startLineWebhook(options) {
+    const path = options.path ?? "/line/webhook";
+    const middleware = createLineWebhookMiddleware({
+        channelSecret: options.channelSecret,
+        onEvents: options.onEvents,
+        runtime: options.runtime,
+    });
+    return { path, handler: middleware };
+}

package/dist/link-understanding/apply.js

@@ -0,0 +1,22 @@
+import { finalizeInboundContext } from "../auto-reply/reply/inbound-context.js";
+import { formatLinkUnderstandingBody } from "./format.js";
+import { runLinkUnderstanding } from "./runner.js";
+export async function applyLinkUnderstanding(params) {
+    const result = await runLinkUnderstanding({
+        cfg: params.cfg,
+        ctx: params.ctx,
+    });
+    if (result.outputs.length === 0) {
+        return result;
+    }
+    params.ctx.LinkUnderstanding = [...(params.ctx.LinkUnderstanding ?? []), ...result.outputs];
+    params.ctx.Body = formatLinkUnderstandingBody({
+        body: params.ctx.Body,
+        outputs: result.outputs,
+    });
+    finalizeInboundContext(params.ctx, {
+        forceBodyForAgent: true,
+        forceBodyForCommands: true,
+    });
+    return result;
+}

package/dist/link-understanding/defaults.js

@@ -0,0 +1,2 @@
+export const DEFAULT_LINK_TIMEOUT_SECONDS = 30;
+export const DEFAULT_MAX_LINKS = 3;

package/dist/link-understanding/detect.js

@@ -0,0 +1,49 @@
+import { DEFAULT_MAX_LINKS } from "./defaults.js";
+// Remove markdown link syntax so only bare URLs are considered.
+const MARKDOWN_LINK_RE = /\[[^\]]*]\((https?:\/\/\S+?)\)/gi;
+const BARE_LINK_RE = /https?:\/\/\S+/gi;
+function stripMarkdownLinks(message) {
+    return message.replace(MARKDOWN_LINK_RE, " ");
+}
+function resolveMaxLinks(value) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return Math.floor(value);
+    }
+    return DEFAULT_MAX_LINKS;
+}
+function isAllowedUrl(raw) {
+    try {
+        const parsed = new URL(raw);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+            return false;
+        if (parsed.hostname === "127.0.0.1")
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function extractLinksFromMessage(message, opts) {
+    const source = message?.trim();
+    if (!source)
+        return [];
+    const maxLinks = resolveMaxLinks(opts?.maxLinks);
+    const sanitized = stripMarkdownLinks(source);
+    const seen = new Set();
+    const results = [];
+    for (const match of sanitized.matchAll(BARE_LINK_RE)) {
+        const raw = match[0]?.trim();
+        if (!raw)
+            continue;
+        if (!isAllowedUrl(raw))
+            continue;
+        if (seen.has(raw))
+            continue;
+        seen.add(raw);
+        results.push(raw);
+        if (results.length >= maxLinks)
+            break;
+    }
+    return results;
+}

package/dist/link-understanding/format.js

@@ -0,0 +1,10 @@
+export function formatLinkUnderstandingBody(params) {
+    const outputs = params.outputs.map((output) => output.trim()).filter(Boolean);
+    if (outputs.length === 0) {
+        return params.body ?? "";
+    }
+    const base = (params.body ?? "").trim();
+    if (!base)
+        return outputs.join("\n");
+    return `${base}\n\n${outputs.join("\n")}`;
+}

package/dist/link-understanding/index.js

@@ -0,0 +1,4 @@
+export { applyLinkUnderstanding } from "./apply.js";
+export { extractLinksFromMessage } from "./detect.js";
+export { formatLinkUnderstandingBody } from "./format.js";
+export { runLinkUnderstanding } from "./runner.js";

package/dist/link-understanding/runner.js

@@ -0,0 +1,99 @@
+import { applyTemplate } from "../auto-reply/templating.js";
+import { logVerbose, shouldLogVerbose } from "../globals.js";
+import { runExec } from "../process/exec.js";
+import { CLI_OUTPUT_MAX_BUFFER } from "../media-understanding/defaults.js";
+import { resolveTimeoutMs } from "../media-understanding/resolve.js";
+import { normalizeMediaUnderstandingChatType, resolveMediaUnderstandingScope, } from "../media-understanding/scope.js";
+import { DEFAULT_LINK_TIMEOUT_SECONDS } from "./defaults.js";
+import { extractLinksFromMessage } from "./detect.js";
+function resolveScopeDecision(params) {
+    return resolveMediaUnderstandingScope({
+        scope: params.config?.scope,
+        sessionKey: params.ctx.SessionKey,
+        channel: params.ctx.Surface ?? params.ctx.Provider,
+        chatType: normalizeMediaUnderstandingChatType(params.ctx.ChatType),
+    });
+}
+function resolveTimeoutMsFromConfig(params) {
+    const configured = params.entry.timeoutSeconds ?? params.config?.timeoutSeconds;
+    return resolveTimeoutMs(configured, DEFAULT_LINK_TIMEOUT_SECONDS);
+}
+async function runCliEntry(params) {
+    if ((params.entry.type ?? "cli") !== "cli")
+        return null;
+    const command = params.entry.command.trim();
+    if (!command)
+        return null;
+    const args = params.entry.args ?? [];
+    const timeoutMs = resolveTimeoutMsFromConfig({ config: params.config, entry: params.entry });
+    const templCtx = {
+        ...params.ctx,
+        LinkUrl: params.url,
+    };
+    const argv = [command, ...args].map((part, index) => index === 0 ? part : applyTemplate(part, templCtx));
+    if (shouldLogVerbose()) {
+        logVerbose(`Link understanding via CLI: ${argv.join(" ")}`);
+    }
+    const { stdout } = await runExec(argv[0], argv.slice(1), {
+        timeoutMs,
+        maxBuffer: CLI_OUTPUT_MAX_BUFFER,
+    });
+    const trimmed = stdout.trim();
+    return trimmed || null;
+}
+async function runLinkEntries(params) {
+    let lastError;
+    for (const entry of params.entries) {
+        try {
+            const output = await runCliEntry({
+                entry,
+                ctx: params.ctx,
+                url: params.url,
+                config: params.config,
+            });
+            if (output)
+                return output;
+        }
+        catch (err) {
+            lastError = err;
+            if (shouldLogVerbose()) {
+                logVerbose(`Link understanding failed for ${params.url}: ${String(err)}`);
+            }
+        }
+    }
+    if (lastError && shouldLogVerbose()) {
+        logVerbose(`Link understanding exhausted for ${params.url}`);
+    }
+    return null;
+}
+export async function runLinkUnderstanding(params) {
+    const config = params.cfg.tools?.links;
+    if (!config || config.enabled === false)
+        return { urls: [], outputs: [] };
+    const scopeDecision = resolveScopeDecision({ config, ctx: params.ctx });
+    if (scopeDecision === "deny") {
+        if (shouldLogVerbose()) {
+            logVerbose("Link understanding disabled by scope policy.");
+        }
+        return { urls: [], outputs: [] };
+    }
+    const message = params.message ?? params.ctx.CommandBody ?? params.ctx.RawBody ?? params.ctx.Body;
+    const links = extractLinksFromMessage(message ?? "", { maxLinks: config?.maxLinks });
+    if (links.length === 0)
+        return { urls: [], outputs: [] };
+    const entries = config?.models ?? [];
+    if (entries.length === 0)
+        return { urls: links, outputs: [] };
+    const outputs = [];
+    for (const url of links) {
+        const output = await runLinkEntries({
+            entries,
+            ctx: params.ctx,
+            url,
+            config,
+        });
+        if (output)
+            outputs.push(output);
+    }
+    return { urls: links, outputs };
+}

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/pigbot";
-export const DEFAULT_LOG_FILE = path.join(DEFAULT_LOG_DIR, "pigbot.log"); // legacy single-file path
-const LOG_PREFIX = "pigbot";
+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";
 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: "pigbot",
+        name: "moltbot",
         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 __PIGBOT_VERSION__ === "string" && __PIGBOT_VERSION__) ||
-    process.env.PIGBOT_BUNDLED_VERSION ||
+const BUNDLED_VERSION = (typeof __CLAWDBOT_VERSION__ === "string" && __CLAWDBOT_VERSION__) ||
+    process.env.CLAWDBOT_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 `pigbot --version` behavior for Swift env/version checks.
+        // Match `moltbot --version` behavior for Swift env/version checks.
         // Keep output a single line.
         console.log(BUNDLED_VERSION);
         process.exit(0);
@@ -47,7 +47,7 @@ async function main() {
     setGatewayWsLogStyle(wsLogStyle);
     const cfg = loadConfig();
     const portRaw = argValue(args, "--port") ??
-        process.env.PIGBOT_GATEWAY_PORT ??
+        process.env.CLAWDBOT_GATEWAY_PORT ??
         (typeof cfg.gateway?.port === "number" ? String(cfg.gateway.port) : "") ??
         "18789";
     const port = Number.parseInt(portRaw, 10);
@@ -56,7 +56,7 @@ async function main() {
         process.exit(1);
     }
     const bindRaw = argValue(args, "--bind") ??
-        process.env.PIGBOT_GATEWAY_BIND ??
+        process.env.CLAWDBOT_GATEWAY_BIND ??
         cfg.gateway?.bind ??
         "loopback";
     const bind = bindRaw === "loopback" ||
@@ -72,7 +72,7 @@ async function main() {
     }
     const token = argValue(args, "--token");
     if (token)
-        process.env.PIGBOT_GATEWAY_TOKEN = token;
+        process.env.CLAWDBOT_GATEWAY_TOKEN = token;
     let server = null;
     let lock = null;
     let shuttingDown = false;
@@ -173,6 +173,6 @@ async function main() {
     }
 }
 void main().catch((err) => {
-    console.error("[pigbot] Gateway daemon failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+    console.error("[moltbot] 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.PIGBOT_SMOKE_QR === "1" || env.PIGBOT_SMOKE === "qr")) {
+    if (args.length === 0 && (env.CLAWDBOT_SMOKE_QR === "1" || env.CLAWDBOT_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 __PIGBOT_VERSION__ === "string" && __PIGBOT_VERSION__) ||
-    process.env.PIGBOT_BUNDLED_VERSION ||
+const BUNDLED_VERSION = (typeof __CLAWDBOT_VERSION__ === "string" && __CLAWDBOT_VERSION__) ||
+    process.env.CLAWDBOT_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 { ensurePigbotCliOnPath } = await import("../infra/path-env.js");
-    ensurePigbotCliOnPath();
+    const { ensureMoltbotCliOnPath } = await import("../infra/path-env.js");
+    ensureMoltbotCliOnPath();
     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("[pigbot] Uncaught exception:", formatUncaughtError(error));
+        console.error("[moltbot] Uncaught exception:", formatUncaughtError(error));
         process.exit(1);
     });
     await program.parseAsync(process.argv);
 }
 void main().catch((err) => {
-    console.error("[pigbot] Relay failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+    console.error("[moltbot] 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("pigbot webhook")}\`/\`${formatCliCommand("pigbot up")}\` or re-run with --serve-media.`);
+        throw new Error(`Media hosting requires the webhook/Funnel server. Start \`${formatCliCommand("moltbot webhook")}\`/\`${formatCliCommand("moltbot 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.PIGBOT_IMAGE_BACKEND === "sips" ||
-        (process.env.PIGBOT_IMAGE_BACKEND !== "sharp" && isBun() && process.platform === "darwin"));
+    return (process.env.CLAWDBOT_IMAGE_BACKEND === "sips" ||
+        (process.env.CLAWDBOT_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(), "pigbot-img-"));
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-img-"));
     try {
         return await fn(dir);
     }