@assistkick/create 1.10.0 → 1.12.0

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

@@ -0,0 +1,204 @@
+/**
+ * Preview server routes — REST API for managing dev preview servers
+ * and reverse proxy middleware for forwarding requests to dev servers.
+ *
+ * API routes:
+ *   POST   /api/preview/start          — start a preview server
+ *   POST   /api/preview/stop            — stop a preview server
+ *   GET    /api/preview/list            — list running preview servers
+ *   POST   /api/preview/toggle-access   — toggle public/private access
+ *
+ * Proxy route:
+ *   /apps/<app-name>/*  — reverse proxy to the dev server
+ */
+
+import { Router } from 'express';
+import type { Request, Response } from 'express';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+import type { PreviewServerManager } from '../services/preview_server_manager.js';
+import type { AuthMiddleware } from '../middleware/auth_middleware.js';
+import type { ProjectWorkspaceService } from '../services/project_workspace_service.js';
+
+interface PreviewRoutesDeps {
+  previewManager: PreviewServerManager;
+  workspaceService: ProjectWorkspaceService;
+  projectService: { getById: (id: string) => Promise<{ previewCommand: string | null } | null> };
+  log: (tag: string, ...args: unknown[]) => void;
+}
+
+export const createPreviewApiRoutes = ({ previewManager, workspaceService, projectService, log }: PreviewRoutesDeps): Router => {
+  const router: Router = Router();
+
+  // POST /api/preview/start
+  router.post('/start', async (req: Request, res: Response) => {
+    const { appName, projectDir, projectId, command } = req.body;
+
+    if (!appName || typeof appName !== 'string') {
+      res.status(400).json({ error: 'appName is required' });
+      return;
+    }
+
+    // Resolve projectDir from projectId if not provided directly
+    const resolvedDir = projectDir || (projectId ? workspaceService.getWorkspacePath(projectId) : null);
+    if (!resolvedDir || typeof resolvedDir !== 'string') {
+      res.status(400).json({ error: 'projectDir or projectId is required' });
+      return;
+    }
+
+    // Validate appName: only alphanumeric, hyphens, underscores
+    if (!/^[a-zA-Z0-9_-]+$/.test(appName)) {
+      res.status(400).json({ error: 'appName must contain only alphanumeric characters, hyphens, and underscores' });
+      return;
+    }
+
+    // Resolve command: explicit > project previewCommand > auto-detect (in manager)
+    let resolvedCommand = command?.trim() || undefined;
+    if (!resolvedCommand && projectId) {
+      const project = await projectService.getById(projectId);
+      if (project?.previewCommand) {
+        resolvedCommand = project.previewCommand;
+      }
+    }
+
+    try {
+      const app = await previewManager.start(appName.trim(), resolvedDir.trim(), resolvedCommand);
+      log('PREVIEW', `Started preview app "${app.appName}" on port ${app.port}`);
+      res.status(201).json({ app });
+    } catch (err: any) {
+      log('PREVIEW', `Failed to start preview: ${err.message}`);
+      res.status(409).json({ error: err.message });
+    }
+  });
+
+  // POST /api/preview/stop
+  router.post('/stop', async (req: Request, res: Response) => {
+    const { appName } = req.body;
+
+    if (!appName || typeof appName !== 'string') {
+      res.status(400).json({ error: 'appName is required' });
+      return;
+    }
+
+    const stopped = previewManager.stop(appName.trim());
+    if (!stopped) {
+      res.status(404).json({ error: `Preview app "${appName}" not found` });
+      return;
+    }
+
+    res.json({ ok: true });
+  });
+
+  // GET /api/preview/list
+  router.get('/list', async (_req: Request, res: Response) => {
+    const apps = previewManager.list();
+    res.json({ apps });
+  });
+
+  // POST /api/preview/toggle-access
+  router.post('/toggle-access', async (req: Request, res: Response) => {
+    const { appName, isPublic } = req.body;
+
+    if (!appName || typeof appName !== 'string') {
+      res.status(400).json({ error: 'appName is required' });
+      return;
+    }
+    if (typeof isPublic !== 'boolean') {
+      res.status(400).json({ error: 'isPublic (boolean) is required' });
+      return;
+    }
+
+    const toggled = previewManager.toggleAccess(appName.trim(), isPublic);
+    if (!toggled) {
+      res.status(404).json({ error: `Preview app "${appName}" not found` });
+      return;
+    }
+
+    res.json({ ok: true, isPublic });
+  });
+
+  return router;
+};
+
+interface PreviewProxyDeps {
+  previewManager: PreviewServerManager;
+  authMiddleware: AuthMiddleware;
+  log: (tag: string, ...args: unknown[]) => void;
+}
+
+/**
+ * Creates the /apps/:appName proxy middleware.
+ * - Checks if the app exists and is running
+ * - Enforces auth for private apps
+ * - Resets idle timer on each request
+ * - Proxies HTTP and WebSocket to the dev server
+ */
+export const createPreviewProxyMiddleware = ({ previewManager, authMiddleware, log }: PreviewProxyDeps): Router => {
+  const router: Router = Router();
+
+  // Dynamic proxy — resolves the target per-request based on the app name
+  const proxy = createProxyMiddleware({
+    router: (req) => {
+      const appName = (req as any).previewAppName as string;
+      const app = previewManager.get(appName);
+      if (!app) {
+        return 'http://127.0.0.1:1'; // Will fail, caught by error handler
+      }
+      return `http://127.0.0.1:${app.port}`;
+    },
+    pathRewrite: (path, req) => {
+      const appName = (req as any).previewAppName as string;
+      // Strip /apps/<appName> prefix from the path
+      const prefix = `/apps/${appName}`;
+      return path.startsWith(prefix) ? path.slice(prefix.length) || '/' : path;
+    },
+    changeOrigin: true,
+    ws: true,
+    on: {
+      error: (err, req, res) => {
+        log('PREVIEW', `Proxy error: ${err.message}`);
+        if ('writeHead' in res && typeof res.writeHead === 'function') {
+          (res as any).writeHead(502);
+          (res as any).end('Preview server unavailable');
+        }
+      },
+    },
+  });
+
+  // Middleware to extract app name, check access, reset idle timer
+  router.use('/apps/:appName', async (req: Request, res: Response, next) => {
+    const appName = req.params.appName as string;
+    const app = previewManager.get(appName);
+
+    if (!app) {
+      res.status(404).json({ error: `Preview app "${appName}" not found or not running` });
+      return;
+    }
+
+    // Enforce auth for private apps
+    if (!app.isPublic) {
+      // Use auth middleware inline — if it sends 401, we stop here
+      await new Promise<void>((resolve) => {
+        authMiddleware.requireAuth(req, res, (() => {
+          resolve();
+        }) as any);
+      });
+      // If response was already sent (401), don't proceed
+      if (res.headersSent) {
+        return;
+      }
+    }
+
+    // Reset idle timer on access
+    previewManager.resetIdleTimer(appName);
+
+    // Attach app name for the proxy router function
+    (req as any).previewAppName = appName;
+
+    next();
+  });
+
+  // Mount the proxy after the access-check middleware
+  router.use('/apps/:appName', proxy as any);
+
+  return router;
+};

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

