agent-dag 3.22.0 → 3.22.3

package/src/server/open-url.mjs

@@ -1,242 +0,0 @@
-// Opening the browser, without the ten packages it used to cost.
-//
-// `open@10` was this package's ONLY runtime dependency, and it brought nine
-// more with it — bundle-name, default-browser, default-browser-id,
-// define-lazy-prop, is-docker, is-inside-container, is-wsl, run-applescript,
-// wsl-utils. Ten tarballs to fetch, extract and link on a machine whose npm
-// cache is empty, for one call, made once, whose whole job is to hand a
-// localhost URL to whatever the desktop already uses. On a fast link that is a
-// second; on the links the people who reported a hung `npx ccdeck` are on, it
-// is ten more round trips before the deck's own tarball is even unpacked.
-//
-// What it did that is worth keeping is the platform knowledge, and that is
-// small enough to hold here: three commands, plus the WSL case where
-// `process.platform` says linux and the browser is on the Windows side.
-//
-// DELIBERATELY FIRE AND FORGET. `open` returned a promise the boot awaited;
-// nothing downstream of that await needed the child, and a launcher that takes
-// its time — xdg-open on a machine with no desktop session hunting through
-// every handler it knows — held the boot behind it. Here the candidates are
-// tried in order, the failures move to the next one on their own, and the boot
-// never waits for any of it.
-import { spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
-
-/** How long a launcher gets to prove it worked before the next one is tried.
- *  A launcher that is still running is a launcher that found something: macOS
- *  `open` and cmd's `start` both exit at once, and xdg-open stays up as the
- *  browser's parent. So only an EARLY non-zero exit moves on. */
-export const LAUNCH_GRACE_MS = 1_500;
-
-/**
- * Is this a Linux that is really Windows?
- *
- * WSL reports `process.platform === "linux"`, has no desktop session of its
- * own on a default install, and its browser lives on the Windows side — so
- * xdg-open there either is not installed or opens nothing anybody can see.
- * Both signals are read because either can be absent: the env var is set by
- * the WSL launcher and lost by anything that scrubs the environment, and
- * /proc/version is the kernel's own answer and cannot be.
- */
-export function isWsl(platform = process.platform, env = process.env, readProcVersion = defaultProcVersion) {
-  if (platform !== "linux") return false;
-  if (env.WSL_DISTRO_NAME || env.WSL_INTEROP) return true;
-  return /microsoft/i.test(readProcVersion());
-}
-
-function defaultProcVersion() {
-  try {
-    return readFileSync("/proc/version", "utf8");
-  } catch {
-    return "";
-  }
-}
-
-/**
- * The launchers to try for `url`, best first.
- *
- * A list rather than one answer, because every platform below has a case where
- * the first choice is missing: a Linux without xdg-utils, a WSL without
- * wslview, a Windows whose comspec has been moved. Each entry is exactly what
- * `spawn` is given, so the test can read the command line rather than infer it.
- *
- * Exported with platform and env as parameters for the reason exec.mjs exports
- * its own that way: the Windows and Linux answers have to be checkable from the
- * Mac this is written on.
- */
-export function launchers(url, { platform = process.platform, env = process.env, wsl } = {}) {
-  const inWsl = wsl === undefined ? isWsl(platform, env) : wsl;
-
-  if (platform === "darwin") {
-    // The absolute path first: `open` is also a shell builtin in a few setups
-    // and a user's own script called `open` on the PATH is not unheard of, and
-    // /usr/bin/open has been on every macOS this package supports.
-    return [
-      { file: "/usr/bin/open", args: [url] },
-      { file: "open", args: [url] },
-    ];
-  }
-
-  if (platform === "win32") {
-    // PowerShell FIRST, and this order is the one thing here that was decided by
-    // evidence rather than by taste.
-    //
-    // `open@10` — the dependency this file replaces — launches a Windows URL
-    // through `powershell -EncodedCommand` running `Start "<url>"`. That is what
-    // every ccdeck install on Windows has been using, so it is the path with a
-    // year of field evidence behind it and `cmd /c start` has none.
-    //
-    // And the fallback below cannot rescue a wrong first choice. `start` exits 0
-    // whether or not anything opened — measured on a real Windows 10 box, exit
-    // code 0 with no browser process created — so a candidate list that led with
-    // it would never reach a second candidate, however badly the first had done.
-    // Leading with the one whose failure is visible is the only ordering where
-    // having a fallback means anything.
-    //
-    // The cost is PowerShell's startup, a few hundred milliseconds, and it is
-    // paid by nobody: openUrl does not wait for the launcher and the boot does
-    // not wait for openUrl.
-    const tries = [{
-      file: "powershell.exe",
-      // The URL as its own argv entry rather than inside a script string, where
-      // `;` and `&` are PowerShell's own operators.
-      args: ["-NoProfile", "-NonInteractive", "-Command", "Start-Process", url],
-    }];
-    const viaCmd = startCommand(url, env);
-    tries.push(viaCmd);
-    // comspec is read by startCommand, and a comspec pointing somewhere that is
-    // no longer there is the one way that line fails on a machine which is
-    // otherwise fine. The bare name is what the PATH would have answered.
-    if (viaCmd.file.toLowerCase() !== "cmd.exe") tries.push(startCommand(url, env, "cmd.exe"));
-    return tries;
-  }
-
-  if (inWsl) {
-    return [
-      // Ships with wslu and is what a WSL user's own `xdg-open` is usually
-      // symlinked to anyway. It knows how to hand a URL across the boundary.
-      { file: "wslview", args: [url] },
-      // No wslu: go to Windows directly. cmd.exe is reachable from WSL through
-      // the interop path and needs no PATH entry of its own.
-      startCommand(url, env, "/mnt/c/Windows/System32/cmd.exe"),
-      startCommand(url, env, "cmd.exe"),
-      // Last, and only useful on a WSL that really does run a desktop.
-      { file: "xdg-open", args: [url] },
-    ];
-  }
-
-  // Plain Linux, and every other Unix. xdg-open is the standard answer; the
-  // rest are the ones that exist on machines that never installed xdg-utils,
-  // in the order of how likely they are to be configured rather than merely
-  // present.
-  return [
-    { file: "xdg-open", args: [url] },
-    { file: "gio", args: ["open", url] },
-    { file: "x-www-browser", args: [url] },
-    { file: "sensible-browser", args: [url] },
-    { file: "wslview", args: [url] },
-  ];
-}
-
-/**
- * `start` the way cmd.exe needs to be given it.
- *
- * Three details, each of which is a bug if it is missing. The empty `""` is the
- * window TITLE — `start "http://…"` opens a console window titled with the URL
- * and nothing else happens. The URL is quoted so an `&` in a query string ends
- * the argument instead of the command. And `windowsVerbatimArguments` stops
- * Node quoting the line a second time, which is exactly what exec.mjs's
- * `viaCmd` does for the same reason.
- */
-export function startCommand(url, env = process.env, comspec) {
-  const shell = comspec || env.comspec || env.ComSpec || "cmd.exe";
-  return {
-    file: shell,
-    args: ["/d", "/s", "/c", `start "" "${url}"`],
-    opts: { windowsVerbatimArguments: true },
-  };
-}
-
-/**
- * The address to actually hand the desktop, or null when it is not one — and
- * the ONLY guard, since #798 removed the `isOpenable` boolean that sat in front
- * of it with no caller but the suite.
- *
- * Refuse anything that is not an http(s) URL: today's one caller passes a
- * loopback address this deck built itself, so this is not guarding against a
- * hostile input — it is guarding against the day a second caller passes a path,
- * because every launcher above would happily open it and `start` would run it.
- *
- * The guard used to parse into a local `u`, check its protocol and throw the
- * parse away — so what reached `launchers` was the RAW string. `new URL()`
- * accepts characters it normalizes only in `href`, a `"` among them, and on
- * Windows `startCommand` builds `start "" "<url>"` with
- * `windowsVerbatimArguments: true`, where a quote is syntax. Today the only
- * caller passes a loopback URL this deck built itself, so nothing is reachable;
- * the function's own doc says it exists "for the day a second caller passes a
- * path", and as written it would not have stopped that caller.
- *
- * Returning the normalized `href` means the string that was checked is the
- * string that is launched.
- */
-export function normalizeOpenable(url) {
-  try {
-    const u = new URL(String(url));
-    if (u.protocol !== "http:" && u.protocol !== "https:") return null;
-    return u.href;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Hand `url` to the desktop. Returns nothing, waits for nothing, throws never.
- *
- * The boot calls this between binding the port and starting the pulse line, and
- * neither of those has anything to learn from how it went — a browser that does
- * not open leaves a URL on screen that the user can click or paste, which is
- * the same recovery an error row would have offered.
- */
-export function openUrl(url, { platform = process.platform, env = process.env, spawnFn = spawn } = {}) {
-  const href = normalizeOpenable(url);
-  if (href === null) return;
-  const tries = launchers(href, { platform, env });
-
-  const attempt = (i) => {
-    if (i >= tries.length) return;
-    const { file, args, opts } = tries[i];
-    let child;
-    try {
-      child = spawnFn(file, args, {
-        stdio: "ignore",
-        // The launcher outlives us on purpose: xdg-open is the browser's parent
-        // process on a cold start, and a deck stopped with Ctrl+C two seconds
-        // later should not take the window with it. Not on Windows, where a
-        // detached child is a child with its own console — the thing
-        // windowsHide exists to prevent.
-        detached: platform !== "win32",
-        windowsHide: true,
-        ...opts,
-      });
-    } catch {
-      attempt(i + 1);
-      return;
-    }
-    // ENOENT and EACCES both land here rather than throwing, because the failure
-    // happens after spawn returns.
-    child.on("error", () => attempt(i + 1));
-    // An early non-zero exit is xdg-open saying it found no handler (exit 3) or
-    // cmd saying it could not find `start`. A launcher still alive after the
-    // grace period is one that worked, so the timer is what closes the question.
-    let open = true;
-    const settled = setTimeout(() => { open = false; }, LAUNCH_GRACE_MS);
-    settled.unref?.();
-    child.on("exit", (code) => {
-      clearTimeout(settled);
-      if (open && code !== 0) attempt(i + 1);
-    });
-    child.unref?.();
-  };
-
-  attempt(0);
-}

package/src/server/presence.mjs

@@ -1,40 +0,0 @@
-// Whether somebody is looking at the deck right now, as its tabs say.
-//
-// The server can tell whether a page is CONNECTED — `sseClients.size` — but not
-// whether anybody is looking at one: a tab behind other windows keeps its
-// stream open all day. The away-update (auto-update.mjs) needs the second fact,
-// so each tab reports it (src/web/presence.ts), and a claim expires here unless
-// it is renewed, because a tab that crashed or lost its network never gets to
-// take it back.
-export const PRESENCE_TTL_MS = 45_000;
-/** More tabs than anybody opens on one deck. A bound because the ids arrive
- *  from pages; past it the oldest claim goes. */
-const MAX_TABS = 32;
-const TAB_ID = /^[\w-]{1,64}$/;
-
-export function createPresence({ ttlMs = PRESENCE_TTL_MS } = {}) {
-  /** tab id → when it last said it was looking */
-  const seen = new Map();
-  return {
-    /** A tab saying whether it is being looked at. False for an id no page
-     *  could have made, which the route answers with a 400. */
-    report(tab, looking, now) {
-      if (typeof tab !== "string" || !TAB_ID.test(tab)) return false;
-      seen.delete(tab);
-      if (looking) {
-        seen.set(tab, now);
-        while (seen.size > MAX_TABS) seen.delete(seen.keys().next().value);
-      }
-      return true;
-    },
-    /** Whether any tab's claim is still live. A claim stamped by a clock that
-     *  has since moved either way is as expired as an old one. */
-    looking(now) {
-      for (const [tab, at] of seen) {
-        if (Math.abs(now - at) > ttlMs) seen.delete(tab);
-        else return true;
-      }
-      return false;
-    },
-  };
-}