agent-reader 1.0.0

package/src/utils/output.js

@@ -0,0 +1,85 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const DEFAULT_ROOT = path.join(os.tmpdir(), 'agent-reader');
+
+function sanitizeName(name) {
+  const value = String(name || 'output').trim();
+  return value.replace(/[^a-zA-Z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'output';
+}
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+export function getOutputRoot(outDir) {
+  return outDir ? path.resolve(outDir) : DEFAULT_ROOT;
+}
+
+export async function createOutputDir(name = 'output', outDir) {
+  const rootDir = getOutputRoot(outDir);
+  await ensureDir(rootDir);
+
+  const shortId = randomUUID().slice(0, 8);
+  const dirName = `${sanitizeName(path.parse(name).name)}-${shortId}`;
+  const finalDir = path.join(rootDir, dirName);
+  await ensureDir(finalDir);
+
+  return finalDir;
+}
+
+async function getDirSize(targetPath) {
+  const stat = await fs.stat(targetPath);
+  if (!stat.isDirectory()) {
+    return stat.size;
+  }
+
+  let total = 0;
+  const entries = await fs.readdir(targetPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path.join(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      total += await getDirSize(entryPath);
+    } else if (entry.isFile()) {
+      const fileStat = await fs.stat(entryPath);
+      total += fileStat.size;
+    }
+  }
+
+  return total;
+}
+
+export async function cleanOldOutputs(maxAgeDays = 7, outDir) {
+  const rootDir = getOutputRoot(outDir);
+  await ensureDir(rootDir);
+
+  const cutoffMs = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+  const entries = await fs.readdir(rootDir, { withFileTypes: true });
+
+  let deletedCount = 0;
+  let reclaimedBytes = 0;
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const fullPath = path.join(rootDir, entry.name);
+    const stat = await fs.stat(fullPath);
+    if (stat.mtimeMs > cutoffMs) {
+      continue;
+    }
+
+    reclaimedBytes += await getDirSize(fullPath);
+    await fs.rm(fullPath, { recursive: true, force: true });
+    deletedCount += 1;
+  }
+
+  return {
+    deletedCount,
+    reclaimedBytes,
+    rootDir,
+  };
+}

package/src/utils/preferences.js

@@ -0,0 +1,89 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const CONFIG_DIR = path.join(os.homedir(), '.agent-reader');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'preferences.json');
+
+const MODE_ALIASES = {
+  auto: 'auto',
+  web: 'web',
+  html: 'web',
+  browser: 'web',
+  word: 'word',
+  docx: 'word',
+  pdf: 'pdf',
+  ppt: 'ppt',
+  slides: 'ppt',
+  slideshow: 'ppt',
+  presentation: 'ppt',
+};
+
+const DEFAULT_PREFERENCES = {
+  default_open_mode: 'web',
+  default_theme: 'light',
+};
+
+function sanitizeTheme(theme) {
+  const value = typeof theme === 'string' ? theme.trim() : '';
+  return value || DEFAULT_PREFERENCES.default_theme;
+}
+
+export function normalizeOpenMode(mode, fallback = 'auto') {
+  const key = String(mode || '').trim().toLowerCase();
+  if (!key) {
+    return fallback;
+  }
+  return MODE_ALIASES[key] || fallback;
+}
+
+export function getPreferencesPath() {
+  return CONFIG_PATH;
+}
+
+export async function ensurePreferencesDir() {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+}
+
+export function sanitizePreferences(input = {}) {
+  return {
+    default_open_mode: normalizeOpenMode(input.default_open_mode, DEFAULT_PREFERENCES.default_open_mode),
+    default_theme: sanitizeTheme(input.default_theme),
+  };
+}
+
+export async function loadPreferences() {
+  await ensurePreferencesDir();
+
+  let parsed = {};
+  try {
+    const raw = await fs.readFile(CONFIG_PATH, 'utf8');
+    parsed = JSON.parse(raw);
+  } catch {
+    parsed = {};
+  }
+
+  return {
+    ...DEFAULT_PREFERENCES,
+    ...sanitizePreferences(parsed),
+  };
+}
+
+export async function savePreferences(preferences) {
+  const finalPreferences = {
+    ...DEFAULT_PREFERENCES,
+    ...sanitizePreferences(preferences),
+  };
+
+  await ensurePreferencesDir();
+  await fs.writeFile(CONFIG_PATH, `${JSON.stringify(finalPreferences, null, 2)}\n`, 'utf8');
+  return finalPreferences;
+}
+
+export async function updatePreferences(partial) {
+  const current = await loadPreferences();
+  return savePreferences({
+    ...current,
+    ...partial,
+  });
+}

