opencons 0.1.0

package/src/server/static.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const sourceCache = require('../store/source-cache');
+const { logger } = require('../lib/logger');
+const { WidgetServerError } = require('../lib/errors');
+const { sendText, sendJsonError, sendJson } = require('../lib/http-response');
+
+/** @type {http.Server | null} */
+let server = null;
+
+/** @type {number | null} */
+let listeningPort = null;
+
+const WIDGET_ROOT = path.join(__dirname, '..', '..', 'widget');
+
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.ico': 'image/x-icon',
+};
+
+/**
+ * @param {import('http').IncomingMessage} req
+ * @param {import('http').ServerResponse} res
+ */
+function handleWidgetRequest(req, res) {
+  try {
+    if (req.url && req.url.startsWith('/api/source')) {
+      return handleSourceApi(req, res);
+    }
+
+    const urlPath = req.url === '/' ? '/index.html' : req.url.split('?')[0];
+    const filePath = path.normalize(path.join(WIDGET_ROOT, urlPath));
+
+    if (!filePath.startsWith(WIDGET_ROOT)) {
+      sendText(res, 403, 'Forbidden');
+      return;
+    }
+
+    fs.readFile(filePath, (err, data) => {
+      if (err) {
+        sendText(res, 404, 'Not found');
+        return;
+      }
+
+      const ext = path.extname(filePath);
+      res.writeHead(200, { 'Content-Type': MIME_TYPES[ext] || 'application/octet-stream' });
+      res.end(data);
+    });
+  } catch (err) {
+    logger.error('Widget request handler failed', err);
+    sendJsonError(res, 500, { error: 'Internal server error', code: 'WIDGET_REQUEST_ERROR' });
+  }
+}
+
+/**
+ * @param {number} port
+ * @param {number} [maxAttempts]
+ * @returns {Promise<{ server: http.Server, port: number }>}
+ */
+function createStaticServer(port, maxAttempts = 10) {
+  if (server && listeningPort) {
+    return Promise.resolve({ server, port: listeningPort });
+  }
+
+  return new Promise((resolve, reject) => {
+    let attempt = 0;
+
+    const tryListen = (candidatePort) => {
+      const httpServer = http.createServer(handleWidgetRequest);
+
+      const onError = (err) => {
+        httpServer.removeListener('error', onError);
+        httpServer.close(() => {});
+
+        if (err.code === 'EADDRINUSE' && attempt < maxAttempts - 1) {
+          attempt += 1;
+          const nextPort = port + attempt;
+
+          if (attempt === 1) {
+            logger.warn(
+              `Port ${candidatePort} is in use — trying ${nextPort}. ` +
+                'Kill the old process or set opencons({ port: N }).'
+            );
+          }
+
+          tryListen(nextPort);
+          return;
+        }
+
+        reject(new WidgetServerError(`Failed to bind widget server on port ${candidatePort}`, err));
+      };
+
+      httpServer.once('error', onError);
+      httpServer.listen(candidatePort, () => {
+        httpServer.removeListener('error', onError);
+        server = httpServer;
+        listeningPort = candidatePort;
+
+        logger.info(`Widget → http://localhost:${candidatePort}`);
+
+        if (candidatePort !== port) {
+          logger.warn(
+            `Port ${port} was busy. Open http://localhost:${candidatePort} (not ${port}).`
+          );
+        }
+
+        resolve({ server: httpServer, port: candidatePort });
+      });
+    };
+
+    tryListen(port);
+  });
+}
+
+/**
+ * @returns {http.Server | null}
+ */
+function getServer() {
+  return server;
+}
+
+/**
+ * @returns {number | null}
+ */
+function getListeningPort() {
+  return listeningPort;
+}
+
+/**
+ * @param {import('http').IncomingMessage} req
+ * @param {import('http').ServerResponse} res
+ */
+function handleSourceApi(req, res) {
+  const url = new URL(req.url, 'http://localhost');
+  const file = url.searchParams.get('file');
+  const line = Number(url.searchParams.get('line')) || 1;
+
+  if (!file) {
+    sendJsonError(res, 400, { error: 'file query param required', code: 'MISSING_FILE_PARAM' });
+    return;
+  }
+
+  const snippet = sourceCache.getSnippet(file, line);
+
+  if (!snippet) {
+    sendJsonError(res, 404, { error: 'source not found', code: 'SOURCE_NOT_FOUND' });
+    return;
+  }
+
+  sendJson(res, snippet);
+}
+
+module.exports = {
+  createStaticServer,
+  getServer,
+  getListeningPort,
+};

