botinabox 2.5.2 → 2.6.0

package/dist/core/orchestrator/adapters/process-manager.d.ts

@@ -1,15 +0,0 @@
-import type { ChildProcess } from 'node:child_process';
-export interface SpawnOpts {
-    cwd: string;
-    allowedEnvVars?: string[];
-    extraEnv?: Record<string, string>;
-    timeoutMs?: number;
-}
-/**
- * Spawn a process with its own PGID (detached=true) and piped stdio.
- */
-export declare function spawnProcess(command: string, args: string[], opts: SpawnOpts): ChildProcess;
-/**
- * Kill an entire process group by negative PID.
- */
-export declare function killProcessGroup(pid: number, signal?: NodeJS.Signals): void;

package/dist/core/orchestrator/adapters/process-manager.js

@@ -1,26 +0,0 @@
-import { spawn } from 'node:child_process';
-import { filterEnv } from './env-whitelist.js';
-/**
- * Spawn a process with its own PGID (detached=true) and piped stdio.
- */
-export function spawnProcess(command, args, opts) {
-    const env = filterEnv(opts.allowedEnvVars, opts.extraEnv);
-    const child = spawn(command, args, {
-        cwd: opts.cwd,
-        env,
-        detached: true,
-        stdio: 'pipe',
-    });
-    return child;
-}
-/**
- * Kill an entire process group by negative PID.
- */
-export function killProcessGroup(pid, signal = 'SIGTERM') {
-    try {
-        process.kill(-pid, signal);
-    }
-    catch {
-        // Process may already be gone
-    }
-}

package/dist/core/orchestrator/adapters/tool-loop.d.ts

@@ -1,22 +0,0 @@
-import type { ChatMessage, ChatParams, ChatResult, ToolDefinition } from "../../../shared/index.js";
-export interface ToolExecutor {
-    (toolName: string, toolInput: unknown): Promise<string>;
-}
-export declare function toolLoop(params: {
-    model: string;
-    messages: ChatMessage[];
-    systemPrompt?: string;
-    tools?: ToolDefinition[];
-    maxIterations?: number;
-    signal?: AbortSignal;
-}, callLLM: (params: ChatParams) => Promise<ChatResult>, executeTool?: ToolExecutor): AsyncGenerator<{
-    type: 'text';
-    content: string;
-} | {
-    type: 'tool_use';
-    name: string;
-    input: unknown;
-} | {
-    type: 'done';
-    result: ChatResult;
-}>;

package/dist/core/orchestrator/adapters/tool-loop.js

@@ -1,66 +0,0 @@
-export async function* toolLoop(params, callLLM, executeTool) {
-    const maxIterations = params.maxIterations ?? 20;
-    const messages = [...params.messages];
-    let iterations = 0;
-    while (iterations < maxIterations) {
-        if (params.signal?.aborted) {
-            return;
-        }
-        iterations++;
-        const chatParams = {
-            model: params.model,
-            messages,
-            system: params.systemPrompt,
-            tools: params.tools,
-        };
-        const result = await callLLM(chatParams);
-        if (result.content) {
-            yield { type: 'text', content: result.content };
-        }
-        if (result.stopReason === 'end_turn' || result.stopReason === 'stop_sequence' || result.stopReason === 'max_tokens') {
-            yield { type: 'done', result };
-            return;
-        }
-        if (result.stopReason === 'tool_use' && result.toolUses && result.toolUses.length > 0) {
-            const toolResults = [];
-            for (const toolUse of result.toolUses) {
-                yield { type: 'tool_use', name: toolUse.name, input: toolUse.input };
-                if (executeTool) {
-                    const toolResult = await executeTool(toolUse.name, toolUse.input);
-                    toolResults.push(toolResult);
-                    // Add assistant message with tool use
-                    messages.push({
-                        role: 'assistant',
-                        content: [
-                            ...(result.content ? [{ type: 'text', text: result.content }] : []),
-                            { type: 'tool_use', id: toolUse.id, name: toolUse.name, input: toolUse.input },
-                        ],
-                    });
-                    // Add tool result message
-                    messages.push({
-                        role: 'user',
-                        content: [
-                            { type: 'tool_result', tool_use_id: toolUse.id, content: toolResult },
-                        ],
-                    });
-                }
-            }
-            if (!executeTool) {
-                yield { type: 'done', result };
-                return;
-            }
-        }
-        else {
-            yield { type: 'done', result };
-            return;
-        }
-    }
-    // Max iterations reached — yield final done with last known state
-    const finalResult = await callLLM({
-        model: params.model,
-        messages,
-        system: params.systemPrompt,
-        tools: params.tools,
-    });
-    yield { type: 'done', result: finalResult };
-}

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

