clawdbot 2026.1.4-1

package/dist/config/legacy.js

@@ -0,0 +1,159 @@
+const LEGACY_CONFIG_RULES = [
+    {
+        path: ["routing", "allowFrom"],
+        message: "routing.allowFrom was removed; use whatsapp.allowFrom instead (run `clawdbot doctor` to migrate).",
+    },
+    {
+        path: ["routing", "groupChat", "requireMention"],
+        message: 'routing.groupChat.requireMention was removed; use whatsapp/telegram/imessage groups defaults (e.g. whatsapp.groups."*".requireMention) instead (run `clawdbot doctor` to migrate).',
+    },
+    {
+        path: ["telegram", "requireMention"],
+        message: 'telegram.requireMention was removed; use telegram.groups."*".requireMention instead (run `clawdbot doctor` to migrate).',
+    },
+];
+const LEGACY_CONFIG_MIGRATIONS = [
+    {
+        id: "routing.allowFrom->whatsapp.allowFrom",
+        describe: "Move routing.allowFrom to whatsapp.allowFrom",
+        apply: (raw, changes) => {
+            const routing = raw.routing;
+            if (!routing || typeof routing !== "object")
+                return;
+            const allowFrom = routing.allowFrom;
+            if (allowFrom === undefined)
+                return;
+            const whatsapp = raw.whatsapp && typeof raw.whatsapp === "object"
+                ? raw.whatsapp
+                : {};
+            if (whatsapp.allowFrom === undefined) {
+                whatsapp.allowFrom = allowFrom;
+                changes.push("Moved routing.allowFrom → whatsapp.allowFrom.");
+            }
+            else {
+                changes.push("Removed routing.allowFrom (whatsapp.allowFrom already set).");
+            }
+            delete routing.allowFrom;
+            if (Object.keys(routing).length === 0) {
+                delete raw.routing;
+            }
+            raw.whatsapp = whatsapp;
+        },
+    },
+    {
+        id: "routing.groupChat.requireMention->groups.*.requireMention",
+        describe: "Move routing.groupChat.requireMention to whatsapp/telegram/imessage groups",
+        apply: (raw, changes) => {
+            const routing = raw.routing;
+            if (!routing || typeof routing !== "object")
+                return;
+            const groupChat = routing.groupChat &&
+                typeof routing.groupChat === "object"
+                ? routing.groupChat
+                : null;
+            if (!groupChat)
+                return;
+            const requireMention = groupChat.requireMention;
+            if (requireMention === undefined)
+                return;
+            const applyTo = (key) => {
+                const section = raw[key] && typeof raw[key] === "object"
+                    ? raw[key]
+                    : {};
+                const groups = section.groups && typeof section.groups === "object"
+                    ? section.groups
+                    : {};
+                const defaultKey = "*";
+                const entry = groups[defaultKey] && typeof groups[defaultKey] === "object"
+                    ? groups[defaultKey]
+                    : {};
+                if (entry.requireMention === undefined) {
+                    entry.requireMention = requireMention;
+                    groups[defaultKey] = entry;
+                    section.groups = groups;
+                    raw[key] = section;
+                    changes.push(`Moved routing.groupChat.requireMention → ${key}.groups."*".requireMention.`);
+                }
+                else {
+                    changes.push(`Removed routing.groupChat.requireMention (${key}.groups."*" already set).`);
+                }
+            };
+            applyTo("whatsapp");
+            applyTo("telegram");
+            applyTo("imessage");
+            delete groupChat.requireMention;
+            if (Object.keys(groupChat).length === 0) {
+                delete routing.groupChat;
+            }
+            if (Object.keys(routing).length === 0) {
+                delete raw.routing;
+            }
+        },
+    },
+    {
+        id: "telegram.requireMention->telegram.groups.*.requireMention",
+        describe: "Move telegram.requireMention to telegram.groups.*.requireMention",
+        apply: (raw, changes) => {
+            const telegram = raw.telegram;
+            if (!telegram || typeof telegram !== "object")
+                return;
+            const requireMention = telegram
+                .requireMention;
+            if (requireMention === undefined)
+                return;
+            const groups = telegram.groups &&
+                typeof telegram.groups === "object"
+                ? telegram.groups
+                : {};
+            const defaultKey = "*";
+            const entry = groups[defaultKey] && typeof groups[defaultKey] === "object"
+                ? groups[defaultKey]
+                : {};
+            if (entry.requireMention === undefined) {
+                entry.requireMention = requireMention;
+                groups[defaultKey] = entry;
+                telegram.groups = groups;
+                changes.push('Moved telegram.requireMention → telegram.groups."*".requireMention.');
+            }
+            else {
+                changes.push('Removed telegram.requireMention (telegram.groups."*" already set).');
+            }
+            delete telegram.requireMention;
+            if (Object.keys(telegram).length === 0) {
+                delete raw.telegram;
+            }
+        },
+    },
+];
+export function findLegacyConfigIssues(raw) {
+    if (!raw || typeof raw !== "object")
+        return [];
+    const root = raw;
+    const issues = [];
+    for (const rule of LEGACY_CONFIG_RULES) {
+        let cursor = root;
+        for (const key of rule.path) {
+            if (!cursor || typeof cursor !== "object") {
+                cursor = undefined;
+                break;
+            }
+            cursor = cursor[key];
+        }
+        if (cursor !== undefined) {
+            issues.push({ path: rule.path.join("."), message: rule.message });
+        }
+    }
+    return issues;
+}
+export function applyLegacyMigrations(raw) {
+    if (!raw || typeof raw !== "object")
+        return { next: null, changes: [] };
+    const next = structuredClone(raw);
+    const changes = [];
+    for (const migration of LEGACY_CONFIG_MIGRATIONS) {
+        migration.apply(next, changes);
+    }
+    if (changes.length === 0)
+        return { next: null, changes: [] };
+    return { next, changes };
+}

