@cadcrawl/cad-browser 0.3.0

package/src/project-store.js

@@ -0,0 +1,127 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { scanProject } from './scanner.js';
+import { analyzeFile } from './analyzer.js';
+import { createProjectCache, readCache, writeCache } from './cache.js';
+import { resolveInside } from './path-safety.js';
+
+export class ProjectStore extends EventEmitter {
+  constructor(rootPath) {
+    super();
+    this.rootPath = path.resolve(rootPath);
+    this.cache = null;
+    this.cacheIndex = null;
+    this.snapshot = null;
+    this.queue = [];
+    this.queued = new Set();
+    this.active = 0;
+    this.concurrency = 2;
+    this.cacheWrite = Promise.resolve();
+  }
+
+  async initialize() {
+    this.cache = await createProjectCache(this.rootPath);
+    this.cacheIndex = await readCache(this.cache);
+    await this.rescan();
+  }
+
+  async rescan() {
+    const scanned = await scanProject(this.rootPath);
+    const files = scanned.files.map((file) => {
+      const cached = this.cacheIndex.files[file.path];
+      const fresh = cached?.modifiedKey === file.modifiedKey;
+      return {
+        ...file,
+        status: file.analyzable ? (fresh ? 'ready' : 'queued') : 'plain',
+        analysis: fresh ? cached.analysis : null,
+      };
+    });
+    this.snapshot = {
+      rootName: path.basename(this.rootPath),
+      rootPath: this.rootPath,
+      scannedAt: new Date().toISOString(),
+      tree: scanned.tree,
+      files,
+      counts: countKinds(files),
+    };
+    this.emit('snapshot', this.publicSnapshot());
+    for (const file of files.filter((item) => item.analyzable && item.status === 'queued')) {
+      this.enqueue(file.path);
+    }
+    return this.publicSnapshot();
+  }
+
+  publicSnapshot() {
+    return {
+      ...this.snapshot,
+      rootPath: this.rootPath,
+      cachePath: this.cache.directory,
+    };
+  }
+
+  findFile(relativePath) {
+    return this.snapshot.files.find((file) => file.path === relativePath) ?? null;
+  }
+
+  enqueue(relativePath, force = false) {
+    const file = this.findFile(relativePath);
+    if (!file?.analyzable || this.queued.has(relativePath)) return;
+    if (!force && file.status === 'ready') return;
+    file.status = 'queued';
+    this.queue.push({ relativePath, force });
+    this.queued.add(relativePath);
+    this.pump();
+  }
+
+  async pump() {
+    while (this.active < this.concurrency && this.queue.length > 0) {
+      const job = this.queue.shift();
+      this.active += 1;
+      this.process(job).finally(() => {
+        this.active -= 1;
+        this.queued.delete(job.relativePath);
+        this.pump();
+      });
+    }
+  }
+
+  async process({ relativePath }) {
+    const file = this.findFile(relativePath);
+    if (!file) return;
+    file.status = 'processing';
+    this.emit('file', file);
+    try {
+      const absolutePath = resolveInside(this.rootPath, relativePath);
+      const analysis = await analyzeFile(absolutePath, relativePath, this.cache, file.kind);
+      file.analysis = analysis;
+      file.status = 'ready';
+      file.error = null;
+      this.cacheIndex.files[relativePath] = {
+        modifiedKey: file.modifiedKey,
+        analysis,
+      };
+      this.cacheWrite = this.cacheWrite.then(() => writeCache(this.cache, this.cacheIndex));
+      await this.cacheWrite;
+    } catch (error) {
+      file.status = 'error';
+      file.error = error instanceof Error ? error.message : String(error);
+    }
+    this.emit('file', file);
+  }
+
+  async rawFile(relativePath) {
+    const absolutePath = resolveInside(this.rootPath, relativePath);
+    await fs.access(absolutePath);
+    return absolutePath;
+  }
+}
+
+function countKinds(files) {
+  return files.reduce((counts, file) => {
+    counts.total += 1;
+    counts[file.kind] = (counts[file.kind] ?? 0) + 1;
+    if (file.analyzable) counts.engineering += 1;
+    return counts;
+  }, { total: 0, engineering: 0, cad: 0, pdf: 0, image: 0, file: 0 });
+}