@@ -1,31 +0,0 @@
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-export declare class AgentRegistry {
-    private db;
-    private hooks;
-    constructor(db: DataStore, hooks: HookBus);
-    register(agent: {
-        slug: string;
-        name: string;
-        adapter: string;
-        role?: string;
-        [key: string]: unknown;
-    }, opts?: {
-        actorAgentId?: string;
-    }): Promise<string>;
-    getById(id: string): Promise<Record<string, unknown> | undefined>;
-    getBySlug(slug: string): Promise<Record<string, unknown> | undefined>;
-    list(filter?: {
-        status?: string;
-        role?: string;
-    }): Promise<Record<string, unknown>[]>;
-    update(id: string, changes: Record<string, unknown>): Promise<void>;
-    setStatus(id: string, newStatus: string): Promise<void>;
-    terminate(id: string): Promise<void>;
-    seedFromConfig(agentConfigs: Array<{
-        slug: string;
-        name: string;
-        adapter: string;
-        [key: string]: unknown;
-    }>): Promise<void>;
-}

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

@@ -1,135 +0,0 @@
-import { createConfigRevision } from './config-revisions.js';
-const VALID_TRANSITIONS = {
-    idle: ['running', 'paused'],
-    running: ['idle', 'paused', 'terminated'],
-    paused: ['idle', 'terminated'],
-    terminated: [],
-};
-const WRITE_ACTIVITY_LOG_STATUSES = new Set(['paused', 'terminated']);
-export class AgentRegistry {
-    db;
-    hooks;
-    constructor(db, hooks) {
-        this.db = db;
-        this.hooks = hooks;
-    }
-    async register(agent, opts) {
-        if (!agent.slug || !agent.name || !agent.adapter) {
-            throw new Error('Agent must have slug, name, and adapter');
-        }
-        // Permission check: if actorAgentId is set, verify the actor can create agents
-        if (opts?.actorAgentId) {
-            const actor = await this.db.get('agents', { id: opts.actorAgentId });
-            if (!actor)
-                throw new Error(`Actor agent not found: ${opts.actorAgentId}`);
-            // Check canCreateAgents in adapter_config JSON
-            let canCreate = false;
-            try {
-                const cfg = JSON.parse(actor['adapter_config'] ?? '{}');
-                canCreate = cfg['canCreateAgents'] === true;
-            }
-            catch {
-                canCreate = false;
-            }
-            if (!canCreate) {
-                throw new Error(`Agent ${opts.actorAgentId} does not have permission to create agents`);
-            }
-        }
-        const row = await this.db.insert('agents', {
-            slug: agent.slug,
-            name: agent.name,
-            adapter: agent.adapter,
-            role: agent.role ?? 'general',
-            ...Object.fromEntries(Object.entries(agent).filter(([k]) => !['slug', 'name', 'adapter', 'role'].includes(k))),
-        });
-        const newAgentId = row['id'];
-        if (opts?.actorAgentId) {
-            await this.db.insert('activity_log', {
-                agent_id: opts.actorAgentId,
-                event_type: 'agent_created_by_agent',
-                payload: JSON.stringify({
-                    actorAgentId: opts.actorAgentId,
-                    newAgentId,
-                    slug: agent.slug,
-                }),
-            });
-        }
-        await this.hooks.emit('agent.created', { agentId: newAgentId, slug: agent.slug });
-        return newAgentId;
-    }
-    async getById(id) {
-        return (await this.db.get('agents', { id })) ?? undefined;
-    }
-    async getBySlug(slug) {
-        const rows = await this.db.query('agents', { where: { slug } });
-        return rows[0] ?? undefined;
-    }
-    async list(filter) {
-        const where = {};
-        if (filter?.status)
-            where['status'] = filter.status;
-        if (filter?.role)
-            where['role'] = filter.role;
-        return await this.db.query('agents', Object.keys(where).length ? { where } : undefined);
-    }
-    async update(id, changes) {
-        const existing = await this.db.get('agents', { id });
-        if (!existing)
-            throw new Error(`Agent not found: ${id}`);
-        const before = { ...existing };
-        await createConfigRevision(this.db, id, before, { ...before, ...changes });
-        await this.db.update('agents', { id }, {
-            ...changes,
-            updated_at: new Date().toISOString(),
-        });
-    }
-    async setStatus(id, newStatus) {
-        const agent = await this.db.get('agents', { id });
-        if (!agent)
-            throw new Error(`Agent not found: ${id}`);
-        const currentStatus = agent['status'];
-        const allowed = VALID_TRANSITIONS[currentStatus] ?? [];
-        if (!allowed.includes(newStatus)) {
-            throw new Error(`Invalid status transition: ${currentStatus} → ${newStatus}`);
-        }
-        await this.db.update('agents', { id }, {
-            status: newStatus,
-            updated_at: new Date().toISOString(),
-        });
-        if (WRITE_ACTIVITY_LOG_STATUSES.has(newStatus)) {
-            await this.db.insert('activity_log', {
-                agent_id: id,
-                event_type: `agent.${newStatus}`,
-                payload: JSON.stringify({ agentId: id, status: newStatus }),
-            });
-        }
-    }
-    async terminate(id) {
-        const agent = await this.db.get('agents', { id });
-        if (!agent)
-            throw new Error(`Agent not found: ${id}`);
-        const currentStatus = agent['status'];
-        if (currentStatus === 'terminated') {
-            // Already terminated — no-op
-            return;
-        }
-        await this.db.update('agents', { id }, {
-            status: 'terminated',
-            deleted_at: new Date().toISOString(),
-            updated_at: new Date().toISOString(),
-        });
-        await this.db.insert('activity_log', {
-            agent_id: id,
-            event_type: 'agent.terminated',
-            payload: JSON.stringify({ agentId: id }),
-        });
-    }
-    async seedFromConfig(agentConfigs) {
-        for (const config of agentConfigs) {
-            const existing = await this.getBySlug(config.slug);
-            if (existing)
-                continue; // Skip — DB values take precedence
-            await this.register(config);
-        }
-    }
-}

