thanh-kit 2.5.0 → 2.5.1

package/templates/skills/markdown-novel-viewer/scripts/lib/process-mgr.cjs

@@ -0,0 +1,150 @@
+/**
+ * Process manager - handles PID files and server lifecycle
+ * Used by markdown-novel-viewer server
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PID_DIR = '/tmp';
+const PID_PREFIX = 'md-novel-viewer-';
+
+/**
+ * Get PID file path for a port
+ * @param {number} port - Server port
+ * @returns {string} - PID file path
+ */
+function getPidFilePath(port) {
+  return path.join(PID_DIR, `${PID_PREFIX}${port}.pid`);
+}
+
+/**
+ * Write PID file for running server
+ * @param {number} port - Server port
+ * @param {number} pid - Process ID
+ */
+function writePidFile(port, pid) {
+  const pidPath = getPidFilePath(port);
+  fs.writeFileSync(pidPath, String(pid));
+}
+
+/**
+ * Read PID from file
+ * @param {number} port - Server port
+ * @returns {number|null} - PID or null if not found
+ */
+function readPidFile(port) {
+  const pidPath = getPidFilePath(port);
+  if (fs.existsSync(pidPath)) {
+    const pid = fs.readFileSync(pidPath, 'utf8').trim();
+    return parseInt(pid, 10);
+  }
+  return null;
+}
+
+/**
+ * Remove PID file
+ * @param {number} port - Server port
+ */
+function removePidFile(port) {
+  const pidPath = getPidFilePath(port);
+  if (fs.existsSync(pidPath)) {
+    fs.unlinkSync(pidPath);
+  }
+}
+
+/**
+ * Find all running server instances
+ * @returns {Array<{port: number, pid: number}>} - Running instances
+ */
+function findRunningInstances() {
+  const instances = [];
+  const files = fs.readdirSync(PID_DIR);
+
+  for (const file of files) {
+    if (file.startsWith(PID_PREFIX) && file.endsWith('.pid')) {
+      const port = parseInt(file.replace(PID_PREFIX, '').replace('.pid', ''), 10);
+      const pid = readPidFile(port);
+      if (pid) {
+        // Check if process is actually running
+        try {
+          process.kill(pid, 0);
+          instances.push({ port, pid });
+        } catch {
+          // Process not running, clean up stale PID file
+          removePidFile(port);
+        }
+      }
+    }
+  }
+
+  return instances;
+}
+
+/**
+ * Stop server by port
+ * @param {number} port - Server port
+ * @returns {boolean} - True if stopped successfully
+ */
+function stopServer(port) {
+  const pid = readPidFile(port);
+  if (!pid) return false;
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    removePidFile(port);
+    return true;
+  } catch {
+    removePidFile(port);
+    return false;
+  }
+}
+
+/**
+ * Stop all running servers
+ * @returns {number} - Number of servers stopped
+ */
+function stopAllServers() {
+  const instances = findRunningInstances();
+  let stopped = 0;
+
+  for (const { port, pid } of instances) {
+    try {
+      process.kill(pid, 'SIGTERM');
+      removePidFile(port);
+      stopped++;
+    } catch {
+      removePidFile(port);
+    }
+  }
+
+  return stopped;
+}
+
+/**
+ * Setup graceful shutdown handlers
+ * @param {number} port - Server port
+ * @param {Function} cleanup - Additional cleanup function
+ */
+function setupShutdownHandlers(port, cleanup) {
+  const handler = (signal) => {
+    if (cleanup) cleanup();
+    removePidFile(port);
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', handler);
+  process.on('SIGINT', handler);
+}
+
+module.exports = {
+  getPidFilePath,
+  writePidFile,
+  readPidFile,
+  removePidFile,
+  findRunningInstances,
+  stopServer,
+  stopAllServers,
+  setupShutdownHandlers,
+  PID_PREFIX
+};

package/templates/skills/markdown-novel-viewer/scripts/server.cjs

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+
+/**
+ * Markdown Novel Viewer Server
+ * Background HTTP server rendering markdown files with calm, book-like UI
+ *
+ * Universal viewer - pass ANY path and view it:
+ * - Markdown files → novel-reader UI
+ * - Directories → file listing browser
+ *
+ * Usage:
+ *   node server.cjs --file ./plan.md [--port 3456] [--no-open] [--stop] [--host 0.0.0.0]
+ *   node server.cjs --dir ./plans [--port 3456]  # Browse directory
+ *
+ * Options:
+ *   --file <path>   Path to markdown file
+ *   --dir <path>    Path to directory (browse mode)
+ *   --port <number> Server port (default: 3456, auto-increment if busy)
+ *   --host <addr>   Host to bind (default: localhost, use 0.0.0.0 for all interfaces)
+ *   --no-open       Disable auto-open browser (opens by default)
+ *   --stop          Stop all running servers
+ *   --background    Run in background (detached) - legacy mode
+ *   --foreground    Run in foreground (for CC background tasks)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+
+const { findAvailablePort, DEFAULT_PORT } = require('./lib/port-finder.cjs');
+const { writePidFile, stopAllServers, setupShutdownHandlers, findRunningInstances } = require('./lib/process-mgr.cjs');
+const { createHttpServer } = require('./lib/http-server.cjs');
+const { renderMarkdownFile, renderTOCHtml } = require('./lib/markdown-renderer.cjs');
+const { generateNavSidebar, generateNavFooter, detectPlan, getNavigationContext } = require('./lib/plan-navigator.cjs');
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(argv) {
+  const args = {
+    file: null,
+    dir: null,
+    port: DEFAULT_PORT,
+    host: 'localhost',
+    open: true,  // Auto-open browser by default
+    stop: false,
+    background: false,
+    foreground: false,
+    isChild: false
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--file' && argv[i + 1]) {
+      args.file = argv[++i];
+    } else if (arg === '--dir' && argv[i + 1]) {
+      args.dir = argv[++i];
+    } else if (arg === '--port' && argv[i + 1]) {
+      args.port = parseInt(argv[++i], 10);
+    } else if (arg === '--host' && argv[i + 1]) {
+      args.host = argv[++i];
+    } else if (arg === '--open') {
+      args.open = true;
+    } else if (arg === '--no-open') {
+      args.open = false;
+    } else if (arg === '--stop') {
+      args.stop = true;
+    } else if (arg === '--background') {
+      args.background = true;
+    } else if (arg === '--foreground') {
+      args.foreground = true;
+    } else if (arg === '--child') {
+      args.isChild = true;
+    } else if (!arg.startsWith('--') && !args.file && !args.dir) {
+      // Positional argument - could be file or directory
+      args.file = arg;
+    }
+  }
+
+  return args;
+}
+
+/**
+ * Resolve input path - simple logic, no smart detection
+ * @param {string} input - Input path
+ * @param {string} cwd - Current working directory
+ * @returns {{type: 'file'|'directory'|null, path: string|null}}
+ */
+function resolveInput(input, cwd) {
+  if (!input) return { type: null, path: null };
+
+  // Resolve relative to CWD
+  const resolved = path.isAbsolute(input) ? input : path.resolve(cwd, input);
+
+  if (!fs.existsSync(resolved)) {
+    return { type: null, path: null };
+  }
+
+  const stats = fs.statSync(resolved);
+
+  // File mode
+  if (stats.isFile()) {
+    return { type: 'file', path: resolved };
+  }
+
+  // Directory mode - browse, no auto-detection of plan.md
+  if (stats.isDirectory()) {
+    return { type: 'directory', path: resolved };
+  }
+
+  return { type: null, path: null };
+}
+
+/**
+ * Open browser with URL
+ */
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+
+  if (platform === 'darwin') {
+    cmd = `open "${url}"`;
+  } else if (platform === 'win32') {
+    // On Windows, start command treats first quoted arg as window title
+    // Use empty title "" before the URL to prevent this
+    cmd = `start "" "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
+  }
+
+  try {
+    execSync(cmd, { stdio: 'ignore' });
+  } catch {
+    // Ignore browser open errors
+  }
+}
+
+/**
+ * Generate full HTML page from markdown
+ */
+function generateFullPage(filePath, assetsDir) {
+  const { html, toc, frontmatter, title } = renderMarkdownFile(filePath);
+  const tocHtml = renderTOCHtml(toc);
+  const navSidebar = generateNavSidebar(filePath);
+  const navFooter = generateNavFooter(filePath);
+  const planInfo = detectPlan(filePath);
+  const navContext = getNavigationContext(filePath);
+
+  // Read template
+  const templatePath = path.join(assetsDir, 'template.html');
+  let template = fs.readFileSync(templatePath, 'utf8');
+
+  // Generate back button (links to parent directory browser)
+  const parentDir = path.dirname(filePath);
+  const backButton = `
+    <a href="/browse?dir=${encodeURIComponent(parentDir)}" class="icon-btn back-btn" title="Back to folder">
+      <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+        <path d="M19 12H5M12 19l-7-7 7-7"/>
+      </svg>
+    </a>`;
+
+  // Generate header nav (prev/next) for plan files
+  let headerNav = '';
+  if (navContext.prev || navContext.next) {
+    const prevBtn = navContext.prev && fs.existsSync(navContext.prev.file)
+      ? `<a href="/view?file=${encodeURIComponent(navContext.prev.file)}" class="header-nav-btn prev" title="${navContext.prev.name}">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M15 18l-6-6 6-6"/></svg>
+          <span>Prev</span>
+        </a>`
+      : '';
+    const nextBtn = navContext.next && fs.existsSync(navContext.next.file)
+      ? `<a href="/view?file=${encodeURIComponent(navContext.next.file)}" class="header-nav-btn next" title="${navContext.next.name}">
+          <span>Next</span>
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M9 18l6-6-6-6"/></svg>
+        </a>`
+      : '';
+    headerNav = `<div class="header-nav">${prevBtn}${nextBtn}</div>`;
+  }
+
+  // Replace placeholders
+  template = template
+    .replace(/\{\{title\}\}/g, title)
+    .replace('{{toc}}', tocHtml)
+    .replace('{{nav-sidebar}}', navSidebar)
+    .replace('{{nav-footer}}', navFooter)
+    .replace('{{content}}', html)
+    .replace('{{has-plan}}', planInfo.isPlan ? 'has-plan' : '')
+    .replace('{{frontmatter}}', JSON.stringify(frontmatter || {}))
+    .replace('{{back-button}}', backButton)
+    .replace('{{header-nav}}', headerNav);
+
+  return template;
+}
+
+/**
+ * Get local network IP address for remote access
+ * @returns {string|null} - Local IP or null if not found
+ */
+function getLocalIP() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      // Skip internal (loopback) and non-IPv4 addresses
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Build URL with query parameters (fixes path conflicts)
+ * @returns {{url: string, networkUrl: string|null}} - Local and network URLs
+ */
+function buildUrl(host, port, type, filePath) {
+  const displayHost = host === '0.0.0.0' ? 'localhost' : host;
+  const baseUrl = `http://${displayHost}:${port}`;
+
+  let urlPath = '';
+  if (type === 'file') {
+    urlPath = `/view?file=${encodeURIComponent(filePath)}`;
+  } else if (type === 'directory') {
+    urlPath = `/browse?dir=${encodeURIComponent(filePath)}`;
+  }
+
+  const url = baseUrl + urlPath;
+
+  // If binding to all interfaces, provide network URL for remote access
+  let networkUrl = null;
+  if (host === '0.0.0.0') {
+    const localIP = getLocalIP();
+    if (localIP) {
+      networkUrl = `http://${localIP}:${port}${urlPath}`;
+    }
+  }
+
+  return { url, networkUrl };
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const args = parseArgs(process.argv);
+  const cwd = process.cwd();
+  const assetsDir = path.join(__dirname, '..', 'assets');
+
+  // Handle --stop
+  if (args.stop) {
+    const instances = findRunningInstances();
+    if (instances.length === 0) {
+      console.log('No server running to stop');
+      process.exit(0);
+    }
+    const stopped = stopAllServers();
+    console.log(`Stopped ${stopped} server(s)`);
+    process.exit(0);
+  }
+
+  // Determine input
+  const input = args.dir || args.file;
+
+  // Validate input
+  if (!input) {
+    console.error('Error: --file or --dir argument required');
+    console.error('Usage:');
+    console.error('  node server.cjs --file <path.md> [--port 3456] [--open]');
+    console.error('  node server.cjs --dir <path> [--port 3456] [--open]  # Browse directory');
+    process.exit(1);
+  }
+
+  // Resolve input path - simple logic
+  let resolved = resolveInput(input, cwd);
+
+  // If --dir was explicitly used, force directory mode
+  if (args.dir && resolved.type === null) {
+    const dirPath = path.isAbsolute(args.dir) ? args.dir : path.resolve(cwd, args.dir);
+    if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+      resolved = { type: 'directory', path: dirPath };
+    }
+  }
+
+  if (resolved.type === null) {
+    console.error(`Error: Invalid path: ${input}`);
+    console.error('Path must be a file or directory.');
+    process.exit(1);
+  }
+
+  // Background mode - spawn child and exit (legacy mode for manual runs)
+  // Skip if --foreground is set (for Claude Code background tasks)
+  if (args.background && !args.foreground && !args.isChild) {
+    const childArgs = ['--port', String(args.port), '--host', args.host, '--child'];
+    if (resolved.type === 'file') {
+      childArgs.unshift('--file', resolved.path);
+    } else {
+      childArgs.unshift('--dir', resolved.path);
+    }
+    if (args.open) childArgs.push('--open');
+
+    const child = spawn(process.execPath, [__filename, ...childArgs], {
+      detached: true,
+      stdio: 'ignore',
+      cwd: cwd
+    });
+    child.unref();
+
+    // Wait briefly for child to start
+    await new Promise(r => setTimeout(r, 500));
+
+    // Find the port the child is using
+    const instances = findRunningInstances();
+    const instance = instances.find(i => i.port >= args.port);
+    const port = instance ? instance.port : args.port;
+
+    const { url, networkUrl } = buildUrl(args.host, port, resolved.type, resolved.path);
+
+    const result = {
+      success: true,
+      url,
+      path: resolved.path,
+      port,
+      host: args.host,
+      mode: resolved.type
+    };
+    if (networkUrl) result.networkUrl = networkUrl;
+
+    console.log(JSON.stringify(result));
+
+    process.exit(0);
+  }
+
+  // Find available port
+  const port = await findAvailablePort(args.port);
+  if (port !== args.port) {
+    console.error(`Port ${args.port} in use, using ${port}`);
+  }
+
+  // Determine allowed directories for security
+  const allowedDirs = [assetsDir, cwd];
+  if (resolved.path) {
+    const targetDir = resolved.type === 'file' ? path.dirname(resolved.path) : resolved.path;
+    if (!allowedDirs.includes(targetDir)) {
+      allowedDirs.push(targetDir);
+    }
+  }
+
+  // Create server
+  const server = createHttpServer({
+    assetsDir,
+    renderMarkdown: (fp) => generateFullPage(fp, assetsDir),
+    allowedDirs
+  });
+
+  // Start server
+  server.listen(port, args.host, () => {
+    const { url, networkUrl } = buildUrl(args.host, port, resolved.type, resolved.path);
+
+    // Write PID file
+    writePidFile(port, process.pid);
+
+    // Setup shutdown handlers
+    setupShutdownHandlers(port, () => {
+      server.close();
+    });
+
+    // Output for CLI/command integration
+    // In foreground mode (CC background task), always output JSON
+    if (args.foreground || args.isChild || process.env.CLAUDE_COMMAND) {
+      const result = {
+        success: true,
+        url,
+        path: resolved.path,
+        port,
+        host: args.host,
+        mode: resolved.type
+      };
+      if (networkUrl) result.networkUrl = networkUrl;
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(`\nMarkdown Novel Viewer`);
+      console.log(`${'─'.repeat(40)}`);
+      console.log(`URL: ${url}`);
+      if (networkUrl) {
+        console.log(`Network: ${networkUrl}`);
+      }
+      console.log(`Path: ${resolved.path}`);
+      console.log(`Port: ${port}`);
+      console.log(`Host: ${args.host}`);
+      console.log(`Mode: ${resolved.type === 'file' ? 'File Viewer' : 'Directory Browser'}`);
+      console.log(`\nPress Ctrl+C to stop\n`);
+    }
+
+    // Open browser
+    if (args.open) {
+      openBrowser(url);
+    }
+  });
+
+  server.on('error', (err) => {
+    console.error(`Server error: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// Run
+main().catch(err => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});