agent-yes 1.272.0 → 1.274.0

package/ts/needsInput.ts

@@ -78,7 +78,7 @@ export interface MenuState {
 
 // An option row: an optional box border / cursor glyph / bullet, then "N. " (the
 // trailing space rejects version-like "3.5GB" that isn't a menu option). The `│`
-// matters: claude/gemini render their permission + AskUserQuestion menus inside a
+// matters: claude renders its permission + AskUserQuestion menus inside a
 // rounded box, so real option rows arrive as "│ ❯ 1. Yes" — without it only the
 // cursor row is ever collected and `ay select N` can't reach any other option.
 // Keep `-` last in the class so it stays a literal rather than a range.

package/ts/parseCliArgs.spec.ts

@@ -131,7 +131,7 @@ describe("CLI argument parsing", () => {
       "/usr/local/bin/claude-yes",
       "--prompt",
       "test",
-      "gemini",
+      "codex",
     ]);
 
     // cliName (from script) takes precedence over positional arg

package/ts/parseCliArgs.ts

@@ -173,7 +173,7 @@ export function parseCliArgs(argv: string[], supportedClis?: readonly string[])
       hidden: true,
     })
     .positional("cli", {
-      describe: "The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini",
+      describe: "The AI CLI to run, e.g., claude, codex, copilot, cursor",
       type: "string",
       choices: supportedClis as string[] | undefined,
       demandOption: false,

package/ts/postbuild.ts

@@ -13,7 +13,7 @@ const cliNames = [...Object.keys(CLIS_CONFIG), "agent"];
 const suffixes = ["-yes"];
 
 // Short aliases: maps alias name → target CLI name (alias resolves in parseCliArgs.ts)
-const shortAliases: Record<string, string> = { cy: "claude", orcy: "openrouter" };
+const shortAliases: Record<string, string> = { cy: "claude" };
 
 // Under Bun (dev via `bun link`), run TypeScript source directly — no build needed.
 // Under Node (published install or CI), use the compiled dist/cli.js.

package/ts/remotes.ts

@@ -2,7 +2,7 @@ import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
 import yaml from "yaml";
-import { isWebrtcSpec } from "./webrtcLink.ts";
+import { isWebrtcSpec, parseWebrtcLink } from "./webrtcLink.ts";
 
 function remotesPath(): string {
   const dir = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
@@ -18,6 +18,14 @@ export interface ResolvedRemote {
   url: string;
   token: string;
   keyword?: string;
+  /** Stable, human-readable name for display — never the loopback bridge URL. */
+  label: string;
+}
+
+/** A display label for a WebRTC share link: the room id, never the local bridge. */
+function webrtcLabel(link: string): string {
+  const parsed = parseWebrtcLink(link);
+  return parsed ? `webrtc:${parsed.room}` : "webrtc";
 }
 
 export async function readRemotes(): Promise<Map<string, RemoteConfig>> {
@@ -82,11 +90,16 @@ export function parseDirectRemoteSpec(
 export async function resolveRemoteSpec(spec: string): Promise<ResolvedRemote | null> {
   // Inline WebRTC share link: `ay ls webrtc://…` or `ay ls https://…/w/#room:token`.
   // These carry their own secret and have no keyword (use an alias to add one).
-  if (isWebrtcSpec(spec)) return resolveWebrtc(spec, undefined);
+  if (isWebrtcSpec(spec)) return resolveWebrtc(spec, undefined, webrtcLabel(spec));
 
   const direct = parseDirectRemoteSpec(spec);
   if (direct) {
-    return { url: direct.baseUrl, token: direct.token, keyword: direct.keyword };
+    return {
+      url: direct.baseUrl,
+      token: direct.token,
+      keyword: direct.keyword,
+      label: `${direct.host}:${direct.port}`,
+    };
   }
 
   // alias[:keyword]
@@ -98,8 +111,8 @@ export async function resolveRemoteSpec(spec: string): Promise<ResolvedRemote |
   const cfg = remotes.get(alias);
   if (!cfg) return null;
   // A saved alias may point at a WebRTC link; bridge it just like an inline one.
-  if (isWebrtcSpec(cfg.url)) return resolveWebrtc(cfg.url, keyword);
-  return { url: cfg.url, token: cfg.token, keyword };
+  if (isWebrtcSpec(cfg.url)) return resolveWebrtc(cfg.url, keyword, alias);
+  return { url: cfg.url, token: cfg.token, keyword, label: alias };
 }
 
 /**
@@ -107,10 +120,14 @@ export async function resolveRemoteSpec(spec: string): Promise<ResolvedRemote |
  * ordinary http remote, so every fetch-based remote command works unchanged.
  * The bridge lives for the rest of the process (torn down on `process.exit`).
  */
-async function resolveWebrtc(link: string, keyword?: string): Promise<ResolvedRemote> {
+async function resolveWebrtc(
+  link: string,
+  keyword: string | undefined,
+  label: string,
+): Promise<ResolvedRemote> {
   const { startWebrtcBridge } = await import("./webrtcRemote.ts");
   const bridge = await startWebrtcBridge(link);
-  return { url: bridge.baseUrl, token: bridge.token, keyword };
+  return { url: bridge.baseUrl, token: bridge.token, keyword, label };
 }
 
 // ---------------------------------------------------------------------------

package/ts/rustBinary.spec.ts

@@ -0,0 +1,81 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { gcOldBinaryDirs } from "./rustBinary.ts";
+import { _setInstalledPackageForTesting } from "./versionChecker.ts";
+
+// Startup GC for the versioned binary download cache (PERFORMANCE-EVENT
+// 2026-08-13): each release pins ~/.cache/agent-yes/bin/<version>/, and
+// nothing used to delete the old ones. GC must remove ONLY strict x.y.z dirs
+// strictly below the current version, and report the freed byte count.
+
+const root = mkdtempSync(path.join(os.tmpdir(), "ay-gc-"));
+const prevCacheDir = process.env.AGENT_YES_CACHE_DIR;
+
+function seed(name: string, bytes: number): string {
+  const dir = path.join(root, "agent-yes", "bin", name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, "agent-yes-darwin-arm64"), "x".repeat(bytes));
+  return dir;
+}
+
+beforeAll(() => {
+  process.env.AGENT_YES_CACHE_DIR = path.join(root, "agent-yes");
+  _setInstalledPackageForTesting({ name: "agent-yes", version: "1.272.0" });
+});
+
+afterAll(() => {
+  if (prevCacheDir === undefined) delete process.env.AGENT_YES_CACHE_DIR;
+  else process.env.AGENT_YES_CACHE_DIR = prevCacheDir;
+  _setInstalledPackageForTesting(null);
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe("gcOldBinaryDirs", () => {
+  it("removes only strict x.y.z dirs strictly below the current version", () => {
+    const oldA = seed("1.271.0", 10);
+    const oldB = seed("1.256.1", 20);
+    const current = seed("1.272.0", 5);
+    const newer = seed("1.273.0", 7);
+    const prerelease = seed("1.270.0-beta.0", 9);
+    const junk = seed("temp", 3);
+
+    const res = gcOldBinaryDirs();
+
+    expect(res.removed.sort()).toEqual(["1.256.1", "1.271.0"]);
+    expect(res.freedBytes).toBe(30);
+    expect(existsSync(oldA)).toBe(false);
+    expect(existsSync(oldB)).toBe(false);
+    for (const keep of [current, newer, prerelease, junk]) {
+      expect(existsSync(keep), `should keep ${keep}`).toBe(true);
+    }
+  });
+
+  it("is idempotent — a second run removes nothing", () => {
+    const res = gcOldBinaryDirs();
+    expect(res.removed).toEqual([]);
+    expect(res.freedBytes).toBe(0);
+  });
+
+  it("does nothing when the cache dir does not exist", () => {
+    const prev = process.env.AGENT_YES_CACHE_DIR;
+    process.env.AGENT_YES_CACHE_DIR = path.join(root, "does-not-exist");
+    try {
+      expect(gcOldBinaryDirs()).toEqual({ removed: [], freedBytes: 0 });
+    } finally {
+      process.env.AGENT_YES_CACHE_DIR = prev;
+    }
+  });
+
+  it("does nothing when the current version is a pre-release", () => {
+    _setInstalledPackageForTesting({ name: "agent-yes", version: "1.272.0-beta.0" });
+    try {
+      const res = gcOldBinaryDirs();
+      expect(res.removed).toEqual([]);
+      expect(res.freedBytes).toBe(0);
+    } finally {
+      _setInstalledPackageForTesting({ name: "agent-yes", version: "1.272.0" });
+    }
+  });
+});

package/ts/rustBinary.ts

@@ -3,10 +3,10 @@
  */
 
 import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, unlinkSync } from "fs";
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
 import path from "path";
-import { getInstalledPackage } from "./versionChecker.ts";
+import { compareVersions, getInstalledPackage } from "./versionChecker.ts";
 
 // Platform/arch to binary name mapping
 const PLATFORM_MAP: Record<string, string> = {
@@ -36,6 +36,22 @@ export function getBinaryName(): string {
   return binaryName + (platform === "win32" ? ".exe" : "");
 }
 
+/**
+ * The version-scoped download cache root (`~/.cache/agent-yes/bin/`) WITHOUT
+ * the version segment. Independent of `getBinDir()`'s npm-package shortcut:
+ * GC only ever touches the user cache, never a packaged bin dir.
+ */
+function getCacheBinRoot(): string {
+  const cacheDir =
+    process.env.AGENT_YES_CACHE_DIR ||
+    path.join(
+      process.env.XDG_CACHE_HOME || path.join(process.env.HOME || "/tmp", ".cache"),
+      "agent-yes",
+    );
+
+  return path.join(cacheDir, "bin");
+}
+
 /**
  * Get the directory where binaries are stored
  */
@@ -55,14 +71,79 @@ export function getBinDir(): string {
   // previous (older) release downloaded, and a published binary fix would never
   // reach a machine that already has one cached. A version segment makes a new
   // release miss the path and re-download; old binaries sit harmlessly beside it.
-  const cacheDir =
-    process.env.AGENT_YES_CACHE_DIR ||
-    path.join(
-      process.env.XDG_CACHE_HOME || path.join(process.env.HOME || "/tmp", ".cache"),
-      "agent-yes",
-    );
+  return path.join(getCacheBinRoot(), getInstalledPackage().version);
+}
 
-  return path.join(cacheDir, "bin", getInstalledPackage().version);
+// Only a strict `x.y.z` release version is ever eligible for GC. A pre-release
+// or dev suffix (e.g. `1.270.0-beta.0`) is never deleted, even if semver would
+// order it below the current version — a user may still be running it.
+const STRICT_SEMVER = /^\d+\.\d+\.\d+$/;
+
+export interface BinaryGcResult {
+  /** Version dir names that were removed. */
+  removed: string[];
+  /** Total bytes of removed files. */
+  freedBytes: number;
+}
+
+function dirSizeBytes(dir: string): number {
+  let total = 0;
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) total += dirSizeBytes(p);
+      else if (entry.isFile()) {
+        try {
+          total += statSync(p).size;
+        } catch {
+          /* raced with deletion — count what we can */
+        }
+      }
+    }
+  } catch {
+    /* unreadable dir — best effort */
+  }
+  return total;
+}
+
+/**
+ * Delete versioned binary cache dirs strictly older than the CURRENT package
+ * version.
+ *
+ * `~/.cache/agent-yes/bin/<version>/` accumulates one dir per release a user
+ * has ever run (PERFORMANCE-EVENT 2026-08-13), each holding a ~20-30 MiB
+ * binary that nothing ever cleaned up. Keep the current version; delete only
+ * dirs named `x.y.z` that compare strictly less than it (never pre-release /
+ * dev, never anything newer or malformed). Idempotent and best-effort: a dir
+ * that cannot be removed simply survives until the next run.
+ */
+export function gcOldBinaryDirs(): BinaryGcResult {
+  const result: BinaryGcResult = { removed: [], freedBytes: 0 };
+  const current = getInstalledPackage().version;
+  if (!STRICT_SEMVER.test(current)) return result; // dev/pre-release current — do nothing
+
+  const root = getCacheBinRoot();
+  let entries: string[];
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return result; // no cache dir at all — nothing to collect
+  }
+
+  for (const name of entries) {
+    if (!STRICT_SEMVER.test(name)) continue;
+    if (compareVersions(name, current) >= 0) continue;
+    const dir = path.join(root, name);
+    const size = dirSizeBytes(dir);
+    try {
+      rmSync(dir, { recursive: true, force: true });
+      result.removed.push(name);
+      result.freedBytes += size;
+    } catch {
+      // locked/in-use dir — leave it for the next run
+    }
+  }
+  return result;
 }
 
 /**
@@ -339,6 +420,22 @@ export async function getRustBinary(
 ): Promise<string> {
   const { verbose = false, forceDownload = false } = options;
 
+  // Startup GC: collect cache dirs left behind by OLDER package versions (each
+  // release pins its own <version>/ subdir; nothing ever deleted them — see
+  // PERFORMANCE-EVENT 2026-08-13). Safe and idempotent: only strict x.y.z dirs
+  // that are strictly below the current version are removed, never this
+  // version's dir, and all failures are swallowed.
+  try {
+    const freed = gcOldBinaryDirs();
+    if (verbose && freed.removed.length > 0) {
+      console.log(
+        `[rust] GC removed ${freed.removed.length} old binary cache dir(s): ${freed.removed.join(", ")}`,
+      );
+    }
+  } catch {
+    /* never block the agent run on cache GC */
+  }
+
   // First try to find existing binary
   if (!forceDownload) {
     const existing = findRustBinary(verbose);

package/ts/subcommands.spec.ts

@@ -121,8 +121,6 @@ describe("subcommands.isSubcommand", () => {
     expect(isSubcommand("stop")).toBe(true);
     expect(isSubcommand("tail")).toBe(true);
     expect(isSubcommand("send")).toBe(true);
-    expect(isSubcommand("deepseek")).toBe(true);
-    expect(isSubcommand("ds")).toBe(true);
     expect(isSubcommand("not-a-command")).toBe(false);
     expect(isSubcommand(undefined)).toBe(false);
   });
@@ -145,9 +143,9 @@ describe("subcommands ↔ rs/src/cli.rs subcommand mirror", () => {
   // The Rust runner keeps its OWN hardcoded copy of both lists (it must decide
   // whether to re-exec the JS launcher before clap swallows the word as prompt
   // text). Nothing enforced that copy, so it silently drifted: `key`, `select`,
-  // `todo`, `tray`, `deepseek` and `ds` existed only on the TS side, and running
-  // them on the Rust binary directly launched an agent with the subcommand as
-  // its prompt. Parse both sources and require them to stay identical.
+  // `todo`, `tray` existed only on the TS side, and running them on the Rust
+  // binary directly launched an agent with the subcommand as its prompt. Parse
+  // both sources and require them to stay identical.
   const names = (src: string, re: RegExp): string[] =>
     [...(src.match(re)?.[1] ?? "").matchAll(/"([^"]+)"/g)].map((m) => m[1]).sort();
 
@@ -171,7 +169,7 @@ describe("subcommands ↔ rs/src/cli.rs subcommand mirror", () => {
 });
 
 describe("subcommands.isUnknownManagerToken (footgun guard)", () => {
-  const CLIS = ["claude", "codex", "gemini"];
+  const CLIS = ["claude", "codex"];
   it("flags a bare non-cli non-subcommand word on the manager entry", async () => {
     const { isUnknownManagerToken } = await loadModule();
     // `ay frobnicate` / a newer subcommand on an older build — neither a
@@ -232,6 +230,7 @@ describe("subcommands.cmdHelp", () => {
     expect(await capture()).toContain("ay setup"); // default = manager
     expect(await capture(false)).not.toContain("ay setup"); // cli-bound alias (cy)
     expect(await capture(false)).toContain("ay ls"); // universal commands still shown
+    expect(await capture()).toContain("ay notify watch --unread"); // Management entry
   });
 
   it("stays plain for a human shell (no AGENT_YES_PID)", async () => {
@@ -280,6 +279,7 @@ describe("subcommands.cmdHelp", () => {
       expect(out).toContain("Spawn a sub-agent");
       expect(out).toContain(`ay ls --cwd /work/parent/child`);
       expect(out).toContain(`ay ls --watch --cwd /work/parent/child`);
+      expect(out).toContain("ay notify watch --unread");
     } finally {
       if (saved === undefined) delete process.env.AGENT_YES_PID;
       else process.env.AGENT_YES_PID = saved;
@@ -349,7 +349,6 @@ describe("subcommands.stopTipForCli", () => {
     expect(stopTipForCli("claude", 1234)).toMatch(/ay stop 1234/);
     expect(stopTipForCli("claude", 1234)).toMatch(/\/exit/);
     expect(stopTipForCli("codex", 99)).toMatch(/ay stop 99/);
-    expect(stopTipForCli("gemini", 7)).toMatch(/\/quit/);
   });
 
   it("returns null for CLIs without a known graceful command", async () => {
@@ -360,11 +359,10 @@ describe("subcommands.stopTipForCli", () => {
 });
 
 describe("subcommands.GRACEFUL_EXIT_COMMANDS", () => {
-  it("maps the three known CLIs to their /exit-style commands", async () => {
+  it("maps the known CLIs to their /exit-style commands", async () => {
     const { GRACEFUL_EXIT_COMMANDS } = await loadModule();
     expect(GRACEFUL_EXIT_COMMANDS["claude"]).toBe("/exit");
     expect(GRACEFUL_EXIT_COMMANDS["codex"]).toBe("/exit");
-    expect(GRACEFUL_EXIT_COMMANDS["gemini"]).toBe("/quit");
   });
 });