@cef-ai/cli 0.2.7 → 0.3.0

package/dist/commands/playground/index.js

@@ -1,75 +0,0 @@
-import { loadConfig } from '../../lib/config.js';
-import { createApiClient } from '../../lib/api.js';
-import { errorMessage } from '../../lib/utils.js';
-import { resolveAgentId, runPlaygroundTest } from './test.js';
-function printResults(results) {
-    const passed = results.filter(r => r.status === 'pass').length;
-    const failed = results.filter(r => r.status === 'fail').length;
-    const errors = results.filter(r => r.status === 'error').length;
-    console.log('');
-    for (const r of results) {
-        const tag = r.status === 'pass' ? '[PASS]' :
-            r.status === 'fail' ? '[FAIL]' :
-                '[ERROR]';
-        console.log(`  ${tag} ${r.agent} > ${r.tool} (${r.durationMs}ms)`);
-        if (r.status === 'pass' && r.response?.result) {
-            console.log(`    ${JSON.stringify(r.response.result.data)}`);
-        }
-        if (r.status === 'fail' && r.expectationFailures) {
-            for (const f of r.expectationFailures) {
-                console.log(`    - ${f}`);
-            }
-        }
-        if (r.status === 'fail' && r.error) {
-            console.log(`    Error: ${r.error}`);
-        }
-        if (r.status === 'error') {
-            console.log(`    ${r.error}`);
-        }
-    }
-    console.log(`\nResults: ${passed} passed, ${failed} failed, ${errors} errors`);
-}
-export function registerPlaygroundCommands(program) {
-    const playground = program
-        .command('playground')
-        .description('Test and interact with agents');
-    playground
-        .command('test')
-        .description('Run playground tests against agent tools via MCP')
-        .option('--config <path>', 'Config file path', './cef.config.yaml')
-        .option('--agent <name>', 'Agent name, alias, or agentId')
-        .option('--tool <alias>', 'Task alias (tool name) to call')
-        .option('--args <json>', 'JSON arguments to pass to the tool')
-        .option('--test-file <path>', 'Path to cef.tests.yaml for batch testing')
-        .option('--list-tools', 'List available tools on an agent')
-        .action(async (opts) => {
-        try {
-            const resolved = loadConfig(opts.config);
-            if (opts.listTools) {
-                if (!opts.agent) {
-                    console.error('--agent is required with --list-tools');
-                    process.exit(1);
-                }
-                const { agentId } = resolveAgentId(resolved.config, opts.agent);
-                const api = createApiClient(resolved.env, resolved.config.agentServicePubKey);
-                const result = await api.listTools(agentId);
-                console.log(JSON.stringify(result, null, 2));
-                return;
-            }
-            const results = await runPlaygroundTest(resolved, {
-                agent: opts.agent,
-                tool: opts.tool,
-                arguments: opts.args,
-                testFile: opts.testFile,
-            });
-            printResults(results);
-            const hasFailures = results.some(r => r.status !== 'pass');
-            if (hasFailures)
-                process.exit(1);
-        }
-        catch (err) {
-            console.error(`Playground test failed: ${errorMessage(err)}`);
-            process.exit(1);
-        }
-    });
-}

package/dist/commands/playground/test.d.ts

@@ -1,15 +0,0 @@
-import type { CefConfig, AgentConfig, ResolvedConfig, PlaygroundTestCase, PlaygroundTestResult } from '../../lib/types.js';
-export interface PlaygroundOptions {
-    agent?: string;
-    tool?: string;
-    arguments?: string;
-    testFile?: string;
-    listTools?: boolean;
-}
-export declare function resolveAgentId(config: CefConfig, nameOrId: string): {
-    agentId: string;
-    agent: AgentConfig;
-};
-export declare function deepPartialMatch(actual: unknown, expected: unknown, path?: string): string[];
-export declare function loadTestFile(filePath: string): PlaygroundTestCase[];
-export declare function runPlaygroundTest(resolved: ResolvedConfig, options: PlaygroundOptions): Promise<PlaygroundTestResult[]>;

