portos-ai-toolkit 0.1.0

package/src/server/providers.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, rm, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { createProviderService } from './providers.js';
+
+const TEST_DATA_DIR = join(process.cwd(), 'test-data');
+
+describe('Provider Service', () => {
+  let providerService;
+
+  beforeEach(async () => {
+    // Create test data directory
+    if (!existsSync(TEST_DATA_DIR)) {
+      await mkdir(TEST_DATA_DIR, { recursive: true });
+    }
+
+    providerService = createProviderService({
+      dataDir: TEST_DATA_DIR,
+      providersFile: 'providers.json'
+    });
+  });
+
+  afterEach(async () => {
+    // Clean up test data
+    if (existsSync(TEST_DATA_DIR)) {
+      await rm(TEST_DATA_DIR, { recursive: true });
+    }
+  });
+
+  it('should create a provider', async () => {
+    const provider = await providerService.createProvider({
+      name: 'Test Provider',
+      type: 'cli',
+      command: 'test',
+      args: ['--version']
+    });
+
+    expect(provider).toBeDefined();
+    expect(provider.id).toBe('test-provider');
+    expect(provider.name).toBe('Test Provider');
+    expect(provider.type).toBe('cli');
+  });
+
+  it('should get all providers', async () => {
+    await providerService.createProvider({
+      name: 'Test Provider 1',
+      type: 'cli',
+      command: 'test1'
+    });
+
+    await providerService.createProvider({
+      name: 'Test Provider 2',
+      type: 'api',
+      endpoint: 'https://api.example.com'
+    });
+
+    const { providers } = await providerService.getAllProviders();
+    expect(providers).toHaveLength(2);
+  });
+
+  it('should set active provider', async () => {
+    const newProvider = await providerService.createProvider({
+      name: 'Test Provider',
+      type: 'cli',
+      command: 'test'
+    });
+
+    const active = await providerService.setActiveProvider(newProvider.id);
+    expect(active).toBeDefined();
+    expect(active.id).toBe(newProvider.id);
+
+    const activeProvider = await providerService.getActiveProvider();
+    expect(activeProvider.id).toBe(newProvider.id);
+  });
+
+  it('should update a provider', async () => {
+    const newProvider = await providerService.createProvider({
+      name: 'Test Provider',
+      type: 'cli',
+      command: 'test'
+    });
+
+    const updated = await providerService.updateProvider(newProvider.id, {
+      command: 'updated-test'
+    });
+
+    expect(updated.command).toBe('updated-test');
+  });
+
+  it('should delete a provider', async () => {
+    const newProvider = await providerService.createProvider({
+      name: 'Test Provider',
+      type: 'cli',
+      command: 'test'
+    });
+
+    const deleted = await providerService.deleteProvider(newProvider.id);
+    expect(deleted).toBe(true);
+
+    const retrieved = await providerService.getProviderById(newProvider.id);
+    expect(retrieved).toBeNull();
+  });
+
+  it('should throw error for duplicate provider', async () => {
+    await providerService.createProvider({
+      name: 'Test Provider',
+      type: 'cli',
+      command: 'test'
+    });
+
+    await expect(
+      providerService.createProvider({
+        name: 'Test Provider',
+        type: 'cli',
+        command: 'test'
+      })
+    ).rejects.toThrow('Provider with this ID already exists');
+  });
+});

package/src/server/routes/prompts.js

