clementine-agent 1.0.0

package/dist/channels/discord-bot-manager.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Clementine TypeScript — Discord bot manager.
+ *
+ * Orchestrates the lifecycle of agent bot clients. Agents with a
+ * `discordToken` in their profile get their own dedicated discord.js Client.
+ * Bots discover their channels on connect (by name, explicit ID, or fallback
+ * to all visible).
+ */
+import type { Gateway } from '../gateway/router.js';
+import type { CronScheduler } from '../gateway/heartbeat.js';
+import { type AgentBotStatus } from './discord-agent-bot.js';
+export interface BotManagerConfig {
+    gateway: Gateway;
+    ownerId: string;
+    cronScheduler?: CronScheduler;
+    statusFilePath?: string;
+}
+export interface BotStatus {
+    slug: string;
+    status: AgentBotStatus;
+    botTag?: string;
+    avatarUrl?: string;
+    channelIds: string[];
+    error?: string;
+}
+export declare class BotManager {
+    private bots;
+    private gateway;
+    private ownerId;
+    private cronScheduler?;
+    private statusFilePath;
+    private pollInterval?;
+    private statusInterval?;
+    constructor(config: BotManagerConfig);
+    /**
+     * Scan all agents for discordToken, start bots, return owned channel IDs.
+     * Channel IDs are resolved AFTER bots connect (auto-discovery).
+     */
+    startAll(): Promise<string[]>;
+    startBot(slug: string): Promise<void>;
+    stopBot(slug: string): Promise<void>;
+    stopAll(): Promise<void>;
+    getStatuses(): Map<string, BotStatus>;
+    /**
+     * Get all channel IDs managed by agent bots (main bot should NOT watch these).
+     * Includes both exclusive channels and team chat channels — the main bot
+     * should not respond in either type.
+     */
+    getOwnedChannelIds(): string[];
+    /** Get channel IDs that are shared team chat channels (multiple agents listen). */
+    getTeamChatChannelIds(): string[];
+    /** Get the primary channel ID for a specific agent bot (for team message delivery). */
+    getChannelForAgent(slug: string): string | null;
+    /** Reverse lookup: which agent slug owns a given channel ID? */
+    getAgentForChannel(channelId: string): string | null;
+    /** Get the owner ID (used for building session keys). */
+    getOwnerId(): string;
+    /** Check if an agent has a running bot. */
+    hasBot(slug: string): boolean;
+    /**
+     * Send a notification through an agent's bot (DM to owner).
+     * Uses embed formatting for cron-style messages, plain text for others.
+     * Throws if the bot is unavailable — callers should fall back to main bot.
+     */
+    sendAsAgent(slug: string, text: string): Promise<void>;
+    /**
+     * Deliver a team message to an agent's bot — posts the message visibly
+     * in the bot's channel and triggers the agent to process and respond.
+     * Returns the agent's response text, or null if delivery failed.
+     */
+    deliverTeamMessage(toSlug: string, fromName: string, fromSlug: string, content: string): Promise<string | null>;
+    /**
+     * Poll for new/removed agents with discordToken at the given interval.
+     */
+    startPolling(intervalMs: number): void;
+    private pollForChanges;
+    /** Write status to disk so the dashboard can read it. */
+    private startStatusWriter;
+}
+//# sourceMappingURL=discord-bot-manager.d.ts.map

package/dist/channels/discord-bot-manager.js

