botinabox 2.5.2 → 2.5.3

package/dist/core/chat/message-store.d.ts

@@ -1,66 +0,0 @@
-/**
- * MessageStore — store-before-respond guarantee for all chat interactions.
- * Story 7.1
- *
- * Every inbound message (with attachments) is stored BEFORE the bot responds.
- * Every outbound message is stored BEFORE it is sent to the user.
- * Storage confirmation is required before any response flows.
- */
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-import type { InboundMessage } from './types.js';
-export interface StoredAttachment {
-    fileType: string;
-    filename?: string;
-    mimeType?: string;
-    sizeBytes?: number;
-    contents?: string;
-    summary?: string;
-    url?: string;
-}
-export interface StoreResult {
-    messageId: string;
-    attachmentIds: string[];
-}
-export declare class MessageStore {
-    private db;
-    private hooks;
-    constructor(db: DataStore, hooks: HookBus);
-    /**
-     * Store an inbound message and its attachments.
-     * Must complete successfully before any bot response is generated.
-     */
-    storeInbound(msg: InboundMessage): Promise<StoreResult>;
-    /**
-     * Store an outbound message BEFORE sending it.
-     * Returns the message ID for confirmation tracking.
-     */
-    storeOutbound(opts: {
-        channel: string;
-        text: string;
-        threadId?: string;
-        agentId?: string;
-        agentSlug?: string;
-        taskId?: string;
-    }): Promise<string>;
-    /**
-     * Store an attachment linked to a message.
-     */
-    storeAttachment(messageId: string, att: StoredAttachment): Promise<string>;
-    /**
-     * Get recent messages in a thread for context building.
-     */
-    getThreadHistory(threadId: string, limit?: number): Promise<Array<Record<string, unknown>>>;
-    /**
-     * Get recent outbound messages in a thread for redundancy checking.
-     */
-    getRecentOutbound(threadId: string, limit?: number): Promise<Array<Record<string, unknown>>>;
-    /**
-     * Get recent messages from a specific user across all threads.
-     */
-    getUserHistory(userId: string, channel: string, limit?: number): Promise<Array<Record<string, unknown>>>;
-    /**
-     * Get attachments for a message.
-     */
-    getAttachments(messageId: string): Promise<Array<Record<string, unknown>>>;
-}

package/dist/core/chat/message-store.js

