@vibe-lark/larkpal 0.1.85 → 0.1.86

package/dist/json-file-BQRNuxmK-DhJM5NsG.mjs

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/json-file-BQRNuxmK.js
+const JSON_FILE_MODE = 384;
+const JSON_DIR_MODE = 448;
+function trySetSecureMode(pathname) {
+	try {
+		fs.chmodSync(pathname, JSON_FILE_MODE);
+	} catch {}
+}
+function trySyncDirectory(pathname) {
+	let fd;
+	try {
+		fd = fs.openSync(path.dirname(pathname), "r");
+		fs.fsyncSync(fd);
+	} catch {} finally {
+		if (fd !== void 0) try {
+			fs.closeSync(fd);
+		} catch {}
+	}
+}
+function readSymlinkTargetPath(linkPath) {
+	const target = fs.readlinkSync(linkPath);
+	return path.resolve(path.dirname(linkPath), target);
+}
+function resolveJsonWriteTarget(pathname) {
+	let currentPath = pathname;
+	const visited = /* @__PURE__ */ new Set();
+	let followsSymlink = false;
+	for (;;) {
+		let stat;
+		try {
+			stat = fs.lstatSync(currentPath);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			return {
+				targetPath: currentPath,
+				followsSymlink
+			};
+		}
+		if (!stat.isSymbolicLink()) return {
+			targetPath: currentPath,
+			followsSymlink
+		};
+		if (visited.has(currentPath)) {
+			const err = /* @__PURE__ */ new Error(`Too many symlink levels while resolving ${pathname}`);
+			err.code = "ELOOP";
+			throw err;
+		}
+		visited.add(currentPath);
+		followsSymlink = true;
+		currentPath = readSymlinkTargetPath(currentPath);
+	}
+}
+function renameJsonFileWithFallback(tmpPath, pathname) {
+	try {
+		fs.renameSync(tmpPath, pathname);
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (code === "EPERM" || code === "EEXIST") {
+			fs.copyFileSync(tmpPath, pathname);
+			fs.rmSync(tmpPath, { force: true });
+			return;
+		}
+		throw error;
+	}
+}
+function writeTempJsonFile(pathname, payload) {
+	const fd = fs.openSync(pathname, "w", JSON_FILE_MODE);
+	try {
+		fs.writeFileSync(fd, payload, "utf8");
+		fs.fsyncSync(fd);
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+function loadJsonFile(pathname) {
+	try {
+		const raw = fs.readFileSync(pathname, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return;
+	}
+}
+function saveJsonFile(pathname, data) {
+	const { targetPath, followsSymlink } = resolveJsonWriteTarget(pathname);
+	const tmpPath = `${targetPath}.${randomUUID()}.tmp`;
+	const payload = `${JSON.stringify(data, null, 2)}\n`;
+	if (!followsSymlink) fs.mkdirSync(path.dirname(targetPath), {
+		recursive: true,
+		mode: JSON_DIR_MODE
+	});
+	try {
+		writeTempJsonFile(tmpPath, payload);
+		trySetSecureMode(tmpPath);
+		renameJsonFileWithFallback(tmpPath, targetPath);
+		trySetSecureMode(targetPath);
+		trySyncDirectory(targetPath);
+	} finally {
+		try {
+			fs.rmSync(tmpPath, { force: true });
+		} catch {}
+	}
+}
+//#endregion
+export { saveJsonFile as n, loadJsonFile as t };

package/dist/json-parse-v_HIJjjI.mjs

@@ -0,0 +1,381 @@
+import { t as __commonJSMin } from "./chunk-D6SyT4dJ.mjs";
+//#region node_modules/.pnpm/partial-json@0.1.7/node_modules/partial-json/dist/options.js
+var require_options = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Sometimes you don't allow every type to be partially parsed.
+	* For example, you may not want a partial number because it may increase its size gradually before it's complete.
+	* In this case, you can use the `Allow` object to control what types you allow to be partially parsed.
+	* @module
+	*/
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Allow = exports.ALL = exports.COLLECTION = exports.ATOM = exports.SPECIAL = exports.INF = exports._INFINITY = exports.INFINITY = exports.NAN = exports.BOOL = exports.NULL = exports.OBJ = exports.ARR = exports.NUM = exports.STR = void 0;
+	/**
+	* allow partial strings like `"hello \u12` to be parsed as `"hello "`
+	*/
+	exports.STR = 1;
+	/**
+	* allow partial numbers like `123.` to be parsed as `123`
+	*/
+	exports.NUM = 2;
+	/**
+	* allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+	*/
+	exports.ARR = 4;
+	/**
+	* allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+	*/
+	exports.OBJ = 8;
+	/**
+	* allow `nu` to be parsed as `null`
+	*/
+	exports.NULL = 16;
+	/**
+	* allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+	*/
+	exports.BOOL = 32;
+	/**
+	* allow `Na` to be parsed as `NaN`
+	*/
+	exports.NAN = 64;
+	/**
+	* allow `Inf` to be parsed as `Infinity`
+	*/
+	exports.INFINITY = 128;
+	/**
+	* allow `-Inf` to be parsed as `-Infinity`
+	*/
+	exports._INFINITY = 256;
+	exports.INF = exports.INFINITY | exports._INFINITY;
+	exports.SPECIAL = exports.NULL | exports.BOOL | exports.INF | exports.NAN;
+	exports.ATOM = exports.STR | exports.NUM | exports.SPECIAL;
+	exports.COLLECTION = exports.ARR | exports.OBJ;
+	exports.ALL = exports.ATOM | exports.COLLECTION;
+	/**
+	* Control what types you allow to be partially parsed.
+	* The default is to allow all types to be partially parsed, which in most casees is the best option.
+	* @example
+	* If you don't want to allow partial objects, you can use the following code:
+	* ```ts
+	* import { Allow, parse } from "partial-json";
+	* parse(`[{"a": 1, "b": 2}, {"a": 3,`, Allow.ARR); // [ { a: 1, b: 2 } ]
+	* ```
+	* Or you can use `~` to disallow a type:
+	* ```ts
+	* parse(`[{"a": 1, "b": 2}, {"a": 3,`, ~Allow.OBJ); // [ { a: 1, b: 2 } ]
+	* ```
+	* @example
+	* If you don't want to allow partial strings, you can use the following code:
+	* ```ts
+	* import { Allow, parse } from "partial-json";
+	* parse(`["complete string", "incompl`, ~Allow.STR); // [ 'complete string' ]
+	* ```
+	*/
+	exports.Allow = {
+		STR: exports.STR,
+		NUM: exports.NUM,
+		ARR: exports.ARR,
+		OBJ: exports.OBJ,
+		NULL: exports.NULL,
+		BOOL: exports.BOOL,
+		NAN: exports.NAN,
+		INFINITY: exports.INFINITY,
+		_INFINITY: exports._INFINITY,
+		INF: exports.INF,
+		SPECIAL: exports.SPECIAL,
+		ATOM: exports.ATOM,
+		COLLECTION: exports.COLLECTION,
+		ALL: exports.ALL
+	};
+	exports.default = exports.Allow;
+}));
+//#endregion
+//#region node_modules/.pnpm/@mariozechner+pi-ai@0.69.0_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6__ws@8.21.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/utils/json-parse.js
+var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Allow = exports.MalformedJSON = exports.PartialJSON = exports.parseJSON = exports.parse = void 0;
+	const options_1 = require_options();
+	Object.defineProperty(exports, "Allow", {
+		enumerable: true,
+		get: function() {
+			return options_1.Allow;
+		}
+	});
+	__exportStar(require_options(), exports);
+	var PartialJSON = class extends Error {};
+	exports.PartialJSON = PartialJSON;
+	var MalformedJSON = class extends Error {};
+	exports.MalformedJSON = MalformedJSON;
+	/**
+	* Parse incomplete JSON
+	* @param {string} jsonString Partial JSON to be parsed
+	* @param {number} allowPartial Specify what types are allowed to be partial, see {@link Allow} for details
+	* @returns The parsed JSON
+	* @throws {PartialJSON} If the JSON is incomplete (related to the `allow` parameter)
+	* @throws {MalformedJSON} If the JSON is malformed
+	*/
+	function parseJSON(jsonString, allowPartial = options_1.Allow.ALL) {
+		if (typeof jsonString !== "string") throw new TypeError(`expecting str, got ${typeof jsonString}`);
+		if (!jsonString.trim()) throw new Error(`${jsonString} is empty`);
+		return _parseJSON(jsonString.trim(), allowPartial);
+	}
+	exports.parseJSON = parseJSON;
+	const _parseJSON = (jsonString, allow) => {
+		const length = jsonString.length;
+		let index = 0;
+		const markPartialJSON = (msg) => {
+			throw new PartialJSON(`${msg} at position ${index}`);
+		};
+		const throwMalformedError = (msg) => {
+			throw new MalformedJSON(`${msg} at position ${index}`);
+		};
+		const parseAny = () => {
+			skipBlank();
+			if (index >= length) markPartialJSON("Unexpected end of input");
+			if (jsonString[index] === "\"") return parseStr();
+			if (jsonString[index] === "{") return parseObj();
+			if (jsonString[index] === "[") return parseArr();
+			if (jsonString.substring(index, index + 4) === "null" || options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index))) {
+				index += 4;
+				return null;
+			}
+			if (jsonString.substring(index, index + 4) === "true" || options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index))) {
+				index += 4;
+				return true;
+			}
+			if (jsonString.substring(index, index + 5) === "false" || options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index))) {
+				index += 5;
+				return false;
+			}
+			if (jsonString.substring(index, index + 8) === "Infinity" || options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index))) {
+				index += 8;
+				return Infinity;
+			}
+			if (jsonString.substring(index, index + 9) === "-Infinity" || options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index))) {
+				index += 9;
+				return -Infinity;
+			}
+			if (jsonString.substring(index, index + 3) === "NaN" || options_1.Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index))) {
+				index += 3;
+				return NaN;
+			}
+			return parseNum();
+		};
+		const parseStr = () => {
+			const start = index;
+			let escape = false;
+			index++;
+			while (index < length && (jsonString[index] !== "\"" || escape && jsonString[index - 1] === "\\")) {
+				escape = jsonString[index] === "\\" ? !escape : false;
+				index++;
+			}
+			if (jsonString.charAt(index) == "\"") try {
+				return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
+			} catch (e) {
+				throwMalformedError(String(e));
+			}
+			else if (options_1.Allow.STR & allow) try {
+				return JSON.parse(jsonString.substring(start, index - Number(escape)) + "\"");
+			} catch (e) {
+				return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + "\"");
+			}
+			markPartialJSON("Unterminated string literal");
+		};
+		const parseObj = () => {
+			index++;
+			skipBlank();
+			const obj = {};
+			try {
+				while (jsonString[index] !== "}") {
+					skipBlank();
+					if (index >= length && options_1.Allow.OBJ & allow) return obj;
+					const key = parseStr();
+					skipBlank();
+					index++;
+					try {
+						obj[key] = parseAny();
+					} catch (e) {
+						if (options_1.Allow.OBJ & allow) return obj;
+						else throw e;
+					}
+					skipBlank();
+					if (jsonString[index] === ",") index++;
+				}
+			} catch (e) {
+				if (options_1.Allow.OBJ & allow) return obj;
+				else markPartialJSON("Expected '}' at end of object");
+			}
+			index++;
+			return obj;
+		};
+		const parseArr = () => {
+			index++;
+			const arr = [];
+			try {
+				while (jsonString[index] !== "]") {
+					arr.push(parseAny());
+					skipBlank();
+					if (jsonString[index] === ",") index++;
+				}
+			} catch (e) {
+				if (options_1.Allow.ARR & allow) return arr;
+				markPartialJSON("Expected ']' at end of array");
+			}
+			index++;
+			return arr;
+		};
+		const parseNum = () => {
+			if (index === 0) {
+				if (jsonString === "-") throwMalformedError("Not sure what '-' is");
+				try {
+					return JSON.parse(jsonString);
+				} catch (e) {
+					if (options_1.Allow.NUM & allow) try {
+						return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+					} catch (e) {}
+					throwMalformedError(String(e));
+				}
+			}
+			const start = index;
+			if (jsonString[index] === "-") index++;
+			while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1) index++;
+			if (index == length && !(options_1.Allow.NUM & allow)) markPartialJSON("Unterminated number literal");
+			try {
+				return JSON.parse(jsonString.substring(start, index));
+			} catch (e) {
+				if (jsonString.substring(start, index) === "-") markPartialJSON("Not sure what '-' is");
+				try {
+					return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
+				} catch (e) {
+					throwMalformedError(String(e));
+				}
+			}
+		};
+		const skipBlank = () => {
+			while (index < length && " \n\r	".includes(jsonString[index])) index++;
+		};
+		return parseAny();
+	};
+	exports.parse = parseJSON;
+})))();
+const VALID_JSON_ESCAPES = new Set([
+	"\"",
+	"\\",
+	"/",
+	"b",
+	"f",
+	"n",
+	"r",
+	"t",
+	"u"
+]);
+function isControlCharacter(char) {
+	const codePoint = char.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 0 && codePoint <= 31;
+}
+function escapeControlCharacter(char) {
+	switch (char) {
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		default: return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+	}
+}
+/**
+* Repairs malformed JSON string literals by:
+* - escaping raw control characters inside strings
+* - doubling backslashes before invalid escape characters
+*/
+function repairJson(json) {
+	let repaired = "";
+	let inString = false;
+	for (let index = 0; index < json.length; index++) {
+		const char = json[index];
+		if (!inString) {
+			repaired += char;
+			if (char === "\"") inString = true;
+			continue;
+		}
+		if (char === "\"") {
+			repaired += char;
+			inString = false;
+			continue;
+		}
+		if (char === "\\") {
+			const nextChar = json[index + 1];
+			if (nextChar === void 0) {
+				repaired += "\\\\";
+				continue;
+			}
+			if (nextChar === "u") {
+				const unicodeDigits = json.slice(index + 2, index + 6);
+				if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+					repaired += `\\u${unicodeDigits}`;
+					index += 5;
+					continue;
+				}
+			}
+			if (VALID_JSON_ESCAPES.has(nextChar)) {
+				repaired += `\\${nextChar}`;
+				index += 1;
+				continue;
+			}
+			repaired += "\\\\";
+			continue;
+		}
+		repaired += isControlCharacter(char) ? escapeControlCharacter(char) : char;
+	}
+	return repaired;
+}
+function parseJsonWithRepair(json) {
+	try {
+		return JSON.parse(json);
+	} catch (error) {
+		const repairedJson = repairJson(json);
+		if (repairedJson !== json) return JSON.parse(repairedJson);
+		throw error;
+	}
+}
+/**
+* Attempts to parse potentially incomplete JSON during streaming.
+* Always returns a valid object, even if the JSON is incomplete.
+*
+* @param partialJson The partial JSON string from streaming
+* @returns Parsed object or empty object if parsing fails
+*/
+function parseStreamingJson(partialJson) {
+	if (!partialJson || partialJson.trim() === "") return {};
+	try {
+		return parseJsonWithRepair(partialJson);
+	} catch {
+		try {
+			return (0, import_dist.parse)(partialJson) ?? {};
+		} catch {
+			try {
+				return (0, import_dist.parse)(repairJson(partialJson)) ?? {};
+			} catch {
+				return {};
+			}
+		}
+	}
+}
+//#endregion
+export { parseStreamingJson as n, parseJsonWithRepair as t };