luxlabs 1.0.0

package/commands/workflows.js

@@ -0,0 +1,836 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const {
+  getApiUrl,
+  getStudioApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+  getOrgId,
+  getFlowsDir,
+  loadLocalFlow,
+  saveLocalFlow,
+  listLocalFlows,
+  deleteLocalFlow,
+} = require('../lib/config');
+const {
+  error,
+  success,
+  info,
+  formatJson,
+  formatTable,
+  requireArgs,
+  readFile,
+  parseJson,
+} = require('../lib/helpers');
+
+// Webhook helper functions
+const WEBHOOK_WORKER_URL = 'https://webhook-trigger-worker.jason-a5d.workers.dev';
+
+/**
+ * Get webhook token for a workflow
+ */
+async function getWebhookToken(workflowId) {
+  // Use container API URL for lux-api-2 routes
+  const containerUrl = process.env.CONTAINER_API_URL || 'http://localhost:8000';
+  const { data } = await axios.get(
+    `${containerUrl}/lux-api-2/workflows/${workflowId}/webhook-token`,
+    { headers: getAuthHeaders() }
+  );
+  return data;
+}
+
+/**
+ * Get captured webhook payload from worker
+ */
+async function getCapturedPayload(token) {
+  const { data } = await axios.get(
+    `${WEBHOOK_WORKER_URL}/listening/poll/${token}`
+  );
+  return data;
+}
+
+/**
+ * Get workflow draft config
+ */
+async function getWorkflowDraft(workflowId) {
+  const apiUrl = getApiUrl();
+  const { data } = await axios.get(
+    `${apiUrl}/api/workflows/${workflowId}/draft`,
+    { headers: getAuthHeaders() }
+  );
+  return data;
+}
+
+/**
+ * Save workflow draft config
+ */
+async function saveWorkflowDraft(workflowId, config) {
+  const apiUrl = getApiUrl();
+  await axios.put(
+    `${apiUrl}/api/workflows/${workflowId}/draft`,
+    { config },
+    { headers: getAuthHeaders() }
+  );
+}
+
+async function handleWorkflows(args) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  const command = args[0];
+
+  if (!command) {
+    console.log(`
+${chalk.bold('Usage:')} lux workflows <command> [args]
+
+${chalk.bold('Commands:')}
+  list                        List all workflows (from local storage)
+  get <id>                    Get workflow details with config
+  status <id>                 Show sync status for a workflow
+  create <name> [desc] [--publish]  Create workflow (use --publish to publish immediately)
+  init <name> [desc] [--publish]    Initialize workflow (alias for create)
+  save <id> <config-file>     Save draft config from file (local)
+  sync                        Sync published workflows from cloud
+  publish <id>                Publish workflow to cloud
+  delete <id>                 Delete a local workflow
+  diff <id>                   Show local vs published differences
+
+${chalk.bold('Sync Status:')}
+  draft     - Never published, local only
+  synced    - Matches published version
+  dirty     - Has local changes since publish
+  conflict  - Local changes + cloud has newer version
+
+${chalk.bold('Webhook Commands:')}
+  webhook-url <id>            Get webhook URL and status
+  webhook-listen <id>         Start listening session for webhook capture
+  webhook-poll <id>           Check for captured webhook payload
+  webhook-accept <id>         Accept webhook format and save variables
+  webhook-decline <id>        Decline webhook and reset session
+
+${chalk.bold('Examples:')}
+  lux workflows list
+  lux workflows get flow_123
+  lux workflows status flow_123
+  lux workflows create "My Workflow" "Description"
+  lux workflows create "My Workflow" --publish    # Create and publish immediately
+  lux flow init "My Workflow" --publish
+  lux workflows save flow_123 ./config.json
+  lux workflows sync
+  lux workflows publish flow_123
+  lux workflows diff flow_123
+
+  ${chalk.bold('Webhook workflow:')}
+  lux flow webhook-url flow_123
+  lux flow webhook-listen flow_123
+  lux flow webhook-poll flow_123
+  lux flow webhook-accept flow_123
+`);
+    process.exit(0);
+  }
+
+  // Use studio API (v2.uselux.ai) for workflow operations
+  const apiUrl = getStudioApiUrl();
+
+  try {
+    switch (command) {
+      case 'list': {
+        info('Loading workflows from local storage...');
+        const localFlows = listLocalFlows();
+
+        if (localFlows.length === 0) {
+          console.log('\n(No local workflows found)');
+          console.log(chalk.gray('Run "lux workflows sync" to sync from cloud, or "lux workflows create" to create one.\n'));
+        } else {
+          console.log(`\nFound ${localFlows.length} workflow(s):\n`);
+
+          // Color-code sync status
+          const statusColors = {
+            draft: chalk.gray,
+            synced: chalk.green,
+            dirty: chalk.yellow,
+            conflict: chalk.red,
+          };
+
+          const formatted = localFlows.map((w) => ({
+            id: w.id,
+            name: w.name,
+            sync: statusColors[w.syncStatus]?.(w.syncStatus) || w.syncStatus,
+            local_v: w.localVersion || 1,
+            published_v: w.publishedVersion || '-',
+            updated: w.updatedAt ? new Date(w.updatedAt).toLocaleDateString() : '-',
+          }));
+          formatTable(formatted);
+
+          // Show legend
+          console.log(chalk.gray('\nSync status: ') +
+            chalk.gray('draft') + ' | ' +
+            chalk.green('synced') + ' | ' +
+            chalk.yellow('dirty') + ' | ' +
+            chalk.red('conflict'));
+        }
+        break;
+      }
+
+      case 'status': {
+        requireArgs(args.slice(1), 1, 'lux workflows status <id>');
+        const workflowId = args[1];
+
+        const flow = loadLocalFlow(workflowId);
+        if (!flow) {
+          error(`Workflow not found locally: ${workflowId}`);
+          break;
+        }
+
+        // Determine sync status
+        let syncStatus = 'draft';
+        if (flow.publishedVersion) {
+          if (flow.cloudVersion && flow.cloudVersion > flow.publishedVersion) {
+            syncStatus = flow.localVersion > flow.publishedVersion ? 'conflict' : 'synced';
+          } else if (flow.localVersion > flow.publishedVersion) {
+            syncStatus = 'dirty';
+          } else {
+            syncStatus = 'synced';
+          }
+        }
+
+        const statusColors = {
+          draft: chalk.gray,
+          synced: chalk.green,
+          dirty: chalk.yellow,
+          conflict: chalk.red,
+        };
+
+        console.log(`\n📝 Workflow: ${flow.name}`);
+        console.log(`   ID: ${workflowId}`);
+        console.log(`   Sync Status: ${statusColors[syncStatus](syncStatus)}`);
+        console.log(`   Local Version: ${flow.localVersion || 1}`);
+        console.log(`   Published Version: ${flow.publishedVersion || '(never published)'}`);
+        console.log(`   Cloud Version: ${flow.cloudVersion || '(unknown)'}`);
+        console.log(`   Last Updated: ${flow.updatedAt || '(unknown)'}`);
+        console.log(`   Last Published: ${flow.lastPublishedAt || '(never)'}`);
+        console.log(`   Nodes: ${flow.nodes?.length || 0}`);
+        console.log(`   Edges: ${flow.edges?.length || 0}`);
+
+        if (syncStatus === 'conflict') {
+          console.log(chalk.red('\n⚠️  This workflow has conflicts with the cloud version.'));
+          console.log(chalk.gray('   Use the Lux Studio app to resolve conflicts.\n'));
+        } else if (syncStatus === 'dirty') {
+          console.log(chalk.yellow('\n📤 This workflow has unpublished local changes.'));
+          console.log(chalk.gray('   Run "lux workflows publish ' + workflowId + '" to publish.\n'));
+        }
+        break;
+      }
+
+      case 'sync': {
+        info('Syncing workflows from cloud...');
+
+        const { data } = await axios.get(`${apiUrl}/api/workflows?include_config=true`, {
+          headers: getAuthHeaders(),
+        });
+
+        const cloudFlows = data.workflows || [];
+        let synced = 0;
+        let newFromCloud = 0;
+        let conflicts = 0;
+
+        for (const cloudFlow of cloudFlows) {
+          // Only sync published flows
+          if (cloudFlow.status !== 'published') continue;
+
+          const localFlow = loadLocalFlow(cloudFlow.id);
+          const now = new Date().toISOString();
+
+          if (!localFlow) {
+            // New from cloud
+            const newFlow = {
+              id: cloudFlow.id,
+              name: cloudFlow.name,
+              description: cloudFlow.description,
+              nodes: cloudFlow.config?.nodes || [],
+              edges: cloudFlow.config?.edges || [],
+              localVersion: cloudFlow.version || 1,
+              publishedVersion: cloudFlow.version || 1,
+              cloudVersion: cloudFlow.version || 1,
+              lastSyncedAt: now,
+              createdAt: cloudFlow.updated_at || cloudFlow.created_at,
+              updatedAt: cloudFlow.updated_at,
+            };
+            saveLocalFlow(cloudFlow.id, newFlow);
+            newFromCloud++;
+          } else {
+            const hasLocalChanges = localFlow.publishedVersion
+              ? localFlow.localVersion > localFlow.publishedVersion
+              : true;
+            const cloudVersion = cloudFlow.version || 1;
+            const cloudHasNewerVersion = cloudVersion > (localFlow.cloudVersion || 0);
+
+            if (hasLocalChanges && cloudHasNewerVersion) {
+              // Conflict
+              const updatedFlow = {
+                ...localFlow,
+                cloudVersion,
+                lastSyncedAt: now,
+                cloudData: {
+                  nodes: cloudFlow.config?.nodes || [],
+                  edges: cloudFlow.config?.edges || [],
+                  version: cloudVersion,
+                  updatedAt: cloudFlow.updated_at,
+                },
+              };
+              saveLocalFlow(cloudFlow.id, updatedFlow);
+              conflicts++;
+            } else if (cloudHasNewerVersion && !hasLocalChanges) {
+              // Update from cloud
+              const updatedFlow = {
+                ...localFlow,
+                name: cloudFlow.name,
+                description: cloudFlow.description,
+                nodes: cloudFlow.config?.nodes || [],
+                edges: cloudFlow.config?.edges || [],
+                localVersion: cloudVersion,
+                publishedVersion: cloudVersion,
+                cloudVersion,
+                lastSyncedAt: now,
+                updatedAt: cloudFlow.updated_at,
+              };
+              saveLocalFlow(cloudFlow.id, updatedFlow);
+              synced++;
+            } else {
+              // Up to date
+              const updatedFlow = {
+                ...localFlow,
+                cloudVersion,
+                lastSyncedAt: now,
+              };
+              saveLocalFlow(cloudFlow.id, updatedFlow);
+            }
+          }
+        }
+
+        success('Sync complete!');
+        console.log(`   Synced: ${synced}`);
+        console.log(`   New from cloud: ${newFromCloud}`);
+        if (conflicts > 0) {
+          console.log(chalk.red(`   Conflicts: ${conflicts}`));
+          console.log(chalk.gray('\n   Use "lux workflows list" to see workflows with conflicts.'));
+        }
+        break;
+      }
+
+      case 'delete': {
+        requireArgs(args.slice(1), 1, 'lux workflows delete <id>');
+        const workflowId = args[1];
+
+        const flow = loadLocalFlow(workflowId);
+        if (!flow) {
+          error(`Workflow not found locally: ${workflowId}`);
+          break;
+        }
+
+        if (flow.publishedVersion) {
+          console.log(chalk.yellow(`\n⚠️  Warning: "${flow.name}" has been published.`));
+          console.log(chalk.gray('   This only deletes the local copy. The published version remains in the cloud.\n'));
+        }
+
+        deleteLocalFlow(workflowId);
+        success(`Deleted local workflow: ${flow.name}`);
+        break;
+      }
+
+      case 'get': {
+        requireArgs(args.slice(1), 1, 'lux workflows get <id>');
+        const workflowId = args[1];
+
+        info(`Loading workflow: ${workflowId}`);
+        const { data } = await axios.get(
+          `${apiUrl}/api/workflows/${workflowId}`,
+          { headers: getAuthHeaders() }
+        );
+
+        if (!data.workflow) {
+          error(`Workflow not found: ${workflowId}`);
+        }
+
+        const workflow = data.workflow;
+
+        console.log(`\n📝 Name: ${workflow.name}`);
+        console.log(`📊 Status: ${workflow.status}`);
+        console.log(`🔢 Version: ${workflow.version}`);
+        console.log(`📅 Created: ${workflow.created_at}`);
+        console.log(`📅 Updated: ${workflow.updated_at}`);
+
+        if (workflow.config) {
+          console.log(`\n📋 Current Config:\n`);
+          console.log(formatJson(workflow.config));
+        }
+
+        break;
+      }
+
+      case 'create':
+      case 'init': {
+        // Check for --publish flag
+        const publishFlagIndex = args.indexOf('--publish');
+        const shouldPublish = publishFlagIndex !== -1;
+        if (shouldPublish) {
+          args.splice(publishFlagIndex, 1); // Remove flag from args
+        }
+
+        requireArgs(args.slice(1), 1, 'lux workflows create <name> [description] [--publish]');
+        const name = args[1];
+        const description = args[2] || '';
+
+        // Slugify the name for the flow ID
+        const slug = name
+          .toLowerCase()
+          .replace(/[^a-z0-9]+/g, '-')
+          .replace(/^-|-$/g, '');
+        const flowId = `${slug}-flow`;
+
+        // Check if flow already exists
+        const existingFlow = loadLocalFlow(flowId);
+        if (existingFlow) {
+          error(`Flow already exists: ${flowId}`);
+          console.log(chalk.gray(`Use a different name or delete the existing flow first.`));
+          break;
+        }
+
+        const now = new Date().toISOString();
+
+        // Create locally only - no API call
+        const newFlow = {
+          id: flowId,
+          name,
+          description,
+          nodes: [],
+          edges: [],
+          localVersion: 1,
+          createdAt: now,
+          updatedAt: now,
+        };
+
+        info(`Creating local workflow: ${name}`);
+
+        if (saveLocalFlow(flowId, newFlow)) {
+          success(`Workflow created locally!`);
+          console.log(`   ID: ${flowId}`);
+
+          // If --publish flag was provided, publish immediately
+          if (shouldPublish) {
+            info(`Publishing workflow to cloud...`);
+
+            try {
+              const publishConfig = {
+                nodes: newFlow.nodes || [],
+                edges: newFlow.edges || [],
+                variables: newFlow.variables || {},
+                metadata: newFlow.metadata || {},
+              };
+
+              // Step 1: Create workflow in cloud database (this generates a cloud UUID)
+              const createResponse = await axios.post(
+                `${apiUrl}/api/workflows`,
+                {
+                  name: newFlow.name,
+                  description: newFlow.description,
+                  config: publishConfig,
+                },
+                { headers: getAuthHeaders() }
+              );
+
+              const cloudId = createResponse.data.workflow?.id || createResponse.data.workflow?.workflow_id;
+              if (!cloudId) {
+                throw new Error('No workflow ID returned from cloud');
+              }
+
+              info(`Created in cloud with ID: ${cloudId}`);
+
+              // Step 2: Publish the workflow (copies draft config to published)
+              const publishResponse = await axios.post(
+                `${apiUrl}/api/workflows/${cloudId}/publish`,
+                {},
+                { headers: getAuthHeaders() }
+              );
+
+              const newVersion = publishResponse.data.version || 1;
+
+              // Update local storage with published version and cloud ID
+              const updatedFlow = {
+                ...newFlow,
+                cloudId: cloudId,
+                publishedVersion: newVersion,
+                cloudVersion: newVersion,
+                lastPublishedAt: new Date().toISOString(),
+                lastSyncedAt: new Date().toISOString(),
+              };
+              saveLocalFlow(flowId, updatedFlow);
+
+              success('Workflow published!');
+              console.log(`   Cloud ID: ${cloudId}`);
+              console.log(`   Status: ${chalk.green('published')}`);
+              console.log(`   Version: ${newVersion}`);
+            } catch (publishError) {
+              error(`Failed to publish: ${publishError.response?.data?.error || publishError.message}`);
+              console.log(`   Status: ${chalk.gray('draft')}`);
+              console.log(chalk.gray(`\nRun "lux workflows publish ${flowId}" to try again.`));
+            }
+          } else {
+            console.log(`   Status: ${chalk.gray('draft')}`);
+            console.log(chalk.gray(`\n   This workflow is local only. Run "lux workflows publish ${flowId}" to publish to cloud.`));
+          }
+        } else {
+          error('Failed to create workflow. Make sure you are authenticated.');
+        }
+        break;
+      }
+
+      case 'save': {
+        requireArgs(args.slice(1), 2, 'lux workflows save <id> <config-file>');
+        const workflowId = args[1];
+        const configFile = args[2];
+
+        // Load existing local flow
+        const existingFlow = loadLocalFlow(workflowId);
+        if (!existingFlow) {
+          error(`Workflow not found locally: ${workflowId}`);
+          console.log(chalk.gray('Run "lux workflows sync" to sync from cloud first.'));
+          break;
+        }
+
+        info(`Reading config from: ${configFile}`);
+        const configJson = readFile(configFile);
+        const config = parseJson(configJson, 'workflow config');
+
+        // Update local flow with new config
+        const updatedFlow = {
+          ...existingFlow,
+          nodes: config.nodes || existingFlow.nodes,
+          edges: config.edges || existingFlow.edges,
+          localVersion: (existingFlow.localVersion || 1) + 1,
+          updatedAt: new Date().toISOString(),
+        };
+
+        info(`Saving to local storage: ${workflowId}`);
+        if (saveLocalFlow(workflowId, updatedFlow)) {
+          success('Workflow saved locally!');
+          console.log(`   Local Version: ${updatedFlow.localVersion}`);
+
+          // Show sync status
+          const hasPublished = existingFlow.publishedVersion;
+          if (!hasPublished) {
+            console.log(`   Status: ${chalk.gray('draft')}`);
+          } else if (updatedFlow.localVersion > existingFlow.publishedVersion) {
+            console.log(`   Status: ${chalk.yellow('dirty')} (has unpublished changes)`);
+          }
+
+          console.log(chalk.gray(`\nRun "lux workflows publish ${workflowId}" to publish to cloud.`));
+        } else {
+          error('Failed to save workflow locally.');
+        }
+        break;
+      }
+
+      case 'publish': {
+        requireArgs(args.slice(1), 1, 'lux workflows publish <id>');
+        const workflowId = args[1];
+
+        // Load local flow
+        const localFlow = loadLocalFlow(workflowId);
+        if (!localFlow) {
+          error(`Workflow not found locally: ${workflowId}`);
+          console.log(chalk.gray('Run "lux workflows sync" to sync from cloud first.'));
+          break;
+        }
+
+        // Check for conflicts
+        if (localFlow.cloudVersion && localFlow.publishedVersion &&
+            localFlow.cloudVersion > localFlow.publishedVersion &&
+            localFlow.localVersion > localFlow.publishedVersion) {
+          error('Cannot publish: workflow has conflicts with cloud version.');
+          console.log(chalk.gray('Resolve conflicts in Lux Studio first.'));
+          break;
+        }
+
+        info(`Publishing workflow: ${workflowId}`);
+
+        // Publish directly to cloud with config in request body
+        const publishConfig = {
+          nodes: localFlow.nodes || [],
+          edges: localFlow.edges || [],
+          variables: localFlow.variables || {},
+          metadata: localFlow.metadata || {},
+        };
+
+        const { data } = await axios.post(
+          `${apiUrl}/api/workflows/${workflowId}/publish`,
+          {
+            name: localFlow.name,
+            description: localFlow.description,
+            config: publishConfig,
+          },
+          { headers: getAuthHeaders() }
+        );
+
+        const newVersion = data.version || (localFlow.publishedVersion || 0) + 1;
+
+        // Update local storage with new published version
+        const updatedFlow = {
+          ...localFlow,
+          publishedVersion: newVersion,
+          cloudVersion: newVersion,
+          lastPublishedAt: new Date().toISOString(),
+          lastSyncedAt: new Date().toISOString(),
+          cloudData: undefined, // Clear any stored conflict data
+        };
+        saveLocalFlow(workflowId, updatedFlow);
+
+        success('Workflow published!');
+        console.log(`   Name: ${localFlow.name}`);
+        console.log(`   Version: ${newVersion}`);
+        console.log(`   Status: ${chalk.green('synced')}`);
+        break;
+      }
+
+      case 'diff': {
+        requireArgs(args.slice(1), 1, 'lux workflows diff <id>');
+        const workflowId = args[1];
+
+        // Load local flow
+        const localFlow = loadLocalFlow(workflowId);
+        if (!localFlow) {
+          error(`Workflow not found locally: ${workflowId}`);
+          break;
+        }
+
+        info(`Comparing local vs published for: ${workflowId}`);
+
+        const localConfig = {
+          nodes: localFlow.nodes || [],
+          edges: localFlow.edges || [],
+        };
+
+        // Check if never published
+        if (!localFlow.publishedVersion) {
+          console.log('\n📝 NEW WORKFLOW (not yet published)\n');
+          console.log(`   Name: ${localFlow.name}`);
+          console.log(`   Local Version: ${localFlow.localVersion || 1}`);
+          console.log(`   Nodes: ${localConfig.nodes.length}`);
+          console.log(`   Edges: ${localConfig.edges.length}`);
+          console.log(chalk.gray(`\nRun "lux workflows publish ${workflowId}" to publish.\n`));
+          break;
+        }
+
+        // Check for conflicts
+        if (localFlow.cloudData) {
+          console.log('\n⚠️  CONFLICT DETECTED\n');
+          console.log('Local version:');
+          console.log(`   Version: ${localFlow.localVersion}`);
+          console.log(`   Nodes: ${localConfig.nodes.length}`);
+          console.log(`   Edges: ${localConfig.edges.length}`);
+          console.log('\nCloud version:');
+          console.log(`   Version: ${localFlow.cloudData.version}`);
+          console.log(`   Nodes: ${localFlow.cloudData.nodes?.length || 0}`);
+          console.log(`   Edges: ${localFlow.cloudData.edges?.length || 0}`);
+          console.log(`   Updated: ${localFlow.cloudData.updatedAt}`);
+          console.log(chalk.gray('\nResolve this conflict in Lux Studio.\n'));
+          break;
+        }
+
+        // Check if has local changes
+        const hasLocalChanges = localFlow.localVersion > localFlow.publishedVersion;
+
+        if (!hasLocalChanges) {
+          success('No changes - local matches published version');
+          console.log(`   Published Version: ${localFlow.publishedVersion}`);
+        } else {
+          console.log('\n📊 LOCAL CHANGES (unpublished)\n');
+          console.log(`   Local Version: ${localFlow.localVersion}`);
+          console.log(`   Published Version: ${localFlow.publishedVersion}`);
+          console.log(`   Nodes: ${localConfig.nodes.length}`);
+          console.log(`   Edges: ${localConfig.edges.length}`);
+          console.log(chalk.gray(`\nRun "lux workflows publish ${workflowId}" to publish changes.\n`));
+        }
+        break;
+      }
+
+      case 'webhook-url': {
+        requireArgs(args.slice(1), 1, 'lux flow webhook-url <flow-id>');
+        const workflowId = args[1];
+
+        info(`Getting webhook URL for: ${workflowId}`);
+        const tokenData = await getWebhookToken(workflowId);
+
+        console.log(`\n📍 Webhook URL:\n${tokenData.webhookUrl}\n`);
+        console.log(`📊 Status:`);
+        console.log(`   Format Confirmed: ${tokenData.formatConfirmed ? '✅ Yes' : '❌ No'}`);
+        console.log(`   Webhook Trigger Enabled: ${tokenData.webhookTrigger ? '✅ Yes' : '❌ No'}\n`);
+
+        if (!tokenData.formatConfirmed) {
+          console.log(chalk.yellow('ℹ️  Run "lux flow webhook-listen" to capture a sample webhook'));
+        }
+        break;
+      }
+
+      case 'webhook-listen': {
+        requireArgs(args.slice(1), 1, 'lux flow webhook-listen <flow-id>');
+        const workflowId = args[1];
+
+        info(`Starting webhook listening session for: ${workflowId}`);
+        const tokenData = await getWebhookToken(workflowId);
+
+        // Start listening session
+        await axios.post(`${WEBHOOK_WORKER_URL}/listening/start/${tokenData.token}`);
+
+        success('Listening session started!');
+        console.log(`\n📡 Now listening for webhooks at:\n${tokenData.webhookUrl}\n`);
+        console.log('Session expires in 5 minutes.');
+        console.log(`\nSend a webhook request to the URL above, then run:`);
+        console.log(chalk.white(`   lux flow webhook-poll ${workflowId}\n`));
+        break;
+      }
+
+      case 'webhook-poll': {
+        requireArgs(args.slice(1), 1, 'lux flow webhook-poll <flow-id>');
+        const workflowId = args[1];
+
+        const tokenData = await getWebhookToken(workflowId);
+        const pollData = await getCapturedPayload(tokenData.token);
+
+        // Return raw JSON response
+        console.log(formatJson(pollData));
+        break;
+      }
+
+      case 'webhook-accept': {
+        requireArgs(args.slice(1), 1, 'lux flow webhook-accept <flow-id>');
+        const workflowId = args[1];
+
+        info(`Accepting webhook format for: ${workflowId}`);
+
+        // Step 1: Get webhook token
+        const tokenData = await getWebhookToken(workflowId);
+
+        // Step 2: Poll for captured payload
+        const pollData = await getCapturedPayload(tokenData.token);
+
+        // Check if payload was captured
+        if (pollData.waiting || !pollData.payload) {
+          error('No webhook captured. Run "lux flow webhook-listen" first and send a test webhook.');
+          break;
+        }
+
+        const capturedPayload = pollData.payload;
+
+        // Step 3: Transform payload into schema
+        info('Creating webhook schema from captured payload...');
+        const schema = {};
+
+        Object.entries(capturedPayload).forEach(([key, value]) => {
+          const varType =
+            typeof value === 'number' ? 'number' :
+            typeof value === 'boolean' ? 'boolean' : 'string';
+
+          schema[key] = {
+            type: varType,
+            description: `Webhook parameter: ${key}`,
+            example: value,
+          };
+        });
+
+        // Step 4: Save schema to database (does NOT set format_confirmed yet)
+        info('Saving webhook schema to database...');
+        const containerUrl = process.env.CONTAINER_API_URL || 'http://localhost:8000';
+        await axios.put(`${containerUrl}/lux-api-2/webhooks/${tokenData.token}/schema`, {
+          schema,
+        }, {
+          headers: getAuthHeaders(),
+        });
+
+        // Step 5: Call worker accept endpoint (if not already confirmed)
+        info('Confirming webhook format with worker...');
+        let alreadyConfirmed = false;
+        try {
+          await axios.post(`${WEBHOOK_WORKER_URL}/listening/accept/${tokenData.token}`);
+        } catch (workerError) {
+          const errorMessage = workerError.response?.data?.error || '';
+          if (errorMessage.includes('already confirmed')) {
+            alreadyConfirmed = true;
+            info('Webhook already confirmed, updating schema only...');
+          } else {
+            throw workerError;
+          }
+        }
+
+        // Step 6: ONLY if worker accepted (first time), set format_confirmed to 1
+        if (!alreadyConfirmed) {
+          info('Setting format_confirmed flag...');
+          await axios.post(`${containerUrl}/lux-api-2/webhooks/${tokenData.token}/confirm`, {}, {
+            headers: getAuthHeaders(),
+          });
+        }
+
+        success('Webhook format updated!');
+        console.log(`\n✅ Captured schema with ${Object.keys(schema).length} parameters`);
+        console.log(`✅ Schema saved to database`);
+        if (!alreadyConfirmed) {
+          console.log(`✅ Worker accepted format`);
+          console.log(`✅ Format confirmed`);
+        } else {
+          console.log(`✅ Schema updated (already confirmed)`);
+        }
+        console.log('');
+
+        // Show the schema
+        console.log('Captured schema:');
+        Object.entries(schema).forEach(([key, value]) => {
+          console.log(`  ${key}: ${value.type}`);
+        });
+        console.log('');
+        break;
+      }
+
+      case 'webhook-decline': {
+        requireArgs(args.slice(1), 1, 'lux flow webhook-decline <flow-id>');
+        const workflowId = args[1];
+
+        info(`Declining webhook format for: ${workflowId}`);
+        const tokenData = await getWebhookToken(workflowId);
+
+        // Clear webhook schema from database
+        info('Clearing webhook schema...');
+        const containerUrl = process.env.CONTAINER_API_URL || 'http://localhost:8000';
+        await axios.delete(`${containerUrl}/lux-api-2/webhooks/${tokenData.token}/schema`, {
+          headers: getAuthHeaders(),
+        });
+
+        // Call worker decline endpoint (clears listening session)
+        await axios.delete(`${WEBHOOK_WORKER_URL}/listening/decline/${tokenData.token}`);
+
+        success('Webhook format declined!');
+        console.log('\n✅ Schema cleared from database');
+        console.log('✅ Listening session has been reset');
+        console.log(`\nRun "lux flow webhook-listen ${workflowId}" to try again.\n`);
+        break;
+      }
+
+      default:
+        error(
+          `Unknown command: ${command}\n\nRun 'lux workflows' to see available commands`
+        );
+    }
+  } catch (err) {
+    const errorMessage =
+      err.response?.data?.error || err.message || 'Unknown error';
+    error(`${errorMessage}`);
+  }
+}
+
+module.exports = { handleWorkflows };