agent-yes 1.300.3 → 1.300.4

package/ts/serve.spec.ts

@@ -2,6 +2,9 @@ import { readFile } from "fs/promises";
 import { describe, expect, it } from "vitest";
 import {
   installerArgv,
+  LEGACY_AYRS_TASK,
+  legacyAyrsTaskArgv,
+  serveLauncher,
   probeDaemon,
   isNoNodeExecError,
   oxmgrCmd,
@@ -284,3 +287,103 @@ describe("vendorAssetType", () => {
     expect(vendorAssetType("")).toBeNull();
   });
 });
+
+// The daemon manager stores this argv verbatim and re-runs it on every
+// restart: a baked-in `~/.bun/bin/ay` symlink (recreated on each global
+// upgrade, absent on some images until the first one) or a bare `ay` that a
+// manager's minimal PATH cannot resolve both turn into an ENOENT restart loop.
+describe("serveLauncher", () => {
+  const realpath = (p: string) =>
+    p.replace(
+      "/home/alice/.bun/bin/ay",
+      "/home/alice/.bun/install/global/node_modules/agent-yes/dist/cli.js",
+    );
+
+  it("resolves the PATH symlink to the real script and runs it under bun", () => {
+    expect(
+      serveLauncher({
+        which: "/home/alice/.bun/bin/ay",
+        script: "/x/cli.js",
+        execPath: "/usr/bin/bun",
+        platform: "linux",
+        realpath,
+      }),
+    ).toEqual([
+      "/usr/bin/bun",
+      "/home/alice/.bun/install/global/node_modules/agent-yes/dist/cli.js",
+    ]);
+  });
+
+  it("falls back to the running script, never to a bare `ay`, when nothing is on PATH", () => {
+    expect(
+      serveLauncher({
+        which: null,
+        script: "/repo/alpha/dist/cli.js",
+        execPath: "/usr/bin/bun",
+        platform: "linux",
+        realpath,
+      }),
+    ).toEqual(["/usr/bin/bun", "/repo/alpha/dist/cli.js"]);
+  });
+
+  it("survives a realpath failure by keeping the path it was given", () => {
+    const boom = () => {
+      throw new Error("ENOENT");
+    };
+    expect(
+      serveLauncher({
+        which: "/opt/ay",
+        script: undefined,
+        execPath: "/usr/bin/bun",
+        platform: "linux",
+        realpath: boom,
+      }),
+    ).toEqual(["/usr/bin/bun", "/opt/ay"]);
+  });
+
+  it("runs a Windows exe shim directly and a script under bun", () => {
+    const id = (p: string) => p;
+    expect(
+      serveLauncher({
+        which: "C:/Users/alice/.bun/bin/ay.exe",
+        script: undefined,
+        execPath: "C:/bun.exe",
+        platform: "win32",
+        realpath: id,
+      }),
+    ).toEqual(["C:/Users/alice/.bun/bin/ay.exe"]);
+    expect(
+      serveLauncher({
+        which: null,
+        script: "C:/repo/alpha/dist/cli.js",
+        execPath: "C:/bun.exe",
+        platform: "win32",
+        realpath: id,
+      }),
+    ).toEqual(["C:/bun.exe", "C:/repo/alpha/dist/cli.js"]);
+  });
+});
+
+// A scheduled-task host from before the oxmgr move keeps the WebRTC room; the
+// new daemon then waits on it forever. Install and uninstall both clear it.
+describe("legacyAyrsTaskArgv", () => {
+  it("names the task ayrs serve install registered, with the right schtasks verbs", () => {
+    expect(LEGACY_AYRS_TASK).toBe("com.snomiao.ayrs-serve");
+    expect(legacyAyrsTaskArgv("query")).toEqual([
+      "schtasks",
+      "/query",
+      "/tn",
+      LEGACY_AYRS_TASK,
+      "/fo",
+      "LIST",
+    ]);
+    expect(legacyAyrsTaskArgv("end")).toEqual(["schtasks", "/end", "/tn", LEGACY_AYRS_TASK]);
+    expect(legacyAyrsTaskArgv("delete")).toEqual([
+      "schtasks",
+      "/delete",
+      "/tn",
+      LEGACY_AYRS_TASK,
+      "/f",
+    ]);
+  });
+});

