@cef-ai/cli 0.2.7 → 0.4.0

package/package.json

@@ -1,70 +1,35 @@
 {
   "name": "@cef-ai/cli",
-  "version": "0.2.7",
-  "description": "CEF AI command-line interface",
+  "version": "0.4.0",
   "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "bin": {
-    "cef": "dist/cli.js",
-    "cef-deploy": "dist/cli.js"
+    "cef": "./dist/cli.js"
   },
   "files": [
-    "dist/",
-    "README.md",
-    "example/agents",
-    "example/engagements",
-    "example/queries",
-    "example/.env.example",
-    "example/cef.config.yaml"
+    "dist"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/CEF-AI/deploy-sdk"
-  },
-  "homepage": "https://github.com/CEF-AI/deploy-sdk#readme",
-  "keywords": [
-    "cef",
-    "cef-ai",
-    "deploy",
-    "cli",
-    "cere"
-  ],
-  "scripts": {
-    "build": "tsc && cp -r src/commands/dev/static dist/commands/dev/static",
-    "prepublishOnly": "npm run build",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "test:integration": "vitest run --config vitest.integration.config.ts",
-    "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src tests",
-    "dev": "tsx src/cli.ts"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "better-sqlite3": "^12.8.0",
-    "esbuild": "^0.25.0",
-    "chalk": "^5.6.2",
-    "commander": "^14.0.3",
-    "dotenv": "^16.4.5",
-    "ora": "^9.3.0",
-    "sqlite-vec": "^0.1.9",
-    "typescript": "^5.4.5",
-    "ws": "^8.20.0",
-    "yaml": "^2.8.3"
+    "@noble/ed25519": "^2.1.0",
+    "@noble/hashes": "^2.2.0",
+    "canonicalize": "^3.0.0",
+    "commander": "^12.0.0",
+    "esbuild": "^0.21.0",
+    "json-schema-to-typescript": "^14.0.0",
+    "typescript": "^5.4.0",
+    "@cef-ai/agent-sdk": "0.1.0"
   },
   "devDependencies": {
-    "@eslint/js": "^9.15.0",
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^20.14.0",
-    "@types/ws": "^8.18.1",
-    "@vitest/coverage-v8": "^4.1.0",
-    "eslint": "^9.15.0",
-    "tsx": "^4.15.7",
-    "typescript-eslint": "^8.15.0",
-    "vitest": "^4.1.0"
+    "@types/node": "^20.11.0",
+    "vitest": "^1.5.0"
   },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "license": "Apache-2.0"
-}
+  "scripts": {
+    "build": "tsc -b && chmod +x dist/cli.js",
+    "test": "vitest run",
+    "lint": "eslint src"
+  }
+}

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

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

package/dist/commands/auth/index.js