package/src/server/ws.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { WebSocketServer } = require('ws');
+const { getServer, getListeningPort } = require('./static');
+const { logger } = require('../lib/logger');
+const { WebSocketError } = require('../lib/errors');
+
+/** @type {import('ws').WebSocketServer | null} */
+let wss = null;
+
+/**
+ * @param {ReturnType<import('../store/trace-store').createTraceStore>} traceStore
+ */
+function createWebSocketServer(traceStore) {
+  if (wss) return wss;
+
+  const httpServer = getServer();
+  const port = getListeningPort();
+
+  if (!httpServer || !port) {
+    throw new WebSocketError('HTTP server must be listening before WebSocket server');
+  }
+
+  wss = new WebSocketServer({ server: httpServer });
+
+  wss.on('connection', (socket) => {
+    traceStore.subscribe(socket);
+
+    socket.on('message', (raw) => {
+      try {
+        const message = JSON.parse(raw.toString());
+
+        if (message.type === 'get_history') {
+          const history = traceStore.getAll(message.limit || 50);
+          socket.send(JSON.stringify({ type: 'history', payload: history }));
+          return;
+        }
+
+        logger.debug(`Ignoring unknown WebSocket message type: ${message.type}`);
+      } catch (err) {
+        logger.debug('Ignoring malformed WebSocket message', err);
+      }
+    });
+
+    socket.on('close', () => {
+      traceStore.unsubscribe(socket);
+    });
+
+    socket.on('error', (err) => {
+      logger.debug('WebSocket client error', err);
+      traceStore.unsubscribe(socket);
+    });
+  });
+
+  logger.info(`WebSocket → ws://localhost:${port}`);
+
+  return wss;
+}
+
+module.exports = {
+  createWebSocketServer,
+};

package/src/store/source-cache.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/** @type {Map<string, { source: string, map: object | null, filename: string }>} */
+const cache = new Map();
+
+/** @type {string | null} */
+let projectRoot = null;
+
+/**
+ * @param {string} root
+ */
+function setProjectRoot(root) {
+  projectRoot = path.normalize(root);
+}
+
+/**
+ * @param {string} filename
+ * @param {string} source
+ * @param {object | null} map
+ */
+function store(filename, source, map) {
+  const key = normalizeKey(filename);
+  cache.set(key, {
+    filename,
+    source,
+    map,
+  });
+}
+
+/**
+ * @param {string} filename
+ */
+function storeOriginal(filename) {
+  const key = normalizeKey(filename);
+
+  if (cache.has(key)) return;
+
+  try {
+    const source = fs.readFileSync(filename, 'utf8');
+    cache.set(key, { filename, source, map: null });
+  } catch {
+    // unreadable source — widget peek will return 404
+  }
+}
+
+/**
+ * Resolve a cache entry by project-relative path, absolute path, or basename.
+ *
+ * @param {string} fileKey
+ */
+function get(fileKey) {
+  const direct = cache.get(fileKey);
+  if (direct) return direct;
+
+  const normalized = normalizeKey(fileKey);
+  const byNormalized = cache.get(normalized);
+  if (byNormalized) return byNormalized;
+
+  const basename = path.basename(fileKey);
+  if (basename !== normalized) {
+    return cache.get(basename) || null;
+  }
+
+  return null;
+}
+
+/**
+ * Prefer project-relative paths to avoid basename collisions across folders.
+ *
+ * @param {string} filename
+ */
+function normalizeKey(filename) {
+  const resolved = path.resolve(filename);
+
+  if (projectRoot) {
+    const relative = path.relative(projectRoot, resolved).replace(/\\/g, '/');
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+      return relative;
+    }
+  }
+
+  return path.basename(resolved);
+}
+
+/**
+ * @param {string} fileKey
+ * @param {number} line
+ * @param {number} [contextLines]
+ */
+function getSnippet(fileKey, line, contextLines = 4) {
+  const entry = get(fileKey);
+  if (!entry) return null;
+
+  const lines = entry.source.split('\n');
+  const start = Math.max(0, line - contextLines - 1);
+  const end = Math.min(lines.length, line + contextLines);
+
+  return {
+    file: entry.filename,
+    line,
+    startLine: start + 1,
+    lines: lines.slice(start, end).map((text, index) => ({
+      number: start + index + 1,
+      text,
+      highlight: start + index + 1 === line,
+    })),
+  };
+}
+
+module.exports = {
+  setProjectRoot,
+  store,
+  storeOriginal,
+  get,
+  getSnippet,
+  normalizeKey,
+};

