agent-yes 1.70.1 → 1.72.0

package/dist/tray-Dyiihcrq.js

@@ -0,0 +1,180 @@
+import { n as getRunningAgentCount } from "./runningLock-BBI_URhR.js";
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
+import path from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+
+//#region ts/tray.ts
+const POLL_INTERVAL = 2e3;
+const getTrayDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
+const getTrayPidFile = () => path.join(getTrayDir(), "tray.pid");
+const ICON_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAjklEQVQ4T2NkoBAwUqifgWoGMDIyNjAyMv5nYGBYQMgVjMgCQM0LGBkZHYDYAY8BDUBxByB2wGcAyAUOQOwAxPYMDAyOeCzAbwBIMyMjowNQsz0ely8ACjng8wJeA0CaGRgY7IHYAZ8hQHEHfF7AawBYMwODPZABRHsBpwEgzUDN9kDsgM8lQHEHfC4gJhwAAM3hMBGq3cNNAAAAAElFTkSuQmCC";
+function buildMenuItems(tasks) {
+	const items = [];
+	if (tasks.length === 0) items.push({
+		title: "No running agents",
+		tooltip: "",
+		enabled: false
+	});
+	else {
+		items.push({
+			title: `Running agents: ${tasks.length}`,
+			tooltip: "",
+			enabled: false
+		});
+		items.push({
+			title: "---",
+			tooltip: "",
+			enabled: false
+		});
+		for (const task of tasks) {
+			const dir = task.cwd.replace(/^.*[/\\]/, "");
+			const desc = task.task ? ` - ${task.task.slice(0, 40)}` : "";
+			items.push({
+				title: `[${task.pid}] ${dir}${desc}`,
+				tooltip: task.cwd,
+				enabled: false
+			});
+		}
+	}
+	items.push({
+		title: "---",
+		tooltip: "",
+		enabled: false
+	});
+	items.push({
+		title: "Quit Tray",
+		tooltip: "Exit tray icon",
+		enabled: true
+	});
+	return items;
+}
+function isDesktopOS() {
+	return process.platform === "darwin" || process.platform === "win32";
+}
+function isTrayProcessRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Write the current process PID to the tray PID file
+*/
+async function writeTrayPid() {
+	await mkdir(getTrayDir(), { recursive: true });
+	await writeFile(getTrayPidFile(), String(process.pid), "utf8");
+}
+/**
+* Remove the tray PID file
+*/
+async function removeTrayPid() {
+	try {
+		await unlink(getTrayPidFile());
+	} catch {}
+}
+/**
+* Check if a tray process is already running
+*/
+async function isTrayRunning() {
+	try {
+		const pidFile = getTrayPidFile();
+		if (!existsSync(pidFile)) return false;
+		const pid = parseInt(await readFile(pidFile, "utf8"), 10);
+		if (isNaN(pid)) return false;
+		return isTrayProcessRunning(pid);
+	} catch {
+		return false;
+	}
+}
+/**
+* Auto-spawn a tray process in the background if not already running.
+* Only spawns on desktop OS (macOS/Windows).
+* Silently does nothing if systray2 is not installed or on non-desktop OS.
+*/
+async function ensureTray() {
+	if (!isDesktopOS()) return;
+	if (await isTrayRunning()) return;
+	try {
+		const cliPath = new URL("./cli.ts", import.meta.url).pathname;
+		const { spawn } = await import("child_process");
+		spawn(process.execPath, [
+			cliPath,
+			"--tray",
+			"--no-rust"
+		], {
+			detached: true,
+			stdio: "ignore",
+			env: { ...process.env }
+		}).unref();
+	} catch {}
+}
+async function startTray() {
+	if (!isDesktopOS()) {
+		console.error("Tray icon is only supported on macOS and Windows.");
+		return;
+	}
+	if (await isTrayRunning()) {
+		console.error("Tray is already running.");
+		return;
+	}
+	await writeTrayPid();
+	let SysTray;
+	try {
+		SysTray = (await import("systray2")).default;
+	} catch {
+		await removeTrayPid();
+		console.error("systray2 is not installed. Install it with: npm install systray2");
+		return;
+	}
+	const { count, tasks } = await getRunningAgentCount();
+	const systray = new SysTray({
+		menu: {
+			icon: ICON_BASE64,
+			title: `AY: ${count}`,
+			tooltip: `agent-yes: ${count} running`,
+			items: buildMenuItems(tasks)
+		},
+		debug: false,
+		copyDir: false
+	});
+	await systray.ready();
+	console.log(`Tray started. Watching ${count} running agent(s).`);
+	systray.onClick((action) => {
+		if (action.item.title === "Quit Tray") {
+			systray.kill(false);
+			removeTrayPid().finally(() => process.exit(0));
+		}
+	});
+	let lastCount = count;
+	const interval = setInterval(async () => {
+		try {
+			const { count: newCount, tasks: newTasks } = await getRunningAgentCount();
+			if (newCount !== lastCount) {
+				lastCount = newCount;
+				systray.sendAction({
+					type: "update-menu",
+					menu: {
+						icon: ICON_BASE64,
+						title: `AY: ${newCount}`,
+						tooltip: `agent-yes: ${newCount} running`,
+						items: buildMenuItems(newTasks)
+					}
+				});
+			}
+		} catch {}
+	}, POLL_INTERVAL);
+	const cleanup = () => {
+		clearInterval(interval);
+		systray.kill(false);
+		removeTrayPid().finally(() => process.exit(0));
+	};
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+}
+
+//#endregion
+export { ensureTray, startTray };
+//# sourceMappingURL=tray-Dyiihcrq.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.70.1",
+  "version": "1.72.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -130,6 +130,9 @@
       "optional": true
     }
   },