package/ts/serve.ts

@@ -10,7 +10,7 @@ import {
   unlink,
   writeFile,
 } from "fs/promises";
-import { existsSync, renameSync, watch, writeFileSync } from "node:fs";
+import { existsSync, realpathSync, renameSync, watch, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createHash, randomBytes, timingSafeEqual } from "crypto";
@@ -949,16 +949,72 @@ export function oxmgrCmd(argv: string[]): string {
   return argv.map((a) => (/[\\\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a)).join(" ");
 }
 
+/**
+ * The argv a daemon manager runs for `ay serve …`. Pure so the contract is
+ * testable: `which` is the `ay` on PATH (or null), `script` is THIS process's
+ * own entry (`process.argv[1]`, always present), `realpath` resolves symlinks.
+ *
+ * Never bake in the `~/.bun/bin/ay` symlink: `bun add -g` removes and recreates
+ * it on every upgrade, and some images ship without it until the first update
+ * — a manager that stored it then restarts into ENOENT thousands of times.
+ * Resolve to the real file instead, and when nothing is on PATH fall back to
+ * the script running this very install (never a bare `ay`, which a manager's
+ * minimal PATH cannot resolve). On POSIX the entry is a `#!/usr/bin/env bun`
+ * script run via bun; on Windows it is a self-contained exe.
+ */
+export function serveLauncher(opts: {
+  which: string | null;
+  script: string | undefined;
+  execPath: string;
+  platform: NodeJS.Platform;
+  realpath: (p: string) => string;
+}): string[] {
+  const resolve = (p: string) => {
+    try {
+      return opts.realpath(p);
+    } catch {
+      return p;
+    }
+  };
+  const entry = opts.which ? resolve(opts.which) : opts.script ? resolve(opts.script) : null;
+  if (!entry) return ["ay"];
+  if (opts.platform === "win32")
+    return /\.(exe|cmd|bat)$/i.test(entry) ? [entry] : [opts.execPath, entry];
+  return [opts.execPath, entry];
+}
+
 function ayServeArgv(args: string[]): string[] {
-  const ayBin = Bun.which("ay");
-  const launcher = ayBin
-    ? process.platform === "win32"
-      ? [ayBin]
-      : [process.execPath, ayBin]
-    : ["ay"];
+  const launcher = serveLauncher({
+    which: Bun.which("ay"),
+    script: process.argv[1],
+    execPath: process.execPath,
+    platform: process.platform,
+    realpath: realpathSync,
+  });
   return [...launcher, "serve", ...args];
 }
 
+// The Task Scheduler entry `ayrs serve install` registered before the daemon
+// moved under oxmgr. A leftover one keeps hosting the WebRTC room, and the new
+// daemon then waits forever on "another ayrs host is already serving room …".
+// Mirrors rs/src/serve/service.rs LABEL / uninstall_quiet.
+export const LEGACY_AYRS_TASK = "com.snomiao.ayrs-serve";
+
+export function legacyAyrsTaskArgv(step: "query" | "end" | "delete"): string[] {
+  const base = ["schtasks", `/${step}`, "/tn", LEGACY_AYRS_TASK];
+  return step === "query" ? [...base, "/fo", "LIST"] : step === "delete" ? [...base, "/f"] : base;
+}
+
+async function stopLegacyAyrsTask(): Promise<void> {
+  if (process.platform !== "win32") return;
+  if ((await spawnExit(legacyAyrsTaskArgv("query"))) !== 0) return; // not registered
+  process.stdout.write(
+    `stopping legacy scheduled task '${LEGACY_AYRS_TASK}' (it would keep hosting the WebRTC room)\n`,
+  );
+  await spawnExit(legacyAyrsTaskArgv("end"));
+  await spawnExit(legacyAyrsTaskArgv("delete"));
+}
+
 // Per-user login auto-start entry on Windows. pm2 core has no Windows startup
 // integration (`pm2 startup` errors "Init system not found"), so we register a
 // HKCU Run value that runs `pm2 resurrect` at login — no admin, removed on
@@ -1197,6 +1253,14 @@ async function warnStrayServeProcesses(): Promise<void> {
 // mints a persisted room instead). Mirrors how cmdServe resolves argv.webrtc/argv.share,
 // but over the raw arg list install holds (oxmgr splits the command on whitespace →
 // `--webrtc url`; pm2/`=` → `--webrtc=url`).
+// Which runtime a daemon registered with `args` hosts its room under — see
+// serveRust.ts daemonShareRuntime; the binary check is the live one cmdServe makes.
+async function daemonShareRuntime(args: string[]): Promise<"ts" | "rust"> {
+  const { daemonShareRuntime: decide } = await import("./serveRust.ts");
+  const { findAyrsBinary } = await import("./rustBinary.ts");
+  return decide(args, () => !!findAyrsBinary());
+}
+
 function explicitWebrtcUrl(args: string[]): string | undefined {
   for (let i = 0; i < args.length; i++) {
     const a = args[i]!;
@@ -1329,6 +1393,7 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
     }
     if (removed === 0 && failed === 0)
       process.stdout.write(`no '${DAEMON_NAME}' daemon registered with any manager\n`);
+    await stopLegacyAyrsTask();
     await warnStrayServeProcesses();
     return failed ? 1 : 0;
   }
@@ -1380,11 +1445,20 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
     const webrtcDaemon = effArgs.some((a) => a.startsWith("--webrtc") || a.startsWith("--share"));
     let shareLink: string | null = null;
     let shareLinkMinted = false; // auto-minted (persisted/rotatable) vs explicit URL
+    // The daemon's `ay serve …` delegates to ayrs whenever it can (serveRust.ts),
+    // and ayrs persists its room in a DIFFERENT file (.share-room-ayrs) — mint
+    // and print from the file of the runtime that will actually host.
+    let roomFile = ".share-room";
     if (webrtcDaemon) {
       try {
-        const { loadOrCreateShareRoom, shareLinkFromRoomUrl } = await import("./share.ts");
+        const { loadOrCreateShareRoom, shareLinkFromRoomUrl, shareRoomFileName } =
+          await import("./share.ts");
+        const runtime = await daemonShareRuntime(effArgs);
+        roomFile = shareRoomFileName(runtime);
         const explicit = explicitWebrtcUrl(effArgs);
-        shareLink = shareLinkFromRoomUrl(explicit ?? (await loadOrCreateShareRoom()));
+        shareLink = shareLinkFromRoomUrl(
+          explicit ?? (await loadOrCreateShareRoom(undefined, runtime)),
+        );
         shareLinkMinted = !explicit;
       } catch {
         /* best effort — fall back to the .share-link file hint in emitShareLink */
@@ -1397,7 +1471,7 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
           `\nshared over WebRTC — open this link (the token is eaten from the URL on open):\n` +
             `  ${shareLink}\n` +
             (shareLinkMinted
-              ? `  (persistent room — same link across restarts; delete ~/.agent-yes/.share-room to rotate)\n`
+              ? `  (persistent room — same link across restarts; delete ~/.agent-yes/${roomFile} to rotate)\n`
               : ``),
         );
         // Offer to jump straight into the console (default yes); no-ops on a
@@ -1407,8 +1481,8 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
       } else
         process.stdout.write(
           `\nthe WebRTC share link carries a secret, so the daemon does NOT log it —\n` +
-            `read it from ~/.agent-yes/.share-link (mode 0600). The room persists in\n` +
-            `~/.agent-yes/.share-room, so the link survives restarts.\n`,
+            `read it with \`ay share status\`. The room persists in\n` +
+            `~/.agent-yes/${roomFile}, so the link survives restarts.\n`,
         );
     };
 
@@ -1439,6 +1513,9 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
       await spawnExit([mgr.bin, "stop", DAEMON_NAME]);
       await spawnExit([mgr.bin, "delete", DAEMON_NAME]);
     }