package/src/store/trace-store.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const { logger } = require('../lib/logger');
+
+/**
+ * In-memory store for active and completed trace graphs.
+ * @param {number} maxTraces
+ */
+function createTraceStore(maxTraces = 100) {
+  /** @type {Map<string, import('../core/tracer').TraceGraph>} */
+  const active = new Map();
+
+  /** @type {import('../core/tracer').TraceGraph[]} */
+  const completed = [];
+
+  /** @type {Set<import('ws').WebSocket>} */
+  const subscribers = new Set();
+
+  /**
+   * @param {string} type
+   * @param {import('../core/tracer').TraceGraph} trace
+   */
+  function broadcast(type, trace) {
+    const message = JSON.stringify({ type, payload: trace });
+
+    for (const client of subscribers) {
+      if (client.readyState !== 1) continue;
+
+      try {
+        client.send(message);
+      } catch (err) {
+        logger.debug('WebSocket send failed; removing subscriber', err);
+        subscribers.delete(client);
+      }
+    }
+  }
+
+  return {
+    /**
+     * Broadcast a newly discovered in-flight request.
+     * @param {import('../core/tracer').TraceGraph} trace
+     */
+    start(trace) {
+      active.set(trace.id, trace);
+      broadcast('trace_start', trace);
+    },
+
+    /**
+     * Stream live progress for an active request.
+     * @param {import('../core/tracer').TraceGraph} trace
+     */
+    update(trace) {
+      if (!active.has(trace.id)) return;
+      active.set(trace.id, trace);
+      broadcast('trace_update', trace);
+    },
+
+    /**
+     * Finalise and archive a completed request trace.
+     * @param {import('../core/tracer').TraceGraph} trace
+     */
+    complete(trace) {
+      active.delete(trace.id);
+      completed.unshift(trace);
+
+      if (completed.length > maxTraces) {
+        completed.length = maxTraces;
+      }
+
+      broadcast('trace', trace);
+    },
+
+    /**
+     * @deprecated Use complete() — kept for internal compatibility.
+     * @param {import('../core/tracer').TraceGraph} trace
+     */
+    add(trace) {
+      this.complete(trace);
+    },
+
+    /**
+     * @param {number} [limit]
+     */
+    getAll(limit = 100) {
+      const activeTraces = Array.from(active.values()).sort((a, b) => b.timestamp - a.timestamp);
+      const merged = [...activeTraces, ...completed];
+      return merged.slice(0, limit);
+    },
+
+    /**
+     * @param {string} id
+     * @returns {import('../core/tracer').TraceGraph | undefined}
+     */
+    getById(id) {
+      if (active.has(id)) return active.get(id);
+      return completed.find((trace) => trace.id === id);
+    },
+
+    /**
+     * @param {import('ws').WebSocket} client
+     */
+    subscribe(client) {
+      subscribers.add(client);
+    },
+
+    /**
+     * @param {import('ws').WebSocket} client
+     */
+    unsubscribe(client) {
+      subscribers.delete(client);
+    },
+  };
+}
+
+module.exports = {
+  createTraceStore,
+};

