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

package/server/headless.ts

@@ -0,0 +1,358 @@
+// Starting a window, and typing into one, with no terminal attached.
+//
+// A window's session is normally created by the certificate's force-command
+// the first time a browser or `vibe-os attach` logs in as it. Automation wants
+// the window running before anyone looks at it, so `startSession` logs in the
+// same way: it mints a throwaway key, has the CA sign it with the window's
+// command, and connects to sshd with it. The session then comes from sshd, like
+// every other one, with the login environment and the logind session that go
+// with it. Spawning the command from this process instead would put it in the
+// server's cgroup, where restarting the service ends it.
+//
+// `paste` is the prompt band's Send, done from here: the text goes into the
+// pty wrapped in bracketed-paste markers, through `dtach -p`, which writes to a
+// session without attaching to it. Knowing when a window is ready for it, past
+// raw mode, needs its screen, which is screens.ts and the API's `deliver`.
+
+import { execFile, spawn } from "node:child_process";
+import { chmod, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { type AttachTarget, liveSessions } from "./attach.ts";
+import type { Config } from "./config.ts";
+import { log } from "./log.ts";
+import type { Profile } from "./profiles.ts";
+import { pgrep } from "./reaper.ts";
+import { socketPath, windowCommand } from "./session.ts";
+import type { SshCa } from "./ssh-ca.ts";
+
+const run = promisify(execFile);
+
+/** How long the certificate behind a headless login is good for. */
+const CERT_TTL_S = 60;
+/** How long the ssh login that creates the session may take. */
+const LOGIN_TIMEOUT_MS = 30_000;
+/** How long after the login the socket has to start answering. */
+const SOCKET_WAIT_MS = 5_000;
+/** How long `sendText` waits for the program to start reading keys. */
+export const INPUT_WAIT_MS = 60_000;
+/**
+ * How long the pty has to stay in raw mode before the program counts as ready.
+ *
+ * A harness switches the terminal to raw mode early in its startup, and
+ * switches on bracketed paste a moment after. Text that arrives in between is
+ * read as typed keys. A second of quiet covers the gap with room to spare.
+ */
+const SETTLE_MS = 1_000;
+const POLL_MS = 250;
+/** Between the paste and the Enter that submits it, so they are two events. */
+const SUBMIT_DELAY_MS = 300;
+
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+export interface StartDeps {
+  config: Config;
+  ca: SshCa;
+  /** `type blob`, as discovered at startup. Null skips host key checking. */
+  hostKey: string | null;
+}
+
+/** Whether a window's session is running. */
+export async function isLive(
+  config: Config,
+  target: AttachTarget,
+): Promise<boolean> {
+  return (await liveSessions(config)).has(target.session);
+}
+
+/**
+ * Creates a window's session if it is not running, without attaching to it.
+ *
+ * Returns false when the session was already there. `resume` is asked only when
+ * a session is about to be created, because answering it clears the window's
+ * flag: see `takeResume`.
+ */
+export async function startSession(
+  deps: StartDeps,
+  target: AttachTarget,
+  profile: Profile | undefined,
+  resume: () => boolean,
+): Promise<boolean> {
+  const { config, ca, hostKey } = deps;
+  if (await isLive(config, target)) return false;
+
+  const forceCommand = windowCommand(
+    target.session,
+    target.cwd,
+    config,
+    profile,
+    { resume: resume(), detached: true },
+  );
+  if (!forceCommand) throw new Error("sessions are off (--no-sessions)");
+
+  const dir = await mkdtemp(path.join(os.tmpdir(), "vibe-os-start-"));
+  try {
+    await chmod(dir, 0o700);
+    const key = path.join(dir, "id");
+    await run("ssh-keygen", ["-q", "-t", "ed25519", "-N", "", "-f", key], {
+      timeout: 15_000,
+    });
+    const cert = await ca.signUserCert({
+      publicKey: await readFile(`${key}.pub`, "utf8"),
+      principal: config.user,
+      identity: `vibe-os/${target.session}/headless`,
+      forceCommand,
+      ttlSeconds: CERT_TTL_S,
+    });
+    await writeFile(`${key}-cert.pub`, cert, { mode: 0o600 });
+
+    const knownHosts = path.join(dir, "known_hosts");
+    if (hostKey) {
+      await writeFile(
+        knownHosts,
+        `${knownHostsName(config.sshHost, config.sshPort)} ${hostKey}\n`,
+        { mode: 0o600 },
+      );
+    }
+
+    await ssh(
+      sshArgs(config, key, hostKey ? knownHosts : null),
+      LOGIN_TIMEOUT_MS,
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+
+  // The login returns once dtach has forked, which can be a moment before the
+  // socket is listening.
+  const deadline = Date.now() + SOCKET_WAIT_MS;
+  while (!(await isLive(config, target))) {
+    if (Date.now() > deadline)
+      throw new Error(
+        `${target.session} did not start; check the server log and vibe-os doctor`,
+      );
+    await sleep(POLL_MS);
+  }
+  log.info(`started ${target.session} with no terminal attached`);
+  return true;
+}
+
+/** How a host appears in known_hosts: bare on port 22, bracketed otherwise. */
+export function knownHostsName(host: string, port: number): string {
+  return port === 22 ? host : `[${host}]:${port}`;
+}
+
+/**
+ * The ssh invocation for a headless login.
+ *
+ * No command: the certificate forces one. `-T` because there is no terminal to
+ * give it, and `BatchMode` so nothing can stop to ask a question.
+ */
+export function sshArgs(
+  config: Config,
+  key: string,
+  knownHosts: string | null,
+): string[] {
+  const hostChecking = knownHosts
+    ? [
+        "-o",
+        "StrictHostKeyChecking=yes",
+        "-o",
+        `UserKnownHostsFile=${knownHosts}`,
+      ]
+    : ["-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null"];
+  return [
+    "-T",
+    "-i",
+    key,
+    "-o",
+    `CertificateFile=${key}-cert.pub`,
+    "-o",
+    "IdentitiesOnly=yes",
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "ConnectTimeout=10",
+    "-o",
+    "LogLevel=ERROR",
+    "-o",
+    "GlobalKnownHostsFile=/dev/null",
+    ...hostChecking,
+    "-p",
+    String(config.sshPort),
+    `${config.user}@${config.sshHost}`,
+  ];
+}
+
+function ssh(args: string[], timeout: number): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn("ssh", args, {
+      stdio: ["ignore", "ignore", "pipe"],
+      timeout,
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) =>
+      reject(new Error(`could not run ssh: ${err.message}`)),
+    );
+    child.on("exit", (code, signal) => {
+      if (code === 0) return resolve();
+      const reason =
+        stderr.trim().split("\n").pop() || `exit ${code ?? signal}`;
+      reject(new Error(`headless login failed: ${reason}`));
+    });
+  });
+}
+
+// ── typing into a session ────────────────────────────────────────────────────
+
+/**
+ * The bytes a paste of `text` puts on the wire.
+ *
+ * What xterm.js does for the browser's Send: line endings become carriage
+ * returns, the way a terminal sends Enter, and the text is wrapped in
+ * bracketed-paste markers so a multi-line prompt arrives as one block rather
+ * than submitting at its first newline. An end marker inside the text would
+ * close the paste early and type the rest, so the markers are stripped from it.
+ */
+export function pasteBytes(text: string): string {
+  const body = text
+    .replaceAll(PASTE_START, "")
+    .replaceAll(PASTE_END, "")
+    .replace(/\r?\n/g, "\r");
+  return `${PASTE_START}${body}${PASTE_END}`;
+}
+
+/** Writes bytes into a session's pty, as if typed, without attaching. */
+async function push(sock: string, bytes: string): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn("dtach", ["-p", sock], {
+      stdio: ["pipe", "ignore", "pipe"],
+      timeout: 10_000,
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("exit", (code) =>
+      code === 0
+        ? resolve()
+        : reject(new Error(stderr.trim() || `dtach -p exited ${code}`)),
+    );
+    child.stdin.end(bytes);
+  });
+}
+
+/**
+ * The terminal device the session's program runs on, like `/dev/pts/3`.
+ *
+ * The dtach master holds the pty and its one child is the program, which is
+ * where `ps` reports the device.
+ */
+export async function sessionTty(sock: string): Promise<string | null> {
+  for (const master of await pgrep(["-f", `^([^ ]*/)?dtach -n ${sock}`])) {
+    for (const child of await pgrep(["-P", String(master)])) {
+      const { stdout } = await run("ps", ["-o", "tty=", "-p", String(child)], {
+        timeout: 10_000,
+      }).catch(() => ({ stdout: "" }));
+      const tty = stdout.trim();
+      if (tty && tty !== "?" && tty !== "??") return `/dev/${tty}`;
+    }
+  }
+  return null;
+}
+
+/**
+ * Whether a terminal is in raw mode, which is how a program says it is reading
+ * keys itself. Null when it cannot be read.
+ */
+export async function isRaw(tty: string): Promise<boolean | null> {
+  const flag = process.platform === "darwin" ? "-f" : "-F";
+  try {
+    const { stdout } = await run("stty", [flag, tty, "-a"], {
+      timeout: 5_000,
+    });
+    return parseRaw(stdout);
+  } catch {
+    return null;
+  }
+}
+
+/** Reads `stty -a` output: `-icanon` means raw, `icanon` means cooked. */
+export function parseRaw(sttyOutput: string): boolean | null {
+  const words = sttyOutput.split(/[\s;]+/);
+  if (words.includes("-icanon")) return true;
+  if (words.includes("icanon")) return false;
+  return null;
+}
+
+/**
+ * Waits until the session's program is reading keys.
+ *
+ * A session started a moment ago is still a shell running `cd` and `stty`, and
+ * then a harness loading. The pty is in canonical mode until the program takes
+ * it, and the program's own setup may flush what is waiting, so text sent
+ * before then is lost or garbled. Raw mode held for `SETTLE_MS` is the signal.
+ */
+export async function waitForInput(
+  config: Config,
+  session: string,
+  timeoutMs = INPUT_WAIT_MS,
+): Promise<void> {
+  const sock = socketPath(config, session);
+  const deadline = Date.now() + timeoutMs;
+  let rawSince: number | null = null;
+  for (;;) {
+    const tty = await sessionTty(sock);
+    const raw = tty ? await isRaw(tty) : null;
+    const now = Date.now();
+    if (raw) {
+      rawSince ??= now;
+      if (now - rawSince >= SETTLE_MS) return;
+    } else {
+      rawSince = null;
+    }
+    if (now > deadline)
+      throw new Error(
+        tty
+          ? `${session} is not reading input after ${Math.round(timeoutMs / 1000)}s`
+          : `${session} is not running`,
+      );
+    await sleep(POLL_MS);
+  }
+}
+
+/** Pastes text into a running session, then presses Enter if asked to. */
+export async function sendText(
+  config: Config,
+  session: string,
+  text: string,
+  opts: { submit?: boolean; timeoutMs?: number } = {},
+): Promise<void> {
+  await waitForInput(config, session, opts.timeoutMs);
+  await paste(config, session, text);
+  if (opts.submit) await submit(config, session);
+}
+
+/** Pastes text into a session now, without waiting for it to be ready. */
+export async function paste(
+  config: Config,
+  session: string,
+  text: string,
+): Promise<void> {
+  await push(socketPath(config, session), pasteBytes(text));
+  log.info(`pasted ${text.length} characters into ${session}`);
+}
+
+/** Presses Enter, a moment after a paste so the two arrive as two events. */
+export async function submit(config: Config, session: string): Promise<void> {
+  await sleep(SUBMIT_DELAY_MS);
+  await push(socketPath(config, session), "\r");
+}