package/dist/config/paths.js

@@ -0,0 +1,71 @@
+import os from "node:os";
+import path from "node:path";
+import { resolveUserPath } from "../utils.js";
+/**
+ * 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.CLAWDBOT_NIX_MODE === "1";
+}
+export const isNixMode = resolveIsNixMode();
+/**
+ * State directory for mutable data (sessions, logs, caches).
+ * Can be overridden via CLAWDBOT_STATE_DIR environment variable.
+ * Default: ~/.clawdbot
+ */
+export function resolveStateDir(env = process.env, homedir = os.homedir) {
+    const override = env.CLAWDBOT_STATE_DIR?.trim();
+    if (override)
+        return override;
+    return path.join(homedir(), ".clawdbot");
+}
+export const STATE_DIR_CLAWDBOT = resolveStateDir();
+/**
+ * Config file path (JSON5).
+ * Can be overridden via CLAWDBOT_CONFIG_PATH environment variable.
+ * Default: ~/.clawdbot/clawdbot.json (or $CLAWDBOT_STATE_DIR/clawdbot.json)
+ */
+export function resolveConfigPath(env = process.env, stateDir = resolveStateDir(env, os.homedir)) {
+    const override = env.CLAWDBOT_CONFIG_PATH?.trim();
+    if (override)
+        return override;
+    return path.join(stateDir, "clawdbot.json");
+}
+export const CONFIG_PATH_CLAWDBOT = resolveConfigPath();
+export const DEFAULT_GATEWAY_PORT = 18789;
+const OAUTH_FILENAME = "oauth.json";
+/**
+ * OAuth credentials storage directory.
+ *
+ * Precedence:
+ * - `CLAWDBOT_OAUTH_DIR` (explicit override)
+ * - `CLAWDBOT_STATE_DIR/credentials` (canonical server/default)
+ * - `~/.clawdbot/credentials` (legacy default)
+ */
+export function resolveOAuthDir(env = process.env, stateDir = resolveStateDir(env, os.homedir)) {
+    const override = env.CLAWDBOT_OAUTH_DIR?.trim();
+    if (override)
+        return resolveUserPath(override);
+    return path.join(stateDir, "credentials");
+}
+export function resolveOAuthPath(env = process.env, stateDir = resolveStateDir(env, os.homedir)) {
+    return path.join(resolveOAuthDir(env, stateDir), OAUTH_FILENAME);
+}
+export function resolveGatewayPort(cfg, env = process.env) {
+    const envRaw = env.CLAWDBOT_GATEWAY_PORT?.trim();
+    if (envRaw) {
+        const parsed = Number.parseInt(envRaw, 10);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    const configPort = cfg?.gateway?.port;
+    if (typeof configPort === "number" && Number.isFinite(configPort)) {
+        if (configPort > 0)
+            return configPort;
+    }
+    return DEFAULT_GATEWAY_PORT;
+}

package/dist/config/schema.js

@@ -0,0 +1,150 @@
+import { VERSION } from "../version.js";
+import { ClawdbotSchema } from "./zod-schema.js";
+const GROUP_LABELS = {
+    identity: "Identity",
+    wizard: "Wizard",
+    logging: "Logging",
+    gateway: "Gateway",
+    agent: "Agent",
+    models: "Models",
+    routing: "Routing",
+    messages: "Messages",
+    session: "Session",
+    cron: "Cron",
+    hooks: "Hooks",
+    ui: "UI",
+    browser: "Browser",
+    talk: "Talk",
+    telegram: "Telegram",
+    discord: "Discord",
+    slack: "Slack",
+    signal: "Signal",
+    imessage: "iMessage",
+    whatsapp: "WhatsApp",
+    skills: "Skills",
+    discovery: "Discovery",
+    presence: "Presence",
+    voicewake: "Voice Wake",
+};
+const GROUP_ORDER = {
+    identity: 10,
+    wizard: 20,
+    gateway: 30,
+    agent: 40,
+    models: 50,
+    routing: 60,
+    messages: 70,
+    session: 80,
+    cron: 90,
+    hooks: 100,
+    ui: 110,
+    browser: 120,
+    talk: 130,
+    telegram: 140,
+    discord: 150,
+    slack: 155,
+    signal: 160,
+    imessage: 170,
+    whatsapp: 180,
+    skills: 190,
+    discovery: 200,
+    presence: 210,
+    voicewake: 220,
+    logging: 900,
+};
+const FIELD_LABELS = {
+    "gateway.remote.url": "Remote Gateway URL",
+    "gateway.remote.token": "Remote Gateway Token",
+    "gateway.remote.password": "Remote Gateway Password",
+    "gateway.auth.token": "Gateway Token",
+    "gateway.auth.password": "Gateway Password",
+    "gateway.controlUi.basePath": "Control UI Base Path",
+    "gateway.reload.mode": "Config Reload Mode",
+    "gateway.reload.debounceMs": "Config Reload Debounce (ms)",
+    "agent.workspace": "Workspace",
+    "agent.model": "Default Model",
+    "agent.imageModel": "Image Model",
+    "agent.modelFallbacks": "Model Fallbacks",
+    "agent.imageModelFallbacks": "Image Model Fallbacks",
+    "ui.seamColor": "Accent Color",
+    "browser.controlUrl": "Browser Control URL",
+    "session.agentToAgent.maxPingPongTurns": "Agent-to-Agent Ping-Pong Turns",
+    "talk.apiKey": "Talk API Key",
+    "telegram.botToken": "Telegram Bot Token",
+    "discord.token": "Discord Bot Token",
+    "slack.botToken": "Slack Bot Token",
+    "slack.appToken": "Slack App Token",
+    "signal.account": "Signal Account",
+    "imessage.cliPath": "iMessage CLI Path",
+};
+const FIELD_HELP = {
+    "gateway.remote.url": "Remote Gateway WebSocket URL (ws:// or wss://).",
+    "gateway.auth.token": "Required for multi-machine access or non-loopback binds.",
+    "gateway.auth.password": "Required for Tailscale funnel.",
+    "gateway.controlUi.basePath": "Optional URL prefix where the Control UI is served (e.g. /clawdbot).",
+    "gateway.reload.mode": 'Hot reload strategy for config changes ("hybrid" recommended).',
+    "gateway.reload.debounceMs": "Debounce window (ms) before applying config changes.",
+    "agent.modelFallbacks": "Ordered fallback models (provider/model). Used when the primary model fails.",
+    "agent.imageModel": "Optional image-capable model (provider/model) used by the image tool.",
+    "agent.imageModelFallbacks": "Ordered fallback image models (provider/model) used by the image tool.",
+    "session.agentToAgent.maxPingPongTurns": "Max reply-back turns between requester and target (0–5).",
+};
+const FIELD_PLACEHOLDERS = {
+    "gateway.remote.url": "ws://host:18789",
+    "gateway.controlUi.basePath": "/clawdbot",
+};
+const SENSITIVE_PATTERNS = [/token/i, /password/i, /secret/i, /api.?key/i];
+function isSensitivePath(path) {
+    return SENSITIVE_PATTERNS.some((pattern) => pattern.test(path));
+}
+function buildBaseHints() {
+    const hints = {};
+    for (const [group, label] of Object.entries(GROUP_LABELS)) {
+        hints[group] = {
+            label,
+            group: label,
+            order: GROUP_ORDER[group],
+        };
+    }
+    for (const [path, label] of Object.entries(FIELD_LABELS)) {
+        const current = hints[path];
+        hints[path] = current ? { ...current, label } : { label };
+    }
+    for (const [path, help] of Object.entries(FIELD_HELP)) {
+        const current = hints[path];
+        hints[path] = current ? { ...current, help } : { help };
+    }
+    for (const [path, placeholder] of Object.entries(FIELD_PLACEHOLDERS)) {
+        const current = hints[path];
+        hints[path] = current ? { ...current, placeholder } : { placeholder };
+    }
+    return hints;
+}
+function applySensitiveHints(hints) {
+    const next = { ...hints };
+    for (const key of Object.keys(next)) {
+        if (isSensitivePath(key)) {
+            next[key] = { ...next[key], sensitive: true };
+        }
+    }
+    return next;
+}
+let cached = null;
+export function buildConfigSchema() {
+    if (cached)
+        return cached;
+    const schema = ClawdbotSchema.toJSONSchema({
+        target: "draft-07",
+        unrepresentable: "any",
+    });
+    schema.title = "ClawdbotConfig";
+    const hints = applySensitiveHints(buildBaseHints());
+    const next = {
+        schema,
+        uiHints: hints,
+        version: VERSION,
+        generatedAt: new Date().toISOString(),
+    };
+    cached = next;
+    return next;
+}

package/dist/config/sessions.js

@@ -0,0 +1,282 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import JSON5 from "json5";
+import { normalizeE164 } from "../utils.js";
+const GROUP_SURFACES = new Set([
+    "whatsapp",
+    "telegram",
+    "discord",
+    "signal",
+    "imessage",
+    "webchat",
+    "slack",
+]);
+export function resolveSessionTranscriptsDir() {
+    return path.join(os.homedir(), ".clawdbot", "sessions");
+}
+export function resolveDefaultSessionStorePath() {
+    return path.join(resolveSessionTranscriptsDir(), "sessions.json");
+}
+export const DEFAULT_RESET_TRIGGER = "/new";
+export const DEFAULT_RESET_TRIGGERS = ["/new", "/reset"];
+export const DEFAULT_IDLE_MINUTES = 60;
+export function resolveSessionTranscriptPath(sessionId) {
+    return path.join(resolveSessionTranscriptsDir(), `${sessionId}.jsonl`);
+}
+export function resolveStorePath(store) {
+    if (!store)
+        return resolveDefaultSessionStorePath();
+    if (store.startsWith("~"))
+        return path.resolve(store.replace("~", os.homedir()));
+    return path.resolve(store);
+}
+export function resolveMainSessionKey(cfg) {
+    if (cfg?.session?.scope === "global")
+        return "global";
+    return "main";
+}
+function normalizeGroupLabel(raw) {
+    const trimmed = raw?.trim().toLowerCase() ?? "";
+    if (!trimmed)
+        return "";
+    const dashed = trimmed.replace(/\s+/g, "-");
+    const cleaned = dashed.replace(/[^a-z0-9#@._+-]+/g, "-");
+    return cleaned.replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+}
+function shortenGroupId(value) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed)
+        return "";
+    if (trimmed.length <= 14)
+        return trimmed;
+    return `${trimmed.slice(0, 6)}...${trimmed.slice(-4)}`;
+}
+export function buildGroupDisplayName(params) {
+    const surfaceKey = (params.surface?.trim().toLowerCase() || "group").trim();
+    const room = params.room?.trim();
+    const space = params.space?.trim();
+    const subject = params.subject?.trim();
+    const detail = (room && space
+        ? `${space}${room.startsWith("#") ? "" : "#"}${room}`
+        : room || subject || space || "") || "";
+    const fallbackId = params.id?.trim() || params.key.replace(/^group:/, "");
+    const rawLabel = detail || fallbackId;
+    let token = normalizeGroupLabel(rawLabel);
+    if (!token) {
+        token = normalizeGroupLabel(shortenGroupId(rawLabel));
+    }
+    if (!params.room && token.startsWith("#")) {
+        token = token.replace(/^#+/, "");
+    }
+    if (token &&
+        !/^[@#]/.test(token) &&
+        !token.startsWith("g-") &&
+        !token.includes("#")) {
+        token = `g-${token}`;
+    }
+    return token ? `${surfaceKey}:${token}` : surfaceKey;
+}
+export function resolveGroupSessionKey(ctx) {
+    const from = typeof ctx.From === "string" ? ctx.From.trim() : "";
+    if (!from)
+        return null;
+    const chatType = ctx.ChatType?.trim().toLowerCase();
+    const isGroup = chatType === "group" ||
+        from.startsWith("group:") ||
+        from.includes("@g.us") ||
+        from.includes(":group:") ||
+        from.includes(":channel:");
+    if (!isGroup)
+        return null;
+    const surfaceHint = ctx.Surface?.trim().toLowerCase();
+    const hasLegacyGroupPrefix = from.startsWith("group:");
+    const raw = (hasLegacyGroupPrefix ? from.slice("group:".length) : from).trim();
+    let surface;
+    let kind;
+    let id = "";
+    const parseKind = (value) => {
+        if (value === "channel")
+            return "channel";
+        return "group";
+    };
+    const parseParts = (parts) => {
+        if (parts.length >= 2 && GROUP_SURFACES.has(parts[0])) {
+            surface = parts[0];
+            if (parts.length >= 3) {
+                const kindCandidate = parts[1];
+                if (["group", "channel"].includes(kindCandidate)) {
+                    kind = parseKind(kindCandidate);
+                    id = parts.slice(2).join(":");
+                }
+                else {
+                    id = parts.slice(1).join(":");
+                }
+            }
+            else {
+                id = parts[1];
+            }
+            return;
+        }
+        if (parts.length >= 2 && ["group", "channel"].includes(parts[0])) {
+            kind = parseKind(parts[0]);
+            id = parts.slice(1).join(":");
+        }
+    };
+    if (hasLegacyGroupPrefix) {
+        const legacyParts = raw.split(":").filter(Boolean);
+        if (legacyParts.length > 1) {
+            parseParts(legacyParts);
+        }
+        else {
+            id = raw;
+        }
+    }
+    else if (from.includes("@g.us") && !from.includes(":")) {
+        id = from;
+    }
+    else {
+        parseParts(from.split(":").filter(Boolean));
+        if (!id) {
+            id = raw || from;
+        }
+    }
+    const resolvedSurface = surface ?? surfaceHint;
+    if (!resolvedSurface) {
+        const legacy = hasLegacyGroupPrefix ? `group:${raw}` : `group:${from}`;
+        return {
+            key: legacy,
+            id: raw || from,
+            legacyKey: legacy,
+            chatType: "group",
+        };
+    }
+    const resolvedKind = kind === "channel" ? "channel" : "group";
+    const key = `${resolvedSurface}:${resolvedKind}:${id || raw || from}`;
+    let legacyKey;
+    if (hasLegacyGroupPrefix || from.includes("@g.us")) {
+        legacyKey = `group:${id || raw || from}`;
+    }
+    return {
+        key,
+        legacyKey,
+        surface: resolvedSurface,
+        id: id || raw || from,
+        chatType: resolvedKind === "channel" ? "room" : "group",
+    };
+}
+export function loadSessionStore(storePath) {
+    try {
+        const raw = fs.readFileSync(storePath, "utf-8");
+        const parsed = JSON5.parse(raw);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore missing/invalid store; we'll recreate it
+    }
+    return {};
+}
+export async function saveSessionStore(storePath, store) {
+    await fs.promises.mkdir(path.dirname(storePath), { recursive: true });
+    const json = JSON.stringify(store, null, 2);
+    const tmp = `${storePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        await fs.promises.writeFile(tmp, json, "utf-8");
+        await fs.promises.rename(tmp, storePath);
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code === "ENOENT") {
+            // In tests the temp session-store directory may be deleted while writes are in-flight.
+            // Best-effort: try a direct write (recreating the parent dir), otherwise ignore.
+            try {
+                await fs.promises.mkdir(path.dirname(storePath), { recursive: true });
+                await fs.promises.writeFile(storePath, json, "utf-8");
+            }
+            catch (err2) {
+                const code2 = err2 && typeof err2 === "object" && "code" in err2
+                    ? String(err2.code)
+                    : null;
+                if (code2 === "ENOENT")
+                    return;
+                throw err2;
+            }
+            return;
+        }
+        throw err;
+    }
+    finally {
+        await fs.promises.rm(tmp, { force: true });
+    }
+}
+export async function updateLastRoute(params) {
+    const { storePath, sessionKey, channel, to } = params;
+    const store = loadSessionStore(storePath);
+    const existing = store[sessionKey];
+    const now = Date.now();
+    const next = {
+        sessionId: existing?.sessionId ?? crypto.randomUUID(),
+        updatedAt: Math.max(existing?.updatedAt ?? 0, now),
+        systemSent: existing?.systemSent,
+        abortedLastRun: existing?.abortedLastRun,
+        thinkingLevel: existing?.thinkingLevel,
+        verboseLevel: existing?.verboseLevel,
+        providerOverride: existing?.providerOverride,
+        modelOverride: existing?.modelOverride,
+        sendPolicy: existing?.sendPolicy,
+        queueMode: existing?.queueMode,
+        inputTokens: existing?.inputTokens,
+        outputTokens: existing?.outputTokens,
+        totalTokens: existing?.totalTokens,
+        modelProvider: existing?.modelProvider,
+        model: existing?.model,
+        contextTokens: existing?.contextTokens,
+        displayName: existing?.displayName,
+        chatType: existing?.chatType,
+        surface: existing?.surface,
+        subject: existing?.subject,
+        room: existing?.room,
+        space: existing?.space,
+        skillsSnapshot: existing?.skillsSnapshot,
+        lastChannel: channel,
+        lastTo: to?.trim() ? to.trim() : undefined,
+    };
+    store[sessionKey] = next;
+    await saveSessionStore(storePath, store);
+    return next;
+}
+// Decide which session bucket to use (per-sender vs global).
+export function deriveSessionKey(scope, ctx) {
+    if (scope === "global")
+        return "global";
+    const resolvedGroup = resolveGroupSessionKey(ctx);
+    if (resolvedGroup)
+        return resolvedGroup.key;
+    const from = ctx.From ? normalizeE164(ctx.From) : "";
+    return from || "unknown";
+}
+/**
+ * Resolve the session key with a canonical direct-chat bucket (default: "main").
+ * All non-group direct chats collapse to this bucket; groups stay isolated.
+ */
+export function resolveSessionKey(scope, ctx, mainKey) {
+    const explicit = ctx.SessionKey?.trim();
+    if (explicit)
+        return explicit;
+    const raw = deriveSessionKey(scope, ctx);
+    if (scope === "global")
+        return raw;
+    // Default to a single shared direct-chat session called "main"; groups stay isolated.
+    const canonical = (mainKey ?? "main").trim() || "main";
+    const isGroup = raw.startsWith("group:") ||
+        raw.includes(":group:") ||
+        raw.includes(":channel:");
+    if (!isGroup)
+        return canonical;
+    return raw;
+}

package/dist/config/talk.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function readTalkApiKeyFromProfile(deps = {}) {
+    const fsImpl = deps.fs ?? fs;
+    const osImpl = deps.os ?? os;
+    const pathImpl = deps.path ?? path;
+    const home = osImpl.homedir();
+    const candidates = [".profile", ".zprofile", ".zshrc", ".bashrc"].map((name) => pathImpl.join(home, name));
+    for (const candidate of candidates) {
+        if (!fsImpl.existsSync(candidate))
+            continue;
+        try {
+            const text = fsImpl.readFileSync(candidate, "utf-8");
+            const match = text.match(/(?:^|\n)\s*(?:export\s+)?ELEVENLABS_API_KEY\s*=\s*["']?([^\n"']+)["']?/);
+            const value = match?.[1]?.trim();
+            if (value)
+                return value;
+        }
+        catch {
+            // Ignore profile read errors.
+        }
+    }
+    return null;
+}
+export function resolveTalkApiKey(env = process.env, deps = {}) {
+    const envValue = (env.ELEVENLABS_API_KEY ?? "").trim();
+    if (envValue)
+        return envValue;
+    return readTalkApiKeyFromProfile(deps);
+}

package/dist/config/types.js

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