botinabox 2.4.2 → 2.5.0

package/dist/core/orchestrator/secret-store.js

@@ -1,171 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { scryptSync, createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-const ENC_PREFIX = "enc:";
-const ALGORITHM = "aes-256-gcm";
-const IV_LEN = 12;
-const TAG_LEN = 16;
-function deriveEncKey(masterKey) {
-    return scryptSync(masterKey, "botinabox-secrets-v1", 32);
-}
-function encryptValue(plaintext, key) {
-    const iv = randomBytes(IV_LEN);
-    const cipher = createCipheriv(ALGORITHM, key, iv);
-    const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return ENC_PREFIX + Buffer.concat([iv, tag, encrypted]).toString("base64");
-}
-function decryptValue(ciphertext, key) {
-    if (!ciphertext.startsWith(ENC_PREFIX))
-        return ciphertext; // plaintext passthrough for migration
-    const buf = Buffer.from(ciphertext.slice(ENC_PREFIX.length), "base64");
-    const iv = buf.subarray(0, IV_LEN);
-    const tag = buf.subarray(IV_LEN, IV_LEN + TAG_LEN);
-    const data = buf.subarray(IV_LEN + TAG_LEN);
-    const decipher = createDecipheriv(ALGORITHM, key, iv);
-    decipher.setAuthTag(tag);
-    return decipher.update(data).toString("utf8") + decipher.final("utf8");
-}
-export class SecretStore {
-    db;
-    hooks;
-    encKey;
-    /**
-     * @param db - DataStore instance
-     * @param hooks - HookBus instance
-     * @param encryptionKey - Optional master key for encrypting secrets at rest.
-     *   When provided, all new secrets are encrypted with AES-256-GCM.
-     *   Existing plaintext secrets are read transparently (passthrough on decrypt).
-     */
-    constructor(db, hooks, encryptionKey) {
-        this.db = db;
-        this.hooks = hooks;
-        this.encKey = encryptionKey ? deriveEncKey(encryptionKey) : null;
-    }
-    async set(input) {
-        const id = uuidv4();
-        const data = { ...input, id };
-        if (this.encKey && data.value) {
-            data.value = encryptValue(data.value, this.encKey);
-        }
-        await this.db.insert("secrets", data);
-        await this.hooks.emit("secret.created", { name: input.name });
-        const inserted = await this.db.get("secrets", id);
-        return this._toMeta(inserted);
-    }
-    async get(name, environment = "production") {
-        const rows = await this.db.query("secrets", {
-            where: { name, environment },
-            filters: [{ col: "deleted_at", op: "isNull" }],
-            limit: 1,
-        });
-        if (rows.length === 0)
-            return null;
-        await this.hooks.emit("secret.accessed", { name, environment });
-        const raw = rows[0].value ?? null;
-        if (raw && this.encKey)
-            return decryptValue(raw, this.encKey);
-        return raw;
-    }
-    async getMeta(name, environment = "production") {
-        const rows = await this.db.query("secrets", {
-            where: { name, environment },
-            filters: [{ col: "deleted_at", op: "isNull" }],
-            limit: 1,
-        });
-        return rows.length > 0 ? this._toMeta(rows[0]) : null;
-    }
-    async list() {
-        const rows = await this.db.query("secrets", {
-            filters: [{ col: "deleted_at", op: "isNull" }],
-            orderBy: "name",
-        });
-        return rows.map((r) => this._toMeta(r));
-    }
-    async rotate(name, newValue, environment = "production") {
-        const rows = await this.db.query("secrets", {
-            where: { name, environment },
-            filters: [{ col: "deleted_at", op: "isNull" }],
-            limit: 1,
-        });
-        if (rows.length === 0)
-            throw new Error(`Secret "${name}" not found`);
-        const storedValue = this.encKey ? encryptValue(newValue, this.encKey) : newValue;
-        await this.db.update("secrets", rows[0].id, {
-            value: storedValue,
-            updated_at: new Date().toISOString(),
-        });
-        await this.hooks.emit("secret.rotated", { name, environment });
-    }
-    async delete(name, environment = "production") {
-        const rows = await this.db.query("secrets", {
-            where: { name, environment },
-            filters: [{ col: "deleted_at", op: "isNull" }],
-            limit: 1,
-        });
-        if (rows.length === 0)
-            return;
-        await this.db.update("secrets", rows[0].id, {
-            deleted_at: new Date().toISOString(),
-        });
-        await this.hooks.emit("secret.deleted", { name, environment });
-    }
-    // ── Cursor persistence helpers ──────────────────────────────────
-    /**
-     * Load a sync cursor by key. Returns undefined if not found.
-     * Cursors are stored as secrets with type='sync_cursor'.
-     */
-    async loadCursor(key) {
-        const name = `sync-cursor:${key}`;
-        const rows = await this.db.query("secrets", {
-            where: { name },
-            filters: [{ col: "deleted_at", op: "isNull" }],
-            limit: 1,
-        });
-        const raw = rows[0]?.value ?? undefined;
-        if (raw && this.encKey)
-            return decryptValue(raw, this.encKey);
-        return raw;
-    }
-    /**
-     * Persist a sync cursor by key. Creates or updates the secret.
-     */
-    async saveCursor(key, value) {
-        const name = `sync-cursor:${key}`;
-        const storedValue = this.encKey ? encryptValue(value, this.encKey) : value;
-        const rows = await this.db.query("secrets", {
-            where: { name },
-            filters: [{ col: "deleted_at", op: "isNull" }],
-            limit: 1,
-        });
-        if (rows.length > 0) {
-            await this.db.update("secrets", rows[0].id, {
-                value: storedValue,
-                updated_at: new Date().toISOString(),
-            });
-        }
-        else {
-            await this.db.insert("secrets", {
-                id: uuidv4(),
-                name,
-                type: "sync_cursor",
-                value: storedValue,
-            });
-        }
-    }
-    _toMeta(row) {
-        return {
-            id: row.id,
-            org_id: row.org_id ?? null,
-            name: row.name,
-            type: row.type,
-            environment: row.environment,
-            location: row.location ?? null,
-            description: row.description ?? null,
-            rotation_schedule: row.rotation_schedule ?? null,
-            expires_at: row.expires_at ?? null,
-            notes: row.notes ?? null,
-            created_at: row.created_at,
-            updated_at: row.updated_at,
-        };
-    }
-}

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

@@ -1,13 +0,0 @@
-import type { DataStore } from '../data/data-store.js';
-export declare class SessionManager {
-    private db;
-    constructor(db: DataStore);
-    save(agentId: string, channelId: string, peerId: string, params: Record<string, unknown>): Promise<string>;
-    load(agentId: string, channelId: string, peerId: string): Promise<Record<string, unknown> | undefined>;
-    clear(agentId: string, channelId: string, peerId: string): Promise<void>;
-    shouldClear(session: Record<string, unknown>, opts: {
-        maxRuns?: number;
-        maxAgeHours?: number;
-    }): Promise<boolean>;
-    private _find;
-}

package/dist/core/orchestrator/session-manager.js

@@ -1,66 +0,0 @@
-export class SessionManager {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async save(agentId, channelId, peerId, params) {
-        const existing = await this._find(agentId, channelId, peerId);
-        if (existing) {
-            await this.db.update('sessions', { id: existing['id'] }, {
-                context: JSON.stringify(params),
-                last_message_at: new Date().toISOString(),
-                message_count: (existing['message_count'] ?? 0) + 1,
-            });
-            return existing['id'];
-        }
-        else {
-            const row = await this.db.insert('sessions', {
-                agent_id: agentId,
-                channel: channelId,
-                peer_id: peerId,
-                context: JSON.stringify(params),
-                last_message_at: new Date().toISOString(),
-                message_count: 1,
-            });
-            return row['id'];
-        }
-    }
-    async load(agentId, channelId, peerId) {
-        const session = await this._find(agentId, channelId, peerId);
-        if (!session)
-            return undefined;
-        const context = session['context']
-            ? JSON.parse(session['context'])
-            : {};
-        return { ...session, ...context };
-    }
-    async clear(agentId, channelId, peerId) {
-        const session = await this._find(agentId, channelId, peerId);
-        if (session) {
-            await this.db.delete('sessions', { id: session['id'] });
-        }
-    }
-    async shouldClear(session, opts) {
-        if (opts.maxRuns !== undefined) {
-            const messageCount = session['message_count'] ?? 0;
-            if (messageCount > opts.maxRuns)
-                return true;
-        }
-        if (opts.maxAgeHours !== undefined) {
-            const createdAt = session['created_at'];
-            if (createdAt) {
-                const ageMs = Date.now() - new Date(createdAt).getTime();
-                const ageHours = ageMs / (1000 * 60 * 60);
-                if (ageHours > opts.maxAgeHours)
-                    return true;
-            }
-        }
-        return false;
-    }
-    async _find(agentId, channelId, peerId) {
-        const rows = await this.db.query('sessions', {
-            where: { agent_id: agentId, channel: channelId, peer_id: peerId },
-        });
-        return rows[0] ?? undefined;
-    }
-}

package/dist/core/orchestrator/task-queue.d.ts

@@ -1,34 +0,0 @@
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-import { MAX_CHAIN_DEPTH } from './chain-guard.js';
-export { MAX_CHAIN_DEPTH };
-export declare class TaskQueue {
-    private db;
-    private hooks;
-    private config?;
-    private pollTimer;
-    private readonly pollIntervalMs;
-    private readonly staleThresholdMs;
-    constructor(db: DataStore, hooks: HookBus, config?: {
-        pollIntervalMs?: number;
-        staleThresholdMs?: number;
-    } | undefined);
-    create(task: {
-        title: string;
-        description?: string;
-        assignee_id?: string;
-        priority?: number;
-        chain_depth?: number;
-        chain_origin_id?: string;
-        [key: string]: unknown;
-    }): Promise<string>;
-    update(id: string, changes: Record<string, unknown>): Promise<void>;
-    get(id: string): Promise<Record<string, unknown> | undefined>;
-    list(filter?: {
-        status?: string;
-        assignee_id?: string;
-    }): Promise<Record<string, unknown>[]>;
-    startPolling(): void;
-    stopPolling(): void;
-    private poll;
-}

package/dist/core/orchestrator/task-queue.js

@@ -1,83 +0,0 @@
-import { MAX_CHAIN_DEPTH, checkChainDepth } from './chain-guard.js';
-export { MAX_CHAIN_DEPTH };
-export class TaskQueue {
-    db;
-    hooks;
-    config;
-    pollTimer = null;
-    pollIntervalMs;
-    staleThresholdMs;
-    constructor(db, hooks, config) {
-        this.db = db;
-        this.hooks = hooks;
-        this.config = config;
-        this.pollIntervalMs = config?.pollIntervalMs ?? 30_000;
-        this.staleThresholdMs = config?.staleThresholdMs ?? 5 * 60 * 1_000;
-    }
-    async create(task) {
-        const depth = task.chain_depth ?? 0;
-        checkChainDepth(depth, MAX_CHAIN_DEPTH);
-        const row = await this.db.insert('tasks', {
-            title: task.title,
-            description: task.description,
-            assignee_id: task.assignee_id,
-            priority: task.priority ?? 5,
-            chain_depth: depth,
-            chain_origin_id: task.chain_origin_id,
-            status: 'todo',
-            ...Object.fromEntries(Object.entries(task).filter(([k]) => !['title', 'description', 'assignee_id', 'priority', 'chain_depth', 'chain_origin_id', 'status'].includes(k))),
-        });
-        const taskId = row['id'];
-        // Non-blocking: let callers do setup (e.g. insert related records) before
-        // hook handlers (like execution engines) run.
-        void this.hooks.emit('task.created', { taskId, title: task.title });
-        return taskId;
-    }
-    async update(id, changes) {
-        await this.db.update('tasks', { id }, {
-            ...changes,
-            updated_at: new Date().toISOString(),
-        });
-    }
-    async get(id) {
-        return (await this.db.get('tasks', { id })) ?? undefined;
-    }
-    async list(filter) {
-        const where = {};
-        if (filter?.status)
-            where['status'] = filter.status;
-        if (filter?.assignee_id)
-            where['assignee_id'] = filter.assignee_id;
-        return await this.db.query('tasks', Object.keys(where).length ? { where } : undefined);
-    }
-    startPolling() {
-        if (this.pollTimer)
-            return;
-        this.pollTimer = setInterval(() => {
-            void this.poll();
-        }, this.pollIntervalMs);
-    }
-    stopPolling() {
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
-    }
-    async poll() {
-        // Find tasks with status='todo', assignee_id NOT NULL
-        const todoTasks = (await this.db.query('tasks', { where: { status: 'todo' } }))
-            .filter((t) => t['assignee_id'] != null);
-        // Check which have no active run
-        const activeTasks = new Set((await this.db.query('runs', { where: { status: 'running' } })).map((r) => r['task_id']));
-        const eligible = todoTasks
-            .filter((t) => !activeTasks.has(t['id']))
-            .sort((a, b) => a['priority'] - b['priority']);
-        for (const task of eligible) {
-            await this.hooks.emit('agent.wakeup', {
-                agentId: task['assignee_id'],
-                taskId: task['id'],
-                source: 'poll',
-            });
-        }
-    }
-}

package/dist/core/orchestrator/template-interpolate.d.ts

@@ -1,5 +0,0 @@
-/**
- * Simple template interpolation for workflow step templates.
- * Supports {{key}} and {{steps.stepId.output}} patterns.
- */
-export declare function interpolate(template: string, context: Record<string, unknown>): string;

package/dist/core/orchestrator/template-interpolate.js

@@ -1,18 +0,0 @@
-/**
- * Simple template interpolation for workflow step templates.
- * Supports {{key}} and {{steps.stepId.output}} patterns.
- */
-export function interpolate(template, context) {
-    return template.replace(/\{\{([^}]+)\}\}/g, (_match, path) => {
-        const parts = path.trim().split('.');
-        let value = context;
-        for (const part of parts) {
-            if (value == null || typeof value !== 'object')
-                return '';
-            value = value[part];
-        }
-        if (value == null)
-            return '';
-        return String(value);
-    });
-}