package/dist/core/orchestrator/budget-controller.d.ts

@@ -1,19 +0,0 @@
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-export declare class BudgetController {
-    private db;
-    private hooks;
-    constructor(db: DataStore, hooks: HookBus);
-    checkBudget(agentId: string): Promise<{
-        allowed: boolean;
-        reason?: string;
-        currentSpendCents: number;
-        limitCents: number;
-    }>;
-    resetMonthlySpend(agentId: string): Promise<void>;
-    globalCheck(): Promise<{
-        allowed: boolean;
-        totalSpentCents: number;
-        limitCents: number;
-    }>;
-}

package/dist/core/orchestrator/budget-controller.js

@@ -1,73 +0,0 @@
-export class BudgetController {
-    db;
-    hooks;
-    constructor(db, hooks) {
-        this.db = db;
-        this.hooks = hooks;
-    }
-    async checkBudget(agentId) {
-        const agent = await this.db.get('agents', { id: agentId });
-        if (!agent) {
-            throw new Error(`Agent not found: ${agentId}`);
-        }
-        const limitCents = agent['budget_monthly_cents'] ?? 0;
-        const currentSpendCents = agent['spent_monthly_cents'] ?? 0;
-        // No budget set = always allowed
-        if (limitCents <= 0) {
-            return { allowed: true, currentSpendCents, limitCents };
-        }
-        if (currentSpendCents >= limitCents) {
-            return {
-                allowed: false,
-                reason: 'Monthly budget exceeded',
-                currentSpendCents,
-                limitCents,
-            };
-        }
-        // Check warn threshold — look up agent-specific policy first, then global
-        let warnPercent = 80;
-        const agentPolicies = await this.db.query('budget_policies', {
-            where: { agent_id: agentId },
-        });
-        if (agentPolicies.length > 0) {
-            warnPercent = agentPolicies[0]['warn_percent'] ?? 80;
-        }
-        const warnThreshold = limitCents * (warnPercent / 100);
-        if (currentSpendCents >= warnThreshold) {
-            await this.hooks.emit('budget.exceeded', {
-                agentId,
-                currentSpendCents,
-                limitCents,
-                warnPercent,
-                message: `Budget warning: ${currentSpendCents} of ${limitCents} cents used (${warnPercent}% threshold)`,
-            });
-        }
-        return { allowed: true, currentSpendCents, limitCents };
-    }
-    async resetMonthlySpend(agentId) {
-        await this.db.update('agents', { id: agentId }, {
-            spent_monthly_cents: 0,
-            updated_at: new Date().toISOString(),
-        });
-    }
-    async globalCheck() {
-        const agents = await this.db.query('agents');
-        const totalSpentCents = agents.reduce((sum, a) => sum + (a['spent_monthly_cents'] ?? 0), 0);
-        // Find global budget policy
-        const globalPolicies = await this.db.query('budget_policies', {
-            where: { scope: 'global' },
-        });
-        if (globalPolicies.length === 0) {
-            return { allowed: true, totalSpentCents, limitCents: 0 };
-        }
-        const limitCents = globalPolicies[0]['monthly_limit_cents'] ?? 0;
-        if (limitCents <= 0) {
-            return { allowed: true, totalSpentCents, limitCents };
-        }
-        return {
-            allowed: totalSpentCents < limitCents,
-            totalSpentCents,
-            limitCents,
-        };
-    }
-}

