haraps 1.0.5 → 1.0.6

package/dev.ps1

@@ -0,0 +1,409 @@
+# =============================================
+# Medizys Local Development Runner
+# =============================================
+# Starts the Worker and Next.js frontend
+# using concurrently in a single terminal window.
+
+Write-Host ""
+Write-Host "=============================================" -ForegroundColor Cyan
+Write-Host "  🚀 Medizys Local Dev Server" -ForegroundColor Cyan
+Write-Host "=============================================" -ForegroundColor Cyan
+Write-Host ""
+Write-Host "  Backend             → http://localhost:8787" -ForegroundColor Green
+Write-Host "  Frontend            → http://localhost:3000" -ForegroundColor Blue
+Write-Host ""
+Write-Host "  Starting unified development environment..." -ForegroundColor Yellow
+Write-Host "=============================================" -ForegroundColor Cyan
+Write-Host ""
+
+# Cleanup zombie worker processes and ports to prevent conflicts
+Write-Host "  Performing aggressive process cleanup..." -ForegroundColor Gray
+
+# Define processes to kill
+$procNames = @("workerd", "node", "concurrently")
+
+foreach ($procName in $procNames) {
+    $procs = Get-Process $procName -ErrorAction SilentlyContinue
+    if ($procs) {
+        Write-Host "  Stopping $procName ($($procs.Count) instances)..." -ForegroundColor Yellow
+        $procs | Stop-Process -Force -ErrorAction SilentlyContinue
+    }
+}
+
+# Active verification loop to ensure all target processes have fully exited
+$maxWaitSeconds = 5
+$stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
+while ($stopwatch.Elapsed.TotalSeconds -lt $maxWaitSeconds) {
+    $remainingProcs = Get-Process $procNames -ErrorAction SilentlyContinue
+    if (-not $remainingProcs) {
+        break
+    }
+    Start-Sleep -Milliseconds 200
+}
+
+# Function to robustly remove a directory with retry logic
+function Remove-CacheDirectory($path, $label) {
+    if (Test-Path $path) {
+        Write-Host "  Purging $label cache ($path)..." -ForegroundColor Gray
+        $attempts = 0
+        $maxAttempts = 5
+        $success = $false
+
+        while ($attempts -lt $maxAttempts -and -not $success) {
+            try {
+                Remove-Item -Recurse -Force $path -ErrorAction Stop
+                $success = $true
+            } catch {
+                $attempts++
+                if ($attempts -lt $maxAttempts) {
+                    Write-Host "    Lock detected on $path. Retrying ($attempts/$maxAttempts)..." -ForegroundColor DarkYellow
+                    Start-Sleep -Milliseconds (300 * $attempts)
+                } else {
+                    Write-Host "    Warning: Could not fully purge $path. Some files may be locked." -ForegroundColor Red
+                }
+            }
+        }
+    }
+}
+
+# Hard clear of wrangler state and Next.js cache to prevent Turbopack panics and corrupted dependency graphs
+Remove-CacheDirectory "worker/.wrangler" "wrangler state"
+Remove-CacheDirectory "frontend/.next" "frontend Turbopack cache"
+
+$ports = @(8787, 3000)
+foreach ($port in $ports) {
+    Write-Host "  Ensuring port $port is free..." -ForegroundColor Gray
+    $retryCount = 0
+    while ($retryCount -lt 5) {
+        $netstatOutput = netstat -ano | Select-String ":$port\s+.*LISTENING\s+(\d+)"
+        if ($netstatOutput) {
+            $targetPid = $netstatOutput.Matches[0].Groups[1].Value
+            Write-Host "  Port $port occupied by PID $targetPid. Terminating..." -ForegroundColor Red
+            Stop-Process -Id $targetPid -Force -ErrorAction SilentlyContinue
+            Start-Sleep -Seconds 1
+            $retryCount++
+        } else {
+            break
+        }
+    }
+}
+
+# Telegram watcher disabled by user request
+# Write-Host "  Starting Telegram watcher in background..." -ForegroundColor Magenta
+# $watcherJob = Start-Job -ScriptBlock {
+#     & "$using:PSScriptRoot\scripts\telegram-watcher.ps1"
+# }
+# Write-Host "  Telegram watcher running (Job ID: $($watcherJob.Id))" -ForegroundColor Magenta
+# Write-Host "  Reply to @mediisysbot on Telegram to queue instructions." -ForegroundColor DarkMagenta
+# Write-Host ""
+
+# Disable wrangler usage metrics prompt to prevent concurrently from hanging
+$env:WRANGLER_SEND_METRICS = "false"
+
+# Limit Node.js memory to prevent OOM crashes while providing 4GB for Next.js App Router
+$env:NODE_OPTIONS = "--max-old-space-size=4096"
+
+# Run the monorepo dev command through a Node.js wrapper to capture logs
+# and listen for the 'c' keypress to copy output to the clipboard.
+Write-Host "Starting development environment..." -ForegroundColor Green
+$runnerScript = @'
+const { spawn, execSync } = require('child_process');
+let buffer = '';
+let workerChild;
+let frontendChild;
+let lastRestartTime = 0;
+const startTime = Date.now();
+
+function formatSize(bytes) {
+    if (bytes < 1024) return bytes + 'B';
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + 'KB';
+    return (bytes / (1024 * 1024)).toFixed(1) + 'MB';
+}
+
+function formatUptime() {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    const m = Math.floor(elapsed / 60).toString().padStart(2, '0');
+    const s = (elapsed % 60).toString().padStart(2, '0');
+    const h = Math.floor(elapsed / 3600);
+    if (h > 0) return `${h}h ${m}m ${s}s`;
+    return `${m}m ${s}s`;
+}
+
+let lastRows = 0;
+let lastCols = 0;
+
+function updateLegend() {
+    if (!process.stdout.isTTY) return;
+    const rows = process.stdout.rows || 30;
+    const cols = process.stdout.columns || 80;
+    
+    // Set scrolling region only if changed (DECSTBM homes the cursor to 1,1!)
+    if (rows !== lastRows || cols !== lastCols) {
+        process.stdout.write(`\x1b[1;${rows - 2}r`);
+        lastRows = rows;
+        lastCols = cols;
+    }
+    
+    const lineCount = (buffer.match(/\n/g) || []).length;
+    const sizeStr = formatSize(Buffer.byteLength(buffer, 'utf8'));
+    const uptimeStr = formatUptime();
+    const legend1 = ` [Copy] 'c': All (${lineCount}L / ${sizeStr}) | 's': 500L | 'w': Backend | 'f': Frontend | 'e': Errors `;
+    const legend2 = ` [System] Uptime: ${uptimeStr} | 'x': Clear | 'r': Restart ALL | '1': Frontend | '2': Backend | 'q': Quit | 'Q': Clean & Quit `;
+    
+    // Draw legend
+    process.stdout.write(`\x1b[s`); // save cursor
+    process.stdout.write(`\x1b[${rows - 1};1H\x1b[42m\x1b[30m${legend1.padEnd(cols)}\x1b[0m`);
+    process.stdout.write(`\x1b[${rows};1H\x1b[42m\x1b[30m${legend2.padEnd(cols)}\x1b[0m`);
+    process.stdout.write(`\x1b[u`); // restore cursor
+}
+
+let legendInterval;
+function startLegendUpdater() {
+    if (legendInterval) clearInterval(legendInterval);
+    legendInterval = setInterval(() => {
+        updateLegend();
+    }, 1000);
+}
+
+function cleanupLegend() {
+    if (legendInterval) clearInterval(legendInterval);
+    if (!process.stdout.isTTY) return;
+    process.stdout.write('\x1b[r'); // reset scrolling region
+}
+
+process.stdout.on('resize', () => {
+    if (!process.stdout.isTTY) return;
+    cleanupLegend();
+    console.clear();
+    lastRows = 0;
+    updateLegend();
+});
+
+function extractErrors(text) {
+    const lines = text.split('\n');
+    const errorPattern = /(error|exception|fail|⨯|✗|traceback)/i;
+    let inErrorBlock = false;
+    let blockStart = 0;
+    const blocks = [];
+    
+    for (let i = 0; i < lines.length; i++) {
+        // Check for error keywords or stack trace lines
+        if (errorPattern.test(lines[i]) || (inErrorBlock && lines[i].trim().startsWith('at '))) {
+            if (!inErrorBlock) {
+                inErrorBlock = true;
+                blockStart = Math.max(0, i - 2); // 2 lines of context before
+            }
+        } else {
+            if (inErrorBlock) {
+                // If the next line is empty, we might just be between stack traces
+                if (lines[i].trim() === '') continue;
+                
+                // End of error block
+                const blockEnd = Math.min(lines.length - 1, i + 2); // 2 lines of context after
+                blocks.push(lines.slice(blockStart, blockEnd + 1).join('\n'));
+                inErrorBlock = false;
+            }
+        }
+    }
+    if (inErrorBlock) {
+        blocks.push(lines.slice(blockStart).join('\n'));
+    }
+    
+    return blocks.length > 0 ? blocks.join('\n\n--- [Next Error Block] ---\n\n') : '';
+}
+
+function formatPrefix(isError, source) {
+    const d = new Date();
+    const ts = String(d.getHours()).padStart(2, '0') + ':' + 
+               String(d.getMinutes()).padStart(2, '0') + ':' + 
+               String(d.getSeconds()).padStart(2, '0');
+    
+    // Cyan for worker, Magenta for frontend
+    const color = source === 'worker' ? '\x1b[36m' : '\x1b[35m';
+    const tag = source === 'worker' ? '[BACKEND]' : '[FRONTEND]';
+    return `\x1b[90m[${ts}]\x1b[0m ${color}${tag}\x1b[0m `;
+}
+
+function createStreamHandler(isError, source) {
+    let remainder = '';
+    return (d) => {
+        const chunk = remainder + d.toString();
+        const lines = chunk.split('\n');
+        remainder = lines.pop();
+        for (let line of lines) {
+            // Strip terminal-clearing and cursor-resetting escape codes
+            line = line.replace(/\x1b\[[23]J/g, '').replace(/\x1b\[[0-9;]*H/g, '').replace(/\x1bc/g, '');
+            // Strip cursor up/down and line clear codes
+            line = line.replace(/\x1b\[[0-9]*[A-G]/g, '').replace(/\x1b\[[0-9]*[K]/g, '');
+            // Strip carriage returns which cause overwrite from start of line
+            line = line.replace(/\r/g, '');
+            
+            // Remove concurrently's prefix so we can add our own clean one
+            line = line.replace(/^\[[^\]]+\]\s*/, '');
+
+            if (line.trim() === '') continue;
+
+            const prefix = formatPrefix(isError, source);
+            const out = prefix + line + '\n';
+            
+            if (isError) process.stderr.write(out);
+            else process.stdout.write(out);
+            buffer += out;
+        }
+        if (buffer.length > 1000000) {
+            const idx = buffer.indexOf('\n', buffer.length - 500000);
+            buffer = buffer.slice(idx === -1 ? -500000 : idx + 1);
+        }
+    };
+}
+
+function startWorker() {
+    workerChild = spawn('npx.cmd', ['concurrently', '-c', 'cyan', '-n', 'worker', '"npm run dev --prefix worker"'], {
+        env: { ...process.env, FORCE_COLOR: '1' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        shell: true
+    });
+    workerChild.stdout.on('data', createStreamHandler(false, 'worker'));
+    workerChild.stderr.on('data', createStreamHandler(true, 'worker'));
+}
+
+function startFrontend() {
+    frontendChild = spawn('npx.cmd', ['concurrently', '-c', 'magenta', '-n', 'frontend', '"npm run dev --prefix frontend"'], {
+        env: { ...process.env, FORCE_COLOR: '1' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        shell: true
+    });
+    frontendChild.stdout.on('data', createStreamHandler(false, 'frontend'));
+    frontendChild.stderr.on('data', createStreamHandler(true, 'frontend'));
+}
+
+function startServices() {
+    startWorker();
+    startFrontend();
+}
+
+console.clear();
+updateLegend();
+startLegendUpdater();
+startServices();
+
+if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', k => {
+        const now = Date.now();
+        if (k === 'c' || k === 'C') {
+            const clean = buffer.replace(/\x1B(?:[@-Z\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+            if (!clean.trim()) {
+                console.log('\n\x1b[33m⚠️ Buffer is empty.\x1b[0m\n');
+                return;
+            }
+            try {
+                execSync('clip', { input: clean });
+                console.log('\n\x1b[32m📋 Copied ALL logs to clipboard!\x1b[0m\n');
+            } catch (e) {}
+        } else if (k === 's' || k === 'S') {
+            const clean = buffer.replace(/\x1B(?:[@-Z\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+            const shortLines = clean.split('\n').slice(-500).join('\n');
+            try {
+                execSync('clip', { input: shortLines });
+                console.log('\n\x1b[32m📋 Copied last 500 lines to clipboard!\x1b[0m\n');
+            } catch (e) {}
+        } else if (k === 'w' || k === 'W') {
+            const clean = buffer.replace(/\x1B(?:[@-Z\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+            const workerLogs = clean.split('\n').filter(l => l.includes('[BACKEND]')).slice(-1000).join('\n');
+            try {
+                execSync('clip', { input: workerLogs });
+                console.log('\n\x1b[32m📋 Copied BACKEND logs to clipboard!\x1b[0m\n');
+            } catch (e) {}
+        } else if (k === 'f' || k === 'F') {
+            const clean = buffer.replace(/\x1B(?:[@-Z\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+            const frontendLogs = clean.split('\n').filter(l => l.includes('[FRONTEND]')).slice(-1000).join('\n');
+            try {
+                execSync('clip', { input: frontendLogs });
+                console.log('\n\x1b[32m📋 Copied FRONTEND logs to clipboard!\x1b[0m\n');
+            } catch (e) {}
+        } else if (k === 'e' || k === 'E') {
+            const clean = buffer.replace(/\x1B(?:[@-Z\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+            const errors = extractErrors(clean);
+            if (errors) {
+                try {
+                    execSync('clip', { input: errors });
+                    console.log('\n\x1b[31m🚨 Errors copied to clipboard!\x1b[0m\n');
+                } catch (e) {}
+            } else {
+                console.log('\n\x1b[32m✅ No errors detected.\x1b[0m\n');
+            }
+        } else if (k === 'r' || k === 'R') {
+            if (now - lastRestartTime < 1000) return;
+            lastRestartTime = now;
+            console.log('\n\x1b[33m🔄 Restarting ALL services...\x1b[0m\n');
+            if (workerChild) try { execSync('taskkill /pid ' + workerChild.pid + ' /t /f', { stdio: 'ignore' }); } catch(e) {}
+            if (frontendChild) try { execSync('taskkill /pid ' + frontendChild.pid + ' /t /f', { stdio: 'ignore' }); } catch(e) {}
+            startServices();
+        } else if (k === '1') {
+            if (now - lastRestartTime < 1000) return;
+            lastRestartTime = now;
+            console.log('\n\x1b[33m🔄 Restarting FRONTEND...\x1b[0m\n');
+            if (frontendChild) try { execSync('taskkill /pid ' + frontendChild.pid + ' /t /f', { stdio: 'ignore' }); } catch(e) {}
+            startFrontend();
+        } else if (k === '2') {
+            if (now - lastRestartTime < 1000) return;
+            lastRestartTime = now;
+            console.log('\n\x1b[33m🔄 Restarting BACKEND...\x1b[0m\n');
+            if (workerChild) try { execSync('taskkill /pid ' + workerChild.pid + ' /t /f', { stdio: 'ignore' }); } catch(e) {}
+            startWorker();
+        } else if (k === 'x' || k === 'X') {
+            console.clear();
+            buffer = '';
+            lastRows = 0;
+            updateLegend();
+            console.log('\x1b[32m🧹 Terminal cleared.\x1b[0m\n');
+        } else if (k === '\u0003' || k === 'q') {
+            console.log('\n\x1b[33mStopping services...\x1b[0m');
+            cleanupLegend();
+            if (workerChild) try { execSync('taskkill /pid ' + workerChild.pid + ' /t /f', { stdio: 'ignore' }); } catch(e) {}
+            if (frontendChild) try { execSync('taskkill /pid ' + frontendChild.pid + ' /t /f', { stdio: 'ignore' }); } catch(e) {}
+            process.exit();
+        } else if (k === 'Q') {
+            console.log('\n\x1b[31m🧹 Cleaning cache and dependencies, then stopping services...\x1b[0m');
+            cleanupLegend();
+            if (workerChild) try { execSync('taskkill /pid ' + workerChild.pid + ' /t /f', { stdio: 'ignore' }); } catch(e) {}
+            if (frontendChild) try { execSync('taskkill /pid ' + frontendChild.pid + ' /t /f', { stdio: 'ignore' }); } catch(e) {}
+            
+            console.log('\x1b[33mRemoving node_modules, .next, and .wrangler...\x1b[0m');
+            const fs = require('fs');
+            const pathsToClean = ['frontend/.next', 'worker/.wrangler', 'frontend/node_modules', 'worker/node_modules', 'node_modules'];
+            for (const p of pathsToClean) {
+                try { fs.rmSync(p, { recursive: true, force: true }); } catch(e) {}
+            }
+            console.log('\x1b[32mCleanup complete.\x1b[0m');
+            process.exit();
+        }
+    });
+}
+
+// Cleanup on unexpected exits
+process.on('SIGINT', () => {
+    cleanupLegend();
+    process.exit();
+});
+process.on('exit', () => {
+    cleanupLegend();
+    console.clear();
+});
+'@
+$runnerPath = Join-Path $env:TEMP "mediqueue-dev-runner.js"
+Set-Content -Path $runnerPath -Value $runnerScript -Encoding UTF8
+node $runnerPath
+
+# Cleanup watcher on exit
+if ($null -ne (Get-Variable -Name watcherJob -ErrorAction SilentlyContinue)) {
+    if ($watcherJob) {
+        Stop-Job -Job $watcherJob -ErrorAction SilentlyContinue
+        Remove-Job -Job $watcherJob -ErrorAction SilentlyContinue
+    }
+}