package/dist/core/orchestrator/user-registry.d.ts

@@ -1,47 +0,0 @@
-import type { DataStore } from "../data/data-store.js";
-import type { HookBus } from "../hooks/hook-bus.js";
-export interface UserInput {
-    id?: string;
-    org_id?: string;
-    name: string;
-    email?: string;
-    role?: string;
-    title?: string;
-    external_id?: string;
-    channel?: string;
-    timezone?: string;
-    preferences?: string;
-    notes?: string;
-}
-export interface User {
-    id: string;
-    org_id: string | null;
-    name: string;
-    email: string | null;
-    role: string | null;
-    title: string | null;
-    external_id: string | null;
-    channel: string | null;
-    timezone: string | null;
-    preferences: string;
-    notes: string | null;
-    created_at: string;
-    updated_at: string;
-    deleted_at: string | null;
-}
-export declare class UserRegistry {
-    private readonly db;
-    private readonly hooks;
-    constructor(db: DataStore, hooks: HookBus);
-    register(input: UserInput): Promise<User>;
-    getById(id: string): Promise<User | null>;
-    getByEmail(email: string): Promise<User | null>;
-    resolveByIdentity(channel: string, externalId: string): Promise<User | null>;
-    resolveOrCreate(externalId: string, channel: string, defaults?: Partial<UserInput>): Promise<User>;
-    list(filter?: {
-        role?: string;
-        org_id?: string;
-    }): Promise<User[]>;
-    update(id: string, changes: Partial<UserInput>): Promise<void>;
-    addIdentity(userId: string, channel: string, externalId: string, displayName?: string): Promise<void>;
-}

