design-learn-server 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "design-learn-server",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "private": false,
   "description": "Design-Learn server skeleton for REST/WS/MCP routes",
   "main": "src/server.js",

package/src/http/createServer.js

@@ -0,0 +1,89 @@
+const http = require('http');
+const { URL } = require('url');
+
+const { createRouter } = require('./router');
+const { registerRoutes } = require('../routes');
+const { sendJson, sendMethodNotAllowed } = require('./response');
+const { readJsonBody } = require('./request');
+const { handleWebSocketUpgrade } = require('../ws/upgrade');
+
+function isMcpPath(pathname) {
+  return pathname === '/mcp' || pathname.startsWith('/mcp/');
+}
+
+function isWsPath(pathname) {
+  return pathname === '/ws' || pathname.startsWith('/ws/');
+}
+
+function handleWsHttpFallback(req, res) {
+  sendJson(res, 426, { error: 'upgrade_required' });
+}
+
+function createServer(deps) {
+  const router = createRouter();
+  registerRoutes(router, deps);
+
+  async function handleRequest(req, res) {
+    const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+    const pathname = url.pathname;
+
+    console.log(`[http] ${req.method} ${pathname}`);
+
+    if (isMcpPath(pathname)) {
+      if (req.method === 'POST') {
+        const body = await readJsonBody(req, res);
+        if (!body) {
+          return;
+        }
+        await deps.mcpHandler.handleRequest(req, res, body);
+        return;
+      }
+
+      await deps.mcpHandler.handleRequest(req, res);
+      return;
+    }
+
+    if (isWsPath(pathname)) {
+      return handleWsHttpFallback(req, res);
+    }
+
+    const result = await router.handle(req, res, url, deps);
+    if (result?.methodNotAllowed) {
+      return sendMethodNotAllowed(res);
+    }
+    if (result?.handled) {
+      return;
+    }
+
+    return sendJson(res, 404, { error: 'not_found', path: pathname });
+  }
+
+  const server = http.createServer((req, res) => {
+    handleRequest(req, res).catch((error) => {
+      console.error('[http] handler error', error);
+      if (!res.headersSent) {
+        sendJson(res, 500, { error: 'internal_error' });
+      }
+    });
+  });
+
+  server.on('upgrade', (req, socket) => {
+    try {
+      handleWebSocketUpgrade(req, socket);
+    } catch (error) {
+      console.error('[ws] upgrade error', error);
+      socket.destroy();
+    }
+  });
+
+  server.on('clientError', (err, socket) => {
+    console.error('[http] client error', err.message);
+    socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+  });
+
+  return server;
+}
+
+module.exports = {
+  createServer,
+};

package/src/http/request.js

@@ -0,0 +1,68 @@
+function readJsonBody(req, res) {
+  return new Promise((resolve) => {
+    let data = '';
+    req.on('data', (chunk) => {
+      data += chunk;
+    });
+    req.on('end', () => {
+      if (!data) {
+        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: 'empty_body' }));
+        resolve(null);
+        return;
+      }
+      try {
+        resolve(JSON.parse(data));
+      } catch (error) {
+        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: 'invalid_json' }));
+        resolve(null);
+      }
+    });
+  });
+}
+
+function parseOptionalBoolean(value) {
+  if (value === null || value === undefined || value === '') {
+    return undefined;
+  }
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return null;
+}
+
+function parseLimitOffset(url) {
+  const limitRaw = Number(url.searchParams.get('limit'));
+  const offsetRaw = Number(url.searchParams.get('offset'));
+  const limit = Number.isFinite(limitRaw) ? Math.min(Math.max(limitRaw, 1), 100) : 20;
+  const offset = Number.isFinite(offsetRaw) ? Math.max(offsetRaw, 0) : 0;
+  return { limit, offset };
+}
+
+function parseLimitOffsetStrict(url) {
+  const limitRaw = url.searchParams.get('limit');
+  const offsetRaw = url.searchParams.get('offset');
+
+  if (limitRaw !== null && !Number.isFinite(Number(limitRaw))) {
+    return { error: 'invalid_limit' };
+  }
+  if (offsetRaw !== null && !Number.isFinite(Number(offsetRaw))) {
+    return { error: 'invalid_offset' };
+  }
+
+  return parseLimitOffset(url);
+}
+
+function paginate(items, limit, offset) {
+  const total = items.length;
+  const paged = items.slice(offset, offset + limit);
+  return { items: paged, total };
+}
+
+module.exports = {
+  readJsonBody,
+  parseOptionalBoolean,
+  parseLimitOffset,
+  parseLimitOffsetStrict,
+  paginate,
+};

