agent-yes 1.60.0 → 1.60.2

package/dist/SUPPORTED_CLIS-TKiMwx-X.js

@@ -0,0 +1,1952 @@
+import { t as logger } from "./logger-CY9ormLF.js";
+import { arch, platform } from "process";
+import { execSync } from "child_process";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync } from "fs";
+import path, { dirname, join } from "path";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path$1 from "node:path";
+import winston from "winston";
+import { execaCommandSync, parseCommandString } from "execa";
+import { fromWritable } from "from-node-stream";
+import { appendFile, mkdir as mkdir$1, readFile as readFile$1, readdir, rename, writeFile as writeFile$1 } from "fs/promises";
+import DIE from "phpdie";
+import sflow from "sflow";
+import { TerminalRenderStream } from "terminal-render";
+import { homedir } from "os";
+import { lock } from "proper-lockfile";
+import { execSync as execSync$1 } from "node:child_process";
+import { fileURLToPath } from "url";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region ts/resume/codexSessionManager.ts
+const getSessionsFile = () => process.env.CLI_YES_TEST_HOME ? path.join(process.env.CLI_YES_TEST_HOME, ".config", "agent-yes", "codex-sessions.json") : path.join(homedir(), ".config", "agent-yes", "codex-sessions.json");
+const getCodexSessionsDir = () => process.env.CLI_YES_TEST_HOME ? path.join(process.env.CLI_YES_TEST_HOME, ".codex", "sessions") : path.join(homedir(), ".codex", "sessions");
+/**
+* Load the session map from the config file
+*/
+async function loadSessionMap() {
+	try {
+		const content = await readFile$1(getSessionsFile(), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+/**
+* Save the session map to the config file
+*/
+async function saveSessionMap(sessionMap) {
+	try {
+		const sessionsFile = getSessionsFile();
+		await mkdir$1(path.dirname(sessionsFile), { recursive: true });
+		await writeFile$1(sessionsFile, JSON.stringify(sessionMap, null, 2));
+	} catch (error) {
+		console.warn("Failed to save codex session map:", error);
+	}
+}
+/**
+* Store a session ID for a specific working directory
+*/
+async function storeSessionForCwd(cwd, sessionId) {
+	const sessionMap = await loadSessionMap();
+	sessionMap[cwd] = {
+		sessionId,
+		lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await saveSessionMap(sessionMap);
+}
+/**
+* Parse a codex session file to extract session metadata
+*/
+async function parseCodexSessionFile(filePath) {
+	try {
+		const lines = (await readFile$1(filePath, "utf-8")).trim().split("\n");
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			const data = JSON.parse(line);
+			if (data.type === "session_meta" && data.payload) {
+				const payload = data.payload;
+				return {
+					id: payload.id,
+					timestamp: payload.timestamp || data.timestamp,
+					cwd: payload.cwd,
+					filePath,
+					git: payload.git
+				};
+			}
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Get all codex sessions from the .codex/sessions directory
+*/
+async function getAllCodexSessions() {
+	const sessions = [];
+	const codexSessionsDir = getCodexSessionsDir();
+	try {
+		const years = await readdir(codexSessionsDir);
+		for (const year of years) {
+			const yearPath = path.join(codexSessionsDir, year);
+			try {
+				const months = await readdir(yearPath);
+				for (const month of months) {
+					const monthPath = path.join(yearPath, month);
+					try {
+						const days = await readdir(monthPath);
+						for (const day of days) {
+							const dayPath = path.join(monthPath, day);
+							try {
+								const files = await readdir(dayPath);
+								for (const file of files) if (file.endsWith(".jsonl")) {
+									const session = await parseCodexSessionFile(path.join(dayPath, file));
+									if (session) sessions.push(session);
+								}
+							} catch {}
+						}
+					} catch {}
+				}
+			} catch {}
+		}
+	} catch {
+		return [];
+	}
+	return sessions.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+}
+/**
+* Get the most recent session for a specific working directory from actual codex files
+*/
+async function getMostRecentCodexSessionForCwd(targetCwd) {
+	return (await getAllCodexSessions()).filter((session) => session.cwd === targetCwd)[0] || null;
+}
+/**
+* Get the last session ID for a specific working directory
+* Now checks actual codex session files first, falls back to stored mapping
+*/
+async function getSessionForCwd(cwd) {
+	const recentSession = await getMostRecentCodexSessionForCwd(cwd);
+	if (recentSession) return recentSession.id;
+	return (await loadSessionMap())[cwd]?.sessionId || null;
+}
+/**
+* Extract session ID from codex output
+* Session IDs are UUIDs in the format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+*/
+function extractSessionId(output) {
+	const match = output.match(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i);
+	return match ? match[0] : null;
+}
+
+//#endregion
+//#region ts/pty.ts
+async function getPty() {
+	return globalThis.Bun ? await import("bun-pty").catch((error) => {
+		logger.error("Failed to load bun-pty:", error);
+		throw error;
+	}) : await import("node-pty").catch((error) => {
+		logger.error("Failed to load node-pty:", error);
+		throw error;
+	});
+}
+const pty = await getPty();
+const ptyPackage = globalThis.Bun ? "bun-pty" : "node-pty";
+
+//#endregion
+//#region ts/removeControlCharacters.ts
+function removeControlCharacters(str) {
+	return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+}
+
+//#endregion
+//#region ts/runningLock.ts
+const getLockDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
+const getLockFile = () => path.join(getLockDir(), "running.lock.json");
+const MAX_RETRIES = 5;
+const RETRY_DELAYS = [
+	50,
+	100,
+	200,
+	400,
+	800
+];
+const POLL_INTERVAL = 2e3;
+/**
+* Check if a process is running
+*/
+function isProcessRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Get git repository root for a directory
+*/
+function getGitRoot(cwd) {
+	try {
+		return execSync("git rev-parse --show-toplevel", {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+/**
+* Check if directory is in a git repository
+*/
+function isGitRepo(cwd) {
+	try {
+		return getGitRoot(cwd) !== null;
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve path to real path (handling symlinks)
+*/
+function resolveRealPath(p) {
+	try {
+		return path.resolve(p);
+	} catch {
+		return p;
+	}
+}
+/**
+* Sleep for a given number of milliseconds
+*/
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Read lock file with retry logic and stale lock cleanup
+*/
+async function readLockFile() {
+	try {
+		const lockDir = getLockDir();
+		const lockFilePath = getLockFile();
+		await mkdir$1(lockDir, { recursive: true });
+		if (!existsSync(lockFilePath)) return { tasks: [] };
+		const content = await readFile$1(lockFilePath, "utf8");
+		const lockFile = JSON.parse(content);
+		lockFile.tasks = lockFile.tasks.filter((task) => {
+			if (isProcessRunning(task.pid)) return true;
+			return false;
+		});
+		return lockFile;
+	} catch {
+		return { tasks: [] };
+	}
+}
+/**
+* Write lock file atomically with retry logic
+*/
+async function writeLockFile(lockFile, retryCount = 0) {
+	try {
+		const lockDir = getLockDir();
+		const lockFilePath = getLockFile();
+		await mkdir$1(lockDir, { recursive: true });
+		const tempFile = `${lockFilePath}.tmp.${process.pid}`;
+		await writeFile$1(tempFile, JSON.stringify(lockFile, null, 2), "utf8");
+		await rename(tempFile, lockFilePath);
+	} catch (error) {
+		if (retryCount < MAX_RETRIES) {
+			await sleep$1(RETRY_DELAYS[retryCount] || 800);
+			return writeLockFile(lockFile, retryCount + 1);
+		}
+		throw error;
+	}
+}
+/**
+* Check if lock exists for the current working directory
+*/
+async function checkLock(cwd, _prompt) {
+	const resolvedCwd = resolveRealPath(cwd);
+	const gitRoot = isGitRepo(resolvedCwd) ? getGitRoot(resolvedCwd) : null;
+	const lockKey = gitRoot || resolvedCwd;
+	const blockingTasks = (await readLockFile()).tasks.filter((task) => {
+		if (!isProcessRunning(task.pid)) return false;
+		if (task.status !== "running") return false;
+		if (gitRoot && task.gitRoot) return task.gitRoot === gitRoot;
+		else return task.cwd === lockKey;
+	});
+	return {
+		isLocked: blockingTasks.length > 0,
+		blockingTasks,
+		lockKey
+	};
+}
+/**
+* Add a task to the lock file
+*/
+async function addTask(task) {
+	const lockFile = await readLockFile();
+	lockFile.tasks = lockFile.tasks.filter((t) => t.pid !== task.pid);
+	lockFile.tasks.push(task);
+	await writeLockFile(lockFile);
+}
+/**
+* Update task status
+*/
+async function updateTaskStatus(pid, status) {
+	const lockFile = await readLockFile();
+	const task = lockFile.tasks.find((t) => t.pid === pid);
+	if (task) {
+		task.status = status;
+		await writeLockFile(lockFile);
+	}
+}
+/**
+* Remove a task from the lock file
+*/
+async function removeTask(pid) {
+	const lockFile = await readLockFile();
+	lockFile.tasks = lockFile.tasks.filter((t) => t.pid !== pid);
+	await writeLockFile(lockFile);
+}
+/**
+* Wait for lock to be released
+*/
+async function waitForUnlock(blockingTasks, currentTask) {
+	const blockingTask = blockingTasks[0];
+	if (!blockingTask) return;
+	console.log(`⏳ Queueing for unlock of: ${blockingTask.task}`);
+	console.log(`   Press 'b' to bypass queue, 'k' to kill previous instance`);
+	await addTask({
+		...currentTask,
+		status: "queued"
+	});
+	const stdin = process.stdin;
+	const wasRaw = stdin.isRaw;
+	stdin.setRawMode?.(true);
+	stdin.resume();
+	let bypassed = false;
+	let killed = false;
+	const keyHandler = (key) => {
+		const char = key.toString();
+		if (char === "b" || char === "B") {
+			console.log("\n⚡ Bypassing queue...");
+			bypassed = true;
+		} else if (char === "k" || char === "K") {
+			console.log("\n🔪 Killing previous instance...");
+			killed = true;
+		}
+	};
+	stdin.on("data", keyHandler);
+	let dots = 0;
+	while (true) {
+		if (bypassed) {
+			await updateTaskStatus(currentTask.pid, "running");
+			console.log("✓ Queue bypassed, starting task...");
+			break;
+		}
+		if (killed && blockingTask) {
+			try {
+				process.kill(blockingTask.pid, "SIGTERM");
+				console.log(`✓ Killed process ${blockingTask.pid}`);
+				await sleep$1(1e3);
+			} catch (err) {
+				console.log(`⚠️  Could not kill process ${blockingTask.pid}: ${err}`);
+			}
+			killed = false;
+		}
+		await sleep$1(POLL_INTERVAL);
+		if (!(await checkLock(currentTask.cwd, currentTask.task)).isLocked) {
+			await updateTaskStatus(currentTask.pid, "running");
+			console.log(`\n✓ Lock released, starting task...`);
+			break;
+		}
+		dots = (dots + 1) % 4;
+		process.stdout.write(`\r⏳ Queueing${".".repeat(dots)}${" ".repeat(3 - dots)}`);
+	}
+	stdin.off("data", keyHandler);
+	stdin.setRawMode?.(wasRaw);
+	if (!wasRaw) stdin.pause();
+}
+/**
+* Acquire lock or wait if locked
+*/
+async function acquireLock(cwd, prompt = "no prompt provided") {
+	const resolvedCwd = resolveRealPath(cwd);
+	const task = {
+		cwd: resolvedCwd,
+		gitRoot: (isGitRepo(resolvedCwd) ? getGitRoot(resolvedCwd) : null) || void 0,
+		task: prompt.substring(0, 100),
+		pid: process.pid,
+		status: "running",
+		startedAt: Date.now(),
+		lockedAt: Date.now()
+	};
+	const lockCheck = await checkLock(resolvedCwd, prompt);
+	if (lockCheck.isLocked) await waitForUnlock(lockCheck.blockingTasks, task);
+	else await addTask(task);
+}
+/**
+* Release lock for current process
+*/
+async function releaseLock(pid = process.pid) {
+	await removeTask(pid);
+}
+/**
+* Check if we should use locking for this directory
+* Only use locking if we're in a git repository
+*/
+function shouldUseLock(_cwd) {
+	return true;
+}
+
+//#endregion
+//#region ts/JsonlStore.ts
+/**
+* A lightweight NeDB-style JSONL persistence layer.
+*
+* - Append-only writes (one JSON object per line)
+* - Same `_id` → last line wins (fields merged)
+* - `$$deleted` lines act as tombstones
+* - Crash recovery: skip partial last line, recover from temp file
+* - Multi-process safe via proper-lockfile (reads don't need lock)
+* - Compact on close: deduplicates into clean file via atomic rename
+*/
+var JsonlStore = class {
+	filePath;
+	tempPath;
+	lockPath;
+	docs = /* @__PURE__ */ new Map();
+	constructor(filePath) {
+		this.filePath = filePath;
+		this.tempPath = filePath + "~";
+		this.lockPath = path.dirname(filePath);
+	}
+	/**
+	* Load all records from the JSONL file. No lock needed.
+	* Handles crash recovery: partial last line skipped, temp file recovery.
+	*/
+	async load() {
+		await mkdir$1(path.dirname(this.filePath), { recursive: true });
+		if (!existsSync(this.filePath) && existsSync(this.tempPath)) {
+			logger.debug("[JsonlStore] Recovering from temp file");
+			await rename(this.tempPath, this.filePath);
+		}
+		this.docs = /* @__PURE__ */ new Map();
+		let raw = "";
+		try {
+			raw = await readFile$1(this.filePath, "utf-8");
+		} catch (err) {
+			if (err.code === "ENOENT") return this.docs;
+			throw err;
+		}
+		const lines = raw.split("\n");
+		let corruptCount = 0;
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			try {
+				const doc = JSON.parse(trimmed);
+				if (!doc._id) continue;
+				if (doc.$$deleted) this.docs.delete(doc._id);
+				else {
+					const existing = this.docs.get(doc._id);
+					if (existing) this.docs.set(doc._id, {
+						...existing,
+						...doc
+					});
+					else this.docs.set(doc._id, doc);
+				}
+			} catch {
+				corruptCount++;
+			}
+		}
+		if (corruptCount > 0) logger.debug(`[JsonlStore] Skipped ${corruptCount} corrupt line(s) in ${this.filePath}`);
+		return this.docs;
+	}
+	/** Get all live documents. */
+	getAll() {
+		return Array.from(this.docs.values());
+	}
+	/** Find a document by _id. */
+	getById(id) {
+		return this.docs.get(id);
+	}
+	/** Find documents matching a predicate. */
+	find(predicate) {
+		return this.getAll().filter(predicate);
+	}
+	/** Find first document matching a predicate. */
+	findOne(predicate) {
+		for (const doc of this.docs.values()) if (predicate(doc)) return doc;
+	}
+	/**
+	* Append a new document. Acquires lock.
+	* If no _id is provided, one is generated.
+	*/
+	async append(doc) {
+		const id = doc._id || generateId();
+		const { _id: _, ...rest } = doc;
+		const fullDoc = {
+			_id: id,
+			...rest
+		};
+		return await this.withLock(async () => {
+			await appendFile(this.filePath, JSON.stringify(fullDoc) + "\n");
+			const existing = this.docs.get(fullDoc._id);
+			if (existing) this.docs.set(fullDoc._id, {
+				...existing,
+				...fullDoc
+			});
+			else this.docs.set(fullDoc._id, fullDoc);
+			return fullDoc;
+		});
+	}
+	/**
+	* Update a document by _id. Appends a merge line. Acquires lock.
+	*/
+	async updateById(id, patch) {
+		await this.withLock(async () => {
+			const line = {
+				_id: id,
+				...patch
+			};
+			await appendFile(this.filePath, JSON.stringify(line) + "\n");
+			const existing = this.docs.get(id);
+			if (existing) this.docs.set(id, {
+				...existing,
+				...patch
+			});
+		});
+	}
+	/**
+	* Delete a document by _id. Appends a tombstone. Acquires lock.
+	*/
+	async deleteById(id) {
+		await this.withLock(async () => {
+			const tombstone = {
+				_id: id,
+				$$deleted: true
+			};
+			await appendFile(this.filePath, JSON.stringify(tombstone) + "\n");
+			this.docs.delete(id);
+		});
+	}
+	/**
+	* Compact the file: deduplicate entries, remove tombstones.
+	* Writes to temp file, fsyncs, then atomic renames.
+	* Acquires lock.
+	*/
+	async compact() {
+		await this.withLock(async () => {
+			const lines = Array.from(this.docs.values()).map((doc) => {
+				const { _id, $$deleted, ...rest } = doc;
+				return JSON.stringify({
+					_id,
+					...rest
+				});
+			}).join("\n");
+			const content = lines ? lines + "\n" : "";
+			await writeFile$1(this.tempPath, content);
+			const fd = openSync(this.tempPath, "r");
+			fsyncSync(fd);
+			closeSync(fd);
+			await rename(this.tempPath, this.filePath);
+		});
+	}
+	async withLock(fn) {
+		const dir = path.dirname(this.filePath);
+		let release;
+		try {
+			release = await lock(dir, {
+				lockfilePath: this.filePath + ".lock",
+				retries: {
+					retries: 5,
+					minTimeout: 50,
+					maxTimeout: 500
+				}
+			});
+			return await fn();
+		} finally {
+			if (release) await release();
+		}
+	}
+};
+let idCounter = 0;
+function generateId() {
+	return Date.now().toString(36) + (idCounter++).toString(36) + Math.random().toString(36).slice(2, 6);
+}
+
+//#endregion
+//#region ts/pidStore.ts
+var PidStore = class PidStore {
+	storeDir;
+	store;
+	constructor(workingDir) {
+		this.storeDir = path.resolve(workingDir, ".agent-yes");
+		this.store = new JsonlStore(path.join(this.storeDir, "pid-records.jsonl"));
+	}
+	async init() {
+		try {
+			await this.ensureGitignore();
+			await this.store.load();
+			await this.cleanStaleRecords();
+		} catch (error) {
+			logger.warn("[pidStore] Failed to initialize:", error);
+		}
+	}
+	async registerProcess({ pid, cli, args, prompt, cwd }) {
+		const now = Date.now();
+		const record = {
+			pid,
+			cli,
+			args: JSON.stringify(args),
+			prompt,
+			cwd,
+			logFile: path.resolve(this.getLogDir(), `${pid}.log`),
+			fifoFile: this.getFifoPath(pid),
+			status: "active",
+			exitReason: "",
+			startedAt: now
+		};
+		const existing = this.store.findOne((doc) => doc.pid === pid);
+		if (existing) await this.store.updateById(existing._id, record);
+		else await this.store.append(record);
+		const result = this.store.findOne((doc) => doc.pid === pid);
+		if (!result) {
+			const allRecords = this.store.getAll();
+			logger.error(`[pidStore] Failed to find record for PID ${pid}. All records:`, allRecords);
+			throw new Error(`Failed to register process ${pid}`);
+		}
+		logger.debug(`[pidStore] Registered process ${pid}`);
+		return result;
+	}
+	async updateStatus(pid, status, extra) {
+		const existing = this.store.findOne((doc) => doc.pid === pid);
+		if (!existing) return;
+		const patch = { status };
+		if (extra?.exitReason !== void 0) patch.exitReason = extra.exitReason;
+		if (extra?.exitCode !== void 0) patch.exitCode = extra.exitCode;
+		await this.store.updateById(existing._id, patch);
+		logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
+	}
+	getAllRecords() {
+		return this.store.getAll();
+	}
+	getLogDir() {
+		return path.resolve(this.storeDir, "logs");
+	}
+	getFifoPath(pid) {
+		if (process.platform === "win32") return `\\\\.\\pipe\\agent-yes-${pid}`;
+		else return path.resolve(this.storeDir, "fifo", `${pid}.stdin`);
+	}
+	async cleanStaleRecords() {
+		const activeRecords = this.store.find((r) => r.status !== "exited");
+		for (const record of activeRecords) if (!this.isProcessAlive(record.pid)) {
+			await this.store.updateById(record._id, {
+				status: "exited",
+				exitReason: "stale-cleanup"
+			});
+			logger.debug(`[pidStore] Cleaned stale record for PID ${record.pid}`);
+		}
+	}
+	async close() {
+		try {
+			await this.store.compact();
+		} catch (error) {
+			logger.debug("[pidStore] Compact on close failed:", error);
+		}
+		logger.debug("[pidStore] Database compacted and closed");
+	}
+	isProcessAlive(pid) {
+		try {
+			process.kill(pid, 0);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async ensureGitignore() {
+		const gitignorePath = path.join(this.storeDir, ".gitignore");
+		const gitignoreContent = `# Auto-generated .gitignore for agent-yes
+# Ignore all log files and runtime data
+logs/
+fifo/
+pid-db/
+*.jsonl
+*.jsonl~
+*.jsonl.lock
+*.sqlite
+*.sqlite-*
+*.log
+*.raw.log
+*.lines.log
+*.debug.log
+
+# Ignore .gitignore itself
+.gitignore
+
+`;
+		try {
+			await mkdir$1(this.storeDir, { recursive: true });
+			await writeFile$1(gitignorePath, gitignoreContent, { flag: "wx" });
+			logger.debug(`[pidStore] Created .gitignore in ${this.storeDir}`);
+		} catch (error) {
+			if (error.code !== "EEXIST") logger.warn(`[pidStore] Failed to create .gitignore:`, error);
+		}
+	}
+	static async findActiveFifo(workingDir) {
+		try {
+			const store = new PidStore(workingDir);
+			await store.init();
+			const records = store.store.find((r) => r.status !== "exited").sort((a, b) => b.startedAt - a.startedAt);
+			await store.close();
+			return records[0]?.fifoFile ?? null;
+		} catch (error) {
+			logger.warn("[pidStore] findActiveFifo failed:", error);
+			return null;
+		}
+	}
+};
+
+//#endregion
+//#region ts/idleWaiter.ts
+/**
+* A utility class to wait for idle periods based on activity pings.
+*
+* @example
+* const idleWaiter = new IdleWaiter();
+*
+* // Somewhere in your code, when activity occurs:
+* idleWaiter.ping();
+*
+* // To wait for an idle period of 5 seconds:
+* await idleWaiter.wait(5000);
+* console.log('System has been idle for 5 seconds');
+*/
+var IdleWaiter = class {
+	lastActivityTime = Date.now();
+	checkInterval = 100;
+	constructor() {
+		this.ping();
+	}
+	ping() {
+		this.lastActivityTime = Date.now();
+		return this;
+	}
+	async wait(ms) {
+		while (this.lastActivityTime >= Date.now() - ms) await new Promise((resolve) => setTimeout(resolve, this.checkInterval));
+	}
+};
+
+//#endregion
+//#region ts/ReadyManager.ts
+var ReadyManager = class {
+	isReady = false;
+	readyQueue = [];
+	wait() {
+		if (this.isReady) return;
+		return new Promise((resolve) => this.readyQueue.push(resolve));
+	}
+	unready() {
+		this.isReady = false;
+	}
+	ready() {
+		this.isReady = true;
+		if (!this.readyQueue.length) return;
+		this.readyQueue.splice(0).map((resolve) => resolve());
+	}
+};
+
+//#endregion
+//#region ts/core/messaging.ts
+/**
+* Send Enter key to the shell after waiting for idle state
+* @param context Message context with shell and state managers
+* @param waitms Milliseconds to wait for idle before sending Enter (default: 1000)
+*/
+async function sendEnter(context, waitms = 1e3) {
+	const st = Date.now();
+	await context.idleWaiter.wait(waitms);
+	const et = Date.now();
+	logger.debug(`sendingEnter| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`);
+	context.nextStdout.unready();
+	context.shell.write("\r");
+	logger.debug(`enterSent| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`);
+	await Promise.race([context.nextStdout.wait(), new Promise((resolve) => setTimeout(() => {
+		if (!context.nextStdout.ready) context.shell.write("\r");
+		resolve();
+	}, 1e3))]);
+	await Promise.race([context.nextStdout.wait(), new Promise((resolve) => setTimeout(() => {
+		if (!context.nextStdout.ready) context.shell.write("\r");
+		resolve();
+	}, 3e3))]);
+}
+/**
+* Send a message to the shell
+* @param context Message context with shell and state managers
+* @param message Message string to send
+* @param options Options for message sending
+*/
+async function sendMessage(context, message, { waitForReady = true } = {}) {
+	if (waitForReady) await context.stdinReady.wait();
+	logger.debug(`send  |${message}`);
+	context.nextStdout.unready();
+	context.shell.write(message);
+	context.idleWaiter.ping();
+	logger.debug(`waiting next stdout|${message}`);
+	await context.nextStdout.wait();
+	logger.debug(`sending enter`);
+	await sendEnter(context, 1e3);
+	logger.debug(`sent enter`);
+}
+
+//#endregion
+//#region ts/core/logging.ts
+/**
+* Initialize log paths based on PID
+* @param pidStore PID store instance
+* @param pid Process ID
+* @returns Object containing all log paths
+*/
+async function initializeLogPaths(pidStore, pid) {
+	const logDir = pidStore.getLogDir();
+	await mkdir$1(logDir, { recursive: true });
+	return {
+		logPath: logDir,
+		rawLogPath: path.resolve(path.dirname(logDir), `${pid}.raw.log`),
+		rawLinesLogPath: path.resolve(path.dirname(logDir), `${pid}.lines.log`),
+		debuggingLogsPath: path.resolve(path.dirname(logDir), `${pid}.debug.log`)
+	};
+}
+/**
+* Setup debug logging to file
+* @param debuggingLogsPath Path to debug log file
+*/
+function setupDebugLogging(debuggingLogsPath) {
+	if (debuggingLogsPath) logger.add(new winston.transports.File({
+		filename: debuggingLogsPath,
+		level: "debug"
+	}));
+}
+/**
+* Save rendered terminal output to log file
+* @param logPath Path to log file
+* @param content Rendered content to save
+*/
+async function saveLogFile(logPath, content) {
+	if (!logPath) return;
+	await mkdir$1(path.dirname(logPath), { recursive: true }).catch(() => null);
+	await writeFile$1(logPath, content).catch(() => null);
+	logger.info(`Full logs saved to ${logPath}`);
+}
+/**
+* Save logs to deprecated logFile option (for backward compatibility)
+* @param logFile User-specified log file path
+* @param content Rendered content to save
+* @param verbose Whether to log verbose messages
+*/
+async function saveDeprecatedLogFile(logFile, content, verbose) {
+	if (!logFile) return;
+	if (verbose) logger.info(`Writing rendered logs to ${logFile}`);
+	const logFilePath = path.resolve(logFile);
+	await mkdir$1(path.dirname(logFilePath), { recursive: true }).catch(() => null);
+	await writeFile$1(logFilePath, content);
+}
+
+//#endregion
+//#region ts/tryCatch.ts
+/**
+* A utility function to wrap another function with a try-catch block.
+* If an error occurs during the execution of the function, the provided
+* catchFn is called with the error, the original function, and its arguments.
+*
+* @param catchFn - The function to call when an error occurs.
+* @param fn - The function to wrap.
+* @returns A new function that wraps the original function with error handling.
+*/
+function tryCatch(catchFn, fn) {
+	let attempts = 0;
+	return function robustFn(...args) {
+		try {
+			attempts++;
+			return fn(...args);
+		} catch (error) {
+			return catchFn(error, attempts, robustFn, ...args);
+		}
+	};
+}
+
+//#endregion
+//#region package.json
+var name = "agent-yes";
+var version = "1.60.2";
+
+//#endregion
+//#region ts/pty-fix.ts
+var pty_fix_exports = /* @__PURE__ */ __exportAll({});
+function getLibraryName() {
+	switch (platform) {
+		case "win32": return "rust_pty.dll";
+		case "darwin": return arch === "arm64" ? "librust_pty_arm64.dylib" : "librust_pty.dylib";
+		case "linux": return arch === "arm64" ? "librust_pty_arm64.so" : "librust_pty.so";
+		default: return "librust_pty.so";
+	}
+}
+function rebuildBunPty() {
+	try {
+		const cargoCmd = platform === "win32" ? "cargo.exe" : "cargo";
+		try {
+			execSync(`${cargoCmd} --version`, { stdio: "ignore" });
+		} catch {
+			console.warn("Warning: Rust/Cargo not found. bun-pty native module may not work.");
+			console.warn("To fix this, install Rust: https://rustup.rs/");
+			return;
+		}
+		const rustPtyDir = join(bunPtyPath, "rust-pty");
+		const isWindows = platform === "win32";
+		const tempBase = isWindows ? process.env.TEMP || "C:\\Temp" : "/tmp";
+		if (!existsSync(join(rustPtyDir, "Cargo.toml"))) {
+			console.log("Source code not found in npm package, cloning from repository...");
+			const tmpDir = join(tempBase, `bun-pty-build-${Date.now()}`);
+			try {
+				execSync(`git clone https://github.com/snomiao/bun-pty.git "${tmpDir}"`, { stdio: "inherit" });
+				if (isWindows) execSync(`cd /d "${tmpDir}" && cargo build --release --manifest-path rust-pty\\Cargo.toml`, { stdio: "inherit" });
+				else execSync(`cd "${tmpDir}" && cargo build --release --manifest-path rust-pty/Cargo.toml`, { stdio: "inherit" });
+				const builtLib = join(tmpDir, "rust-pty", "target", "release", libName);
+				if (existsSync(builtLib)) {
+					const targetDir = join(rustPtyDir, "target", "release");
+					if (isWindows) {
+						execSync(`if not exist "${targetDir}" mkdir "${targetDir}"`, {});
+						execSync(`copy /Y "${builtLib}" "${libPath}"`, {});
+					} else {
+						execSync(`mkdir -p "${targetDir}"`, { stdio: "inherit" });
+						execSync(`cp "${builtLib}" "${libPath}"`, { stdio: "inherit" });
+					}
+					console.log("Successfully rebuilt bun-pty native module");
+				}
+				if (isWindows) execSync(`rmdir /s /q "${tmpDir}"`, { stdio: "ignore" });
+				else execSync(`rm -rf "${tmpDir}"`, { stdio: "ignore" });
+			} catch (buildError) {
+				console.error("Failed to build bun-pty:", buildError instanceof Error ? buildError.message : buildError);
+				console.warn("The application may not work correctly without bun-pty");
+			}
+		} else {
+			console.log("Building bun-pty from source...");
+			if (isWindows) execSync(`cd /d "${rustPtyDir}" && cargo build --release`, { stdio: "inherit" });
+			else execSync(`cd "${rustPtyDir}" && cargo build --release`, { stdio: "inherit" });
+			console.log("Successfully rebuilt bun-pty native module");
+		}
+	} catch (error) {
+		console.error("Failed to rebuild bun-pty:", error instanceof Error ? error.message : error);
+		console.warn("The application may not work correctly without bun-pty");
+	}
+}
+var bunPtyPath, libName, libPath;
+var init_pty_fix = __esmMin((() => {
+	bunPtyPath = dirname(fileURLToPath(import.meta.resolve("@snomiao/bun-pty"))) + "/..";
+	libName = getLibraryName();
+	libPath = join(bunPtyPath, "rust-pty", "target", "release", libName);
+	if (!existsSync(bunPtyPath)) {
+		console.log({ bunPtyPath });
+		console.log("bun-pty not found, skipping pty-fix in ");
+		process.exit(0);
+	}
+	if (platform === "linux") try {
+		const lddOutput = execSync(`ldd "${libPath}" 2>&1`, { encoding: "utf8" });
+		if (lddOutput.includes("GLIBC") && lddOutput.includes("not found")) {
+			console.log("GLIBC compatibility issue detected, rebuilding bun-pty...");
+			rebuildBunPty();
+		} else console.log("bun-pty binary is compatible");
+	} catch {
+		console.log("Checking bun-pty compatibility...");
+		rebuildBunPty();
+	}
+	else if (platform === "win32") if (!existsSync(libPath)) {
+		console.log("Windows DLL not found, attempting to rebuild...");
+		rebuildBunPty();
+	} else console.log("bun-pty Windows DLL found");
+	else if (platform === "darwin") if (!existsSync(libPath)) {
+		console.log("macOS dylib not found, attempting to rebuild...");
+		rebuildBunPty();
+	} else console.log("bun-pty macOS dylib found");
+	else console.log(`Platform ${platform} may require manual configuration`);
+}));
+
+//#endregion
+//#region ts/core/spawner.ts
+/**
+* Get install command based on platform and configuration
+*
+* Selects the appropriate install command from the configuration
+* based on the current platform (Windows/Unix) and available shells.
+* Falls back to npm if platform-specific commands aren't available.
+*
+* @param installConfig - Install command configuration (string or platform-specific object)
+* @returns Install command string or null if no suitable command found
+*
+* @example
+* ```typescript
+* // Simple string config
+* getInstallCommand('npm install -g claude-cli')
+*
+* // Platform-specific config
+* getInstallCommand({
+*   windows: 'npm install -g claude-cli',
+*   unix: 'curl -fsSL install.sh | sh',
+*   npm: 'npm install -g claude-cli'
+* })
+* ```
+*/
+function getInstallCommand(installConfig) {
+	if (typeof installConfig === "string") return installConfig;
+	const isWindows = process.platform === "win32";
+	const platform = isWindows ? "windows" : "unix";
+	if (installConfig[platform]) return installConfig[platform];
+	if (isWindows && installConfig.powershell) return installConfig.powershell;
+	if (!isWindows && installConfig.bash) return installConfig.bash;
+	if (installConfig.npm) return installConfig.npm;
+	return null;
+}
+/**
+* Check if error is a command not found error
+*/
+function isCommandNotFoundError(e) {
+	if (e instanceof Error) return e.message.includes("command not found") || e.message.includes("ENOENT") || e.message.includes("spawn");
+	return false;
+}
+/**
+* Spawn agent CLI process with error handling and auto-install
+*
+* Creates a new PTY process for the specified CLI with comprehensive error
+* handling. If the CLI is not found and auto-install is enabled, attempts
+* to install it automatically. Includes special handling for bun-pty issues.
+*
+* @param options - Spawn configuration options
+* @returns IPty process instance
+* @throws Error if CLI not found and installation fails or is disabled
+*
+* @example
+* ```typescript
+* const shell = spawnAgent({
+*   cli: 'claude',
+*   cliConf: config.clis.claude,
+*   cliArgs: ['--verbose'],
+*   verbose: true,
+*   install: false,
+*   ptyOptions: {
+*     name: 'xterm-color',
+*     cols: 80,
+*     rows: 30,
+*     cwd: '/path/to/project',
+*     env: process.env
+*   }
+* });
+* ```
+*/
+function spawnAgent(options) {
+	const { cli, cliConf, cliArgs, verbose, install, ptyOptions } = options;
+	const spawn = () => {
+		let [bin, ...args] = [...parseCommandString(cliConf?.binary || cli), ...cliArgs];
+		logger.debug(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
+		const spawned = pty.spawn(bin, args, ptyOptions);
+		logger.info(`[${cli}-yes] Spawned ${bin} with PID ${spawned.pid} (agent-yes v${version})`);
+		return spawned;
+	};
+	return tryCatch((error, attempts, spawn, ...args) => {
+		logger.error(`Fatal: Failed to start ${cli}.`);
+		const isNotFound = isCommandNotFoundError(error);
+		if (cliConf?.install && isNotFound) {
+			const installCmd = getInstallCommand(cliConf.install);
+			if (!installCmd) {
+				logger.error(`No suitable install command found for ${cli} on this platform`);
+				throw error;
+			}
+			logger.info(`Please install the cli by run ${installCmd}`);
+			if (install) {
+				logger.debug(`Attempting to install ${cli}...`);
+				execSync$1(installCmd, { stdio: "inherit" });
+				logger.info(`${cli} installed successfully. Please rerun the command.`);
+				return spawn(...args);
+			} else {
+				logger.error(`If you did not installed it yet, Please install it first: ${installCmd}`);
+				throw error;
+			}
+		}
+		if (globalThis.Bun && error instanceof Error && error.stack?.includes("bun-pty")) {
+			logger.error(`Detected bun-pty issue, attempted to fix it. Please try again.`);
+			init_pty_fix();
+		}
+		throw error;
+	}, spawn)();
+}
+
+//#endregion
+//#region ts/core/context.ts
+/**
+* Shared context for agent session
+*
+* Groups related state and dependencies for easier passing between modules.
+* This class encapsulates all stateful components needed during an agent session,
+* including the PTY shell, configuration, state managers, and flags.
+*
+* @example
+* ```typescript
+* const ctx = new AgentContext({
+*   shell,
+*   pidStore,
+*   logPaths,
+*   cli: 'claude',
+*   cliConf,
+*   verbose: true,
+*   robust: true
+* });
+*
+* // Access message context for sending messages
+* await sendMessage(ctx.messageContext, 'Hello');
+*
+* // Check and update state
+* if (ctx.isFatal) {
+*   await exitAgent();
+* }
+* ```
+*/
+var AgentContext = class {
+	shell;
+	pidStore;
+	logPaths;
+	cli;
+	cliConf;
+	verbose;
+	robust;
+	stdinReady = new ReadyManager();
+	stdinFirstReady = new ReadyManager();
+	nextStdout = new ReadyManager();
+	idleWaiter = new IdleWaiter();
+	isFatal = false;
+	shouldRestartWithoutContinue = false;
+	autoYesEnabled = true;
+	constructor(params) {
+		this.shell = params.shell;
+		this.pidStore = params.pidStore;
+		this.logPaths = params.logPaths;
+		this.cli = params.cli;
+		this.cliConf = params.cliConf;
+		this.verbose = params.verbose;
+		this.robust = params.robust;
+		this.autoYesEnabled = params.autoYes ?? true;
+	}
+	/**
+	* Get message context for sendMessage/sendEnter helpers
+	*
+	* Provides a lightweight object with only the dependencies needed
+	* for message sending operations, avoiding circular references.
+	*
+	* @returns MessageContext object for use with sendMessage/sendEnter
+	*/
+	get messageContext() {
+		return {
+			shell: this.shell,
+			idleWaiter: this.idleWaiter,
+			stdinReady: this.stdinReady,
+			nextStdout: this.nextStdout
+		};
+	}
+};
+
+//#endregion
+//#region ts/core/streamHelpers.ts
+/**
+* Stream processing utilities for terminal I/O
+*
+* Provides helper functions for stream lifecycle management.
+*/
+/**
+* Create a terminator transform stream that ends when promise resolves
+*
+* Creates a TransformStream that automatically terminates when the provided
+* promise resolves. Used to stop output processing when the agent exits.
+*
+* @param exitPromise - Promise that resolves when stream should terminate
+* @returns TransformStream that terminates on promise resolution
+*
+* @example
+* ```typescript
+* const exitPromise = Promise.withResolvers<number>();
+* stream.by(createTerminatorStream(exitPromise.promise));
+*
+* // Later, when agent exits:
+* exitPromise.resolve(0);
+* ```
+*/
+function createTerminatorStream(exitPromise) {
+	return new TransformStream({
+		start: function terminator(ctrl) {
+			exitPromise.then(() => ctrl.terminate());
+		},
+		transform: (e, ctrl) => ctrl.enqueue(e),
+		flush: (ctrl) => ctrl.terminate()
+	});
+}
+
+//#endregion
+//#region ts/agentRegistry.ts
+const MAX_BUFFER_SIZE = 1e3;
+var AgentRegistry = class {
+	agents = /* @__PURE__ */ new Map();
+	/**
+	* Register a new agent instance
+	*/
+	register(pid, instance) {
+		this.agents.set(pid, instance);
+	}
+	/**
+	* Unregister an agent instance
+	*/
+	unregister(pid) {
+		this.agents.delete(pid);
+	}
+	/**
+	* Get an agent instance by PID
+	*/
+	get(pid) {
+		return this.agents.get(pid);
+	}
+	/**
+	* List all registered agents
+	*/
+	list() {
+		return Array.from(this.agents.values());
+	}
+	/**
+	* Append stdout data to an agent's buffer (circular buffer)
+	*/
+	appendStdout(pid, data) {
+		const instance = this.agents.get(pid);
+		if (!instance) return;
+		const lines = data.split("\n");
+		instance.stdoutBuffer.push(...lines);
+		if (instance.stdoutBuffer.length > MAX_BUFFER_SIZE) instance.stdoutBuffer = instance.stdoutBuffer.slice(-MAX_BUFFER_SIZE);
+	}
+	/**
+	* Get stdout from an agent's buffer
+	*/
+	getStdout(pid, tail) {
+		const instance = this.agents.get(pid);
+		if (!instance) return [];
+		if (tail !== void 0) return instance.stdoutBuffer.slice(-tail);
+		return instance.stdoutBuffer;
+	}
+};
+const globalAgentRegistry = new AgentRegistry();
+
+//#endregion
+//#region ts/installEnv.ts
+const installDir = path$1.join(import.meta.dir, "..");
+function parseEnvContent(content) {
+	const result = {};
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex < 0) continue;
+		const key = trimmed.slice(0, eqIndex).trim();
+		let value = trimmed.slice(eqIndex + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		result[key] = value;
+	}
+	return result;
+}
+let _installEnv = null;
+/**
+* Load .env from the agent-yes install directory (not the working dir).
+* Install dir is ${import.meta.dir}/.. relative to this file.
+* Cached after first load.
+*/
+async function loadInstallEnv() {
+	if (_installEnv) return _installEnv;
+	const envPath = path$1.join(installDir, ".env");
+	try {
+		_installEnv = parseEnvContent(await readFile(envPath, "utf-8"));
+	} catch {
+		_installEnv = {};
+	}
+	return _installEnv;
+}
+/**
+* Get a value from the install .env, falling back to process.env.
+*/
+async function getInstallEnv(key) {
+	return (await loadInstallEnv())[key] ?? process.env[key];
+}
+
+//#endregion
+//#region ts/webhookNotifier.ts
+/**
+* Notify the AGENT_YES_MESSAGE_WEBHOOK URL with a status message.
+*
+* AGENT_YES_MESSAGE_WEBHOOK should be set in the agent-yes install dir .env, e.g.:
+*   AGENT_YES_MESSAGE_WEBHOOK=https://example.com/hook?q=%s
+*
+* The %s placeholder is replaced with the URL-encoded message:
+*   [STATUS] hostname:cwd details
+*/
+async function notifyWebhook(status, details, cwd = process.cwd()) {
+	const webhookTemplate = await getInstallEnv("AGENT_YES_MESSAGE_WEBHOOK");
+	if (!webhookTemplate) return;
+	const message = `[${status}] ${os.hostname()}:${cwd}${details ? " " + details : ""}`;
+	const url = webhookTemplate.replace("%s", encodeURIComponent(message));
+	try {
+		const res = await fetch(url);
+		logger.debug(`[webhook] ${status} notified (${res.status}): ${url}`);
+	} catch (error) {
+		logger.warn(`[webhook] Failed to notify ${status}: ${error}`);
+	}
+}
+
+//#endregion
+//#region ts/index.ts
+const config = await import("./agent-yes.config-XmUcKFde.js").then((mod) => mod.default || mod);
+const CLIS_CONFIG = config.clis;
+/**
+* Main function to run agent-cli with automatic yes/no responses
+* @param options Configuration options
+* @param options.continueOnCrash - If true, automatically restart agent-cli when it crashes:
+*   1. Shows message 'agent-cli crashed, restarting..'
+*   2. Spawns a new 'agent-cli --continue' process
+*   3. Re-attaches the new process to the shell stdio (pipes new process stdin/stdout)
+*   4. If it crashes with "No conversation found to continue", exits the process
+* @param options.exitOnIdle - Exit when agent-cli is idle. Boolean or timeout in milliseconds, recommended 5000 - 60000, default is false
+* @param options.cliArgs - Additional arguments to pass to the agent-cli CLI
+* @param options.removeControlCharactersFromStdout - Remove ANSI control characters from stdout. Defaults to !process.stdout.isTTY
+* @param options.disableLock - Disable the running lock feature that prevents concurrent agents in the same directory/repo
+*
+* @example
+* ```typescript
+* import agentYes from 'agent-yes';
+* await agentYes({
+*   prompt: 'help me solve all todos in my codebase',
+*
+*   // optional
+*   cliArgs: ['--verbose'], // additional args to pass to agent-cli
+*   exitOnIdle: 30000, // exit after 30 seconds of idle
+*   robust: true, // auto restart with --continue if claude crashes, default is true
+*   logFile: 'claude-output.log', // save logs to file
+*   disableLock: false, // disable running lock (default is false)
+* });
+* ```
+*/
+async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, exitOnIdle, logFile, removeControlCharactersFromStdout = false, verbose = false, queue = false, install = false, resume = false, useSkills = false, useStdinAppend = false, autoYes = true }) {
+	if (!cli) throw new Error(`cli is required`);
+	const conf = CLIS_CONFIG[cli] || DIE(`Unsupported cli tool: ${cli}, current process.argv: ${process.argv.join(" ")}`);
+	const workingDir = cwd ?? process.cwd();
+	if (queue) {
+		if (queue && shouldUseLock(workingDir)) await acquireLock(workingDir, prompt ?? "Interactive session");
+		const cleanupLock = async () => {
+			if (queue && shouldUseLock(workingDir)) await releaseLock().catch(() => null);
+		};
+		process.on("exit", () => {
+			if (queue) releaseLock().catch(() => null);
+		});
+		process.on("SIGINT", async (code) => {
+			await cleanupLock();
+			process.exit(code);
+		});
+		process.on("SIGTERM", async (code) => {
+			await cleanupLock();
+			process.exit(code);
+		});
+	}
+	const pidStore = new PidStore(workingDir);
+	await pidStore.init();
+	let userSentCtrlC = false;
+	if (verbose) logger.debug(`[stdin] isTTY: ${process.stdin.isTTY}, setRawMode available: ${!!process.stdin.setRawMode}`);
+	process.stdin.setRawMode?.(true);
+	if (verbose) logger.debug(`[stdin] Raw mode set, isRaw: ${process.stdin.isRaw}`);
+	const terminalStream = new TerminalRenderStream({ mode: "raw" });
+	const terminalRender = terminalStream.getRenderer();
+	const outputWriter = terminalStream.writable.getWriter();
+	logger.debug(`Using ${ptyPackage} for pseudo terminal management.`);
+	if (!!process.env.CLAUDE_PPID) logger.info(`[${cli}-yes] Running as sub-agent (CLAUDE_PPID=${process.env.CLAUDE_PPID})`);
+	const cliConf = CLIS_CONFIG[cli] || {};
+	cliArgs = cliConf.defaultArgs ? [...cliConf.defaultArgs, ...cliArgs] : cliArgs;
+	try {
+		const workingDir = cwd ?? process.cwd();
+		if (useSkills && cli !== "claude") {
+			let gitRoot = null;
+			try {
+				const result = execaCommandSync("git rev-parse --show-toplevel", {
+					cwd: workingDir,
+					reject: false
+				});
+				if (result.exitCode === 0) gitRoot = result.stdout.trim();
+			} catch {}
+			const skillHeaders = [];
+			let currentDir = workingDir;
+			const searchLimit = gitRoot || path.parse(currentDir).root;
+			while (true) {
+				const md = await readFile$1(path.resolve(currentDir, "SKILL.md"), "utf8").catch(() => null);
+				if (md) {
+					const headerMatch = md.match(/^[\s\S]*?(?=\n##\s)/);
+					const headerRaw = (headerMatch ? headerMatch[0] : md).trim();
+					if (headerRaw) {
+						skillHeaders.push(headerRaw);
+						if (verbose) logger.info(`[skills] Found SKILL.md in ${currentDir} (${headerRaw.length} chars)`);
+					}
+				}
+				if (currentDir === searchLimit) break;
+				const parentDir = path.dirname(currentDir);
+				if (parentDir === currentDir) break;
+				currentDir = parentDir;
+			}
+			if (skillHeaders.length > 0) {
+				const combined = skillHeaders.join("\n\n---\n\n");
+				const MAX = 2e3;
+				const header = combined.length > MAX ? combined.slice(0, MAX) + "…" : combined;
+				const prefix = `Use this repository skill as context:\n\n${header}`;
+				prompt = prompt ? `${prefix}\n\n${prompt}` : prefix;
+				if (verbose) logger.info(`[skills] Injected ${skillHeaders.length} SKILL.md header(s) (${header.length} chars total)`);
+			} else if (verbose) logger.info("[skills] No SKILL.md found in directory hierarchy");
+		}
+	} catch (error) {
+		if (verbose) logger.warn("[skills] Failed to inject SKILL.md header:", { error });
+	}
+	if (resume) if (cli === "codex" && resume) {
+		const storedSessionId = await getSessionForCwd(workingDir);
+		if (storedSessionId) {
+			cliArgs = [
+				"resume",
+				storedSessionId,
+				...cliArgs
+			];
+			await logger.debug(`resume|using stored session ID: ${storedSessionId}`);
+		} else throw new Error(`No stored session found for codex in directory: ${workingDir}, please try without resume option.`);
+	} else if (cli === "claude") {
+		cliArgs = ["--continue", ...cliArgs];
+		await logger.debug(`resume|adding --continue flag for claude`);
+	} else if (cli === "gemini") {
+		cliArgs = ["--resume", ...cliArgs];
+		await logger.debug(`resume|adding --resume flag for gemini`);
+	} else throw new Error(`Resume option is not supported for cli: ${cli}, make a feature request if you want it. https://github.com/snomiao/agent-yes/issues`);
+	if (prompt && cliConf.promptArg) if (cliConf.promptArg === "first-arg") {
+		cliArgs = [prompt, ...cliArgs];
+		prompt = void 0;
+	} else if (cliConf.promptArg === "last-arg") {
+		cliArgs = [...cliArgs, prompt];
+		prompt = void 0;
+	} else if (cliConf.promptArg.startsWith("--")) {
+		cliArgs = [
+			cliConf.promptArg,
+			prompt,
+			...cliArgs
+		];
+		prompt = void 0;
+	} else logger.warn(`Unknown promptArg format: ${cliConf.promptArg}`);
+	const ptyEnv = { ...env ?? process.env };
+	const ptyOptions = {
+		name: "xterm-color",
+		...getTerminalDimensions(),
+		cwd: cwd ?? process.cwd(),
+		env: ptyEnv
+	};
+	let shell = spawnAgent({
+		cli,
+		cliConf,
+		cliArgs,
+		verbose,
+		install,
+		ptyOptions
+	});
+	try {
+		await pidStore.registerProcess({
+			pid: shell.pid,
+			cli,
+			args: cliArgs,
+			prompt,
+			cwd: workingDir
+		});
+	} catch (error) {
+		logger.warn(`[pidStore] Failed to register process ${shell.pid}:`, error);
+	}
+	notifyWebhook("RUNNING", prompt ?? "", workingDir).catch(() => null);
+	const logPaths = await initializeLogPaths(pidStore, shell.pid);
+	setupDebugLogging(logPaths.debuggingLogsPath);
+	const ctx = new AgentContext({
+		shell,
+		pidStore,
+		logPaths,
+		cli,
+		cliConf,
+		verbose,
+		robust,
+		autoYes
+	});
+	try {
+		globalAgentRegistry.register(shell.pid, {
+			pid: shell.pid,
+			context: ctx,
+			cwd: workingDir,
+			cli,
+			prompt,
+			startTime: Date.now(),
+			stdoutBuffer: []
+		});
+	} catch (error) {
+		logger.warn(`[agentRegistry] Failed to register agent ${shell.pid}:`, error);
+	}
+	if (!ctx.autoYesEnabled) process.stderr.write("\x1B[33m[auto-yes: OFF]\x1B[0m Press Ctrl+Y to toggle\n");
+	if (cliConf.ready && cliConf.ready.length === 0 || !ctx.autoYesEnabled) {
+		ctx.stdinReady.ready();
+		ctx.stdinFirstReady.ready();
+	}
+	sleep(1e4).then(() => {
+		if (!ctx.stdinReady.isReady) ctx.stdinReady.ready();
+		if (!ctx.stdinFirstReady.isReady) ctx.stdinFirstReady.ready();
+	});
+	const pendingExitCode = Promise.withResolvers();
+	function onData(data) {
+		const currentPid = shell.pid;
+		outputWriter.write(data);
+		globalAgentRegistry.appendStdout(currentPid, data);
+	}
+	shell.onData(onData);
+	shell.onExit(async function onExit({ exitCode }) {
+		const exitedPid = shell.pid;
+		globalAgentRegistry.unregister(exitedPid);
+		ctx.stdinReady.unready();
+		const agentCrashed = exitCode !== 0 && !(exitCode === 130 || exitCode === 143 || userSentCtrlC);
+		if (ctx.shouldRestartWithoutContinue) {
+			try {
+				await pidStore.updateStatus(exitedPid, "exited", {
+					exitReason: "restarted",
+					exitCode: exitCode ?? void 0
+				});
+			} catch (error) {
+				logger.warn(`[pidStore] Failed to update status for PID ${exitedPid}:`, error);
+			}
+			ctx.shouldRestartWithoutContinue = false;
+			ctx.isFatal = false;
+			let [bin, ...args] = [...parseCommandString(cliConf?.binary || cli), ...cliArgs.filter((arg) => !["--continue", "--resume"].includes(arg))];
+			logger.info(`Restarting ${cli} ${JSON.stringify([bin, ...args])}`);
+			const restartPtyOptions = {
+				name: "xterm-color",
+				...getTerminalDimensions(),
+				cwd: cwd ?? process.cwd(),
+				env: ptyEnv
+			};
+			shell = pty.spawn(bin, args, restartPtyOptions);
+			try {
+				await pidStore.registerProcess({
+					pid: shell.pid,
+					cli,
+					args,
+					prompt,
+					cwd: workingDir
+				});
+			} catch (error) {
+				logger.warn(`[pidStore] Failed to register restarted process ${shell.pid}:`, error);
+			}
+			ctx.shell = shell;
+			try {
+				globalAgentRegistry.register(shell.pid, {
+					pid: shell.pid,
+					context: ctx,
+					cwd: workingDir,
+					cli,
+					prompt,
+					startTime: Date.now(),
+					stdoutBuffer: []
+				});
+			} catch (error) {
+				logger.warn(`[agentRegistry] Failed to register restarted agent ${shell.pid}:`, error);
+			}
+			shell.onData(onData);
+			shell.onExit(onExit);
+			if (cliConf.ready && cliConf.ready.length === 0 || !ctx.autoYesEnabled) {
+				ctx.stdinReady.ready();
+				ctx.stdinFirstReady.ready();
+			}
+			return;
+		}
+		if (agentCrashed && robust && conf?.restoreArgs) {
+			if (!conf.restoreArgs) {
+				logger.warn(`robust is only supported for ${Object.entries(CLIS_CONFIG).filter(([_, v]) => v.restoreArgs).map(([k]) => k).join(", ")} currently, not ${cli}`);
+				return;
+			}
+			if (ctx.isFatal) {
+				try {
+					await pidStore.updateStatus(exitedPid, "exited", {
+						exitReason: "fatal",
+						exitCode: exitCode ?? void 0
+					});
+				} catch (error) {
+					logger.warn(`[pidStore] Failed to update status for PID ${exitedPid}:`, error);
+				}
+				notifyWebhook("EXIT", `fatal exitCode=${exitCode ?? "?"}`, workingDir).catch(() => null);
+				return pendingExitCode.resolve(exitCode);
+			}
+			try {
+				await pidStore.updateStatus(exitedPid, "exited", {
+					exitReason: "restarted",
+					exitCode: exitCode ?? void 0
+				});
+			} catch (error) {
+				logger.warn(`[pidStore] Failed to update status for PID ${exitedPid}:`, error);
+			}
+			logger.info(`${cli} crashed (exit code: ${exitCode}), restarting...`);
+			let restoreArgs = conf.restoreArgs;
+			if (cli === "codex") {
+				const storedSessionId = await getSessionForCwd(workingDir);
+				if (storedSessionId) {
+					restoreArgs = ["resume", storedSessionId];
+					logger.debug(`restore|using stored session ID: ${storedSessionId}`);
+				} else logger.debug(`restore|no stored session, using default restore args`);
+			}
+			const restorePtyOptions = {
+				name: "xterm-color",
+				...getTerminalDimensions(),
+				cwd: cwd ?? process.cwd(),
+				env: ptyEnv
+			};
+			shell = pty.spawn(cli, restoreArgs, restorePtyOptions);
+			try {
+				await pidStore.registerProcess({
+					pid: shell.pid,
+					cli,
+					args: restoreArgs,
+					prompt,
+					cwd: workingDir
+				});
+			} catch (error) {
+				logger.warn(`[pidStore] Failed to register restored process ${shell.pid}:`, error);
+			}
+			ctx.shell = shell;
+			try {
+				globalAgentRegistry.register(shell.pid, {
+					pid: shell.pid,
+					context: ctx,
+					cwd: workingDir,
+					cli,
+					prompt,
+					startTime: Date.now(),
+					stdoutBuffer: []
+				});
+			} catch (error) {
+				logger.warn(`[agentRegistry] Failed to register restored agent ${shell.pid}:`, error);
+			}
+			shell.onData(onData);
+			shell.onExit(onExit);
+			if (cliConf.ready && cliConf.ready.length === 0 || !ctx.autoYesEnabled) {
+				ctx.stdinReady.ready();
+				ctx.stdinFirstReady.ready();
+			}
+			return;
+		}
+		const exitReason = agentCrashed ? "crash" : "normal";
+		try {
+			await pidStore.updateStatus(exitedPid, "exited", {
+				exitReason,
+				exitCode: exitCode ?? void 0
+			});
+		} catch (error) {
+			logger.warn(`[pidStore] Failed to update status for PID ${exitedPid}:`, error);
+		}
+		notifyWebhook("EXIT", `${exitReason} exitCode=${exitCode ?? "?"}`, workingDir).catch(() => null);
+		return pendingExitCode.resolve(exitCode);
+	});
+	process.stdout.on("resize", () => {
+		const { cols, rows } = getTerminalDimensions();
+		shell.resize(cols, rows);
+	});
+	const isStillWorkingQ = () => {
+		const rendered = terminalRender.tail(24).replace(/\s+/g, " ");
+		return conf.working?.some((rgx) => rgx.test(rendered));
+	};
+	let lastHeartbeatRendered = "";
+	const heartbeatInterval = setInterval(async () => {
+		try {
+			const rendered = removeControlCharacters(terminalRender.tail(12));
+			if (rendered === lastHeartbeatRendered) return;
+			lastHeartbeatRendered = rendered;
+			const lines = rendered.split("\n").filter((line) => line.trim());
+			for (const line of lines) {
+				if (conf.ready?.some((rx) => rx.test(line))) {
+					logger.debug(`heartbeat|ready |${line}`);
+					ctx.stdinReady.ready();
+					ctx.stdinFirstReady.ready();
+				}
+				if (conf.enter?.some((rx) => rx.test(line))) {
+					logger.debug(`heartbeat|sendEnter matched|${line}`);
+					await sendEnter(ctx.messageContext, 400);
+					continue;
+				}
+				const typeingRespondMatched = Object.entries(conf.typingRespond ?? {}).filter(([_sendString, onThePatterns]) => onThePatterns.some((rx) => rx.test(line)));
+				if (typeingRespondMatched.length) {
+					await sflow(typeingRespondMatched).map(async ([sendString]) => await sendMessage(ctx.messageContext, sendString, { waitForReady: false })).toCount();
+					continue;
+				}
+				if (conf.fatal?.some((rx) => rx.test(line))) {
+					logger.debug(`heartbeat|fatal |${line}`);
+					ctx.isFatal = true;
+					await exitAgent();
+					break;
+				}
+				if (conf.restartWithoutContinueArg?.some((rx) => rx.test(line))) {
+					logger.debug(`heartbeat|restart-without-continue|${line}`);
+					ctx.shouldRestartWithoutContinue = true;
+					ctx.isFatal = true;
+					await exitAgent();
+					break;
+				}
+				if (cli === "codex") {
+					const sessionId = extractSessionId(line);
+					if (sessionId) {
+						logger.debug(`heartbeat|session|captured session ID: ${sessionId}`);
+						await storeSessionForCwd(workingDir, sessionId);
+					}
+				}
+			}
+		} catch (error) {
+			logger.debug(`heartbeat|error: ${error}`);
+		}
+	}, 800);
+	const cleanupHeartbeat = () => clearInterval(heartbeatInterval);
+	shell.onExit(cleanupHeartbeat);
+	if (exitOnIdle) ctx.idleWaiter.wait(exitOnIdle).then(async () => {
+		await pidStore.updateStatus(shell.pid, "idle").catch(() => null);
+		if (isStillWorkingQ()) {
+			logger.warn(`[${cli}-yes] ${cli} is idle, but seems still working, not exiting yet`);
+			return;
+		}
+		logger.info(`[${cli}-yes] ${cli} is idle, exiting...`);
+		notifyWebhook("IDLE", "", workingDir).catch(() => null);
+		await exitAgent();
+	});
+	const stdinStream = new ReadableStream({
+		start(controller) {
+			process.stdin.resume();
+			let closed = false;
+			const dataHandler = (chunk) => {
+				try {
+					controller.enqueue(chunk);
+				} catch {}
+			};
+			const endHandler = () => {
+				if (closed) return;
+				closed = true;
+				try {
+					controller.close();
+				} catch {}
+			};
+			const errorHandler = (err) => {
+				if (closed) return;
+				closed = true;
+				try {
+					controller.error(err);
+				} catch {}
+			};
+			process.stdin.on("data", dataHandler);
+			process.stdin.on("end", endHandler);
+			process.stdin.on("close", endHandler);
+			process.stdin.on("error", errorHandler);
+		},
+		cancel(reason) {
+			process.stdin.pause();
+		}
+	});
+	let aborted = false;
+	await sflow(stdinStream).map((buffer) => {
+		const str = buffer.toString();
+		const CTRL_Z = "";
+		const CTRL_C = "";
+		if (!aborted && str === CTRL_Z) return "";
+		if (!aborted && !ctx.stdinReady.isReady && str === CTRL_C) {
+			logger.error("User aborted: SIGINT");
+			shell.kill("SIGINT");
+			pendingExitCode.resolve(130);
+			aborted = true;
+			return str;
+		}
+		if (str === CTRL_C) {
+			userSentCtrlC = true;
+			setTimeout(() => {
+				userSentCtrlC = false;
+			}, 2e3);
+		}
+		return str;
+	}).map((() => {
+		let line = "";
+		const toggleAutoYes = () => {
+			ctx.autoYesEnabled = !ctx.autoYesEnabled;
+			if (!ctx.autoYesEnabled) {
+				ctx.stdinReady.ready();
+				ctx.stdinFirstReady.ready();
+			}
+			const status = ctx.autoYesEnabled ? "\x1B[32m[auto-yes: ON]\x1B[0m" : "\x1B[33m[auto-yes: OFF]\x1B[0m";
+			process.stderr.write(`\r${status} (Ctrl+Y to toggle)\n`);
+		};
+		return (data) => {
+			let out = "";
+			for (const ch of data) {
+				if (ch === "") {
+					toggleAutoYes();
+					continue;
+				}
+				if (ch === "\r" || ch === "\n") {
+					if (line.length <= 20) {
+						if (line.replace(/[\x00-\x1f]|\x1b\[[0-9;]*[A-Za-z]|\[[A-Z]/g, "").trim() === "/auto") {
+							out += "";
+							toggleAutoYes();
+							line = "";
+							continue;
+						}
+					}
+					line = "";
+					out += ch;
+					continue;
+				}
+				if (ch === "" || ch === "\b") {
+					if (line.length > 0) line = line.slice(0, -1);
+					out += ch;
+					continue;
+				}
+				if (ch >= " " && ch <= "~" && line.length < 50) line += ch;
+				out += ch;
+			}
+			return out;
+		};
+	})()).onStart(async function promptOnStart() {
+		logger.debug("Sending prompt message: " + JSON.stringify(prompt));
+		if (prompt) await sendMessage(ctx.messageContext, prompt);
+	}).by({
+		writable: new WritableStream({ write: async (data) => {
+			await ctx.stdinReady.wait();
+			shell.write(data);
+		} }),
+		readable: terminalStream.readable
+	}).forEach(() => {
+		ctx.idleWaiter.ping();
+		pidStore.updateStatus(shell.pid, "active").catch(() => null);
+		ctx.nextStdout.ready();
+	}).forkTo(async function rawLogger(f) {
+		const rawLogPath = ctx.logPaths.rawLogPath;
+		if (!rawLogPath) return f.run();
+		return await mkdir$1(path.dirname(rawLogPath), { recursive: true }).then(() => {
+			logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
+			return f.forEach(async (chars) => {
+				await writeFile$1(rawLogPath, chars, { flag: "a" }).catch(() => null);
+			}).run();
+		}).catch(() => f.run());
+	}).by(function consoleResponder(e) {
+		let lastRendered = "";
+		return e.forEach((chunk) => {
+			terminalRender.write(chunk);
+			if (chunk.includes("\x1B[c") || chunk.includes("\x1B[0c")) {
+				shell.write("\x1B[?1;2c");
+				if (verbose) logger.debug("device|respond DA: VT100 with Advanced Video Option");
+				return;
+			}
+			if (process.stdin.isTTY) return;
+			if (!chunk.includes("\x1B[6n")) return;
+			const { col, row } = terminalRender.getCursorPosition();
+			shell.write(`\u001b[${row};${col}R`);
+			logger.debug(`cursor|respond position: row=${String(row)}, col=${String(col)}`);
+		}).forEach(async (line, lineIndex) => {
+			if (terminalRender.tail(24) === lastRendered) return;
+			logger.debug(`stdout|${line}`);
+			if (conf.ready?.some((rx) => line.match(rx))) {
+				logger.debug(`ready |${line}`);
+				if (cli === "gemini" && lineIndex <= 80) return;
+				ctx.stdinReady.ready();
+				ctx.stdinFirstReady.ready();
+			}
+			if (conf.enter?.some((rx) => line.match(rx))) {
+				logger.debug(`sendEnter matched|${line}`);
+				return await sendEnter(ctx.messageContext, 400);
+			}
+			const typeingRespondMatched = Object.entries(conf.typingRespond ?? {}).filter(([_sendString, onThePatterns]) => onThePatterns.some((rx) => line.match(rx)));
+			if (typeingRespondMatched.length && await sflow(typeingRespondMatched).map(async ([sendString]) => await sendMessage(ctx.messageContext, sendString, { waitForReady: false })).toCount()) return;
+			if (conf.fatal?.some((rx) => line.match(rx))) {
+				logger.debug(`fatal |${line}`);
+				ctx.isFatal = true;
+				await exitAgent();
+			}
+			if (conf.restartWithoutContinueArg?.some((rx) => line.match(rx))) {
+				logger.debug(`restart-without-continue|${line}`);
+				ctx.shouldRestartWithoutContinue = true;
+				ctx.isFatal = true;
+				await exitAgent();
+			}
+			if (cli === "codex") {
+				const sessionId = extractSessionId(line);
+				if (sessionId) {
+					logger.debug(`session|captured session ID: ${sessionId}`);
+					await storeSessionForCwd(workingDir, sessionId);
+				}
+			}
+		});
+	}).by((s) => removeControlCharactersFromStdout ? s.map((e) => removeControlCharacters(e)) : s).by(createTerminatorStream(pendingExitCode.promise)).to(fromWritable(process.stdout));
+	await saveLogFile(ctx.logPaths.logPath, terminalRender.render());
+	const exitCode = await pendingExitCode.promise;
+	logger.info(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
+	await pidStore.close();
+	await outputWriter.close();
+	await saveDeprecatedLogFile(logFile, terminalRender.render(), verbose);
+	return {
+		exitCode,
+		logs: terminalRender.render()
+	};
+	async function exitAgent() {
+		ctx.robust = false;
+		for (const cmd of cliConf.exitCommands ?? ["/exit"]) await sendMessage(ctx.messageContext, cmd);
+		let exited = false;
+		await Promise.race([pendingExitCode.promise.then(() => exited = true), new Promise((resolve) => setTimeout(() => {
+			if (exited) return;
+			shell.kill();
+			resolve();
+		}, 5e3))]);
+	}
+	function getTerminalDimensions() {
+		if (!process.stdout.isTTY) return {
+			cols: 80,
+			rows: 24
+		};
+		return {
+			cols: Math.max(20, process.stdout.columns),
+			rows: process.stdout.rows
+		};
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region ts/SUPPORTED_CLIS.ts
+const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
+
+//#endregion
+export { AgentContext as a, PidStore as c, config as i, removeControlCharacters as l, CLIS_CONFIG as n, name as o, agentYes as r, version as s, SUPPORTED_CLIS as t };
+//# sourceMappingURL=SUPPORTED_CLIS-TKiMwx-X.js.map