@runuai/host 0.4.1 → 0.4.3

package/db/migrations/0008_host_mcp_connections.sql

@@ -0,0 +1,18 @@
+-- ADR-057: user-authed MCP connections. Secrets sealed with the host master
+-- key (ct.nonce base64, like host_project_env.value_enc); the cloud holds only
+-- non-secret metadata.
+CREATE TABLE `host_mcp_connections` (
+	`id` text PRIMARY KEY NOT NULL,
+	`user_id` text NOT NULL,
+	`url` text NOT NULL,
+	`auth_kind` text NOT NULL,
+	`token_endpoint` text,
+	`redirect_uri` text,
+	`client_id` text,
+	`client_secret_enc` text,
+	`pkce_verifier_enc` text,
+	`secret_enc` text,
+	`status` text DEFAULT 'pending' NOT NULL,
+	`scopes` text,
+	`updated_at` integer NOT NULL
+);

package/db/migrations/meta/_journal.json

@@ -57,6 +57,13 @@
       "when": 1779900008000,
       "tag": "0007_host_github_token_kind",
       "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "6",
+      "when": 1779900009000,
+      "tag": "0008_host_mcp_connections",
+      "breakpoints": true
     }
   ]
-}
+}

package/db/schema.ts

@@ -115,3 +115,31 @@ export const hostProjectEnv = sqliteTable(
 
 export type HostProjectEnv = typeof hostProjectEnv.$inferSelect;
 export type NewHostProjectEnv = typeof hostProjectEnv.$inferInsert;
+
+// User-authed MCP connections (ADR-057). One row per cloud connection id; all
+// secret material (static header, OAuth client secret, PKCE verifier, tokens)
+// is sealed with the host master key in single-column `ct.nonce` base64 form
+// (same packing as host_project_env). The cloud only ever holds the non-secret
+// metadata; acks never echo secrets back.
+export const mcpConnections = sqliteTable("host_mcp_connections", {
+  id: text("id").primaryKey(), // cloud uai_mcp_connections id
+  userId: text("user_id").notNull(),
+  url: text("url").notNull(),
+  // "oauth" | "token" | "none"
+  authKind: text("auth_kind").notNull(),
+  // OAuth machinery discovered at probe time.
+  tokenEndpoint: text("token_endpoint"),
+  redirectUri: text("redirect_uri"),
+  clientId: text("client_id"),
+  clientSecretEnc: text("client_secret_enc"),
+  // PKCE verifier held between probe and oauth.complete.
+  pkceVerifierEnc: text("pkce_verifier_enc"),
+  // Sealed JSON: {"headerName","headerValue"} (token kind) or
+  // {"accessToken","refreshToken","expiresAt"} (oauth kind). Null for "none".
+  secretEnc: text("secret_enc"),
+  status: text("status").notNull().default("pending"), // pending|connected
+  scopes: text("scopes"),
+  updatedAt: integer("updated_at", { mode: "number" }).notNull(),
+});
+
+export type McpConnection = typeof mcpConnections.$inferSelect;

package/images/standard/Dockerfile

@@ -70,6 +70,21 @@ RUN apt-get update \
       zsh \
  && rm -rf /var/lib/apt/lists/*
 
+# ADR-053: agent browser (Playwright/Chromium) runtime libs + the watchable
+# display stack (Xvfb → x11vnc → noVNC). Baked here because the
+# per-container background apt raced session start (headless-stuck MCP
+# server, viewer lagging the preview by minutes — Debian's novnc drags a
+# large Python tree). The Chromium BINARY still comes from the shared
+# uai-playwright volume (downloaded once per host); these are its deps.
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends \
+      libnss3 libnspr4 libatk1.0-0 libatk-bridge2.0-0 libcups2 libdrm2 \
+      libxkbcommon0 libatspi2.0-0 libxcomposite1 libxdamage1 libxfixes3 \
+      libxrandr2 libgbm1 libasound2 libpango-1.0-0 libcairo2 \
+      fonts-liberation fonts-unifont \
+      xvfb x11vnc novnc websockify \
+ && rm -rf /var/lib/apt/lists/*
+
 # GitHub CLI (`gh`) — used by the ship/PR flow inside the container.
 RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg \
       | tee /usr/share/keyrings/githubcli-archive-keyring.gpg >/dev/null \

package/lib/agent-cli.ts

@@ -193,6 +193,13 @@ async function main() {
       })).memory);
       break;
     }
+    case "memory delete": {
+      const id = pos[0] || flags.id;
+      if (!id) { console.error("uai: memory delete needs an id"); process.exit(1); }
+      await api("DELETE", "/api/agent/memory/" + encodeURIComponent(id));
+      out("deleted " + id);
+      break;
+    }
     case "task create": {
       out((await api("POST", "/api/agent/tasks", {
         name: flags.name,
@@ -205,6 +212,11 @@ async function main() {
       break;
     }
     case "whoami ": case "whoami undefined": out({ apiUrl: API_URL }); break;
+    case "react heart": case "react check": case "react x": {
+      const r = await api("POST", "/api/agent/react", { emoji: action, msg: flags.msg || undefined });
+      out((r.reacted ? "reacted to " : "un-reacted from ") + r.messageId);
+      break;
+    }
     default:
       console.error([
         "uai — agent CLI. Commands:",
@@ -214,6 +226,8 @@ async function main() {
         "  uai task create --name <n> --prompt <p> [--projects id,id] [--team id] [--agents handle,handle]",
         "  uai memory search <query>",
         "  uai memory save <text> [--project id] [--tags a,b]",
+        "  uai memory delete <id>",
+        "  uai react <heart|check|x> [--msg #id]   (no --msg = the message you were last handed)",
         "  uai whoami",
       ].join("\\n"));
       process.exit(argv.length ? 1 : 0);

package/lib/agents/claude.ts

@@ -35,10 +35,11 @@ import type {
 // resolves these aliases to the current dated snapshots, so this list is
 // stable across point releases. UPDATE WHEN MODELS CHANGE (new family or a
 // retired alias). Order is display order in the cloud picker.
-const CLAUDE_MODELS = ["opus", "sonnet", "haiku"];
+const CLAUDE_MODELS = ["fable", "opus", "sonnet", "haiku"];
 
-// Opus ("opus" alias = Opus 4.8) is the default: the strongest coding model
-// for the interactive loop. Update alongside CLAUDE_MODELS.
+// Opus ("opus" alias = Opus 4.8) stays the default; "fable" (Claude
+// Fable 5, the Mythos-class flagship) is opt-in per agent. Update
+// alongside CLAUDE_MODELS.
 const CLAUDE_DEFAULT_MODEL = "opus";
 
 // Reasoning levels passed through via `claude --effort <level>`. Taken from

package/lib/agents/codex.ts

@@ -49,6 +49,9 @@ import type {
 // Sourced from that picker; UPDATE WHEN MODELS CHANGE. Order = display order
 // in the cloud picker. Legacy models remain reachable via config.toml.
 const CODEX_MODELS = [
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
   "gpt-5.5",
   "gpt-5.4",
   "gpt-5.4-mini",
@@ -57,16 +60,20 @@ const CODEX_MODELS = [
   "gpt-5.2",
 ];
 
-// gpt-5.5 is Codex's current frontier coding model. Update alongside
-// CODEX_MODELS. When an agent's model is null the adapter omits the override
-// entirely and Codex uses the user's own configured default.
-const CODEX_DEFAULT_MODEL = "gpt-5.5";
+// gpt-5.6-sol is Codex's current frontier coding model (the CLI default).
+// Update alongside CODEX_MODELS. When an agent's model is null the adapter
+// omits the override entirely and Codex uses the user's own configured
+// default.
+const CODEX_DEFAULT_MODEL = "gpt-5.6-sol";
 
-// Reasoning levels set via `-c model_reasoning_effort=<level>`. "xhigh" is the
-// picker's "Extra high". UPDATE WHEN CODEX CHANGES its reasoning levels.
-const CODEX_EFFORTS = ["low", "medium", "high", "xhigh"];
+// Reasoning levels set via `-c model_reasoning_effort=<level>`. "xhigh" is
+// the picker's "Extra high"; gpt-5.6 added "max" and "ultra" (ultra =
+// maximum reasoning with automatic task delegation). UPDATE WHEN CODEX
+// CHANGES its reasoning levels.
+const CODEX_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
 
-// medium is Codex's default reasoning level. Update alongside CODEX_EFFORTS.
+// medium stays OUR default (the 5.6 CLI defaults to low — too light for
+// agentic task work). Update alongside CODEX_EFFORTS.
 const CODEX_DEFAULT_EFFORT = "medium";
 
 // ---------------------------------------------------------------------------

package/lib/browser-testing.ts

@@ -0,0 +1,235 @@
+/**
+ * ADR-053: in-container browser for agents — Playwright MCP wiring.
+ *
+ * When a task's project opted into browser testing, session start calls
+ * `setupBrowserTesting`, which (idempotently, via a versioned marker file)
+ * writes the MCP config for BOTH engines and kicks the installs in the
+ * background:
+ *
+ *   - `/workspace/.mcp.json` — Claude Code's project-scoped MCP config,
+ *     declaring the `browser` server (headFUL on DISPLAY :99).
+ *   - `/workspace/.claude/settings.json` — `enableAllProjectMcpServers` so
+ *     headless sessions load it without an approval prompt.
+ *   - `~/.codex/config.toml` — an `[mcp_servers.browser]` block (appended
+ *     once; the task owns a private copy of this file).
+ *
+ * Phase 2 (the WATCHABLE browser): Chromium runs headful under Xvfb (:99),
+ * mirrored by x11vnc → websockify/noVNC on container port 6080 — which the
+ * cloud surfaces as the synthetic "browser" preview, so the human can watch
+ * the agents click around from the preview menu. The viewer stack is
+ * (re)started on every setup call, pgrep-guarded, so it survives container
+ * restarts.
+ *
+ * Browser binaries land on the host-wide `uai-playwright` volume
+ * (PLAYWRIGHT_BROWSERS_PATH=/opt/pw-browsers, mounted by the generated
+ * compose) so Chromium downloads once per HOST. Everything here is
+ * best-effort and never blocks session start.
+ *
+ * Hard-won asdf rules (2026-07-07): npx resolves ONLY where a .tool-versions
+ * applies → always `-w /workspace`; and root has no ~/.tool-versions →
+ * root execs also need `-e HOME=/home/node`.
+ */
+import { dockerCli } from "./docker-exec";
+
+// v3: self-sufficient MCP launcher + loop-wrapped viewer daemons. Bumping
+// re-runs setup on live channels; config writes stay `[ -f ] ||`-guarded so
+// a task keeps the configs it started with.
+const MARKER = "/workspace/.uai/.browser-mcp-ready-v3";
+
+const SERVER_DISPLAY = ":99";
+const XVFB_CMD = `Xvfb ${SERVER_DISPLAY} -screen 0 1440x900x24 -nolisten tcp`;
+
+/**
+ * The MCP server launcher — self-sufficient by design (learned live: a
+ * session that spawns while the apt installs are still running got a DEAD
+ * mcp server, and the agent had to improvise). It ensures its own display
+ * when Xvfb exists (headful → watchable), and falls back to a HEADLESS
+ * browser while the viewer packages are still installing — the agent always
+ * gets working tools. `sh -lc` + cd /workspace for the asdf shims. No
+ * single quotes in here: it's embedded in single-quoted JSON/TOML strings.
+ */
+// X's own lockfile is the display-up signal — no pgrep (pgrep -f guards
+// self-matched their launcher's cmdline and skipped every start; found
+// live 2026-07-08), and it also detects displays an AGENT started itself.
+const X_LOCK = `/tmp/.X${SERVER_DISPLAY.slice(1)}-lock`;
+
+const SERVER_LAUNCHER =
+  `cd /workspace; ` +
+  `if command -v Xvfb >/dev/null 2>&1; then ` +
+  `[ -e ${X_LOCK} ] || (nohup ${XVFB_CMD} >>/tmp/uai-xvfb.log 2>&1 &); ` +
+  `sleep 1; export DISPLAY=${SERVER_DISPLAY}; ` +
+  `exec npx -y @playwright/mcp@latest --browser chromium --no-sandbox; ` +
+  `else ` +
+  `exec npx -y @playwright/mcp@latest --browser chromium --no-sandbox --headless; ` +
+  `fi`;
+
+const SERVER_COMMAND = "sh";
+const SERVER_ARGS = ["-lc", SERVER_LAUNCHER];
+
+const MCP_JSON = JSON.stringify(
+  {
+    mcpServers: {
+      browser: { command: SERVER_COMMAND, args: SERVER_ARGS },
+    },
+  },
+  null,
+  2,
+);
+
+const CLAUDE_SETTINGS_JSON = JSON.stringify(
+  { enableAllProjectMcpServers: true },
+  null,
+  2,
+);
+
+const CODEX_TOML = [
+  "",
+  "# uai ADR-053: in-container browser (Playwright MCP)",
+  "[mcp_servers.browser]",
+  `command = '${SERVER_COMMAND}'`,
+  `args = [${SERVER_ARGS.map((a) => `'${a}'`).join(", ")}]`,
+  "",
+].join("\n");
+
+/**
+ * Start the watchable-browser stack (Xvfb → x11vnc → noVNC on :6080) if its
+ * binaries are installed and it isn't already up. x11vnc and websockify run
+ * under tiny restart loops — x11vnc EXITS whenever the X server it watches
+ * isn't up yet (the race that killed the first live run), and the loops
+ * also reattach after the display owner changes. Safe to run repeatedly:
+ * every piece is pgrep-guarded, including the loops themselves.
+ */
+/**
+ * The viewer daemons, one docker-exec each (the single-line nohup shape is
+ * the only one that reliably survives `docker exec -d`). Guards use the X
+ * lockfile and PIDFILES — never pgrep: a pgrep -f guard sharing a cmdline
+ * with its own payload self-matches and skips the start (this exact bug
+ * kept the stack down in every container until 2026-07-08).
+ */
+const VIEWER_STEPS: string[] = [
+  // Xvfb — one-shot; the X lockfile is the truth (also set when an agent
+  // started the display itself). If it dies the lock clears and the next
+  // session ensure relaunches it.
+  `command -v Xvfb >/dev/null 2>&1 || exit 0; [ -e ${X_LOCK} ] || nohup ${XVFB_CMD} >>/tmp/uai-xvfb.log 2>&1 &`,
+  // x11vnc under a restart loop (it exits whenever the X server isn't up
+  // yet). Pidfile-guarded.
+  `command -v x11vnc >/dev/null 2>&1 || exit 0; [ -f /tmp/uai-x11vnc.pid ] && kill -0 "$(cat /tmp/uai-x11vnc.pid)" 2>/dev/null && exit 0; nohup sh -c 'echo $$ > /tmp/uai-x11vnc.pid; while true; do x11vnc -display ${SERVER_DISPLAY} -forever -shared -nopw -quiet >>/tmp/uai-x11vnc.log 2>&1; sleep 2; done' >/dev/null 2>&1 &`,
+  // websockify/noVNC under the same pattern.
+  `command -v websockify >/dev/null 2>&1 || exit 0; [ -f /tmp/uai-novnc.pid ] && kill -0 "$(cat /tmp/uai-novnc.pid)" 2>/dev/null && exit 0; nohup sh -c 'echo $$ > /tmp/uai-novnc.pid; while true; do websockify --web=/usr/share/novnc 0.0.0.0:6080 localhost:5900 >>/tmp/uai-websockify.log 2>&1; sleep 2; done' >/dev/null 2>&1 &`,
+];
+
+export async function setupBrowserTesting(
+  taskId: string,
+  containerName: string,
+  hasCodex: boolean,
+): Promise<void> {
+  try {
+    // The viewer stack restarts whenever it died (container restart, crash) —
+    // outside the marker guard on purpose. No-op until its packages install.
+    // ONE exec per daemon: the single-line nohup shape is the only one that
+    // reliably survives `docker exec -d`.
+    for (const step of VIEWER_STEPS) {
+      await dockerCli(["exec", "-d", containerName, "sh", "-c", step], {
+        timeoutMs: 10_000,
+      });
+    }
+
+    const marked = await dockerCli(
+      ["exec", containerName, "test", "-f", MARKER],
+      { timeoutMs: 5_000 },
+    );
+    if (marked.status === 0) return;
+
+    const script = [
+      "set -e",
+      "mkdir -p /workspace/.uai /workspace/.claude",
+      // Claude: project-scoped MCP config + auto-approve setting. The
+      // workspace is fresh per task, so plain writes are safe; keep them
+      // conditional anyway so a human's later edits survive re-runs.
+      `[ -f /workspace/.mcp.json ] || printf '%s\\n' ${shellQuote(MCP_JSON)} > /workspace/.mcp.json`,
+      `[ -f /workspace/.claude/settings.json ] || printf '%s\\n' ${shellQuote(CLAUDE_SETTINGS_JSON)} > /workspace/.claude/settings.json`,
+      ...(hasCodex
+        ? [
+            // Codex: append once to the task's PRIVATE config copy.
+            `grep -q "mcp_servers.browser" /home/node/.codex/config.toml 2>/dev/null || printf '%s' ${shellQuote(CODEX_TOML)} >> /home/node/.codex/config.toml`,
+          ]
+        : []),
+      `touch ${MARKER}`,
+    ].join(" && ");
+
+    const wrote = await dockerCli(
+      ["exec", containerName, "sh", "-lc", script],
+      { timeoutMs: 20_000 },
+    );
+    if (wrote.status !== 0) {
+      console.warn(
+        `[browser] task ${taskId}: MCP config write failed: ${wrote.stderr.slice(0, 300)}`,
+      );
+      return;
+    }
+
+    // Volume ownership, then the browser download as NODE (host-wide
+    // one-timer on the shared volume).
+    await dockerCli(
+      ["exec", "-u", "root", containerName, "chown", "node:node", "/opt/pw-browsers"],
+      { timeoutMs: 5_000 },
+    );
+    await dockerCli(
+      [
+        "exec",
+        "-d",
+        "-w",
+        "/workspace",
+        containerName,
+        "sh",
+        "-lc",
+        "npx -y playwright@latest install chromium >/tmp/uai-pw-browser.log 2>&1 || true",
+      ],
+      { timeoutMs: 10_000 },
+    );
+    // Chromium apt libs + the viewer stack packages, then start the stack —
+    // one ordered root chain, backgrounded, per-container.
+    await dockerCli(
+      [
+        "exec",
+        "-d",
+        "-u",
+        "root",
+        // HOME=/home/node is for asdf version resolution ONLY — without the
+        // cache redirect below, root's npx writes ROOT-OWNED entries into
+        // node's ~/.npm and breaks the node user's own npx (which launches
+        // the MCP server). Found live 2026-07-08.
+        "-e",
+        "HOME=/home/node",
+        "-e",
+        "npm_config_cache=/tmp/uai-root-npm-cache",
+        "-w",
+        "/workspace",
+        containerName,
+        "sh",
+        "-lc",
+        "{ npx -y playwright@latest install-deps chromium && " +
+          "apt-get install -y --no-install-recommends xvfb x11vnc novnc websockify && " +
+          // Older-image containers get their packages only HERE (post-apt),
+          // so kick the viewer daemons now. Each step subshelled: the steps'
+          // internal `exit 0` guards must not abort their siblings.
+          `su -s /bin/sh node -c '${VIEWER_STEPS.map((s) => `( ${s} )`)
+            .join("; ")
+            .replace(/'/g, `'\\''`)}'; ` +
+          // Heal any damage a pre-fix host already did to the cache.
+          "chown -R node:node /home/node/.npm 2>/dev/null; } " +
+          ">/tmp/uai-pw-deps.log 2>&1 || true",
+      ],
+      { timeoutMs: 10_000 },
+    );
+    console.log(`[browser] task ${taskId}: Playwright MCP wired (installs backgrounded)`);
+  } catch (err) {
+    // Best-effort by design — a task without a browser still runs.
+    console.warn(`[browser] task ${taskId}: setup failed`, err);
+  }
+}
+
+/** Single-quote for `sh -c` (POSIX-safe). */
+function shellQuote(text: string): string {
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}