botinabox 2.9.0 → 2.9.2

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

@@ -0,0 +1,47 @@
+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/wakeup-queue.d.ts

@@ -0,0 +1,9 @@
+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/workflow-engine.d.ts

@@ -0,0 +1,47 @@
+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;
+}

package/dist/core/security/audit.d.ts

@@ -0,0 +1,20 @@
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { AuditEvent } from './types.js';
+interface AuditEmitterOptions {
+    auditTables?: string[];
+}
+/**
+ * Emits audit events via the HookBus for tracked tables.
+ *
+ * - auditTables defaults to [] (nothing audited)
+ * - '*' wildcard audits all tables
+ * - emit is fire-and-forget — errors are swallowed, no awaiting
+ */
+export declare class AuditEmitter {
+    private readonly hooks;
+    private readonly auditTables;
+    constructor(hooks: HookBus, opts?: AuditEmitterOptions);
+    shouldAudit(table: string): boolean;
+    emit(event: AuditEvent): void;
+}
+export {};

package/dist/core/security/column-validator.d.ts

@@ -0,0 +1,20 @@
+import type { DataStore } from '../data/data-store.js';
+export interface ColumnValidator {
+    validateWrite(table: string, row: Record<string, unknown>): Record<string, unknown>;
+    validateRead(table: string, columns: string[]): void;
+    invalidateCache(table: string): void;
+}
+/**
+ * Validates column names against the live SQLite schema.
+ *
+ * - validateWrite: strips unknown columns silently
+ * - validateRead: throws on unknown columns
+ */
+export declare class ColumnValidatorImpl implements ColumnValidator {
+    private readonly db;
+    constructor(db: DataStore);
+    private getValidColumns;
+    validateWrite(table: string, row: Record<string, unknown>): Record<string, unknown>;
+    validateRead(table: string, columns: string[]): void;
+    invalidateCache(_table: string): void;
+}

package/dist/core/security/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './sanitizer.js';
+export * from './column-validator.js';
+export * from './audit.js';
+export * from './process-env.js';

package/dist/core/security/process-env.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Build a clean environment for spawned subprocesses.
+ * Strips secrets and passes only safe system variables.
+ * Used by the CLI execution adapter when spawning agent processes.
+ */
+/**
+ * Build a filtered environment for subprocess execution.
+ * Only passes explicitly allowed variables — all secrets are stripped.
+ *
+ * @param allowedKeys - Additional keys to allow beyond the defaults
+ * @param inject - Extra key-value pairs to inject into the env
+ */
+export declare function buildProcessEnv(allowedKeys?: string[], inject?: Record<string, string>): Record<string, string>;

package/dist/core/security/sanitizer.d.ts

@@ -0,0 +1,11 @@
+import type { SanitizerOptions } from './types.js';
+/**
+ * Sanitizes a row object by:
+ * 1. Stripping null bytes from string values
+ * 2. Stripping control characters (preserving \n, \r, \t)
+ * 3. Truncating fields that exceed their byte length limit
+ *
+ * Non-string values pass through unchanged.
+ * Returns a new object — input is never mutated.
+ */
+export declare function sanitize(row: Record<string, unknown>, opts?: SanitizerOptions): Record<string, unknown>;

package/dist/core/security/types.d.ts

@@ -0,0 +1,11 @@
+export interface SanitizerOptions {
+    fieldLengthLimits?: Record<string, number>;
+    truncateSuffix?: string;
+}
+export interface AuditEvent {
+    table: string;
+    operation: 'insert' | 'update' | 'delete';
+    pk: unknown;
+    timestamp: number;
+    changedColumns?: string[];
+}

package/dist/core/update/auto-update.d.ts

