agent-yes 1.73.0 → 1.74.0

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-Bn0B_jWZ.js

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

package/dist/pidStore-CHLHMBEM.js

@@ -0,0 +1,340 @@
+import { n as logger } from "./logger-B9h0djqx.js";
+import { r as updateGlobalPidStatus, t as appendGlobalPid } from "./globalPidIndex-DNEh8a_O.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 argsJson = JSON.stringify(args);
+		const logFile = path.resolve(this.getLogDir(), `${pid}.log`);
+		const fifoFile = this.getFifoPath(pid);
+		const record = {
+			pid,
+			cli,
+			args: argsJson,
+			prompt,
+			cwd,
+			logFile,
+			fifoFile,
+			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}`);
+		appendGlobalPid({
+			pid,
+			cli,
+			prompt: prompt ?? null,
+			cwd,
+			log_file: logFile,
+			fifo_file: fifoFile,
+			status: "active",
+			exit_code: null,
+			exit_reason: null,
+			started_at: now
+		}).catch(() => null);
+		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}`);
+		updateGlobalPidStatus(pid, {
+			status,
+			exit_code: extra?.exitCode ?? null,
+			exit_reason: extra?.exitReason ?? null
+		}).catch(() => null);
+	}
+	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-CHLHMBEM.js.map

package/dist/pidStore-DR1yPY3t.js

@@ -0,0 +1,5 @@
+import "./logger-B9h0djqx.js";
+import { t as PidStore } from "./pidStore-CHLHMBEM.js";
+import "./globalPidIndex-DNEh8a_O.js";
+
+export { PidStore };

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