+    // A pre-oxmgr scheduled-task host left behind would keep the WebRTC room
+    // and the new daemon would wait on it forever.
+    await stopLegacyAyrsTask();
     await warnStrayServeProcesses();
 
     // oxmgr takes the command as one string; pm2 takes the binary plus its
@@ -1627,11 +1704,18 @@ async function cmdServeStatus(args: string[]): Promise<number> {
   const json = args.includes("--json");
   const mgr = await resolveActiveManager();
   const token = await loadTokenReadOnly();
-  const shareLink = await readShareLink();
 
   // A non-null arg list means the daemon is registered with the manager.
   const daemonArgs = mgr ? await readDaemonServeArgs(mgr) : null;
   const installed = daemonArgs !== null;
+  // The link of the room the registered daemon HOSTS: derived read-only from
+  // the room file of its runtime (ayrs by default — a different file from the
+  // TS host's). `.share-link` is only ever written by the TS host, so for a
+  // Rust daemon it is stale or absent; keep it as the fallback for TS daemons
+  // and for the uninstalled-but-left-over case shareLinkStatus flags.
+  const { daemonShareLink } = await import("./shareCmd.ts");
+  const shareLink =
+    (installed ? await daemonShareLink(daemonArgs) : null) ?? (await readShareLink());
   // Manager-reported process state — the only up/down signal for webrtc daemons.
   const running = installed ? await readDaemonRunning(mgr!) : false;
   const a = daemonArgs ?? [];
@@ -1781,8 +1865,9 @@ export async function cmdServe(rest: string[]): Promise<number> {
         `                    agent-yes.com, or pass a room link to join that room:\n` +
         `                    https://agent-yes.com/room/#room=<id>&s=e1.<secret>).\n` +
         `                    Alone it needs NO port — combine with --http for both.\n` +
-        `                    The minted room persists in ~/.agent-yes/.share-room\n` +
-        `                    (stable link across restarts; delete the file to rotate).\n` +
+        `                    The minted room persists in ~/.agent-yes/.share-room-ayrs\n` +
+        `                    (.share-room under --no-rust); stable link across restarts,\n` +
+        `                    delete the file to rotate.\n` +
         `  --share [URL]     Legacy alias for --http --webrtc\n\n` +
         `Runtime: like \`ay <cli>\`, the Rust daemon (ayrs serve) runs by default for\n` +
         `  the flags it supports — --webrtc [webrtc://url], --port N, --sighost H.\n` +

package/ts/serveRust.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { planRustServe } from "./serveRust.ts";
+import { daemonShareRuntime, planRustServe } from "./serveRust.ts";
 
 // `ay serve` runs the Rust daemon (`ayrs serve`) by default, like `ay <cli>`
 // runs the Rust agent runtime — but only for invocations ayrs can express.
@@ -83,3 +83,26 @@ describe("planRustServe", () => {
     });
   });
 });
