@aiscene/shared 8.0.3 → 8.0.4

package/dist/lib/agent-tools/user-prompt.js

@@ -0,0 +1,103 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    promptInputExtraSchema: ()=>promptInputExtraSchema,
+    composeUserPrompt: ()=>composeUserPrompt
+});
+const external_zod_namespaceObject = require("zod");
+function normalizeStringList(raw, fieldName) {
+    if (null == raw) return [];
+    if ('string' == typeof raw) {
+        const trimmed = raw.trim();
+        return trimmed ? [
+            trimmed
+        ] : [];
+    }
+    if (Array.isArray(raw)) return raw.map((item, index)=>{
+        if ('string' != typeof item) throw new Error(`${fieldName}[${index}]: expected a string.`);
+        return item.trim();
+    });
+    throw new Error(`${fieldName}: expected a string or string array, got ${typeof raw}.`);
+}
+function composeImages(input) {
+    const urls = normalizeStringList(input.image, 'image');
+    const names = normalizeStringList(input.imageName, 'imageName');
+    if (urls.length !== names.length) throw new Error(`image/imageName: expected the same number of --image and --image-name values, got ${urls.length} image(s) and ${names.length} image name(s).`);
+    return urls.map((url, index)=>({
+            name: names[index],
+            url
+        }));
+}
+function coerceBoolean(value) {
+    if (null == value) return;
+    if ('boolean' == typeof value) return value;
+    if ('string' == typeof value) {
+        const trimmed = value.trim();
+        if (!trimmed) return;
+        const v = trimmed.toLowerCase();
+        if ('true' === v || '1' === v) return true;
+        if ('false' === v || '0' === v) return false;
+        throw new Error(`convertHttpImage2Base64: expected "true", "false", "1", or "0"; got ${JSON.stringify(value)}.`);
+    }
+    throw new Error(`convertHttpImage2Base64: expected a boolean, got ${typeof value}.`);
+}
+function composeUserPrompt(input) {
+    const images = composeImages({
+        image: input.image,
+        imageName: input.imageName
+    });
+    const convertFlag = coerceBoolean(input.convertHttpImage2Base64);
+    if (0 === images.length && void 0 === convertFlag) return input.prompt;
+    const payload = {
+        prompt: input.prompt
+    };
+    if (images.length > 0) payload.images = images;
+    if (void 0 !== convertFlag) payload.convertHttpImage2Base64 = convertFlag;
+    return payload;
+}
+const promptInputExtraSchema = {
+    image: external_zod_namespaceObject.z.union([
+        external_zod_namespaceObject.z.string(),
+        external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
+    ]).optional().describe('Reference image URL/path. Repeat --image for multiple images.'),
+    imageName: external_zod_namespaceObject.z.union([
+        external_zod_namespaceObject.z.string(),
+        external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
+    ]).optional().describe('Reference image name. Repeat --image-name; must align with --image order.'),
+    convertHttpImage2Base64: external_zod_namespaceObject.z.union([
+        external_zod_namespaceObject.z.boolean(),
+        external_zod_namespaceObject.z.string()
+    ]).optional().describe('If true, convert http(s) image URLs to base64 before sending to the model.')
+};
+exports.composeUserPrompt = __webpack_exports__.composeUserPrompt;
+exports.promptInputExtraSchema = __webpack_exports__.promptInputExtraSchema;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "composeUserPrompt",
+    "promptInputExtraSchema"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cli/interrupt.js

