@cef-ai/cli 0.2.7 → 0.3.0

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

@@ -1,77 +0,0 @@
-class PushableStreamImpl {
-    queue = [];
-    resolve = null;
-    ended = false;
-    push(packet) {
-        if (this.ended)
-            return;
-        if (this.resolve) {
-            const r = this.resolve;
-            this.resolve = null;
-            r({ value: packet, done: false });
-        }
-        else {
-            this.queue.push(packet);
-        }
-    }
-    end() {
-        this.ended = true;
-        if (this.resolve) {
-            const r = this.resolve;
-            this.resolve = null;
-            r({ value: undefined, done: true });
-        }
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                if (this.queue.length > 0) {
-                    return Promise.resolve({ value: this.queue.shift(), done: false });
-                }
-                if (this.ended) {
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                return new Promise(resolve => {
-                    this.resolve = resolve;
-                });
-            },
-        };
-    }
-}
-export class StreamManager {
-    streams = new Map();
-    createStream(streamId) {
-        if (this.streams.has(streamId)) {
-            throw new Error(`Stream "${streamId}" already exists`);
-        }
-        const stream = new PushableStreamImpl();
-        this.streams.set(streamId, stream);
-        return stream;
-    }
-    getStream(streamId) {
-        const stream = this.streams.get(streamId);
-        if (!stream) {
-            throw new Error(`No active stream "${streamId}"`);
-        }
-        return stream;
-    }
-    pushToStream(streamId, packet) {
-        this.getStream(streamId).push(packet);
-    }
-    hasStream(streamId) {
-        return this.streams.has(streamId);
-    }
-    removeStream(streamId) {
-        const stream = this.streams.get(streamId);
-        if (stream) {
-            stream.end();
-            this.streams.delete(streamId);
-        }
-    }
-    shutdown() {
-        for (const stream of this.streams.values()) {
-            stream.end();
-        }
-        this.streams.clear();
-    }
-}

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

@@ -1,76 +0,0 @@
-export interface LogEntry {
-    timestamp: number;
-    executionId: string;
-    agentAlias?: string;
-    taskAlias?: string;
-    level: 'log' | 'warn' | 'error';
-    args: unknown[];
-}
-export interface CallChainEntry {
-    caller: string;
-    callee: string;
-    timestamp: number;
-    durationMs?: number;
-    success: boolean;
-}
-export interface EngagementHandle {
-    executionId: string;
-    pushPacket(data: unknown): void;
-    stop(): void;
-}
-export interface TriggerResult {
-    executionId: string;
-    started: boolean;
-    error?: string;
-}
-export interface AgentCallResult {
-    success: boolean;
-    result?: unknown;
-    error?: string;
-    durationMs: number;
-}
-export interface DevServerOptions {
-    port: number;
-    host: string;
-    configPath: string;
-}
-export interface TraceEvent {
-    timestamp: number;
-    executionId: string;
-    type: 'engagement:start' | 'agent:call' | 'agent:return' | 'cubby:query' | 'cubby:exec';
-    caller?: string;
-    callee?: string;
-    cubbyAlias?: string;
-    sql?: string;
-    durationMs?: number;
-    success?: boolean;
-    error?: string;
-    rowsAffected?: number;
-    rowsRead?: number;
-}
-export interface QueryResult {
-    columns: string[];
-    rows: unknown[][] | null;
-    meta: {
-        duration: number;
-        rowsRead: number;
-    };
-}
-export interface ExecResult {
-    rowsAffected: number;
-    lastInsertId: number;
-    meta: {
-        duration: number;
-        rowsRead: number;
-    };
-}
-export interface StreamPacket {
-    sequenceNum: number;
-    payload: Uint8Array;
-    metadata?: Record<string, unknown>;
-}
-export interface PushableStream {
-    push(packet: StreamPacket): void;
-    end(): void;
-    [Symbol.asyncIterator](): AsyncIterator<StreamPacket>;
-}

package/dist/lib/runtime/types.js

@@ -1,2 +0,0 @@
-// ─── Local runtime types for cef dev ───────────────────────────────────────
-export {};

package/dist/lib/transpile.d.ts

@@ -1 +0,0 @@
-export declare function transpileTypeScript(code: string): string;

package/dist/lib/transpile.js