@@ -1,131 +0,0 @@
-/**
- * MessageStore — store-before-respond guarantee for all chat interactions.
- * Story 7.1
- *
- * Every inbound message (with attachments) is stored BEFORE the bot responds.
- * Every outbound message is stored BEFORE it is sent to the user.
- * Storage confirmation is required before any response flows.
- */
-export class MessageStore {
-    db;
-    hooks;
-    constructor(db, hooks) {
-        this.db = db;
-        this.hooks = hooks;
-    }
-    /**
-     * Store an inbound message and its attachments.
-     * Must complete successfully before any bot response is generated.
-     */
-    async storeInbound(msg) {
-        const row = await this.db.insert('messages', {
-            channel: msg.channel,
-            direction: 'inbound',
-            from_user: msg.from,
-            user_id: msg.userId,
-            body: msg.body,
-            thread_id: msg.threadId,
-        });
-        const messageId = row['id'];
-        const attachmentIds = [];
-        // Store each attachment
-        if (msg.attachments && msg.attachments.length > 0) {
-            for (const att of msg.attachments) {
-                const attId = await this.storeAttachment(messageId, {
-                    fileType: att.type,
-                    filename: att.filename,
-                    mimeType: att.mimeType,
-                    sizeBytes: att.size,
-                    url: att.url,
-                });
-                attachmentIds.push(attId);
-            }
-        }
-        await this.hooks.emit('message.stored', {
-            messageId,
-            direction: 'inbound',
-            channel: msg.channel,
-            from: msg.from,
-            attachmentCount: attachmentIds.length,
-        });
-        return { messageId, attachmentIds };
-    }
-    /**
-     * Store an outbound message BEFORE sending it.
-     * Returns the message ID for confirmation tracking.
-     */
-    async storeOutbound(opts) {
-        const row = await this.db.insert('messages', {
-            channel: opts.channel,
-            direction: 'outbound',
-            from_agent: opts.agentSlug,
-            agent_id: opts.agentId,
-            body: opts.text,
-            thread_id: opts.threadId,
-            task_id: opts.taskId,
-        });
-        const messageId = row['id'];
-        await this.hooks.emit('message.stored', {
-            messageId,
-            direction: 'outbound',
-            channel: opts.channel,
-        });
-        return messageId;
-    }
-    /**
-     * Store an attachment linked to a message.
-     */
-    async storeAttachment(messageId, att) {
-        const row = await this.db.insert('message_attachments', {
-            message_id: messageId,
-            file_type: att.fileType,
-            filename: att.filename,
-            mime_type: att.mimeType,
-            size_bytes: att.sizeBytes,
-            contents: att.contents,
-            summary: att.summary,
-            url: att.url,
-        });
-        return row['id'];
-    }
-    /**
-     * Get recent messages in a thread for context building.
-     */
-    async getThreadHistory(threadId, limit = 20) {
-        const messages = await this.db.query('messages', {
-            where: { thread_id: threadId },
-            orderBy: 'created_at',
-            limit,
-        });
-        return messages;
-    }
-    /**
-     * Get recent outbound messages in a thread for redundancy checking.
-     */
-    async getRecentOutbound(threadId, limit = 10) {
-        const messages = await this.db.query('messages', {
-            where: { thread_id: threadId, direction: 'outbound' },
-            orderBy: 'created_at',
-            limit,
-        });
-        return messages;
-    }
-    /**
-     * Get recent messages from a specific user across all threads.
-     */
-    async getUserHistory(userId, channel, limit = 50) {
-        return this.db.query('messages', {
-            where: { from_user: userId, channel },
-            orderBy: 'created_at',
-            limit,
-        });
-    }
-    /**
-     * Get attachments for a message.
-     */
-    async getAttachments(messageId) {
-        return this.db.query('message_attachments', {
-            where: { message_id: messageId },
-        });
-    }
-}

package/dist/core/chat/notification-queue.d.ts

@@ -1,34 +0,0 @@
-/**
- * NotificationQueue — persistent outbound notification queue with retry.
- * Story 4.4
- */
-import type { DataStore } from "../data/data-store.js";
-import type { HookBus } from "../hooks/hook-bus.js";
-import type { ChannelRegistry } from "./channel-registry.js";
-export interface NotificationQueueOpts {
-    maxRetries?: number;
-    pollIntervalMs?: number;
-}
-export declare class NotificationQueue {
-    private readonly db;
-    private readonly hooks;
-    private readonly channelRegistry;
-    private readonly maxRetries;
-    private readonly pollIntervalMs;
-    private timer;
-    constructor(db: DataStore, hooks: HookBus, channelRegistry: ChannelRegistry, opts?: NotificationQueueOpts);
-    /**
-     * Enqueue a notification for delivery.
-     * Returns the notification ID.
-     */
-    enqueue(channel: string, recipient: string, payload: {
-        text: string;
-        threadId?: string;
-        [key: string]: unknown;
-    }): Promise<string>;
-    /** Start the background worker polling for pending notifications. */
-    startWorker(): void;
-    /** Stop the background worker. */
-    stopWorker(): void;
-    private processNext;
-}

package/dist/core/chat/notification-queue.js

