agent-yes 1.72.4 → 1.73.2

package/dist/cli.js

@@ -1,23 +1,22 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bqw9gxey.js";
-import { t as logger } from "./logger-CX77vJDA.js";
+import { n as logger } from "./logger-B9h0djqx.js";
+import { n as version, t as name } from "./package-DpfHTSW2.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { execaCommand } from "execa";
+import { existsSync, lstatSync, mkdirSync, readlinkSync, unlinkSync } from "fs";
 import { chmod, copyFile, mkdir, readFile, writeFile } from "fs/promises";
-import path from "path";
 import { homedir } from "os";
-import { existsSync, mkdirSync, unlinkSync } from "fs";
+import path from "path";
 
 //#region ts/parseCliArgs.ts
 /**
 * Parse CLI arguments the same way cli.ts does
 * This is a test helper that mirrors the parsing logic in cli.ts
 */
-function parseCliArgs(argv) {
+function parseCliArgs(argv, supportedClis) {
 	const scriptBaseName = argv[1]?.split(/[/\\]/).at(-1)?.replace(/(\.[jt]s)?$/, "") || "";
 	const CLI_ALIASES = { cy: "claude" };
 	const cliName = (() => {
@@ -129,7 +128,7 @@ function parseCliArgs(argv) {
 	}).positional("cli", {
 		describe: "The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini",
 		type: "string",
-		choices: SUPPORTED_CLIS,
+		choices: supportedClis,
 		demandOption: false,
 		default: cliName
 	}).help().version(false).option("version", {
@@ -156,26 +155,53 @@ function parseCliArgs(argv) {
 			if (key === "continue") yargsConsumed.add("-c");
 		}
 	});
+	const positionalPromptWords = [];
 	const cliArgsForSpawn = (() => {
-		if (parsedArgv._[0] && !cliName) return rawArgs.slice((cliArgIndex ?? 0) + 1, dashIndex ?? void 0);
-		else if (cliName) {
+		if (parsedArgv._[0] && !cliName) {
+			const allAfterCli = rawArgs.slice((cliArgIndex ?? 0) + 1, dashIndex ?? void 0);
+			const result = [];
+			for (let i = 0; i < allAfterCli.length; i++) {
+				const arg = allAfterCli[i];
+				if (arg.startsWith("-")) {
+					result.push(arg);
+					if (!arg.includes("=") && i + 1 < allAfterCli.length) {
+						const nextArg = allAfterCli[i + 1];
+						if (nextArg && !nextArg.startsWith("-")) {
+							result.push(nextArg);
+							i++;
+						}
+					}
+				} else positionalPromptWords.push(arg);
+			}
+			return result;
+		} else if (cliName) {
 			const result = [];
 			const argsToCheck = rawArgs.slice(0, dashIndex ?? void 0);
 			for (let i = 0; i < argsToCheck.length; i++) {
 				const arg = argsToCheck[i];
 				if (!arg) continue;
 				const [flag] = arg.split("=");
-				if (flag && yargsConsumed.has(flag)) {
+				if (flag && yargsConsumed.has(flag) || flag?.startsWith("--no-") && yargsConsumed.has(`--${flag.slice(5)}`)) {
 					if (!arg.includes("=") && i + 1 < argsToCheck.length) {
 						const nextArg = argsToCheck[i + 1];
 						if (nextArg && !nextArg.startsWith("-")) i++;
 					}
-				} else result.push(arg);
+				} else if (arg.startsWith("-")) {
+					result.push(arg);
+					if (!arg.includes("=") && i + 1 < argsToCheck.length) {
+						const nextArg = argsToCheck[i + 1];
+						if (nextArg && !nextArg.startsWith("-")) {
+							result.push(nextArg);
+							i++;
+						}
+					}
+				} else positionalPromptWords.push(arg);
 			}
 			return result;
 		}
 		return [];
 	})();
+	const positionalPrompt = positionalPromptWords.join(" ") || void 0;
 	const dashPrompt = dashIndex === void 0 ? void 0 : rawArgs.slice(dashIndex + 1).join(" ");
 	if (parsedArgv.exitOnIdle !== void 0) console.warn("\x1B[33m⚠ Warning: --exit-on-idle and -e are deprecated. Please use --timeout instead.\x1B[0m");
 	return {
@@ -183,7 +209,11 @@ function parseCliArgs(argv) {
 		env: process.env,
 		cli: cliName || parsedArgv.cli || (dashIndex !== 0 ? parsedArgv._[0]?.toString()?.replace?.(/-yes$/, "") : void 0),
 		cliArgs: [...cliArgsForSpawn, ...parsedArgv.yes ? ["--dangerously-skip-permissions"] : []],
-		prompt: [parsedArgv.prompt, dashPrompt].filter(Boolean).join(" ") || void 0,
+		prompt: [
+			parsedArgv.prompt,
+			positionalPrompt,
+			dashPrompt
+		].filter(Boolean).join(" ") || void 0,
 		install: parsedArgv.install,
 		exitOnIdle: Number((parsedArgv.timeout || parsedArgv.idle || parsedArgv.exitOnIdle)?.replace(/.*/, (e) => String(ms(e))) || 0),
 		queue: parsedArgv.queue,
@@ -242,7 +272,12 @@ function detectPackageManager() {
 */
 async function checkAndAutoUpdate() {
 	if (process.env.AGENT_YES_NO_UPDATE) return;
-	if (process.env.AGENT_YES_UPDATED === version) return;
+	if (process.env.AGENT_YES_UPDATED) return;
+	if (import.meta.url.startsWith("file://") && !import.meta.url.includes("node_modules")) {
+		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+		const repoRoot = path.resolve(scriptDir, "..");
+		if (existsSync(path.join(repoRoot, ".git"))) return;
+	}
 	try {
 		let latestVersion;
 		const cache = await readUpdateCache();
@@ -265,6 +300,7 @@ async function runInstall(latestVersion) {
 	const installCmd = detectPackageManager() === "bun" ? `bun add -g agent-yes@${latestVersion}` : `npm install -g agent-yes@${latestVersion}`;
 	process.stderr.write(`\x1b[33m[agent-yes] Updating ${version} → ${latestVersion}…\x1b[0m\n`);
 	try {
+		const { execaCommand } = await import("execa");
 		await execaCommand(installCmd, { stdio: "inherit" });
 		process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
 		return true;
@@ -321,10 +357,47 @@ function compareVersions(v1, v2) {
 	return 0;
 }
 /**
+* Detect how agent-yes was installed.
+* Returns a short label: "git", "bun link", "bun", "npm", "npx", or "unknown"
+*/
+function detectInstallMethod() {
+	try {
+		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+		if (!scriptDir.includes("node_modules")) {
+			const repoRoot = path.resolve(scriptDir, "..");
+			if (existsSync(path.join(repoRoot, ".git"))) return "git";
+			return "source";
+		}
+		const nodeModulesEntry = scriptDir.replace(/\/dist$/, "");
+		try {
+			if (lstatSync(nodeModulesEntry).isSymbolicLink()) {
+				const target = readlinkSync(nodeModulesEntry);
+				const resolvedTarget = path.resolve(path.dirname(nodeModulesEntry), target);
+				if (existsSync(path.join(resolvedTarget, ".git"))) return "bun link (git)";
+				return "bun link";
+			}
+		} catch {}
+		if (scriptDir.includes(".bun/")) return "bun";
+		if (scriptDir.includes(".npm/")) return "npx";
+		if (process.env.npm_execpath?.includes("bun")) return "bun";
+		if (process.env.npm_config_user_agent?.startsWith("bun")) return "bun";
+		if (process.env.npm_config_user_agent?.startsWith("npm")) return "npm";
+		return "npm";
+	} catch {
+		return "unknown";
+	}
+}
+/**
+* Format version string with install method
+*/
+function versionString() {
+	return `agent-yes v${version} (${detectInstallMethod()})`;
+}
+/**
 * Display version information with async latest version check
 */
 async function displayVersion() {
-	console.log(version);
+	console.log(versionString());
 	const latestVersion = await fetchLatestVersion();
 	if (latestVersion) {
 		const comparison = compareVersions(version, latestVersion);
@@ -466,6 +539,53 @@ async function downloadBinary(verbose = false) {
 	return binaryPath;
 }
 /**
+* Get the version of a Rust binary by running it with --version
+*/
+function getRustBinaryVersion(binaryPath) {
+	try {
+		const match = execFileSync(binaryPath, ["--version"], {
+			timeout: 5e3,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).match(/(\d+\.\d+\.\d+)/);
+		return match ? match[1] : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Check if a binary path is inside a git repo (dev build), and rebuild if outdated.
+* Returns the same path if up-to-date or rebuilt, undefined if rebuild failed.
+*/
+function autoRebuildIfOutdated(binaryPath, verbose) {
+	if (!binaryPath.includes("/target/release") && !binaryPath.includes("/target/debug")) return true;
+	const binaryVersion = getRustBinaryVersion(binaryPath);
+	if (verbose) console.log(`[rust] Binary version: ${binaryVersion}, package version: ${version}`);
+	if (binaryVersion === version) return true;
+	const rsDir = binaryPath.replace(/\/target\/(release|debug)\/agent-yes.*$/, "");
+	if (!existsSync(path.join(rsDir, "Cargo.toml"))) {
+		if (verbose) console.log(`[rust] Cannot find Cargo.toml at ${rsDir}, skipping rebuild`);
+		return true;
+	}
+	process.stderr.write(`\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${version}), rebuilding…\x1b[0m\n`);
+	try {
+		execFileSync("cargo", ["build", ...binaryPath.includes("/target/release") ? ["--release"] : []], {
+			cwd: rsDir,
+			stdio: "inherit",
+			timeout: 3e5
+		});
+		process.stderr.write(`\x1b[32m[rust] Rebuild complete\x1b[0m\n`);
+		return true;
+	} catch {
+		process.stderr.write(`\x1b[31m[rust] Auto-rebuild failed, using outdated binary\x1b[0m\n`);
+		return true;
+	}
+}
+/**
 * Get or download the Rust binary
 */
 async function getRustBinary(options = {}) {
@@ -474,6 +594,7 @@ async function getRustBinary(options = {}) {
 		const existing = findRustBinary(verbose);
 		if (existing) {
 			if (verbose) console.log(`[rust] Using existing binary: ${existing}`);
+			autoRebuildIfOutdated(existing, verbose);
 			return existing;
 		}
 	}
@@ -506,15 +627,23 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 
 //#endregion
 //#region ts/cli.ts
+{
+	const rawArgs = process.argv.slice(2);
+	if (rawArgs[0] === "-v" || rawArgs.includes("--version")) {
+		console.log(versionString());
+		process.exit(0);
+	}
+}
 await checkAndAutoUpdate();
+logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-CPpdxTV-.js");
+	const { startTray } = await import("./tray-Bzb1owBN.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-CPpdxTV-.js");
+	const { ensureTray } = await import("./tray-Bzb1owBN.js");
 	ensureTray();
 }
 if (config.useRust) {
@@ -528,6 +657,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-C7sGMdKJ.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);
@@ -557,6 +687,7 @@ if (config.showVersion) {
 	process.exit(0);
 }
 if (config.appendPrompt) {
+	const { PidStore } = await import("./pidStore-B4yDm3TL.js");
 	const ipcPath = await PidStore.findActiveFifo(process.cwd());
 	if (!ipcPath) {
 		console.error("No active agent with IPC found in current directory.");

package/dist/index.js

@@ -1,4 +1,5 @@
-import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-Bqw9gxey.js";
-import "./logger-CX77vJDA.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-CsdLrLod.js";
+import "./logger-B9h0djqx.js";
+import "./pidStore-CPrgJSJi.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/dist/logger-B9h0djqx.js

@@ -0,0 +1,51 @@
+//#region ts/logger.ts
+let _inner = null;
+let _initPromise = null;
+const _queue = [];
+function init() {
+	if (_initPromise) return _initPromise;
+	_initPromise = import("winston").then(({ default: winston }) => {
+		const logFormat = winston.format.combine(winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+			return `${timestamp} [${level}]: ${message}${Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : ""}`;
+		}));
+		_inner = winston.createLogger({
+			level: process.env.VERBOSE ? "debug" : "info",
+			format: logFormat,
+			transports: [new winston.transports.Console({ format: winston.format.combine(winston.format.colorize(), logFormat) })],
+			silent: false
+		});
+		for (const { level, msg, meta } of _queue.splice(0)) _inner[level](msg, ...meta);
+	});
+	return _initPromise;
+}
+function makeMethod(level) {
+	return (msg, ...meta) => {
+		if (_inner) _inner[level](msg, ...meta);
+		else {
+			_queue.push({
+				level,
+				msg,
+				meta
+			});
+			init().catch((e) => console.error("[logger] Failed to load winston:", e));
+		}
+	};
+}
+/** Add a winston transport. Awaits logger initialization first. */
+async function addTransport(transport) {
+	await init();
+	_inner.add(transport);
+}
+const logger = {
+	error: makeMethod("error"),
+	warn: makeMethod("warn"),
+	info: makeMethod("info"),
+	http: makeMethod("http"),
+	verbose: makeMethod("verbose"),
+	debug: makeMethod("debug"),
+	silly: makeMethod("silly")
+};
+
+//#endregion
+export { logger as n, addTransport as t };
+//# sourceMappingURL=logger-B9h0djqx.js.map

package/dist/package-DpfHTSW2.js

@@ -0,0 +1,7 @@
+//#region package.json
+var name = "agent-yes";
+var version = "1.73.1";
+
+//#endregion
+export { version as n, name as t };
+//# sourceMappingURL=package-DpfHTSW2.js.map

package/dist/pidStore-B4yDm3TL.js

@@ -0,0 +1,4 @@
+import "./logger-B9h0djqx.js";
+import { t as PidStore } from "./pidStore-CPrgJSJi.js";
+
+export { PidStore };

package/dist/pidStore-CPrgJSJi.js

@@ -0,0 +1,319 @@
+import { n as logger } from "./logger-B9h0djqx.js";
+import { closeSync, existsSync, fsyncSync, openSync } from "fs";
+import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
+import path from "path";
+import { lock } from "proper-lockfile";
+
+//#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;
+	docs = /* @__PURE__ */ new Map();
+	constructor(filePath) {
+		this.filePath = filePath;
+		this.tempPath = 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(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(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() {
+		const lines = Array.from(this.docs.values()).map((doc) => {
+			const { _id, $$deleted: _$$deleted, ...rest } = doc;
+			return JSON.stringify({
+				_id,
+				...rest
+			});
+		}).join("\n");
+		const content = lines ? lines + "\n" : "";
+		try {
+			await this.withLock(async () => {
+				await writeFile(this.tempPath, content);
+				const fd = openSync(this.tempPath, "r");
+				fsyncSync(fd);
+				closeSync(fd);
+				await rename(this.tempPath, this.filePath);
+			});
+		} catch {
+			await writeFile(this.filePath, content);
+		}
+	}
+	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(this.storeDir, { recursive: true });
+			await writeFile(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
+export { PidStore as t };
+//# sourceMappingURL=pidStore-CPrgJSJi.js.map

package/dist/{runningLock-BBI_URhR.js → runningLock-DQWJSptq.js}

@@ -1,8 +1,8 @@
 import { execSync } from "child_process";
+import { existsSync } from "fs";
 import { mkdir, readFile, rename, writeFile } from "fs/promises";
-import path from "path";
 import { homedir } from "os";
-import { existsSync } from "fs";
+import path from "path";
 
 //#region ts/runningLock.ts
 const getLockDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
@@ -260,4 +260,4 @@ function shouldUseLock(_cwd) {
 
 //#endregion
 export { shouldUseLock as i, getRunningAgentCount as n, releaseLock as r, acquireLock as t };
-//# sourceMappingURL=runningLock-BBI_URhR.js.map
+//# sourceMappingURL=runningLock-DQWJSptq.js.map