jsana 1.0.1 → 1.0.3

package/bin/jsana.js

@@ -16,6 +16,7 @@ Options:
   -c, --concurrency <n>    Concurrent fetches (default: 50)
   -r, --retries <n>        Max retries per URL (default: 2)
   -t, --timeout <ms>       Request timeout in ms (default: 30000)
+  --resume                 Resume a previous interrupted scan
   --category <name>        Filter to specific categories (repeatable)
   -h, --help               Show this help
 
@@ -25,6 +26,7 @@ Categories:
 Examples:
   jsana urls.txt
   jsana urls.txt -o results.txt -c 100 --json
+  jsana urls.txt --resume -o results.txt    # resume interrupted scan
   jsana urls.txt --category secret --category xss-sink
 `;
 
@@ -37,6 +39,7 @@ function parseArgs(argv) {
     retries: 2,
     timeout: 30000,
     categories: [],
+    resume: false,
     help: false,
   };
 
@@ -56,6 +59,8 @@ function parseArgs(argv) {
         args.retries = parseInt(argv[++i], 10); break;
       case '-t': case '--timeout':
         args.timeout = parseInt(argv[++i], 10); break;
+      case '--resume':
+        args.resume = true; break;
       case '--category':
         args.categories.push(argv[++i]); break;
       default:
@@ -93,6 +98,7 @@ async function main() {
     retries: args.retries,
     timeout: args.timeout,
     categories: args.categories,
+    resume: args.resume,
   });
 }
 

package/lib/pipeline.js

@@ -1,4 +1,4 @@
-import { createReadStream } from 'node:fs';
+import { createReadStream, createWriteStream, existsSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { fetchUrl, closeAllPools } from './fetcher.js';
 import { scan } from './scanner.js';
@@ -7,7 +7,21 @@ import { Progress, countLines } from './progress.js';
 import { getPatterns } from './patterns.js';
 import { withRetry } from './retry.js';
 
-// Simple semaphore for concurrency control
+// Load already-processed URLs from the progress file
+async function loadDoneSet(progressFile) {
+  const done = new Set();
+  if (!existsSync(progressFile)) return done;
+  const rl = createInterface({
+    input: createReadStream(progressFile, { encoding: 'utf8' }),
+    crlfDelay: Infinity,
+  });
+  for await (const line of rl) {
+    if (line) done.add(line);
+  }
+  return done;
+}
+
+// Simple semaphore for concurrency control, with abort support
 class Semaphore {
   constructor(max) {
     this.max = max;
@@ -19,14 +33,23 @@ class Semaphore {
       this.current++;
       return Promise.resolve();
     }
-    return new Promise(resolve => this.queue.push(resolve));
+    return new Promise((resolve, reject) => {
+      this.queue.push({ resolve, reject });
+    });
   }
   release() {
     this.current--;
     if (this.queue.length > 0) {
       this.current++;
-      this.queue.shift()();
+      this.queue.shift().resolve();
+    }
+  }
+  // Reject all waiters so they unblock immediately
+  abortAll() {
+    for (const { reject } of this.queue) {
+      reject(new Error('aborted'));
     }
+    this.queue = [];
   }
 }
 
@@ -38,6 +61,7 @@ export async function run(urlsFile, opts) {
     retries = 2,
     timeout = 30000,
     categories = [],
+    resume = false,
   } = opts;
 
   const patterns = getPatterns(categories);
@@ -46,30 +70,75 @@ export async function run(urlsFile, opts) {
     return;
   }
 
+  // Resume support: progress file tracks processed URLs
+  const progressFile = output + '.progress';
+  let doneSet = new Set();
+  if (resume) {
+    doneSet = await loadDoneSet(progressFile);
+    if (doneSet.size > 0) {
+      process.stderr.write(`[jsana] Resuming — ${doneSet.size} URLs already processed, skipping.\n`);
+    }
+  }
+  const progressLog = createWriteStream(progressFile, { flags: resume ? 'a' : 'w', encoding: 'utf8' });
+
   // Pre-count lines for progress
   const totalLines = await countLines(urlsFile);
   const progress = new Progress(totalLines);
-  const reporter = new Reporter(output, { json });
+  const reporter = new Reporter(output, { json, append: resume });
   const sem = new Semaphore(concurrency);
 
   let shuttingDown = false;
+  let forceExit = false;
   const inFlight = new Set();
+  const abortController = new AbortController();
+
+  const fileStream = createReadStream(urlsFile, { encoding: 'utf8' });
+  const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
 
-  // Graceful shutdown
-  const shutdown = () => {
-    if (shuttingDown) return;
+  // Graceful shutdown: 1st Ctrl+C stops new work, 2nd force exits
+  const shutdown = async () => {
+    if (forceExit) {
+      process.stderr.write('\n[jsana] Force exit.\n');
+      process.exit(1);
+    }
+    if (shuttingDown) {
+      forceExit = true;
+      process.stderr.write('\n[jsana] Press Ctrl+C again to force exit.\n');
+      return;
+    }
     shuttingDown = true;
-    process.stderr.write('\n[jsana] Shutting down gracefully...\n');
+    abortController.abort();
+    process.stderr.write('\n[jsana] Interrupted. Waiting for in-flight requests to finish...\n');
+
+    // Stop reading new URLs
+    rl.close();
+    fileStream.destroy();
+
+    // Unblock anything waiting on the semaphore
+    sem.abortAll();
+
+    // Wait for in-flight tasks (with a 5s timeout)
+    const deadline = setTimeout(() => {}, 5000);
+    await Promise.allSettled([...inFlight]);
+    clearTimeout(deadline);
+
+    progress.stop();
+    progressLog.end();
+    await reporter.close();
+    await closeAllPools();
+
+    process.stderr.write(
+      `[jsana] Stopped. ${progress.processed} URLs processed, ` +
+      `${reporter.count} findings, ${progress.errors} errors. ` +
+      `Output: ${output}\n` +
+      `[jsana] Resume with: jsana ${urlsFile} --resume -o ${output}\n`
+    );
+    process.exit(0);
   };
   process.on('SIGINT', shutdown);
 
   progress.start();
 
-  const rl = createInterface({
-    input: createReadStream(urlsFile, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-
   for await (const rawLine of rl) {
     if (shuttingDown) break;
 
@@ -91,11 +160,23 @@ export async function run(urlsFile, opts) {
       continue;
     }
 
-    await sem.acquire();
+    // Skip already-processed URLs on resume
+    if (doneSet.has(url.href)) {
+      progress.skip();
+      continue;
+    }
+
+    try {
+      await sem.acquire();
+    } catch {
+      break; // aborted
+    }
     if (shuttingDown) { sem.release(); break; }
 
     const task = (async () => {
       try {
+        if (shuttingDown) return;
+
         const stream = await withRetry(
           () => fetchUrl(url.href, { timeout }),
           { maxRetries: retries }
@@ -114,12 +195,12 @@ export async function run(urlsFile, opts) {
           }
         } catch {
           // Stream error mid-scan (e.g. response too large, connection reset)
-          // Already counted as error below if fetch itself threw
         }
         progress.addFindings(findingsInUrl);
       } catch (err) {
         progress.addError();
       } finally {
+        progressLog.write(url.href + '\n');
         progress.tick();
         sem.release();
       }
@@ -129,18 +210,25 @@ export async function run(urlsFile, opts) {
     task.finally(() => inFlight.delete(task));
   }
 
-  // Wait for all in-flight tasks
-  await Promise.allSettled([...inFlight]);
+  if (!shuttingDown) {
+    // Normal completion (not interrupted)
+    await Promise.allSettled([...inFlight]);
+
+    progress.stop();
+    progressLog.end();
+    await reporter.close();
+    await closeAllPools();
 
-  progress.stop();
-  await reporter.close();
-  await closeAllPools();
+    process.removeListener('SIGINT', shutdown);
 
-  process.removeListener('SIGINT', shutdown);
+    // Clean up progress file on successful completion
+    const { unlink } = await import('node:fs/promises');
+    await unlink(progressFile).catch(() => {});
 
-  process.stderr.write(
-    `[jsana] Done. ${progress.processed} URLs processed, ` +
-    `${reporter.count} findings, ${progress.errors} errors. ` +
-    `Output: ${output}\n`
-  );
+    process.stderr.write(
+      `[jsana] Done. ${progress.processed} URLs processed, ` +
+      `${reporter.count} findings, ${progress.errors} errors. ` +
+      `Output: ${output}\n`
+    );
+  }
 }

package/lib/progress.js

@@ -20,6 +20,7 @@ export class Progress {
   constructor(total) {
     this.total = total;
     this.processed = 0;
+    this.skipped = 0;
     this.findings = 0;
     this.errors = 0;
     this.startTime = Date.now();
@@ -32,15 +33,19 @@ export class Progress {
   }
 
   tick() { this.processed++; }
+  skip() { this.skipped++; this.processed++; }
   addFindings(n) { this.findings += n; }
   addError() { this.errors++; }
 
   _render() {
     const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
-    const rate = this.processed > 0 ? (this.processed / (elapsed || 1)).toFixed(1) : '0.0';
-    const pct = ((this.processed / this.total) * 100).toFixed(1);
-    const line = `\r[jsana] ${this.processed}/${this.total} (${pct}%) | findings: ${this.findings} | errors: ${this.errors} | ${rate} URLs/s | ${elapsed}s`;
-    process.stderr.write(line);
+    const active = this.processed - this.skipped;
+    const rate = active > 0 ? (active / (elapsed || 1)).toFixed(1) : '0.0';
+    const pct = Math.min(100, (this.processed / this.total) * 100).toFixed(1);
+    let line = `\r[jsana] ${this.processed}/${this.total} (${pct}%) | findings: ${this.findings} | errors: ${this.errors} | ${rate} URLs/s | ${elapsed}s`;
+    if (this.skipped > 0) line += ` | resumed: ${this.skipped} skipped`;
+    // Clear any leftover chars from previous longer line
+    process.stderr.write(line + '   ');
   }
 
   stop() {

package/lib/reporter.js

@@ -1,9 +1,9 @@
 import { createWriteStream } from 'node:fs';
 
 export class Reporter {
-  constructor(outputPath, { json = false } = {}) {
+  constructor(outputPath, { json = false, append = false } = {}) {
     this.json = json;
-    this.stream = createWriteStream(outputPath, { flags: 'w', encoding: 'utf8' });
+    this.stream = createWriteStream(outputPath, { flags: append ? 'a' : 'w', encoding: 'utf8' });
     this.count = 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsana",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "JavaScript Security Analyzer for Bug Bounty",
   "type": "module",
   "license": "MIT",