mdv-live 0.3.0 → 0.3.2

package/src/utils/fileTypes.js

@@ -2,62 +2,70 @@
  * File type detection and classification
  */
 
-// File extension to type mapping
+// Helper functions to reduce repetition
+function code(icon, lang) {
+  return { type: 'code', icon, lang, binary: false };
+}
+
+function binary(type, icon = type) {
+  return { type, icon, lang: null, binary: true };
+}
+
 const FILE_TYPES = {
   // Markdown
   md: { type: 'markdown', icon: 'markdown', lang: null, binary: false },
   markdown: { type: 'markdown', icon: 'markdown', lang: null, binary: false },
 
   // Code - Python
-  py: { type: 'code', icon: 'python', lang: 'python', binary: false },
-  pyw: { type: 'code', icon: 'python', lang: 'python', binary: false },
+  py: code('python', 'python'),
+  pyw: code('python', 'python'),
 
   // Code - JavaScript/TypeScript
-  js: { type: 'code', icon: 'javascript', lang: 'javascript', binary: false },
-  mjs: { type: 'code', icon: 'javascript', lang: 'javascript', binary: false },
-  cjs: { type: 'code', icon: 'javascript', lang: 'javascript', binary: false },
-  ts: { type: 'code', icon: 'typescript', lang: 'typescript', binary: false },
-  tsx: { type: 'code', icon: 'react', lang: 'tsx', binary: false },
-  jsx: { type: 'code', icon: 'react', lang: 'jsx', binary: false },
+  js: code('javascript', 'javascript'),
+  mjs: code('javascript', 'javascript'),
+  cjs: code('javascript', 'javascript'),
+  ts: code('typescript', 'typescript'),
+  tsx: code('react', 'tsx'),
+  jsx: code('react', 'jsx'),
 
   // Code - Web
-  html: { type: 'code', icon: 'html', lang: 'html', binary: false },
-  htm: { type: 'code', icon: 'html', lang: 'html', binary: false },
-  css: { type: 'code', icon: 'css', lang: 'css', binary: false },
-  scss: { type: 'code', icon: 'css', lang: 'scss', binary: false },
-  less: { type: 'code', icon: 'css', lang: 'less', binary: false },
-  vue: { type: 'code', icon: 'vue', lang: 'vue', binary: false },
-  svelte: { type: 'code', icon: 'default', lang: 'svelte', binary: false },
+  html: code('html', 'html'),
+  htm: code('html', 'html'),
+  css: code('css', 'css'),
+  scss: code('css', 'scss'),
+  less: code('css', 'less'),
+  vue: code('vue', 'vue'),
+  svelte: code('default', 'svelte'),
 
   // Data formats
-  json: { type: 'code', icon: 'json', lang: 'json', binary: false },
-  yaml: { type: 'code', icon: 'yaml', lang: 'yaml', binary: false },
-  yml: { type: 'code', icon: 'yaml', lang: 'yaml', binary: false },
-  toml: { type: 'code', icon: 'config', lang: 'toml', binary: false },
-  xml: { type: 'code', icon: 'default', lang: 'xml', binary: false },
+  json: code('json', 'json'),
+  yaml: code('yaml', 'yaml'),
+  yml: code('yaml', 'yaml'),
+  toml: code('config', 'toml'),
+  xml: code('default', 'xml'),
 
   // Shell/Config
-  sh: { type: 'code', icon: 'shell', lang: 'bash', binary: false },
-  bash: { type: 'code', icon: 'shell', lang: 'bash', binary: false },
-  zsh: { type: 'code', icon: 'shell', lang: 'bash', binary: false },
-  fish: { type: 'code', icon: 'shell', lang: 'bash', binary: false },
-  env: { type: 'code', icon: 'config', lang: 'bash', binary: false },
-  ini: { type: 'code', icon: 'config', lang: 'ini', binary: false },
-  conf: { type: 'code', icon: 'config', lang: 'ini', binary: false },
+  sh: code('shell', 'bash'),
+  bash: code('shell', 'bash'),
+  zsh: code('shell', 'bash'),
+  fish: code('shell', 'bash'),
+  env: code('config', 'bash'),
+  ini: code('config', 'ini'),
+  conf: code('config', 'ini'),
 
   // Other languages
-  go: { type: 'code', icon: 'default', lang: 'go', binary: false },
-  rs: { type: 'code', icon: 'default', lang: 'rust', binary: false },
-  rb: { type: 'code', icon: 'default', lang: 'ruby', binary: false },
-  php: { type: 'code', icon: 'default', lang: 'php', binary: false },
-  java: { type: 'code', icon: 'default', lang: 'java', binary: false },
-  kt: { type: 'code', icon: 'default', lang: 'kotlin', binary: false },
-  swift: { type: 'code', icon: 'default', lang: 'swift', binary: false },
-  c: { type: 'code', icon: 'default', lang: 'c', binary: false },
-  cpp: { type: 'code', icon: 'default', lang: 'cpp', binary: false },
-  h: { type: 'code', icon: 'default', lang: 'c', binary: false },
-  cs: { type: 'code', icon: 'default', lang: 'csharp', binary: false },
-  sql: { type: 'code', icon: 'database', lang: 'sql', binary: false },
+  go: code('default', 'go'),
+  rs: code('default', 'rust'),
+  rb: code('default', 'ruby'),
+  php: code('default', 'php'),
+  java: code('default', 'java'),
+  kt: code('default', 'kotlin'),
+  swift: code('default', 'swift'),
+  c: code('default', 'c'),
+  cpp: code('default', 'cpp'),
+  h: code('default', 'c'),
+  cs: code('default', 'csharp'),
+  sql: code('database', 'sql'),
 
   // Text files
   txt: { type: 'text', icon: 'text', lang: null, binary: false },
@@ -65,84 +73,85 @@ const FILE_TYPES = {
   csv: { type: 'text', icon: 'text', lang: null, binary: false },
 
   // Images
-  png: { type: 'image', icon: 'image', lang: null, binary: true },
-  jpg: { type: 'image', icon: 'image', lang: null, binary: true },
-  jpeg: { type: 'image', icon: 'image', lang: null, binary: true },
-  gif: { type: 'image', icon: 'image', lang: null, binary: true },
-  svg: { type: 'image', icon: 'image', lang: null, binary: true },
-  webp: { type: 'image', icon: 'image', lang: null, binary: true },
-  ico: { type: 'image', icon: 'image', lang: null, binary: true },
+  png: binary('image'),
+  jpg: binary('image'),
+  jpeg: binary('image'),
+  gif: binary('image'),
+  svg: binary('image'),
+  webp: binary('image'),
+  ico: binary('image'),
 
   // PDF
-  pdf: { type: 'pdf', icon: 'pdf', lang: null, binary: true },
+  pdf: binary('pdf'),
 
   // Video
-  mp4: { type: 'video', icon: 'video', lang: null, binary: true },
-  webm: { type: 'video', icon: 'video', lang: null, binary: true },
-  mov: { type: 'video', icon: 'video', lang: null, binary: true },
-  avi: { type: 'video', icon: 'video', lang: null, binary: true },
-  mkv: { type: 'video', icon: 'video', lang: null, binary: true },
+  mp4: binary('video'),
+  webm: binary('video'),
+  mov: binary('video'),
+  avi: binary('video'),
+  mkv: binary('video'),
 
   // Audio
-  mp3: { type: 'audio', icon: 'audio', lang: null, binary: true },
-  wav: { type: 'audio', icon: 'audio', lang: null, binary: true },
-  ogg: { type: 'audio', icon: 'audio', lang: null, binary: true },
-  m4a: { type: 'audio', icon: 'audio', lang: null, binary: true },
-  flac: { type: 'audio', icon: 'audio', lang: null, binary: true },
+  mp3: binary('audio'),
+  wav: binary('audio'),
+  ogg: binary('audio'),
+  m4a: binary('audio'),
+  flac: binary('audio'),
 
   // Archives
-  zip: { type: 'archive', icon: 'archive', lang: null, binary: true },
-  tar: { type: 'archive', icon: 'archive', lang: null, binary: true },
-  gz: { type: 'archive', icon: 'archive', lang: null, binary: true },
-  rar: { type: 'archive', icon: 'archive', lang: null, binary: true },
-  '7z': { type: 'archive', icon: 'archive', lang: null, binary: true },
+  zip: binary('archive'),
+  tar: binary('archive'),
+  gz: binary('archive'),
+  rar: binary('archive'),
+  '7z': binary('archive'),
 
   // Office
-  doc: { type: 'office', icon: 'office', lang: null, binary: true },
-  docx: { type: 'office', icon: 'office', lang: null, binary: true },
-  xls: { type: 'office', icon: 'office', lang: null, binary: true },
-  xlsx: { type: 'office', icon: 'office', lang: null, binary: true },
-  ppt: { type: 'office', icon: 'office', lang: null, binary: true },
-  pptx: { type: 'office', icon: 'office', lang: null, binary: true },
+  doc: binary('office'),
+  docx: binary('office'),
+  xls: binary('office'),
+  xlsx: binary('office'),
+  ppt: binary('office'),
+  pptx: binary('office'),
 
   // Executables
-  exe: { type: 'executable', icon: 'executable', lang: null, binary: true },
-  dmg: { type: 'executable', icon: 'executable', lang: null, binary: true },
-  app: { type: 'executable', icon: 'executable', lang: null, binary: true },
+  exe: binary('executable'),
+  dmg: binary('executable'),
+  app: binary('executable'),
 };
 
-// Special filenames
+// Special filenames that don't follow extension-based detection
 const SPECIAL_FILES = {
-  'Dockerfile': { type: 'code', icon: 'config', lang: 'dockerfile', binary: false },
-  'Makefile': { type: 'code', icon: 'config', lang: 'makefile', binary: false },
-  '.gitignore': { type: 'code', icon: 'config', lang: 'gitignore', binary: false },
-  '.env': { type: 'code', icon: 'config', lang: 'bash', binary: false },
-  '.env.local': { type: 'code', icon: 'config', lang: 'bash', binary: false },
-  '.env.example': { type: 'code', icon: 'config', lang: 'bash', binary: false },
+  'Dockerfile': code('config', 'dockerfile'),
+  'Makefile': code('config', 'makefile'),
+  '.gitignore': code('config', 'gitignore'),
+  '.env': code('config', 'bash'),
+  '.env.local': code('config', 'bash'),
+  '.env.example': code('config', 'bash'),
 };
 
+const DEFAULT_FILE_TYPE = { type: 'text', icon: 'text', lang: null, binary: false };
+
 /**
- * Get file type information
+ * Get file type information from filename or path
  * @param {string} filename - File name or path
- * @returns {Object} File type info { type, icon, lang, binary }
+ * @returns {{ type: string, icon: string, lang: string|null, binary: boolean }}
  */
 export function getFileType(filename) {
-  const basename = filename.split('/').pop();
+  const basename = filename.split('/').pop() || '';
 
   // Check special filenames first
   if (SPECIAL_FILES[basename]) {
     return SPECIAL_FILES[basename];
   }
 
-  // Get extension
-  const ext = basename.split('.').pop()?.toLowerCase();
-
-  if (ext && FILE_TYPES[ext]) {
-    return FILE_TYPES[ext];
+  // Extract extension (last part after dot)
+  const lastDotIndex = basename.lastIndexOf('.');
+  if (lastDotIndex === -1 || lastDotIndex === basename.length - 1) {
+    return DEFAULT_FILE_TYPE;
   }
 
-  // Default to text file
-  return { type: 'text', icon: 'text', lang: null, binary: false };
+  const ext = basename.slice(lastDotIndex + 1).toLowerCase();
+  return FILE_TYPES[ext] || DEFAULT_FILE_TYPE;
 }
 
-export default { getFileType, FILE_TYPES };
+export { FILE_TYPES };

package/src/utils/path.js

@@ -5,19 +5,19 @@
 import path from 'path';
 
 /**
- * Validate that a path is within the allowed root directory
- * Prevents path traversal attacks
- * @param {string} targetPath - Path to validate (must be relative)
+ * Validate that a path is within the allowed root directory.
+ * Prevents path traversal attacks, null byte injection, and absolute path access.
+ * @param {string} targetPath - Relative path to validate
  * @param {string} rootDir - Allowed root directory
- * @returns {boolean} True if path is valid
+ * @returns {boolean} True if path is safe and within rootDir
  */
 export function validatePath(targetPath, rootDir) {
-  // Reject null bytes (null byte injection attack)
+  // Reject null bytes (injection attack vector)
   if (targetPath.includes('\0') || targetPath.includes('%00')) {
     return false;
   }
 
-  // Reject absolute paths (e.g., /etc/passwd)
+  // Reject absolute paths
   if (path.isAbsolute(targetPath)) {
     return false;
   }
@@ -27,22 +27,19 @@ export function validatePath(targetPath, rootDir) {
     return false;
   }
 
-  const fullPath = path.join(rootDir, targetPath);
-  const resolved = path.resolve(fullPath);
+  // Verify resolved path stays within root directory
+  const resolved = path.resolve(rootDir, targetPath);
   const resolvedRoot = path.resolve(rootDir);
 
-  // Check if the resolved path starts with the root directory
   return resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path.sep);
 }
 
 /**
- * Get relative path from root
- * @param {string} fullPath - Full path
+ * Convert absolute path to relative path with forward slashes
+ * @param {string} fullPath - Absolute file path
  * @param {string} rootDir - Root directory
- * @returns {string} Relative path with forward slashes
+ * @returns {string} Relative path using forward slashes
  */
 export function getRelativePath(fullPath, rootDir) {
   return path.relative(rootDir, fullPath).split(path.sep).join('/');
 }
-
-export default { validatePath, getRelativePath };

package/src/watcher.js

@@ -6,6 +6,30 @@ import chokidar from 'chokidar';
 import path from 'path';
 import { renderFile } from './rendering/index.js';
 
+const IGNORED_PATTERNS = [
+  /(^|[\/\\])\../,  // Dotfiles
+  /node_modules/,
+  /\.git/,
+  /__pycache__/,
+  /\.pyc$/,
+  /\.cache/,
+  /\.pytest_cache/,
+  /\.mypy_cache/,
+  /\.ruff_cache/,
+  /venv/,
+  /\.venv/,
+  /dist/,
+  /build/,
+  /\.next/,
+  /\.nuxt/,
+  /coverage/,
+  /\.DS_Store/,
+  /Thumbs\.db/,
+  /desktop\.ini/,
+];
+
+const TREE_CHANGE_EVENTS = ['add', 'unlink', 'addDir', 'unlinkDir'];
+
 /**
  * Setup file watcher
  * @param {string} rootDir - Root directory to watch
@@ -14,32 +38,7 @@ import { renderFile } from './rendering/index.js';
  */
 export function setupWatcher(rootDir, wss) {
   const watcher = chokidar.watch(rootDir, {
-    ignored: [
-      /(^|[\/\\])\../,  // Ignore dotfiles
-      /node_modules/,
-      /\.git/,
-      /__pycache__/,
-      /\.pyc$/,
-      // Python cache/build
-      /\.cache/,
-      /\.pytest_cache/,
-      /\.mypy_cache/,
-      /\.ruff_cache/,
-      /venv/,
-      /\.venv/,
-      // Build outputs
-      /dist/,
-      /build/,
-      // Framework specific
-      /\.next/,
-      /\.nuxt/,
-      // Test coverage
-      /coverage/,
-      // OS generated files
-      /\.DS_Store/,
-      /Thumbs\.db/,
-      /desktop\.ini/,
-    ],
+    ignored: IGNORED_PATTERNS,
     persistent: true,
     ignoreInitial: true,
     awaitWriteFinish: {
@@ -48,20 +47,22 @@ export function setupWatcher(rootDir, wss) {
     }
   });
 
-  // Helper to get relative path
-  const getRelativePath = (filePath) => {
+  function toRelativePath(filePath) {
     return path.relative(rootDir, filePath).split(path.sep).join('/');
-  };
+  }
+
+  function broadcastTreeUpdate() {
+    wss.broadcast({
+      type: 'tree_update',
+      tree: null
+    });
+  }
 
-  // File change handler
   watcher.on('change', async (filePath) => {
-    const relativePath = getRelativePath(filePath);
+    const relativePath = toRelativePath(filePath);
 
     try {
-      // Render the file content
       const rendered = await renderFile(filePath);
-
-      // Broadcast to clients watching this file
       wss.broadcastFileUpdate(relativePath, {
         type: 'file_update',
         path: relativePath,
@@ -72,20 +73,9 @@ export function setupWatcher(rootDir, wss) {
     }
   });
 
-  // Tree change handlers
-  const broadcastTreeUpdate = async () => {
-    // We'll implement getFileTree in api/tree.js
-    // For now, just notify clients to refresh
-    wss.broadcast({
-      type: 'tree_update',
-      tree: null // Client will fetch via API
-    });
-  };
-
-  watcher.on('add', broadcastTreeUpdate);
-  watcher.on('unlink', broadcastTreeUpdate);
-  watcher.on('addDir', broadcastTreeUpdate);
-  watcher.on('unlinkDir', broadcastTreeUpdate);
+  for (const event of TREE_CHANGE_EVENTS) {
+    watcher.on(event, broadcastTreeUpdate);
+  }
 
   watcher.on('error', (err) => {
     console.error('Watcher error:', err);

package/src/websocket.js

@@ -2,7 +2,16 @@
  * WebSocket management for MDV
  */
 
-import { WebSocketServer } from 'ws';
+import { WebSocketServer, WebSocket } from 'ws';
+
+/**
+ * Check if a WebSocket client is ready to receive messages
+ * @param {WebSocket} client - WebSocket client
+ * @returns {boolean} True if client is open and ready
+ */
+function isClientReady(client) {
+  return client.readyState === WebSocket.OPEN;
+}
 
 /**
  * Setup WebSocket server
@@ -11,8 +20,6 @@ import { WebSocketServer } from 'ws';
  */
 export function setupWebSocket(server) {
   const wss = new WebSocketServer({ server });
-
-  // Track watched files per client
   const clientWatches = new Map();
 
   wss.on('connection', (ws) => {
@@ -23,7 +30,6 @@ export function setupWebSocket(server) {
         const message = JSON.parse(data.toString());
 
         if (message.type === 'watch') {
-          // Client wants to watch a file
           const watches = clientWatches.get(ws);
           watches.clear();
           watches.add(message.path);
@@ -43,30 +49,28 @@ export function setupWebSocket(server) {
     });
   });
 
-  // Add broadcast helper
   wss.broadcast = (data) => {
     const message = JSON.stringify(data);
     wss.clients.forEach((client) => {
-      if (client.readyState === 1) { // WebSocket.OPEN
+      if (isClientReady(client)) {
         client.send(message);
       }
     });
   };
 
-  // Add targeted broadcast for file updates
   wss.broadcastFileUpdate = (filePath, data) => {
     const message = JSON.stringify(data);
     wss.clients.forEach((client) => {
-      if (client.readyState === 1) {
-        const watches = clientWatches.get(client);
-        if (watches && watches.has(filePath)) {
-          client.send(message);
-        }
+      if (!isClientReady(client)) {
+        return;
+      }
+      const watches = clientWatches.get(client);
+      if (watches && watches.has(filePath)) {
+        client.send(message);
       }
     });
   };
 
-  // Store clientWatches for external access
   wss.clientWatches = clientWatches;
 
   return wss;