@cef-ai/cli 0.2.1

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+export declare function createProgram(): Command;

package/dist/cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import { registerDeployCommands } from './commands/deploy/index.js';
+import { registerServiceCommands } from './commands/service/index.js';
+import { registerPlaygroundCommands } from './commands/playground/index.js';
+import { registerDevCommands } from './commands/dev/index.js';
+function getVersion() {
+    try {
+        const dir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.join(dir, '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function showWelcome(version) {
+    console.log(`
+  \x1b[1mCEF AI CLI\x1b[0m \x1b[2mv${version}\x1b[0m
+
+  \x1b[36mQuick start:\x1b[0m
+
+    \x1b[33m$\x1b[0m cef dev                  Start local dev server with UI
+    \x1b[33m$\x1b[0m cef deploy               Deploy topology to orchestrator
+    \x1b[33m$\x1b[0m cef status               Compare local vs deployed state
+
+  \x1b[36mOther commands:\x1b[0m
+
+    \x1b[33m$\x1b[0m cef service list          List agent services
+    \x1b[33m$\x1b[0m cef service create        Create a new agent service
+    \x1b[33m$\x1b[0m cef clone --pubkey 0x...  Download existing service
+    \x1b[33m$\x1b[0m cef delete               Delete deployed entities
+    \x1b[33m$\x1b[0m cef --help               Show all options
+
+  \x1b[2mDocs: https://github.com/CEF-AI/deploy-sdk#readme\x1b[0m
+`);
+}
+export function createProgram() {
+    const program = new Command();
+    program
+        .name('cef')
+        .description('CEF AI command-line interface')
+        .version(getVersion(), '-V, --version');
+    registerDeployCommands(program);
+    registerServiceCommands(program);
+    registerPlaygroundCommands(program);
+    registerDevCommands(program);
+    return program;
+}
+const isDirectRun = process.argv[1] &&
+    (fileURLToPath(import.meta.url) === process.argv[1] ||
+        process.argv[1].endsWith('/cli.js'));
+if (isDirectRun) {
+    const program = createProgram();
+    // No args (or only node + script): show welcome instead of crashing into deploy
+    const userArgs = process.argv.slice(2);
+    if (userArgs.length === 0) {
+        showWelcome(getVersion());
+        process.exit(0);
+    }
+    program.parse();
+}

package/dist/commands/deploy/clone.d.ts

@@ -0,0 +1,13 @@
+import type { EnvConfig } from '../../lib/types.js';
+export interface CloneOptions {
+    pubkey: string;
+    outputDir: string;
+    force: boolean;
+}
+export interface CloneResult {
+    entity: string;
+    name: string;
+    action: 'written' | 'skipped' | 'fetched';
+    file?: string;
+}
+export declare function runClone(env: EnvConfig, options: CloneOptions): Promise<CloneResult[]>;

package/dist/commands/deploy/clone.js

@@ -0,0 +1,143 @@
+import fs from 'fs';
+import path from 'path';
+import { stringify } from 'yaml';
+import { createApiClient } from '../../lib/api.js';
+import { toFileName, errorMessage } from '../../lib/utils.js';
+function writeFileIfAllowed(filePath, content, force, allowedBase) {
+    if (allowedBase) {
+        const resolved = path.resolve(filePath);
+        const base = path.resolve(allowedBase);
+        if (!resolved.startsWith(base + path.sep) && resolved !== base) {
+            throw new Error(`Path traversal detected: ${filePath} escapes ${allowedBase}`);
+        }
+    }
+    if (fs.existsSync(filePath) && !force)
+        return 'skipped';
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf8');
+    return 'written';
+}
+async function safeFetch(label, fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        console.warn(`Warning: Could not fetch ${label}: ${errorMessage(err)}`);
+        return null;
+    }
+}
+export async function runClone(env, options) {
+    const { pubkey, outputDir, force } = options;
+    const api = createApiClient(env, pubkey);
+    const results = [];
+    // Fetch in parallel
+    const [engagementsRes, agentsRes, ontologyRes, cubbiesRes] = await Promise.all([
+        safeFetch('engagements', () => api.getEngagements()),
+        safeFetch('agents', () => api.getAgents()),
+        safeFetch('ontology', () => api.getOntology()),
+        safeFetch('cubbies', () => api.getCubbies()),
+    ]);
+    const allAgents = agentsRes?.data ?? [];
+    const engagements = engagementsRes?.data ?? [];
+    // Separate concierge agents from user agents
+    const conciergeMap = new Map(allAgents.filter(a => a.isConcierge).map(a => [a.agentId, a]));
+    const userAgents = allAgents.filter(a => !a.isConcierge);
+    // ─── Write engagement files ────────────────────────────────────────────
+    const engagementConfigs = engagements.map(eng => {
+        const concierge = conciergeMap.get(eng.conciergeAgentId);
+        const tsCode = concierge?.tasks[0]?.tsCode ?? '';
+        let fileName = `${toFileName(eng.name)}.ts`;
+        if (fileName === 'unknown.ts')
+            fileName = `unknown-${eng.engagementId}.ts`;
+        const relPath = `./engagements/${fileName}`;
+        const absPath = path.join(outputDir, 'engagements', fileName);
+        if (tsCode) {
+            const action = writeFileIfAllowed(absPath, tsCode, force, outputDir);
+            results.push({ entity: 'engagement', name: eng.name, action, file: relPath });
+        }
+        return {
+            name: eng.name,
+            description: eng.description || undefined,
+            engagementId: eng.engagementId,
+            file: relPath,
+            version: eng.version || '1.0.0',
+        };
+    });
+    // ─── Write agent task files ────────────────────────────────────────────
+    const agentConfigs = userAgents.map(agent => {
+        const tasks = agent.tasks.map(task => {
+            let taskFileName = `${toFileName(task.alias)}.ts`;
+            if (taskFileName === 'unknown.ts')
+                taskFileName = `unknown-${task.id}.ts`;
+            const relPath = `./agents/${agent.alias}/tasks/${taskFileName}`;
+            const absPath = path.join(outputDir, 'agents', agent.alias, 'tasks', taskFileName);
+            if (task.tsCode) {
+                const action = writeFileIfAllowed(absPath, task.tsCode, force, outputDir);
+                results.push({ entity: 'agent-task', name: `${agent.name}/${task.name}`, action, file: relPath });
+            }
+            return {
+                name: task.name,
+                alias: task.alias,
+                file: relPath,
+                parameters: task.parameters,
+                returns: task.returns,
+            };
+        });
+        return {
+            name: agent.name,
+            alias: agent.alias,
+            description: agent.description || undefined,
+            agentId: agent.agentId,
+            version: agent.version || '1.0.0',
+            tasks,
+        };
+    });
+    // ─── Map ontology to workspace config ──────────────────────────────────
+    const workspaceConfigs = ontologyRes?.workspaces?.map(ws => ({
+        name: ws.name,
+        description: ws.description || undefined,
+        workspaceId: ws.workspaceId,
+        streams: ws.streams?.map(s => ({
+            name: s.name,
+            description: s.description || undefined,
+            streamId: s.streamId,
+            selectors: s.selectors?.length ? s.selectors : undefined,
+            deployments: s.deployments?.map(d => ({
+                name: d.name,
+                description: d.description || undefined,
+                deploymentId: d.deploymentId,
+                engagement: d.engagements?.[0]?.name ?? '',
+                isActive: d.isActive,
+                triggers: d.triggers?.length ? d.triggers : undefined,
+            })),
+        })),
+    }));
+    // ─── Map remote cubbies to config ───────────────────────────────────────
+    const remoteCubbies = cubbiesRes ?? [];
+    const cubbyConfigs = remoteCubbies.map(cubby => ({
+        alias: cubby.alias,
+        name: cubby.name,
+        description: cubby.description || undefined,
+        cubbyId: cubby.cubbyId,
+        migrations: cubby.migrations,
+        maxSizeBytes: cubby.maxSizeBytes,
+        idleTimeout: cubby.idleTimeout,
+    }));
+    // ─── Build config ──────────────────────────────────────────────────────
+    const config = {
+        agentServicePubKey: pubkey,
+    };
+    if (engagementConfigs.length)
+        config.engagements = engagementConfigs;
+    if (agentConfigs.length)
+        config.agents = agentConfigs;
+    if (cubbyConfigs.length)
+        config.cubbies = cubbyConfigs;
+    if (workspaceConfigs && workspaceConfigs.length)
+        config.workspaces = workspaceConfigs;
+    // Write config file (respects --force)
+    const configPath = path.join(outputDir, 'cef.config.yaml');
+    const configAction = writeFileIfAllowed(configPath, stringify(config), force);
+    results.push({ entity: 'config', name: 'cef.config.yaml', action: configAction, file: configPath });
+    return results;
+}

package/dist/commands/deploy/delete.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedConfig } from '../../lib/types.js';
+export interface DeleteResult {
+    entity: string;
+    name: string;
+    id: string;
+    action: 'deleted' | 'skipped' | 'failed';
+    error?: string;
+}
+interface DeleteOptions {
+    only?: string;
+    force?: boolean;
+}
+export declare function runDelete(resolved: ResolvedConfig, options: DeleteOptions): Promise<DeleteResult[]>;
+export {};