package/src/http/response.js

@@ -0,0 +1,23 @@
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Content-Length': Buffer.byteLength(payload),
+  });
+  res.end(payload);
+}
+
+function sendNoContent(res) {
+  res.writeHead(204);
+  res.end();
+}
+
+function sendMethodNotAllowed(res) {
+  sendJson(res, 405, { error: 'method_not_allowed' });
+}
+
+module.exports = {
+  sendJson,
+  sendNoContent,
+  sendMethodNotAllowed,
+};

package/src/http/router.js

@@ -0,0 +1,99 @@
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function compilePath(path) {
+  if (path === '/') {
+    return { regex: /^\/$/, paramNames: [], score: 0 };
+  }
+
+  const segments = path.split('/').filter(Boolean);
+  const paramNames = [];
+  const pattern = segments
+    .map((segment) => {
+      if (segment.startsWith(':')) {
+        paramNames.push(segment.slice(1));
+        return '([^/]+)';
+      }
+      return escapeRegExp(segment);
+    })
+    .join('/');
+
+  const staticCount = segments.filter((segment) => !segment.startsWith(':')).length;
+  const score = staticCount * 100 + segments.length;
+
+  return {
+    regex: new RegExp(`^/${pattern}$`),
+    paramNames,
+    score,
+  };
+}
+
+function createRouter() {
+  const routes = [];
+
+  function add(method, path, handler) {
+    const compiled = compilePath(path);
+    routes.push({
+      method,
+      path,
+      handler,
+      regex: compiled.regex,
+      paramNames: compiled.paramNames,
+      score: compiled.score,
+      order: routes.length,
+    });
+  }
+
+  async function handle(req, res, url, deps) {
+    const pathname = url.pathname;
+    const matches = [];
+
+    for (const route of routes) {
+      const match = route.regex.exec(pathname);
+      if (!match) {
+        continue;
+      }
+
+      const params = {};
+      route.paramNames.forEach((name, index) => {
+        params[name] = match[index + 1];
+      });
+
+      matches.push({ route, params });
+    }
+
+    if (!matches.length) {
+      return { handled: false };
+    }
+
+    let bestScore = -1;
+    for (const match of matches) {
+      if (match.route.score > bestScore) {
+        bestScore = match.route.score;
+      }
+    }
+
+    const bestMatches = matches.filter((match) => match.route.score === bestScore);
+    const methodCandidates = bestMatches.filter((match) => match.route.method === req.method);
+    const methodMatch = methodCandidates.sort((a, b) => a.route.order - b.route.order)[0];
+
+    if (methodMatch) {
+      await methodMatch.route.handler(req, res, {
+        url,
+        params: methodMatch.params,
+        deps,
+        pathname,
+      });
+      return { handled: true };
+    }
+
+    return { methodNotAllowed: true };
+  }
+
+  return { add, handle };
+}
+
+module.exports = {
+  createRouter,
+};

package/src/playwrightSupport.js

@@ -23,7 +23,15 @@ function installPlaywright(logger) {
     });
     child.stdout?.on('data', (chunk) => logger?.(chunk.toString()));
     child.stderr?.on('data', (chunk) => logger?.(chunk.toString()));
-    child.on('error', reject);
+    child.on('error', (error) => {
+      if (error?.code === 'ENOENT') {
+        const notInstalled = new Error('playwright_not_installed');
+        notInstalled.cause = error;
+        reject(notInstalled);
+        return;
+      }
+      reject(error);
+    });
     child.on('exit', (code) => {
       if (code === 0) resolve();
       else reject(new Error(`npm_install_failed:${code ?? 'unknown'}`));
@@ -43,7 +51,14 @@ async function ensurePlaywrightInstalled(options = {}) {
       installPromise = null;
     });
   }
