@cef-ai/cli 0.2.6 → 0.3.0

package/dist/lib/runtime/context-builder.js

@@ -1,166 +0,0 @@
-/**
- * Builds the context object injected into agent/engagement V8 sandboxes.
- *
- * This is THE single source of truth for the Context API shape.
- * When the platform API changes, update this file.
- *
- * Properties are grouped into:
- * 1. Typed properties (from typecheck.ts Context interface)
- * 2. Non-typed extensions (in platform docs but not in typecheck.ts)
- */
-export function buildContext(opts) {
-    const { executionId, logCollector, agentRouter, cubbyManager, streamManager, workspaceId, agentServiceId, agentAlias, taskAlias, callerLabel, } = opts;
-    const currentLabel = agentAlias && taskAlias
-        ? `${agentAlias}.${taskAlias}`
-        : callerLabel ?? 'engagement';
-    // ─── Typed properties (from typecheck.ts Context interface) ───────────
-    const log = (...args) => {
-        logCollector.add(executionId, 'log', args, agentAlias, taskAlias);
-    };
-    const warn = (...args) => {
-        logCollector.add(executionId, 'warn', args, agentAlias, taskAlias);
-    };
-    const error = (...args) => {
-        logCollector.add(executionId, 'error', args, agentAlias, taskAlias);
-    };
-    const emit = (eventType, payload, _targetId) => {
-        logCollector.add(executionId, 'log', ['[emit]', eventType, payload], agentAlias, taskAlias);
-    };
-    // Agents proxy: context.agents.{alias}.{task}(payload)
-    // Wrapped with trace events for execution flow tracking
-    const agents = new Proxy({}, {
-        get(_, targetAgentAlias) {
-            return new Proxy({}, {
-                get(_, targetTaskAlias) {
-                    return async (payload) => {
-                        const calleeLabel = `${targetAgentAlias}.${targetTaskAlias}`;
-                        logCollector.emitTrace({
-                            timestamp: Date.now(),
-                            executionId,
-                            type: 'agent:call',
-                            caller: currentLabel,
-                            callee: calleeLabel,
-                        });
-                        const start = performance.now();
-                        try {
-                            const childContext = buildContext({
-                                ...opts,
-                                agentAlias: targetAgentAlias,
-                                taskAlias: targetTaskAlias,
-                                callerLabel: currentLabel,
-                            });
-                            const result = await agentRouter.call(targetAgentAlias, targetTaskAlias, payload, childContext);
-                            logCollector.emitTrace({
-                                timestamp: Date.now(),
-                                executionId,
-                                type: 'agent:return',
-                                caller: currentLabel,
-                                callee: calleeLabel,
-                                durationMs: performance.now() - start,
-                                success: true,
-                            });
-                            return result;
-                        }
-                        catch (err) {
-                            logCollector.emitTrace({
-                                timestamp: Date.now(),
-                                executionId,
-                                type: 'agent:return',
-                                caller: currentLabel,
-                                callee: calleeLabel,
-                                durationMs: performance.now() - start,
-                                success: false,
-                                error: err.message,
-                            });
-                            throw err;
-                        }
-                    };
-                },
-            });
-        },
-    });
-    // Cubbies proxy: context.cubbies.{alias}.query/exec
-    // Wrapped with trace events
-    const cubbies = new Proxy({}, {
-        get(_, alias) {
-            return {
-                query: async (...args) => {
-                    const resolved = resolveOverloadedArgs(args);
-                    logCollector.emitTrace({
-                        timestamp: Date.now(),
-                        executionId,
-                        type: 'cubby:query',
-                        caller: currentLabel,
-                        cubbyAlias: alias,
-                        sql: truncate(resolved.sql, 100),
-                    });
-                    const result = await cubbyManager.queryOverloaded(alias, args);
-                    return result;
-                },
-                exec: async (...args) => {
-                    const resolved = resolveOverloadedArgs(args);
-                    const result = await cubbyManager.execOverloaded(alias, args);
-                    logCollector.emitTrace({
-                        timestamp: Date.now(),
-                        executionId,
-                        type: 'cubby:exec',
-                        caller: currentLabel,
-                        cubbyAlias: alias,
-                        sql: truncate(resolved.sql, 100),
-                        rowsAffected: result.rowsAffected,
-                    });
-                    return result;
-                },
-            };
-        },
-    });
-    // Streams
-    const streams = {
-        subscribe: async (streamId) => {
-            return streamManager.getStream(streamId);
-        },
-    };
-    // Rafts stub
-    const rafts = new Proxy({}, {
-        get(_, alias) {
-            return {
-                query: async () => {
-                    throw new Error(`Raft queries not available in local dev mode (raft alias: "${alias}")`);
-                },
-            };
-        },
-    });
-    // ─── Non-typed extensions (platform docs, not in typecheck.ts) ────────
-    const workspace = {
-        id: workspaceId,
-        agentServiceId,
-    };
-    return {
-        // Typed properties (must match typecheck.ts Context interface)
-        fetch: globalThis.fetch,
-        emit,
-        log,
-        warn,
-        error,
-        streams,
-        cubbies,
-        agents,
-        rafts,
-        // Non-typed extensions
-        workspace,
-    };
-}
-// Extract SQL from overloaded cubby args for trace display
-function resolveOverloadedArgs(args) {
-    const first = args[0];
-    if (typeof first === 'string' && first.includes(' ')) {
-        return { sql: first };
-    }
-    if (typeof args[1] === 'string') {
-        return { sql: args[1] };
-    }
-    return { sql: '(unknown)' };
-}
-function truncate(s, max) {
-    return s.length > max ? s.slice(0, max) + '...' : s;
-}

