@pablopunk/tau 0.0.0-stage → 0.1.1

package/dist/serve-Dmzn5V0l.js

@@ -0,0 +1 @@
+export { t as serveInForeground } from "./serve-Cmy0rUWr.js";

package/dist/service-command-C74K0saj.js

@@ -0,0 +1,34 @@
+import { i as realContext, n as listServices, r as uninstallHome, t as createServiceManager } from "./manager-B_WHbb1U.js";
+import { t as cliEntry } from "./cli-entry-DcDpQ30L.js";
+import { parseArgs } from "node:util";
+//#region src/service/service-command.ts
+const USAGE = "Usage: tau service install | uninstall [--home <path>] | list";
+/** `tau service install | uninstall [--home <path>] | list`. `argv` starts after the word `service`. */
+async function runServiceCommandWith(deps, argv) {
+	const { positionals, values } = parseArgs({
+		args: [...argv],
+		allowPositionals: true,
+		options: { home: { type: "string" } }
+	});
+	const home = values.home ?? deps.context.env.TAU_HOME ?? deps.context.defaultHome;
+	const [action] = positionals;
+	if (action === "install") {
+		const warnings = await createServiceManager(deps.context, cliEntry(), home).install();
+		for (const warning of warnings) deps.out(`warning: ${warning}`);
+		deps.out("tau service installed.");
+	} else if (action === "uninstall") {
+		await uninstallHome(deps.context, home);
+		deps.out("tau service removed.");
+	} else if (action === "list") {
+		const names = await listServices(deps.context);
+		deps.out(names.length === 0 ? "No tau services." : names.join("\n"));
+	} else throw new Error(USAGE);
+}
+async function runServiceCommand(argv) {
+	await runServiceCommandWith({
+		context: realContext(),
+		out: (message) => console.log(message)
+	}, argv);
+}
+//#endregion
+export { runServiceCommandWith as n, runServiceCommand as t };

package/dist/service-command-DqcstJ8e.js

@@ -0,0 +1 @@
+export { t as runServiceCommand } from "./service-command-C74K0saj.js";

package/dist/shell-CQa4e7rx.js

