carto-cli 0.1.0-rc.1

package/dist/commands/workflows.js

@@ -0,0 +1,1025 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowsList = workflowsList;
+exports.workflowsDelete = workflowsDelete;
+exports.workflowsGet = workflowsGet;
+exports.workflowsCreate = workflowsCreate;
+exports.workflowsUpdate = workflowsUpdate;
+exports.workflowsExtensionsInstall = workflowsExtensionsInstall;
+exports.workflowScheduleAdd = workflowScheduleAdd;
+exports.workflowScheduleUpdate = workflowScheduleUpdate;
+exports.workflowsCopy = workflowsCopy;
+exports.workflowScheduleRemove = workflowScheduleRemove;
+const api_1 = require("../api");
+const colors_1 = require("../colors");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const schedule_parser_1 = require("../schedule-parser");
+const prompt_1 = require("../prompt");
+async function workflowsList(options, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        let result;
+        if (options.all) {
+            // Fetch all pages automatically
+            const baseParams = {};
+            if (options.orderBy)
+                baseParams['order_by'] = options.orderBy;
+            if (options.orderDirection)
+                baseParams['order_direction'] = options.orderDirection;
+            if (options.search)
+                baseParams['search'] = options.search;
+            if (options.privacy)
+                baseParams['privacy'] = options.privacy;
+            if (options.tags)
+                baseParams['tags'] = JSON.stringify(options.tags);
+            const paginatedResult = await client.getAllPaginated('/v3/organization-workflows', baseParams);
+            result = {
+                data: paginatedResult.data,
+                meta: {
+                    page: {
+                        total: paginatedResult.total,
+                        current: 1,
+                        pageSize: paginatedResult.total,
+                        totalPages: 1
+                    }
+                }
+            };
+        }
+        else {
+            // Fetch single page
+            const params = new URLSearchParams();
+            if (options.orderBy)
+                params.append('order_by', options.orderBy);
+            if (options.orderDirection)
+                params.append('order_direction', options.orderDirection);
+            if (options.pageSize)
+                params.append('page_size', options.pageSize);
+            if (options.page)
+                params.append('page', options.page);
+            if (options.search)
+                params.append('search', options.search);
+            if (options.privacy)
+                params.append('privacy', options.privacy);
+            if (options.tags)
+                params.append('tags', JSON.stringify(options.tags));
+            const queryString = params.toString();
+            const path = `/v3/organization-workflows${queryString ? '?' + queryString : ''}`;
+            result = await client.get(path);
+        }
+        if (jsonOutput) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            const total = result.meta?.page?.total || result.data?.length || 0;
+            // Display header with search query if present
+            const header = options.search
+                ? `\n${total} workflows found for '${options.search}':\n`
+                : `\nWorkflows (${total}):\n`;
+            console.log((0, colors_1.bold)(header));
+            const workflows = result.data || [];
+            workflows.forEach((workflow) => {
+                console.log((0, colors_1.bold)('Workflow ID: ') + workflow.id);
+                console.log('  Name: ' + (workflow.title || workflow.name));
+                console.log('  Privacy: ' + (workflow.privacy || 'N/A'));
+                if (workflow.tags && workflow.tags.length > 0) {
+                    console.log('  Tags: ' + workflow.tags.join(', '));
+                }
+                console.log('  Created: ' + new Date(workflow.createdAt || workflow.created_at).toLocaleString());
+                console.log('  Updated: ' + new Date(workflow.updatedAt || workflow.updated_at).toLocaleString());
+                console.log('');
+            });
+            if (options.all) {
+                console.log((0, colors_1.dim)(`Fetched all ${total} workflows`));
+            }
+            else if (result.meta?.page) {
+                const page = result.meta.page;
+                console.log((0, colors_1.dim)(`Page ${page.current || 1} of ${page.totalPages || 1} (use --all to fetch all pages)`));
+            }
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to list workflows: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}
+async function workflowsDelete(workflowId, token, baseUrl, jsonOutput, debug = false, profile, yes) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        // Skip confirmation if --yes or --json flag is set
+        const skipConfirmation = yes || jsonOutput;
+        if (!skipConfirmation) {
+            // Fetch workflow details to show in confirmation prompt
+            let workflowDetails;
+            try {
+                workflowDetails = await client.get(`/v3/workflows/${workflowId}`);
+            }
+            catch (err) {
+                // If we can't fetch details, proceed with generic message
+                console.log((0, colors_1.warning)('\n⚠️  Warning: This will permanently delete this workflow.'));
+                console.log((0, colors_1.warning)(`   Workflow ID: ${workflowId}`));
+            }
+            if (workflowDetails) {
+                const title = workflowDetails.title || workflowDetails.config?.title || '(Untitled)';
+                console.log((0, colors_1.warning)('\n⚠️  Warning: This will permanently delete:'));
+                console.log(`   Workflow: "${title}"`);
+                console.log(`   ID: ${workflowId}`);
+                if (workflowDetails.privacy) {
+                    console.log(`   Privacy: ${workflowDetails.privacy}`);
+                }
+            }
+            console.log('');
+            const confirmed = await (0, prompt_1.promptForConfirmation)("Type 'delete' to confirm: ", 'delete');
+            if (!confirmed) {
+                console.log('\nDeletion cancelled');
+                process.exit(0);
+            }
+            console.log('');
+        }
+        await client.delete(`/v3/organization-workflows/${workflowId}`);
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: true, message: 'Workflow deleted successfully', id: workflowId }));
+        }
+        else {
+            console.log((0, colors_1.success)(`✓ Workflow ${workflowId} deleted successfully`));
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            console.log((0, colors_1.error)('✗ Failed to delete workflow: ' + err.message));
+        }
+        process.exit(1);
+    }
+}
+async function workflowsGet(workflowId, options, token, baseUrl, jsonOutput, debug = false) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug);
+        // Build query parameters
+        const params = new URLSearchParams();
+        if (options.client)
+            params.append('client', options.client);
+        const queryString = params.toString();
+        const path = `/v3/workflows/${workflowId}${queryString ? '?' + queryString : ''}`;
+        const result = await client.get(path);
+        if (jsonOutput) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            console.log((0, colors_1.bold)('\nWorkflow Details:\n'));
+            console.log((0, colors_1.bold)('ID: ') + result.id);
+            const title = result.title || result.config?.title || result.name;
+            console.log('  Title: ' + title);
+            const description = result.description || result.config?.description;
+            if (description)
+                console.log('  Description: ' + description);
+            console.log('  Privacy: ' + (result.privacy || 'N/A'));
+            if (result.tags && result.tags.length > 0) {
+                console.log('  Tags: ' + result.tags.join(', '));
+            }
+            if (result.connectionProvider || result.providerId) {
+                console.log('  Connection Provider: ' + (result.connectionProvider || result.providerId));
+            }
+            if (result.schemaVersion)
+                console.log('  Schema Version: ' + result.schemaVersion);
+            console.log('  Created: ' + new Date(result.createdAt || result.created_at).toLocaleString());
+            console.log('  Updated: ' + new Date(result.updatedAt || result.updated_at).toLocaleString());
+            if (result.config) {
+                console.log('\n' + (0, colors_1.bold)('Configuration:'));
+                console.log('  Nodes: ' + (result.config.nodes?.length || 0));
+                console.log('  Edges: ' + (result.config.edges?.length || 0));
+                if (result.config.procedure !== undefined)
+                    console.log('  Procedure: ' + result.config.procedure);
+                if (result.config.useCache !== undefined)
+                    console.log('  Use Cache: ' + result.config.useCache);
+            }
+            if (result.executionInfo) {
+                console.log('\n' + (0, colors_1.bold)('Execution Info:'));
+                if (result.executionInfo.status)
+                    console.log('  Status: ' + result.executionInfo.status);
+                if (result.executionInfo.startedAt)
+                    console.log('  Started: ' + new Date(result.executionInfo.startedAt).toLocaleString());
+                if (result.executionInfo.finishedAt)
+                    console.log('  Finished: ' + new Date(result.executionInfo.finishedAt).toLocaleString());
+            }
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            console.log((0, colors_1.error)('✗ Failed to get workflow: ' + err.message));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Get JSON from various input sources (arg, file, stdin)
+ */
+async function getJsonFromInput(jsonString, options) {
+    let json = jsonString;
+    // Priority 1: --file flag
+    if (options.file) {
+        try {
+            json = (0, fs_1.readFileSync)(options.file, 'utf-8').trim();
+        }
+        catch (err) {
+            throw new Error(`Failed to read file: ${err.message}`);
+        }
+    }
+    // Priority 2: stdin
+    if (!json && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        json = Buffer.concat(chunks).toString('utf-8').trim();
+    }
+    // Parse JSON if we have it
+    if (!json) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON: ${err.message}`);
+    }
+}
+async function workflowsCreate(jsonString, options, token, baseUrl, jsonOutput, debug = false) {
+    try {
+        if (!jsonOutput) {
+            console.error((0, colors_1.dim)('⚠️  Note: workflows create is experimental and subject to change\n'));
+        }
+        const client = await api_1.ApiClient.create(token, baseUrl, debug);
+        // Get workflow config from various sources
+        const body = await getJsonFromInput(jsonString, options);
+        if (!body) {
+            throw new Error('No workflow config provided. Use: carto workflows create <json> or --file <path> or pipe via stdin');
+        }
+        // Ensure required fields
+        if (!body.connectionId) {
+            throw new Error('connectionId is required');
+        }
+        // Set default client if not provided
+        if (!body.client) {
+            body.client = 'carto-cli';
+        }
+        const result = await client.post('/v3/workflows', body);
+        if (jsonOutput) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            console.log((0, colors_1.success)(`✓ Workflow created successfully`));
+            console.log((0, colors_1.bold)('\nWorkflow ID: ') + result.id);
+            if (result.title)
+                console.log('Title: ' + result.title);
+            if (result.connectionProvider)
+                console.log('Connection Provider: ' + result.connectionProvider);
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            console.log((0, colors_1.error)('✗ Failed to create workflow: ' + err.message));
+        }
+        process.exit(1);
+    }
+}
+async function workflowsUpdate(workflowId, jsonString, options, token, baseUrl, jsonOutput, debug = false) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug);
+        // Get update config from various sources
+        const body = await getJsonFromInput(jsonString, options);
+        if (!body) {
+            throw new Error('No update config provided. Use: carto workflows update <id> <json> or --file <path> or pipe via stdin');
+        }
+        // Ensure required fields
+        if (!body.config) {
+            throw new Error('config object is required');
+        }
+        // Set default client if not provided
+        if (!body.client) {
+            body.client = 'carto-cli';
+        }
+        const result = await client.patch(`/v3/workflows/${workflowId}`, body);
+        if (jsonOutput) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            console.log((0, colors_1.success)(`✓ Workflow ${workflowId} updated successfully`));
+            if (result.title)
+                console.log('Title: ' + result.title);
+            if (result.updated_at)
+                console.log('Updated: ' + new Date(result.updated_at).toLocaleString());
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            console.log((0, colors_1.error)('✗ Failed to update workflow: ' + err.message));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Install a workflow extension from a local zip file
+ */
+async function workflowsExtensionsInstall(extensionFile, connectionName, token, baseUrl, jsonOutput, debug = false, profile) {
+    let tempDir;
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Installing extension...'));
+        }
+        // Create temp directory
+        tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'carto-extension-'));
+        // Extract zip file
+        try {
+            (0, child_process_1.execSync)(`unzip -q -o "${extensionFile}" -d "${tempDir}"`, { stdio: 'pipe' });
+        }
+        catch (err) {
+            throw new Error(`Failed to extract extension file: ${err.message}`);
+        }
+        // Read metadata.json
+        const metadataPath = (0, path_1.join)(tempDir, 'metadata.json');
+        let metadata;
+        try {
+            const metadataContent = (0, fs_1.readFileSync)(metadataPath, 'utf-8');
+            metadata = JSON.parse(metadataContent);
+        }
+        catch (err) {
+            throw new Error(`Failed to read metadata.json: ${err.message}`);
+        }
+        if (!metadata.provider) {
+            throw new Error('Extension metadata missing "provider" field');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Extension: ${metadata.name || 'unknown'} (provider: ${metadata.provider})`));
+            console.log((0, colors_1.dim)(`Finding connection: ${connectionName}...`));
+        }
+        // Find connection by name
+        const connectionsResult = await client.getAllPaginated('/v3/connections', {});
+        const connectionSummary = connectionsResult.data.find((conn) => conn.name === connectionName);
+        if (!connectionSummary) {
+            throw new Error(`Connection '${connectionName}' not found`);
+        }
+        // Get full connection details (list endpoint doesn't include extensionsLocations)
+        const connection = await client.get(`/v3/connections/${connectionSummary.id}`);
+        // Validate provider compatibility
+        if (metadata.provider !== connection.provider_id) {
+            throw new Error(`Extension provider '${metadata.provider}' does not match connection provider '${connection.provider_id}'`);
+        }
+        // Get extensionsLocations FQN
+        if (!connection.extensionsLocations || connection.extensionsLocations.length === 0) {
+            throw new Error(`Connection '${connectionName}' has no extensionsLocations configured`);
+        }
+        const fqn = connection.extensionsLocations[0].fqn;
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Connection found: ${connection.id} (${connection.provider_id})`));
+            console.log((0, colors_1.dim)(`Extensions location: ${fqn}`));
+            console.log((0, colors_1.dim)('Processing SQL...'));
+        }
+        // Read and process extension.sql
+        const sqlPath = (0, path_1.join)(tempDir, 'extension.sql');
+        let sql;
+        try {
+            sql = (0, fs_1.readFileSync)(sqlPath, 'utf-8');
+        }
+        catch (err) {
+            throw new Error(`Failed to read extension.sql: ${err.message}`);
+        }
+        // Replace placeholder
+        sql = sql.replace(/@@workflows_temp@@/g, fqn);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Executing extension SQL...'));
+        }
+        // Execute SQL job
+        const jobBody = {
+            query: sql,
+            queryParameters: {}
+        };
+        const jobResult = await client.post(`/v3/sql/${encodeURIComponent(connectionName)}/job`, jobBody);
+        const jobId = jobResult.externalId || jobResult.jobId;
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Job created: ${jobId}`));
+            console.log((0, colors_1.dim)('Waiting for completion...'));
+        }
+        // Poll for job completion
+        const maxRetries = 600; // 10 minutes
+        let retries = 0;
+        let jobStatus;
+        while (retries < maxRetries) {
+            jobStatus = await client.get(`/v3/sql/${encodeURIComponent(connectionName)}/job/${encodeURIComponent(jobId)}`);
+            if (!jsonOutput && retries > 0 && retries % 5 === 0) {
+                console.log((0, colors_1.dim)(`Status: ${jobStatus.status}...`));
+            }
+            if (jobStatus.status === 'success' || jobStatus.status === 'failed' || jobStatus.status === 'failure') {
+                break;
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            retries++;
+        }
+        if (retries >= maxRetries) {
+            throw new Error('Job timeout: Installation took longer than 10 minutes');
+        }
+        // Check final status
+        if (jobStatus.status === 'failed' || jobStatus.status === 'failure') {
+            const errorMsg = jobStatus.error?.msg || jobStatus.error?.message || jobStatus.error || 'Unknown error';
+            throw new Error(`Installation failed: ${errorMsg}`);
+        }
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                extensionName: metadata.name,
+                provider: metadata.provider,
+                connection: connectionName,
+                jobId: jobId
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)(`\n✓ Extension '${metadata.name}' installed successfully`));
+            console.log((0, colors_1.dim)(`Job ID: ${jobId}`));
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+    finally {
+        // Clean up temp directory
+        if (tempDir) {
+            try {
+                (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+/**
+ * Add a schedule to a workflow
+ */
+async function workflowScheduleAdd(workflowId, options, token, baseUrl, jsonOutput, debug = false, profile) {
+    let tempDir;
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        if (!options.expression) {
+            throw new Error('Schedule expression is required (use --expression)');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Fetching workflow details...'));
+        }
+        // 1. Get workflow details
+        const workflow = await client.get(`/v3/workflows/${workflowId}`);
+        if (!workflow.connectionId) {
+            throw new Error('Workflow does not have a connectionId');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Workflow: ${workflow.title || workflow.config?.title || workflowId}`));
+            console.log((0, colors_1.dim)('Fetching connection details...'));
+        }
+        // 2. Get connection details
+        const connection = await client.get(`/v3/connections/${workflow.connectionId}`);
+        const connectionName = connection.name;
+        const region = connection.region || 'US';
+        const provider = connection.provider_id || connection.providerId;
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Connection: ${connectionName} (${provider}, region: ${region})`));
+            console.log((0, colors_1.dim)('Generating SQL from workflow...'));
+        }
+        // 3. Generate SQL from workflow config
+        tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'carto-workflow-'));
+        const diagramPath = (0, path_1.join)(tempDir, 'workflow.json');
+        (0, fs_1.writeFileSync)(diagramPath, JSON.stringify(workflow.config, null, 2), 'utf-8');
+        let sql;
+        try {
+            sql = (0, child_process_1.execSync)(`workflows-engine diagram to-sql "${diagramPath}"`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+        }
+        catch (err) {
+            throw new Error(`Failed to generate SQL: ${err.message}`);
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Creating schedule in data warehouse...'));
+        }
+        // 4. Create schedule via SQL API
+        const scheduleBody = {
+            schedule: options.expression,
+            query: sql,
+            region: region,
+            name: `workflows.${workflowId}`,
+            client: 'workflows-schedule'
+        };
+        await client.post(`/v3/sql/${encodeURIComponent(connectionName)}/schedule`, scheduleBody);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Parsing schedule expression...'));
+        }
+        // 5. Parse schedule expression to metadata
+        const scheduleMetadata = (0, schedule_parser_1.parseScheduleExpression)(options.expression, provider);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Updating workflow metadata...'));
+        }
+        // 6. Update workflow with schedule metadata in config
+        const updatedConfig = {
+            ...workflow.config,
+            schedule: {
+                time: scheduleMetadata.time,
+                frequency: scheduleMetadata.frequency,
+                daysOfWeek: scheduleMetadata.daysOfWeek,
+                expression: options.expression,
+                daysOfMonth: scheduleMetadata.daysOfMonth,
+                repeatInterval: scheduleMetadata.repeatInterval
+            }
+        };
+        const updateBody = {
+            config: updatedConfig,
+            client: 'carto-cli'
+        };
+        await client.patch(`/v3/workflows/${workflowId}`, updateBody);
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                workflowId,
+                schedule: options.expression,
+                metadata: scheduleMetadata
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)(`\n✓ Schedule added successfully`));
+            console.log((0, colors_1.bold)('Workflow: ') + workflowId);
+            console.log((0, colors_1.bold)('Schedule: ') + options.expression);
+            console.log((0, colors_1.bold)('Time: ') + scheduleMetadata.time);
+            if (scheduleMetadata.daysOfWeek.length < 7) {
+                const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+                const days = scheduleMetadata.daysOfWeek.map(d => dayNames[d]).join(', ');
+                console.log((0, colors_1.bold)('Days: ') + days);
+            }
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to add schedule: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+    finally {
+        if (tempDir) {
+            try {
+                (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+/**
+ * Update a workflow schedule
+ */
+async function workflowScheduleUpdate(workflowId, options, token, baseUrl, jsonOutput, debug = false, profile) {
+    let tempDir;
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        if (!options.expression) {
+            throw new Error('Schedule expression is required (use --expression)');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Fetching workflow details...'));
+        }
+        // 1. Get workflow details
+        const workflow = await client.get(`/v3/workflows/${workflowId}`);
+        if (!workflow.connectionId) {
+            throw new Error('Workflow does not have a connectionId');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Workflow: ${workflow.title || workflow.config?.title || workflowId}`));
+            console.log((0, colors_1.dim)('Fetching connection details...'));
+        }
+        // 2. Get connection details
+        const connection = await client.get(`/v3/connections/${workflow.connectionId}`);
+        const connectionName = connection.name;
+        const region = connection.region || 'US';
+        const provider = connection.provider_id || connection.providerId;
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Connection: ${connectionName} (${provider}, region: ${region})`));
+            console.log((0, colors_1.dim)('Generating SQL from workflow...'));
+        }
+        // 3. Generate SQL from workflow config
+        tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'carto-workflow-'));
+        const diagramPath = (0, path_1.join)(tempDir, 'workflow.json');
+        (0, fs_1.writeFileSync)(diagramPath, JSON.stringify(workflow.config, null, 2), 'utf-8');
+        let sql;
+        try {
+            sql = (0, child_process_1.execSync)(`workflows-engine diagram to-sql "${diagramPath}"`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+        }
+        catch (err) {
+            throw new Error(`Failed to generate SQL: ${err.message}`);
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Updating schedule in data warehouse...'));
+        }
+        // 4. Update schedule via SQL API
+        const schedulePath = `/v3/sql/${encodeURIComponent(connectionName)}/schedule/workflows.${workflowId}?region=${region}`;
+        const scheduleBody = {
+            schedule: options.expression,
+            query: sql,
+            name: `workflows.${workflowId}`,
+            region: region,
+            client: 'workflows-schedule'
+        };
+        await client.patch(schedulePath, scheduleBody);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Parsing schedule expression...'));
+        }
+        // 5. Parse schedule expression to metadata
+        const scheduleMetadata = (0, schedule_parser_1.parseScheduleExpression)(options.expression, provider);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Updating workflow metadata...'));
+        }
+        // 6. Update workflow with new schedule metadata in config
+        const updatedConfig = {
+            ...workflow.config,
+            schedule: {
+                time: scheduleMetadata.time,
+                frequency: scheduleMetadata.frequency,
+                daysOfWeek: scheduleMetadata.daysOfWeek,
+                expression: options.expression,
+                daysOfMonth: scheduleMetadata.daysOfMonth,
+                repeatInterval: scheduleMetadata.repeatInterval
+            }
+        };
+        const updateBody = {
+            config: updatedConfig,
+            client: 'carto-cli'
+        };
+        await client.patch(`/v3/workflows/${workflowId}`, updateBody);
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                workflowId,
+                schedule: options.expression,
+                metadata: scheduleMetadata
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)(`\n✓ Schedule updated successfully`));
+            console.log((0, colors_1.bold)('Workflow: ') + workflowId);
+            console.log((0, colors_1.bold)('New schedule: ') + options.expression);
+            console.log((0, colors_1.bold)('Time: ') + scheduleMetadata.time);
+            if (scheduleMetadata.daysOfWeek.length < 7) {
+                const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+                const days = scheduleMetadata.daysOfWeek.map(d => dayNames[d]).join(', ');
+                console.log((0, colors_1.bold)('Days: ') + days);
+            }
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to update schedule: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+    finally {
+        if (tempDir) {
+            try {
+                (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+/**
+ * Validate that a table source is accessible in the destination connection
+ * Uses dry-run SQL queries with WHERE 1=0 to test without transferring data
+ */
+async function validateTableSource(client, connectionName, tableFqn, jsonOutput) {
+    try {
+        // Build dry-run query
+        const validationSQL = `SELECT * FROM ${tableFqn} WHERE 1=0 LIMIT 1`;
+        if (!jsonOutput) {
+            const displayTable = tableFqn.length > 60
+                ? tableFqn.substring(0, 57) + '...'
+                : tableFqn;
+            console.log((0, colors_1.dim)(`  ✓ ${displayTable}`));
+        }
+        // Execute validation query via SQL API
+        await client.post(`/v3/sql/${encodeURIComponent(connectionName)}/query`, {
+            q: validationSQL,
+            queryParameters: {}
+        });
+        // Success - table is accessible
+        return { accessible: true };
+    }
+    catch (err) {
+        // Extract meaningful error message from API response
+        let errorMsg = 'Unknown error';
+        if (err.message) {
+            errorMsg = err.message;
+            // Try to extract detail from API error JSON
+            try {
+                const match = err.message.match(/"detail":"([^"]+)"/);
+                if (match) {
+                    errorMsg = match[1];
+                }
+                else {
+                    // Try to extract just the main error message
+                    const errorMatch = err.message.match(/"error":"([^"]+)"/);
+                    if (errorMatch) {
+                        errorMsg = errorMatch[1];
+                    }
+                }
+            }
+            catch {
+                // Keep original error message if parsing fails
+            }
+        }
+        return {
+            accessible: false,
+            error: errorMsg
+        };
+    }
+}
+/**
+ * Copy a workflow from one profile to another
+ */
+async function workflowsCopy(workflowId, connectionName, sourceProfile, destProfile, options, token, baseUrl, jsonOutput, debug = false) {
+    try {
+        // Step 1: Create API clients for source and destination
+        const sourceClient = await api_1.ApiClient.create(token, baseUrl, debug, sourceProfile);
+        const destClient = await api_1.ApiClient.create(token, baseUrl, debug, destProfile);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Copying workflow ${workflowId} from ${sourceProfile} to ${destProfile}...`));
+        }
+        // Step 2: Fetch source workflow
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('→ Fetching source workflow...'));
+        }
+        const workflow = await sourceClient.get(`/v3/workflows/${workflowId}`);
+        if (!workflow.connectionId) {
+            throw new Error('Source workflow does not have a connectionId');
+        }
+        // Step 3: Get source connection details
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('→ Fetching source connection details...'));
+        }
+        const sourceConnection = await sourceClient.get(`/v3/connections/${workflow.connectionId}`);
+        const sourceConnectionName = sourceConnection.name;
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`→ Source connection: ${sourceConnectionName}`));
+        }
+        // Step 4: Resolve destination connection
+        const destConnectionName = connectionName || sourceConnectionName;
+        if (!jsonOutput) {
+            if (connectionName) {
+                console.log((0, colors_1.dim)(`→ Using destination connection: ${destConnectionName} (manual)`));
+            }
+            else {
+                console.log((0, colors_1.dim)(`→ Using destination connection: ${destConnectionName} (auto-mapped by name)`));
+            }
+        }
+        // Fetch destination connections
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('→ Fetching connections from destination...'));
+        }
+        const destConnections = await destClient.getAllPaginated('/v3/connections', {});
+        const destConnection = destConnections.data.find((c) => c.name === destConnectionName);
+        if (!destConnection) {
+            const errorMsg = [
+                `Connection "${destConnectionName}" not found in destination organization.`,
+                '',
+                'Solutions:',
+                '  1. Create the connection in destination organization',
+                '  2. Use --connection to specify a different destination connection name'
+            ].join('\n');
+            throw new Error(errorMsg);
+        }
+        const destConnectionId = destConnection.id;
+        // Step 5: Validate source tables (unless --skip-source-validation)
+        if (!options.skipSourceValidation) {
+            // Extract source tables from workflow config nodes
+            const sourceTables = [];
+            if (workflow.config && workflow.config.nodes && Array.isArray(workflow.config.nodes)) {
+                for (const node of workflow.config.nodes) {
+                    // Look for nodes that reference source tables
+                    // Common patterns: node.data.source, node.data.tableName, node.data.table
+                    if (node.data) {
+                        const source = node.data.source || node.data.tableName || node.data.table;
+                        if (source && typeof source === 'string' && source.includes('.')) {
+                            // Only include if it looks like a FQN (has dots) and not a temp table
+                            if (!source.startsWith('temp_') && !source.startsWith('tmp_')) {
+                                if (!sourceTables.includes(source)) {
+                                    sourceTables.push(source);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (sourceTables.length > 0) {
+                if (!jsonOutput) {
+                    console.log((0, colors_1.dim)(`→ Validating ${sourceTables.length} source table(s)...`));
+                }
+                const inaccessibleTables = [];
+                for (const tableFqn of sourceTables) {
+                    const result = await validateTableSource(destClient, destConnectionName, tableFqn, jsonOutput);
+                    if (!result.accessible) {
+                        inaccessibleTables.push({
+                            table: tableFqn,
+                            error: result.error
+                        });
+                    }
+                }
+                if (inaccessibleTables.length > 0) {
+                    const errorMsg = [
+                        'Source validation failed - workflow references inaccessible tables:',
+                        ...inaccessibleTables.map(t => `  • ${t.table}\n    Error: ${t.error}`),
+                        '',
+                        'Solutions:',
+                        '  1. Grant access to these tables in destination connection',
+                        '  2. Ensure tables exist in destination data warehouse',
+                        '  3. Use --skip-source-validation to create workflow anyway (may fail at runtime)'
+                    ].join('\n');
+                    throw new Error(errorMsg);
+                }
+                if (!jsonOutput) {
+                    console.log((0, colors_1.dim)(`→ All source table(s) validated successfully`));
+                }
+            }
+            else {
+                if (!jsonOutput) {
+                    console.log((0, colors_1.dim)('→ No source tables found to validate'));
+                }
+            }
+        }
+        // Step 6: Create workflow in destination
+        const newTitle = options.title || workflow.title || workflow.config?.title;
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`→ Creating workflow "${newTitle}" in destination...`));
+        }
+        // Update config with new title if provided
+        const updatedConfig = { ...workflow.config };
+        if (options.title) {
+            updatedConfig.title = options.title;
+        }
+        const workflowPayload = {
+            connectionId: destConnectionId,
+            config: updatedConfig,
+            client: 'carto-cli'
+        };
+        const newWorkflow = await destClient.post('/v3/workflows', workflowPayload);
+        const newWorkflowId = newWorkflow.id;
+        if (!newWorkflowId) {
+            throw new Error('Failed to create workflow in destination');
+        }
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                sourceWorkflowId: workflowId,
+                newWorkflowId: newWorkflowId,
+                sourceProfile: sourceProfile,
+                destProfile: destProfile,
+                sourceConnection: sourceConnectionName,
+                destConnection: destConnectionName,
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)(`\n✓ Workflow copied successfully!`));
+            console.log((0, colors_1.bold)('New Workflow ID: ') + newWorkflowId);
+            console.log((0, colors_1.dim)(`Source connection: ${sourceConnectionName} → Destination connection: ${destConnectionName}`));
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            console.log((0, colors_1.error)('✗ Failed to copy workflow: ' + err.message));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Remove a workflow schedule
+ */
+async function workflowScheduleRemove(workflowId, options, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Fetching workflow details...'));
+        }
+        // 1. Get workflow details
+        const workflow = await client.get(`/v3/workflows/${workflowId}`);
+        if (!workflow.connectionId) {
+            throw new Error('Workflow does not have a connectionId');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Workflow: ${workflow.title || workflow.config?.title || workflowId}`));
+            console.log((0, colors_1.dim)('Fetching connection details...'));
+        }
+        // 2. Get connection details
+        const connection = await client.get(`/v3/connections/${workflow.connectionId}`);
+        const connectionName = connection.name;
+        const region = connection.region || 'US';
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Connection: ${connectionName} (region: ${region})`));
+            console.log((0, colors_1.dim)('Removing schedule from data warehouse...'));
+        }
+        // 3. Delete schedule via SQL API
+        const schedulePath = `/v3/sql/${encodeURIComponent(connectionName)}/schedule/workflows.${workflowId}?region=${region}&client=workflows-schedule`;
+        await client.delete(schedulePath);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Updating workflow metadata...'));
+        }
+        // 4. Update workflow to remove schedule metadata from config
+        const updatedConfig = { ...workflow.config };
+        delete updatedConfig.schedule;
+        const updateBody = {
+            config: updatedConfig,
+            client: 'carto-cli'
+        };
+        await client.patch(`/v3/workflows/${workflowId}`, updateBody);
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                workflowId
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)(`\n✓ Schedule removed successfully`));
+            console.log((0, colors_1.bold)('Workflow: ') + workflowId);
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to remove schedule: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}