package/dist/lib/runtime/cubby-manager.d.ts

@@ -1,20 +0,0 @@
-import type { CubbyConfig } from '../types.js';
-import type { QueryResult, ExecResult } from './types.js';
-export declare class CubbyManager {
-    private dataDir;
-    private definitions;
-    private instances;
-    constructor(dataDir: string);
-    initialize(cubbies: CubbyConfig[]): Promise<void>;
-    getAliases(): string[];
-    query(alias: string, instanceId: string, sql: string, params: unknown[]): Promise<QueryResult>;
-    exec(alias: string, instanceId: string, sql: string, params: unknown[]): Promise<ExecResult>;
-    queryOverloaded(alias: string, args: unknown[]): Promise<QueryResult>;
-    execOverloaded(alias: string, args: unknown[]): Promise<ExecResult>;
-    listInstances(alias: string): string[];
-    shutdown(): void;
-    private resolveOverload;
-    private getOrCreateInstance;
-    private applyMigrations;
-    private getDbPath;
-}

package/dist/lib/runtime/cubby-manager.js

@@ -1,162 +0,0 @@
-import Database from 'better-sqlite3';
-import * as sqliteVec from 'sqlite-vec';
-import fs from 'fs';
-import path from 'path';
-export class CubbyManager {
-    dataDir;
-    definitions = new Map();
-    instances = new Map(); // key: alias/instanceId
-    constructor(dataDir) {
-        this.dataDir = dataDir;
-    }
-    async initialize(cubbies) {
-        for (const cubby of cubbies) {
-            this.definitions.set(cubby.alias, {
-                alias: cubby.alias,
-                migrations: cubby.migrations ?? [],
-            });
-        }
-    }
-    getAliases() {
-        return [...this.definitions.keys()];
-    }
-    async query(alias, instanceId, sql, params) {
-        const db = this.getOrCreateInstance(alias, instanceId);
-        const start = performance.now();
-        try {
-            const stmt = db.prepare(sql);
-            const columns = stmt.columns().map(c => c.name);
-            const rawRows = stmt.raw().all(...params);
-            const rows = rawRows.length === 0 ? null : rawRows;
-            const duration = (performance.now() - start) / 1000;
-            return { columns, rows, meta: { duration, rowsRead: rawRows.length } };
-        }
-        catch (err) {
-            throw new Error(`Cubby "${alias}" query error: ${err.message}`);
-        }
-    }
-    async exec(alias, instanceId, sql, params) {
-        const db = this.getOrCreateInstance(alias, instanceId);
-        const start = performance.now();
-        try {
-            const result = db.prepare(sql).run(...params);
-            const duration = (performance.now() - start) / 1000;
-            return {
-                rowsAffected: result.changes,
-                lastInsertId: Number(result.lastInsertRowid),
-                meta: { duration, rowsRead: 0 },
-            };
-        }
-        catch (err) {
-            throw new Error(`Cubby "${alias}" exec error: ${err.message}`);
-        }
-    }
-    // Overloaded signature resolver matching production heuristic
-    async queryOverloaded(alias, args) {
-        const { instanceId, sql, params } = this.resolveOverload(args);
-        return this.query(alias, instanceId, sql, params);
-    }
-    async execOverloaded(alias, args) {
-        const { instanceId, sql, params } = this.resolveOverload(args);
-        return this.exec(alias, instanceId, sql, params);
-    }
-    listInstances(alias) {
-        const prefix = `${alias}/`;
-        const instances = [];
-        for (const key of this.instances.keys()) {
-            if (key.startsWith(prefix)) {
-                instances.push(key.slice(prefix.length));
-            }
-        }
-        return instances;
-    }
-    shutdown() {
-        for (const db of this.instances.values()) {
-            try {
-                db.close();
-            }
-            catch {
-                // best effort
-            }
-        }
-        this.instances.clear();
-    }
-    resolveOverload(args) {
-        const first = args[0];
-        if (typeof first !== 'string') {
-            throw new Error('First argument must be a string (SQL or instanceId)');
-        }
-        // Heuristic: if first arg contains a space, it is SQL
-        if (first.includes(' ')) {
-            const sql = first;
-            const params = Array.isArray(args[1]) ? args[1] : [];
-            return { instanceId: 'default', sql, params };
-        }
-        // First arg is instanceId
-        const instanceId = first;
-        const sql = args[1];
-        if (typeof sql !== 'string') {
-            throw new Error('Second argument must be SQL string when first is instanceId');
-        }
-        const params = Array.isArray(args[2]) ? args[2] : [];
-        return { instanceId, sql, params };
-    }
-    getOrCreateInstance(alias, instanceId) {
-        const def = this.definitions.get(alias);
-        if (!def) {
-            throw new Error(`Cubby "${alias}" not defined in config`);
-        }
-        const key = `${alias}/${instanceId}`;
-        if (this.instances.has(key)) {
-            return this.instances.get(key);
-        }
-        const dbPath = this.getDbPath(alias, instanceId);
-        const dbDir = path.dirname(dbPath);
-        fs.mkdirSync(dbDir, { recursive: true });
-        const db = new Database(dbPath);
-        // Load sqlite-vec extension for vector operations
-        sqliteVec.load(db);
-        // Apply PRAGMAs
-        db.pragma('cache_size = -64000');
-        db.pragma('temp_store = MEMORY');
-        db.pragma('busy_timeout = 5000');
-        db.pragma('journal_mode = WAL');
-        db.pragma('synchronous = NORMAL');
-        // Apply migrations
-        this.applyMigrations(db, def.migrations);
-        this.instances.set(key, db);
-        return db;
-    }
-    applyMigrations(db, migrations) {
-        // Create tracking table
-        db.exec(`CREATE TABLE IF NOT EXISTS schema_migrations (
-      version INTEGER PRIMARY KEY,
-      applied_at TEXT DEFAULT (datetime('now'))
-    )`);
-        // Get applied versions
-        const applied = new Set();
-        const rows = db.prepare('SELECT version FROM schema_migrations').all();
-        for (const row of rows) {
-            applied.add(row.version);
-        }
-        // Apply pending migrations in order
-        const sorted = [...migrations].sort((a, b) => a.version - b.version);
-        for (const migration of sorted) {
-            if (applied.has(migration.version))
-                continue;
-            const transaction = db.transaction(() => {
-                db.exec(migration.up);
-                db.prepare('INSERT INTO schema_migrations (version) VALUES (?)').run(migration.version);
-            });
-            try {
-                transaction();
-            }
-            catch (err) {
-                throw new Error(`Migration v${migration.version} failed for cubby: ${err.message}`);
-            }
-        }
-    }
-    getDbPath(alias, instanceId) {
-        return path.join(this.dataDir, alias, `${instanceId}.db`);
-    }
-}