package/dist/commands/deploy/delete.js

@@ -0,0 +1,134 @@
+import readline from 'readline/promises';
+import { createApiClient } from '../../lib/api.js';
+import { writeIdsBack } from './deploy.js';
+import { errorMessage } from '../../lib/utils.js';
+function collectEntitiesToDelete(config, api) {
+    const entities = [];
+    // Reverse dependency order: deployments -> rafts -> streams -> workspaces -> agents -> engagements
+    for (const ws of config.workspaces ?? []) {
+        for (const stream of ws.streams ?? []) {
+            for (const dep of stream.deployments ?? []) {
+                if (dep.deploymentId) {
+                    entities.push({
+                        entity: 'deployment',
+                        name: dep.name,
+                        id: dep.deploymentId,
+                        deleteFn: () => api.deleteDeployment(dep.deploymentId),
+                        clearId: () => { dep.deploymentId = undefined; },
+                    });
+                }
+            }
+            for (const raft of stream.rafts ?? []) {
+                if (raft.raftId) {
+                    entities.push({
+                        entity: 'raft',
+                        name: raft.name,
+                        id: raft.raftId,
+                        deleteFn: () => api.deleteRaft(raft.raftId),
+                        clearId: () => { raft.raftId = undefined; },
+                    });
+                }
+            }
+            if (stream.streamId) {
+                entities.push({
+                    entity: 'stream',
+                    name: stream.name,
+                    id: stream.streamId,
+                    deleteFn: () => api.deleteStream(stream.streamId),
+                    clearId: () => { stream.streamId = undefined; },
+                });
+            }
+        }
+        if (ws.workspaceId) {
+            entities.push({
+                entity: 'workspace',
+                name: ws.name,
+                id: ws.workspaceId,
+                deleteFn: () => api.deleteWorkspace(ws.workspaceId),
+                clearId: () => { ws.workspaceId = undefined; },
+            });
+        }
+    }
+    for (const agent of config.agents ?? []) {
+        if (agent.agentId) {
+            entities.push({
+                entity: 'agent',
+                name: agent.name,
+                id: agent.agentId,
+                deleteFn: () => api.deleteAgent(agent.agentId),
+                clearId: () => { agent.agentId = undefined; },
+            });
+        }
+    }
+    for (const eng of config.engagements ?? []) {
+        if (eng.engagementId) {
+            entities.push({
+                entity: 'engagement',
+                name: eng.name,
+                id: eng.engagementId,
+                deleteFn: () => api.deleteEngagement(eng.engagementId),
+                clearId: () => { eng.engagementId = undefined; },
+            });
+        }
+    }
+    return entities;
+}
+async function confirmDelete(count, pubkey) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error(`Cannot confirm deletion of ${count} entities in non-interactive mode. Use --force to skip confirmation.`);
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`Delete ${count} entity/entities from agent service ${pubkey}? This cannot be undone. (y/n) `);
+        return /^y(es)?$/i.test((answer ?? '').trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runDelete(resolved, options) {
+    const { config, env, configPath } = resolved;
+    const api = createApiClient(env, config.agentServicePubKey, config.agentServiceId);
+    let entities = collectEntitiesToDelete(config, api);
+    if (options.only) {
+        entities = entities.filter(e => e.entity === options.only);
+    }
+    // Warn about cubbies that cannot be deleted via CLI
+    for (const cubby of config.cubbies ?? []) {
+        if (cubby.cubbyId && (!options.only || options.only === 'cubby')) {
+            console.warn(`Warning: cubby "${cubby.name}" cannot be deleted via CLI. Remove manually if needed.`);
+        }
+    }
+    if (entities.length === 0) {
+        console.log('No entities with IDs to delete.');
+        return [];
+    }
+    console.log(`\nEntities to delete (${entities.length}):`);
+    for (const e of entities) {
+        console.log(`  ${e.entity}: ${e.name} (${e.id})`);
+    }
+    if (!options.force) {
+        const confirmed = await confirmDelete(entities.length, config.agentServicePubKey);
+        if (!confirmed) {
+            console.log('Cancelled.');
+            return entities.map(e => ({ entity: e.entity, name: e.name, id: e.id, action: 'skipped' }));
+        }
+    }
+    const results = [];
+    for (const e of entities) {
+        try {
+            console.log(`Deleting ${e.entity}: ${e.name} (${e.id})`);
+            await e.deleteFn();
+            e.clearId();
+            results.push({ entity: e.entity, name: e.name, id: e.id, action: 'deleted' });
+        }
+        catch (err) {
+            const msg = errorMessage(err);
+            console.error(`  Failed to delete ${e.entity} "${e.name}": ${msg}`);
+            results.push({ entity: e.entity, name: e.name, id: e.id, action: 'failed', error: msg });
+        }
+    }
+    // Write cleaned config (IDs removed for successfully deleted entities)
+    writeIdsBack(configPath, config);
+    return results;
+}

package/dist/commands/deploy/deploy.d.ts

@@ -0,0 +1,24 @@
+import type { ResolvedConfig, DeployResult, CefConfig } from '../../lib/types.js';
+export type PromptForCopyEntity = 'engagement' | 'agent' | 'workspace' | 'stream' | 'deployment' | 'raft';
+export type PromptForCopy = (entity: PromptForCopyEntity, name: string) => Promise<boolean>;
+/** Return workspace ID for this agent service, or undefined to create new. */
+export type PromptForWorkspaceId = (workspaceName: string) => Promise<string | undefined>;
+/** Called when config.agentServiceId doesn't match the resolved ID from ROB, indicating the config was likely copied from another service. Return true to clear all entity IDs and deploy fresh. */
+export type PromptForClearIds = (oldServiceId: string, newServiceId: string) => Promise<boolean>;
+interface DeployOptions {
+    dryRun?: boolean;
+    only?: string;
+    /** When update returns 404 (e.g. ID from another agent service), call this to ask if we should create a copy. Default: interactive y/n when TTY, else throw. */
+    promptForCopy?: PromptForCopy;
+    /** When workspace has no workspaceId and we can't resolve it from the orchestrator, call this. Return ID or undefined to create new. Default: interactive prompt when TTY. */
+    promptForWorkspaceId?: PromptForWorkspaceId;
+    /** When agentServiceId mismatch is detected (config copied from another service), call this to ask if all entity IDs should be cleared. Default: interactive y/n when TTY, else throw. */
+    promptForClearIds?: PromptForClearIds;
+}
+/** Strip all entity IDs from config so everything deploys as new. */
+export declare function clearAllEntityIds(config: CefConfig): void;
+/** Detect if config was copied from a different agent service and offer to clear all entity IDs. */
+export declare function detectAndClearStaleIds(config: CefConfig, oldServiceId: string | undefined, newServiceId: string, promptFn: PromptForClearIds): Promise<boolean>;
+export declare function writeIdsBack(configPath: string, config: CefConfig): void;
+export declare function runDeploy(resolved: ResolvedConfig, options: DeployOptions): Promise<DeployResult[]>;
+export {};