@@ -0,0 +1,262 @@
+/**
+ * Clementine TypeScript — Discord bot manager.
+ *
+ * Orchestrates the lifecycle of agent bot clients. Agents with a
+ * `discordToken` in their profile get their own dedicated discord.js Client.
+ * Bots discover their channels on connect (by name, explicit ID, or fallback
+ * to all visible).
+ */
+import { writeFileSync } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+import { AgentBotClient } from './discord-agent-bot.js';
+import { formatCronEmbed } from './discord-utils.js';
+const logger = pino({ name: 'clementine.bot-manager' });
+export class BotManager {
+    bots = new Map();
+    gateway;
+    ownerId;
+    cronScheduler;
+    statusFilePath;
+    pollInterval;
+    statusInterval;
+    constructor(config) {
+        this.gateway = config.gateway;
+        this.ownerId = config.ownerId;
+        this.cronScheduler = config.cronScheduler;
+        this.statusFilePath = config.statusFilePath ??
+            path.join(process.env.CLEMENTINE_HOME || path.join(process.env.HOME || '', '.clementine'), '.bot-status.json');
+    }
+    /**
+     * Scan all agents for discordToken, start bots, return owned channel IDs.
+     * Channel IDs are resolved AFTER bots connect (auto-discovery).
+     */
+    async startAll() {
+        const mgr = this.gateway.getAgentManager();
+        const allAgents = mgr.listAll();
+        logger.info({ agentCount: allAgents.length }, 'Scanning agents for discordToken');
+        for (const agent of allAgents) {
+            logger.info({ slug: agent.slug, hasToken: Boolean(agent.discordToken) }, 'Checking agent');
+            if (!agent.discordToken)
+                continue;
+            try {
+                await this.startBot(agent.slug);
+            }
+            catch (err) {
+                logger.error({ err, slug: agent.slug }, 'Failed to start agent bot');
+            }
+        }
+        // Start status file writer
+        this.startStatusWriter();
+        // Return owned channel IDs (resolved after bot connect)
+        return this.getOwnedChannelIds();
+    }
+    async startBot(slug) {
+        // If already running, stop first
+        if (this.bots.has(slug)) {
+            await this.stopBot(slug);
+        }
+        const mgr = this.gateway.getAgentManager();
+        const profile = mgr.get(slug);
+        if (!profile) {
+            throw new Error(`Agent '${slug}' not found`);
+        }
+        if (!profile.discordToken) {
+            throw new Error(`Agent '${slug}' has no discordToken`);
+        }
+        // Build channel IDs from explicit config (auto-discovery happens on connect)
+        const explicitChannelIds = profile.discordChannelId
+            ? [profile.discordChannelId]
+            : undefined;
+        const bot = new AgentBotClient({
+            slug,
+            token: profile.discordToken,
+            ownerId: this.ownerId,
+            profile,
+            channelIds: explicitChannelIds,
+            cronScheduler: this.cronScheduler,
+            allowedUsers: profile.team?.allowedUsers,
+        }, this.gateway);
+        await bot.start();
+        this.bots.set(slug, bot);
+        logger.info({ slug }, 'Agent bot started');
+    }
+    async stopBot(slug) {
+        const bot = this.bots.get(slug);
+        if (!bot)
+            return;
+        await bot.stop();
+        this.bots.delete(slug);
+    }
+    async stopAll() {
+        const slugs = [...this.bots.keys()];
+        await Promise.all(slugs.map(slug => this.stopBot(slug)));
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = undefined;
+        }
+        if (this.statusInterval) {
+            clearInterval(this.statusInterval);
+            this.statusInterval = undefined;
+        }
+    }
+    getStatuses() {
+        const result = new Map();
+        for (const [slug, bot] of this.bots) {
+            const s = bot.getStatus();
+            result.set(slug, {
+                slug,
+                status: s.status,
+                botTag: s.botTag,
+                avatarUrl: s.avatarUrl,
+                channelIds: bot.getChannelIds(),
+                error: s.error,
+            });
+        }
+        return result;
+    }
+    /**
+     * Get all channel IDs managed by agent bots (main bot should NOT watch these).
+     * Includes both exclusive channels and team chat channels — the main bot
+     * should not respond in either type.
+     */
+    getOwnedChannelIds() {
+        const ids = [];
+        for (const bot of this.bots.values()) {
+            ids.push(...bot.getChannelIds());
+        }
+        return ids;
+    }
+    /** Get channel IDs that are shared team chat channels (multiple agents listen). */
+    getTeamChatChannelIds() {
+        const ids = [];
+        for (const bot of this.bots.values()) {
+            if (bot.isTeamChat()) {
+                ids.push(...bot.getChannelIds());
+            }
+        }
+        return [...new Set(ids)]; // deduplicate
+    }
+    /** Get the primary channel ID for a specific agent bot (for team message delivery). */
+    getChannelForAgent(slug) {
+        const bot = this.bots.get(slug);
+        if (!bot)
+            return null;
+        const channels = bot.getChannelIds();
+        return channels[0] ?? null;
+    }
+    /** Reverse lookup: which agent slug owns a given channel ID? */
+    getAgentForChannel(channelId) {
+        for (const [slug, bot] of this.bots) {
+            if (bot.getChannelIds().includes(channelId))
+                return slug;
+        }
+        return null;
+    }
+    /** Get the owner ID (used for building session keys). */
+    getOwnerId() {
+        return this.ownerId;
+    }
+    /** Check if an agent has a running bot. */
+    hasBot(slug) {
+        return this.bots.has(slug);
+    }
+    /**
+     * Send a notification through an agent's bot (DM to owner).
+     * Uses embed formatting for cron-style messages, plain text for others.
+     * Throws if the bot is unavailable — callers should fall back to main bot.
+     */
+    async sendAsAgent(slug, text) {
+        const bot = this.bots.get(slug);
+        if (!bot)
+            throw new Error(`No bot for agent '${slug}'`);
+        const status = bot.getStatus();
+        if (status.status !== 'online')
+            throw new Error(`Bot '${slug}' is ${status.status}`);
+        const embed = formatCronEmbed(text);
+        await bot.sendNotification(text, embed ?? undefined);
+    }
+    /**
+     * Deliver a team message to an agent's bot — posts the message visibly
+     * in the bot's channel and triggers the agent to process and respond.
+     * Returns the agent's response text, or null if delivery failed.
+     */
+    async deliverTeamMessage(toSlug, fromName, fromSlug, content) {
+        const bot = this.bots.get(toSlug);
+        if (!bot)
+            return null;
+        try {
+            return await bot.receiveTeamMessage(fromName, fromSlug, content);
+        }
+        catch (err) {
+            logger.error({ err, toSlug, fromSlug }, 'Failed to deliver team message via bot');
+            return null;
+        }
+    }
+    /**
+     * Poll for new/removed agents with discordToken at the given interval.
+     */
+    startPolling(intervalMs) {
+        if (this.pollInterval)
+            clearInterval(this.pollInterval);
+        this.pollInterval = setInterval(async () => {
+            try {
+                await this.pollForChanges();
+            }
+            catch (err) {
+                logger.error({ err }, 'Bot polling error');
+            }
+        }, intervalMs);
+    }
+    async pollForChanges() {
+        const mgr = this.gateway.getAgentManager();
+        mgr.invalidateCache();
+        const allAgents = mgr.listAll();
+        // Find agents that should have bots (just need a discordToken)
+        const shouldHaveBot = new Set();
+        for (const agent of allAgents) {
+            if (agent.discordToken) {
+                shouldHaveBot.add(agent.slug);
+            }
+        }
+        // Start new bots
+        for (const slug of shouldHaveBot) {
+            if (!this.bots.has(slug)) {
+                logger.info({ slug }, 'Detected new agent with discordToken — starting bot');
+                try {
+                    await this.startBot(slug);
+                }
+                catch (err) {
+                    logger.error({ err, slug }, 'Failed to start new agent bot');
+                }
+            }
+        }
+        // Stop removed bots
+        for (const slug of this.bots.keys()) {
+            if (!shouldHaveBot.has(slug)) {
+                logger.info({ slug }, 'Agent no longer has discordToken — stopping bot');
+                await this.stopBot(slug);
+            }
+        }
+    }
+    /** Write status to disk so the dashboard can read it. */
+    startStatusWriter() {
+        if (this.statusInterval)
+            clearInterval(this.statusInterval);
+        const writeStatus = () => {
+            try {
+                const statuses = {};
+                for (const [slug, status] of this.getStatuses()) {
+                    statuses[slug] = status;
+                }
+                writeFileSync(this.statusFilePath, JSON.stringify(statuses, null, 2));
+            }
+            catch {
+                // Non-fatal
+            }
+        };
+        writeStatus();
+        this.statusInterval = setInterval(writeStatus, 10_000);
+    }
+}
+//# sourceMappingURL=discord-bot-manager.js.map