@@ -0,0 +1,156 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createCliInterruptWaiter: ()=>createCliInterruptWaiter,
+    hasActiveCliInterruptWaiter: ()=>hasActiveCliInterruptWaiter,
+    waitForCliInterrupt: ()=>waitForCliInterrupt
+});
+const activeInterruptWaiters = new WeakMap();
+const noop = ()=>{};
+const sigintExitCode = 130;
+function guardTerminalCtrlC(input, onInterrupt) {
+    if (!input?.isTTY || !input.setRawMode) return noop;
+    const wasRaw = true === input.isRaw;
+    const wasFlowing = true === input.readableFlowing;
+    const onData = (chunk)=>{
+        const includesCtrlC = 'string' == typeof chunk && chunk.includes('\u0003') || chunk instanceof Uint8Array && chunk.includes(3);
+        if (includesCtrlC) onInterrupt();
+    };
+    const dispose = ()=>{
+        input.removeListener('data', onData);
+        try {
+            if (!wasFlowing) input.pause?.();
+        } finally{
+            if (!wasRaw) input.setRawMode?.(false);
+        }
+    };
+    input.setRawMode(true);
+    try {
+        input.on('data', onData);
+    } catch (error) {
+        dispose();
+        throw error;
+    }
+    return dispose;
+}
+function registerCliInterruptWaiter(source) {
+    const key = source;
+    activeInterruptWaiters.set(key, (activeInterruptWaiters.get(key) ?? 0) + 1);
+    let active = true;
+    return ()=>{
+        if (!active) return;
+        active = false;
+        const remaining = (activeInterruptWaiters.get(key) ?? 1) - 1;
+        if (remaining > 0) activeInterruptWaiters.set(key, remaining);
+        else activeInterruptWaiters.delete(key);
+    };
+}
+function hasActiveCliInterruptWaiter(source = process) {
+    return (activeInterruptWaiters.get(source) ?? 0) > 0;
+}
+function createCliInterruptWaiter(watchdogMs, options = {}) {
+    const source = options.source ?? process;
+    const input = options.input ?? (source === process ? process.stdin : void 0);
+    const forceExit = options.forceExit ?? (source === process ? (exitCode)=>{
+        process.exit(exitCode);
+    } : void 0);
+    const unregisterWaiter = registerCliInterruptWaiter(source);
+    let timer;
+    let finished = false;
+    let disposed = false;
+    let disposeInput = noop;
+    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 onSighup = ()=>finish('sighup');
+    function dispose() {
+        if (disposed) return;
+        disposed = true;
+        source.removeListener('SIGINT', onSigint);
+        source.removeListener('SIGTERM', onSigterm);
+        source.removeListener('SIGHUP', onSighup);
+        try {
+            disposeInput();
+        } finally{
+            if (timer) {
+                clearTimeout(timer);
+                timer = void 0;
+            }
+            unregisterWaiter();
+        }
+    }
+    const onTerminalCtrlC = ()=>{
+        if (!finished) return void finish('sigint');
+        dispose();
+        forceExit?.(sigintExitCode);
+    };
+    try {
+        source.on('SIGINT', onSigint);
+        source.on('SIGTERM', onSigterm);
+        source.on('SIGHUP', onSighup);
+        disposeInput = guardTerminalCtrlC(input, onTerminalCtrlC);
+        if (watchdogMs > 0) timer = setTimeout(()=>finish('watchdog'), watchdogMs);
+    } catch (error) {
+        dispose();
+        rejectResult(error);
+    }
+    return {
+        result,
+        dispose
+    };
+}
+function waitForCliInterrupt(watchdogMs, source = process, input = source === process ? process.stdin : void 0) {
+    const waiter = createCliInterruptWaiter(watchdogMs, {
+        source,
+        input
+    });
+    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];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,164 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRecordCliCommand: ()=>createRecordCliCommand
+});
+const external_zod_namespaceObject = require("zod");
+const error_formatter_js_namespaceObject = require("../agent-tools/error-formatter.js");
+const observation_artifact_js_namespaceObject = require("../agent-tools/observation-artifact.js");
+const observation_record_js_namespaceObject = require("../agent-tools/observation-record.js");
+const external_interrupt_js_namespaceObject = require("./interrupt.js");
+const external_verbose_js_namespaceObject = require("./verbose.js");
+const recordCliMetadata = {
+    positionals: [
+        'action'
+    ],
+    options: {
+        intervalMs: {
+            preferredName: 'interval-ms',
+            aliases: [
+                'intervalMs'
+            ]
+        },
+        maxFrames: {
+            preferredName: 'max-frames',
+            aliases: [
+                'maxFrames'
+            ]
+        },
+        watchdogMs: {
+            preferredName: 'watchdog-ms',
+            aliases: [
+                'watchdogMs'
+            ]
+        },
+        action: {
+            hidden: true
+        }
+    }
+};
+function mergeCliMetadata(base, extra) {
+    return {
+        positionals: base.positionals,
+        options: {
+            ...base.options ?? {},
+            ...extra?.options ?? {}
+        }
+    };
+}
+function createErrorResult(message) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: message
+            }
+        ],
+        isError: true
+    };
+}
+function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata) {
+    return {
+        name: 'record',
+        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.'),
+            intervalMs: external_zod_namespaceObject.z.number().min(200).optional().describe('Sampling interval in milliseconds. Defaults to 1000; minimum 200 (5fps).'),
+            maxFrames: external_zod_namespaceObject.z.number().int().min(2).optional().describe('Maximum buffered frames. Defaults to 30; minimum 2.'),
+            watchdogMs: external_zod_namespaceObject.z.number().min(0).optional().describe('Safety timeout in milliseconds. Defaults to 300000 (5 minutes); 0 disables it.'),
+            ...initArgSchema
+        },
+        cli: mergeCliMetadata(recordCliMetadata, initArgCliMetadata),
+        handler: async (args = {})=>{
+            if ('start' !== args.action) return createErrorResult('record requires the start operation (for example: record start --output ./observation.json)');
+            try {
+                const agent = await getAgent(args);
+                (0, external_verbose_js_namespaceObject.emitCliVerboseEvent)({
+                    event: 'agent_ready',
+                    tool: 'record'
+                });
+                if (!agent.startObserving) throw new Error('record is not supported because this agent does not provide startObserving');
+                const observationArtifacts = (0, observation_artifact_js_namespaceObject.resolveObservationArtifactAdapter)(agent);
+                if (!observationArtifacts) throw new Error('record is not supported because this agent does not provide observation artifact persistence');
+                const unsubscribeVerbose = (0, external_verbose_js_namespaceObject.attachCliVerboseDumpListener)(agent, {
+                    toolName: 'record'
+                });
+                let observer;
+                let interruptWaiter;
+                try {
+                    const watchdogMs = args.watchdogMs ?? 300000;
+                    observer = await agent.startObserving({
+                        intervalMs: args.intervalMs,
+                        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 interruptWaiter.result;
+                    (0, external_verbose_js_namespaceObject.emitCliVerboseEvent)({
+                        event: 'recording_stopping',
+                        tool: 'record',
+                        reason: stopReason
+                    });
+                    const observation = await observer.stop();
+                    const record = await observationArtifacts.exportRecord(observation);
+                    const outputPath = (0, observation_record_js_namespaceObject.writeUIObservationRecord)(record, args.output);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Observation record saved: ${outputPath}`
+                            }
+                        ]
+                    };
+                } finally{
+                    try {
+                        await observer?.dispose?.();
+                    } finally{
+                        interruptWaiter?.dispose();
+                        unsubscribeVerbose();
+                    }
+                }
+            } catch (error) {
+                const errorMessage = (0, error_formatter_js_namespaceObject.getErrorMessage)(error);
+                console.error('Error executing record:', errorMessage);
+                return createErrorResult(`Failed to execute record: ${errorMessage}`);
+            }
+        }
+    };
+}
+exports.createRecordCliCommand = __webpack_exports__.createRecordCliCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRecordCliCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cli/screenshot-file.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    writeCliScreenshotFile: ()=>writeCliScreenshotFile
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+function safeScreenshotFilenamePart(value) {
+    const text = 'string' == typeof value && value.length > 0 ? value : 'shot';
+    return text.replace(/[^a-zA-Z0-9._-]/g, '_') || 'shot';
+}
+function extensionFromImageMetadata(mimeType, extension) {
+    if ('jpeg' === extension || 'jpg' === extension) return 'jpeg';
+    if ('png' === extension) return 'png';
+    return 'image/jpeg' === mimeType ? 'jpeg' : 'png';
+}
+function writeCliScreenshotFile(rawBase64, options = {}) {
+    const extension = extensionFromImageMetadata(options.mimeType, options.extension);
+    const directory = options.directoryPath ? options.directoryPath : options.directoryName ? (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), options.directoryName) : (0, external_node_os_namespaceObject.tmpdir)();
+    if (!(0, external_node_fs_namespaceObject.existsSync)(directory)) (0, external_node_fs_namespaceObject.mkdirSync)(directory, {
+        recursive: true
+    });
+    const filename = void 0 !== options.id ? `${safeScreenshotFilenamePart(options.id)}.${extension}` : `${options.filenamePrefix ?? 'screenshot'}-${Date.now()}.${extension}`;
+    const filePath = (0, external_node_path_namespaceObject.join)(directory, filename);
+    if (false !== options.overwrite || !(0, external_node_fs_namespaceObject.existsSync)(filePath)) (0, external_node_fs_namespaceObject.writeFileSync)(filePath, Buffer.from(rawBase64, 'base64'));
+    return filePath;
+}
+exports.writeCliScreenshotFile = __webpack_exports__.writeCliScreenshotFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "writeCliScreenshotFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});