+  "optionalDependencies": {
+    "systray2": "^2.1.4"
+  },
   "engines": {
     "node": ">=22.0.0"
   },

package/ts/cli.ts

@@ -15,6 +15,13 @@ const updateCheckPromise = checkAndAutoUpdate();
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
 
+// Handle --tray: show system tray icon and block
+if (config.tray) {
+  const { startTray } = await import("./tray.ts");
+  await startTray();
+  await new Promise(() => {}); // Block forever, exit via tray quit or signal
+}
+
 // Handle --rust: spawn the Rust binary instead, fall back to TypeScript if unavailable
 if (config.useRust) {
   let rustBinary: string | undefined;
@@ -135,6 +142,12 @@ if (config.verbose) {
   console.log(argv);
 }
 
+// Auto-spawn tray icon in background on desktop OS (best-effort, silent failure)
+{
+  const { ensureTray } = await import("./tray.ts");
+  ensureTray(); // fire-and-forget, don't await
+}
+
 const { default: cliYes } = await import("./index.ts");
 const { exitCode } = await cliYes({ ...config, autoYes: config.autoYes });
 

package/ts/parseCliArgs.ts

@@ -126,6 +126,11 @@ export function parseCliArgs(argv: string[]) {
       default: false,
       alias: "y",
     })
