@cef-ai/cli 0.2.6 → 0.3.0

package/dist/commands/deploy/deploy.js

@@ -1,654 +0,0 @@
-import fs from 'fs';
-import readline from 'readline/promises';
-import { stringify } from 'yaml';
-import { createApiClient, listAgentServices } from '../../lib/api.js';
-import { typecheckAll } from '../../lib/typecheck.js';
-import { extractId } from '../../lib/utils.js';
-const NOT_FOUND_HTTP = '404';
-const NOT_FOUND_CODE = 'RESOURCE_NOT_FOUND';
-function isNotFoundError(err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return msg.includes(NOT_FOUND_HTTP) || msg.includes(NOT_FOUND_CODE);
-}
-// Required by the API; replaced server-side with a permanent value
-const PLACEHOLDER_CID_PREFIX = 'temp-cid-';
-function defaultPromptForCopy(entity, name) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        throw new Error(`${entity} "${name}" not found on this agent service (ID may be from another service). ` +
-            'Run deploy in an interactive terminal to create a copy here, or remove the id from cef.config.yaml.');
-    }
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const question = `${entity} "${name}" not found on this agent service (ID may be from another service). Create a copy here? (y/n) `;
-    return rl.question(question).then((answer) => {
-        rl.close();
-        return /^y(es)?$/i.test((answer ?? '').trim());
-    }).catch((err) => {
-        rl.close();
-        throw err;
-    });
-}
-function defaultPromptForWorkspaceId(workspaceName) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        return Promise.resolve(undefined);
-    }
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const question = `Workspace "${workspaceName}" has no workspaceId. Enter workspace ID for this agent service (or press Enter to create new): `;
-    return rl.question(question).then((answer) => {
-        rl.close();
-        const id = (answer ?? '').trim();
-        return id === '' ? undefined : id;
-    }).catch((err) => {
-        rl.close();
-        throw err;
-    });
-}
-function defaultPromptForClearIds(oldServiceId, newServiceId) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        throw new Error(`Config appears to be from a different agent service (old: ${oldServiceId}, resolved: ${newServiceId}). ` +
-            'Run deploy in an interactive terminal to clear IDs and deploy fresh, or manually remove entity IDs from cef.config.yaml.');
-    }
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const question = `Config appears to be from a different agent service (old: ${oldServiceId}, resolved: ${newServiceId}). ` +
-        `Clear all entity IDs and deploy fresh? (y/n) `;
-    return rl.question(question).then((answer) => {
-        rl.close();
-        return /^y(es)?$/i.test((answer ?? '').trim());
-    }).catch((err) => {
-        rl.close();
-        throw err;
-    });
-}
-/** Check if config has any entity IDs that might be stale from another service. */
-function configHasEntityIds(config) {
-    for (const eng of config.engagements ?? []) {
-        if (eng.engagementId)
-            return true;
-    }
-    for (const agent of config.agents ?? []) {
-        if (agent.agentId)
-            return true;
-    }
-    for (const cubby of config.cubbies ?? []) {
-        if (cubby.cubbyId)
-            return true;
-    }
-    for (const ws of config.workspaces ?? []) {
-        if (ws.workspaceId)
-            return true;
-        for (const stream of ws.streams ?? []) {
-            if (stream.streamId)
-                return true;
-            for (const dep of stream.deployments ?? []) {
-                if (dep.deploymentId)
-                    return true;
-            }
-            for (const raft of stream.rafts ?? []) {
-                if (raft.raftId)
-                    return true;
-            }
-        }
-    }
-    return false;
-}
-/** Strip all entity IDs from config so everything deploys as new. */
-export function clearAllEntityIds(config) {
-    for (const eng of config.engagements ?? []) {
-        eng.engagementId = undefined;
-    }
-    for (const agent of config.agents ?? []) {
-        agent.agentId = undefined;
-    }
-    for (const cubby of config.cubbies ?? []) {
-        cubby.cubbyId = undefined;
-    }
-    for (const ws of config.workspaces ?? []) {
-        ws.workspaceId = undefined;
-        for (const stream of ws.streams ?? []) {
-            stream.streamId = undefined;
-            for (const dep of stream.deployments ?? []) {
-                dep.deploymentId = undefined;
-            }
-            for (const raft of stream.rafts ?? []) {
-                raft.raftId = undefined;
-            }
-        }
-    }
-}
-/** Detect if config was copied from a different agent service and offer to clear all entity IDs. */
-export async function detectAndClearStaleIds(config, oldServiceId, newServiceId, promptFn) {
-    if (!oldServiceId)
-        return false;
-    if (oldServiceId === newServiceId)
-        return false;
-    if (!configHasEntityIds(config))
-        return false;
-    const shouldClear = await promptFn(oldServiceId, newServiceId);
-    if (shouldClear) {
-        clearAllEntityIds(config);
-        config.agentServiceId = newServiceId;
-        log('Cleared all entity IDs. Deploying fresh.');
-        return true;
-    }
-    return false;
-}
-function log(msg) {
-    console.log(msg);
-}
-/** Resolve current agentServiceId (ROB data-service id) from ROB so config stays up to date. Run before creating API client. */
-async function resolveAgentServiceId(env, agentServicePubKey) {
-    if (!env.robApiUrl?.trim())
-        return undefined;
-    try {
-        const services = await listAgentServices(env.robApiUrl, env.authToken);
-        const match = services.find((s) => s.publicKey === agentServicePubKey);
-        return match?.id;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Fetch workspaces for this agent service, resolve workspaceId by name, and clear stale IDs. Run before any deploy commands. */
-async function resolveAndVerifyWorkspaces(ctx) {
-    const workspaces = ctx.config.workspaces ?? [];
-    if (workspaces.length === 0) {
-        ctx.remoteWorkspaces = [];
-        return;
-    }
-    if (ctx.dryRun) {
-        ctx.remoteWorkspaces = [];
-        return;
-    }
-    try {
-        const res = await ctx.api.getWorkspaces();
-        const list = (res.data ?? []).map((w) => ({
-            workspaceId: w.workspaceId,
-            name: w.name,
-        }));
-        ctx.remoteWorkspaces = list;
-        if (list.length > 0) {
-            log(`Verifying workspaces: found ${list.length} workspace(s) for this agent service.`);
-        }
-        const byId = new Map(list.map((w) => [w.workspaceId, w]));
-        for (const workspace of workspaces) {
-            const byName = list.filter((w) => w.name === workspace.name);
-            if (byName.length === 1) {
-                workspace.workspaceId = byName[0].workspaceId;
-                log(`  Resolved "${workspace.name}" → workspaceId: ${workspace.workspaceId}`);
-            }
-            else if (workspace.workspaceId && !byId.has(workspace.workspaceId)) {
-                log(`  Workspace "${workspace.name}" has workspaceId ${workspace.workspaceId} which is not in the orchestrator's workspace list for this agent service. Keeping existing ID (may have been created via ROB UI or another path).`);
-            }
-            if (!workspace.workspaceId) {
-                const entered = await ctx.promptForWorkspaceId(workspace.name);
-                if (entered) {
-                    workspace.workspaceId = entered;
-                    log(`  Using workspaceId for "${workspace.name}": ${entered}`);
-                }
-            }
-        }
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.warn(`Warning: Could not fetch remote workspaces: ${msg}`);
-        ctx.remoteWorkspaces = [];
-        // Orchestrator may not support getWorkspaces; deployWorkspaceTree will handle prompt/create
-    }
-}
-export function writeIdsBack(configPath, config) {
-    const clean = JSON.parse(JSON.stringify(config));
-    for (const eng of clean.engagements ?? []) {
-        delete eng.tsCode;
-        delete eng._resolvedFilePath;
-    }
-    for (const agent of clean.agents ?? []) {
-        for (const task of agent.tasks ?? []) {
-            delete task.tsCode;
-            delete task._resolvedFilePath;
-        }
-    }
-    // Cubbies have no transient fields to strip
-    for (const ws of clean.workspaces ?? []) {
-        for (const stream of ws.streams ?? []) {
-            for (const raft of stream.rafts ?? []) {
-                delete raft.tsCode;
-                delete raft._resolvedFilePath;
-            }
-        }
-    }
-    const tmpPath = configPath + '.tmp';
-    fs.writeFileSync(tmpPath, stringify(clean, { indent: 2 }));
-    fs.renameSync(tmpPath, configPath);
-}
-async function deployEngagements(ctx, engagementIdMap) {
-    for (const eng of ctx.config.engagements ?? []) {
-        const payload = {
-            agentServicePubKey: ctx.config.agentServicePubKey,
-            name: eng.name,
-            description: eng.description ?? '',
-            version: eng.version ?? '1.0.0',
-            conciergeAgent: {
-                name: `Concierge for ${eng.name}`,
-                description: `Orchestrates ${eng.name}`,
-                tsCode: eng.tsCode ?? '',
-            },
-        };
-        if (ctx.dryRun) {
-            log(`[dry-run] Would ${eng.engagementId ? 'update' : 'create'} engagement: ${eng.name}`);
-            ctx.results.push({ entity: 'engagement', name: eng.name, action: 'dry-run' });
-            if (eng.engagementId)
-                engagementIdMap.set(eng.name, eng.engagementId);
-            continue;
-        }
-        if (eng.engagementId) {
-            try {
-                log(`Updating engagement: ${eng.name}`);
-                await ctx.api.updateEngagement(eng.engagementId, payload);
-                engagementIdMap.set(eng.name, eng.engagementId);
-                ctx.results.push({ entity: 'engagement', name: eng.name, action: 'updated', id: eng.engagementId });
-            }
-            catch (err) {
-                if (!isNotFoundError(err))
-                    throw err;
-                const createCopy = await ctx.promptForCopy('engagement', eng.name);
-                if (!createCopy) {
-                    throw new Error(`Engagement "${eng.name}" not found on this agent service. Remove engagementId from cef.config.yaml to create a new one, or use the correct agent service.`);
-                }
-                log(`Creating engagement: ${eng.name}`);
-                const res = await ctx.api.createEngagement(payload);
-                const id = extractId(res, 'engagementId', 'id', '_id');
-                if (!id)
-                    log(`Warning: engagement created but no ID in response: ${JSON.stringify(res)}`);
-                eng.engagementId = id;
-                engagementIdMap.set(eng.name, id);
-                ctx.results.push({ entity: 'engagement', name: eng.name, action: 'created', id });
-            }
-        }
-        else {
-            log(`Creating engagement: ${eng.name}`);
-            const res = await ctx.api.createEngagement(payload);
-            const id = extractId(res, 'engagementId', 'id', '_id');
-            if (!id)
-                log(`Warning: engagement created but no ID in response: ${JSON.stringify(res)}`);
-            eng.engagementId = id;
-            engagementIdMap.set(eng.name, id);
-            ctx.results.push({ entity: 'engagement', name: eng.name, action: 'created', id });
-        }
-    }
-}
-async function deployAgents(ctx) {
-    for (const agent of ctx.config.agents ?? []) {
-        const tasks = agent.tasks.map(task => ({
-            name: task.name,
-            alias: task.alias,
-            tsCode: task.tsCode ?? '',
-            parameters: task.parameters ?? { properties: {}, type: 'object' },
-            returns: task.returns ?? { properties: {}, type: 'object' },
-        }));
-        if (ctx.dryRun) {
-            log(`[dry-run] Would ${agent.agentId ? 'update' : 'create'} agent: ${agent.name}`);
-            ctx.results.push({ entity: 'agent', name: agent.name, action: 'dry-run' });
-            continue;
-        }
-        if (agent.agentId) {
-            try {
-                log(`Updating agent: ${agent.name}`);
-                await ctx.api.updateAgent(agent.agentId, { tasks });
-                ctx.results.push({ entity: 'agent', name: agent.name, action: 'updated', id: agent.agentId });
-            }
-            catch (err) {
-                if (!isNotFoundError(err))
-                    throw err;
-                const createCopy = await ctx.promptForCopy('agent', agent.name);
-                if (!createCopy) {
-                    throw new Error(`Agent "${agent.name}" not found on this agent service. Remove agentId from cef.config.yaml to create a new one, or use the correct agent service.`);
-                }
-                log(`Creating agent: ${agent.name}`);
-                const res = await ctx.api.createAgent({
-                    agentServicePubKey: ctx.config.agentServicePubKey,
-                    name: agent.name,
-                    alias: agent.alias,
-                    description: agent.description ?? '',
-                    version: agent.version ?? '1.0.0',
-                    cid: `${PLACEHOLDER_CID_PREFIX}${Date.now()}`,
-                    tasks,
-                });
-                const id = extractId(res, 'agentId', 'id', '_id');
-                agent.agentId = id;
-                ctx.results.push({ entity: 'agent', name: agent.name, action: 'created', id });
-            }
-        }
-        else {
-            log(`Creating agent: ${agent.name}`);
-            const res = await ctx.api.createAgent({
-                agentServicePubKey: ctx.config.agentServicePubKey,
-                name: agent.name,
-                alias: agent.alias,
-                description: agent.description ?? '',
-                version: agent.version ?? '1.0.0',
-                cid: `${PLACEHOLDER_CID_PREFIX}${Date.now()}`,
-                tasks,
-            });
-            const id = extractId(res, 'agentId', 'id', '_id');
-            agent.agentId = id;
-            ctx.results.push({ entity: 'agent', name: agent.name, action: 'created', id });
-        }
-    }
-}
-async function deployCubbies(ctx) {
-    for (const cubby of ctx.config.cubbies ?? []) {
-        const isNew = !cubby.cubbyId;
-        if (ctx.dryRun) {
-            log(`[dry-run] Would ${isNew ? 'create' : 'update'} cubby: ${cubby.name}`);
-            ctx.results.push({ entity: 'cubby', name: cubby.name, action: 'dry-run' });
-            continue;
-        }
-        const payload = {
-            alias: cubby.alias,
-            name: cubby.name,
-            description: cubby.description,
-            migrations: cubby.migrations,
-            maxSizeBytes: cubby.maxSizeBytes,
-            idleTimeout: cubby.idleTimeout,
-        };
-        if (isNew) {
-            log(`Creating cubby: ${cubby.name}`);
-            const res = await ctx.api.createCubby(payload);
-            const id = extractId(res, 'cubbyId', 'id');
-            cubby.cubbyId = id;
-            ctx.results.push({ entity: 'cubby', name: cubby.name, action: 'created', id });
-        }
-        else {
-            log(`Updating cubby: ${cubby.name}`);
-            await ctx.api.updateCubby(cubby.cubbyId, payload);
-            ctx.results.push({ entity: 'cubby', name: cubby.name, action: 'updated', id: cubby.cubbyId });
-        }
-    }
-}
-async function deployWorkspaceTree(ctx, engagementIdMap, only) {
-    const shouldRun = (entity) => !only || only === entity;
-    for (const workspace of ctx.config.workspaces ?? []) {
-        if (shouldRun('workspace')) {
-            if (!workspace.workspaceId && !ctx.dryRun) {
-                const entered = await ctx.promptForWorkspaceId(workspace.name);
-                if (entered) {
-                    workspace.workspaceId = entered;
-                    log(`Using workspaceId for "${workspace.name}": ${entered}`);
-                }
-            }
-            if (ctx.dryRun) {
-                log(`[dry-run] Would ${workspace.workspaceId ? 'update' : 'create'} workspace: ${workspace.name}`);
-                ctx.results.push({ entity: 'workspace', name: workspace.name, action: 'dry-run' });
-            }
-            else if (workspace.workspaceId) {
-                try {
-                    log(`Updating workspace: ${workspace.name}`);
-                    await ctx.api.updateWorkspace(workspace.workspaceId, {
-                        agentServicePubKey: ctx.config.agentServicePubKey,
-                        name: workspace.name,
-                        description: workspace.description ?? '',
-                        workspaceId: workspace.workspaceId,
-                    });
-                    ctx.results.push({ entity: 'workspace', name: workspace.name, action: 'updated', id: workspace.workspaceId });
-                }
-                catch (err) {
-                    if (!isNotFoundError(err))
-                        throw err;
-                    const createCopy = await ctx.promptForCopy('workspace', workspace.name);
-                    if (!createCopy) {
-                        throw new Error(`Workspace "${workspace.name}" not found on this agent service. Remove workspaceId from cef.config.yaml to create a new one, or use the correct agent service.`);
-                    }
-                    log(`Creating workspace: ${workspace.name}`);
-                    const robId = await ctx.api.createWorkspaceOnRob(workspace.name);
-                    log(`  ROB workspace registered (id: ${robId}), provisioning on orchestrator…`);
-                    await ctx.api.createWorkspace({
-                        agentServicePubKey: ctx.config.agentServicePubKey,
-                        name: workspace.name,
-                        description: workspace.description ?? '',
-                        workspaceId: robId,
-                    });
-                    workspace.workspaceId = robId;
-                    ctx.results.push({ entity: 'workspace', name: workspace.name, action: 'created', id: robId });
-                }
-            }
-            else {
-                log(`Creating workspace: ${workspace.name}`);
-                const robId = await ctx.api.createWorkspaceOnRob(workspace.name);
-                log(`  ROB workspace registered (id: ${robId}), provisioning on orchestrator…`);
-                await ctx.api.createWorkspace({
-                    agentServicePubKey: ctx.config.agentServicePubKey,
-                    name: workspace.name,
-                    description: workspace.description ?? '',
-                    workspaceId: robId,
-                });
-                workspace.workspaceId = robId;
-                ctx.results.push({ entity: 'workspace', name: workspace.name, action: 'created', id: robId });
-            }
-        }
-        const effectiveWorkspaceId = workspace.workspaceId;
-        if (!effectiveWorkspaceId && !ctx.dryRun && (shouldRun('stream') || shouldRun('deployment'))) {
-            throw new Error(`Workspace "${workspace.name}" has no workspaceId. ` +
-                `Run a full deploy (or --only workspace) first to create it.`);
-        }
-        for (const stream of workspace.streams ?? []) {
-            if (shouldRun('stream')) {
-                const baseStreamPayload = {
-                    agentServicePubKey: ctx.config.agentServicePubKey,
-                    name: stream.name,
-                    description: stream.description ?? '',
-                    selectors: stream.selectors ?? [{ name: 'all', conditions: ['*'] }],
-                };
-                if (ctx.dryRun) {
-                    log(`[dry-run] Would ${stream.streamId ? 'update' : 'create'} stream: ${stream.name}`);
-                    ctx.results.push({ entity: 'stream', name: stream.name, action: 'dry-run' });
-                }
-                else if (stream.streamId) {
-                    try {
-                        log(`Updating stream: ${stream.name}`);
-                        await ctx.api.updateStream(stream.streamId, { ...baseStreamPayload, parentId: effectiveWorkspaceId });
-                        ctx.results.push({ entity: 'stream', name: stream.name, action: 'updated', id: stream.streamId });
-                    }
-                    catch (err) {
-                        if (!isNotFoundError(err))
-                            throw err;
-                        const createCopy = await ctx.promptForCopy('stream', stream.name);
-                        if (!createCopy) {
-                            throw new Error(`Stream "${stream.name}" not found on this agent service. Remove streamId from cef.config.yaml to create a new one, or use the correct agent service.`);
-                        }
-                        log(`Creating stream: ${stream.name}`);
-                        const res = await ctx.api.createStream(effectiveWorkspaceId, { ...baseStreamPayload, workspaceId: effectiveWorkspaceId });
-                        const id = extractId(res, 'streamId', 'id', '_id');
-                        stream.streamId = id;
-                        ctx.results.push({ entity: 'stream', name: stream.name, action: 'created', id });
-                    }
-                }
-                else {
-                    log(`Creating stream: ${stream.name}`);
-                    const res = await ctx.api.createStream(effectiveWorkspaceId, { ...baseStreamPayload, workspaceId: effectiveWorkspaceId });
-                    const id = extractId(res, 'streamId', 'id', '_id');
-                    stream.streamId = id;
-                    ctx.results.push({ entity: 'stream', name: stream.name, action: 'created', id });
-                }
-            }
-            const effectiveStreamId = stream.streamId ?? '';
-            // ─── Deploy rafts ───────────────────────────────────────────────────
-            async function createRaftAndRegisterOnRob(raft, effectiveStreamId, raftPayload) {
-                log(`Creating raft: ${raft.name}`);
-                const res = await ctx.api.createRaft(effectiveStreamId, raftPayload);
-                const id = extractId(res, 'raftId', 'id', '_id');
-                raft.raftId = id;
-                const robPayload = {
-                    raftId: id,
-                    streamId: effectiveStreamId,
-                    name: raft.name,
-                    description: raft.description,
-                    tsCode: raft.tsCode ?? '',
-                    dataSourcesIds: raft.dataSourcesIds,
-                    queryOperations: raft.queryOperations,
-                };
-                await ctx.api.registerRaftOnRob(robPayload);
-                ctx.results.push({ entity: 'raft', name: raft.name, action: 'created', id });
-            }
-            for (const raft of stream.rafts ?? []) {
-                if (!shouldRun('raft'))
-                    continue;
-                const raftPayload = {
-                    alias: raft.name.replace(/[^a-zA-Z0-9_]/g, '_'),
-                    tsCode: raft.tsCode ?? '',
-                };
-                if (ctx.dryRun) {
-                    log(`[dry-run] Would ${raft.raftId ? 'update' : 'create'} raft: ${raft.name}`);
-                    ctx.results.push({ entity: 'raft', name: raft.name, action: 'dry-run' });
-                }
-                else if (raft.raftId) {
-                    try {
-                        log(`Updating raft: ${raft.name}`);
-                        await ctx.api.updateRaft(raft.raftId, raftPayload);
-                        await ctx.api.updateRaftOnRob({
-                            raftId: raft.raftId,
-                            streamId: effectiveStreamId,
-                            name: raft.name,
-                            description: raft.description,
-                            tsCode: raft.tsCode ?? '',
-                            dataSourcesIds: raft.dataSourcesIds,
-                            queryOperations: raft.queryOperations,
-                        });
-                        ctx.results.push({ entity: 'raft', name: raft.name, action: 'updated', id: raft.raftId });
-                    }
-                    catch (err) {
-                        if (!isNotFoundError(err))
-                            throw err;
-                        const createCopy = await ctx.promptForCopy('raft', raft.name);
-                        if (!createCopy) {
-                            throw new Error(`Raft "${raft.name}" not found on this agent service. Remove raftId from cef.config.yaml to create a new one, or use the correct agent service.`);
-                        }
-                        await createRaftAndRegisterOnRob(raft, effectiveStreamId, raftPayload);
-                    }
-                }
-                else {
-                    await createRaftAndRegisterOnRob(raft, effectiveStreamId, raftPayload);
-                }
-            }
-            for (const deployment of stream.deployments ?? []) {
-                if (!shouldRun('deployment'))
-                    continue;
-                const resolvedEngagementId = engagementIdMap.get(deployment.engagement)
-                    ?? ctx.config.engagements?.find(e => e.name === deployment.engagement)?.engagementId
-                    ?? '';
-                if (!resolvedEngagementId && !ctx.dryRun) {
-                    throw new Error(`Cannot resolve engagementId for deployment "${deployment.name}": ` +
-                        `engagement "${deployment.engagement}" not found or not yet deployed.`);
-                }
-                const deploymentPayload = {
-                    name: deployment.name,
-                    description: deployment.description ?? '',
-                    isActive: deployment.isActive ?? true,
-                    streamId: effectiveStreamId,
-                    engagements: [{ id: resolvedEngagementId, rules: deployment.engagementRules ?? [] }],
-                    triggers: deployment.triggers ?? [{ name: 'all-events', conditions: ['*'] }],
-                };
-                if (ctx.dryRun) {
-                    log(`[dry-run] Would ${deployment.deploymentId ? 'update' : 'create'} deployment: ${deployment.name}`);
-                    ctx.results.push({ entity: 'deployment', name: deployment.name, action: 'dry-run' });
-                }
-                else if (deployment.deploymentId) {
-                    try {
-                        log(`Updating deployment: ${deployment.name}`);
-                        await ctx.api.updateDeployment(deployment.deploymentId, {
-                            ...deploymentPayload,
-                            deploymentId: deployment.deploymentId,
-                        });
-                        ctx.results.push({ entity: 'deployment', name: deployment.name, action: 'updated', id: deployment.deploymentId });
-                    }
-                    catch (err) {
-                        if (!isNotFoundError(err))
-                            throw err;
-                        const createCopy = await ctx.promptForCopy('deployment', deployment.name);
-                        if (!createCopy) {
-                            throw new Error(`Deployment "${deployment.name}" not found on this agent service. Remove deploymentId from cef.config.yaml to create a new one, or use the correct agent service.`);
-                        }
-                        log(`Creating deployment: ${deployment.name}`);
-                        const res = await ctx.api.createDeployment(effectiveStreamId, deploymentPayload);
-                        const id = extractId(res, 'deploymentId', 'id', '_id');
-                        deployment.deploymentId = id;
-                        ctx.results.push({ entity: 'deployment', name: deployment.name, action: 'created', id });
-                    }
-                }
-                else {
-                    log(`Creating deployment: ${deployment.name}`);
-                    const res = await ctx.api.createDeployment(effectiveStreamId, deploymentPayload);
-                    const id = extractId(res, 'deploymentId', 'id', '_id');
-                    deployment.deploymentId = id;
-                    ctx.results.push({ entity: 'deployment', name: deployment.name, action: 'created', id });
-                }
-            }
-        }
-    }
-}
-export async function runDeploy(resolved, options) {
-    const { config, env, configPath } = resolved;
-    const { dryRun = false, only } = options;
-    const typeErrors = typecheckAll(config);
-    if (typeErrors.length > 0) {
-        for (const e of typeErrors) {
-            log(`  TypeScript error ${e.file}:${e.line} — ${e.message}`);
-        }
-        throw new Error(`Type check failed with ${typeErrors.length} error(s). Fix before deploying.`);
-    }
-    const oldAgentServiceId = config.agentServiceId;
-    const resolvedAgentServiceId = await resolveAgentServiceId(env, config.agentServicePubKey);
-    if (resolvedAgentServiceId) {
-        if (config.agentServiceId !== resolvedAgentServiceId) {
-            log(`Resolved agentServiceId from ROB: ${resolvedAgentServiceId}`);
-        }
-        const promptForClearIds = options.promptForClearIds ?? defaultPromptForClearIds;
-        await detectAndClearStaleIds(config, oldAgentServiceId, resolvedAgentServiceId, promptForClearIds);
-        config.agentServiceId = resolvedAgentServiceId;
-    }
-    // Prefer fresh id from ROB; pass config.agentServiceId as fallback when listing data services fails (e.g. 403).
-    const api = createApiClient(env, config.agentServicePubKey, config.agentServiceId);
-    const results = [];
-    const engagementIdMap = new Map();
-    const shouldRun = (entity) => !only || only === entity;
-    const promptForCopy = options.promptForCopy ?? defaultPromptForCopy;
-    const promptForWorkspaceId = options.promptForWorkspaceId ?? defaultPromptForWorkspaceId;
-    const ctx = {
-        config,
-        api,
-        dryRun,
-        results,
-        promptForCopy,
-        promptForWorkspaceId,
-        configPath,
-        remoteWorkspaces: [],
-    };
-    await resolveAndVerifyWorkspaces(ctx);
-    // writeIdsBack is called after each entity type so that IDs are persisted
-    // incrementally. If the process crashes mid-deploy, already-created IDs
-    // are preserved in the config file for crash recovery.
-    if (shouldRun('engagement')) {
-        await deployEngagements(ctx, engagementIdMap);
-        if (!dryRun)
-            writeIdsBack(configPath, config);
-    }
-    if (shouldRun('agent')) {
-        await deployAgents(ctx);
-        if (!dryRun)
-            writeIdsBack(configPath, config);
-    }
-    if (shouldRun('cubby')) {
-        await deployCubbies(ctx);
-        if (!dryRun)
-            writeIdsBack(configPath, config);
-    }
-    await deployWorkspaceTree(ctx, engagementIdMap, only);
-    if (!dryRun)
-        writeIdsBack(configPath, config);
-    if (!dryRun) {
-        const resolvedSvcId = api.getResolvedAgentServiceId() ?? resolvedAgentServiceId;
-        if (resolvedSvcId) {
-            config.agentServiceId = resolvedSvcId;
-            writeIdsBack(configPath, config);
-        }
-    }
-    return results;
-}

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

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