package/dist/core/orchestrator/user-registry.js

@@ -1,76 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-export class UserRegistry {
-    db;
-    hooks;
-    constructor(db, hooks) {
-        this.db = db;
-        this.hooks = hooks;
-    }
-    async register(input) {
-        const id = input.id ?? uuidv4();
-        await this.db.insert("users", { ...input, id });
-        const user = await this.db.get("users", id);
-        await this.hooks.emit("user.created", { user });
-        return user;
-    }
-    async getById(id) {
-        const row = await this.db.get("users", id);
-        return row ?? null;
-    }
-    async getByEmail(email) {
-        const rows = await this.db.query("users", {
-            where: { email },
-            filters: [{ col: "deleted_at", op: "isNull" }],
-            limit: 1,
-        });
-        return rows.length > 0 ? rows[0] : null;
-    }
-    async resolveByIdentity(channel, externalId) {
-        const identities = await this.db.query("user_identities", {
-            where: { channel, external_id: externalId },
-            limit: 1,
-        });
-        if (identities.length === 0)
-            return null;
-        return this.getById(identities[0].user_id);
-    }
-    async resolveOrCreate(externalId, channel, defaults) {
-        const existing = await this.resolveByIdentity(channel, externalId);
-        if (existing)
-            return existing;
-        const user = await this.register({
-            name: defaults?.name ?? externalId,
-            external_id: externalId,
-            channel,
-            ...defaults,
-        });
-        await this.addIdentity(user.id, channel, externalId);
-        return user;
-    }
-    async list(filter) {
-        const where = {};
-        const filters = [{ col: "deleted_at", op: "isNull" }];
-        if (filter?.role)
-            where.role = filter.role;
-        if (filter?.org_id)
-            where.org_id = filter.org_id;
-        const rows = await this.db.query("users", { where, filters });
-        return rows;
-    }
-    async update(id, changes) {
-        await this.db.update("users", id, {
-            ...changes,
-            updated_at: new Date().toISOString(),
-        });
-    }
-    async addIdentity(userId, channel, externalId, displayName) {
-        await this.db.insert("user_identities", {
-            id: uuidv4(),
-            user_id: userId,
-            channel,
-            external_id: externalId,
-            display_name: displayName ?? null,
-            verified: 0,
-        });
-    }
-}

