@midscene/shared 1.12.1 → 1.12.2-beta-20260827052510.0

package/dist/es/cli/interrupt.mjs

@@ -14,28 +14,54 @@ function registerCliInterruptWaiter(source) {
 function hasActiveCliInterruptWaiter(source = process) {
     return (activeInterruptWaiters.get(source) ?? 0) > 0;
 }
-function waitForCliInterrupt(watchdogMs, source = process) {
+function createCliInterruptWaiter(watchdogMs, source = process) {
     const unregisterWaiter = registerCliInterruptWaiter(source);
-    return new Promise((resolve, reject)=>{
-        let timer;
-        let finished = false;
-        const finish = (reason)=>{
-            if (finished) return;
-            finished = true;
-            source.removeListener('SIGINT', onSigint);
-            if (timer) clearTimeout(timer);
-            unregisterWaiter();
-            resolve(reason);
-        };
-        const onSigint = ()=>finish('sigint');
-        try {
-            source.once('SIGINT', onSigint);
-        } catch (error) {
-            unregisterWaiter();
-            reject(error);
-            return;
+    let timer;
+    let finished = false;
+    let disposed = false;
+    let resolveResult;
+    let rejectResult;
+    const result = new Promise((resolve, reject)=>{
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    const finish = (reason)=>{
+        if (finished) return;
+        finished = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = void 0;
         }
+        resolveResult(reason);
+    };
+    const onSigint = ()=>finish('sigint');
+    const onSigterm = ()=>finish('sigterm');
+    const dispose = ()=>{
+        if (disposed) return;
+        disposed = true;
+        source.removeListener('SIGINT', onSigint);
+        source.removeListener('SIGTERM', onSigterm);
+        if (timer) {
+            clearTimeout(timer);
+            timer = void 0;
+        }
+        unregisterWaiter();
+    };
+    try {
+        source.on('SIGINT', onSigint);
+        source.on('SIGTERM', onSigterm);
         if (watchdogMs > 0) timer = setTimeout(()=>finish('watchdog'), watchdogMs);
-    });
+    } catch (error) {
+        dispose();
+        rejectResult(error);
+    }
+    return {
+        result,
+        dispose
+    };
+}
+function waitForCliInterrupt(watchdogMs, source = process) {
+    const waiter = createCliInterruptWaiter(watchdogMs, source);
+    return waiter.result.finally(waiter.dispose);
 }
-export { hasActiveCliInterruptWaiter, waitForCliInterrupt };
+export { createCliInterruptWaiter, hasActiveCliInterruptWaiter, waitForCliInterrupt };

package/dist/es/cli/record-command.mjs

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { getErrorMessage } from "../agent-tools/error-formatter.mjs";
 import { resolveObservationArtifactAdapter } from "../agent-tools/observation-artifact.mjs";
 import { writeUIObservationRecord } from "../agent-tools/observation-record.mjs";
-import { waitForCliInterrupt } from "./interrupt.mjs";
+import { createCliInterruptWaiter } from "./interrupt.mjs";
 import { attachCliVerboseDumpListener, emitCliVerboseEvent } from "./verbose.mjs";
 const recordCliMetadata = {
     positionals: [
@@ -55,7 +55,7 @@ function createErrorResult(message) {
 function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata) {
     return {
         name: 'record',
-        description: 'Record the page/screen in the foreground until Ctrl+C, then save the ordered frame window for a later assert command.',
+        description: 'Record the page/screen in the foreground until Ctrl+C or a termination signal, then save the ordered frame window for a later assert command.',
         schema: {
             action: z.literal('start').describe('Start a foreground recording. Press Ctrl+C to finish.'),
             output: z.string().optional().describe('Path for the JSON observation manifest. Frames are stored in an adjacent <name>.frames directory. Defaults to a generated path under midscene_run/output.'),
@@ -80,6 +80,7 @@ function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata
                     toolName: 'record'
                 });
                 let observer;
+                let interruptWaiter;
                 try {
                     const watchdogMs = args.watchdogMs ?? 300000;
                     observer = await agent.startObserving({
@@ -87,12 +88,13 @@ function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata
                         maxFrames: args.maxFrames,
                         watchdogMs
                     });
+                    interruptWaiter = createCliInterruptWaiter(watchdogMs);
                     emitCliVerboseEvent({
                         event: 'recording_ready',
                         tool: 'record',
                         watchdogMs
                     });
-                    const stopReason = await waitForCliInterrupt(watchdogMs);
+                    const stopReason = await interruptWaiter.result;
                     emitCliVerboseEvent({
                         event: 'recording_stopping',
                         tool: 'record',
@@ -110,8 +112,12 @@ function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata
                         ]
                     };
                 } finally{
-                    await observer?.dispose?.();
-                    unsubscribeVerbose();
+                    try {
+                        await observer?.dispose?.();
+                    } finally{
+                        interruptWaiter?.dispose();
+                        unsubscribeVerbose();
+                    }
                 }
             } catch (error) {
                 const errorMessage = getErrorMessage(error);

package/dist/es/cli/verbose.mjs

@@ -305,7 +305,8 @@ function renderCliVerboseEventText(event, context) {
         case 'recording_ready':
             return '[Midscene] Recording. Press Ctrl+C to stop and save.';
         case 'recording_stopping':
-            return 'watchdog' === event.reason ? '[Midscene] Recording watchdog reached; finalizing and saving.' : '[Midscene] Ctrl+C received; finalizing and saving.';
+            if ('watchdog' === event.reason) return '[Midscene] Recording watchdog reached; finalizing and saving.';
+            return 'sigterm' === event.reason ? '[Midscene] SIGTERM received; finalizing and saving.' : '[Midscene] Ctrl+C received; finalizing and saving.';
         case 'dump_update':
             {
                 if (isActVerboseEvent(command, tool)) return;

package/dist/es/env/parse-model-config.mjs

@@ -5,7 +5,7 @@ import { assert } from "../utils.mjs";
 import { maskConfig, parseJson } from "./helper.mjs";
 import { initDebugConfig } from "./init-debug.mjs";
 const MODEL_CONFIG_DOC_URL = 'https://midscenejs.com/model-common-config.html';
-const getCurrentVersion = ()=>"1.12.1";
+const getCurrentVersion = ()=>"1.12.2-beta-20260827052510.0";
 const getInvalidModelFamilyMessage = (modelFamily)=>`Invalid MIDSCENE_MODEL_FAMILY value: ${modelFamily}. Current version v${getCurrentVersion()} accepts the following model families: ${MODEL_FAMILY_VALUES.join(', ')}. You can also visit ${MODEL_CONFIG_DOC_URL} for the latest configuration information.`;
 const KEYS_MAP = {
     insight: INSIGHT_MODEL_CONFIG_KEYS,

package/dist/lib/cli/interrupt.js

@@ -24,6 +24,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    createCliInterruptWaiter: ()=>createCliInterruptWaiter,
     hasActiveCliInterruptWaiter: ()=>hasActiveCliInterruptWaiter,
     waitForCliInterrupt: ()=>waitForCliInterrupt
 });
@@ -43,33 +44,61 @@ function registerCliInterruptWaiter(source) {
 function hasActiveCliInterruptWaiter(source = process) {
     return (activeInterruptWaiters.get(source) ?? 0) > 0;
 }
-function waitForCliInterrupt(watchdogMs, source = process) {
+function createCliInterruptWaiter(watchdogMs, source = process) {
     const unregisterWaiter = registerCliInterruptWaiter(source);
-    return new Promise((resolve, reject)=>{
-        let timer;
-        let finished = false;
-        const finish = (reason)=>{
-            if (finished) return;
-            finished = true;
-            source.removeListener('SIGINT', onSigint);
-            if (timer) clearTimeout(timer);
-            unregisterWaiter();
-            resolve(reason);
-        };
-        const onSigint = ()=>finish('sigint');
-        try {
-            source.once('SIGINT', onSigint);
-        } catch (error) {
-            unregisterWaiter();
-            reject(error);
-            return;
+    let timer;
+    let finished = false;
+    let disposed = false;
+    let resolveResult;
+    let rejectResult;
+    const result = new Promise((resolve, reject)=>{
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    const finish = (reason)=>{
+        if (finished) return;
+        finished = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = void 0;
         }
+        resolveResult(reason);
+    };
+    const onSigint = ()=>finish('sigint');
+    const onSigterm = ()=>finish('sigterm');
+    const dispose = ()=>{
+        if (disposed) return;
+        disposed = true;
+        source.removeListener('SIGINT', onSigint);
+        source.removeListener('SIGTERM', onSigterm);
+        if (timer) {
+            clearTimeout(timer);
+            timer = void 0;
+        }
+        unregisterWaiter();
+    };
+    try {
+        source.on('SIGINT', onSigint);
+        source.on('SIGTERM', onSigterm);
         if (watchdogMs > 0) timer = setTimeout(()=>finish('watchdog'), watchdogMs);
-    });
+    } catch (error) {
+        dispose();
+        rejectResult(error);
+    }
+    return {
+        result,
+        dispose
+    };
+}
+function waitForCliInterrupt(watchdogMs, source = process) {
+    const waiter = createCliInterruptWaiter(watchdogMs, source);
+    return waiter.result.finally(waiter.dispose);
 }
+exports.createCliInterruptWaiter = __webpack_exports__.createCliInterruptWaiter;
 exports.hasActiveCliInterruptWaiter = __webpack_exports__.hasActiveCliInterruptWaiter;
 exports.waitForCliInterrupt = __webpack_exports__.waitForCliInterrupt;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCliInterruptWaiter",
     "hasActiveCliInterruptWaiter",
     "waitForCliInterrupt"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/lib/cli/record-command.js

@@ -83,7 +83,7 @@ function createErrorResult(message) {
 function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata) {
     return {
         name: 'record',
-        description: 'Record the page/screen in the foreground until Ctrl+C, then save the ordered frame window for a later assert command.',
+        description: 'Record the page/screen in the foreground until Ctrl+C or a termination signal, then save the ordered frame window for a later assert command.',
         schema: {
             action: external_zod_namespaceObject.z.literal('start').describe('Start a foreground recording. Press Ctrl+C to finish.'),
             output: external_zod_namespaceObject.z.string().optional().describe('Path for the JSON observation manifest. Frames are stored in an adjacent <name>.frames directory. Defaults to a generated path under midscene_run/output.'),
@@ -108,6 +108,7 @@ function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata
                     toolName: 'record'
                 });
                 let observer;
+                let interruptWaiter;
                 try {
                     const watchdogMs = args.watchdogMs ?? 300000;
                     observer = await agent.startObserving({
@@ -115,12 +116,13 @@ function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata
                         maxFrames: args.maxFrames,
                         watchdogMs
                     });
+                    interruptWaiter = (0, external_interrupt_js_namespaceObject.createCliInterruptWaiter)(watchdogMs);
                     (0, external_verbose_js_namespaceObject.emitCliVerboseEvent)({
                         event: 'recording_ready',
                         tool: 'record',
                         watchdogMs
                     });
-                    const stopReason = await (0, external_interrupt_js_namespaceObject.waitForCliInterrupt)(watchdogMs);
+                    const stopReason = await interruptWaiter.result;
                     (0, external_verbose_js_namespaceObject.emitCliVerboseEvent)({
                         event: 'recording_stopping',
                         tool: 'record',
@@ -138,8 +140,12 @@ function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata
                         ]
                     };
                 } finally{
-                    await observer?.dispose?.();
-                    unsubscribeVerbose();
+                    try {
+                        await observer?.dispose?.();
+                    } finally{
+                        interruptWaiter?.dispose();
+                        unsubscribeVerbose();
+                    }
                 }
             } catch (error) {
                 const errorMessage = (0, error_formatter_js_namespaceObject.getErrorMessage)(error);

package/dist/lib/cli/verbose.js

@@ -342,7 +342,8 @@ function renderCliVerboseEventText(event, context) {
         case 'recording_ready':
             return '[Midscene] Recording. Press Ctrl+C to stop and save.';
         case 'recording_stopping':
-            return 'watchdog' === event.reason ? '[Midscene] Recording watchdog reached; finalizing and saving.' : '[Midscene] Ctrl+C received; finalizing and saving.';
+            if ('watchdog' === event.reason) return '[Midscene] Recording watchdog reached; finalizing and saving.';
+            return 'sigterm' === event.reason ? '[Midscene] SIGTERM received; finalizing and saving.' : '[Midscene] Ctrl+C received; finalizing and saving.';
         case 'dump_update':
             {
                 if (isActVerboseEvent(command, tool)) return;

package/dist/lib/env/parse-model-config.js

@@ -37,7 +37,7 @@ const external_utils_js_namespaceObject = require("../utils.js");
 const external_helper_js_namespaceObject = require("./helper.js");
 const external_init_debug_js_namespaceObject = require("./init-debug.js");
 const MODEL_CONFIG_DOC_URL = 'https://midscenejs.com/model-common-config.html';
-const getCurrentVersion = ()=>"1.12.1";
+const getCurrentVersion = ()=>"1.12.2-beta-20260827052510.0";
 const getInvalidModelFamilyMessage = (modelFamily)=>`Invalid MIDSCENE_MODEL_FAMILY value: ${modelFamily}. Current version v${getCurrentVersion()} accepts the following model families: ${external_types_js_namespaceObject.MODEL_FAMILY_VALUES.join(', ')}. You can also visit ${MODEL_CONFIG_DOC_URL} for the latest configuration information.`;
 const KEYS_MAP = {
     insight: external_constants_js_namespaceObject.INSIGHT_MODEL_CONFIG_KEYS,

package/dist/types/cli/interrupt.d.ts

@@ -1,13 +1,30 @@
-export type CliInterruptReason = 'sigint' | 'watchdog';
+export type CliInterruptReason = 'sigint' | 'sigterm' | 'watchdog';
+type CliInterruptSignal = 'SIGINT' | 'SIGTERM';
 export interface CliInterruptSource {
-    once(event: 'SIGINT', listener: () => void): unknown;
-    removeListener(event: 'SIGINT', listener: () => void): unknown;
+    on(event: CliInterruptSignal, listener: () => void): unknown;
+    removeListener(event: CliInterruptSignal, listener: () => void): unknown;
+}
+export interface CliInterruptWaiter {
+    /** Resolves on the first stop signal or watchdog timeout. */
+    readonly result: Promise<CliInterruptReason>;
+    /** Release signal handlers after asynchronous finalization has completed. */
+    dispose(): void;
 }
 /** Whether a foreground CLI command is currently waiting for this source. */
 export declare function hasActiveCliInterruptWaiter(source?: CliInterruptSource): boolean;
 /**
- * Wait until the foreground CLI receives Ctrl+C. A positive watchdog keeps a
- * forgotten recording from running forever and uses the same graceful save
- * path as an explicit interrupt.
+ * Keep graceful-stop handlers installed until the caller has finished saving.
+ *
+ * Package runners such as pnpm can deliver SIGINT to the foreground child and
+ * immediately follow it with SIGTERM while shutting down their own process.
+ * Resolving on the first signal is not enough: removing the handlers at that
+ * point lets the forwarded SIGTERM kill the child during asynchronous artifact
+ * finalization.
+ */
+export declare function createCliInterruptWaiter(watchdogMs: number, source?: CliInterruptSource): CliInterruptWaiter;
+/**
+ * Wait for one stop request and release the handlers immediately afterwards.
+ * Long-running finalizers should use {@link createCliInterruptWaiter} instead.
  */
 export declare function waitForCliInterrupt(watchdogMs: number, source?: CliInterruptSource): Promise<CliInterruptReason>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midscene/shared",
-  "version": "1.12.1",
+  "version": "1.12.2-beta-20260827052510.0",
   "repository": "https://github.com/web-infra-dev/midscene",
   "homepage": "https://midscenejs.com/",
   "types": "./dist/types/index.d.ts",

package/src/cli/interrupt.ts

@@ -1,8 +1,17 @@
-export type CliInterruptReason = 'sigint' | 'watchdog';
+export type CliInterruptReason = 'sigint' | 'sigterm' | 'watchdog';
+
+type CliInterruptSignal = 'SIGINT' | 'SIGTERM';
 
 export interface CliInterruptSource {
-  once(event: 'SIGINT', listener: () => void): unknown;
-  removeListener(event: 'SIGINT', listener: () => void): unknown;
+  on(event: CliInterruptSignal, listener: () => void): unknown;
+  removeListener(event: CliInterruptSignal, listener: () => void): unknown;
+}
+
+export interface CliInterruptWaiter {
+  /** Resolves on the first stop signal or watchdog timeout. */
+  readonly result: Promise<CliInterruptReason>;
+  /** Release signal handlers after asynchronous finalization has completed. */
+  dispose(): void;
 }
 
 const activeInterruptWaiters = new WeakMap<object, number>();
@@ -33,39 +42,76 @@ export function hasActiveCliInterruptWaiter(
 }
 
 /**
- * Wait until the foreground CLI receives Ctrl+C. A positive watchdog keeps a
- * forgotten recording from running forever and uses the same graceful save
- * path as an explicit interrupt.
+ * Keep graceful-stop handlers installed until the caller has finished saving.
+ *
+ * Package runners such as pnpm can deliver SIGINT to the foreground child and
+ * immediately follow it with SIGTERM while shutting down their own process.
+ * Resolving on the first signal is not enough: removing the handlers at that
+ * point lets the forwarded SIGTERM kill the child during asynchronous artifact
+ * finalization.
  */
-export function waitForCliInterrupt(
+export function createCliInterruptWaiter(
   watchdogMs: number,
   source: CliInterruptSource = process,
-): Promise<CliInterruptReason> {
+): CliInterruptWaiter {
   const unregisterWaiter = registerCliInterruptWaiter(source);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let finished = false;
+  let disposed = false;
+  let resolveResult!: (reason: CliInterruptReason) => void;
+  let rejectResult!: (error: unknown) => void;
 
-  return new Promise((resolve, reject) => {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    let finished = false;
+  const result = new Promise<CliInterruptReason>((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
 
-    const finish = (reason: CliInterruptReason) => {
-      if (finished) return;
-      finished = true;
-      source.removeListener('SIGINT', onSigint);
-      if (timer) clearTimeout(timer);
-      unregisterWaiter();
-      resolve(reason);
-    };
-    const onSigint = () => finish('sigint');
+  const finish = (reason: CliInterruptReason) => {
+    if (finished) return;
+    finished = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+    resolveResult(reason);
+  };
+  const onSigint = () => finish('sigint');
+  const onSigterm = () => finish('sigterm');
 
-    try {
-      source.once('SIGINT', onSigint);
-    } catch (error) {
-      unregisterWaiter();
-      reject(error);
-      return;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    source.removeListener('SIGINT', onSigint);
+    source.removeListener('SIGTERM', onSigterm);
+    if (timer) {
+      clearTimeout(timer);
+      timer = undefined;
     }
+    unregisterWaiter();
+  };
+
+  try {
+    source.on('SIGINT', onSigint);
+    source.on('SIGTERM', onSigterm);
     if (watchdogMs > 0) {
       timer = setTimeout(() => finish('watchdog'), watchdogMs);
     }
-  });
+  } catch (error) {
+    dispose();
+    rejectResult(error);
+  }
+
+  return { result, dispose };
+}
+
+/**
+ * Wait for one stop request and release the handlers immediately afterwards.
+ * Long-running finalizers should use {@link createCliInterruptWaiter} instead.
+ */
+export function waitForCliInterrupt(
+  watchdogMs: number,
+  source: CliInterruptSource = process,
+): Promise<CliInterruptReason> {
+  const waiter = createCliInterruptWaiter(watchdogMs, source);
+  return waiter.result.finally(waiter.dispose);
 }

package/src/cli/record-command.ts

@@ -9,7 +9,7 @@ import type {
   ToolResult,
   ToolSchema,
 } from '../agent-tools/types';
-import { waitForCliInterrupt } from './interrupt';
+import { type CliInterruptWaiter, createCliInterruptWaiter } from './interrupt';
 import { attachCliVerboseDumpListener, emitCliVerboseEvent } from './verbose';
 
 const recordCliMetadata: ToolCliMetadata = {
@@ -62,7 +62,7 @@ export function createRecordCliCommand(
   return {
     name: 'record',
     description:
-      'Record the page/screen in the foreground until Ctrl+C, then save the ordered frame window for a later assert command.',
+      'Record the page/screen in the foreground until Ctrl+C or a termination signal, then save the ordered frame window for a later assert command.',
     schema: {
       action: z
         .literal('start')
@@ -125,6 +125,7 @@ export function createRecordCliCommand(
         let observer:
           | Awaited<ReturnType<NonNullable<BaseAgent['startObserving']>>>
           | undefined;
+        let interruptWaiter: CliInterruptWaiter | undefined;
         try {
           const watchdogMs = (args.watchdogMs as number | undefined) ?? 300_000;
           observer = await agent.startObserving({
@@ -132,12 +133,13 @@ export function createRecordCliCommand(
             maxFrames: args.maxFrames as number | undefined,
             watchdogMs,
           });
+          interruptWaiter = createCliInterruptWaiter(watchdogMs);
           emitCliVerboseEvent({
             event: 'recording_ready',
             tool: 'record',
             watchdogMs,
           });
-          const stopReason = await waitForCliInterrupt(watchdogMs);
+          const stopReason = await interruptWaiter.result;
           emitCliVerboseEvent({
             event: 'recording_stopping',
             tool: 'record',
@@ -158,8 +160,12 @@ export function createRecordCliCommand(
             ],
           };
         } finally {
-          await observer?.dispose?.();
-          unsubscribeVerbose();
+          try {
+            await observer?.dispose?.();
+          } finally {
+            interruptWaiter?.dispose();
+            unsubscribeVerbose();
+          }
         }
       } catch (error: unknown) {
         const errorMessage = getErrorMessage(error);

package/src/cli/verbose.ts

@@ -587,8 +587,11 @@ function renderCliVerboseEventText(
     case 'recording_ready':
       return '[Midscene] Recording. Press Ctrl+C to stop and save.';
     case 'recording_stopping':
-      return event.reason === 'watchdog'
-        ? '[Midscene] Recording watchdog reached; finalizing and saving.'
+      if (event.reason === 'watchdog') {
+        return '[Midscene] Recording watchdog reached; finalizing and saving.';
+      }
+      return event.reason === 'sigterm'
+        ? '[Midscene] SIGTERM received; finalizing and saving.'
         : '[Midscene] Ctrl+C received; finalizing and saving.';
     case 'dump_update': {
       if (isActVerboseEvent(command, tool)) {