package/dist/commands/playground/test.js

@@ -1,166 +0,0 @@
-import fs from 'fs';
-import { parse } from 'yaml';
-import { createApiClient } from '../../lib/api.js';
-export function resolveAgentId(config, nameOrId) {
-    const agents = config.agents;
-    if (!agents || agents.length === 0) {
-        throw new Error('No agents defined in cef.config.yaml');
-    }
-    const match = agents.find(a => a.name === nameOrId ||
-        a.alias === nameOrId ||
-        a.agentId === nameOrId);
-    if (!match) {
-        const available = agents.map(a => a.name).join(', ');
-        throw new Error(`Agent "${nameOrId}" not found. Available: ${available}`);
-    }
-    if (!match.agentId) {
-        throw new Error(`Agent "${match.name}" has no agentId. Run \`cef deploy\` first to deploy it.`);
-    }
-    return { agentId: match.agentId, agent: match };
-}
-export function deepPartialMatch(actual, expected, path = '') {
-    if (expected === null || expected === undefined) {
-        if (actual === expected)
-            return [];
-        return [`${path || 'root'}: expected ${String(expected)}, got ${String(actual)}`];
-    }
-    if (Array.isArray(expected)) {
-        if (!Array.isArray(actual)) {
-            return [`${path || 'root'}: expected array, got ${typeof actual}`];
-        }
-        const failures = [];
-        for (let i = 0; i < expected.length; i++) {
-            const p = path ? `${path}[${i}]` : `[${i}]`;
-            if (i >= actual.length) {
-                failures.push(`${p}: missing (expected ${JSON.stringify(expected[i])})`);
-            }
-            else {
-                failures.push(...deepPartialMatch(actual[i], expected[i], p));
-            }
-        }
-        return failures;
-    }
-    if (typeof expected === 'object') {
-        if (typeof actual !== 'object' || actual === null) {
-            return [`${path || 'root'}: expected object, got ${String(actual)}`];
-        }
-        const failures = [];
-        for (const key of Object.keys(expected)) {
-            const p = path ? `${path}.${key}` : key;
-            const actualObj = actual;
-            const expectedObj = expected;
-            if (!(key in actualObj)) {
-                failures.push(`${p}: missing (expected ${JSON.stringify(expectedObj[key])})`);
-            }
-            else {
-                failures.push(...deepPartialMatch(actualObj[key], expectedObj[key], p));
-            }
-        }
-        return failures;
-    }
-    if (actual !== expected) {
-        return [`${path || 'root'}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`];
-    }
-    return [];
-}
-export function loadTestFile(filePath) {
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`Test file not found: ${filePath}`);
-    }
-    const raw = fs.readFileSync(filePath, 'utf8');
-    const parsed = parse(raw);
-    if (!parsed || !Array.isArray(parsed.tests)) {
-        throw new Error(`Invalid test file: expected a "tests" array at top level`);
-    }
-    return parsed.tests;
-}
-async function runSingleTest(api, agentId, testCase) {
-    const start = Date.now();
-    try {
-        const response = await api.callTool(agentId, testCase.tool, testCase.arguments);
-        const durationMs = Date.now() - start;
-        const hasError = !!response.error;
-        if (hasError && !testCase.expect) {
-            return {
-                agent: testCase.agent,
-                tool: testCase.tool,
-                status: 'fail',
-                durationMs,
-                response,
-                error: response.error.message,
-            };
-        }
-        if (testCase.expect) {
-            const failures = [];
-            if (testCase.expect.success === true && hasError) {
-                failures.push(`Expected success but got error: "${response.error.message}"`);
-            }
-            if (testCase.expect.success === false && !hasError) {
-                failures.push('Expected error but got success');
-            }
-            if (testCase.expect.result && response.result) {
-                failures.push(...deepPartialMatch(response.result.data, testCase.expect.result));
-            }
-            if (failures.length > 0) {
-                return {
-                    agent: testCase.agent,
-                    tool: testCase.tool,
-                    status: 'fail',
-                    durationMs,
-                    response,
-                    expectationFailures: failures,
-                };
-            }
-        }
-        return {
-            agent: testCase.agent,
-            tool: testCase.tool,
-            status: 'pass',
-            durationMs,
-            response,
-        };
-    }
-    catch (err) {
-        return {
-            agent: testCase.agent,
-            tool: testCase.tool,
-            status: 'error',
-            durationMs: Date.now() - start,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-export async function runPlaygroundTest(resolved, options) {
-    const api = createApiClient(resolved.env, resolved.config.agentServicePubKey);
-    if (options.testFile) {
-        const testCases = loadTestFile(options.testFile);
-        const results = [];
-        for (const tc of testCases) {
-            const { agentId } = resolveAgentId(resolved.config, tc.agent);
-            results.push(await runSingleTest(api, agentId, tc));
-        }
-        return results;
-    }
-    if (!options.agent) {
-        throw new Error('Provide --agent and --tool for single test, or --test-file for batch testing');
-    }
-    if (!options.tool) {
-        throw new Error('--tool is required when running a single test');
-    }
-    let args = {};
-    if (options.arguments) {
-        try {
-            args = JSON.parse(options.arguments);
-        }
-        catch {
-            throw new Error(`Invalid JSON in --args: ${options.arguments}`);
-        }
-    }
-    const { agentId } = resolveAgentId(resolved.config, options.agent);
-    const testCase = {
-        agent: options.agent,
-        tool: options.tool,
-        arguments: args,
-    };
-    return [await runSingleTest(api, agentId, testCase)];
-}

package/dist/commands/service/index.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function registerServiceCommands(program: Command): void;

package/dist/commands/service/index.js

@@ -1,89 +0,0 @@
-import path from 'path';
-import dotenv from 'dotenv';
-import { loadEnv } from '../../lib/config.js';
-import { listAgentServices, createAgentServiceOnRob, createAgentServiceOnOrchestrator } from '../../lib/api.js';
-import { errorMessage } from '../../lib/utils.js';
-function loadEnvFromDir(dir) {
-    const resolved = path.resolve(dir);
-    dotenv.config({ path: path.join(resolved, '.env') });
-    return loadEnv();
-}
-async function handleList(opts) {
-    const configDir = path.dirname(path.resolve(opts.config));
-    try {
-        const env = loadEnvFromDir(configDir);
-        if (!env.robApiUrl) {
-            console.error('CEF_ROB_API_URL is required to list agent services');
-            process.exit(1);
-        }
-        const services = await listAgentServices(env.robApiUrl, env.authToken);
-        const active = services.filter(s => !s.archived);
-        console.log(`\nAgent Services (${active.length}):\n`);
-        for (const s of active) {
-            console.log(`  ${s.name}`);
-            console.log(`    agentServiceId:     ${s.id}`);
-            console.log(`    agentServicePubKey: ${s.publicKey}`);
-            console.log(`    created:            ${s.createdAt}`);
-            console.log('');
-        }
-    }
-    catch (err) {
-        console.error(`Failed to list services: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-}
-async function handleCreate(opts) {
-    const configDir = path.dirname(path.resolve(opts.config));
-    const env = loadEnvFromDir(configDir);
-    if (!env.robApiUrl) {
-        console.error('CEF_ROB_API_URL is required to create an agent service');
-        process.exit(1);
-    }
-    try {
-        console.log(`Creating agent service "${opts.name}" on orchestrator...`);
-        const orchRes = await createAgentServiceOnOrchestrator(env.orchestratorUrl, env.authToken, opts.bucketId, opts.name);
-        const orchData = orchRes.data;
-        const agentServicePubKey = String(orchData?.agentServicePubKey ?? orchRes.agentServicePubKey ?? '');
-        if (!agentServicePubKey) {
-            throw new Error('Orchestrator did not return agentServicePubKey');
-        }
-        console.log(`  Orchestrator registered: agentServicePubKey=${agentServicePubKey}`);
-        console.log(`Registering agent service on ROB...`);
-        let service;
-        try {
-            service = await createAgentServiceOnRob(env.robApiUrl, env.authToken, opts.name, agentServicePubKey);
-        }
-        catch (robErr) {
-            console.error(`ROB registration failed: ${errorMessage(robErr)}`);
-            console.error(`Orchestrator service was created with pubkey: ${agentServicePubKey}`);
-            console.error(`Re-run or manually register this key on ROB to complete setup.`);
-            process.exit(1);
-        }
-        console.log(`  ROB registered: id=${service.id}`);
-        console.log(`\nAgent service created:`);
-        console.log(`  name:                ${service.name}`);
-        console.log(`  agentServiceId:      ${service.id}`);
-        console.log(`  agentServicePubKey:  ${agentServicePubKey}`);
-    }
-    catch (err) {
-        console.error(`Create service failed: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-}
-export function registerServiceCommands(program) {
-    const service = program
-        .command('service')
-        .description('Manage agent services');
-    service
-        .command('list')
-        .description('List agent services from ROB')
-        .option('--config <path>', 'Config file path', './cef.config.yaml')
-        .action(handleList);
-    service
-        .command('create')
-        .description('Create a new agent service')
-        .requiredOption('--name <name>', 'Name of the new agent service')
-        .option('--config <path>', 'Config file path', './cef.config.yaml')
-        .option('--bucket-id <id>', 'DDC bucket ID', '1')
-        .action(handleCreate);
-}

package/dist/lib/api.d.ts

@@ -1,146 +0,0 @@
-import type { EnvConfig, WorkspacePayload, StreamPayload, EngagementPayload, JsonRpcResponse, AgentPayload, AgentUpdatePayload, DeploymentPayload, CubbyCreatePayload, CubbyMigration, CubbyInstance, CubbyStats, RaftOrchestratorPayload } from './types.js';
-/** Payload for registering or updating a raft on ROB (RMS). */
-export interface RaftRobPayload {
-    raftId: string;
-    streamId: string;
-    name: string;
-    description?: string;
-    tsCode: string;
-    dataSourcesIds?: string[];
-    queryOperations?: unknown[];
-}
-export interface RemoteTask {
-    id: string;
-    name: string;
-    alias: string;
-    tsCode: string;
-    parameters: Record<string, unknown>;
-    returns: Record<string, unknown>;
-}
-export interface RemoteAgent {
-    agentId: string;
-    name: string;
-    alias: string;
-    description: string;
-    isConcierge: boolean;
-    version: string;
-    tasks: RemoteTask[];
-}
-export interface RemoteEngagement {
-    engagementId: string;
-    name: string;
-    description: string;
-    conciergeAgentId: string;
-    version: string;
-}
-export interface OntologyDeployment {
-    deploymentId: string;
-    name: string;
-    description: string;
-    isActive: boolean;
-    triggers: Array<{
-        name: string;
-        conditions: string[];
-    }>;
-    engagements: Array<{
-        id: string;
-        name: string;
-    }>;
-}
-export interface OntologyStream {
-    streamId: string;
-    name: string;
-    description: string;
-    selectors: Array<{
-        name: string;
-        conditions: string[];
-    }>;
-    deployments: OntologyDeployment[];
-}
-export interface OntologyWorkspace {
-    workspaceId: string;
-    name: string;
-    description: string;
-    streams: OntologyStream[];
-}
-export interface OntologyResponse {
-    agentService: {
-        agentServicePubKey: string;
-        name: string;
-        description: string;
-    };
-    workspaces: OntologyWorkspace[];
-}
-export interface RemoteCubby {
-    cubbyId: string;
-    agentServicePubKey?: string;
-    alias: string;
-    name: string;
-    description?: string;
-    migrations?: CubbyMigration[];
-    maxSizeBytes?: number;
-    idleTimeout?: string;
-    createdAt?: string;
-    updatedAt?: string;
-}
-interface ApiResponse {
-    id?: string;
-    [key: string]: unknown;
-}
-interface ApiListResponse<T> {
-    data: T[];
-}
-export interface RemoteWorkspace {
-    workspaceId: string;
-    agentServicePubKey: string;
-    name: string;
-    description: string;
-}
-export declare function createApiClient(env: EnvConfig, asPubKey: string, agentServiceId?: string): {
-    getResolvedAgentServiceId(): string | undefined;
-    createEngagement(payload: EngagementPayload): Promise<ApiResponse>;
-    updateEngagement(engagementId: string, payload: EngagementPayload): Promise<ApiResponse>;
-    createAgent(payload: AgentPayload): Promise<ApiResponse>;
-    updateAgent(agentId: string, payload: AgentUpdatePayload): Promise<ApiResponse>;
-    createWorkspaceOnRob(name: string): Promise<string>;
-    createWorkspace(payload: WorkspacePayload): Promise<ApiResponse>;
-    updateWorkspace(workspaceId: string, payload: WorkspacePayload): Promise<ApiResponse>;
-    getWorkspaces(): Promise<ApiListResponse<RemoteWorkspace>>;
-    createStream(workspaceId: string, payload: StreamPayload): Promise<ApiResponse>;
-    updateStream(streamId: string, payload: StreamPayload): Promise<ApiResponse>;
-    createDeployment(streamId: string, payload: DeploymentPayload): Promise<ApiResponse>;
-    updateDeployment(deploymentId: string, payload: DeploymentPayload): Promise<ApiResponse>;
-    createCubby(payload: CubbyCreatePayload): Promise<ApiResponse>;
-    updateCubby(cubbyId: string, payload: CubbyCreatePayload): Promise<ApiResponse>;
-    getAgents(): Promise<ApiListResponse<RemoteAgent>>;
-    getEngagements(): Promise<ApiListResponse<RemoteEngagement>>;
-    getOntology(): Promise<OntologyResponse>;
-    getCubbies(): Promise<RemoteCubby[]>;
-    getCubbyInstances(cubbyId: string): Promise<CubbyInstance[]>;
-    getCubbyStats(cubbyId: string): Promise<CubbyStats>;
-    deleteEngagement(engagementId: string): Promise<ApiResponse>;
-    deleteAgent(agentId: string): Promise<ApiResponse>;
-    deleteWorkspace(workspaceId: string): Promise<ApiResponse>;
-    deleteStream(streamId: string): Promise<ApiResponse>;
-    deleteDeployment(deploymentId: string): Promise<ApiResponse>;
-    createRaft(streamId: string, payload: RaftOrchestratorPayload): Promise<ApiResponse>;
-    updateRaft(raftId: string, payload: RaftOrchestratorPayload): Promise<ApiResponse>;
-    deleteRaft(raftId: string): Promise<ApiResponse>;
-    syncRaftToRob(payload: RaftRobPayload, method: "POST" | "PUT"): Promise<void>;
-    registerRaftOnRob(payload: RaftRobPayload): Promise<void>;
-    updateRaftOnRob(payload: RaftRobPayload): Promise<void>;
-    callTool(agentId: string, toolName: string, args: Record<string, unknown>): Promise<JsonRpcResponse>;
-    listTools(agentId: string): Promise<unknown>;
-};
-export type ApiClient = ReturnType<typeof createApiClient>;
-export interface AgentService {
-    id: string;
-    name: string;
-    publicKey: string;
-    archived: boolean;
-    createdAt: string;
-}
-export declare function listAgentServices(robApiUrl: string, authToken: string): Promise<AgentService[]>;
-export declare function createAgentServiceOnRob(robApiUrl: string, authToken: string, name: string, publicKey: string): Promise<AgentService>;
-export declare function createAgentServiceOnOrchestrator(orchestratorUrl: string, authToken: string, bucketId: string, name: string): Promise<ApiResponse>;
-export {};