package/dist/lib/runtime/index.d.ts

@@ -1,51 +0,0 @@
-import type { CefConfig } from '../types.js';
-import type { LogEntry, AgentCallResult, QueryResult, ExecResult, EngagementHandle } from './types.js';
-import { LogCollector } from './log-collector.js';
-export declare class LocalRuntime {
-    private config;
-    private logCollector;
-    private agentRouter;
-    private cubbyManager;
-    private streamManager;
-    private activeEngagements;
-    constructor(dataDir: string);
-    initialize(config: CefConfig): Promise<void>;
-    callAgentTask(agentAlias: string, taskAlias: string, payload: unknown): Promise<AgentCallResult>;
-    startEngagement(name: string, payload: Record<string, unknown>): Promise<EngagementHandle>;
-    pushToStream(streamId: string, packet: import('./types.js').StreamPacket): void;
-    queryCubby(alias: string, instanceId: string, sql: string, params: unknown[]): Promise<QueryResult>;
-    execCubby(alias: string, instanceId: string, sql: string, params: unknown[]): Promise<ExecResult>;
-    listCubbyInstances(alias: string): string[];
-    getLogs(executionId?: string): LogEntry[];
-    getTopology(): {
-        agents: {
-            name: string;
-            alias: string;
-            tasks: {
-                name: string;
-                alias: string;
-                parameters: Record<string, unknown> | undefined;
-                returns: Record<string, unknown> | undefined;
-                batchSql: string | null;
-                batchCubby: string | null;
-            }[];
-        }[];
-        cubbies: {
-            alias: string;
-            name: string;
-            migrations: number;
-        }[];
-        engagements: {
-            name: string;
-            parameters: Record<string, unknown> | undefined;
-        }[];
-        workspaces: {
-            name: string;
-            workspaceId: string | undefined;
-        }[];
-    };
-    reloadFile(agentAlias: string, taskAlias: string, tsCode: string): void;
-    get logEmitter(): LogCollector;
-    shutdown(): void;
-    private buildContextForExecution;
-}