package/src/reveal-file.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import open from 'open';
+
+export function revealCommand(filePath, platform = process.platform, windowsDirectory = process.env.SystemRoot ?? process.env.WINDIR ?? 'C:\\Windows') {
+  if (platform === 'win32') {
+    return {
+      command: path.win32.join(windowsDirectory, 'explorer.exe'),
+      args: [`/select,${filePath}`],
+    };
+  }
+  if (platform === 'darwin') {
+    return { command: 'open', args: ['-R', filePath] };
+  }
+  return { command: 'xdg-open', args: [path.dirname(filePath)] };
+}
+
+export async function revealFile(filePath, platform = process.platform) {
+  const { command, args } = revealCommand(filePath, platform);
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: false,
+    });
+    child.once('error', reject);
+    child.once('spawn', () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+export async function openFile(filePath) {
+  await open(filePath, { wait: false });
+}

package/src/scanner.js

@@ -0,0 +1,75 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { classifyExtension, canAnalyze } from './file-types.js';
+import { toProjectPath } from './path-safety.js';
+
+const DEFAULT_IGNORES = new Set([
+  '.git', '.svn', '.hg', 'node_modules', '__pycache__', '.pytest_cache',
+  '.mypy_cache', '.ruff_cache', '.next', '.cache', 'coverage', 'dist', 'out',
+]);
+
+export async function scanProject(rootPath) {
+  const files = [];
+  const root = createDirectoryNode('', '');
+  await walk(rootPath, root, files, rootPath);
+  root.fileCount = countFiles(root);
+  sortTree(root);
+  files.sort((left, right) => left.path.localeCompare(right.path, undefined, { numeric: true }));
+  return { tree: root, files };
+}
+
+async function walk(directoryPath, parentNode, files, rootPath) {
+  let entries = await fs.readdir(directoryPath, { withFileTypes: true });
+  entries = entries.filter((entry) => !entry.name.startsWith('.') || entry.name === '.github');
+
+  for (const entry of entries) {
+    if (DEFAULT_IGNORES.has(entry.name)) continue;
+    const absolutePath = path.join(directoryPath, entry.name);
+    const relativePath = toProjectPath(rootPath, absolutePath);
+
+    if (entry.isDirectory()) {
+      const node = createDirectoryNode(entry.name, relativePath);
+      parentNode.children.push(node);
+      await walk(absolutePath, node, files, rootPath);
+      node.fileCount = countFiles(node);
+      continue;
+    }
+
+    if (!entry.isFile()) continue;
+    const stat = await fs.stat(absolutePath);
+    const extension = path.extname(entry.name).toLowerCase();
+    const file = {
+      name: entry.name,
+      path: relativePath,
+      parent: toProjectPath(rootPath, directoryPath),
+      extension,
+      kind: classifyExtension(extension),
+      analyzable: canAnalyze(extension),
+      size: stat.size,
+      modifiedAt: stat.mtime.toISOString(),
+      modifiedKey: `${stat.size}:${stat.mtimeMs}`,
+    };
+    files.push(file);
+    parentNode.children.push({ type: 'file', name: file.name, path: file.path, kind: file.kind });
+  }
+}
+
+function createDirectoryNode(name, nodePath) {
+  return { type: 'directory', name, path: nodePath, children: [], fileCount: 0 };
+}
+
+function countFiles(node) {
+  return node.children.reduce((count, child) => (
+    count + (child.type === 'file' ? 1 : countFiles(child))
+  ), 0);
+}
+
+function sortTree(node) {
+  node.children.sort((left, right) => {
+    if (left.type !== right.type) return left.type === 'directory' ? -1 : 1;
+    return left.name.localeCompare(right.name, undefined, { numeric: true });
+  });
+  for (const child of node.children) {
+    if (child.type === 'directory') sortTree(child);
+  }
+}

package/src/server.js

@@ -0,0 +1,103 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fs from 'node:fs/promises';
+import express from 'express';
+import { resolveInside } from './path-safety.js';
+import { openFile, revealFile } from './reveal-file.js';
+
+const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+
+export async function createServer(store, options = {}) {
+  const app = express();
+  const reveal = options.revealFile ?? revealFile;
+  const openWithDefaultApp = options.openFile ?? openFile;
+  app.disable('x-powered-by');
+  app.use(express.json({ limit: '32kb' }));
+
+  app.get('/api/project', (_request, response) => {
+    response.json(store.publicSnapshot());
+  });
+
+  app.post('/api/rescan', async (_request, response, next) => {
+    try {
+      response.json(await store.rescan());
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.post('/api/analyze', (request, response) => {
+    const relativePath = String(request.body?.path ?? '');
+    const file = store.findFile(relativePath);
+    if (!file) return response.status(404).json({ error: 'File not found' });
+    store.enqueue(relativePath, Boolean(request.body?.force));
+    return response.status(202).json({ status: 'queued' });
+  });
+
+  app.post('/api/reveal', async (request, response, next) => {
+    try {
+      const relativePath = String(request.body?.path ?? '');
+      const file = store.findFile(relativePath);
+      if (!file) return response.status(404).json({ error: 'File not found' });
+      await reveal(await store.rawFile(relativePath));
+      return response.json({ ok: true });
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.post('/api/open', async (request, response, next) => {
+    try {
+      const relativePath = String(request.body?.path ?? '');
+      const file = store.findFile(relativePath);
+      if (!file) return response.status(404).json({ error: 'File not found' });
+      await openWithDefaultApp(await store.rawFile(relativePath));
+      return response.json({ ok: true });
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.get('/api/raw', async (request, response, next) => {
+    try {
+      response.sendFile(await store.rawFile(String(request.query.path ?? '')));
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.get('/api/preview', async (request, response, next) => {
+    try {
+      const requestedPath = String(request.query.path ?? '');
+      const absolutePath = resolveInside(store.cache.rendersDirectory, requestedPath);
+      response.type('png').send(await fs.readFile(absolutePath));
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.get('/api/events', (request, response) => {
+    response.setHeader('Content-Type', 'text/event-stream');
+    response.setHeader('Cache-Control', 'no-cache');
+    response.setHeader('Connection', 'keep-alive');
+    response.flushHeaders();
+    const sendFile = (file) => response.write(`event: file\ndata: ${JSON.stringify(file)}\n\n`);
+    const heartbeat = setInterval(() => response.write(': heartbeat\n\n'), 15000);
+    store.on('file', sendFile);
+    request.on('close', () => {
+      clearInterval(heartbeat);
+      store.off('file', sendFile);
+    });
+  });
+
+  const clientDirectory = options.clientDirectory
+    ?? path.resolve(moduleDirectory, '../dist/client');
+  app.use(express.static(clientDirectory, { index: false, maxAge: '1h' }));
+  app.get('*splat', (_request, response) => response.sendFile(path.join(clientDirectory, 'index.html')));
+
+  app.use((error, _request, response, _next) => {
+    response.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+  });
+
+  return app;
+}