@d34dman/flowdrop 0.0.1 → 0.0.2

package/dist/adapters/WorkflowAdapter.js

@@ -13,7 +13,7 @@
  * - External applications that want to integrate with FlowDrop
  * - Systems that need to generate or modify workflows programmatically
  */
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 /**
  * Workflow Adapter Class
  * Provides a clean API for workflow operations without exposing SvelteFlow internals
@@ -34,7 +34,7 @@ export class WorkflowAdapter {
             nodes: [],
             edges: [],
             metadata: {
-                version: "1.0.0",
+                version: '1.0.0',
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString()
             }
@@ -44,7 +44,7 @@ export class WorkflowAdapter {
      * Add a node to a workflow
      */
     addNode(workflow, nodeType, position, config) {
-        const metadata = this.nodeTypes.find(nt => nt.id === nodeType);
+        const metadata = this.nodeTypes.find((nt) => nt.id === nodeType);
         if (!metadata) {
             throw new Error(`Node type '${nodeType}' not found`);
         }
@@ -66,12 +66,12 @@ export class WorkflowAdapter {
      * Remove a node from a workflow
      */
     removeNode(workflow, nodeId) {
-        const nodeIndex = workflow.nodes.findIndex(n => n.id === nodeId);
+        const nodeIndex = workflow.nodes.findIndex((n) => n.id === nodeId);
         if (nodeIndex === -1)
             return false;
         workflow.nodes.splice(nodeIndex, 1);
         // Remove associated edges
-        workflow.edges = workflow.edges.filter(edge => edge.source !== nodeId && edge.target !== nodeId);
+        workflow.edges = workflow.edges.filter((edge) => edge.source !== nodeId && edge.target !== nodeId);
         workflow.metadata.updatedAt = new Date().toISOString();
         return true;
     }
@@ -79,7 +79,7 @@ export class WorkflowAdapter {
      * Update node position
      */
     updateNodePosition(workflow, nodeId, position) {
-        const node = workflow.nodes.find(n => n.id === nodeId);
+        const node = workflow.nodes.find((n) => n.id === nodeId);
         if (!node)
             return false;
         node.position = position;
@@ -90,7 +90,7 @@ export class WorkflowAdapter {
      * Update node configuration
      */
     updateNodeConfig(workflow, nodeId, config) {
-        const node = workflow.nodes.find(n => n.id === nodeId);
+        const node = workflow.nodes.find((n) => n.id === nodeId);
         if (!node)
             return false;
         node.data.config = { ...node.data.config, ...config };
@@ -116,7 +116,7 @@ export class WorkflowAdapter {
      * Remove an edge from a workflow
      */
     removeEdge(workflow, edgeId) {
-        const edgeIndex = workflow.edges.findIndex(e => e.id === edgeId);
+        const edgeIndex = workflow.edges.findIndex((e) => e.id === edgeId);
         if (edgeIndex === -1)
             return false;
         workflow.edges.splice(edgeIndex, 1);
@@ -127,20 +127,20 @@ export class WorkflowAdapter {
      * Get all nodes of a specific type
      */
     getNodesByType(workflow, nodeType) {
-        return workflow.nodes.filter(node => node.type === nodeType);
+        return workflow.nodes.filter((node) => node.type === nodeType);
     }
     /**
      * Get all edges connected to a node
      */
     getNodeEdges(workflow, nodeId) {
-        return workflow.edges.filter(edge => edge.source === nodeId || edge.target === nodeId);
+        return workflow.edges.filter((edge) => edge.source === nodeId || edge.target === nodeId);
     }
     /**
      * Get connected nodes (both incoming and outgoing)
      */
     getConnectedNodes(workflow, nodeId) {
         const connectedNodeIds = new Set();
-        workflow.edges.forEach(edge => {
+        workflow.edges.forEach((edge) => {
             if (edge.source === nodeId) {
                 connectedNodeIds.add(edge.target);
             }
@@ -148,7 +148,7 @@ export class WorkflowAdapter {
                 connectedNodeIds.add(edge.source);
             }
         });
-        return workflow.nodes.filter(node => connectedNodeIds.has(node.id));
+        return workflow.nodes.filter((node) => connectedNodeIds.has(node.id));
     }
     /**
      * Validate workflow structure
@@ -158,11 +158,11 @@ export class WorkflowAdapter {
         const warnings = [];
         // Check for empty workflow
         if (workflow.nodes.length === 0) {
-            warnings.push("Workflow has no nodes");
+            warnings.push('Workflow has no nodes');
         }
         // Check for orphaned edges
-        const nodeIds = new Set(workflow.nodes.map(n => n.id));
-        workflow.edges.forEach(edge => {
+        const nodeIds = new Set(workflow.nodes.map((n) => n.id));
+        workflow.edges.forEach((edge) => {
             if (!nodeIds.has(edge.source)) {
                 errors.push(`Edge ${edge.id} references non-existent source node ${edge.source}`);
             }
@@ -171,14 +171,14 @@ export class WorkflowAdapter {
             }
         });
         // Check for self-connections
-        workflow.edges.forEach(edge => {
+        workflow.edges.forEach((edge) => {
             if (edge.source === edge.target) {
                 errors.push(`Node ${edge.source} cannot connect to itself`);
             }
         });
         // Check for duplicate node IDs
         const nodeIdCounts = new Map();
-        workflow.nodes.forEach(node => {
+        workflow.nodes.forEach((node) => {
             nodeIdCounts.set(node.id, (nodeIdCounts.get(node.id) || 0) + 1);
         });
         nodeIdCounts.forEach((count, id) => {
@@ -188,7 +188,7 @@ export class WorkflowAdapter {
         });
         // Check for duplicate edge IDs
         const edgeIdCounts = new Map();
-        workflow.edges.forEach(edge => {
+        workflow.edges.forEach((edge) => {
             edgeIdCounts.set(edge.id, (edgeIdCounts.get(edge.id) || 0) + 1);
         });
         edgeIdCounts.forEach((count, id) => {
@@ -217,11 +217,11 @@ export class WorkflowAdapter {
             // Validate the imported workflow
             const validation = this.validateWorkflow(workflow);
             if (!validation.valid) {
-                throw new Error(`Invalid workflow: ${validation.errors.join(", ")}`);
+                throw new Error(`Invalid workflow: ${validation.errors.join(', ')}`);
             }
             // Update metadata
             workflow.metadata = {
-                version: workflow.metadata?.version || "1.0.0",
+                version: workflow.metadata?.version || '1.0.0',
                 createdAt: workflow.metadata?.createdAt || new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
                 author: workflow.metadata?.author,
@@ -230,7 +230,7 @@ export class WorkflowAdapter {
             return workflow;
         }
         catch (error) {
-            throw new Error(`Failed to import workflow: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to import workflow: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     /**
@@ -241,7 +241,7 @@ export class WorkflowAdapter {
             id: svelteFlowWorkflow.id,
             name: svelteFlowWorkflow.name,
             description: svelteFlowWorkflow.description,
-            nodes: svelteFlowWorkflow.nodes.map(node => ({
+            nodes: svelteFlowWorkflow.nodes.map((node) => ({
                 id: node.id,
                 type: node.data.metadata.id,
                 position: node.position,
@@ -251,7 +251,7 @@ export class WorkflowAdapter {
                     metadata: node.data.metadata
                 }
             })),
-            edges: svelteFlowWorkflow.edges.map(edge => ({
+            edges: svelteFlowWorkflow.edges.map((edge) => ({
                 id: edge.id,
                 source: edge.source,
                 target: edge.target,
@@ -269,9 +269,9 @@ export class WorkflowAdapter {
             id: workflow.id,
             name: workflow.name,
             description: workflow.description,
-            nodes: workflow.nodes.map(node => ({
+            nodes: workflow.nodes.map((node) => ({
                 id: node.id,
-                type: "workflowNode",
+                type: 'workflowNode',
                 position: node.position,
                 deletable: true,
                 data: {
@@ -281,7 +281,7 @@ export class WorkflowAdapter {
                     nodeId: node.id
                 }
             })),
-            edges: workflow.edges.map(edge => ({
+            edges: workflow.edges.map((edge) => ({
                 id: edge.id,
                 source: edge.source,
                 target: edge.target,
@@ -296,7 +296,7 @@ export class WorkflowAdapter {
      */
     getWorkflowStats(workflow) {
         const nodeTypeCounts = new Map();
-        workflow.nodes.forEach(node => {
+        workflow.nodes.forEach((node) => {
             nodeTypeCounts.set(node.type, (nodeTypeCounts.get(node.type) || 0) + 1);
         });
         return {
@@ -313,12 +313,12 @@ export class WorkflowAdapter {
         const cloned = JSON.parse(JSON.stringify(workflow));
         // Generate new IDs for all nodes and edges
         const idMapping = new Map();
-        cloned.nodes.forEach(node => {
+        cloned.nodes.forEach((node) => {
             const oldId = node.id;
             node.id = uuidv4();
             idMapping.set(oldId, node.id);
         });
-        cloned.edges.forEach(edge => {
+        cloned.edges.forEach((edge) => {
             edge.id = uuidv4();
             edge.source = idMapping.get(edge.source) || edge.source;
             edge.target = idMapping.get(edge.target) || edge.target;
@@ -326,7 +326,7 @@ export class WorkflowAdapter {
         cloned.id = uuidv4();
         cloned.name = newName || `${workflow.name} (Copy)`;
         cloned.metadata = {
-            version: cloned.metadata?.version || "1.0.0",
+            version: cloned.metadata?.version || '1.0.0',
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             author: cloned.metadata?.author,

package/dist/api/client.d.ts

@@ -1,7 +1,7 @@
 /**
  * API Client for FlowDrop Workflow Library
  */
-import type { NodeMetadata, Workflow, ExecutionResult } from "../types/index.js";
+import type { NodeMetadata, Workflow, ExecutionResult, PortConfig } from '../types/index.js';
 /**
  * HTTP API client for FlowDrop
  */
@@ -76,4 +76,27 @@ export declare class FlowDropApiClient {
      * Import workflow from JSON
      */
     importWorkflow(workflowJson: string): Promise<Workflow>;
+    /**
+     * Fetch port configuration
+     */
+    getPortConfig(): Promise<PortConfig>;
+    /**
+     * Fetch pipeline data including job information and status
+     */
+    getPipelineData(pipelineId: string): Promise<{
+        status: string;
+        jobs: Array<Record<string, unknown>>;
+        node_statuses: Record<string, {
+            status: string;
+            [key: string]: unknown;
+        }>;
+        job_status_summary: {
+            total: number;
+            pending: number;
+            running: number;
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
+    }>;
 }

package/dist/api/client.js

@@ -8,12 +8,12 @@ export class FlowDropApiClient {
     baseUrl;
     headers;
     constructor(baseUrl, apiKey) {
-        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.baseUrl = baseUrl.replace(/\/$/, '');
         this.headers = {
-            "Content-Type": "application/json",
+            'Content-Type': 'application/json'
         };
         if (apiKey) {
-            this.headers["Authorization"] = `Bearer ${apiKey}`;
+            this.headers['Authorization'] = `Bearer ${apiKey}`;
         }
     }
     /**
@@ -23,7 +23,7 @@ export class FlowDropApiClient {
         const url = `${this.baseUrl}${endpoint}`;
         const config = {
             headers: this.headers,
-            ...options,
+            ...options
         };
         try {
             const response = await fetch(url, config);
@@ -34,17 +34,17 @@ export class FlowDropApiClient {
             return data;
         }
         catch (error) {
-            console.error("API request failed:", error);
-            throw new Error(`API request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+            console.error('API request failed:', error);
+            throw new Error(`API request failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     /**
      * Fetch available node types and their metadata
      */
     async getAvailableNodes() {
-        const response = await this.request("/api/nodes");
+        const response = await this.request('/api/flowdrop/nodes');
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to fetch available nodes");
+            throw new Error(response.error || 'Failed to fetch available nodes');
         }
         return response.data;
     }
@@ -54,7 +54,7 @@ export class FlowDropApiClient {
     async getNodesByCategory(category) {
         const response = await this.request(`/api/nodes?category=${encodeURIComponent(category)}`);
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to fetch nodes by category");
+            throw new Error(response.error || 'Failed to fetch nodes by category');
         }
         return response.data;
     }
@@ -64,7 +64,7 @@ export class FlowDropApiClient {
     async getNodeMetadata(nodeId) {
         const response = await this.request(`/api/nodes/${encodeURIComponent(nodeId)}`);
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to fetch node metadata");
+            throw new Error(response.error || 'Failed to fetch node metadata');
         }
         return response.data;
     }
@@ -72,12 +72,12 @@ export class FlowDropApiClient {
      * Save a workflow
      */
     async saveWorkflow(workflow) {
-        const response = await this.request("/api/workflows", {
-            method: "POST",
-            body: JSON.stringify(workflow),
+        const response = await this.request('/api/flowdrop/workflows', {
+            method: 'POST',
+            body: JSON.stringify(workflow)
         });
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to save workflow");
+            throw new Error(response.error || 'Failed to save workflow');
         }
         return response.data;
     }
@@ -86,11 +86,11 @@ export class FlowDropApiClient {
      */
     async updateWorkflow(workflowId, workflow) {
         const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}`, {
-            method: "PUT",
-            body: JSON.stringify(workflow),
+            method: 'PUT',
+            body: JSON.stringify(workflow)
         });
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to update workflow");
+            throw new Error(response.error || 'Failed to update workflow');
         }
         return response.data;
     }
@@ -100,7 +100,7 @@ export class FlowDropApiClient {
     async loadWorkflow(workflowId) {
         const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}`);
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to load workflow");
+            throw new Error(response.error || 'Failed to load workflow');
         }
         return response.data;
     }
@@ -108,9 +108,9 @@ export class FlowDropApiClient {
      * List all workflows
      */
     async listWorkflows() {
-        const response = await this.request("/api/workflows");
+        const response = await this.request('/api/flowdrop/workflows');
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to list workflows");
+            throw new Error(response.error || 'Failed to list workflows');
         }
         return response.data;
     }
@@ -119,10 +119,10 @@ export class FlowDropApiClient {
      */
     async deleteWorkflow(workflowId) {
         const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}`, {
-            method: "DELETE",
+            method: 'DELETE'
         });
         if (!response.success) {
-            throw new Error(response.error || "Failed to delete workflow");
+            throw new Error(response.error || 'Failed to delete workflow');
         }
     }
     /**
@@ -130,11 +130,11 @@ export class FlowDropApiClient {
      */
     async executeWorkflow(workflowId, inputs) {
         const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}/execute`, {
-            method: "POST",
-            body: JSON.stringify({ inputs }),
+            method: 'POST',
+            body: JSON.stringify({ inputs })
         });
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to execute workflow");
+            throw new Error(response.error || 'Failed to execute workflow');
         }
         return response.data;
     }
@@ -144,7 +144,7 @@ export class FlowDropApiClient {
     async getExecutionStatus(executionId) {
         const response = await this.request(`/api/executions/${encodeURIComponent(executionId)}`);
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to get execution status");
+            throw new Error(response.error || 'Failed to get execution status');
         }
         return response.data;
     }
@@ -153,10 +153,10 @@ export class FlowDropApiClient {
      */
     async cancelExecution(executionId) {
         const response = await this.request(`/api/executions/${encodeURIComponent(executionId)}/cancel`, {
-            method: "POST",
+            method: 'POST'
         });
         if (!response.success) {
-            throw new Error(response.error || "Failed to cancel execution");
+            throw new Error(response.error || 'Failed to cancel execution');
         }
     }
     /**
@@ -165,7 +165,7 @@ export class FlowDropApiClient {
     async getExecutionLogs(executionId) {
         const response = await this.request(`/api/executions/${encodeURIComponent(executionId)}/logs`);
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to get execution logs");
+            throw new Error(response.error || 'Failed to get execution logs');
         }
         return response.data;
     }
@@ -173,12 +173,12 @@ export class FlowDropApiClient {
      * Validate workflow configuration
      */
     async validateWorkflow(workflow) {
-        const response = await this.request("/api/workflows/validate", {
-            method: "POST",
-            body: JSON.stringify(workflow),
+        const response = await this.request('/api/flowdrop/workflows/validate', {
+            method: 'POST',
+            body: JSON.stringify(workflow)
         });
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to validate workflow");
+            throw new Error(response.error || 'Failed to validate workflow');
         }
         return response.data;
     }
@@ -188,7 +188,7 @@ export class FlowDropApiClient {
     async exportWorkflow(workflowId) {
         const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}/export`);
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to export workflow");
+            throw new Error(response.error || 'Failed to export workflow');
         }
         return response.data;
     }
@@ -196,13 +196,30 @@ export class FlowDropApiClient {
      * Import workflow from JSON
      */
     async importWorkflow(workflowJson) {
-        const response = await this.request("/api/workflows/import", {
-            method: "POST",
-            body: JSON.stringify({ workflow: workflowJson }),
+        const response = await this.request('/api/flowdrop/workflows/import', {
+            method: 'POST',
+            body: JSON.stringify({ workflow: workflowJson })
         });
         if (!response.success || !response.data) {
-            throw new Error(response.error || "Failed to import workflow");
+            throw new Error(response.error || 'Failed to import workflow');
         }
         return response.data;
     }
+    /**
+     * Fetch port configuration
+     */
+    async getPortConfig() {
+        const response = await this.request('/api/flowdrop/port-config');
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to fetch port configuration');
+        }
+        return response.data;
+    }
+    /**
+     * Fetch pipeline data including job information and status
+     */
+    async getPipelineData(pipelineId) {
+        const response = await this.request(`/api/flowdrop/pipeline/${encodeURIComponent(pipelineId)}`);
+        return response;
+    }
 }

package/dist/api/enhanced-client.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Enhanced API Client for FlowDrop
+ * Uses configurable endpoints for all API actions
+ */
+import type { NodeMetadata, Workflow, ExecutionResult } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
+/**
+ * Enhanced HTTP API client for FlowDrop with configurable endpoints
+ */
+export declare class EnhancedFlowDropApiClient {
+    private config;
+    constructor(config: EndpointConfig);
+    /**
+     * Make HTTP request with error handling and retry logic
+     */
+    private request;
+    getAvailableNodes(): Promise<NodeMetadata[]>;
+    getNodesByCategory(category: string): Promise<NodeMetadata[]>;
+    getNodeMetadata(nodeId: string): Promise<NodeMetadata>;
+    saveWorkflow(workflow: Workflow): Promise<Workflow>;
+    updateWorkflow(workflowId: string, workflow: Partial<Workflow>): Promise<Workflow>;
+    loadWorkflow(workflowId: string): Promise<Workflow>;
+    listWorkflows(): Promise<Workflow[]>;
+    deleteWorkflow(workflowId: string): Promise<void>;
+    validateWorkflow(workflow: Workflow): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+    exportWorkflow(workflowId: string): Promise<string>;
+    importWorkflow(workflowJson: string): Promise<Workflow>;
+    executeWorkflow(workflowId: string, inputs?: Record<string, unknown>): Promise<ExecutionResult>;
+    getExecutionStatus(executionId: string): Promise<ExecutionResult>;
+    cancelExecution(executionId: string): Promise<void>;
+    getExecutionLogs(executionId: string): Promise<string[]>;
+    listTemplates(): Promise<Workflow[]>;
+    getTemplate(templateId: string): Promise<Workflow>;
+    getSystemHealth(): Promise<{
+        status: string;
+        timestamp: number;
+    }>;
+    getSystemConfig(): Promise<Record<string, unknown>>;
+    getSystemVersion(): Promise<{
+        version: string;
+        build: string;
+    }>;
+}