@webskill/sdk 0.0.1

package/dist/dist-9fczg9Pa.js

@@ -0,0 +1,1122 @@
+import { D as normalizeToolContent, G as parseSkillMarkdown, H as isValidSkillName, J as resolveInsideRoot, O as parseBridgeRequest, R as WebSkillError, Y as validateSkills, o as FsArtifactStore, s as FsMemoryStore, x as bridgeError } from "./dist-B_ldNWwT.js";
+import { existsSync, promises, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { format, promisify } from "node:util";
+import { Worker } from "node:worker_threads";
+import { createInterface } from "node:readline/promises";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { unzipSync, zipSync } from "fflate";
+import * as tar from "tar";
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+
+//#region ../node/dist/index.js
+const toPlatform$3 = (p) => p.split("/").join(path.sep);
+const toPosix = (p) => p.split(path.sep).join("/");
+const isEnoent = (e) => typeof e === "object" && e !== null && e.code === "ENOENT";
+/** 基于 node:fs/promises 的 FileSystemProvider；接受 `/` 风格路径，写入自动创建父目录 */
+var NodeFS = class {
+	kind = "node";
+	async readText(p) {
+		try {
+			return await promises.readFile(toPlatform$3(p), "utf8");
+		} catch (e) {
+			throw this.#mapError(e, p);
+		}
+	}
+	async writeText(p, content) {
+		const target = toPlatform$3(p);
+		await promises.mkdir(path.dirname(target), { recursive: true });
+		await promises.writeFile(target, content, "utf8");
+	}
+	async readBinary(p) {
+		try {
+			return await promises.readFile(toPlatform$3(p));
+		} catch (e) {
+			throw this.#mapError(e, p);
+		}
+	}
+	async writeBinary(p, content) {
+		const target = toPlatform$3(p);
+		await promises.mkdir(path.dirname(target), { recursive: true });
+		await promises.writeFile(target, content);
+	}
+	async exists(p) {
+		try {
+			await promises.access(toPlatform$3(p));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async stat(p) {
+		try {
+			const s = await promises.stat(toPlatform$3(p));
+			return {
+				path: toPosix(p),
+				type: s.isDirectory() ? "directory" : "file",
+				size: s.isFile() ? s.size : void 0,
+				mtimeMs: s.mtimeMs
+			};
+		} catch (e) {
+			throw this.#mapError(e, p);
+		}
+	}
+	async list(p) {
+		let dirents;
+		try {
+			dirents = await promises.readdir(toPlatform$3(p), { withFileTypes: true });
+		} catch (e) {
+			throw this.#mapError(e, p);
+		}
+		return dirents.map((d) => ({
+			path: toPosix(path.join(toPlatform$3(p), d.name)),
+			type: d.isDirectory() ? "directory" : "file"
+		}));
+	}
+	async mkdir(p) {
+		await promises.mkdir(toPlatform$3(p), { recursive: true });
+	}
+	async remove(p, options) {
+		try {
+			await promises.rm(toPlatform$3(p), { recursive: options?.recursive ?? false });
+		} catch (e) {
+			throw this.#mapError(e, p);
+		}
+	}
+	#mapError(e, p) {
+		if (isEnoent(e)) return new WebSkillError("FS_NOT_FOUND", `Path not found: ${p}`);
+		return e;
+	}
+};
+const baseName$1 = (p) => p.split("/").pop() ?? p;
+const toPlatform$2 = (p) => p.split("/").join(path.sep);
+/**
+* 进程内脚本执行器。接口按沙箱语义设计（context 无隐式宿主访问），
+* worker_threads 沙箱见 deferred-items D1。
+*/
+var NodeScriptExecutor = class {
+	#fs;
+	constructor(fs) {
+		this.#fs = fs;
+	}
+	/** 定位 scripts/<name>.ts|js；冲突/缺失抛结构化错误 */
+	async #locateScript(skillRoot, scriptName) {
+		const tsPath = `${skillRoot}/scripts/${scriptName}.ts`;
+		const jsPath = `${skillRoot}/scripts/${scriptName}.js`;
+		const [hasTs, hasJs] = await Promise.all([this.#fs.exists(tsPath), this.#fs.exists(jsPath)]);
+		if (hasTs && hasJs) throw new WebSkillError("TOOL_EXECUTION_FAILED", `Script "${scriptName}" is ambiguous: both .ts and .js exist under ${skillRoot}/scripts`);
+		if (!hasTs && !hasJs) throw new WebSkillError("TOOL_NOT_FOUND", `Script "${scriptName}" not found under ${skillRoot}/scripts`);
+		return hasTs ? tsPath : jsPath;
+	}
+	async #loadModule(scriptPath) {
+		return await import(`${pathToFileURL(toPlatform$2(scriptPath)).href}?t=${Date.now()}`);
+	}
+	async loadDefinition(skillRoot, scriptName) {
+		const scriptPath = await this.#locateScript(skillRoot, scriptName);
+		const skillName = baseName$1(skillRoot);
+		let module;
+		try {
+			module = await this.#loadModule(scriptPath);
+		} catch (e) {
+			throw new WebSkillError("TOOL_EXECUTION_FAILED", `Failed to load script "${scriptName}": ${e instanceof Error ? e.message : String(e)}`, e);
+		}
+		return {
+			name: `${skillName}__${scriptName}`,
+			description: typeof module.description === "string" ? module.description : void 0,
+			inputSchema: typeof module.inputSchema === "object" && module.inputSchema !== null ? module.inputSchema : void 0,
+			source: "script",
+			skillName
+		};
+	}
+	async execute(input) {
+		const { skillRoot, scriptName, args, context, timeoutMs } = input;
+		let scriptPath;
+		try {
+			scriptPath = await this.#locateScript(skillRoot, scriptName);
+		} catch (e) {
+			return this.#failure(e);
+		}
+		let module;
+		try {
+			module = await this.#loadModule(scriptPath);
+		} catch (e) {
+			return this.#failure(e);
+		}
+		if (typeof module.run !== "function") return {
+			ok: false,
+			content: [],
+			error: {
+				code: "TOOL_EXECUTION_FAILED",
+				message: `Script "${scriptName}" does not export a run function`
+			}
+		};
+		const missing = this.#missingRequiredArgs(module.inputSchema, args);
+		if (missing.length > 0) return {
+			ok: false,
+			content: [],
+			error: {
+				code: "TOOL_EXECUTION_FAILED",
+				message: `Missing required argument(s): ${missing.join(", ")}`
+			}
+		};
+		const stdout = [];
+		const stderr = [];
+		const originals = {
+			log: console.log,
+			info: console.info,
+			debug: console.debug,
+			warn: console.warn,
+			error: console.error
+		};
+		console.log = console.info = console.debug = (...a) => stdout.push(format(...a));
+		console.warn = console.error = (...a) => stderr.push(format(...a));
+		let timer;
+		try {
+			const runFn = module.run;
+			const timeout = new Promise((_, reject) => {
+				timer = setTimeout(() => reject(new WebSkillError("RUN_TIMEOUT", `Script "${scriptName}" timed out after ${timeoutMs}ms`)), timeoutMs);
+			});
+			const content = normalizeToolContent(await Promise.race([Promise.resolve().then(() => runFn(args, context)), timeout]));
+			if (stdout.length > 0) content.push({
+				type: "text",
+				text: stdout.join("\n")
+			});
+			return {
+				ok: true,
+				content
+			};
+		} catch (e) {
+			return this.#failure(e, stderr);
+		} finally {
+			if (timer) clearTimeout(timer);
+			console.log = originals.log;
+			console.info = originals.info;
+			console.debug = originals.debug;
+			console.warn = originals.warn;
+			console.error = originals.error;
+		}
+	}
+	#missingRequiredArgs(schema, args) {
+		if (typeof schema !== "object" || schema === null) return [];
+		const required = schema.required;
+		if (!Array.isArray(required)) return [];
+		return required.filter((key) => typeof key === "string" && args[key] === void 0);
+	}
+	#failure(e, stderr = []) {
+		const isTimeout = e instanceof WebSkillError && e.code === "RUN_TIMEOUT";
+		const code = e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED";
+		const base = e instanceof Error ? e.message : String(e);
+		const stderrSummary = stderr.length > 0 ? ` | stderr: ${stderr.join(" | ").slice(0, 500)}` : "";
+		return {
+			ok: false,
+			content: [],
+			error: {
+				code: isTimeout ? "RUN_TIMEOUT" : code,
+				message: `${base}${stderrSummary}`
+			}
+		};
+	}
+};
+const baseName = (p) => p.split("/").pop() ?? p;
+const toPlatform$1 = (p) => p.split("/").join(path.sep);
+const messageOf$5 = (e) => e instanceof Error ? e.message : String(e);
+/** Worker 入口文件：src 为同目录 .ts；dist 为 dist/executor/ 下的 .js */
+function workerEntryPath() {
+	const dir = path.dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		path.join(dir, "sandboxWorkerEntry.js"),
+		path.join(dir, "sandboxWorkerEntry.ts"),
+		path.join(dir, "executor", "sandboxWorkerEntry.js")
+	];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+	return candidates[0];
+}
+/**
+* D1：worker_threads 沙箱脚本执行器。
+* 每次执行独立 Worker（resourceLimits + env 白名单），loadDefinition 同样在
+* Worker 内完成（禁止主进程 import 不可信脚本）；超时 terminate（可杀同步死循环）。
+* 能力桥协议与浏览器同一来源（runtime/sandbox/bridgeProtocol）。
+*/
+var SandboxedScriptExecutor = class {
+	#fs;
+	#options;
+	#capabilities;
+	constructor(fs, options = {}) {
+		this.#fs = fs;
+		this.#options = options;
+		this.#capabilities = {
+			readReference: options.capabilities?.readReference ?? true,
+			writeArtifact: options.capabilities?.writeArtifact ?? true,
+			confirm: options.capabilities?.confirm ?? true
+		};
+	}
+	async #locateScript(skillRoot, scriptName) {
+		const tsPath = `${skillRoot}/scripts/${scriptName}.ts`;
+		const jsPath = `${skillRoot}/scripts/${scriptName}.js`;
+		const [hasTs, hasJs] = await Promise.all([this.#fs.exists(tsPath), this.#fs.exists(jsPath)]);
+		if (hasTs && hasJs) throw new WebSkillError("TOOL_EXECUTION_FAILED", `Script "${scriptName}" is ambiguous: both .ts and .js exist under ${skillRoot}/scripts`);
+		if (!hasTs && !hasJs) throw new WebSkillError("TOOL_NOT_FOUND", `Script "${scriptName}" not found under ${skillRoot}/scripts`);
+		return hasTs ? tsPath : jsPath;
+	}
+	async loadDefinition(skillRoot, scriptName) {
+		const scriptPath = await this.#locateScript(skillRoot, scriptName);
+		const skillName = baseName(skillRoot);
+		const result = await this.#runWorker({
+			mode: "load",
+			scriptPath: toPlatform$1(scriptPath),
+			scriptName
+		});
+		if (!result.ok) throw new WebSkillError("TOOL_EXECUTION_FAILED", `Failed to load script "${scriptName}": ${result.error?.message ?? "unknown error"}`);
+		return {
+			name: `${skillName}__${scriptName}`,
+			description: result.definition?.description,
+			inputSchema: result.definition?.inputSchema,
+			source: "script",
+			skillName
+		};
+	}
+	async execute(input) {
+		const { skillRoot, scriptName, args, context, timeoutMs } = input;
+		let scriptPath;
+		try {
+			scriptPath = await this.#locateScript(skillRoot, scriptName);
+		} catch (e) {
+			return {
+				ok: false,
+				content: [],
+				error: {
+					code: e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED",
+					message: messageOf$5(e)
+				}
+			};
+		}
+		try {
+			const result = await this.#runWorker({
+				mode: "execute",
+				scriptPath: toPlatform$1(scriptPath),
+				scriptName,
+				skillName: context.skillName,
+				runId: context.runId,
+				args
+			}, timeoutMs, (request) => this.#handleBridge(request, context));
+			if (!result.ok) {
+				const stderrSummary = result.stderr?.length ? ` | stderr: ${result.stderr.join(" | ").slice(0, 500)}` : "";
+				return {
+					ok: false,
+					content: [],
+					error: {
+						code: result.error?.code ?? "TOOL_EXECUTION_FAILED",
+						message: `${result.error?.message ?? "script execution failed"}${stderrSummary}`
+					}
+				};
+			}
+			const content = normalizeToolContent(result.value);
+			if (result.stdout?.length) content.push({
+				type: "text",
+				text: result.stdout.join("\n")
+			});
+			return {
+				ok: true,
+				content
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				content: [],
+				error: {
+					code: e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED",
+					message: messageOf$5(e)
+				}
+			};
+		}
+	}
+	/** 起独立 Worker 执行任务；超时 terminate（同步死循环可杀）；非零退出码 → TOOL_EXECUTION_FAILED */
+	#runWorker(workerData, timeoutMs = 3e4, onBridge) {
+		const envWhitelist = this.#options.envWhitelist ?? [];
+		const env = Object.fromEntries(envWhitelist.filter((key) => process.env[key] !== void 0).map((key) => [key, process.env[key]]));
+		return new Promise((resolve, reject) => {
+			const worker = new Worker(workerEntryPath(), {
+				workerData,
+				env,
+				resourceLimits: this.#options.resourceLimits ?? {
+					maxOldGenerationSizeMb: 64,
+					maxYoungGenerationSizeMb: 16
+				}
+			});
+			let settled = false;
+			const timer = setTimeout(() => {
+				if (settled) return;
+				settled = true;
+				worker.terminate();
+				reject(new WebSkillError("RUN_TIMEOUT", `Sandboxed script timed out after ${timeoutMs}ms (worker terminated)`));
+			}, timeoutMs);
+			const done = (fn) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				fn();
+			};
+			worker.on("message", (msg) => {
+				if (msg?.type === "bridge" && onBridge) {
+					const request = parseBridgeRequest(msg.request);
+					const respond = (response) => worker.postMessage({
+						type: "bridge-response",
+						response
+					});
+					if (!request) {
+						respond(bridgeError("unknown", "TOOL_EXECUTION_FAILED", "invalid bridge request"));
+						return;
+					}
+					onBridge(request).then(respond, (e) => respond(bridgeError(request.id, "TOOL_EXECUTION_FAILED", messageOf$5(e))));
+					return;
+				}
+				if (msg?.type === "load-result" || msg?.type === "execute-result") done(() => resolve(msg));
+			});
+			worker.on("error", (e) => done(() => reject(e)));
+			worker.on("exit", (code) => {
+				if (code !== 0) done(() => reject(new WebSkillError("TOOL_EXECUTION_FAILED", `Sandbox worker exited with code ${code}`)));
+			});
+		});
+	}
+	/** 能力桥宿主侧处理：能力关闭即 TOOL_UNSUPPORTED；委托 context */
+	async #handleBridge(request, context) {
+		const unsupported = (capability) => bridgeError(request.id, "TOOL_UNSUPPORTED", `Capability "${capability}" is disabled`);
+		try {
+			switch (request.kind) {
+				case "readReference":
+					if (!this.#capabilities.readReference) return unsupported("readReference");
+					return {
+						id: request.id,
+						ok: true,
+						value: await context.readReference(request.path)
+					};
+				case "writeArtifact": {
+					if (!this.#capabilities.writeArtifact) return unsupported("writeArtifact");
+					const content = typeof request.content === "string" ? request.content : new Uint8Array(request.content);
+					const artifact = await context.writeArtifact(request.path, content, { ...request.mimeType ? { mimeType: request.mimeType } : {} });
+					return {
+						id: request.id,
+						ok: true,
+						value: artifact
+					};
+				}
+				case "confirm":
+					if (!this.#capabilities.confirm || !context.confirm) return unsupported("confirm");
+					return {
+						id: request.id,
+						ok: true,
+						value: await context.confirm(request.message)
+					};
+			}
+		} catch (e) {
+			return bridgeError(request.id, e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED", messageOf$5(e));
+		}
+	}
+};
+/**
+* FileArtifactStore：兼容别名，语义同阶段 2-4。
+* 实现已上移到 runtime 的 FsArtifactStore；node 侧保留 NodeFS 默认值。
+*/
+var FileArtifactStore = class extends FsArtifactStore {
+	constructor(deps) {
+		super({
+			root: deps.root,
+			fs: deps.fs ?? new NodeFS()
+		});
+	}
+};
+/**
+* FileMemoryStore：兼容别名，语义同阶段 3。
+* 实现已上移到 runtime 的 FsMemoryStore；node 侧保留 NodeFS 默认值。
+*/
+var FileMemoryStore = class extends FsMemoryStore {
+	constructor(deps) {
+		super({
+			root: deps.root,
+			fs: deps.fs ?? new NodeFS()
+		});
+	}
+};
+/**
+* 命令行 UiBridge：ask→问答，confirm→y/n（带默认值），
+* form→逐字段提示（显示默认值与必填标记），select→编号列表。
+* 输入/输出流可注入（测试用 PassThrough）。
+*/
+var CliUiBridge = class {
+	#input;
+	#output;
+	constructor(deps = {}) {
+		this.#input = deps.input ?? process.stdin;
+		this.#output = deps.output ?? process.stdout;
+	}
+	async request(input) {
+		switch (input.type) {
+			case "ask": return {
+				id: input.id,
+				value: await this.#question(`${input.message}\n> `)
+			};
+			case "confirm": {
+				const hint = input.defaultValue === false ? "y/N" : "Y/n";
+				const answer = (await this.#question(`${input.message} [${hint}] `)).trim().toLowerCase();
+				const value = answer === "" ? input.defaultValue ?? true : answer === "y" || answer === "yes";
+				return {
+					id: input.id,
+					value
+				};
+			}
+			case "form": {
+				const value = {};
+				if (input.title) this.#write(`${input.title}\n`);
+				for (const field of input.fields) value[field.name] = await this.#askField(field);
+				return {
+					id: input.id,
+					value
+				};
+			}
+			case "select": {
+				const lines = input.options.map((o, i) => `  ${i + 1}) ${o.label}`).join("\n");
+				const answer = (await this.#question(`${input.message}\n${lines}\n> `)).trim();
+				const index = Number.parseInt(answer, 10) - 1;
+				const option = input.options[index];
+				return {
+					id: input.id,
+					value: option ? option.value : void 0
+				};
+			}
+		}
+	}
+	async progress(input) {
+		const pct = input.value !== void 0 ? ` (${Math.round(input.value * 100)}%)` : "";
+		this.#write(`[progress] ${input.message}${pct}\n`);
+	}
+	async renderResult(input) {
+		const lines = [`\n[result] ${input.summary ?? ""}`];
+		for (const block of input.blocks) if (block.type === "markdown") lines.push(block.text);
+		else if (block.type === "json") lines.push(JSON.stringify(block.data, null, 2));
+		else if (block.type === "file") lines.push(`[file] ${block.path}`);
+		this.#write(`${lines.join("\n")}\n`);
+	}
+	#write(text) {
+		this.#output.write(text);
+	}
+	async #askField(field) {
+		const requiredMark = field.required ? " (required)" : "";
+		const defaultMark = field.defaultValue !== void 0 ? ` [${JSON.stringify(field.defaultValue)}]` : "";
+		if (field.type === "select" && field.options) {
+			const lines = field.options.map((o, i) => `  ${i + 1}) ${o.label}`).join("\n");
+			const answer = (await this.#question(`${field.label}${requiredMark}${defaultMark}:\n${lines}\n> `)).trim();
+			if (answer === "") return field.defaultValue;
+			const option = field.options[Number.parseInt(answer, 10) - 1];
+			return option ? option.value : field.defaultValue;
+		}
+		const answer = (await this.#question(`${field.label}${requiredMark}${defaultMark}: `)).trim();
+		if (answer === "") return field.defaultValue;
+		switch (field.type) {
+			case "number": {
+				const n = Number(answer);
+				return Number.isNaN(n) ? field.defaultValue : n;
+			}
+			case "boolean": return answer === "y" || answer === "yes" || answer === "true";
+			case "textarea": try {
+				return JSON.parse(answer);
+			} catch {
+				return answer;
+			}
+			default: return answer;
+		}
+	}
+	#rl;
+	#lines = [];
+	#waiters = [];
+	/** 常驻 line 监听进入内部队列：预写入的多行输入不会在两次提问之间丢失 */
+	#ensureInterface() {
+		if (this.#rl) return;
+		this.#rl = createInterface({
+			input: this.#input,
+			output: this.#output,
+			terminal: false
+		});
+		this.#rl.on("line", (line) => {
+			const waiter = this.#waiters.shift();
+			if (waiter) waiter(line);
+			else this.#lines.push(line);
+		});
+	}
+	async #question(prompt) {
+		this.#ensureInterface();
+		this.#output.write(prompt);
+		const queued = this.#lines.shift();
+		if (queued !== void 0) return queued;
+		return new Promise((resolve) => this.#waiters.push(resolve));
+	}
+};
+const messageOf$4 = (e) => e instanceof Error ? e.message : String(e);
+const toPlatform = (p) => p.split("/").join(path.sep);
+const isZipArchive = (data) => data.length > 1 && data[0] === 80 && data[1] === 75;
+/**
+* zip 解包（fflate）。每个条目路径过 resolveInsideRoot：
+* 拒绝 `..` 段、绝对路径、反斜杠穿越（zip-slip 防护）。
+*/
+async function extractZipData(fs, data, destRoot) {
+	let entries;
+	try {
+		entries = unzipSync(data);
+	} catch (e) {
+		throw new WebSkillError("INSTALL_FAILED", `Failed to read zip archive: ${messageOf$4(e)}`, e);
+	}
+	for (const [entryPath, content] of Object.entries(entries)) {
+		const target = resolveInsideRoot(destRoot, entryPath);
+		if (entryPath.endsWith("/")) await fs.mkdir(target);
+		else await fs.writeBinary(target, content);
+	}
+}
+/**
+* tar/tar.gz 解包（tar 包）。先列条目逐一过 resolveInsideRoot 校验，
+* 再解包；符号链接/硬链接条目不跟随（跳过）。
+*/
+async function extractTarFile(archivePath, destRoot) {
+	try {
+		const entryPaths = [];
+		await tar.t({
+			file: toPlatform(archivePath),
+			onentry: (entry) => {
+				entryPaths.push(entry.path);
+			}
+		});
+		for (const p of entryPaths) if (!p.replace(/\\/g, "/").split("/").every((s) => s === "" || s === ".")) resolveInsideRoot(destRoot, p);
+		await tar.x({
+			file: toPlatform(archivePath),
+			cwd: toPlatform(destRoot),
+			filter: (_p, entry) => !("type" in entry) || entry.type !== "SymbolicLink" && entry.type !== "Link"
+		});
+	} catch (e) {
+		if (e instanceof WebSkillError) throw e;
+		throw new WebSkillError("INSTALL_FAILED", `Failed to extract tar archive: ${messageOf$4(e)}`, e);
+	}
+}
+/** 递归列出目录内全部文件（相对路径，posix 分隔，不含目录条目） */
+async function listFiles(fs, root, prefix = "") {
+	const out = [];
+	for (const entry of await fs.list(root)) {
+		const name = entry.path.split("/").pop() ?? "";
+		const rel = prefix === "" ? name : `${prefix}/${name}`;
+		if (entry.type === "directory") out.push(...await listFiles(fs, entry.path, rel));
+		else out.push(rel);
+	}
+	return out;
+}
+/** 递归拷贝目录（含子目录与二进制文件） */
+async function copyDir(fs, from, to) {
+	await fs.mkdir(to);
+	for (const entry of await fs.list(from)) {
+		const name = entry.path.split("/").pop() ?? "";
+		if (entry.type === "directory") await copyDir(fs, entry.path, `${to}/${name}`);
+		else await fs.writeBinary(`${to}/${name}`, await fs.readBinary(entry.path));
+	}
+}
+/** 删除目录（不存在时静默） */
+async function removeDirQuiet(fs, dir) {
+	try {
+		if (await fs.exists(dir)) await fs.remove(dir, { recursive: true });
+	} catch {}
+}
+/** 技能目录内的安装清单文件名（不参与 files 列表与 digest） */
+const SKILL_MANIFEST_FILE = "webskill.skill-manifest.json";
+/** managed root 下的锁定文件名（不参与 files 列表与 digest） */
+const SKILLS_LOCKFILE = "skills.lock.json";
+const messageOf$3 = (e) => e instanceof Error ? e.message : String(e);
+/** 导出技能目录全部文件（含 manifest）为 zip/tar 归档，返回 outPath */
+async function exportArchive(fs, skillRoot, options) {
+	try {
+		if (options.format === "zip") {
+			const files = {};
+			for (const rel of await listFiles(fs, skillRoot)) files[rel] = await fs.readBinary(`${skillRoot}/${rel}`);
+			await fs.writeBinary(options.outPath, zipSync(files, { level: 6 }));
+		} else await tar.c({
+			file: toPlatform(options.outPath),
+			cwd: toPlatform(skillRoot)
+		}, ["."]);
+		return options.outPath;
+	} catch (e) {
+		if (e instanceof WebSkillError) throw e;
+		throw new WebSkillError("EXPORT_FAILED", `Failed to export ${options.format} archive: ${messageOf$3(e)}`, e);
+	}
+}
+/** 只解出归档中的 webskill.skill-manifest.json 条目（安装前预览） */
+async function readArchiveManifest(fs, archivePath) {
+	const notFound = () => new WebSkillError("EXPORT_FAILED", `Archive ${archivePath} does not contain ${SKILL_MANIFEST_FILE}`);
+	const data = await fs.readBinary(archivePath);
+	if (isZipArchive(data)) {
+		const entries = unzipSync(data);
+		const key = Object.keys(entries).find((k) => k === "webskill.skill-manifest.json" || k.endsWith(`/webskill.skill-manifest.json`));
+		if (!key) throw notFound();
+		return JSON.parse(new TextDecoder().decode(entries[key]));
+	}
+	let manifestText;
+	try {
+		await tar.t({
+			file: toPlatform(archivePath),
+			onentry: (entry) => {
+				if (entry.path === "webskill.skill-manifest.json" || entry.path.endsWith(`/webskill.skill-manifest.json`)) {
+					const chunks = [];
+					entry.on("data", (chunk) => chunks.push(chunk));
+					entry.on("end", () => {
+						manifestText = Buffer.concat(chunks).toString("utf8");
+					});
+				}
+			}
+		});
+	} catch (e) {
+		throw new WebSkillError("EXPORT_FAILED", `Failed to read tar archive: ${messageOf$3(e)}`, e);
+	}
+	if (manifestText === void 0) throw notFound();
+	return JSON.parse(manifestText);
+}
+const _execFileP = promisify(execFile);
+const messageOf$2 = (e) => e instanceof Error ? e.message : String(e);
+/**
+* 跨平台执行命令：Windows 下对 npm 等 cmd 包装的命令通过 cmd.exe 代理执行，
+* git 等原生 exe 不受影响。
+*/
+async function execFileP(command, args) {
+	if (process.platform === "win32" && command === "npm") return _execFileP("cmd", [
+		"/c",
+		command,
+		...args
+	]);
+	return _execFileP(command, args);
+}
+/** 命令缺失/失败 → INSTALL_FAILED 结构化诊断 */
+function commandFailed(command, e) {
+	return new WebSkillError("INSTALL_FAILED", `Failed to run ${command}: ${e?.code === "ENOENT" ? `command "${command}" not found on this system` : messageOf$2(e)}`, e);
+}
+/** git 源：clone --depth 1 + rev-parse HEAD 记录 commit */
+async function stageGit(source, ctx) {
+	const skillDir = `${ctx.stagingRoot}/repo`;
+	const args = [
+		"clone",
+		"--depth",
+		"1",
+		...source.ref ? ["--branch", source.ref] : [],
+		source.url,
+		skillDir
+	];
+	try {
+		await execFileP("git", args);
+	} catch (e) {
+		throw commandFailed("git", e);
+	}
+	let commit;
+	try {
+		const { stdout } = await execFileP("git", [
+			"-C",
+			skillDir,
+			"rev-parse",
+			"HEAD"
+		]);
+		commit = stdout.trim() || void 0;
+	} catch {}
+	return {
+		skillDir,
+		source: {
+			...source,
+			...commit ? { commit } : {}
+		}
+	};
+}
+function sha256Hex(data) {
+	return createHash("sha256").update(data).digest("hex");
+}
+/** 整体 digest：逐文件 "<path>:<sha256>\n" 拼接串（文件按 path 排序）的 sha256 */
+function computeDigest(files) {
+	return sha256Hex([...files].sort((a, b) => a.path.localeCompare(b.path)).map((f) => `${f.path}:${f.sha256}\n`).join(""));
+}
+const messageOf$1 = (e) => e instanceof Error ? e.message : String(e);
+/** http 源：下载归档（可选 expectedSha256 校验包体）→ 解包 → 定位技能根 */
+async function stageHttp(source, ctx, expectedSha256) {
+	const fetchImpl = ctx.fetchImpl ?? fetch;
+	let res;
+	try {
+		res = await fetchImpl(source.url);
+	} catch (e) {
+		throw new WebSkillError("INSTALL_FAILED", `Download failed: ${messageOf$1(e)}`, e);
+	}
+	if (!res.ok) throw new WebSkillError("INSTALL_FAILED", `Download failed with HTTP ${res.status}`);
+	const data = new Uint8Array(await res.arrayBuffer());
+	if (expectedSha256 !== void 0) {
+		const actual = sha256Hex(data);
+		if (actual !== expectedSha256) throw new WebSkillError("INSTALL_FAILED", `Archive checksum mismatch: expected ${expectedSha256}, got ${actual}`);
+	}
+	const contentDir = `${ctx.stagingRoot}/content`;
+	await ctx.fs.mkdir(contentDir);
+	if (isZipArchive(data)) await extractZipData(ctx.fs, data, contentDir);
+	else {
+		const archivePath = `${ctx.stagingRoot}/archive.tar`;
+		await ctx.fs.writeBinary(archivePath, data);
+		await extractTarFile(toPlatform(archivePath), toPlatform(contentDir));
+	}
+	if (await ctx.fs.exists(`${contentDir}/SKILL.md`)) return {
+		skillDir: contentDir,
+		source
+	};
+	const dirs = (await ctx.fs.list(contentDir)).filter((e) => e.type === "directory");
+	if (dirs.length === 1 && await ctx.fs.exists(`${dirs[0]?.path}/SKILL.md`)) return {
+		skillDir: dirs[0].path,
+		source
+	};
+	throw new WebSkillError("INSTALL_FAILED", "Archive does not contain a SKILL.md at its root or in a single top-level directory");
+}
+/** local 源：校验源目录存在，拷贝到 staging */
+async function stageLocal(source, ctx) {
+	if (!await ctx.fs.exists(source.path)) throw new WebSkillError("INSTALL_FAILED", `Local skill directory not found: ${source.path}`);
+	const skillDir = `${ctx.stagingRoot}/skill`;
+	await copyDir(ctx.fs, source.path, skillDir);
+	return {
+		skillDir,
+		source
+	};
+}
+/** npm 源：npm pack → 解 tar.gz；技能根取包的 skill/ 子目录（存在时）否则包根 */
+async function stageNpm(source, ctx) {
+	const spec = source.version ? `${source.packageName}@${source.version}` : source.packageName;
+	let stdout;
+	try {
+		({stdout} = await execFileP("npm", [
+			"pack",
+			spec,
+			"--pack-destination",
+			ctx.stagingRoot
+		]));
+	} catch (e) {
+		throw commandFailed("npm", e);
+	}
+	const tarball = stdout.trim().split("\n").filter(Boolean).pop();
+	const tgzPath = tarball ? `${ctx.stagingRoot}/${tarball}` : "";
+	if (!tarball || !await ctx.fs.exists(tgzPath)) throw new WebSkillError("INSTALL_FAILED", `npm pack output not found in staging directory: ${tarball ?? "(empty output)"}`);
+	const pkgDir = `${ctx.stagingRoot}/pkg`;
+	await ctx.fs.mkdir(pkgDir);
+	await extractTarFile(toPlatform(tgzPath), toPlatform(pkgDir));
+	const pkgRoot = `${pkgDir}/package`;
+	const skillDir = await ctx.fs.exists(`${pkgRoot}/skill/SKILL.md`) ? `${pkgRoot}/skill` : pkgRoot;
+	let packageName = source.packageName;
+	let version = source.version;
+	try {
+		const pkg = JSON.parse(await ctx.fs.readText(`${pkgRoot}/package.json`));
+		packageName = pkg.name ?? packageName;
+		version = pkg.version ?? version;
+	} catch {}
+	return {
+		skillDir,
+		source: {
+			type: "npm",
+			packageName,
+			...version ? { version } : {}
+		}
+	};
+}
+const emptyLockfile = () => ({
+	schemaVersion: 1,
+	skills: {}
+});
+/** 读取 lockfile；不存在返回空结构；损坏 JSON → INTEGRITY_FAILED */
+async function readLockfile(fs, managedRoot) {
+	const path = `${managedRoot}/${SKILLS_LOCKFILE}`;
+	if (!await fs.exists(path)) return emptyLockfile();
+	try {
+		const parsed = JSON.parse(await fs.readText(path));
+		if (typeof parsed !== "object" || parsed === null || typeof parsed.skills !== "object") throw new Error("unexpected lockfile shape");
+		return parsed;
+	} catch (e) {
+		throw new WebSkillError("INTEGRITY_FAILED", `Skills lockfile at ${path} is corrupted: ${e instanceof Error ? e.message : String(e)}`, e);
+	}
+}
+async function upsertLockEntry(fs, managedRoot, name, entry) {
+	const lockfile = await readLockfile(fs, managedRoot);
+	lockfile.skills[name] = entry;
+	await fs.writeText(`${managedRoot}/${SKILLS_LOCKFILE}`, JSON.stringify(lockfile, null, 2));
+	return lockfile;
+}
+async function removeLockEntry(fs, managedRoot, name) {
+	const lockfile = await readLockfile(fs, managedRoot);
+	delete lockfile.skills[name];
+	await fs.writeText(`${managedRoot}/${SKILLS_LOCKFILE}`, JSON.stringify(lockfile, null, 2));
+	return lockfile;
+}
+const EXCLUDED_FILES = /* @__PURE__ */ new Set([SKILL_MANIFEST_FILE, SKILLS_LOCKFILE]);
+/** 递归收集技能目录内的文件（相对路径，posix 分隔） */
+async function walkFiles(fs, root, prefix = "") {
+	const out = [];
+	for (const entry of await fs.list(root)) {
+		const name = entry.path.split("/").pop() ?? "";
+		const rel = prefix === "" ? name : `${prefix}/${name}`;
+		if (entry.type === "directory") out.push(...await walkFiles(fs, entry.path, rel));
+		else if (!EXCLUDED_FILES.has(name)) out.push(rel);
+	}
+	return out;
+}
+/** 生成并写入 webskill.skill-manifest.json */
+async function createManifest(fs, skillRoot, input) {
+	const files = [];
+	for (const rel of (await walkFiles(fs, skillRoot)).sort()) {
+		const content = await fs.readBinary(`${skillRoot}/${rel}`);
+		files.push({
+			path: rel,
+			size: content.length,
+			sha256: sha256Hex(content)
+		});
+	}
+	const manifest = {
+		schemaVersion: 1,
+		name: input.name,
+		...input.version !== void 0 ? { version: input.version } : {},
+		source: input.source,
+		installedAt: input.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		integrity: {
+			algorithm: "sha256",
+			digest: computeDigest(files)
+		},
+		files
+	};
+	await fs.writeText(`${skillRoot}/${SKILL_MANIFEST_FILE}`, JSON.stringify(manifest, null, 2));
+	return manifest;
+}
+/** 读取技能目录内的 manifest；缺失/损坏 → INTEGRITY_FAILED */
+async function readManifest(fs, skillRoot) {
+	const path = `${skillRoot}/${SKILL_MANIFEST_FILE}`;
+	if (!await fs.exists(path)) throw new WebSkillError("INTEGRITY_FAILED", `Skill manifest not found at ${path} (was the skill installed via SkillManager?)`);
+	try {
+		return JSON.parse(await fs.readText(path));
+	} catch (e) {
+		throw new WebSkillError("INTEGRITY_FAILED", `Skill manifest at ${path} is corrupted: ${e instanceof Error ? e.message : String(e)}`, e);
+	}
+}
+/** 按 manifest.files 逐文件重算 sha256 比对 */
+async function verifyIntegrity(fs, skillRoot) {
+	const manifest = await readManifest(fs, skillRoot);
+	const mismatches = [];
+	for (const file of manifest.files) {
+		const path = `${skillRoot}/${file.path}`;
+		if (!await fs.exists(path)) {
+			mismatches.push(file.path);
+			continue;
+		}
+		if (sha256Hex(await fs.readBinary(path)) !== file.sha256) mismatches.push(file.path);
+	}
+	return {
+		ok: mismatches.length === 0,
+		mismatches
+	};
+}
+const messageOf = (e) => e instanceof Error ? e.message : String(e);
+const asInstallFailed = (e) => e instanceof WebSkillError && e.code === "INSTALL_FAILED" ? e : new WebSkillError("INSTALL_FAILED", `Install failed: ${messageOf(e)}`, e);
+/**
+* 技能管理门面：统一安装管线（staging → 解析 name → 校验 → 拷贝 → manifest → lockfile），
+* 任何失败清理现场抛 INSTALL_FAILED。
+*/
+var SkillManager = class {
+	#managedRoot;
+	#fs;
+	#fetchImpl;
+	constructor(deps) {
+		this.#managedRoot = deps.managedRoot.replace(/\/+$/, "");
+		this.#fs = deps.fs ?? new NodeFS();
+		this.#fetchImpl = deps.fetchImpl;
+	}
+	async install(source, options) {
+		const fs = this.#fs;
+		const stagingRoot = (await mkdtemp(path.join(tmpdir(), "webskill-install-"))).split(path.sep).join("/");
+		/** 已写入目标目录时用于回滚 */
+		let targetDir;
+		try {
+			const ctx = {
+				fs,
+				stagingRoot,
+				...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+			};
+			let staged;
+			switch (source.type) {
+				case "local":
+					staged = await stageLocal(source, ctx);
+					break;
+				case "http":
+					staged = await stageHttp(source, ctx, options?.expectedSha256);
+					break;
+				case "git":
+					staged = await stageGit(source, ctx);
+					break;
+				case "npm":
+					staged = await stageNpm(source, ctx);
+					break;
+			}
+			let name;
+			let version;
+			try {
+				const { metadata } = parseSkillMarkdown(await fs.readText(`${staged.skillDir}/SKILL.md`));
+				name = metadata.name;
+				version = typeof metadata["version"] === "string" ? metadata["version"] : void 0;
+			} catch (e) {
+				throw new WebSkillError("INSTALL_FAILED", `Failed to read skill name from SKILL.md: ${messageOf(e)}`, e);
+			}
+			const finalRoot = `${stagingRoot}/final`;
+			const finalDir = `${finalRoot}/${name}`;
+			await copyDir(fs, staged.skillDir, finalDir);
+			const report = await validateSkills(fs, [finalRoot]);
+			if (!report.ok) {
+				const errors = report.issues.filter((i) => i.severity === "error");
+				throw new WebSkillError("INSTALL_FAILED", `Skill "${name}" failed validation: ${errors.map((i) => i.message).join("; ")}`, errors);
+			}
+			targetDir = `${this.#managedRoot}/${name}`;
+			if (await fs.exists(targetDir)) await fs.remove(targetDir, { recursive: true });
+			await copyDir(fs, finalDir, targetDir);
+			const manifest = await createManifest(fs, targetDir, {
+				name,
+				...version ? { version } : {},
+				source: staged.source
+			});
+			await upsertLockEntry(fs, this.#managedRoot, name, {
+				digest: manifest.integrity.digest,
+				installedAt: manifest.installedAt,
+				source: staged.source
+			});
+			targetDir = void 0;
+			return manifest;
+		} catch (e) {
+			if (targetDir) await removeDirQuiet(fs, targetDir);
+			throw asInstallFailed(e);
+		} finally {
+			await removeDirQuiet(fs, stagingRoot);
+		}
+	}
+	async uninstall(name) {
+		if (!isValidSkillName(name)) throw new WebSkillError("UNINSTALL_FAILED", `Invalid skill name (path traversal rejected): ${JSON.stringify(name)}`);
+		const targetDir = `${this.#managedRoot}/${name}`;
+		if (!await this.#fs.exists(targetDir)) throw new WebSkillError("UNINSTALL_FAILED", `Skill "${name}" is not installed`);
+		try {
+			await this.#fs.remove(targetDir, { recursive: true });
+			await removeLockEntry(this.#fs, this.#managedRoot, name);
+		} catch (e) {
+			throw new WebSkillError("UNINSTALL_FAILED", `Failed to uninstall "${name}": ${messageOf(e)}`, e);
+		}
+	}
+	async verifyIntegrity(name) {
+		if (!isValidSkillName(name)) throw new WebSkillError("INTEGRITY_FAILED", `Invalid skill name (path traversal rejected): ${JSON.stringify(name)}`);
+		return verifyIntegrity(this.#fs, `${this.#managedRoot}/${name}`);
+	}
+	async listInstalled() {
+		return readLockfile(this.#fs, this.#managedRoot);
+	}
+	async exportArchive(name, options) {
+		if (!isValidSkillName(name)) throw new WebSkillError("EXPORT_FAILED", `Invalid skill name (path traversal rejected): ${JSON.stringify(name)}`);
+		const skillRoot = `${this.#managedRoot}/${name}`;
+		if (!await this.#fs.exists(skillRoot)) throw new WebSkillError("EXPORT_FAILED", `Skill "${name}" is not installed`);
+		return exportArchive(this.#fs, skillRoot, options);
+	}
+};
+/**
+* 解析 .env（简单 KEY=VALUE 行解析，不引依赖），
+* 读取 VITE_BASE_URL / VITE_API_KEY / VITE_MODEL_NAME；缺项返回 undefined 供测试 skip 判断。
+*/
+function loadLlmConfigFromEnv(dotenvPath = ".env") {
+	let raw;
+	try {
+		raw = readFileSync(dotenvPath, "utf8");
+	} catch {
+		return;
+	}
+	const vars = /* @__PURE__ */ new Map();
+	for (const line of raw.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (trimmed === "" || trimmed.startsWith("#")) continue;
+		const eq = trimmed.indexOf("=");
+		if (eq <= 0) continue;
+		const key = trimmed.slice(0, eq).trim();
+		let value = trimmed.slice(eq + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		vars.set(key, value);
+	}
+	const baseUrl = vars.get("VITE_BASE_URL");
+	const apiKey = vars.get("VITE_API_KEY");
+	const model = vars.get("VITE_MODEL_NAME");
+	if (!baseUrl || !apiKey || !model) return void 0;
+	return {
+		baseUrl,
+		apiKey,
+		model
+	};
+}
+let capabilitiesCache;
+/**
+* 探测 LLM 能力（结果模块级缓存）：
+* - available：GET /models 可达（与 checkAvailability 同语义）
+* - nonStreaming：最小非流式 chat completion（max_tokens=1，短超时）；
+*   HTTP 400/404 或明确不支持非流式的错误 → false
+* - streaming 能力由 available 推断（SSE 解析在 SDK 侧实现）
+* 环境变量 VITE_LLM_NON_STREAMING=0 可显式强制 nonStreaming=false（模拟流式-only 回归）。
+*/
+function probeLlmCapabilities(config) {
+	capabilitiesCache ??= doProbeLlmCapabilities(config);
+	return capabilitiesCache;
+}
+async function doProbeLlmCapabilities(config) {
+	const baseUrl = config.baseUrl.replace(/\/+$/, "");
+	const headers = { authorization: `Bearer ${config.apiKey}` };
+	let available = false;
+	try {
+		available = (await fetch(`${baseUrl}/models`, {
+			headers,
+			signal: AbortSignal.timeout(1e4)
+		})).ok;
+	} catch {
+		available = false;
+	}
+	if (!available) return {
+		available: false,
+		nonStreaming: false,
+		reason: "endpoint unreachable or unauthorized"
+	};
+	if (process.env["VITE_LLM_NON_STREAMING"] === "0") return {
+		available: true,
+		nonStreaming: false,
+		reason: "non-streaming disabled via VITE_LLM_NON_STREAMING=0 (simulated)"
+	};
+	try {
+		const res = await fetch(`${baseUrl}/chat/completions`, {
+			method: "POST",
+			headers: {
+				...headers,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify({
+				model: config.model,
+				messages: [{
+					role: "user",
+					content: "OK"
+				}],
+				max_tokens: 1
+			}),
+			signal: AbortSignal.timeout(15e3)
+		});
+		if (res.ok) return {
+			available: true,
+			nonStreaming: true
+		};
+		const detail = (await res.text().catch(() => "")).slice(0, 200);
+		return {
+			available: true,
+			nonStreaming: false,
+			reason: `endpoint rejects non-streaming chat completions (HTTP ${res.status})${detail ? `: ${detail}` : ""}`
+		};
+	} catch (e) {
+		return {
+			available: true,
+			nonStreaming: false,
+			reason: `non-streaming probe failed: ${e instanceof Error ? e.message : String(e)}`
+		};
+	}
+}
+
+//#endregion
+export { NodeScriptExecutor as a, SandboxedScriptExecutor as c, probeLlmCapabilities as d, readArchiveManifest as f, NodeFS as i, SkillManager as l, FileArtifactStore as n, SKILLS_LOCKFILE as o, FileMemoryStore as r, SKILL_MANIFEST_FILE as s, CliUiBridge as t, loadLlmConfigFromEnv as u };