pi-ptc-subagents 7.2.0 → 7.4.0

package/dist/ptc/cli.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { n as runPtcProgram, t as createFsBindings } from "./fs-bindings-DCGErhvt.js";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+// src/cli.ts
+const USAGE = `用法：ptc <program.ts> [--workdir <dir>] [--timeout <ms>] [--json]
+
+程序在运行格里跑（看不见 process / fetch / 动态 import），能调的只有文件四件套
+（read / write / grep / glob / edit），且只在 workdir 内活动。`;
+function parseArgs(argv) {
+	let program = "";
+	let workdir = process.cwd();
+	let timeoutMs;
+	let json = false;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--json") json = true;
+		else if (arg === "--workdir" || arg === "-w") workdir = argv[++i] ?? workdir;
+		else if (arg === "--timeout") timeoutMs = Number(argv[++i]);
+		else if (arg.startsWith("-")) throw new Error(`未知参数 ${arg}`);
+		else if (program) throw new Error(`只能跑一个程序（多给了 ${arg}）`);
+		else program = arg;
+	}
+	if (!program) throw new Error(USAGE);
+	if (timeoutMs !== void 0 && !Number.isFinite(timeoutMs)) throw new Error("--timeout 要一个毫秒数");
+	return {
+		program,
+		workdir: resolve(workdir),
+		timeoutMs,
+		json
+	};
+}
+function isVoid(value) {
+	return typeof value === "object" && value !== null && "$void" in value;
+}
+async function main() {
+	const argv = process.argv.slice(2);
+	if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+		console.log(USAGE);
+		return;
+	}
+	const options = parseArgs(argv);
+	const outcome = await runPtcProgram({
+		code: readFileSync(options.program, "utf8"),
+		cwd: options.workdir,
+		timeoutMs: options.timeoutMs,
+		bindings: createFsBindings(options.workdir)
+	});
+	for (const line of outcome.logs) console.error(line);
+	if (options.json) console.log(JSON.stringify(outcome, null, 2));
+	else if (outcome.status === "fulfilled") console.log(isVoid(outcome.value) ? "(程序无返回值)" : JSON.stringify(outcome.value, null, 2));
+	if (outcome.status !== "fulfilled") {
+		console.error(outcome.status === "canceled" ? outcome.reason : outcome.error);
+		process.exitCode = 1;
+	}
+}
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});
+export {};

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

@@ -0,0 +1,423 @@
+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/index.js

@@ -0,0 +1,77 @@
+import { i as DEFAULT_LIMITS, n as runPtcProgram, r as spawnPtcWorker, t as createFsBindings } from "./fs-bindings-DCGErhvt.js";
+// src/pool.ts
+var WorkerPool = class {
+	#spawn;
+	#capacity;
+	#idle = [];
+	#waiters = [];
+	#retired = /* @__PURE__ */ new WeakSet();
+	#spawned = 0;
+	#draining = false;
+	constructor(spawn, capacity = DEFAULT_LIMITS.poolSize) {
+		this.#spawn = spawn;
+		this.#capacity = capacity;
+	}
+	acquire(timeoutMs = DEFAULT_LIMITS.poolAcquireTimeoutMs) {
+		const idle = this.#idle.pop();
+		if (idle) return Promise.resolve(idle);
+		if (this.#spawned < this.#capacity) {
+			this.#draining = false;
+			this.#spawned++;
+			return Promise.resolve(this.#track(this.#spawn()));
+		}
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				const index = this.#waiters.findIndex((w) => w.timer === timer);
+				if (index >= 0) this.#waiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`worker acquire timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+			this.#waiters.push({
+				resolve,
+				timer
+			});
+		});
+	}
+	release(worker) {
+		if (this.#draining) {
+			this.#retire(worker);
+			worker.terminate();
+			return;
+		}
+		const waiter = this.#waiters.shift();
+		if (waiter) {
+			clearTimeout(waiter.timer);
+			waiter.resolve(worker);
+			return;
+		}
+		this.#idle.push(worker);
+	}
+	/** 被杀/卡死/崩溃的 worker：收回名额并摘出空闲表（terminate 幂等） */
+	discard(worker) {
+		this.#retire(worker);
+		const index = this.#idle.indexOf(worker);
+		if (index >= 0) this.#idle.splice(index, 1);
+		worker.terminate();
+	}
+	drain() {
+		this.#draining = true;
+		for (const worker of this.#idle.splice(0)) {
+			this.#retire(worker);
+			worker.terminate();
+		}
+	}
+	#track(worker) {
+		worker.once("exit", () => {
+			this.#retire(worker);
+			const index = this.#idle.indexOf(worker);
+			if (index >= 0) this.#idle.splice(index, 1);
+		});
+		return worker;
+	}
+	#retire(worker) {
+		if (this.#retired.has(worker)) return;
+		this.#retired.add(worker);
+		this.#spawned = Math.max(0, this.#spawned - 1);
+	}
+};
+export { DEFAULT_LIMITS, WorkerPool, createFsBindings, runPtcProgram, spawnPtcWorker };