@tsconfigdotjson/vibe-os 0.0.0-stage → 0.1.0

package/server/mcp.ts

@@ -0,0 +1,291 @@
+// Which MCP servers this box has, and how to hand one of them to a profile.
+//
+// Claude has no "use only these servers" flag that takes names. What it has is
+// `--mcp-config`, which takes definitions, and `--strict-mcp-config`, which
+// says to ignore everything else. So picking servers per profile means writing
+// definitions somewhere and pointing at them.
+//
+// Copying a definition into the profile's arguments would work and is wrong for
+// two reasons: it puts whatever the server needs to authenticate — an API key
+// in `env`, a bearer token in `headers` — into a command line that shows up in
+// `ps`, and it freezes a copy that stops matching the box the moment the URL
+// changes. So the profile stores a *path* and the file behind it is regenerated
+// from the box's own config, the same way the model list is read off the
+// installed binary rather than hardcoded. Change a server with `claude mcp add`
+// and every profile using it follows.
+
+import { createHash } from "node:crypto";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  stat,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Where Claude keeps a server definition, which decides how long it lives.
+ *
+ * - `user` is `mcpServers` in `~/.claude.json` — the whole machine, permanent.
+ * - `project` is a `.mcp.json` checked into the repo — shared with whoever
+ *   clones it.
+ * - `local` is `projects."<dir>".mcpServers` in `~/.claude.json`, which is what
+ *   a bare `claude mcp add` writes. It is keyed by the directory it was run in,
+ *   so one added inside a workspace is gone with the worktree. Surfaced anyway,
+ *   labelled with that directory, because otherwise the answer to "I added it,
+ *   where is it?" is nowhere.
+ */
+import type { McpScope, McpServer } from "../shared/wire.ts";
+import { log } from "./log.ts";
+
+export type { McpScope, McpServer };
+
+/** Directories to look in. Kept separate because they mean different things. */
+export interface McpScan {
+  /** Project roots, whose `.mcp.json` is the project scope. */
+  roots: string[];
+  /** Directories that may hold local-scope servers: roots and their worktrees. */
+  dirs: string[];
+}
+
+interface Definition {
+  type?: string;
+  transport?: string;
+  url?: string;
+  command?: string;
+  args?: string[];
+}
+
+/**
+ * `~/.claude.json` for the account the sessions run as.
+ *
+ * `$HOME` first, `os.homedir()` after: the environment is what a service unit
+ * sets and what an operator can override, while the passwd entry is the right
+ * answer when nothing set it at all. This assumes the server and the SSH
+ * sessions are the same user, which is what the deployment instructions set up
+ * and what `harness.ts` already assumes when it looks for the binary.
+ */
+const claudeConfigPath = (): string =>
+  path.join(process.env.HOME || os.homedir(), ".claude.json");
+
+/** Where the generated single-server files live. Under the state dir, 0700. */
+export const mirrorDir = (stateDir: string): string =>
+  path.join(stateDir, "mcp");
+
+/**
+ * A stable filename for one server.
+ *
+ * Stable is the whole requirement: a profile stores this path, so it cannot
+ * change because some unrelated server appeared or went away. A plain
+ * `linear.json` is worth having for the common case — it is what the Advanced
+ * preview shows — so a user-scope server with a filename-safe name gets it, and
+ * everything else is disambiguated by a hash of what identifies it.
+ */
+function mirrorName(scope: McpScope, source: string, name: string): string {
+  if (scope === "user" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,47}$/.test(name))
+    return `${name}.json`;
+  const slug =
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "")
+      .slice(0, 32) || "server";
+  const hash = createHash("sha256")
+    .update(`${scope}\0${source}\0${name}`)
+    .digest("hex")
+    .slice(0, 8);
+  return `${slug}-${hash}.json`;
+}
+
+/** `http`/`sse` when there is a URL, `stdio` otherwise. Claude's own default. */
+function transportOf(def: Definition): string {
+  return def.type ?? def.transport ?? (def.url ? "http" : "stdio");
+}
+
+function detailOf(def: Definition): string {
+  if (def.url) return def.url;
+  return [def.command ?? "", ...(def.args ?? [])].join(" ").trim();
+}
+
+async function readJson(file: string): Promise<Record<string, unknown> | null> {
+  try {
+    return JSON.parse(await readFile(file, "utf8")) as Record<string, unknown>;
+  } catch {
+    // Absent is the common case and not worth a line; malformed is the box's
+    // problem to fix and would be reported by Claude itself.
+    return null;
+  }
+}
+
+const asServers = (value: unknown): Record<string, Definition> =>
+  value && typeof value === "object"
+    ? (value as Record<string, Definition>)
+    : {};
+
+/**
+ * `~/.claude.json`, parsed at most once per change.
+ *
+ * It is a hundred-odd kilobytes on a machine that has been used, and this is
+ * read on every window attach as well as by the editor, so it is cached against
+ * the file's size and mtime rather than re-parsed each time.
+ */
+let cache: { key: string; data: Record<string, unknown> | null } | null = null;
+
+async function claudeConfig(): Promise<Record<string, unknown> | null> {
+  const file = claudeConfigPath();
+  let key = "missing";
+  try {
+    const info = await stat(file);
+    key = `${info.size}:${info.mtimeMs}`;
+  } catch {
+    // fall through with the sentinel; a missing file still caches as "nothing"
+  }
+  if (cache?.key === key) return cache.data;
+  const data = key === "missing" ? null : await readJson(file);
+  cache = { key, data };
+  return data;
+}
+
+/**
+ * Every MCP server visible to the given directories.
+ *
+ * Project scope reads only the roots: a worktree is a copy of the repo, so
+ * scanning worktrees too would list the same `.mcp.json` once per workspace.
+ */
+/**
+ * A discovered server together with the definition it was parsed from.
+ *
+ * The definition carries API keys and bearer tokens, so it deliberately does
+ * not travel on `McpServer`, which is a wire type the browser receives.
+ */
+export interface DiscoveredMcp {
+  server: McpServer;
+  def: Definition;
+}
+
+/** Discovery that keeps the parsed definitions, for the mirror writer. */
+export async function discoverMcpWithDefs(
+  stateDir: string,
+  scan: McpScan,
+): Promise<DiscoveredMcp[]> {
+  const found: DiscoveredMcp[] = [];
+  const add = (
+    scope: McpScope,
+    source: string,
+    name: string,
+    def: Definition,
+  ) => {
+    found.push({
+      def,
+      server: {
+        name,
+        scope,
+        source,
+        transport: transportOf(def),
+        detail: detailOf(def),
+        configPath: path.join(
+          mirrorDir(stateDir),
+          mirrorName(scope, source, name),
+        ),
+      },
+    });
+  };
+
+  const config = await claudeConfig();
+  if (config) {
+    for (const [name, def] of Object.entries(asServers(config.mcpServers))) {
+      add("user", claudeConfigPath(), name, def);
+    }
+    const projects = asServers(config.projects) as unknown as Record<
+      string,
+      { mcpServers?: unknown }
+    >;
+    for (const dir of new Set(scan.dirs)) {
+      for (const [name, def] of Object.entries(
+        asServers(projects[dir]?.mcpServers),
+      )) {
+        add("local", dir, name, def);
+      }
+    }
+  }
+
+  for (const root of new Set(scan.roots)) {
+    const file = path.join(root, ".mcp.json");
+    const data = await readJson(file);
+    if (!data) continue;
+    for (const [name, def] of Object.entries(asServers(data.mcpServers)))
+      add("project", file, name, def);
+  }
+
+  return found;
+}
+
+/** Just the wire shape, for the API and the profile editor. */
+export async function discoverMcp(
+  stateDir: string,
+  scan: McpScan,
+): Promise<McpServer[]> {
+  return (await discoverMcpWithDefs(stateDir, scan)).map((d) => d.server);
+}
+
+const NOTE = `Generated by vibe-os. One file per MCP server on this box, each holding just
+that server, so a profile can ask for exactly the ones it wants with
+--mcp-config. Rewritten from ~/.claude.json and each project's .mcp.json
+whenever the list is read or a window starts, so edit those, not these.
+`;
+
+/**
+ * Writes one file per server and removes the ones that no longer have a server.
+ *
+ * Pruning is deliberate: a profile pointing at a server that has been deleted
+ * should fail visibly at launch, not keep working from a copy nobody can see.
+ * Files are only rewritten when the contents actually differ, so this stays
+ * cheap enough to run on every window attach.
+ */
+/**
+ * Writes one file per MCP server, so a profile can point `--mcp-config` at
+ * exactly the ones it wants.
+ *
+ * Takes the definitions discovery already parsed rather than looking each one
+ * up again: the previous version re-read and re-parsed the source file once per
+ * server, so a project with five servers in one `.mcp.json` read that file five
+ * times — on every certificate request.
+ */
+export async function syncMcpMirrors(
+  stateDir: string,
+  discovered: DiscoveredMcp[],
+): Promise<void> {
+  const dir = mirrorDir(stateDir);
+
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+
+  const wanted = new Set<string>();
+  for (const { server, def } of discovered) {
+    if (!def) continue;
+    wanted.add(path.basename(server.configPath));
+    const body = `${JSON.stringify({ mcpServers: { [server.name]: def } }, null, 2)}\n`;
+    // Definitions carry API keys and bearer tokens, so 0600 and never anywhere
+    // the web root can reach.
+    if (
+      (await readFile(server.configPath, "utf8").catch(() => null)) !== body
+    ) {
+      await writeFile(server.configPath, body, { mode: 0o600 });
+      log.debug(`wrote mcp config for ${server.name} (${server.scope})`);
+    }
+  }
+
+  // Compared first, like the json files beside it: this runs on every
+  // certificate request, and rewriting an unchanged file each time is a write
+  // for nothing.
+  const readmePath = path.join(dir, "README");
+  if ((await readFile(readmePath, "utf8").catch(() => null)) !== NOTE)
+    await writeFile(readmePath, NOTE, { mode: 0o600 }).catch(() => {});
+
+  for (const entry of await readdir(dir).catch(() => [] as string[])) {
+    if (!entry.endsWith(".json") || wanted.has(entry)) continue;
+    await unlink(path.join(dir, entry)).catch(() => {});
+    log.debug(`removed stale mcp config ${entry}`);
+  }
+}