@@ -1,111 +0,0 @@
-/**
- * NotificationQueue — persistent outbound notification queue with retry.
- * Story 4.4
- */
-export class NotificationQueue {
-    db;
-    hooks;
-    channelRegistry;
-    maxRetries;
-    pollIntervalMs;
-    timer = null;
-    constructor(db, hooks, channelRegistry, opts) {
-        this.db = db;
-        this.hooks = hooks;
-        this.channelRegistry = channelRegistry;
-        this.maxRetries = opts?.maxRetries ?? 3;
-        this.pollIntervalMs = opts?.pollIntervalMs ?? 5_000;
-    }
-    /**
-     * Enqueue a notification for delivery.
-     * Returns the notification ID.
-     */
-    async enqueue(channel, recipient, payload) {
-        if (!this.channelRegistry.has(channel)) {
-            throw new Error(`No registered adapter for channel: ${channel}`);
-        }
-        const row = await this.db.insert("notifications", {
-            channel,
-            recipient_id: recipient,
-            message: JSON.stringify(payload),
-            status: "pending",
-            retries: 0,
-        });
-        await this.hooks.emit("notification.enqueued", {
-            notificationId: row["id"],
-            channel,
-            recipient,
-        });
-        return row["id"];
-    }
-    /** Start the background worker polling for pending notifications. */
-    startWorker() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => {
-            void this.processNext();
-        }, this.pollIntervalMs);
-    }
-    /** Stop the background worker. */
-    stopWorker() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    async processNext() {
-        // Query up to 10 pending or retry notifications
-        const rows = await this.db.query("notifications", {
-            where: { status: "pending" },
-            limit: 10,
-        });
-        for (const row of rows) {
-            const id = row["id"];
-            const channel = row["channel"];
-            const recipient = row["recipient_id"];
-            const retries = row["retries"] ?? 0;
-            let payload;
-            try {
-                payload = JSON.parse(row["message"]);
-            }
-            catch {
-                await this.db.update("notifications", { id }, { status: "failed", error: "Invalid payload" });
-                continue;
-            }
-            const adapter = this.channelRegistry.get(channel);
-            if (!adapter) {
-                await this.db.update("notifications", { id }, {
-                    status: "failed",
-                    error: `No adapter for channel: ${channel}`,
-                });
-                continue;
-            }
-            try {
-                await adapter.send({ peerId: recipient, threadId: payload.threadId }, payload);
-                await this.db.update("notifications", { id }, {
-                    status: "sent",
-                    sent_at: new Date().toISOString(),
-                });
-                await this.hooks.emit("notification.sent", { notificationId: id, channel, recipient });
-            }
-            catch (err) {
-                const newRetries = retries + 1;
-                if (newRetries >= this.maxRetries) {
-                    await this.db.update("notifications", { id }, {
-                        status: "failed",
-                        retries: newRetries,
-                        error: String(err),
-                    });
-                    await this.hooks.emit("notification.failed", { notificationId: id, channel, recipient, error: String(err) });
-                }
-                else {
-                    await this.db.update("notifications", { id }, {
-                        status: "pending",
-                        retries: newRetries,
-                        error: String(err),
-                    });
-                }
-            }
-        }
-    }
-}

package/dist/core/chat/pipeline.d.ts

@@ -1,38 +0,0 @@
-/**
- * MessagePipeline — routes inbound messages to the task queue.
- * Story 4.2
- */
-import type { HookBus } from "../hooks/hook-bus.js";
-import type { AgentRegistry } from "../orchestrator/agent-registry.js";
-import type { TaskQueue } from "../orchestrator/task-queue.js";
-import type { UserRegistry } from "../orchestrator/user-registry.js";
-import type { BotConfig } from "../../shared/index.js";
-import type { InboundMessage } from "./types.js";
-export declare class MessagePipeline {
-    private readonly hooks;
-    private readonly agentRegistry;
-    private readonly taskQueue;
-    private readonly config;
-    private readonly agentBindings;
-    private readonly userRegistry?;
-    constructor(hooks: HookBus, agentRegistry: AgentRegistry, taskQueue: TaskQueue, config: BotConfig, userRegistry?: UserRegistry);
-    /**
-     * Process an inbound message end-to-end.
-     * 1. Emit 'message.inbound'
-     * 2. Resolve agent
-     * 3. Check policy (allowlist / mention gate)
-     * 4. Create task
-     * 5. Emit 'message.processed'
-     */
-    processInbound(msg: InboundMessage): Promise<void>;
-    /**
-     * Resolve the best agent for a given inbound message.
-     * Returns agentId (slug) or undefined if no match.
-     */
-    resolveAgent(msg: InboundMessage): string | undefined;
-    /**
-     * Evaluate messaging policy for the given agent.
-     * Returns false if the message is blocked.
-     */
-    evaluatePolicy(msg: InboundMessage, agentId: string): boolean;
-}

