@assistkick/create 1.6.0 → 1.8.0

package/templates/assistkick-product-system/packages/backend/src/services/video_render_service.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { VideoRenderService } from './video_render_service.js';
+
+describe('VideoRenderService', () => {
+  let logs: string[];
+  let dbRows: Map<string, any>;
+  let deletedIds: string[];
+
+  const makeMockDb = () => {
+    return {
+      select: () => ({
+        from: () => ({
+          where: (condition: any) => {
+            // Return matching rows based on condition
+            const results: any[] = [];
+            for (const row of dbRows.values()) {
+              results.push(row);
+            }
+            // Filter by the mock condition — simple implementation
+            return Promise.resolve(results.filter(r => {
+              // We'll set a flag for what we're querying
+              if ((mockDb as any)._lastQueryId) {
+                return r.id === (mockDb as any)._lastQueryId;
+              }
+              if ((mockDb as any)._lastQueryProjectId) {
+                return r.projectId === (mockDb as any)._lastQueryProjectId;
+              }
+              return true;
+            }));
+          },
+          orderBy: () => {
+            const results = Array.from(dbRows.values());
+            // Sort by createdAt desc
+            results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+            return Promise.resolve(results);
+          },
+        }),
+      }),
+      insert: () => ({
+        values: (row: any) => {
+          dbRows.set(row.id, row);
+          return Promise.resolve();
+        },
+      }),
+      update: () => ({
+        set: (fields: any) => ({
+          where: (condition: any) => {
+            // Update matching rows
+            for (const [id, row] of dbRows.entries()) {
+              Object.assign(row, fields);
+            }
+            return Promise.resolve();
+          },
+        }),
+      }),
+      delete: () => ({
+        where: (condition: any) => {
+          // Delete the row matching _lastQueryId
+          const id = (mockDb as any)._lastDeleteId;
+          if (id) {
+            dbRows.delete(id);
+            deletedIds.push(id);
+          }
+          return Promise.resolve();
+        },
+      }),
+    };
+  };
+
+  let mockDb: any;
+
+  const makeService = () => {
+    logs = [];
+    dbRows = new Map();
+    deletedIds = [];
+    mockDb = null;
+
+    // We need a more precise mock. Let's use a simpler approach:
+    // Directly test the data transformation logic.
+    return new VideoRenderService({
+      getDb: () => mockDb,
+      workspacesDir: '/data/workspaces',
+      bundleOutputDir: '/data/bundle',
+      log: (tag: string, ...args: any[]) => { logs.push(`[${tag}] ${args.join(' ')}`); },
+    });
+  };
+
+  describe('listRenders', () => {
+    it('returns renders sorted by createdAt desc', async () => {
+      const svc = makeService();
+
+      const rows = [
+        {
+          id: 'r1', projectId: 'proj1', featureId: 'f1', compositionId: 'comp1',
+          status: 'complete', progress: 100, filePath: '/data/r1.mp4', fileSize: 1024,
+          durationSeconds: 10.5, error: null, resolution: '1920x1080',
+          createdAt: '2026-03-10T10:00:00Z', completedAt: '2026-03-10T10:05:00Z',
+        },
+        {
+          id: 'r2', projectId: 'proj1', featureId: 'f1', compositionId: 'comp2',
+          status: 'rendering', progress: 45, filePath: null, fileSize: null,
+          durationSeconds: null, error: null, resolution: '1280x720',
+          createdAt: '2026-03-10T11:00:00Z', completedAt: null,
+        },
+      ];
+
+      // Mock the db to return rows sorted desc
+      mockDb = {
+        select: () => ({
+          from: () => ({
+            where: () => ({
+              orderBy: () => Promise.resolve([rows[1], rows[0]]),  // r2 first (newer)
+            }),
+          }),
+        }),
+      };
+
+      const result = await svc.listRenders('proj1');
+      assert.equal(result.length, 2);
+      assert.equal(result[0].id, 'r2');
+      assert.equal(result[0].status, 'rendering');
+      assert.equal(result[0].progress, 45);
+      assert.equal(result[1].id, 'r1');
+      assert.equal(result[1].status, 'complete');
+      assert.equal(result[1].fileSize, 1024);
+      assert.equal(result[1].durationSeconds, 10.5);
+    });
+
+    it('returns empty array when no renders exist', async () => {
+      const svc = makeService();
+
+      mockDb = {
+        select: () => ({
+          from: () => ({
+            where: () => ({
+              orderBy: () => Promise.resolve([]),
+            }),
+          }),
+        }),
+      };
+
+      const result = await svc.listRenders('proj1');
+      assert.deepEqual(result, []);
+    });
+  });
+
+  describe('deleteRender', () => {
+    it('returns false when render does not exist', async () => {
+      const svc = makeService();
+
+      mockDb = {
+        select: () => ({
+          from: () => ({
+            where: () => Promise.resolve([]),
+          }),
+        }),
+      };
+
+      const result = await svc.deleteRender('nonexistent');
+      assert.equal(result, false);
+    });
+
+    it('deletes db row and logs when file does not exist on disk', async () => {
+      const svc = makeService();
+
+      let deletedFromDb = false;
+      mockDb = {
+        select: () => ({
+          from: () => ({
+            where: () => Promise.resolve([{
+              id: 'r1', filePath: '/nonexistent/path.mp4',
+              projectId: 'proj1', compositionId: 'comp1', status: 'complete',
+            }]),
+          }),
+        }),
+        delete: () => ({
+          where: () => { deletedFromDb = true; return Promise.resolve(); },
+        }),
+      };
+
+      const result = await svc.deleteRender('r1');
+      assert.equal(result, true);
+      assert.equal(deletedFromDb, true);
+      assert.ok(logs.some(l => l.includes('Deleted render record r1')));
+    });
+
+    it('deletes db row when filePath is null', async () => {
+      const svc = makeService();
+
+      let deletedFromDb = false;
+      mockDb = {
+        select: () => ({
+          from: () => ({
+            where: () => Promise.resolve([{
+              id: 'r1', filePath: null,
+              projectId: 'proj1', compositionId: 'comp1', status: 'queued',
+            }]),
+          }),
+        }),
+        delete: () => ({
+          where: () => { deletedFromDb = true; return Promise.resolve(); },
+        }),
+      };
+
+      const result = await svc.deleteRender('r1');
+      assert.equal(result, true);
+      assert.equal(deletedFromDb, true);
+    });
+  });
+
+  describe('getStatus', () => {
+    it('returns null when render does not exist', async () => {
+      const svc = makeService();
+
+      mockDb = {
+        select: () => ({
+          from: () => ({
+            where: () => Promise.resolve([]),
+          }),
+        }),
+      };
+
+      const result = await svc.getStatus('nonexistent');
+      assert.equal(result, null);
+    });
+
+    it('maps db row to RenderStatus correctly', async () => {
+      const svc = makeService();
+
+      mockDb = {
+        select: () => ({
+          from: () => ({
+            where: () => Promise.resolve([{
+              id: 'r1', status: 'complete', progress: 100,
+              filePath: '/data/r1.mp4', fileSize: 2048,
+              durationSeconds: 15.3, error: null,
+              compositionId: 'my-comp', resolution: '1920x1080',
+              createdAt: '2026-03-10T10:00:00Z', completedAt: '2026-03-10T10:05:00Z',
+            }]),
+          }),
+        }),
+      };
+
+      const result = await svc.getStatus('r1');
+      assert.ok(result);
+      assert.equal(result.id, 'r1');
+      assert.equal(result.status, 'complete');
+      assert.equal(result.progress, 100);
+      assert.equal(result.fileSize, 2048);
+      assert.equal(result.durationSeconds, 15.3);
+      assert.equal(result.compositionId, 'my-comp');
+      assert.equal(result.resolution, '1920x1080');
+    });
+  });
+});

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

