@rglabs/butterfly 2.0.1

package/dist/commands/diff.js

@@ -0,0 +1,238 @@
+import React, { useEffect, useState } from 'react';
+import { render, Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { join } from 'path';
+import { loadAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+import { UploadHandler } from '../utils/uploadHandler.js';
+import { saveObjectWithSpecs, saveReportData } from '../utils/files.js';
+import { DiffEngine } from '../diff/engine.js';
+import { DiffView } from '../components/DiffView.js';
+import { ConflictResolver } from '../components/ConflictResolver.js';
+const DiffCommand = ({ options, api: apiProp }) => {
+    const [state, setState] = useState({
+        status: 'loading',
+        message: 'Loading configuration...',
+        diffs: [],
+        currentIndex: 0,
+        applied: { kept: 0, taken: 0, skipped: 0 }
+    });
+    const api = apiProp;
+    const [engine] = useState(() => new DiffEngine());
+    const [remoteData, setRemoteData] = useState(new Map());
+    const [showDetails, setShowDetails] = useState(false);
+    useEffect(() => {
+        const run = async () => {
+            try {
+                const basePath = options.output || './butterfly-resources';
+                setState(s => ({ ...s, status: 'comparing', message: 'Comparing resources...' }));
+                const diffs = await engine.diff(apiProp, basePath, options, {
+                    onLoadingLocal: (type) => setState(s => ({
+                        ...s,
+                        status: 'fetching_local',
+                        message: `Loading local ${type}...`
+                    })),
+                    onFetchingRemote: (type) => setState(s => ({
+                        ...s,
+                        status: 'fetching_remote',
+                        message: `Fetching remote ${type}...`
+                    })),
+                    onComparing: (type) => setState(s => ({
+                        ...s,
+                        status: 'comparing',
+                        message: `Comparing ${type}...`
+                    }))
+                });
+                const adapters = engine.getAdapters();
+                const remoteDataMap = new Map();
+                for (const [type, adapter] of adapters) {
+                    if (options.type && type !== options.type)
+                        continue;
+                    const remote = await adapter.fetchRemote(apiProp);
+                    remoteDataMap.set(type, remote);
+                }
+                setRemoteData(remoteDataMap);
+                if (diffs.length === 0) {
+                    setState(s => ({
+                        ...s,
+                        status: 'no_changes',
+                        message: 'No differences found!'
+                    }));
+                    setTimeout(() => process.exit(0), 2000);
+                    return;
+                }
+                setState(s => ({
+                    ...s,
+                    status: 'reviewing',
+                    message: '',
+                    diffs
+                }));
+            }
+            catch (error) {
+                setState(s => ({
+                    ...s,
+                    status: 'error',
+                    message: error instanceof Error ? error.message : 'Unknown error'
+                }));
+                setTimeout(() => process.exit(1), 3000);
+            }
+        };
+        run();
+    }, []);
+    const handleResolve = async (action) => {
+        const currentDiff = state.diffs[state.currentIndex];
+        const newApplied = { ...state.applied };
+        const basePath = options.output || './butterfly-resources';
+        if (action === 'keep_local' && api && currentDiff.localPath) {
+            setState(s => ({ ...s, status: 'applying' }));
+            try {
+                const handler = new UploadHandler(api);
+                if (currentDiff.resourceType === 'objects') {
+                    await handler.uploadFile(join(currentDiff.localPath, 'object.json'));
+                    for (const childDiff of currentDiff.children || []) {
+                        if (childDiff.status !== 'remote_only' && childDiff.resourceName) {
+                            const specPath = join(currentDiff.localPath, childDiff.resourceName, 'spec.json');
+                            try {
+                                await handler.uploadFile(specPath);
+                            }
+                            catch {
+                            }
+                        }
+                    }
+                }
+                else if (currentDiff.resourceType === 'reports') {
+                    await handler.uploadFile(join(currentDiff.localPath, 'report.json'));
+                    for (const childDiff of currentDiff.children || []) {
+                        if (childDiff.status !== 'remote_only' && childDiff.resourceName) {
+                            if (childDiff.resourceType === 'cms_report_queries') {
+                                const queryPath = join(currentDiff.localPath, 'queries', childDiff.resourceName, 'query.json');
+                                try {
+                                    await handler.uploadFile(queryPath);
+                                }
+                                catch {
+                                }
+                            }
+                            else if (childDiff.resourceType === 'cms_report_specs') {
+                                const specPath = join(currentDiff.localPath, 'specs', childDiff.resourceName, 'spec.json');
+                                try {
+                                    await handler.uploadFile(specPath);
+                                }
+                                catch {
+                                }
+                            }
+                        }
+                    }
+                }
+                newApplied.kept++;
+            }
+            catch (error) {
+                console.error('Error uploading:', error);
+            }
+        }
+        else if (action === 'take_remote' && api) {
+            setState(s => ({ ...s, status: 'applying' }));
+            try {
+                const typeRemoteData = remoteData.get(currentDiff.resourceType);
+                const remoteResource = typeRemoteData?.get(currentDiff.resourceId);
+                if (remoteResource) {
+                    if (currentDiff.resourceType === 'objects') {
+                        await saveObjectWithSpecs(basePath, remoteResource.main.table_name, remoteResource.main, remoteResource.children?.specs || []);
+                    }
+                    else if (currentDiff.resourceType === 'reports') {
+                        await saveReportData(basePath, remoteResource.main, remoteResource.children?.specs || [], remoteResource.children?.queries || [], []);
+                    }
+                }
+                newApplied.taken++;
+            }
+            catch (error) {
+                console.error('Error downloading:', error);
+            }
+        }
+        else {
+            newApplied.skipped++;
+        }
+        const nextIndex = state.currentIndex + 1;
+        setShowDetails(false);
+        if (nextIndex < state.diffs.length) {
+            setState(s => ({
+                ...s,
+                status: 'reviewing',
+                currentIndex: nextIndex,
+                applied: newApplied
+            }));
+        }
+        else {
+            setState(s => ({
+                ...s,
+                status: 'complete',
+                applied: newApplied,
+                message: ''
+            }));
+            setTimeout(() => process.exit(0), 3000);
+        }
+    };
+    const summary = engine.getSummary(state.diffs);
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, "Butterfly CLI - Diff")),
+        (state.status === 'loading' ||
+            state.status === 'fetching_local' ||
+            state.status === 'fetching_remote' ||
+            state.status === 'comparing') && (React.createElement(Box, null,
+            React.createElement(Text, { color: "yellow" },
+                React.createElement(Spinner, { type: "dots" }),
+                " "),
+            React.createElement(Text, null, state.message))),
+        state.status === 'no_changes' && (React.createElement(Box, null,
+            React.createElement(Text, { color: "green" }, "No differences found between local and remote resources."))),
+        state.status === 'reviewing' && state.diffs[state.currentIndex] && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "gray" },
+                    "Found ",
+                    summary.totalResources,
+                    " differences: ",
+                    summary.modified,
+                    " modified, ",
+                    summary.localOnly,
+                    " local only, ",
+                    summary.remoteOnly,
+                    " remote only")),
+            React.createElement(DiffView, { diff: state.diffs[state.currentIndex], currentIndex: state.currentIndex, totalCount: state.diffs.length, showDetails: showDetails }),
+            React.createElement(ConflictResolver, { diff: state.diffs[state.currentIndex], onResolve: handleResolve, onShowDetails: () => setShowDetails(true), isApplying: false }))),
+        state.status === 'applying' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(DiffView, { diff: state.diffs[state.currentIndex], currentIndex: state.currentIndex, totalCount: state.diffs.length }),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "blue" },
+                    React.createElement(Spinner, { type: "dots" }),
+                    " "),
+                React.createElement(Text, null, "Applying changes...")))),
+        state.status === 'complete' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true, color: "green" }, "Diff complete!"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, null,
+                    "  Kept local (uploaded): ",
+                    state.applied.kept),
+                React.createElement(Text, null,
+                    "  Took remote (downloaded): ",
+                    state.applied.taken),
+                React.createElement(Text, null,
+                    "  Skipped: ",
+                    state.applied.skipped)))),
+        state.status === 'error' && (React.createElement(Box, null,
+            React.createElement(Text, { color: "red" },
+                "Error: ",
+                state.message)))));
+};
+export default async (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(DiffCommand, { options: options, api: api }));
+};
+//# sourceMappingURL=diff.js.map