+
+// Every printed share link must come from the room file of the runtime that
+// hosts the room: ayrs persists its room in .share-room-ayrs, TS in .share-room.
+// A link derived from the wrong file points at a room nobody serves.
+describe("daemonShareRuntime", () => {
+  const env = {};
+  const ayrs = () => true;
+  const noAyrs = () => false;
+
+  it("is rust for the args ayrs serve accepts, when the binary exists", () => {
+    expect(daemonShareRuntime(["--webrtc"], ayrs, env)).toBe("rust");
+    expect(daemonShareRuntime(["--webrtc", "--sighost", "s.example"], ayrs, env)).toBe("rust");
+    expect(daemonShareRuntime(["--webrtc", "--port", "0"], ayrs, env)).toBe("rust");
+  });
+
+  it("is ts whenever cmdServe would fall back to the TypeScript host", () => {
+    expect(daemonShareRuntime(["--webrtc"], noAyrs, env)).toBe("ts");
+    expect(daemonShareRuntime(["--webrtc", "--no-rust"], ayrs, env)).toBe("ts");
+    expect(daemonShareRuntime(["--webrtc"], ayrs, { AGENT_YES_NO_RUST: "1" })).toBe("ts");
+    expect(daemonShareRuntime(["--share"], ayrs, env)).toBe("ts");
+    expect(daemonShareRuntime([], ayrs, env)).toBe("ts");
+  });
+});

