@sembix/cli 1.2.1 → 1.4.0

package/dist/commands/workflow.js

@@ -0,0 +1,1201 @@
+// Node.js built-ins
+import { readFile } from 'fs/promises';
+// Internal utilities
+import { getAuthenticatedProfile } from '../utils/studio-config.js';
+import { readProfile } from '../utils/config-file.js';
+import { isInteractive } from '../utils/environment.js';
+import { addRecentWorkflow } from '../utils/recent-workflows.js';
+import * as ui from '../utils/ui.js';
+import { getOutputFormat, outputSuccess, outputError } from '../utils/output.js';
+// Services
+import { StudioApiClient } from '../services/studio-api-client.js';
+export async function workflowStartCommand(options) {
+    try {
+        // Determine output format
+        const format = getOutputFormat(options);
+        // Show UI elements only in TEXT mode
+        console.log();
+        ui.banner('Start Workflow Execution');
+        console.log();
+        // Load profile and validate authentication
+        const { profile, tokens } = await getAuthenticatedProfile(options.profile);
+        // Create API client
+        const apiClient = new StudioApiClient(profile, tokens);
+        // Handle project selection
+        let projectId = options.projectId;
+        let projectName;
+        if (!projectId) {
+            // Check if in interactive mode
+            if (!isInteractive()) {
+                // Non-interactive mode requires explicit project ID
+                const profileConfig = await readProfile(options.profile);
+                if (profileConfig?.defaultProjectId) {
+                    throw new Error(`Missing required argument: --project-id\n\n` +
+                        `Default project is set for profile '${profile.name}' but not being used in non-interactive mode.\n` +
+                        `Use: --project-id ${profileConfig.defaultProjectId}`);
+                }
+                else {
+                    throw new Error(`Missing required argument: --project-id\n\n` +
+                        `In non-interactive mode, you must provide explicit arguments.\n` +
+                        `For CI/CD, consider setting a default project:\n` +
+                        `  sembix profile set-default-project ${profile.name} <project-id>\n\n` +
+                        `Or provide the flag explicitly:\n` +
+                        `  sembix workflow start --project-id <id> --workflow-id <id>`);
+                }
+            }
+            // Interactive mode - check for default project first
+            const profileConfig = await readProfile(options.profile);
+            if (profileConfig?.defaultProjectId) {
+                projectId = profileConfig.defaultProjectId;
+                console.log(`Using default project: ${ui.highlight(projectId)}`);
+                console.log();
+                // Fetch project name for display and caching
+                try {
+                    const project = await apiClient.getProject(projectId);
+                    projectName = project?.name;
+                }
+                catch {
+                    // Silently fail - we'll use the ID
+                }
+            }
+            else {
+                // No default project - prompt for selection
+                console.log('No default project set. Select a project:');
+                console.log();
+                const { promptForProject } = await import('../prompts/project-selection.js');
+                const selectedProject = await promptForProject(apiClient, profile.name);
+                projectId = selectedProject.projectId;
+                projectName = selectedProject.name;
+                console.log();
+                console.log(`Selected: ${ui.highlight(selectedProject.name)} (${projectId})`);
+                console.log();
+            }
+        }
+        // Validate project ID
+        if (!projectId) {
+            throw new Error('Project ID is required but was not provided or selected.');
+        }
+        // Handle workflow selection
+        let workflowId = options.workflowId;
+        let workflowName = options.workflowName;
+        // Validate mutually exclusive options
+        if (workflowId && workflowName) {
+            throw new Error('Cannot specify both --workflow-id and --workflow-name. Choose one.');
+        }
+        if (!workflowId && !workflowName) {
+            // Check if in interactive mode
+            if (!isInteractive()) {
+                throw new Error(`Missing required argument: --workflow-id or --workflow-name\n\n` +
+                    `In non-interactive mode, you must provide explicit arguments.\n` +
+                    `Use: --workflow-id <id> or --workflow-name <name>`);
+            }
+            // Interactive mode - prompt for workflow
+            console.log('Select a workflow to start:');
+            console.log();
+            const { promptForWorkflow } = await import('../prompts/workflow-selection.js');
+            const selectedWorkflow = await promptForWorkflow(apiClient, profile.name, projectId);
+            workflowId = selectedWorkflow.workflowId;
+            workflowName = selectedWorkflow.name;
+            console.log();
+            console.log(`Selected: ${ui.highlight(selectedWorkflow.name)} (${workflowId})`);
+            console.log();
+        }
+        // Resolve workflow ID from name if needed (when provided via CLI flag)
+        if (workflowName && !workflowId) {
+            const lookupSpinner = ui.spinner(`Looking up workflow by name: ${workflowName}...`);
+            lookupSpinner.start();
+            const workflow = await apiClient.findWorkflowByName(projectId, workflowName);
+            lookupSpinner.stop();
+            if (!workflow) {
+                console.log();
+                ui.error(`Workflow with name "${workflowName}" not found in project ${projectId}.`);
+                console.log();
+                console.log(`Use: sembix workflow list --project-id ${projectId}`);
+                console.log();
+                process.exit(1);
+            }
+            workflowId = workflow.workflowId;
+            workflowName = workflow.name; // Update with canonical name
+            console.log(`Found workflow: ${ui.highlight(workflow.name)} (${workflowId})`);
+            console.log();
+        }
+        // Validate workflow ID
+        if (!workflowId) {
+            throw new Error('Workflow ID is required but was not provided or selected.');
+        }
+        // Resolve parent workflow to published child
+        // The workflow lists show parent workflows, but we must start child workflows
+        console.log('Resolving to published workflow version...');
+        console.log();
+        const resolveSpinner = ui.spinner('Finding published version...');
+        resolveSpinner.start();
+        let parentWorkflowId;
+        let parentWorkflowName;
+        try {
+            const publishedWorkflow = await apiClient.resolveToPublishedChild(projectId, workflowId);
+            resolveSpinner.stop();
+            // Store the parent workflow ID for cache (so users see parent in recent list)
+            parentWorkflowId = workflowId;
+            parentWorkflowName = workflowName || publishedWorkflow.name;
+            // Update workflowId to the published child (for starting)
+            workflowId = publishedWorkflow.workflowId;
+            workflowName = publishedWorkflow.name;
+            console.log(`Using published version: ${ui.highlight(`v${publishedWorkflow.version || '?'}`)} (${workflowId})`);
+            console.log();
+        }
+        catch (error) {
+            resolveSpinner.stop();
+            // If resolution fails, show clear error message
+            if (error instanceof Error) {
+                ui.error(error.message);
+                process.exit(1);
+            }
+            throw error;
+        }
+        // Parse input configuration
+        // Initialize with empty initialInstructions (API requires this field)
+        const startConfiguration = {
+            initialInstructions: []
+        };
+        // Check for interactive input prompting
+        // Only fetch template and prompt if:
+        // 1. No --inputs flag provided
+        // 2. Running in interactive terminal (TTY)
+        // 3. Not explicitly disabled with --no-interactive
+        if (!options.inputs && options.interactive !== false) {
+            const { isInteractive } = await import('../utils/environment.js');
+            if (isInteractive()) {
+                try {
+                    // Show UI regardless of output format (this is input, not output)
+                    console.error('Fetching workflow template...');
+                    const workflowTemplate = await apiClient.getWorkflowTemplateForWorkflow(projectId, workflowId);
+                    if (!workflowTemplate) {
+                        console.error('No template found for this workflow. Starting without inputs...');
+                    }
+                    else {
+                        // Find the Start step (it may not be the first step)
+                        const startStep = workflowTemplate.steps?.find(step => step.name === 'Start');
+                        const initialInstructions = startStep?.initialInstructions;
+                        if (!initialInstructions || initialInstructions.length === 0) {
+                            console.error('This workflow has no input parameters. Starting workflow...');
+                        }
+                        else {
+                            // Template has inputs - prompt user directly (interactive mode already checked)
+                            const { promptForWorkflowInputs } = await import('../prompts/workflow-inputs.js');
+                            const inputs = await promptForWorkflowInputs(initialInstructions);
+                            startConfiguration.initialInstructions = inputs;
+                        }
+                    }
+                }
+                catch (error) {
+                    // Check if user cancelled (Ctrl+C)
+                    if (error instanceof Error &&
+                        (error.message.includes('SIGINT') ||
+                            error.message.includes('force closed') ||
+                            error.message.includes('User cancelled'))) {
+                        console.error('\nOperation cancelled by user.');
+                        process.exit(0);
+                    }
+                    // Show warning on stderr so it doesn't interfere with JSON output
+                    console.error(`Warning: Could not fetch workflow template (${error instanceof Error ? error.message : 'unknown error'}). Starting without inputs...`);
+                }
+            }
+        }
+        if (options.inputs) {
+            // Support @file.json syntax or direct JSON string
+            let inputsJson;
+            if (options.inputs.startsWith('@')) {
+                const filePath = options.inputs.slice(1);
+                try {
+                    inputsJson = await readFile(filePath, 'utf-8');
+                }
+                catch (error) {
+                    throw new Error(`Failed to read input file "${filePath}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+                }
+            }
+            else {
+                inputsJson = options.inputs;
+            }
+            // Auto-detect format and parse
+            try {
+                const { parseWorkflowInputs } = await import('../utils/input-parser.js');
+                const parsedConfig = parseWorkflowInputs(inputsJson);
+                Object.assign(startConfiguration, parsedConfig);
+            }
+            catch (error) {
+                throw new Error(`Failed to parse inputs: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        // Add optional workspace and issue metadata (nested structure)
+        if (options.workspaceId || options.workspaceName || options.issueId || options.issueKey) {
+            startConfiguration.workspaceMetadata = {};
+            if (options.workspaceId) {
+                startConfiguration.workspaceMetadata.workspaceId = options.workspaceId;
+            }
+            if (options.workspaceName) {
+                startConfiguration.workspaceMetadata.workspaceName = options.workspaceName;
+            }
+            if (options.issueId || options.issueKey) {
+                startConfiguration.workspaceMetadata.issueMetadata = {
+                    issueId: options.issueId,
+                    issueKey: options.issueKey
+                };
+            }
+        }
+        // Start workflow execution
+        const spinner = ui.spinner('Starting workflow execution...');
+        spinner.start();
+        const response = await apiClient.startWorkflow(projectId, workflowId, startConfiguration);
+        spinner.stop();
+        // Update recent workflows cache with parent workflow ID
+        // (fire and forget - don't block on cache errors)
+        if (parentWorkflowName && parentWorkflowId) {
+            addRecentWorkflow(profile.name, projectId, projectName || projectId, parentWorkflowId, // Store parent ID so users see parent in recent list
+            parentWorkflowName).catch(() => {
+                // Silently fail - cache update errors shouldn't break the command
+            });
+        }
+        // Output results based on format
+        outputSuccess(response, { format });
+        // TEXT mode: human-readable output
+        console.log();
+        ui.success('Workflow started successfully!');
+        console.log();
+        console.log(`Run ID:   ${ui.highlight(response.runId)}`);
+        console.log(`Task ARN: ${ui.highlight(response.taskArn)}`);
+        console.log();
+        console.log(`Check status with: sembix workflow run status --workflow-id ${workflowId} --run-id ${response.runId}`);
+        console.log();
+    }
+    catch (error) {
+        // Output error based on format
+        const format = getOutputFormat(options);
+        if (format === 'text') {
+            console.log();
+            if (error instanceof Error) {
+                ui.error(error.message);
+                // Provide actionable next steps
+                if (error.message.includes('authentication') || error.message.includes('token')) {
+                    console.log();
+                    console.log(`Run: sembix login${options.profile ? ` --profile ${options.profile}` : ''}`);
+                }
+            }
+            else {
+                ui.error('An unexpected error occurred');
+                console.error(error);
+            }
+            console.log();
+            process.exit(1);
+        }
+        else {
+            outputError(error, 1);
+        }
+    }
+}
+export async function workflowListCommand(options) {
+    try {
+        // Determine output format
+        const format = getOutputFormat(options);
+        // Show UI elements only in TEXT mode
+        console.log();
+        ui.banner('List Workflows');
+        console.log();
+        // Load profile and validate authentication
+        const { profile, tokens } = await getAuthenticatedProfile(options.profile);
+        // Create API client
+        const apiClient = new StudioApiClient(profile, tokens);
+        // Handle project ID requirement
+        let projectId = options.projectId;
+        if (!projectId) {
+            // Try to use default project from profile
+            const profileConfig = await readProfile(options.profile);
+            if (profileConfig?.defaultProjectId) {
+                projectId = profileConfig.defaultProjectId;
+                if (format === 'text') {
+                    console.log(`Using default project: ${ui.highlight(projectId)}`);
+                    console.log();
+                }
+            }
+            else {
+                // No project ID and no default - show helpful error
+                throw new Error(`Project ID is required to list workflows.\n\n` +
+                    `Either:\n` +
+                    `  • Use: --project-id <id>\n` +
+                    `  • Set a default project: sembix profile set-default-project ${profile.name} <project-id>\n\n` +
+                    `To see available projects: sembix project list`);
+            }
+        }
+        // Build filter params
+        const filterParams = {
+            projectId: projectId
+        };
+        if (options.workflowTemplateIds) {
+            filterParams.workflowTemplateIds = options.workflowTemplateIds;
+        }
+        if (options.parentWorkflowId) {
+            filterParams.parentWorkflowId = options.parentWorkflowId;
+        }
+        // List workflows
+        const spinner = ui.spinner('Loading workflows...');
+        spinner.start();
+        const response = await apiClient.listWorkflows(filterParams);
+        spinner.stop();
+        // Output results based on format
+        outputSuccess(response, { format });
+        // TEXT mode: human-readable output
+        console.log();
+        if (response.workflows.length === 0) {
+            ui.warning('No workflows found matching the criteria.');
+            console.log();
+            return;
+        }
+        ui.success(`Found ${response.workflows.length} workflow(s):`);
+        console.log();
+        for (const workflow of response.workflows) {
+            console.log(`  ${ui.highlight(workflow.name)} (${workflow.workflowId})`);
+            console.log(`    Project:  ${projectId}`);
+            console.log(`    Template: ${workflow.workflowTemplateId}`);
+            console.log(`    State:    ${workflow.state}`);
+            if (workflow.parentWorkflowId) {
+                console.log(`    Parent:   ${workflow.parentWorkflowId}`);
+            }
+            if (workflow.isPublished) {
+                console.log(`    Published: Yes (v${workflow.version})`);
+            }
+            console.log(`    Created:  ${new Date(workflow.createdAt).toLocaleString()}`);
+            console.log();
+        }
+    }
+    catch (error) {
+        // Output error based on format
+        const format = getOutputFormat(options);
+        if (format === 'text') {
+            console.log();
+            if (error instanceof Error) {
+                ui.error(error.message);
+                if (error.message.includes('authentication') || error.message.includes('token')) {
+                    console.log();
+                    console.log(`Run: sembix login${options.profile ? ` --profile ${options.profile}` : ''}`);
+                }
+            }
+            else {
+                ui.error('An unexpected error occurred');
+                console.error(error);
+            }
+            console.log();
+            process.exit(1);
+        }
+        else {
+            outputError(error, 1);
+        }
+    }
+}
+export async function workflowShowCommand(options) {
+    try {
+        // Determine output format
+        const format = getOutputFormat(options);
+        // Validate required options
+        if (!options.projectId) {
+            throw new Error('Project ID is required. Use --project-id flag.');
+        }
+        if (!options.workflowId) {
+            throw new Error('Workflow ID is required. Use --workflow-id flag.');
+        }
+        // Show UI elements only in TEXT mode
+        console.log();
+        ui.banner('Workflow Details');
+        console.log();
+        // Load profile and validate authentication
+        const { profile, tokens } = await getAuthenticatedProfile(options.profile);
+        // Create API client
+        const apiClient = new StudioApiClient(profile, tokens);
+        // Get workflow
+        const spinner = ui.spinner(`Fetching workflow ${options.workflowId}...`);
+        spinner.start();
+        const workflow = await apiClient.getWorkflow(options.projectId, options.workflowId);
+        spinner.stop();
+        // Fetch template info if available
+        let template = null;
+        if (workflow.workflowTemplateId) {
+            try {
+                template = await apiClient.getWorkflowTemplate(options.projectId, workflow.workflowTemplateId);
+            }
+            catch {
+                // Ignore template fetch errors - workflow info is still useful
+            }
+        }
+        // Output results based on format
+        outputSuccess(workflow, { format });
+        // TEXT mode: human-readable output
+        console.log();
+        console.log(`Name:         ${ui.highlight(workflow.name)}`);
+        console.log(`Workflow ID:  ${workflow.workflowId}`);
+        console.log(`Project ID:   ${workflow.projectId}`);
+        console.log(`Template ID:  ${workflow.workflowTemplateId}`);
+        console.log(`State:        ${workflow.state}`);
+        console.log(`Created:      ${new Date(workflow.createdAt).toLocaleString()}`);
+        console.log(`Updated:      ${new Date(workflow.updatedAt).toLocaleString()}`);
+        console.log(`Creator ID:   ${workflow.creatorId}`);
+        console.log(`Updated By:   ${workflow.updatedBy}`);
+        if (workflow.description) {
+            console.log(`Description:  ${workflow.description}`);
+        }
+        if (workflow.parentWorkflowId) {
+            console.log(`Parent:       ${workflow.parentWorkflowId}`);
+        }
+        if (workflow.isPublished) {
+            console.log(`Published:    Yes (v${workflow.version})`);
+        }
+        console.log();
+        // Show template information if available
+        if (template) {
+            ui.section('Template Information');
+            console.log(`Template:     ${ui.highlight(template.name)}`);
+            if (template.description) {
+                console.log(`Description:  ${template.description}`);
+            }
+            if (template.initialInstructions && template.initialInstructions.length > 0) {
+                console.log();
+                console.log(`Inputs:       ${template.initialInstructions.length} parameter(s)`);
+                for (const instr of template.initialInstructions) {
+                    const req = instr.isRequired ? '(required)' : '(optional)';
+                    console.log(`  - ${instr.name} ${ui.dim(req)}`);
+                }
+                console.log();
+                console.log(ui.dim('For detailed template info:'));
+                console.log(ui.code(`sembix workflow template show --project-id ${workflow.projectId} --template-id ${workflow.workflowTemplateId}`));
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        // Output error based on format
+        const format = getOutputFormat(options);
+        if (format === 'text') {
+            console.log();
+            if (error instanceof Error) {
+                ui.error(error.message);
+                if (error.message.includes('authentication') || error.message.includes('token')) {
+                    console.log();
+                    console.log(`Run: sembix login${options.profile ? ` --profile ${options.profile}` : ''}`);
+                }
+                else if (error.message.includes('404') || error.message.includes('not found')) {
+                    console.log();
+                    console.log('Workflow not found. Check the project ID and workflow ID.');
+                }
+            }
+            else {
+                ui.error('An unexpected error occurred');
+                console.error(error);
+            }
+            console.log();
+            process.exit(1);
+        }
+        else {
+            outputError(error, 4);
+        }
+    }
+}
+export async function workflowTemplateShowCommand(options) {
+    try {
+        // Determine output format
+        const format = getOutputFormat(options);
+        // Validate: projectId always required, plus either templateId OR workflowId
+        if (!options.projectId) {
+            throw new Error('--project-id is required');
+        }
+        if (!options.templateId && !options.workflowId) {
+            throw new Error('Either --template-id OR --workflow-id is required');
+        }
+        // Show UI elements only in TEXT mode
+        console.log();
+        ui.banner('Workflow Template Details');
+        console.log();
+        // Load profile and validate authentication
+        const { profile, tokens } = await getAuthenticatedProfile(options.profile);
+        // Create API client
+        const apiClient = new StudioApiClient(profile, tokens);
+        // Get template
+        const spinner = ui.spinner('Fetching workflow template...');
+        spinner.start();
+        let template;
+        if (options.templateId && options.projectId) {
+            template = await apiClient.getWorkflowTemplate(options.projectId, options.templateId);
+        }
+        else if (options.projectId && options.workflowId) {
+            const t = await apiClient.getWorkflowTemplateForWorkflow(options.projectId, options.workflowId);
+            if (!t) {
+                throw new Error('Workflow has no associated template');
+            }
+            template = t;
+        }
+        else {
+            throw new Error('Must provide projectId with either templateId or workflowId');
+        }
+        spinner.stop();
+        // Output results based on format
+        outputSuccess(template, { format });
+        // TEXT mode: human-readable output
+        console.log();
+        console.log(`Name:          ${ui.highlight(template.name)}`);
+        console.log(`Template ID:   ${template.workflowTemplateId}`);
+        if (template.description) {
+            console.log(`Description:   ${template.description}`);
+        }
+        if (template.category) {
+            console.log(`Category:      ${template.category}`);
+        }
+        if (template.version) {
+            console.log(`Version:       ${template.version}`);
+        }
+        console.log(`Created:       ${new Date(template.createdAt).toLocaleString()}`);
+        console.log(`Updated:       ${new Date(template.updatedAt).toLocaleString()}`);
+        if (template.tags && template.tags.length > 0) {
+            console.log(`Tags:          ${template.tags.join(', ')}`);
+        }
+        console.log();
+        // Show input requirements
+        if (template.initialInstructions && template.initialInstructions.length > 0) {
+            ui.section('Input Parameters');
+            for (const instr of template.initialInstructions) {
+                const required = instr.isRequired ? ui.highlight('(required)') : ui.dim('(optional)');
+                console.log(`  ${ui.highlight(instr.name)} ${required}`);
+                if (instr.description) {
+                    console.log(`    ${ui.dim(instr.description)}`);
+                }
+                if (instr.dataType) {
+                    console.log(`    Type: ${instr.dataType}`);
+                }
+                if (instr.instruction !== undefined) {
+                    console.log(`    Default: ${instr.instruction}`);
+                }
+                console.log();
+            }
+            console.log();
+            console.log(ui.dim('Use these parameters when starting a workflow:'));
+            console.log();
+            console.log(ui.code(`sembix workflow start --project-id <id> --workflow-id <id> \\
+  --inputs '[{"id": "${template.initialInstructions[0].id}", "instruction": "value"}]'`));
+            console.log();
+        }
+        else {
+            console.log(ui.dim('This template has no input parameters.'));
+            console.log();
+        }
+    }
+    catch (error) {
+        // Error handling
+        const format = getOutputFormat(options);
+        if (format === 'text') {
+            console.log();
+            if (error instanceof Error) {
+                ui.error(error.message);
+                if (error.message.includes('authentication') || error.message.includes('token')) {
+                    console.log();
+                    console.log(`Run: sembix login${options.profile ? ` --profile ${options.profile}` : ''}`);
+                }
+            }
+            else {
+                ui.error('An unexpected error occurred');
+                console.error(error);
+            }
+            console.log();
+            process.exit(1);
+        }
+        else {
+            outputError(error, 1);
+        }
+    }
+}
+export async function workflowStatusCommand(options) {
+    try {
+        // Determine output format
+        const format = getOutputFormat(options);
+        // Validate required options
+        if (!options.workflowId) {
+            throw new Error('Workflow ID is required. Use --workflow-id flag.');
+        }
+        if (!options.runId) {
+            throw new Error('Run ID is required. Use --run-id flag.');
+        }
+        // Watch mode not supported in JSON/PRETTY output
+        if (options.watch && format !== 'text') {
+            throw new Error('Watch mode (--watch) is only supported with --output text');
+        }
+        // Show UI elements only in TEXT mode
+        console.log();
+        ui.banner('Workflow Run Status');
+        console.log();
+        // Load profile and validate authentication
+        const { profile, tokens } = await getAuthenticatedProfile(options.profile);
+        // Create API client
+        const apiClient = new StudioApiClient(profile, tokens);
+        // Function to fetch and display status with optional change highlighting
+        const fetchAndDisplayStatus = async (previousRun) => {
+            const response = await apiClient.getWorkflowRun(options.workflowId, options.runId);
+            const run = response.run;
+            // Display status information
+            console.log(`Run ID:       ${ui.highlight(run.runId)}`);
+            console.log(`Workflow ID:  ${ui.highlight(run.workflowId)}`);
+            console.log(`Name:         ${run.name || 'N/A'}`);
+            // Color-code status (with change highlighting if in watch mode)
+            let statusDisplay = run.status;
+            const statusChanged = previousRun && previousRun.status !== run.status;
+            if (run.status === 'COMPLETED') {
+                statusDisplay = statusChanged
+                    ? `\x1b[32m\x1b[1m${run.status}\x1b[0m` // Green + Bold
+                    : `\x1b[32m${run.status}\x1b[0m`; // Green
+            }
+            else if (run.status === 'FAILED') {
+                statusDisplay = statusChanged
+                    ? `\x1b[31m\x1b[1m${run.status}\x1b[0m` // Red + Bold
+                    : `\x1b[31m${run.status}\x1b[0m`; // Red
+            }
+            else if (run.status === 'IN_PROGRESS') {
+                statusDisplay = statusChanged
+                    ? `\x1b[33m\x1b[1m${run.status}\x1b[0m` // Yellow + Bold
+                    : `\x1b[33m${run.status}\x1b[0m`; // Yellow
+            }
+            console.log(`Status:       ${statusDisplay}`);
+            // Highlight progress if changed
+            const progressValue = run.progress || 0;
+            const progressChanged = previousRun && previousRun.progress !== progressValue;
+            const progressDisplay = progressChanged ? ui.changed(`${progressValue}%`) : `${progressValue}%`;
+            console.log(`Progress:     ${progressDisplay}`);
+            console.log(`Created At:   ${new Date(run.createdAt).toLocaleString()}`);
+            console.log(`Creator ID:   ${run.creatorId}`);
+            // Highlight current step if changed
+            if (run.currentStepId) {
+                const stepChanged = previousRun && previousRun.currentStepId !== run.currentStepId;
+                const stepDisplay = stepChanged ? ui.changed(run.currentStepId) : run.currentStepId;
+                console.log(`Current Step: ${stepDisplay}`);
+            }
+            if (run.error) {
+                console.log(`Error:        ${ui.highlight(run.error)}`);
+            }
+            // Return true if status is terminal (completed, failed, stopped)
+            return ['COMPLETED', 'FAILED', 'STOPPED'].includes(run.status);
+        };
+        if (options.watch) {
+            // Watch mode: poll every 5 seconds until terminal status
+            let previousRun = null;
+            let iteration = 0;
+            let isTerminal = false;
+            // Hide cursor to prevent flicker during updates
+            ui.hideCursor();
+            try {
+                while (!isTerminal) {
+                    // Restore cursor to saved position (after first iteration)
+                    if (iteration > 0) {
+                        ui.restoreCursorPosition();
+                    }
+                    // Save cursor position here (right after banner, before dynamic content)
+                    ui.saveCursorPosition();
+                    // Show watch header with timestamp
+                    console.log(ui.dim('Watching workflow status... (Ctrl+C to stop)'));
+                    console.log(ui.dim(`Last updated: ${new Date().toLocaleTimeString()} (refreshes every 5s)`));
+                    console.log();
+                    // Clear everything below this point
+                    ui.clearFromCursorDown();
+                    // Fetch and display with change highlighting
+                    const response = await apiClient.getWorkflowRun(options.workflowId, options.runId);
+                    isTerminal = await fetchAndDisplayStatus(previousRun);
+                    previousRun = response.run;
+                    if (!isTerminal) {
+                        await new Promise(resolve => setTimeout(resolve, 5000));
+                    }
+                    iteration++;
+                }
+                // Show cursor again when done
+                ui.showCursor();
+                console.log();
+                ui.success('Workflow execution completed');
+                console.log();
+            }
+            catch (error) {
+                // Ensure cursor is restored even on error
+                ui.showCursor();
+                throw error;
+            }
+        }
+        else {
+            // Single fetch
+            const spinner = ui.spinner('Fetching workflow status...');
+            spinner.start();
+            const response = await apiClient.getWorkflowRun(options.workflowId, options.runId);
+            spinner.stop();
+            // Output results based on format
+            outputSuccess(response.run, { format });
+            // TEXT mode: human-readable output
+            console.log();
+            await fetchAndDisplayStatus();
+            console.log();
+        }
+    }
+    catch (error) {
+        // Output error based on format
+        const format = getOutputFormat(options);
+        if (format === 'text') {
+            console.log();
+            if (error instanceof Error) {
+                ui.error(error.message);
+                if (error.message.includes('authentication') || error.message.includes('token')) {
+                    console.log();
+                    console.log(`Run: sembix login${options.profile ? ` --profile ${options.profile}` : ''}`);
+                }
+                else if (error.message.includes('404') || error.message.includes('not found')) {
+                    console.log();
+                    console.log('Workflow run not found. Check the workflow ID and run ID.');
+                }
+            }
+            else {
+                ui.error('An unexpected error occurred');
+                console.error(error);
+            }
+            console.log();
+            process.exit(1);
+        }
+        else {
+            outputError(error, 4);
+        }
+    }
+}
+export async function workflowRunListCommand(options) {
+    try {
+        // Determine output format
+        const format = getOutputFormat(options);
+        // Show UI elements only in TEXT mode
+        console.log();
+        ui.banner('List Workflow Runs');
+        console.log();
+        // Load profile and validate authentication
+        const { profile, tokens } = await getAuthenticatedProfile(options.profile);
+        // Create API client
+        const apiClient = new StudioApiClient(profile, tokens);
+        // Build search parameters
+        const searchParams = {
+            limit: options.limit || 10,
+            offset: options.offset || 0,
+            sortBy: options.sortBy || 'createdAt',
+            sortOrder: options.sortOrder || 'DESC'
+        };
+        // Default behavior: exclude subflows (only show top-level runs)
+        // Users can opt-in to see subflows with --include-subflows
+        // Or specify a specific parent with --parent-id
+        if (options.parentId !== undefined) {
+            // Explicit parent ID specified (could be 'NULL' or a specific ID)
+            searchParams.parentId = options.parentId;
+        }
+        else if (!options.includeSubflows) {
+            // Default: only show top-level runs (parent_id IS NULL)
+            searchParams.parentId = 'NULL';
+        }
+        // If includeSubflows is true, don't set parentId at all (shows everything)
+        if (options.workflowId)
+            searchParams.workflowId = options.workflowId;
+        if (options.projectId)
+            searchParams.projectId = options.projectId;
+        if (options.workflowTemplateId)
+            searchParams.workflowTemplateId = options.workflowTemplateId;
+        if (options.status)
+            searchParams.status = options.status;
+        if (options.currentUser)
+            searchParams.currentUser = true;
+        if (options.workspaceId)
+            searchParams.workspaceId = options.workspaceId;
+        if (options.workspaceName)
+            searchParams.workspaceName = options.workspaceName;
+        if (options.issueId)
+            searchParams.issueId = options.issueId;
+        if (options.issueKey)
+            searchParams.issueKey = options.issueKey;
+        // Fetch workflow runs
+        const spinner = ui.spinner('Fetching workflow runs...');
+        spinner.start();
+        const response = await apiClient.searchWorkflowRuns(searchParams);
+        spinner.stop();
+        // Output results based on format
+        outputSuccess(response, { format });
+        // TEXT mode: human-readable output
+        console.log();
+        if (response.runs.length === 0) {
+            console.log('No workflow runs found.');
+            console.log();
+            return;
+        }
+        // Display table header
+        console.log('─'.repeat(120));
+        console.log(`${'Run ID'.padEnd(40)} ${'Workflow ID'.padEnd(30)} ${'Status'.padEnd(12)} ${'Progress'.padEnd(10)} ${'Created At'.padEnd(20)}`);
+        console.log('─'.repeat(120));
+        // Display each run
+        for (const run of response.runs) {
+            const runId = run.runId.padEnd(40);
+            const workflowId = (run.workflowId || 'N/A').padEnd(30);
+            // Color-code status
+            let status = run.status.padEnd(12);
+            if (run.status === 'COMPLETED') {
+                status = `\x1b[32m${run.status.padEnd(12)}\x1b[0m`;
+            }
+            else if (run.status === 'FAILED') {
+                status = `\x1b[31m${run.status.padEnd(12)}\x1b[0m`;
+            }
+            else if (run.status === 'IN_PROGRESS') {
+                status = `\x1b[33m${run.status.padEnd(12)}\x1b[0m`;
+            }
+            const progress = `${run.progress || 0}%`.padEnd(10);
+            const createdAt = new Date(run.createdAt).toLocaleString().padEnd(20);
+            console.log(`${runId} ${workflowId} ${status} ${progress} ${createdAt}`);
+        }
+        console.log('─'.repeat(120));
+        console.log();
+        // Display pagination info
+        const start = response.offset + 1;
+        const end = Math.min(response.offset + response.limit, response.totalCount);
+        console.log(`Showing ${start}-${end} of ${response.totalCount} results`);
+        console.log();
+        // Show next page hint if there are more results
+        if (end < response.totalCount) {
+            const nextOffset = response.offset + response.limit;
+            console.log(`To see more results, use: --offset ${nextOffset}`);
+            console.log();
+        }
+    }
+    catch (error) {
+        // Output error based on format
+        const format = getOutputFormat(options);
+        if (format === 'text') {
+            console.log();
+            if (error instanceof Error) {
+                ui.error(error.message);
+                if (error.message.includes('authentication') || error.message.includes('token')) {
+                    console.log();
+                    console.log(`Run: sembix login${options.profile ? ` --profile ${options.profile}` : ''}`);
+                }
+            }
+            else {
+                ui.error('An unexpected error occurred');
+                console.error(error);
+            }
+            console.log();
+            process.exit(1);
+        }
+        else {
+            outputError(error, 1);
+        }
+    }
+}
+export async function workflowStopCommand(options) {
+    try {
+        // Determine output format
+        const format = getOutputFormat(options);
+        // Validate required options
+        if (!options.projectId) {
+            throw new Error('Project ID is required. Use --project-id flag.');
+        }
+        if (!options.workflowId && !options.workflowName) {
+            throw new Error('Either --workflow-id or --workflow-name is required.');
+        }
+        if (options.workflowId && options.workflowName) {
+            throw new Error('Cannot specify both --workflow-id and --workflow-name. Choose one.');
+        }
+        if (!options.runId) {
+            throw new Error('Run ID is required. Use --run-id flag.');
+        }
+        // Show UI elements only in TEXT mode
+        console.log();
+        ui.banner('Stop Workflow Run');
+        console.log();
+        // Load profile and validate authentication
+        const { profile, tokens } = await getAuthenticatedProfile(options.profile);
+        // Create API client
+        const apiClient = new StudioApiClient(profile, tokens);
+        // Resolve workflow ID from name if needed
+        let workflowId = options.workflowId;
+        if (options.workflowName) {
+            const lookupSpinner = ui.spinner(`Looking up workflow by name: ${options.workflowName}...`);
+            lookupSpinner.start();
+            const workflow = await apiClient.findWorkflowByName(options.projectId, options.workflowName);
+            lookupSpinner.stop();
+            if (!workflow) {
+                throw new Error(`Workflow with name "${options.workflowName}" not found in project ${options.projectId}`);
+            }
+            workflowId = workflow.workflowId;
+            console.log(`Found workflow: ${ui.highlight(workflow.name)} (${workflowId})`);
+            console.log();
+        }
+        // Stop workflow run
+        const spinner = ui.spinner('Stopping workflow run...');
+        spinner.start();
+        await apiClient.stopWorkflowRun(options.projectId, workflowId, options.runId);
+        spinner.stop();
+        // Output results based on format
+        const result = {
+            success: true,
+            runId: options.runId,
+            workflowId: workflowId,
+            projectId: options.projectId
+        };
+        outputSuccess(result, { format });
+        // TEXT mode: human-readable output
+        console.log();
+        ui.success('Workflow run stopped successfully!');
+        console.log();
+        console.log(`Run ID: ${ui.highlight(options.runId)}`);
+        console.log();
+        console.log(`Check final status with: sembix workflow status --workflow-id ${workflowId} --run-id ${options.runId}`);
+        console.log();
+    }
+    catch (error) {
+        // Output error based on format
+        const format = getOutputFormat(options);
+        if (format === 'text') {
+            console.log();
+            if (error instanceof Error) {
+                ui.error(error.message);
+                if (error.message.includes('authentication') || error.message.includes('token')) {
+                    console.log();
+                    console.log(`Run: sembix login${options.profile ? ` --profile ${options.profile}` : ''}`);
+                }
+                else if (error.message.includes('404') || error.message.includes('not found')) {
+                    console.log();
+                    console.log('Workflow run not found. Check the project ID, workflow ID, and run ID.');
+                }
+            }
+            else {
+                ui.error('An unexpected error occurred');
+                console.error(error);
+            }
+            console.log();
+            process.exit(1);
+        }
+        else {
+            outputError(error, 4);
+        }
+    }
+}
+export async function workflowRunShowCommand(options) {
+    try {
+        // Determine output format
+        const format = getOutputFormat(options);
+        // Validate required options
+        if (!options.workflowId) {
+            throw new Error('Workflow ID is required. Use --workflow-id flag.');
+        }
+        if (!options.runId) {
+            throw new Error('Run ID is required. Use --run-id flag.');
+        }
+        // Watch mode not supported in JSON/PRETTY output
+        if (options.watch && format !== 'text') {
+            throw new Error('Watch mode (--watch) is only supported with --output text');
+        }
+        // Show UI elements only in TEXT mode
+        console.log();
+        ui.banner('Workflow Run Details');
+        console.log();
+        // Load profile and validate authentication
+        const { profile, tokens } = await getAuthenticatedProfile(options.profile);
+        // Create API client
+        const apiClient = new StudioApiClient(profile, tokens);
+        if (options.watch) {
+            // Watch mode: poll every 5 seconds until terminal status
+            let previousRun = null;
+            let iteration = 0;
+            let isTerminal = false;
+            // Hide cursor to prevent flicker during updates
+            ui.hideCursor();
+            try {
+                while (!isTerminal) {
+                    // Restore cursor to saved position (after first iteration)
+                    if (iteration > 0) {
+                        ui.restoreCursorPosition();
+                    }
+                    // Save cursor position here (right after banner, before dynamic content)
+                    ui.saveCursorPosition();
+                    // Show watch header with timestamp
+                    console.log(ui.dim('Watching workflow run details... (Ctrl+C to stop)'));
+                    console.log(ui.dim(`Last updated: ${new Date().toLocaleTimeString()} (refreshes every 5s)`));
+                    console.log();
+                    // Clear everything below this point
+                    ui.clearFromCursorDown();
+                    // Fetch latest run
+                    const response = await apiClient.getWorkflowRun(options.workflowId, options.runId);
+                    // Display with change highlighting (with truncation for watch mode)
+                    formatWorkflowRunOutput(response.run, previousRun, true);
+                    previousRun = response.run;
+                    isTerminal = ['COMPLETED', 'FAILED', 'STOPPED'].includes(response.run.status);
+                    if (!isTerminal) {
+                        await new Promise(resolve => setTimeout(resolve, 5000));
+                    }
+                    iteration++;
+                }
+                // Show cursor again when done
+                ui.showCursor();
+                console.log();
+                ui.success('Workflow execution completed');
+                console.log();
+            }
+            catch (error) {
+                // Ensure cursor is restored even on error
+                ui.showCursor();
+                throw error;
+            }
+        }
+        else {
+            // Single fetch
+            const spinner = ui.spinner(`Fetching workflow run ${options.runId}...`);
+            spinner.start();
+            const response = await apiClient.getWorkflowRun(options.workflowId, options.runId);
+            spinner.stop();
+            // Output results based on format
+            outputSuccess(response, { format });
+            // TEXT mode: human-readable output
+            formatWorkflowRunOutput(response.run);
+        }
+    }
+    catch (error) {
+        // Output error based on format
+        const format = getOutputFormat(options);
+        if (format === 'text') {
+            console.log();
+            if (error instanceof Error) {
+                ui.error(error.message);
+                if (error.message.includes('authentication') || error.message.includes('token')) {
+                    console.log();
+                    console.log(`Run: sembix login${options.profile ? ` --profile ${options.profile}` : ''}`);
+                }
+                else if (error.message.includes('404') || error.message.includes('not found')) {
+                    console.log();
+                    console.log('Workflow run not found. Check the workflow ID and run ID.');
+                }
+            }
+            else {
+                ui.error('An unexpected error occurred');
+                console.error(error);
+            }
+            console.log();
+            process.exit(1);
+        }
+        else {
+            outputError(error, 4);
+        }
+    }
+}
+// ============================================================================
+// Helper: Format Workflow Run Output
+// ============================================================================
+function formatWorkflowRunOutput(run, previousRun, watchMode = false) {
+    console.log();
+    ui.section('Workflow Run Details');
+    console.log();
+    // Basic info - highlight status if changed
+    const statusChanged = previousRun && previousRun.status !== run.status;
+    const statusDisplay = statusChanged ? ui.changed(run.status) : run.status;
+    ui.table({
+        'Run ID': run.runId,
+        'Workflow ID': run.workflowId,
+        'Project ID': run.projectId,
+        'Status': statusDisplay,
+        'Version': run.version?.toString() || 'N/A',
+    });
+    console.log();
+    // MOST IMPORTANT: Summary (outcome and intent)
+    if (run.summary) {
+        // Highlight summary if changed
+        const summaryChanged = previousRun && previousRun.summary !== run.summary;
+        const sectionTitle = summaryChanged ? 'Summary (UPDATED)' : 'Summary';
+        ui.section(sectionTitle);
+        // Truncate summary in watch mode if it's very long
+        const summaryToDisplay = watchMode
+            ? ui.truncateForWatch(run.summary, 500)
+            : run.summary;
+        console.log(summaryToDisplay);
+        console.log();
+    }
+    // IMPORTANT: Final step outputs (outcome)
+    if (run.steps && run.steps.length > 0) {
+        // Find the last completed step with outputs
+        const stepsWithOutputs = run.steps.filter(s => s.outputs && s.outputs.length > 0);
+        if (stepsWithOutputs.length > 0) {
+            const lastStepWithOutputs = stepsWithOutputs[stepsWithOutputs.length - 1];
+            ui.section(`Outputs from "${lastStepWithOutputs.name}"`);
+            console.log();
+            for (const output of lastStepWithOutputs.outputs) {
+                console.log(`${ui.highlight(output.name)}:`);
+                // In watch mode, truncate long outputs for readability
+                if (watchMode) {
+                    console.log(ui.formatValueForWatch(output.value, 300));
+                }
+                else {
+                    if (typeof output.value === 'object') {
+                        console.log(JSON.stringify(output.value, null, 2));
+                    }
+                    else {
+                        console.log(output.value);
+                    }
+                }
+                console.log();
+            }
+        }
+    }
+    // Extracted entities (if available)
+    if (run.summaryExtractedEntities && Object.keys(run.summaryExtractedEntities).length > 0) {
+        ui.section('Extracted Entities');
+        // Truncate in watch mode
+        if (watchMode) {
+            console.log(ui.formatValueForWatch(run.summaryExtractedEntities, 300));
+        }
+        else {
+            console.log(JSON.stringify(run.summaryExtractedEntities, null, 2));
+        }
+        console.log();
+    }
+    // Timestamps
+    ui.section('Execution Timeline');
+    ui.table({
+        'Created': new Date(run.createdAt).toLocaleString(),
+        'Started': run.startedAt ? new Date(run.startedAt).toLocaleString() : 'N/A',
+        'Completed': run.completedAt ? new Date(run.completedAt).toLocaleString() : 'N/A',
+    });
+    // Progress - highlight if changed
+    if (run.currentStepId !== undefined || run.progress !== undefined) {
+        console.log();
+        if (run.progress !== undefined) {
+            const progressChanged = previousRun && previousRun.progress !== run.progress;
+            const progressDisplay = progressChanged ? ui.changed(`${run.progress}%`) : `${run.progress}%`;
+            console.log(`Progress: ${progressDisplay}`);
+        }
+        if (run.currentStepId) {
+            const stepChanged = previousRun && previousRun.currentStepId !== run.currentStepId;
+            const stepDisplay = stepChanged ? ui.changed(run.currentStepId) : run.currentStepId;
+            console.log(`Current Step: ${stepDisplay}`);
+        }
+    }
+    // Error info (if any)
+    if (run.error) {
+        console.log();
+        ui.error(`Error: ${run.error}`);
+    }
+    // Steps summary (overview) - highlight state changes
+    if (run.steps && run.steps.length > 0) {
+        console.log();
+        ui.section(`Steps Overview (${run.steps.length})`);
+        console.log();
+        for (const step of run.steps) {
+            // Check if this step's state changed
+            const previousStep = previousRun?.steps?.find(s => s.stepId === step.stepId);
+            const stateChanged = previousStep && previousStep.state !== step.state;
+            const statusIcon = step.state === 'Complete' ? '✓' :
+                step.state === 'Failed' ? '✗' :
+                    step.state === 'Pending' ? '○' : '·';
+            const stepStateDisplay = stateChanged ? ui.changed(step.state) : step.state;
+            console.log(`  ${statusIcon} ${step.name} [${stepStateDisplay}]`);
+            if (step.errors && step.errors.length > 0) {
+                for (const error of step.errors) {
+                    console.log(`    Error: ${ui.dim(error)}`);
+                }
+            }
+        }
+    }
+    console.log();
+}
+//# sourceMappingURL=workflow.js.map