@tsconfigdotjson/vibe-os 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsconfigdotjson/vibe-os",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A coding desktop in the browser, on a box you own. Git worktrees per piece of work, terminals that survive a reload, and SSH that runs in the tab.",
   "type": "module",
   "license": "MIT",

package/server/api.ts

@@ -25,7 +25,10 @@ import type { Db } from "./db.ts";
 import { ID_PATTERN } from "./db.ts";
 import { discover, specs } from "./harness.ts";
 import {
+  KEY_NAMES,
+  keyBytes,
   paste,
+  press,
   submit as pressEnter,
   startSession,
   waitForInput,
@@ -134,6 +137,9 @@ async function refreshMcpMirrors(db: Db, stateDir: string): Promise<void> {
 /** Ceiling on text sent to a window, matching a profile prompt's. */
 const MAX_SEND_CHARS = 16_000;
 
+/** Most keys one send can press. */
+const MAX_KEYS = 32;
+
 /** Longest label a window can be tagged with. */
 const MAX_LABEL_CHARS = 200;
 /**
@@ -162,7 +168,9 @@ function textToSend(
 ): string {
   if (body.text !== undefined) {
     if (typeof body.text !== "string" || body.text === "")
-      throw new Error("text must be a non-empty string");
+      throw new Error(
+        'text must be a non-empty string. To press Enter alone, send keys: ["Enter"]',
+      );
     if (body.blanks !== undefined)
       throw new Error(
         "blanks fill the profile prompt; leave out text to use it",
@@ -192,6 +200,31 @@ function textToSend(
   return filled.text;
 }
 
+/**
+ * The keys a send presses instead of pasting. Throws with a message for the
+ * caller when they are not keys, or come with something a key send ignores.
+ */
+function keysToPress(body: SendInput): string[] {
+  const { keys } = body;
+  if (
+    !Array.isArray(keys) ||
+    keys.length === 0 ||
+    keys.length > MAX_KEYS ||
+    keys.some((k) => typeof k !== "string")
+  )
+    throw new Error(`keys must be a list of 1 to ${MAX_KEYS} key names`);
+  const unknown = keys.find((k) => keyBytes(k) === null);
+  if (unknown !== undefined)
+    throw new Error(
+      `unknown key ${JSON.stringify(unknown)}. A key is one character or one of ${KEY_NAMES.join(", ")}`,
+    );
+  if (body.text !== undefined || body.blanks !== undefined)
+    throw new Error("send text or keys, not both");
+  if (body.submit !== undefined)
+    throw new Error('submit is for text; put "Enter" in keys instead');
+  return keys;
+}
+
 export interface ApiDeps {
   config: Config;
   ca: SshCa;
@@ -293,6 +326,25 @@ export function createApi(deps: ApiDeps) {
     return { started, delivered: true, state };
   }
 
+  /**
+   * Starts a window if need be, and presses keys in it once it reads them.
+   *
+   * No wait for quiet and no refusal on a question, unlike `deliver`: keys are
+   * how a question is answered, and an Escape is how a busy agent is stopped.
+   */
+  async function pressKeys(
+    target: AttachTarget,
+    profile: Profile | undefined,
+    keys: string[],
+  ): Promise<SendResult> {
+    const { session } = target;
+    const started = await start(target, profile);
+    await waitForInput(config, session);
+    const state = screens.get(session)?.activity() ?? "idle";
+    await press(config, session, keys);
+    return { started, delivered: true, state };
+  }
+
   return async function handleApi(
     req: Request,
     url: URL,
@@ -701,6 +753,7 @@ export function createApi(deps: ApiDeps) {
         : undefined;
 
       let text: string | undefined;
+      let keys: string[] | undefined;
       let submit = false;
       let force = false;
       if (startMatch[2] === "send") {
@@ -712,7 +765,8 @@ export function createApi(deps: ApiDeps) {
         submit = body.submit === true;
         force = body.force === true;
         try {
-          text = textToSend(body, profile);
+          if (body.keys !== undefined) keys = keysToPress(body);
+          else text = textToSend(body, profile);
         } catch (err) {
           return json({ error: describeError(err) }, 400);
         }
@@ -720,9 +774,11 @@ export function createApi(deps: ApiDeps) {
 
       try {
         const result =
-          text !== undefined
-            ? await deliver(target, profile, text, { submit, force })
-            : { started: await start(target, profile) };
+          keys !== undefined
+            ? await pressKeys(target, profile, keys)
+            : text !== undefined
+              ? await deliver(target, profile, text, { submit, force })
+              : { started: await start(target, profile) };
         return json({
           ...result,
           window: summarise(target, new Set([target.session])),

package/server/headless.ts

@@ -48,6 +48,8 @@ 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;
+/** Between keys pressed in one send, so each arrives as its own read. */
+const KEY_GAP_MS = 100;
 
 const PASTE_START = "\x1b[200~";
 const PASTE_END = "\x1b[201~";
@@ -356,3 +358,60 @@ export async function submit(config: Config, session: string): Promise<void> {
   await sleep(SUBMIT_DELAY_MS);
   await push(socketPath(config, session), "\r");
 }
+
+/** Keys a send can press by name, as the bytes a terminal sends for them. */
+const NAMED_KEYS: Record<string, string> = {
+  Enter: "\r",
+  Escape: "\x1b",
+  Tab: "\t",
+  BackTab: "\x1b[Z",
+  Backspace: "\x7f",
+  Delete: "\x1b[3~",
+  Space: " ",
+  Up: "\x1b[A",
+  Down: "\x1b[B",
+  Right: "\x1b[C",
+  Left: "\x1b[D",
+  Home: "\x1b[H",
+  End: "\x1b[F",
+  PageUp: "\x1b[5~",
+  PageDown: "\x1b[6~",
+};
+
+/** Every name `keyBytes` takes, for the caller's error message. */
+export const KEY_NAMES = [...Object.keys(NAMED_KEYS), "Ctrl+<letter>"];
+
+/**
+ * The bytes for one key: a name from `NAMED_KEYS`, `Ctrl+` and a letter, or a
+ * single character, which is typed as it is. Null for anything else.
+ */
+export function keyBytes(key: string): string | null {
+  if (Object.hasOwn(NAMED_KEYS, key)) return NAMED_KEYS[key];
+  const ctrl = /^Ctrl\+([A-Za-z])$/.exec(key);
+  if (ctrl)
+    return String.fromCharCode(ctrl[1].toUpperCase().charCodeAt(0) - 64);
+  // One character, counted by code point so an emoji is one too.
+  if ([...key].length === 1 && key >= " " && key !== "\x7f") return key;
+  return null;
+}
+
+/**
+ * Presses keys in a session, one at a time.
+ *
+ * Each is its own write, a moment after the last, so an Escape followed by a
+ * letter is read as two keys rather than as Alt and the letter.
+ */
+export async function press(
+  config: Config,
+  session: string,
+  keys: string[],
+): Promise<void> {
+  const sock = socketPath(config, session);
+  for (const [i, key] of keys.entries()) {
+    const bytes = keyBytes(key);
+    if (bytes === null) throw new Error(`unknown key ${key}`);
+    if (i > 0) await sleep(KEY_GAP_MS);
+    await push(sock, bytes);
+  }
+  log.info(`pressed ${keys.join(" ")} in ${session}`);
+}

package/server/screens.ts

@@ -18,7 +18,7 @@ import { readdir } from "node:fs/promises";
 import net from "node:net";
 import os from "node:os";
 import { promisify } from "node:util";
-import { Terminal } from "@xterm/headless";
+import { type IBufferLine, Terminal } from "@xterm/headless";
 import type { Activity } from "../shared/wire.ts";
 import type { Config } from "./config.ts";
 import { sessionTty } from "./headless.ts";
@@ -129,15 +129,23 @@ async function ttySize(
  * long line reads as it was written rather than as the width it was drawn at.
  * Blank lines at the bottom, which are only the unused part of the screen, are
  * dropped.
+ *
+ * Faint text on the cursor's line is left out. That is where a harness draws a
+ * placeholder or a suggested prompt, greyed out with SGR 2 (Claude's `Try
+ * "…"`, Codex's hint), and as plain text it reads the same as something typed
+ * and not yet sent. The cursor is the input caret in both, so its line is the
+ * input line.
  */
 export function bufferText(term: Terminal, count: number): string {
   const buf = term.buffer.active;
+  const cursorRow = buf.baseY + buf.cursorY;
   const lines: string[] = [];
   for (let i = 0; i < buf.length; i++) {
     const line = buf.getLine(i);
     if (!line) continue;
     // Untrimmed until joined, or a space at the wrap point would be lost.
-    const text = line.translateToString(true);
+    const text =
+      i === cursorRow ? withoutFaint(line) : line.translateToString(true);
     if (line.isWrapped && lines.length > 0) lines[lines.length - 1] += text;
     else lines.push(text);
   }
@@ -147,6 +155,18 @@ export function bufferText(term: Terminal, count: number): string {
   return trimmed.slice(-count).join("\n");
 }
 
+/** A line's text with every faint cell read as a blank. */
+function withoutFaint(line: IBufferLine): string {
+  let text = "";
+  for (let x = 0; x < line.length; x++) {
+    const cell = line.getCell(x);
+    // The second half of a wide character has width 0 and no text of its own.
+    if (!cell || cell.getWidth() === 0) continue;
+    text += cell.isDim() ? " ".repeat(cell.getWidth()) : cell.getChars() || " ";
+  }
+  return text.trimEnd();
+}
+
 /** One session's screen, kept up to date by its connection. */
 export class Screen {
   readonly term = new Terminal({

package/shared/wire.ts

@@ -222,13 +222,15 @@ export interface SendInput {
   submit?: boolean;
   /** Paste even when the window is stopped on a question. */
   force?: boolean;
+  /** Instead of text: keys to press, like `["Enter"]` or `["Escape"]`. */
+  keys?: string[];
 }
 
 /** What a send did. */
 export interface SendResult {
   /** The session was started for this send. */
   started: boolean;
-  /** The text went in and the window drew it. */
+  /** The text went in and the window drew it, or the keys were pressed. */
   delivered: boolean;
   /** What the window was doing when the text went in, or why it did not. */
   state: Activity;