package/server/preflight.ts

@@ -0,0 +1,87 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, copyFile } from "node:fs/promises";
+import path from "node:path";
+import { isFile } from "./fsx.ts";
+import { log } from "./log.ts";
+import { FETCH_WASM, IS_COMPILED, PKG_ROOT } from "./runtime.ts";
+
+const WASM_FILES = ["ssh.wasm", "wasm_exec.js"];
+
+/**
+ * Downloads the pair unconditionally.
+ *
+ * Deliberately without `--if-missing`: that flag answers "is the pair in
+ * public/ *or* in the package's own dist/web", and the only caller has already
+ * established that public/ does not have them. With a custom --web-root and a
+ * populated dist/web, the flag made the script exit successfully having copied
+ * nothing, and ensureWasm then reported the files as unfetchable on a machine
+ * that had them.
+ */
+function runFetchScript(): Promise<void> {
+  const script = FETCH_WASM;
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [script], {
+      stdio: "inherit",
+    });
+    child.on("error", reject);
+    child.on("close", (code) =>
+      code === 0 ? resolve() : reject(new Error(`fetch-wasm exited ${code}`)),
+    );
+  });
+}
+
+/**
+ * Makes sure the WASM pair is present in the served directory.
+ *
+ * These are the only two files that are not built from this repo, so they can
+ * legitimately be missing on a fresh checkout or after a failed (soft-failing)
+ * postinstall. Fetching here rather than erroring means the first run of
+ * `vibe-os start` on a blank VPS still works.
+ */
+export async function ensureWasm(webRoot: string): Promise<void> {
+  // A compiled binary carries every asset inside it; there is no directory to
+  // check and nothing to fetch.
+  if (IS_COMPILED) return;
+
+  const missing = [];
+  for (const name of WASM_FILES) {
+    if (!(await isFile(path.join(webRoot, name)))) missing.push(name);
+  }
+  if (missing.length === 0) return;
+
+  const publicDir = path.join(PKG_ROOT, "public");
+  const stillMissing = [];
+  for (const name of missing) {
+    if (!(await isFile(path.join(publicDir, name)))) stillMissing.push(name);
+  }
+
+  if (stillMissing.length > 0) {
+    log.info(`fetching ${stillMissing.join(" and ")}…`);
+    await runFetchScript();
+  }
+
+  for (const name of missing) {
+    const from = path.join(publicDir, name);
+    if (await isFile(from)) {
+      await copyFile(from, path.join(webRoot, name));
+    } else {
+      throw new Error(
+        `${name} is missing from ${webRoot} and could not be fetched`,
+      );
+    }
+  }
+}
+
+export async function ensureWebRoot(webRoot: string): Promise<void> {
+  if (IS_COMPILED) return;
+
+  try {
+    await access(path.join(webRoot, "index.html"), constants.R_OK);
+  } catch {
+    throw new Error(
+      `no built web app at ${webRoot}\n` +
+        "  If you are running from a git checkout, build it first:  bun run build",
+    );
+  }
+}

