@assistkick/create 1.6.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistkick/create",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Scaffold assistkick-product-system into any project",
   "type": "module",
   "bin": {
@@ -14,7 +14,7 @@
     "build": "tsc",
     "prepare_templates": "bash scripts/prepare_templates.sh",
     "prepublishOnly": "bash scripts/prepare_templates.sh && pnpm build",
-    "publish": "npm publish",
+    "npm-publish": "npm publish",
     "test": "tsx --test tests/**/*.test.ts"
   },
   "devDependencies": {

package/templates/assistkick-product-system/.env.example

@@ -6,3 +6,4 @@ NODE_ENV=development
 RESEND_API_KEY=your-resend-api-key
 APP_BASE_URL=http://localhost:3000
 EMAIL_FROM=noreply@yourdomain.com
+WORKSPACES_DIR=./worktrees

package/templates/assistkick-product-system/package.json

@@ -7,12 +7,14 @@
   "scripts": {
     "dev": "concurrently -n backend,frontend -c blue,green \"pnpm --filter @assistkick/backend dev\" \"pnpm --filter @assistkick/frontend dev\"",
     "build": "pnpm -r build",
-    "start": "tsx packages/backend/src/server.ts",
+    "start": "concurrently -n backend,frontend -c blue,green \"pnpm --filter @assistkick/backend start\" \"pnpm --filter @assistkick/frontend dev\"",
     "test": "tsx --test tests/**/*.test.ts",
     "clean": "pnpm -r clean",
     "db:migrate": "pnpm --filter @assistkick/shared db:migrate",
     "db:rollback": "pnpm --filter @assistkick/shared db:rollback",
-    "db:generate": "pnpm --filter @assistkick/shared db:generate"
+    "db:generate": "pnpm --filter @assistkick/shared db:generate",
+    "remotion:studio": "pnpm --filter @assistkick/video studio",
+    "remotion:render": "pnpm --filter @assistkick/video render"
   },
   "pnpm": {
     "onlyBuiltDependencies": ["esbuild", "node-pty"]

package/templates/assistkick-product-system/packages/backend/package.json

@@ -12,6 +12,7 @@
   },
   "dependencies": {
     "@assistkick/shared": "workspace:*",
+    "@remotion/renderer": "^4.0.434",
     "bcryptjs": "^3.0.3",
     "cookie-parser": "^1.4.7",
     "cors": "^2.8.5",
@@ -21,6 +22,7 @@
     "gray-matter": "^4.0.3",
     "jose": "^6.1.3",
     "node-pty": "^1.1.0",
+    "remotion": "^4.0.434",
     "resend": "^6.9.3",
     "ws": "^8.19.0"
   },

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

@@ -0,0 +1,165 @@
+/**
+ * Agent routes — CRUD endpoints for agent management.
+ * GET    /api/agents            — list agents (scope=global|project, projectId)
+ * GET    /api/agents/:id        — get single agent
+ * POST   /api/agents            — create agent
+ * PUT    /api/agents/:id        — update agent
+ * DELETE /api/agents/:id        — delete agent (409 if assigned or default)
+ * POST   /api/agents/:id/reset  — reset default agent to original prompt
+ */
+
+import { Router } from 'express';
+import type { AgentService } from '../services/agent_service.js';
+
+interface AgentRoutesDeps {
+  agentService: AgentService;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export const createAgentRoutes = ({ agentService, log }: AgentRoutesDeps): Router => {
+  const router: Router = Router();
+
+  // GET /api/agents?scope=global|project&projectId=...
+  router.get('/', async (req, res) => {
+    const scope = (req.query.scope as string) || 'global';
+    const projectId = req.query.projectId as string | undefined;
+    log('AGENTS', `GET /api/agents scope=${scope} projectId=${projectId || 'none'}`);
+
+    if (scope !== 'global' && scope !== 'project') {
+      res.status(400).json({ error: 'scope must be "global" or "project"' });
+      return;
+    }
+
+    if (scope === 'project' && !projectId) {
+      res.status(400).json({ error: 'projectId is required for project scope' });
+      return;
+    }
+
+    try {
+      const agentList = await agentService.listAgents(scope, projectId);
+      res.json({ agents: agentList });
+    } catch (err: any) {
+      log('AGENTS', `List agents failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to list agents' });
+    }
+  });
+
+  // GET /api/agents/:id
+  router.get('/:id', async (req, res) => {
+    const { id } = req.params;
+    log('AGENTS', `GET /api/agents/${id}`);
+
+    try {
+      const agent = await agentService.getById(id);
+      if (!agent) {
+        res.status(404).json({ error: 'Agent not found' });
+        return;
+      }
+      res.json({ agent });
+    } catch (err: any) {
+      log('AGENTS', `Get agent failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to get agent' });
+    }
+  });
+
+  // POST /api/agents
+  router.post('/', async (req, res) => {
+    const { name, promptTemplate, projectId } = req.body;
+    log('AGENTS', `POST /api/agents name="${name}"`);
+
+    if (!name || typeof name !== 'string' || !name.trim()) {
+      res.status(400).json({ error: 'Agent name is required' });
+      return;
+    }
+
+    if (!promptTemplate || typeof promptTemplate !== 'string') {
+      res.status(400).json({ error: 'promptTemplate is required' });
+      return;
+    }
+
+    try {
+      const agent = await agentService.create({
+        name: name.trim(),
+        promptTemplate,
+        projectId: projectId || null,
+      });
+      res.status(201).json({ agent });
+    } catch (err: any) {
+      log('AGENTS', `Create agent failed: ${err.message}`);
+      res.status(500).json({ error: 'Failed to create agent' });
+    }
+  });
+
+  // PUT /api/agents/:id
+  router.put('/:id', async (req, res) => {
+    const { id } = req.params;
+    const { name, promptTemplate } = req.body;
+    log('AGENTS', `PUT /api/agents/${id}`);
+
+    if (name !== undefined && (typeof name !== 'string' || !name.trim())) {
+      res.status(400).json({ error: 'Agent name must be a non-empty string' });
+      return;
+    }
+
+    try {
+      const agent = await agentService.update(id, {
+        name: name?.trim(),
+        promptTemplate,
+      });
+      res.json({ agent });
+    } catch (err: any) {
+      log('AGENTS', `Update agent failed: ${err.message}`);
+      if (err.message === 'Agent not found') {
+        res.status(404).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: 'Failed to update agent' });
+    }
+  });
+
+  // DELETE /api/agents/:id
+  router.delete('/:id', async (req, res) => {
+    const { id } = req.params;
+    log('AGENTS', `DELETE /api/agents/${id}`);
+
+    try {
+      await agentService.delete(id);
+      res.json({ success: true });
+    } catch (err: any) {
+      log('AGENTS', `Delete agent failed: ${err.message}`);
+      if (err.message === 'Agent not found') {
+        res.status(404).json({ error: err.message });
+        return;
+      }
+      if (err.message === 'Cannot delete a default agent' || err.message === 'Cannot delete an agent that is assigned to a stage') {
+        res.status(409).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: 'Failed to delete agent' });
+    }
+  });
+
+  // POST /api/agents/:id/reset
+  router.post('/:id/reset', async (req, res) => {
+    const { id } = req.params;
+    log('AGENTS', `POST /api/agents/${id}/reset`);
+
+    try {
+      const agent = await agentService.resetToDefault(id);
+      res.json({ agent });
+    } catch (err: any) {
+      log('AGENTS', `Reset agent failed: ${err.message}`);
+      if (err.message === 'Agent not found') {
+        res.status(404).json({ error: err.message });
+        return;
+      }
+      if (err.message === 'Only default agents can be reset') {
+        res.status(400).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: 'Failed to reset agent' });
+    }
+  });
+
+  return router;
+};

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