package/ts/serveRust.ts

@@ -112,3 +112,22 @@ export function planRustServe(
   }
   return { kind: "rust", argv };
 }
+
+/**
+ * Which runtime a daemon registered with these `ay serve` args actually runs —
+ * and therefore which persisted room file holds the room it hosts
+ * (`.share-room` for TypeScript, `.share-room-ayrs` for ayrs; see share.ts).
+ *
+ * Mirrors cmdServe exactly: an argv that planRustServe delegates runs under
+ * ayrs whenever the binary exists, and falls back to TypeScript otherwise. Any
+ * link we print for a daemon must be derived through this, or `ay share` hands
+ * out a link to a room nobody serves. `hasAyrs` is injected so the decision
+ * stays a pure function for tests.
+ */
+export function daemonShareRuntime(
+  args: string[],
+  hasAyrs: () => boolean,
+  env: Record<string, string | undefined> = process.env,
+): "ts" | "rust" {
+  return planRustServe(args, env).kind === "rust" && hasAyrs() ? "rust" : "ts";
+}

package/ts/share.bun.spec.ts

@@ -1,5 +1,15 @@
-import { describe, it, expect } from "bun:test";
-import { formatRoomLink, shareLinkFromRoomUrl } from "./share.ts";
+import { afterEach, beforeEach, describe, it, expect } from "bun:test";
+import {
+  formatRoomLink,
+  loadOrCreateShareRoom,
+  readShareRoom,
+  shareLinkFromRoomUrl,
+  shareRoomFileName,
+  shareRoomPath,
+} from "./share.ts";
+import { mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
 import { parseWebrtcLink, toWebrtcUrl } from "./webrtcLink.ts";
 import { MARKER } from "../lab/ui/e2e.js";
 
@@ -56,3 +66,45 @@ describe("formatRoomLink \u2194 the CLI parser", () => {
     expect(parseWebrtcLink(link)).toMatchObject({ room: "r1a2b3c", host: "localhost:7778" });
   });
 });
+
+// The two hosts persist their rooms in different files (same format). Minting
+// and reading must target the file of the runtime that hosts, and a read must
+// never mint — `ay serve status` is read-only.
+describe("share room files per runtime", () => {
+  let home: string;
+  const prev = process.env.AGENT_YES_HOME;
+  beforeEach(async () => {
+    home = await mkdtemp(path.join(tmpdir(), "ay-share-room-"));
+    process.env.AGENT_YES_HOME = home;
+  });
+  afterEach(async () => {
+    if (prev === undefined) delete process.env.AGENT_YES_HOME;
+    else process.env.AGENT_YES_HOME = prev;
+    await rm(home, { recursive: true, force: true });
+  });
+
+  it("maps each runtime to its own file", () => {
+    expect(shareRoomFileName("ts")).toBe(".share-room");
+    expect(shareRoomFileName("rust")).toBe(".share-room-ayrs");
+    expect(shareRoomPath("rust")).toBe(path.join(home, ".share-room-ayrs"));
+    expect(shareRoomPath()).toBe(path.join(home, ".share-room"));
+  });
+
+  it("mints into the rust file and leaves the ts file alone", async () => {
+    const url = await loadOrCreateShareRoom("s.example", "rust");
+    expect(url).toMatch(/^webrtc:\/\/r[0-9a-f]{12}:e1\.[0-9a-f]{64}@s\.example$/);
+    expect((await readFile(path.join(home, ".share-room-ayrs"), "utf-8")).trim()).toBe(url);
+    await expect(readFile(path.join(home, ".share-room"))).rejects.toThrow();
+    // Stable: a second load returns the persisted room, no re-mint.
+    expect(await loadOrCreateShareRoom("s.example", "rust")).toBe(url);
+  });
+
+  it("reads without minting, and ignores a legacy unencrypted room", async () => {
+    expect(await readShareRoom("rust")).toBeNull();
+    await expect(readFile(path.join(home, ".share-room-ayrs"))).rejects.toThrow();
+    await writeFile(path.join(home, ".share-room"), `webrtc://room0:${S}@s.example`);
+    expect(await readShareRoom("ts")).toBeNull();
+    await writeFile(path.join(home, ".share-room"), `webrtc://room0:${TOK}@s.example`);
+    expect(await readShareRoom("ts")).toBe(`webrtc://room0:${TOK}@s.example`);
+  });
+});