-  await installPromise;
+  try {
+    await installPromise;
+  } catch (error) {
+    if (error?.message === 'playwright_not_installed') {
+      throw error;
+    }
+    throw new Error('playwright_not_installed');
+  }
 }
 
 async function loadPlaywright(options = {}) {

package/src/routes/config.js

@@ -0,0 +1,89 @@
+const { getConfigPath } = require('../storage/paths');
+const { readJson, writeJson } = require('../storage/fileStore');
+const { readJsonBody } = require('../http/request');
+const { sendJson } = require('../http/response');
+
+const DEFAULT_CONFIG = {
+  model: {
+    name: '',
+    version: '',
+    provider: '',
+  },
+  aiModels: [],
+  selectedModelId: '',
+  templates: {
+    styleguide: '',
+    components: '',
+  },
+  extractOptions: {
+    includeRules: true,
+    includeComponents: true,
+  },
+  updatedAt: null,
+};
+
+async function loadConfig(storage) {
+  const configPath = getConfigPath(storage.dataDir);
+  try {
+    return await readJson(configPath);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return { ...DEFAULT_CONFIG };
+    }
+    throw error;
+  }
+}
+
+function normalizeConfig(input) {
+  const now = new Date().toISOString();
+  const model = input?.model || {};
+  const templates = input?.templates || {};
+  const extractOptions = input?.extractOptions || {};
+  const aiModels = Array.isArray(input?.aiModels) ? input.aiModels : [];
+  const selectedModelId = typeof input?.selectedModelId === 'string' ? input.selectedModelId : '';
+  return {
+    model: {
+      ...DEFAULT_CONFIG.model,
+      ...model,
+    },
+    aiModels,
+    selectedModelId,
+    templates: {
+      ...DEFAULT_CONFIG.templates,
+      ...templates,
+    },
+    extractOptions: {
+      ...DEFAULT_CONFIG.extractOptions,
+      ...extractOptions,
+    },
+    updatedAt: now,
+  };
+}
+
+async function handleConfigGet(res, storage) {
+  const config = await loadConfig(storage);
+  sendJson(res, 200, config);
+}
+
+async function handleConfigPut(req, res, storage) {
+  const body = await readJsonBody(req, res);
+  if (!body) {
+    return;
+  }
+  if (typeof body !== 'object' || Array.isArray(body)) {
+    return sendJson(res, 400, { error: 'invalid_config' });
+  }
+  const config = normalizeConfig(body);
+  await writeJson(getConfigPath(storage.dataDir), config);
+  return sendJson(res, 200, config);
+}
+
+function registerConfigRoutes(router, deps) {
+  const { storage } = deps;
+  router.add('GET', '/api/config', (req, res) => handleConfigGet(res, storage));
+  router.add('PUT', '/api/config', (req, res) => handleConfigPut(req, res, storage));
+}
+
+module.exports = {
+  registerConfigRoutes,
+};

package/src/routes/designs.js

