@cef-ai/cli 0.2.6 → 0.3.0

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 {};