package/src/transform/ast.js

@@ -0,0 +1,255 @@
+'use strict';
+
+const path = require('path');
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const generate = require('@babel/generator').default;
+const t = require('@babel/types');
+
+const PROBE_MODULE = path.join(__dirname, 'probe.js');
+
+/**
+ * @param {string} filename
+ * @param {number} line
+ * @param {string} kind
+ * @param {string} [projectRoot]
+ */
+function probeLabel(filename, line, kind, projectRoot) {
+  const resolved = path.resolve(filename);
+  let relative = path.basename(resolved);
+
+  if (projectRoot) {
+    const fromRoot = path.relative(projectRoot, resolved).replace(/\\/g, '/');
+    if (fromRoot && !fromRoot.startsWith('..') && !path.isAbsolute(fromRoot)) {
+      relative = fromRoot;
+    }
+  }
+
+  return `${kind}:${relative}:${line}`;
+}
+
+/**
+ * @param {string} source
+ * @param {import('@babel/types').Node} node
+ */
+function sliceFromSource(source, node) {
+  if (typeof node.start === 'number' && typeof node.end === 'number') {
+    return source.slice(node.start, node.end).trim();
+  }
+
+  return null;
+}
+
+/**
+ * @param {string} label
+ * @param {import('@babel/types').Expression} expression
+ * @param {string | null} conditionText
+ * @param {boolean} [hasElse]
+ */
+function probeCall(label, expression, conditionText, hasElse = false) {
+  const args = [t.stringLiteral(label), expression];
+
+  if (conditionText) {
+    args.push(t.stringLiteral(conditionText));
+  }
+
+  args.push(t.booleanLiteral(hasElse));
+
+  return t.callExpression(t.identifier('__rg_probe'), args);
+}
+
+/**
+ * @param {string} label
+ */
+function elseProbeStatement(label) {
+  return t.expressionStatement(
+    t.callExpression(t.identifier('__rg_else_probe'), [t.stringLiteral(label)])
+  );
+}
+
+/**
+ * @param {string} source
+ * @param {string} filename
+ * @param {{ projectRoot?: string }} [options]
+ * @returns {{ code: string, map: object | null, skipped: boolean, reason?: string }}
+ */
+function transformSource(source, filename, options = {}) {
+  const projectRoot = options.projectRoot;
+  if (source.includes('opencons-skip') || source.includes('routegrapher-skip')) {
+    return { code: source, map: null, skipped: true, reason: 'opencons-skip' };
+  }
+
+  if (isLikelyMinified(source)) {
+    return { code: source, map: null, skipped: true, reason: 'minified' };
+  }
+
+  let ast;
+
+  try {
+    ast = parser.parse(source, {
+      sourceType: 'script',
+      plugins: ['jsx', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+      errorRecovery: true,
+      ranges: true,
+    });
+  } catch (err) {
+    return { code: source, map: null, skipped: true, reason: `parse-error: ${err.message}` };
+  }
+
+  const probeImportPath = PROBE_MODULE.replace(/\\/g, '/');
+
+  traverse(ast, {
+    Program(programPath) {
+      const body = programPath.node.body;
+
+      if (!hasProbeImport(body)) {
+        body.unshift(
+          t.variableDeclaration('const', [
+            t.variableDeclarator(
+              t.objectPattern([
+                t.objectProperty(t.identifier('__rg_probe'), t.identifier('__rg_probe'), false, true),
+                t.objectProperty(
+                  t.identifier('__rg_else_probe'),
+                  t.identifier('__rg_else_probe'),
+                  false,
+                  true
+                ),
+                t.objectProperty(
+                  t.identifier('__rg_catch_probe'),
+                  t.identifier('__rg_catch_probe'),
+                  false,
+                  true
+                ),
+              ]),
+              t.callExpression(t.identifier('require'), [t.stringLiteral(probeImportPath)])
+            ),
+          ])
+        );
+      }
+    },
+
+    IfStatement(ifPath) {
+      const line = ifPath.node.loc?.start.line || 0;
+      const label = probeLabel(filename, line, 'if', projectRoot);
+      const test = ifPath.node.test;
+      const conditionText = sliceFromSource(source, test);
+      const hasElse = Boolean(ifPath.node.alternate);
+      ifPath.node.test = probeCall(label, test, conditionText, hasElse);
+
+      if (ifPath.node.alternate) {
+        if (t.isBlockStatement(ifPath.node.alternate)) {
+          ifPath.node.alternate.body.unshift(elseProbeStatement(label));
+        } else {
+          ifPath.node.alternate = t.blockStatement([
+            elseProbeStatement(label),
+            t.isStatement(ifPath.node.alternate)
+              ? ifPath.node.alternate
+              : t.expressionStatement(ifPath.node.alternate),
+          ]);
+        }
+      }
+    },
+
+    ConditionalExpression(condPath) {
+      const line = condPath.node.loc?.start.line || 0;
+      const label = probeLabel(filename, line, 'ternary', projectRoot);
+      const test = condPath.node.test;
+      condPath.node.test = probeCall(label, test, sliceFromSource(source, test), true);
+    },
+
+    SwitchStatement(switchPath) {
+      const line = switchPath.node.loc?.start.line || 0;
+      const label = probeLabel(filename, line, 'switch', projectRoot);
+      const discriminant = switchPath.node.discriminant;
+      switchPath.node.discriminant = probeCall(
+        label,
+        discriminant,
+        sliceFromSource(source, discriminant),
+        false
+      );
+    },
+
+    WhileStatement(whilePath) {
+      const line = whilePath.node.loc?.start.line || 0;
+      const label = probeLabel(filename, line, 'while', projectRoot);
+      const test = whilePath.node.test;
+      whilePath.node.test = probeCall(label, test, sliceFromSource(source, test), false);
+    },
+
+    DoWhileStatement(doWhilePath) {
+      const line = doWhilePath.node.loc?.start.line || 0;
+      const label = probeLabel(filename, line, 'while', projectRoot);
+      const test = doWhilePath.node.test;
+      doWhilePath.node.test = probeCall(label, test, sliceFromSource(source, test), false);
+    },
+
+    ForStatement(forPath) {
+      if (!forPath.node.test) return;
+      const line = forPath.node.loc?.start.line || 0;
+      const label = probeLabel(filename, line, 'for', projectRoot);
+      const test = forPath.node.test;
+      forPath.node.test = probeCall(label, test, sliceFromSource(source, test), false);
+    },
+
+    CatchClause(catchPath) {
+      const line = catchPath.node.loc?.start.line || 0;
+      const label = probeLabel(filename, line, 'catch', projectRoot);
+      const paramName = t.isIdentifier(catchPath.node.param)
+        ? catchPath.node.param.name
+        : 'err';
+
+      catchPath.node.body.body.unshift(
+        t.expressionStatement(
+          t.callExpression(t.identifier('__rg_catch_probe'), [
+            t.stringLiteral(label),
+            t.identifier(paramName),
+          ])
+        )
+      );
+    },
+  });
+
+  const output = generate(ast, {
+    sourceMaps: true,
+    sourceFileName: filename,
+  }, source);
+
+  return {
+    code: output.code,
+    map: output.map,
+    skipped: false,
+  };
+}
+
+/**
+ * @param {import('@babel/types').Statement[]} body
+ */
+function hasProbeImport(body) {
+  return body.some(
+    (stmt) =>
+      t.isVariableDeclaration(stmt) &&
+      stmt.declarations.some(
+        (decl) =>
+          t.isObjectPattern(decl.id) &&
+          decl.id.properties.some(
+            (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key, { name: '__rg_probe' })
+          )
+      )
+  );
+}
+
+/**
+ * @param {string} source
+ */
+function isLikelyMinified(source) {
+  const lines = source.split('\n');
+  if (lines.length < 3 && source.length > 500) return true;
+
+  const avgLine = source.length / Math.max(lines.length, 1);
+  return avgLine > 300;
+}
+
+module.exports = {
+  transformSource,
+  probeLabel,
+};