@runuai/host 0.9.139 → 0.9.141

package/lib/mcp-connections.ts

@@ -14,9 +14,10 @@
 import { createHash, randomBytes } from "node:crypto";
 import { eq } from "drizzle-orm";
 
-import { queueStoreWrite, userParameterName } from "./credential-store";
+import { configuredCredentialStore, queueStoreWrite, userParameterName } from "./credential-store";
 import { getDb, schema } from "./db";
 import { sealAesGcm, openAesGcm } from "./secrets";
+import { signInBoxMode } from "./signin-box";
 import type { McpOp } from "../src/protocol";
 
 const FETCH_TIMEOUT_MS = 10_000;
@@ -311,6 +312,27 @@ async function probe(op: Extract<McpOp, { kind: "probe" }>): Promise<McpAck> {
       const lead = `unexpected response (${res.status})`;
       throw new Error(why ? `${lead}: ${why}` : lead);
     }
+    if (signInBoxMode()) {
+      // ADR-136 sign-in box: the store first, a row with no secret.
+      await putMcpConnectionStoreFirst({
+        v: 1,
+        kind: "mcp",
+        id: op.connectionId,
+        userId: op.userId,
+        url: op.url,
+        authKind: "token",
+        tokenEndpoint: null,
+        redirectUri: null,
+        clientId: null,
+        clientSecret: null,
+        pkceVerifier: null,
+        secret: JSON.stringify(header),
+        status: "connected",
+        scopes: null,
+        updatedAt: now,
+      });
+      return { status: "connected" };
+    }
     db.insert(schema.mcpConnections)
       .values({
         id: op.connectionId,
@@ -339,6 +361,26 @@ async function probe(op: Extract<McpOp, { kind: "probe" }>): Promise<McpAck> {
   // Bare probe.
   const res = await mcpInitialize(op.url);
   if (res.ok) {
+    if (signInBoxMode()) {
+      await putMcpConnectionStoreFirst({
+        v: 1,
+        kind: "mcp",
+        id: op.connectionId,
+        userId: op.userId,
+        url: op.url,
+        authKind: "none",
+        tokenEndpoint: null,
+        redirectUri: null,
+        clientId: null,
+        clientSecret: null,
+        pkceVerifier: null,
+        secret: null,
+        status: "connected",
+        scopes: null,
+        updatedAt: now,
+      });
+      return { status: "connected" };
+    }
     db.insert(schema.mcpConnections)
       .values({
         id: op.connectionId,
@@ -396,6 +438,28 @@ async function probe(op: Extract<McpOp, { kind: "probe" }>): Promise<McpAck> {
     authorize.searchParams.set("scope", found.scopesSupported.join(" "));
   }
 
+  if (signInBoxMode()) {
+    // ADR-136 sign-in box: the pending half-flow (verifier, client secret)
+    // lives in memory only until oauth.complete; nothing pending reaches the
+    // store or the row. A box restart mid-flow means "probe again".
+    boxPendingOauth.set(op.connectionId, { verifier, clientSecret: clientSecret ?? null });
+    upsertStoreHeldMcpConnectionRow(
+      {
+        id: op.connectionId,
+        userId: op.userId,
+        url: op.url,
+        authKind: "oauth",
+        tokenEndpoint: found.tokenEndpoint,
+        redirectUri: op.redirectUri,
+        clientId,
+        status: "pending",
+        scopes: found.scopesSupported?.join(" ") ?? null,
+        updatedAt: now,
+      },
+      null,
+    );
+    return { status: "auth_required", authorizeUrl: authorize.toString() };
+  }
   const fields = {
     userId: op.userId,
     url: op.url,
@@ -426,9 +490,25 @@ async function oauthComplete(connectionId: string, code: string): Promise<McpAck
     .where(eq(schema.mcpConnections.id, connectionId))
     .get();
   if (!row) throw new Error("unknown connection — probe first");
-  if (!row.tokenEndpoint || !row.clientId || !row.pkceVerifierEnc || !row.redirectUri) {
-    throw new Error("connection has no pending OAuth flow");
+  const pending = signInBoxMode() ? (boxPendingOauth.get(connectionId) ?? null) : null;
+  if (
+    !row.tokenEndpoint ||
+    !row.clientId ||
+    !row.redirectUri ||
+    (!pending && !row.pkceVerifierEnc)
+  ) {
+    throw new Error(
+      signInBoxMode() && !pending
+        ? "the sign-in box restarted during this OAuth flow — probe again"
+        : "connection has no pending OAuth flow",
+    );
   }
+  const verifier = pending ? pending.verifier : unpack(row.pkceVerifierEnc!);
+  const clientSecret = pending
+    ? (pending.clientSecret ?? undefined)
+    : row.clientSecretEnc
+      ? unpack(row.clientSecretEnc)
+      : undefined;
 
   const { ok, status, json } = await postTokenEndpoint(
     row.tokenEndpoint,
@@ -437,12 +517,12 @@ async function oauthComplete(connectionId: string, code: string): Promise<McpAck
       code,
       redirect_uri: row.redirectUri,
       client_id: row.clientId,
-      code_verifier: unpack(row.pkceVerifierEnc),
+      code_verifier: verifier,
       // RFC 8707, mirrored from the authorize request.
       resource: row.url,
     },
     row.clientId,
-    row.clientSecretEnc ? unpack(row.clientSecretEnc) : undefined,
+    clientSecret,
   );
   if (!ok || typeof json.access_token !== "string") {
     const detail =
@@ -463,6 +543,30 @@ async function oauthComplete(connectionId: string, code: string): Promise<McpAck
     typeof json.scope === "string" && json.scope.length > 0
       ? json.scope
       : row.scopes;
+  if (pending) {
+    await putMcpConnectionStoreFirst({
+      v: 1,
+      kind: "mcp",
+      id: connectionId,
+      userId: row.userId,
+      url: row.url,
+      authKind: "oauth",
+      tokenEndpoint: row.tokenEndpoint,
+      redirectUri: row.redirectUri,
+      clientId: row.clientId,
+      clientSecret: pending.clientSecret,
+      pkceVerifier: null,
+      secret: JSON.stringify(secret),
+      status: "connected",
+      scopes,
+      updatedAt: Date.now(),
+    });
+    boxPendingOauth.delete(connectionId);
+    return {
+      status: "connected",
+      scopes: scopes ? scopes.split(" ").filter(Boolean) : undefined,
+    };
+  }
   db.update(schema.mcpConnections)
     .set({
       secretEnc: pack(JSON.stringify(secret)),
@@ -698,6 +802,9 @@ export function listMcpConnectionStoreRows(): Array<{
 }
 
 export function mirrorMcpConnectionToStore(id: string): void {
+  // ADR-136 sign-in box: rows hold no secret; the store was written first,
+  // and a mirror of a secret-less row would overwrite the only copy.
+  if (signInBoxMode()) return;
   queueStoreWrite(`mirror mcp connection ${id}`, async (store) => {
     const value = mcpConnectionStoreValue(id);
     if (!value) return;
@@ -720,6 +827,102 @@ export function deleteMcpConnectionLocal(id: string): void {
   queueStoreWrite(`delete mcp connection ${id}`, (store) => store.delete(name));
 }
 
+// ---------------------------------------------------------------------------
+// ADR-136 sign-in box: connection rows here hold NO secret — the header or
+// OAuth tokens, the client secret and the PKCE verifier live in the store (or,
+// for a half-finished OAuth flow, in memory only). What the box lists (url,
+// auth kind, status, scopes) also rides as tags so a replacement box needs no
+// value read.
+// ---------------------------------------------------------------------------
+
+export const MCP_CONNECTION_TAGS = {
+  urlB64: "uai_url_b64",
+  authKind: "uai_auth_kind",
+  status: "uai_status",
+  scopesB64: "uai_scopes_b64",
+  updatedAt: "uai_updated_at",
+} as const;
+
+const boxPendingOauth = new Map<string, { verifier: string; clientSecret: string | null }>();
+
+/** Test seam. */
+export function pendingOauthForTesting(connectionId: string): boolean {
+  return boxPendingOauth.has(connectionId);
+}
+
+export type StoreHeldMcpConnectionRow = Pick<
+  StoredMcpConnection,
+  "id" | "userId" | "url" | "authKind" | "tokenEndpoint" | "redirectUri" | "clientId" | "status" | "scopes" | "updatedAt"
+>;
+
+export function mcpConnectionMetadataTags(value: {
+  url: string;
+  authKind: string;
+  status: string;
+  scopes: string | null;
+  updatedAt: number;
+}): Record<string, string> {
+  return {
+    [MCP_CONNECTION_TAGS.urlB64]: Buffer.from(value.url, "utf8").toString("base64url").slice(0, 256),
+    [MCP_CONNECTION_TAGS.authKind]: value.authKind,
+    [MCP_CONNECTION_TAGS.status]: value.status,
+    [MCP_CONNECTION_TAGS.scopesB64]: value.scopes
+      ? Buffer.from(value.scopes, "utf8").toString("base64url").slice(0, 256)
+      : "",
+    [MCP_CONNECTION_TAGS.updatedAt]: String(value.updatedAt),
+  };
+}
+
+/** Upsert a row with every secret column null. */
+export function upsertStoreHeldMcpConnectionRow(
+  value: StoreHeldMcpConnectionRow,
+  storeRef: string | null,
+): void {
+  const fields = {
+    userId: value.userId,
+    url: value.url,
+    authKind: value.authKind,
+    tokenEndpoint: value.tokenEndpoint,
+    redirectUri: value.redirectUri,
+    clientId: value.clientId,
+    clientSecretEnc: null,
+    pkceVerifierEnc: null,
+    secretEnc: null,
+    status: value.status,
+    scopes: value.scopes,
+    updatedAt: value.updatedAt,
+    storeRef,
+  };
+  getDb()
+    .insert(schema.mcpConnections)
+    .values({ id: value.id, ...fields })
+    .onConflictDoUpdate({ target: schema.mcpConnections.id, set: fields })
+    .run();
+}
+
+/** The store first, awaited (a refused put is the op's failure), then tags
+ *  and a secret-less row. */
+export async function putMcpConnectionStoreFirst(value: StoredMcpConnection): Promise<void> {
+  const store = configuredCredentialStore();
+  if (!store) throw new Error("the sign-in box has no credential store to hold the connection");
+  const name = mcpConnectionParameterName(value.userId, value.id);
+  await store.put(name, JSON.stringify(value));
+  try {
+    await store.tag(name, mcpConnectionMetadataTags(value));
+  } catch (err) {
+    console.warn(
+      `[mcp] connection ${value.id}: tagging ${name} failed (${err instanceof Error ? err.message : String(err)}) — a replacement box needs the transitional read to list it`,
+    );
+  }
+  upsertStoreHeldMcpConnectionRow(value, name);
+}
+
+/** Delete the row only (no store call). */
+export function deleteMcpConnectionRowLocal(id: string): void {
+  boxPendingOauth.delete(id);
+  getDb().delete(schema.mcpConnections).where(eq(schema.mcpConnections.id, id)).run();
+}
+
 /** Reconcile import: a connection this host lacks. Existing rows win. */
 export function importMcpConnectionFromStore(
   value: StoredMcpConnection,