@rglabs/butterfly 2.0.1

package/dist/commands/add.js

@@ -0,0 +1,303 @@
+import React, { useEffect, useState } from 'react';
+import { render, Box, Text } from 'ink';
+import { loadAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+import { saveWorkflowData } from '../utils/files.js';
+function parseConnectFrom(spec) {
+    const parts = spec.split(':');
+    if (parts.length < 1 || parts.length > 2) {
+        throw new Error(`Invalid --connect-from spec "${spec}". Format: node_id[:output_key]`);
+    }
+    const nodeId = parseInt(parts[0], 10);
+    if (isNaN(nodeId)) {
+        throw new Error(`Invalid node ID in --connect-from spec "${spec}"`);
+    }
+    const outputKey = parts[1] || 'output';
+    return { nodeId, outputKey };
+}
+function parseConnectTo(spec) {
+    const parts = spec.split(':');
+    if (parts.length < 1 || parts.length > 2) {
+        throw new Error(`Invalid --connect-to spec "${spec}". Format: node_id[:input_key]`);
+    }
+    const nodeId = parseInt(parts[0], 10);
+    if (isNaN(nodeId)) {
+        throw new Error(`Invalid node ID in --connect-to spec "${spec}"`);
+    }
+    const inputKey = parts[1] || 'input';
+    return { nodeId, inputKey };
+}
+const AddCommand = ({ options, api }) => {
+    const [state, setState] = useState({ status: 'loading', message: 'Initializing...' });
+    useEffect(() => {
+        const run = async () => {
+            try {
+                const outputPath = options.output || './butterfly-resources';
+                if (options.type === 'workflow') {
+                    await createWorkflow(api, options, outputPath, setState);
+                }
+                else if (options.type === 'workflow-node') {
+                    await createWorkflowNode(api, options, outputPath, setState);
+                }
+                else if (options.type === 'workflow-connection') {
+                    await createWorkflowConnection(api, options, outputPath, setState);
+                }
+                else {
+                    setState({ status: 'error', message: `Unknown type: ${options.type}. Supported types: workflow, workflow-node, workflow-connection` });
+                }
+            }
+            catch (error) {
+                setState({
+                    status: 'error',
+                    message: error instanceof Error ? error.message : 'Unknown error occurred'
+                });
+            }
+        };
+        run();
+    }, []);
+    return (React.createElement(Box, { flexDirection: "column" },
+        state.status === 'loading' && React.createElement(Text, { color: "yellow" },
+            "\u23F3 ",
+            state.message),
+        state.status === 'creating' && React.createElement(Text, { color: "blue" },
+            "\uD83D\uDD04 ",
+            state.message),
+        state.status === 'downloading' && React.createElement(Text, { color: "cyan" },
+            "\uD83D\uDCE5 ",
+            state.message),
+        state.status === 'complete' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" },
+                "\u2713 ",
+                state.message),
+            state.createdId && React.createElement(Text, { color: "gray" },
+                "  Created ID: ",
+                state.createdId))),
+        state.status === 'error' && React.createElement(Text, { color: "red" },
+            "\u2717 ",
+            state.message)));
+};
+async function createWorkflow(api, options, outputPath, setState) {
+    setState({ status: 'creating', message: 'Creating new workflow...' });
+    const name = options.title || 'New Workflow';
+    const seo = `webhook/${name.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`;
+    const formData = new URLSearchParams();
+    formData.append('name', name);
+    formData.append('seo', seo);
+    formData.append('bfy_workflow_version_id', '0');
+    formData.append('bfy_workflow_node_id', '0');
+    const response = await api.httpClient.post('/admin/ajax/cms_object/operation?do=bfy_workflows__add', formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (!response.data?.success || !response.data?.id) {
+        throw new Error(response.data?.error || response.data?.message || 'Failed to create workflow');
+    }
+    const workflowId = response.data.id;
+    setState({ status: 'downloading', message: `Created workflow with ID ${workflowId}. Downloading...` });
+    await downloadWorkflowById(api, workflowId, outputPath);
+    setState({
+        status: 'complete',
+        message: `Workflow "${name}" created and downloaded successfully!`,
+        createdId: workflowId
+    });
+}
+async function createWorkflowNode(api, options, outputPath, setState) {
+    if (!options.workflow) {
+        throw new Error('--workflow is required (workflow name or ID)');
+    }
+    setState({ status: 'loading', message: 'Finding workflow...' });
+    const workflows = await api.fetchTable('bfy_workflows');
+    let workflow = workflows.find((w) => w.id.toString() === options.workflow ||
+        w.name.toLowerCase() === options.workflow?.toLowerCase());
+    if (!workflow) {
+        throw new Error(`Workflow not found: ${options.workflow}`);
+    }
+    const versions = await api.fetchTable('bfy_workflow_versions');
+    let version;
+    if (options.version) {
+        version = versions.find((v) => v.bfy_workflow_id === workflow.id &&
+            (v.id.toString() === options.version || v.version_number.toString() === options.version));
+    }
+    else {
+        const workflowVersions = versions.filter((v) => v.bfy_workflow_id === workflow.id);
+        version = workflowVersions.sort((a, b) => b.version_number - a.version_number)[0];
+    }
+    if (!version) {
+        throw new Error(`No version found for workflow: ${options.workflow}`);
+    }
+    setState({ status: 'creating', message: `Creating node in workflow "${workflow.name}" v${version.version_number}...` });
+    const title = options.title || 'New Node';
+    const nodeGroup = options.nodeGroup || 'Code';
+    const nodeIdentifier = options.nodeType || 'CustomScript';
+    const systemName = options.systemName || title.toLowerCase().replace(/[^a-z0-9]+/g, '_');
+    const nodes = await api.fetchTable('bfy_workflow_nodes');
+    const versionNodes = nodes.filter((n) => n.bfy_workflow_version_id === version.id);
+    const maxX = versionNodes.reduce((max, n) => Math.max(max, parseInt(n.position_x) || 0), 0);
+    const positionX = maxX + 240;
+    const positionY = 200;
+    const formData = new URLSearchParams();
+    formData.append('bfy_workflow_id', workflow.id.toString());
+    formData.append('bfy_workflow_version_id', version.id.toString());
+    formData.append('node_group_class_name', nodeGroup);
+    formData.append('node_identifier_key', nodeIdentifier);
+    formData.append('title', title);
+    formData.append('system_name', systemName);
+    formData.append('position_x', positionX.toString());
+    formData.append('position_y', positionY.toString());
+    formData.append('params', '');
+    formData.append('connections', '');
+    formData.append('pinned_data', '');
+    const response = await api.httpClient.post('/admin/ajax/cms_object/operation?do=bfy_workflow_nodes__add', formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (!response.data?.success || !response.data?.id) {
+        throw new Error(response.data?.error || response.data?.message || 'Failed to create node');
+    }
+    const nodeId = response.data.id;
+    const connectionsCreated = [];
+    if (options.connectFrom) {
+        setState({ status: 'creating', message: `Created node ${nodeId}. Creating connection from source node...` });
+        const spec = parseConnectFrom(options.connectFrom);
+        const sourceNode = versionNodes.find((n) => n.id === spec.nodeId);
+        if (!sourceNode) {
+            throw new Error(`Source node ${spec.nodeId} not found in workflow version`);
+        }
+        const connResult = await api.createWorkflowConnection({
+            source_node_id: spec.nodeId,
+            target_node_id: nodeId,
+            source_output_key: spec.outputKey,
+            target_input_key: 'input',
+            connection_type: 'data'
+        });
+        if (connResult?.success) {
+            connectionsCreated.push(`${spec.nodeId}:${spec.outputKey} → ${nodeId}:input`);
+        }
+    }
+    if (options.connectTo) {
+        setState({ status: 'creating', message: `Created node ${nodeId}. Creating connection to target node...` });
+        const spec = parseConnectTo(options.connectTo);
+        const targetNode = versionNodes.find((n) => n.id === spec.nodeId);
+        if (!targetNode) {
+            throw new Error(`Target node ${spec.nodeId} not found in workflow version`);
+        }
+        const connResult = await api.createWorkflowConnection({
+            source_node_id: nodeId,
+            target_node_id: spec.nodeId,
+            source_output_key: 'output',
+            target_input_key: spec.inputKey,
+            connection_type: 'data'
+        });
+        if (connResult?.success) {
+            connectionsCreated.push(`${nodeId}:output → ${spec.nodeId}:${spec.inputKey}`);
+        }
+    }
+    setState({ status: 'downloading', message: `Created node with ID ${nodeId}. Downloading workflow...` });
+    await downloadWorkflowById(api, workflow.id, outputPath);
+    const connectionMsg = connectionsCreated.length > 0
+        ? ` Connections: ${connectionsCreated.join(', ')}.`
+        : '';
+    setState({
+        status: 'complete',
+        message: `Node "${title}" created in workflow "${workflow.name}" v${version.version_number}!${connectionMsg}`,
+        createdId: nodeId
+    });
+}
+async function createWorkflowConnection(api, options, outputPath, setState) {
+    if (!options.workflow) {
+        throw new Error('--workflow is required (workflow name or ID)');
+    }
+    if (!options.from) {
+        throw new Error('--from is required (source node ID)');
+    }
+    if (!options.to) {
+        throw new Error('--to is required (target node ID)');
+    }
+    const sourceNodeId = parseInt(options.from, 10);
+    const targetNodeId = parseInt(options.to, 10);
+    if (isNaN(sourceNodeId)) {
+        throw new Error(`Invalid source node ID: ${options.from}`);
+    }
+    if (isNaN(targetNodeId)) {
+        throw new Error(`Invalid target node ID: ${options.to}`);
+    }
+    setState({ status: 'loading', message: 'Finding workflow and validating nodes...' });
+    const workflows = await api.fetchTable('bfy_workflows');
+    const workflow = workflows.find((w) => w.id.toString() === options.workflow ||
+        w.name.toLowerCase() === options.workflow?.toLowerCase());
+    if (!workflow) {
+        throw new Error(`Workflow not found: ${options.workflow}`);
+    }
+    const versions = await api.fetchTable('bfy_workflow_versions');
+    let version;
+    if (options.version) {
+        version = versions.find((v) => v.bfy_workflow_id === workflow.id &&
+            (v.id.toString() === options.version || v.version_number.toString() === options.version));
+    }
+    else {
+        const workflowVersions = versions.filter((v) => v.bfy_workflow_id === workflow.id);
+        version = workflowVersions.sort((a, b) => b.version_number - a.version_number)[0];
+    }
+    if (!version) {
+        throw new Error(`No version found for workflow: ${options.workflow}`);
+    }
+    const nodes = await api.fetchTable('bfy_workflow_nodes');
+    const versionNodes = nodes.filter((n) => n.bfy_workflow_version_id === version.id);
+    const sourceNode = versionNodes.find((n) => n.id === sourceNodeId);
+    const targetNode = versionNodes.find((n) => n.id === targetNodeId);
+    if (!sourceNode) {
+        throw new Error(`Source node ${sourceNodeId} not found in workflow "${workflow.name}" v${version.version_number}`);
+    }
+    if (!targetNode) {
+        throw new Error(`Target node ${targetNodeId} not found in workflow "${workflow.name}" v${version.version_number}`);
+    }
+    setState({ status: 'creating', message: `Creating connection from "${sourceNode.title}" to "${targetNode.title}"...` });
+    const sourceOutputKey = options.fromOutput || 'output';
+    const targetInputKey = options.toInput || 'input';
+    const connResult = await api.createWorkflowConnection({
+        source_node_id: sourceNodeId,
+        target_node_id: targetNodeId,
+        source_output_key: sourceOutputKey,
+        target_input_key: targetInputKey,
+        connection_type: 'data'
+    });
+    if (!connResult?.success) {
+        throw new Error(connResult?.error || connResult?.message || 'Failed to create connection');
+    }
+    setState({ status: 'downloading', message: `Connection created. Downloading workflow...` });
+    await downloadWorkflowById(api, workflow.id, outputPath);
+    setState({
+        status: 'complete',
+        message: `Connection created: "${sourceNode.title}":${sourceOutputKey} → "${targetNode.title}":${targetInputKey}`,
+        createdId: connResult.id
+    });
+}
+async function downloadWorkflowById(api, workflowId, outputPath) {
+    const [workflows, versions, nodes, connections] = await Promise.all([
+        api.fetchTable('bfy_workflows'),
+        api.fetchTable('bfy_workflow_versions'),
+        api.fetchTable('bfy_workflow_nodes'),
+        api.fetchTable('bfy_workflow_connections')
+    ]);
+    const workflow = workflows.find((w) => w.id === workflowId);
+    if (!workflow) {
+        throw new Error(`Workflow with ID ${workflowId} not found`);
+    }
+    const relatedVersions = versions.filter((v) => v.bfy_workflow_id === workflowId);
+    const versionIds = relatedVersions.map((v) => v.id);
+    const relatedNodes = nodes.filter((n) => versionIds.includes(n.bfy_workflow_version_id));
+    const nodeIds = relatedNodes.map((n) => n.id);
+    const relatedConnections = connections.filter((c) => nodeIds.includes(c.source_node_id) || nodeIds.includes(c.target_node_id));
+    await saveWorkflowData(outputPath, workflow, relatedVersions, relatedNodes, relatedConnections);
+}
+export default async function addCommand(options) {
+    const config = await loadAuthConfig();
+    if (!config) {
+        console.error('No authentication configured. Run "butterfly-cli setup" first.');
+        process.exit(1);
+    }
+    const api = new ButterflyAPI(config);
+    await api.authenticate();
+    if (api.needs2FA)
+        await api.complete2FA();
+    render(React.createElement(AddCommand, { options: options, api: api }));
+}
+//# sourceMappingURL=add.js.map

package/dist/commands/code.d.ts

@@ -0,0 +1,11 @@
+interface CodeCommandOptions {
+    code?: string;
+    file?: string;
+    output?: string;
+    vars?: boolean;
+    outputOnly?: boolean;
+    raw?: boolean;
+}
+export default function codeCommand(options: CodeCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=code.d.ts.map

package/dist/commands/code.js

@@ -0,0 +1,72 @@
+import { promises as fs } from 'fs';
+import { loadAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+export default async function codeCommand(options) {
+    try {
+        if (!options.code && !options.file) {
+            console.error('ERROR: Either --code or --file is required');
+            process.exit(1);
+        }
+        if (options.code && options.file) {
+            console.error('ERROR: Cannot use both --code and --file together');
+            process.exit(1);
+        }
+        let code;
+        if (options.file) {
+            try {
+                code = await fs.readFile(options.file, 'utf-8');
+            }
+            catch (error) {
+                console.error(`ERROR: Failed to read file: ${error.message}`);
+                process.exit(1);
+            }
+        }
+        else {
+            code = options.code;
+        }
+        const config = await loadAuthConfig();
+        if (!config) {
+            console.error('ERROR: No authentication configured. Run "butterfly-cli setup" first.');
+            process.exit(1);
+        }
+        const api = new ButterflyAPI(config);
+        await api.authenticate();
+        if (api.needs2FA)
+            await api.complete2FA();
+        const result = await api.executeCode(code);
+        if (!result.success) {
+            console.error(`ERROR: ${result.error || 'Code execution failed'}`);
+            process.exit(1);
+        }
+        let outputData;
+        if (options.vars) {
+            outputData = result.vars;
+        }
+        else if (options.outputOnly) {
+            outputData = result.output;
+        }
+        else {
+            outputData = {
+                success: result.success,
+                vars: result.vars,
+                output: result.output
+            };
+        }
+        const outputStr = options.raw && typeof outputData === 'string'
+            ? outputData
+            : JSON.stringify(outputData, null, 2);
+        if (options.output) {
+            await fs.writeFile(options.output, outputStr, 'utf-8');
+            console.log(`SUCCESS: Output saved to ${options.output}`);
+        }
+        else {
+            console.log(outputStr);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(`ERROR: ${error.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=code.js.map

package/dist/commands/create-object.d.ts

@@ -0,0 +1,6 @@
+interface CreateObjectOptions {
+    file: string;
+}
+declare const _default: (options: CreateObjectOptions) => void;
+export default _default;
+//# sourceMappingURL=create-object.d.ts.map