package/dist/core/chat/pipeline.js

@@ -1,89 +0,0 @@
-/**
- * MessagePipeline — routes inbound messages to the task queue.
- * Story 4.2
- */
-import { buildAgentBindings } from "./routing.js";
-import { checkAllowlist, checkMentionGate } from "./policies.js";
-export class MessagePipeline {
-    hooks;
-    agentRegistry;
-    taskQueue;
-    config;
-    agentBindings;
-    userRegistry;
-    constructor(hooks, agentRegistry, taskQueue, config, userRegistry) {
-        this.hooks = hooks;
-        this.agentRegistry = agentRegistry;
-        this.taskQueue = taskQueue;
-        this.config = config;
-        this.agentBindings = buildAgentBindings(config.agents);
-        this.userRegistry = userRegistry;
-    }
-    /**
-     * Process an inbound message end-to-end.
-     * 1. Emit 'message.inbound'
-     * 2. Resolve agent
-     * 3. Check policy (allowlist / mention gate)
-     * 4. Create task
-     * 5. Emit 'message.processed'
-     */
-    async processInbound(msg) {
-        await this.hooks.emit("message.inbound", { message: msg, channel: msg.channel });
-        // Resolve sender to a user record (auto-creates if UserRegistry is available)
-        if (this.userRegistry && !msg.userId) {
-            const user = await this.userRegistry.resolveOrCreate(msg.from, msg.channel);
-            msg.userId = user.id;
-        }
-        const agentId = this.resolveAgent(msg);
-        if (agentId !== undefined) {
-            const allowed = this.evaluatePolicy(msg, agentId);
-            if (allowed) {
-                await this.taskQueue.create({
-                    title: `Message from ${msg.from} on ${msg.channel}`,
-                    description: msg.body,
-                    assignee_id: agentId,
-                    context: JSON.stringify({ message: msg, userId: msg.userId }),
-                });
-            }
-        }
-        await this.hooks.emit("message.processed", {
-            message: msg,
-            channel: msg.channel,
-            agentId: agentId ?? null,
-            userId: msg.userId ?? null,
-        });
-    }
-    /**
-     * Resolve the best agent for a given inbound message.
-     * Returns agentId (slug) or undefined if no match.
-     */
-    resolveAgent(msg) {
-        // Try direct channel binding first
-        const bound = this.agentBindings.get(msg.channel);
-        if (bound)
-            return bound;
-        // Fallback: first agent in config
-        const first = this.config.agents[0];
-        return first?.slug;
-    }
-    /**
-     * Evaluate messaging policy for the given agent.
-     * Returns false if the message is blocked.
-     */
-    evaluatePolicy(msg, agentId) {
-        const channelConfig = this.config.channels[msg.channel];
-        // Check allowlist
-        const allowFrom = channelConfig?.["allowFrom"] ?? [];
-        if (!checkAllowlist(allowFrom, msg.from)) {
-            return false;
-        }
-        // Check mention gate
-        const mentionGated = channelConfig?.["requireMention"] ?? false;
-        if (mentionGated) {
-            if (!checkMentionGate(msg, agentId)) {
-                return false;
-            }
-        }
-        return true;
-    }
-}

package/dist/core/chat/policies.d.ts