package/src/utils/server.js

@@ -0,0 +1,295 @@
+import http from 'node:http';
+import net from 'node:net';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { exportDOCXFromHTML, exportPDF } from '../core/exporter.js';
+
+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',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+  '.ico': 'image/x-icon',
+  '.pdf': 'application/pdf',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+};
+
+function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || 'application/octet-stream';
+}
+
+function normalizePath(requestPath) {
+  const decoded = decodeURIComponent(requestPath);
+  return decoded.split('?')[0].split('#')[0];
+}
+
+function createHttpError(statusCode, message) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}
+
+function isPathInside(rootDir, candidatePath) {
+  const normalizedRoot = rootDir.endsWith(path.sep) ? rootDir : `${rootDir}${path.sep}`;
+  return candidatePath === rootDir || candidatePath.startsWith(normalizedRoot);
+}
+
+async function resolvePathFromRequest(rootDir, requestPath) {
+  const relativePath = requestPath === '/' ? '/index.html' : requestPath;
+  const candidate = path.resolve(rootDir, `.${relativePath}`);
+
+  if (!isPathInside(rootDir, candidate)) {
+    throw createHttpError(403, 'Forbidden');
+  }
+
+  const stat = await fs.stat(candidate).catch(() => null);
+  if (!stat) {
+    throw createHttpError(404, 'Not Found');
+  }
+
+  if (stat.isDirectory()) {
+    const indexPath = path.join(candidate, 'index.html');
+    const indexStat = await fs.stat(indexPath).catch(() => null);
+    if (!indexStat) {
+      throw createHttpError(404, 'Not Found');
+    }
+    return indexPath;
+  }
+
+  return candidate;
+}
+
+function sendJson(res, statusCode, payload) {
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store',
+  });
+  res.end(JSON.stringify(payload));
+}
+
+async function resolveExportSourcePath(req, rootDir, sourceParam) {
+  const fromQuery = sourceParam ? normalizePath(sourceParam) : null;
+
+  if (fromQuery) {
+    return resolvePathFromRequest(rootDir, fromQuery);
+  }
+
+  const referer = req.headers.referer;
+  if (typeof referer === 'string' && referer.length > 0) {
+    try {
+      const refererUrl = new URL(referer);
+      return resolvePathFromRequest(rootDir, normalizePath(refererUrl.pathname));
+    } catch {
+      throw createHttpError(400, 'invalid referer url');
+    }
+  }
+
+  throw createHttpError(400, 'missing source path');
+}
+
+async function handleExportRequest(req, res, rootDir, urlObject) {
+  if (req.method !== 'GET') {
+    sendJson(res, 405, { error: 'method not allowed' });
+    return;
+  }
+
+  const format = String(urlObject.searchParams.get('format') || '').toLowerCase();
+  if (!['pdf', 'docx'].includes(format)) {
+    sendJson(res, 400, { error: 'missing or invalid export format' });
+    return;
+  }
+
+  try {
+    const sourceParam = urlObject.searchParams.get('source');
+    const sourcePath = await resolveExportSourcePath(req, rootDir, sourceParam);
+    const sourceExt = path.extname(sourcePath).toLowerCase();
+    if (sourceExt !== '.html') {
+      throw createHttpError(400, 'source must be an html file');
+    }
+
+    const sourceHtml = await fs.readFile(sourcePath, 'utf8');
+    const sourceDir = path.dirname(sourcePath);
+    const rawName = path.parse(sourcePath).name || 'document';
+    const dirBaseName = path.basename(sourceDir) || 'document';
+    const cleanDirName = dirBaseName.replace(/-[a-f0-9]{8}$/, '') || dirBaseName;
+    const sourceName = rawName.startsWith('_') ? cleanDirName : rawName;
+
+    let outputPath;
+    let warnings = [];
+
+    if (format === 'pdf') {
+      const isLandscape = sourceHtml.includes('size: A4 landscape') || sourceHtml.includes('size:A4 landscape');
+      const result = await exportPDF(sourceHtml, {
+        outDir: sourceDir,
+        fileName: `${sourceName}.pdf`,
+        htmlPath: sourcePath,
+        landscape: isLandscape,
+      });
+      outputPath = result.pdfPath;
+      warnings = result.warnings || [];
+    } else {
+      const result = await exportDOCXFromHTML(sourceHtml, {
+        htmlPath: sourcePath,
+        baseDir: sourceDir,
+        outDir: sourceDir,
+        fileName: `${sourceName}.docx`,
+      });
+      outputPath = result.docxPath;
+      warnings = result.warnings || [];
+    }
+
+    const output = await fs.readFile(outputPath);
+    const warningHeader = warnings.length ? warnings.join(' | ') : '';
+
+    res.writeHead(200, {
+      'Content-Type': getMimeType(outputPath),
+      'Content-Disposition': `attachment; filename="${path.basename(outputPath)}"`,
+      'Cache-Control': 'no-store',
+      ...(warningHeader ? { 'X-Agent-Reader-Warnings': warningHeader } : {}),
+    });
+    res.end(output);
+  } catch (error) {
+    const statusCode = Number(error?.statusCode) || 500;
+    sendJson(res, statusCode, { error: error.message || 'export failed' });
+  }
+}
+
+async function isPortInUse(host, port) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let settled = false;
+
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.destroy();
+      resolve(value);
+    };
+
+    socket.setTimeout(200);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', (error) => {
+      if (error.code === 'ECONNREFUSED' || error.code === 'EHOSTUNREACH') {
+        finish(false);
+        return;
+      }
+      finish(true);
+    });
+
+    socket.connect(port, host);
+  });
+}
+
+export async function startStaticServer(rootDir, { host = '127.0.0.1', port = 3000 } = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+
+  const server = http.createServer(async (req, res) => {
+    const urlObject = new URL(req.url || '/', `http://${host}:${port}`);
+    try {
+      if (urlObject.pathname === '/api/export') {
+        await handleExportRequest(req, res, absoluteRoot, urlObject);
+        return;
+      }
+
+      const reqPath = normalizePath(urlObject.pathname);
+      const target = await resolvePathFromRequest(absoluteRoot, reqPath);
+
+      const content = await fs.readFile(target);
+      res.writeHead(200, {
+        'Content-Type': getMimeType(target),
+        'Cache-Control': 'no-store',
+      });
+      res.end(content);
+    } catch (error) {
+      const statusCode = Number(error?.statusCode) || 404;
+      const message = statusCode === 403 ? 'Forbidden' : 'Not Found';
+      res.writeHead(statusCode, { 'Content-Type': 'text/plain; charset=utf-8' });
+      res.end(message);
+    }
+  });
+
+  const actualPort = await new Promise((resolve, reject) => {
+    const tryPort = async (nextPort) => {
+      const occupied = await isPortInUse(host, nextPort);
+      if (occupied) {
+        await tryPort(nextPort + 1);
+        return;
+      }
+
+      const onError = (error) => {
+        server.off('error', onError);
+        if (error.code === 'EADDRINUSE') {
+          void tryPort(nextPort + 1);
+        } else {
+          reject(error);
+        }
+      };
+
+      server.once('error', onError);
+      server.listen({ port: nextPort, host, exclusive: true }, () => {
+        server.off('error', onError);
+        resolve(nextPort);
+      });
+    };
+
+    void tryPort(port);
+  });
+
+  return {
+    host,
+    port: actualPort,
+    url: `http://${host}:${actualPort}`,
+    close: () =>
+      new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      }),
+    server,
+  };
+}
+
+export async function waitForServerExit(serverHandle, timeoutMs = 10 * 60 * 1000) {
+  await new Promise((resolve) => {
+    let finished = false;
+
+    const complete = async () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      await serverHandle.close().catch(() => {});
+      process.off('SIGINT', onSigInt);
+      process.off('SIGTERM', onSigTerm);
+      resolve();
+    };
+
+    const onSigInt = async () => {
+      await complete();
+    };
+    const onSigTerm = async () => {
+      await complete();
+    };
+
+    process.once('SIGINT', onSigInt);
+    process.once('SIGTERM', onSigTerm);
+
+    setTimeout(() => {
+      void complete();
+    }, timeoutMs).unref();
+  });
+}