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

package/server/client.ts

@@ -0,0 +1,440 @@
+// The CLI verbs that drive a running server: `ls`, `workspace`, `open`,
+// `output`, `close`.
+//
+// Every one of them goes through the HTTP API rather than the database, so the
+// same command works on the box and from anywhere else with `--url` and
+// `--token`, and does exactly what the API does for any other client.
+
+import { readFile } from "node:fs/promises";
+import type {
+  Activity,
+  Profile,
+  SendResult,
+  WindowSummary,
+  WorkspaceSummary,
+} from "../shared/wire.ts";
+import { loadPersisted, type RawOptions } from "./config.ts";
+import { color, describeError, log } from "./log.ts";
+
+export interface Remote {
+  url: string;
+  token: string | null;
+}
+
+interface ProjectRow {
+  id: string;
+  name: string;
+  path: string;
+}
+
+/**
+ * Where the server is, and the token to show it.
+ *
+ * On the box both come from the state dir, where `start` records the address
+ * it bound and the token it requires. `--port` overrides the address. With `--url` the remembered token is
+ * not used, since it belongs to this box and not to the one named.
+ */
+export async function resolveRemote(
+  values: RawOptions,
+  local: { port: number; stateDir: string },
+): Promise<Remote> {
+  const given = (values.url as string | undefined) ?? process.env.VIBE_OS_URL;
+  const persisted = given ? {} : await loadPersisted(local.stateDir);
+  const recorded =
+    typeof persisted.localUrl === "string" ? persisted.localUrl : null;
+  const url = (
+    given ??
+    (values.port === undefined && recorded
+      ? recorded
+      : `http://127.0.0.1:${local.port}`)
+  ).replace(/\/+$/, "");
+  if (!/^https?:\/\//.test(url))
+    throw new Error(`--url must start with http:// or https://, not ${url}`);
+
+  let token: string | null = null;
+  if (typeof values.token === "string" && values.token !== "")
+    token = values.token;
+  else if (process.env.VIBE_OS_TOKEN) token = process.env.VIBE_OS_TOKEN;
+  else if (!given) token = persisted.token ?? null;
+  return { url, token };
+}
+
+/** Thrown for an answer the server gave, as opposed to not reaching it. */
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+    readonly body: Record<string, unknown>,
+  ) {
+    super(message);
+  }
+}
+
+export async function request<T>(
+  remote: Remote,
+  method: string,
+  route: string,
+  body?: unknown,
+): Promise<T> {
+  const headers: Record<string, string> = {};
+  if (remote.token) headers.authorization = `Bearer ${remote.token}`;
+  if (body !== undefined) headers["content-type"] = "application/json";
+
+  let res: Response;
+  try {
+    res = await fetch(`${remote.url}${route}`, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body),
+      redirect: "manual",
+    });
+  } catch (err) {
+    throw new Error(
+      `could not reach vibe-os at ${remote.url}: ${describeError(err)}`,
+    );
+  }
+
+  const text = await res.text();
+  let parsed: unknown;
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    parsed = { error: text.trim() || res.statusText };
+  }
+  if (!res.ok) {
+    const detail = (parsed as { error?: unknown }).error;
+    const message =
+      res.status === 401
+        ? `${remote.url} wants a token: pass --token or set VIBE_OS_TOKEN`
+        : typeof detail === "string"
+          ? detail
+          : `${method} ${route} answered ${res.status}`;
+    throw new ApiError(message, res.status, parsed as Record<string, unknown>);
+  }
+  return parsed as T;
+}
+
+// ── finding things by name ───────────────────────────────────────────────────
+
+/** A project by id, name or path. */
+export function findProject(projects: ProjectRow[], name: string): ProjectRow {
+  const found = projects.find(
+    (p) => p.id === name || p.name === name || p.path === name,
+  );
+  if (found) return found;
+  throw new Error(
+    projects.length === 0
+      ? `no project called ${name}: this box has no projects yet`
+      : `no project called ${name}. Projects: ${projects.map((p) => p.name).join(", ")}`,
+  );
+}
+
+/**
+ * A workspace by id, name, or `project/name`.
+ *
+ * Names are three random words, so two projects sharing one is unlikely, and
+ * an error that asks for the project is better than guessing.
+ */
+export function findWorkspace(
+  all: WorkspaceSummary[],
+  name: string,
+): WorkspaceSummary {
+  const byId = all.find((w) => w.id === name);
+  if (byId) return byId;
+  const slash = name.lastIndexOf("/");
+  const matches =
+    slash === -1
+      ? all.filter((w) => w.name === name)
+      : all.filter(
+          (w) =>
+            w.name === name.slice(slash + 1) &&
+            w.project === name.slice(0, slash),
+        );
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1)
+    throw new Error(
+      `${name} is in more than one project: ${matches.map((w) => `${w.project}/${w.name}`).join(", ")}`,
+    );
+  throw new Error(`no workspace called ${name}`);
+}
+
+/** A profile by id or by name, ignoring case. */
+export function findProfile(profiles: Profile[], name: string): Profile {
+  const lower = name.toLowerCase();
+  const found = profiles.find(
+    (p) => p.id === name || p.name.toLowerCase() === lower,
+  );
+  if (found) return found;
+  throw new Error(
+    profiles.length === 0
+      ? `no profile called ${name}: this project has no profiles`
+      : `no profile called ${name}. Profiles: ${profiles.map((p) => p.name).join(", ")}`,
+  );
+}
+
+/** A window by id or by ref, with or without the `vibe-` prefix. */
+export function findWindow(
+  windows: WindowSummary[],
+  name: string,
+): WindowSummary {
+  const ref = name.replace(/^vibe-/, "");
+  const found = windows.find((w) => w.id === name || w.ref === ref);
+  if (found) return found;
+  throw new Error(`no window called ${name}`);
+}
+
+/** `--blank key=value`, repeatable, into an object. */
+export function parseBlanks(pairs: string[]): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const pair of pairs) {
+    const at = pair.indexOf("=");
+    if (at <= 0) throw new Error(`--blank wants label=value, not ${pair}`);
+    out[pair.slice(0, at).trim()] = pair.slice(at + 1);
+  }
+  return out;
+}
+
+// ── the verbs ────────────────────────────────────────────────────────────────
+
+const print = (values: RawOptions, data: unknown, human: () => void) => {
+  if (values.json) console.log(JSON.stringify(data, null, 2));
+  else human();
+};
+
+/** A window's state, padded to one width so the columns line up. */
+function stateLabel(state: Activity | null): string {
+  const text = (state ?? "stopped").padEnd(8);
+  if (state === "busy") return color.green(text);
+  if (state === "question") return color.yellow(text);
+  if (state === "idle") return text;
+  return color.dim(text);
+}
+
+async function ls(remote: Remote, values: RawOptions): Promise<number> {
+  const windows = await request<WindowSummary[]>(remote, "GET", "/api/windows");
+  print(values, windows, () => {
+    if (windows.length === 0) {
+      console.log("no windows");
+      return;
+    }
+    for (const w of windows) {
+      const role = w.role ?? color.dim("terminal");
+      console.log(
+        `${stateLabel(w.state)}  ${w.ref.padEnd(30)} ${role.padEnd(20)} ${color.dim(`${w.project}/${w.workspace}`)}${w.label ? `  ${w.label}` : ""}`,
+      );
+    }
+  });
+  return 0;
+}
+
+async function workspace(
+  remote: Remote,
+  values: RawOptions,
+  args: string[],
+): Promise<number> {
+  const [verb, projectName] = args;
+  if (verb === "ls") {
+    const all = await request<WorkspaceSummary[]>(
+      remote,
+      "GET",
+      "/api/workspaces",
+    );
+    const shown = projectName
+      ? all.filter(
+          (w) => w.project === projectName || w.projectId === projectName,
+        )
+      : all;
+    print(values, shown, () => {
+      for (const w of shown)
+        console.log(`${w.project}/${w.name}  ${color.dim(w.path)}`);
+    });
+    return 0;
+  }
+  if (verb !== "new" || !projectName) {
+    log.error("usage: vibe-os workspace new <project> [--from <branch>]");
+    return 1;
+  }
+
+  const project = findProject(
+    await request<ProjectRow[]>(remote, "GET", "/api/projects"),
+    projectName,
+  );
+  const created = await request<{
+    id: string;
+    name: string;
+    path: string;
+    base: string;
+    warning: string | null;
+  }>(
+    remote,
+    "POST",
+    `/api/projects/${encodeURIComponent(project.id)}/workspaces`,
+    { name: values.name, from: values.from },
+  );
+  if (created.warning) log.warn(created.warning);
+  print(values, created, () => {
+    console.log(`${project.name}/${created.name}`);
+    console.log(color.dim(`  ${created.path}, from ${created.base}`));
+  });
+  return 0;
+}
+
+/** `--prompt -` reads the prompt from stdin, for text too long for argv. */
+async function promptText(values: RawOptions): Promise<string | undefined> {
+  if (values.prompt === undefined) return undefined;
+  const given = String(values.prompt);
+  if (given !== "-") return given;
+  return await readFile("/dev/stdin", "utf8");
+}
+
+async function open(
+  remote: Remote,
+  values: RawOptions,
+  name: string | undefined,
+): Promise<number> {
+  if (!name) {
+    log.error(
+      "usage: vibe-os open <workspace> [--profile <name>] [--prompt <text>] [--blank label=value]",
+    );
+    return 1;
+  }
+  const text = await promptText(values);
+  const blanks = parseBlanks(values.blank ?? []);
+  const hasBlanks = Object.keys(blanks).length > 0;
+  if (text !== undefined && hasBlanks)
+    throw new Error(
+      "--blank fills the profile's prompt, and --prompt replaces it: use one",
+    );
+
+  const ws = findWorkspace(
+    await request<WorkspaceSummary[]>(remote, "GET", "/api/workspaces"),
+    name,
+  );
+  let profileId: string | undefined;
+  if (values.profile) {
+    profileId = findProfile(
+      await request<Profile[]>(
+        remote,
+        "GET",
+        `/api/projects/${encodeURIComponent(ws.projectId)}/profiles`,
+      ),
+      String(values.profile),
+    ).id;
+  } else if (hasBlanks) {
+    throw new Error("--blank needs --profile, whose prompt it fills");
+  }
+
+  // One call: the server creates the window, starts it, waits for it to be
+  // ready and pastes, and takes the window back out if it cannot start.
+  const send = text !== undefined || hasBlanks;
+  type Opened = Partial<SendResult> & { window: WindowSummary };
+  let result: Opened;
+  try {
+    result = await request<Opened>(
+      remote,
+      "POST",
+      `/api/workspaces/${encodeURIComponent(ws.id)}/windows`,
+      {
+        profileId,
+        force: values.force === true,
+        label: values.label,
+        start: true,
+        prompt: text,
+        blanks: hasBlanks ? blanks : undefined,
+        submit: send ? values.submit === true : undefined,
+      },
+    );
+  } catch (err) {
+    if (err instanceof ApiError && err.body.capacity === true)
+      throw new Error(`${err.message}\nPass --force to open it anyway.`);
+    throw err;
+  }
+
+  const { window } = result;
+  print(values, values.json ? result : window, () => {
+    console.log(window.ref);
+    console.log(
+      color.dim(
+        `  ${window.role ?? "terminal"} in ${window.project}/${window.workspace}${send && result.delivered ? (values.submit ? ", prompt submitted" : ", prompt pasted") : ""}`,
+      ),
+    );
+  });
+  if (send && !result.delivered) {
+    log.error(
+      `${window.ref} is open, but the prompt was not sent: ${result.reason ?? result.state}.` +
+        ` See it with: vibe-os output ${window.ref}`,
+    );
+    return 1;
+  }
+  return 0;
+}
+
+async function output(
+  remote: Remote,
+  values: RawOptions,
+  name: string | undefined,
+): Promise<number> {
+  if (!name) {
+    log.error("usage: vibe-os output <window> [--lines <n>]");
+    return 1;
+  }
+  const win = findWindow(
+    await request<WindowSummary[]>(remote, "GET", "/api/windows"),
+    name,
+  );
+  const lines =
+    values.lines === undefined
+      ? ""
+      : `?lines=${encodeURIComponent(String(values.lines))}`;
+  const out = await request<{ text: string; state: Activity }>(
+    remote,
+    "GET",
+    `/api/windows/${encodeURIComponent(win.id)}/output${lines}`,
+  );
+  print(values, out, () => console.log(out.text));
+  return 0;
+}
+
+async function close(
+  remote: Remote,
+  name: string | undefined,
+): Promise<number> {
+  if (!name) {
+    log.error("usage: vibe-os close <window>");
+    return 1;
+  }
+  const win = findWindow(
+    await request<WindowSummary[]>(remote, "GET", "/api/windows"),
+    name,
+  );
+  await request(remote, "DELETE", `/api/windows/${encodeURIComponent(win.id)}`);
+  console.log(`closed ${win.ref}`);
+  return 0;
+}
+
+/** Runs one client verb. Errors are printed here, as one line. */
+export async function runClient(
+  command: "ls" | "workspace" | "open" | "output" | "close",
+  args: string[],
+  values: RawOptions,
+  local: { port: number; stateDir: string },
+): Promise<number> {
+  try {
+    const remote = await resolveRemote(values, local);
+    switch (command) {
+      case "ls":
+        return await ls(remote, values);
+      case "workspace":
+        return await workspace(remote, values, args);
+      case "open":
+        return await open(remote, values, args[0]);
+      case "output":
+        return await output(remote, values, args[0]);
+      case "close":
+        return await close(remote, args[0]);
+    }
+  } catch (err) {
+    log.error(describeError(err));
+    return 1;
+  }
+}

