@godscene/core 1.7.11

package/dist/es/types.mjs

@@ -0,0 +1,202 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { restoreImageReferences } from "./dump/screenshot-restoration.mjs";
+import { ScreenshotStore } from "./dump/screenshot-store.mjs";
+import { ScreenshotItem } from "./screenshot-item.mjs";
+export * from "./yaml.mjs";
+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;
+}
+class UIContext {
+}
+class ServiceError extends Error {
+    constructor(message, dump){
+        super(message), _define_property(this, "dump", void 0);
+        this.name = 'ServiceError';
+        this.dump = dump;
+    }
+}
+function replacerForDumpSerialization(_key, value) {
+    if (value && value.constructor?.name === 'Page') return '[Page object]';
+    if (value && value.constructor?.name === 'Browser') return '[Browser object]';
+    if (value && 'function' == typeof value.toSerializable) return value.toSerializable();
+    return value;
+}
+function reviverForDumpDeserialization(key, value) {
+    if ('screenshot' !== key || 'object' != typeof value || null === value) return value;
+    ScreenshotItem.isSerialized(value);
+    return value;
+}
+class ExecutionDump {
+    serialize(indents) {
+        return JSON.stringify(this.toJSON(), replacerForDumpSerialization, indents);
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            logTime: this.logTime,
+            name: this.name,
+            description: this.description,
+            tasks: this.tasks.map((task)=>({
+                    ...task,
+                    recorder: task.recorder || []
+                })),
+            aiActContext: this.aiActContext
+        };
+    }
+    static fromSerializedString(serialized) {
+        const parsed = JSON.parse(serialized, reviverForDumpDeserialization);
+        return new ExecutionDump(parsed);
+    }
+    static fromJSON(data) {
+        return new ExecutionDump(data);
+    }
+    collectScreenshots() {
+        const screenshots = [];
+        for (const task of this.tasks){
+            if (task.uiContext?.screenshot instanceof ScreenshotItem) screenshots.push(task.uiContext.screenshot);
+            if (task.recorder) {
+                for (const record of task.recorder)if (record.screenshot instanceof ScreenshotItem) screenshots.push(record.screenshot);
+            }
+        }
+        return screenshots;
+    }
+    constructor(data){
+        _define_property(this, "id", void 0);
+        _define_property(this, "logTime", void 0);
+        _define_property(this, "name", void 0);
+        _define_property(this, "description", void 0);
+        _define_property(this, "tasks", void 0);
+        _define_property(this, "aiActContext", void 0);
+        this.id = data.id;
+        this.logTime = data.logTime;
+        this.name = data.name;
+        this.description = data.description;
+        this.tasks = data.tasks;
+        this.aiActContext = data.aiActContext;
+    }
+}
+class ReportActionDump {
+    serialize(indents) {
+        return JSON.stringify(this.toJSON(), replacerForDumpSerialization, indents);
+    }
+    serializeWithInlineScreenshots(indents) {
+        const processValue = (obj)=>{
+            if (obj instanceof ScreenshotItem) return {
+                base64: obj.base64,
+                capturedAt: obj.capturedAt
+            };
+            if (Array.isArray(obj)) return obj.map(processValue);
+            if (obj && 'object' == typeof obj) {
+                const entries = Object.entries(obj).map(([key, value])=>[
+                        key,
+                        processValue(value)
+                    ]);
+                return Object.fromEntries(entries);
+            }
+            return obj;
+        };
+        const data = processValue(this.toJSON());
+        return JSON.stringify(data, null, indents);
+    }
+    toJSON() {
+        return {
+            sdkVersion: this.sdkVersion,
+            groupName: this.groupName,
+            groupDescription: this.groupDescription,
+            modelBriefs: this.modelBriefs,
+            executions: this.executions.map((exec)=>exec.toJSON()),
+            deviceType: this.deviceType
+        };
+    }
+    static fromSerializedString(serialized) {
+        const parsed = JSON.parse(serialized, reviverForDumpDeserialization);
+        return new ReportActionDump(parsed);
+    }
+    static fromJSON(data) {
+        return new ReportActionDump(data);
+    }
+    collectAllScreenshots() {
+        const screenshots = [];
+        for (const execution of this.executions)screenshots.push(...execution.collectScreenshots());
+        return screenshots;
+    }
+    serializeToFiles(basePath) {
+        const screenshotsDir = `${basePath}.screenshots`;
+        if (!existsSync(screenshotsDir)) mkdirSync(screenshotsDir, {
+            recursive: true
+        });
+        const screenshots = this.collectAllScreenshots();
+        for (const screenshot of screenshots){
+            const imagePath = join(screenshotsDir, `${screenshot.id}.${screenshot.extension}`);
+            if (existsSync(imagePath)) continue;
+            const rawBase64 = screenshot.rawBase64;
+            writeFileSync(imagePath, Buffer.from(rawBase64, 'base64'));
+        }
+        writeFileSync(basePath, this.serialize(), 'utf-8');
+    }
+    static fromFilesAsInlineJson(basePath) {
+        const dumpString = readFileSync(basePath, 'utf-8');
+        const screenshotsDir = `${basePath}.screenshots`;
+        const loadFromExecutionScreenshotDir = (id, mimeType)=>{
+            const ext = 'image/jpeg' === mimeType ? 'jpeg' : 'png';
+            const filePath = join(screenshotsDir, `${id}.${ext}`);
+            if (!existsSync(filePath)) return '';
+            const data = readFileSync(filePath);
+            return `data:image/${ext};base64,${data.toString('base64')}`;
+        };
+        const dumpData = JSON.parse(dumpString);
+        const store = new ScreenshotStore({
+            mode: 'directory',
+            reportPath: basePath
+        });
+        const processedData = restoreImageReferences(dumpData, (ref)=>{
+            const executionFileImage = loadFromExecutionScreenshotDir(ref.id, ref.mimeType);
+            if (executionFileImage) return executionFileImage;
+            if ('inline' === ref.storage) return '';
+            return store.loadBase64(ref);
+        });
+        return JSON.stringify(processedData);
+    }
+    static cleanupFiles(basePath) {
+        const filesToClean = [
+            basePath,
+            `${basePath}.screenshots`
+        ];
+        for (const filePath of filesToClean)try {
+            rmSync(filePath, {
+                force: true,
+                recursive: true
+            });
+        } catch  {}
+    }
+    static getFilePaths(basePath) {
+        return [
+            basePath,
+            `${basePath}.screenshots`
+        ];
+    }
+    constructor(data){
+        _define_property(this, "sdkVersion", void 0);
+        _define_property(this, "groupName", void 0);
+        _define_property(this, "groupDescription", void 0);
+        _define_property(this, "modelBriefs", void 0);
+        _define_property(this, "executions", void 0);
+        _define_property(this, "deviceType", void 0);
+        this.sdkVersion = data.sdkVersion;
+        this.groupName = data.groupName;
+        this.groupDescription = data.groupDescription;
+        this.modelBriefs = data.modelBriefs;
+        this.executions = data.executions.map((exec)=>exec instanceof ExecutionDump ? exec : ExecutionDump.fromJSON(exec));
+        this.deviceType = data.deviceType;
+    }
+}
+const GroupedActionDump = ReportActionDump;
+export { ExecutionDump, GroupedActionDump, ReportActionDump, ServiceError, UIContext };

