@marktoflow/gui 2.0.0-alpha.4 → 2.0.1

package/tests/e2e/workflow.spec.ts

@@ -1,185 +0,0 @@
-import { test, expect } from '@playwright/test';
-
-test.describe('Workflow Management', () => {
-  test.beforeEach(async ({ page }) => {
-    await page.goto('/');
-  });
-
-  test('should display list of workflows', async ({ page }) => {
-    // Check that demo workflows are listed
-    await expect(page.locator('text=Code Review')).toBeVisible();
-    await expect(page.locator('text=Daily Standup')).toBeVisible();
-  });
-
-  test('should select a workflow from the list', async ({ page }) => {
-    // Click on a workflow
-    await page.click('text=Daily Standup');
-
-    // The workflow should be selected (highlighted)
-    const workflowButton = page.locator('button:has-text("Daily Standup")');
-    await expect(workflowButton).toHaveClass(/bg-primary/);
-  });
-
-  test('should load workflow into canvas when selected', async ({ page }) => {
-    // Click on a workflow
-    await page.click('text=Code Review');
-
-    // Wait for canvas to update
-    await page.waitForTimeout(500);
-
-    // Canvas should show nodes
-    const nodes = page.locator('.react-flow__node');
-    expect(await nodes.count()).toBeGreaterThan(0);
-  });
-
-  test('should show workflow properties when nothing is selected', async ({ page }) => {
-    // Click somewhere on canvas to deselect any node
-    await page.click('.react-flow__pane');
-
-    // Properties panel should show workflow info
-    await expect(page.locator('text=Workflow')).toBeVisible();
-    await expect(page.locator('text=Name')).toBeVisible();
-  });
-
-  test('should search for workflows', async ({ page }) => {
-    // Type in search box
-    const searchInput = page.locator('input[placeholder*="Search"]').first();
-    await searchInput.fill('Code');
-
-    // Code Review should still be visible
-    await expect(page.locator('text=Code Review')).toBeVisible();
-  });
-});
-
-test.describe('Workflow Execution', () => {
-  test.beforeEach(async ({ page }) => {
-    await page.goto('/');
-    // Wait for app to load
-    await page.waitForSelector('.react-flow');
-  });
-
-  test('should have execute button', async ({ page }) => {
-    const executeButton = page.locator('button:has-text("Execute")');
-    await expect(executeButton).toBeVisible();
-    await expect(executeButton).toBeEnabled();
-  });
-
-  test('should start execution when clicking Execute', async ({ page }) => {
-    // Click execute button
-    await page.click('button:has-text("Execute")');
-
-    // Execution overlay or status should appear
-    // The button text should change or overlay should show
-    await page.waitForTimeout(500);
-
-    // Either executing or showing results
-    const isExecuting = await page.locator('text=Stop').isVisible().catch(() => false);
-    const executionStarted = await page.locator('.react-flow__node').first().isVisible();
-
-    expect(executionStarted).toBe(true);
-  });
-
-  test('should show execution history', async ({ page }) => {
-    // Click history tab
-    await page.click('button:has-text("History")');
-
-    // History tab should be visible
-    await expect(page.locator('text=No execution history').or(page.locator('text=Run #'))).toBeVisible();
-  });
-
-  test('should save workflow', async ({ page }) => {
-    // Click save button
-    const saveButton = page.locator('button:has-text("Save")');
-    await saveButton.click();
-
-    // Save should be triggered (may show success message or just complete)
-    await page.waitForTimeout(500);
-
-    // App should still be functional
-    await expect(page.locator('.react-flow')).toBeVisible();
-  });
-});
-
-test.describe('New Step Wizard', () => {
-  test.beforeEach(async ({ page }) => {
-    await page.goto('/');
-    await page.waitForSelector('.react-flow');
-  });
-
-  test('should open new step wizard', async ({ page }) => {
-    // Click Add Step button
-    await page.click('button:has-text("Add Step")');
-
-    // Wizard dialog should open
-    await expect(page.locator('role=dialog')).toBeVisible();
-  });
-
-  test('should close wizard on cancel', async ({ page }) => {
-    // Open wizard
-    await page.click('button:has-text("Add Step")');
-
-    // Click cancel or close
-    const cancelButton = page.locator('button:has-text("Cancel")');
-    if (await cancelButton.isVisible()) {
-      await cancelButton.click();
-    } else {
-      // Press escape
-      await page.keyboard.press('Escape');
-    }
-
-    // Dialog should close
-    await expect(page.locator('role=dialog')).not.toBeVisible();
-  });
-
-  test('should open new step wizard with N key', async ({ page }) => {
-    // Focus on canvas area
-    await page.click('.react-flow__pane');
-
-    // Press N key
-    await page.keyboard.press('n');
-
-    // Wizard should open
-    await expect(page.locator('role=dialog')).toBeVisible();
-  });
-});
-
-test.describe('AI Prompt', () => {
-  test.beforeEach(async ({ page }) => {
-    await page.goto('/');
-  });
-
-  test('should have AI prompt input', async ({ page }) => {
-    // Check for prompt input area
-    const promptInput = page.locator('textarea[placeholder*="Ask"]').or(page.locator('input[placeholder*="Ask"]'));
-    const hasPrompt = await promptInput.isVisible().catch(() => false);
-
-    // May or may not be visible based on UI state
-    expect(true).toBe(true);
-  });
-});
-
-test.describe('Keyboard Shortcuts', () => {
-  test.beforeEach(async ({ page }) => {
-    await page.goto('/');
-    await page.waitForSelector('.react-flow');
-  });
-
-  test('should open shortcuts with Cmd+/', async ({ page }) => {
-    // Press Cmd+/
-    await page.keyboard.press('Meta+/');
-
-    // Shortcuts modal should open
-    await expect(page.locator('text=Keyboard Shortcuts')).toBeVisible();
-  });
-
-  test('should save with Cmd+S', async ({ page }) => {
-    // Focus canvas
-    await page.click('.react-flow__pane');
-
-    // Press Cmd+S
-    await page.keyboard.press('Meta+s');
-
-    // Save should be triggered (app should still work)
-    await expect(page.locator('.react-flow')).toBeVisible();
-  });
-});

