claude-yes 1.71.0 → 1.72.1

package/dist/{SUPPORTED_CLIS-DtYo1wxO.js → SUPPORTED_CLIS-DBk8E5_6.js}

@@ -815,7 +815,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.71.0";
+var version = "1.72.1";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -1895,4 +1895,4 @@ 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-DtYo1wxO.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-DBk8E5_6.js.map

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DtYo1wxO.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DBk8E5_6.js";
 import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
 import { spawn } from "child_process";
@@ -481,10 +481,14 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 const updateCheckPromise = checkAndAutoUpdate();
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-BzSS0v-i.js");
+	const { startTray } = await import("./tray-BQkynk6r.js");
 	await startTray();
 	await new Promise(() => {});
 }
+{
+	const { ensureTray } = await import("./tray-BQkynk6r.js");
+	ensureTray();
+}
 if (config.useRust) {
 	let rustBinary;
 	try {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-DtYo1wxO.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-DBk8E5_6.js";
 import "./logger-CX77vJDA.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/dist/tray-BQkynk6r.js

@@ -0,0 +1,187 @@
+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 IDLE_EXIT_POLLS = 15;
+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).`);
+	let intervalId;
+	const cleanup = () => {
+		if (intervalId) clearInterval(intervalId);
+		systray.kill(false);
+		removeTrayPid().finally(() => process.exit(0));
+	};
+	systray.onClick((action) => {
+		if (action.item.title === "Quit Tray") cleanup();
+	});
+	let lastCount = count;
+	let idlePolls = count === 0 ? 1 : 0;
+	intervalId = setInterval(async () => {
+		try {
+			const { count: newCount, tasks: newTasks } = await getRunningAgentCount();
+			if (newCount === 0) {
+				idlePolls++;
+				if (idlePolls >= IDLE_EXIT_POLLS) {
+					cleanup();
+					return;
+				}
+			} else idlePolls = 0;
+			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);
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+}
+
+//#endregion
+export { ensureTray, startTray };
+//# sourceMappingURL=tray-BQkynk6r.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.71.0",
+  "version": "1.72.1",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/cli.ts

@@ -22,6 +22,13 @@ if (config.tray) {
   await new Promise(() => {}); // Block forever, exit via tray quit or signal
 }
 
+// Auto-spawn tray icon in background on desktop OS (best-effort, silent failure)
+// Must run before --rust spawn since that blocks forever
+{
+  const { ensureTray } = await import("./tray.ts");
+  ensureTray(); // fire-and-forget, don't await
+}
+
 // Handle --rust: spawn the Rust binary instead, fall back to TypeScript if unavailable
 if (config.useRust) {
   let rustBinary: string | undefined;

package/ts/tray.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 
 // Mock systray2 before imports
 const mockSysTray = vi.hoisted(() => {
@@ -8,12 +8,10 @@ const mockSysTray = vi.hoisted(() => {
     sendAction: vi.fn(),
     kill: vi.fn(),
   };
-  const MockClass = vi.fn().mockImplementation(function (this: any, opts: any) {
+  const MockClass = vi.fn().mockImplementation(function (this: any) {
     Object.assign(this, instance);
-    (MockClass as any).__lastOpts = opts;
     return this;
   }) as any;
-  MockClass.__lastOpts = null;
   return {
     instance,
     MockClass,
@@ -33,10 +31,33 @@ 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", () => {
@@ -57,6 +78,8 @@ describe("tray", () => {
       );
       expect(mockSysTray.instance.ready).toHaveBeenCalled();
       expect(mockSysTray.instance.onClick).toHaveBeenCalled();
+      // Should write PID file
+      expect(mockFsPromises.writeFile).toHaveBeenCalled();
 
       Object.defineProperty(process, "platform", { value: originalPlatform });
     });
@@ -94,15 +117,12 @@ describe("tray", () => {
       expect(menuArg.menu.title).toBe("AY: 2");
       expect(menuArg.menu.tooltip).toBe("agent-yes: 2 running");
 
-      // Should have: header, separator, 2 agent items, separator, quit
       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");
-
-      // Last item should be "Quit Tray"
       expect(items[items.length - 1].title).toBe("Quit Tray");
 
       Object.defineProperty(process, "platform", { value: originalPlatform });
@@ -111,20 +131,17 @@ describe("tray", () => {
     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();
 
-      // Get the onClick callback
       const onClickCb = mockSysTray.instance.onClick.mock.calls[0][0];
-
-      // Simulate "Quit Tray" click
       onClickCb({ item: { title: "Quit Tray" } });
 
       expect(mockSysTray.instance.kill).toHaveBeenCalledWith(false);
-      expect(mockExit).toHaveBeenCalledWith(0);
+      // removeTrayPid is called (unlink)
+      await vi.waitFor(() => expect(mockExit).toHaveBeenCalledWith(0));
 
       mockExit.mockRestore();
       Object.defineProperty(process, "platform", { value: originalPlatform });
@@ -133,13 +150,11 @@ describe("tray", () => {
     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();
 
-      // Now simulate agent count change on next poll
       mockGetRunningAgentCount.mockResolvedValue({
         count: 3,
         tasks: [
@@ -170,15 +185,12 @@ describe("tray", () => {
         ],
       });
 
-      // Advance timer past poll interval
       await vi.advanceTimersByTimeAsync(2100);
 
       expect(mockSysTray.instance.sendAction).toHaveBeenCalledWith(
         expect.objectContaining({
           type: "update-menu",
-          menu: expect.objectContaining({
-            title: "AY: 3",
-          }),
+          menu: expect.objectContaining({ title: "AY: 3" }),
         }),
       );
 
@@ -189,19 +201,72 @@ describe("tray", () => {
     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 auto-exit after ~30s with 0 agents", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      vi.useFakeTimers();
+      const mockExit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
 
+      // Keep returning 0 agents for 15 polls (IDLE_EXIT_POLLS)
+      mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
+
+      // Advance 15 * 2s = 30s
+      await vi.advanceTimersByTimeAsync(15 * 2100);
+
+      expect(mockSysTray.instance.kill).toHaveBeenCalledWith(false);
+      await vi.waitFor(() => expect(mockExit).toHaveBeenCalledWith(0));
+
+      mockExit.mockRestore();
+      vi.useRealTimers();
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should reset idle counter when agents appear", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
       vi.useFakeTimers();
+      const mockExit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
 
       const { startTray } = await import("./tray.ts");
       await startTray();
 
-      // Same count on next poll
+      // 10 polls at 0 agents
       mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
+      await vi.advanceTimersByTimeAsync(10 * 2100);
 
+      // Then an agent appears — resets idle counter
+      mockGetRunningAgentCount.mockResolvedValue({
+        count: 1,
+        tasks: [
+          { pid: 1, cwd: "/a", task: "t", status: "running" as const, startedAt: 0, lockedAt: 0 },
+        ],
+      });
       await vi.advanceTimersByTimeAsync(2100);
 
-      expect(mockSysTray.instance.sendAction).not.toHaveBeenCalled();
+      // Then 10 more polls at 0 — should NOT exit yet (need 15 consecutive)
+      mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
+      await vi.advanceTimersByTimeAsync(10 * 2100);
+
+      expect(mockExit).not.toHaveBeenCalled();
 
+      mockExit.mockRestore();
       vi.useRealTimers();
       Object.defineProperty(process, "platform", { value: originalPlatform });
     });
@@ -229,5 +294,103 @@ describe("tray", () => {
 
       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 });
+    });
   });
 });

package/ts/tray.ts

@@ -1,6 +1,14 @@
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile, unlink } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
 import { getRunningAgentCount, type Task } from "./runningLock.ts";
 
 const POLL_INTERVAL = 2000;
+const IDLE_EXIT_POLLS = 15; // Exit after 15 polls (~30s) with 0 agents
+
+const getTrayDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
+const getTrayPidFile = () => path.join(getTrayDir(), "tray.pid");
 
 // Minimal 16x16 white circle PNG as base64 (used as tray icon)
 const ICON_BASE64 =
@@ -40,17 +48,100 @@ function buildMenuItems(tasks: Task[]) {
   return items;
 }
 
+function isDesktopOS(): boolean {
+  return process.platform === "darwin" || process.platform === "win32";
+}
+
+function isTrayProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Write the current process PID to the tray PID file
+ */
+async function writeTrayPid(): Promise<void> {
+  const dir = getTrayDir();
+  await mkdir(dir, { recursive: true });
+  await writeFile(getTrayPidFile(), String(process.pid), "utf8");
+}
+
+/**
+ * Remove the tray PID file
+ */
+async function removeTrayPid(): Promise<void> {
+  try {
+    await unlink(getTrayPidFile());
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Check if a tray process is already running
+ */
+export async function isTrayRunning(): Promise<boolean> {
+  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.
+ */
+export async function ensureTray(): Promise<void> {
+  if (!isDesktopOS()) return;
+  if (await isTrayRunning()) return;
+
+  try {
+    // Resolve the CLI entry point (dist/cli.js or ts/cli.ts)
+    const cliPath = new URL("./cli.ts", import.meta.url).pathname;
+    const { spawn } = await import("child_process");
+
+    // Spawn detached tray process
+    const child = spawn(process.execPath, [cliPath, "--tray", "--no-rust"], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env },
+    });
+    child.unref();
+  } catch {
+    // Silently fail — tray is best-effort
+  }
+}
+
 export async function startTray(): Promise<void> {
-  // Only macOS and Windows have proper tray support
-  if (process.platform !== "darwin" && process.platform !== "win32") {
+  if (!isDesktopOS()) {
     console.error("Tray icon is only supported on macOS and Windows.");
     return;
   }
 
+  // Check if another tray is already running
+  if (await isTrayRunning()) {
+    console.error("Tray is already running.");
+    return;
+  }
+
+  // Register our PID
+  await writeTrayPid();
+
   let SysTray: typeof import("systray2").default;
   try {
     SysTray = (await import("systray2")).default;
   } catch {
+    await removeTrayPid();
     console.error("systray2 is not installed. Install it with: npm install systray2");
     return;
   }
@@ -71,24 +162,39 @@ export async function startTray(): Promise<void> {
   await systray.ready();
   console.log(`Tray started. Watching ${count} running agent(s).`);
 
+  // Cleanup helper
+  let intervalId: ReturnType<typeof setInterval> | undefined;
+  const cleanup = () => {
+    if (intervalId) clearInterval(intervalId);
+    systray.kill(false);
+    removeTrayPid().finally(() => process.exit(0));
+  };
+
   // Handle quit
   systray.onClick((action) => {
-    if (action.item.title === "Quit Tray") {
-      systray.kill(false);
-      process.exit(0);
-    }
+    if (action.item.title === "Quit Tray") cleanup();
   });
 
-  // Poll and update
+  // Poll and update, auto-exit after ~30s idle (0 agents)
   let lastCount = count;
-  const interval = setInterval(async () => {
+  let idlePolls = count === 0 ? 1 : 0;
+  intervalId = setInterval(async () => {
     try {
       const { count: newCount, tasks: newTasks } = await getRunningAgentCount();
 
+      if (newCount === 0) {
+        idlePolls++;
+        if (idlePolls >= IDLE_EXIT_POLLS) {
+          cleanup();
+          return;
+        }
+      } else {
+        idlePolls = 0;
+      }
+
       if (newCount !== lastCount) {
         lastCount = newCount;
 
-        // Update title and tooltip
         systray.sendAction({
           type: "update-menu",
           menu: {
@@ -104,15 +210,6 @@ export async function startTray(): Promise<void> {
     }
   }, POLL_INTERVAL);
 
-  // Cleanup on exit
-  process.on("SIGINT", () => {
-    clearInterval(interval);
-    systray.kill(false);
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    clearInterval(interval);
-    systray.kill(false);
-    process.exit(0);
-  });
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
 }

package/dist/tray-BzSS0v-i.js

@@ -1,109 +0,0 @@
-import { n as getRunningAgentCount } from "./runningLock-BBI_URhR.js";
-
-//#region ts/tray.ts
-const POLL_INTERVAL = 2e3;
-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;
-}
-async function startTray() {
-	if (process.platform !== "darwin" && process.platform !== "win32") {
-		console.error("Tray icon is only supported on macOS and Windows.");
-		return;
-	}
-	let SysTray;
-	try {
-		SysTray = (await import("systray2")).default;
-	} catch {
-		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);
-			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);
-	process.on("SIGINT", () => {
-		clearInterval(interval);
-		systray.kill(false);
-		process.exit(0);
-	});
-	process.on("SIGTERM", () => {
-		clearInterval(interval);
-		systray.kill(false);
-		process.exit(0);
-	});
-}
-
-//#endregion
-export { startTray };
-//# sourceMappingURL=tray-BzSS0v-i.js.map