@@ -1,9 +0,0 @@
-import { transformSync } from 'esbuild';
-export function transpileTypeScript(code) {
-    const result = transformSync(code, {
-        loader: 'ts',
-        target: 'es2022',
-        format: 'esm',
-    });
-    return result.code;
-}

package/dist/lib/typecheck.d.ts

@@ -1,31 +0,0 @@
-export interface TypeCheckError {
-    file: string;
-    line: number;
-    message: string;
-}
-export interface TypecheckContext {
-    agentAliases?: string[];
-    cubbyAliases?: string[];
-}
-export declare function typecheckFile(filePath: string, ctx?: TypecheckContext): TypeCheckError[];
-export declare function typecheckAll(config: {
-    engagements?: Array<{
-        _resolvedFilePath?: string;
-    }>;
-    agents?: Array<{
-        alias: string;
-        tasks: Array<{
-            _resolvedFilePath?: string;
-        }>;
-    }>;
-    cubbies?: Array<{
-        alias: string;
-    }>;
-    workspaces?: Array<{
-        streams?: Array<{
-            rafts?: Array<{
-                _resolvedFilePath?: string;
-            }>;
-        }>;
-    }>;
-}): TypeCheckError[];

package/dist/lib/typecheck.js

@@ -1,175 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import ts from 'typescript';
-// Extracted from UI/ROB/dynamic-indexer-client/src/components/CodeEditor.tsx
-// contextTemplate + additionalTypeDefinitions, with dynamic placeholders replaced by `any`
-const CEF_TYPE_DEFS = `
-interface Packet { data: any; metadata?: any; }
-
-interface RaftContext { log(msg: string, ...args: any[]): void; }
-
-interface RaftAgentContext {
-  stream: { id: string; parentId: string; metadata: any; };
-  rafts: string[];
-  query(dataStreamId: string, raftId: string, request: any): Promise<any>;
-}
-
-interface RaftInfo { raftDefId: string; dataStreamId: string; }
-
-interface SetOptions { ttl?: number; nx?: boolean; xx?: boolean; }
-
-interface VectorSearchOptions { k?: number; filter?: string; }
-interface VectorMatch { id: string; score: number; metadata?: Record<string, any>; }
-
-interface QueryResult {
-  columns: string[];
-  rows: unknown[][] | null;
-  meta: { duration: number; rowsRead: number };
-}
-
-interface ExecResult {
-  rowsAffected: number;
-  lastInsertId: number;
-  meta: { duration: number; rowsRead: number };
-}
-
-interface CubbyHandle {
-  query(sql: string, params?: unknown[]): Promise<QueryResult>;
-  query(instanceId: string, sql: string, params?: unknown[]): Promise<QueryResult>;
-  exec(sql: string, params?: unknown[]): Promise<ExecResult>;
-  exec(instanceId: string, sql: string, params?: unknown[]): Promise<ExecResult>;
-}
-
-interface StreamIterator { [Symbol.asyncIterator](): AsyncIterator<any>; }
-
-declare interface Agent { invoke(params: any): Promise<any>; }
-
-declare interface Context {
-  fetch(url: string, options?: any): Promise<Response>;
-  emit(eventType: string, payload: any, targetId?: string): void;
-  log(message: string, ...args: any[]): void;
-  warn(message: string, ...args: any[]): void;
-  error(message: string, ...args: any[]): void;
-  streams: { subscribe(streamId: string): Promise<StreamIterator>; };
-  cubbies: Record<string, CubbyHandle>;
-  agents: Record<string, any>;
-  rafts: RaftAgentContext;
-}
-
-declare const context: Context;
-
-interface Event {
-  app_id: string;
-  account_id: string;
-  app_pub_key: string;
-  connection_id: string;
-  data_service_pub_key: string;
-  event_type: string;
-  id: string;
-  payload: Record<string, any>;
-  session_id: string;
-  signature: string;
-  signing: string;
-  timestamp: string;
-}
-`;
-function buildCefTypeDefs(ctx) {
-    let defs = CEF_TYPE_DEFS;
-    if (ctx?.agentAliases) {
-        const agentsType = ctx.agentAliases.length > 0
-            ? `{ ${ctx.agentAliases.map(a => `${JSON.stringify(a)}: Agent;`).join(' ')} }`
-            : '{}';
-        defs = defs.replace('agents: Record<string, any>;', `agents: ${agentsType};`);
-    }
-    if (ctx?.cubbyAliases && ctx.cubbyAliases.length > 0) {
-        const cubbiesType = `{ ${ctx.cubbyAliases.map(a => `${JSON.stringify(a)}: CubbyHandle;`).join(' ')} }`;
-        defs = defs.replace('cubbies: Record<string, CubbyHandle>;', `cubbies: ${cubbiesType};`);
-    }
-    return defs;
-}
-// Diagnostic codes to suppress (unresolvable imports are not our concern)
-const SUPPRESSED_CODES = new Set([
-    2307, // Cannot find module 'X'
-    2792, // Cannot find module 'X' (alternative)
-]);
-const CEF_COMPILER_OPTIONS = {
-    noEmit: true,
-    strict: false,
-    skipLibCheck: true,
-    noImplicitAny: false,
-    target: ts.ScriptTarget.ES2022,
-    module: ts.ModuleKind.CommonJS,
-    moduleResolution: ts.ModuleResolutionKind.Node10,
-    lib: ['lib.es2022.d.ts'],
-};
-export function typecheckFile(filePath, ctx) {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cef-typecheck-'));
-    const defsPath = path.join(tmpDir, 'cef-context.d.ts');
-    try {
-        fs.writeFileSync(defsPath, buildCefTypeDefs(ctx));
-        return typecheckFileWithDefs(filePath, defsPath);
-    }
-    finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-}
-/** Typecheck a single file using a pre-written defs file. Shared by typecheckAll. */
-function typecheckFileWithDefs(filePath, defsPath) {
-    const program = ts.createProgram([filePath, defsPath], CEF_COMPILER_OPTIONS);
-    const diagnostics = ts.getPreEmitDiagnostics(program);
-    return [...diagnostics]
-        .filter(d => d.file && path.resolve(d.file.fileName) === path.resolve(filePath))
-        .filter(d => !SUPPRESSED_CODES.has(d.code))
-        .map(d => {
-        const pos = d.file.getLineAndCharacterOfPosition(d.start ?? 0);
-        return {
-            file: path.basename(filePath),
-            line: pos.line + 1,
-            message: ts.flattenDiagnosticMessageText(d.messageText, ' '),
-        };
-    });
-}
-export function typecheckAll(config) {
-    const ctx = {
-        agentAliases: config.agents?.map(a => a.alias) ?? [],
-        cubbyAliases: config.cubbies?.map(c => c.alias) ?? [],
-    };
-    // Collect all files to typecheck
-    const files = [];
-    for (const eng of config.engagements ?? []) {
-        if (eng._resolvedFilePath)
-            files.push(eng._resolvedFilePath);
-    }
-    for (const agent of config.agents ?? []) {
-        for (const task of agent.tasks) {
-            if (task._resolvedFilePath)
-                files.push(task._resolvedFilePath);
-        }
-    }
-    // Cubbies have no file references to typecheck (migrations are inline SQL)
-    for (const ws of config.workspaces ?? []) {
-        for (const stream of ws.streams ?? []) {
-            for (const raft of stream.rafts ?? []) {
-                if (raft._resolvedFilePath)
-                    files.push(raft._resolvedFilePath);
-            }
-        }
-    }
-    if (files.length === 0)
-        return [];
-    // Create one temp dir, write defs once, check all files, clean up once
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cef-typecheck-'));
-    const defsPath = path.join(tmpDir, 'cef-context.d.ts');
-    try {
-        fs.writeFileSync(defsPath, buildCefTypeDefs(ctx));
-        const errors = [];
-        for (const filePath of files) {
-            errors.push(...typecheckFileWithDefs(filePath, defsPath));
-        }
-        return errors;
-    }
-    finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-}