package/server/profiles.ts

@@ -0,0 +1,238 @@
+// Profiles: the roles you can open a terminal as.
+//
+// A profile is a name, a colour, a harness with its flags, and a standing
+// prompt. It belongs to a project, so it is available in every workspace of
+// that project — the prompts and flags describe the codebase, and workspaces
+// are throwaway worktrees of it.
+
+import { asc, eq } from "drizzle-orm";
+import { detokenize, tokenize } from "../shared/args.ts";
+import type { Harness, Profile, ProfileInput } from "../shared/wire.ts";
+import { type Db, newId, profiles, windows } from "./db.ts";
+
+/**
+ * The ten colours a profile can be.
+ *
+ * Stored as tokens rather than hex so the stylesheet stays the single place
+ * that decides what "coral" looks like, and so a stored value can be validated
+ * instead of trusted.
+ */
+export const PALETTE = [
+  "cyan",
+  "teal",
+  "green",
+  "lime",
+  "amber",
+  "orange",
+  "coral",
+  "rose",
+  "violet",
+  "blue",
+] as const;
+
+/**
+ * `satisfies` rather than a plain literal: it is what makes the runtime list and
+ * the wire type fail to compile if they ever stop agreeing.
+ */
+export const HARNESSES = [
+  "claude",
+  "hermes",
+  "cursor",
+  "shell",
+  "custom",
+] as const satisfies readonly Harness[];
+
+const MAX_NAME = 40;
+const MAX_PROMPT = 16_000;
+const MAX_ARGS = 64;
+const MAX_TOKEN = 512;
+
+export type { Profile, ProfileInput };
+export { detokenize, tokenize };
+
+function parseStoredArgs(raw: string): string[] {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return Array.isArray(parsed)
+      ? parsed.filter((t): t is string => typeof t === "string")
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+const hydrate = (row: typeof profiles.$inferSelect): Profile => ({
+  id: row.id,
+  projectId: row.projectId,
+  name: row.name,
+  color: row.color,
+  harness: row.harness as Harness,
+  command: row.command,
+  args: parseStoredArgs(row.args),
+  prompt: row.prompt,
+  position: row.position,
+  createdAt: row.createdAt,
+});
+
+/**
+ * Checks and normalises what the editor sent.
+ *
+ * `partial` is the update case, where an absent field means "leave it alone"
+ * rather than "clear it".
+ */
+type Fields = Partial<typeof profiles.$inferInsert>;
+/** What a non-partial validate guarantees: the three columns with no default. */
+type CompleteFields = Fields &
+  Required<Pick<typeof profiles.$inferInsert, "name" | "color" | "harness">>;
+
+function validate(input: ProfileInput, partial: true): Fields;
+function validate(input: ProfileInput, partial: false): CompleteFields;
+function validate(input: ProfileInput, partial: boolean): Fields {
+  const out: Fields = {};
+
+  if (input.name !== undefined || !partial) {
+    const name = (input.name ?? "").trim();
+    if (name.length === 0) throw new Error("a profile needs a name");
+    if (name.length > MAX_NAME)
+      throw new Error(`name must be ${MAX_NAME} characters or fewer`);
+    out.name = name;
+  }
+
+  if (input.color !== undefined || !partial) {
+    const color = input.color ?? PALETTE[0];
+    if (!(PALETTE as readonly string[]).includes(color))
+      throw new Error(`unknown colour ${color}`);
+    out.color = color;
+  }
+
+  if (input.harness !== undefined || !partial) {
+    const harness = input.harness ?? "claude";
+    if (!(HARNESSES as readonly string[]).includes(harness))
+      throw new Error(`unknown harness ${harness}`);
+    out.harness = harness;
+  }
+
+  if (input.command !== undefined || !partial) {
+    const command = (input.command ?? "").trim();
+    out.command = command === "" ? null : command;
+  }
+
+  if (input.args !== undefined || !partial) {
+    const tokens = tokenize(input.args ?? "");
+    if (tokens.length > MAX_ARGS)
+      throw new Error(`too many arguments (limit ${MAX_ARGS})`);
+    for (const token of tokens) {
+      if (token.length > MAX_TOKEN) throw new Error("an argument is too long");
+      // Both would be truncated or mangled by the time they reached execve.
+      if (token.includes("\0") || /[\r\n]/.test(token))
+        throw new Error("arguments cannot span lines");
+    }
+    out.args = JSON.stringify(tokens);
+  }
+
+  if (input.prompt !== undefined || !partial) {
+    const prompt = input.prompt ?? "";
+    if (prompt.length > MAX_PROMPT)
+      throw new Error(`prompt must be under ${MAX_PROMPT} characters`);
+    out.prompt = prompt;
+  }
+
+  // A custom harness with no command would launch nothing at all, silently.
+  const harness = out.harness ?? input.harness;
+  if (harness === "custom" && out.command === null)
+    throw new Error("a custom harness needs a command");
+
+  return out;
+}
+
+export function listProfiles(db: Db, projectId: string): Profile[] {
+  return db
+    .select()
+    .from(profiles)
+    .where(eq(profiles.projectId, projectId))
+    .orderBy(asc(profiles.position), asc(profiles.createdAt))
+    .all()
+    .map(hydrate);
+}
+
+export function getProfile(db: Db, id: string): Profile | undefined {
+  const row = db.select().from(profiles).where(eq(profiles.id, id)).get();
+  return row ? hydrate(row) : undefined;
+}
+
+export function createProfile(
+  db: Db,
+  projectId: string,
+  input: ProfileInput,
+): Profile {
+  const fields = validate(input, false);
+  const siblings = listProfiles(db, projectId);
+  const id = newId();
+
+  db.insert(profiles)
+    .values({
+      id,
+      projectId,
+      name: fields.name,
+      color: fields.color,
+      harness: fields.harness,
+      command: fields.command ?? null,
+      args: fields.args ?? "[]",
+      prompt: fields.prompt ?? "",
+      position: input.position ?? siblings.length,
+      createdAt: Date.now(),
+    })
+    .run();
+
+  const created = getProfile(db, id);
+  if (!created) throw new Error(`profile ${id} vanished after insert`);
+  return created;
+}
+
+export function updateProfile(
+  db: Db,
+  id: string,
+  input: ProfileInput,
+): Profile | undefined {
+  const current = getProfile(db, id);
+  if (!current) return undefined;
+
+  // Merged before validating so a partial update cannot land an invalid
+  // combination — clearing the command on an already-custom profile, say.
+  const fields = validate(
+    { harness: current.harness, command: current.command, ...input },
+    true,
+  );
+  if (Object.keys(fields).length > 0) {
+    db.update(profiles).set(fields).where(eq(profiles.id, id)).run();
+  }
+  if (input.position !== undefined) {
+    db.update(profiles)
+      .set({ position: input.position })
+      .where(eq(profiles.id, id))
+      .run();
+  }
+  return getProfile(db, id);
+}
+
+/**
+ * Forgets a profile, leaving its windows running.
+ *
+ * Those windows are live sessions with real work in them. Deleting the
+ * definition of a role should not kill the session doing it — the window simply
+ * becomes an ordinary terminal.
+ */
+export function deleteProfile(db: Db, id: string): boolean {
+  const current = getProfile(db, id);
+  if (!current) return false;
+  db.update(windows)
+    .set({ profileId: null })
+    .where(eq(windows.profileId, id))
+    .run();
+  db.delete(profiles).where(eq(profiles.id, id)).run();
+  return true;
+}
+
+export function deleteProjectProfiles(db: Db, projectId: string): void {
+  db.delete(profiles).where(eq(profiles.projectId, projectId)).run();
+}