package/dist/core/orchestrator/chain-guard.d.ts

@@ -1,14 +0,0 @@
-export declare const MAX_CHAIN_DEPTH = 5;
-/**
- * Throws if depth exceeds the maximum allowed chain depth.
- */
-export declare function checkChainDepth(depth: number, max?: number): void;
-/**
- * Build chain origin metadata for a new child task.
- * If parentTaskId is provided, sets chain_origin_id and increments depth.
- * Otherwise returns depth=0 with no origin.
- */
-export declare function buildChainOrigin(parentTaskId?: string, parentOriginId?: string, parentDepth?: number): {
-    chain_origin_id?: string;
-    chain_depth: number;
-};

package/dist/core/orchestrator/chain-guard.js

@@ -1,23 +0,0 @@
-export const MAX_CHAIN_DEPTH = 5;
-/**
- * Throws if depth exceeds the maximum allowed chain depth.
- */
-export function checkChainDepth(depth, max = MAX_CHAIN_DEPTH) {
-    if (depth > max) {
-        throw new Error(`Chain depth limit exceeded (max ${max})`);
-    }
-}
-/**
- * Build chain origin metadata for a new child task.
- * If parentTaskId is provided, sets chain_origin_id and increments depth.
- * Otherwise returns depth=0 with no origin.
- */
-export function buildChainOrigin(parentTaskId, parentOriginId, parentDepth) {
-    if (!parentTaskId) {
-        return { chain_depth: 0 };
-    }
-    return {
-        chain_origin_id: parentOriginId ?? parentTaskId,
-        chain_depth: (parentDepth ?? 0) + 1,
-    };
-}

