amalgm 0.1.36 → 0.1.37

package/runtime/scripts/local-gateway.js

@@ -46,12 +46,34 @@ const pty = loadPty();
 const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
 const STATE_FILE = path.join(AMALGM_DIR, 'runtime-state.json');
 const ARTIFACTS_FILE = path.join(AMALGM_DIR, 'artifacts.json');
+const LOG_DIR = path.join(AMALGM_DIR, 'logs');
 const BIND_HOST = process.env.AMALGM_BIND_HOST || '127.0.0.1';
 const OWNER = process.env.AMALGM_RUNTIME_SOURCE || 'local';
 const VERSION = process.env.npm_package_version || process.env.AMALGM_RUNTIME_VERSION || '';
 const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || os.homedir();
 const PORT = Number.parseInt(process.env.AMALGM_GATEWAY_PORT || '28781', 10);
 const RUNTIME_TOKEN_HEADER = 'x-amalgm-runtime-token';
+const DEFAULT_DIAGNOSTIC_LOG_TAIL_BYTES = 256 * 1024;
+const MAX_DIAGNOSTIC_LOG_TAIL_BYTES = 2 * 1024 * 1024;
+
+const DIAGNOSTIC_LOG_FILES = Object.freeze({
+  daemon: 'daemon.log',
+  'chat-server': 'chat-server.log',
+  'local-gateway': 'local-gateway.log',
+  'amalgm-mcp': 'amalgm-mcp.log',
+  'fs-watcher': 'fs-watcher.log',
+  'port-monitor': 'port-monitor.log',
+});
+
+const DIAGNOSTIC_LOG_ALIASES = Object.freeze({
+  chat: 'chat-server',
+  mcp: 'amalgm-mcp',
+  gateway: 'local-gateway',
+  events: 'daemon',
+  'event-tunnel': 'daemon',
+  'chat-tunnel': 'daemon',
+  tunnel: 'daemon',
+});
 
 const SERVICE_PORTS = {
   gateway: PORT,
@@ -314,6 +336,137 @@ function sendJson(res, statusCode, payload) {
   res.end(JSON.stringify(payload));
 }
 
+function diagnosticLogServices() {
+  return Object.keys(DIAGNOSTIC_LOG_FILES);
+}
+
+function normalizeDiagnosticLogService(value) {
+  let service = String(value || 'daemon').trim().toLowerCase();
+  if (service.endsWith('.log')) service = service.slice(0, -4);
+  service = service.replace(/[^a-z0-9_-]/g, '');
+  return DIAGNOSTIC_LOG_ALIASES[service] || service;
+}
+
+function parseDiagnosticTailBytes(value) {
+  const parsed = Number.parseInt(String(value || ''), 10);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_DIAGNOSTIC_LOG_TAIL_BYTES;
+  return Math.min(parsed, MAX_DIAGNOSTIC_LOG_TAIL_BYTES);
+}
+
+function parseDiagnosticLineLimit(value) {
+  const parsed = Number.parseInt(String(value || ''), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return Math.min(parsed, 5000);
+}
+
+function redactDiagnosticLogContent(content) {
+  return String(content)
+    .replace(/(authorization\s*[:=]\s*)(?:Bearer\s+)?[A-Za-z0-9._~+/=-]{8,}/gi, '$1[REDACTED]')
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{20,}\b/gi, 'Bearer [REDACTED]')
+    .replace(/\b(?:sk|pk|rk|ghp|github_pat|glpat|xox[baprs])[-_][A-Za-z0-9_./+=-]{16,}\b/g, '[REDACTED_TOKEN]')
+    .replace(
+      /((?:api[_-]?key|apikey|token|secret|password|cookie|set-cookie)[^:=\n]{0,32}[:=]\s*["']?)[^\s"',;}]+/gi,
+      '$1[REDACTED]',
+    );
+}
+
+function applyDiagnosticLineLimit(content, lineLimit) {
+  if (!lineLimit) return { content, lineTruncated: false };
+  const lines = String(content).split(/\r?\n/);
+  if (lines.length <= lineLimit) return { content, lineTruncated: false };
+  return {
+    content: lines.slice(-lineLimit).join('\n'),
+    lineTruncated: true,
+  };
+}
+
+async function readDiagnosticLogTail(logPath, maxBytes) {
+  const stats = await fs.promises.stat(logPath);
+  if (!stats.isFile()) {
+    const error = new Error('Diagnostic log path is not a file');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  const bytes = Math.min(stats.size, maxBytes);
+  if (bytes === 0) {
+    return {
+      stats,
+      bytes,
+      content: '',
+      byteTruncated: false,
+    };
+  }
+
+  const handle = await fs.promises.open(logPath, 'r');
+  try {
+    const buffer = Buffer.alloc(bytes);
+    await handle.read(buffer, 0, bytes, stats.size - bytes);
+    return {
+      stats,
+      bytes,
+      content: buffer.toString('utf8'),
+      byteTruncated: stats.size > bytes,
+    };
+  } finally {
+    await handle.close();
+  }
+}
+
+async function handleDiagnosticLogs(req, res, url) {
+  if (req.method !== 'GET') {
+    res.writeHead(405, { Allow: 'GET' });
+    res.end();
+    return;
+  }
+
+  const service = normalizeDiagnosticLogService(
+    url.searchParams.get('service') || url.searchParams.get('name'),
+  );
+  const filename = DIAGNOSTIC_LOG_FILES[service];
+  if (!filename) {
+    sendJson(res, 400, {
+      error: 'Unknown diagnostic log service',
+      availableServices: diagnosticLogServices(),
+    });
+    return;
+  }
+
+  const tailBytes = parseDiagnosticTailBytes(url.searchParams.get('tailBytes'));
+  const lineLimit = parseDiagnosticLineLimit(url.searchParams.get('lines'));
+  const logPath = path.join(LOG_DIR, filename);
+
+  try {
+    const tail = await readDiagnosticLogTail(logPath, tailBytes);
+    const lineLimited = applyDiagnosticLineLimit(tail.content, lineLimit);
+    sendJson(res, 200, {
+      service,
+      path: logPath,
+      exists: true,
+      size: tail.stats.size,
+      mtime: tail.stats.mtime.toISOString(),
+      tailBytes: tail.bytes,
+      truncated: tail.byteTruncated || lineLimited.lineTruncated,
+      content: redactDiagnosticLogContent(lineLimited.content),
+    });
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      sendJson(res, 404, {
+        service,
+        path: logPath,
+        exists: false,
+        error: 'Diagnostic log file not found',
+      });
+      return;
+    }
+    const status = typeof error?.statusCode === 'number' ? error.statusCode : 500;
+    sendJson(res, status, {
+      service,
+      error: error instanceof Error ? error.message : 'Failed to read diagnostic log',
+    });
+  }
+}
+
 async function readBody(req) {
   const chunks = [];
   for await (const chunk of req) chunks.push(Buffer.from(chunk));
@@ -760,6 +913,11 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === '/diagnostics/logs') {
+      await handleDiagnosticLogs(req, res, url);
+      return;
+    }
+
     if (url.pathname === '/pty/session' || url.pathname === '/pty/resize') {
       await handlePtyHttp(req, res, url.pathname);
       return;