@@ -0,0 +1,205 @@
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { createProjectRoutes } from './projects.ts';
+import express from 'express';
+import type { Server } from 'node:http';
+
+const createMockProjectService = () => ({
+  listActive: mock.fn(async () => []),
+  create: mock.fn(async (name: string, type: string) => ({
+    id: 'proj_test1234',
+    name,
+    type,
+    isDefault: 0,
+    archivedAt: null,
+    repoUrl: null,
+    githubInstallationId: null,
+    githubRepoFullName: null,
+    baseBranch: null,
+    gitAuthMethod: null,
+    sshPrivateKeyEncrypted: null,
+    sshPublicKey: null,
+    previewCommand: null,
+    createdAt: '2026-03-11T00:00:00.000Z',
+    updatedAt: '2026-03-11T00:00:00.000Z',
+  })),
+  rename: mock.fn(),
+  updatePreviewCommand: mock.fn(async (id: string, cmd: string | null) => ({
+    id,
+    name: 'Test',
+    type: 'software',
+    isDefault: 0,
+    archivedAt: null,
+    previewCommand: cmd,
+    createdAt: '2026-03-11T00:00:00.000Z',
+    updatedAt: '2026-03-17T00:00:00.000Z',
+  })),
+  archive: mock.fn(),
+  restore: mock.fn(),
+});
+
+const createMockWorkspaceService = (gitAvailable = true) => ({
+  verifyGitAvailable: mock.fn(async () => {
+    if (!gitAvailable) {
+      throw new Error('Git is required to create a project. Please install git and try again.');
+    }
+  }),
+  initWorkspace: mock.fn(async () => '/tmp/workspaces/proj_test1234'),
+});
+
+const createTestApp = (projectService: any, workspaceService: any) => {
+  const log = mock.fn();
+  const app = express();
+  app.use(express.json());
+  const routes = createProjectRoutes({ projectService, workspaceService, log });
+  app.use('/api/projects', routes);
+  return { app, log };
+};
+
+const request = (server: Server) => {
+  const addr = server.address() as { port: number };
+  const base = `http://127.0.0.1:${addr.port}`;
+  return {
+    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() };
+    },
+    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('Project Routes — POST /api/projects', () => {
+  let server: Server;
+
+  afterEach(() => {
+    if (server) server.close();
+  });
+
+  it('creates a project with git init when git is available', async () => {
+    const projectService = createMockProjectService();
+    const workspaceService = createMockWorkspaceService(true);
+    const { app } = createTestApp(projectService, workspaceService);
+    server = app.listen(0);
+    const req = request(server);
+
+    const res = await req.post('/api/projects', { name: 'My Project' });
+
+    assert.equal(res.status, 201);
+    assert.equal(res.body.project.name, 'My Project');
+    assert.equal(res.body.project.id, 'proj_test1234');
+
+    // Verify git was checked and workspace was initialized
+    assert.equal(workspaceService.verifyGitAvailable.mock.calls.length, 1);
+    assert.equal(workspaceService.initWorkspace.mock.calls.length, 1);
+    assert.equal(workspaceService.initWorkspace.mock.calls[0].arguments[0], 'proj_test1234');
+  });
+
+  it('returns 400 when git is not available', async () => {
+    const projectService = createMockProjectService();
+    const workspaceService = createMockWorkspaceService(false);
+    const { app } = createTestApp(projectService, workspaceService);
+    server = app.listen(0);
+    const req = request(server);
+
+    const res = await req.post('/api/projects', { name: 'My Project' });
+
+    assert.equal(res.status, 400);
+    assert.equal(res.body.error, 'Git is required to create a project. Please install git and try again.');
+
+    // Project should NOT have been created
+    assert.equal(projectService.create.mock.calls.length, 0);
+    assert.equal(workspaceService.initWorkspace.mock.calls.length, 0);
+  });
+
+  it('returns 400 when project name is missing', async () => {
+    const projectService = createMockProjectService();
+    const workspaceService = createMockWorkspaceService(true);
+    const { app } = createTestApp(projectService, workspaceService);
+    server = app.listen(0);
+    const req = request(server);
+
+    const res = await req.post('/api/projects', {});
+
+    assert.equal(res.status, 400);
+    assert.equal(res.body.error, 'Project name is required');
+
+    // Neither git check nor creation should have been called
+    assert.equal(workspaceService.verifyGitAvailable.mock.calls.length, 0);
+    assert.equal(projectService.create.mock.calls.length, 0);
+  });
+
+  it('passes project type through to service', async () => {
+    const projectService = createMockProjectService();
+    const workspaceService = createMockWorkspaceService(true);
+    const { app } = createTestApp(projectService, workspaceService);
+    server = app.listen(0);
+    const req = request(server);
+
+    await req.post('/api/projects', { name: 'Video Proj', type: 'video' });
+
+    assert.equal(projectService.create.mock.calls[0].arguments[0], 'Video Proj');
+    assert.equal(projectService.create.mock.calls[0].arguments[1], 'video');
+  });
+});
+
+describe('Project Routes — PATCH /api/projects/:id', () => {
+  let server: Server;
+
+  afterEach(() => {
+    if (server) server.close();
+  });
+
+  it('updates preview command via PATCH', async () => {
+    const projectService = createMockProjectService();
+    const workspaceService = createMockWorkspaceService(true);
+    const { app } = createTestApp(projectService, workspaceService);
+    server = app.listen(0);
+    const req = request(server);
+
+    const res = await req.patch('/api/projects/proj_test1234', { previewCommand: 'npm run dev' });
+
+    assert.equal(res.status, 200);
+    assert.equal(res.body.project.previewCommand, 'npm run dev');
+    assert.equal(projectService.updatePreviewCommand.mock.calls.length, 1);
+    assert.equal(projectService.updatePreviewCommand.mock.calls[0].arguments[0], 'proj_test1234');
+    assert.equal(projectService.updatePreviewCommand.mock.calls[0].arguments[1], 'npm run dev');
+  });
+
+  it('clears preview command when empty string is sent', async () => {
+    const projectService = createMockProjectService();
+    const workspaceService = createMockWorkspaceService(true);
+    const { app } = createTestApp(projectService, workspaceService);
+    server = app.listen(0);
+    const req = request(server);
+
+    const res = await req.patch('/api/projects/proj_test1234', { previewCommand: '' });
+
+    assert.equal(res.status, 200);
+    assert.equal(projectService.updatePreviewCommand.mock.calls.length, 1);
+    assert.equal(projectService.updatePreviewCommand.mock.calls[0].arguments[1], null);
+  });
+
+  it('returns 400 when neither name nor previewCommand provided', async () => {
+    const projectService = createMockProjectService();
+    const workspaceService = createMockWorkspaceService(true);
+    const { app } = createTestApp(projectService, workspaceService);
+    server = app.listen(0);
+    const req = request(server);
+
+    const res = await req.patch('/api/projects/proj_test1234', {});
+
+    assert.equal(res.status, 400);
+    assert.equal(res.body.error, 'At least one of name or previewCommand is required');
+  });
+});

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