package/ts/share.spec.ts

@@ -1,5 +1,15 @@
-import { describe, it, expect } from "vitest";
-import { formatRoomLink, shareLinkFromRoomUrl } from "./share.ts";
+import { afterEach, beforeEach, describe, it, expect } from "vitest";
+import {
+  formatRoomLink,
+  loadOrCreateShareRoom,
+  readShareRoom,
+  shareLinkFromRoomUrl,
+  shareRoomFileName,
+  shareRoomPath,
+} from "./share.ts";
+import { mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
 import { parseWebrtcLink, toWebrtcUrl } from "./webrtcLink.ts";
 import { MARKER } from "../lab/ui/e2e.js";
 
@@ -56,3 +66,45 @@ describe("formatRoomLink \u2194 the CLI parser", () => {
     expect(parseWebrtcLink(link)).toMatchObject({ room: "r1a2b3c", host: "localhost:7778" });
   });
 });
+
+// The two hosts persist their rooms in different files (same format). Minting
+// and reading must target the file of the runtime that hosts, and a read must
+// never mint — `ay serve status` is read-only.
+describe("share room files per runtime", () => {
+  let home: string;
+  const prev = process.env.AGENT_YES_HOME;
+  beforeEach(async () => {
+    home = await mkdtemp(path.join(tmpdir(), "ay-share-room-"));
+    process.env.AGENT_YES_HOME = home;
+  });
+  afterEach(async () => {
+    if (prev === undefined) delete process.env.AGENT_YES_HOME;
+    else process.env.AGENT_YES_HOME = prev;
+    await rm(home, { recursive: true, force: true });
+  });
+
+  it("maps each runtime to its own file", () => {
+    expect(shareRoomFileName("ts")).toBe(".share-room");
+    expect(shareRoomFileName("rust")).toBe(".share-room-ayrs");
+    expect(shareRoomPath("rust")).toBe(path.join(home, ".share-room-ayrs"));
+    expect(shareRoomPath()).toBe(path.join(home, ".share-room"));
+  });
+
+  it("mints into the rust file and leaves the ts file alone", async () => {
+    const url = await loadOrCreateShareRoom("s.example", "rust");
+    expect(url).toMatch(/^webrtc:\/\/r[0-9a-f]{12}:e1\.[0-9a-f]{64}@s\.example$/);
+    expect((await readFile(path.join(home, ".share-room-ayrs"), "utf-8")).trim()).toBe(url);
+    await expect(readFile(path.join(home, ".share-room"))).rejects.toThrow();
+    // Stable: a second load returns the persisted room, no re-mint.
+    expect(await loadOrCreateShareRoom("s.example", "rust")).toBe(url);
+  });
+
+  it("reads without minting, and ignores a legacy unencrypted room", async () => {
+    expect(await readShareRoom("rust")).toBeNull();
+    await expect(readFile(path.join(home, ".share-room-ayrs"))).rejects.toThrow();
+    await writeFile(path.join(home, ".share-room"), `webrtc://room0:${S}@s.example`);
+    expect(await readShareRoom("ts")).toBeNull();
+    await writeFile(path.join(home, ".share-room"), `webrtc://room0:${TOK}@s.example`);
+    expect(await readShareRoom("ts")).toBe(`webrtc://room0:${TOK}@s.example`);
+  });
+});

package/ts/share.ts