package/dist/lib/runtime/index.js

@@ -1,181 +0,0 @@
-import vm from 'vm';
-import { transpileTypeScript } from '../transpile.js';
-import { LogCollector } from './log-collector.js';
-import { AgentRouter } from './agent-router.js';
-import { CubbyManager } from './cubby-manager.js';
-import { StreamManager } from './stream-manager.js';
-import { buildContext } from './context-builder.js';
-let executionCounter = 0;
-function nextExecutionId() {
-    return `exec-${++executionCounter}-${Date.now()}`;
-}
-export class LocalRuntime {
-    config;
-    logCollector;
-    agentRouter;
-    cubbyManager;
-    streamManager;
-    activeEngagements = new Map();
-    constructor(dataDir) {
-        this.logCollector = new LogCollector();
-        this.agentRouter = new AgentRouter();
-        this.cubbyManager = new CubbyManager(dataDir);
-        this.streamManager = new StreamManager();
-    }
-    async initialize(config) {
-        this.config = config;
-        if (config.agents) {
-            this.agentRouter.loadAgents(config.agents);
-        }
-        if (config.cubbies) {
-            await this.cubbyManager.initialize(config.cubbies);
-        }
-    }
-    async callAgentTask(agentAlias, taskAlias, payload) {
-        const executionId = nextExecutionId();
-        const start = performance.now();
-        try {
-            const context = this.buildContextForExecution(executionId, agentAlias, taskAlias);
-            const result = await this.agentRouter.call(agentAlias, taskAlias, payload, context);
-            return {
-                success: true,
-                result,
-                durationMs: performance.now() - start,
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err.message,
-                durationMs: performance.now() - start,
-            };
-        }
-    }
-    async startEngagement(name, payload) {
-        const engagement = this.config.engagements?.find(e => e.name === name);
-        if (!engagement) {
-            throw new Error(`Engagement "${name}" not found`);
-        }
-        const executionId = nextExecutionId();
-        const streamId = payload.streamId ?? `local-stream-${executionId}`;
-        // Create a stream for this engagement
-        const stream = this.streamManager.createStream(streamId);
-        this.logCollector.emitTrace({
-            timestamp: Date.now(),
-            executionId,
-            type: 'engagement:start',
-            callee: name,
-        });
-        const context = this.buildContextForExecution(executionId, undefined, undefined);
-        // Transpile and run engagement code in the background
-        const jsCode = transpileTypeScript(engagement.tsCode ?? '');
-        const event = { payload: { ...payload, streamId } };
-        const sandbox = {
-            event,
-            context,
-            console: { log: context.log, warn: context.warn, error: context.error },
-            TextDecoder,
-            TextEncoder,
-            JSON,
-            Promise,
-            Uint8Array,
-        };
-        const wrappedCode = `
-      ${jsCode}
-      __result__ = handle(event, context);
-    `;
-        const vmContext = vm.createContext(sandbox);
-        vm.runInContext(wrappedCode, vmContext);
-        // The handle function is now running asynchronously (processing the stream)
-        const handlePromise = sandbox.__result__;
-        // Catch errors from the engagement
-        handlePromise.catch((err) => {
-            this.logCollector.add(executionId, 'error', [`Engagement "${name}" error: ${err.message}`]);
-        });
-        const handle = {
-            executionId,
-            pushPacket: (data) => {
-                stream.push(data);
-            },
-            stop: () => {
-                stream.end();
-                this.streamManager.removeStream(streamId);
-                this.activeEngagements.delete(executionId);
-            },
-        };
-        this.activeEngagements.set(executionId, handle);
-        return handle;
-    }
-    pushToStream(streamId, packet) {
-        this.streamManager.pushToStream(streamId, packet);
-    }
-    async queryCubby(alias, instanceId, sql, params) {
-        return this.cubbyManager.query(alias, instanceId, sql, params);
-    }
-    async execCubby(alias, instanceId, sql, params) {
-        return this.cubbyManager.exec(alias, instanceId, sql, params);
-    }
-    listCubbyInstances(alias) {
-        return this.cubbyManager.listInstances(alias);
-    }
-    getLogs(executionId) {
-        if (executionId) {
-            return this.logCollector.getLogs(executionId);
-        }
-        // Return all logs from all executions
-        const all = [];
-        for (const id of this.logCollector.getRecentExecutions()) {
-            all.push(...this.logCollector.getLogs(id));
-        }
-        return all;
-    }
-    getTopology() {
-        return {
-            agents: (this.config.agents ?? []).map(a => ({
-                name: a.name,
-                alias: a.alias,
-                tasks: a.tasks.map(t => ({ name: t.name, alias: t.alias, parameters: t.parameters, returns: t.returns, batchSql: t.batchSql ?? null, batchCubby: t.batch_cubby ?? null })),
-            })),
-            cubbies: (this.config.cubbies ?? []).map(c => ({
-                alias: c.alias,
-                name: c.name,
-                migrations: c.migrations?.length ?? 0,
-            })),
-            engagements: (this.config.engagements ?? []).map(e => ({
-                name: e.name,
-                parameters: e.parameters,
-            })),
-            workspaces: (this.config.workspaces ?? []).map(w => ({
-                name: w.name,
-                workspaceId: w.workspaceId,
-            })),
-        };
-    }
-    reloadFile(agentAlias, taskAlias, tsCode) {
-        this.agentRouter.reloadTask(agentAlias, taskAlias, tsCode);
-    }
-    get logEmitter() {
-        return this.logCollector;
-    }
-    shutdown() {
-        for (const handle of this.activeEngagements.values()) {
-            handle.stop();
-        }
-        this.activeEngagements.clear();
-        this.streamManager.shutdown();
-        this.cubbyManager.shutdown();
-    }
-    buildContextForExecution(executionId, agentAlias, taskAlias) {
-        return buildContext({
-            executionId,
-            logCollector: this.logCollector,
-            agentRouter: this.agentRouter,
-            cubbyManager: this.cubbyManager,
-            streamManager: this.streamManager,
-            workspaceId: this.config.workspaces?.[0]?.workspaceId ?? 'local-ws',
-            agentServiceId: this.config.agentServicePubKey,
-            agentAlias,
-            taskAlias,
-        });
-    }
-}

