From 75a4843076314de75ec5ddc5921543822cd05445 Mon Sep 17 00:00:00 2001
From: meenu155 <meenusinghms392@gmail.com>
Date: Wed, 5 Nov 2025 19:38:50 +0530
Subject: [PATCH 1/6] feat(logging): Implement comprehensive logging feature
 across services

- Added logging initialization in scaffold.js for new services.
- Updated documentation to include a new "Service Logs" feature section.
- Created logs-feature.md detailing CLI and web-based log viewing capabilities.
- Enhanced Go service with structured logging and log retrieval endpoint.
- Integrated logging functionality in Node.js service with middleware for request logging.
- Implemented logging in Python FastAPI service with file-based logging.
- Added logging capabilities in Spring Boot service with structured log entries.
---
 bin/index.js                                  |  22 +
 bin/lib/admin.js                              | 414 ++++++++++++-
 bin/lib/logs.js                               | 570 ++++++++++++++++++
 bin/lib/scaffold.js                           |   9 +
 docs/.vitepress/config.mjs                    |   6 +-
 docs/logs-feature.md                          | 218 +++++++
 templates/go/main.go                          | 200 +++++-
 templates/node/src/index.js                   | 117 ++++
 templates/python/app/main.py                  | 148 ++++-
 .../java/com/example/DemoApplication.java     | 146 ++++-
 .../target/classes/application.properties.txt |   1 -
 .../classes/com/example/DemoApplication.class | Bin 1230 -> 0 bytes
 12 files changed, 1835 insertions(+), 16 deletions(-)
 create mode 100644 bin/lib/logs.js
 create mode 100644 docs/logs-feature.md
 delete mode 100644 templates/spring-boot/target/classes/application.properties.txt
 delete mode 100644 templates/spring-boot/target/classes/com/example/DemoApplication.class

diff --git a/bin/index.js b/bin/index.js
index ec252a0..2ce376e 100755
--- a/bin/index.js
+++ b/bin/index.js
@@ -9,6 +9,7 @@ import { renderServicesTable } from './lib/ui.js';
 import { runDev } from './lib/dev.js';
 import { startAdminDashboard } from './lib/admin.js';
 import { runHotReload } from './lib/hotreload.js';
+import { viewLogs } from './lib/logs.js';
  
 const program = new Command();
  
@@ -177,6 +178,27 @@ program
       process.exit(1);
     }
   });
+
+// Service logs viewer and management
+program
+  .command('logs')
+  .description('View and manage service logs')
+  .argument('[service]', 'Specific service name (optional, shows all services if omitted)')
+  .option('-f, --follow', 'Follow log output in real-time')
+  .option('-t, --tail <lines>', 'Number of recent lines to show (default: 50)', '50')
+  .option('--since <time>', 'Show logs since timestamp (ISO format or relative like "1h", "30m")')
+  .option('--filter <pattern>', 'Filter logs by pattern (regex supported)')
+  .option('--level <level>', 'Filter by log level (error, warn, info, debug)')
+  .option('--export <format>', 'Export logs to file (json, csv, txt)')
+  .option('--clear', 'Clear all logs for the specified service(s)')
+  .action(async (serviceName, opts) => {
+    try {
+      await viewLogs(serviceName, opts);
+    } catch (e) {
+      console.error(chalk.red('Failed to view logs:'), e.message);
+      process.exit(1);
+    }
+  });
  
 program.parse();
  
diff --git a/bin/lib/admin.js b/bin/lib/admin.js
index afb1ea6..fee6f3a 100644
--- a/bin/lib/admin.js
+++ b/bin/lib/admin.js
@@ -2,9 +2,109 @@ import fs from 'fs';
 import path from 'path';
 import chalk from 'chalk';
 import http from 'http';
+import crypto from 'crypto';
 import { spawn } from 'node:child_process';
+import { getLogsForAPI } from './logs.js';
  
