@paa1997/metho 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paa1997/metho",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Automated recon pipeline: subfinder → gau → filter → katana → findsomething",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -1,10 +1,11 @@
 import { Command } from 'commander';
 import { resolve } from 'path';
 import { existsSync } from 'fs';
-import { runPipeline } from './engine.js';
+import { createInterface } from 'readline';
+import { runPipeline, findIncompleteRun } from './engine.js';
 import { createLogger } from './logger.js';
 
-export function run() {
+export async function run() {
   const program = new Command();
 
   program
@@ -66,11 +67,35 @@ export function run() {
     katanaDepth: parseInt(opts.katanaDepth, 10),
     findsomethingPath: opts.findsomethingPath || '',
     debug: opts.debug || false,
+    resumeDir: null,
   };
 
+  // Check for incomplete previous run
+  const incomplete = findIncompleteRun(config.outputDir, config.domain, config.domainList);
+  if (incomplete) {
+    const stepNames = incomplete.completedSteps.map(s => s.name).join(', ');
+    console.log(`\n  Previous incomplete run found: ${incomplete.runDir}`);
+    console.log(`  Completed steps: ${stepNames}`);
+
+    const answer = await askUser('  Resume this run? [Y/n] ');
+    if (answer.toLowerCase() !== 'n') {
+      config.resumeDir = incomplete.runDir;
+    }
+  }
+
   const logger = createLogger(config.debug);
   runPipeline(config, logger).catch((err) => {
     logger.error(`Pipeline failed: ${err.message}`);
     process.exit(1);
   });
 }
+
+function askUser(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}

package/src/engine.js

@@ -1,5 +1,5 @@
-import { mkdirSync, writeFileSync, copyFileSync, readFileSync, existsSync } from 'fs';
-import { join, basename } from 'path';
+import { mkdirSync, writeFileSync, copyFileSync, readFileSync, existsSync, readdirSync, statSync, rmSync } from 'fs';
+import { join, basename, resolve } from 'path';
 import { setupSignalHandlers, getGlobalContext, createRunContext } from './signals.js';
 import { ensureTools } from './tools/manager.js';
 import { SubfinderStep } from './steps/subfinder.js';
@@ -9,8 +9,22 @@ import { FilterStep } from './steps/filter.js';
 import { KatanaStep } from './steps/katana.js';
 import { FindSomethingStep } from './steps/findsomething.js';
 
+// Step output files in order
+const STEP_FILES = [
+  { num: 1, file: '01-subdomains.txt', name: 'Subfinder' },
+  { num: 2, file: '02-live-subdomains.txt', name: 'Subdomain Probe' },
+  { num: 3, file: '03-passive-urls.txt', name: 'GAU' },
+  { num: 4, file: '04-live-urls.txt', name: 'Filter' },
+  { num: 5, file: '05-crawled-urls.txt', name: 'Katana' },
+  { num: 6, file: '06-secrets.txt', name: 'FindSomething' },
+];
+
+function getRunLabel(domain, domainList) {
+  return domain || basename(domainList, '.txt');
+}
+
 function makeRunDir(outputDir, domain, domainList) {
-  const label = domain || basename(domainList, '.txt');
+  const label = getRunLabel(domain, domainList);
   const now = new Date();
   const ts = now.toISOString().replace(/[-:T]/g, '').replace(/\..+/, '').replace(/(\d{8})(\d{6})/, '$1-$2');
   const dirName = `${label}-${ts}`;
@@ -19,6 +33,82 @@ function makeRunDir(outputDir, domain, domainList) {
   return runDir;
 }
 
+/**
+ * Check if a file exists and has content (>0 bytes).
+ */
+function fileHasContent(filePath) {
+  try {
+    return existsSync(filePath) && statSync(filePath).size > 0;
+  } catch { return false; }
+}
+
+/**
+ * Find the most recent incomplete run for a given domain/label.
+ * Returns { runDir, completedSteps, lastCompletedFile } or null.
+ */
+export function findIncompleteRun(outputDir, domain, domainList) {
+  const label = getRunLabel(domain, domainList);
+  const absOutputDir = resolve(outputDir);
+
+  if (!existsSync(absOutputDir)) return null;
+
+  let dirs;
+  try {
+    dirs = readdirSync(absOutputDir)
+      .filter(d => d.startsWith(label + '-'))
+      .filter(d => {
+        try { return statSync(join(absOutputDir, d)).isDirectory(); } catch { return false; }
+      })
+      .sort()
+      .reverse(); // most recent first
+  } catch { return null; }
+
+  for (const dir of dirs) {
+    const runDir = join(absOutputDir, dir);
+    const completed = [];
+    let lastFile = null;
+
+    for (const step of STEP_FILES) {
+      const filePath = join(runDir, step.file);
+      if (fileHasContent(filePath)) {
+        completed.push({ num: step.num, name: step.name, file: step.file });
+        lastFile = filePath;
+      } else {
+        break; // steps must be sequential
+      }
+    }
+
+    // Incomplete = has input file + at least 1 completed step but not all 6
+    const hasInput = fileHasContent(join(runDir, '00-input-domains.txt'));
+    if (hasInput && completed.length > 0 && completed.length < STEP_FILES.length) {
+      return { runDir, completedSteps: completed, lastCompletedFile: lastFile, label };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Delete all run directories in the output directory.
+ */
+export function deleteAllRuns(outputDir) {
+  const absOutputDir = resolve(outputDir);
+  if (!existsSync(absOutputDir)) return 0;
+
+  let count = 0;
+  const entries = readdirSync(absOutputDir);
+  for (const entry of entries) {
+    const fullPath = join(absOutputDir, entry);
+    try {
+      if (statSync(fullPath).isDirectory()) {
+        rmSync(fullPath, { recursive: true, force: true });
+        count++;
+      }
+    } catch { /* ignore */ }
+  }
+  return count;
+}
+
 /**
  * Run the full recon pipeline.
  * @param {object} config - pipeline configuration
@@ -34,21 +124,41 @@ export async function runPipeline(config, logger, ctx) {
 
   logger.banner('METHO - Automated Recon Pipeline');
 
-  // Create output directory
-  const runDir = makeRunDir(config.outputDir, config.domain, config.domainList);
-  logger.info(`Output directory: ${runDir}`);
+  // Determine run directory (resume existing or create new)
+  let runDir;
+  let resumeFrom = 0; // 0 = no resume, N = resume after step N
+
+  if (config.resumeDir && existsSync(config.resumeDir)) {
+    runDir = config.resumeDir;
+    logger.info(`Resuming run in: ${runDir}`);
+
+    // Detect which steps are already complete
+    for (const step of STEP_FILES) {
+      if (fileHasContent(join(runDir, step.file))) {
+        resumeFrom = step.num;
+      } else {
+        break;
+      }
+    }
+    logger.info(`Resuming after step ${resumeFrom} (${STEP_FILES[resumeFrom - 1]?.name || 'none'})`);
+  } else {
+    runDir = makeRunDir(config.outputDir, config.domain, config.domainList);
+    logger.info(`Output directory: ${runDir}`);
+  }
 
-  // Set up log file
+  // Set up log file (append if resuming)
   const logFile = join(runDir, 'metho.log');
   logger.setLogFile(logFile);
   logger.debug(`Config: ${JSON.stringify(config, null, 2)}`);
 
   // Prepare input file
   const inputFile = join(runDir, '00-input-domains.txt');
-  if (config.domain) {
-    writeFileSync(inputFile, config.domain + '\n');
-  } else {
-    copyFileSync(config.domainList, inputFile);
+  if (!config.resumeDir) {
+    if (config.domain) {
+      writeFileSync(inputFile, config.domain + '\n');
+    } else {
+      copyFileSync(config.domainList, inputFile);
+    }
   }
   ctx.trackFile(inputFile, 'Input domains');
   logger.info(`Input: ${config.domain || config.domainList}`);
@@ -59,14 +169,29 @@ export async function runPipeline(config, logger, ctx) {
 
   // Track results for final summary
   const results = [];
+
+  // If resuming, set currentInput to the last completed step's output
   let currentInput = inputFile;
+  if (resumeFrom > 0) {
+    const lastFile = join(runDir, STEP_FILES[resumeFrom - 1].file);
+    if (fileHasContent(lastFile)) currentInput = lastFile;
+  }
   let stepNum = 0;
 
+  // Helper: check if a step should be skipped because it's already done (resume)
+  function isResumeComplete(num) { return resumeFrom >= num; }
+
   // --- Step 1: Subfinder ---
   stepNum++;
   const subdomainsFile = join(runDir, '01-subdomains.txt');
   if (config.skipSubfinder) {
     logger.step(stepNum, 'Subfinder (subdomain enumeration)', 'skip');
+  } else if (isResumeComplete(1)) {
+    const lines = readFileSync(subdomainsFile, 'utf-8').trim().split('\n').length;
+    logger.step(stepNum, `Subfinder → ${lines} subdomains (cached)`, 'done');
+    results.push({ step: 'Subfinder', file: subdomainsFile, lines });
+    logger.result('Subfinder', subdomainsFile, lines);
+    currentInput = subdomainsFile;
   } else {
     logger.step(stepNum, 'Subfinder (subdomain enumeration)', 'start');
     const subfinder = new SubfinderStep(logger, ctx);
@@ -84,6 +209,12 @@ export async function runPipeline(config, logger, ctx) {
   const liveSubsFile = join(runDir, '02-live-subdomains.txt');
   if (config.skipSubdomainProbe) {
     logger.step(stepNum, 'Subdomain Probe (httpx)', 'skip');
+  } else if (isResumeComplete(2)) {
+    const lines = readFileSync(liveSubsFile, 'utf-8').trim().split('\n').length;
+    logger.step(stepNum, `Subdomain Probe → ${lines} live subdomains (cached)`, 'done');
+    results.push({ step: 'Subdomain Probe', file: liveSubsFile, lines });
+    logger.result('Subdomain Probe', liveSubsFile, lines);
+    currentInput = liveSubsFile;
   } else {
     logger.step(stepNum, 'Subdomain Probe (httpx on subdomains)', 'start');
     const probe = new SubdomainProbeStep(logger, ctx);
@@ -101,6 +232,12 @@ export async function runPipeline(config, logger, ctx) {
   const gauFile = join(runDir, '03-passive-urls.txt');
   if (config.skipGau) {
     logger.step(stepNum, 'GAU (passive URL crawling)', 'skip');
+  } else if (isResumeComplete(3)) {
+    const lines = readFileSync(gauFile, 'utf-8').trim().split('\n').length;
+    logger.step(stepNum, `GAU → ${lines} URLs (cached)`, 'done');
+    results.push({ step: 'GAU', file: gauFile, lines });
+    logger.result('GAU', gauFile, lines);
+    currentInput = gauFile;
   } else {
     logger.step(stepNum, 'GAU (passive URL crawling)', 'start');
     const gau = new GauStep(logger, ctx);
@@ -118,6 +255,12 @@ export async function runPipeline(config, logger, ctx) {
   const liveUrlsFile = join(runDir, '04-live-urls.txt');
   if (config.skipFilter) {
     logger.step(stepNum, 'Filter (extension + liveness)', 'skip');
+  } else if (isResumeComplete(4)) {
+    const lines = readFileSync(liveUrlsFile, 'utf-8').trim().split('\n').length;
+    logger.step(stepNum, `Filter → ${lines} live URLs (cached)`, 'done');
+    results.push({ step: 'Filter', file: liveUrlsFile, lines });
+    logger.result('Filter', liveUrlsFile, lines);
+    currentInput = liveUrlsFile;
   } else {
     logger.step(stepNum, 'Filter (extension + liveness)', 'start');
     const filter = new FilterStep(logger, ctx);
@@ -135,6 +278,12 @@ export async function runPipeline(config, logger, ctx) {
   const crawledFile = join(runDir, '05-crawled-urls.txt');
   if (config.skipKatana) {
     logger.step(stepNum, 'Katana (active crawling)', 'skip');
+  } else if (isResumeComplete(5)) {
+    const lines = readFileSync(crawledFile, 'utf-8').trim().split('\n').length;
+    logger.step(stepNum, `Katana → ${lines} URLs (cached)`, 'done');
+    results.push({ step: 'Katana', file: crawledFile, lines });
+    logger.result('Katana', crawledFile, lines);
+    currentInput = crawledFile;
   } else {
     logger.step(stepNum, 'Katana (active crawling)', 'start');
     const katana = new KatanaStep(logger, ctx);
@@ -152,6 +301,11 @@ export async function runPipeline(config, logger, ctx) {
   const secretsFile = join(runDir, '06-secrets.txt');
   if (config.skipFindsomething) {
     logger.step(stepNum, 'FindSomething (secret scanning)', 'skip');
+  } else if (isResumeComplete(6)) {
+    const lines = readFileSync(secretsFile, 'utf-8').trim().split('\n').length;
+    logger.step(stepNum, `FindSomething → ${lines} findings (cached)`, 'done');
+    results.push({ step: 'FindSomething', file: secretsFile, lines });
+    logger.result('FindSomething', secretsFile, lines);
   } else {
     logger.step(stepNum, 'FindSomething (secret scanning)', 'start');
     const fs = new FindSomethingStep(logger, ctx);

package/src/gui.html

@@ -256,6 +256,50 @@
     font-family: 'Cascadia Code', 'Fira Code', monospace;
   }
   .run-dir-bar strong { color: #a78bfa; }
+
+  /* Modal overlay */
+  .modal-overlay {
+    display: none; position: fixed; top: 0; left: 0; right: 0; bottom: 0;
+    background: rgba(0,0,0,0.7); z-index: 1000;
+    align-items: center; justify-content: center;
+  }
+  .modal-overlay.open { display: flex; }
+  .modal {
+    background: #1a1a2e; border: 1px solid #2a2a4a; border-radius: 12px;
+    padding: 28px 32px; max-width: 500px; width: 90%; box-shadow: 0 20px 60px rgba(0,0,0,0.5);
+  }
+  .modal h3 {
+    font-size: 16px; color: #a78bfa; margin-bottom: 14px; font-weight: 700;
+  }
+  .modal p { color: #bbb; font-size: 13px; line-height: 1.6; margin-bottom: 12px; }
+  .modal .step-list {
+    background: #12121f; border: 1px solid #2a2a4a; border-radius: 6px;
+    padding: 10px 14px; margin-bottom: 16px; font-size: 12px; color: #22c55e;
+    font-family: 'Cascadia Code', 'Fira Code', monospace;
+  }
+  .modal-actions { display: flex; gap: 10px; justify-content: flex-end; }
+  .modal-actions .btn { padding: 8px 22px; font-size: 13px; }
+  .btn-secondary {
+    background: #2a2a4a; color: #ccc; border: 1px solid #3a3a5a; border-radius: 6px;
+    padding: 8px 22px; font-size: 13px; font-weight: 600; cursor: pointer;
+    transition: all 0.15s;
+  }
+  .btn-secondary:hover { background: #3a3a5a; color: #fff; }
+  .btn-danger {
+    background: #dc2626; color: #fff; border: none; border-radius: 6px;
+    padding: 8px 22px; font-size: 13px; font-weight: 600; cursor: pointer;
+    transition: all 0.15s;
+  }
+  .btn-danger:hover { background: #ef4444; }
+
+  /* Settings gear */
+  .btn-gear {
+    background: none; border: 1px solid #2a2a4a; border-radius: 6px;
+    color: #888; font-size: 18px; width: 38px; height: 38px; cursor: pointer;
+    display: flex; align-items: center; justify-content: center;
+    transition: all 0.15s;
+  }
+  .btn-gear:hover { color: #a78bfa; border-color: #7c3aed; }
 </style>
 </head>
 <body>
@@ -309,6 +353,7 @@
     <div class="actions">
       <button class="btn btn-run" id="btn-run" onclick="startPipeline()">Run</button>
       <button class="btn btn-stop" id="btn-stop-all" onclick="stopAllRuns()" disabled>Stop All</button>
+      <button class="btn-gear" onclick="openSettings()" title="Settings">&#9881;</button>
     </div>
   </div>
 
@@ -318,6 +363,51 @@
   <div id="no-runs" class="no-runs-placeholder">Run the pipeline to see results here</div>
 </div>
 
+<!-- Resume modal -->
+<div class="modal-overlay" id="resume-modal">
+  <div class="modal">
+    <h3>Previous Run Found</h3>
+    <p>An incomplete run was found for <strong id="resume-label"></strong></p>
+    <p>Completed steps:</p>
+    <div class="step-list" id="resume-steps"></div>
+    <p>Would you like to resume from where it left off?</p>
+    <div class="modal-actions">
+      <button class="btn-secondary" onclick="dismissResume()">Start New</button>
+      <button class="btn btn-run" onclick="confirmResume()">Resume</button>
+    </div>
+  </div>
+</div>
+
+<!-- Settings modal -->
+<div class="modal-overlay" id="settings-modal">
+  <div class="modal">
+    <h3>Settings</h3>
+    <p>Manage your pipeline data and preferences.</p>
+    <div style="margin-top: 16px;">
+      <button class="btn-danger" onclick="confirmDeleteLogs()">Delete All Run Logs</button>
+      <p style="font-size: 11px; color: #666; margin-top: 8px;">
+        Removes all previous results and prevents resuming any past runs.
+      </p>
+    </div>
+    <div class="modal-actions" style="margin-top: 24px;">
+      <button class="btn-secondary" onclick="closeSettings()">Close</button>
+    </div>
+  </div>
+</div>
+
+<!-- Delete confirmation modal -->
+<div class="modal-overlay" id="delete-modal">
+  <div class="modal">
+    <h3>Confirm Deletion</h3>
+    <p>Are you sure you want to delete <strong>all</strong> run logs and results?</p>
+    <p style="color: #f59e0b;">This action cannot be undone and will prevent you from resuming any previous runs.</p>
+    <div class="modal-actions">
+      <button class="btn-secondary" onclick="closeDeleteModal()">Cancel</button>
+      <button class="btn-danger" onclick="executeDeleteLogs()">Delete Everything</button>
+    </div>
+  </div>
+</div>
+
 <!-- Template for a run panel (cloned per run) -->
 <template id="run-panel-template">
   <div class="run-panel">
@@ -359,6 +449,7 @@
 let eventSource = null;
 let sseConnected = false;
 let activeRunId = null; // currently viewed tab
+let sseRetryTimer = null;
 
 // Per-run state: runId → { label, status, logLines, resultCount, el, tabEl }
 const runs = {};
@@ -390,55 +481,60 @@ function esc(str) {
   return d.innerHTML;
 }
 
-// ---- SSE Connection ----
+// ---- SSE Connection (with auto-reconnect) ----
+
+function connectSSE() {
+  if (eventSource) { eventSource.close(); eventSource = null; }
+  sseConnected = false;
+  if (sseRetryTimer) { clearTimeout(sseRetryTimer); sseRetryTimer = null; }
+
+  const es = new EventSource('/events');
+
+  es.onmessage = (e) => {
+    try {
+      const data = JSON.parse(e.data);
+      if (data.type === 'connected') {
+        sseConnected = true;
+        eventSource = es;
+        return;
+      }
+      handleEvent(data);
+    } catch { /* ignore */ }
+  };
+
+  es.onerror = () => {
+    sseConnected = false;
+    eventSource = null;
+    es.close();
+    // Auto-reconnect after 2 seconds if there are running runs
+    const hasRunning = Object.values(runs).some(r => r.status === 'running');
+    if (hasRunning) {
+      sseRetryTimer = setTimeout(() => connectSSE(), 2000);
+    }
+  };
+}
 
 function ensureSSE() {
   if (eventSource && sseConnected) return Promise.resolve();
   return new Promise((resolve, reject) => {
-    if (eventSource) { eventSource.close(); eventSource = null; }
-    sseConnected = false;
-
-    const es = new EventSource('/events');
-    const timeout = setTimeout(() => { es.close(); reject(new Error('SSE timeout')); }, 5000);
-
-    es.onmessage = (e) => {
-      try {
-        const data = JSON.parse(e.data);
-        if (data.type === 'connected' && !sseConnected) {
-          sseConnected = true;
-          clearTimeout(timeout);
-          eventSource = es;
-          resolve();
-          return;
-        }
-        handleEvent(data);
-      } catch { /* ignore */ }
-    };
-
-    es.onerror = () => {
-      if (!sseConnected) {
-        clearTimeout(timeout);
-        es.close();
-        reject(new Error('SSE connection failed'));
-      } else {
-        sseConnected = false;
-        eventSource = null;
-      }
-    };
+    connectSSE();
+    // Wait for connection
+    let attempts = 0;
+    const check = setInterval(() => {
+      if (sseConnected) { clearInterval(check); resolve(); }
+      else if (++attempts > 25) { clearInterval(check); reject(new Error('SSE timeout')); }
+    }, 200);
   });
 }
 
 // ---- Start / Stop ----
 
-async function startPipeline() {
-  const domain = document.getElementById('domain').value.trim();
-  const domainList = document.getElementById('domainList').value.trim();
-  if (!domain && !domainList) { alert('Enter a domain or domain list file path'); return; }
-  if (domain && domainList) { alert('Use either domain or domain list, not both'); return; }
+let pendingResumeDir = null; // set when user chooses resume
 
-  const config = {
-    domain: domain || null,
-    domainList: domainList || null,
+function buildConfig() {
+  return {
+    domain: document.getElementById('domain').value.trim() || null,
+    domainList: document.getElementById('domainList').value.trim() || null,
     outputDir: document.getElementById('outputDir').value.trim() || './metho-results',
     findsomethingPath: document.getElementById('findsomethingPath').value.trim() || '',
     katanaDepth: parseInt(document.getElementById('katanaDepth').value) || 2,
@@ -450,6 +546,43 @@ async function startPipeline() {
     skipKatana: document.getElementById('skipKatana').checked,
     skipFindsomething: document.getElementById('skipFindsomething').checked,
   };
+}
+
+async function startPipeline() {
+  const domain = document.getElementById('domain').value.trim();
+  const domainList = document.getElementById('domainList').value.trim();
+  if (!domain && !domainList) { alert('Enter a domain or domain list file path'); return; }
+  if (domain && domainList) { alert('Use either domain or domain list, not both'); return; }
+
+  // Check for incomplete previous run
+  try {
+    const checkResp = await fetch('/check-resume', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        domain: domain || null,
+        domainList: domainList || null,
+        outputDir: document.getElementById('outputDir').value.trim() || './metho-results',
+      }),
+    });
+    const checkData = await checkResp.json();
+    if (checkData.hasIncomplete) {
+      // Show resume modal
+      pendingResumeDir = checkData.runDir;
+      document.getElementById('resume-label').textContent = checkData.label;
+      document.getElementById('resume-steps').textContent =
+        checkData.completedSteps.map(s => s.name).join(' -> ');
+      document.getElementById('resume-modal').classList.add('open');
+      return;
+    }
+  } catch { /* check failed, proceed with new run */ }
+
+  launchRun(null);
+}
+
+async function launchRun(resumeDir) {
+  const config = buildConfig();
+  if (resumeDir) config.resumeDir = resumeDir;
 
   try {
     await ensureSSE();
@@ -472,6 +605,53 @@ async function startPipeline() {
   }
 }
 
+function confirmResume() {
+  document.getElementById('resume-modal').classList.remove('open');
+  launchRun(pendingResumeDir);
+  pendingResumeDir = null;
+}
+
+function dismissResume() {
+  document.getElementById('resume-modal').classList.remove('open');
+  launchRun(null);
+  pendingResumeDir = null;
+}
+
+// ---- Settings ----
+
+function openSettings() {
+  document.getElementById('settings-modal').classList.add('open');
+}
+
+function closeSettings() {
+  document.getElementById('settings-modal').classList.remove('open');
+}
+
+function confirmDeleteLogs() {
+  document.getElementById('settings-modal').classList.remove('open');
+  document.getElementById('delete-modal').classList.add('open');
+}
+
+function closeDeleteModal() {
+  document.getElementById('delete-modal').classList.remove('open');
+}
+
+async function executeDeleteLogs() {
+  document.getElementById('delete-modal').classList.remove('open');
+  const outputDir = document.getElementById('outputDir').value.trim() || './metho-results';
+  try {
+    const resp = await fetch('/delete-logs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ outputDir }),
+    });
+    const data = await resp.json();
+    alert('Deleted ' + data.deleted + ' run(s).');
+  } catch (err) {
+    alert('Failed to delete: ' + err.message);
+  }
+}
+
 function stopAllRuns() {
   fetch('/stop', { method: 'POST', body: '{}' }).catch(() => {});
   for (const runId of Object.keys(runs)) {
@@ -619,9 +799,6 @@ function handleEvent(data) {
       if (runs[runId] && runs[runId].status === 'running') {
         setRunStatus(runId, 'stopped');
       }
-      if (data.activeRuns === 0 && eventSource) {
-        eventSource.close(); eventSource = null; sseConnected = false;
-      }
       break;
   }
 }
@@ -761,6 +938,27 @@ async function loadResultFile(filePath, runId, tabId) {
   }
 }
 
+// ---- Restore active runs on page load ----
+
+async function restoreActiveRuns() {
+  try {
+    const resp = await fetch('/status');
+    const data = await resp.json();
+    if (data.running > 0) {
+      // There are active runs — reconnect SSE and create placeholder tabs
+      for (const run of data.runs) {
+        if (!runs[run.runId]) {
+          createRunTab(run.runId, run.label);
+          addRunLog(run.runId, 'warn', 'Reconnected — earlier log history was lost');
+        }
+      }
+      connectSSE();
+    }
+  } catch { /* server not reachable, ignore */ }
+}
+
+window.addEventListener('load', restoreActiveRuns);
+
 async function copyTab(tabId) {
   const data = tabFileData[tabId];
   if (!data) return;

package/src/server.js

@@ -4,7 +4,7 @@ import { resolve, dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { exec } from 'child_process';
 import { createLogger } from './logger.js';
-import { runPipeline } from './engine.js';
+import { runPipeline, findIncompleteRun, deleteAllRuns } from './engine.js';
 import { createRunContext } from './signals.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -129,6 +129,7 @@ export function startServer(port = 3000) {
           katanaChunkSize: parseInt(params.katanaChunkSize, 10) || 1000,
           katanaDepth: parseInt(params.katanaDepth, 10) || 2,
           findsomethingPath: params.findsomethingPath || '',
+          resumeDir: params.resumeDir || null,
           debug: true,
         };
 
@@ -195,6 +196,39 @@ export function startServer(port = 3000) {
         }
       }
 
+      // POST /check-resume → check for incomplete runs
+      if (method === 'POST' && url === '/check-resume') {
+        const body = await readBody(req);
+        let params;
+        try { params = JSON.parse(body); } catch {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          return res.end(JSON.stringify({ error: 'Invalid JSON' }));
+        }
+        const outputDir = resolve(params.outputDir || './metho-results');
+        const result = findIncompleteRun(outputDir, params.domain || null, params.domainList || null);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        if (result) {
+          return res.end(JSON.stringify({
+            hasIncomplete: true,
+            runDir: result.runDir,
+            completedSteps: result.completedSteps,
+            label: result.label,
+          }));
+        }
+        return res.end(JSON.stringify({ hasIncomplete: false }));
+      }
+
+      // POST /delete-logs → delete all run directories
+      if (method === 'POST' && url === '/delete-logs') {
+        const body = await readBody(req);
+        let params = {};
+        try { params = JSON.parse(body); } catch { /* use defaults */ }
+        const outputDir = resolve(params.outputDir || './metho-results');
+        const count = deleteAllRuns(outputDir);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ ok: true, deleted: count }));
+      }
+
       // 404
       res.writeHead(404, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: 'Not found' }));
@@ -232,18 +266,6 @@ export function startServer(port = 3000) {
     } finally {
       activeRuns.delete(runId);
       broadcast({ type: 'run-ended', runId, activeRuns: activeRuns.size });
-
-      // Close SSE clients only when ALL runs are done
-      if (activeRuns.size === 0) {
-        setTimeout(() => {
-          if (activeRuns.size === 0) {
-            for (const client of sseClients) {
-              try { client.end(); } catch { /* ignore */ }
-            }
-            sseClients = [];
-          }
-        }, 3000);
-      }
     }
   }