package/server/config.ts

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs, promisify } from "node:util";
+import { type MemoryLimits, parseSize } from "./memory.ts";
 
 const run = promisify(execFile);
 
@@ -63,6 +64,12 @@ export interface Config {
    * from whether dtach is installed, unless forced.
    */
   sessions: boolean;
+  /**
+   * The MemoryHigh and MemoryMax each window's scope gets unless its profile
+   * says otherwise, and the MemorySwapMax every window gets. All null
+   * (`--no-memory-limit`) starts windows without a scope at all.
+   */
+  memory: MemoryLimits;
 }
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
@@ -90,6 +97,10 @@ export const OPTION_SPEC = {
   "theme-color": { type: "string" as const },
   sessions: { type: "boolean" as const },
   "no-sessions": { type: "boolean" as const },
+  "memory-high": { type: "string" as const },
+  "memory-max": { type: "string" as const },
+  "memory-swap-max": { type: "string" as const },
+  "no-memory-limit": { type: "boolean" as const },
   // doctor only, same reasoning as the install-browser block below: parseArgs
   // is strict, so a flag it has never heard of is an error.
   reap: { type: "boolean" as const },
@@ -108,13 +119,29 @@ export const OPTION_SPEC = {
   "no-restart": { type: "boolean" as const },
   "vnc-password": { type: "string" as const },
   "no-vnc-password": { type: "boolean" as const },
+  // ls, workspace, open, output and close: the client verbs. `--token` is shared with
+  // start, where it is the token to require rather than the one to send.
+  url: { type: "string" as const },
+  json: { type: "boolean" as const },
+  name: { type: "string" as const },
+  from: { type: "string" as const },
+  profile: { type: "string" as const },
+  prompt: { type: "string" as const },
+  blank: { type: "string" as const, multiple: true },
+  submit: { type: "boolean" as const },
+  force: { type: "boolean" as const },
+  label: { type: "string" as const },
+  lines: { type: "string" as const },
   help: { type: "boolean" as const, short: "h" },
   version: { type: "boolean" as const, short: "v" },
 };
 
 export type RawOptions = Partial<
-  Record<Exclude<keyof typeof OPTION_SPEC, "allowed-host">, string | boolean>
-> & { "allowed-host"?: string[] };
+  Record<
+    Exclude<keyof typeof OPTION_SPEC, "allowed-host" | "blank">,
+    string | boolean
+  >
+> & { "allowed-host"?: string[]; blank?: string[] };
 
 /**
  * Flags that mean "generate one" when given no value.
@@ -225,6 +252,40 @@ function userName(value: unknown, label: string): string {
   return name;
 }
 
+/**
+ * Defaults that leave room for one runaway on a small box and change nothing
+ * on a large one: on 4 GB a window is throttled at 1.6 GB and killed at 2 GB.
+ */
+export const DEFAULT_MEMORY_HIGH = "40%";
+export const DEFAULT_MEMORY_MAX = "50%";
+/** Of RAM, as systemd reads it: about 400 MB of swap per window on 4 GB. */
+export const DEFAULT_MEMORY_SWAP_MAX = "10%";
+
+function memoryLimits(values: RawOptions): MemoryLimits {
+  if (flag(values["no-memory-limit"] ?? process.env.VIBE_OS_NO_MEMORY_LIMIT))
+    return { high: null, max: null, swapMax: null };
+  return {
+    high: parseSize(
+      values["memory-high"] ??
+        process.env.VIBE_OS_MEMORY_HIGH ??
+        DEFAULT_MEMORY_HIGH,
+      "--memory-high",
+    ),
+    max: parseSize(
+      values["memory-max"] ??
+        process.env.VIBE_OS_MEMORY_MAX ??
+        DEFAULT_MEMORY_MAX,
+      "--memory-max",
+    ),
+    swapMax: parseSize(
+      values["memory-swap-max"] ??
+        process.env.VIBE_OS_MEMORY_SWAP_MAX ??
+        DEFAULT_MEMORY_SWAP_MAX,
+      "--memory-swap-max",
+    ),
+  };
+}
+
 function num(value: unknown, fallback: number, label: string): number {
   if (value === undefined || value === "") return fallback;
   const n = Number(value);
@@ -381,5 +442,6 @@ export async function resolveConfig(values: RawOptions): Promise<Config> {
       "cert-ttl",
     ),
     sessions,
+    memory: memoryLimits(values),
   };
 }