package/dist/core/orchestrator/wakeup-queue.d.ts

@@ -1,9 +0,0 @@
-import type { DataStore } from '../data/data-store.js';
-export declare class WakeupQueue {
-    private db;
-    constructor(db: DataStore);
-    enqueue(agentId: string, source: string, context?: Record<string, unknown>): Promise<string>;
-    coalesce(agentId: string, context?: Record<string, unknown>): Promise<void>;
-    getNext(agentId: string): Promise<Record<string, unknown> | undefined>;
-    markFired(wakeupId: string, runId: string): Promise<void>;
-}

package/dist/core/orchestrator/wakeup-queue.js

@@ -1,45 +0,0 @@
-export class WakeupQueue {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async enqueue(agentId, source, context) {
-        const row = await this.db.insert('wakeups', {
-            agent_id: agentId,
-            scheduled_at: new Date().toISOString(),
-            context: context ? JSON.stringify({ source, ...context }) : JSON.stringify({ source }),
-        });
-        return row['id'];
-    }
-    async coalesce(agentId, context) {
-        // Find existing queued wakeup (no fired_at) for agent
-        const existing = (await this.db.query('wakeups', {
-            where: { agent_id: agentId },
-        })).filter((w) => w['fired_at'] == null);
-        if (existing.length === 0)
-            return;
-        // Merge context into oldest queued wakeup
-        const wakeup = existing[0];
-        const currentCtx = wakeup['context']
-            ? JSON.parse(wakeup['context'])
-            : {};
-        const merged = { ...currentCtx, ...(context ?? {}) };
-        await this.db.update('wakeups', { id: wakeup['id'] }, {
-            context: JSON.stringify(merged),
-        });
-    }
-    async getNext(agentId) {
-        const queued = (await this.db.query('wakeups', {
-            where: { agent_id: agentId },
-        }))
-            .filter((w) => w['fired_at'] == null)
-            .sort((a, b) => a['scheduled_at'].localeCompare(b['scheduled_at']));
-        return queued[0] ?? undefined;
-    }
-    async markFired(wakeupId, runId) {
-        await this.db.update('wakeups', { id: wakeupId }, {
-            fired_at: new Date().toISOString(),
-            run_id: runId,
-        });
-    }
-}