package/dist/channels/discord-utils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Clementine TypeScript — Shared Discord utilities.
+ *
+ * Extracted from discord.ts so agent bot clients can reuse streaming,
+ * chunking, and sanitization without importing the monolith.
+ */
+import { EmbedBuilder, type Message } from 'discord.js';
+export declare const STREAM_EDIT_INTERVAL = 400;
+export declare const THINKING_INDICATOR = "\u2728 *thinking...*";
+export declare const DISCORD_MSG_LIMIT = 2000;
+export declare function sanitizeResponse(text: string): string;
+export declare function chunkText(text: string, maxLen?: number): string[];
+export declare function sendChunked(channel: Message['channel'], text: string): Promise<void>;
+export declare function friendlyToolName(name: string, input?: Record<string, unknown>): string;
+export declare class DiscordStreamingMessage {
+    private message;
+    private lastEdit;
+    private pendingText;
+    private lastFlushedText;
+    private isFinal;
+    private channel;
+    private flushTimer;
+    private progressTimer;
+    private toolStatus;
+    private startTime;
+    private toolCallCount;
+    private lastTextTime;
+    /** The message ID of the final bot response (available after finalize). */
+    messageId: string | null;
+    constructor(channel: Message['channel']);
+    start(): Promise<void>;
+    /** Update the tool activity status line shown during streaming. */
+    setToolStatus(status: string): void;
+    update(text: string): Promise<void>;
+    finalize(text: string): Promise<void>;
+    /** Format elapsed milliseconds as human-readable duration. */
+    private formatElapsed;
+    private flush;
+}
+export type CronEmbedType = 'success' | 'progress' | 'error';
+/**
+ * Detect whether a notification message looks like a cron result.
+ * Returns the embed type if so, or null for non-cron messages.
+ */
+export declare function detectCronType(text: string): CronEmbedType | null;
+/**
+ * Format a cron notification as a Discord embed.
+ * Returns null if the text doesn't look like a cron message.
+ */
+export declare function formatCronEmbed(text: string): EmbedBuilder | null;
+//# sourceMappingURL=discord-utils.d.ts.map

