@gguf/pigbot 0.0.1 → 0.0.2

package/dist/infra/update-runner.js

@@ -10,6 +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"]);
 function normalizeDir(value) {
     if (!value)
         return null;
@@ -57,6 +59,17 @@ async function readPackageVersion(root) {
         return null;
     }
 }
+async function readPackageName(root) {
+    try {
+        const raw = await fs.readFile(path.join(root, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        const name = parsed?.name?.trim();
+        return name ? name : null;
+    }
+    catch {
+        return null;
+    }
+}
 async function readBranchName(runCommand, root, timeoutMs) {
     const res = await runCommand(["git", "-C", root, "rev-parse", "--abbrev-ref", "HEAD"], {
         timeoutMs,
@@ -114,7 +127,8 @@ async function findPackageRoot(candidates) {
             try {
                 const raw = await fs.readFile(pkgPath, "utf-8");
                 const parsed = JSON.parse(raw);
-                if (parsed?.name === "pigbot")
+                const name = parsed?.name?.trim();
+                if (name && CORE_PACKAGE_NAMES.has(name))
                     return current;
             }
             catch {
@@ -198,7 +212,12 @@ function normalizeTag(tag) {
     const trimmed = tag?.trim();
     if (!trimmed)
         return "latest";
-    return trimmed.startsWith("pigbot@") ? trimmed.slice("pigbot@".length) : trimmed;
+    if (trimmed.startsWith("moltbot@"))
+        return trimmed.slice("moltbot@".length);
+    if (trimmed.startsWith(`${DEFAULT_PACKAGE_NAME}@`)) {
+        return trimmed.slice(`${DEFAULT_PACKAGE_NAME}@`.length);
+    }
+    return trimmed;
 }
 export async function runGatewayUpdate(opts = {}) {
     const startedAt = Date.now();
@@ -238,7 +257,7 @@ export async function runGatewayUpdate(opts = {}) {
             status: "error",
             mode: "unknown",
             root: gitRoot,
-            reason: "not-pigbot-root",
+            reason: "not-moltbot-root",
             steps: [],
             durationMs: Date.now() - startedAt,
         };
@@ -254,8 +273,8 @@ export async function runGatewayUpdate(opts = {}) {
         const channel = opts.channel ?? "dev";
         const branch = channel === "dev" ? await readBranchName(runCommand, gitRoot, timeoutMs) : null;
         const needsCheckoutMain = channel === "dev" && branch !== DEV_BRANCH;
-        gitTotalSteps = channel === "dev" ? (needsCheckoutMain ? 10 : 9) : 8;
-        const statusCheck = await runStep(step("clean check", ["git", "-C", gitRoot, "status", "--porcelain"], gitRoot));
+        gitTotalSteps = channel === "dev" ? (needsCheckoutMain ? 11 : 10) : 9;
+        const statusCheck = await runStep(step("clean check", ["git", "-C", gitRoot, "status", "--porcelain", "--", ":!dist/control-ui/"], gitRoot));
         steps.push(statusCheck);
         const hasUncommittedChanges = statusCheck.stdoutTail && statusCheck.stdoutTail.trim().length > 0;
         if (hasUncommittedChanges) {
@@ -351,7 +370,7 @@ export async function runGatewayUpdate(opts = {}) {
                 };
             }
             const manager = await detectPackageManager(gitRoot);
-            const preflightRoot = await fs.mkdtemp(path.join(os.tmpdir(), "pigbot-update-preflight-"));
+            const preflightRoot = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-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);
@@ -485,7 +504,11 @@ export async function runGatewayUpdate(opts = {}) {
         steps.push(buildStep);
         const uiBuildStep = await runStep(step("ui:build", managerScriptArgs(manager, "ui:build"), gitRoot));
         steps.push(uiBuildStep);
-        const doctorStep = await runStep(step("pigbot doctor", managerScriptArgs(manager, "pigbot", ["doctor", "--non-interactive"]), gitRoot, { PIGBOT_UPDATE_IN_PROGRESS: "1" }));
+        // Restore dist/control-ui/ to committed state to prevent dirty repo after update
+        // (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" }));
         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));
@@ -517,7 +540,8 @@ export async function runGatewayUpdate(opts = {}) {
     const beforeVersion = await readPackageVersion(pkgRoot);
     const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs);
     if (globalManager) {
-        const spec = `pigbot@${normalizeTag(opts.tag)}`;
+        const packageName = (await readPackageName(pkgRoot)) ?? DEFAULT_PACKAGE_NAME;
+        const spec = `${packageName}@${normalizeTag(opts.tag)}`;
         const updateStep = await runStep({
             runCommand,
             name: "global update",

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 { resolvePigbotPackageRoot } from "./pigbot-root.js";
+import { resolveMoltbotPackageRoot } from "./moltbot-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 resolvePigbotPackageRoot({
+    const root = await resolveMoltbotPackageRoot({
         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("pigbot update")}`);
+            params.log.info(`update available (${tag}): v${resolved.version} (current v${VERSION}). Run: ${formatCliCommand("moltbot update")}`);
             nextState.lastNotifiedVersion = resolved.version;
             nextState.lastNotifiedTag = tag;
         }

package/dist/infra/warnings.js

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

package/dist/infra/widearea-dns.js

@@ -2,8 +2,8 @@ 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 = "pigbot.internal.";
-export const WIDE_AREA_ZONE_FILENAME = "pigbot.internal.db";
+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);
 }
@@ -45,7 +45,7 @@ function extractSerial(zoneText) {
     return Number.isFinite(parsed) ? parsed : null;
 }
 function extractContentHash(zoneText) {
-    const match = zoneText.match(/^\s*;\s*pigbot-content-hash:\s*(\S+)\s*$/m);
+    const match = zoneText.match(/^\s*;\s*moltbot-content-hash:\s*(\S+)\s*$/m);
     return match?.[1] ?? null;
 }
 function computeContentHash(body) {
@@ -58,9 +58,9 @@ function computeContentHash(body) {
     return (h >>> 0).toString(16).padStart(8, "0");
 }
 function renderZone(opts) {
-    const hostname = os.hostname().split(".")[0] ?? "pigbot";
-    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "pigbot");
-    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "pigbot-gw");
+    const hostname = os.hostname().split(".")[0] ?? "moltbot";
+    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "moltbot");
+    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "moltbot-gw");
     const txt = [
         `displayName=${opts.displayName.trim() || hostname}`,
         `role=gateway`,
@@ -93,15 +93,15 @@ function renderZone(opts) {
     if (opts.tailnetIPv6) {
         records.push(`${hostLabel} IN AAAA ${opts.tailnetIPv6}`);
     }
-    records.push(`_pigbot-gw._tcp IN PTR ${instanceLabel}._pigbot-gw._tcp`);
-    records.push(`${instanceLabel}._pigbot-gw._tcp IN SRV 0 0 ${opts.gatewayPort} ${hostLabel}`);
-    records.push(`${instanceLabel}._pigbot-gw._tcp IN TXT ${txt.map(txtQuote).join(" ")}`);
+    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(" ")}`);
     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 `; pigbot-content-hash: ${contentHash}\n${contentBody}`;
+    return `; moltbot-content-hash: ${contentHash}\n${contentBody}`;
 }
 export function renderWideAreaGatewayZoneText(opts) {
     return renderZone(opts);

package/dist/line/accounts.js

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+export const DEFAULT_ACCOUNT_ID = "default";
+function readFileIfExists(filePath) {
+    if (!filePath)
+        return undefined;
+    try {
+        return fs.readFileSync(filePath, "utf-8").trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveToken(params) {
+    const { accountId, baseConfig, accountConfig } = params;
+    // Check account-level config first
+    if (accountConfig?.channelAccessToken?.trim()) {
+        return { token: accountConfig.channelAccessToken.trim(), tokenSource: "config" };
+    }
+    // Check account-level token file
+    const accountFileToken = readFileIfExists(accountConfig?.tokenFile);
+    if (accountFileToken) {
+        return { token: accountFileToken, tokenSource: "file" };
+    }
+    // For default account, check base config and env
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+        if (baseConfig?.channelAccessToken?.trim()) {
+            return { token: baseConfig.channelAccessToken.trim(), tokenSource: "config" };
+        }
+        const baseFileToken = readFileIfExists(baseConfig?.tokenFile);
+        if (baseFileToken) {
+            return { token: baseFileToken, tokenSource: "file" };
+        }
+        const envToken = process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim();
+        if (envToken) {
+            return { token: envToken, tokenSource: "env" };
+        }
+    }
+    return { token: "", tokenSource: "none" };
+}
+function resolveSecret(params) {
+    const { accountId, baseConfig, accountConfig } = params;
+    // Check account-level config first
+    if (accountConfig?.channelSecret?.trim()) {
+        return accountConfig.channelSecret.trim();
+    }
+    // Check account-level secret file
+    const accountFileSecret = readFileIfExists(accountConfig?.secretFile);
+    if (accountFileSecret) {
+        return accountFileSecret;
+    }
+    // For default account, check base config and env
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+        if (baseConfig?.channelSecret?.trim()) {
+            return baseConfig.channelSecret.trim();
+        }
+        const baseFileSecret = readFileIfExists(baseConfig?.secretFile);
+        if (baseFileSecret) {
+            return baseFileSecret;
+        }
+        const envSecret = process.env.LINE_CHANNEL_SECRET?.trim();
+        if (envSecret) {
+            return envSecret;
+        }
+    }
+    return "";
+}
+export function resolveLineAccount(params) {
+    const { cfg, accountId = DEFAULT_ACCOUNT_ID } = params;
+    const lineConfig = cfg.channels?.line;
+    const accounts = lineConfig?.accounts;
+    const accountConfig = accountId !== DEFAULT_ACCOUNT_ID ? accounts?.[accountId] : undefined;
+    const { token, tokenSource } = resolveToken({
+        accountId,
+        baseConfig: lineConfig,
+        accountConfig,
+    });
+    const secret = resolveSecret({
+        accountId,
+        baseConfig: lineConfig,
+        accountConfig,
+    });
+    const mergedConfig = {
+        ...lineConfig,
+        ...accountConfig,
+    };
+    const enabled = accountConfig?.enabled ??
+        (accountId === DEFAULT_ACCOUNT_ID ? (lineConfig?.enabled ?? true) : false);
+    const name = accountConfig?.name ?? (accountId === DEFAULT_ACCOUNT_ID ? lineConfig?.name : undefined);
+    return {
+        accountId,
+        name,
+        enabled,
+        channelAccessToken: token,
+        channelSecret: secret,
+        tokenSource,
+        config: mergedConfig,
+    };
+}
+export function listLineAccountIds(cfg) {
+    const lineConfig = cfg.channels?.line;
+    const accounts = lineConfig?.accounts;
+    const ids = new Set();
+    // Add default account if configured at base level
+    if (lineConfig?.channelAccessToken?.trim() ||
+        lineConfig?.tokenFile ||
+        process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim()) {
+        ids.add(DEFAULT_ACCOUNT_ID);
+    }
+    // Add named accounts
+    if (accounts) {
+        for (const id of Object.keys(accounts)) {
+            ids.add(id);
+        }
+    }
+    return Array.from(ids);
+}
+export function resolveDefaultLineAccountId(cfg) {
+    const ids = listLineAccountIds(cfg);
+    if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+        return DEFAULT_ACCOUNT_ID;
+    }
+    return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+export function normalizeAccountId(accountId) {
+    const trimmed = accountId?.trim().toLowerCase();
+    if (!trimmed || trimmed === "default") {
+        return DEFAULT_ACCOUNT_ID;
+    }
+    return trimmed;
+}

package/dist/line/auto-reply-delivery.js

@@ -0,0 +1,102 @@
+export async function deliverLineAutoReply(params) {
+    const { payload, lineData, replyToken, accountId, to, textLimit, deps } = params;
+    let replyTokenUsed = params.replyTokenUsed;
+    const pushLineMessages = async (messages) => {
+        if (messages.length === 0)
+            return;
+        for (let i = 0; i < messages.length; i += 5) {
+            await deps.pushMessagesLine(to, messages.slice(i, i + 5), {
+                accountId,
+            });
+        }
+    };
+    const sendLineMessages = async (messages, allowReplyToken) => {
+        if (messages.length === 0)
+            return;
+        let remaining = messages;
+        if (allowReplyToken && replyToken && !replyTokenUsed) {
+            const replyBatch = remaining.slice(0, 5);
+            try {
+                await deps.replyMessageLine(replyToken, replyBatch, {
+                    accountId,
+                });
+            }
+            catch (err) {
+                deps.onReplyError?.(err);
+                await pushLineMessages(replyBatch);
+            }
+            replyTokenUsed = true;
+            remaining = remaining.slice(replyBatch.length);
+        }
+        if (remaining.length > 0) {
+            await pushLineMessages(remaining);
+        }
+    };
+    const richMessages = [];
+    const hasQuickReplies = Boolean(lineData.quickReplies?.length);
+    if (lineData.flexMessage) {
+        richMessages.push(deps.createFlexMessage(lineData.flexMessage.altText.slice(0, 400), lineData.flexMessage.contents));
+    }
+    if (lineData.templateMessage) {
+        const templateMsg = deps.buildTemplateMessageFromPayload(lineData.templateMessage);
+        if (templateMsg) {
+            richMessages.push(templateMsg);
+        }
+    }
+    if (lineData.location) {
+        richMessages.push(deps.createLocationMessage(lineData.location));
+    }
+    const processed = payload.text
+        ? deps.processLineMessage(payload.text)
+        : { text: "", flexMessages: [] };
+    for (const flexMsg of processed.flexMessages) {
+        richMessages.push(deps.createFlexMessage(flexMsg.altText.slice(0, 400), flexMsg.contents));
+    }
+    const chunks = processed.text ? deps.chunkMarkdownText(processed.text, textLimit) : [];
+    const mediaUrls = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+    const mediaMessages = mediaUrls
+        .map((url) => url?.trim())
+        .filter((url) => Boolean(url))
+        .map((url) => deps.createImageMessage(url));
+    if (chunks.length > 0) {
+        const hasRichOrMedia = richMessages.length > 0 || mediaMessages.length > 0;
+        if (hasQuickReplies && hasRichOrMedia) {
+            try {
+                await sendLineMessages([...richMessages, ...mediaMessages], false);
+            }
+            catch (err) {
+                deps.onReplyError?.(err);
+            }
+        }
+        const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
+            to,
+            chunks,
+            quickReplies: lineData.quickReplies,
+            replyToken,
+            replyTokenUsed,
+            accountId,
+            replyMessageLine: deps.replyMessageLine,
+            pushMessageLine: deps.pushMessageLine,
+            pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
+            createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
+        });
+        replyTokenUsed = nextReplyTokenUsed;
+        if (!hasQuickReplies || !hasRichOrMedia) {
+            await sendLineMessages(richMessages, false);
+            if (mediaMessages.length > 0) {
+                await sendLineMessages(mediaMessages, false);
+            }
+        }
+    }
+    else {
+        const combined = [...richMessages, ...mediaMessages];
+        if (hasQuickReplies && combined.length > 0) {
+            const quickReply = deps.createQuickReplyItems(lineData.quickReplies);
+            const targetIndex = replyToken && !replyTokenUsed ? Math.min(4, combined.length - 1) : combined.length - 1;
+            const target = combined[targetIndex];
+            combined[targetIndex] = { ...target, quickReply };
+        }
+        await sendLineMessages(combined, true);
+    }
+    return { replyTokenUsed };
+}

package/dist/line/bot-access.js

@@ -0,0 +1,38 @@
+function normalizeAllowEntry(value) {
+    const trimmed = String(value).trim();
+    if (!trimmed)
+        return "";
+    if (trimmed === "*")
+        return "*";
+    return trimmed.replace(/^line:(?:user:)?/i, "");
+}
+export const normalizeAllowFrom = (list) => {
+    const entries = (list ?? []).map((value) => normalizeAllowEntry(value)).filter(Boolean);
+    const hasWildcard = entries.includes("*");
+    return {
+        entries,
+        hasWildcard,
+        hasEntries: entries.length > 0,
+    };
+};
+export const normalizeAllowFromWithStore = (params) => {
+    const combined = [...(params.allowFrom ?? []), ...(params.storeAllowFrom ?? [])];
+    return normalizeAllowFrom(combined);
+};
+export const firstDefined = (...values) => {
+    for (const value of values) {
+        if (typeof value !== "undefined")
+            return value;
+    }
+    return undefined;
+};
+export const isSenderAllowed = (params) => {
+    const { allow, senderId } = params;
+    if (!allow.hasEntries)
+        return false;
+    if (allow.hasWildcard)
+        return true;
+    if (!senderId)
+        return false;
+    return allow.entries.includes(senderId);
+};