@@ -154,30 +154,54 @@ export interface ShareOpts {
 // browser that saved the room) survives restarts — important for daemons,
 // which would otherwise mint a new link on every restart. Delete the file to
 // rotate the room.
-function shareRoomPath(): string {
+//
+// Two hosts, two files. The TypeScript server persists its room in
+// `.share-room`; the Rust daemon (`ayrs serve --webrtc`, the default whenever
+// the ayrs binary exists — see serveRust.ts) persists its own in
+// `.share-room-ayrs`, so the two can run side by side without fighting over one
+// room (they hold different host locks). Same on-disk format. Every link we
+// PRINT must therefore come from the file of the runtime that actually hosts,
+// or the operator hands out a link to a room nobody serves.
+export type ShareRuntime = "ts" | "rust";
+
+export function shareRoomFileName(runtime: ShareRuntime): string {
+  return runtime === "rust" ? ".share-room-ayrs" : ".share-room";
+}
+
+export function shareRoomPath(runtime: ShareRuntime = "ts"): string {
   const home = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
-  return path.join(home, ".share-room");
+  return path.join(home, shareRoomFileName(runtime));
 }
 
-export async function loadOrCreateShareRoom(sighost = DEFAULT_SIGHOST): Promise<string> {
+// Read-only: the persisted room url, or null when none (or a legacy markerless
+// one) is on disk. `ay serve status` must never mint.
+export async function readShareRoom(runtime: ShareRuntime = "ts"): Promise<string | null> {
   try {
-    const url = (await readFile(shareRoomPath(), "utf-8")).trim();
-    if (url.startsWith("webrtc://")) {
-      // A v2 (encrypted) room carries the e1. marker on its secret — reuse it.
-      // A legacy markerless room is rotated to a fresh encrypted room below: the
-      // signaling DO has pinned the old room to its plaintext token, so we must
-      // mint a NEW room name. This is a one-time, deliberate security upgrade —
-      // old share links stop working; re-open the new printed link.
-      if (parseShareUrl(url).token.startsWith(MARKER)) return url;
-    }
+    const url = (await readFile(shareRoomPath(runtime), "utf-8")).trim();
+    // A v2 (encrypted) room carries the e1. marker on its secret — reuse it.
+    // A legacy markerless room is rotated to a fresh encrypted room by
+    // loadOrCreateShareRoom: the signaling DO has pinned the old room to its
+    // plaintext token, so we must mint a NEW room name. This is a one-time,
+    // deliberate security upgrade — old share links stop working; re-open the
+    // new printed link.
+    if (url.startsWith("webrtc://") && parseShareUrl(url).token.startsWith(MARKER)) return url;
   } catch {
     /* not yet minted */
   }
+  return null;
+}
+
+export async function loadOrCreateShareRoom(
+  sighost = DEFAULT_SIGHOST,
+  runtime: ShareRuntime = "ts",
+): Promise<string> {
+  const existing = await readShareRoom(runtime);
+  if (existing) return existing;
   const room = "r" + randomBytes(6).toString("hex");
   const s = randomBytes(32).toString("hex");
   const url = `webrtc://${room}:${MARKER}${s}@${sighost}`;
-  await mkdir(path.dirname(shareRoomPath()), { recursive: true });
-  await writeFile(shareRoomPath(), url, { mode: 0o600 });
+  await mkdir(path.dirname(shareRoomPath(runtime)), { recursive: true });
+  await writeFile(shareRoomPath(runtime), url, { mode: 0o600 });
   return url;
 }
 
@@ -236,7 +260,8 @@ export function shareLinkFromRoomUrl(url: string): string {
   const { s, v2 } = parseSecret(token);
   if (!v2)
     throw new Error(
-      "refusing to derive a link for an unencrypted room — delete ~/.agent-yes/.share-room to rotate to an encrypted link",
+      "refusing to derive a link for an unencrypted room — delete the persisted room file " +
+        "(~/.agent-yes/.share-room, or .share-room-ayrs for the Rust daemon) to rotate to an encrypted link",
     );
   return formatShareLink(room, s, host);
 }

package/ts/shareCmd.ts

@@ -132,6 +132,27 @@ const HELP =
   `The URL carries this host's serve token: whoever holds it can read and steer\n` +
   `every agent here. Rotate: rm ~/.agent-yes/.serve-token && ay serve install\n`;
 
+// Which runtime hosts the room for a daemon registered with `args` — the Rust
+// daemon (ayrs) whenever the args delegate and the binary exists, else TS.
+async function shareRuntimeOf(args: string[] | null): Promise<"ts" | "rust"> {
+  const { daemonShareRuntime } = await import("./serveRust.ts");
+  const { findAyrsBinary } = await import("./rustBinary.ts");
+  return daemonShareRuntime(args ?? [], () => !!findAyrsBinary());
+}
+
+// The console link for the room a `--webrtc` daemon hosts, derived read-only
+// from the persisted room file of its runtime; null when nothing is minted yet.
+export async function daemonShareLink(args: string[] | null): Promise<string | null> {
+  const { readShareRoom, shareLinkFromRoomUrl } = await import("./share.ts");
+  const room = await readShareRoom(await shareRuntimeOf(args));
+  if (!room) return null;
+  try {
+    return shareLinkFromRoomUrl(room);
+  } catch {
+    return null; // legacy unencrypted room — the host itself rotates it on start
+  }
+}
+
 // ay share status — end-to-end health of each way this machine is shared.
 async function cmdShareStatus(mount: string): Promise<number> {
   const { inspectServeDaemon } = await import("./serve.ts");
@@ -148,7 +169,12 @@ async function cmdShareStatus(mount: string): Promise<number> {
     d.port ? (d.httpUp ? `up on 127.0.0.1:${d.port}` : `DOWN (127.0.0.1:${d.port})`) : "off",
   );
   if (d.consoleUrl) line("portless:", d.httpUp ? d.consoleUrl.replace(/#.*/, "") : "DOWN");
-  line("webrtc:", webrtc ? "on (agent-yes.com room)" : "off");
+  if (webrtc) {
+    // Print the link the RUNNING host serves — from the room file of the
+    // runtime that hosts it (Rust by default), read-only: status never mints.
+    const link = await daemonShareLink(d.args);
+    line("webrtc:", link ? `on — ${link}` : "on (room not minted yet — run `ay share webrtc`)");
+  } else line("webrtc:", "off");
   if (!ts) {
     line("tailscale:", Bun.which("tailscale") ? "not running" : "not installed");
     return d.httpUp || webrtc ? 0 : 1;
@@ -306,8 +332,13 @@ export async function cmdShare(rest: string[]): Promise<number> {
   let url: string;
   const port = state.port ?? (portArg ? Number(portArg) : DEFAULT_SHARE_PORT);
   if (mode === "webrtc") {
+    // The daemon just (re)installed runs `ay serve --webrtc`, which is the Rust
+    // host whenever ayrs exists — read ITS room file, not the TS one, or the
+    // link points at a room nobody hosts.
     const { loadOrCreateShareRoom, shareLinkFromRoomUrl } = await import("./share.ts");
-    url = shareLinkFromRoomUrl(await loadOrCreateShareRoom());
+    url = shareLinkFromRoomUrl(
+      await loadOrCreateShareRoom(undefined, await shareRuntimeOf(state.args)),
+    );
   } else if (mode === "portless") {
     url = state.consoleUrl ?? httpShareUrl("https://agent-yes.localhost", state.token);
   } else if (mode === "local") {

package/ts/strayServe.ts

@@ -7,6 +7,7 @@ const MANAGEMENT_COMMAND_RE = /\b(?:install|uninstall|status|logs|restart)\b/;
 function isServeCommand(command: string): boolean {
   return (
     /\bay(?:\.js)?\s+serve\b/.test(command) ||
+    /\bayrs(?:\.exe)?\s+serve\b/.test(command) ||
     /\bagent-yes(?:\.js)?\s+serve\b/.test(command) ||
     /\bagent-yes\.js\s+serve\b/.test(command)
   );