@@ -1,162 +0,0 @@
-import http from 'http';
-import { exec } from 'child_process';
-import { saveCredentials, loadCredentials, clearCredentials, parseToken, getCredentialsPath, } from '../../lib/credentials.js';
-const DEFAULT_ROB_URL = 'https://rob.compute.test.ddcdragon.com';
-const LOGIN_TIMEOUT_MS = 300_000;
-function openBrowser(url) {
-    const cmd = process.platform === 'darwin'
-        ? `open "${url}"`
-        : process.platform === 'win32'
-            ? `start "" "${url}"`
-            : `xdg-open "${url}"`;
-    exec(cmd, (err) => {
-        if (err) {
-            console.log(`  Could not open browser automatically.`);
-            console.log(`  Open this URL manually:\n  ${url}\n`);
-        }
-    });
-}
-function saveAndPrint(token) {
-    const parsed = parseToken(token);
-    if (!parsed) {
-        console.error('  Error: Invalid token format. Expected: base64.base64.signature');
-        process.exit(1);
-    }
-    const expiresAt = new Date(parsed.expiresAt).getTime();
-    if (expiresAt <= Date.now()) {
-        console.error('  Error: Token is already expired.');
-        process.exit(1);
-    }
-    saveCredentials({
-        email: parsed.email,
-        publicKey: parsed.publicKey,
-        token,
-        expiresAt: parsed.expiresAt,
-    });
-    const expiresIn = Math.round((expiresAt - Date.now()) / 3600000);
-    console.log(`\n  Logged in as ${parsed.email}`);
-    console.log(`  Token expires in ~${expiresIn}h`);
-    console.log(`  Credentials saved to ${getCredentialsPath()}\n`);
-}
-function loginWithCallback(robUrl) {
-    return new Promise((resolve, reject) => {
-        let port = 0;
-        const server = http.createServer((req, res) => {
-            // CORS preflight
-            if (req.method === 'OPTIONS') {
-                res.writeHead(204, {
-                    'Access-Control-Allow-Origin': '*',
-                    'Access-Control-Allow-Methods': 'POST',
-                    'Access-Control-Allow-Headers': 'Content-Type',
-                });
-                res.end();
-                return;
-            }
-            if (req.method === 'POST' && req.url === '/callback') {
-                let body = '';
-                req.on('data', (chunk) => { body += chunk; });
-                req.on('end', () => {
-                    try {
-                        const { token } = JSON.parse(body);
-                        if (!token)
-                            throw new Error('Missing token');
-                        res.writeHead(200, {
-                            'Content-Type': 'application/json',
-                            'Access-Control-Allow-Origin': '*',
-                        });
-                        res.end(JSON.stringify({ ok: true }));
-                        saveAndPrint(token);
-                        server.close();
-                        resolve();
-                    }
-                    catch {
-                        res.writeHead(400, {
-                            'Content-Type': 'application/json',
-                            'Access-Control-Allow-Origin': '*',
-                        });
-                        res.end(JSON.stringify({ error: 'Invalid request' }));
-                    }
-                });
-                return;
-            }
-            res.writeHead(404);
-            res.end();
-        });
-        server.on('error', (err) => {
-            reject(err);
-        });
-        server.listen(0, '127.0.0.1', () => {
-            const addr = server.address();
-            port = typeof addr === 'object' ? addr.port : 0;
-            const authUrl = `${robUrl}/#/cli-auth?port=${port}`;
-            console.log(`\n  Opening browser for authentication...`);
-            console.log(`  If the browser doesn't open, visit:\n  ${authUrl}\n`);
-            console.log(`  Waiting for login...`);
-            openBrowser(authUrl);
-        });
-        const timeout = setTimeout(() => {
-            server.close();
-            reject(new Error('Login timed out. Try again with: cef login'));
-        }, LOGIN_TIMEOUT_MS);
-        server.on('close', () => clearTimeout(timeout));
-    });
-}
-async function handleLogin(opts) {
-    if (opts.token) {
-        saveAndPrint(opts.token);
-        return;
-    }
-    await loginWithCallback(DEFAULT_ROB_URL);
-}
-function handleLogout() {
-    const cleared = clearCredentials();
-    if (cleared) {
-        console.log('\n  Logged out. Credentials cleared.\n');
-    }
-    else {
-        console.log('\n  Not logged in (no credentials found).\n');
-    }
-}
-function handleWhoami() {
-    const creds = loadCredentials();
-    if (!creds) {
-        console.log('\n  Not logged in. Run `cef login` to authenticate.\n');
-        return;
-    }
-    const expiresAt = new Date(creds.expiresAt);
-    const msLeft = expiresAt.getTime() - Date.now();
-    const hoursLeft = Math.max(0, Math.round(msLeft / 3600000));
-    const minutesLeft = Math.max(0, Math.round(msLeft / 60000));
-    console.log(`\n  Email:      ${creds.email}`);
-    console.log(`  Public Key: ${creds.publicKey}`);
-    if (minutesLeft < 60) {
-        console.log(`  Expires in: ${minutesLeft} minutes`);
-    }
-    else {
-        console.log(`  Expires in: ~${hoursLeft} hours`);
-    }
-    console.log(`  Stored at:  ${getCredentialsPath()}\n`);
-}
-export function registerAuthCommands(program) {
-    program
-        .command('login')
-        .description('Authenticate with CEF platform')
-        .option('--token <token>', 'Manually provide a bearer token')
-        .action(async (opts) => {
-        try {
-            await handleLogin(opts);
-        }
-        catch (err) {
-            console.error(`\n  Login failed: ${err.message}\n`);
-            process.exit(1);
-        }
-    });
-    program
-        .command('logout')
-        .description('Clear stored credentials')
-        .action(() => handleLogout());
-    program
-        .command('whoami')
-        .description('Show current authentication status')
-        .action(() => handleWhoami());
-}

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

@@ -1,13 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

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