@hsafa/cli 0.0.1

package/dist/commands/agent.js

@@ -0,0 +1,853 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import api from '../utils/api.js';
+import { graphqlRequest } from '../utils/graphql.js';
+import ora from 'ora';
+import { randomUUID } from 'crypto';
+import { startChatSession } from './chat.js';
+import fs from 'fs';
+export function registerAgentCommands(program) {
+    const agent = program.command('agent').description('Agent management');
+    const isJson = () => Boolean(program.opts()?.json);
+    const output = (data) => {
+        console.log(JSON.stringify(data, null, 2));
+    };
+    const outputError = (error) => {
+        const message = error?.message || String(error);
+        if (isJson()) {
+            console.error(JSON.stringify({ error: message }, null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        console.error(chalk.red(message));
+        process.exitCode = 1;
+    };
+    const readStdin = async () => {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+        }
+        return Buffer.concat(chunks).toString('utf8');
+    };
+    const readJsonInput = async (options) => {
+        if (options.input !== undefined) {
+            return JSON.parse(options.input);
+        }
+        if (options.inputFile) {
+            return JSON.parse(fs.readFileSync(options.inputFile, 'utf8'));
+        }
+        if (options.inputStdin) {
+            const text = await readStdin();
+            return JSON.parse(text);
+        }
+        throw new Error('No input provided. Use --input, --input-file, or --input-stdin');
+    };
+    const getAgentWithFlow = async (id) => {
+        const query = `
+      query($id: ID!) {
+        agentWithFlow(id: $id) {
+          id
+          name
+          description
+          type
+          color
+          icon
+          status
+          configNodesCount
+          toolNodesCount
+          nodePositionX
+          nodePositionY
+          createdAt
+          updatedAt
+          flowNodes {
+            nodeId
+            nodeType
+            label
+            positionX
+            positionY
+            data
+            createdAt
+            updatedAt
+          }
+          flowEdges {
+            edgeId
+            sourceId
+            targetId
+            edgeType
+            data
+            createdAt
+            updatedAt
+          }
+          toolLinks {
+            id
+            agentId
+            toolId
+            isEnabled
+            order
+            tool {
+              id
+              name
+              description
+              inputSchema
+              outputSchema
+              executionType
+              executionConfig
+              isSystemTool
+              createdAt
+              updatedAt
+            }
+          }
+          knowledgeBaseLinks {
+            id
+            agentId
+            knowledgeBaseId
+            isEnabled
+            knowledgeBase {
+              id
+              name
+              description
+              createdAt
+              updatedAt
+            }
+          }
+        }
+      }
+    `;
+        const data = await graphqlRequest(query, { id });
+        return data.agentWithFlow;
+    };
+    const saveAgentFlow = async (agentId, flow) => {
+        const mutation = `
+      mutation($agentId: ID!, $input: SaveAgentFlowInput!) {
+        saveAgentFlow(agentId: $agentId, input: $input)
+      }
+    `;
+        return graphqlRequest(mutation, {
+            agentId,
+            input: {
+                nodes: flow.nodes,
+                edges: flow.edges,
+            },
+        });
+    };
+    const normalizeFlow = (input) => {
+        const nodes = input?.nodes || input?.flowNodes;
+        const edges = input?.edges || input?.flowEdges;
+        if (!Array.isArray(nodes) || !Array.isArray(edges)) {
+            throw new Error('Invalid flow input. Expected { nodes, edges } or { flowNodes, flowEdges }.');
+        }
+        return {
+            nodes: nodes.map((n) => ({
+                nodeId: n.nodeId,
+                nodeType: n.nodeType,
+                label: n.label,
+                positionX: n.positionX,
+                positionY: n.positionY,
+                data: n.data ?? undefined,
+            })),
+            edges: edges.map((e) => ({
+                edgeId: e.edgeId,
+                sourceId: e.sourceId,
+                targetId: e.targetId,
+                edgeType: e.edgeType ?? null,
+                data: e.data ?? undefined,
+            })),
+        };
+    };
+    agent
+        .command('list')
+        .description('List all available agents')
+        .option('-p, --project <id>', 'Project ID')
+        .action(async (options) => {
+        const globalOptions = program.opts();
+        const spinner = !globalOptions.json ? ora('Fetching agents...').start() : null;
+        try {
+            const projectId = options.project;
+            if (!projectId) {
+                if (spinner)
+                    spinner.fail('Project ID is required. Use -p <id>');
+                else
+                    console.error(JSON.stringify({ error: 'Project ID is required' }));
+                return;
+            }
+            const response = await api.get(`/api/projects/${projectId}/agents`);
+            const agents = response.data;
+            if (spinner)
+                spinner.stop();
+            if (globalOptions.json) {
+                console.log(JSON.stringify(agents, null, 2));
+                return;
+            }
+            if (agents.length === 0) {
+                console.log(chalk.yellow('No agents found for this project.'));
+                return;
+            }
+            const table = new Table({
+                head: [chalk.cyan('ID'), chalk.cyan('Name'), chalk.cyan('Description'), chalk.cyan('Status')],
+                colWidths: [36, 20, 40, 10]
+            });
+            agents.forEach((a) => {
+                table.push([a.id, a.name, a.description || 'N/A', a.status]);
+            });
+            console.log(table.toString());
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to fetch agents: ${error.message}`);
+            else
+                console.error(JSON.stringify({ error: error.message }));
+        }
+    });
+    agent
+        .command('chat <id>')
+        .description('Start a persistent chat with an agent')
+        .action(async (id) => {
+        await startChatSession(id);
+    });
+    agent
+        .command('export <id>')
+        .description('Export agent configuration to JSON')
+        .action(async (id) => {
+        const spinner = ora('Exporting agent...').start();
+        try {
+            const query = `
+          query($id: ID!) {
+            agentWithFlow(id: $id) {
+              name
+              description
+              type
+              color
+              icon
+              status
+              flowNodes {
+                nodeId
+                nodeType
+                label
+                positionX
+                positionY
+                data
+              }
+              flowEdges {
+                edgeId
+                sourceId
+                targetId
+                edgeType
+                data
+              }
+            }
+          }
+        `;
+            const data = await graphqlRequest(query, { id });
+            const agentData = data.agentWithFlow;
+            spinner.stop();
+            console.log(JSON.stringify(agentData, null, 2));
+        }
+        catch (error) {
+            spinner.fail(`Export failed: ${error.message}`);
+        }
+    });
+    agent
+        .command('import <file>')
+        .description('Import agent configuration from a JSON file')
+        .option('-w, --workspace <id>', 'Target workspace ID')
+        .action(async (file, options) => {
+        const spinner = ora('Importing agent...').start();
+        try {
+            if (!fs.existsSync(file)) {
+                spinner.fail(`File not found: ${file}`);
+                return;
+            }
+            const agentData = JSON.parse(fs.readFileSync(file, 'utf8'));
+            // 1. Get Workspace ID
+            let workspaceId = options.workspace;
+            if (!workspaceId) {
+                const wsQuery = `query { workspaces { id } }`;
+                const wsData = await graphqlRequest(wsQuery);
+                workspaceId = wsData.workspaces[0]?.id;
+                if (!workspaceId) {
+                    spinner.fail('No workspace found.');
+                    return;
+                }
+            }
+            // 2. Create Agent
+            const createMutation = `
+          mutation($workspaceId: ID!, $input: CreateAgentInput!) {
+            createAgent(workspaceId: $workspaceId, input: $input) {
+              id
+            }
+          }
+        `;
+            const created = await graphqlRequest(createMutation, {
+                workspaceId,
+                input: {
+                    name: agentData.name + ' (Imported)',
+                    description: agentData.description,
+                    type: agentData.type,
+                    color: agentData.color,
+                    icon: agentData.icon
+                }
+            });
+            const newId = created.createAgent.id;
+            // 3. Save Flow
+            const saveFlowMutation = `
+          mutation($agentId: ID!, $input: SaveAgentFlowInput!) {
+            saveAgentFlow(agentId: $agentId, input: $input)
+          }
+        `;
+            await graphqlRequest(saveFlowMutation, {
+                agentId: newId,
+                input: {
+                    nodes: agentData.flowNodes,
+                    edges: agentData.flowEdges
+                }
+            });
+            spinner.succeed(chalk.green(`Agent imported successfully with ID: ${newId}`));
+        }
+        catch (error) {
+            spinner.fail(`Import failed: ${error.message}`);
+        }
+    });
+    agent
+        .command('run <id> <message>')
+        .description('Run a single command with an agent')
+        .action(async (id, message) => {
+        const spinner = ora('Executing...').start();
+        try {
+            const response = await api.post(`/api/run/${id}`, {
+                messages: [{ role: 'user', content: message }],
+            }, {
+                responseType: 'stream',
+            });
+            spinner.stop();
+            process.stdout.write(chalk.cyan('Agent: '));
+            const stream = response.data;
+            await new Promise((resolve, reject) => {
+                let buffer = '';
+                stream.on('data', (chunk) => {
+                    buffer += chunk.toString();
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.trim())
+                            continue;
+                        try {
+                            const data = JSON.parse(line);
+                            if (data.type === 'text-delta' || data.type === 'text') {
+                                process.stdout.write(data.textDelta || data.text);
+                            }
+                        }
+                        catch (e) { }
+                    }
+                });
+                stream.on('end', () => {
+                    process.stdout.write('\n');
+                    resolve();
+                });
+                stream.on('error', reject);
+            });
+        }
+        catch (error) {
+            spinner.fail(`Error: ${error.message}`);
+        }
+    });
+    agent
+        .command('set-model <id> <model>')
+        .description('Set the LLM model for an agent')
+        .action(async (id, model) => {
+        const spinner = ora('Updating model...').start();
+        try {
+            // Update the agent's main model type
+            const mutation = `
+          mutation($id: ID!, $input: UpdateAgentInput!) {
+            updateAgent(id: $id, input: $input) {
+              id
+              type
+            }
+          }
+        `;
+            await graphqlRequest(mutation, { id, input: { type: model } });
+            // Also try to find a 'model' node in the flow and update it
+            const flowData = await getAgentWithFlow(id);
+            const modelNode = (flowData?.flowNodes || []).find((n) => n.nodeType === 'model');
+            if (modelNode) {
+                const updateNodeMutation = `
+            mutation($agentId: ID!, $nodeId: String!, $input: UpdateFlowNodeInput!) {
+              updateFlowNode(agentId: $agentId, nodeId: $nodeId, input: $input) {
+                nodeId
+              }
+            }
+          `;
+                await graphqlRequest(updateNodeMutation, {
+                    agentId: id,
+                    nodeId: modelNode.nodeId,
+                    input: { data: { ...(modelNode.data || {}), modelName: model } }
+                });
+            }
+            spinner.succeed(chalk.green(`Agent model set to ${model}`));
+        }
+        catch (error) {
+            spinner.fail(`Failed to update model: ${error.message}`);
+        }
+    });
+    agent
+        .command('set-prompt <id> <prompt>')
+        .description('Set the system prompt for an agent')
+        .action(async (id, prompt) => {
+        const spinner = ora('Updating system prompt...').start();
+        try {
+            const flowData = await getAgentWithFlow(id);
+            const systemPromptNode = (flowData?.flowNodes || []).find((n) => n.nodeType === 'system_prompt');
+            if (!systemPromptNode) {
+                spinner.fail('No system_prompt node found for this agent.');
+                return;
+            }
+            const updateNodeMutation = `
+          mutation($agentId: ID!, $nodeId: String!, $input: UpdateFlowNodeInput!) {
+            updateFlowNode(agentId: $agentId, nodeId: $nodeId, input: $input) {
+              nodeId
+            }
+          }
+        `;
+            await graphqlRequest(updateNodeMutation, {
+                agentId: id,
+                nodeId: systemPromptNode.nodeId,
+                input: { data: { ...(systemPromptNode.data || {}), systemPrompt: prompt } }
+            });
+            spinner.succeed(chalk.green('System prompt updated successfully.'));
+        }
+        catch (error) {
+            spinner.fail(`Failed to update prompt: ${error.message}`);
+        }
+    });
+    agent
+        .command('get <id>')
+        .description('Get full agent data (including flow nodes/edges)')
+        .option('--nodes', 'Return only flowNodes')
+        .option('--edges', 'Return only flowEdges')
+        .option('--tools', 'Return only toolLinks')
+        .option('--kbs', 'Return only knowledgeBaseLinks')
+        .action(async (id, options) => {
+        const spinner = !isJson() ? ora('Fetching agent...').start() : null;
+        try {
+            const data = await getAgentWithFlow(id);
+            if (spinner)
+                spinner.stop();
+            if (options.nodes)
+                return output(data.flowNodes);
+            if (options.edges)
+                return output(data.flowEdges);
+            if (options.tools)
+                return output(data.toolLinks);
+            if (options.kbs)
+                return output(data.knowledgeBaseLinks);
+            return output(data);
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to fetch agent: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    agent
+        .command('update <id>')
+        .description('Update agent metadata (name/description/type/color/icon/mode)')
+        .option('--input <json>', 'Inline JSON object with UpdateAgentInput')
+        .option('--input-file <path>', 'Read UpdateAgentInput JSON from a file')
+        .option('--input-stdin', 'Read UpdateAgentInput JSON from stdin')
+        .action(async (id, options) => {
+        const spinner = !isJson() ? ora('Updating agent...').start() : null;
+        try {
+            const input = await readJsonInput({
+                input: options.input,
+                inputFile: options.inputFile,
+                inputStdin: options.inputStdin,
+            });
+            const mutation = `
+          mutation($id: ID!, $input: UpdateAgentInput!) {
+            updateAgent(id: $id, input: $input) {
+              id
+              name
+              description
+              type
+              color
+              icon
+              status
+              createdAt
+              updatedAt
+            }
+          }
+        `;
+            const data = await graphqlRequest(mutation, { id, input });
+            if (spinner)
+                spinner.stop();
+            output(data.updateAgent);
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to update agent: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    agent
+        .command('replace <id>')
+        .description('Replace agent metadata and flow from JSON export')
+        .option('--input <json>', 'Inline JSON object (agent export format)')
+        .option('--input-file <path>', 'Read agent export JSON from file')
+        .option('--input-stdin', 'Read agent export JSON from stdin')
+        .action(async (id, options) => {
+        const spinner = !isJson() ? ora('Replacing agent...').start() : null;
+        try {
+            const exported = await readJsonInput({
+                input: options.input,
+                inputFile: options.inputFile,
+                inputStdin: options.inputStdin,
+            });
+            const updateInput = {};
+            if (exported.name !== undefined)
+                updateInput.name = exported.name;
+            if (exported.description !== undefined)
+                updateInput.description = exported.description;
+            if (exported.type !== undefined)
+                updateInput.type = exported.type;
+            if (exported.color !== undefined)
+                updateInput.color = exported.color;
+            if (exported.icon !== undefined)
+                updateInput.icon = exported.icon;
+            if (exported.mode !== undefined)
+                updateInput.mode = exported.mode;
+            const updateMutation = `
+          mutation($id: ID!, $input: UpdateAgentInput!) {
+            updateAgent(id: $id, input: $input) { id }
+          }
+        `;
+            await graphqlRequest(updateMutation, { id, input: updateInput });
+            const flow = normalizeFlow(exported);
+            await saveAgentFlow(id, flow);
+            if (spinner)
+                spinner.stop();
+            output({ ok: true });
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to replace agent: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    const flow = agent.command('flow').description('Agent flow operations (nodes + edges)');
+    flow
+        .command('apply <agentId>')
+        .description('Apply flow JSON (overwrites nodes and edges)')
+        .option('--input <json>', 'Inline JSON for {nodes,edges} or {flowNodes,flowEdges}')
+        .option('--input-file <path>', 'Read flow JSON from file')
+        .option('--input-stdin', 'Read flow JSON from stdin')
+        .action(async (agentId, options) => {
+        const spinner = !isJson() ? ora('Saving agent flow...').start() : null;
+        try {
+            const data = await readJsonInput({
+                input: options.input,
+                inputFile: options.inputFile,
+                inputStdin: options.inputStdin,
+            });
+            const normalized = normalizeFlow(data);
+            await saveAgentFlow(agentId, normalized);
+            if (spinner)
+                spinner.stop();
+            output({ ok: true });
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to save flow: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    const node = agent.command('node').description('Flow node operations');
+    node
+        .command('get <agentId> <nodeId>')
+        .description('Get a specific flow node by nodeId')
+        .action(async (agentId, nodeId) => {
+        const spinner = !isJson() ? ora('Fetching node...').start() : null;
+        try {
+            const query = `
+          query($agentId: ID!) {
+            agentFlowNodes(agentId: $agentId) {
+              nodeId
+              nodeType
+              label
+              positionX
+              positionY
+              data
+              createdAt
+              updatedAt
+            }
+          }
+        `;
+            const data = await graphqlRequest(query, { agentId });
+            const found = (data.agentFlowNodes || []).find((n) => n.nodeId === nodeId);
+            if (!found)
+                throw new Error(`Node not found: ${nodeId}`);
+            if (spinner)
+                spinner.stop();
+            output(found);
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to fetch node: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    node
+        .command('create <agentId>')
+        .description('Create a flow node')
+        .requiredOption('--type <nodeType>', 'nodeType')
+        .option('--nodeId <nodeId>', 'nodeId (defaults to random UUID)')
+        .option('--label <label>', 'label (defaults to nodeType)')
+        .option('--x <x>', 'positionX', '0')
+        .option('--y <y>', 'positionY', '0')
+        .option('--data <json>', 'Inline JSON for node data')
+        .option('--data-file <path>', 'Read node data JSON from file')
+        .option('--data-stdin', 'Read node data JSON from stdin')
+        .action(async (agentId, options) => {
+        const spinner = !isJson() ? ora('Creating node...').start() : null;
+        try {
+            const nodeId = options.nodeId || randomUUID();
+            const data = options.data !== undefined || options.dataFile || options.dataStdin
+                ? await readJsonInput({
+                    input: options.data,
+                    inputFile: options.dataFile,
+                    inputStdin: options.dataStdin,
+                })
+                : undefined;
+            const mutation = `
+          mutation($agentId: ID!, $input: CreateFlowNodeInput!) {
+            createFlowNode(agentId: $agentId, input: $input) {
+              nodeId
+              nodeType
+              label
+              positionX
+              positionY
+              data
+            }
+          }
+        `;
+            const result = await graphqlRequest(mutation, {
+                agentId,
+                input: {
+                    nodeId,
+                    nodeType: options.type,
+                    label: options.label || options.type,
+                    positionX: Number(options.x),
+                    positionY: Number(options.y),
+                    data,
+                },
+            });
+            if (spinner)
+                spinner.stop();
+            output(result.createFlowNode);
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to create node: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    node
+        .command('update <agentId> <nodeId>')
+        .description('Update a flow node (label/position/data)')
+        .option('--label <label>', 'Update label')
+        .option('--x <x>', 'Update positionX')
+        .option('--y <y>', 'Update positionY')
+        .option('--data <json>', 'Inline JSON for node data')
+        .option('--data-file <path>', 'Read node data JSON from file')
+        .option('--data-stdin', 'Read node data JSON from stdin')
+        .option('--merge', 'Merge provided data into existing node data instead of replacing')
+        .action(async (agentId, nodeId, options) => {
+        const spinner = !isJson() ? ora('Updating node...').start() : null;
+        try {
+            let dataUpdate = undefined;
+            const hasDataInput = options.data !== undefined || options.dataFile || options.dataStdin;
+            if (hasDataInput) {
+                dataUpdate = await readJsonInput({
+                    input: options.data,
+                    inputFile: options.dataFile,
+                    inputStdin: options.dataStdin,
+                });
+            }
+            if (options.merge && hasDataInput) {
+                const query = `
+            query($agentId: ID!) {
+              agentFlowNodes(agentId: $agentId) {
+                nodeId
+                data
+              }
+            }
+          `;
+                const current = await graphqlRequest(query, { agentId });
+                const found = (current.agentFlowNodes || []).find((n) => n.nodeId === nodeId);
+                dataUpdate = { ...(found?.data || {}), ...(dataUpdate || {}) };
+            }
+            const mutation = `
+          mutation($agentId: ID!, $nodeId: String!, $input: UpdateFlowNodeInput!) {
+            updateFlowNode(agentId: $agentId, nodeId: $nodeId, input: $input) {
+              nodeId
+              nodeType
+              label
+              positionX
+              positionY
+              data
+              updatedAt
+            }
+          }
+        `;
+            const input = {};
+            if (options.label !== undefined)
+                input.label = options.label;
+            if (options.x !== undefined)
+                input.positionX = Number(options.x);
+            if (options.y !== undefined)
+                input.positionY = Number(options.y);
+            if (hasDataInput)
+                input.data = dataUpdate;
+            const result = await graphqlRequest(mutation, { agentId, nodeId, input });
+            if (spinner)
+                spinner.stop();
+            output(result.updateFlowNode);
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to update node: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    node
+        .command('delete <agentId> <nodeId>')
+        .description('Delete a flow node')
+        .action(async (agentId, nodeId) => {
+        const spinner = !isJson() ? ora('Deleting node...').start() : null;
+        try {
+            const mutation = `
+          mutation($agentId: ID!, $nodeId: String!) {
+            deleteFlowNode(agentId: $agentId, nodeId: $nodeId)
+          }
+        `;
+            const result = await graphqlRequest(mutation, { agentId, nodeId });
+            if (spinner)
+                spinner.stop();
+            output({ ok: Boolean(result.deleteFlowNode) });
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to delete node: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    const edge = agent.command('edge').description('Flow edge operations');
+    edge
+        .command('get <agentId> <edgeId>')
+        .description('Get a specific flow edge by edgeId')
+        .action(async (agentId, edgeId) => {
+        const spinner = !isJson() ? ora('Fetching edge...').start() : null;
+        try {
+            const query = `
+          query($agentId: ID!) {
+            agentFlowEdges(agentId: $agentId) {
+              edgeId
+              sourceId
+              targetId
+              edgeType
+              data
+              createdAt
+              updatedAt
+            }
+          }
+        `;
+            const data = await graphqlRequest(query, { agentId });
+            const found = (data.agentFlowEdges || []).find((e) => e.edgeId === edgeId);
+            if (!found)
+                throw new Error(`Edge not found: ${edgeId}`);
+            if (spinner)
+                spinner.stop();
+            output(found);
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to fetch edge: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    edge
+        .command('add <agentId>')
+        .description('Add or replace a flow edge (link nodes)')
+        .requiredOption('--source <nodeId>', 'source nodeId')
+        .requiredOption('--target <nodeId>', 'target nodeId')
+        .option('--edgeId <edgeId>', 'edgeId (defaults to random UUID)')
+        .option('--type <edgeType>', 'edgeType')
+        .option('--data <json>', 'Inline JSON for edge data')
+        .option('--data-file <path>', 'Read edge data JSON from file')
+        .option('--data-stdin', 'Read edge data JSON from stdin')
+        .action(async (agentId, options) => {
+        const spinner = !isJson() ? ora('Saving edge...').start() : null;
+        try {
+            const edgeId = options.edgeId || randomUUID();
+            const edgeData = options.data !== undefined || options.dataFile || options.dataStdin
+                ? await readJsonInput({
+                    input: options.data,
+                    inputFile: options.dataFile,
+                    inputStdin: options.dataStdin,
+                })
+                : undefined;
+            const agentData = await getAgentWithFlow(agentId);
+            const flow = normalizeFlow(agentData);
+            const nextEdges = (flow.edges || []).filter((e) => e.edgeId !== edgeId);
+            nextEdges.push({
+                edgeId,
+                sourceId: options.source,
+                targetId: options.target,
+                edgeType: options.type ?? null,
+                data: edgeData ?? undefined,
+            });
+            await saveAgentFlow(agentId, { nodes: flow.nodes, edges: nextEdges });
+            if (spinner)
+                spinner.stop();
+            output({ ok: true, edgeId });
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to save edge: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+    edge
+        .command('delete <agentId> <edgeId>')
+        .description('Delete a flow edge by edgeId (unlink nodes)')
+        .action(async (agentId, edgeId) => {
+        const spinner = !isJson() ? ora('Deleting edge...').start() : null;
+        try {
+            const agentData = await getAgentWithFlow(agentId);
+            const flow = normalizeFlow(agentData);
+            const nextEdges = (flow.edges || []).filter((e) => e.edgeId !== edgeId);
+            if (nextEdges.length === (flow.edges || []).length) {
+                throw new Error(`Edge not found: ${edgeId}`);
+            }
+            await saveAgentFlow(agentId, { nodes: flow.nodes, edges: nextEdges });
+            if (spinner)
+                spinner.stop();
+            output({ ok: true });
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to delete edge: ${error.message}`);
+            else
+                outputError(error);
+        }
+    });
+}