@sudobility/testomniac_runner 0.0.132 → 0.0.134

package/package.json

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

package/src/index.ts

@@ -15,6 +15,10 @@ const config = loadConfig();
 const pollIntervalMs = Number(process.env.SCAN_POLL_INTERVAL_MS ?? 10_000);
 const maxConcurrentRunners = config.maxConcurrentRunners;
 const runnerManager = new RunnerManager(pollIntervalMs, maxConcurrentRunners);
+const runnerInstanceId =
+  process.env.TESTOMNIAC_RUNNER_INSTANCE_ID ??
+  process.env.TESTOMNIAC_RUNNER_PROCESS_INSTANCE_ID;
+const runnerInstanceName = process.env.TESTOMNIAC_RUNNER_INSTANCE_NAME;
 
 const app = new Hono();
 
@@ -66,8 +70,8 @@ if (import.meta.main) {
         baseUrl,
         sizeClass,
         scanMode,
-        runnerInstanceId: crypto.randomUUID(),
-        runnerInstanceName: "mcp-runner",
+        runnerInstanceId: runnerInstanceId ?? crypto.randomUUID(),
+        runnerInstanceName: runnerInstanceName ?? "mcp-runner",
       });
       logger.info({ scanId }, "one-shot run completed");
       process.exit(0);
@@ -94,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,
@@ -163,6 +165,8 @@ export interface SequenceRunOptions {
   sequenceRunId: number;
   runnerId: number;
   sizeClass?: string;
+  runnerInstanceId?: string;
+  runnerInstanceName?: string;
 }
 
 export async function runSequenceScan(
@@ -211,8 +215,15 @@ export async function runSequenceScan(
         sequenceRunId: options.sequenceRunId,
         runnerId: options.runnerId,
         sizeClass,
-        runnerInstanceId: crypto.randomUUID(),
-        runnerInstanceName: "mcp-runner",
+        runnerInstanceId:
+          options.runnerInstanceId ??
+          process.env.TESTOMNIAC_RUNNER_INSTANCE_ID ??
+          process.env.TESTOMNIAC_RUNNER_PROCESS_INSTANCE_ID ??
+          crypto.randomUUID(),
+        runnerInstanceName:
+          options.runnerInstanceName ??
+          process.env.TESTOMNIAC_RUNNER_INSTANCE_NAME ??
+          "mcp-runner",
       },
       api,
       expertises,

package/src/runner-manager.ts

@@ -11,10 +11,12 @@ const logger = pino({
 type ActiveRun = {
   runId: number;
   startedAtMs: number;
+  abortController: AbortController;
 };
 
 export class RunnerManager {
-  private readonly processInstanceId = crypto.randomUUID();
+  private readonly processInstanceId =
+    process.env.TESTOMNIAC_RUNNER_PROCESS_INSTANCE_ID ?? crypto.randomUUID();
   private readonly activeRuns = new Map<number, ActiveRun>();
   private tickInFlight = false;
 
@@ -27,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;
 
@@ -106,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(
@@ -131,6 +150,7 @@ export class RunnerManager {
           runnerInstanceName,
           quickScan: pendingRun.quickScan ?? false,
           scanMode: readScanMode(pendingRun),
+          signal: abortController.signal,
         });
       }
     } catch (err) {
@@ -150,6 +170,7 @@ export class RunnerManager {
     runnerInstanceName: string;
     quickScan: boolean;
     scanMode?: "full" | "partial" | "minimum";
+    signal: AbortSignal;
   }): Promise<void> {
     const config = loadConfig();
     const api = getApiClient(
@@ -169,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");