@assistkick/create 1.7.0 → 1.8.0

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

@@ -0,0 +1,119 @@
+/**
+ * Workflow group routes — CRUD endpoints for reusable workflow groups.
+ * GET    /api/workflow-groups           — list groups (optional projectId query param)
+ * GET    /api/workflow-groups/:id       — get single group
+ * POST   /api/workflow-groups           — create group
+ * PUT    /api/workflow-groups/:id       — update group
+ * DELETE /api/workflow-groups/:id       — delete group
+ */
+
+import { Router } from 'express';
+import type { WorkflowGroupService } from '../services/workflow_group_service.js';
+
+interface WorkflowGroupRoutesDeps {
+  workflowGroupService: WorkflowGroupService;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export const createWorkflowGroupRoutes = ({ workflowGroupService, log }: WorkflowGroupRoutesDeps): Router => {
+  const router: Router = Router();
+
+  // GET /api/workflow-groups?projectId=...
+  router.get('/', async (req, res) => {
+    const projectId = req.query.projectId as string | undefined;
+    log('WORKFLOW_GROUPS', `GET /api/workflow-groups projectId=${projectId || 'none'}`);
+
+    try {
+      const groups = await workflowGroupService.list(projectId);
+      res.json({ groups });
+    } catch (err: any) {
+      log('WORKFLOW_GROUPS', `List groups failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to list workflow groups' });
+    }
+  });
+
+  // GET /api/workflow-groups/:id
+  router.get('/:id', async (req, res) => {
+    const { id } = req.params;
+    log('WORKFLOW_GROUPS', `GET /api/workflow-groups/${id}`);
+
+    try {
+      const group = await workflowGroupService.getById(id);
+      if (!group) {
+        res.status(404).json({ error: 'Workflow group not found' });
+        return;
+      }
+      res.json({ group });
+    } catch (err: any) {
+      log('WORKFLOW_GROUPS', `Get group failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to get workflow group' });
+    }
+  });
+
+  // POST /api/workflow-groups
+  router.post('/', async (req, res) => {
+    const { name, projectId, graphData } = req.body;
+    log('WORKFLOW_GROUPS', `POST /api/workflow-groups name="${name}"`);
+
+    if (!name || typeof name !== 'string' || !name.trim()) {
+      res.status(400).json({ error: 'Group name is required' });
+      return;
+    }
+
+    if (!graphData || typeof graphData !== 'string') {
+      res.status(400).json({ error: 'graphData is required (JSON string)' });
+      return;
+    }
+
+    try {
+      const group = await workflowGroupService.create({
+        name: name.trim(),
+        projectId: projectId || null,
+        graphData,
+      });
+      res.status(201).json({ group });
+    } catch (err: any) {
+      log('WORKFLOW_GROUPS', `Create group failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to create workflow group' });
+    }
+  });
+
+  // PUT /api/workflow-groups/:id
+  router.put('/:id', async (req, res) => {
+    const { id } = req.params;
+    const { name, graphData } = req.body;
+    log('WORKFLOW_GROUPS', `PUT /api/workflow-groups/${id}`);
+
+    try {
+      const group = await workflowGroupService.update(id, { name, graphData });
+      res.json({ group });
+    } catch (err: any) {
+      log('WORKFLOW_GROUPS', `Update group failed: ${err.message}`);
+      if (err.message === 'Workflow group not found') {
+        res.status(404).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: 'Failed to update workflow group' });
+    }
+  });
+
+  // DELETE /api/workflow-groups/:id
+  router.delete('/:id', async (req, res) => {
+    const { id } = req.params;
+    log('WORKFLOW_GROUPS', `DELETE /api/workflow-groups/${id}`);
+
+    try {
+      await workflowGroupService.delete(id);
+      res.json({ success: true });
+    } catch (err: any) {
+      log('WORKFLOW_GROUPS', `Delete group failed: ${err.message}`);
+      if (err.message === 'Workflow group not found') {
+        res.status(404).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: 'Failed to delete workflow group' });
+    }
+  });
+
+  return router;
+};

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

@@ -0,0 +1,154 @@
+/**
+ * Workflow routes — CRUD endpoints for workflow management.
+ * GET    /api/workflows              — list workflows (optional projectId query param)
+ * GET    /api/workflows/:id          — get single workflow with graph_data
+ * POST   /api/workflows              — create workflow
+ * PUT    /api/workflows/:id          — update workflow
+ * DELETE /api/workflows/:id          — delete workflow (400 if active executions)
+ * POST   /api/workflows/:id/set-default — mark workflow as default for its scope
+ */
+
+import { Router } from 'express';
+import type { WorkflowService } from '../services/workflow_service.js';
+
+interface WorkflowRoutesDeps {
+  workflowService: WorkflowService;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export const createWorkflowRoutes = ({ workflowService, log }: WorkflowRoutesDeps): Router => {
+  const router: Router = Router();
+
+  // GET /api/workflows?projectId=...
+  router.get('/', async (req, res) => {
+    const projectId = req.query.projectId as string | undefined;
+    log('WORKFLOWS', `GET /api/workflows projectId=${projectId || 'none'}`);
+
+    try {
+      const workflowList = await workflowService.list(projectId);
+      res.json({ workflows: workflowList });
+    } catch (err: any) {
+      log('WORKFLOWS', `List workflows failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to list workflows' });
+    }
+  });
+
+  // GET /api/workflows/:id
+  router.get('/:id', async (req, res) => {
+    const { id } = req.params;
+    log('WORKFLOWS', `GET /api/workflows/${id}`);
+
+    try {
+      const workflow = await workflowService.getById(id);
+      if (!workflow) {
+        res.status(404).json({ error: 'Workflow not found' });
+        return;
+      }
+      res.json({ workflow });
+    } catch (err: any) {
+      log('WORKFLOWS', `Get workflow failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to get workflow' });
+    }
+  });
+
+  // POST /api/workflows
+  router.post('/', async (req, res) => {
+    const { name, description, projectId, featureType, graphData } = req.body;
+    log('WORKFLOWS', `POST /api/workflows name="${name}"`);
+
+    if (!name || typeof name !== 'string' || !name.trim()) {
+      res.status(400).json({ error: 'Workflow name is required' });
+      return;
+    }
+
+    if (!graphData || typeof graphData !== 'string') {
+      res.status(400).json({ error: 'graphData is required (JSON string)' });
+      return;
+    }
+
+    try {
+      const workflow = await workflowService.create({
+        name: name.trim(),
+        description: description || null,
+        projectId: projectId || null,
+        featureType: featureType || null,
+        graphData,
+      });
+      res.status(201).json({ workflow });
+    } catch (err: any) {
+      log('WORKFLOWS', `Create workflow failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to create workflow' });
+    }
+  });
+
+  // PUT /api/workflows/:id
+  router.put('/:id', async (req, res) => {
+    const { id } = req.params;
+    const { name, description, featureType, graphData } = req.body;
+    log('WORKFLOWS', `PUT /api/workflows/${id}`);
+
+    if (name !== undefined && (typeof name !== 'string' || !name.trim())) {
+      res.status(400).json({ error: 'Workflow name must be a non-empty string' });
+      return;
+    }
+
+    try {
+      const workflow = await workflowService.update(id, {
+        name: name?.trim(),
+        description,
+        featureType,
+        graphData,
+      });
+      res.json({ workflow });
+    } catch (err: any) {
+      log('WORKFLOWS', `Update workflow failed: ${err.message}`);
+      if (err.message === 'Workflow not found') {
+        res.status(404).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: 'Failed to update workflow' });
+    }
+  });
+
+  // DELETE /api/workflows/:id
+  router.delete('/:id', async (req, res) => {
+    const { id } = req.params;
+    log('WORKFLOWS', `DELETE /api/workflows/${id}`);
+
+    try {
+      await workflowService.delete(id);
+      res.json({ success: true });
+    } catch (err: any) {
+      log('WORKFLOWS', `Delete workflow failed: ${err.message}`);
+      if (err.message === 'Workflow not found') {
+        res.status(404).json({ error: err.message });
+        return;
+      }
+      if (err.message === 'Cannot delete a workflow with active executions') {
+        res.status(400).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: 'Failed to delete workflow' });
+    }
+  });
+
+  // POST /api/workflows/:id/set-default
+  router.post('/:id/set-default', async (req, res) => {
+    const { id } = req.params;
+    log('WORKFLOWS', `POST /api/workflows/${id}/set-default`);
+
+    try {
+      const workflow = await workflowService.setDefault(id);
+      res.json({ workflow });
+    } catch (err: any) {
+      log('WORKFLOWS', `Set default workflow failed: ${err.message}`);
+      if (err.message === 'Workflow not found') {
+        res.status(404).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: 'Failed to set default workflow' });
+    }
+  });
+
+  return router;
+};

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

@@ -16,7 +16,7 @@ import { fileURLToPath } from 'node:url';
 import { existsSync } from 'node:fs';
 import { WebSocketServer } from 'ws';
 import * as pty from 'node-pty';
-import { initServices, log, githubAppService, workspaceService } from './services/init.js';
+import { initServices, log, githubAppService, sshKeyService, workspaceService, workflowEngine, orchestrator, workflowService as initWorkflowService, workflowGroupService as initWorkflowGroupService } from './services/init.js';
 import { AuthService } from './services/auth_service.js';
 import { EmailService } from './services/email_service.js';
 import { PasswordResetService } from './services/password_reset_service.js';
@@ -33,9 +33,18 @@ import { createTerminalRoutes } from './routes/terminal.js';
 import { getDb } from '@assistkick/shared/lib/db.js';
 import graphRoutes from './routes/graph.js';
 import kanbanRoutes from './routes/kanban.js';
-import pipelineRoutes from './routes/pipeline.js';
+import { createWorkflowExecutionRoutes } from './routes/pipeline.js';
 import coherenceRoutes from './routes/coherence.js';
 import { createGitRoutes } from './routes/git.js';
+import { createFileRoutes } from './routes/files.js';
+import { AgentService } from './services/agent_service.js';
+import { createAgentRoutes } from './routes/agents.js';
+import { createWorkflowRoutes } from './routes/workflows.js';
+import { createWorkflowGroupRoutes } from './routes/workflow_groups.js';
+import { TtsService } from './services/tts_service.js';
+import { BundleService } from './services/bundle_service.js';
+import { VideoRenderService } from './services/video_render_service.js';
+import { createVideoRoutes } from './routes/video.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_PORT = parseInt(process.env.PORT || '3000', 10);
@@ -70,8 +79,8 @@ app.use((req, res, next) => {
   const start = Date.now();
   res.on('finish', () => {
     const duration = Date.now() - start;
-    // Skip noisy pipeline and orchestrator status polls
-    if (req.originalUrl.endsWith('/pipeline') || req.originalUrl.endsWith('/orchestrator-status')) return;
+    // Skip noisy workflow-status and orchestrator status polls
+    if (req.originalUrl.endsWith('/workflow-status') || req.originalUrl.endsWith('/orchestrator-status')) return;
     log('HTTP', `${req.method} ${req.originalUrl} ${res.statusCode} ${duration}ms`);
   });
   next();
@@ -104,28 +113,91 @@ const projectRoutes = createProjectRoutes({ projectService, log });
 app.use('/api/projects', authMiddleware.requireAuth, projectRoutes);
 
 // Git repository routes (nested under /api/projects/:id/git)
-const gitRoutes = createGitRoutes({ projectService, githubAppService, workspaceService, log });
+const gitRoutes = createGitRoutes({ projectService, githubAppService, workspaceService, sshKeyService, log });
 app.use('/api/projects/:id/git', authMiddleware.requireAuth, gitRoutes);
 
+// File system routes (nested under /api/projects/:id/files)
+const fileRoutes = createFileRoutes({ workspaceService, log });
+app.use('/api/projects/:id/files', authMiddleware.requireAuth, fileRoutes);
+
+// Agent management routes (authenticated)
+const SKILLS_DIR = join(__dirname, '..', '..', '..', '..', '.claude', 'skills');
+const agentService = new AgentService({
+  getDb,
+  log,
+  skillPaths: {
+    developer: join(SKILLS_DIR, 'assistkick-developer', 'SKILL.md'),
+    reviewer: join(SKILLS_DIR, 'assistkick-code-reviewer', 'SKILL.md'),
+    debugger: join(SKILLS_DIR, 'assistkick-debugger', 'SKILL.md'),
+    videoScriptWriter: join(SKILLS_DIR, 'video-script-writer', 'SKILL.md'),
+    videoCompositionAgent: join(SKILLS_DIR, 'video-composition-agent', 'SKILL.md'),
+  },
+});
+const agentRoutes = createAgentRoutes({ agentService, log });
+app.use('/api/agents', authMiddleware.requireAuth, agentRoutes);
+
+// Workflow management routes (authenticated)
+const workflowRoutes = createWorkflowRoutes({ workflowService: initWorkflowService, log });
+app.use('/api/workflows', authMiddleware.requireAuth, workflowRoutes);
+
+// Workflow group routes (authenticated)
+const workflowGroupRoutes = createWorkflowGroupRoutes({ workflowGroupService: initWorkflowGroupService, log });
+app.use('/api/workflow-groups', authMiddleware.requireAuth, workflowGroupRoutes);
+
+// Video routes (authenticated) — TTS audio generation, bundle management, compositions
+const VIDEO_PACKAGE_DIR = join(__dirname, '..', '..', 'video');
+const BUNDLE_OUTPUT_DIR = process.env.REMOTION_BUNDLE_DIR || join(__dirname, '..', '..', '..', '..', 'data', 'remotion-bundle');
+const ttsService = new TtsService({
+  workspacesDir: process.env.WORKSPACES_DIR || join(__dirname, '..', '..', '..', '..', 'workspaces'),
+  videoPackageDir: VIDEO_PACKAGE_DIR,
+  log,
+});
+const bundleService = new BundleService({
+  videoPackageDir: VIDEO_PACKAGE_DIR,
+  bundleOutputDir: BUNDLE_OUTPUT_DIR,
+  log,
+});
+const videoRenderService = new VideoRenderService({
+  getDb,
+  workspacesDir: process.env.WORKSPACES_DIR || join(__dirname, '..', '..', '..', '..', 'workspaces'),
+  bundleOutputDir: BUNDLE_OUTPUT_DIR,
+  log,
+});
+const videoRoutes = createVideoRoutes({ ttsService, bundleService, videoRenderService, log });
+app.use('/api/video', authMiddleware.requireAuth, videoRoutes);
+
 // Ensure default project exists and assign orphan nodes on startup
 projectService.ensureDefaultAndAssignOrphans().catch((err: any) => {
   log('STARTUP', `Failed to ensure default project: ${err.message}`);
 });
 
+// Sync default agent prompts with latest SKILL.md + template code
+agentService.syncDefaults().catch((err: any) => {
+  log('STARTUP', `Failed to sync default agents: ${err.message}`);
+});
+
 // PTY session manager — initialized early so terminal REST routes can reference it
 // Resolve project root: from packages/backend/src → assistkick-product-system → repo root
 const PROJECT_ROOT = join(__dirname, '..', '..', '..', '..');
-const ptyManager = new PtySessionManager({ spawn: pty.spawn, log, projectRoot: PROJECT_ROOT });
+const ptyManager = new PtySessionManager({ spawn: pty.spawn, log, projectRoot: PROJECT_ROOT, getDb });
 
 // Terminal session management REST routes (admin-only, auth required)
 const terminalRoutes = createTerminalRoutes({ ptyManager, log });
 app.use('/api/terminal', authMiddleware.requireAuth, terminalRoutes);
 
+// Workflow execution routes (authenticated) — replaces old pipeline routes
+const workflowExecRoutes = createWorkflowExecutionRoutes({
+  workflowEngine,
+  orchestrator,
+  workflowService: initWorkflowService,
+  log,
+});
+
 // Protected API routes — require authentication
 app.use('/api', authMiddleware.requireAuth, graphRoutes);
 app.use('/api/kanban', authMiddleware.requireAuth, kanbanRoutes);
-app.use('/api/kanban', authMiddleware.requireAuth, pipelineRoutes);
-app.use('/api/pipeline', authMiddleware.requireAuth, pipelineRoutes);
+app.use('/api/kanban', authMiddleware.requireAuth, workflowExecRoutes);
+app.use('/api/pipeline', authMiddleware.requireAuth, workflowExecRoutes);
 app.use('/api/coherence', authMiddleware.requireAuth, coherenceRoutes);
 
 // Redirect favicon.ico to SVG favicon served from static files
@@ -154,7 +226,7 @@ server.on('upgrade', (req, socket, head) => {
 
 // Clean up PTY sessions on server shutdown
 process.on('SIGTERM', () => {
-  ptyManager.destroyAll();
+  ptyManager.destroyAllPty();
   server.close();
 });