package/tests/integration/api.test.ts

@@ -1,452 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import request from 'supertest';
-import { createTestApp } from './testApp.js';
-
-const app = createTestApp();
-
-describe('API Integration Tests', () => {
-  describe('GET /api/health', () => {
-    it('should return health status', async () => {
-      const response = await request(app).get('/api/health');
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual({
-        status: 'ok',
-        version: '2.0.0-alpha.2',
-      });
-    });
-  });
-
-  describe('Tools API', () => {
-    describe('GET /api/tools', () => {
-      it('should return list of available tools', async () => {
-        const response = await request(app).get('/api/tools');
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('tools');
-        expect(Array.isArray(response.body.tools)).toBe(true);
-        expect(response.body.tools.length).toBeGreaterThan(0);
-      });
-
-      it('should include expected tool properties', async () => {
-        const response = await request(app).get('/api/tools');
-        const tool = response.body.tools[0];
-
-        expect(tool).toHaveProperty('id');
-        expect(tool).toHaveProperty('name');
-        expect(tool).toHaveProperty('icon');
-        expect(tool).toHaveProperty('category');
-        expect(tool).toHaveProperty('description');
-        expect(tool).toHaveProperty('actionCount');
-      });
-
-      it('should include slack tool', async () => {
-        const response = await request(app).get('/api/tools');
-        const slackTool = response.body.tools.find((t: { id: string }) => t.id === 'slack');
-
-        expect(slackTool).toBeDefined();
-        expect(slackTool.name).toBe('Slack');
-        expect(slackTool.sdk).toBe('@slack/web-api');
-      });
-
-      it('should include github tool', async () => {
-        const response = await request(app).get('/api/tools');
-        const githubTool = response.body.tools.find((t: { id: string }) => t.id === 'github');
-
-        expect(githubTool).toBeDefined();
-        expect(githubTool.name).toBe('GitHub');
-        expect(githubTool.sdk).toBe('@octokit/rest');
-      });
-
-      it('should include all new payment integrations', async () => {
-        const response = await request(app).get('/api/tools');
-        const stripeTool = response.body.tools.find((t: { id: string }) => t.id === 'stripe');
-
-        expect(stripeTool).toBeDefined();
-        expect(stripeTool.name).toBe('Stripe');
-        expect(stripeTool.category).toBe('Payments');
-        expect(stripeTool.sdk).toBe('stripe');
-      });
-
-      it('should include all new communication integrations', async () => {
-        const response = await request(app).get('/api/tools');
-
-        const twilioTool = response.body.tools.find((t: { id: string }) => t.id === 'twilio');
-        expect(twilioTool).toBeDefined();
-        expect(twilioTool.name).toBe('Twilio');
-        expect(twilioTool.category).toBe('Communication');
-
-        const sendgridTool = response.body.tools.find((t: { id: string }) => t.id === 'sendgrid');
-        expect(sendgridTool).toBeDefined();
-        expect(sendgridTool.name).toBe('SendGrid');
-
-        const teamsTool = response.body.tools.find((t: { id: string }) => t.id === 'teams');
-        expect(teamsTool).toBeDefined();
-        expect(teamsTool.name).toBe('Microsoft Teams');
-      });
-
-      it('should include all new e-commerce integrations', async () => {
-        const response = await request(app).get('/api/tools');
-        const shopifyTool = response.body.tools.find((t: { id: string }) => t.id === 'shopify');
-
-        expect(shopifyTool).toBeDefined();
-        expect(shopifyTool.name).toBe('Shopify');
-        expect(shopifyTool.category).toBe('E-commerce');
-        expect(shopifyTool.sdk).toBe('@shopify/shopify-api');
-      });
-
-      it('should include all new support integrations', async () => {
-        const response = await request(app).get('/api/tools');
-        const zendeskTool = response.body.tools.find((t: { id: string }) => t.id === 'zendesk');
-
-        expect(zendeskTool).toBeDefined();
-        expect(zendeskTool.name).toBe('Zendesk');
-        expect(zendeskTool.category).toBe('Support');
-        expect(zendeskTool.sdk).toBe('node-zendesk');
-      });
-
-      it('should include all new marketing integrations', async () => {
-        const response = await request(app).get('/api/tools');
-        const mailchimpTool = response.body.tools.find((t: { id: string }) => t.id === 'mailchimp');
-
-        expect(mailchimpTool).toBeDefined();
-        expect(mailchimpTool.name).toBe('Mailchimp');
-        expect(mailchimpTool.category).toBe('Marketing');
-        expect(mailchimpTool.sdk).toBe('@mailchimp/mailchimp_marketing');
-      });
-
-      it('should include all new project management integrations', async () => {
-        const response = await request(app).get('/api/tools');
-
-        const asanaTool = response.body.tools.find((t: { id: string }) => t.id === 'asana');
-        expect(asanaTool).toBeDefined();
-        expect(asanaTool.name).toBe('Asana');
-        expect(asanaTool.category).toBe('Project Management');
-
-        const trelloTool = response.body.tools.find((t: { id: string }) => t.id === 'trello');
-        expect(trelloTool).toBeDefined();
-        expect(trelloTool.name).toBe('Trello');
-      });
-
-      it('should include all new storage integrations', async () => {
-        const response = await request(app).get('/api/tools');
-
-        const dropboxTool = response.body.tools.find((t: { id: string }) => t.id === 'dropbox');
-        expect(dropboxTool).toBeDefined();
-        expect(dropboxTool.name).toBe('Dropbox');
-        expect(dropboxTool.category).toBe('Storage');
-
-        const s3Tool = response.body.tools.find((t: { id: string }) => t.id === 'aws-s3');
-        expect(s3Tool).toBeDefined();
-        expect(s3Tool.name).toBe('AWS S3');
-        expect(s3Tool.category).toBe('Storage');
-      });
-    });
-
-    describe('GET /api/tools/:toolId', () => {
-      it('should return tool details', async () => {
-        const response = await request(app).get('/api/tools/slack');
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('tool');
-        expect(response.body.tool.id).toBe('slack');
-        expect(response.body.tool.actions).toBeDefined();
-        expect(Array.isArray(response.body.tool.actions)).toBe(true);
-      });
-
-      it('should include action details', async () => {
-        const response = await request(app).get('/api/tools/slack');
-        const actions = response.body.tool.actions;
-
-        expect(actions.length).toBeGreaterThan(0);
-
-        const postMessage = actions.find((a: { id: string }) => a.id === 'chat.postMessage');
-        expect(postMessage).toBeDefined();
-        expect(postMessage.name).toBe('Post Message');
-        expect(postMessage.inputs).toBeDefined();
-        expect(postMessage.output).toBeDefined();
-      });
-
-      it('should return 404 for unknown tool', async () => {
-        const response = await request(app).get('/api/tools/unknown-tool');
-
-        expect(response.status).toBe(404);
-        expect(response.body.error).toBe('Tool not found');
-      });
-    });
-
-    describe('GET /api/tools/:toolId - New Integrations', () => {
-      it('should return stripe tool with payment actions', async () => {
-        const response = await request(app).get('/api/tools/stripe');
-
-        expect(response.status).toBe(200);
-        expect(response.body.tool.id).toBe('stripe');
-        expect(response.body.tool.actions).toBeDefined();
-
-        const createCustomer = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'customers.create'
-        );
-        expect(createCustomer).toBeDefined();
-        expect(createCustomer.name).toBe('Create Customer');
-
-        const createPaymentIntent = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'paymentIntents.create'
-        );
-        expect(createPaymentIntent).toBeDefined();
-      });
-
-      it('should return twilio tool with messaging actions', async () => {
-        const response = await request(app).get('/api/tools/twilio');
-
-        expect(response.status).toBe(200);
-        expect(response.body.tool.id).toBe('twilio');
-
-        const sendSMS = response.body.tool.actions.find((a: { id: string }) => a.id === 'sendSMS');
-        expect(sendSMS).toBeDefined();
-        expect(sendSMS.name).toBe('Send SMS');
-
-        const sendWhatsApp = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'sendWhatsApp'
-        );
-        expect(sendWhatsApp).toBeDefined();
-      });
-
-      it('should return shopify tool with e-commerce actions', async () => {
-        const response = await request(app).get('/api/tools/shopify');
-
-        expect(response.status).toBe(200);
-        expect(response.body.tool.id).toBe('shopify');
-
-        const createProduct = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'createProduct'
-        );
-        expect(createProduct).toBeDefined();
-
-        const createOrder = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'createOrder'
-        );
-        expect(createOrder).toBeDefined();
-      });
-
-      it('should return zendesk tool with support actions', async () => {
-        const response = await request(app).get('/api/tools/zendesk');
-
-        expect(response.status).toBe(200);
-        expect(response.body.tool.id).toBe('zendesk');
-
-        const createTicket = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'createTicket'
-        );
-        expect(createTicket).toBeDefined();
-        expect(createTicket.name).toBe('Create Ticket');
-      });
-
-      it('should return asana tool with project management actions', async () => {
-        const response = await request(app).get('/api/tools/asana');
-
-        expect(response.status).toBe(200);
-        expect(response.body.tool.id).toBe('asana');
-
-        const createTask = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'createTask'
-        );
-        expect(createTask).toBeDefined();
-
-        const createProject = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'createProject'
-        );
-        expect(createProject).toBeDefined();
-      });
-
-      it('should return dropbox tool with storage actions', async () => {
-        const response = await request(app).get('/api/tools/dropbox');
-
-        expect(response.status).toBe(200);
-        expect(response.body.tool.id).toBe('dropbox');
-
-        const uploadFile = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'uploadFile'
-        );
-        expect(uploadFile).toBeDefined();
-
-        const createSharedLink = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'createSharedLink'
-        );
-        expect(createSharedLink).toBeDefined();
-      });
-
-      it('should return aws-s3 tool with object storage actions', async () => {
-        const response = await request(app).get('/api/tools/aws-s3');
-
-        expect(response.status).toBe(200);
-        expect(response.body.tool.id).toBe('aws-s3');
-
-        const uploadObject = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'uploadObject'
-        );
-        expect(uploadObject).toBeDefined();
-
-        const listObjects = response.body.tool.actions.find(
-          (a: { id: string }) => a.id === 'listObjects'
-        );
-        expect(listObjects).toBeDefined();
-      });
-    });
-
-    describe('GET /api/tools/:toolId/actions/:actionId', () => {
-      it('should return action details', async () => {
-        const response = await request(app).get('/api/tools/github/actions/pulls.get');
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('action');
-        expect(response.body.action.id).toBe('pulls.get');
-        expect(response.body.action.name).toBe('Get Pull Request');
-        expect(response.body.action.inputs).toBeDefined();
-      });
-
-      it('should include tool info in response', async () => {
-        const response = await request(app).get('/api/tools/github/actions/pulls.get');
-
-        expect(response.body).toHaveProperty('tool');
-        expect(response.body.tool.id).toBe('github');
-        expect(response.body.tool.name).toBe('GitHub');
-      });
-
-      it('should return 404 for unknown action', async () => {
-        const response = await request(app).get('/api/tools/slack/actions/unknown-action');
-
-        expect(response.status).toBe(404);
-        expect(response.body.error).toBe('Action not found');
-      });
-
-      it('should return 404 for unknown tool', async () => {
-        const response = await request(app).get('/api/tools/unknown/actions/any');
-
-        expect(response.status).toBe(404);
-        expect(response.body.error).toBe('Tool not found');
-      });
-    });
-  });
-
-  describe('Execute API', () => {
-    describe('POST /api/execute/:path', () => {
-      it('should start workflow execution', async () => {
-        const response = await request(app)
-          .post('/api/execute/test-workflow.md')
-          .send({ inputs: { foo: 'bar' } });
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('runId');
-        expect(response.body).toHaveProperty('status', 'started');
-        // The workflowPath is decoded from URL params
-        expect(response.body.workflowPath).toBeDefined();
-      });
-
-      it('should support dry run mode', async () => {
-        const response = await request(app)
-          .post('/api/execute/test-workflow.md')
-          .send({ inputs: {}, dryRun: true });
-
-        expect(response.status).toBe(200);
-        expect(response.body.dryRun).toBe(true);
-      });
-    });
-
-    describe('GET /api/execute/status/:runId', () => {
-      it('should return execution status', async () => {
-        const response = await request(app).get('/api/execute/status/run-123');
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('runId', 'run-123');
-        expect(response.body).toHaveProperty('status');
-      });
-    });
-
-    describe('POST /api/execute/cancel/:runId', () => {
-      it('should cancel execution', async () => {
-        const response = await request(app).post('/api/execute/cancel/run-123');
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('runId', 'run-123');
-        expect(response.body).toHaveProperty('status', 'cancelled');
-      });
-    });
-  });
-
-  describe('Workflows API', () => {
-    describe('GET /api/workflows', () => {
-      it('should return list of workflows', async () => {
-        const response = await request(app).get('/api/workflows');
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('workflows');
-        expect(Array.isArray(response.body.workflows)).toBe(true);
-      });
-    });
-
-    describe('POST /api/workflows', () => {
-      it('should require name parameter', async () => {
-        const response = await request(app)
-          .post('/api/workflows')
-          .send({});
-
-        expect(response.status).toBe(400);
-        expect(response.body.error).toBe('Name is required');
-      });
-    });
-
-    describe('PUT /api/workflows/:path', () => {
-      it('should require workflow data', async () => {
-        const response = await request(app)
-          .put('/api/workflows/test.md')
-          .send({});
-
-        expect(response.status).toBe(400);
-        expect(response.body.error).toBe('Workflow data is required');
-      });
-    });
-  });
-
-  describe('AI API', () => {
-    describe('POST /api/ai/prompt', () => {
-      it('should require prompt parameter', async () => {
-        const response = await request(app)
-          .post('/api/ai/prompt')
-          .send({});
-
-        expect(response.status).toBe(400);
-        expect(response.body.error).toBe('Prompt is required');
-      });
-
-      it('should handle missing workflow gracefully', async () => {
-        const response = await request(app)
-          .post('/api/ai/prompt')
-          .send({ prompt: 'Add a step' });
-
-        // Service handles missing workflow, may return error
-        expect([200, 500]).toContain(response.status);
-      });
-    });
-
-    describe('GET /api/ai/history', () => {
-      it('should return prompt history', async () => {
-        const response = await request(app).get('/api/ai/history');
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('history');
-        expect(Array.isArray(response.body.history)).toBe(true);
-      });
-    });
-
-    describe('POST /api/ai/suggestions', () => {
-      it('should return suggestions for workflow', async () => {
-        const response = await request(app)
-          .post('/api/ai/suggestions')
-          .send({ workflow: { steps: [] } });
-
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('suggestions');
-      });
-    });
-  });
-});

package/tests/integration/testApp.ts

@@ -1,31 +0,0 @@
-import express, { type Express } from 'express';
-import cors from 'cors';
-import { workflowRoutes } from '../../src/server/routes/workflows.js';
-import { aiRoutes } from '../../src/server/routes/ai.js';
-import { executeRoutes } from '../../src/server/routes/execute.js';
-import { toolsRoutes } from '../../src/server/routes/tools.js';
-
-/**
- * Create a test Express app with all routes configured
- * This allows testing the API without starting an actual server
- */
-export function createTestApp(): Express {
-  const app = express();
-
-  // Middleware
-  app.use(cors());
-  app.use(express.json());
-
-  // Routes
-  app.use('/api/workflows', workflowRoutes);
-  app.use('/api/ai', aiRoutes);
-  app.use('/api/execute', executeRoutes);
-  app.use('/api/tools', toolsRoutes);
-
-  // Health check
-  app.get('/api/health', (_req, res) => {
-    res.json({ status: 'ok', version: '2.0.0-alpha.2' });
-  });
-
-  return app;
-}