@@ -0,0 +1,358 @@
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { existsSync } from 'node:fs';
+import { createFileRoutes } from './files.ts';
+import express from 'express';
+import type { Server } from 'node:http';
+
+/** Create a test app with file routes mounted at /api/projects/:id/files */
+const createTestApp = (workspacePath: string) => {
+  const workspaceService = {
+    getWorkspacePath: (_projectId: string) => workspacePath,
+  } as any;
+  const log = mock.fn();
+  const app = express();
+  app.use(express.json());
+  const fileRoutes = createFileRoutes({ workspaceService, log });
+  app.use('/api/projects/:id/files', fileRoutes);
+  return { app, log };
+};
+
+/** Simple HTTP request helper using built-in fetch against an Express server */
+const request = (server: Server) => {
+  const addr = server.address() as { port: number };
+  const base = `http://127.0.0.1:${addr.port}`;
+  return {
+    get: async (path: string) => {
+      const res = await fetch(`${base}${path}`);
+      return { status: res.status, body: await res.json() };
+    },
+    post: async (path: string, body: any) => {
+      const res = await fetch(`${base}${path}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      return { status: res.status, body: await res.json() };
+    },
+    put: async (path: string, body: any) => {
+      const res = await fetch(`${base}${path}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      return { status: res.status, body: await res.json() };
+    },
+    delete: async (path: string) => {
+      const res = await fetch(`${base}${path}`, { method: 'DELETE' });
+      return { status: res.status, body: await res.json() };
+    },
+    patch: async (path: string, body: any) => {
+      const res = await fetch(`${base}${path}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      return { status: res.status, body: await res.json() };
+    },
+  };
+};
+
+describe('File Routes', () => {
+  let tmpDir: string;
+  let server: Server;
+  let http: ReturnType<typeof request>;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'file-routes-test-'));
+    const { app } = createTestApp(tmpDir);
+    server = await new Promise<Server>((resolve) => {
+      const s = app.listen(0, '127.0.0.1', () => resolve(s));
+    });
+    http = request(server);
+  });
+
+  afterEach(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('GET / — directory tree', () => {
+    it('returns empty tree for empty workspace', async () => {
+      const { status, body } = await http.get('/api/projects/proj_1/files');
+      assert.equal(status, 200);
+      assert.deepEqual(body.tree, []);
+    });
+
+    it('returns recursive tree with files and directories', async () => {
+      await mkdir(join(tmpDir, 'src'));
+      await writeFile(join(tmpDir, 'src', 'index.ts'), 'console.log("hello")');
+      await writeFile(join(tmpDir, 'README.md'), '# Hello');
+
+      const { status, body } = await http.get('/api/projects/proj_1/files');
+      assert.equal(status, 200);
+      assert.equal(body.tree.length, 2);
+
+      // Directories come first
+      const srcEntry = body.tree.find((e: any) => e.name === 'src');
+      assert.ok(srcEntry);
+      assert.equal(srcEntry.type, 'directory');
+      assert.equal(srcEntry.children.length, 1);
+      assert.equal(srcEntry.children[0].name, 'index.ts');
+      assert.equal(srcEntry.children[0].type, 'file');
+
+      const readmeEntry = body.tree.find((e: any) => e.name === 'README.md');
+      assert.ok(readmeEntry);
+      assert.equal(readmeEntry.type, 'file');
+    });
+
+    it('skips hidden files and directories', async () => {
+      await mkdir(join(tmpDir, '.git'));
+      await writeFile(join(tmpDir, '.gitignore'), 'node_modules');
+      await writeFile(join(tmpDir, 'visible.ts'), 'export {}');
+
+      const { status, body } = await http.get('/api/projects/proj_1/files');
+      assert.equal(status, 200);
+      assert.equal(body.tree.length, 1);
+      assert.equal(body.tree[0].name, 'visible.ts');
+    });
+  });
+
+  describe('GET /content — read file', () => {
+    it('returns file content and language', async () => {
+      await writeFile(join(tmpDir, 'hello.ts'), 'const x = 1;');
+      const { status, body } = await http.get('/api/projects/proj_1/files/content?path=hello.ts');
+      assert.equal(status, 200);
+      assert.equal(body.content, 'const x = 1;');
+      assert.equal(body.language, 'typescript');
+    });
+
+    it('returns 404 for non-existent file', async () => {
+      const { status, body } = await http.get('/api/projects/proj_1/files/content?path=missing.ts');
+      assert.equal(status, 404);
+      assert.equal(body.error, 'File not found');
+    });
+
+    it('returns 400 for path traversal', async () => {
+      const { status, body } = await http.get('/api/projects/proj_1/files/content?path=../../../etc/passwd');
+      assert.equal(status, 400);
+      assert.equal(body.error, 'Invalid path');
+    });
+
+    it('returns 400 when path is missing', async () => {
+      const { status } = await http.get('/api/projects/proj_1/files/content');
+      assert.equal(status, 400);
+    });
+
+    it('returns binary flag for binary files', async () => {
+      await writeFile(join(tmpDir, 'image.png'), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+      const { status, body } = await http.get('/api/projects/proj_1/files/content?path=image.png');
+      assert.equal(status, 200);
+      assert.equal(body.binary, true);
+      assert.equal(typeof body.size, 'number');
+      assert.equal(body.content, undefined);
+    });
+
+    it('infers language from extension', async () => {
+      await writeFile(join(tmpDir, 'style.css'), 'body {}');
+      const { status, body } = await http.get('/api/projects/proj_1/files/content?path=style.css');
+      assert.equal(status, 200);
+      assert.equal(body.language, 'css');
+    });
+  });
+
+  describe('PUT /content — write file', () => {
+    it('writes content to an existing file', async () => {
+      await writeFile(join(tmpDir, 'test.ts'), 'old content');
+      const { status, body } = await http.put('/api/projects/proj_1/files/content', {
+        path: 'test.ts',
+        content: 'new content',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+
+      // Verify content was written
+      const readRes = await http.get('/api/projects/proj_1/files/content?path=test.ts');
+      assert.equal(readRes.body.content, 'new content');
+    });
+
+    it('returns 404 for non-existent file', async () => {
+      const { status, body } = await http.put('/api/projects/proj_1/files/content', {
+        path: 'nonexistent.ts',
+        content: 'hello',
+      });
+      assert.equal(status, 404);
+      assert.equal(body.error, 'File not found');
+    });
+
+    it('returns 400 for path traversal', async () => {
+      const { status, body } = await http.put('/api/projects/proj_1/files/content', {
+        path: '../evil.ts',
+        content: 'hack',
+      });
+      assert.equal(status, 400);
+      assert.equal(body.error, 'Invalid path');
+    });
+
+    it('returns 400 when path or content is missing', async () => {
+      const { status } = await http.put('/api/projects/proj_1/files/content', { path: 'test.ts' });
+      assert.equal(status, 400);
+    });
+  });
+
+  describe('POST / — create file or folder', () => {
+    it('creates a new file', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/files', {
+        path: 'new_file.ts',
+        type: 'file',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.ok(existsSync(join(tmpDir, 'new_file.ts')));
+    });
+
+    it('creates a new directory', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/files', {
+        path: 'new_dir',
+        type: 'directory',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.ok(existsSync(join(tmpDir, 'new_dir')));
+    });
+
+    it('creates nested file with parent directories', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/files', {
+        path: 'deep/nested/file.ts',
+        type: 'file',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.ok(existsSync(join(tmpDir, 'deep', 'nested', 'file.ts')));
+    });
+
+    it('returns 400 when path already exists', async () => {
+      await writeFile(join(tmpDir, 'existing.ts'), 'content');
+      const { status, body } = await http.post('/api/projects/proj_1/files', {
+        path: 'existing.ts',
+        type: 'file',
+      });
+      assert.equal(status, 400);
+      assert.equal(body.error, 'Path already exists');
+    });
+
+    it('returns 400 for path traversal', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/files', {
+        path: '../evil.ts',
+        type: 'file',
+      });
+      assert.equal(status, 400);
+      assert.equal(body.error, 'Invalid path');
+    });
+
+    it('returns 400 for invalid type', async () => {
+      const { status } = await http.post('/api/projects/proj_1/files', {
+        path: 'test.ts',
+        type: 'symlink',
+      });
+      assert.equal(status, 400);
+    });
+  });
+
+  describe('DELETE / — delete file or folder', () => {
+    it('deletes a file', async () => {
+      await writeFile(join(tmpDir, 'to_delete.ts'), 'bye');
+      const { status, body } = await http.delete('/api/projects/proj_1/files?path=to_delete.ts');
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.ok(!existsSync(join(tmpDir, 'to_delete.ts')));
+    });
+
+    it('deletes a directory recursively', async () => {
+      await mkdir(join(tmpDir, 'dir_to_delete', 'sub'), { recursive: true });
+      await writeFile(join(tmpDir, 'dir_to_delete', 'sub', 'file.ts'), 'nested');
+      const { status, body } = await http.delete('/api/projects/proj_1/files?path=dir_to_delete');
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.ok(!existsSync(join(tmpDir, 'dir_to_delete')));
+    });
+
+    it('returns 404 for non-existent file', async () => {
+      const { status, body } = await http.delete('/api/projects/proj_1/files?path=ghost.ts');
+      assert.equal(status, 404);
+      assert.equal(body.error, 'File not found');
+    });
+
+    it('returns 400 for path traversal', async () => {
+      const { status, body } = await http.delete('/api/projects/proj_1/files?path=../evil');
+      assert.equal(status, 400);
+      assert.equal(body.error, 'Invalid path');
+    });
+
+    it('returns 400 when path is missing', async () => {
+      const { status } = await http.delete('/api/projects/proj_1/files');
+      assert.equal(status, 400);
+    });
+  });
+
+  describe('PATCH / — rename/move', () => {
+    it('renames a file', async () => {
+      await writeFile(join(tmpDir, 'old_name.ts'), 'content');
+      const { status, body } = await http.patch('/api/projects/proj_1/files', {
+        oldPath: 'old_name.ts',
+        newPath: 'new_name.ts',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.ok(!existsSync(join(tmpDir, 'old_name.ts')));
+      assert.ok(existsSync(join(tmpDir, 'new_name.ts')));
+    });
+
+    it('moves a file to a new directory', async () => {
+      await writeFile(join(tmpDir, 'movable.ts'), 'content');
+      const { status, body } = await http.patch('/api/projects/proj_1/files', {
+        oldPath: 'movable.ts',
+        newPath: 'subdir/movable.ts',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.ok(existsSync(join(tmpDir, 'subdir', 'movable.ts')));
+    });
+
+    it('returns 404 when source does not exist', async () => {
+      const { status, body } = await http.patch('/api/projects/proj_1/files', {
+        oldPath: 'nonexistent.ts',
+        newPath: 'target.ts',
+      });
+      assert.equal(status, 404);
+      assert.equal(body.error, 'File not found');
+    });
+
+    it('returns 400 for path traversal in oldPath', async () => {
+      const { status, body } = await http.patch('/api/projects/proj_1/files', {
+        oldPath: '../evil.ts',
+        newPath: 'safe.ts',
+      });
+      assert.equal(status, 400);
+      assert.equal(body.error, 'Invalid path');
+    });
+
+    it('returns 400 for path traversal in newPath', async () => {
+      await writeFile(join(tmpDir, 'safe.ts'), 'content');
+      const { status, body } = await http.patch('/api/projects/proj_1/files', {
+        oldPath: 'safe.ts',
+        newPath: '../evil.ts',
+      });
+      assert.equal(status, 400);
+      assert.equal(body.error, 'Invalid path');
+    });
+
+    it('returns 400 when oldPath or newPath is missing', async () => {
+      const { status } = await http.patch('/api/projects/proj_1/files', { oldPath: 'test.ts' });
+      assert.equal(status, 400);
+    });
+  });
+});