@@ -0,0 +1,21 @@
+interface UpdateResult {
+    updated: boolean;
+    packages: Array<{
+        name: string;
+        from: string;
+        to: string;
+    }>;
+    restartRequired: boolean;
+}
+/**
+ * Check npm for newer versions of framework packages and install them.
+ * Returns what was updated. Safe to call on every startup — skips if
+ * already on latest.
+ *
+ * @param packages - Package names to check (default: botinabox + latticesql)
+ * @param opts.quiet - Suppress console output (default: false)
+ */
+export declare function autoUpdate(packages?: string[], opts?: {
+    quiet?: boolean;
+}): Promise<UpdateResult>;
+export {};

package/dist/core/update/backup-manager.d.ts

@@ -0,0 +1,7 @@
+export declare class BackupManager {
+    private projectRoot;
+    constructor(projectRoot: string);
+    backup(): Promise<string>;
+    restore(backupPath: string): Promise<void>;
+    cleanup(backupPath: string): Promise<void>;
+}

package/dist/core/update/index.d.ts

@@ -0,0 +1,8 @@
+export type { PackageUpdate, UpdateManifest } from './types.js';
+export { parseVersion, compareVersions, classifyUpdate } from './version-utils.js';
+export { UpdateChecker } from './update-checker.js';
+export { BackupManager } from './backup-manager.js';
+export { UpdateManager } from './update-manager.js';
+export { runPackageMigrations } from './migration-hooks.js';
+export type { PackageMigration } from './migration-hooks.js';
+export { autoUpdate } from './auto-update.js';

package/dist/core/update/migration-hooks.d.ts

@@ -0,0 +1,11 @@
+import type { DataStore } from '../data/data-store.js';
+export interface PackageMigration {
+    version: string;
+    package: string;
+    sql: string;
+}
+/**
+ * Runs package migrations using the __lattice_migrations table for tracking.
+ * Each migration is keyed by "{package}:{version}" to ensure idempotency.
+ */
+export declare function runPackageMigrations(db: DataStore, migrations: PackageMigration[]): Promise<void>;

package/dist/core/update/types.d.ts

@@ -0,0 +1,11 @@
+export interface PackageUpdate {
+    name: string;
+    installedVersion: string;
+    latestVersion: string;
+    updateType: 'patch' | 'minor' | 'major';
+}
+export interface UpdateManifest {
+    checkedAt: string;
+    packages: PackageUpdate[];
+    hasUpdates: boolean;
+}

package/dist/core/update/update-checker.d.ts

@@ -0,0 +1,11 @@
+import type { UpdateManifest } from './types.js';
+export declare class UpdateChecker {
+    private nodeModulesPath;
+    private opts?;
+    private readonly fetchFn;
+    constructor(nodeModulesPath: string, opts?: {
+        fetch?: typeof globalThis.fetch;
+    } | undefined);
+    getInstalledPackages(): string[];
+    check(packageNames?: string[]): Promise<UpdateManifest>;
+}

package/dist/core/update/update-manager.d.ts

@@ -0,0 +1,25 @@
+import type { DataStore } from '../data/data-store.js';
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { PackageUpdate, UpdateManifest } from './types.js';
+import { UpdateChecker } from './update-checker.js';
+type UpdatePolicy = 'auto-all' | 'auto-compatible' | 'auto-patch' | 'notify' | 'manual';
+export declare class UpdateManager {
+    private checker;
+    private db;
+    private hooks;
+    private opts?;
+    private backupManager;
+    constructor(checker: UpdateChecker, db: DataStore, hooks: HookBus, opts?: {
+        projectRoot?: string;
+        policy?: UpdatePolicy;
+        maintenanceWindow?: {
+            utcHourStart: number;
+            utcHourEnd: number;
+        };
+    } | undefined);
+    checkAndNotify(): Promise<UpdateManifest>;
+    applyUpdates(updates: PackageUpdate[]): Promise<void>;
+    isInMaintenanceWindow(): boolean;
+    filterByPolicy(updates: PackageUpdate[]): PackageUpdate[];
+}
+export {};

package/dist/core/update/version-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Simple semver utilities — no external deps.
+ */
+export declare function parseVersion(v: string): [number, number, number];
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+export declare function classifyUpdate(from: string, to: string): 'patch' | 'minor' | 'major' | 'none';