@@ -9,13 +9,15 @@
 
 import { Router } from 'express';
 import type { ProjectService } from '../services/project_service.js';
+import type { ProjectWorkspaceService } from '../services/project_workspace_service.js';
 
 interface ProjectRoutesDeps {
   projectService: ProjectService;
+  workspaceService: ProjectWorkspaceService;
   log: (tag: string, ...args: any[]) => void;
 }
 
-export const createProjectRoutes = ({ projectService, log }: ProjectRoutesDeps): Router => {
+export const createProjectRoutes = ({ projectService, workspaceService, log }: ProjectRoutesDeps): Router => {
   const router: Router = Router();
 
   // GET /api/projects — list active projects
@@ -44,8 +46,21 @@ export const createProjectRoutes = ({ projectService, log }: ProjectRoutesDeps):
     const validTypes = ['software', 'video'];
     const projectType = type && validTypes.includes(type) ? type : 'software';
 
+    try {
+      // Verify git is available before creating the project
+      await workspaceService.verifyGitAvailable();
+    } catch (err: any) {
+      log('PROJECTS', `Git verification failed: ${err.message}`);
+      res.status(400).json({ error: err.message });
+      return;
+    }
+
     try {
       const project = await projectService.create(name.trim(), projectType);
+
+      // Auto-initialize local git repo with an empty commit
+      await workspaceService.initWorkspace(project.id);
+
       res.status(201).json({ project });
     } catch (err: any) {
       log('PROJECTS', `Create project failed: ${err.message}`);
@@ -53,27 +68,40 @@ export const createProjectRoutes = ({ projectService, log }: ProjectRoutesDeps):
     }
   });
 
