@rglabs/butterfly 2.0.1

package/dist/utils/api.js

@@ -0,0 +1,1031 @@
+import axios from 'axios';
+import { wrapper } from 'axios-cookiejar-support';
+import { CookieJar } from 'tough-cookie';
+import { join } from 'path';
+import { promises as fs } from 'fs';
+import { createInterface } from 'node:readline';
+import { appendFileSync, mkdirSync } from 'fs';
+const CONFIG_DIR = '.butterfly';
+const COOKIES_FILE = 'cookies.json';
+const LOG_FILE = 'requests.log';
+export class ButterflyAPI {
+    config;
+    client;
+    cookieJar;
+    csrfToken;
+    lastValidated;
+    debug = process.env.BUTTERFLY_DEBUG === 'true';
+    pending2FAData = null;
+    static VALIDATION_CACHE_TTL = 5 * 60 * 1000;
+    constructor(config) {
+        this.config = config;
+        this.cookieJar = new CookieJar(undefined, {
+            rejectPublicSuffixes: false,
+            allowSpecialUseDomain: true,
+            looseMode: true
+        });
+        this.client = wrapper(axios.create({
+            baseURL: config.endpoint,
+            timeout: 30000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            jar: this.cookieJar,
+            withCredentials: true,
+        }));
+        this.client.interceptors.request.use(async (config) => {
+            const url = new URL(config.url, this.config.endpoint);
+            const cookies = await this.cookieJar.getCookies(url.href);
+            if (cookies && cookies.length > 0) {
+                const cookieString = cookies.map(c => `${c.key}=${c.value}`).join('; ');
+                config.headers['Cookie'] = cookieString;
+            }
+            if (this.debug) {
+                console.log('\n--- REQUEST ---');
+                console.log('URL:', config.url);
+                console.log('Method:', config.method?.toUpperCase());
+                console.log('Headers:', JSON.stringify(config.headers, null, 2));
+                console.log('Data:', JSON.stringify(config.data, null, 2));
+                console.log('Existing Cookies:', cookies);
+            }
+            return config;
+        }, (error) => {
+            if (this.debug) {
+                console.error('Request Error:', error.message);
+            }
+            return Promise.reject(error);
+        });
+        this.client.interceptors.response.use((response) => {
+            this.logRequest(response.config.method || 'GET', response.config.url || '', response.status);
+            if (this.debug) {
+                console.log('\n--- RESPONSE ---');
+                console.log('Status:', response.status, response.statusText);
+                console.log('Headers:', JSON.stringify(response.headers, null, 2));
+                console.log('Data:', JSON.stringify(response.data, null, 2));
+                console.log('Cookies:', this.cookieJar.getCookiesSync(this.config.endpoint));
+            }
+            return response;
+        }, (error) => {
+            this.logRequest(error.config?.method || 'GET', error.config?.url || '', error.response?.status, error.message);
+            if (this.debug) {
+                console.error('\n--- ERROR RESPONSE ---');
+                if (error.response) {
+                    console.error('Status:', error.response.status, error.response.statusText);
+                    console.error('Headers:', JSON.stringify(error.response.headers, null, 2));
+                    console.error('Data:', JSON.stringify(error.response.data, null, 2));
+                }
+                else if (error.request) {
+                    console.error('No response received');
+                    console.error('Request:', error.request);
+                }
+                else {
+                    console.error('Error:', error.message);
+                }
+            }
+            return Promise.reject(error);
+        });
+    }
+    getCookiesPath() {
+        return join(process.cwd(), CONFIG_DIR, COOKIES_FILE);
+    }
+    getLogPath() {
+        return join(process.cwd(), CONFIG_DIR, LOG_FILE);
+    }
+    logRequest(method, url, status, error) {
+        try {
+            const configDir = join(process.cwd(), CONFIG_DIR);
+            mkdirSync(configDir, { recursive: true });
+            const timestamp = new Date().toISOString();
+            const statusStr = status ? `${status}` : 'PENDING';
+            const errorStr = error ? ` | ERROR: ${error}` : '';
+            const logLine = `[${timestamp}] ${method.toUpperCase().padEnd(6)} ${statusStr.padEnd(3)} ${url}${errorStr}\n`;
+            appendFileSync(this.getLogPath(), logLine);
+        }
+        catch (e) {
+        }
+    }
+    async saveCookies() {
+        try {
+            const configDir = join(process.cwd(), CONFIG_DIR);
+            await fs.mkdir(configDir, { recursive: true });
+            const rawCookies = this.cookieJar.getCookiesSync(this.config.endpoint);
+            const cookies = rawCookies.map(c => ({
+                key: c.key,
+                value: c.value,
+                domain: c.domain || new URL(this.config.endpoint).hostname,
+                path: c.path || '/',
+                expires: c.expires instanceof Date ? c.expires.toISOString() : undefined
+            }));
+            const session = {
+                endpoint: this.config.endpoint,
+                cookies,
+                csrfToken: this.csrfToken,
+                timestamp: Date.now(),
+                lastValidated: this.lastValidated
+            };
+            await fs.writeFile(this.getCookiesPath(), JSON.stringify(session, null, 2));
+            if (this.debug) {
+                console.log('Cookies saved to disk:', cookies.map(c => c.key));
+            }
+        }
+        catch (error) {
+            if (this.debug) {
+                console.error('Failed to save cookies:', error.message);
+            }
+        }
+    }
+    async loadCookies() {
+        try {
+            const data = await fs.readFile(this.getCookiesPath(), 'utf-8');
+            const session = JSON.parse(data);
+            if (session.endpoint !== this.config.endpoint) {
+                if (this.debug) {
+                    console.log('Stored cookies are for different endpoint, ignoring');
+                }
+                return false;
+            }
+            const maxAge = 24 * 60 * 60 * 1000;
+            if (Date.now() - session.timestamp > maxAge) {
+                if (this.debug) {
+                    console.log('Stored cookies are too old, ignoring');
+                }
+                return false;
+            }
+            const url = this.config.endpoint;
+            for (const cookie of session.cookies) {
+                const cookieStr = `${cookie.key}=${cookie.value}; Domain=${cookie.domain}; Path=${cookie.path}`;
+                await this.cookieJar.setCookie(cookieStr, url);
+            }
+            this.csrfToken = session.csrfToken;
+            this.lastValidated = session.lastValidated;
+            if (this.debug) {
+                console.log('Cookies loaded from disk:', session.cookies.map(c => c.key));
+            }
+            return true;
+        }
+        catch (error) {
+            if (this.debug) {
+                console.log('No stored cookies found or failed to load:', error.message);
+            }
+            return false;
+        }
+    }
+    isRecentlyValidated() {
+        if (!this.lastValidated)
+            return false;
+        return (Date.now() - this.lastValidated) < ButterflyAPI.VALIDATION_CACHE_TTL;
+    }
+    async isSessionValid() {
+        if (this.isRecentlyValidated() && this.csrfToken) {
+            if (this.debug) {
+                console.log('Session recently validated, skipping validation request');
+            }
+            return true;
+        }
+        try {
+            const response = await this.client.get('/admin/ajax/cms_object/get', {
+                params: { table_name: 'users', column: 'id', value: '1', columns: 'id' }
+            });
+            if (response.data && (response.data.success === true || response.data.data)) {
+                const csrfResponse = await this.client.get('/admin/ajax/user/csrf');
+                if (csrfResponse.data?.token) {
+                    this.csrfToken = csrfResponse.data.token;
+                }
+                this.lastValidated = Date.now();
+                if (this.debug) {
+                    console.log('Existing session is valid');
+                }
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            if (this.debug) {
+                console.log('Session validation failed:', error.message);
+            }
+            return false;
+        }
+    }
+    async fetchCSRFToken() {
+        try {
+            if (this.debug) {
+                console.log('\nFetching CSRF token...');
+            }
+            const response = await this.client.get('/admin/ajax/user/csrf');
+            if (response.data && response.data.token && typeof response.data.token === 'string') {
+                const token = response.data.token;
+                this.csrfToken = token;
+                if (this.debug) {
+                    console.log('CSRF token fetched successfully');
+                }
+                return token;
+            }
+            else {
+                throw new Error('CSRF token not found in response');
+            }
+        }
+        catch (error) {
+            console.error('Failed to fetch CSRF token:', error.message);
+            throw new Error('Failed to fetch CSRF token');
+        }
+    }
+    async promptForInput(question) {
+        if (typeof process.stdin.setRawMode === 'function') {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.resume();
+        process.stdin.ref();
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+    }
+    async handle2FAVerification(data) {
+        const method = data.method;
+        console.log('\nTwo-factor authentication required.');
+        if (method === 'totp') {
+            console.log('Method: Authenticator App');
+        }
+        else if (method === 'sms') {
+            console.log(`Method: SMS${data.recipient ? ` (sent to ${data.recipient})` : ''}`);
+        }
+        else if (method === 'email') {
+            console.log(`Method: Email${data.recipient ? ` (sent to ${data.recipient})` : ''}`);
+        }
+        if (data.message) {
+            console.log(`Server: ${data.message}`);
+        }
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const code = await this.promptForInput('\nEnter verification code: ');
+            if (!code) {
+                console.log('No code entered.');
+                if (attempt < maxAttempts) {
+                    console.log(`${maxAttempts - attempt} attempt(s) remaining.`);
+                }
+                continue;
+            }
+            try {
+                await this.fetchCSRFToken();
+                const formData = new URLSearchParams();
+                formData.append('code', code);
+                formData.append('trust_device', '1');
+                formData.append('csrf_token', this.csrfToken);
+                const verifyResponse = await this.client.post('/admin/ajax/twofactor/verify_code', formData, {
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                    }
+                });
+                if (verifyResponse.data?.success) {
+                    console.log('\n2FA verification successful!');
+                    await this.saveCookies();
+                    return;
+                }
+                console.log(`\nVerification failed: ${verifyResponse.data?.message || 'Invalid code'}`);
+                if (attempt < maxAttempts) {
+                    console.log(`${maxAttempts - attempt} attempt(s) remaining.`);
+                }
+            }
+            catch (error) {
+                const message = error.response?.data?.message || error.message;
+                console.error(`\nVerification error: ${message}`);
+                if (attempt < maxAttempts) {
+                    console.log(`${maxAttempts - attempt} attempt(s) remaining.`);
+                }
+            }
+        }
+        throw new Error('2FA verification failed after maximum attempts.');
+    }
+    get needs2FA() {
+        return this.pending2FAData !== null;
+    }
+    async complete2FA() {
+        if (!this.pending2FAData)
+            return;
+        await this.handle2FAVerification(this.pending2FAData);
+        this.pending2FAData = null;
+    }
+    async authenticate() {
+        const cookiesLoaded = await this.loadCookies();
+        if (cookiesLoaded) {
+            const isValid = await this.isSessionValid();
+            if (isValid) {
+                console.log('Reusing existing session...');
+                await this.saveCookies();
+                return;
+            }
+            if (this.debug) {
+                console.log('Stored session is invalid, performing fresh login');
+            }
+        }
+        console.log('\nAttempting to authenticate...');
+        console.log('Endpoint:', this.config.endpoint);
+        console.log('Email:', this.config.email);
+        console.log('Password:', '***' + this.config.password.slice(-3));
+        try {
+            await this.fetchCSRFToken();
+            const formData = new URLSearchParams();
+            formData.append('email', this.config.email);
+            formData.append('password', this.config.password);
+            formData.append('csrf_token', this.csrfToken);
+            const response = await this.client.post('/admin/ajax/user/login', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            if (response.data?.require_2fa_setup) {
+                throw new Error('Two-factor authentication setup is required.\n' +
+                    'Please set up 2FA via your browser at:\n' +
+                    `${this.config.endpoint}/admin/user/twofa_setup`);
+            }
+            if (response.data?.require_2fa) {
+                this.pending2FAData = response.data;
+                await this.saveCookies();
+                return;
+            }
+            if (response.data?.require_otp) {
+                this.pending2FAData = {
+                    method: 'sms',
+                    recipient: response.data.recipient || '***',
+                };
+                await this.saveCookies();
+                return;
+            }
+            if (!response.data || response.data.success !== true) {
+                throw new Error(`Authentication failed: ${response.data?.error || response.data?.message || 'Invalid credentials'}`);
+            }
+            console.log('\nAuthentication successful!');
+            await this.saveCookies();
+            if (this.debug) {
+                console.log('Response status:', response.status);
+                console.log('Response data:', JSON.stringify(response.data, null, 2));
+            }
+        }
+        catch (error) {
+            console.error('\nAuthentication failed!');
+            if (error.response) {
+                console.error('Server responded with error:');
+                console.error('Status:', error.response.status, error.response.statusText);
+                console.error('Response data:', JSON.stringify(error.response.data, null, 2));
+                if (error.response.status === 401) {
+                    throw new Error('Authentication failed: Invalid credentials');
+                }
+                else if (error.response.status === 404) {
+                    throw new Error('Authentication failed: Login endpoint not found');
+                }
+                else if (error.response.status >= 500) {
+                    throw new Error(`Authentication failed: Server error (${error.response.status})`);
+                }
+                else {
+                    throw new Error(`Authentication failed: ${error.response.status} ${error.response.statusText}`);
+                }
+            }
+            else if (error.request) {
+                console.error('No response received from server');
+                console.error('This could be due to:');
+                console.error('- Network connectivity issues');
+                console.error('- Invalid endpoint URL');
+                console.error('- Server is down');
+                throw new Error('Authentication failed: No response from server');
+            }
+            else {
+                console.error('Request setup error:', error.message);
+                throw new Error(`Authentication failed: ${error.message}`);
+            }
+        }
+    }
+    get httpClient() {
+        return this.client;
+    }
+    async downloadResource(type, name) {
+        try {
+            const url = name ? `/${type}/${name}` : `/${type}`;
+            const response = await this.client.get(url);
+            return Array.isArray(response.data) ? response.data : [response.data];
+        }
+        catch (error) {
+            throw new Error(`Failed to download ${type}`);
+        }
+    }
+    async fetchTable(tableName, column, value) {
+        try {
+            if (this.debug) {
+                console.log(`Cookies before fetch${tableName}:`, this.cookieJar.getCookiesSync(this.config.endpoint));
+            }
+            const params = {
+                table_name: tableName,
+                db_alias: 'default'
+            };
+            if (column && value !== undefined) {
+                params.column = column;
+                params.value = value;
+            }
+            const response = await this.client.get('/admin/ajax/cms_object/get', { params });
+            if (response.data && response.data.success === false &&
+                (response.data.message === "Records Not Found" || response.data.message === "Object Not Found")) {
+                return [];
+            }
+            if (!response.data || !response.data.data) {
+                throw new Error(`Invalid response format from ${tableName} endpoint: ` + JSON.stringify(response.data));
+            }
+            return response.data.data;
+        }
+        catch (error) {
+            console.error(`Error fetching ${tableName}:`, error.message);
+            throw new Error(`Failed to fetch ${tableName} from Butterfly`);
+        }
+    }
+    async fetchTableAdvanced(tableName, options = {}) {
+        try {
+            if (this.debug) {
+                console.log(`Cookies before fetch${tableName}:`, this.cookieJar.getCookiesSync(this.config.endpoint));
+            }
+            const params = {
+                table_name: tableName,
+                database_alias: options.dbAlias || 'default'
+            };
+            if (options.column && options.value !== undefined) {
+                params.column = options.column;
+                params.value = options.value;
+            }
+            if (options.columns) {
+                params.columns = options.columns;
+            }
+            const response = await this.client.get('/admin/ajax/cms_object/get', { params });
+            if (response.data && response.data.success === false &&
+                (response.data.message === "Records Not Found" || response.data.message === "Object Not Found")) {
+                return [];
+            }
+            if (!response.data || !response.data.data) {
+                throw new Error(`Invalid response format from ${tableName} endpoint: ` + JSON.stringify(response.data));
+            }
+            return response.data.data;
+        }
+        catch (error) {
+            console.error(`Error fetching ${tableName}:`, error.message);
+            throw new Error(`Failed to fetch ${tableName} from Butterfly`);
+        }
+    }
+    async fetchObjects() {
+        return this.fetchTable('objects', 'is_cms_object', '0');
+    }
+    async fetchCMSObjects() {
+        return this.fetchTable('objects', 'is_cms_object', '1');
+    }
+    async fetchObjectSpecs(objectId) {
+        try {
+            return await this.fetchTable('object_specs', 'object_id', objectId.toString());
+        }
+        catch (error) {
+            console.error(`Error fetching specs for object ${objectId}:`, error.message);
+            return [];
+        }
+    }
+    async fetchAllObjectSpecs() {
+        try {
+            return await this.fetchTable('object_specs');
+        }
+        catch (error) {
+            console.error('Error fetching all object specs:', error.message);
+            return [];
+        }
+    }
+    async fetchReports() {
+        return this.fetchTable('cms_reports');
+    }
+    async fetchReportCategories() {
+        try {
+            return await this.fetchTable('cms_report_categories');
+        }
+        catch (error) {
+            console.error('Error fetching report categories:', error.message);
+            return [];
+        }
+    }
+    async fetchReportSpecs(reportId) {
+        try {
+            return await this.fetchTable('cms_report_specs', 'cms_report_id', reportId.toString());
+        }
+        catch (error) {
+            console.error(`Error fetching specs for report ${reportId}:`, error.message);
+            return [];
+        }
+    }
+    async fetchReportQueries(reportId) {
+        try {
+            return await this.fetchTable('cms_report_queries', 'cms_report_id', reportId.toString());
+        }
+        catch (error) {
+            console.error(`Error fetching queries for report ${reportId}:`, error.message);
+            return [];
+        }
+    }
+    async fetchAllReportSpecs() {
+        try {
+            return await this.fetchTable('cms_report_specs');
+        }
+        catch (error) {
+            console.error('Error fetching all report specs:', error.message);
+            return [];
+        }
+    }
+    async fetchAllReportQueries() {
+        try {
+            return await this.fetchTable('cms_report_queries');
+        }
+        catch (error) {
+            console.error('Error fetching all report queries:', error.message);
+            return [];
+        }
+    }
+    async updateReport(reportId, updateData) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('id', reportId.toString());
+            Object.entries(updateData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=cms_reports__edit', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error updating report ${reportId}:`, error.message);
+            throw new Error(`Failed to update report: ${error.message}`);
+        }
+    }
+    async createReport(reportData) {
+        try {
+            const formData = new URLSearchParams();
+            if (reportData.hide_in_list === undefined || reportData.hide_in_list === null) {
+                formData.append('hide_in_list', '0');
+            }
+            Object.entries(reportData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=cms_reports__add', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error creating report:', error.message);
+            throw new Error(`Failed to create report: ${error.message}`);
+        }
+    }
+    async updateReportSpec(specId, updateData) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('id', specId.toString());
+            Object.entries(updateData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=cms_report_specs__edit', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error updating report spec ${specId}:`, error.message);
+            throw new Error(`Failed to update report spec: ${error.message}`);
+        }
+    }
+    async createReportSpec(specData) {
+        try {
+            const formData = new URLSearchParams();
+            Object.entries(specData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=cms_report_specs__add', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error creating report spec:', error.message);
+            throw new Error(`Failed to create report spec: ${error.message}`);
+        }
+    }
+    async updateReportQuery(queryId, updateData) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('id', queryId.toString());
+            Object.entries(updateData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=cms_report_queries__edit', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error updating report query ${queryId}:`, error.message);
+            throw new Error(`Failed to update report query: ${error.message}`);
+        }
+    }
+    async createReportQuery(queryData) {
+        try {
+            const formData = new URLSearchParams();
+            Object.entries(queryData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=cms_report_queries__add', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error creating report query:', error.message);
+            throw new Error(`Failed to create report query: ${error.message}`);
+        }
+    }
+    async uploadResource(filePath, data) {
+        try {
+            const pathParts = filePath.split('/');
+            const fileName = pathParts[pathParts.length - 1];
+            if (pathParts.includes('objects')) {
+                if (fileName === 'object.json') {
+                    return await this.updateObject(data);
+                }
+                else if (fileName === 'spec.json') {
+                    return await this.updateObjectSpec(data);
+                }
+            }
+            else if (pathParts.includes('reports')) {
+                if (fileName === 'report.json') {
+                    return await this.updateReportFromData(data);
+                }
+                else if (fileName === 'spec.json') {
+                    return await this.updateReportSpecFromData(data);
+                }
+            }
+            throw new Error(`Unsupported file type: ${fileName} in path: ${filePath}`);
+        }
+        catch (error) {
+            console.error(`Error uploading resource ${filePath}:`, error.message);
+            throw error;
+        }
+    }
+    async updateObject(objectData) {
+        const formData = new URLSearchParams();
+        if (this.csrfToken) {
+            formData.append('csrf_token', this.csrfToken);
+        }
+        Object.keys(objectData).forEach(key => {
+            if (objectData[key] !== null && objectData[key] !== undefined) {
+                formData.append(key, objectData[key].toString());
+            }
+        });
+        const url = `/admin/ajax/cms_object/operation?do=objects__edit`;
+        const response = await this.client.post(url, formData, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            }
+        });
+        if (!response.data || !response.data.success) {
+            throw new Error(`Failed to update object: ${response.data?.error || 'Unknown error'}`);
+        }
+        return response.data;
+    }
+    async updateObjectSpec(specData) {
+        const formData = new URLSearchParams();
+        if (this.csrfToken) {
+            formData.append('csrf_token', this.csrfToken);
+        }
+        Object.keys(specData).forEach(key => {
+            if (specData[key] !== null && specData[key] !== undefined) {
+                formData.append(key, specData[key].toString());
+            }
+        });
+        const url = `/admin/ajax/cms_object/operation?do=object_specs__edit`;
+        const response = await this.client.post(url, formData, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            }
+        });
+        if (!response.data || !response.data.success) {
+            throw new Error(`Failed to update object spec: ${response.data?.error || 'Unknown error'}`);
+        }
+        return response.data;
+    }
+    async updateReportFromData(reportData) {
+        const formData = new URLSearchParams();
+        if (this.csrfToken) {
+            formData.append('csrf_token', this.csrfToken);
+        }
+        Object.keys(reportData).forEach(key => {
+            if (reportData[key] !== null && reportData[key] !== undefined) {
+                formData.append(key, reportData[key].toString());
+            }
+        });
+        const url = `/admin/ajax/cms_object/operation?do=cms_reports__edit`;
+        const response = await this.client.post(url, formData, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            }
+        });
+        if (!response.data || !response.data.success) {
+            throw new Error(`Failed to update report: ${response.data?.error || 'Unknown error'}`);
+        }
+        return response.data;
+    }
+    async updateReportSpecFromData(specData) {
+        const formData = new URLSearchParams();
+        if (this.csrfToken) {
+            formData.append('csrf_token', this.csrfToken);
+        }
+        Object.keys(specData).forEach(key => {
+            if (specData[key] !== null && specData[key] !== undefined) {
+                formData.append(key, specData[key].toString());
+            }
+        });
+        const url = `/admin/ajax/cms_object/operation?do=cms_report_specs__edit`;
+        const response = await this.client.post(url, formData, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            }
+        });
+        if (!response.data || !response.data.success) {
+            throw new Error(`Failed to update report spec: ${response.data?.error || 'Unknown error'}`);
+        }
+        return response.data;
+    }
+    async createWorkflowConnection(connectionData) {
+        try {
+            const formData = new URLSearchParams();
+            Object.entries(connectionData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=bfy_workflow_connections__add', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error creating workflow connection:', error.message);
+            throw new Error(`Failed to create workflow connection: ${error.message}`);
+        }
+    }
+    async updateWorkflowConnection(connectionId, updateData) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('id', connectionId.toString());
+            Object.entries(updateData).forEach(([key, value]) => {
+                if (key !== 'id' && value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=bfy_workflow_connections__edit', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error updating workflow connection ${connectionId}:`, error.message);
+            throw new Error(`Failed to update workflow connection: ${error.message}`);
+        }
+    }
+    async deleteWorkflowConnection(connectionId) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('id', connectionId.toString());
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=bfy_workflow_connections__delete', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error deleting workflow connection ${connectionId}:`, error.message);
+            throw new Error(`Failed to delete workflow connection: ${error.message}`);
+        }
+    }
+    async createWorkflowNode(nodeData) {
+        try {
+            const formData = new URLSearchParams();
+            Object.entries(nodeData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    if (typeof value === 'object') {
+                        formData.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        formData.append(key, String(value));
+                    }
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=bfy_workflow_nodes__add', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error creating workflow node:', error.message);
+            throw new Error(`Failed to create workflow node: ${error.message}`);
+        }
+    }
+    async updateWorkflowNode(nodeId, updateData) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('id', nodeId.toString());
+            Object.entries(updateData).forEach(([key, value]) => {
+                if (key !== 'id' && value !== null && value !== undefined) {
+                    if (typeof value === 'object') {
+                        formData.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        formData.append(key, String(value));
+                    }
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=bfy_workflow_nodes__edit', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error updating workflow node ${nodeId}:`, error.message);
+            throw new Error(`Failed to update workflow node: ${error.message}`);
+        }
+    }
+    async deleteWorkflowNode(nodeId) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('id', nodeId.toString());
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=bfy_workflow_nodes__delete', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error deleting workflow node ${nodeId}:`, error.message);
+            throw new Error(`Failed to delete workflow node: ${error.message}`);
+        }
+    }
+    async createWorkflowVersion(versionData) {
+        try {
+            const formData = new URLSearchParams();
+            Object.entries(versionData).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=bfy_workflow_versions__add', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error creating workflow version:', error.message);
+            throw new Error(`Failed to create workflow version: ${error.message}`);
+        }
+    }
+    async updateWorkflowVersion(versionId, updateData) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('id', versionId.toString());
+            Object.entries(updateData).forEach(([key, value]) => {
+                if (key !== 'id' && value !== null && value !== undefined) {
+                    formData.append(key, String(value));
+                }
+            });
+            const response = await this.client.post('/admin/ajax/cms_object/operation?do=bfy_workflow_versions__edit', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error updating workflow version ${versionId}:`, error.message);
+            throw new Error(`Failed to update workflow version: ${error.message}`);
+        }
+    }
+    async publishWorkflowVersion(versionId) {
+        return this.updateWorkflowVersion(versionId, { status: 2 });
+    }
+    async archiveWorkflowVersion(versionId) {
+        return this.updateWorkflowVersion(versionId, { status: 3 });
+    }
+    async executeCode(code) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('code', code);
+            const response = await this.client.post('/admin/api/code', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return {
+                success: response.data?.success === true,
+                vars: response.data?.vars,
+                output: response.data?.output,
+                error: response.data?.error
+            };
+        }
+        catch (error) {
+            console.error('Error executing code:', error.message);
+            return {
+                success: false,
+                error: error.message || 'Unknown error'
+            };
+        }
+    }
+    async fetchRecordById(tableName, id, _dbAlias = 'default') {
+        try {
+            const records = await this.fetchTable(tableName, 'id', id.toString());
+            return records.length > 0 ? records[0] : null;
+        }
+        catch (error) {
+            console.error(`Error fetching record ${id} from ${tableName}:`, error.message);
+            return null;
+        }
+    }
+    async performOperation(tableName, operation, data, dbAlias = 'default') {
+        try {
+            const formData = new URLSearchParams();
+            if (this.csrfToken) {
+                formData.append('csrf_token', this.csrfToken);
+            }
+            if (dbAlias !== 'default') {
+                formData.append('db_alias', dbAlias);
+            }
+            Object.entries(data).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    if (typeof value === 'object') {
+                        formData.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        formData.append(key, String(value));
+                    }
+                }
+            });
+            const endpoint = `/admin/ajax/cms_object/operation?do=${tableName}__${operation}`;
+            const response = await this.client.post(endpoint, formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            });
+            return {
+                success: response.data?.success === true,
+                id: response.data?.id,
+                error: response.data?.error,
+                message: response.data?.message,
+                xtra: response.data?.xtra
+            };
+        }
+        catch (error) {
+            console.error(`Error performing ${operation} on ${tableName}:`, error.message);
+            return {
+                success: false,
+                error: error.message || 'Unknown error'
+            };
+        }
+    }
+}
+//# sourceMappingURL=api.js.map