@rglabs/butterfly 2.0.1

package/dist/commands/layout.js

@@ -0,0 +1,83 @@
+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 { promises as fs } from 'fs';
+const LayoutCommand = ({ options, api }) => {
+    const [state, setState] = useState({ status: 'loading', message: 'Initializing...' });
+    useEffect(() => {
+        const run = async () => {
+            try {
+                let layoutData;
+                if (options.file) {
+                    setState({ status: 'loading', message: `Reading layout from file: ${options.file}` });
+                    const fileContent = await fs.readFile(options.file, 'utf-8');
+                    layoutData = JSON.parse(fileContent);
+                }
+                else if (options.data) {
+                    layoutData = JSON.parse(options.data);
+                }
+                else {
+                    setState({ status: 'error', message: 'Either --file or --data is required' });
+                    return;
+                }
+                if (!Array.isArray(layoutData)) {
+                    setState({ status: 'error', message: 'Layout data must be an array' });
+                    return;
+                }
+                setState({ status: 'updating', message: 'Updating layout order...' });
+                const response = await api.httpClient.post('/admin/ajax/cms_object_specs/edit_order', layoutData, {
+                    headers: { 'Content-Type': 'application/json' }
+                });
+                if (response.data?.success === false) {
+                    throw new Error(response.data?.error || response.data?.message || 'Failed to update layout');
+                }
+                let tabCount = 0;
+                let specCount = 0;
+                for (const position of layoutData) {
+                    tabCount += position.tabs?.length || 0;
+                    for (const tab of position.tabs || []) {
+                        specCount += tab.specs?.length || 0;
+                    }
+                }
+                setState({
+                    status: 'complete',
+                    message: `Layout updated successfully! (${tabCount} tabs, ${specCount} fields)`
+                });
+            }
+            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 === 'updating' && React.createElement(Text, { color: "blue" },
+            "\uD83D\uDD04 ",
+            state.message),
+        state.status === 'complete' && React.createElement(Text, { color: "green" },
+            "\u2713 ",
+            state.message),
+        state.status === 'error' && React.createElement(Text, { color: "red" },
+            "\u2717 ",
+            state.message)));
+};
+export default async function layoutCommand(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(LayoutCommand, { options: options, api: api }));
+}
+//# sourceMappingURL=layout.js.map

package/dist/commands/record.d.ts

@@ -0,0 +1,21 @@
+import { ButterflyAPI } from '../utils/api.js';
+interface RecordCommandProps {
+    operation: string;
+    table: string;
+    api: ButterflyAPI;
+    options: {
+        id?: string;
+        column?: string;
+        value?: string;
+        columns?: string;
+        data?: string;
+        file?: string;
+        dbAlias?: string;
+        preview?: boolean;
+        yes?: boolean;
+        output?: string;
+    };
+}
+export default function recordCommand(operation: string, table: string, options: RecordCommandProps['options']): Promise<void>;
+export {};
+//# sourceMappingURL=record.d.ts.map

package/dist/commands/record.js