package/dist/es/utils.mjs

@@ -0,0 +1,232 @@
+import { execFile } from "node:child_process";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, truncateSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { defaultRunDirName, getMidsceneRunSubDir } from "@godscene/shared/common";
+import { MIDSCENE_CACHE, MIDSCENE_DEBUG_MODE, globalConfigManager } from "@godscene/shared/env";
+import { getRunningPkgInfo } from "@godscene/shared/node";
+import { assert, escapeScriptTag, ifInBrowser, ifInWorker, logMsg, uuid } from "@godscene/shared/utils";
+let logEnvReady = false;
+const groupedActionDumpFileExt = 'web-dump.json';
+function processCacheConfig(cache, cacheId) {
+    if (void 0 !== cache) {
+        if (false === cache) return;
+        if (true === cache) return {
+            id: cacheId
+        };
+        if ('object' == typeof cache && null !== cache) {
+            if (!cache.id) return {
+                ...cache,
+                id: cacheId
+            };
+            return cache;
+        }
+    }
+    const envEnabled = globalConfigManager.getEnvConfigInBoolean(MIDSCENE_CACHE);
+    if (envEnabled && cacheId) return {
+        id: cacheId
+    };
+}
+const reportInitializedMap = new Map();
+const reportGroupIdMap = new Map();
+function getReportTpl() {
+    const reportTpl = /*REPORT_HTML_REPLACED*/"<!doctype html>\n<html>\n\n<head>\n  <title>Report - RPA智能助手</title>\n  <link rel=\"icon\" type=\"image/png\" sizes=\"32x32\" href=\"./favicon-32x32.png\" />\n</head>\n\n<body>\n  <!-- it should be replaced by the actual content -->\n  <div id=\"<%= mountId %>\" style=\"height: 100vh; width: 100vw\"></div>\n</body>\n\n</html>";
+    return reportTpl;
+}
+function insertContentBeforeClosingHtml(html, content) {
+    const htmlEndIdx = html.lastIndexOf('</html>');
+    if (-1 === htmlEndIdx) return html + content;
+    return `${html.slice(0, htmlEndIdx)}${content}\n${html.slice(htmlEndIdx)}`;
+}
+function insertScriptBeforeClosingHtml(filePath, scriptContent) {
+    const htmlEndTag = '</html>';
+    const stat = statSync(filePath);
+    const readSize = Math.min(stat.size, 4096);
+    const start = Math.max(0, stat.size - readSize);
+    const buffer = Buffer.alloc(stat.size - start);
+    const fd = openSync(filePath, 'r');
+    readSync(fd, buffer, 0, buffer.length, start);
+    closeSync(fd);
+    const tailStr = buffer.toString('utf8');
+    const htmlEndIdx = tailStr.lastIndexOf(htmlEndTag);
+    if (-1 === htmlEndIdx) throw new Error(`No </html> found in file：${filePath}`);
+    const beforeHtmlInTail = tailStr.slice(0, htmlEndIdx);
+    const htmlEndPos = start + Buffer.byteLength(beforeHtmlInTail, 'utf8');
+    truncateSync(filePath, htmlEndPos);
+    appendFileSync(filePath, `${scriptContent}\n${htmlEndTag}\n`);
+}
+function reportHTMLContent(dumpData, reportPath, appendReport, withTpl = true) {
+    let tpl = '';
+    if (withTpl) {
+        tpl = getReportTpl();
+        if (!tpl) {
+            console.warn('reportTpl is not set, will not write report');
+            return '';
+        }
+    }
+    const writeToFile = reportPath && !ifInBrowser;
+    let dumpContent = '';
+    const resolveAutoGroupId = ()=>{
+        if (!reportPath || !appendReport) return uuid();
+        const existingGroupId = reportGroupIdMap.get(reportPath);
+        if (existingGroupId) return existingGroupId;
+        const newGroupId = uuid();
+        reportGroupIdMap.set(reportPath, newGroupId);
+        return newGroupId;
+    };
+    if ('string' == typeof dumpData) {
+        const groupId = resolveAutoGroupId();
+        dumpContent = '<script type="midscene_web_dump" type="application/json" data-group-id="' + encodeURIComponent(groupId) + '">\n' + escapeScriptTag(dumpData) + "\n<\/script>";
+    } else {
+        const { dumpString, attributes } = dumpData;
+        const attributesArr = Object.entries(attributes || {}).filter((entry)=>void 0 !== entry[1] && null !== entry[1]).map(([key, value])=>`${key}="${encodeURIComponent(value)}"`);
+        dumpContent = '<script type="midscene_web_dump" type="application/json" ' + attributesArr.join(' ') + '>\n' + escapeScriptTag(dumpString) + "\n<\/script>";
+    }
+    if (writeToFile) {
+        if (!appendReport) {
+            writeFileSync(reportPath, insertContentBeforeClosingHtml(tpl, dumpContent), {
+                flag: 'w'
+            });
+            return reportPath;
+        }
+        if (!reportInitializedMap.get(reportPath)) {
+            writeFileSync(reportPath, tpl, {
+                flag: 'w'
+            });
+            reportInitializedMap.set(reportPath, true);
+        }
+        insertScriptBeforeClosingHtml(reportPath, dumpContent);
+        return reportPath;
+    }
+    return insertContentBeforeClosingHtml(tpl, dumpContent);
+}
+function writeDumpReport(fileName, dumpData, appendReport) {
+    if (ifInBrowser || ifInWorker) {
+        console.log('will not write report in browser');
+        return null;
+    }
+    const reportPath = join(getMidsceneRunSubDir('report'), `${fileName}.html`);
+    reportHTMLContent(dumpData, reportPath, appendReport);
+    if (process.env.MIDSCENE_DEBUG_LOG_JSON) {
+        const jsonPath = `${reportPath}.json`;
+        let data;
+        data = 'string' == typeof dumpData ? JSON.parse(dumpData) : dumpData;
+        writeFileSync(jsonPath, JSON.stringify(data, null, 2), {
+            flag: appendReport ? 'a' : 'w'
+        });
+        logMsg(`Midscene - dump file written: ${jsonPath}`);
+    }
+    return reportPath;
+}
+function writeLogFile(opts) {
+    if (ifInBrowser || ifInWorker) return '/mock/report.html';
+    const { fileName, fileExt, fileContent, type = 'dump' } = opts;
+    const targetDir = getMidsceneRunSubDir(type);
+    if (!logEnvReady) {
+        assert(targetDir, 'logDir should be set before writing dump file');
+        const gitIgnorePath = join(targetDir, '../../.gitignore');
+        const gitPath = join(targetDir, '../../.git');
+        let gitIgnoreContent = '';
+        if (existsSync(gitPath)) {
+            if (existsSync(gitIgnorePath)) gitIgnoreContent = readFileSync(gitIgnorePath, 'utf-8');
+            if (!gitIgnoreContent.includes(`${defaultRunDirName}/`)) writeFileSync(gitIgnorePath, `${gitIgnoreContent}\n# RPA智能助手 dump files\n${defaultRunDirName}/dump\n${defaultRunDirName}/report\n${defaultRunDirName}/tmp\n${defaultRunDirName}/log\n`, 'utf-8');
+        }
+        logEnvReady = true;
+    }
+    const filePath = join(targetDir, `${fileName}.${fileExt}`);
+    if ('dump' !== type) writeFileSync(filePath, JSON.stringify(fileContent));
+    if (opts?.generateReport) return writeDumpReport(fileName, fileContent, opts.appendReport);
+    return filePath;
+}
+function getTmpDir() {
+    try {
+        const runningPkgInfo = getRunningPkgInfo();
+        if (!runningPkgInfo) return null;
+        const { name } = runningPkgInfo;
+        const tmpPath = join(tmpdir(), name);
+        mkdirSync(tmpPath, {
+            recursive: true
+        });
+        return tmpPath;
+    } catch (e) {
+        return null;
+    }
+}
+function getTmpFile(fileExtWithoutDot) {
+    if (ifInBrowser || ifInWorker) return null;
+    const tmpDir = getTmpDir();
+    const filename = `${uuid()}.${fileExtWithoutDot}`;
+    return join(tmpDir, filename);
+}
+function overlapped(container, target) {
+    return container.left < target.left + target.width && container.left + container.width > target.left && container.top < target.top + target.height && container.top + container.height > target.top;
+}
+async function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+function replacerForPageObject(_key, value) {
+    if (value && value.constructor?.name === 'Page') return '[Page object]';
+    if (value && value.constructor?.name === 'Browser') return '[Browser object]';
+    if (value && 'function' == typeof value.toSerializable) return value.toSerializable();
+    return value;
+}
+function stringifyDumpData(data, indents) {
+    return JSON.stringify(data, replacerForPageObject, indents);
+}
+function getVersion() {
+    return "1.7.10";
+}
+function debugLog(...message) {
+    const debugMode = process.env[MIDSCENE_DEBUG_MODE];
+    if (debugMode) console.log('[Midscene]', ...message);
+}
+let gitInfoPromise = null;
+function getGitInfoAsync() {
+    if (gitInfoPromise) return gitInfoPromise;
+    const execFileAsync = promisify(execFile);
+    gitInfoPromise = Promise.all([
+        execFileAsync('git', [
+            'config',
+            '--get',
+            'remote.origin.url'
+        ]).then(({ stdout })=>stdout.trim(), ()=>''),
+        execFileAsync('git', [
+            'config',
+            '--get',
+            'user.email'
+        ]).then(({ stdout })=>stdout.trim(), ()=>'')
+    ]).then(([repoUrl, userEmail])=>({
+            repoUrl,
+            userEmail
+        }));
+    return gitInfoPromise;
+}
+let lastReportedRepoUrl = '';
+async function uploadTestInfoToServer({ testUrl, serverUrl }) {
+    if (!serverUrl) return;
+    const { repoUrl, userEmail } = await getGitInfoAsync();
+    if (repoUrl ? repoUrl !== lastReportedRepoUrl : !!testUrl) {
+        debugLog('Uploading test info to server', {
+            serverUrl,
+            repoUrl,
+            testUrl,
+            userEmail
+        });
+        fetch(serverUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                repo_url: repoUrl,
+                test_url: testUrl,
+                user_email: userEmail
+            })
+        }).then((response)=>response.json()).then((data)=>{
+            debugLog('Successfully uploaded test info to server:', data);
+        }).catch((error)=>debugLog('Failed to upload test info to server:', error));
+        lastReportedRepoUrl = repoUrl;
+    }
+}
+export { appendFileSync, getReportTpl, getTmpDir, getTmpFile, getVersion, groupedActionDumpFileExt, insertContentBeforeClosingHtml, insertScriptBeforeClosingHtml, overlapped, processCacheConfig, replacerForPageObject, reportHTMLContent, sleep, stringifyDumpData, uploadTestInfoToServer, writeDumpReport, writeLogFile };

package/dist/es/yaml/builder.mjs

@@ -0,0 +1,11 @@
+import js_yaml from "js-yaml";
+function buildYaml(env, tasks) {
+    const result = {
+        target: env,
+        tasks
+    };
+    return js_yaml.dump(result, {
+        indent: 2
+    });
+}
+export { buildYaml };

package/dist/es/yaml/index.mjs

@@ -0,0 +1,4 @@
+export * from "../yaml.mjs";
+export * from "./player.mjs";
+export * from "./builder.mjs";
+export * from "./utils.mjs";