@@ -1,16 +0,0 @@
-/**
- * Chat policy helpers — allowlist and mention gate checks.
- * Story 4.2
- */
-import type { InboundMessage } from "./types.js";
-/**
- * Returns true if the sender is in the allowlist.
- * If allowFrom is empty, all senders are allowed.
- */
-export declare function checkAllowlist(allowFrom: string[], senderId: string): boolean;
-/**
- * Returns true if the message passes the mention gate.
- * In group/channel contexts, the bot must be mentioned (body contains @botId or similar).
- * In direct contexts, always passes.
- */
-export declare function checkMentionGate(msg: InboundMessage, botId: string): boolean;

package/dist/core/chat/policies.js

@@ -1,25 +0,0 @@
-/**
- * Chat policy helpers — allowlist and mention gate checks.
- * Story 4.2
- */
-/**
- * Returns true if the sender is in the allowlist.
- * If allowFrom is empty, all senders are allowed.
- */
-export function checkAllowlist(allowFrom, senderId) {
-    if (allowFrom.length === 0)
-        return true;
-    return allowFrom.includes(senderId);
-}
-/**
- * Returns true if the message passes the mention gate.
- * In group/channel contexts, the bot must be mentioned (body contains @botId or similar).
- * In direct contexts, always passes.
- */
-export function checkMentionGate(msg, botId) {
-    // For direct messages, no mention required
-    // We check via a simple heuristic: if the message contains the botId mention
-    // This is called only when mention gating is enabled
-    const body = msg.body ?? "";
-    return body.includes(`@${botId}`) || body.includes(botId);
-}

package/dist/core/chat/routing.d.ts

@@ -1,17 +0,0 @@
-/**
- * Chat routing — maps channel/scope to agentId.
- * Story 4.2
- *
- * @deprecated Use TriageRouter for content-aware routing with keyword/regex
- * matching and LLM fallback. This static channel→agent binding is kept for
- * backward compatibility only. See `./triage-router.ts`.
- */
-import type { AgentConfig } from "../../shared/index.js";
-/**
- * Build a map from channel identifier to agentId.
- * Each agent may have a config.channel or config.channels binding.
- *
- * @deprecated Use TriageRouter instead — it supports keyword, regex,
- * and LLM-based routing with ownership chain logging.
- */
-export declare function buildAgentBindings(agents: AgentConfig[]): Map<string, string>;

package/dist/core/chat/routing.js

@@ -1,36 +0,0 @@
-/**
- * Chat routing — maps channel/scope to agentId.
- * Story 4.2
- *
- * @deprecated Use TriageRouter for content-aware routing with keyword/regex
- * matching and LLM fallback. This static channel→agent binding is kept for
- * backward compatibility only. See `./triage-router.ts`.
- */
-/**
- * Build a map from channel identifier to agentId.
- * Each agent may have a config.channel or config.channels binding.
- *
- * @deprecated Use TriageRouter instead — it supports keyword, regex,
- * and LLM-based routing with ownership chain logging.
- */
-export function buildAgentBindings(agents) {
-    const bindings = new Map();
-    for (const agent of agents) {
-        const agentId = agent.slug;
-        const cfg = agent.config ?? {};
-        // Support config.channel (single) or config.channels (array)
-        const channels = [];
-        if (typeof cfg["channel"] === "string") {
-            channels.push(cfg["channel"]);
-        }
-        if (Array.isArray(cfg["channels"])) {
-            for (const ch of cfg["channels"]) {
-                channels.push(ch);
-            }
-        }
-        for (const ch of channels) {
-            bindings.set(ch, agentId);
-        }
-    }
-    return bindings;
-}

package/dist/core/chat/session-key.d.ts

