@tsconfigdotjson/vibe-os 0.2.0-rc.1 → 0.3.0

package/server/attach.ts

@@ -20,7 +20,7 @@
 // process that owns the pty is `dtach -n <socket> …` and every attachment is
 // `dtach -a <socket>`. They differ in argv, so the two are never confused.
 
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { readdir, rm } from "node:fs/promises";
 import { promisify } from "node:util";
 import { and, desc, eq } from "drizzle-orm";
@@ -84,6 +84,8 @@ export interface AttachTarget {
   project: string;
   /** The role the window was opened as, when it has one. */
   role: string | null;
+  /** The caller's own tag for the window. */
+  label: string | null;
 }
 
 // ── resolution ───────────────────────────────────────────────────────────────
@@ -114,6 +116,7 @@ const targetRows = (db: Db) =>
       lastOpenedAt: workspaces.lastOpenedAt,
       project: projects.name,
       role: profiles.name,
+      label: windows.label,
     })
     .from(windows)
     .innerJoin(workspaces, eq(windows.workspaceId, workspaces.id))
@@ -133,6 +136,7 @@ const toTarget = (r: TargetRow): AttachTarget => ({
   workspace: r.workspace,
   project: r.project,
   role: r.role,
+  label: r.label,
 });
 
 export function resolveTarget(
@@ -189,41 +193,86 @@ export function commandFor(
   db: Db,
   config: Config,
   target: AttachTarget,
+  opts?: { resume?: boolean },
 ): string | undefined {
   const profile = target.profileId
     ? getProfile(db, target.profileId)
     : undefined;
-  return windowCommand(target.session, target.cwd, config, profile);
+  return windowCommand(target.session, target.cwd, config, profile, opts);
 }
 
 // ── talking to dtach ─────────────────────────────────────────────────────────
 
-/** Sessions with something still holding the other end of their socket. */
-export async function liveSessions(config: Config): Promise<Set<string>> {
+/**
+ * Whether something still holds the other end of a session socket.
+ *
+ * Writing nothing to it succeeds only then, which is what separates a live
+ * session from a socket a killed one left behind. "Nothing" has to be an empty
+ * stdin: `dtach -p` sends stdin until EOF, and execFile hands it a pipe that is
+ * never closed, so every probe ran to its timeout and read as dead.
+ */
+function answers(sock: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const child = spawn("dtach", ["-p", sock], {
+      stdio: "ignore",
+      timeout: 10_000,
+    });
+    child.on("error", () => resolve(false));
+    child.on("exit", (code) => resolve(code === 0));
+  });
+}
+
+/**
+ * Every socket in the sessions directory, split by whether anything answers.
+ *
+ * A dead one is a session that died without its harness exiting: dtach removes
+ * its socket when the program underneath exits, and only a kill (a reboot, the
+ * OOM killer) leaves the file behind with nothing holding it.
+ */
+async function probeSessions(
+  config: Config,
+): Promise<{ live: Set<string>; dead: Set<string> }> {
+  const live = new Set<string>();
+  const dead = new Set<string>();
   try {
     const dir = `${config.stateDir}/sessions`;
     const names = await readdir(dir);
-    const live = new Set<string>();
     await Promise.all(
       names
         .filter((n) => n.endsWith(".sock"))
         .map(async (n) => {
-          // Writing nothing to the socket succeeds only if something is still
-          // holding the other end, which is what separates a live session from
-          // a socket a crashed one left behind.
-          const ok = await run("dtach", ["-p", `${dir}/${n}`], {
-            timeout: 10_000,
-          })
-            .then(() => true)
-            .catch(() => false);
-          if (ok) live.add(n.replace(/\.sock$/, ""));
+          const ok = await answers(`${dir}/${n}`);
+          (ok ? live : dead).add(n.replace(/\.sock$/, ""));
         }),
     );
-    return live;
   } catch {
     // No sessions directory yet: nothing has ever been opened.
-    return new Set();
   }
+  return { live, dead };
+}
+
+/** Sessions with something still holding the other end of their socket. */
+export async function liveSessions(config: Config): Promise<Set<string>> {
+  return (await probeSessions(config)).live;
+}
+
+/**
+ * Windows whose session died under them rather than ending.
+ *
+ * Meant for server start, before any browser logs in: the first login to a
+ * window removes its dead socket on the way to creating a new session, and
+ * with it the only evidence there was something to bring back.
+ */
+export async function interruptedWindows(
+  db: Db,
+  config: Config,
+): Promise<string[]> {
+  if (!config.sessions) return [];
+  const { dead } = await probeSessions(config);
+  if (dead.size === 0) return [];
+  return listTargets(db)
+    .filter((t) => dead.has(t.session))
+    .map((t) => t.windowId);
 }
 
 /**

package/server/browser.ts

@@ -167,10 +167,7 @@ export interface Unit {
 /**
  * Where the units are written, named once.
  *
- * `install-browser` writes them and three readers go looking: doctor, the Hermes
- * discovery in `harness.ts`, and `connect-hermes`. They had a path literal each
- * until the third one wanted the same file, which is one copy past the point
- * where they can be trusted to stay in step.
+ * `install-browser` writes them and doctor goes looking for them.
  */
 export const UNIT_DIR = "/etc/systemd/system";
 export const CHROME_UNIT_PATH = `${UNIT_DIR}/vibe-os-chrome.service`;