@@ -0,0 +1,66 @@
+const { sendJson, sendNoContent } = require('../http/response');
+const { readJsonBody, parseLimitOffset, paginate } = require('../http/request');
+
+function handleDesignList(res, url, storage) {
+  const { limit, offset } = parseLimitOffset(url);
+  const designs = storage.listDesigns();
+  const { items, total } = paginate(designs, limit, offset);
+  sendJson(res, 200, { items, limit, offset, total });
+}
+
+async function handleDesignCreate(req, res, storage) {
+  const body = await readJsonBody(req, res);
+  if (!body) {
+    return;
+  }
+  const design = await storage.createDesign(body);
+  sendJson(res, 201, design);
+}
+
+async function handleDesignGet(res, storage, designId) {
+  const design = await storage.getDesign(designId);
+  if (!design) {
+    return sendJson(res, 404, { error: 'design_not_found' });
+  }
+  return sendJson(res, 200, design);
+}
+
+async function handleDesignPatch(req, res, storage, designId) {
+  const body = await readJsonBody(req, res);
+  if (!body) {
+    return;
+  }
+  const design = await storage.updateDesign(designId, body);
+  if (!design) {
+    return sendJson(res, 404, { error: 'design_not_found' });
+  }
+  return sendJson(res, 200, design);
+}
+
+async function handleDesignDelete(res, storage, designId) {
+  const design = await storage.getDesign(designId);
+  if (!design) {
+    return sendJson(res, 404, { error: 'design_not_found' });
+  }
+  await storage.deleteDesign(designId);
+  return sendNoContent(res);
+}
+
+function registerDesignRoutes(router, deps) {
+  const { storage } = deps;
+  router.add('GET', '/api/designs', (req, res, ctx) => handleDesignList(res, ctx.url, storage));
+  router.add('POST', '/api/designs', (req, res) => handleDesignCreate(req, res, storage));
+  router.add('GET', '/api/designs/:designId', (req, res, ctx) =>
+    handleDesignGet(res, storage, ctx.params.designId)
+  );
+  router.add('PATCH', '/api/designs/:designId', (req, res, ctx) =>
+    handleDesignPatch(req, res, storage, ctx.params.designId)
+  );
+  router.add('DELETE', '/api/designs/:designId', (req, res, ctx) =>
+    handleDesignDelete(res, storage, ctx.params.designId)
+  );
+}
+
+module.exports = {
+  registerDesignRoutes,
+};

package/src/routes/import.js

