More automation fixes (#4)

Author: AlCalzone

.github/workflows/run-zwave-wsl.yml

@@ -92,6 +92,7 @@ jobs:
           --exclude=PI_CertificationData_Rev01 `
           --exclude=DD_ManufacturerSpecificCCData_Rev01 `
           --exclude=DD_VersionCCData_Rev01 `
+          --exclude=CSR_LifelineMandatoryReports_Rev03 `
           --verbose
       env:
         CI: true

docs/ipc-protocol.md

@@ -29,7 +29,9 @@ Runner                              Orchestrator
    │                                     │
    │<─────── handleCttPrompt request ────│
    │                                     │
-   │──── handleCttPrompt response ──────>│
+   │──── handleCttPrompt response ──────>│  (if handler matched)
+   │  OR                                 │
+   │──── noHandler notification ────────>│  (if no handler matched)
    │                                     │
    │         ... more prompts ...        │
    │                                     │
@@ -59,6 +61,19 @@ Sent immediately after WebSocket connection is established.
 **Parameters:**
 - `name` (string): Display name for the runner, used in logs
 
+### noHandler
+
+Sent when a `handleCttPrompt` request was received but no prompt handler matched. This allows the orchestrator to cancel the test run in CI mode to prevent hanging.
+
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "noHandler"
+}
+```
+
+**Note:** This is a notification only - no response is expected. The runner does not send a response to the original `handleCttPrompt` request when no handler matches, allowing interactive user input to work in non-CI environments.
+
 ## Requests (Orchestrator → Runner)
 
 ### start

dut/zwave-js/handlers/behaviors/disregardRecommendation.ts

@@ -0,0 +1,65 @@
+import {
+  registerHandler,
+  type PromptContext,
+  type PromptResponse,
+} from "../../prompt-handlers.ts";
+
+// State key for storing warning context
+const DISREGARD_RECOMMENDATION_CONTEXT = "disregardRecommendationContext";
+
+// Enum for different recommendation reasons - extend as needed
+enum Recommendation {
+  IndicatorReportInAGI = "IndicatorReportInAGI",
+}
+
+// Context stored in state
+type DisregardRecommendationContext = {
+  recommendation: Recommendation;
+};
+
+// Rules for how to respond based on reason - static response or function
+type RuleResponse = PromptResponse | ((ctx: PromptContext) => PromptResponse);
+
+const rules: Record<Recommendation, RuleResponse> = {
+  [Recommendation.IndicatorReportInAGI]: "Yes",
+};
+
+registerHandler(/.*/, {
+  onLog: async (ctx) => {
+    let recContext: DisregardRecommendationContext | undefined;
+    // Detect INDICATOR_REPORT not advertised in AGI Command List Report
+    if (
+      /INDICATOR_REPORT.+RECOMMENDED.+does not advertise.+AGI Command List Report/is.test(
+        ctx.logText
+      )
+    ) {
+      recContext = {
+        recommendation: Recommendation.IndicatorReportInAGI,
+      };
+    }
+
+    if (recContext) {
+      ctx.state.set(DISREGARD_RECOMMENDATION_CONTEXT, recContext);
+    }
+
+    return undefined;
+  },
+
+  onPrompt: async (ctx) => {
+    if (
+      !/Is it intended to disregard the recommendation\?/i.test(ctx.promptText)
+    ) {
+      return undefined;
+    }
+
+    const context = ctx.state.get(DISREGARD_RECOMMENDATION_CONTEXT) as
+      | DisregardRecommendationContext
+      | undefined;
+    if (!context) return undefined;
+
+    ctx.state.delete(DISREGARD_RECOMMENDATION_CONTEXT);
+
+    const rule = rules[context.recommendation];
+    return typeof rule === "function" ? rule(ctx) : rule;
+  },
+});

dut/zwave-js/run.ts

@@ -29,6 +29,7 @@ import type {
   SuccessResponse,
   ErrorResponse,
   ReadyNotification,
+  NoHandlerNotification,
 } from "../../src/runner-ipc.ts";
 import {
   getHandlersForTest,
@@ -119,6 +120,14 @@ function sendReady(): void {
   ws?.send(JSON.stringify(notification));
 }
 
+function sendNoHandlerNotification(): void {
+  const notification: NoHandlerNotification = {
+    jsonrpc: "2.0",
+    method: "noHandler",
+  };
+  ws?.send(JSON.stringify(notification));
+}
+
 // === Request Handlers ===
 
 async function handleStart(id: number, params: StartParams): Promise<void> {
@@ -360,7 +369,8 @@ async function handleCttPrompt(
     }
   }
 
-  // No automatic handler - don't respond, let user input win the race
+  // No automatic handler - notify orchestrator so it can cancel in CI mode
+  sendNoHandlerNotification();
 }
 
 async function handleCttLog(id: number, params: CttLogParams): Promise<void> {

src/ctt-device-proxy.ts

@@ -67,12 +67,18 @@ export class CTTDeviceProxy {
   private handleConnection(config: ProxyConfig, clientSocket: net.Socket): void {
     console.log(c.dim(`[Proxy ${config.name}] CTT connected`));
 
+    // Disable Nagle's algorithm for low-latency communication
+    clientSocket.setNoDelay(true);
+
     // Connect to target device
     const targetSocket = net.createConnection({
       host: config.targetHost,
       port: config.targetPort,
     });
 
+    // Disable Nagle's algorithm for low-latency communication
+    targetSocket.setNoDelay(true);
+
     const connection: ProxyConnection = {
       clientSocket,
       targetSocket,

src/runner-host.ts

@@ -20,9 +20,11 @@ import {
   isSuccessResponse,
   isErrorResponse,
   isReadyNotification,
+  isNoHandlerNotification,
   DEFAULT_IPC_PORT,
   IPC_PORT_ENV_VAR,
 } from "./runner-ipc.ts";
+import { cancelTestRun } from "./ctt-client.ts";
 import c from "ansi-colors";
 import * as readline from "readline";
 
@@ -35,13 +37,16 @@ export interface RunnerHostOptions {
   readyTimeout?: number;
   /** Callback when runner process exits unexpectedly */
   onUnexpectedExit?: () => void;
+  /** CI mode - cancel test run on unhandled prompts (default: auto-detect via CI env var) */
+  ciMode?: boolean;
 }
 
 export class RunnerHost {
   private runnerPath: string;
   private ipcPort: number;
   private readyTimeout: number;
   private onUnexpectedExit?: () => void;
+  private ciMode: boolean;
 
   private wss?: WebSocketServer;
   private runnerProcess?: ChildProcess;
@@ -69,6 +74,7 @@ export class RunnerHost {
     this.ipcPort = options.ipcPort ?? DEFAULT_IPC_PORT;
     this.readyTimeout = options.readyTimeout ?? 30000;
     this.onUnexpectedExit = options.onUnexpectedExit;
+    this.ciMode = options.ciMode ?? !!process.env.CI;
 
     // Create readline interface for user prompts
     this.rl = readline.createInterface({
@@ -376,6 +382,12 @@ export class RunnerHost {
       return;
     }
 
+    // Check for no-handler notification (no prompt handler matched)
+    if (isNoHandlerNotification(msg)) {
+      this.handleNoHandler();
+      return;
+    }
+
     // Check for response to a pending request
     if (isSuccessResponse(msg)) {
       // Check if this is a response to the active prompt
@@ -433,4 +445,17 @@ export class RunnerHost {
       });
     });
   }
+
+  private async handleNoHandler(): Promise<void> {
+    if (this.ciMode) {
+      console.error("\n[CI] Unhandled prompt - cancelling test run to prevent hang\n");
+
+      try {
+        await cancelTestRun();
+      } catch (error) {
+        console.error("Failed to cancel test run:", error);
+      }
+    }
+    // In non-CI mode, do nothing - let user input work
+  }
 }

src/runner-ipc.ts

@@ -5,6 +5,16 @@
  * via WebSocket using these JSON-RPC message formats.
  */
 
+// === Base JSON-RPC Types ===
+
+interface JsonRpcMessage {
+  jsonrpc: "2.0";
+}
+
+interface JsonRpcMethodMessage extends JsonRpcMessage {
+  method: string;
+}
+
 // === Security Key Types ===
 
 export interface SecurityKeys {
@@ -51,36 +61,31 @@ export interface TestCaseStartedParams {
 
 // === Request Messages (Orchestrator -> Runner) ===
 
-export interface StartRequest {
-  jsonrpc: "2.0";
+export interface StartRequest extends JsonRpcMethodMessage {
   id: number;
   method: "start";
   params: StartParams;
 }
 
-export interface StopRequest {
-  jsonrpc: "2.0";
+export interface StopRequest extends JsonRpcMethodMessage {
   id: number;
   method: "stop";
   params: Record<string, never>;
 }
 
-export interface HandleCttPromptRequest {
-  jsonrpc: "2.0";
+export interface HandleCttPromptRequest extends JsonRpcMethodMessage {
   id: number;
   method: "handleCttPrompt";
   params: CttPromptParams;
 }
 
-export interface TestCaseStartedRequest {
-  jsonrpc: "2.0";
+export interface TestCaseStartedRequest extends JsonRpcMethodMessage {
   id: number;
   method: "testCaseStarted";
   params: TestCaseStartedParams;
 }
 
-export interface HandleCttLogRequest {
-  jsonrpc: "2.0";
+export interface HandleCttLogRequest extends JsonRpcMethodMessage {
   id: number;
   method: "handleCttLog";
   params: CttLogParams;
@@ -90,14 +95,12 @@ export type IpcRequest = StartRequest | StopRequest | HandleCttPromptRequest | T
 
 // === Response Messages (Runner -> Orchestrator) ===
 
-export interface SuccessResponse {
-  jsonrpc: "2.0";
+export interface SuccessResponse extends JsonRpcMessage {
   id: number;
   result: string; // "ok" for start/stop, button name for handleCttPrompt
 }
 
-export interface ErrorResponse {
-  jsonrpc: "2.0";
+export interface ErrorResponse extends JsonRpcMessage {
   id: number;
   error: {
     code: number;
@@ -109,50 +112,48 @@ export type IpcResponse = SuccessResponse | ErrorResponse;
 
 // === Notification Messages (Runner -> Orchestrator) ===
 
-export interface ReadyNotification {
-  jsonrpc: "2.0";
+export interface ReadyNotification extends JsonRpcMethodMessage {
   method: "ready";
   params: {
     name: string; // Runner name for logging
   };
 }
 
-export type IpcNotification = ReadyNotification;
+export interface NoHandlerNotification extends JsonRpcMethodMessage {
+  method: "noHandler";
+}
+
+export type IpcNotification = ReadyNotification | NoHandlerNotification;
 
 // === Type Guards ===
 
-export function isSuccessResponse(msg: unknown): msg is SuccessResponse {
+function isJsonRpcMessage(msg: unknown): msg is JsonRpcMessage {
   return (
     typeof msg === "object" &&
     msg !== null &&
     "jsonrpc" in msg &&
-    msg.jsonrpc === "2.0" &&
-    "id" in msg &&
-    "result" in msg
+    msg.jsonrpc === "2.0"
   );
 }
 
+function isJsonRpcMethodMessage(msg: unknown): msg is JsonRpcMethodMessage {
+  return isJsonRpcMessage(msg) && "method" in msg;
+}
+
+export function isSuccessResponse(msg: unknown): msg is SuccessResponse {
+  return isJsonRpcMessage(msg) && "id" in msg && "result" in msg;
+}
+
 export function isErrorResponse(msg: unknown): msg is ErrorResponse {
-  return (
-    typeof msg === "object" &&
-    msg !== null &&
-    "jsonrpc" in msg &&
-    msg.jsonrpc === "2.0" &&
-    "id" in msg &&
-    "error" in msg
-  );
+  return isJsonRpcMessage(msg) && "id" in msg && "error" in msg;
 }
 
 export function isReadyNotification(msg: unknown): msg is ReadyNotification {
-  return (
-    typeof msg === "object" &&
-    msg !== null &&
-    "jsonrpc" in msg &&
-    msg.jsonrpc === "2.0" &&
-    "method" in msg &&
-    msg.method === "ready" &&
-    "params" in msg
-  );
+  return isJsonRpcMethodMessage(msg) && msg.method === "ready" && "params" in msg;
+}
+
+export function isNoHandlerNotification(msg: unknown): msg is NoHandlerNotification {
+  return isJsonRpcMethodMessage(msg) && msg.method === "noHandler";
 }
 
 // === Constants ===