package/dist/lib/runtime/log-collector.d.ts

@@ -1,17 +0,0 @@
-import { EventEmitter } from 'events';
-import type { LogEntry, TraceEvent } from './types.js';
-export declare class LogCollector extends EventEmitter {
-    private logs;
-    private traces;
-    private executionOrder;
-    private maxExecutions;
-    constructor(maxExecutions?: number);
-    add(executionId: string, level: LogEntry['level'], args: unknown[], agentAlias?: string, taskAlias?: string): void;
-    getLogs(executionId: string): LogEntry[];
-    getRecentExecutions(): string[];
-    emitTrace(event: TraceEvent): void;
-    getTraces(executionId: string): TraceEvent[];
-    clear(executionId: string): void;
-    clearAll(): void;
-    private evict;
-}

package/dist/lib/runtime/log-collector.js

@@ -1,61 +0,0 @@
-import { EventEmitter } from 'events';
-export class LogCollector extends EventEmitter {
-    logs = new Map();
-    traces = new Map();
-    executionOrder = [];
-    maxExecutions;
-    constructor(maxExecutions = 100) {
-        super();
-        this.maxExecutions = maxExecutions;
-    }
-    add(executionId, level, args, agentAlias, taskAlias) {
-        const entry = {
-            timestamp: Date.now(),
-            executionId,
-            level,
-            args,
-            agentAlias,
-            taskAlias,
-        };
-        if (!this.logs.has(executionId)) {
-            this.logs.set(executionId, []);
-            this.executionOrder.push(executionId);
-            this.evict();
-        }
-        this.logs.get(executionId).push(entry);
-        this.emit('log', entry);
-    }
-    getLogs(executionId) {
-        return this.logs.get(executionId) ?? [];
-    }
-    getRecentExecutions() {
-        return [...this.executionOrder];
-    }
-    emitTrace(event) {
-        const { executionId } = event;
-        if (!this.traces.has(executionId)) {
-            this.traces.set(executionId, []);
-        }
-        this.traces.get(executionId).push(event);
-        this.emit('trace', event);
-    }
-    getTraces(executionId) {
-        return this.traces.get(executionId) ?? [];
-    }
-    clear(executionId) {
-        this.logs.delete(executionId);
-        this.traces.delete(executionId);
-        this.executionOrder = this.executionOrder.filter(id => id !== executionId);
-    }
-    clearAll() {
-        this.logs.clear();
-        this.traces.clear();
-        this.executionOrder = [];
-    }
-    evict() {
-        while (this.executionOrder.length > this.maxExecutions) {
-            const oldest = this.executionOrder.shift();
-            this.logs.delete(oldest);
-        }
-    }
-}

package/dist/lib/runtime/stream-manager.d.ts

@@ -1,10 +0,0 @@
-import type { StreamPacket, PushableStream } from './types.js';
-export declare class StreamManager {
-    private streams;
-    createStream(streamId: string): PushableStream;
-    getStream(streamId: string): PushableStream;
-    pushToStream(streamId: string, packet: StreamPacket): void;
-    hasStream(streamId: string): boolean;
-    removeStream(streamId: string): void;
-    shutdown(): void;
-}