@sudobility/testomniac_runner 0.0.133 → 0.0.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sudobility/testomniac_runner",
-  "version": "0.0.133",
+  "version": "0.0.134",
   "publishConfig": {
     "access": "public"
   },

package/src/index.ts

@@ -98,12 +98,65 @@ if (import.meta.main) {
     }
   } else {
     // Default: polling mode
-    setInterval(() => {
+    const pollInterval = setInterval(() => {
       void runnerManager.tick();
     }, pollIntervalMs);
 
     void runnerManager.tick();
 
+    // IPC listener: parent process can send JSON messages on stdin
+    if (process.stdin.isTTY === false || process.stdin.readable) {
+      process.stdin.setEncoding("utf-8");
+      let ipcBuffer = "";
+      process.stdin.on("data", (chunk: string) => {
+        ipcBuffer += chunk;
+        let newlineIdx;
+        while ((newlineIdx = ipcBuffer.indexOf("\n")) !== -1) {
+          const line = ipcBuffer.slice(0, newlineIdx).trim();
+          ipcBuffer = ipcBuffer.slice(newlineIdx + 1);
+          if (!line) continue;
+          try {
+            const msg = JSON.parse(line);
+            if (msg.type === "stop_run" && typeof msg.runId === "number") {
+              logger.info({ runId: msg.runId }, "IPC: stop_run received");
+              const stopped = runnerManager.stopRun(msg.runId);
+              logger.info(
+                { runId: msg.runId, stopped },
+                "IPC: stop_run result"
+              );
+            }
+          } catch {
+            logger.warn({ line }, "IPC: ignoring malformed message");
+          }
+        }
+      });
+      process.stdin.on("end", () => {
+        logger.info("IPC: stdin closed");
+      });
+    }
+
+    // Graceful shutdown
+    let shuttingDown = false;
+    for (const sig of ["SIGTERM", "SIGINT"] as const) {
+      process.on(sig, () => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        logger.info({ signal: sig }, "graceful shutdown initiated");
+        clearInterval(pollInterval);
+        runnerManager.stopAllRuns();
+        const check = setInterval(() => {
+          if (runnerManager.getActiveRunCount() === 0) {
+            clearInterval(check);
+            process.exit(0);
+          }
+        }, 500);
+        setTimeout(() => {
+          logger.warn("graceful shutdown timed out, forcing exit");
+          process.exit(1);
+        }, 30_000);
+      });
+    }
+
     logger.warn(
       { port, pollIntervalMs, maxConcurrentRunners },
       "starting scanner service"

package/src/orchestrator.ts

@@ -41,6 +41,7 @@ export interface RunOptions {
   entityCredentialId?: number;
   quickScan?: boolean;
   scanMode?: "full" | "partial" | "minimum";
+  signal?: AbortSignal;
 }
 
 export async function runFullScan(options: RunOptions): Promise<void> {
@@ -121,6 +122,7 @@ export async function runFullScan(options: RunOptions): Promise<void> {
         credentials: options.credentials,
         quickScan: options.quickScan,
         scanMode: options.scanMode,
+        signal: options.signal,
       },
       api,
       expertises,

package/src/runner-manager.ts

@@ -11,6 +11,7 @@ const logger = pino({
 type ActiveRun = {
   runId: number;
   startedAtMs: number;
+  abortController: AbortController;
 };
 
 export class RunnerManager {
@@ -28,6 +29,21 @@ export class RunnerManager {
     return this.activeRuns.size;
   }
 
+  stopRun(runId: number): boolean {
+    const run = this.activeRuns.get(runId);
+    if (!run) return false;
+    logger.info({ runId }, "stopping run via abort signal");
+    run.abortController.abort();
+    return true;
+  }
+
+  stopAllRuns(): void {
+    for (const [runId, run] of this.activeRuns) {
+      logger.info({ runId }, "stopping run (shutdown)");
+      run.abortController.abort();
+    }
+  }
+
   async tick(): Promise<void> {
     if (this.tickInFlight) return;
 
@@ -107,9 +123,11 @@ export class RunnerManager {
           continue;
         }
 
+        const abortController = new AbortController();
         this.activeRuns.set(pendingRun.id, {
           runId: pendingRun.id,
           startedAtMs: Date.now(),
+          abortController,
         });
 
         logger.info(
@@ -132,6 +150,7 @@ export class RunnerManager {
           runnerInstanceName,
           quickScan: pendingRun.quickScan ?? false,
           scanMode: readScanMode(pendingRun),
+          signal: abortController.signal,
         });
       }
     } catch (err) {
@@ -151,6 +170,7 @@ export class RunnerManager {
     runnerInstanceName: string;
     quickScan: boolean;
     scanMode?: "full" | "partial" | "minimum";
+    signal: AbortSignal;
   }): Promise<void> {
     const config = loadConfig();
     const api = getApiClient(
@@ -170,6 +190,7 @@ export class RunnerManager {
         runnerInstanceName: params.runnerInstanceName,
         quickScan: params.quickScan,
         scanMode: params.scanMode,
+        signal: params.signal,
       });
 
       logger.info({ runId: params.runId }, "run completed successfully");