agent-yes 1.298.1 → 1.299.0

package/ts/shareCore.ts

@@ -0,0 +1,148 @@
+import type { networkInterfaces } from "node:os";
+
+// Pure helpers behind `ay share` (ts/shareCmd.ts, the interactive shell): which
+// daemon args a mode needs, LAN/tailscale detection parsing, the exact
+// third-party commands the [y/N] prompts show, and the share URL format.
+
+export type ShareMode = "local" | "portless" | "lan" | "tailscale" | "webrtc";
+export const SHARE_MODES: ShareMode[] = ["local", "portless", "lan", "tailscale", "webrtc"];
+export const DEFAULT_SHARE_PORT = 7432;
+export const DEFAULT_TS_PATH = "/ay";
+
+export function flagValue(args: string[], flag: string): string | undefined {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    if (a === flag) return args[i + 1];
+    if (a.startsWith(`${flag}=`)) return a.slice(flag.length + 1);
+  }
+  return undefined;
+}
+
+export function hasFlag(args: string[], flag: string): boolean {
+  return args.some((a) => a === flag || a.startsWith(`${flag}=`));
+}
+
+export function dropFlagWithValue(args: string[], flag: string): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    if (a === flag) {
+      i++;
+      continue;
+    }
+    if (a.startsWith(`${flag}=`)) continue;
+    out.push(a);
+  }
+  return out;
+}
+
+/**
+ * The daemon args a mode needs, built on top of whatever the daemon already runs
+ * with (so sharing over one more way never drops an existing one). `prior` null =
+ * no daemon installed. Returns `prior` unchanged when it already fits.
+ */
+export function planDaemonArgs(
+  prior: string[] | null,
+  mode: ShareMode,
+  defaultPort = DEFAULT_SHARE_PORT,
+): string[] {
+  let args = [...(prior ?? [])];
+  const hasWebrtc = hasFlag(args, "--webrtc") || hasFlag(args, "--share");
+  // HTTP is the default mode — on unless the daemon is webrtc-only.
+  const hasHttp = hasFlag(args, "--http") || hasFlag(args, "--share") || !hasWebrtc;
+
+  if (mode === "webrtc") {
+    if (!hasWebrtc) {
+      if (prior !== null && hasHttp && !hasFlag(args, "--http")) args.push("--http");
+      args.push("--webrtc");
+    }
+    return args;
+  }
+  if (!hasHttp) args.push("--http");
+  // Portless owns the port (it assigns the backend and fronts it at
+  // https://agent-yes.localhost), so it's exactly the mode WITHOUT --port; every
+  // other HTTP mode needs a stable port to point a browser / LAN / tailscale at.
+  if (mode === "portless") return dropFlagWithValue(args, "--port");
+  if (flagValue(args, "--port") === undefined) args.push("--port", String(defaultPort));
+  if (mode === "lan" && flagValue(args, "--host") !== "0.0.0.0") {
+    args = dropFlagWithValue(args, "--host");
+    args.push("--host", "0.0.0.0");
+  }
+  return args;
+}
+
+type Ifaces = ReturnType<typeof networkInterfaces>;
+
+/** First private-range IPv4 (not loopback, not Tailscale's 100.64/10 CGNAT). */
+export function pickLanIp(ifaces: Ifaces): string | null {
+  for (const list of Object.values(ifaces)) {
+    for (const a of list ?? []) {
+      if (a.family !== "IPv4" || a.internal) continue;
+      const [x, y] = a.address.split(".").map(Number) as [number, number];
+      const priv = x === 10 || (x === 192 && y === 168) || (x === 172 && y >= 16 && y <= 31);
+      if (priv) return a.address;
+    }
+  }
+  return null;
+}
+
+/** MagicDNS name of this node from `tailscale status --json`, or null when not up. */
+export function tailscaleDnsName(status: any): string | null {
+  if (!status || status.BackendState !== "Running") return null;
+  const dns = String(status.Self?.DNSName ?? "").replace(/\.$/, "");
+  return dns || null;
+}
+
+export type TsRoute =
+  | { status: "ok" }
+  | { status: "missing" }
+  | { status: "conflict"; proxy: string };
+
+/**
+ * Is `https://<dns>/<mount>` already proxied to our loopback port? Tailscale
+ * strips the mount before forwarding, so the target must be the port's root.
+ */
+export function findTailscaleRoute(
+  serveStatus: any,
+  dns: string,
+  mount: string,
+  port: number,
+): TsRoute {
+  const handlers = serveStatus?.Web?.[`${dns}:443`]?.Handlers ?? {};
+  const want = mount.replace(/\/+$/, "");
+  for (const [p, h] of Object.entries<any>(handlers)) {
+    if (p.replace(/\/+$/, "") !== want) continue;
+    const proxy = String(h?.Proxy ?? "");
+    const m = /^(?:https?:\/\/)?(?:127\.0\.0\.1|localhost|\[::1\]):(\d+)(\/.*)?$/.exec(proxy);
+    if (m && Number(m[1]) === port && (!m[2] || m[2] === "/")) return { status: "ok" };
+    return { status: "conflict", proxy };
+  }
+  return { status: "missing" };
+}
+
+export function tailscaleServeArgv(mount: string, port: number): string[] {
+  return [
+    "tailscale",
+    "serve",
+    "--bg",
+    "--https=443",
+    `--set-path=${mount}`,
+    `http://127.0.0.1:${port}`,
+  ];
+}
+
+export function tailscaleServeOffArgv(mount: string): string[] {
+  return ["tailscale", "serve", "--https=443", `--set-path=${mount}`, "off"];
+}
+
+/** How to install portless with what's on PATH (npm first, as its docs say). */
+export function portlessInstallArgv(has: (bin: string) => boolean): string[] | null {
+  if (has("npm")) return ["npm", "install", "-g", "portless"];
+  if (has("bun")) return ["bun", "add", "-g", "portless"];
+  return null;
+}
+
+/** The one URL for the web console AND `ay connect` (HTTP modes). */
+export function httpShareUrl(base: string, token: string): string {
+  return `${base.replace(/\/+$/, "")}/#k=${encodeURIComponent(token)}`;
+}