package/dist/core/orchestrator/circuit-breaker.d.ts

@@ -1,65 +0,0 @@
-/**
- * CircuitBreaker — prevents runaway agent failures with automatic escalation.
- * Story 6.2
- *
- * States:
- *   CLOSED  → normal operation, failures counted
- *   OPEN    → tripped, all executions blocked, escalated to human
- *   HALF_OPEN → probe mode, one execution allowed to test recovery
- *
- * Integrates with LoopDetector and RunManager via HookBus events.
- */
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-export declare enum BreakerState {
-    CLOSED = "closed",
-    OPEN = "open",
-    HALF_OPEN = "half_open"
-}
-export interface CircuitBreakerConfig {
-    /** Failures before tripping. Default: 3 */
-    failureThreshold?: number;
-    /** Milliseconds to wait before half-open probe. Default: 300_000 (5 min) */
-    resetTimeoutMs?: number;
-    /** Log events to the database. Default: true */
-    persist?: boolean;
-}
-export declare class CircuitBreaker {
-    private db;
-    private hooks;
-    private readonly breakers;
-    private readonly failureThreshold;
-    private readonly resetTimeoutMs;
-    private readonly persist;
-    constructor(db: DataStore, hooks: HookBus, config?: CircuitBreakerConfig);
-    /**
-     * Check if an agent is allowed to execute.
-     * Returns true if execution is allowed, false if circuit is open.
-     */
-    canExecute(agentId: string): boolean;
-    /**
-     * Record a successful execution. Resets the breaker to CLOSED.
-     */
-    recordSuccess(agentId: string): Promise<void>;
-    /**
-     * Record a failed execution. Increments failure count and may trip breaker.
-     */
-    recordFailure(agentId: string, reason?: string): Promise<void>;
-    /**
-     * Trip the breaker to OPEN state and escalate to human.
-     */
-    trip(agentId: string, reason: string): Promise<void>;
-    /**
-     * Manually reset a breaker (e.g. after human review).
-     */
-    reset(agentId: string): Promise<void>;
-    /**
-     * Get the current state of a breaker.
-     */
-    getState(agentId: string): BreakerState;
-    /**
-     * Get failure count for an agent.
-     */
-    getFailureCount(agentId: string): number;
-    private logEvent;
-}

package/dist/core/orchestrator/circuit-breaker.js