@@ -0,0 +1,643 @@
+import { i as __require, t as __commonJSMin } from "./rolldown-runtime-1p2KPIdQ.js";
+import { existsSync } from "node:fs";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "fs";
+import { join } from "node:path";
+import { homedir } from "os";
+import { basename as basename$1, dirname as dirname$1, join as join$1, resolve as resolve$1 } from "path";
+import { homedir as homedir$1 } from "node:os";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "module";
+import { fileURLToPath as fileURLToPath$1 } from "url";
+import { spawnSync } from "child_process";
+import "node:child_process";
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs = __require("fs");
+	function checkPathExt(path, options) {
+		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+		if (!pathext) return true;
+		pathext = pathext.split(";");
+		if (pathext.indexOf("") !== -1) return true;
+		for (var i = 0; i < pathext.length; i++) {
+			var p = pathext[i].toLowerCase();
+			if (p && path.substr(-p.length).toLowerCase() === p) return true;
+		}
+		return false;
+	}
+	function checkStat(stat, path, options) {
+		if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+		return checkPathExt(path, options);
+	}
+	function isexe(path, options, cb) {
+		fs.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, path, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs.statSync(path), path, options);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs = __require("fs");
+	function isexe(path, options, cb) {
+		fs.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs.statSync(path), options);
+	}
+	function checkStat(stat, options) {
+		return stat.isFile() && checkMode(stat, options);
+	}
+	function checkMode(stat, options) {
+		var mod = stat.mode;
+		var uid = stat.uid;
+		var gid = stat.gid;
+		var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+		var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+		var u = parseInt("100", 8);
+		var g = parseInt("010", 8);
+		var o = parseInt("001", 8);
+		var ug = u | g;
+		return mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	__require("fs");
+	var core;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) core = require_windows();
+	else core = require_mode();
+	module.exports = isexe;
+	isexe.sync = sync;
+	function isexe(path, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		if (!cb) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(resolve, reject) {
+				isexe(path, options || {}, function(er, is) {
+					if (er) reject(er);
+					else resolve(is);
+				});
+			});
+		}
+		core(path, options || {}, function(er, is) {
+			if (er) {
+				if (er.code === "EACCES" || options && options.ignoreErrors) {
+					er = null;
+					is = false;
+				}
+			}
+			cb(er, is);
+		});
+	}
+	function sync(path, options) {
+		try {
+			return core.sync(path, options || {});
+		} catch (er) {
+			if (options && options.ignoreErrors || er.code === "EACCES") return false;
+			else throw er;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const path = __require("path");
+	const COLON = isWindows ? ";" : ":";
+	const isexe = require_isexe();
+	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
+	const getPathInfo = (cmd, opt) => {
+		const colon = opt.colon || COLON;
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || 
+		/* istanbul ignore next: very unusual */ "").split(colon)];
+		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+		if (isWindows) {
+			if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") pathExt.unshift("");
+		}
+		return {
+			pathEnv,
+			pathExt,
+			pathExtExe
+		};
+	};
+	const which = (cmd, opt, cb) => {
+		if (typeof opt === "function") {
+			cb = opt;
+			opt = {};
+		}
+		if (!opt) opt = {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		const step = (i) => new Promise((resolve, reject) => {
+			if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			resolve(subStep(p, i, 0));
+		});
+		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+			if (ii === pathExt.length) return resolve(step(i + 1));
+			const ext = pathExt[ii];
+			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+				if (!er && is) {
+					if (opt.all) found.push(p + ext);
+					else return resolve(p + ext);
+				}
+				return resolve(subStep(p, i, ii + 1));
+			});
+		});
+		return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+	};
+	const whichSync = (cmd, opt) => {
+		opt = opt || {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		for (let i = 0; i < pathEnv.length; i++) {
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			for (let j = 0; j < pathExt.length; j++) {
+				const cur = p + pathExt[j];
+				try {
+					if (isexe.sync(cur, { pathExt: pathExtExe })) {
+						if (opt.all) found.push(cur);
+						else return cur;
+					}
+				} catch (ex) {}
+			}
+		}
+		if (opt.all && found.length) return found;
+		if (opt.nothrow) return null;
+		throw getNotFoundError(cmd);
+	};
+	module.exports = which;
+	which.sync = whichSync;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pathKey = (options = {}) => {
+		const environment = options.env || process.env;
+		if ((options.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+	};
+	module.exports = pathKey;
+	module.exports.default = pathKey;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const which = require_which();
+	const getPathKey = require_path_key();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+		const env = parsed.options.env || process.env;
+		const cwd = process.cwd();
+		const hasCustomCwd = parsed.options.cwd != null;
+		const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+		if (shouldSwitchCwd) try {
+			process.chdir(parsed.options.cwd);
+		} catch (err) {}
+		let resolved;
+		try {
+			resolved = which.sync(parsed.command, {
+				path: env[getPathKey({ env })],
+				pathExt: withoutPathExt ? path.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (shouldSwitchCwd) process.chdir(cwd);
+		}
+		if (resolved) resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		return resolved;
+	}
+	function resolveCommand(parsed) {
+		return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	module.exports = resolveCommand;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+		arg = `${arg}`;
+		arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		arg = `"${arg}"`;
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	module.exports.command = escapeCommand;
+	module.exports.argument = escapeArgument;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = /^#!(.*)/;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const shebangRegex = require_shebang_regex();
+	module.exports = (string = "") => {
+		const match = string.match(shebangRegex);
+		if (!match) return null;
+		const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+		const binary = path.split("/").pop();
+		if (binary === "env") return argument;
+		return argument ? `${binary} ${argument}` : binary;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("fs");
+	const shebangCommand = require_shebang_command();
+	function readShebang(command) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd;
+		try {
+			fd = fs.openSync(command, "r");
+			fs.readSync(fd, buffer, 0, size, 0);
+			fs.closeSync(fd);
+		} catch (e) {}
+		return shebangCommand(buffer.toString());
+	}
+	module.exports = readShebang;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const resolveCommand = require_resolveCommand();
+	const escape = require_escape();
+	const readShebang = require_readShebang();
+	const isWin = process.platform === "win32";
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+		parsed.file = resolveCommand(parsed);
+		const shebang = parsed.file && readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+		return parsed.file;
+	}
+	function parseNonShell(parsed) {
+		if (!isWin) return parsed;
+		const commandFile = detectShebang(parsed);
+		const needsShell = !isExecutableRegExp.test(commandFile);
+		if (parsed.options.forceShell || needsShell) {
+			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+			parsed.command = path.normalize(parsed.command);
+			parsed.command = escape.command(parsed.command);
+			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+			parsed.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
+			];
+			parsed.command = process.env.comspec || "cmd.exe";
+			parsed.options.windowsVerbatimArguments = true;
+		}
+		return parsed;
+	}
+	function parse(command, args, options) {
+		if (args && !Array.isArray(args)) {
+			options = args;
+			args = null;
+		}
+		args = args ? args.slice(0) : [];
+		options = Object.assign({}, options);
+		const parsed = {
+			command,
+			args,
+			options,
+			file: void 0,
+			original: {
+				command,
+				args
+			}
+		};
+		return options.shell ? parsed : parseNonShell(parsed);
+	}
+	module.exports = parse;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWin = process.platform === "win32";
+	function notFoundError(original, syscall) {
+		return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${syscall} ${original.command}`,
+			path: original.command,
+			spawnargs: original.args
+		});
+	}
+	function hookChildProcess(cp, parsed) {
+		if (!isWin) return;
+		const originalEmit = cp.emit;
+		cp.emit = function(name, arg1) {
+			if (name === "exit") {
+				const err = verifyENOENT(arg1, parsed);
+				if (err) return originalEmit.call(cp, "error", err);
+			}
+			return originalEmit.apply(cp, arguments);
+		};
+	}
+	function verifyENOENT(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+		return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+		return null;
+	}
+	module.exports = {
+		hookChildProcess,
+		verifyENOENT,
+		verifyENOENTSync,
+		notFoundError
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const cp = __require("child_process");
+	const parse = require_parse();
+	const enoent = require_enoent();
+	function spawn(command, args, options) {
+		const parsed = parse(command, args, options);
+		const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+		enoent.hookChildProcess(spawned, parsed);
+		return spawned;
+	}
+	function spawnSync(command, args, options) {
+		const parsed = parse(command, args, options);
+		const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+		result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+		return result;
+	}
+	module.exports = spawn;
+	module.exports.spawn = spawn;
+	module.exports.sync = spawnSync;
+	module.exports._parse = parse;
+	module.exports._enoent = enoent;
+}));
+require_cross_spawn();
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-coding-agent@1.3.0_@aws-sdk+credential-provider-node@3.972.86_@model_188af9db56b10bdf99c9b8c64c2036e8/node_modules/@earendil-works/pi-coding-agent/dist/utils/paths.js
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+/** Convert Git Bash, MSYS, Cygwin, and WSL drive paths to a form native Windows APIs accept. */
+function normalizeWindowsShellPath(filePath) {
+	if (!filePath.startsWith("/") || filePath.startsWith("//") || filePath.includes("\\")) return filePath;
+	const match = filePath.match(/^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i);
+	if (!match) return filePath;
+	const suffix = match[2]?.replaceAll("/", "\\");
+	return `${match[1].toUpperCase()}:\\${suffix ?? ""}`;
+}
+function normalizePath(input, options = {}) {
+	let normalized = options.trim ? input.trim() : input;
+	if (options.normalizeUnicodeSpaces) normalized = normalized.replace(UNICODE_SPACES, " ");
+	if (options.stripAtPrefix && normalized.startsWith("@")) normalized = normalized.slice(1);
+	if (process.platform === "win32") normalized = normalizeWindowsShellPath(normalized);
+	if (options.expandTilde ?? true) {
+		const home = options.homeDir ?? homedir$1();
+		if (normalized === "~") return home;
+		if (normalized.startsWith("~/") || process.platform === "win32" && normalized.startsWith("~\\")) return join(home, normalized.slice(2));
+	}
+	if (/^file:\/\//.test(normalized)) return fileURLToPath(normalized);
+	return normalized;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-coding-agent@1.3.0_@aws-sdk+credential-provider-node@3.972.86_@model_188af9db56b10bdf99c9b8c64c2036e8/node_modules/@earendil-works/pi-coding-agent/dist/utils/text.js
+/** Split a leading UTF-8 byte order mark from decoded text. */
+function splitBom(content) {
+	return content.startsWith("") ? {
+		bom: "",
+		text: content.slice(1)
+	} : {
+		bom: "",
+		text: content
+	};
+}
+/** Remove a leading UTF-8 byte order mark from decoded text. */
+function stripBom(content) {
+	return splitBom(content).text;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-coding-agent@1.3.0_@aws-sdk+credential-provider-node@3.972.86_@model_188af9db56b10bdf99c9b8c64c2036e8/node_modules/@earendil-works/pi-coding-agent/dist/config.js
+const __filename = fileURLToPath$1(import.meta.url);
+const __dirname = dirname$1(__filename);
+/**
+* Detect if we're running as a Bun compiled binary.
+* Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
+*/
+const isBunBinary = import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
+process.versions.bun;
+const isBundledNode = typeof PI_BUNDLED_NODE !== "undefined" && PI_BUNDLED_NODE;
+/**
+* Get the base directory for resolving package assets (themes, package.json, README.md, CHANGELOG.md).
+* - For Bun binary: returns the directory containing the executable
+* - For Node.js: returns the package root containing package.json
+* - Ignores Bun binary metadata copied into dist/ when the package root is available
+*/
+function findNodePackageDir(startDir) {
+	let dir = startDir;
+	while (dir !== dirname$1(dir)) {
+		if (existsSync$1(join$1(dir, "package.json"))) {
+			const parent = dirname$1(dir);
+			if (basename$1(dir) === "dist" && existsSync$1(join$1(parent, "package.json"))) return parent;
+			return dir;
+		}
+		dir = dirname$1(dir);
+	}
+	return startDir;
+}
+function getPackageDir() {
+	const envDir = process.env.PI_PACKAGE_DIR;
+	if (envDir) return normalizePath(envDir);
+	if (isBunBinary) return dirname$1(process.execPath);
+	return findNodePackageDir(__dirname);
+}
+/** Get path to package.json */
+function getPackageJsonPath() {
+	return join$1(getPackageDir(), "package.json");
+}
+/** Get path to docs directory */
+function getDocsPath() {
+	return resolve$1(join$1(getPackageDir(), "docs"));
+}
+let quickJSWasmPath;
+/**
+* Get path to `quickjs-wasi/quickjs.wasm`, the VM that runs codemode scripts. Resolved once so the
+* compiled module cached per path keeps working after an update removes this install (#10439).
+*/
+function getQuickJSWasmPath() {
+	quickJSWasmPath ??= createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm");
+	return quickJSWasmPath;
+}
+/** Resolve the codemode worker entry for a release runtime. */
+function resolveCodemodeWorkerSpecifier(runtime, moduleUrl) {
+	if (runtime === "bun-binary") return "./src/extensions/codemode/worker.ts";
+	if (runtime === "bundled-node") return new URL("./codemode-worker.js", moduleUrl);
+}
+let codemodeWorkerDataUrl;
+/**
+* Get the codemode worker entry, or undefined to use the worker that ships next to pi-codemode.
+* The Bun and Node release builds both pass the worker as an extra entrypoint.
+*/
+function getCodemodeWorkerSpecifier() {
+	const runtime = isBunBinary ? "bun-binary" : isBundledNode ? "bundled-node" : "unbundled";
+	const specifier = resolveCodemodeWorkerSpecifier(runtime, import.meta.url);
+	if (runtime !== "bundled-node" || !(specifier instanceof URL)) return specifier;
+	codemodeWorkerDataUrl ??= new URL(`data:text/javascript;base64,${readFileSync$1(specifier).toString("base64")}`);
+	return codemodeWorkerDataUrl;
+}
+let pkg = {};
+try {
+	const packageJsonPath = getPackageJsonPath();
+	pkg = JSON.parse(stripBom(readFileSync$1(packageJsonPath, "utf-8")));
+} catch (e) {
+	if (e.code !== "ENOENT") throw e;
+}
+const piConfigName = pkg.piConfig?.name;
+pkg.name;
+const APP_NAME = piConfigName || "pi";
+const CONFIG_DIR_NAME = pkg.piConfig?.configDir || ".pi";
+const VERSION = pkg.version || "0.0.0";
+const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
+`${APP_NAME.toUpperCase()}`;
+function expandTildePath(path) {
+	return normalizePath(path);
+}
+/** Get the agent config directory (e.g., ~/.pi/agent/) */
+function getAgentDir() {
+	const envDir = process.env[ENV_AGENT_DIR];
+	if (envDir) return expandTildePath(envDir);
+	return join$1(homedir(), CONFIG_DIR_NAME, "agent");
+}
+/** Get path to managed binaries directory (fd, rg) */
+function getBinDir() {
+	return join$1(getAgentDir(), "bin");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-coding-agent@1.3.0_@aws-sdk+credential-provider-node@3.972.86_@model_188af9db56b10bdf99c9b8c64c2036e8/node_modules/@earendil-works/pi-coding-agent/dist/utils/shell.js
+/**
+* Find bash executable on PATH (cross-platform)
+*/
+function isLegacyWslBashPath(path) {
+	const normalized = path.replace(/\//g, "\\").toLowerCase();
+	return /^[a-z]:\\windows\\(?:system32|sysnative)\\bash\.exe$/.test(normalized);
+}
+function getBashShellConfig(shell) {
+	return isLegacyWslBashPath(shell) ? {
+		shell,
+		args: ["-s"],
+		commandTransport: "stdin"
+	} : {
+		shell,
+		args: ["-c"]
+	};
+}
+function findExecutableOnPath(executable) {
+	if (process.platform === "win32") {
+		try {
+			const result = spawnSync("where", [executable], {
+				encoding: "utf-8",
+				timeout: 5e3,
+				windowsHide: true
+			});
+			if (result.status === 0 && result.stdout) {
+				const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+				if (firstMatch && existsSync(firstMatch)) return firstMatch;
+			}
+		} catch {}
+		return null;
+	}
+	try {
+		const result = spawnSync("which", [executable], {
+			encoding: "utf-8",
+			timeout: 5e3
+		});
+		if (result.status === 0 && result.stdout) {
+			const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+			if (firstMatch) return firstMatch;
+		}
+	} catch {}
+	return null;
+}
+/**
+* Resolve shell configuration based on platform and an optional explicit shell path.
+* Resolution order:
+* 1. User-specified shellPath
+* 2. On Windows: Git Bash in known locations, then bash on PATH
+* 3. On Unix: /bin/bash, then bash on PATH, then fallback to sh
+*/
+function getShellConfig(customShellPath) {
+	if (customShellPath) {
+		if (existsSync(customShellPath)) return getBashShellConfig(customShellPath);
+		throw new Error(`Custom shell path not found: ${customShellPath}`);
+	}
+	if (process.platform === "win32") {
+		const paths = [];
+		const programFiles = process.env.ProgramFiles;
+		if (programFiles) paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
+		const programFilesX86 = process.env["ProgramFiles(x86)"];
+		if (programFilesX86) paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+		for (const path of paths) if (existsSync(path)) return getBashShellConfig(path);
+		const bashOnPath = findExecutableOnPath("bash.exe");
+		if (bashOnPath) return getBashShellConfig(bashOnPath);
+		throw new Error(`No bash shell found. Options:
+  1. Install Git for Windows: https://git-scm.com/download/win
+  2. Add your bash to PATH (Cygwin, MSYS2, etc.)
+  3. Set shellPath in settings.json
+
+Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`);
+	}
+	if (existsSync("/bin/bash")) return getBashShellConfig("/bin/bash");
+	const bashOnPath = findExecutableOnPath("bash");
+	if (bashOnPath) return getBashShellConfig(bashOnPath);
+	return {
+		shell: "sh",
+		args: ["-c"]
+	};
+}
+/**
+* Sanitize binary output for display/storage.
+* Removes characters that crash string-width or cause display issues:
+* - Control characters (except tab, newline, carriage return)
+* - Unicode interlinear annotation characters U+FFF9..U+FFFB (crash string-width due to a bug)
+*/
+function sanitizeBinaryOutput(str) {
+	return str.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\uFFF9-\uFFFB]/g, "");
+}
+//#endregion
+export { VERSION as a, getCodemodeWorkerSpecifier as c, getQuickJSWasmPath as d, isBunBinary as f, CONFIG_DIR_NAME as i, getDocsPath as l, require_cross_spawn as m, sanitizeBinaryOutput as n, getAgentDir as o, normalizePath as p, APP_NAME as r, getBinDir as s, getShellConfig as t, getPackageDir as u };