@@ -419,67 +416,6 @@ export function vncPasswordFileFromUnit(
   return match ? match[1] : null;
 }
 
-/**
- * What Hermes has to be told so its browser tools drive this Chrome.
- *
- * Hermes reads its CDP target from `browser.cdp_url` in `~/.hermes/config.yaml`
- * and offers no flag for it, so this is set once for the box rather than per
- * profile. `browser-use` is named explicitly even though it is already the
- * default, because the default is conditional on the CLI being runnable and a
- * config that says what it means survives someone else reading it.
- *
- * `cloud_provider: local` is what stops a Browserbase or Firecrawl key, set
- * later for something else, from quietly taking the browser back.
- *
- * Returned as pairs rather than written here: they are handed to
- * `hermes config set`, which owns that file and knows where a secret goes.
- */
-export function hermesBrowserSettings(
-  cdpPort: number,
-): { key: string; value: string }[] {
-  return [
-    { key: "browser.cdp_url", value: `http://127.0.0.1:${cdpPort}` },
-    { key: "browser.backend", value: "browser-use" },
-    { key: "browser.cloud_provider", value: "local" },
-  ];
-}
-
-/**
- * Whether a configured `cdp_url` names this box's Chrome.
- *
- * Written by hand as often as by `connect-hermes`, so the comparison is on what
- * the URL means rather than on its spelling: `localhost` and `127.0.0.1` are the
- * same host, and `ws://` and `http://` are the same endpoint to a CDP client.
- * A bare `127.0.0.1:9222` is accepted too, because it is what people type.
- *
- * The port has to be explicit. A URL with no port is not a CDP endpoint that
- * would ever have worked, and inferring 80 from `http://` would report a
- * misconfigured box as connected.
- */
-export function cdpUrlMatches(
-  configured: string | null | undefined,
-  cdpPort: number,
-): boolean {
-  const raw = configured?.trim();
-  if (!raw) return false;
-  // A scheme is optional in what people write but not in what URL will parse.
-  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw)
-    ? raw
-    : `http://${raw}`;
-  let url: URL;
-  try {
-    url = new URL(withScheme);
-  } catch {
-    return false;
-  }
-  if (!/^(https?|wss?):$/.test(url.protocol)) return false;
-  if (url.port !== String(cdpPort)) return false;
-  // Chrome binds the debug port to loopback, so anything else is a different
-  // browser on a different machine and saying "connected" would be a guess.
-  const host = url.hostname.replace(/^\[/, "").replace(/\]$/, "");
-  return host === "127.0.0.1" || host === "localhost" || host === "::1";
-}
-
 export interface MemInfo {
   totalKb: number;
   swapKb: number;

package/server/cli.ts

@@ -18,17 +18,14 @@ import {
   BROWSER_COMMANDS,
   browserServices,
   browserUnits,
-  CHROME_UNIT_PATH,
-  DEFAULT_CDP_PORT,
   defaultBrowserOptions,
-  hermesBrowserSettings,
-  portsFromUnits,
   type Unit,
   VNC_PASSWORD_LENGTH,
   vncPasswordFileFromUnit,
   vncPasswordPath,
   XVNC_UNIT_PATH,
 } from "./browser.ts";
+import { runClient } from "./client.ts";
 import {
   type Config,
   parseCliArgs,
@@ -38,12 +35,13 @@ import {
 } from "./config.ts";
 import { openDb } from "./db.ts";
 import { type Check, homeFor, onPath, runDoctor } from "./doctor.ts";
-import { HERMES_INSTALL } from "./harness.ts";
+import { loadHarnesses } from "./harness.ts";
 import { startServer } from "./index.ts";
 import { color, describeError, log } from "./log.ts";
 import { reapLeaks } from "./reaper.ts";
 import { ENTRY, FETCH_WASM, IS_COMPILED } from "./runtime.ts";
 import { confirmFirewall, runSetup } from "./setup.ts";
+import { takeResume } from "./windows.ts";
 
 const run = promisify(execFile);
 const BUN = process.execPath;
@@ -60,9 +58,20 @@ const HELP = `
     vibe-os setup                fix what doctor finds, asking first
     vibe-os install-service      write and enable a systemd unit (needs root)
     vibe-os install-browser      run one Chrome on a virtual display (needs root)
-    vibe-os connect-hermes       point Hermes' browser tools at that Chrome
     vibe-os fetch-wasm           (re)download the SSH WASM runtime
 
+    vibe-os ls                   list windows, and what each is doing
+    vibe-os workspace new <project> [--from <branch>] [--name <name>]
+                                 cut a workspace
+    vibe-os workspace ls [project]
+                                 list workspaces
+    vibe-os open <workspace> [--profile <name>] [--prompt <text>]
+                 [--blank label=value] [--submit] [--force] [--label <text>]
+                                 open a window and start it
+    vibe-os output <window> [--lines <n>]
+                                 print what a window shows
+    vibe-os close <window>       close a window and end its session
+
   ${color.bold("Options")}
     --port <n>          HTTP port (default 80)
     --host <addr>       bind address (default 0.0.0.0)
@@ -86,6 +95,13 @@ const HELP = `
                         one the browser reached the desktop on
     --user <name>       unix user to log in as (default: current user)
     --no-sessions       plain login shells instead of persistent dtach sessions
+    --memory-high <size>
+                        throttle a window past this (default 40%, of RAM)
+    --memory-max <size> kill a window past this (default 50%)
+    --memory-swap-max <size>
+                        swap a window may use (default 10%, of RAM). Sizes
+                        are systemd's: 1500M, 2G, 40%, infinity
+    --no-memory-limit   start windows without a memory scope
     --cert-ttl <secs>   certificate lifetime (default 43200)
 
     --workspace <dir>   root for projects and worktrees (default ~/workspace)
@@ -95,6 +111,21 @@ const HELP = `
     -h, --help          show this
     -v, --version       print the version
 
+  ${color.bold("ls, workspace, open, output, close")}
+    --url <url>         the server to talk to (default VIBE_OS_URL, or on this
+                        box the address start is listening on)
+    --token <value>     its token (default VIBE_OS_TOKEN, or on this box the
+                        one start remembered)
+    --json              print JSON instead of text
+    --prompt <text>     paste this into the window; - reads it from stdin
+    --blank <label=value>
+                        fill a blank in the profile's prompt and paste that.
+                        Repeatable
+    --submit            press Enter after pasting
+    --force             open even when the box is short of memory
+    --label <text>      tag the window, to find it again in ls --json
+    --lines <n>         how many lines output prints (default 50)
+
   ${color.bold("install-browser")}
     --geometry <WxH>    virtual screen size (default 1600x900)
     --display <n>       X display number (default 99)
@@ -109,10 +140,6 @@ const HELP = `
                         this. An existing one is kept unless --no-vnc-password
     --no-vnc-password   serve the display with no authentication
 
-  ${color.bold("connect-hermes")}
-    --cdp-port <n>      the debug port to point Hermes at, when there is no
-                        installed browser unit to read it from
-
   ${color.bold("doctor")}
     --reap              kill processes that outlived their workspace or session
 
@@ -308,7 +335,7 @@ async function installBrowser(
       `  ${color.cyan("sudo apt install -y tigervnc-standalone-server openbox x11-utils")}`,
     );
     console.log(
-      `  ${color.dim("Chrome is not in the distro repos; see the README for the Google apt repo.")}`,
+      `  ${color.dim("Chrome is not in the distro repos; for the Google apt repo see https://github.com/tsconfigdotjson/vibe-os/blob/main/docs/deploying.md#an-always-on-browser")}`,
     );
     console.log("");
     return 1;
@@ -427,142 +454,6 @@ async function installBrowser(
     `  ${color.dim("Sign in to the extension once, through the viewer. The profile keeps it.")}`,
   );
 
-  // Last, and quietly. Hermes usually arrives after the browser, so not finding
-  // it is the common case rather than a failure worth interrupting the summary.
-  if (await connectHermes(user, home, opts.cdpPort, true)) {
-    console.log("");
-    console.log(
-      `  ${color.dim(`Hermes browser tools point at 127.0.0.1:${opts.cdpPort}.`)}`,
-    );
-  } else {
-    console.log("");
-    console.log(
-      `  ${color.dim("For Hermes browser tools, install it and run: vibe-os connect-hermes")}`,
-    );
-  }
-  console.log("");
-  return 0;
-}
-
-/**
- * Points Hermes' browser tools at this box's Chrome.
- *
- * Every setting goes through `hermes config set` rather than into the YAML
- * directly. Hermes owns that file, knows which of its keys are secrets and
- * belong in `.env` instead, and migrates its own schema between versions —
- * three things a hand-written merge here would have to keep guessing at.
- *
- * ── Why this is a box-wide setting and not a profile one ─────────────────────
- * The CDP target lives at `browser.cdp_url` in `~/.hermes/config.yaml` and has
- * no command-line equivalent, so there is nothing a profile could carry. Doing
- * it per launch would mean two Python startups before every window and a global
- * file rewritten by whichever window opened last.
- *
- * Returns false when Hermes is not installed, which is not an error: plenty of
- * boxes run the browser for the Claude extension and nothing else.
- */
-async function connectHermes(
-  user: string,
-  home: string,
-  cdpPort: number,
-  /** True when this process is root and has to drop to the login user. */
-  asUser: boolean,
-): Promise<boolean> {
-  /*
-   * A login shell, deliberately.
-   *
-   * Hermes installs to `/usr/local/bin` when it can write there and
-   * `~/.local/bin` when it cannot, and root's PATH reaches neither reliably
-   * under systemd. `runuser -l` runs `.profile`, which is what put the second
-   * one on PATH in the first place. runuser is util-linux, the same package
-   * `flock` comes from, so it is present wherever the session lock already is.
-   */
-  const asLoginUser = (script: string): [string, string[]] =>
-    asUser
-      ? ["runuser", ["-u", user, "--", "/bin/sh", "-lc", script]]
-      : ["/bin/sh", ["-lc", script]];
-
-  const [probe, probeArgs] = asLoginUser("command -v hermes");
-  const installed = await run(probe, probeArgs, {
-    timeout: 10_000,
-    env: { ...process.env, HOME: home },
-  })
-    .then(({ stdout }) => Boolean(stdout.trim()))
-    .catch(() => false);
-  if (!installed) return false;
-
-  for (const { key, value } of hermesBrowserSettings(cdpPort)) {
-    // Quoted as a single argument: a value never contains a space today, and
-    // the day one does is not the day to find out this was a bare expansion.
-    const [cmd, args] = asLoginUser(
-      `hermes config set ${JSON.stringify(key)} ${JSON.stringify(value)}`,
-    );
-    try {
-      await run(cmd, args, {
-        timeout: 60_000,
-        env: { ...process.env, HOME: home },
-      });
-      log.ok(`hermes ${key} = ${value}`);
-    } catch (err) {
-      log.error(`could not set hermes ${key}: ${describeError(err)}`);
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * `vibe-os connect-hermes` — the same thing, for a Hermes installed later.
- *
- * `install-browser` does this as its last step, but it is the browser's
- * installer and Hermes usually arrives after it. No root: it writes one file in
- * your own home directory, through a command you own.
- */
-async function connectHermesCommand(
-  config: Config,
-  values: RawOptions,
-): Promise<number> {
-  const user = process.env.SUDO_USER ?? config.user;
-  const home = (await homeFor(user)) ?? os.homedir();
-
-  // What the unit actually opened, not what the default is. install-browser may
-  // have been given --cdp-port long ago, and writing the default into Hermes
-  // would point it at a port nothing is listening on.
-  const unit = await readFile(CHROME_UNIT_PATH, "utf8").catch(() => null);
-  const cdpPort = values["cdp-port"]
-    ? numeric(values["cdp-port"], "cdp-port")
-    : unit
-      ? portsFromUnits({ chrome: unit }).cdpPort
-      : DEFAULT_CDP_PORT;
-
-  if (!unit && !values["cdp-port"]) {
-    log.warn(
-      `no browser installed here, so this assumes the default port ${cdpPort}`,
-    );
-    log.warn("run sudo vibe-os install-browser first, or pass --cdp-port");
-  }
-
-  const connected = await connectHermes(
-    user,
-    home,
-    cdpPort,
-    process.getuid?.() === 0,
-  );
-  if (!connected) {
-    log.error(`hermes is not installed for ${user}`);
-    console.log("");
-    console.log(`  ${color.cyan(HERMES_INSTALL)}`);
-    console.log("");
-    return 1;
-  }
-
-  console.log("");
-  console.log(
-    `  Hermes browser tools will drive the box's Chrome on 127.0.0.1:${cdpPort}.`,
-  );
-  console.log(
-    `  ${color.dim("Watch it work: ssh -L 5900:127.0.0.1:5900, then any VNC viewer.")}`,
-  );
   console.log("");
   return 0;
 }
@@ -714,7 +605,9 @@ async function attach(
   }
   if (!target) return 0;
 
-  const command = commandFor(db, config, target);
+  const command = commandFor(db, config, target, {
+    resume: takeResume(db, target.windowId),
+  });
   if (!command) {
     log.error(`could not build a command for ${target.ref}`);
     return 1;
@@ -795,6 +688,7 @@ export async function main(argv: string[]): Promise<number> {
   let config: Awaited<ReturnType<typeof resolveConfig>>;
   try {
     config = await resolveConfig(values);
+    loadHarnesses(config.stateDir);
   } catch (err) {
     log.error(describeError(err));
     console.log(HELP);
@@ -828,8 +722,6 @@ export async function main(argv: string[]): Promise<number> {
       return installService(config, argv);
     case "install-browser":
       return installBrowser(config, values);
-    case "connect-hermes":
-      return connectHermesCommand(config, values);
     case "fetch-wasm": {
       // A standalone binary carries the wasm inside it: there is no script on
       // disk to run (FETCH_WASM points into the virtual /$bunfs root) and
@@ -846,6 +738,12 @@ export async function main(argv: string[]): Promise<number> {
       process.stdout.write(stdout);
       return 0;
     }
+    case "ls":
+    case "workspace":
+    case "open":
+    case "output":
+    case "close":
+      return runClient(command, positionals.slice(1), values, config);
     case "help":
       console.log(HELP);
       return 0;