@rglabs/butterfly 2.0.1

package/dist/diff/adapters/types.d.ts

@@ -0,0 +1,19 @@
+import { ButterflyAPI } from '../../utils/api.js';
+import { ResourceDiff } from '../types.js';
+export interface LocalResource {
+    main: Record<string, any>;
+    children: Record<string, any[]>;
+    path: string;
+}
+export interface RemoteResource {
+    main: Record<string, any>;
+    children: Record<string, any[]>;
+}
+export interface ResourceAdapter {
+    readonly resourceType: string;
+    loadLocal(basePath: string): Promise<Map<number, LocalResource>>;
+    fetchRemote(api: ButterflyAPI): Promise<Map<number, RemoteResource>>;
+    compare(local: LocalResource | null, remote: RemoteResource | null, localPath?: string): ResourceDiff;
+    getDisplayName(data: Record<string, any>): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/diff/adapters/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/diff/engine.d.ts

@@ -0,0 +1,19 @@
+import { ButterflyAPI } from '../utils/api.js';
+import { ResourceDiff, DiffOptions, DiffSummary } from './types.js';
+import { ResourceAdapter } from './adapters/index.js';
+export interface DiffEngineCallbacks {
+    onProgress?: (message: string) => void;
+    onLoadingLocal?: (type: string) => void;
+    onFetchingRemote?: (type: string) => void;
+    onComparing?: (type: string) => void;
+}
+export declare class DiffEngine {
+    private adapters;
+    constructor();
+    getAdapters(): Map<string, ResourceAdapter>;
+    getSupportedTypes(): string[];
+    diff(api: ButterflyAPI, basePath: string, options?: DiffOptions, callbacks?: DiffEngineCallbacks): Promise<ResourceDiff[]>;
+    getSummary(diffs: ResourceDiff[]): DiffSummary;
+    groupByType(diffs: ResourceDiff[]): Map<string, ResourceDiff[]>;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/diff/engine.js

@@ -0,0 +1,57 @@
+import { calculateSummary } from './types.js';
+import { getAdapters } from './adapters/index.js';
+export class DiffEngine {
+    adapters;
+    constructor() {
+        this.adapters = getAdapters();
+    }
+    getAdapters() {
+        return this.adapters;
+    }
+    getSupportedTypes() {
+        return Array.from(this.adapters.keys());
+    }
+    async diff(api, basePath, options = {}, callbacks = {}) {
+        const results = [];
+        const typesToDiff = options.type
+            ? [options.type]
+            : Array.from(this.adapters.keys());
+        for (const type of typesToDiff) {
+            const adapter = this.adapters.get(type);
+            if (!adapter) {
+                continue;
+            }
+            callbacks.onLoadingLocal?.(type);
+            const local = await adapter.loadLocal(basePath);
+            callbacks.onFetchingRemote?.(type);
+            const remote = await adapter.fetchRemote(api);
+            callbacks.onComparing?.(type);
+            const allIds = new Set([...local.keys(), ...remote.keys()]);
+            for (const id of allIds) {
+                const localResource = local.get(id) || null;
+                const remoteResource = remote.get(id) || null;
+                const diff = adapter.compare(localResource, remoteResource);
+                if (options.name && diff.resourceName !== options.name) {
+                    continue;
+                }
+                if (diff.status !== 'unchanged') {
+                    results.push(diff);
+                }
+            }
+        }
+        return results;
+    }
+    getSummary(diffs) {
+        return calculateSummary(diffs);
+    }
+    groupByType(diffs) {
+        const grouped = new Map();
+        for (const diff of diffs) {
+            const existing = grouped.get(diff.resourceType) || [];
+            existing.push(diff);
+            grouped.set(diff.resourceType, existing);
+        }
+        return grouped;
+    }
+}
+//# sourceMappingURL=engine.js.map

package/dist/diff/types.d.ts

@@ -0,0 +1,34 @@
+export type DiffStatus = 'unchanged' | 'local_only' | 'remote_only' | 'modified';
+export interface FieldDiff {
+    field: string;
+    localValue: any;
+    remoteValue: any;
+    status: DiffStatus;
+}
+export interface ResourceDiff {
+    resourceType: string;
+    resourceName: string;
+    resourceId: number;
+    localPath?: string;
+    status: DiffStatus;
+    fieldDiffs: FieldDiff[];
+    children?: ResourceDiff[];
+}
+export interface DiffSummary {
+    totalResources: number;
+    unchanged: number;
+    modified: number;
+    localOnly: number;
+    remoteOnly: number;
+}
+export interface DiffOptions {
+    type?: string;
+    name?: string;
+    output?: string;
+}
+export declare const IGNORE_FIELDS: string[];
+export declare function valuesEqual(a: any, b: any): boolean;
+export declare function compareFields(local: Record<string, any> | null, remote: Record<string, any> | null, ignoreFields?: string[]): FieldDiff[];
+export declare function formatValue(value: any, maxLength?: number): string;
+export declare function calculateSummary(diffs: ResourceDiff[]): DiffSummary;
+//# sourceMappingURL=types.d.ts.map

package/dist/diff/types.js

@@ -0,0 +1,110 @@
+export const IGNORE_FIELDS = [
+    'updated_at',
+    'created_at',
+    'updated_by',
+    'created_by'
+];
+export function valuesEqual(a, b) {
+    if (a === null || a === undefined) {
+        return b === null || b === undefined;
+    }
+    if (b === null || b === undefined) {
+        return false;
+    }
+    if (typeof a !== 'object' && typeof b !== 'object') {
+        return String(a) === String(b);
+    }
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function isDefaultValue(value) {
+    return value === null || value === '' || value === 0 || value === '0';
+}
+export function compareFields(local, remote, ignoreFields = IGNORE_FIELDS) {
+    const diffs = [];
+    if (!local && !remote) {
+        return diffs;
+    }
+    const allFields = new Set([
+        ...Object.keys(local || {}),
+        ...Object.keys(remote || {})
+    ]);
+    for (const field of allFields) {
+        if (ignoreFields.includes(field))
+            continue;
+        const localVal = local?.[field];
+        const remoteVal = remote?.[field];
+        let status;
+        if (valuesEqual(localVal, remoteVal)) {
+            status = 'unchanged';
+        }
+        else if (localVal === undefined && isDefaultValue(remoteVal)) {
+            status = 'unchanged';
+        }
+        else if (remoteVal === undefined && isDefaultValue(localVal)) {
+            status = 'unchanged';
+        }
+        else if (localVal === undefined) {
+            status = 'remote_only';
+        }
+        else if (remoteVal === undefined) {
+            status = 'local_only';
+        }
+        else {
+            status = 'modified';
+        }
+        if (status !== 'unchanged') {
+            diffs.push({
+                field,
+                localValue: localVal,
+                remoteValue: remoteVal,
+                status
+            });
+        }
+    }
+    return diffs;
+}
+export function formatValue(value, maxLength = 60) {
+    if (value === null)
+        return '<null>';
+    if (value === undefined)
+        return '<undefined>';
+    if (typeof value === 'object') {
+        const json = JSON.stringify(value);
+        if (json.length > maxLength) {
+            return json.substring(0, maxLength) + '...';
+        }
+        return json;
+    }
+    const str = String(value);
+    if (str.length > maxLength) {
+        return str.substring(0, maxLength) + '...';
+    }
+    return str;
+}
+export function calculateSummary(diffs) {
+    const summary = {
+        totalResources: diffs.length,
+        unchanged: 0,
+        modified: 0,
+        localOnly: 0,
+        remoteOnly: 0
+    };
+    for (const diff of diffs) {
+        switch (diff.status) {
+            case 'unchanged':
+                summary.unchanged++;
+                break;
+            case 'modified':
+                summary.modified++;
+                break;
+            case 'local_only':
+                summary.localOnly++;
+                break;
+            case 'remote_only':
+                summary.remoteOnly++;
+                break;
+        }
+    }
+    return summary;
+}
+//# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { config } from 'dotenv';
+import setupCommand from './commands/setup.js';
+import downloadCommand from './commands/download.js';
+import uploadCommand from './commands/upload.js';
+import diffCommand from './commands/diff.js';
+import addCommand from './commands/add.js';
+import workflowInfoCommand from './commands/workflow-info.js';
+import recordCommand from './commands/record.js';
+import codeCommand from './commands/code.js';
+import layoutCommand from './commands/layout.js';
+import syncDocsCommand from './commands/sync-docs.js';
+import translateCommand from './commands/translate.js';
+config();
+program
+    .name('butterfly-cli')
+    .description('CLI tool to download resources from the Butterfly platform')
+    .version('2.0.1');
+program
+    .command('setup')
+    .description('Configure authentication for the Butterfly platform')
+    .action(setupCommand);
+program
+    .command('download')
+    .description('Download resources from the Butterfly platform')
+    .option('-t, --type <type>', 'Resource type to download (objects, reports, bfy_ai_tasks, bfy_state_machines, pages, bfy_cronjobs, cms_email_templates, cms_email_layouts, bfy_workflows, webservices, translations)')
+    .option('-n, --name <name>', 'Specific resource name to download')
+    .option('-o, --output <path>', 'Output directory path', './butterfly-resources')
+    .option('--cleanup', 'Clean existing contents before downloading')
+    .action(downloadCommand);
+program
+    .command('diff')
+    .description('Compare local resources with remote server and apply changes interactively')
+    .option('-t, --type <type>', 'Resource type to compare (objects, reports)')
+    .option('-n, --name <name>', 'Specific resource name to compare')
+    .option('-o, --output <path>', 'Base path', './butterfly-resources')
+    .action(diffCommand);
+program
+    .command('upload <targets...>')
+    .description('Upload files or folders to the Butterfly platform')
+    .action(uploadCommand);
+program
+    .command('add')
+    .description('Create new resources via API and download them')
+    .option('-t, --type <type>', 'Resource type to create (workflow, workflow-node, workflow-connection)')
+    .option('-w, --workflow <name>', 'Workflow name or ID (for workflow-node, workflow-connection)')
+    .option('-v, --version <number>', 'Version number (defaults to latest)')
+    .option('--title <title>', 'Title/name of the resource')
+    .option('--node-type <type>', 'Node identifier key (e.g., CustomScript, WebHook, RESTAPI)')
+    .option('--node-group <group>', 'Node group class (e.g., Code, Trigger, Connector, Output)')
+    .option('--system-name <name>', 'System name for the resource')
+    .option('--connect-from <spec>', 'Connect FROM existing node TO new node (format: node_id[:output_key])')
+    .option('--connect-to <spec>', 'Connect FROM new node TO existing node (format: node_id[:input_key])')
+    .option('--from <id>', 'Source node ID (for workflow-connection)')
+    .option('--from-output <key>', 'Source node output key (default: output)')
+    .option('--to <id>', 'Target node ID (for workflow-connection)')
+    .option('--to-input <key>', 'Target node input key (default: input)')
+    .option('-o, --output <path>', 'Output directory path', './butterfly-resources')
+    .action(addCommand);
+program
+    .command('workflow-info')
+    .description('Get information about workflow node groups and node types')
+    .option('--groups', 'List all available node groups')
+    .option('--nodes <group>', 'List nodes in a specific group (e.g., --nodes Database)')
+    .option('--details <node>', 'Get details for a specific node (requires --group)')
+    .option('--group <group>', 'Node group for --details option')
+    .action(workflowInfoCommand);
+program
+    .command('record <operation> <table>')
+    .description('Perform CRUD operations (get/add/edit/delete) on any Butterfly table with preview')
+    .option('--id <id>', 'Record ID (required for edit/delete, optional for get)')
+    .option('--column <column>', 'Filter column(s) for get (comma-separated for OR search, e.g., "name,title")')
+    .option('--value <value>', 'Filter value (use * for wildcard, e.g., "test*" for LIKE)')
+    .option('--columns <columns>', 'Select specific columns to return (comma-separated, e.g., "id,name,status")')
+    .option('--data <json>', 'JSON data for the operation')
+    .option('--file <path>', 'Path to JSON file with data')
+    .option('--db-alias <alias>', 'Database alias', 'default')
+    .option('--preview', 'Show preview before executing (default: true)', true)
+    .option('--no-preview', 'Skip preview and execute directly')
+    .option('-y, --yes', 'Auto-confirm without prompting')
+    .option('--output <path>', 'For get: save record(s) to file instead of stdout')
+    .action(recordCommand);
+program
+    .command('code')
+    .description('Execute Twig code on the server and retrieve variables/output')
+    .option('-c, --code <code>', 'Twig code to execute (inline)')
+    .option('-f, --file <path>', 'Path to file containing Twig code')
+    .option('-o, --output <path>', 'Save output to file instead of stdout')
+    .option('--vars', 'Output only the vars object')
+    .option('--output-only', 'Output only the output field')
+    .option('--raw', 'Output raw string (no JSON formatting) for --output-only')
+    .action(codeCommand);
+program
+    .command('layout')
+    .description('Update object page layout (tab and field ordering)')
+    .option('-f, --file <path>', 'Path to JSON file with layout data')
+    .option('-d, --data <json>', 'Inline JSON layout data')
+    .action(layoutCommand);
+program
+    .command('sync-docs')
+    .description('Sync documentation files from the CLI package to the project')
+    .action(syncDocsCommand);
+program
+    .command('translate <operation>')
+    .description('Manage translations (get-untranslated, add, bulk, languages)')
+    .option('--lang <iso_code>', 'Language ISO code (e.g., tr, de, en)')
+    .option('--lang-id <id>', 'Language ID')
+    .option('--source <text>', 'Source text to translate')
+    .option('--source-id <id>', 'Source text ID')
+    .option('--text <translation>', 'Translated text')
+    .option('-f, --file <path>', 'CSV file (tab-delimited) for bulk operations')
+    .option('--format <format>', 'Output format: json or table (default: table)')
+    .option('--limit <count>', 'Limit number of results')
+    .action(translateCommand);
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+export interface AuthConfig {
+    endpoint: string;
+    email: string;
+    password: string;
+    core?: boolean;
+}
+export interface DownloadOptions {
+    type?: string;
+    name?: string;
+    output?: string;
+    cleanup?: boolean;
+}
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/utils/api.d.ts

@@ -0,0 +1,85 @@
+import { AxiosInstance } from 'axios';
+import { AuthConfig } from '../types/index.js';
+export declare class ButterflyAPI {
+    private config;
+    private client;
+    private cookieJar;
+    private csrfToken?;
+    private lastValidated?;
+    private debug;
+    private pending2FAData;
+    private static readonly VALIDATION_CACHE_TTL;
+    constructor(config: AuthConfig);
+    private getCookiesPath;
+    private getLogPath;
+    private logRequest;
+    private saveCookies;
+    private loadCookies;
+    private isRecentlyValidated;
+    private isSessionValid;
+    fetchCSRFToken(): Promise<string>;
+    private promptForInput;
+    private handle2FAVerification;
+    get needs2FA(): boolean;
+    complete2FA(): Promise<void>;
+    authenticate(): Promise<void>;
+    get httpClient(): AxiosInstance;
+    downloadResource(type: string, name?: string): Promise<any[]>;
+    fetchTable(tableName: string, column?: string, value?: string): Promise<any[]>;
+    fetchTableAdvanced(tableName: string, options?: {
+        column?: string;
+        value?: string;
+        columns?: string;
+        dbAlias?: string;
+    }): Promise<any[]>;
+    fetchObjects(): Promise<any[]>;
+    fetchCMSObjects(): Promise<any[]>;
+    fetchObjectSpecs(objectId: number): Promise<any[]>;
+    fetchAllObjectSpecs(): Promise<any[]>;
+    fetchReports(): Promise<any[]>;
+    fetchReportCategories(): Promise<any[]>;
+    fetchReportSpecs(reportId: number): Promise<any[]>;
+    fetchReportQueries(reportId: number): Promise<any[]>;
+    fetchAllReportSpecs(): Promise<any[]>;
+    fetchAllReportQueries(): Promise<any[]>;
+    updateReport(reportId: number, updateData: Record<string, any>): Promise<any>;
+    createReport(reportData: Record<string, any>): Promise<any>;
+    updateReportSpec(specId: number, updateData: Record<string, any>): Promise<any>;
+    createReportSpec(specData: Record<string, any>): Promise<any>;
+    updateReportQuery(queryId: number, updateData: Record<string, any>): Promise<any>;
+    createReportQuery(queryData: Record<string, any>): Promise<any>;
+    uploadResource(filePath: string, data: any): Promise<any>;
+    private updateObject;
+    private updateObjectSpec;
+    private updateReportFromData;
+    private updateReportSpecFromData;
+    createWorkflowConnection(connectionData: Record<string, any>): Promise<any>;
+    updateWorkflowConnection(connectionId: number, updateData: Record<string, any>): Promise<any>;
+    deleteWorkflowConnection(connectionId: number): Promise<any>;
+    createWorkflowNode(nodeData: Record<string, any>): Promise<any>;
+    updateWorkflowNode(nodeId: number, updateData: Record<string, any>): Promise<any>;
+    deleteWorkflowNode(nodeId: number): Promise<any>;
+    createWorkflowVersion(versionData: Record<string, any>): Promise<any>;
+    updateWorkflowVersion(versionId: number, updateData: Record<string, any>): Promise<any>;
+    publishWorkflowVersion(versionId: number): Promise<any>;
+    archiveWorkflowVersion(versionId: number): Promise<any>;
+    executeCode(code: string): Promise<{
+        success: boolean;
+        vars?: Record<string, any>;
+        output?: string;
+        error?: string;
+    }>;
+    fetchRecordById(tableName: string, id: number, _dbAlias?: string): Promise<Record<string, any> | null>;
+    performOperation(tableName: string, operation: 'add' | 'edit' | 'delete', data: Record<string, any>, dbAlias?: string): Promise<{
+        success: boolean;
+        id?: number;
+        error?: string;
+        message?: string;
+        xtra?: {
+            type: string;
+            alias: string;
+            message: string;
+        };
+    }>;
+}
+//# sourceMappingURL=api.d.ts.map