package/dist/core/orchestrator/workflow-engine.d.ts

@@ -1,47 +0,0 @@
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-import type { TaskQueue } from './task-queue.js';
-export interface WorkflowStep {
-    id: string;
-    name: string;
-    agentSlug?: string;
-    taskTemplate: {
-        title: string;
-        description: string;
-    };
-    dependsOn?: string[];
-    onComplete?: 'next' | 'parallel' | 'end';
-    onFail?: 'abort' | 'skip' | 'retry';
-}
-export interface WorkflowDefinition {
-    name: string;
-    description?: string;
-    steps: WorkflowStep[];
-    trigger?: {
-        type: 'task_completed' | 'event' | 'schedule' | 'manual';
-        filter?: Record<string, unknown>;
-    };
-}
-export declare class WorkflowEngine {
-    private db;
-    private hooks;
-    private taskQueue;
-    constructor(db: DataStore, hooks: HookBus, taskQueue: TaskQueue);
-    /**
-     * Define/register a workflow.
-     */
-    define(slug: string, def: WorkflowDefinition): Promise<void>;
-    /**
-     * Start a workflow run.
-     */
-    start(workflowSlug: string, context: Record<string, unknown>): Promise<string>;
-    /**
-     * Called when a task with workflow_run_id completes.
-     */
-    onStepCompleted(taskId: string, output: string): Promise<void>;
-    /**
-     * Mark a workflow run as failed.
-     */
-    onStepFailed(taskId: string, error: string): Promise<void>;
-    private _createStepTask;
-}