luxlabs 1.0.16 → 1.0.17

package/commands/webview.js

@@ -233,6 +233,27 @@ async function wait(interfaceId, ms) {
   return result;
 }
 
+/**
+ * Refresh the webview (soft or hard refresh)
+ */
+async function refresh(interfaceId, hard = false) {
+  const id = generateId();
+  const result = await sendCommand({
+    id,
+    type: 'refresh',
+    appId: interfaceId,
+    payload: { hard },
+  });
+
+  if (result.success) {
+    console.log(chalk.green(hard ? 'Hard refresh completed!' : 'Refresh completed!'));
+  } else {
+    console.log(chalk.red('Refresh failed:'), result.error);
+  }
+
+  return result;
+}
+
 /**
  * Start the interface preview in Lux Studio
  */
@@ -265,6 +286,7 @@ function showHelp() {
   console.log('  lux test url <interface-id>                       Get current URL');
   console.log('  lux test navigate <interface-id> <url>            Navigate to URL');
   console.log('  lux test wait <interface-id> <ms>                 Wait for duration');
+  console.log('  lux test refresh <interface-id> [--hard]          Refresh the page');
   console.log('');
   console.log(chalk.cyan('Examples:'));
   console.log('  lux test screenshot my-interface ./screenshot.png');
@@ -272,6 +294,7 @@ function showHelp() {
   console.log('  lux test type my-interface "#email" "user@example.com"');
   console.log('  lux test eval my-interface "document.title"');
   console.log('  lux test navigate my-interface "http://localhost:3000/login"');
+  console.log('  lux test refresh my-interface --hard');
   console.log('');
   console.log(chalk.dim('Note: <interface-id> is the interface ID or name from "lux servers"'));
   console.log('');
@@ -370,6 +393,18 @@ async function handleTest(args = []) {
         break;
       }
 
+      case 'refresh': {
+        const [interfaceId, ...flags] = rest;
+        if (!interfaceId) {
+          console.log(chalk.red('Error: interface-id is required'));
+          showHelp();
+          return;
+        }
+        const hard = flags.includes('--hard') || flags.includes('-h');
+        await refresh(interfaceId, hard);
+        break;
+      }
+
       default:
         console.log(chalk.red(`Unknown test command: ${subcommand}`));
         showHelp();
@@ -388,6 +423,7 @@ module.exports = {
   getUrl,
   navigate,
   wait,
+  refresh,
   startPreview,
   sendCommand,
 };

package/commands/workflows.js

@@ -102,6 +102,11 @@ ${chalk.bold('Commands:')}
   delete <id>                 Delete a local workflow
   diff <id>                   Show local vs published differences
 
+${chalk.bold('Execution History:')}
+  executions <flow-id> [--limit N]  List execution history for a flow
+  execution <flow-id> <exec-id>     Get full execution details
+  node <flow-id> <exec-id> <node-id>  Get specific node execution details
+
 ${chalk.bold('Sync Status:')}
   draft     - Never published, local only
   synced    - Matches published version
@@ -127,6 +132,12 @@ ${chalk.bold('Examples:')}
   lux workflows publish flow_123
   lux workflows diff flow_123
 
+  ${chalk.bold('Execution history:')}
+  lux flow executions my-flow-id
+  lux flow executions my-flow-id --limit 50
+  lux flow execution my-flow-id exec_abc123
+  lux flow node my-flow-id exec_abc123 node-1
+
   ${chalk.bold('Webhook workflow:')}
   lux flow webhook-url flow_123
   lux flow webhook-listen flow_123
@@ -851,6 +862,229 @@ ${chalk.bold('Examples:')}
         break;
       }
 
+      // ============ EXECUTION HISTORY COMMANDS ============
+
+      case 'executions': {
+        requireArgs(args.slice(1), 1, 'lux flow executions <flow-id> [--limit N]');
+        const flowId = args[1];
+
+        // Parse --limit flag
+        const limitIndex = args.indexOf('--limit');
+        const limit = limitIndex !== -1 && args[limitIndex + 1] ? parseInt(args[limitIndex + 1], 10) : 20;
+
+        info(`Fetching execution history for: ${flowId}`);
+
+        const { data } = await axios.get(
+          `${apiUrl}/api/flows/${flowId}/executions?limit=${limit}`,
+          { headers: getAuthHeaders() }
+        );
+
+        if (!data.executions || data.executions.length === 0) {
+          console.log(chalk.dim('\nNo executions found for this flow.\n'));
+          break;
+        }
+
+        console.log(`\n📊 Execution History for: ${flowId}\n`);
+
+        // Status colors
+        const statusColors = {
+          completed: chalk.green,
+          running: chalk.cyan,
+          failed: chalk.red,
+          cancelled: chalk.yellow,
+        };
+
+        const formatted = data.executions.map((exec) => {
+          const statusColor = statusColors[exec.status] || chalk.white;
+          const duration = exec.durationMs ? `${exec.durationMs}ms` : '-';
+          const startedAt = exec.startedAt ? new Date(exec.startedAt).toLocaleString() : '-';
+          const nodeCount = exec.nodeExecutions?.length || 0;
+
+          return {
+            id: exec.id.substring(0, 16) + '...',
+            status: statusColor(exec.status),
+            trigger: exec.triggerType || '-',
+            duration: duration,
+            nodes: nodeCount,
+            started: startedAt,
+            test: exec.isTest ? chalk.yellow('test') : '',
+          };
+        });
+
+        formatTable(formatted);
+
+        if (data.pagination?.hasMore) {
+          console.log(chalk.dim(`\nShowing ${data.executions.length} of ${data.pagination.total} executions.`));
+          console.log(chalk.dim(`Use --limit N to see more.\n`));
+        }
+
+        console.log(chalk.gray(`\nTo see full details: lux flow execution ${flowId} <execution-id>\n`));
+        break;
+      }
+
+      case 'execution': {
+        requireArgs(args.slice(1), 2, 'lux flow execution <flow-id> <execution-id>');
+        const flowId = args[1];
+        const executionId = args[2];
+
+        info(`Fetching execution: ${executionId}`);
+
+        const { data } = await axios.get(
+          `${apiUrl}/api/flows/${flowId}/executions/${executionId}`,
+          { headers: getAuthHeaders() }
+        );
+
+        if (!data.execution) {
+          error(`Execution not found: ${executionId}`);
+          break;
+        }
+
+        const exec = data.execution;
+        const statusColors = {
+          completed: chalk.green,
+          running: chalk.cyan,
+          failed: chalk.red,
+          cancelled: chalk.yellow,
+        };
+        const statusColor = statusColors[exec.status] || chalk.white;
+
+        console.log(`\n📋 Execution Details\n`);
+        console.log(`   ID: ${exec.id}`);
+        console.log(`   Flow: ${exec.flowId}`);
+        console.log(`   Status: ${statusColor(exec.status)}`);
+        console.log(`   Trigger: ${exec.triggerType || '-'}`);
+        console.log(`   Duration: ${exec.durationMs ? exec.durationMs + 'ms' : '-'}`);
+        console.log(`   Started: ${exec.startedAt ? new Date(exec.startedAt).toLocaleString() : '-'}`);
+        console.log(`   Completed: ${exec.completedAt ? new Date(exec.completedAt).toLocaleString() : '-'}`);
+        console.log(`   Version: ${exec.flowVersion || '-'}`);
+        console.log(`   Test Run: ${exec.isTest ? chalk.yellow('Yes') : 'No'}`);
+
+        if (exec.error) {
+          console.log(`\n${chalk.red('❌ Error:')}`);
+          console.log(`   ${exec.error}`);
+        }
+
+        // Show input data
+        if (exec.inputData && Object.keys(exec.inputData).length > 0) {
+          console.log(`\n${chalk.cyan('📥 Input Data:')}`);
+          console.log(formatJson(exec.inputData));
+        }
+
+        // Show output data
+        if (exec.outputData && Object.keys(exec.outputData).length > 0) {
+          console.log(`\n${chalk.cyan('📤 Output Data:')}`);
+          console.log(formatJson(exec.outputData));
+        }
+
+        // Show node executions summary
+        if (exec.nodeExecutions && exec.nodeExecutions.length > 0) {
+          console.log(`\n${chalk.cyan('🔗 Node Executions:')} (${exec.nodeExecutions.length} nodes)\n`);
+
+          const nodeFormatted = exec.nodeExecutions.map((node) => {
+            const nodeStatus = node.status || 'unknown';
+            const nodeStatusColor = statusColors[nodeStatus] || chalk.white;
+            const nodeDuration = node.durationMs ? `${node.durationMs}ms` : '-';
+
+            return {
+              node_id: node.nodeId || node.id,
+              type: node.nodeType || '-',
+              status: nodeStatusColor(nodeStatus),
+              duration: nodeDuration,
+              error: node.error ? chalk.red('⚠') : '',
+            };
+          });
+
+          formatTable(nodeFormatted);
+
+          console.log(chalk.gray(`\nTo see node details: lux flow node ${flowId} ${executionId} <node-id>\n`));
+        }
+
+        break;
+      }
+
+      case 'node': {
+        requireArgs(args.slice(1), 3, 'lux flow node <flow-id> <execution-id> <node-id>');
+        const flowId = args[1];
+        const executionId = args[2];
+        const nodeId = args[3];
+
+        info(`Fetching node execution: ${nodeId}`);
+
+        const { data } = await axios.get(
+          `${apiUrl}/api/flows/${flowId}/executions/${executionId}`,
+          { headers: getAuthHeaders() }
+        );
+
+        if (!data.execution) {
+          error(`Execution not found: ${executionId}`);
+          break;
+        }
+
+        const exec = data.execution;
+        const nodeExec = exec.nodeExecutions?.find(
+          (n) => n.nodeId === nodeId || n.id === nodeId
+        );
+
+        if (!nodeExec) {
+          error(`Node not found in execution: ${nodeId}`);
+          console.log(chalk.dim(`\nAvailable nodes:`));
+          exec.nodeExecutions?.forEach((n) => {
+            console.log(chalk.dim(`  - ${n.nodeId || n.id} (${n.nodeType || 'unknown'})`));
+          });
+          break;
+        }
+
+        const statusColors = {
+          completed: chalk.green,
+          running: chalk.cyan,
+          failed: chalk.red,
+          cancelled: chalk.yellow,
+          skipped: chalk.gray,
+        };
+        const statusColor = statusColors[nodeExec.status] || chalk.white;
+
+        console.log(`\n🔗 Node Execution Details\n`);
+        console.log(`   Node ID: ${nodeExec.nodeId || nodeExec.id}`);
+        console.log(`   Type: ${nodeExec.nodeType || '-'}`);
+        console.log(`   Label: ${nodeExec.label || '-'}`);
+        console.log(`   Status: ${statusColor(nodeExec.status || 'unknown')}`);
+        console.log(`   Duration: ${nodeExec.durationMs ? nodeExec.durationMs + 'ms' : '-'}`);
+        console.log(`   Started: ${nodeExec.startedAt ? new Date(nodeExec.startedAt).toLocaleString() : '-'}`);
+        console.log(`   Completed: ${nodeExec.completedAt ? new Date(nodeExec.completedAt).toLocaleString() : '-'}`);
+
+        if (nodeExec.error) {
+          console.log(`\n${chalk.red('❌ Error:')}`);
+          console.log(`   ${nodeExec.error}`);
+        }
+
+        // Show node config
+        if (nodeExec.config && Object.keys(nodeExec.config).length > 0) {
+          console.log(`\n${chalk.cyan('⚙️  Node Config:')}`);
+          console.log(formatJson(nodeExec.config));
+        }
+
+        // Show input
+        if (nodeExec.input !== undefined) {
+          console.log(`\n${chalk.cyan('📥 Input:')}`);
+          console.log(formatJson(nodeExec.input));
+        }
+
+        // Show output
+        if (nodeExec.output !== undefined) {
+          console.log(`\n${chalk.cyan('📤 Output:')}`);
+          console.log(formatJson(nodeExec.output));
+        }
+
+        // Show raw data if nothing else
+        if (!nodeExec.input && !nodeExec.output && !nodeExec.config) {
+          console.log(`\n${chalk.cyan('📋 Raw Node Data:')}`);
+          console.log(formatJson(nodeExec));
+        }
+
+        console.log('');
+        break;
+      }
+
       default:
         error(
           `Unknown command: ${command}\n\nRun 'lux workflows' to see available commands`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luxlabs",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "CLI tool for Lux - Upload and deploy interfaces from your terminal",
   "author": "Jason Henkel <jason@uselux.ai>",
   "license": "SEE LICENSE IN LICENSE",