package/dist/lib/types.d.ts

@@ -1,246 +0,0 @@
-export interface SelectorConfig {
-    name: string;
-    conditions: string[];
-}
-export interface TriggerConfig {
-    name: string;
-    conditions: string[];
-}
-export interface DeploymentConfig {
-    name: string;
-    description?: string;
-    deploymentId?: string;
-    engagement: string;
-    isActive?: boolean;
-    triggers?: TriggerConfig[];
-    engagementRules?: unknown[];
-}
-export interface RaftConfig {
-    name: string;
-    description?: string;
-    raftId?: string;
-    file?: string;
-    tsCode?: string;
-    _resolvedFilePath?: string;
-    dataSourcesIds?: string[];
-    queryOperations?: unknown[];
-}
-export interface StreamConfig {
-    name: string;
-    description?: string;
-    streamId?: string;
-    selectors?: SelectorConfig[];
-    deployments?: DeploymentConfig[];
-    rafts?: RaftConfig[];
-}
-export interface WorkspaceConfig {
-    name: string;
-    description?: string;
-    workspaceId?: string;
-    streams?: StreamConfig[];
-}
-export interface TaskConfig {
-    name: string;
-    alias: string;
-    file: string;
-    parameters?: Record<string, unknown>;
-    returns?: Record<string, unknown>;
-    tsCode?: string;
-    _resolvedFilePath?: string;
-    /** Local dev only: SQL file that queries a cubby to produce batch inputs */
-    batch_file?: string;
-    /** Local dev only: cubby alias to run batch_file query against */
-    batch_cubby?: string;
-    /** Resolved at startup from batch_file contents */
-    batchSql?: string;
-}
-export interface AgentConfig {
-    name: string;
-    alias: string;
-    description?: string;
-    agentId?: string;
-    version?: string;
-    tasks: TaskConfig[];
-}
-export interface EngagementConfig {
-    name: string;
-    description?: string;
-    engagementId?: string;
-    file: string;
-    version?: string;
-    tsCode?: string;
-    _resolvedFilePath?: string;
-    /** Local-only: JSON Schema for expected payload. Not sent to orchestrator API. */
-    parameters?: Record<string, unknown>;
-}
-export interface CubbyMigration {
-    version: number;
-    up: string;
-}
-export interface CubbyConfig {
-    alias: string;
-    name: string;
-    description?: string;
-    cubbyId?: string;
-    migrations?: CubbyMigration[];
-    maxSizeBytes?: number;
-    idleTimeout?: string;
-}
-export interface CefConfig {
-    agentServicePubKey: string;
-    agentServiceId?: string;
-    workspaces?: WorkspaceConfig[];
-    engagements?: EngagementConfig[];
-    agents?: AgentConfig[];
-    cubbies?: CubbyConfig[];
-}
-export interface EnvConfig {
-    authToken: string;
-    orchestratorUrl: string;
-    robApiUrl: string;
-    /** Optional Origin header for ROB requests (e.g. http://localhost:5173 to match UI). */
-    robOrigin?: string;
-}
-export interface ResolvedConfig {
-    config: CefConfig;
-    env: EnvConfig;
-    configPath: string;
-}
-export interface WorkspacePayload {
-    agentServicePubKey: string;
-    name: string;
-    description: string;
-    workspaceId?: string;
-}
-export interface StreamPayload {
-    agentServicePubKey: string;
-    workspaceId?: string;
-    parentId?: string;
-    name: string;
-    description: string;
-    selectors: SelectorConfig[];
-}
-export interface EngagementPayload {
-    agentServicePubKey: string;
-    name: string;
-    description: string;
-    version: string;
-    conciergeAgent: {
-        name: string;
-        description: string;
-        tsCode: string;
-    };
-}
-export interface TaskPayload {
-    name: string;
-    alias: string;
-    tsCode: string;
-    parameters: Record<string, unknown>;
-    returns: Record<string, unknown>;
-}
-export interface AgentPayload {
-    agentServicePubKey: string;
-    name: string;
-    alias: string;
-    description: string;
-    version: string;
-    cid: string;
-    tasks: TaskPayload[];
-}
-export interface AgentUpdatePayload {
-    tasks: TaskPayload[];
-}
-export interface DeploymentPayload {
-    name: string;
-    description: string;
-    isActive: boolean;
-    streamId: string;
-    engagements: Array<{
-        id: string;
-        rules: unknown[];
-    }>;
-    triggers: TriggerConfig[];
-    deploymentId?: string;
-}
-export interface RaftOrchestratorPayload {
-    alias: string;
-    tsCode: string;
-}
-export interface CubbyCreatePayload {
-    alias: string;
-    name?: string;
-    description?: string;
-    migrations?: CubbyMigration[];
-    maxSizeBytes?: number;
-    idleTimeout?: string;
-}
-export interface CubbyInstance {
-    agentServicePubKey: string;
-    cubbyId: string;
-    instanceId: string;
-    nodeId: string;
-    state: string;
-    schemaVersion: number;
-    sizeBytes: number;
-    createdAt: string;
-    lastAccessedAt: string;
-}
-export interface CubbyStats {
-    cubbyId: string;
-    instanceCount: number;
-    totalSizeBytes: number;
-}
-export type EntityType = 'engagement' | 'agent' | 'cubby' | 'workspace' | 'stream' | 'deployment' | 'raft';
-export interface DeployResult {
-    entity: EntityType;
-    name: string;
-    action: 'created' | 'updated' | 'dry-run';
-    id?: string;
-}
-export type OnlyFilter = EntityType | undefined;
-export interface JsonRpcRequest {
-    jsonrpc: '2.0';
-    id: number;
-    method: string;
-    params: {
-        name: string;
-        arguments: Record<string, unknown>;
-    };
-    context: {
-        jobId: string;
-        workspaceId: string;
-        engagementId: string;
-        deploymentId: string;
-        executionId: string;
-    };
-}
-export interface JsonRpcResponse {
-    jsonrpc: '2.0';
-    id: number;
-    result?: {
-        data: unknown;
-    };
-    error?: {
-        code: number;
-        message: string;
-        data?: unknown;
-    };
-}
-export interface PlaygroundTestCase {
-    agent: string;
-    tool: string;
-    arguments: Record<string, unknown>;
-    expect?: {
-        success?: boolean;
-        result?: Record<string, unknown>;
-    };
-}
-export interface PlaygroundTestResult {
-    agent: string;
-    tool: string;
-    status: 'pass' | 'fail' | 'error';
-    durationMs: number;
-    response?: JsonRpcResponse;
-    error?: string;
-    expectationFailures?: string[];
-}