@@ -1,30 +0,0 @@
-/**
- * SessionKey — structured key for chat sessions.
- * Story 4.3
- */
-export declare class SessionKey {
-    readonly agentId: string;
-    readonly channel: string;
-    readonly scope: string;
-    constructor(agentId: string, channel: string, scope: string);
-    toString(): string;
-    toJSON(): {
-        agentId: string;
-        channel: string;
-        scope: string;
-    };
-    static fromString(key: string): SessionKey;
-    /**
-     * Build a session key from structured parameters.
-     *
-     * @param agentId      - The agent identifier
-     * @param channel      - The channel identifier
-     * @param chatType     - 'dm' or 'group'
-     * @param peerId       - The peer/user ID
-     * @param dmScope      - DM scoping strategy
-     *   - 'main'               → single session per agent+channel regardless of peer
-     *   - 'per-peer'           → one session per (agent, peer)
-     *   - 'per-channel-peer'   → one session per (agent, channel, peer)
-     */
-    static build(agentId: string, channel: string, chatType: "dm" | "group", peerId: string, dmScope: "main" | "per-peer" | "per-channel-peer"): SessionKey;
-}

package/dist/core/chat/session-key.js

@@ -1,65 +0,0 @@
-/**
- * SessionKey — structured key for chat sessions.
- * Story 4.3
- */
-export class SessionKey {
-    agentId;
-    channel;
-    scope;
-    constructor(agentId, channel, scope) {
-        this.agentId = agentId;
-        this.channel = channel;
-        this.scope = scope;
-    }
-    toString() {
-        return `agent:${this.agentId}:${this.channel}:${this.scope}`;
-    }
-    toJSON() {
-        return {
-            agentId: this.agentId,
-            channel: this.channel,
-            scope: this.scope,
-        };
-    }
-    static fromString(key) {
-        const parts = key.split(":");
-        if (parts.length < 4 || parts[0] !== "agent") {
-            throw new Error(`Invalid SessionKey format: ${key}`);
-        }
-        // agentId might contain ':', so reconstruct carefully
-        // Format: "agent:{agentId}:{channel}:{scope}"
-        // We assume agentId, channel, scope do NOT contain ':'
-        const [, agentId, channel, scope] = parts;
-        if (!agentId || !channel || !scope) {
-            throw new Error(`Invalid SessionKey format: ${key}`);
-        }
-        return new SessionKey(agentId, channel, scope);
-    }
-    /**
-     * Build a session key from structured parameters.
-     *
-     * @param agentId      - The agent identifier
-     * @param channel      - The channel identifier
-     * @param chatType     - 'dm' or 'group'
-     * @param peerId       - The peer/user ID
-     * @param dmScope      - DM scoping strategy
-     *   - 'main'               → single session per agent+channel regardless of peer
-     *   - 'per-peer'           → one session per (agent, peer)
-     *   - 'per-channel-peer'   → one session per (agent, channel, peer)
-     */
-    static build(agentId, channel, chatType, peerId, dmScope) {
-        if (chatType === "group") {
-            // Groups are always scoped to the channel
-            return new SessionKey(agentId, channel, channel);
-        }
-        // DM scoping
-        switch (dmScope) {
-            case "main":
-                return new SessionKey(agentId, channel, "main");
-            case "per-peer":
-                return new SessionKey(agentId, channel, peerId);
-            case "per-channel-peer":
-                return new SessionKey(agentId, channel, `${channel}:${peerId}`);
-        }
-    }
-}

package/dist/core/chat/session-manager.d.ts

@@ -1,17 +0,0 @@
-/**
- * ChatSessionManager — wraps orchestrator SessionManager with SessionKey-based lookup.
- * Story 4.3
- */
-import type { DataStore } from "../data/data-store.js";
-import { SessionKey } from "./session-key.js";
-export declare class ChatSessionManager {
-    private readonly inner;
-    constructor(db: DataStore);
-    save(key: SessionKey, params: Record<string, unknown>): Promise<string>;
-    load(key: SessionKey): Promise<Record<string, unknown> | undefined>;
-    clear(key: SessionKey): Promise<void>;
-    shouldClear(session: Record<string, unknown>, opts: {
-        maxRuns?: number;
-        maxAgeHours?: number;
-    }): Promise<boolean>;
-}