package/dist/commands/download.d.ts

@@ -0,0 +1,4 @@
+import { DownloadOptions } from '../types/index.js';
+declare const _default: (options: DownloadOptions) => Promise<void>;
+export default _default;
+//# sourceMappingURL=download.d.ts.map

package/dist/commands/download.js

@@ -0,0 +1,374 @@
+import React, { useEffect, useState } from 'react';
+import { render, Box, Text } from 'ink';
+import { join } from 'path';
+import { DownloadProgress } from '../components/DownloadProgress.js';
+import { loadAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+import { saveResource, saveObjectWithSpecs, saveReportData, saveAiTask, saveTableRecord, saveStateMachineData, saveWorkflowData, cleanupDirectory } from '../utils/files.js';
+import { generateTableSummary } from '../utils/summaryGenerator.js';
+import { LockManager } from '../utils/lockManager.js';
+async function downloadTableWithSpecs(api, outputPath, tableName, specsTableName, parentIdColumn, setProgress, filter) {
+    let allRecords;
+    if (filter) {
+        allRecords = await api.fetchTable(tableName, filter.column, filter.value);
+    }
+    else {
+        allRecords = await api.fetchTable(tableName);
+    }
+    const allSpecs = await api.fetchTable(specsTableName);
+    const specsByParentId = new Map();
+    allSpecs.forEach(spec => {
+        const parentId = spec[parentIdColumn];
+        if (!specsByParentId.has(parentId)) {
+            specsByParentId.set(parentId, []);
+        }
+        specsByParentId.get(parentId).push(spec);
+    });
+    setProgress({ current: 0, total: allRecords.length });
+    const batchSize = 5;
+    for (let i = 0; i < allRecords.length; i += batchSize) {
+        const batch = allRecords.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (record) => {
+            const specs = specsByParentId.get(record.id) || [];
+            await saveObjectWithSpecs(outputPath, record.table_name || tableName, record, specs);
+        }));
+        setProgress({ current: Math.min(i + batchSize, allRecords.length), total: allRecords.length });
+    }
+}
+async function downloadObjects(api, outputPath, setProgress, includeCore = false) {
+    await downloadTableWithSpecs(api, outputPath, 'objects', 'object_specs', 'object_id', setProgress, { column: 'is_cms_object', value: '0' });
+    if (includeCore) {
+        await downloadTableWithSpecs(api, outputPath, 'objects', 'object_specs', 'object_id', setProgress, { column: 'is_cms_object', value: '1' });
+    }
+}
+async function downloadPages(api, outputPath, setProgress) {
+    const pages = await api.fetchTable('pages');
+    setProgress({ current: 0, total: pages.length });
+    const batchSize = 5;
+    for (let i = 0; i < pages.length; i += batchSize) {
+        const batch = pages.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (page) => {
+            await saveTableRecord(outputPath, 'pages', page);
+        }));
+        setProgress({ current: Math.min(i + batchSize, pages.length), total: pages.length });
+    }
+}
+async function downloadReports(api, outputPath, setProgress) {
+    const reports = await api.fetchTable('cms_reports');
+    const categories = await api.fetchTable('cms_report_categories');
+    const allSpecs = await api.fetchTable('cms_report_specs');
+    const allQueries = await api.fetchTable('cms_report_queries');
+    const specsByReportId = new Map();
+    allSpecs.forEach(spec => {
+        const reportId = spec.cms_report_id;
+        if (!specsByReportId.has(reportId)) {
+            specsByReportId.set(reportId, []);
+        }
+        specsByReportId.get(reportId).push(spec);
+    });
+    const queriesByReportId = new Map();
+    allQueries.forEach(query => {
+        const reportId = query.cms_report_id;
+        if (!queriesByReportId.has(reportId)) {
+            queriesByReportId.set(reportId, []);
+        }
+        queriesByReportId.get(reportId).push(query);
+    });
+    setProgress({ current: 0, total: reports.length });
+    const batchSize = 5;
+    for (let i = 0; i < reports.length; i += batchSize) {
+        const batch = reports.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (report) => {
+            const specs = specsByReportId.get(report.id) || [];
+            const queries = queriesByReportId.get(report.id) || [];
+            await saveReportData(outputPath, report, specs, queries, categories);
+        }));
+        setProgress({ current: Math.min(i + batchSize, reports.length), total: reports.length });
+    }
+}
+async function downloadAiTasks(api, outputPath, setProgress) {
+    const aiTasks = await api.fetchTable('bfy_ai_tasks');
+    setProgress({ current: 0, total: aiTasks.length });
+    const batchSize = 5;
+    for (let i = 0; i < aiTasks.length; i += batchSize) {
+        const batch = aiTasks.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (task) => {
+            await saveAiTask(outputPath, task);
+        }));
+        setProgress({ current: Math.min(i + batchSize, aiTasks.length), total: aiTasks.length });
+    }
+}
+async function downloadStateMachines(api, outputPath, setProgress) {
+    const [stateMachines, states, roles, transitions, transitionSpecs, actions, actionSpecs, transitionActions] = await Promise.all([
+        api.fetchTable('bfy_state_machines'),
+        api.fetchTable('bfy_state_machine_states'),
+        api.fetchTable('bfy_state_machine_roles'),
+        api.fetchTable('bfy_state_machine_transitions'),
+        api.fetchTable('bfy_state_machine_transition_specs'),
+        api.fetchTable('bfy_sm_actions'),
+        api.fetchTable('bfy_sm_action_specs'),
+        api.fetchTable('bfy_sm_transition_actions')
+    ]);
+    setProgress({ current: 0, total: stateMachines.length });
+    const batchSize = 3;
+    for (let i = 0; i < stateMachines.length; i += batchSize) {
+        const batch = stateMachines.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (stateMachine) => {
+            const relatedStates = states.filter(s => s.bfy_state_machine_id === stateMachine.id);
+            const relatedRoles = roles.filter(r => r.bfy_state_machine_id === stateMachine.id);
+            const relatedTransitions = transitions.filter(t => t.bfy_state_machine_id === stateMachine.id);
+            const relatedActions = actions.filter(a => a.bfy_state_machine_id === stateMachine.id);
+            const transitionIds = relatedTransitions.map(t => t.id);
+            const actionIds = relatedActions.map(a => a.id);
+            const relatedTransitionSpecs = transitionSpecs.filter(spec => transitionIds.includes(spec.bfy_state_machine_transition_id));
+            const relatedActionSpecs = actionSpecs.filter(spec => actionIds.includes(spec.bfy_sm_action_id));
+            const relatedTransitionActions = transitionActions.filter(ta => transitionIds.includes(ta.bfy_state_machine_transition_id) &&
+                actionIds.includes(ta.bfy_sm_action_id));
+            await saveStateMachineData(outputPath, stateMachine, relatedStates, relatedRoles, relatedTransitions, relatedTransitionSpecs, relatedActions, relatedActionSpecs, relatedTransitionActions);
+        }));
+        setProgress({ current: Math.min(i + batchSize, stateMachines.length), total: stateMachines.length });
+    }
+}
+async function downloadCronjobs(api, outputPath, setProgress) {
+    const cronjobs = await api.fetchTable('bfy_cronjobs');
+    setProgress({ current: 0, total: cronjobs.length });
+    const batchSize = 5;
+    for (let i = 0; i < cronjobs.length; i += batchSize) {
+        const batch = cronjobs.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (cronjob) => {
+            await saveTableRecord(outputPath, 'bfy_cronjobs', cronjob);
+        }));
+        setProgress({ current: Math.min(i + batchSize, cronjobs.length), total: cronjobs.length });
+    }
+}
+async function downloadEmailTemplates(api, outputPath, setProgress) {
+    const emailTemplates = await api.fetchTable('cms_email_templates');
+    setProgress({ current: 0, total: emailTemplates.length });
+    const batchSize = 5;
+    for (let i = 0; i < emailTemplates.length; i += batchSize) {
+        const batch = emailTemplates.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (template) => {
+            await saveTableRecord(outputPath, 'cms_email_templates', template);
+        }));
+        setProgress({ current: Math.min(i + batchSize, emailTemplates.length), total: emailTemplates.length });
+    }
+}
+async function downloadPdfTemplates(api, outputPath, setProgress) {
+    const pdfTemplates = await api.fetchTable('pdf_templates');
+    setProgress({ current: 0, total: pdfTemplates.length });
+    const batchSize = 5;
+    for (let i = 0; i < pdfTemplates.length; i += batchSize) {
+        const batch = pdfTemplates.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (template) => {
+            await saveTableRecord(outputPath, 'pdf_templates', template);
+        }));
+        setProgress({ current: Math.min(i + batchSize, pdfTemplates.length), total: pdfTemplates.length });
+    }
+}
+async function downloadEmailLayouts(api, outputPath, setProgress) {
+    try {
+        const emailLayouts = await api.fetchTable('cms_email_layouts');
+        setProgress({ current: 0, total: emailLayouts.length });
+        const batchSize = 5;
+        for (let i = 0; i < emailLayouts.length; i += batchSize) {
+            const batch = emailLayouts.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (layout) => {
+                await saveTableRecord(outputPath, 'cms_email_layouts', layout);
+            }));
+            setProgress({ current: Math.min(i + batchSize, emailLayouts.length), total: emailLayouts.length });
+        }
+    }
+    catch (error) {
+        setProgress({ current: 0, total: 0 });
+    }
+}
+async function downloadWebservices(api, outputPath, setProgress) {
+    const webservices = await api.fetchTable('webservices');
+    setProgress({ current: 0, total: webservices.length });
+    const batchSize = 5;
+    for (let i = 0; i < webservices.length; i += batchSize) {
+        const batch = webservices.slice(i, i + batchSize);
+        await Promise.all(batch.map(async (webservice) => {
+            await saveTableRecord(outputPath, 'webservices', webservice);
+        }));
+        setProgress({ current: Math.min(i + batchSize, webservices.length), total: webservices.length });
+    }
+}
+async function downloadWorkflows(api, outputPath, setProgress) {
+    try {
+        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')
+        ]);
+        setProgress({ current: 0, total: workflows.length });
+        const batchSize = 3;
+        for (let i = 0; i < workflows.length; i += batchSize) {
+            const batch = workflows.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (workflow) => {
+                const relatedVersions = versions.filter(v => v.bfy_workflow_id === workflow.id);
+                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);
+            }));
+            setProgress({ current: Math.min(i + batchSize, workflows.length), total: workflows.length });
+        }
+    }
+    catch (error) {
+        setProgress({ current: 0, total: 0 });
+    }
+}
+async function downloadTranslations(api, outputPath, setProgress) {
+    const { promises: fs } = await import('fs');
+    const yaml = await import('yaml');
+    const [languages, sourceTexts, translations] = await Promise.all([
+        api.fetchTable('bfy_languages'),
+        api.fetchTable('bfy_translation_texts'),
+        api.fetchTable('bfy_translations'),
+    ]);
+    const sourceTextMap = new Map();
+    sourceTexts.forEach((t) => sourceTextMap.set(t.id, t.source));
+    const translationsByLanguage = new Map();
+    translations.forEach((t) => {
+        if (!translationsByLanguage.has(t.bfy_language_id)) {
+            translationsByLanguage.set(t.bfy_language_id, new Map());
+        }
+        translationsByLanguage.get(t.bfy_language_id).set(t.bfy_translation_text_id, t.text);
+    });
+    const translationsDir = join(outputPath, 'translations');
+    await fs.mkdir(translationsDir, { recursive: true });
+    setProgress({ current: 0, total: languages.length });
+    for (let i = 0; i < languages.length; i++) {
+        const lang = languages[i];
+        const langTranslations = translationsByLanguage.get(lang.id) || new Map();
+        const translationData = {};
+        sourceTexts.forEach((sourceText) => {
+            const translated = langTranslations.get(sourceText.id);
+            translationData[sourceText.source] = translated || '';
+        });
+        const yamlContent = [
+            `# ${lang.name} (${lang.iso_code})`,
+            `# Language ID: ${lang.id}`,
+            `# Total strings: ${sourceTexts.length}`,
+            `# Translated: ${langTranslations.size}`,
+            `# Untranslated: ${sourceTexts.length - langTranslations.size}`,
+            '',
+            yaml.stringify(translationData, {
+                lineWidth: 0,
+                defaultStringType: 'QUOTE_DOUBLE',
+                sortMapEntries: true,
+            }),
+        ].join('\n');
+        const filePath = join(translationsDir, `${lang.iso_code}.yaml`);
+        await fs.writeFile(filePath, yamlContent, 'utf-8');
+        setProgress({ current: i + 1, total: languages.length });
+    }
+}
+const DownloadCommand = ({ options, api, isCore }) => {
+    const [status, setStatus] = useState('loading');
+    const [error, setError] = useState('');
+    const [progress, setProgress] = useState({ current: 0, total: 0 });
+    useEffect(() => {
+        const download = async () => {
+            try {
+                await LockManager.acquireLock('download');
+                LockManager.setupCleanup();
+                setStatus('downloading');
+                let resourceTypes = options.type ? [options.type] : ['objects'];
+                if (!options.type) {
+                    resourceTypes = ['objects', 'reports', 'bfy_ai_tasks', 'bfy_state_machines', 'pages', 'bfy_cronjobs', 'cms_email_templates', 'pdf_templates', 'cms_email_layouts', 'bfy_workflows', 'webservices', 'translations'];
+                }
+                const outputPath = options.output || './butterfly-resources';
+                if (options.cleanup) {
+                    if (options.type) {
+                        await cleanupDirectory(join(outputPath, options.type));
+                    }
+                    else {
+                        await cleanupDirectory(outputPath);
+                    }
+                }
+                for (const type of resourceTypes) {
+                    if (type === 'objects') {
+                        await downloadObjects(api, outputPath, setProgress, isCore);
+                    }
+                    else if (type === 'reports') {
+                        await downloadReports(api, outputPath, setProgress);
+                    }
+                    else if (type === 'bfy_ai_tasks') {
+                        await downloadAiTasks(api, outputPath, setProgress);
+                    }
+                    else if (type === 'bfy_state_machines') {
+                        await downloadStateMachines(api, outputPath, setProgress);
+                    }
+                    else if (type === 'pages') {
+                        await downloadPages(api, outputPath, setProgress);
+                    }
+                    else if (type === 'bfy_cronjobs') {
+                        await downloadCronjobs(api, outputPath, setProgress);
+                    }
+                    else if (type === 'cms_email_templates') {
+                        await downloadEmailTemplates(api, outputPath, setProgress);
+                    }
+                    else if (type === 'pdf_templates') {
+                        await downloadPdfTemplates(api, outputPath, setProgress);
+                    }
+                    else if (type === 'cms_email_layouts') {
+                        await downloadEmailLayouts(api, outputPath, setProgress);
+                    }
+                    else if (type === 'bfy_workflows') {
+                        await downloadWorkflows(api, outputPath, setProgress);
+                    }
+                    else if (type === 'webservices') {
+                        await downloadWebservices(api, outputPath, setProgress);
+                    }
+                    else if (type === 'translations') {
+                        await downloadTranslations(api, outputPath, setProgress);
+                    }
+                    else {
+                        const resources = await api.downloadResource(type, options.name);
+                        setProgress({ current: 0, total: resources.length });
+                        for (let i = 0; i < resources.length; i++) {
+                            const resource = resources[i];
+                            await saveResource(outputPath, type, resource.name || resource.id || `${type}-${i}`, resource);
+                            setProgress({ current: i + 1, total: resources.length });
+                        }
+                    }
+                }
+                if (resourceTypes.includes('objects')) {
+                    await generateTableSummary(outputPath);
+                }
+                setStatus('complete');
+                await LockManager.releaseLock();
+                setTimeout(() => process.exit(0), 2000);
+            }
+            catch (err) {
+                await LockManager.releaseLock();
+                setError(err instanceof Error ? err.message : 'Unknown error');
+                setStatus('error');
+                setTimeout(() => process.exit(1), 3000);
+            }
+        };
+        download();
+    }, []);
+    return (React.createElement(Box, { flexDirection: "column" },
+        status === 'loading' && React.createElement(Text, { color: "yellow" }, "Loading configuration..."),
+        status === 'downloading' && (React.createElement(DownloadProgress, { resourceType: options.type || 'resources', current: progress.current, total: progress.total, status: "downloading" })),
+        status === 'complete' && (React.createElement(DownloadProgress, { resourceType: options.type || 'resources', current: progress.total, total: progress.total, status: "complete" })),
+        status === 'error' && (React.createElement(DownloadProgress, { resourceType: options.type || 'resources', current: 0, total: 0, status: "error", error: error }))));
+};
+export default async (options) => {
+    const config = await loadAuthConfig();
+    if (!config) {
+        console.error('No authentication configured. Please 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(DownloadCommand, { options: options, api: api, isCore: config.core || false }));
+};
+//# sourceMappingURL=download.js.map

package/dist/commands/layout.d.ts

@@ -0,0 +1,12 @@
+import { ButterflyAPI } from '../utils/api.js';
+interface LayoutCommandProps {
+    api: ButterflyAPI;
+    options: {
+        object?: string;
+        file?: string;
+        data?: string;
+    };
+}
+export default function layoutCommand(options: LayoutCommandProps['options']): Promise<void>;
+export {};
+//# sourceMappingURL=layout.d.ts.map