-  // PATCH /api/projects/:id — rename a project
+  // PATCH /api/projects/:id — update a project (name and/or previewCommand)
   router.patch('/:id', async (req, res) => {
     const { id } = req.params;
-    const { name } = req.body;
-    log('PROJECTS', `PATCH /api/projects/${id} name="${name}"`);
+    const { name, previewCommand } = req.body;
+    log('PROJECTS', `PATCH /api/projects/${id} name="${name}" previewCommand="${previewCommand}"`);
 
-    if (!name || typeof name !== 'string' || !name.trim()) {
-      res.status(400).json({ error: 'Project name is required' });
+    // At least one field must be provided
+    const hasName = name && typeof name === 'string' && name.trim();
+    const hasPreviewCommand = previewCommand !== undefined;
+
+    if (!hasName && !hasPreviewCommand) {
+      res.status(400).json({ error: 'At least one of name or previewCommand is required' });
       return;
     }
 
     try {
-      const project = await projectService.rename(id, name.trim());
+      let project;
+      if (hasName) {
+        project = await projectService.rename(id, name.trim());
+      }
+      if (hasPreviewCommand) {
+        const cmd = typeof previewCommand === 'string' && previewCommand.trim()
+          ? previewCommand.trim()
+          : null;
+        project = await projectService.updatePreviewCommand(id, cmd);
+      }
       res.json({ project });
     } catch (err: any) {
-      log('PROJECTS', `Rename project failed: ${err.message}`);
+      log('PROJECTS', `Update project failed: ${err.message}`);
       if (err.message === 'Project not found') {
         res.status(404).json({ error: err.message });
         return;
       }
-      res.status(500).json({ error: 'Failed to rename project' });
+      res.status(500).json({ error: 'Failed to update project' });
     }
   });
 

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

@@ -0,0 +1,139 @@
+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 { createSkillRoutes, parseSkillMd } from './skills.ts';
+import express from 'express';
+import type { Server } from 'node:http';
+
+/** Create a test app with skill routes mounted at /api/projects/:id/skills */
+const createTestApp = (workspacePath: string) => {
+  const workspaceService = {
+    getWorkspacePath: (_projectId: string) => workspacePath,
+  } as any;
+  const log = mock.fn();
+  const app = express();
+  app.use(express.json());
+  const skillRoutes = createSkillRoutes({ workspaceService, log });
+  app.use('/api/projects/:id/skills', skillRoutes);
+  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() };
+    },
+  };
+};
+
+describe('Skills Routes', () => {
+  let tmpDir: string;
+  let server: Server;
+  let http: ReturnType<typeof request>;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'skills-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 / — list skills', () => {
+    it('returns empty skills when .claude/skills does not exist', async () => {
+      const { status, body } = await http.get('/api/projects/proj_1/skills');
+      assert.equal(status, 200);
+      assert.deepEqual(body.skills, []);
+    });
+
+    it('returns skill folders with parsed SKILL.md metadata', async () => {
+      const skillsDir = join(tmpDir, '.claude', 'skills', 'my-skill');
+      await mkdir(skillsDir, { recursive: true });
+      await writeFile(join(skillsDir, 'SKILL.md'), '# My Awesome Skill\nDoes amazing things.\n\n## Usage\n...');
+
+      const { status, body } = await http.get('/api/projects/proj_1/skills');
+      assert.equal(status, 200);
+      assert.equal(body.skills.length, 1);
+      assert.equal(body.skills[0].folderName, 'my-skill');
+      assert.equal(body.skills[0].name, 'My Awesome Skill');
+      assert.equal(body.skills[0].description, 'Does amazing things.');
+    });
+
+    it('uses folder name as fallback when SKILL.md is missing', async () => {
+      const skillsDir = join(tmpDir, '.claude', 'skills', 'bare-skill');
+      await mkdir(skillsDir, { recursive: true });
+
+      const { status, body } = await http.get('/api/projects/proj_1/skills');
+      assert.equal(status, 200);
+      assert.equal(body.skills.length, 1);
+      assert.equal(body.skills[0].folderName, 'bare-skill');
+      assert.equal(body.skills[0].name, 'bare-skill');
+      assert.equal(body.skills[0].description, '');
+    });
+
+    it('lists multiple skills sorted by discovery order', async () => {
+      const baseDir = join(tmpDir, '.claude', 'skills');
+      await mkdir(join(baseDir, 'alpha-skill'), { recursive: true });
+      await mkdir(join(baseDir, 'beta-skill'), { recursive: true });
+      await writeFile(join(baseDir, 'alpha-skill', 'SKILL.md'), '# Alpha\nFirst skill.');
+      await writeFile(join(baseDir, 'beta-skill', 'SKILL.md'), '# Beta\nSecond skill.');
+
+      const { status, body } = await http.get('/api/projects/proj_1/skills');
+      assert.equal(status, 200);
+      assert.equal(body.skills.length, 2);
+      const names = body.skills.map((s: any) => s.folderName);
+      assert.ok(names.includes('alpha-skill'));
+      assert.ok(names.includes('beta-skill'));
+    });
+
+    it('ignores non-directory entries in skills folder', async () => {
+      const baseDir = join(tmpDir, '.claude', 'skills');
+      await mkdir(baseDir, { recursive: true });
+      await writeFile(join(baseDir, 'not-a-skill.txt'), 'just a file');
+      await mkdir(join(baseDir, 'real-skill'));
+
+      const { status, body } = await http.get('/api/projects/proj_1/skills');
+      assert.equal(status, 200);
+      assert.equal(body.skills.length, 1);
+      assert.equal(body.skills[0].folderName, 'real-skill');
+    });
+  });
+});
+
+describe('parseSkillMd', () => {
+  it('parses name and description from markdown', () => {
+    const result = parseSkillMd('# My Skill\nThis is the description.\n\n## Details\nMore info.');
+    assert.equal(result.name, 'My Skill');
+    assert.equal(result.description, 'This is the description.');
+  });
+
+  it('returns empty strings for empty content', () => {
+    const result = parseSkillMd('');
+    assert.equal(result.name, '');
+    assert.equal(result.description, '');
+  });
+
+  it('handles content with only a heading', () => {
+    const result = parseSkillMd('# Just A Heading');
+    assert.equal(result.name, 'Just A Heading');
+    assert.equal(result.description, '');
+  });
+
+  it('skips sub-headings when looking for description', () => {
+    const result = parseSkillMd('# Name\n## Sub Heading\nActual description here.');
+    assert.equal(result.name, 'Name');
+    assert.equal(result.description, 'Actual description here.');
+  });
+});