@aiscene/shared 8.0.3 → 8.0.5

package/dist/lib/agent-tools/observation-record.js

@@ -0,0 +1,297 @@
+"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__, {
+    cloneUIObservationRecord: ()=>cloneUIObservationRecord,
+    writeUIObservationRecord: ()=>writeUIObservationRecord,
+    UIObservationRecordWriter: ()=>UIObservationRecordWriter,
+    readUIObservationRecord: ()=>readUIObservationRecord,
+    parseUIObservationRecord: ()=>parseUIObservationRecord,
+    defaultObservationRecordPath: ()=>defaultObservationRecordPath
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_zod_namespaceObject = require("zod");
+const external_common_js_namespaceObject = require("../common.js");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const observationRecordSchema = external_zod_namespaceObject.z.object({
+    type: external_zod_namespaceObject.z.literal('midscene_ui_observation'),
+    version: external_zod_namespaceObject.z.literal(1),
+    startedAt: external_zod_namespaceObject.z.number().finite().nonnegative(),
+    endedAt: external_zod_namespaceObject.z.number().finite().nonnegative(),
+    frames: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.object({
+        path: external_zod_namespaceObject.z.string().min(1),
+        mimeType: external_zod_namespaceObject.z["enum"]([
+            'image/png',
+            'image/jpeg'
+        ]),
+        capturedAt: external_zod_namespaceObject.z.number().finite().nonnegative()
+    }).strict()).min(1),
+    shotSize: external_zod_namespaceObject.z.object({
+        width: external_zod_namespaceObject.z.number().finite().positive(),
+        height: external_zod_namespaceObject.z.number().finite().positive()
+    }).strict(),
+    shrunkShotToLogicalRatio: external_zod_namespaceObject.z.number().finite().positive()
+}).strict().refine((record)=>record.endedAt >= record.startedAt, {
+    path: [
+        'endedAt'
+    ],
+    message: 'must be greater than or equal to startedAt'
+});
+function defaultObservationRecordPath() {
+    const suffix = Math.random().toString(36).slice(2, 10);
+    return (0, external_node_path_namespaceObject.resolve)((0, external_common_js_namespaceObject.getMidsceneRunSubDir)('output'), `observation-${Date.now()}-${suffix}.json`);
+}
+function parseUIObservationRecord(input) {
+    const result = observationRecordSchema.safeParse(input);
+    if (!result.success) {
+        const issue = result.error.issues[0];
+        const location = issue.path.length > 0 ? issue.path.join('.') : 'record';
+        throw new Error(`Invalid UI observation record at ${location}: ${issue.message}`);
+    }
+    return result.data;
+}
+function cloneUIObservationRecord(record) {
+    return {
+        ...record,
+        frames: record.frames.map((frame)=>({
+                ...frame
+            })),
+        shotSize: {
+            ...record.shotSize
+        }
+    };
+}
+function readUIObservationRecord(filePath) {
+    const resolvedPath = (0, external_node_path_namespaceObject.resolve)(filePath);
+    let parsed;
+    try {
+        parsed = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(resolvedPath, 'utf8'));
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read UI observation record ${resolvedPath}: ${message}`);
+    }
+    const record = parseUIObservationRecord(parsed);
+    const manifestDirectory = (0, external_node_path_namespaceObject.dirname)(resolvedPath);
+    return {
+        ...record,
+        frames: record.frames.map((frame, index)=>{
+            if ((0, external_node_path_namespaceObject.isAbsolute)(frame.path)) throw new Error(`Invalid UI observation record at frames.${index}.path: expected a relative image path`);
+            const imagePath = (0, external_node_path_namespaceObject.resolve)(manifestDirectory, frame.path);
+            const relativeToManifest = (0, external_node_path_namespaceObject.relative)(manifestDirectory, imagePath);
+            if ('..' === relativeToManifest || relativeToManifest.startsWith(`..${'win32' === process.platform ? '\\' : '/'}`) || (0, external_node_path_namespaceObject.isAbsolute)(relativeToManifest)) throw new Error(`Invalid UI observation record at frames.${index}.path: image path escapes the manifest directory`);
+            try {
+                if (!(0, external_node_fs_namespaceObject.statSync)(imagePath).isFile()) throw new Error('path is not a file');
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Invalid UI observation record at frames.${index}.path: cannot read image ${imagePath}: ${message}`);
+            }
+            return {
+                ...frame,
+                path: imagePath
+            };
+        })
+    };
+}
+class UIObservationRecordWriter {
+    persistFrame(dataUrl, capturedAt) {
+        if (this.disposed) throw new Error('UI observation record writer has been disposed');
+        if (this.finalized) throw new Error('UI observation record has already been finalized');
+        const match = /^data:image\/(png|jpe?g);base64,([\s\S]+)$/i.exec(dataUrl);
+        if (!match) throw new Error('UI observation frame must be a PNG or JPEG data URL');
+        const format = 'png' === match[1].toLowerCase() ? 'png' : 'jpeg';
+        const mimeType = 'png' === format ? 'image/png' : 'image/jpeg';
+        const bytes = Buffer.from(match[2], 'base64');
+        if (0 === bytes.length) throw new Error('UI observation frame contains no image data');
+        const digest = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(bytes).digest('hex');
+        const fileName = `${digest}.${format}`;
+        (0, external_node_fs_namespaceObject.mkdirSync)(this.temporaryFramesDirectory, {
+            recursive: true
+        });
+        const temporaryPath = (0, external_node_path_namespaceObject.join)(this.temporaryFramesDirectory, fileName);
+        if (!(0, external_node_fs_namespaceObject.existsSync)(temporaryPath)) (0, external_node_fs_namespaceObject.writeFileSync)(temporaryPath, bytes);
+        return {
+            path: `${(0, external_node_path_namespaceObject.basename)(this.framesDirectory)}/${fileName}`,
+            mimeType,
+            capturedAt
+        };
+    }
+    resolveFramePath(frame) {
+        if (this.disposed) throw new Error('UI observation record writer has been disposed');
+        const directory = this.finalized ? this.framesDirectory : this.temporaryFramesDirectory;
+        return (0, external_node_path_namespaceObject.join)(directory, (0, external_node_path_namespaceObject.basename)(frame.path));
+    }
+    pruneFrames(frames) {
+        if (this.disposed) throw new Error('UI observation record writer has been disposed');
+        if (this.finalized || !(0, external_node_fs_namespaceObject.existsSync)(this.temporaryFramesDirectory)) return;
+        const retainedFiles = new Set(frames.map((frame)=>(0, external_node_path_namespaceObject.basename)(frame.path)));
+        for (const fileName of (0, external_node_fs_namespaceObject.readdirSync)(this.temporaryFramesDirectory))if (!retainedFiles.has(fileName)) (0, external_node_fs_namespaceObject.rmSync)((0, external_node_path_namespaceObject.join)(this.temporaryFramesDirectory, fileName), {
+            force: true
+        });
+    }
+    finalize(frames, metadata) {
+        if (this.disposed) throw new Error('UI observation record writer has been disposed');
+        if (this.finalizedRecord) return this.finalizedRecord;
+        const record = parseUIObservationRecord({
+            type: 'midscene_ui_observation',
+            version: 1,
+            frames,
+            ...metadata
+        });
+        this.pruneFrames(record.frames);
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(this.outputPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)(this.temporaryFramesDirectory, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.rmSync)(this.framesDirectory, {
+            recursive: true,
+            force: true
+        });
+        (0, external_node_fs_namespaceObject.renameSync)(this.temporaryFramesDirectory, this.framesDirectory);
+        this.finalized = true;
+        this.finalizedRecord = {
+            ...record,
+            frames: record.frames.map((frame)=>({
+                    ...frame,
+                    path: (0, external_node_path_namespaceObject.resolve)((0, external_node_path_namespaceObject.dirname)(this.outputPath), frame.path)
+                }))
+        };
+        return this.finalizedRecord;
+    }
+    dispose() {
+        if (this.disposed) return;
+        (0, external_node_fs_namespaceObject.rmSync)(this.temporaryFramesDirectory, {
+            recursive: true,
+            force: true
+        });
+        (0, external_node_fs_namespaceObject.rmSync)(this.framesDirectory, {
+            recursive: true,
+            force: true
+        });
+        this.disposed = true;
+        this.finalizedRecord = null;
+    }
+    constructor(filePath){
+        _define_property(this, "outputPath", void 0);
+        _define_property(this, "framesDirectory", void 0);
+        _define_property(this, "temporaryFramesDirectory", void 0);
+        _define_property(this, "finalized", false);
+        _define_property(this, "disposed", false);
+        _define_property(this, "finalizedRecord", null);
+        this.outputPath = filePath ? (0, external_node_path_namespaceObject.resolve)(filePath) : defaultObservationRecordPath();
+        const extension = (0, external_node_path_namespaceObject.extname)(this.outputPath);
+        const stem = (0, external_node_path_namespaceObject.basename)(this.outputPath, extension);
+        this.framesDirectory = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(this.outputPath), `${stem}.frames`);
+        this.temporaryFramesDirectory = `${this.framesDirectory}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+}
+function writeUIObservationRecord(record, filePath) {
+    const validated = parseUIObservationRecord(record);
+    const outputPath = filePath ? (0, external_node_path_namespaceObject.resolve)(filePath) : defaultObservationRecordPath();
+    const extension = (0, external_node_path_namespaceObject.extname)(outputPath);
+    const stem = (0, external_node_path_namespaceObject.basename)(outputPath, extension);
+    const framesDirectory = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(outputPath), `${stem}.frames`);
+    const temporaryFramesDirectory = `${framesDirectory}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+    const temporaryManifest = `${outputPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+    const copiedPaths = new Map();
+    try {
+        (0, external_node_fs_namespaceObject.mkdirSync)(temporaryFramesDirectory, {
+            recursive: true
+        });
+        const frames = validated.frames.map((frame, index)=>{
+            const sourcePath = (0, external_node_path_namespaceObject.resolve)(frame.path);
+            try {
+                if (!(0, external_node_fs_namespaceObject.statSync)(sourcePath).isFile()) throw new Error('path is not a file');
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Invalid UI observation record at frames.${index}.path: cannot read image ${sourcePath}: ${message}`);
+            }
+            let relativePath = copiedPaths.get(sourcePath);
+            if (!relativePath) {
+                const imageExtension = 'image/png' === frame.mimeType ? 'png' : 'jpeg';
+                const fileName = `${String(copiedPaths.size).padStart(4, '0')}.${imageExtension}`;
+                relativePath = `${(0, external_node_path_namespaceObject.basename)(framesDirectory)}/${fileName}`;
+                (0, external_node_fs_namespaceObject.copyFileSync)(sourcePath, (0, external_node_path_namespaceObject.join)(temporaryFramesDirectory, fileName));
+                copiedPaths.set(sourcePath, relativePath);
+            }
+            return {
+                ...frame,
+                path: relativePath
+            };
+        });
+        const serializedRecord = parseUIObservationRecord({
+            ...validated,
+            frames
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(outputPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(temporaryManifest, JSON.stringify(serializedRecord, null, 2), 'utf8');
+        (0, external_node_fs_namespaceObject.rmSync)(framesDirectory, {
+            recursive: true,
+            force: true
+        });
+        (0, external_node_fs_namespaceObject.renameSync)(temporaryFramesDirectory, framesDirectory);
+        (0, external_node_fs_namespaceObject.renameSync)(temporaryManifest, outputPath);
+        return outputPath;
+    } finally{
+        (0, external_node_fs_namespaceObject.rmSync)(temporaryFramesDirectory, {
+            recursive: true,
+            force: true
+        });
+        (0, external_node_fs_namespaceObject.rmSync)(temporaryManifest, {
+            force: true
+        });
+    }
+}
+exports.UIObservationRecordWriter = __webpack_exports__.UIObservationRecordWriter;
+exports.cloneUIObservationRecord = __webpack_exports__.cloneUIObservationRecord;
+exports.defaultObservationRecordPath = __webpack_exports__.defaultObservationRecordPath;
+exports.parseUIObservationRecord = __webpack_exports__.parseUIObservationRecord;
+exports.readUIObservationRecord = __webpack_exports__.readUIObservationRecord;
+exports.writeUIObservationRecord = __webpack_exports__.writeUIObservationRecord;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "UIObservationRecordWriter",
+    "cloneUIObservationRecord",
+    "defaultObservationRecordPath",
+    "parseUIObservationRecord",
+    "readUIObservationRecord",
+    "writeUIObservationRecord"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/agent-tools/tool-defaults.js

@@ -0,0 +1,97 @@
+"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__, {
+    TOOL_BEHAVIOR_FLAGS: ()=>TOOL_BEHAVIOR_FLAGS,
+    mergeToolDefaults: ()=>mergeToolDefaults,
+    resolveToolDefaults: ()=>resolveToolDefaults,
+    stripBehaviorFlags: ()=>stripBehaviorFlags
+});
+const TOOL_BEHAVIOR_FLAGS = [
+    {
+        cli: 'deep-locate',
+        description: 'Force deep locate for every locating operation (better precision for small/ambiguous targets, a bit slower).',
+        defaults: {
+            locate: {
+                deepLocate: true
+            },
+            act: {
+                deepLocate: true
+            }
+        }
+    },
+    {
+        cli: 'deep-think',
+        description: 'Plan the act tool with deep thinking (richer context and sub-goal decomposition, a bit slower).',
+        defaults: {
+            act: {
+                deepThink: true
+            }
+        }
+    }
+];
+function mergeToolDefaults(a, b) {
+    const locate = {
+        ...a.locate,
+        ...b.locate
+    };
+    const act = {
+        ...a.act,
+        ...b.act
+    };
+    const result = {};
+    if (Object.keys(locate).length > 0) result.locate = locate;
+    if (Object.keys(act).length > 0) result.act = act;
+    return result;
+}
+function resolveToolDefaults(isEnabled) {
+    return TOOL_BEHAVIOR_FLAGS.reduce((acc, flag)=>isEnabled(flag.cli) ? mergeToolDefaults(acc, flag.defaults) : acc, {});
+}
+function stripBehaviorFlags(argv) {
+    const enabled = new Set();
+    const rawArgs = [];
+    for (const arg of argv){
+        const flag = TOOL_BEHAVIOR_FLAGS.find((f)=>arg === `--${f.cli}`);
+        if (flag) enabled.add(flag.cli);
+        else rawArgs.push(arg);
+    }
+    return {
+        rawArgs,
+        toolDefaults: resolveToolDefaults((cli)=>enabled.has(cli))
+    };
+}
+exports.TOOL_BEHAVIOR_FLAGS = __webpack_exports__.TOOL_BEHAVIOR_FLAGS;
+exports.mergeToolDefaults = __webpack_exports__.mergeToolDefaults;
+exports.resolveToolDefaults = __webpack_exports__.resolveToolDefaults;
+exports.stripBehaviorFlags = __webpack_exports__.stripBehaviorFlags;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TOOL_BEHAVIOR_FLAGS",
+    "mergeToolDefaults",
+    "resolveToolDefaults",
+    "stripBehaviorFlags"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});