@@ -0,0 +1,96 @@
+import { Router } from 'express';
+
+/**
+ * Create prompts routes
+ */
+export function createPromptsRoutes(promptsService, options = {}) {
+  const router = Router();
+  const { asyncHandler = (fn) => fn } = options;
+
+  // GET /prompts/stages - Get all stages
+  router.get('/stages', asyncHandler(async (req, res) => {
+    const stages = promptsService.getStages();
+    res.json(stages);
+  }));
+
+  // GET /prompts/stages/:name - Get specific stage
+  router.get('/stages/:name', asyncHandler(async (req, res) => {
+    const stage = promptsService.getStage(req.params.name);
+
+    if (!stage) {
+      return res.status(404).json({ error: 'Stage not found' });
+    }
+
+    const template = await promptsService.getStageTemplate(req.params.name);
+    res.json({ ...stage, template });
+  }));
+
+  // PUT /prompts/stages/:name - Update stage
+  router.put('/stages/:name', asyncHandler(async (req, res) => {
+    const { config, template } = req.body;
+
+    if (config) {
+      await promptsService.updateStageConfig(req.params.name, config);
+    }
+
+    if (template) {
+      await promptsService.updateStageTemplate(req.params.name, template);
+    }
+
+    const updated = promptsService.getStage(req.params.name);
+    const updatedTemplate = await promptsService.getStageTemplate(req.params.name);
+
+    res.json({ ...updated, template: updatedTemplate });
+  }));
+
+  // POST /prompts/stages/:name/preview - Preview stage with test data
+  router.post('/stages/:name/preview', asyncHandler(async (req, res) => {
+    const preview = await promptsService.previewPrompt(req.params.name, req.body);
+    res.json({ preview });
+  }));
+
+  // GET /prompts/variables - Get all variables
+  router.get('/variables', asyncHandler(async (req, res) => {
+    const variables = promptsService.getVariables();
+    res.json(variables);
+  }));
+
+  // GET /prompts/variables/:key - Get specific variable
+  router.get('/variables/:key', asyncHandler(async (req, res) => {
+    const variable = promptsService.getVariable(req.params.key);
+
+    if (!variable) {
+      return res.status(404).json({ error: 'Variable not found' });
+    }
+
+    res.json(variable);
+  }));
+
+  // POST /prompts/variables - Create variable
+  router.post('/variables', asyncHandler(async (req, res) => {
+    const { key, ...data } = req.body;
+
+    if (!key) {
+      return res.status(400).json({ error: 'Variable key is required' });
+    }
+
+    await promptsService.createVariable(key, data);
+    const created = promptsService.getVariable(key);
+    res.status(201).json(created);
+  }));
+
+  // PUT /prompts/variables/:key - Update variable
+  router.put('/variables/:key', asyncHandler(async (req, res) => {
+    await promptsService.updateVariable(req.params.key, req.body);
+    const updated = promptsService.getVariable(req.params.key);
+    res.json(updated);
+  }));
+
+  // DELETE /prompts/variables/:key - Delete variable
+  router.delete('/variables/:key', asyncHandler(async (req, res) => {
+    await promptsService.deleteVariable(req.params.key);
+    res.status(204).send();
+  }));
+
+  return router;
+}

package/src/server/routes/providers.js

@@ -0,0 +1,105 @@
+import { Router } from 'express';
+
+/**
+ * Create providers routes
+ */
+export function createProvidersRoutes(providerService, options = {}) {
+  const router = Router();
+  const { asyncHandler = (fn) => fn } = options;
+
+  // GET /providers - List all providers
+  router.get('/', asyncHandler(async (req, res) => {
+    const data = await providerService.getAllProviders();
+    res.json(data);
+  }));
+
+  // GET /providers/active - Get active provider
+  router.get('/active', asyncHandler(async (req, res) => {
+    const provider = await providerService.getActiveProvider();
+    res.json(provider);
+  }));
+
+  // PUT /providers/active - Set active provider
+  router.put('/active', asyncHandler(async (req, res) => {
+    const { id } = req.body;
+    if (!id) {
+      return res.status(400).json({ error: 'Provider ID required' });
+    }
+
+    const provider = await providerService.setActiveProvider(id);
+
+    if (!provider) {
+      return res.status(404).json({ error: 'Provider not found' });
+    }
+
+    res.json(provider);
+  }));
+
+  // GET /providers/:id - Get provider by ID
+  router.get('/:id', asyncHandler(async (req, res) => {
+    const provider = await providerService.getProviderById(req.params.id);
+
+    if (!provider) {
+      return res.status(404).json({ error: 'Provider not found' });
+    }
+
+    res.json(provider);
+  }));
+
+  // POST /providers - Create new provider
+  router.post('/', asyncHandler(async (req, res) => {
+    const { name, type } = req.body;
+
+    if (!name) {
+      return res.status(400).json({ error: 'Name is required' });
+    }
+
+    if (!type || !['cli', 'api'].includes(type)) {
+      return res.status(400).json({ error: 'Type must be "cli" or "api"' });
+    }
+
+    const provider = await providerService.createProvider(req.body);
+    res.status(201).json(provider);
+  }));
+
+  // PUT /providers/:id - Update provider
+  router.put('/:id', asyncHandler(async (req, res) => {
+    const provider = await providerService.updateProvider(req.params.id, req.body);
+
+    if (!provider) {
+      return res.status(404).json({ error: 'Provider not found' });
+    }
+
+    res.json(provider);
+  }));
+
+  // DELETE /providers/:id - Delete provider
+  router.delete('/:id', asyncHandler(async (req, res) => {
+    const deleted = await providerService.deleteProvider(req.params.id);
+
+    if (!deleted) {
+      return res.status(404).json({ error: 'Provider not found' });
+    }
+
+    res.status(204).send();
+  }));
+
+  // POST /providers/:id/test - Test provider connectivity
+  router.post('/:id/test', asyncHandler(async (req, res) => {
+    const result = await providerService.testProvider(req.params.id);
+    res.json(result);
+  }));
+
+  // POST /providers/:id/refresh-models - Refresh models for API provider
+  router.post('/:id/refresh-models', asyncHandler(async (req, res) => {
+    const provider = await providerService.refreshProviderModels(req.params.id);
+
+    if (!provider) {
+      return res.status(404).json({ error: 'Provider not found or not an API type' });
+    }
+
+    res.json(provider);
+  }));
+
+  return router;
+}