@@ -0,0 +1,157 @@
+const { URL } = require('url');
+
+const { sendJson } = require('../http/response');
+const { readJsonBody } = require('../http/request');
+
+function handleImportStream(req, res, extractionPipeline, url) {
+  const jobIdFilter = url.searchParams.get('jobId');
+
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream; charset=utf-8',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+  });
+  res.write(`event: connected\ndata: ${JSON.stringify({ status: 'ok' })}\n\n`);
+
+  const unsubscribe = extractionPipeline.onProgress((event) => {
+    if (jobIdFilter && event.job.id !== jobIdFilter) {
+      return;
+    }
+    res.write(`event: ${event.event}\ndata: ${JSON.stringify(event)}\n\n`);
+  });
+
+  req.on('close', () => {
+    unsubscribe();
+  });
+}
+
+function handleImportJobs(res, extractionPipeline) {
+  sendJson(res, 200, { jobs: extractionPipeline.listJobs() });
+}
+
+function handleImportJob(res, extractionPipeline, jobId) {
+  const job = extractionPipeline.getJob(jobId);
+  if (!job) {
+    return sendJson(res, 404, { error: 'job_not_found' });
+  }
+  return sendJson(res, 200, { job });
+}
+
+async function handleImportBrowser(req, res, extractionPipeline) {
+  const body = await readJsonBody(req, res);
+  if (!body) {
+    return;
+  }
+
+  try {
+    const job = extractionPipeline.enqueueImportFromBrowser(body);
+    sendJson(res, 202, { job });
+  } catch (error) {
+    sendJson(res, 400, { error: error.message });
+  }
+}
+
+async function handleImportUrl(req, res, storage, extractionPipeline, importJobs) {
+  const body = await readJsonBody(req, res);
+  if (!body) {
+    return;
+  }
+
+  try {
+    const rawUrl = body.url || '';
+    if (!rawUrl) {
+      return sendJson(res, 400, { error: 'url_required' });
+    }
+
+    try {
+      new URL(rawUrl);
+    } catch {
+      return sendJson(res, 400, { error: 'invalid_url' });
+    }
+
+    const requestedDesignId = body.designId || null;
+    let requestedDesign = null;
+    if (requestedDesignId) {
+      requestedDesign = await storage.getDesign(requestedDesignId);
+      if (!requestedDesign) {
+        return sendJson(res, 404, { error: 'design_not_found' });
+      }
+    }
+
+    const existing = requestedDesign ? null : storage.listDesigns().find((item) => item.url === rawUrl);
+    const now = new Date().toISOString();
+    const useAI = !!body?.options?.useAI;
+    const hasPromptTemplateId = Object.prototype.hasOwnProperty.call(body?.options || {}, 'promptTemplateId');
+    const promptTemplateIdRaw = body?.options?.promptTemplateId;
+    const promptTemplateId =
+      hasPromptTemplateId && typeof promptTemplateIdRaw === 'string'
+        ? promptTemplateIdRaw.trim() || null
+        : hasPromptTemplateId
+          ? null
+          : undefined;
+
+    let designId = requestedDesign?.id || existing?.id || null;
+    if (!designId) {
+      let name = rawUrl;
+      try {
+        const parsed = new URL(rawUrl);
+        name = parsed.hostname || rawUrl;
+      } catch {}
+
+      const design = await storage.createDesign({
+        name,
+        url: rawUrl,
+        source: 'script',
+        metadata: {
+          extractedFrom: 'playwright',
+          processingStatus: 'processing',
+          processingStartedAt: now,
+          processingError: null,
+          aiRequested: useAI,
+          aiCompleted: false,
+          ...(promptTemplateId !== undefined ? { promptTemplateId } : {}),
+          tags: [],
+        },
+      });
+      designId = design.id;
+    }
+
+    const job = extractionPipeline.enqueueImportFromUrl({ ...body, designId });
+    importJobs.trackImportJob(job.id, designId);
+
+    await storage.updateDesign(designId, {
+      metadata: {
+        processingStatus: 'processing',
+        processingStartedAt: now,
+        processingJobId: job.id,
+        processingError: null,
+        aiRequested: useAI,
+        ...(useAI ? { aiCompleted: false } : {}),
+        ...(promptTemplateId !== undefined ? { promptTemplateId } : {}),
+      },
+    });
+
+    sendJson(res, 202, { job, designId });
+  } catch (error) {
+    sendJson(res, 400, { error: error.message });
+  }
+}
+
+function registerImportRoutes(router, deps) {
+  const { storage, extractionPipeline, importJobs } = deps;
+  router.add('GET', '/api/import/stream', (req, res, ctx) => handleImportStream(req, res, extractionPipeline, ctx.url));
+  router.add('GET', '/api/import/jobs', (req, res) => handleImportJobs(res, extractionPipeline));
+  router.add('GET', '/api/import/jobs/:jobId', (req, res, ctx) =>
+    handleImportJob(res, extractionPipeline, ctx.params.jobId)
+  );
+  router.add('POST', '/api/import/browser', (req, res) => handleImportBrowser(req, res, extractionPipeline));
+  router.add('POST', '/api/import/url', (req, res) =>
+    handleImportUrl(req, res, storage, extractionPipeline, importJobs)
+  );
+  router.add('POST', '/api/designs/import', (req, res) => handleImportBrowser(req, res, extractionPipeline));
+  router.add('POST', '/api/snapshots/import', (req, res) => handleImportBrowser(req, res, extractionPipeline));
+}
+
+module.exports = {
+  registerImportRoutes,
+};

package/src/routes/index.js

@@ -0,0 +1,29 @@
+const { registerRootRoutes } = require('./root');
+const { registerImportRoutes } = require('./import');
+const { registerDesignRoutes } = require('./designs');
+const { registerVersionRoutes } = require('./versions');
+const { registerSnapshotRoutes } = require('./snapshots');
+const { registerPreviewRoutes } = require('./previews');
+const { registerTaskRoutes } = require('./tasks');
+const { registerConfigRoutes } = require('./config');
+const { registerPromptTemplateRoutes } = require('./promptTemplates');
+const { registerUiproRoutes } = require('./uipro');
+const { registerScanRoutes } = require('./scanRoutes');
+
+function registerRoutes(router, deps) {
+  registerRootRoutes(router, deps);
+  registerImportRoutes(router, deps);
+  registerConfigRoutes(router, deps);
+  registerPromptTemplateRoutes(router, deps);
+  registerDesignRoutes(router, deps);
+  registerVersionRoutes(router, deps);
+  registerSnapshotRoutes(router, deps);
+  registerPreviewRoutes(router, deps);
+  registerTaskRoutes(router, deps);
+  registerScanRoutes(router, deps);
+  registerUiproRoutes(router, deps);
+}
+
+module.exports = {
+  registerRoutes,
+};