pi-ptc-subagents 7.7.0 → 7.8.0

package/dist/ptc/fs-bindings-DCGErhvt.js

@@ -1,423 +0,0 @@
-import { Worker } from "node:worker_threads";
-import { existsSync, globSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { basename, dirname, resolve, sep } from "node:path";
-// src/limits.ts
-const DEFAULT_LIMITS = {
-	timeoutMs: 12e4,
-	maxTimeoutMs: 6e5,
-	graceMs: 3e3,
-	maxOutputBytes: 67108864,
-	maxPendingCalls: 128,
-	maxParallelSubCalls: 10,
-	poolSize: 4,
-	poolAcquireTimeoutMs: 3e4
-};
-function effectiveTimeoutMs(requested) {
-	if (requested === void 0) return DEFAULT_LIMITS.timeoutMs;
-	return Math.min(Math.max(requested, 1e3), DEFAULT_LIMITS.maxTimeoutMs);
-}
-// src/sub-calls.ts
-const PREVIEW_MAX_CHARS = 60;
-var SubCallTracker = class {
-	#records = /* @__PURE__ */ new Map();
-	#order = [];
-	start(callId, name, args) {
-		let preview = "";
-		try {
-			preview = JSON.stringify(args) ?? "";
-		} catch {
-			preview = String(args);
-		}
-		this.#records.set(callId, {
-			callId,
-			name,
-			argsPreview: preview.slice(0, PREVIEW_MAX_CHARS),
-			status: "running",
-			startedAt: performance.now()
-		});
-		this.#order.push(callId);
-	}
-	end(callId, status) {
-		const record = this.#records.get(callId);
-		if (!record) return;
-		record.status = status;
-		record.durationMs = Math.round(performance.now() - record.startedAt);
-	}
-	snapshot() {
-		return this.#order.map((callId) => this.#records.get(callId));
-	}
-};
-// src/worker-source.ts
-function buildWorkerUrl(from) {
-	const built = new URL("./worker.js", from);
-	if (existsSync(built)) return built;
-	return new URL("../src/worker-entry.ts", from);
-}
-// src/dispatcher.ts
-const WORKER_ENV_ALLOW_LIST = [
-	"PATH",
-	"PATHEXT",
-	"SYSTEMROOT",
-	"WINDIR",
-	"TEMP",
-	"TMP"
-];
-function workerEnv() {
-	return Object.fromEntries(WORKER_ENV_ALLOW_LIST.filter((key) => key in process.env).map((key) => [key, process.env[key]]));
-}
-function spawnPtcWorker() {
-	return new Worker(buildWorkerUrl(import.meta.url), {
-		env: workerEnv(),
-		execArgv: [],
-		resourceLimits: {
-			maxOldGenerationSizeMb: 512,
-			maxYoungGenerationSizeMb: 64
-		}
-	});
-}
-async function runPtcProgram(request) {
-	const timeoutMs = effectiveTimeoutMs(request.timeoutMs);
-	const cwd = request.cwd ?? process.cwd();
-	const worker = request.pool ? await request.pool.acquire() : spawnPtcWorker();
-	return new Promise((resolve) => {
-		const runId = crypto.randomUUID();
-		const logs = [];
-		const images = [];
-		const subCalls = new SubCallTracker();
-		let pendingCalls = 0;
-		let runningCalls = 0;
-		const callQueue = [];
-		const controllers = /* @__PURE__ */ new Set();
-		let settled = false;
-		let waitingReset = false;
-		let resetTimer;
-		const send = (frame) => worker.postMessage(frame);
-		const finish = (outcome) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			callQueue.length = 0;
-			for (const abort of controllers) abort.abort();
-			const withExtras = {
-				...outcome,
-				subCalls: subCalls.snapshot()
-			};
-			if (withExtras.status === "fulfilled" && images.length > 0) withExtras.images = images;
-			resolve(withExtras);
-			if (request.pool) {
-				waitingReset = true;
-				resetTimer = setTimeout(() => {
-					if (!waitingReset) return;
-					waitingReset = false;
-					request.pool.discard(worker);
-				}, DEFAULT_LIMITS.graceMs);
-				resetTimer.unref();
-				send({ kind: "reset" });
-			} else worker.terminate();
-		};
-		const timer = setTimeout(() => {
-			send({
-				kind: "cancel",
-				id: runId,
-				reason: "timeout"
-			});
-			finish({
-				status: "canceled",
-				reason: `timeout after ${timeoutMs}ms`,
-				logs
-			});
-		}, timeoutMs);
-		const onMessage = (frame) => {
-			if (settled && frame.kind !== "ready") return;
-			if (frame.kind === "ready") {
-				if (waitingReset) {
-					waitingReset = false;
-					if (resetTimer) clearTimeout(resetTimer);
-					worker.off("message", onMessage);
-					worker.off("error", onError);
-					worker.off("exit", onExit);
-					request.pool.release(worker);
-				}
-				return;
-			}
-			if (frame.runId !== runId) return;
-			if (frame.kind === "log") {
-				logs.push(frame.text);
-				return;
-			}
-			if (frame.kind === "call") {
-				if (pendingCalls >= DEFAULT_LIMITS.maxPendingCalls) {
-					send({
-						kind: "result",
-						callId: frame.callId,
-						ok: false,
-						error: `maxPendingCalls ${DEFAULT_LIMITS.maxPendingCalls} reached`
-					});
-					return;
-				}
-				pendingCalls++;
-				subCalls.start(frame.callId, frame.name, frame.args);
-				const execute = async () => {
-					if (settled) return;
-					const controller = new AbortController();
-					controllers.add(controller);
-					try {
-						const binding = request.bindings[frame.name];
-						if (!binding) {
-							subCalls.end(frame.callId, "rejected");
-							send({
-								kind: "result",
-								callId: frame.callId,
-								ok: false,
-								error: `unknown binding ${frame.name}`
-							});
-							return;
-						}
-						const value = await binding(frame.args, {
-							cwd,
-							emitImage: (image) => images.push(image),
-							signal: controller.signal
-						});
-						subCalls.end(frame.callId, "ok");
-						send({
-							kind: "result",
-							callId: frame.callId,
-							ok: true,
-							value: value === void 0 ? null : value
-						});
-					} catch (error) {
-						subCalls.end(frame.callId, "error");
-						send({
-							kind: "result",
-							callId: frame.callId,
-							ok: false,
-							error: error instanceof Error ? error.message : String(error)
-						});
-					} finally {
-						controllers.delete(controller);
-						pendingCalls--;
-						runningCalls--;
-						const next = callQueue.shift();
-						if (next) {
-							runningCalls++;
-							next();
-						}
-					}
-				};
-				if (runningCalls < DEFAULT_LIMITS.maxParallelSubCalls) {
-					runningCalls++;
-					execute();
-				} else callQueue.push(execute);
-				return;
-			}
-			if (frame.kind === "settled") {
-				const outcome = frame.outcome;
-				if (JSON.stringify({
-					logs: outcome.logs,
-					value: outcome.status === "fulfilled" ? outcome.value : void 0
-				}).length > DEFAULT_LIMITS.maxOutputBytes) {
-					finish({
-						status: "rejected",
-						error: `output exceeds ${DEFAULT_LIMITS.maxOutputBytes} bytes budget`,
-						logs
-					});
-					return;
-				}
-				finish(outcome);
-			}
-		};
-		worker.on("message", onMessage);
-		const onError = (error) => void finish({
-			status: "rejected",
-			error: `worker error: ${error instanceof Error ? error.message : String(error)}`,
-			logs
-		});
-		const onExit = (code) => {
-			if (!settled) finish({
-				status: "rejected",
-				error: `worker exited early with code ${code}`,
-				logs
-			});
-		};
-		worker.on("error", onError);
-		worker.on("exit", onExit);
-		send({
-			kind: "init",
-			surface: request.surface ?? "run_code",
-			bindingNames: Object.keys(request.bindings)
-		});
-		send({
-			kind: "run",
-			id: runId,
-			code: request.code,
-			args: request.args ?? {}
-		});
-	});
-}
-// src/fs-bindings.ts
-const SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
-const SKIP_SUFFIXES = /* @__PURE__ */ new Set([
-	".png",
-	".jpg",
-	".jpeg",
-	".gif",
-	".webp",
-	".ico",
-	".zip",
-	".gz",
-	".tgz",
-	".pdf",
-	".woff",
-	".woff2",
-	".map"
-]);
-const GREP_MAX_RESULTS = 500;
-const GLOB_MAX_RESULTS = 1e3;
-const READ_MAX_BYTES = 2097152;
-const WRITE_MAX_BYTES = 2097152;
-function strArg(args, key) {
-	const value = args?.[key];
-	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} 必须是非空字符串`);
-	return value;
-}
-function jailed(workdirReal, p) {
-	const abs = resolve(workdirReal, p);
-	let real;
-	try {
-		real = realpathSync(abs);
-	} catch {
-		real = resolve(realpathSync(dirname(abs)), basename(abs));
-	}
-	if (real !== workdirReal && !real.startsWith(workdirReal + sep)) throw new Error(`path escapes workdir: ${p}`);
-	return real;
-}
-function* walk(dir) {
-	let entries;
-	try {
-		entries = readdirSync(dir, { withFileTypes: true });
-	} catch {
-		return;
-	}
-	for (const entry of entries) if (entry.isDirectory()) {
-		if (SKIP_DIRS.has(entry.name)) continue;
-		yield* walk(resolve(dir, entry.name));
-	} else if (entry.isFile()) yield resolve(dir, entry.name);
-}
-function readPlainText(file) {
-	const stat = statSync(file);
-	const dot = file.lastIndexOf(".");
-	const suffix = dot === -1 ? "" : file.slice(dot).toLowerCase();
-	if (stat.size > READ_MAX_BYTES || SKIP_SUFFIXES.has(suffix)) return void 0;
-	const text = readFileSync(file, "utf8");
-	return text.includes("�") ? void 0 : text;
-}
-function createFsBindings(workdir, onCall) {
-	let workdirReal;
-	try {
-		workdirReal = realpathSync(resolve(workdir));
-	} catch {
-		throw new Error(`workdir 不存在或不可达: ${workdir}（workdir 传用户工作区绝对路径）`);
-	}
-	const table = {
-		read: async (args) => {
-			const real = jailed(workdirReal, strArg(args, "path"));
-			const stat = statSync(real);
-			if (!stat.isFile()) throw new Error(`not a file: ${strArg(args, "path")}`);
-			if (stat.size > READ_MAX_BYTES) throw new Error(`file too large (${stat.size} bytes > ${READ_MAX_BYTES})`);
-			return readFileSync(real, "utf8");
-		},
-		write: async (args) => {
-			const p = strArg(args, "path");
-			const content = strArg(args, "content");
-			const bytes = Buffer.byteLength(content, "utf8");
-			if (bytes > WRITE_MAX_BYTES) throw new Error(`content too large (${bytes} bytes > ${WRITE_MAX_BYTES} bytes)`);
-			const abs = resolve(workdirReal, p);
-			const parentAbs = dirname(abs);
-			if (!existsSync(parentAbs)) throw new Error(`parent dir does not exist: ${dirname(p)}（write 不隐式建目录）`);
-			const parentReal = jailed(workdirReal, parentAbs);
-			const real = resolve(parentReal, basename(abs));
-			const tmp = `${real}.ptc-${randomUUID()}`;
-			writeFileSync(tmp, content, "utf8");
-			renameSync(tmp, real);
-			return { written: real.slice(workdirReal.length + 1) };
-		},
-		grep: async (args) => {
-			const pattern = strArg(args, "pattern");
-			const scope = typeof args?.path === "string" ? jailed(workdirReal, strArg(args, "path")) : workdirReal;
-			let regex;
-			try {
-				regex = new RegExp(pattern);
-			} catch {
-				throw new Error(`invalid pattern: ${pattern}`);
-			}
-			const hits = [];
-			const files = statSync(scope).isFile() ? [scope] : walk(scope);
-			outer: for (const file of files) {
-				let text;
-				try {
-					text = readPlainText(file);
-				} catch {
-					continue;
-				}
-				if (text === void 0) continue;
-				const lines = text.split("\n");
-				for (let i = 0; i < lines.length; i++) if (regex.test(lines[i])) {
-					hits.push(`${file.slice(workdirReal.length + 1)}:${i + 1}: ${lines[i]}`);
-					if (hits.length >= GREP_MAX_RESULTS) {
-						hits.push(`…（已截断：达到 ${GREP_MAX_RESULTS} 条上限）`);
-						break outer;
-					}
-				}
-			}
-			return hits;
-		},
-		glob: async (args) => {
-			const pattern = strArg(args, "pattern");
-			let found;
-			try {
-				found = globSync(pattern, { cwd: workdirReal });
-			} catch {
-				throw new Error(`invalid glob: ${pattern}`);
-			}
-			return found.slice(0, GLOB_MAX_RESULTS);
-		},
-		edit: async (args) => {
-			const real = jailed(workdirReal, strArg(args, "path"));
-			const oldString = strArg(args, "old_string");
-			const newString = strArg(args, "new_string");
-			const text = readFileSync(real, "utf8");
-			const count = text.split(oldString).length - 1;
-			if (count === 0) throw new Error("old_string not found");
-			if (count > 1) throw new Error(`old_string matches ${count} places — must be unique`);
-			const tmp = `${real}.ptc-${randomUUID()}`;
-			writeFileSync(tmp, text.replace(oldString, newString), "utf8");
-			renameSync(tmp, real);
-			return { edited: real.slice(workdirReal.length + 1) };
-		}
-	};
-	if (!onCall) return table;
-	return {
-		read: (a) => {
-			onCall();
-			return table.read(a);
-		},
-		write: (a) => {
-			onCall();
-			return table.write(a);
-		},
-		grep: (a) => {
-			onCall();
-			return table.grep(a);
-		},
-		glob: (a) => {
-			onCall();
-			return table.glob(a);
-		},
-		edit: (a) => {
-			onCall();
-			return table.edit(a);
-		}
-	};
-}
-export { DEFAULT_LIMITS as i, runPtcProgram as n, spawnPtcWorker as r, createFsBindings as t };

package/dist/ptc/worker.js

@@ -1,197 +0,0 @@
-import { stripTypeScriptTypes } from "node:module";
-import { parentPort, workerData } from "node:worker_threads";
-import vm from "node:vm";
-// src/compile.ts
-function compileProgram(source) {
-	return `"use strict";\n${stripTypeScriptTypes(`async function __ptcProgram() {\n${source}\n}`, { mode: "strip" })}\n;globalThis.__ptcProgram = __ptcProgram;`;
-}
-// src/worker-main.ts
-const CELL_PREAMBLE = `"use strict";
-(function () {
-var __bridge = globalThis.__ptcCall;
-var __emit = globalThis.__ptcConsole;
-var __args = JSON.parse(globalThis.__ptcArgsJson);
-// contextified 全局属性不可 delete（vm 限制）但可写——置 undefined 即脱手，桥只剩序言闭包可达
-globalThis.__ptcCall = undefined;
-globalThis.__ptcConsole = undefined;
-globalThis.__ptcArgsJson = undefined;
-function __ptcFmt(v) {
-  if (typeof v === "string") return v;
-  try { var s = JSON.stringify(v); return s === undefined ? String(v) : s; } catch (e) { return String(v); }
-}
-function __ptcJoin(values) {
-  var out = [];
-  for (var i = 0; i < values.length; i++) out.push(__ptcFmt(values[i]));
-  return out.join(" ");
-}
-var __ptcTools = {};
-__PTC_NAMES__.forEach(function (name) {
-  __ptcTools[name] = function (args) {
-    return new Promise(function (resolve, reject) {
-      __bridge(name, JSON.stringify(args === undefined ? null : args)).then(function (json) {
-        var value;
-        try { value = JSON.parse(json); } catch (e) { reject(e); return; }
-        resolve(value);
-      }, reject);
-    });
-  };
-});
-globalThis.tools = Object.freeze(__ptcTools);
-globalThis.console = Object.freeze({
-  log: function () { __emit("log", __ptcJoin(arguments)); },
-  info: function () { __emit("info", __ptcJoin(arguments)); },
-  warn: function () { __emit("warn", __ptcJoin(arguments)); },
-  error: function () { __emit("error", __ptcJoin(arguments)); },
-  debug: function () { __emit("debug", __ptcJoin(arguments)); }
-});
-globalThis.args = Object.freeze(__args);
-if (__PTC_WORKFLOW__) {
-  globalThis.workflow = Object.freeze({
-    log: function () { __emit("log", __ptcJoin(arguments)); },
-    phase: function (name) { __emit("log", "— phase: " + name + " —"); },
-    parallel: function (items) { return Promise.allSettled(items.map(function (run) { return run(); })); },
-    pipeline: function (items, step) {
-      var results = [];
-      return items.reduce(function (chain, item, index) {
-        return chain.then(function () { return Promise.resolve(step(item, index)).then(function (r) { results.push(r); }); });
-      }, Promise.resolve()).then(function () { return results; });
-    }
-  });
-}
-})();
-`;
-function workerMain(deps) {
-	let bindingNames = [];
-	let surface = "run_code";
-	let pending = /* @__PURE__ */ new Map();
-	let nextCallId = 1;
-	let currentRunId = null;
-	let logs = [];
-	deps.onFrame((frame) => {
-		if (frame.kind === "init") {
-			bindingNames = frame.bindingNames;
-			surface = frame.surface;
-			deps.post({ kind: "ready" });
-			return;
-		}
-		if (frame.kind === "reset") {
-			currentRunId = null;
-			for (const { reject } of pending.values()) reject(/* @__PURE__ */ new Error("run reset：worker 被复用"));
-			pending = /* @__PURE__ */ new Map();
-			deps.post({ kind: "ready" });
-			return;
-		}
-		if (frame.kind === "result") {
-			const entry = pending.get(frame.callId);
-			if (!entry) return;
-			pending.delete(frame.callId);
-			if (frame.ok) {
-				let json;
-				try {
-					json = JSON.stringify(frame.value ?? null);
-				} catch {
-					json = void 0;
-				}
-				if (json === void 0) entry.reject(/* @__PURE__ */ new Error("binding 返回值不可 JSON 序列化（如循环引用）"));
-				else entry.resolve(json);
-			} else entry.reject(new Error(frame.error));
-			return;
-		}
-		if (frame.kind === "cancel") return;
-		run(frame.code, frame.id, frame.args);
-	});
-	function preamble() {
-		return CELL_PREAMBLE.replace(/__PTC_NAMES__/g, () => JSON.stringify(bindingNames)).replace(/__PTC_WORKFLOW__/g, () => surface === "workflow" ? "true" : "false");
-	}
-	async function run(code, runId, args) {
-		currentRunId = runId;
-		logs = [];
-		const postLog = (level, text) => {
-			logs.push(text);
-			deps.post({
-				kind: "log",
-				runId,
-				level,
-				text
-			});
-		};
-		const outcome = await execute(code, vm.createContext({
-			__ptcArgsJson: JSON.stringify(args ?? {}),
-			__ptcCall(name, argsJson) {
-				if (currentRunId === null) return Promise.reject(/* @__PURE__ */ new Error("run 已结束：reset 后不再接受工具调用"));
-				let parsed = null;
-				try {
-					parsed = JSON.parse(argsJson);
-				} catch {
-					return Promise.reject(/* @__PURE__ */ new Error("工具参数不是合法 JSON"));
-				}
-				const call = new Promise((resolve, reject) => {
-					const callId = nextCallId++;
-					pending.set(callId, {
-						resolve,
-						reject
-					});
-					deps.post({
-						kind: "call",
-						runId: currentRunId ?? "",
-						callId,
-						name,
-						args: parsed
-					});
-				});
-				call.catch(() => {});
-				return call;
-			},
-			__ptcConsole(level, text) {
-				postLog(level, String(text));
-			}
-		}));
-		deps.post({
-			kind: "settled",
-			runId,
-			outcome
-		});
-	}
-	function errorMessage(error) {
-		if (error instanceof Error) return error.message;
-		if (error && typeof error === "object" && typeof error.message === "string") return error.message;
-		return String(error);
-	}
-	async function execute(code, context) {
-		try {
-			vm.runInContext(preamble(), context, { filename: "ptc_preamble.js" });
-			vm.runInContext(compileProgram(code), context, { filename: "run_code.js" });
-			const value = await context.__ptcProgram.call(context);
-			if (value === void 0) return {
-				status: "fulfilled",
-				value: { $void: true },
-				logs
-			};
-			const json = JSON.stringify(value);
-			if (json === void 0) return {
-				status: "rejected",
-				error: "程序返回值不可序列化",
-				logs
-			};
-			return {
-				status: "fulfilled",
-				value: JSON.parse(json),
-				logs
-			};
-		} catch (error) {
-			return {
-				status: "rejected",
-				error: errorMessage(error),
-				logs
-			};
-		}
-	}
-}
-// src/worker-entry.ts
-if (!parentPort) throw new Error("worker-entry 只能在 worker 线程里加载");
-Object.freeze(workerData);
-workerMain({
-	post: (frame) => parentPort.postMessage(frame),
-	onFrame: (handler) => parentPort.on("message", (frame) => handler(frame))
-});
-export {};