package/src/server/routes/runs.js

@@ -0,0 +1,157 @@
+import { Router } from 'express';
+
+/**
+ * Create runs routes
+ */
+export function createRunsRoutes(runnerService, options = {}) {
+  const router = Router();
+  const { asyncHandler = (fn) => fn, io = null } = options;
+
+  // GET /runs - List runs
+  router.get('/', asyncHandler(async (req, res) => {
+    const limit = parseInt(req.query.limit) || 50;
+    const offset = parseInt(req.query.offset) || 0;
+    const source = req.query.source || 'all';
+
+    const result = await runnerService.listRuns(limit, offset, source);
+    res.json(result);
+  }));
+
+  // POST /runs - Create and execute a new run
+  router.post('/', asyncHandler(async (req, res) => {
+    const { providerId, model, prompt, workspacePath, workspaceName, timeout, screenshots } = req.body;
+    console.log(`🚀 POST /runs - provider: ${providerId}, model: ${model}, workspace: ${workspaceName}`);
+
+    if (!providerId) {
+      return res.status(400).json({ error: 'providerId is required' });
+    }
+
+    if (!prompt) {
+      return res.status(400).json({ error: 'prompt is required' });
+    }
+
+    const runData = await runnerService.createRun({
+      providerId,
+      model,
+      prompt,
+      workspacePath,
+      workspaceName,
+      timeout,
+      screenshots
+    });
+
+    const { runId, provider, metadata, timeout: effectiveTimeout } = runData;
+    console.log(`🚀 Run created: ${runId}, provider type: ${provider.type}`);
+
+    // Execute based on provider type
+    if (provider.type === 'cli') {
+      runnerService.executeCliRun(
+        runId,
+        provider,
+        prompt,
+        workspacePath,
+        (data) => {
+          io?.emit(`run:${runId}:data`, data);
+        },
+        (finalMetadata) => {
+          console.log(`✅ Run complete: ${runId}, success: ${finalMetadata.success}`);
+          io?.emit(`run:${runId}:complete`, finalMetadata);
+        },
+        effectiveTimeout
+      );
+    } else if (provider.type === 'api') {
+      runnerService.executeApiRun(
+        runId,
+        provider,
+        model,
+        prompt,
+        workspacePath,
+        screenshots,
+        (data) => {
+          io?.emit(`run:${runId}:data`, data);
+        },
+        (finalMetadata) => {
+          io?.emit(`run:${runId}:complete`, finalMetadata);
+        }
+      );
+    }
+
+    // Return immediately with run ID
+    res.status(202).json({
+      runId,
+      status: 'started',
+      metadata
+    });
+  }));
+
+  // GET /runs/:id - Get run metadata
+  router.get('/:id', asyncHandler(async (req, res) => {
+    const metadata = await runnerService.getRun(req.params.id);
+
+    if (!metadata) {
+      return res.status(404).json({ error: 'Run not found' });
+    }
+
+    const isActive = await runnerService.isRunActive(req.params.id);
+    res.json({
+      ...metadata,
+      isActive
+    });
+  }));
+
+  // GET /runs/:id/output - Get run output
+  router.get('/:id/output', asyncHandler(async (req, res) => {
+    const output = await runnerService.getRunOutput(req.params.id);
+
+    if (output === null) {
+      return res.status(404).json({ error: 'Run not found' });
+    }
+
+    res.type('text/plain').send(output);
+  }));
+
+  // GET /runs/:id/prompt - Get run prompt
+  router.get('/:id/prompt', asyncHandler(async (req, res) => {
+    const prompt = await runnerService.getRunPrompt(req.params.id);
+
+    if (prompt === null) {
+      return res.status(404).json({ error: 'Run not found' });
+    }
+
+    res.type('text/plain').send(prompt);
+  }));
+
+  // POST /runs/:id/stop - Stop a running execution
+  router.post('/:id/stop', asyncHandler(async (req, res) => {
+    const stopped = await runnerService.stopRun(req.params.id);
+
+    if (!stopped) {
+      return res.status(404).json({ error: 'Run not found or not active' });
+    }
+
+    res.json({ success: true });
+  }));
+
+  // DELETE /runs/:id - Delete a run
+  router.delete('/:id', asyncHandler(async (req, res) => {
+    const deleted = await runnerService.deleteRun(req.params.id);
+
+    if (!deleted) {
+      return res.status(404).json({ error: 'Run not found' });
+    }
+
+    res.status(204).send();
+  }));
+
+  // DELETE /runs/failed - Delete all failed runs
+  router.delete('/', asyncHandler(async (req, res) => {
+    if (req.query.filter !== 'failed') {
+      return res.status(400).json({ error: 'Only filter=failed is supported for bulk delete' });
+    }
+
+    const deletedCount = await runnerService.deleteFailedRuns();
+    res.json({ deletedCount });
+  }));
+
+  return router;
+}