-// Simple service status checker
+// Simple WebSocket implementation for real-time log streaming
+function handleWebSocketUpgrade(request, socket, head) {
+  const key = request.headers['sec-websocket-key'];
+  if (!key) {
+    socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+    return;
+  }
+  
+  const acceptKey = crypto
+    .createHash('sha1')
+    .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+    .digest('base64');
+  
+  const responseHeaders = [
+    'HTTP/1.1 101 Switching Protocols',
+    'Upgrade: websocket',
+    'Connection: Upgrade',
+    `Sec-WebSocket-Accept: ${acceptKey}`,
+    '\r\n'
+  ].join('\r\n');
+  
+  socket.write(responseHeaders);
+  
+  // Handle WebSocket frames (simplified - only handles text frames)
+  socket.on('data', (buffer) => {
+    // Simple frame parsing for text messages
+    if (buffer.length > 2) {
+      const opcode = buffer[0] & 0x0f;
+      if (opcode === 0x01) { // Text frame
+        let payloadLength = buffer[1] & 0x7f;
+        let maskStart = 2;
+        
+        if (payloadLength === 126) {
+          payloadLength = buffer.readUInt16BE(2);
+          maskStart = 4;
+        } else if (payloadLength === 127) {
+          payloadLength = buffer.readBigUInt64BE(2);
+          maskStart = 10;
+        }
+        
+        const mask = buffer.slice(maskStart, maskStart + 4);
+        const payload = buffer.slice(maskStart + 4, maskStart + 4 + Number(payloadLength));
+        
+        // Unmask payload
+        for (let i = 0; i < payload.length; i++) {
+          payload[i] ^= mask[i % 4];
+        }
+        
+        try {
+          const message = JSON.parse(payload.toString());
+          handleWebSocketMessage(socket, message);
+        } catch (e) {
+          console.error('Invalid WebSocket message:', e.message);
+        }
+      }
+    }
+  });
+  
+  socket.on('close', () => {
+    // Clean up any active log watchers for this socket
+    if (socket.logWatcher) {
+      socket.logWatcher.cleanup();
+    }
+  });
+}
+
+function sendWebSocketMessage(socket, message) {
+  const payload = JSON.stringify(message);
+  const payloadBuffer = Buffer.from(payload);
+  const frame = Buffer.alloc(2 + payloadBuffer.length);
+  
+  frame[0] = 0x81; // FIN + text frame
+  frame[1] = payloadBuffer.length;
+  payloadBuffer.copy(frame, 2);
+  
+  socket.write(frame);
+}
+
+function handleWebSocketMessage(socket, message) {
+  if (message.type === 'start_log_stream') {
+    // Start streaming logs for specified service
+    const serviceName = message.service;
+    // For now, just send initial logs - real streaming would require file watching
+    getLogsForAPI(serviceName, { tail: 50 })
+      .then(logs => {
+        sendWebSocketMessage(socket, {
+          type: 'log_data',
+          service: serviceName,
+          logs: logs
+        });
+      })
+      .catch(err => {
+        sendWebSocketMessage(socket, {
+          type: 'error',
+          message: 'Failed to fetch logs: ' + err.message
+        });
+      });
+  }
+}
 async function checkServiceStatus(service) {
   return new Promise((resolve) => {
     const timeout = setTimeout(() => {
@@ -96,6 +196,27 @@ function generateDashboardHTML(servicesWithStatus, refreshInterval = 5000) {
     .path { font-family:monospace; font-size:.7rem; color:#334155; }
     .footer { margin-top:40px; font-size:.65rem; color:#64748b; text-align:center; }
     .empty { margin-top:80px; text-align:center; font-size:1rem; color:#475569; }
+    
+    /* Logs section styles */
+    .logs-section { margin-top:40px; }
+    .logs-header { display:flex; align-items:center; justify-content:space-between; margin-bottom:16px; }
+    .logs-controls { display:flex; gap:8px; align-items:center; }
+    .logs-controls select, .logs-controls input { padding:4px 8px; border:1px solid #d1d5db; border-radius:4px; font-size:.75rem; }
+    .logs-controls button { padding:4px 12px; background:#0369a1; color:#fff; border:none; border-radius:4px; font-size:.75rem; cursor:pointer; }
+    .logs-controls button:hover { background:#0284c7; }
+    .logs-controls button.secondary { background:#6b7280; }
+    .logs-controls button.secondary:hover { background:#4b5563; }
+    .logs-container { background:#1e293b; color:#e2e8f0; border-radius:6px; padding:16px; height:400px; overflow-y:auto; font-family:monospace; font-size:.75rem; line-height:1.4; }
+    .log-entry { margin-bottom:4px; padding:2px 0; }
+    .log-entry.error { color:#f87171; }
+    .log-entry.warn { color:#fbbf24; }
+    .log-entry.info { color:#60a5fa; }
+    .log-entry.debug { color:#9ca3af; }
+    .log-timestamp { color:#6b7280; }
+    .log-service { color:#a78bfa; font-weight:600; }
+    .log-level { font-weight:600; margin-right:8px; }
+    .logs-empty { text-align:center; color:#6b7280; padding:60px 20px; }
+    
     @media (max-width: 920px) { .layout { flex-direction:column; } .sidebar { width:100%; flex-direction:row; flex-wrap:wrap; } .service-list { display:flex; flex-wrap:wrap; gap:8px; } .service-list li { margin:0; } }
   </style>
   <script>
@@ -177,7 +298,224 @@ function generateDashboardHTML(servicesWithStatus, refreshInterval = 5000) {
     window.addEventListener('DOMContentLoaded', () => {
       scheduleCountdown();
       setTimeout(fetchStatus, REFRESH_MS); // initial schedule
+      initializeLogs();
     });
+    
+    // Logs functionality
+    let currentLogsFilter = {};
+    let logsAutoRefresh = false;
+    let logsRefreshInterval;
+    let wsConnection = null;
+    
+    function initializeLogs() {
+      const refreshBtn = document.querySelector('#logs-refresh');
+      const autoRefreshBtn = document.querySelector('#logs-auto-refresh');
+      const clearBtn = document.querySelector('#logs-clear');
+      const exportBtn = document.querySelector('#logs-export');
+      const streamBtn = document.querySelector('#logs-stream');
+      const serviceFilter = document.querySelector('#logs-service-filter');
+      const levelFilter = document.querySelector('#logs-level-filter');
+      const searchInput = document.querySelector('#logs-search');
+      
+      refreshBtn?.addEventListener('click', fetchLogs);
+      autoRefreshBtn?.addEventListener('click', toggleAutoRefresh);
+      streamBtn?.addEventListener('click', toggleLogStream);
+      clearBtn?.addEventListener('click', clearLogs);
+      exportBtn?.addEventListener('click', exportLogs);
+      serviceFilter?.addEventListener('change', updateLogsFilter);
+      levelFilter?.addEventListener('change', updateLogsFilter);
+      searchInput?.addEventListener('input', debounce(updateLogsFilter, 500));
+      
+      fetchLogs(); // Initial load
+    }
+    
+    function initWebSocket() {
+      if (wsConnection && wsConnection.readyState === WebSocket.OPEN) {
+        return wsConnection;
+      }
+      
+      const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+      const wsUrl = protocol + '//' + location.host + '/ws';
+      
+      wsConnection = new WebSocket(wsUrl);
+      
+      wsConnection.onopen = function() {
+        console.log('WebSocket connected');
+      };
+      
+      wsConnection.onmessage = function(event) {
+        try {
+          const data = JSON.parse(event.data);
+          handleWebSocketMessage(data);
+        } catch (e) {
+          console.error('Failed to parse WebSocket message:', e);
+        }
+      };
+      
+      wsConnection.onclose = function() {
+        console.log('WebSocket disconnected');
+        wsConnection = null;
+      };
+      
+      wsConnection.onerror = function(error) {
+        console.error('WebSocket error:', error);
+      };
+      
+      return wsConnection;
+    }
+    
+    function handleWebSocketMessage(data) {
+      if (data.type === 'log_data') {
+        renderLogs(data.logs);
+      } else if (data.type === 'error') {
+        renderLogsError(data.message);
+      }
+    }
+    
+    function toggleLogStream() {
+      const btn = document.querySelector('#logs-stream');
+      if (!btn) return;
+      
+      if (!wsConnection || wsConnection.readyState !== WebSocket.OPEN) {
+        initWebSocket();
+        btn.textContent = 'Stop Stream';
+        btn.style.background = '#dc2626';
+        
+        // Start streaming for current service filter
+        const serviceFilter = document.querySelector('#logs-service-filter');
+        const service = serviceFilter?.value || null;
+        
+        wsConnection.onopen = function() {
+          wsConnection.send(JSON.stringify({
+            type: 'start_log_stream',
+            service: service
+          }));
+        };
+      } else {
+        wsConnection.close();
+        btn.textContent = 'Live Stream';
+        btn.style.background = '#0369a1';
+      }
+    }
+    
+    function updateLogsFilter() {
+      const serviceFilter = document.querySelector('#logs-service-filter');
+      const levelFilter = document.querySelector('#logs-level-filter');
+      const searchInput = document.querySelector('#logs-search');
+      
+      currentLogsFilter = {
+        service: serviceFilter?.value || '',
+        level: levelFilter?.value || '',
+        filter: searchInput?.value || ''
+      };
+      
+      fetchLogs();
+    }
+    
+    async function fetchLogs() {
+      try {
+        const params = new URLSearchParams();
+        params.set('tail', '100');
+        
+        if (currentLogsFilter.service) params.set('service', currentLogsFilter.service);
+        if (currentLogsFilter.level) params.set('level', currentLogsFilter.level);
+        if (currentLogsFilter.filter) params.set('filter', currentLogsFilter.filter);
+        
+        const res = await fetch('/api/logs?' + params.toString());
+        if (!res.ok) throw new Error('HTTP ' + res.status);
+        
+        const logs = await res.json();
+        renderLogs(logs);
+      } catch (e) {
+        console.error('Failed to fetch logs:', e);
+        renderLogsError('Failed to fetch logs: ' + e.message);
+      }
+    }
+    
+    function renderLogs(logs) {
+      const container = document.querySelector('#logs-container');
+      if (!container) return;
+      
+      if (logs.length === 0) {
+        container.innerHTML = '<div class="logs-empty">No logs found matching the current filters.</div>';
+        return;
+      }
+      
+      const html = logs.map(log => {
+        const timestamp = new Date(log.timestamp).toLocaleTimeString();
+        const levelClass = log.level.toLowerCase();
+        return '<div class="log-entry ' + levelClass + '">' +
+               '<span class="log-timestamp">' + timestamp + '</span> ' +
+               '<span class="log-service">' + log.service.padEnd(10) + '</span> ' +
+               '<span class="log-level ' + levelClass + '">' + log.level.toUpperCase().padEnd(5) + '</span> ' +
+               '<span class="log-message">' + escapeHtml(log.message) + '</span>' +
+               '</div>';
+      }).join('');
+      
+      container.innerHTML = html;
+      container.scrollTop = container.scrollHeight; // Auto-scroll to bottom
+    }
+    
+    function renderLogsError(message) {
+      const container = document.querySelector('#logs-container');
+      if (container) {
+        container.innerHTML = '<div class="logs-empty" style="color:#f87171;">' + escapeHtml(message) + '</div>';
+      }
+    }
+    
+    function toggleAutoRefresh() {
+      const btn = document.querySelector('#logs-auto-refresh');
+      if (!btn) return;
+      
+      logsAutoRefresh = !logsAutoRefresh;
+      
+      if (logsAutoRefresh) {
+        btn.textContent = 'Stop Auto-Refresh';
+        btn.style.background = '#dc2626';
+        logsRefreshInterval = setInterval(fetchLogs, 3000);
+      } else {
+        btn.textContent = 'Auto-Refresh';
+        btn.style.background = '#0369a1';
+        clearInterval(logsRefreshInterval);
+      }
+    }
+    
+    function clearLogs() {
+      if (!confirm('Are you sure you want to clear all logs? This action cannot be undone.')) return;
+      
+      // Note: This would need a backend endpoint to actually clear logs
+      alert('Clear logs functionality would need to be implemented on the backend.');
+    }
+    
+    function exportLogs() {
+      // Create export URL with current filters
+      const params = new URLSearchParams();
+      params.set('tail', '1000'); // Export more logs
+      
+      if (currentLogsFilter.service) params.set('service', currentLogsFilter.service);
+      if (currentLogsFilter.level) params.set('level', currentLogsFilter.level);
+      if (currentLogsFilter.filter) params.set('filter', currentLogsFilter.filter);
+      
+      window.open('/api/logs?' + params.toString(), '_blank');
+    }
+    
+    function escapeHtml(text) {
+      const div = document.createElement('div');
+      div.textContent = text;
+      return div.innerHTML;
+    }
+    
+    function debounce(func, wait) {
+      let timeout;
+      return function executedFunction(...args) {
+        const later = () => {
+          clearTimeout(timeout);
+          func(...args);
+        };
+        clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+      };
+    }
   </script>
 </head>
 <body>
@@ -233,6 +571,36 @@ function generateDashboardHTML(servicesWithStatus, refreshInterval = 5000) {
             </tr>`).join('')}
         </tbody>
       </table>`}
+      
+      <!-- Logs Section -->
+      <div class="logs-section">
+        <div class="logs-header">
+          <h2 style="font-size:1rem; font-weight:600; color:#334155; margin:0;">Service Logs</h2>
+          <div class="logs-controls">
+            <select id="logs-service-filter">
+              <option value="">All Services</option>
+              ${servicesWithStatus.map(s => `<option value="${s.name}">${s.name}</option>`).join('')}
+            </select>
+            <select id="logs-level-filter">
+              <option value="">All Levels</option>
+              <option value="error">Error</option>
+              <option value="warn">Warning</option>
+              <option value="info">Info</option>
+              <option value="debug">Debug</option>
+            </select>
+            <input type="text" id="logs-search" placeholder="Search logs..." style="width:150px;">
+            <button id="logs-refresh">Refresh</button>
+            <button id="logs-auto-refresh" class="secondary">Auto-Refresh</button>
+            <button id="logs-stream" class="secondary">Live Stream</button>
+            <button id="logs-export" class="secondary">Export</button>
+            <button id="logs-clear" class="secondary">Clear</button>
+          </div>
+        </div>
+        <div id="logs-container" class="logs-container">
+          <div class="logs-empty">Loading logs...</div>
+        </div>
+      </div>
+      
       <div class="footer">Polyglot Admin · Generated by create-polyglot</div>
     </main>
   </div>
@@ -261,7 +629,9 @@ export async function startAdminDashboard(options = {}) {
   console.log(chalk.yellow('   Press Ctrl+C to stop\n'));
   
   const server = http.createServer(async (req, res) => {
-    if (req.url === '/api/status') {
+    const url = new URL(req.url, `http://localhost:${port}`);
+    
+    if (url.pathname === '/api/status') {
       // API endpoint for service status
       const servicesWithStatus = await getServicesStatus(cfg.services);
       res.writeHead(200, {
@@ -272,6 +642,37 @@ export async function startAdminDashboard(options = {}) {
       return;
     }
     
+    if (url.pathname === '/api/logs') {
+      // API endpoint for logs
+      try {
+        const serviceName = url.searchParams.get('service');
+        const tail = url.searchParams.get('tail') || '100';
+        const level = url.searchParams.get('level');
+        const since = url.searchParams.get('since');
+        const filter = url.searchParams.get('filter');
+        
+        const logs = await getLogsForAPI(serviceName, {
+          tail: parseInt(tail),
+          level,
+          since,
+          filter
+        });
+        
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*'
+        });
+        res.end(JSON.stringify(logs, null, 2));
+      } catch (e) {
+        res.writeHead(500, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*'
+        });
+        res.end(JSON.stringify({ error: e.message }));
+      }
+      return;
+    }
+    
     // Serve dashboard HTML
     const servicesWithStatus = await getServicesStatus(cfg.services);
     const html = generateDashboardHTML(servicesWithStatus, refreshInterval);
@@ -291,6 +692,15 @@ export async function startAdminDashboard(options = {}) {
     }
   });
   
+  // Handle WebSocket upgrades
+  server.on('upgrade', (request, socket, head) => {
+    if (request.url === '/ws') {
+      handleWebSocketUpgrade(request, socket, head);
+    } else {
+      socket.end();
+    }
+  });
+  
   // Graceful shutdown
   process.on('SIGINT', () => {
     console.log(chalk.yellow('\n🛑 Shutting down Admin Dashboard...'));
diff --git a/bin/lib/logs.js b/bin/lib/logs.js
new file mode 100644
index 0000000..8b4604e
--- /dev/null
+++ b/bin/lib/logs.js
@@ -0,0 +1,570 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+
+// Log levels and their colors
+const LOG_LEVELS = {
+  error: { color: chalk.red, priority: 4 },
+  warn: { color: chalk.yellow, priority: 3 },
+  info: { color: chalk.blue, priority: 2 },
+  debug: { color: chalk.gray, priority: 1 }
+};
+
+// Get logs directory for a service
+function getLogsDir(serviceDir) {
+  return path.join(serviceDir, '.logs');
+}
+
+// Get log file path for a service
+function getLogFile(serviceDir, date = new Date()) {
+  const logsDir = getLogsDir(serviceDir);
+  const dateStr = date.toISOString().split('T')[0]; // YYYY-MM-DD
+  return path.join(logsDir, `${dateStr}.log`);
+}
+
+// Ensure logs directory exists
+function ensureLogsDir(serviceDir) {
+  const logsDir = getLogsDir(serviceDir);
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+  return logsDir;
+}
+
+// Parse time filter (supports relative like "1h", "30m" or ISO timestamps)
+function parseTimeFilter(timeStr) {
+  if (!timeStr) return null;
+  
+  // Check if it's a relative time (e.g., "1h", "30m", "2d")
+  const relativeMatch = timeStr.match(/^(\d+)([hmsd])$/);
+  if (relativeMatch) {
+    const value = parseInt(relativeMatch[1]);
+    const unit = relativeMatch[2];
+    const now = new Date();
+    
+    switch (unit) {
+      case 's': return new Date(now.getTime() - value * 1000);
+      case 'm': return new Date(now.getTime() - value * 60 * 1000);
+      case 'h': return new Date(now.getTime() - value * 60 * 60 * 1000);
+      case 'd': return new Date(now.getTime() - value * 24 * 60 * 60 * 1000);
+    }
+  }
+  
+  // Try to parse as ISO timestamp
+  try {
+    return new Date(timeStr);
+  } catch (e) {
+    throw new Error(`Invalid time format: ${timeStr}. Use ISO format or relative time like "1h", "30m", "2d"`);
+  }
+}
+
+// Parse a log line and extract structured data
+function parseLogLine(line) {
+  if (!line.trim()) return null;
+  
+  // Try to parse structured JSON logs
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed.timestamp && parsed.level && parsed.message) {
+      return {
+        timestamp: new Date(parsed.timestamp),
+        level: parsed.level.toLowerCase(),
+        message: parsed.message,
+        service: parsed.service || 'unknown',
+        data: parsed.data || {},
+        raw: line
+      };
+    }
+  } catch (e) {
+    // Not JSON, fall through to text parsing
+  }
+  
+  // Try to parse common log formats
+  const timestampRegex = /(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})?)/;
+  const levelRegex = /(ERROR|WARN|INFO|DEBUG|error|warn|info|debug)/i;
+  
+  const timestampMatch = line.match(timestampRegex);
+  const levelMatch = line.match(levelRegex);
+  
+  return {
+    timestamp: timestampMatch ? new Date(timestampMatch[1]) : new Date(),
+    level: levelMatch ? levelMatch[1].toLowerCase() : 'info',
+    message: line.trim(),
+    service: 'unknown',
+    data: {},
+    raw: line
+  };
+}
+
+// Read logs from file with filtering
+async function readLogsFromFile(filePath, options = {}) {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+  
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n').filter(line => line.trim());
+  
+  let logs = lines.map(parseLogLine).filter(Boolean);
+  
+  // Apply filters
+  if (options.since) {
+    const sinceDate = parseTimeFilter(options.since);
+    logs = logs.filter(log => log.timestamp >= sinceDate);
+  }
+  
+  if (options.level) {
+    const targetLevel = options.level.toLowerCase();
+    const targetPriority = LOG_LEVELS[targetLevel]?.priority || 0;
+    logs = logs.filter(log => (LOG_LEVELS[log.level]?.priority || 0) >= targetPriority);
+  }
+  
+  if (options.filter) {
+    const regex = new RegExp(options.filter, 'i');
+    logs = logs.filter(log => regex.test(log.message) || regex.test(log.raw));
+  }
+  
+  // Apply tail limit
+  if (options.tail) {
+    const tailCount = parseInt(options.tail);
+    logs = logs.slice(-tailCount);
+  }
+  
+  return logs;
+}
+
+// Get all log files for a service (across all dates)
+function getServiceLogFiles(serviceDir) {
+  const logsDir = getLogsDir(serviceDir);
+  if (!fs.existsSync(logsDir)) {
+    return [];
+  }
+  
+  return fs.readdirSync(logsDir)
+    .filter(file => file.endsWith('.log'))
+    .map(file => path.join(logsDir, file))
+    .sort();
+}
+
+// Read all logs for a service
+async function readServiceLogs(serviceDir, options = {}) {
+  const logFiles = getServiceLogFiles(serviceDir);
+  let allLogs = [];
+  
+  for (const file of logFiles) {
+    const logs = await readLogsFromFile(file, options);
+    allLogs = allLogs.concat(logs);
+  }
+  
+  // Sort by timestamp
+  allLogs.sort((a, b) => a.timestamp - b.timestamp);
+  
+  // Apply tail limit after combining all files
+  if (options.tail) {
+    const tailCount = parseInt(options.tail);
+    allLogs = allLogs.slice(-tailCount);
+  }
+  
+  return allLogs;
+}
+
+// Format log entry for display
+function formatLogEntry(log, options = {}) {
+  const timestamp = log.timestamp.toISOString();
+  const level = log.level.toUpperCase().padEnd(5);
+  const levelColored = LOG_LEVELS[log.level]?.color(level) || level;
+  
+  if (options.json) {
+    return JSON.stringify({
+      timestamp,
+      level: log.level,
+      service: log.service,
+      message: log.message,
+      data: log.data
+    });
+  }
+  
+  return `${chalk.gray(timestamp)} ${levelColored} ${log.message}`;
+}
+
+// Export logs to different formats
+async function exportLogs(logs, format, outputPath) {
+  switch (format.toLowerCase()) {
+    case 'json':
+      const jsonData = logs.map(log => ({
+        timestamp: log.timestamp.toISOString(),
+        level: log.level,
+        service: log.service,
+        message: log.message,
+        data: log.data
+      }));
+      fs.writeFileSync(outputPath, JSON.stringify(jsonData, null, 2));
+      break;
+      
+    case 'csv':
+      const csvHeader = 'timestamp,level,service,message\n';
+      const csvRows = logs.map(log => {
+        const escapedMessage = `"${log.message.replace(/"/g, '""')}"`;
+        return `${log.timestamp.toISOString()},${log.level},${log.service},${escapedMessage}`;
+      }).join('\n');
+      fs.writeFileSync(outputPath, csvHeader + csvRows);
+      break;
+      
+    case 'txt':
+    default:
+      const txtData = logs.map(log => formatLogEntry(log)).join('\n');
+      fs.writeFileSync(outputPath, txtData);
+      break;
+  }
+}
+
+// Clear logs for a service
+async function clearServiceLogs(serviceDir) {
+  const logsDir = getLogsDir(serviceDir);
+  if (fs.existsSync(logsDir)) {
+    const files = fs.readdirSync(logsDir);
+    for (const file of files) {
+      fs.unlinkSync(path.join(logsDir, file));
+    }
+  }
+}
+
+// Watch log file for changes (for follow mode)
+function watchLogFile(filePath, callback) {
+  if (!fs.existsSync(filePath)) {
+    // Create empty file if it doesn't exist
+    fs.writeFileSync(filePath, '');
+  }
+  
+  let lastSize = fs.statSync(filePath).size;
+  
+  const watcher = fs.watchFile(filePath, { interval: 500 }, (curr) => {
+    if (curr.size > lastSize) {
+      const stream = fs.createReadStream(filePath, { start: lastSize, end: curr.size });
+      let buffer = '';
+      
+      stream.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop(); // Keep incomplete line in buffer
+        
+        lines.forEach(line => {
+          if (line.trim()) {
+            const log = parseLogLine(line);
+            if (log) callback(log);
+          }
+        });
+      });
+      
+      lastSize = curr.size;
+    }
+  });
+  
+  return () => fs.unwatchFile(filePath);
+}
+
+// Main logs viewing function
+export async function viewLogs(serviceName, options = {}) {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, 'polyglot.json');
+  
+  if (!fs.existsSync(configPath)) {
+    console.error(chalk.red('❌ polyglot.json not found. Run inside a generated workspace.'));
+    process.exit(1);
+  }
+  
+  const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  let targetServices = cfg.services;
+  
+  // Filter to specific service if requested
+  if (serviceName) {
+    targetServices = cfg.services.filter(s => s.name === serviceName);
+    if (targetServices.length === 0) {
+      console.error(chalk.red(`❌ Service '${serviceName}' not found.`));
+      console.log(chalk.gray('Available services:'), cfg.services.map(s => s.name).join(', '));
+      process.exit(1);
+    }
+  }
+  
+  // Handle clear operation
+  if (options.clear) {
+    console.log(chalk.yellow('🧹 Clearing logs...'));
+    for (const service of targetServices) {
+      const serviceDir = path.join(cwd, 'apps', service.name);
+      await clearServiceLogs(serviceDir);
+      console.log(chalk.green(`✅ Cleared logs for ${service.name}`));
+    }
+    return;
+  }
+  
+  // Handle export operation
+  if (options.export) {
+    console.log(chalk.cyan('📦 Exporting logs...'));
+    let allLogs = [];
+    
+    for (const service of targetServices) {
+      const serviceDir = path.join(cwd, 'apps', service.name);
+      const logs = await readServiceLogs(serviceDir, options);
+      logs.forEach(log => log.service = service.name);
+      allLogs = allLogs.concat(logs);
+    }
+    
+    allLogs.sort((a, b) => a.timestamp - b.timestamp);
+    
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const serviceSuffix = serviceName ? `-${serviceName}` : '-all';
+    const outputPath = path.join(cwd, `logs${serviceSuffix}-${timestamp}.${options.export}`);
+    
+    await exportLogs(allLogs, options.export, outputPath);
+    console.log(chalk.green(`✅ Logs exported to ${outputPath}`));
+    return;
+  }
+  
+  // Handle follow mode
+  if (options.follow) {
+    console.log(chalk.cyan('📡 Following logs (Ctrl+C to stop)...'));
+    console.log(chalk.gray(`Watching ${targetServices.length} service(s): ${targetServices.map(s => s.name).join(', ')}\n`));
+    
+    const unwatchers = [];
+    
+    for (const service of targetServices) {
+      const serviceDir = path.join(cwd, 'apps', service.name);
+      ensureLogsDir(serviceDir);
+      const logFile = getLogFile(serviceDir);
+      
+      const unwatcher = watchLogFile(logFile, (log) => {
+        log.service = service.name;
+        
+        // Apply filters
+        if (options.level) {
+          const targetLevel = options.level.toLowerCase();
+          const targetPriority = LOG_LEVELS[targetLevel]?.priority || 0;
+          if ((LOG_LEVELS[log.level]?.priority || 0) < targetPriority) return;
+        }
+        
+        if (options.filter) {
+          const regex = new RegExp(options.filter, 'i');
+          if (!regex.test(log.message) && !regex.test(log.raw)) return;
+        }
+        
+        console.log(`${chalk.magenta(service.name.padEnd(12))} ${formatLogEntry(log)}`);
+      });
+      
+      unwatchers.push(unwatcher);
+    }
+    
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+      console.log(chalk.yellow('\n🛑 Stopping log following...'));
+      unwatchers.forEach(unwatcher => unwatcher());
+      process.exit(0);
+    });
+    
+    // Keep process alive
+    return new Promise(() => {});
+  }
+  
+  // Default: show recent logs
+  console.log(chalk.cyan('📋 Recent logs'));
+  console.log(chalk.gray(`Services: ${targetServices.map(s => s.name).join(', ')}`));
+  if (options.since) console.log(chalk.gray(`Since: ${options.since}`));
+  if (options.level) console.log(chalk.gray(`Level: ${options.level}+`));
+  if (options.filter) console.log(chalk.gray(`Filter: ${options.filter}`));
+  console.log(chalk.gray(`Tail: ${options.tail} lines\n`));
+  
+  let allLogs = [];
+  
+  for (const service of targetServices) {
+    const serviceDir = path.join(cwd, 'apps', service.name);
+    const logs = await readServiceLogs(serviceDir, options);
+    logs.forEach(log => log.service = service.name);
+    allLogs = allLogs.concat(logs);
+  }
+  
+  allLogs.sort((a, b) => a.timestamp - b.timestamp);
+  
+  if (allLogs.length === 0) {
+    console.log(chalk.yellow('📭 No logs found matching the criteria.'));
+    console.log(chalk.gray('   Try running services first or adjusting filters.'));
+    return;
+  }
+  
+  allLogs.forEach(log => {
+    console.log(`${chalk.magenta(log.service.padEnd(12))} ${formatLogEntry(log)}`);
+  });
+  
+  console.log(chalk.gray(`\n📊 Showing ${allLogs.length} log entries`));
+}
+
+// Log appender function for services to use
+export function appendLog(serviceDir, level, message, data = {}) {
+  try {
+    ensureLogsDir(serviceDir);
+    const logFile = getLogFile(serviceDir);
+    
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      level: level.toLowerCase(),
+      message,
+      data
+    };
+    
+    const logLine = JSON.stringify(logEntry) + '\n';
+    fs.appendFileSync(logFile, logLine);
+    
+    // Check if log rotation is needed
+    rotateLogsIfNeeded(serviceDir);
+  } catch (e) {
+    // Fail silently to avoid breaking services
+    console.error('Failed to write log:', e.message);
+  }
+}
+
+// Log rotation to prevent files from growing too large
+function rotateLogsIfNeeded(serviceDir) {
+  try {
+    const logFile = getLogFile(serviceDir);
+    
+    if (!fs.existsSync(logFile)) return;
+    
+    const stats = fs.statSync(logFile);
+    const maxSize = 10 * 1024 * 1024; // 10MB
+    
+    if (stats.size > maxSize) {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const archiveFile = logFile.replace('.log', `-${timestamp}.log`);
+      
+      // Move current log to archive
+      fs.renameSync(logFile, archiveFile);
+      
+      // Clean up old archives (keep only last 10)
+      cleanupOldLogs(serviceDir);
+    }
+  } catch (e) {
+    console.error('Failed to rotate logs:', e.message);
+  }
+}
+
+// Clean up old log files
+function cleanupOldLogs(serviceDir) {
+  try {
+    const logsDir = getLogsDir(serviceDir);
+    if (!fs.existsSync(logsDir)) return;
+    
+    const files = fs.readdirSync(logsDir)
+      .filter(file => file.endsWith('.log'))
+      .map(file => ({
+        name: file,
+        path: path.join(logsDir, file),
+        mtime: fs.statSync(path.join(logsDir, file)).mtime
+      }))
+      .sort((a, b) => b.mtime - a.mtime); // Sort by modification time, newest first
+    
+    // Keep only the most recent 10 log files
+    const filesToDelete = files.slice(10);
+    
+    filesToDelete.forEach(file => {
+      try {
+        fs.unlinkSync(file.path);
+      } catch (e) {
+        console.error(`Failed to delete old log file ${file.name}:`, e.message);
+      }
+    });
+  } catch (e) {
+    console.error('Failed to cleanup old logs:', e.message);
+  }
+}
+
+// Initialize logs directory for a service
+export function initializeServiceLogs(serviceDir) {
+  ensureLogsDir(serviceDir);
+  
+  // Create a simple logging helper file for the service
+  const loggerHelperPath = path.join(serviceDir, '.logs', 'logger.js');
+  const loggerHelper = `// Auto-generated logger helper for polyglot services
+const fs = require('fs');
+const path = require('path');
+
+const LOG_LEVELS = {
+  error: 4,
+  warn: 3,
+  info: 2,
+  debug: 1
+};
+
+class Logger {
+  constructor(serviceName = 'unknown') {
+    this.serviceName = serviceName;
+    this.logsDir = path.join(__dirname);
+  }
+  
+  log(level, message, data = {}) {
+    try {
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        level: level.toLowerCase(),
+        service: this.serviceName,
+        message: String(message),
+        data
+      };
+      
+      const dateStr = new Date().toISOString().split('T')[0];
+      const logFile = path.join(this.logsDir, \`\${dateStr}.log\`);
+      const logLine = JSON.stringify(logEntry) + '\\n';
+      
+      fs.appendFileSync(logFile, logLine);
+    } catch (e) {
+      console.error('Failed to write log:', e.message);
+    }
+  }
+  
+  error(message, data) { this.log('error', message, data); }
+  warn(message, data) { this.log('warn', message, data); }
+  info(message, data) { this.log('info', message, data); }
+  debug(message, data) { this.log('debug', message, data); }
+}
+
+module.exports = { Logger };
+`;
+  
+  if (!fs.existsSync(loggerHelperPath)) {
+    fs.writeFileSync(loggerHelperPath, loggerHelper);
+  }
+}
+
+// Get logs for API endpoints (used by admin dashboard)
+export async function getLogsForAPI(serviceName = null, options = {}) {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, 'polyglot.json');
+  
+  if (!fs.existsSync(configPath)) {
+    throw new Error('polyglot.json not found');
+  }
+  
+  const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  let targetServices = cfg.services;
+  
+  if (serviceName) {
+    targetServices = cfg.services.filter(s => s.name === serviceName);
+  }
+  
+  let allLogs = [];
+  
+  for (const service of targetServices) {
+    const serviceDir = path.join(cwd, 'apps', service.name);
+    const logs = await readServiceLogs(serviceDir, options);
+    logs.forEach(log => log.service = service.name);
+    allLogs = allLogs.concat(logs);
+  }
+  
+  allLogs.sort((a, b) => a.timestamp - b.timestamp);
+  
+  return allLogs.map(log => ({
+    timestamp: log.timestamp.toISOString(),
+    level: log.level,
+    service: log.service,
+    message: log.message,
+    data: log.data
+  }));
+}
\ No newline at end of file
diff --git a/bin/lib/scaffold.js b/bin/lib/scaffold.js
index 8bf35b2..8df8fca 100644
--- a/bin/lib/scaffold.js
+++ b/bin/lib/scaffold.js
@@ -5,6 +5,7 @@ import path from 'path';
 import url from 'url';
 import { execa } from 'execa';
 import { renderServicesTable, printBoxMessage } from './ui.js';
+import { initializeServiceLogs } from './logs.js';
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -326,6 +327,10 @@ export async function scaffoldMonorepo(projectNameArg, options) {
           await fs.writeFile(path.join(dest, 'README.md'), `# ${svcName} service\n\nScaffolded by create-polyglot.`);
         }
       }
+      
+      // Initialize logging for the service
+      initializeServiceLogs(dest);
+      
       console.log(chalk.green(`✅ Created ${svcName} (${svcType}) service on port ${svcPort}`));
     }
 
@@ -541,6 +546,10 @@ export async function addService(projectDir, { type, name, port }, options = {})
   } else {
     await fs.writeFile(path.join(dest, 'README.md'), `# ${name} (${type}) service\n`);
   }
+  
+  // Initialize logging for the service
+  initializeServiceLogs(dest);
+  
   console.log(chalk.green(`✅ Added service '${name}' (${type}) on port ${port}`));
   cfg.services.push({ name, type, port, path: `services/${name}` });
   await fs.writeJSON(configPath, cfg, { spaces: 2 });
diff --git a/docs/.vitepress/config.mjs b/docs/.vitepress/config.mjs
index 35ef9bf..3dc034d 100644
--- a/docs/.vitepress/config.mjs
+++ b/docs/.vitepress/config.mjs
@@ -16,7 +16,8 @@ export default defineConfig({
     nav: [
       { text: 'Guide', link: '/guide/' },
       { text: 'CLI', link: '/cli/' },
-      { text: 'Templates', link: '/templates/' }
+      { text: 'Templates', link: '/templates/' },
+      { text: 'Features', link: '/logs-feature' }
     ],
     sidebar: {
       '/guide/': [
@@ -24,7 +25,8 @@ export default defineConfig({
         { text: 'Getting Started', link: '/guide/getting-started' },
         { text: 'Presets', link: '/guide/presets' },
         { text: 'Docker & Compose', link: '/guide/docker' },
-        { text: 'Extending (New Service)', link: '/guide/extending-service' }
+        { text: 'Extending (New Service)', link: '/guide/extending-service' },
+        { text: 'Service Logs', link: '/logs-feature' }
       ],
       '/cli/': [
         { text: 'Usage', link: '/cli/' },
diff --git a/docs/logs-feature.md b/docs/logs-feature.md
new file mode 100644
index 0000000..fe40902
--- /dev/null
+++ b/docs/logs-feature.md
@@ -0,0 +1,218 @@
+# Service Logs Feature
+
+A comprehensive logging solution for polyglot microservices that provides both CLI and web-based log viewing capabilities.
+
+## Features
+
+### 📋 CLI Log Viewer
+View logs directly from the command line with powerful filtering and export options:
+
+```bash
+# View all service logs
+create-polyglot logs
+
+# View logs for a specific service
+create-polyglot logs my-service
+
+# Follow logs in real-time
+create-polyglot logs --follow
+
+# Show last 100 lines
+create-polyglot logs --tail 100
+
+# Filter by log level
+create-polyglot logs --level error
+
+# Show logs from the last hour
+create-polyglot logs --since 1h
+
+# Search logs with regex
+create-polyglot logs --filter "database|connection"
+
+# Export logs to JSON
+create-polyglot logs --export json
+
+# Clear all logs
+create-polyglot logs --clear
+```
+
+### 🌐 Web Dashboard
+Enhanced admin dashboard with integrated log viewer:
+
+- **Real-time log streaming** via WebSocket connection
+- **Service filtering** - view logs from specific services
+- **Log level filtering** - filter by error, warn, info, debug
+- **Text search** - search through log messages
+- **Auto-refresh** - automatically update logs every few seconds
+- **Export functionality** - download logs in various formats
+
+Access the dashboard:
+```bash
+create-polyglot admin
+```
+
+### 🗂️ File-based Storage
+Logs are stored in each service directory under `.logs/`:
+
+```
+apps/
+  my-service/
+    .logs/
+      2025-11-05.log    # Daily log files
+      2025-11-04.log
+      logger.js         # Helper utility for services
+```
+
+### 📊 Log Format
+All logs use a consistent JSON format:
+
+```json
+{
+  "timestamp": "2025-11-05T14:30:00.000Z",
+  "level": "info",
+  "service": "my-service",
+  "message": "GET /api/users",
+  "data": {
+    "method": "GET",
+    "path": "/api/users",
+    "ip": "127.0.0.1"
+  }
+}
+```
+
+### 🔄 Log Rotation
+- Files automatically rotate when they exceed 10MB
+- Keeps the last 10 log files per service
+- Old files are cleaned up automatically
+
+## Service Integration
+
+### Node.js Services
+Services automatically include request logging and error handling:
+
+```javascript
+import { Logger } from './.logs/logger.js';
+const logger = new Logger('my-service');
+
+logger.info('Server started', { port: 3001 });
+logger.error('Database connection failed', { error: err.message });
+```
+
+### Python Services (FastAPI)
+Built-in logging with automatic request tracking:
+
+```python
+file_logger.info("Processing request", {"user_id": 123})
+file_logger.error("Validation failed", {"field": "email"})
+```
+
+### Go Services
+Structured logging with request middleware:
+
+```go
+logger.Info("User authenticated", map[string]interface{}{
+    "user_id": userID,
+    "role": "admin",
+})
+```
+
+### Java Services (Spring Boot)
+Integrated with SLF4J and automatic request logging:
+
+```java
+logInfo("Processing payment", Map.of("amount", 100.50));
+logError("Payment failed", Map.of("error", ex.getMessage()));
+```
+
+## API Endpoints
+
+Each service automatically exposes log endpoints:
+
+```bash
+# Get recent logs for a service
+GET http://localhost:3001/logs?tail=50&level=error
+
+# Parameters:
+# - tail: number of recent lines (default: 50)
+# - level: filter by log level
+# - since: ISO timestamp or relative time
+```
+
+## Dashboard Features
+
+### Service Logs Section
+- **Service Filter**: View logs from specific services or all services
+- **Level Filter**: Show only errors, warnings, info, or debug logs
+- **Search**: Real-time text search through log messages
+- **Live Stream**: WebSocket-based real-time log updates
+- **Auto-refresh**: Periodic polling for new logs
+- **Export**: Download logs in JSON, CSV, or text format
+
+### Controls
+- **Refresh**: Manually update logs
+- **Auto-Refresh**: Toggle automatic updates every 3 seconds
+- **Live Stream**: Enable real-time WebSocket streaming
+- **Export**: Download filtered logs
+- **Clear**: Remove all logs (with confirmation)
+
+## Configuration
+
+### Log Levels
+- `error`: Critical errors and exceptions
+- `warn`: Warning messages and deprecations
+- `info`: General information and request logs
+- `debug`: Detailed debugging information
+
+### Time Filters
+- Relative: `1h`, `30m`, `2d`, `1w`
+- Absolute: ISO timestamps like `2025-11-05T10:00:00Z`
+
+### Export Formats
+- **JSON**: Structured data with all fields
+- **CSV**: Comma-separated values for spreadsheets
+- **TXT**: Human-readable plain text format
+
+## Architecture
+
+### Storage
+- Daily log files: `{service}/.logs/YYYY-MM-DD.log`
+- JSON Lines format for easy parsing
+- Automatic rotation and cleanup
+
+### Real-time Updates
+- WebSocket connection for live streaming
+- File watching for follow mode in CLI
+- Periodic polling for auto-refresh
+
+### Performance
+- Efficient tail operations for large log files
+- Lazy loading and streaming for web interface
+- Configurable limits to prevent memory issues
+
+## Troubleshooting
+
+### No logs appearing
+1. Check if services are running and generating logs
+2. Verify `.logs` directory exists in service folders
+3. Check file permissions for log directories
+
+### Dashboard not updating
+1. Ensure WebSocket connection is established
+2. Check browser console for JavaScript errors
+3. Verify admin dashboard is running on correct port
+
+### Large log files
+- Log rotation happens automatically at 10MB
+- Use `--tail` option to limit output
+- Consider using `--since` for time-based filtering
+
+## Security Considerations
+
+- Log files are stored locally in service directories
+- No authentication required for local development
+- Production deployments should secure admin dashboard
+- Sensitive data should not be logged in production
+
+---
+
+This logging system provides comprehensive observability for your polyglot microservices while maintaining simplicity and performance.
\ No newline at end of file
diff --git a/templates/go/main.go b/templates/go/main.go
index e4d45fa..7234de6 100644
--- a/templates/go/main.go
+++ b/templates/go/main.go
@@ -1,16 +1,204 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
+	"io/ioutil"
+	"log"
 	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
 )
 
-func main() {
-	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+type LogEntry struct {
+	Timestamp string                 `json:"timestamp"`
+	Level     string                 `json:"level"`
+	Service   string                 `json:"service"`
+	Message   string                 `json:"message"`
+	Data      map[string]interface{} `json:"data"`
+}
+
+type Logger struct {
+	ServiceName string
+	LogsDir     string
+}
+
+func NewLogger(serviceName string) *Logger {
+	logsDir := filepath.Join(".", ".logs")
+	os.MkdirAll(logsDir, 0755)
+	
+	return &Logger{
+		ServiceName: serviceName,
+		LogsDir:     logsDir,
+	}
+}
+
+func (l *Logger) getLogFile() string {
+	today := time.Now().Format("2006-01-02")
+	return filepath.Join(l.LogsDir, fmt.Sprintf("%s.log", today))
+}
+
+func (l *Logger) writeLog(level, message string, data map[string]interface{}) {
+	if data == nil {
+		data = make(map[string]interface{})
+	}
+	
+	entry := LogEntry{
+		Timestamp: time.Now().UTC().Format(time.RFC3339),
+		Level:     strings.ToLower(level),
+		Service:   l.ServiceName,
+		Message:   message,
+		Data:      data,
+	}
+	
+	jsonData, err := json.Marshal(entry)
+	if err != nil {
+		log.Printf("Failed to marshal log entry: %v", err)
+		return
+	}
+	
+	logFile := l.getLogFile()
+	file, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		log.Printf("Failed to open log file: %v", err)
+		return
+	}
+	defer file.Close()
+	
+	_, err = file.WriteString(string(jsonData) + "\n")
+	if err != nil {
+		log.Printf("Failed to write to log file: %v", err)
+	}
+}
+
+func (l *Logger) Info(message string, data map[string]interface{}) {
+	l.writeLog("info", message, data)
+	log.Printf("[INFO] %s", message)
+}
+
+func (l *Logger) Error(message string, data map[string]interface{}) {
+	l.writeLog("error", message, data)
+	log.Printf("[ERROR] %s", message)
+}
+
+func (l *Logger) Warn(message string, data map[string]interface{}) {
+	l.writeLog("warn", message, data)
+	log.Printf("[WARN] %s", message)
+}
+
+func (l *Logger) Debug(message string, data map[string]interface{}) {
+	l.writeLog("debug", message, data)
+	log.Printf("[DEBUG] %s", message)
+}
+
+var logger *Logger
+
+func logMiddleware(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		logger.Info(fmt.Sprintf("%s %s", r.Method, r.URL.Path), map[string]interface{}{
+			"method":    r.Method,
+			"path":      r.URL.Path,
+			"remote_addr": r.RemoteAddr,
+			"user_agent": r.UserAgent(),
+		})
+		next(w, r)
+	}
+}
+
+func healthHandler(w http.ResponseWriter, r *http.Request) {
+	logger.Info("Health check requested", nil)
+	w.Header().Set("Content-Type", "application/json")
+	_, _ = w.Write([]byte(`{"status":"ok","service":"go"}`))
+}
+
+func logsHandler(w http.ResponseWriter, r *http.Request) {
+	tail := 50
+	if t := r.URL.Query().Get("tail"); t != "" {
+		if parsed, err := strconv.Atoi(t); err == nil {
+			tail = parsed
+		}
+	}
+	
+	level := r.URL.Query().Get("level")
+	since := r.URL.Query().Get("since")
+	
+	// Get today's log file
+	today := time.Now().Format("2006-01-02")
+	logFile := filepath.Join(".logs", fmt.Sprintf("%s.log", today))
+	
+	if _, err := os.Stat(logFile); os.IsNotExist(err) {
 		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"status":"ok","service":"go"}`))
-	})
-	port := "3002"
+		w.Write([]byte("[]"))
+		return
+	}
+	
+	content, err := ioutil.ReadFile(logFile)
+	if err != nil {
+		logger.Error("Failed to read log file", map[string]interface{}{"error": err.Error()})
+		http.Error(w, "Failed to read logs", http.StatusInternalServerError)
+		return
+	}
+	
+	lines := strings.Split(string(content), "\n")
+	var logs []LogEntry
+	
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		
+		var entry LogEntry
+		if err := json.Unmarshal([]byte(line), &entry); err != nil {
+			continue
+		}
+		
+		// Apply filters
+		if level != "" && entry.Level != strings.ToLower(level) {
+			continue
+		}
+		
+		if since != "" {
+			sinceTime, err := time.Parse(time.RFC3339, since)
+			if err == nil {
+				entryTime, err := time.Parse(time.RFC3339, entry.Timestamp)
+				if err != nil || entryTime.Before(sinceTime) {
+					continue
+				}
+			}
+		}
+		
+		logs = append(logs, entry)
+	}
+	
+	// Apply tail limit
+	if len(logs) > tail {
+		logs = logs[len(logs)-tail:]
+	}
+	
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(logs)
+}
+
+func main() {
+	logger = NewLogger("go")
+	
+	http.HandleFunc("/health", logMiddleware(healthHandler))
+	http.HandleFunc("/logs", logMiddleware(logsHandler))
+	
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "3002"
+	}
+	
+	logger.Info(fmt.Sprintf("Go service started on port %s", port), map[string]interface{}{"port": port})
 	fmt.Println("[go] service listening on :" + port)
-	_ = http.ListenAndServe(":"+port, nil)
+	
+	if err := http.ListenAndServe(":"+port, nil); err != nil {
+		logger.Error("Server failed to start", map[string]interface{}{"error": err.Error()})
+		log.Fatal(err)
+	}
 }
diff --git a/templates/node/src/index.js b/templates/node/src/index.js
index f3f0412..068a5cb 100644
--- a/templates/node/src/index.js
+++ b/templates/node/src/index.js
@@ -1,13 +1,130 @@
 import express from 'express';
+import fs from 'fs';
+import path from 'path';
+
+// Initialize logger
+let logger;
+try {
+  const loggerPath = path.join(process.cwd(), '.logs', 'logger.js');
+  if (fs.existsSync(loggerPath)) {
+    const { Logger } = require(loggerPath);
+    logger = new Logger('node');
+  }
+} catch (e) {
+  console.warn('Logger not available:', e.message);
+}
+
+// Helper function to log with fallback to console
+function log(level, message, data = {}) {
+  if (logger) {
+    logger[level](message, data);
+  }
+  console[level === 'error' ? 'error' : 'log'](`[${level.toUpperCase()}] ${message}`);
+}
 
 const app = express();
 const port = process.env.PORT || 3001;
 
+// Middleware for request logging
+app.use((req, res, next) => {
+  log('info', `${req.method} ${req.path}`, { 
+    method: req.method, 
+    path: req.path, 
+    ip: req.ip,
+    userAgent: req.get('User-Agent')
+  });
+  next();
+});
+
 app.get('/health', (_req, res) => {
+  log('info', 'Health check requested');
   res.json({ status: 'ok', service: 'node' });
 });
 
+app.get('/logs', (req, res) => {
+  try {
+    const { tail = 50, level, since } = req.query;
+    
+    // Simple logs endpoint - in a real app you'd want proper pagination
+    const logsDir = path.join(process.cwd(), '.logs');
+    if (!fs.existsSync(logsDir)) {
+      return res.json([]);
+    }
+    
+    // Get today's log file
+    const today = new Date().toISOString().split('T')[0];
+    const logFile = path.join(logsDir, `${today}.log`);
+    
+    if (!fs.existsSync(logFile)) {
+      return res.json([]);
+    }
+    
+    const content = fs.readFileSync(logFile, 'utf-8');
+    let logs = content.split('\n')
+      .filter(line => line.trim())
+      .map(line => {
+        try {
+          return JSON.parse(line);
+        } catch (e) {
+          return null;
+        }
+      })
+      .filter(Boolean);
+    
+    // Apply filters
+    if (level) {
+      logs = logs.filter(log => log.level === level.toLowerCase());
+    }
+    
+    if (since) {
+      const sinceDate = new Date(since);
+      logs = logs.filter(log => new Date(log.timestamp) >= sinceDate);
+    }
+    
+    // Apply tail limit
+    logs = logs.slice(-parseInt(tail));
+    
+    res.json(logs);
+  } catch (e) {
+    log('error', 'Failed to fetch logs', { error: e.message });
+    res.status(500).json({ error: 'Failed to fetch logs' });
+  }
+});
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  log('error', 'Unhandled error', { 
+    error: err.message, 
+    stack: err.stack,
+    path: req.path 
+  });
+  res.status(500).json({ error: 'Internal server error' });
+});
+
 app.listen(port, () => {
+  log('info', `Node service started on port ${port}`, { port });
   console.log(`[node] service listening on :${port}`);
 });
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  log('info', 'Received SIGTERM, shutting down gracefully');
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  log('info', 'Received SIGINT, shutting down gracefully');
+  process.exit(0);
+});
+
+// Catch unhandled errors
+process.on('uncaughtException', (err) => {
+  log('error', 'Uncaught exception', { error: err.message, stack: err.stack });
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  log('error', 'Unhandled rejection', { reason: String(reason), promise: String(promise) });
+});
+
 // test node change 2025-10-05 19:51:20
diff --git a/templates/python/app/main.py b/templates/python/app/main.py
index 22154da..0b92c55 100644
--- a/templates/python/app/main.py
+++ b/templates/python/app/main.py
@@ -1,7 +1,153 @@
-from fastapi import FastAPI
+import os
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+from fastapi import FastAPI, Request, Query
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Simple file-based logger that matches the Node.js format
+class FileLogger:
+    def __init__(self, service_name: str = "python"):
+        self.service_name = service_name
+        self.logs_dir = Path.cwd() / ".logs"
+        self.logs_dir.mkdir(exist_ok=True)
+    
+    def _get_log_file(self):
+        today = datetime.now().strftime("%Y-%m-%d")
+        return self.logs_dir / f"{today}.log"
+    
+    def _write_log(self, level: str, message: str, data: Dict[str, Any] = None):
+        try:
+            log_entry = {
+                "timestamp": datetime.now().isoformat(),
+                "level": level.lower(),
+                "service": self.service_name,
+                "message": str(message),
+                "data": data or {}
+            }
+            
+            with open(self._get_log_file(), "a") as f:
+                f.write(json.dumps(log_entry) + "\n")
+        except Exception as e:
+            print(f"Failed to write log: {e}")
+    
+    def info(self, message: str, data: Dict[str, Any] = None):
+        self._write_log("info", message, data)
+        logger.info(message)
+    
+    def error(self, message: str, data: Dict[str, Any] = None):
+        self._write_log("error", message, data)
+        logger.error(message)
+    
+    def warn(self, message: str, data: Dict[str, Any] = None):
+        self._write_log("warn", message, data)
+        logger.warning(message)
+    
+    def debug(self, message: str, data: Dict[str, Any] = None):
+        self._write_log("debug", message, data)
+        logger.debug(message)
+
+file_logger = FileLogger()
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    file_logger.info(f"{request.method} {request.url.path}", {
+        "method": request.method,
+        "path": str(request.url.path),
+        "query_params": dict(request.query_params),
+        "client_host": getattr(request.client, 'host', 'unknown') if request.client else 'unknown'
+    })
+    
+    response = await call_next(request)
+    return response
+
 @app.get("/health")
 async def health():
+    file_logger.info("Health check requested")
     return {"status": "ok", "service": "python"}
+
+@app.get("/logs")
+async def get_logs(
+    tail: int = Query(50, description="Number of recent lines to show"),
+    level: Optional[str] = Query(None, description="Filter by log level"),
+    since: Optional[str] = Query(None, description="Show logs since timestamp")
+):
+    try:
+        logs_dir = Path.cwd() / ".logs"
+        if not logs_dir.exists():
+            return []
+        
+        # Get today's log file
+        today = datetime.now().strftime("%Y-%m-%d")
+        log_file = logs_dir / f"{today}.log"
+        
+        if not log_file.exists():
+            return []
+        
+        with open(log_file, "r") as f:
+            lines = f.readlines()
+        
+        logs = []
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                log_entry = json.loads(line)
+                logs.append(log_entry)
+            except json.JSONDecodeError:
+                continue
+        
+        # Apply filters
+        if level:
+            logs = [log for log in logs if log.get("level") == level.lower()]
+        
+        if since:
+            try:
+                since_dt = datetime.fromisoformat(since.replace('Z', '+00:00'))
+                logs = [log for log in logs if datetime.fromisoformat(log["timestamp"].replace('Z', '+00:00')) >= since_dt]
+            except ValueError:
+                pass  # Invalid since format, ignore filter
+        
+        # Apply tail limit
+        logs = logs[-tail:]
+        
+        return logs
+    
+    except Exception as e:
+        file_logger.error(f"Failed to fetch logs: {str(e)}")
+        return {"error": "Failed to fetch logs"}
+
+@app.on_event("startup")
+async def startup_event():
+    file_logger.info("Python service started", {"service": "python"})
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    file_logger.info("Python service shutting down")
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", "3004"))
+    file_logger.info(f"Starting Python service on port {port}", {"port": port})
+    uvicorn.run(app, host="0.0.0.0", port=port)
diff --git a/templates/spring-boot/src/main/java/com/example/DemoApplication.java b/templates/spring-boot/src/main/java/com/example/DemoApplication.java
index bb14d3d..310a638 100644
--- a/templates/spring-boot/src/main/java/com/example/DemoApplication.java
+++ b/templates/spring-boot/src/main/java/com/example/DemoApplication.java
@@ -1,17 +1,155 @@
 package com.example;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletRequest;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @SpringBootApplication
 @RestController
 public class DemoApplication {
+    
+    private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);
+    private final ObjectMapper objectMapper = new ObjectMapper();
+    private final String serviceName = "spring-boot";
+    
+    public DemoApplication() {
+        // Ensure logs directory exists
+        try {
+            Files.createDirectories(Paths.get(".logs"));
+        } catch (IOException e) {
+            logger.error("Failed to create logs directory", e);
+        }
+    }
+    
+    private void writeLog(String level, String message, Map<String, Object> data) {
+        try {
+            ObjectNode logEntry = objectMapper.createObjectNode();
+            logEntry.put("timestamp", LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME) + "Z");
+            logEntry.put("level", level.toLowerCase());
+            logEntry.put("service", serviceName);
+            logEntry.put("message", message);
+            logEntry.set("data", objectMapper.valueToTree(data != null ? data : new HashMap<>()));
+            
+            String logLine = objectMapper.writeValueAsString(logEntry) + "\n";
+            String today = LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE);
+            Path logFile = Paths.get(".logs", today + ".log");
+            
+            Files.write(logFile, logLine.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.APPEND);
+        } catch (Exception e) {
+            logger.error("Failed to write log", e);
+        }
+    }
+    
+    private void logInfo(String message, Map<String, Object> data) {
+        writeLog("info", message, data);
+        logger.info(message);
+    }
+    
+    private void logError(String message, Map<String, Object> data) {
+        writeLog("error", message, data);
+        logger.error(message);
+    }
+    
+    private void logWarn(String message, Map<String, Object> data) {
+        writeLog("warn", message, data);
+        logger.warn(message);
+    }
+    
+    private void logRequest(HttpServletRequest request) {
+        Map<String, Object> data = new HashMap<>();
+        data.put("method", request.getMethod());
+        data.put("path", request.getRequestURI());
+        data.put("remoteAddr", request.getRemoteAddr());
+        data.put("userAgent", request.getHeader("User-Agent"));
+        
+        logInfo(request.getMethod() + " " + request.getRequestURI(), data);
+    }
 
     @GetMapping("/health")
-    public java.util.Map<String, String> health() {
-        return java.util.Map.of("status", "ok", "service", "spring-boot");
+    public Map<String, String> health(HttpServletRequest request) {
+        logRequest(request);
+        logInfo("Health check requested", null);
+        return Map.of("status", "ok", "service", "spring-boot");
+    }
+    
+    @GetMapping("/logs")
+    public List<Map<String, Object>> getLogs(
+            HttpServletRequest request,
+            @RequestParam(defaultValue = "50") int tail,
+            @RequestParam(required = false) String level,
+            @RequestParam(required = false) String since) {
+        
+        logRequest(request);
+        
+        try {
+            String today = LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE);
+            Path logFile = Paths.get(".logs", today + ".log");
+            
+            if (!Files.exists(logFile)) {
+                return new ArrayList<>();
+            }
+            
+            List<String> lines = Files.readAllLines(logFile);
+            List<Map<String, Object>> logs = new ArrayList<>();
+            
+            for (String line : lines) {
+                line = line.trim();
+                if (line.isEmpty()) continue;
+                
+                try {
+                    @SuppressWarnings("unchecked")
+                    Map<String, Object> logEntry = objectMapper.readValue(line, Map.class);
+                    
+                    // Apply filters
+                    if (level != null && !level.isEmpty()) {
+                        String entryLevel = (String) logEntry.get("level");
+                        if (!level.toLowerCase().equals(entryLevel)) {
+                            continue;
+                        }
+                    }
+                    
+                    if (since != null && !since.isEmpty()) {
+                        // Simple since filtering - in production you'd want proper date parsing
+                        String timestamp = (String) logEntry.get("timestamp");
+                        if (timestamp != null && timestamp.compareTo(since) < 0) {
+                            continue;
+                        }
+                    }
+                    
+                    logs.add(logEntry);
+                } catch (Exception e) {
+                    // Skip malformed log entries
+                    continue;
+                }
+            }
+            
+            // Apply tail limit
+            if (logs.size() > tail) {
+                logs = logs.subList(logs.size() - tail, logs.size());
+            }
+            
+            return logs;
+            
+        } catch (Exception e) {
+            logError("Failed to fetch logs: " + e.getMessage(), Map.of("error", e.getMessage()));
+            return List.of(Map.of("error", "Failed to fetch logs"));
+        }
     }
 
     public static void main(String[] args) {
diff --git a/templates/spring-boot/target/classes/application.properties.txt b/templates/spring-boot/target/classes/application.properties.txt
deleted file mode 100644
index 3ec6182..0000000
--- a/templates/spring-boot/target/classes/application.properties.txt
+++ /dev/null
@@ -1 +0,0 @@
-server.port=3003
diff --git a/templates/spring-boot/target/classes/com/example/DemoApplication.class b/templates/spring-boot/target/classes/com/example/DemoApplication.class
deleted file mode 100644
index db2112f5b00d0685ae65dc2b2614b379957a06a0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1230
zcmb7DTTc@~6#k~PbSdRl5Jg1AYg>i!7Bnf6AVyz`8ft0`Pt!8A1KXWub{6<q`Xuqe
zAK;HNp4m3C!p6jhJ!j52GvE2nWq<zq{sX{EJk2A+u-Mi;E>A?S?@Rt#_Vi}I@2j@3
zN(Xsl8Kw`!k>I`vI{ba>K(;Nz=(-A&-C!6gSDFmjExjiT7{OQ(IgBz))m0$hMZK0Z
zA4SWT45hkm3%@Cha`w=fwOti5EY<%(p+?!dQuwyZFjKD7V=|FdKHnC73XU~YClEF=
zl;rvO`1;^_%)Mca3Ocomo()1-*ogwGda|iPMf^5{K-;(jMDJN$n+^~A?)knEJ$bCn
zAwQNa-crFH7k}>Zx6%@+zDvW9I}(0Gr1E?~-@|1pB_!A=^svB?(T5%u=|U*Yk!nj1
zOAO<KJS#1&?Ko~=IggtR6Mt1*#4X%*@Anx#mlFjI#*-}ZKRg#(o9zh|FwB>C6FG)$
ztTYR_k4he8hH6@WTmifhH!ZPHMO5*C*2Y8x+)8ra@<kZd(lVvCzpVo+Pb}Zk!M^H5
z#%)z154l~K#*h`JLqnWRL8jH-mbR<+J_t8fD-B&NG<0Oz@{Mv^J9qAXSaow?*hr-m
zS1cl{iCfG`4(oqKtw?YqQZG^g(pG9mhSn8hwC_t(!!oFQ^!I`!?HEQ$=E>ru8R=a0
z8@#V{$e=*dg+ZrrlEuLV(i3DcOk#>ars<r)3`(RY$vaEm+%8y%OEK^ovhllOX})x&
zbhUKt6xYARZ_e;16Zpj;{uu7yE+IQ|Yor|yuf(dSxcBLdUx6Z^+<D4-#?iw=tdM_|
Vz8oXNQRK0F6ccsN9+Uk9_zkh&Knnl>


From 5a5c53cd4ec8c1f1fa09be499f143658493656fd Mon Sep 17 00:00:00 2001
From: meenu155 <meenusinghms392@gmail.com>
Date: Wed, 5 Nov 2025 19:39:08 +0530
Subject: [PATCH 2/6] 1.9.0

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index a89760d..6640199 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "create-polyglot",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "create-polyglot",
-      "version": "1.8.0",
+      "version": "1.9.0",
       "license": "MIT",
       "dependencies": {
         "chalk": "^5.6.2",
diff --git a/package.json b/package.json
index 6cbc74c..db50e37 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "create-polyglot",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Scaffold polyglot microservice monorepos with built-in templates for Node, Python, Go, and more.",
   "main": "bin/index.js",
   "scripts": {

From f97ce715b2cb9468557f6c3fe98a56fc386ae688 Mon Sep 17 00:00:00 2001
From: Meenu Singh <112775342+meenu155@users.noreply.github.com>
Date: Wed, 5 Nov 2025 19:46:35 +0530
Subject: [PATCH 3/6] Potential fix for code scanning alert no. 4: Regular
 expression injection

Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>
---
 bin/lib/logs.js | 4 +++-
 package.json    | 3 ++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/bin/lib/logs.js b/bin/lib/logs.js
index 8b4604e..59ca93e 100644
--- a/bin/lib/logs.js
+++ b/bin/lib/logs.js
@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { spawn } from 'node:child_process';
 import chalk from 'chalk';
+import _ from 'lodash';
 
 // Log levels and their colors
 const LOG_LEVELS = {
@@ -121,7 +122,8 @@ async function readLogsFromFile(filePath, options = {}) {
   }
   
   if (options.filter) {
-    const regex = new RegExp(options.filter, 'i');
+    const safeFilter = _.escapeRegExp(options.filter);
+    const regex = new RegExp(safeFilter, 'i');
     logs = logs.filter(log => regex.test(log.message) || regex.test(log.raw));
   }
   
diff --git a/package.json b/package.json
index db50e37..cb12d39 100644
--- a/package.json
+++ b/package.json
@@ -53,7 +53,8 @@
     "degit": "^2.8.4",
     "fs-extra": "^11.3.2",
     "prompts": "^2.4.2",
-    "execa": "^9.6.0"
+    "execa": "^9.6.0",
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
     "vitepress": "^1.3.3",

From 576a3b650ba932591901c8c103a8c6129373dc26 Mon Sep 17 00:00:00 2001
From: Meenu Singh <112775342+meenu155@users.noreply.github.com>
Date: Wed, 5 Nov 2025 19:47:00 +0530
Subject: [PATCH 4/6] Potential fix for code scanning alert no. 3: Missing rate
 limiting

Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>
---
 templates/node/package.json |  3 ++-
 templates/node/src/index.js | 10 +++++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/templates/node/package.json b/templates/node/package.json
index af0427c..960b8a2 100644
--- a/templates/node/package.json
+++ b/templates/node/package.json
@@ -6,6 +6,7 @@
     "dev": "node src/index.js"
   },
   "dependencies": {
-    "express": "^4.19.2"
+    "express": "^4.19.2",
+    "express-rate-limit": "^8.2.1"
   }
 }
diff --git a/templates/node/src/index.js b/templates/node/src/index.js
index 068a5cb..91a458d 100644
--- a/templates/node/src/index.js
+++ b/templates/node/src/index.js
@@ -1,6 +1,7 @@
 import express from 'express';
 import fs from 'fs';
 import path from 'path';
+import rateLimit from 'express-rate-limit';
 
 // Initialize logger
 let logger;
@@ -25,6 +26,13 @@ function log(level, message, data = {}) {
 const app = express();
 const port = process.env.PORT || 3001;
 
+// Set up rate limiter for the /logs endpoint (max 5 requests per minute)
+const logsLimiter = rateLimit({
+  windowMs: 60 * 1000, // 1 minute
+  max: 5,
+  message: { error: 'Too many requests, please try again later.' }
+});
+
 // Middleware for request logging
 app.use((req, res, next) => {
   log('info', `${req.method} ${req.path}`, { 
@@ -41,7 +49,7 @@ app.get('/health', (_req, res) => {
   res.json({ status: 'ok', service: 'node' });
 });
 
-app.get('/logs', (req, res) => {
+app.get('/logs', logsLimiter, (req, res) => {
   try {
     const { tail = 50, level, since } = req.query;
     

From 5818bbf508791ac196dd1c6c189c4003c043da2d Mon Sep 17 00:00:00 2001
From: meenu155 <meenusinghms392@gmail.com>
Date: Wed, 5 Nov 2025 19:53:14 +0530
Subject: [PATCH 5/6] feat(application): Add initial application properties and
 DemoApplication class

---
 .../target/classes/application.properties.txt    |   1 +
 .../classes/com/example/DemoApplication.class    | Bin 0 -> 1230 bytes
 2 files changed, 1 insertion(+)
 create mode 100644 templates/spring-boot/target/classes/application.properties.txt
 create mode 100644 templates/spring-boot/target/classes/com/example/DemoApplication.class

diff --git a/templates/spring-boot/target/classes/application.properties.txt b/templates/spring-boot/target/classes/application.properties.txt
new file mode 100644
index 0000000..3ec6182
--- /dev/null
+++ b/templates/spring-boot/target/classes/application.properties.txt
@@ -0,0 +1 @@
+server.port=3003
diff --git a/templates/spring-boot/target/classes/com/example/DemoApplication.class b/templates/spring-boot/target/classes/com/example/DemoApplication.class
new file mode 100644
index 0000000000000000000000000000000000000000..db2112f5b00d0685ae65dc2b2614b379957a06a0
GIT binary patch
literal 1230
zcmb7DTTc@~6#k~PbSdRl5Jg1AYg>i!7Bnf6AVyz`8ft0`Pt!8A1KXWub{6<q`Xuqe
zAK;HNp4m3C!p6jhJ!j52GvE2nWq<zq{sX{EJk2A+u-Mi;E>A?S?@Rt#_Vi}I@2j@3
zN(Xsl8Kw`!k>I`vI{ba>K(;Nz=(-A&-C!6gSDFmjExjiT7{OQ(IgBz))m0$hMZK0Z
zA4SWT45hkm3%@Cha`w=fwOti5EY<%(p+?!dQuwyZFjKD7V=|FdKHnC73XU~YClEF=
zl;rvO`1;^_%)Mca3Ocomo()1-*ogwGda|iPMf^5{K-;(jMDJN$n+^~A?)knEJ$bCn
zAwQNa-crFH7k}>Zx6%@+zDvW9I}(0Gr1E?~-@|1pB_!A=^svB?(T5%u=|U*Yk!nj1
zOAO<KJS#1&?Ko~=IggtR6Mt1*#4X%*@Anx#mlFjI#*-}ZKRg#(o9zh|FwB>C6FG)$
ztTYR_k4he8hH6@WTmifhH!ZPHMO5*C*2Y8x+)8ra@<kZd(lVvCzpVo+Pb}Zk!M^H5
z#%)z154l~K#*h`JLqnWRL8jH-mbR<+J_t8fD-B&NG<0Oz@{Mv^J9qAXSaow?*hr-m
zS1cl{iCfG`4(oqKtw?YqQZG^g(pG9mhSn8hwC_t(!!oFQ^!I`!?HEQ$=E>ru8R=a0
z8@#V{$e=*dg+ZrrlEuLV(i3DcOk#>ars<r)3`(RY$vaEm+%8y%OEK^ovhllOX})x&
zbhUKt6xYARZ_e;16Zpj;{uu7yE+IQ|Yor|yuf(dSxcBLdUx6Z^+<D4-#?iw=tdM_|
Vz8oXNQRK0F6ccsN9+Uk9_zkh&Knnl>

literal 0
HcmV?d00001


From 2218e36d80a50ebfa9d8d57b994cc0b1b2ee4822 Mon Sep 17 00:00:00 2001
From: meenu155 <meenusinghms392@gmail.com>
Date: Wed, 5 Nov 2025 19:59:04 +0530
Subject: [PATCH 6/6] fix(DemoApplication): Update import statement to use
 jakarta.servlet for compatibility

---
 .../java/com/example/DemoApplication.java     |   3 +--
 .../classes/com/example/DemoApplication.class | Bin 1230 -> 9065 bytes
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/templates/spring-boot/src/main/java/com/example/DemoApplication.java b/templates/spring-boot/src/main/java/com/example/DemoApplication.java
index 310a638..0de3c6d 100644
--- a/templates/spring-boot/src/main/java/com/example/DemoApplication.java
+++ b/templates/spring-boot/src/main/java/com/example/DemoApplication.java
@@ -8,7 +8,7 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.web.bind.annotation.*;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 import java.io.*;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -18,7 +18,6 @@
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
-import java.util.stream.Collectors;
 
 @SpringBootApplication
 @RestController
diff --git a/templates/spring-boot/target/classes/com/example/DemoApplication.class b/templates/spring-boot/target/classes/com/example/DemoApplication.class
index db2112f5b00d0685ae65dc2b2614b379957a06a0..b3de981f2f9c999eb4bd30d3849942dce13a65ce 100644
GIT binary patch
literal 9065
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

delta 541
zcmY*V%PuTY6kWT!y6e%Ubr;<pm+MVcYu&g>OSnuVMpq({5R3{%mq!;>rKgOI$oT=E
zz=(+44=}jN{R|VIAa*rLGdOGQ$Ju+Wb6%GIsoL|~<6i*t_;sz#cK&v2Zn!{*o7NgZ
zTJ&}u4RNSqlS<+~K2}Ut9s4M(60)ZC=fJMp<+IQ|Dlgk7a|CtO-LKi<nePy0OiNry
zMPcPq;wineuAqaE3_@-P3c3g}?@+-Hf*d%0-Q95%^b%6RiSO3-C$>E=OrZ}0GWrQE
z--L7wVkny5BW#HO`iQt{t!UD*?bZl+b4#3N+SD}-W3XhH;we{>P{6o&&0S_Q%T8GJ
zc2{iQK6XOK4@5nGbB+P<lld3GNJt>bD05b3Cgw!p9?BgDF=&iY8yuw=^^Xh8Eu0b3
zXyqjtj$_EeU`}(jjZga)C_t{UxB{s$ryF^r^W5k*dLHoewlUNcNPiK~KLu0_V}w^n
y?kdcY5yhaw14h@I1~u-0#bp+5np9B41lLP^62wX5u?(~`O*X7Xb5mTN2HpX-v{5$z