@moondeck/station 0.0.1 → 1.0.0

package/lib/user-credentials-store.ts

@@ -0,0 +1,435 @@
+/**
+ * ADR-134 slice 2 — per-user credentials on a Uai-operated host reconcile
+ * with the credential store at start, the same way engine accounts do
+ * (`reconcileEngineAccountsFromStore`):
+ *
+ *   <prefix>/users/<userId>/github         GitHub App user token
+ *   <prefix>/users/<userId>/ssh            the user's host-minted keypair
+ *   <prefix>/users/<userId>/mcp/<connId>   an MCP connection
+ *
+ *  - a parameter with no local row is imported (a replacement host inherits
+ *    every user's credentials without anyone reconnecting);
+ *  - a local row with no `store_ref` is uploaded (first start with the flag);
+ *  - a local row whose `store_ref` is under the listed path but absent from
+ *    it was removed elsewhere — it goes locally too.
+ * The write-through mirrors live next to each table's writes (ssh.ts,
+ * github-tokens.ts, mcp-connections.ts). Owned hosts: `configuredCredentialStore()`
+ * is null and nothing here runs.
+ */
+
+import {
+  configuredCredentialStore,
+  credentialStorePrefix,
+  isParameterPathSegment,
+  type CredentialStore,
+} from "./credential-store";
+import { projectEnvListPaths,
+  projectEnvListsByName, userCredentialListPath } from "./credential-store-scope";
+import {
+  deleteToken as deleteGithubTokenLocal,
+  githubTokenParameterName,
+  githubTokenStoreValue,
+  importGithubTokenFromStore,
+  listGithubTokenStoreRows,
+  setGithubTokenStoreRef,
+  type StoredGithubToken,
+} from "./github-tokens";
+import {
+  deleteMcpConnectionLocal,
+  importMcpConnectionFromStore,
+  listMcpConnectionStoreRows,
+  mcpConnectionParameterName,
+  mcpConnectionStoreValue,
+  setMcpConnectionStoreRef,
+  type StoredMcpConnection,
+} from "./mcp-connections";
+import {
+  deleteProjectEnvLocal,
+  importProjectEnvFromStore,
+  listProjectEnvStoreRows,
+  projectEnvParameterName,
+  projectEnvStoreValue,
+  setProjectEnvStoreRef,
+  noteProjectOrg,
+  tagProjectEnvParameter,
+  type StoredProjectEnv,
+} from "./host-env";
+import {
+  deleteKey as deleteSshKeyLocal,
+  importSshKeyFromStore,
+  listSshKeyStoreRows,
+  setSshKeyStoreRef,
+  sshKeyParameterName,
+  sshKeyStoreValue,
+  type StoredSshKey,
+} from "./ssh";
+
+export interface ReconcileUserCredentialsResult {
+  skipped: boolean;
+  imported: number;
+  uploaded: number;
+  removed: number;
+  errors: number;
+}
+
+type ParsedName =
+  | { kind: "github"; userId: string }
+  | { kind: "ssh"; userId: string }
+  | { kind: "mcp"; userId: string; id: string };
+
+/** `<prefix>/users/<u>/github|ssh|mcp/<id>`; null for anything else. */
+export function parseUserParameterName(
+  name: string,
+  prefix: string = credentialStorePrefix(),
+): ParsedName | null {
+  if (!name.startsWith(`${prefix}/users/`)) return null;
+  const parts = name.slice(prefix.length + 1).split("/");
+  if (!parts.every((p) => isParameterPathSegment(p))) return null;
+  const [, userId, what, id] = parts;
+  if (!userId || !what) return null;
+  if (parts.length === 3 && what === "github") return { kind: "github", userId };
+  if (parts.length === 3 && what === "ssh") return { kind: "ssh", userId };
+  if (parts.length === 4 && what === "mcp" && id) return { kind: "mcp", userId, id };
+  return null;
+}
+
+function obj(value: string): Record<string, unknown> {
+  const parsed: unknown = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("not an object");
+  }
+  const o = parsed as Record<string, unknown>;
+  if (o.v !== 1) throw new Error(`unsupported version ${String(o.v)}`);
+  return o;
+}
+function str(o: Record<string, unknown>, key: string): string {
+  const v = o[key];
+  if (typeof v !== "string") throw new Error(`bad ${key}`);
+  return v;
+}
+function strOrNull(o: Record<string, unknown>, key: string): string | null {
+  const v = o[key];
+  if (v === null || v === undefined) return null;
+  if (typeof v !== "string") throw new Error(`bad ${key}`);
+  return v;
+}
+function num(o: Record<string, unknown>, key: string): number {
+  const v = o[key];
+  if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`bad ${key}`);
+  return v;
+}
+function numOrNull(o: Record<string, unknown>, key: string): number | null {
+  const v = o[key];
+  if (v === null || v === undefined) return null;
+  if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`bad ${key}`);
+  return v;
+}
+
+export function parseStoredGithubToken(value: string): StoredGithubToken {
+  const o = obj(value);
+  if (o.kind !== "github") throw new Error("not a github token");
+  const generation = num(o, "generation");
+  if (!Number.isSafeInteger(generation) || generation < 0) throw new Error("bad generation");
+  return {
+    v: 1,
+    kind: "github",
+    userId: str(o, "userId"),
+    installationId: num(o, "installationId"),
+    generation,
+    tokenKind: str(o, "tokenKind"),
+    token: str(o, "token"),
+    expiresAt: numOrNull(o, "expiresAt"),
+    updatedAt: num(o, "updatedAt"),
+  };
+}
+
+export function parseStoredSshKey(value: string): StoredSshKey {
+  const o = obj(value);
+  if (o.kind !== "ssh") throw new Error("not an ssh key");
+  return {
+    v: 1,
+    kind: "ssh",
+    userId: str(o, "userId"),
+    publicKey: str(o, "publicKey"),
+    privateKey: str(o, "privateKey"),
+    createdAt: num(o, "createdAt"),
+    updatedAt: num(o, "updatedAt"),
+  };
+}
+
+export function parseStoredMcpConnection(value: string): StoredMcpConnection {
+  const o = obj(value);
+  if (o.kind !== "mcp") throw new Error("not an mcp connection");
+  return {
+    v: 1,
+    kind: "mcp",
+    id: str(o, "id"),
+    userId: str(o, "userId"),
+    url: str(o, "url"),
+    authKind: str(o, "authKind"),
+    tokenEndpoint: strOrNull(o, "tokenEndpoint"),
+    redirectUri: strOrNull(o, "redirectUri"),
+    clientId: strOrNull(o, "clientId"),
+    clientSecret: strOrNull(o, "clientSecret"),
+    pkceVerifier: strOrNull(o, "pkceVerifier"),
+    secret: strOrNull(o, "secret"),
+    status: str(o, "status"),
+    scopes: strOrNull(o, "scopes"),
+    updatedAt: num(o, "updatedAt"),
+  };
+}
+
+async function upload(
+  store: CredentialStore,
+  name: string,
+  value: unknown,
+  setRef: (ref: string) => void,
+): Promise<void> {
+  await store.put(name, JSON.stringify(value));
+  setRef(name);
+}
+
+export async function reconcileUserCredentialsFromStore(): Promise<ReconcileUserCredentialsResult> {
+  const result: ReconcileUserCredentialsResult = {
+    skipped: false,
+    imported: 0,
+    uploaded: 0,
+    removed: 0,
+    errors: 0,
+  };
+  const store = configuredCredentialStore();
+  if (!store) return { ...result, skipped: true };
+  const prefix = credentialStorePrefix();
+  const path = userCredentialListPath(prefix);
+  if (path === null) return { ...result, skipped: true };
+  const warn = (line: string): void =>
+    console.warn(`[user-credentials] credential store: ${line}`);
+
+  let listed: Array<{ name: string; value: string }>;
+  try {
+    listed = await store.list(path);
+  } catch (err) {
+    result.errors++;
+    warn(`listing ${path} failed: ${err instanceof Error ? err.message : String(err)}`);
+    // Nothing else is safe to decide without the inventory.
+    return result;
+  }
+
+  const github = new Map(listGithubTokenStoreRows().map((r) => [r.userId, r.storeRef]));
+  const ssh = new Map(listSshKeyStoreRows().map((r) => [r.userId, r.storeRef]));
+  const mcp = new Map(listMcpConnectionStoreRows().map((r) => [r.id, r]));
+  const seen = new Set<string>();
+
+  for (const param of listed) {
+    const at = parseUserParameterName(param.name, prefix);
+    if (!at) continue; // a neighbour from a later slice
+    seen.add(param.name);
+    try {
+      if (at.kind === "github") {
+        const value = parseStoredGithubToken(param.value);
+        if (value.userId !== at.userId) throw new Error("payload names another user");
+        if (github.has(at.userId)) {
+          if (github.get(at.userId) !== param.name) setGithubTokenStoreRef(at.userId, param.name);
+        } else if (importGithubTokenFromStore(value, param.name)) {
+          result.imported++;
+        }
+      } else if (at.kind === "ssh") {
+        const value = parseStoredSshKey(param.value);
+        if (value.userId !== at.userId) throw new Error("payload names another user");
+        if (ssh.has(at.userId)) {
+          if (ssh.get(at.userId) !== param.name) setSshKeyStoreRef(at.userId, param.name);
+        } else if (importSshKeyFromStore(value, param.name)) {
+          result.imported++;
+        }
+      } else {
+        const value = parseStoredMcpConnection(param.value);
+        if (value.userId !== at.userId || value.id !== at.id) {
+          throw new Error("payload does not describe the connection its path names");
+        }
+        const local = mcp.get(at.id);
+        if (local) {
+          if (local.storeRef !== param.name) setMcpConnectionStoreRef(at.id, param.name);
+        } else if (importMcpConnectionFromStore(value, param.name)) {
+          result.imported++;
+        }
+      }
+    } catch (err) {
+      result.errors++;
+      warn(`${param.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  const under = (ref: string): boolean => ref.startsWith(`${path}/`);
+  for (const [userId, storeRef] of github) {
+    try {
+      if (storeRef) {
+        if (under(storeRef) && !seen.has(storeRef)) {
+          deleteGithubTokenLocal(userId);
+          result.removed++;
+        }
+        continue;
+      }
+      const value = githubTokenStoreValue(userId);
+      if (!value) continue;
+      await upload(store, githubTokenParameterName(userId), value, (ref) =>
+        setGithubTokenStoreRef(userId, ref),
+      );
+      result.uploaded++;
+    } catch (err) {
+      result.errors++;
+      warn(`github token ${userId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  for (const [userId, storeRef] of ssh) {
+    try {
+      if (storeRef) {
+        if (under(storeRef) && !seen.has(storeRef)) {
+          deleteSshKeyLocal(userId);
+          result.removed++;
+        }
+        continue;
+      }
+      const value = sshKeyStoreValue(userId);
+      if (!value) continue;
+      await upload(store, sshKeyParameterName(userId), value, (ref) =>
+        setSshKeyStoreRef(userId, ref),
+      );
+      result.uploaded++;
+    } catch (err) {
+      result.errors++;
+      warn(`ssh key ${userId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  for (const [id, row] of mcp) {
+    try {
+      if (row.storeRef) {
+        if (under(row.storeRef) && !seen.has(row.storeRef)) {
+          deleteMcpConnectionLocal(id);
+          result.removed++;
+        }
+        continue;
+      }
+      const value = mcpConnectionStoreValue(id);
+      if (!value) continue;
+      await upload(store, mcpConnectionParameterName(row.userId, id), value, (ref) =>
+        setMcpConnectionStoreRef(id, ref),
+      );
+      result.uploaded++;
+    } catch (err) {
+      result.errors++;
+      warn(`mcp connection ${id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Slice 3: project env values, `<prefix>/projects/<projectId>/env/<KEY>`.
+// Same three moves as above, own listing.
+// ---------------------------------------------------------------------------
+
+export function parseProjectEnvParameterName(
+  name: string,
+  prefix: string = credentialStorePrefix(),
+): { projectId: string; key: string } | null {
+  if (!name.startsWith(`${prefix}/projects/`)) return null;
+  const parts = name.slice(prefix.length + 1).split("/");
+  if (parts.length !== 4 || parts[2] !== "env") return null;
+  if (!parts.every((p) => isParameterPathSegment(p))) return null;
+  const [, projectId, , key] = parts as [string, string, string, string];
+  return { projectId, key };
+}
+
+export function parseStoredProjectEnv(value: string): StoredProjectEnv {
+  const o = obj(value);
+  if (o.kind !== "project-env") throw new Error("not a project env value");
+  return {
+    v: 1,
+    kind: "project-env",
+    projectId: str(o, "projectId"),
+    key: str(o, "key"),
+    value: str(o, "value"),
+    updatedAt: num(o, "updatedAt"),
+    ...(typeof o.orgId === "string" && o.orgId.length > 0 ? { orgId: o.orgId } : {}),
+  };
+}
+
+/**
+ * Host start (whole tree) or, on a task machine, task-up with the task's
+ * project ids (ADR-133: the lease reads `/uai/projects/<id>` only for
+ * parameters tagged with its org, and only the task's projects matter).
+ */
+export async function reconcileProjectEnvFromStore(
+  opts: { projectIds?: readonly string[] } = {},
+): Promise<ReconcileUserCredentialsResult> {
+  const result: ReconcileUserCredentialsResult = {
+    skipped: false,
+    imported: 0,
+    uploaded: 0,
+    removed: 0,
+    errors: 0,
+  };
+  const store = configuredCredentialStore();
+  if (!store) return { ...result, skipped: true };
+  const prefix = credentialStorePrefix();
+  const paths = projectEnvListPaths(prefix, opts.projectIds);
+  if (paths === null) return { ...result, skipped: true };
+  const warn = (line: string): void => console.warn(`[project-env] credential store: ${line}`);
+  const listed: Array<{ name: string; value: string }> = [];
+  const listedPrefixes: string[] = [];
+  const byName = projectEnvListsByName();
+  for (const path of paths) {
+    try {
+      listed.push(...(byName ? await store.listByName(path) : await store.list(path)));
+      listedPrefixes.push(`${path}/`);
+    } catch (err) {
+      result.errors++;
+      warn(`listing ${path} failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const local = new Map(listProjectEnvStoreRows().map((r) => [`${r.projectId}/${r.key}`, r]));
+  const seen = new Set<string>();
+  for (const param of listed) {
+    const at = parseProjectEnvParameterName(param.name, prefix);
+    if (!at) continue;
+    seen.add(param.name);
+    try {
+      const value = parseStoredProjectEnv(param.value);
+      if (value.projectId !== at.projectId || value.key !== at.key) {
+        throw new Error("payload does not describe the value its path names");
+      }
+      const row = local.get(`${at.projectId}/${at.key}`);
+      if (row) {
+        if (row.storeRef !== param.name) setProjectEnvStoreRef(at.projectId, at.key, param.name);
+        if (value.orgId) noteProjectOrg(at.projectId, value.orgId);
+      } else if (importProjectEnvFromStore(value, param.name)) {
+        result.imported++;
+      }
+    } catch (err) {
+      result.errors++;
+      warn(`${param.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  for (const row of local.values()) {
+    try {
+      if (row.storeRef) {
+        const ref = row.storeRef;
+        if (listedPrefixes.some((p) => ref.startsWith(p)) && !seen.has(ref)) {
+          deleteProjectEnvLocal(row.projectId, row.key);
+          result.removed++;
+        }
+        continue;
+      }
+      const name = projectEnvParameterName(row.projectId, row.key);
+      const value = projectEnvStoreValue(row.projectId, row.key);
+      if (!name || !value) continue;
+      await upload(store, name, value, (ref) => setProjectEnvStoreRef(row.projectId, row.key, ref));
+      result.uploaded++;
+      if (value.orgId) await tagProjectEnvParameter(store, name, row.projectId, value.orgId);
+    } catch (err) {
+      result.errors++;
+      warn(`${row.projectId}/${row.key}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return result;
+}

package/lib/vnode-pressure.ts

@@ -0,0 +1,142 @@
+/**
+ * ADR-118 follow-up: the macOS vnode-table pressure sensor.
+ *
+ * Apple's Virtualization.framework virtiofs pins one host vnode per distinct
+ * guest-touched file for the life of the task VM (~12k per task after
+ * ADR-118 moved the pnpm store off virtiofs; ~130k+ before it). The table
+ * ceiling (`kern.maxvnodes`) is a boot-time default the host cannot raise
+ * without root, and AT the ceiling unrelated host software starts failing
+ * with ENFILE — the suspected 2026-08-24 kernel-panic precursor.
+ *
+ * Three surfaces ride this module:
+ *  - `readVnodePressure()` — the sensor (cached; null off-macOS).
+ *  - `vnodeAdmissionProblem()` — task-up guard: refuse to start ANOTHER
+ *    apple-container VM above the threshold instead of letting the kernel
+ *    hit the wall. Existing tasks keep running.
+ *  - `logVnodePressure()` — periodic observability, warn-level near the
+ *    ceiling so host logs explain refusals before they happen.
+ *
+ * Raising the ceiling needs root once: `sudo uai-host tune` (see cli.ts)
+ * installs a LaunchDaemon that reasserts the sysctls at every boot —
+ * sysctl writes alone are ephemeral.
+ */
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import { STATION } from "../src/station-identity";
+
+const exec = promisify(execFile);
+
+/** Refuse NEW apple task VMs above this fraction of the vnode ceiling. */
+const ADMISSION_THRESHOLD = 0.9;
+/** Warn-log above this fraction. */
+const WARN_THRESHOLD = 0.8;
+/**
+ * The vnode counter ALONE cannot refuse: `kern.num_vnodes` includes the
+ * reclaimable vnode cache, and a healthy long-uptime Mac converges to
+ * num_vnodes == maxvnodes forever (live false-positive, 2026-08-31: the
+ * Studio refused every task at "100%" with ZERO VMs running and the file
+ * table at 1.2%). Real virtiofs pinning holds OPEN FILES — the Aug-24
+ * incident read 96% of `kern.num_files/kern.maxfiles`. So refusal
+ * requires the vnode ratio AND genuine file-table pressure together.
+ */
+const FILE_TABLE_CORROBORATION_THRESHOLD = 0.5;
+const CACHE_MS = 15_000;
+
+export interface VnodePressure {
+  current: number;
+  max: number;
+  ratio: number;
+  filesCurrent: number;
+  filesMax: number;
+  filesRatio: number;
+}
+
+let cached: { at: number; value: VnodePressure | null } | null = null;
+
+export async function readVnodePressure(): Promise<VnodePressure | null> {
+  if (process.platform !== "darwin") return null;
+  if (cached && Date.now() - cached.at < CACHE_MS) return cached.value;
+  let value: VnodePressure | null = null;
+  try {
+    const { stdout } = await exec(
+      "/usr/sbin/sysctl",
+      ["-n", "kern.num_vnodes", "kern.maxvnodes", "kern.num_files", "kern.maxfiles"],
+      { timeout: 5_000 },
+    );
+    const parts = stdout.trim().split(/\s+/).map(Number);
+    const current = parts[0] ?? Number.NaN;
+    const max = parts[1] ?? Number.NaN;
+    const filesCurrent = parts[2] ?? Number.NaN;
+    const filesMax = parts[3] ?? Number.NaN;
+    if (
+      Number.isFinite(current) &&
+      Number.isFinite(max) &&
+      max > 0 &&
+      Number.isFinite(filesCurrent) &&
+      Number.isFinite(filesMax) &&
+      filesMax > 0
+    ) {
+      value = {
+        current,
+        max,
+        ratio: current / max,
+        filesCurrent,
+        filesMax,
+        filesRatio: filesCurrent / filesMax,
+      };
+    }
+  } catch {
+    // Sensor failure is never a task failure; admission simply has no data.
+  }
+  cached = { at: Date.now(), value };
+  return value;
+}
+
+/** Non-null = refuse to start another apple-container task VM right now. */
+export async function vnodeAdmissionProblem(): Promise<string | null> {
+  const pressure = await readVnodePressure();
+  if (!pressure || pressure.ratio < ADMISSION_THRESHOLD) return null;
+  // A full vnode table with an idle file table is a warm cache, not danger.
+  if (pressure.filesRatio < FILE_TABLE_CORROBORATION_THRESHOLD) return null;
+  return (
+    `the macOS vnode table is at ${Math.round(pressure.ratio * 100)}% ` +
+    `(${pressure.current}/${pressure.max}) with the file table at ` +
+    `${Math.round(pressure.filesRatio * 100)}% ` +
+    `(${pressure.filesCurrent}/${pressure.filesMax}); starting another task ` +
+    "VM risks system-wide file-table exhaustion. Close a running task, or " +
+    `raise the ceiling once with: sudo ${STATION.command} tune`
+  );
+}
+
+let lastLoggedBand: "ok" | "warn" | "critical" = "ok";
+
+/** Log on band TRANSITIONS only, so a host sitting near the ceiling does not
+ * spam its own log every interval. */
+export async function logVnodePressure(): Promise<void> {
+  const pressure = await readVnodePressure();
+  if (!pressure) return;
+  const refusing =
+    pressure.ratio >= ADMISSION_THRESHOLD &&
+    pressure.filesRatio >= FILE_TABLE_CORROBORATION_THRESHOLD;
+  const band = refusing
+    ? "critical"
+    : pressure.filesRatio >= WARN_THRESHOLD || pressure.ratio >= WARN_THRESHOLD
+      ? "warn"
+      : "ok";
+  if (band === lastLoggedBand) return;
+  lastLoggedBand = band;
+  const detail =
+    `vnodes ${pressure.current}/${pressure.max} (${Math.round(pressure.ratio * 100)}%), ` +
+    `files ${pressure.filesCurrent}/${pressure.filesMax} (${Math.round(pressure.filesRatio * 100)}%)`;
+  if (band === "critical") {
+    console.warn(
+      `[vnode] table at ${detail} — new apple task VMs will be refused; run: sudo ${STATION.command} tune`,
+    );
+  } else if (band === "warn") {
+    console.warn(`[vnode] table filling: ${detail}`);
+  } else {
+    console.log(`[vnode] table pressure back to normal: ${detail}`);
+  }
+}