package/dist/channels/discord-utils.js

@@ -0,0 +1,293 @@
+/**
+ * Clementine TypeScript — Shared Discord utilities.
+ *
+ * Extracted from discord.ts so agent bot clients can reuse streaming,
+ * chunking, and sanitization without importing the monolith.
+ */
+import { EmbedBuilder } from 'discord.js';
+export const STREAM_EDIT_INTERVAL = 400;
+export const THINKING_INDICATOR = '\u2728 *thinking...*';
+export const DISCORD_MSG_LIMIT = 2000;
+// ── Credential sanitisation ───────────────────────────────────────────
+export function sanitizeResponse(text) {
+    // Discord tokens
+    text = text.replace(/[MN][A-Za-z0-9]{23,}\.[A-Za-z0-9_-]{6}\.[A-Za-z0-9_-]{27,}/g, '[REDACTED_TOKEN]');
+    // API keys (Anthropic/OpenAI style)
+    text = text.replace(/sk-[A-Za-z0-9]{20,}/g, '[REDACTED_KEY]');
+    // GitHub PATs
+    text = text.replace(/ghp_[A-Za-z0-9]{36}/g, '[REDACTED_TOKEN]');
+    // Slack bot tokens
+    text = text.replace(/xoxb-[0-9]+-[A-Za-z0-9-]+/g, '[REDACTED_TOKEN]');
+    // Generic key/secret/token/password values
+    text = text.replace(/((?:token|key|secret|password)[=: ]{1,3})\S{20,}/gi, '$1[REDACTED]');
+    return text;
+}
+// ── Chunked sending ───────────────────────────────────────────────────
+export function chunkText(text, maxLen = 1900) {
+    if (text.length <= maxLen)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining) {
+        if (remaining.length <= maxLen) {
+            chunks.push(remaining);
+            break;
+        }
+        let splitAt = remaining.lastIndexOf('\n', maxLen);
+        if (splitAt === -1)
+            splitAt = remaining.lastIndexOf(' ', maxLen);
+        if (splitAt === -1)
+            splitAt = maxLen;
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).replace(/^[\n ]+/, '');
+    }
+    return chunks;
+}
+export async function sendChunked(channel, text) {
+    if (!('send' in channel))
+        return;
+    if (!text) {
+        await channel.send('*(no response)*');
+        return;
+    }
+    text = sanitizeResponse(text);
+    for (const chunk of chunkText(text, 1900)) {
+        await channel.send(chunk);
+    }
+}
+// ── Streaming message (posts as the bot user) ─────────────────────────
+// ── Human-friendly tool names ──────────────────────────────────────────
+const TOOL_LABELS = {
+    Read: '\ud83d\udcd6 Reading',
+    Write: '\ud83d\udcdd Writing',
+    Edit: '\u270f\ufe0f Editing',
+    Bash: '\u2699\ufe0f Running command',
+    Grep: '\ud83d\udd0d Searching',
+    Glob: '\ud83d\udcc2 Finding files',
+    Agent: '\ud83e\udd16 Delegating',
+    WebSearch: '\ud83c\udf10 Web search',
+    WebFetch: '\ud83c\udf10 Fetching',
+};
+export function friendlyToolName(name, input) {
+    // Check direct match first
+    if (TOOL_LABELS[name]) {
+        // Add context from input where helpful
+        if (name === 'Read' && input?.file_path) {
+            const fp = String(input.file_path);
+            const short = fp.length > 40 ? '...' + fp.slice(-37) : fp;
+            return `${TOOL_LABELS[name]} ${short}`;
+        }
+        if (name === 'Bash' && input?.command) {
+            const cmd = String(input.command).slice(0, 40);
+            return `${TOOL_LABELS[name]}: ${cmd}`;
+        }
+        if (name === 'Grep' && input?.pattern) {
+            return `${TOOL_LABELS[name]} for "${String(input.pattern).slice(0, 30)}"`;
+        }
+        return TOOL_LABELS[name];
+    }
+    // MCP tools: strip prefix (e.g., "mcp__clementine__memory_search" → "memory_search")
+    const short = name.includes('__') ? name.split('__').pop() : name;
+    return `\ud83d\udd27 ${short.replace(/_/g, ' ')}`;
+}
+export class DiscordStreamingMessage {
+    message = null;
+    lastEdit = 0;
+    pendingText = '';
+    lastFlushedText = '';
+    isFinal = false;
+    channel;
+    flushTimer = null;
+    progressTimer = null;
+    toolStatus = '';
+    startTime = Date.now();
+    toolCallCount = 0;
+    lastTextTime = 0;
+    /** The message ID of the final bot response (available after finalize). */
+    messageId = null;
+    constructor(channel) {
+        this.channel = channel;
+    }
+    async start() {
+        if (!('send' in this.channel))
+            return;
+        this.message = await this.channel.send(THINKING_INDICATOR);
+        this.lastEdit = Date.now();
+        // Periodic refresh keeps elapsed time display current during long silent stretches
+        this.progressTimer = setInterval(() => {
+            if (!this.isFinal && this.toolCallCount > 3)
+                this.flush().catch(() => { });
+        }, 30_000);
+    }
+    /** Update the tool activity status line shown during streaming. */
+    setToolStatus(status) {
+        this.toolStatus = status;
+        this.toolCallCount++;
+        // Trigger a flush so the status is actually displayed during long tool chains
+        // where no text tokens are being emitted
+        const elapsed = Date.now() - this.lastEdit;
+        if (elapsed >= STREAM_EDIT_INTERVAL) {
+            this.flush().catch(() => { });
+        }
+        else if (!this.flushTimer) {
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.flush().catch(() => { });
+            }, STREAM_EDIT_INTERVAL - elapsed);
+        }
+    }
+    async update(text) {
+        this.pendingText = text;
+        this.lastTextTime = Date.now();
+        const elapsed = Date.now() - this.lastEdit;
+        if (elapsed >= STREAM_EDIT_INTERVAL) {
+            await this.flush();
+        }
+        else if (!this.flushTimer) {
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.flush().catch(() => { });
+            }, STREAM_EDIT_INTERVAL - elapsed);
+        }
+    }
+    async finalize(text) {
+        this.isFinal = true;
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.progressTimer) {
+            clearInterval(this.progressTimer);
+            this.progressTimer = null;
+        }
+        if (!text)
+            text = '*(no response)*';
+        text = sanitizeResponse(text);
+        if (this.message) {
+            if (text.length <= 1900) {
+                await this.message.edit(text);
+                this.messageId = this.message.id;
+            }
+            else {
+                await this.message.delete().catch(() => { });
+                await sendChunked(this.channel, text);
+            }
+        }
+        else {
+            await sendChunked(this.channel, text);
+        }
+    }
+    /** Format elapsed milliseconds as human-readable duration. */
+    formatElapsed(ms) {
+        const s = Math.floor(ms / 1000);
+        if (s < 60)
+            return `${s}s`;
+        const m = Math.floor(s / 60);
+        const rem = s % 60;
+        return rem > 0 ? `${m}m ${rem}s` : `${m}m`;
+    }
+    async flush() {
+        if (!this.message || this.isFinal)
+            return;
+        // Enhanced status when tools have been running 60s+ with no text output
+        const silenceDuration = Date.now() - (this.lastTextTime || this.startTime);
+        const showProgress = this.toolCallCount > 3 && silenceDuration > 60_000;
+        // Skip flush if nothing changed — but always allow when showing progress (elapsed time updates)
+        if (!showProgress) {
+            if (!this.pendingText && !this.toolStatus)
+                return;
+            if (this.pendingText === this.lastFlushedText && !this.toolStatus)
+                return;
+        }
+        let display = this.pendingText;
+        let statusLine;
+        if (showProgress) {
+            const elapsed = this.formatElapsed(Date.now() - this.startTime);
+            const current = this.toolStatus ? ` \u2014 ${this.toolStatus}` : '';
+            statusLine = `\n\n*\ud83d\udd27 Working... (${this.toolCallCount} steps, ${elapsed})${current}*`;
+        }
+        else {
+            statusLine = this.toolStatus ? `\n\n*${this.toolStatus}*` : '\n\n\u270d\ufe0f *typing...*';
+        }
+        if (display.length > 1900) {
+            display = display.slice(0, 1900) + '\n\n*...streaming...*';
+        }
+        else if (display) {
+            display = display + statusLine;
+        }
+        else {
+            // No text yet — show tool status or progress as the main content
+            if (showProgress) {
+                const elapsed = this.formatElapsed(Date.now() - this.startTime);
+                const current = this.toolStatus ? ` \u2014 ${this.toolStatus}` : '';
+                display = `\u2728 *Working... (${this.toolCallCount} steps, ${elapsed})${current}*`;
+            }
+            else {
+                display = this.toolStatus ? `\u2728 *${this.toolStatus}*` : THINKING_INDICATOR;
+            }
+        }
+        try {
+            await this.message.edit(display);
+            this.lastFlushedText = this.pendingText;
+            this.lastEdit = Date.now();
+        }
+        catch {
+            // Discord rate limit or message deleted — ignore
+        }
+    }
+}
+// ── Cron embed formatting ─────────────────────────────────────────────
+const CRON_PREFIX_RE = /^(✅|⏳|❌)\s/;
+/**
+ * Detect whether a notification message looks like a cron result.
+ * Returns the embed type if so, or null for non-cron messages.
+ */
+export function detectCronType(text) {
+    if (text.startsWith('✅'))
+        return 'success';
+    if (text.startsWith('⏳'))
+        return 'progress';
+    if (text.includes('failed:') || text.startsWith('❌'))
+        return 'error';
+    return null;
+}
+const EMBED_COLORS = {
+    success: 0x2ecc71, // green
+    progress: 0x3498db, // blue
+    error: 0xe74c3c, // red
+};
+/**
+ * Format a cron notification as a Discord embed.
+ * Returns null if the text doesn't look like a cron message.
+ */
+export function formatCronEmbed(text) {
+    const type = detectCronType(text);
+    if (!type)
+        return null;
+    // Extract job name from patterns like "✅ Unleashed task **jobName** completed:"
+    // or "⏳ **jobName** — phase N complete:" or "jobName failed: ..."
+    let title = 'Cron Result';
+    const boldMatch = text.match(/\*\*([^*]+)\*\*/);
+    if (boldMatch) {
+        title = boldMatch[1];
+    }
+    else {
+        // "jobName failed: ..." pattern
+        const failMatch = text.match(/^(.+?)\s+failed:/);
+        if (failMatch)
+            title = failMatch[1];
+    }
+    // Strip the emoji prefix and job name prefix for the description body
+    let description = text.replace(CRON_PREFIX_RE, '').trim();
+    // Truncate to Discord embed limit
+    if (description.length > 4096) {
+        description = description.slice(0, 4080) + '\n\n_(truncated)_';
+    }
+    const embed = new EmbedBuilder()
+        .setTitle(title)
+        .setDescription(description)
+        .setColor(EMBED_COLORS[type])
+        .setTimestamp();
+    return embed;
+}
+//# sourceMappingURL=discord-utils.js.map