@marktoflow/gui 2.0.0-alpha.5 → 2.0.2

package/src/server/services/WorkflowService.ts

@@ -1,601 +0,0 @@
-import { readdir, readFile, writeFile, unlink, mkdir } from 'fs/promises';
-import { join, relative, dirname, basename, extname } from 'path';
-import { existsSync } from 'fs';
-import { stringify as yamlStringify, parse as yamlParse } from 'yaml';
-import AdmZip from 'adm-zip';
-// Import from @marktoflow/core for proper parsing
-import { parseFile as coreParseFile, type ExecutionRecord } from '@marktoflow/core';
-import { getStateStore } from '../index.js';
-
-interface WorkflowListItem {
-  path: string;
-  name: string;
-  description?: string;
-  version?: string;
-}
-
-interface WorkflowMetadata {
-  id: string;
-  name: string;
-  version?: string;
-  description?: string;
-  author?: string;
-  tags?: string[];
-}
-
-interface WorkflowStep {
-  id: string;
-  name?: string;
-  action?: string;
-  workflow?: string;
-  inputs: Record<string, unknown>;
-  outputVariable?: string;
-  conditions?: string[];
-  errorHandling?: {
-    action: 'stop' | 'continue' | 'retry';
-    maxRetries?: number;
-    retryDelay?: number;
-    fallbackStep?: string;
-  };
-  timeout?: number;
-}
-
-interface Workflow {
-  metadata: WorkflowMetadata;
-  steps: WorkflowStep[];
-  tools?: Record<string, unknown>;
-  inputs?: Record<string, unknown>;
-  triggers?: unknown[];
-  markdown?: string;
-}
-
-export class WorkflowService {
-  private workflowDir: string;
-
-  constructor(workflowDir?: string) {
-    this.workflowDir = workflowDir || process.env.WORKFLOW_DIR || process.cwd();
-  }
-
-  async listWorkflows(): Promise<WorkflowListItem[]> {
-    const workflows: WorkflowListItem[] = [];
-    const baseDir = this.workflowDir;
-
-    async function scanDirectory(dir: string) {
-      try {
-        const entries = await readdir(dir, { withFileTypes: true });
-
-        for (const entry of entries) {
-          const fullPath = join(dir, entry.name);
-
-          // Skip hidden directories and node_modules
-          if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist') {
-            continue;
-          }
-
-          if (entry.isDirectory()) {
-            await scanDirectory(fullPath);
-          } else if (
-            entry.isFile() &&
-            (entry.name.endsWith('.md') || entry.name.endsWith('.yaml') || entry.name.endsWith('.yml'))
-          ) {
-            // Skip README files (they're documentation, not workflows)
-            if (entry.name.toLowerCase() === 'readme.md') {
-              continue;
-            }
-
-            // Check if it's a workflow file by verifying YAML frontmatter
-            try {
-              const content = await readFile(fullPath, 'utf-8');
-
-              // For markdown files, verify it has YAML frontmatter
-              if (entry.name.endsWith('.md')) {
-                if (!content.trimStart().startsWith('---\n')) {
-                  continue;
-                }
-                const frontmatterMatch = content.match(/^---\n[\s\S]*?\n---/);
-                if (!frontmatterMatch) {
-                  continue;
-                }
-                const frontmatter = frontmatterMatch[0];
-                if (!frontmatter.includes('workflow:') && !frontmatter.includes('steps:')) {
-                  continue;
-                }
-              } else {
-                // For YAML files, check if they contain workflow structure
-                if (!content.includes('workflow:') && !content.includes('steps:')) {
-                  continue;
-                }
-              }
-
-              const relativePath = relative(baseDir, fullPath);
-              const workflowInfo = extractWorkflowInfo(content, entry.name);
-              workflows.push({
-                path: relativePath,
-                ...workflowInfo,
-              });
-            } catch {
-              // Skip files that can't be read
-            }
-          }
-        }
-      } catch {
-        // Skip directories we can't read
-      }
-    }
-
-    await scanDirectory(this.workflowDir);
-    return workflows.sort((a, b) => a.name.localeCompare(b.name));
-  }
-
-  async getWorkflow(workflowPath: string): Promise<Workflow | null> {
-    const fullPath = this.resolvePath(workflowPath);
-
-    if (!existsSync(fullPath)) {
-      return null;
-    }
-
-    try {
-      // Read the raw markdown content for GUI parser
-      const rawContent = await readFile(fullPath, 'utf-8');
-
-      // Use core parser for proper workflow parsing
-      const result = await coreParseFile(fullPath);
-      if (result.warnings && result.warnings.length > 0) {
-        console.warn(`Workflow ${workflowPath} has parsing warnings:`, result.warnings);
-      }
-
-      // Convert core Workflow type to GUI Workflow type
-      const workflow = this.convertCoreWorkflow(result.workflow, workflowPath);
-
-      // Add raw markdown for GUI control flow parsing
-      return {
-        ...workflow,
-        markdown: rawContent,
-      };
-    } catch (error) {
-      console.error(`Error parsing workflow ${workflowPath}:`, error);
-      // Fallback to local parsing if core parser fails
-      try {
-        const content = await readFile(fullPath, 'utf-8');
-        return this.parseWorkflow(content, workflowPath);
-      } catch {
-        return null;
-      }
-    }
-  }
-
-  private convertCoreWorkflow(coreWorkflow: any, path: string): Workflow {
-    return {
-      metadata: {
-        id: coreWorkflow.metadata?.id || path,
-        name: coreWorkflow.metadata?.name || path,
-        version: coreWorkflow.metadata?.version,
-        description: coreWorkflow.metadata?.description,
-        author: coreWorkflow.metadata?.author,
-        tags: coreWorkflow.metadata?.tags,
-      },
-      steps: (coreWorkflow.steps || []).map((step: any) => ({
-        id: step.id,
-        name: step.name,
-        action: step.action,
-        workflow: step.workflow,
-        inputs: step.inputs || {},
-        outputVariable: step.outputVariable || step.output_variable,
-        conditions: step.conditions,
-        errorHandling: step.errorHandling || step.error_handling,
-        timeout: step.timeout,
-      })),
-      tools: coreWorkflow.tools,
-      inputs: coreWorkflow.inputs,
-      triggers: coreWorkflow.triggers,
-    };
-  }
-
-  async createWorkflow(name: string, template?: string): Promise<WorkflowListItem> {
-    const filename = name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '') + '.md';
-    const workflowPath = join('workflows', filename);
-    const fullPath = join(this.workflowDir, workflowPath);
-
-    // Ensure directory exists
-    await mkdir(dirname(fullPath), { recursive: true });
-
-    const content = template || this.generateWorkflowTemplate(name);
-    await writeFile(fullPath, content, 'utf-8');
-
-    return {
-      path: workflowPath,
-      name,
-    };
-  }
-
-  async updateWorkflow(workflowPath: string, workflow: Workflow): Promise<Workflow> {
-    const fullPath = this.resolvePath(workflowPath);
-
-    // Read original file to preserve markdown content
-    let markdownContent = '';
-    if (existsSync(fullPath)) {
-      const originalContent = await readFile(fullPath, 'utf-8');
-      const match = originalContent.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
-      if (match) {
-        markdownContent = match[1];
-      }
-    }
-
-    const content = this.serializeWorkflow(workflow, markdownContent);
-    await writeFile(fullPath, content, 'utf-8');
-    return workflow;
-  }
-
-  async deleteWorkflow(workflowPath: string): Promise<void> {
-    const fullPath = this.resolvePath(workflowPath);
-    if (existsSync(fullPath)) {
-      await unlink(fullPath);
-    }
-  }
-
-  async getExecutionHistory(workflowPath: string): Promise<ExecutionRecord[]> {
-    try {
-      const stateStore = getStateStore();
-      // Use the workflow path as the workflow ID for querying
-      const executions = stateStore.listExecutions({
-        workflowId: workflowPath,
-        limit: 50,
-      });
-      return executions;
-    } catch (error) {
-      console.error('Error getting execution history:', error);
-      return [];
-    }
-  }
-
-  async importWorkflow(
-    fileBuffer: Buffer,
-    originalFilename: string
-  ): Promise<{ success: boolean; results?: Array<{ success: boolean; filename: string; message?: string }>; filename?: string; message?: string }> {
-    const ext = extname(originalFilename).toLowerCase();
-
-    try {
-      // Handle ZIP files - extract and import all workflow files
-      if (ext === '.zip') {
-        return await this.importZipBundle(fileBuffer);
-      }
-
-      // Handle single workflow files (.md, .yaml, .yml)
-      if (['.md', '.yaml', '.yml'].includes(ext)) {
-        const content = fileBuffer.toString('utf-8');
-        await this.importSingleWorkflow(content, originalFilename);
-
-        return {
-          success: true,
-          filename: originalFilename,
-          message: 'Workflow imported successfully',
-        };
-      }
-
-      throw new Error('Unsupported file type');
-    } catch (error) {
-      console.error('Import error:', error);
-      throw error;
-    }
-  }
-
-  private async importSingleWorkflow(content: string, filename: string): Promise<void> {
-    // Validate workflow content
-    try {
-      // Basic validation - try to parse YAML frontmatter or direct YAML
-      if (filename.endsWith('.md')) {
-        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-        if (frontmatterMatch) {
-          yamlParse(frontmatterMatch[1]);
-        } else {
-          throw new Error('Invalid markdown workflow: missing YAML frontmatter');
-        }
-      } else {
-        yamlParse(content);
-      }
-    } catch (error) {
-      throw new Error(`Invalid workflow format: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-
-    // Check for filename conflicts
-    let targetFilename = filename;
-    let fullPath = this.resolvePath(targetFilename);
-    let counter = 1;
-
-    while (existsSync(fullPath)) {
-      const nameWithoutExt = basename(filename, extname(filename));
-      targetFilename = `${nameWithoutExt}-${counter}${extname(filename)}`;
-      fullPath = this.resolvePath(targetFilename);
-      counter++;
-    }
-
-    // Write file
-    await writeFile(fullPath, content, 'utf-8');
-  }
-
-  private async importZipBundle(zipBuffer: Buffer): Promise<{ success: boolean; results: Array<{ success: boolean; filename: string; message?: string }> }> {
-    const results: Array<{ success: boolean; filename: string; message?: string }> = [];
-
-    try {
-      const zip = new AdmZip(zipBuffer);
-      const zipEntries = zip.getEntries();
-
-      for (const entry of zipEntries) {
-        // Skip directories and non-workflow files
-        if (entry.isDirectory) continue;
-
-        const filename = basename(entry.entryName);
-        const ext = extname(filename).toLowerCase();
-
-        if (!['.md', '.yaml', '.yml'].includes(ext)) {
-          results.push({
-            success: false,
-            filename,
-            message: 'Skipped: not a workflow file',
-          });
-          continue;
-        }
-
-        try {
-          const content = entry.getData().toString('utf-8');
-          await this.importSingleWorkflow(content, filename);
-
-          results.push({
-            success: true,
-            filename,
-            message: 'Imported successfully',
-          });
-        } catch (error) {
-          results.push({
-            success: false,
-            filename,
-            message: error instanceof Error ? error.message : 'Unknown error',
-          });
-        }
-      }
-
-      return {
-        success: results.some(r => r.success),
-        results,
-      };
-    } catch (error) {
-      throw new Error(`Failed to extract ZIP file: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  private resolvePath(workflowPath: string): string {
-    // Handle both absolute and relative paths
-    if (workflowPath.startsWith('/')) {
-      return workflowPath;
-    }
-    return join(this.workflowDir, workflowPath);
-  }
-
-  private parseWorkflow(content: string, path: string): Workflow {
-    // Extract YAML frontmatter
-    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-
-    if (!frontmatterMatch) {
-      return {
-        metadata: { id: path, name: path },
-        steps: [],
-      };
-    }
-
-    const yaml = frontmatterMatch[1];
-
-    // Parse the YAML manually for now (will use @marktoflow/core parser when integrated)
-    const workflow: Workflow = {
-      metadata: { id: path, name: path },
-      steps: [],
-    };
-
-    // Extract workflow metadata
-    const workflowSection = yaml.match(/workflow:\s*\n((?:  .*\n)*)/);
-    if (workflowSection) {
-      const idMatch = workflowSection[1].match(/id:\s*(\S+)/);
-      const nameMatch = workflowSection[1].match(/name:\s*["']?(.+?)["']?\s*$/m);
-      const versionMatch = workflowSection[1].match(/version:\s*["']?(.+?)["']?\s*$/m);
-      const descMatch = workflowSection[1].match(/description:\s*["']?(.+?)["']?\s*$/m);
-      const authorMatch = workflowSection[1].match(/author:\s*["']?(.+?)["']?\s*$/m);
-
-      if (idMatch) workflow.metadata.id = idMatch[1].trim();
-      if (nameMatch) workflow.metadata.name = nameMatch[1].trim();
-      if (versionMatch) workflow.metadata.version = versionMatch[1].trim();
-      if (descMatch) workflow.metadata.description = descMatch[1].trim();
-      if (authorMatch) workflow.metadata.author = authorMatch[1].trim();
-
-      // Extract tags
-      const tagsMatch = workflowSection[1].match(/tags:\s*\[(.*?)\]/);
-      if (tagsMatch) {
-        workflow.metadata.tags = tagsMatch[1]
-          .split(',')
-          .map((t) => t.trim().replace(/["']/g, ''))
-          .filter(Boolean);
-      }
-    }
-
-    // Extract steps using regex to find step blocks
-    const stepsSection = yaml.match(/steps:\s*\n((?:  - [\s\S]*?)(?=\n\w|$))/);
-    if (stepsSection) {
-      const stepBlocks = stepsSection[1].split(/\n  - /).filter(Boolean);
-
-      for (const block of stepBlocks) {
-        const stepText = block.startsWith('id:') ? block : block;
-        const step = this.parseStep(stepText);
-        if (step) {
-          workflow.steps.push(step);
-        }
-      }
-    }
-
-    // Extract tools
-    const toolsMatch = yaml.match(/tools:\s*\n((?:  .*\n)*)/);
-    if (toolsMatch) {
-      // Simple extraction - will be enhanced with proper YAML parser
-      workflow.tools = {};
-    }
-
-    // Extract inputs
-    const inputsMatch = yaml.match(/inputs:\s*\n((?:  .*\n)*)/);
-    if (inputsMatch) {
-      workflow.inputs = {};
-    }
-
-    return workflow;
-  }
-
-  private parseStep(stepText: string): WorkflowStep | null {
-    const idMatch = stepText.match(/id:\s*(\S+)/);
-    if (!idMatch) return null;
-
-    const step: WorkflowStep = {
-      id: idMatch[1],
-      inputs: {},
-    };
-
-    const nameMatch = stepText.match(/name:\s*["']?(.+?)["']?\s*$/m);
-    if (nameMatch) step.name = nameMatch[1];
-
-    const actionMatch = stepText.match(/action:\s*(\S+)/);
-    if (actionMatch) step.action = actionMatch[1];
-
-    const workflowMatch = stepText.match(/workflow:\s*(\S+)/);
-    if (workflowMatch) step.workflow = workflowMatch[1];
-
-    const outputMatch = stepText.match(/output_variable:\s*(\S+)/);
-    if (outputMatch) step.outputVariable = outputMatch[1];
-
-    const timeoutMatch = stepText.match(/timeout:\s*(\d+)/);
-    if (timeoutMatch) step.timeout = parseInt(timeoutMatch[1], 10);
-
-    // Parse inputs (simplified)
-    const inputsMatch = stepText.match(/inputs:\s*\n((?:      .*\n)*)/);
-    if (inputsMatch) {
-      const inputLines = inputsMatch[1].split('\n').filter(Boolean);
-      for (const line of inputLines) {
-        const kvMatch = line.match(/^\s*(\w+):\s*(.+)$/);
-        if (kvMatch) {
-          let value: unknown = kvMatch[2].trim();
-          // Remove quotes if present
-          if ((value as string).startsWith("'") && (value as string).endsWith("'")) {
-            value = (value as string).slice(1, -1);
-          } else if ((value as string).startsWith('"') && (value as string).endsWith('"')) {
-            value = (value as string).slice(1, -1);
-          }
-          step.inputs[kvMatch[1]] = value;
-        }
-      }
-    }
-
-    return step;
-  }
-
-  private serializeWorkflow(workflow: Workflow, markdownContent: string = ''): string {
-    const frontmatter: Record<string, unknown> = {
-      workflow: {
-        id: workflow.metadata.id,
-        name: workflow.metadata.name,
-        version: workflow.metadata.version || '1.0.0',
-        description: workflow.metadata.description || '',
-        author: workflow.metadata.author || '',
-        tags: workflow.metadata.tags || [],
-      },
-    };
-
-    if (workflow.tools && Object.keys(workflow.tools).length > 0) {
-      frontmatter.tools = workflow.tools;
-    }
-
-    if (workflow.inputs && Object.keys(workflow.inputs).length > 0) {
-      frontmatter.inputs = workflow.inputs;
-    }
-
-    if (workflow.triggers && workflow.triggers.length > 0) {
-      frontmatter.triggers = workflow.triggers;
-    }
-
-    // Serialize steps
-    frontmatter.steps = workflow.steps.map((step) => {
-      const stepObj: Record<string, unknown> = {
-        id: step.id,
-      };
-
-      if (step.name) stepObj.name = step.name;
-      if (step.action) stepObj.action = step.action;
-      if (step.workflow) stepObj.workflow = step.workflow;
-      if (Object.keys(step.inputs).length > 0) stepObj.inputs = step.inputs;
-      if (step.outputVariable) stepObj.output_variable = step.outputVariable;
-      if (step.conditions && step.conditions.length > 0) stepObj.conditions = step.conditions;
-      if (step.errorHandling) stepObj.error_handling = step.errorHandling;
-      if (step.timeout) stepObj.timeout = step.timeout;
-
-      return stepObj;
-    });
-
-    const yaml = yamlStringify(frontmatter, {
-      indent: 2,
-      lineWidth: 0,
-      defaultKeyType: 'PLAIN',
-      defaultStringType: 'QUOTE_DOUBLE',
-    });
-
-    // Generate markdown if not provided
-    if (!markdownContent.trim()) {
-      markdownContent = `\n# ${workflow.metadata.name}\n\n${workflow.metadata.description || ''}\n`;
-    }
-
-    return `---\n${yaml}---${markdownContent}`;
-  }
-
-  private generateWorkflowTemplate(name: string): string {
-    const id = name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-
-    return `---
-workflow:
-  id: ${id}
-  name: "${name}"
-  version: "1.0.0"
-  description: ""
-  author: ""
-  tags: []
-
-inputs: {}
-
-steps:
-  - id: step-1
-    name: "First Step"
-    action: http.request
-    inputs:
-      url: "https://api.example.com"
-      method: "GET"
-    output_variable: result
----
-
-# ${name}
-
-Describe your workflow here.
-
-## Steps
-
-### Step 1: First Step
-
-This step makes an HTTP request to the API.
-`;
-  }
-}
-
-function extractWorkflowInfo(
-  content: string,
-  filename: string
-): { name: string; description?: string; version?: string } {
-  const nameMatch = content.match(/name:\s*["']?(.+?)["']?\s*$/m);
-  const descMatch = content.match(/description:\s*["']?(.+?)["']?\s*$/m);
-  const versionMatch = content.match(/version:\s*["']?(.+?)["']?\s*$/m);
-
-  return {
-    name: nameMatch?.[1]?.trim() || filename.replace(/\.(md|yaml|yml)$/, '').replace(/-/g, ' '),
-    description: descMatch?.[1]?.trim(),
-    version: versionMatch?.[1]?.trim(),
-  };
-}