@@ -0,0 +1,483 @@
+import React, { useEffect, useState } from 'react';
+import { render, Box, Text, useInput } from 'ink';
+import { promises as fs } from 'fs';
+import { loadAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+import { RecordPreview } from '../components/RecordPreview.js';
+import { downloadSingleResource, shouldTriggerDownload } from '../utils/singleResourceDownload.js';
+const VALID_OPERATIONS = ['get', 'add', 'edit', 'delete'];
+const RecordCommand = ({ operation, table, options, api: apiProp }) => {
+    const [state, setState] = useState({ status: 'loading', message: 'Initializing...' });
+    const api = apiProp;
+    useInput((input, key) => {
+        if (state.status === 'confirming') {
+            if (input.toLowerCase() === 'y' || key.return) {
+                executeOperation();
+            }
+            else if (input.toLowerCase() === 'n' || key.escape) {
+                setState({ status: 'cancelled', message: 'Operation cancelled by user.' });
+                setTimeout(() => process.exit(0), 500);
+            }
+        }
+    });
+    const executeOperation = async () => {
+        if (!api)
+            return;
+        const op = operation;
+        if (op === 'get') {
+            setState({ status: 'complete', message: 'Record retrieved successfully.' });
+            setTimeout(() => process.exit(0), 500);
+            return;
+        }
+        if (!state.data)
+            return;
+        setState({ ...state, status: 'executing', message: `Executing ${operation} on ${table}...` });
+        try {
+            const result = await api.performOperation(table, op, state.data, options.dbAlias);
+            if (result.xtra?.type === 'confirm') {
+                console.log('\n');
+                console.log('⚠️  CONFIRMATION REQUIRED');
+                console.log(`Message: ${result.xtra.message}`);
+                console.log(`\nTo confirm, re-run the command with the following parameter added to --data:`);
+                console.log(`  "confirm_message_${result.xtra.alias}": 1`);
+                console.log('\nExample:');
+                console.log(`  butterfly-cli record ${operation} ${table} --id ${state.data.id} --data '{..., "confirm_message_${result.xtra.alias}": 1}'`);
+                setState({
+                    status: 'complete',
+                    message: 'Operation requires confirmation. See details above.'
+                });
+                setTimeout(() => process.exit(0), 500);
+                return;
+            }
+            if (result.success) {
+                const recordId = result.id || state.data.id;
+                if (op === 'delete') {
+                    setState({
+                        status: 'complete',
+                        message: `Successfully deleted record (ID: ${state.data.id})`,
+                        resultId: state.data.id
+                    });
+                    setTimeout(() => process.exit(0), 1000);
+                    return;
+                }
+                if (shouldTriggerDownload(table)) {
+                    setState({
+                        ...state,
+                        status: 'downloading',
+                        message: `Operation successful. Syncing resource...`,
+                        resultId: recordId
+                    });
+                    const outputPath = './butterfly-resources';
+                    const downloadResult = await downloadSingleResource(api, outputPath, table, recordId, { ...state.data, id: recordId });
+                    if (downloadResult.success) {
+                        setState({
+                            status: 'complete',
+                            message: `Successfully ${op === 'add' ? 'added' : 'updated'} and synced${recordId ? ` (ID: ${recordId})` : ''}`,
+                            resultId: recordId
+                        });
+                    }
+                    else {
+                        setState({
+                            status: 'complete',
+                            message: `${op === 'add' ? 'Added' : 'Updated'} record${recordId ? ` (ID: ${recordId})` : ''} - sync warning: ${downloadResult.message}`,
+                            resultId: recordId
+                        });
+                    }
+                }
+                else {
+                    setState({
+                        status: 'complete',
+                        message: `Successfully ${op === 'add' ? 'added' : 'updated'} record${recordId ? ` (ID: ${recordId})` : ''}`,
+                        resultId: recordId
+                    });
+                }
+                setTimeout(() => process.exit(0), 1000);
+            }
+            else {
+                setState({
+                    status: 'error',
+                    message: result.error || result.message || 'Operation failed'
+                });
+                setTimeout(() => process.exit(1), 2000);
+            }
+        }
+        catch (error) {
+            setState({
+                status: 'error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+            setTimeout(() => process.exit(1), 2000);
+        }
+    };
+    useEffect(() => {
+        const run = async () => {
+            try {
+                const op = operation;
+                if (!VALID_OPERATIONS.includes(op)) {
+                    setState({
+                        status: 'error',
+                        message: `Invalid operation: ${operation}. Use: ${VALID_OPERATIONS.join(', ')}`
+                    });
+                    setTimeout(() => process.exit(1), 2000);
+                    return;
+                }
+                if ((op === 'edit' || op === 'delete') && !options.id) {
+                    setState({
+                        status: 'error',
+                        message: `--id is required for ${op} operation`
+                    });
+                    setTimeout(() => process.exit(1), 2000);
+                    return;
+                }
+                if ((options.column && !options.value) || (!options.column && options.value)) {
+                    setState({
+                        status: 'error',
+                        message: `--column and --value must be used together`
+                    });
+                    setTimeout(() => process.exit(1), 2000);
+                    return;
+                }
+                if ((op === 'add' || op === 'edit') && !options.data && !options.file) {
+                    setState({
+                        status: 'error',
+                        message: `--data or --file is required for ${op} operation`
+                    });
+                    setTimeout(() => process.exit(1), 2000);
+                    return;
+                }
+                let operationData = {};
+                if (options.file) {
+                    setState({ status: 'loading', message: `Reading data from ${options.file}...` });
+                    const fileContent = await fs.readFile(options.file, 'utf-8');
+                    operationData = JSON.parse(fileContent);
+                }
+                else if (options.data) {
+                    operationData = JSON.parse(options.data);
+                }
+                if (options.id) {
+                    operationData.id = parseInt(options.id, 10);
+                }
+                if (op === 'get') {
+                    let records;
+                    let fetchMessage;
+                    if (options.id) {
+                        fetchMessage = `Fetching record ${options.id} from ${table}...`;
+                        setState({ status: 'loading', message: fetchMessage });
+                        records = await apiProp.fetchTableAdvanced(table, {
+                            column: 'id',
+                            value: options.id,
+                            columns: options.columns,
+                            dbAlias: options.dbAlias
+                        });
+                    }
+                    else if (options.column && options.value) {
+                        fetchMessage = `Fetching records from ${table} where ${options.column}=${options.value}...`;
+                        setState({ status: 'loading', message: fetchMessage });
+                        records = await apiProp.fetchTableAdvanced(table, {
+                            column: options.column,
+                            value: options.value,
+                            columns: options.columns,
+                            dbAlias: options.dbAlias
+                        });
+                    }
+                    else {
+                        fetchMessage = `Fetching all records from ${table}...`;
+                        setState({ status: 'loading', message: fetchMessage });
+                        records = await apiProp.fetchTableAdvanced(table, {
+                            columns: options.columns,
+                            dbAlias: options.dbAlias
+                        });
+                    }
+                    if (records.length === 0) {
+                        const filterDesc = options.id
+                            ? `ID ${options.id}`
+                            : options.column
+                                ? `${options.column}=${options.value}`
+                                : 'no filter';
+                        setState({
+                            status: 'error',
+                            message: `No records found in ${table} (${filterDesc})`
+                        });
+                        setTimeout(() => process.exit(1), 2000);
+                        return;
+                    }
+                    const output = records.length === 1 ? records[0] : records;
+                    const countMsg = records.length === 1 ? '1 record' : `${records.length} records`;
+                    if (options.output) {
+                        await fs.writeFile(options.output, JSON.stringify(output, null, 2), 'utf-8');
+                        setState({
+                            status: 'complete',
+                            message: `${countMsg} saved to ${options.output}`,
+                            data: output
+                        });
+                        setTimeout(() => process.exit(0), 1000);
+                    }
+                    else {
+                        console.log('\n' + JSON.stringify(output, null, 2) + '\n');
+                        setState({
+                            status: 'complete',
+                            message: `Retrieved ${countMsg}.`,
+                            data: output
+                        });
+                        setTimeout(() => process.exit(0), 500);
+                    }
+                    return;
+                }
+                let existingRecord;
+                if ((op === 'edit' || op === 'delete') && options.id) {
+                    setState({ status: 'loading', message: `Fetching existing record...` });
+                    const record = await apiProp.fetchRecordById(table, parseInt(options.id, 10), options.dbAlias);
+                    if (record) {
+                        existingRecord = record;
+                    }
+                    else if (op === 'edit') {
+                        setState({
+                            status: 'error',
+                            message: `Record not found: ${table} with ID ${options.id}`
+                        });
+                        setTimeout(() => process.exit(1), 2000);
+                        return;
+                    }
+                }
+                if (options.preview === false || options.yes) {
+                    setState({
+                        status: 'executing',
+                        message: `Executing ${op} on ${table}...`,
+                        data: operationData,
+                        existingRecord
+                    });
+                    const result = await apiProp.performOperation(table, op, operationData, options.dbAlias);
+                    if (result.xtra?.type === 'confirm') {
+                        console.log('\n');
+                        console.log('⚠️  CONFIRMATION REQUIRED');
+                        console.log(`Message: ${result.xtra.message}`);
+                        console.log(`\nTo confirm, re-run the command with the following parameter added to --data:`);
+                        console.log(`  "confirm_message_${result.xtra.alias}": 1`);
+                        console.log('\nExample:');
+                        console.log(`  butterfly-cli record ${op} ${table} --id ${operationData.id} --data '{..., "confirm_message_${result.xtra.alias}": 1}'`);
+                        setState({
+                            status: 'complete',
+                            message: 'Operation requires confirmation. See details above.'
+                        });
+                        setTimeout(() => process.exit(0), 1000);
+                        return;
+                    }
+                    if (result.success) {
+                        const recordId = result.id || operationData.id;
+                        if (op !== 'delete' && shouldTriggerDownload(table) && recordId) {
+                            setState({
+                                status: 'downloading',
+                                message: `Syncing resource...`,
+                                resultId: recordId
+                            });
+                            const outputPath = './butterfly-resources';
+                            const downloadResult = await downloadSingleResource(apiProp, outputPath, table, recordId, { ...operationData, id: recordId });
+                            setState({
+                                status: 'complete',
+                                message: downloadResult.success
+                                    ? `Successfully ${op === 'add' ? 'added' : 'updated'} and synced (ID: ${recordId})`
+                                    : `${op === 'add' ? 'Added' : 'Updated'} record (ID: ${recordId}) - sync: ${downloadResult.message}`,
+                                resultId: recordId
+                            });
+                        }
+                        else {
+                            setState({
+                                status: 'complete',
+                                message: `Successfully ${op === 'add' ? 'added' : op === 'edit' ? 'updated' : 'deleted'} record${recordId ? ` (ID: ${recordId})` : ''}`,
+                                resultId: recordId
+                            });
+                        }
+                    }
+                    else {
+                        setState({
+                            status: 'error',
+                            message: result.error || result.message || 'Operation failed'
+                        });
+                    }
+                    setTimeout(() => process.exit(result.success ? 0 : 1), 1000);
+                    return;
+                }
+                setState({
+                    status: 'preview',
+                    message: '',
+                    data: operationData,
+                    existingRecord
+                });
+                setTimeout(() => {
+                    setState(prev => ({ ...prev, status: 'confirming' }));
+                }, 100);
+            }
+            catch (error) {
+                setState({
+                    status: 'error',
+                    message: error instanceof Error ? error.message : 'Unknown error'
+                });
+                setTimeout(() => process.exit(1), 2000);
+            }
+        };
+        run();
+    }, []);
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Text, { bold: true, color: "cyan" }, "Butterfly CLI - Record Operation"),
+        React.createElement(Text, null, " "),
+        state.status === 'loading' && (React.createElement(Text, { color: "yellow" },
+            "Loading... ",
+            state.message)),
+        (state.status === 'preview' || state.status === 'confirming') && state.data && (React.createElement(RecordPreview, { operation: operation, table: table, data: state.data, existingRecord: state.existingRecord })),
+        state.status === 'confirming' && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "yellow" }, "Proceed with this operation? (y/n): "))),
+        state.status === 'executing' && (React.createElement(Text, { color: "blue" },
+            "Executing... ",
+            state.message)),
+        state.status === 'downloading' && (React.createElement(Text, { color: "cyan" },
+            "Downloading... ",
+            state.message)),
+        state.status === 'complete' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" },
+                "SUCCESS: ",
+                state.message),
+            state.resultId && React.createElement(Text, { color: "gray" },
+                "  Record ID: ",
+                state.resultId))),
+        state.status === 'error' && (React.createElement(Text, { color: "red" },
+            "ERROR: ",
+            state.message)),
+        state.status === 'cancelled' && (React.createElement(Text, { color: "gray" }, state.message))));
+};
+async function runNonInteractive(operation, table, options) {
+    const op = operation;
+    if (!VALID_OPERATIONS.includes(op)) {
+        console.error(`ERROR: Invalid operation: ${operation}. Use: ${VALID_OPERATIONS.join(', ')}`);
+        process.exit(1);
+    }
+    if ((op === 'edit' || op === 'delete') && !options.id) {
+        console.error(`ERROR: --id is required for ${op} operation`);
+        process.exit(1);
+    }
+    if ((options.column && !options.value) || (!options.column && options.value)) {
+        console.error(`ERROR: --column and --value must be used together`);
+        process.exit(1);
+    }
+    if ((op === 'add' || op === 'edit') && !options.data && !options.file) {
+        console.error(`ERROR: --data or --file is required for ${op} operation`);
+        process.exit(1);
+    }
+    try {
+        let operationData = {};
+        if (options.file) {
+            const fileContent = await fs.readFile(options.file, 'utf-8');
+            operationData = JSON.parse(fileContent);
+        }
+        else if (options.data) {
+            operationData = JSON.parse(options.data);
+        }
+        if (options.id) {
+            operationData.id = parseInt(options.id, 10);
+        }
+        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();
+        if (op === 'get') {
+            let records;
+            if (options.id) {
+                records = await api.fetchTableAdvanced(table, {
+                    column: 'id',
+                    value: options.id,
+                    columns: options.columns,
+                    dbAlias: options.dbAlias
+                });
+            }
+            else if (options.column && options.value) {
+                records = await api.fetchTableAdvanced(table, {
+                    column: options.column,
+                    value: options.value,
+                    columns: options.columns,
+                    dbAlias: options.dbAlias
+                });
+            }
+            else {
+                records = await api.fetchTableAdvanced(table, {
+                    columns: options.columns,
+                    dbAlias: options.dbAlias
+                });
+            }
+            if (records.length === 0) {
+                console.error(`ERROR: No records found in ${table}`);
+                process.exit(1);
+            }
+            const output = records.length === 1 ? records[0] : records;
+            if (options.output) {
+                await fs.writeFile(options.output, JSON.stringify(output, null, 2), 'utf-8');
+                console.log(`SUCCESS: ${records.length} record(s) saved to ${options.output}`);
+            }
+            else {
+                console.log(JSON.stringify(output, null, 2));
+            }
+            process.exit(0);
+        }
+        const result = await api.performOperation(table, op, operationData, options.dbAlias);
+        if (result.xtra?.type === 'confirm') {
+            console.log('\n⚠️  CONFIRMATION REQUIRED');
+            console.log(`Message: ${result.xtra.message}`);
+            console.log(`\nTo confirm, re-run the command with the following parameter added to --data:`);
+            console.log(`  "confirm_message_${result.xtra.alias}": 1`);
+            console.log('\nExample:');
+            console.log(`  butterfly-cli record ${operation} ${table} --id ${operationData.id} --data '{..., "confirm_message_${result.xtra.alias}": 1}'`);
+            process.exit(0);
+        }
+        if (result.success) {
+            const recordId = result.id || operationData.id;
+            if (op !== 'delete' && shouldTriggerDownload(table) && recordId) {
+                const outputPath = './butterfly-resources';
+                const downloadResult = await downloadSingleResource(api, outputPath, table, recordId, { ...operationData, id: recordId });
+                if (downloadResult.success) {
+                    console.log(`SUCCESS: ${op} operation completed and synced (ID: ${recordId})`);
+                    if (downloadResult.downloadedResource) {
+                        console.log(`  Synced: ${downloadResult.downloadedResource.type}/${downloadResult.downloadedResource.name || downloadResult.downloadedResource.id}`);
+                    }
+                }
+                else {
+                    console.log(`SUCCESS: ${op} operation completed (ID: ${recordId})`);
+                    console.log(`  Sync warning: ${downloadResult.message}`);
+                }
+            }
+            else {
+                console.log(`SUCCESS: ${op} operation completed${recordId ? ` (ID: ${recordId})` : ''}`);
+            }
+            process.exit(0);
+        }
+        else {
+            console.error(`ERROR: ${result.error || result.message || 'Operation failed'}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`ERROR: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+}
+export default async function recordCommand(operation, table, options) {
+    const isNonInteractive = !process.stdin.isTTY || options.yes || options.preview === false;
+    if (isNonInteractive) {
+        await runNonInteractive(operation, table, options);
+    }
+    else {
+        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(RecordCommand, { operation: operation, table: table, options: options, api: api }));
+    }
+}
+//# sourceMappingURL=record.js.map

package/dist/commands/run-poc.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => void;
+export default _default;
+//# sourceMappingURL=run-poc.d.ts.map

package/dist/commands/run-poc.js

@@ -0,0 +1,18 @@
+import { spawnSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+const PROMPT_FILE = 'POC-Generator/prompts/00-master.md';
+export default () => {
+    const promptPath = path.join(process.cwd(), PROMPT_FILE);
+    if (!existsSync(promptPath)) {
+        console.error(`Prompt file not found: ${promptPath}`);
+        console.error(`Run 'butterfly-cli start-poc' first to clone the repository.`);
+        process.exit(1);
+    }
+    const promptContent = readFileSync(promptPath, 'utf-8');
+    spawnSync('claude', [promptContent], {
+        stdio: 'inherit',
+        cwd: process.cwd()
+    });
+};
+//# sourceMappingURL=run-poc.js.map

package/dist/commands/setup.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => Promise<void>;
+export default _default;
+//# sourceMappingURL=setup.d.ts.map