package/ts/subcommands.spec.ts

@@ -199,6 +199,16 @@ describe("subcommands.isSubcommand", () => {
     expect(isSubcommand("ls", false)).toBe(true);
     expect(isSubcommand("send", false)).toBe(true);
   });
+
+  it("gates `share` / `connect` on the manager entry — they are prompt words", async () => {
+    const { isSubcommand } = await loadModule();
+    // `cy connect the frontend to the API` / `cy share this design` must reach
+    // the agent; the commands live on `ay share` / `ay connect`.
+    for (const sub of ["share", "connect"]) {
+      expect(isSubcommand(sub, true)).toBe(true);
+      expect(isSubcommand(sub, false)).toBe(false);
+    }
+  });
 });
 
 describe("subcommands ↔ rs/src/cli.rs subcommand mirror", () => {
@@ -295,6 +305,15 @@ describe("subcommands.cmdHelp", () => {
     expect(await capture()).toContain("ay notify watch --unread"); // Management entry
   });
 
+  it("labels `ay share` / `ay connect` as ay-only for cli-bound aliases", async () => {
+    // Both lines stay listed (sharing is how the console is reached at all) but
+    // must not read as invokable through `cy`, where those words are prompt text.
+    const alias = await capture(false);
+    expect(alias).toContain("ay share");
+    expect(alias).toContain("`cy share`/`cy connect` are prompts");
+    expect(await capture(true)).not.toContain("are prompts");
+  });
+
   it("stays plain for a human shell (no AGENT_YES_PID)", async () => {
     const out = await capture();
     expect(out).not.toContain("You are running inside an agent");

package/ts/subcommands.ts

@@ -663,11 +663,21 @@ const SUBCOMMANDS = new Set([
   "help",
 ]);
 
-// Subcommands reserved for the GENERIC manager (`ay` / `agent-yes`). A cli-bound
-// alias like `cy` (= claude-yes = "agent-yes claude") must NOT treat these as
-// subcommands — `cy setup …` should run claude with that text, not manage the
-// host. Kept separate from SUBCOMMANDS so a runner alias falls straight through.
-const MANAGER_SUBCOMMANDS = new Set(["setup", "ws"]);
+// Subcommands recognised ONLY on the GENERIC manager entry (`ay` / `agent-yes`).
+// A cli-bound alias like `cy` (= claude-yes = "agent-yes claude") must NOT treat
+// these as subcommands — it falls straight through to running the agent with that
+// text. Two reasons a name lands here: it manages the host, or it is an ordinary
+// English verb people open prompts with (`cy connect the frontend to the API`
+// must reach claude). Kept one per line so the two runtimes' copies of this list
+// stay easy to keep in sync.
+const MANAGER_SUBCOMMANDS = new Set([
+  // manage this host
+  "setup",
+  "ws",
+  // prompt-word verbs: reachable as `ay share` / `ay connect`
+  "share",
+  "connect",
+]);
 
 const IDLE_THRESHOLD_MS = 60 * 1000;
 
@@ -1108,6 +1118,14 @@ export async function runSubcommand(argv: string[]): Promise<number | null> {
         const { cmdRemote } = await import("./remotes.ts");
         return cmdRemote(rest);
       }
+      case "share": {
+        const { cmdShare } = await import("./shareCmd.ts");
+        return cmdShare(rest);
+      }
+      case "connect": {
+        const { cmdConnect } = await import("./remotes.ts");
+        return cmdConnect(rest);
+      }
       case "expose": {
         const { cmdExpose } = await import("./expose.ts");
         return cmdExpose(rest);
@@ -1252,6 +1270,13 @@ export async function cmdHelp(managerCommands = true): Promise<number> {
     ? `  ay ws ls [--status]                 list <owner>/<repo>/tree/<branch> workspaces\n` +
       `  ay ws new <owner>/<repo>[@branch]   clone/refresh a workspace (ay ws help for more)\n`
     : ``;
+  // `share` / `connect` are manager-entry-only for the other reason in
+  // MANAGER_SUBCOMMANDS: they are prompt words, so `cy share …` runs the agent.
+  // Both lines stay visible (`ay share` is how you reach the console at all) —
+  // just labelled, so nobody types `cy connect <url>` and starts a session.
+  const shareAliasNote = managerCommands
+    ? ``
+    : `                                      (\`ay\` only — \`cy share\`/\`cy connect\` are prompts)\n`;
   // Only agents carry AGENT_YES_PID — a human shell never sets it — so this
   // section is skipped entirely (no async work at all) for interactive use.
   const self = process.env.AGENT_YES_PID ? await resolveSender() : null;
@@ -1299,6 +1324,9 @@ export async function cmdHelp(managerCommands = true): Promise<number> {
       `\n` +
       `Remote:\n` +
       setupLine +
+      `  ay share [local|lan|tailscale|webrtc]  share this machine: one URL for web console + CLI\n` +
+      `  ay connect <share-url> [alias]      save another machine's share URL as a remote\n` +
+      shareAliasNote +
       `  ay schedule <when> <cli> -- <msg>   run an agent on a schedule (HH:MM or cron)\n` +
       `  ay serve [--port N]                 start HTTP API server (prints token)\n` +
       `  ay serve status                     show serve daemon/server status\n` +

package/ts/webrtcLink.ts

@@ -85,5 +85,7 @@ export function toWebrtcUrl(link: string): string | null {
 
 /** True if `spec` looks like a WebRTC share link (vs. an http remote or alias). */
 export function isWebrtcSpec(spec: string): boolean {
-  return spec.startsWith("webrtc://") || (/^https?:\/\//.test(spec) && spec.includes("#"));
+  // An http(s) URL counts only when its fragment parses as a room — an
+  // `ay share` console link (…/#k=<token>) is an http remote, not a room.
+  return spec.startsWith("webrtc://") || parseRaw(spec) !== null;
 }

package/dist/remotes-CY69MeQB.js

@@ -1,5 +0,0 @@
-import "./e2e-z1xpwSAg.js";
-import "./webrtcLink-CnQf9pmu.js";
-import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-5P__pAXA.js";
-
-export { cmdRemote };

package/dist/trayApp-s2VuJUP4.js

@@ -1,5 +0,0 @@
-import "./versionChecker-D6zM6Pdv.js";
-import "./rustBinary-BW3BGZ4y.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-DOgsH0en.js";
-
-export { cmdTray };