@assistkick/create 1.6.0 → 1.8.0

package/templates/assistkick-product-system/packages/backend/src/routes/pipeline.ts

@@ -1,88 +1,204 @@
 /**
- * Pipeline API routes — start/status/unblock dev pipeline + orchestrator.
+ * Workflow execution routes — start/resume/status for workflow executions + orchestrator.
+ * Replaces the old pipeline routes with WorkflowEngine-based endpoints.
  */
 
 import { Router } from 'express';
-import { log, pipeline, orchestrator } from '../services/init.js';
-
-const router: Router = Router();
-
-// POST /api/kanban/:id/develop
-router.post('/:id/develop', async (req, res) => {
-  const featureId = req.params.id;
-  try {
-    const result = await pipeline.start(featureId);
-    res.status(result.status).json(result.error ? { error: result.error } : { started: result.started, feature_id: result.feature_id });
-  } catch (err: any) {
-    log('DEVELOP', `UNEXPECTED ERROR: ${err.message}`);
-    res.status(500).json({ error: err.message });
-  }
-});
-
-// GET /api/kanban/:id/pipeline
-router.get('/:id/pipeline', async (req, res) => {
-  const featureId = req.params.id;
-  const result = await pipeline.getStatus(featureId);
-  res.json(result);
-});
-
-// POST /api/kanban/:id/resume
-router.post('/:id/resume', async (req, res) => {
-  const featureId = req.params.id;
-  try {
-    const result = await pipeline.resume(featureId);
-    res.status(result.status).json(result.error ? { error: result.error } : { resumed: result.resumed, feature_id: result.feature_id });
-  } catch (err: any) {
-    log('RESUME', `UNEXPECTED ERROR: ${err.message}`);
-    res.status(500).json({ error: err.message });
-  }
-});
-
-// POST /api/kanban/:id/unblock
-router.post('/:id/unblock', async (req, res) => {
-  const featureId = req.params.id;
-  try {
-    const result = await pipeline.unblock(featureId);
-    res.status(result.status).json(result.error ? { error: result.error } : { unblocked: result.unblocked, feature_id: result.feature_id });
-  } catch (err: any) {
-    log('UNBLOCK', `ERROR: ${err.message}`);
-    res.status(500).json({ error: err.message });
-  }
-});
-
-// --- Orchestrator (Play All) endpoints ---
-
-// POST /api/pipeline/play-all
-router.post('/play-all', async (req, res) => {
-  const projectId = req.query.project_id as string | undefined;
-  try {
-    const result = orchestrator.startPlayAll(projectId);
-    const resolved = await result;
-    res.status(resolved.status).json(
-      resolved.error ? { error: resolved.error } : { started: resolved.started }
-    );
-  } catch (err: any) {
-    log('ORCHESTRATOR', `UNEXPECTED ERROR: ${err.message}`);
-    res.status(500).json({ error: err.message });
-  }
-});
-
-// POST /api/pipeline/stop-all
-router.post('/stop-all', (_req, res) => {
-  try {
-    const result = orchestrator.stopPlayAll();
-    res.status(result.status).json(
-      result.error ? { error: result.error } : { stopped: result.stopped }
-    );
-  } catch (err: any) {
-    log('ORCHESTRATOR', `UNEXPECTED ERROR: ${err.message}`);
-    res.status(500).json({ error: err.message });
-  }
-});
-
-// GET /api/pipeline/orchestrator-status
-router.get('/orchestrator-status', (_req, res) => {
-  res.json(orchestrator.getStatus());
-});
-
-export default router;
+import type { WorkflowEngine } from '@assistkick/shared/lib/workflow_engine.js';
+import type { WorkflowOrchestrator } from '@assistkick/shared/lib/workflow_orchestrator.js';
+import type { WorkflowService } from '../services/workflow_service.js';
+
+interface WorkflowExecutionRoutesDeps {
+  workflowEngine: WorkflowEngine;
+  orchestrator: WorkflowOrchestrator;
+  workflowService: WorkflowService;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export const createWorkflowExecutionRoutes = ({
+  workflowEngine,
+  orchestrator,
+  workflowService,
+  log,
+}: WorkflowExecutionRoutesDeps): Router => {
+  const router: Router = Router();
+
+  // POST /api/kanban/:id/workflow — start a workflow execution for a feature
+  router.post('/:id/workflow', async (req, res) => {
+    const featureId = req.params.id;
+    const { workflowId, projectId } = req.body || {};
+    log('WORKFLOW', `POST /api/kanban/${featureId}/workflow workflowId=${workflowId || 'default'}`);
+
+    if (!projectId) {
+      res.status(400).json({ error: 'projectId is required' });
+      return;
+    }
+
+    try {
+      // Resolve workflow ID: use provided workflowId, or find the default
+      let resolvedWorkflowId = workflowId;
+      if (!resolvedWorkflowId) {
+        const defaultWorkflow = await workflowService.resolveDefault(projectId);
+        if (!defaultWorkflow) {
+          res.status(400).json({ error: 'No default workflow found. Please specify a workflowId or set a default workflow.' });
+          return;
+        }
+        resolvedWorkflowId = defaultWorkflow.id;
+      }
+
+      const result = await workflowEngine.start(featureId, resolvedWorkflowId, projectId);
+      res.json({ started: true, feature_id: featureId, executionId: result.executionId });
+    } catch (err: any) {
+      log('WORKFLOW', `START ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/kanban/:id/workflow-status — get workflow execution state for a feature
+  router.get('/:id/workflow-status', async (req, res) => {
+    const featureId = req.params.id;
+    try {
+      const status = await workflowEngine.getStatus(featureId);
+      res.json(status);
+    } catch (err: any) {
+      log('WORKFLOW', `STATUS ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/kanban/:id/workflow/resume — resume a failed/interrupted workflow
+  router.post('/:id/workflow/resume', async (req, res) => {
+    const featureId = req.params.id;
+    log('WORKFLOW', `POST /api/kanban/${featureId}/workflow/resume`);
+
+    try {
+      // Find the most recent resumable execution for this feature
+      const executionId = await workflowEngine.findResumableExecution(featureId);
+      if (!executionId) {
+        res.status(404).json({ error: `No resumable workflow execution found for feature ${featureId}` });
+        return;
+      }
+
+      await workflowEngine.resume(executionId);
+      res.json({ resumed: true, feature_id: featureId, executionId });
+    } catch (err: any) {
+      log('WORKFLOW', `RESUME ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/kanban/:id/workflow/force-next — skip current node and advance to next
+  router.post('/:id/workflow/force-next', async (req, res) => {
+    const featureId = req.params.id;
+    const { nodeId } = req.body || {};
+    log('WORKFLOW', `POST /api/kanban/${featureId}/workflow/force-next nodeId=${nodeId}`);
+
+    if (!nodeId) {
+      res.status(400).json({ error: 'nodeId is required' });
+      return;
+    }
+
+    try {
+      await workflowEngine.forceNextNode(featureId, nodeId);
+      res.json({ success: true, feature_id: featureId, skippedNodeId: nodeId });
+    } catch (err: any) {
+      log('WORKFLOW', `FORCE-NEXT ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/kanban/:id/workflow/restart-node — restart the current node
+  router.post('/:id/workflow/restart-node', async (req, res) => {
+    const featureId = req.params.id;
+    const { nodeId } = req.body || {};
+    log('WORKFLOW', `POST /api/kanban/${featureId}/workflow/restart-node nodeId=${nodeId}`);
+
+    if (!nodeId) {
+      res.status(400).json({ error: 'nodeId is required' });
+      return;
+    }
+
+    try {
+      await workflowEngine.restartNode(featureId, nodeId);
+      res.json({ success: true, feature_id: featureId, restartedNodeId: nodeId });
+    } catch (err: any) {
+      log('WORKFLOW', `RESTART-NODE ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/kanban/:id/workflow-monitor — get full execution monitor data for a feature
+  router.get('/:id/workflow-monitor', async (req, res) => {
+    const featureId = req.params.id;
+    try {
+      const data = await workflowEngine.getMonitorData(featureId);
+      if (!data) {
+        res.json({ monitor: null });
+        return;
+      }
+      res.json({ monitor: data });
+    } catch (err: any) {
+      log('WORKFLOW', `MONITOR ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/kanban/:id/workflow-metrics — get per-agent KPI metrics for a feature's latest execution
+  router.get('/:id/workflow-metrics', async (req, res) => {
+    const featureId = req.params.id;
+    try {
+      const status = await workflowEngine.getStatus(featureId);
+      const executionId = status.executionId as string | undefined;
+      if (!executionId) {
+        res.json({ metrics: [] });
+        return;
+      }
+      const metrics = await workflowEngine.getExecutionMetrics(executionId);
+      res.json({ metrics });
+    } catch (err: any) {
+      log('WORKFLOW', `METRICS ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // --- Orchestrator (Play All) endpoints ---
+
+  // POST /api/pipeline/play-all
+  router.post('/play-all', async (req, res) => {
+    const projectId = req.query.project_id as string | undefined;
+    const epicId = req.query.epic_id as string | undefined;
+    if (!projectId) {
+      res.status(400).json({ error: 'project_id query parameter is required' });
+      return;
+    }
+    try {
+      const result = await orchestrator.startPlayAll(projectId, epicId);
+      res.status(result.status).json(
+        result.error ? { error: result.error } : { started: result.started },
+      );
+    } catch (err: any) {
+      log('ORCHESTRATOR', `UNEXPECTED ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/pipeline/stop-all
+  router.post('/stop-all', (_req, res) => {
+    try {
+      const result = orchestrator.stopPlayAll();
+      res.status(result.status).json(
+        result.error ? { error: result.error } : { stopped: result.stopped },
+      );
+    } catch (err: any) {
+      log('ORCHESTRATOR', `UNEXPECTED ERROR: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/pipeline/orchestrator-status
+  router.get('/orchestrator-status', (_req, res) => {
+    res.json(orchestrator.getStatus());
+  });
+
+  return router;
+};

package/templates/assistkick-product-system/packages/backend/src/routes/projects.ts

@@ -33,16 +33,19 @@ export const createProjectRoutes = ({ projectService, log }: ProjectRoutesDeps):
 
   // POST /api/projects — create a new project
   router.post('/', async (req, res) => {
-    const { name } = req.body;
-    log('PROJECTS', `POST /api/projects name="${name}"`);
+    const { name, type } = req.body;
+    log('PROJECTS', `POST /api/projects name="${name}" type="${type || 'software'}"`);
 
     if (!name || typeof name !== 'string' || !name.trim()) {
       res.status(400).json({ error: 'Project name is required' });
       return;
     }
 
+    const validTypes = ['software', 'video'];
+    const projectType = type && validTypes.includes(type) ? type : 'software';
+
     try {
-      const project = await projectService.create(name.trim());
+      const project = await projectService.create(name.trim(), projectType);
       res.status(201).json({ project });
     } catch (err: any) {
       log('PROJECTS', `Create project failed: ${err.message}`);

package/templates/assistkick-product-system/packages/backend/src/routes/terminal.ts

@@ -8,7 +8,12 @@
  */
 
 import { Router } from 'express';
+import express from 'express';
 import type { Request, Response } from 'express';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, extname } from 'node:path';
+import { randomBytes } from 'node:crypto';
 import type { PtySessionManager } from '../services/pty_session_manager.js';
 
 interface TerminalRoutesDeps {
@@ -31,13 +36,13 @@ export const createTerminalRoutes = ({ ptyManager, log }: TerminalRoutesDeps): R
   router.use(requireAdmin as any);
 
   // GET /api/terminal/sessions
-  router.get('/sessions', (_req, res) => {
-    const sessions = ptyManager.listSessions();
+  router.get('/sessions', async (_req, res) => {
+    const sessions = await ptyManager.listSessions();
     res.json({ sessions });
   });
 
   // POST /api/terminal/sessions
-  router.post('/sessions', (req, res) => {
+  router.post('/sessions', async (req, res) => {
     const { projectId, projectName } = req.body;
 
     if (!projectId || typeof projectId !== 'string') {
@@ -49,31 +54,62 @@ export const createTerminalRoutes = ({ ptyManager, log }: TerminalRoutesDeps): R
       return;
     }
 
-    const session = ptyManager.createSession(projectId.trim(), projectName.trim(), 80, 24);
+    const session = await ptyManager.createSession(projectId.trim(), projectName.trim(), 80, 24);
     log('TERMINAL', `Created session "${session.name}" for project ${projectId}`);
-    res.status(201).json({
-      session: {
-        id: session.id,
-        name: session.name,
-        projectId: session.projectId,
-        projectName: session.projectName,
-        state: session.state,
-        createdAt: session.createdAt.toISOString(),
-      },
-    });
+    res.status(201).json({ session });
   });
 
+  // POST /api/terminal/upload-image — accept a dropped image, save to temp, return path
+  const UPLOAD_DIR = join(tmpdir(), 'assistkick-terminal-uploads');
+  const ALLOWED_IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp']);
+
+  router.post(
+    '/upload-image',
+    express.raw({ limit: '10mb', type: 'application/octet-stream' }) as any,
+    async (req: Request, res: Response) => {
+      const filename = req.query.filename as string | undefined;
+      if (!filename) {
+        res.status(400).json({ error: 'filename query parameter is required' });
+        return;
+      }
+
+      const ext = extname(filename).toLowerCase();
+      if (!ALLOWED_IMAGE_EXTS.has(ext)) {
+        res.status(400).json({ error: `Unsupported image type: ${ext}` });
+        return;
+      }
+
+      const body = req.body as Buffer;
+      if (!body || body.length === 0) {
+        res.status(400).json({ error: 'Empty file body' });
+        return;
+      }
+
+      try {
+        await mkdir(UPLOAD_DIR, { recursive: true });
+        const uniqueName = `${Date.now()}-${randomBytes(4).toString('hex')}${ext}`;
+        const filePath = join(UPLOAD_DIR, uniqueName);
+        await writeFile(filePath, body);
+        log('TERMINAL', `Uploaded image: ${filePath} (${body.length} bytes)`);
+        res.json({ path: filePath });
+      } catch (err: any) {
+        log('TERMINAL', `Image upload failed: ${err.message}`);
+        res.status(500).json({ error: 'Failed to save image' });
+      }
+    },
+  );
+
   // DELETE /api/terminal/sessions/:id
-  router.delete('/sessions/:id', (req, res) => {
+  router.delete('/sessions/:id', async (req, res) => {
     const { id } = req.params;
-    const session = ptyManager.getSession(id);
+    const session = await ptyManager.getSession(id);
 
     if (!session) {
       res.status(404).json({ error: 'Session not found' });
       return;
     }
 
-    ptyManager.destroySession(id);
+    await ptyManager.destroySession(id);
     log('TERMINAL', `Killed session ${id}`);
     res.json({ ok: true });
   });

package/templates/assistkick-product-system/packages/backend/src/routes/video.ts

@@ -0,0 +1,218 @@
+/**
+ * Video routes — TTS audio generation, bundle management, composition listing, and rendering.
+ *
+ * POST /api/video/generate-tts     — generate TTS audio from a video script
+ * GET  /api/video/compositions      — list available Remotion compositions
+ * GET  /api/video/bundle/status     — get bundle build status
+ * POST /api/video/bundle/rebuild    — trigger a bundle rebuild
+ * GET  /api/video/renders           — list all renders for a project
+ * POST /api/video/render            — start a video render
+ * GET  /api/video/render/:id        — get render status
+ * DELETE /api/video/render/:id      — delete a render and its file
+ * GET  /api/video/file/:renderId    — serve rendered MP4 file
+ */
+
+import { Router } from 'express';
+import express from 'express';
+import { existsSync } from 'node:fs';
+import type { TtsService } from '../services/tts_service.js';
+import type { BundleService } from '../services/bundle_service.js';
+import type { VideoRenderService } from '../services/video_render_service.js';
+
+interface VideoRoutesDeps {
+  ttsService: TtsService;
+  bundleService: BundleService;
+  videoRenderService: VideoRenderService;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export const createVideoRoutes = ({ ttsService, bundleService, videoRenderService, log }: VideoRoutesDeps): Router => {
+  const router: Router = Router();
+
+  // POST /api/video/generate-tts
+  router.post('/generate-tts', async (req, res) => {
+    const { scriptPath, projectId, featureId, force, voiceId } = req.body;
+    log('VIDEO', `POST /api/video/generate-tts project=${projectId} feature=${featureId}`);
+
+    if (!scriptPath || typeof scriptPath !== 'string') {
+      res.status(400).json({ error: 'scriptPath is required' });
+      return;
+    }
+
+    if (!projectId || typeof projectId !== 'string') {
+      res.status(400).json({ error: 'projectId is required' });
+      return;
+    }
+
+    if (!featureId || typeof featureId !== 'string') {
+      res.status(400).json({ error: 'featureId is required' });
+      return;
+    }
+
+    if (!process.env.ELEVENLABS_API_KEY) {
+      res.status(500).json({ error: 'ELEVENLABS_API_KEY is not configured on the server.' });
+      return;
+    }
+
+    try {
+      const result = await ttsService.generate({
+        scriptPath,
+        projectId,
+        featureId,
+        force: force === true,
+        voiceId: typeof voiceId === 'string' ? voiceId : undefined,
+      });
+
+      res.json(result);
+    } catch (err: any) {
+      log('VIDEO', `TTS generation failed: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/video/compositions — list available Remotion compositions with metadata
+  router.get('/compositions', (_req, res) => {
+    log('VIDEO', 'GET /api/video/compositions');
+    try {
+      const compositions = bundleService.listCompositions();
+      res.json({ compositions });
+    } catch (err: any) {
+      log('VIDEO', `Failed to list compositions: ${err.message}`);
+      res.status(500).json({ error: 'Failed to list compositions' });
+    }
+  });
+
+  // GET /api/video/bundle/status — get current bundle status
+  router.get('/bundle/status', (_req, res) => {
+    log('VIDEO', 'GET /api/video/bundle/status');
+    res.json(bundleService.getStatus());
+  });
+
+  // POST /api/video/bundle/rebuild — trigger a bundle rebuild
+  router.post('/bundle/rebuild', async (_req, res) => {
+    log('VIDEO', 'POST /api/video/bundle/rebuild');
+    try {
+      const status = await bundleService.buildBundle();
+      res.json(status);
+    } catch (err: any) {
+      log('VIDEO', `Bundle rebuild failed: ${err.message}`);
+      res.status(500).json({ error: 'Bundle rebuild failed' });
+    }
+  });
+
+  // GET /api/video/renders — list all renders for a project
+  router.get('/renders', async (req, res) => {
+    const projectId = req.query.projectId as string | undefined;
+    log('VIDEO', `GET /api/video/renders project=${projectId}`);
+
+    if (!projectId || typeof projectId !== 'string') {
+      res.status(400).json({ error: 'projectId query parameter is required' });
+      return;
+    }
+
+    try {
+      const renders = await videoRenderService.listRenders(projectId);
+      res.json({ renders });
+    } catch (err: any) {
+      log('VIDEO', `Failed to list renders: ${err.message}`);
+      res.status(500).json({ error: 'Failed to list renders' });
+    }
+  });
+
+  // POST /api/video/render — start a video render
+  router.post('/render', async (req, res) => {
+    const { compositionId, projectId, featureId, resolution, aspectRatio, fileOutputPrefix } = req.body;
+    log('VIDEO', `POST /api/video/render composition=${compositionId} project=${projectId} feature=${featureId}`);
+
+    if (!compositionId || typeof compositionId !== 'string') {
+      res.status(400).json({ error: 'compositionId is required' });
+      return;
+    }
+
+    if (!projectId || typeof projectId !== 'string') {
+      res.status(400).json({ error: 'projectId is required' });
+      return;
+    }
+
+    if (!featureId || typeof featureId !== 'string') {
+      res.status(400).json({ error: 'featureId is required' });
+      return;
+    }
+
+    try {
+      const status = await videoRenderService.startRender({
+        compositionId,
+        projectId,
+        featureId,
+        resolution: typeof resolution === 'string' ? resolution : undefined,
+        aspectRatio: typeof aspectRatio === 'string' ? aspectRatio : undefined,
+        fileOutputPrefix: typeof fileOutputPrefix === 'string' ? fileOutputPrefix : undefined,
+      });
+
+      res.json(status);
+    } catch (err: any) {
+      log('VIDEO', `Render start failed: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/video/render/:id — get render status
+  router.get('/render/:id', async (req, res) => {
+    const { id } = req.params;
+    log('VIDEO', `GET /api/video/render/${id}`);
+
+    try {
+      const status = await videoRenderService.getStatus(id);
+      if (!status) {
+        res.status(404).json({ error: 'Render not found' });
+        return;
+      }
+      res.json(status);
+    } catch (err: any) {
+      log('VIDEO', `Failed to get render status: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // DELETE /api/video/render/:id — delete a render and its MP4 file
+  router.delete('/render/:id', async (req, res) => {
+    const { id } = req.params;
+    log('VIDEO', `DELETE /api/video/render/${id}`);
+
+    try {
+      const deleted = await videoRenderService.deleteRender(id);
+      if (!deleted) {
+        res.status(404).json({ error: 'Render not found' });
+        return;
+      }
+      res.json({ ok: true });
+    } catch (err: any) {
+      log('VIDEO', `Failed to delete render: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/video/file/:renderId — serve the rendered MP4 file
+  router.get('/file/:renderId', async (req, res) => {
+    const { renderId } = req.params;
+    log('VIDEO', `GET /api/video/file/${renderId}`);
+
+    try {
+      const filePath = await videoRenderService.getFilePath(renderId);
+      if (!filePath || !existsSync(filePath)) {
+        res.status(404).json({ error: 'Rendered file not found' });
+        return;
+      }
+      res.sendFile(filePath);
+    } catch (err: any) {
+      log('VIDEO', `Failed to serve render file: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Serve the built bundle as static files at /api/video/bundle/
+  const bundleDir = bundleService.getBundleDir();
+  router.use('/bundle', express.static(bundleDir, { maxAge: '1h' }));
+
+  return router;
+};