package/server/db.ts

@@ -62,6 +62,9 @@ export const profiles = sqliteTable(
     /** JSON array of argv tokens, so each can be quoted on its own. */
     args: text("args").notNull().default("[]"),
     prompt: text("prompt").notNull().default(""),
+    /** systemd sizes for this role's scope, or null to use the server's. */
+    memoryHigh: text("memory_high"),
+    memoryMax: text("memory_max"),
     /** Order in the rail. */
     position: integer("position").notNull(),
     createdAt: integer("created_at").notNull(),
@@ -98,6 +101,14 @@ export const windows = sqliteTable(
     handoffAt: integer("handoff_at"),
     /** Set once a terminal has actually attached to this window's session. */
     handoffSeen: integer("handoff_seen").notNull().default(0),
+    /**
+     * 'ask' when the session died without its harness exiting (a reboot, a
+     * kill), so the desktop offers to bring it back rather than starting one.
+     * 'resume' once the answer was yes, until the next session is created.
+     */
+    restore: text("restore"),
+    /** Free text the caller tagged the window with, so it can find it again. */
+    label: text("label"),
     createdAt: integer("created_at").notNull(),
   },
   (t) => [index("windows_workspace_idx").on(t.workspaceId)],
@@ -131,6 +142,8 @@ const DDL = [
      command TEXT,
      args TEXT NOT NULL DEFAULT '[]',
      prompt TEXT NOT NULL DEFAULT '',
+     memory_high TEXT,
+     memory_max TEXT,
      position INTEGER NOT NULL,
      created_at INTEGER NOT NULL
    )`,
@@ -150,6 +163,8 @@ const DDL = [
      handoff TEXT,
      handoff_at INTEGER,
      handoff_seen INTEGER NOT NULL DEFAULT 0,
+     restore TEXT,
+     label TEXT,
      created_at INTEGER NOT NULL
    )`,
   `CREATE INDEX IF NOT EXISTS windows_workspace_idx ON windows (workspace_id)`,
@@ -173,6 +188,10 @@ const ADDED_COLUMNS: [table: string, column: string, decl: string][] = [
   ["windows", "handoff", "TEXT"],
   ["windows", "handoff_at", "INTEGER"],
   ["windows", "handoff_seen", "INTEGER NOT NULL DEFAULT 0"],
+  ["windows", "restore", "TEXT"],
+  ["windows", "label", "TEXT"],
+  ["profiles", "memory_high", "TEXT"],
+  ["profiles", "memory_max", "TEXT"],
 ];
 
 function ensureColumn(