@@ -0,0 +1,258 @@
+/**
+ * VideoRenderService — triggers Remotion rendering via @remotion/renderer,
+ * tracks render status (queued/rendering/complete/failed) in video_renders table,
+ * and stores output videos on the persistent volume.
+ *
+ * Output path: /data/workspaces/<projectId>/media/<featureId>/outputs/{renderId}.mp4
+ */
+
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { renderMedia, selectComposition } from '@remotion/renderer';
+import { eq, desc, and } from 'drizzle-orm';
+import { videoRenders } from '@assistkick/shared/db/schema.js';
+
+interface VideoRenderServiceDeps {
+  getDb: () => any;
+  workspacesDir: string;
+  bundleOutputDir: string;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export interface RenderRequest {
+  compositionId: string;
+  projectId: string;
+  featureId: string;
+  resolution?: string;
+  aspectRatio?: string;
+  fileOutputPrefix?: string;
+}
+
+export interface RenderStatus {
+  id: string;
+  status: 'queued' | 'rendering' | 'complete' | 'failed';
+  progress: number;
+  filePath: string | null;
+  fileSize: number | null;
+  durationSeconds: number | null;
+  error: string | null;
+  compositionId: string;
+  resolution: string | null;
+  createdAt: string;
+  completedAt: string | null;
+}
+
+export class VideoRenderService {
+  private readonly getDb: VideoRenderServiceDeps['getDb'];
+  private readonly workspacesDir: string;
+  private readonly bundleOutputDir: string;
+  private readonly log: VideoRenderServiceDeps['log'];
+
+  constructor({ getDb, workspacesDir, bundleOutputDir, log }: VideoRenderServiceDeps) {
+    this.getDb = getDb;
+    this.workspacesDir = workspacesDir;
+    this.bundleOutputDir = bundleOutputDir;
+    this.log = log;
+  }
+
+  /** Get the outputs directory for a project/feature. */
+  private getOutputDir = (projectId: string, featureId: string): string => {
+    return join(this.workspacesDir, projectId, 'media', featureId, 'outputs');
+  };
+
+  /** Parse resolution string like "1920x1080" into width/height. */
+  private parseResolution = (resolution?: string): { width: number; height: number } => {
+    if (!resolution) return { width: 1920, height: 1080 };
+    const parts = resolution.split('x');
+    if (parts.length !== 2) return { width: 1920, height: 1080 };
+    const width = parseInt(parts[0], 10);
+    const height = parseInt(parts[1], 10);
+    if (isNaN(width) || isNaN(height)) return { width: 1920, height: 1080 };
+    return { width, height };
+  };
+
+  /**
+   * Start a new render. Creates a queued record and kicks off async rendering.
+   * Returns the render ID immediately.
+   */
+  startRender = async (request: RenderRequest): Promise<RenderStatus> => {
+    const bundlePath = join(this.bundleOutputDir, 'index.html');
+    if (!existsSync(bundlePath)) {
+      throw new Error('Remotion bundle not found. Run a bundle rebuild first.');
+    }
+
+    const id = randomUUID();
+    const now = new Date().toISOString();
+
+    const db = this.getDb();
+    await db.insert(videoRenders).values({
+      id,
+      projectId: request.projectId,
+      featureId: request.featureId,
+      compositionId: request.compositionId,
+      status: 'queued',
+      progress: 0,
+      resolution: request.resolution || '1920x1080',
+      createdAt: now,
+    });
+
+    this.log('RENDER', `Queued render ${id} for composition=${request.compositionId} project=${request.projectId}`);
+
+    // Start rendering asynchronously — don't await
+    this.executeRender(id, request).catch((err) => {
+      this.log('RENDER', `Render ${id} async error: ${err.message}`);
+    });
+
+    return this.getStatus(id) as Promise<RenderStatus>;
+  };
+
+  /** Get the status of a render by ID. */
+  getStatus = async (renderId: string): Promise<RenderStatus | null> => {
+    const db = this.getDb();
+    const rows = await db.select().from(videoRenders).where(eq(videoRenders.id, renderId));
+    if (rows.length === 0) return null;
+
+    const row = rows[0];
+    return {
+      id: row.id,
+      status: row.status as RenderStatus['status'],
+      progress: row.progress,
+      filePath: row.filePath,
+      fileSize: row.fileSize,
+      durationSeconds: row.durationSeconds,
+      error: row.error,
+      compositionId: row.compositionId,
+      resolution: row.resolution,
+      createdAt: row.createdAt,
+      completedAt: row.completedAt,
+    };
+  };
+
+  /** List all renders for a project, sorted by createdAt desc. */
+  listRenders = async (projectId: string): Promise<RenderStatus[]> => {
+    const db = this.getDb();
+    const rows = await db.select()
+      .from(videoRenders)
+      .where(eq(videoRenders.projectId, projectId))
+      .orderBy(desc(videoRenders.createdAt));
+
+    return rows.map((row: any) => ({
+      id: row.id,
+      status: row.status as RenderStatus['status'],
+      progress: row.progress,
+      filePath: row.filePath,
+      fileSize: row.fileSize,
+      durationSeconds: row.durationSeconds,
+      error: row.error,
+      compositionId: row.compositionId,
+      resolution: row.resolution,
+      createdAt: row.createdAt,
+      completedAt: row.completedAt,
+    }));
+  };
+
+  /** Delete a render record and its MP4 file from disk. */
+  deleteRender = async (renderId: string): Promise<boolean> => {
+    const db = this.getDb();
+    const rows = await db.select().from(videoRenders).where(eq(videoRenders.id, renderId));
+    if (rows.length === 0) return false;
+
+    const row = rows[0];
+
+    // Delete the MP4 file from disk if it exists
+    if (row.filePath && existsSync(row.filePath)) {
+      try {
+        unlinkSync(row.filePath);
+        this.log('RENDER', `Deleted file for render ${renderId}: ${row.filePath}`);
+      } catch (err: any) {
+        this.log('RENDER', `Failed to delete file for render ${renderId}: ${err.message}`);
+      }
+    }
+
+    await db.delete(videoRenders).where(eq(videoRenders.id, renderId));
+    this.log('RENDER', `Deleted render record ${renderId}`);
+    return true;
+  };
+
+  /** Get the absolute file path for a completed render's output. */
+  getFilePath = async (renderId: string): Promise<string | null> => {
+    const status = await this.getStatus(renderId);
+    if (!status || status.status !== 'complete' || !status.filePath) return null;
+    return status.filePath;
+  };
+
+  /** Execute the Remotion render for a given render record. */
+  private executeRender = async (renderId: string, request: RenderRequest): Promise<void> => {
+    const db = this.getDb();
+
+    try {
+      // Mark as rendering
+      await db.update(videoRenders)
+        .set({ status: 'rendering' })
+        .where(eq(videoRenders.id, renderId));
+
+      const { width, height } = this.parseResolution(request.resolution);
+      const outputDir = this.getOutputDir(request.projectId, request.featureId);
+      mkdirSync(outputDir, { recursive: true });
+
+      const prefix = request.fileOutputPrefix || renderId;
+      const outputPath = join(outputDir, `${prefix}.mp4`);
+
+      const mediaBasePath = join(this.workspacesDir, request.projectId, 'media', request.featureId);
+
+      this.log('RENDER', `Starting render ${renderId}: ${request.compositionId} → ${outputPath}`);
+
+      const composition = await selectComposition({
+        serveUrl: this.bundleOutputDir,
+        id: request.compositionId,
+        inputProps: { mediaBasePath },
+      });
+
+      await renderMedia({
+        composition: { ...composition, width, height },
+        serveUrl: this.bundleOutputDir,
+        codec: 'h264',
+        outputLocation: outputPath,
+        inputProps: { mediaBasePath },
+        chromiumOptions: {
+          enableMultiProcessOnLinux: true,
+        },
+        onProgress: ({ progress }) => {
+          // Update progress in DB periodically — fire and forget
+          db.update(videoRenders)
+            .set({ progress: Math.round(progress * 100) })
+            .where(eq(videoRenders.id, renderId))
+            .catch(() => { /* ignore progress update failures */ });
+        },
+      });
+
+      // Read output file metadata
+      const stat = statSync(outputPath);
+      const durationSeconds = composition.durationInFrames / composition.fps;
+
+      await db.update(videoRenders)
+        .set({
+          status: 'complete',
+          progress: 100,
+          filePath: outputPath,
+          fileSize: stat.size,
+          durationSeconds,
+          completedAt: new Date().toISOString(),
+        })
+        .where(eq(videoRenders.id, renderId));
+
+      this.log('RENDER', `Render ${renderId} complete: ${outputPath} (${stat.size} bytes)`);
+    } catch (err: any) {
+      this.log('RENDER', `Render ${renderId} failed: ${err.message}`);
+
+      await db.update(videoRenders)
+        .set({
+          status: 'failed',
+          error: err.message,
+          completedAt: new Date().toISOString(),
+        })
+        .where(eq(videoRenders.id, renderId));
+    }
+  };
+}

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

@@ -0,0 +1,106 @@
+/**
+ * WorkflowGroupService — CRUD operations for reusable workflow groups.
+ * Groups are collections of workflow nodes/edges that can be inserted
+ * as a single collapsed node in the workflow canvas.
+ */
+
+import { eq, or, isNull } from 'drizzle-orm';
+import { workflowGroups } from '@assistkick/shared/db/schema.js';
+import { randomUUID } from 'node:crypto';
+
+interface WorkflowGroupServiceDeps {
+  getDb: () => any;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export interface WorkflowGroupRecord {
+  id: string;
+  name: string;
+  projectId: string | null;
+  graphData: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export class WorkflowGroupService {
+  private readonly getDb: () => any;
+  private readonly log: (tag: string, ...args: any[]) => void;
+
+  constructor({ getDb, log }: WorkflowGroupServiceDeps) {
+    this.getDb = getDb;
+    this.log = log;
+  }
+
+  /** List groups visible to the given scope (global + project-specific). */
+  list = async (projectId?: string): Promise<WorkflowGroupRecord[]> => {
+    const db = this.getDb();
+    const condition = projectId
+      ? or(isNull(workflowGroups.projectId), eq(workflowGroups.projectId, projectId))
+      : isNull(workflowGroups.projectId);
+
+    const rows = await db.select().from(workflowGroups).where(condition);
+    this.log('WORKFLOW_GROUPS', `Listed ${rows.length} groups`);
+    return rows;
+  };
+
+  /** Get a single group by ID. */
+  getById = async (id: string): Promise<WorkflowGroupRecord | null> => {
+    const db = this.getDb();
+    const [row] = await db.select().from(workflowGroups).where(eq(workflowGroups.id, id));
+    return row || null;
+  };
+
+  /** Create a new reusable group from selected nodes/edges. */
+  create = async (data: {
+    name: string;
+    projectId?: string | null;
+    graphData: string;
+  }): Promise<WorkflowGroupRecord> => {
+    const db = this.getDb();
+    const now = new Date().toISOString();
+    const id = randomUUID();
+
+    const record: WorkflowGroupRecord = {
+      id,
+      name: data.name,
+      projectId: data.projectId || null,
+      graphData: data.graphData,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    await db.insert(workflowGroups).values(record);
+    this.log('WORKFLOW_GROUPS', `Created group: ${data.name} (${id})`);
+    return record;
+  };
+
+  /** Update a group's name or graph data. */
+  update = async (id: string, data: {
+    name?: string;
+    graphData?: string;
+  }): Promise<WorkflowGroupRecord> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+    if (!existing) throw new Error('Workflow group not found');
+
+    const now = new Date().toISOString();
+    const updates: Record<string, any> = { updatedAt: now };
+
+    if (data.name !== undefined) updates.name = data.name;
+    if (data.graphData !== undefined) updates.graphData = data.graphData;
+
+    await db.update(workflowGroups).set(updates).where(eq(workflowGroups.id, id));
+    this.log('WORKFLOW_GROUPS', `Updated group: ${existing.name} (${id})`);
+    return { ...existing, ...updates };
+  };
+
+  /** Delete a group. */
+  delete = async (id: string): Promise<void> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+    if (!existing) throw new Error('Workflow group not found');
+
+    await db.delete(workflowGroups).where(eq(workflowGroups.id, id));
+    this.log('WORKFLOW_GROUPS', `Deleted group: ${existing.name} (${id})`);
+  };
+}