package/server/index.ts

@@ -5,19 +5,21 @@ import { promisify } from "node:util";
 import type { Server } from "bun";
 import { Acme } from "./acme.ts";
 import { createApi } from "./api.ts";
+import { interruptedWindows } from "./attach.ts";
 import { createGate, hostAllowed, hostName, originAllowed } from "./auth.ts";
 import {
   type BridgeData,
   bridgeConnections,
   createBridgeHandlers,
 } from "./bridge.ts";
-import type { Config } from "./config.ts";
+import { type Config, savePersisted } from "./config.ts";
 import { openDb } from "./db.ts";
-import { discoverClaude, discoverCursor, discoverHermes } from "./harness.ts";
+import { discover, harnesses } from "./harness.ts";
 import { json } from "./http.ts";
 import { color, describeError, log } from "./log.ts";
 import { ensureWasm, ensureWebRoot } from "./preflight.ts";
 import { scanProjects } from "./projects.ts";
+import { Screens } from "./screens.ts";
 import { windowCommand } from "./session.ts";
 import {
   discoverHostKey,
@@ -27,6 +29,7 @@ import {
 } from "./ssh-ca.ts";
 import { createStaticServer } from "./static.ts";
 import { WallpaperStore } from "./wallpapers.ts";
+import { markInterrupted } from "./windows.ts";
 
 const run = promisify(execFile);
 
@@ -230,23 +233,40 @@ export async function startServer(config: Config): Promise<RunningServer> {
   // on the very first page load rather than one poll later.
   await scanProjects(db, config);
 
-  // Warmed here, deliberately not awaited: asking the Claude binary what it
-  // supports costs a few seconds of its startup, and the answer is only needed
-  // the first time someone opens the profile editor. Doing it now means it is
-  // ready by then; doing it there would make the panel hang on first open.
-  void discoverClaude();
-  // Hermes is Python and answers three `config get` calls, so it is slower
-  // still. Same reasoning, more of it.
-  void discoverHermes();
-  // Cursor asks its own service for the model list and login state, so this
-  // one can wait on the network rather than a binary. Same reasoning again.
-  void discoverCursor();
+  // Before listening: the first browser to log in to one of these windows would
+  // otherwise quietly start a fresh session in it.
+  const interrupted = markInterrupted(
+    db,
+    await interruptedWindows(db, config).catch(() => []),
+  );
+  if (interrupted > 0)
+    log.info(
+      interrupted === 1
+        ? "1 window lost its session; the desktop will offer to bring it back"
+        : `${interrupted} windows lost their sessions; the desktop will offer to bring them back`,
+    );
+
+  // Warmed here, deliberately not awaited: asking a binary what it supports
+  // costs seconds of its startup (Hermes is Python; Cursor goes to the
+  // network), and the answer is only needed the first time someone opens the
+  // profile editor. Doing it now means it is ready by then.
+  for (const adapter of harnesses()) void discover(adapter.spec.id);
 
   const gate = createGate(config.token);
   // Only consulted without a token, so only worth the Tailscale probe then.
   const hosts = config.token ? new Set<string>() : await knownHosts(config);
   const serveStatic = createStaticServer(config.webRoot);
-  const handleApi = createApi({ config, ca, hostKey, wallpapers, db });
+  // What every running window shows, so the API can say what is on it.
+  const screens = new Screens(config);
+  if (config.sessions) screens.start();
+  const handleApi = createApi({
+    config,
+    ca,
+    hostKey,
+    wallpapers,
+    db,
+    screens,
+  });
   const bridge = createBridgeHandlers({
     host: config.sshHost,
     port: config.sshPort,
@@ -412,6 +432,18 @@ export async function startServer(config: Config): Promise<RunningServer> {
     log.warn(`listening on ${port} instead of ${config.port}`);
   }
 
+  // Where the client verbs on this box find the server: the port it actually
+  // bound, which may be the fallback, on an address that reaches it.
+  const loopback =
+    config.host === "0.0.0.0" || config.host === "::"
+      ? "127.0.0.1"
+      : config.host;
+  await savePersisted(config.stateDir, {
+    localUrl: `http://${loopback.includes(":") ? `[${loopback}]` : loopback}:${port}`,
+  }).catch((err: unknown) => {
+    log.warn(`could not record the local url: ${describeError(err)}`);
+  });
+
   let httpsServer: Server<BridgeData> | undefined;
   let stopRenewal: (() => void) | undefined;
   const extras: string[] = [];
@@ -461,6 +493,7 @@ export async function startServer(config: Config): Promise<RunningServer> {
     port,
     close() {
       stopRenewal?.();
+      screens.stop();
       httpServer.stop(true);
       httpsServer?.stop(true);
       log.info(`stopped (${bridgeConnections()} bridge connections were open)`);