+    .option("tray", {
+      type: "boolean",
+      description: "Show a system tray icon with running agent count (macOS/Windows only)",
+      default: false,
+    })
     .option("rust", {
       type: "boolean",
       description: "Use the Rust implementation (enabled by default, use --no-rust for TypeScript)",
@@ -275,6 +280,7 @@ export function parseCliArgs(argv: string[]) {
     showVersion: parsedArgv.version,
     autoYes: parsedArgv.auto !== "no", // auto-yes enabled by default, disabled with --auto=no
     idleAction: parsedArgv.idleAction as string | undefined,
+    tray: parsedArgv.tray,
     useRust: parsedArgv.rust,
     // New unified --swarm flag (takes precedence over deprecated flags)
     swarm: parsedArgv.swarm ?? (parsedArgv.experimentalSwarm ? parsedArgv.swarmTopic : undefined),

package/ts/runningLock.ts

@@ -286,6 +286,20 @@ async function waitForUnlock(blockingTasks: Task[], currentTask: Task): Promise<
   if (!wasRaw) stdin.pause();
 }
 
+/**
+ * Read the current lock file (exported for tray and other consumers)
+ */
+export { readLockFile };
+
+/**
+ * Get the count of currently running agents
+ */
+export async function getRunningAgentCount(): Promise<{ count: number; tasks: Task[] }> {
+  const lockFile = await readLockFile();
+  const running = lockFile.tasks.filter((t) => t.status === "running");
+  return { count: running.length, tasks: running };
+}
+
 /**
  * Clean stale locks from the lock file
  */

package/ts/tray.spec.ts

@@ -0,0 +1,340 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock systray2 before imports
+const mockSysTray = vi.hoisted(() => {
+  const instance = {
+    ready: vi.fn().mockResolvedValue(undefined),
+    onClick: vi.fn(),
+    sendAction: vi.fn(),
+    kill: vi.fn(),
+  };
+  const MockClass = vi.fn().mockImplementation(function (this: any) {
+    Object.assign(this, instance);
+    return this;
+  }) as any;
+  return {
+    instance,
+    MockClass,
+  };
+});
+
+vi.mock("systray2", () => ({
+  default: mockSysTray.MockClass,
+}));
+
+// Mock runningLock
+const mockGetRunningAgentCount = vi.hoisted(() =>
+  vi.fn().mockResolvedValue({ count: 0, tasks: [] }),
+);
+
+vi.mock("./runningLock.ts", () => ({
+  getRunningAgentCount: mockGetRunningAgentCount,
+}));
+
+// Mock fs for PID file operations
+const mockFs = vi.hoisted(() => ({
+  existsSync: vi.fn().mockReturnValue(false),
+}));
+const mockFsPromises = vi.hoisted(() => ({
+  mkdir: vi.fn().mockResolvedValue(undefined),
+  readFile: vi.fn().mockResolvedValue(""),
+  writeFile: vi.fn().mockResolvedValue(undefined),
+  unlink: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("fs", () => ({ existsSync: mockFs.existsSync }));
+vi.mock("fs/promises", () => mockFsPromises);
+
+// Mock child_process for ensureTray
+const mockSpawn = vi.hoisted(() => {
+  const child = { unref: vi.fn() };
+  return { spawn: vi.fn().mockReturnValue(child), child };
+});
+
+vi.mock("child_process", () => ({ spawn: mockSpawn.spawn }));
+
+describe("tray", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
+    mockFs.existsSync.mockReturnValue(false);
+  });
+
+  describe("startTray", () => {
+    it("should create a systray instance on macOS", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      expect(mockSysTray.MockClass).toHaveBeenCalledWith(
+        expect.objectContaining({
+          menu: expect.objectContaining({
+            title: "AY: 0",
+            tooltip: "agent-yes: 0 running",
+          }),
+        }),
+      );
+      expect(mockSysTray.instance.ready).toHaveBeenCalled();
+      expect(mockSysTray.instance.onClick).toHaveBeenCalled();
+      // Should write PID file
+      expect(mockFsPromises.writeFile).toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should show running agent count and task details", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      mockGetRunningAgentCount.mockResolvedValue({
+        count: 2,
+        tasks: [
+          {
+            pid: 1234,
+            cwd: "/home/user/project-a",
+            task: "fix bugs",
+            status: "running",
+            startedAt: Date.now(),
+            lockedAt: Date.now(),
+          },
+          {
+            pid: 5678,
+            cwd: "/home/user/project-b",
+            task: "add tests",
+            status: "running",
+            startedAt: Date.now(),
+            lockedAt: Date.now(),
+          },
+        ],
+      });
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      const menuArg = mockSysTray.MockClass.mock.calls[0][0];
+      expect(menuArg.menu.title).toBe("AY: 2");
+      expect(menuArg.menu.tooltip).toBe("agent-yes: 2 running");
+
+      const items = menuArg.menu.items;
+      expect(items[0].title).toBe("Running agents: 2");
+      expect(items[2].title).toContain("[1234]");
+      expect(items[2].title).toContain("project-a");
+      expect(items[3].title).toContain("[5678]");
+      expect(items[3].title).toContain("project-b");
+      expect(items[items.length - 1].title).toBe("Quit Tray");
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should handle quit menu click", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      const mockExit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      const onClickCb = mockSysTray.instance.onClick.mock.calls[0][0];
+      onClickCb({ item: { title: "Quit Tray" } });
+
+      expect(mockSysTray.instance.kill).toHaveBeenCalledWith(false);
+      // removeTrayPid is called (unlink)
+      await vi.waitFor(() => expect(mockExit).toHaveBeenCalledWith(0));
+
+      mockExit.mockRestore();
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should update tray when agent count changes", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      vi.useFakeTimers();
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      mockGetRunningAgentCount.mockResolvedValue({
+        count: 3,
+        tasks: [
+          {
+            pid: 111,
+            cwd: "/a",
+            task: "t1",
+            status: "running" as const,
+            startedAt: 0,
+            lockedAt: 0,
+          },
+          {
+            pid: 222,
+            cwd: "/b",
+            task: "t2",
+            status: "running" as const,
+            startedAt: 0,
+            lockedAt: 0,
+          },
+          {
+            pid: 333,
+            cwd: "/c",
+            task: "t3",
+            status: "running" as const,
+            startedAt: 0,
+            lockedAt: 0,
+          },
+        ],
+      });
+
+      await vi.advanceTimersByTimeAsync(2100);
+
+      expect(mockSysTray.instance.sendAction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "update-menu",
+          menu: expect.objectContaining({ title: "AY: 3" }),
+        }),
+      );
+
+      vi.useRealTimers();
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should not update tray when agent count stays the same", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      vi.useFakeTimers();
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
+      await vi.advanceTimersByTimeAsync(2100);
+
+      expect(mockSysTray.instance.sendAction).not.toHaveBeenCalled();
+
+      vi.useRealTimers();
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should work on Windows", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      expect(mockSysTray.MockClass).toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should skip on Linux", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "linux" });
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      expect(mockSysTray.MockClass).not.toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should skip if tray already running", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      // Simulate existing tray PID file with a live process (our own PID)
+      mockFs.existsSync.mockReturnValue(true);
+      mockFsPromises.readFile.mockResolvedValue(String(process.pid));
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      // Should NOT create systray because one is already running
+      expect(mockSysTray.MockClass).not.toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+  });
+
+  describe("isTrayRunning", () => {
+    it("should return false when no PID file exists", async () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const { isTrayRunning } = await import("./tray.ts");
+      expect(await isTrayRunning()).toBe(false);
+    });
+
+    it("should return false when PID file has invalid content", async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFsPromises.readFile.mockResolvedValue("not-a-number");
+
+      const { isTrayRunning } = await import("./tray.ts");
+      expect(await isTrayRunning()).toBe(false);
+    });
+
+    it("should return true when PID file points to a running process", async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFsPromises.readFile.mockResolvedValue(String(process.pid));
+
+      const { isTrayRunning } = await import("./tray.ts");
+      expect(await isTrayRunning()).toBe(true);
+    });
+
+    it("should return false when PID file points to a dead process", async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFsPromises.readFile.mockResolvedValue("999999999");
+
+      const { isTrayRunning } = await import("./tray.ts");
+      expect(await isTrayRunning()).toBe(false);
+    });
+  });
+
+  describe("ensureTray", () => {
+    it("should spawn tray on macOS when not running", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      mockFs.existsSync.mockReturnValue(false);
+
+      const { ensureTray } = await import("./tray.ts");
+      await ensureTray();
+
+      expect(mockSpawn.spawn).toHaveBeenCalledWith(
+        process.execPath,
+        expect.arrayContaining(["--tray", "--no-rust"]),
+        expect.objectContaining({ detached: true, stdio: "ignore" }),
+      );
+      expect(mockSpawn.child.unref).toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should not spawn on Linux", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "linux" });
+
+      const { ensureTray } = await import("./tray.ts");
+      await ensureTray();
+
+      expect(mockSpawn.spawn).not.toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should not spawn if tray already running", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      // Simulate existing tray
+      mockFs.existsSync.mockReturnValue(true);
+      mockFsPromises.readFile.mockResolvedValue(String(process.pid));
+
+      const { ensureTray } = await import("./tray.ts");
+      await ensureTray();
+
+      expect(mockSpawn.spawn).not.toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+  });
+});