@@ -1,159 +0,0 @@
-/**
- * CircuitBreaker — prevents runaway agent failures with automatic escalation.
- * Story 6.2
- *
- * States:
- *   CLOSED  → normal operation, failures counted
- *   OPEN    → tripped, all executions blocked, escalated to human
- *   HALF_OPEN → probe mode, one execution allowed to test recovery
- *
- * Integrates with LoopDetector and RunManager via HookBus events.
- */
-export var BreakerState;
-(function (BreakerState) {
-    BreakerState["CLOSED"] = "closed";
-    BreakerState["OPEN"] = "open";
-    BreakerState["HALF_OPEN"] = "half_open";
-})(BreakerState || (BreakerState = {}));
-const DEFAULT_FAILURE_THRESHOLD = 3;
-const DEFAULT_RESET_TIMEOUT_MS = 5 * 60 * 1000;
-export class CircuitBreaker {
-    db;
-    hooks;
-    breakers = new Map();
-    failureThreshold;
-    resetTimeoutMs;
-    persist;
-    constructor(db, hooks, config) {
-        this.db = db;
-        this.hooks = hooks;
-        this.failureThreshold = config?.failureThreshold ?? DEFAULT_FAILURE_THRESHOLD;
-        this.resetTimeoutMs = config?.resetTimeoutMs ?? DEFAULT_RESET_TIMEOUT_MS;
-        this.persist = config?.persist ?? true;
-    }
-    /**
-     * Check if an agent is allowed to execute.
-     * Returns true if execution is allowed, false if circuit is open.
-     */
-    canExecute(agentId) {
-        const breaker = this.breakers.get(agentId);
-        if (!breaker)
-            return true;
-        switch (breaker.state) {
-            case BreakerState.CLOSED:
-                return true;
-            case BreakerState.OPEN: {
-                // Check if enough time has passed for a probe
-                const elapsed = Date.now() - (breaker.trippedAt ?? 0);
-                if (elapsed >= this.resetTimeoutMs) {
-                    breaker.state = BreakerState.HALF_OPEN;
-                    return true;
-                }
-                return false;
-            }
-            case BreakerState.HALF_OPEN:
-                // Allow one probe execution
-                return true;
-        }
-    }
-    /**
-     * Record a successful execution. Resets the breaker to CLOSED.
-     */
-    async recordSuccess(agentId) {
-        const breaker = this.breakers.get(agentId);
-        if (!breaker)
-            return;
-        const previousState = breaker.state;
-        breaker.state = BreakerState.CLOSED;
-        breaker.failureCount = 0;
-        if (previousState === BreakerState.HALF_OPEN) {
-            await this.logEvent(agentId, 'circuit_recovered', {
-                previousState,
-            });
-            await this.hooks.emit('circuit_breaker.recovered', {
-                agentId,
-                previousState,
-            });
-        }
-    }
-    /**
-     * Record a failed execution. Increments failure count and may trip breaker.
-     */
-    async recordFailure(agentId, reason) {
-        let breaker = this.breakers.get(agentId);
-        if (!breaker) {
-            breaker = {
-                state: BreakerState.CLOSED,
-                failureCount: 0,
-                lastFailureAt: Date.now(),
-            };
-            this.breakers.set(agentId, breaker);
-        }
-        breaker.failureCount++;
-        breaker.lastFailureAt = Date.now();
-        if (breaker.state === BreakerState.HALF_OPEN) {
-            // Probe failed — reopen
-            await this.trip(agentId, reason ?? 'Probe execution failed during half-open state');
-            return;
-        }
-        if (breaker.failureCount >= this.failureThreshold) {
-            await this.trip(agentId, reason ?? `Failure threshold reached (${this.failureThreshold})`);
-        }
-    }
-    /**
-     * Trip the breaker to OPEN state and escalate to human.
-     */
-    async trip(agentId, reason) {
-        let breaker = this.breakers.get(agentId);
-        if (!breaker) {
-            breaker = {
-                state: BreakerState.CLOSED,
-                failureCount: 0,
-                lastFailureAt: Date.now(),
-            };
-            this.breakers.set(agentId, breaker);
-        }
-        breaker.state = BreakerState.OPEN;
-        breaker.trippedAt = Date.now();
-        await this.logEvent(agentId, 'circuit_tripped', {
-            reason,
-            failureCount: breaker.failureCount,
-        });
-        // Emit escalation hook for human notification
-        await this.hooks.emit('circuit_breaker.tripped', {
-            agentId,
-            reason,
-            failureCount: breaker.failureCount,
-            action: 'escalate_to_human',
-        });
-    }
-    /**
-     * Manually reset a breaker (e.g. after human review).
-     */
-    async reset(agentId) {
-        this.breakers.delete(agentId);
-        await this.logEvent(agentId, 'circuit_reset', {});
-        await this.hooks.emit('circuit_breaker.reset', { agentId });
-    }
-    /**
-     * Get the current state of a breaker.
-     */
-    getState(agentId) {
-        return this.breakers.get(agentId)?.state ?? BreakerState.CLOSED;
-    }
-    /**
-     * Get failure count for an agent.
-     */
-    getFailureCount(agentId) {
-        return this.breakers.get(agentId)?.failureCount ?? 0;
-    }
-    async logEvent(agentId, eventType, payload) {
-        if (!this.persist)
-            return;
-        await this.db.insert('activity_log', {
-            agent_id: agentId,
-            event_type: eventType,
-            payload: JSON.stringify(payload),
-        });
-    }
-}