package/dist/lib/types.js

@@ -1,2 +0,0 @@
-// ─── Config schema types ───────────────────────────────────────────────────
-export {};

package/dist/lib/utils.d.ts

@@ -1,4 +0,0 @@
-export declare function toCamelCase(str: string | undefined | null): string;
-export declare function errorMessage(err: unknown): string;
-export declare function toFileName(name: string): string;
-export declare function extractId(res: Record<string, unknown>, ...keys: string[]): string;

package/dist/lib/utils.js

@@ -1,33 +0,0 @@
-// Matches the toCamelCase logic in ROB's CodeEditor.tsx
-export function toCamelCase(str) {
-    if (!str || typeof str !== 'string')
-        return 'unknown';
-    const cleaned = str
-        .replace(/[^\w\s]/g, '')
-        .replace(/\s+/g, ' ')
-        .trim();
-    const result = cleaned
-        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase())
-        .replace(/\s+/g, '');
-    return result.replace(/^[^a-zA-Z_]/, '_') || 'unknown';
-}
-export function errorMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-export function toFileName(name) {
-    return name
-        .toLowerCase()
-        .replace(/[^\w\s-]/g, '')
-        .replace(/\s+/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '')
-        || 'unknown';
-}
-export function extractId(res, ...keys) {
-    for (const key of keys) {
-        const val = res[key];
-        if (typeof val === 'string' && val)
-            return val;
-    }
-    return '';
-}

package/example/.env.example

@@ -1,6 +0,0 @@
-CEF_AUTH_TOKEN=your-token-here
-CEF_ORCHESTRATOR_URL=https://orchestrator.compute.test.ddcdragon.com
-CEF_ROB_API_URL=https://rob.compute.test.ddcdragon.com/rms-node-backend
-
-# For E2E tests only (npm run test:e2e): agent service public key the token can use
-# CEF_E2E_AGENT_SERVICE_PUB_KEY=0x...

package/example/agents/object-detection/tasks/yolo.ts

@@ -1,28 +0,0 @@
-
-async function handle(event: any, ctx: any) {
-    const { image } = event.payload;
-
-    const response = await ctx.fetch('https://compute-5.devnet.ddc-dragon.com/inference/api/v1/inference', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            model: {
-                "bucket": 1338,
-                "name": "yolo11x_1280",
-                "version": "v1.0.0"
-            },
-            input: {
-                image: image
-            }
-        })
-    }).then(res => res.json());
-    ctx.log('Inference response', JSON.stringify(response));
-
-    const detections = response.output.detections;
-
-    return {
-        totalDetections: detections.length,
-        detections: detections,
-        processingTime: response.metrics.inference_time
-    };
-}