@runuai/host 0.9.138 → 0.9.140

package/lib/engine-connect.ts

@@ -23,10 +23,19 @@ import { addEngineAccount } from "./engine-accounts";
 import { connectEngine, type EngineKind } from "./engines";
 
 const CONNECT_TIMEOUT_MS = 2 * 60_000;
-const MAX_CONCURRENT_CONNECTS = 1;
+// Connects are one store write each; labeled (workspace) connects never touch
+// a shared slot, so they run side by side — a user is never told to wait for
+// someone else's connect (ADR-136 sign-in box). Bounded, not serialised.
+const MAX_CONCURRENT_CONNECTS = 16;
 
 export type EmitEngineConnectEvent = (frame: EngineConnectEventFrame) => void;
 
+export interface AddAccountOutcome {
+  ok: boolean;
+  message: string;
+  id?: string;
+}
+
 export interface EngineConnectManagerOptions {
   /** Re-advertise capabilities after a successful mutation (main.ts). */
   readvertise(): void;
@@ -34,6 +43,17 @@ export interface EngineConnectManagerOptions {
   refreshEngineAccountAgents(kind: string): Promise<void>;
   /** Best-effort post-connect image maintenance (optional engines bake in). */
   ensureStandardImage(): Promise<unknown>;
+  /** ADR-136 sign-in box: only labeled, workspace-scoped connects are
+   *  admitted — nothing here may write the host's default slot. */
+  workspaceOnly?: boolean;
+  /** The labeled-account sink. Defaults to the local `addEngineAccount`; the
+   *  sign-in box supplies the store-first one and awaits its write. */
+  addLabeledAccount?: (
+    kind: EngineConnectKind,
+    label: string,
+    secret: string,
+    scope: string,
+  ) => AddAccountOutcome | Promise<AddAccountOutcome>;
   timers?: {
     setTimeout(handler: () => void, ms: number): NodeJS.Timeout;
     clearTimeout(timer: NodeJS.Timeout): void;
@@ -77,7 +97,7 @@ export class EngineConnectManager {
         engine,
         phase: "done",
         ok: false,
-        message: "Another engine connect is already in progress.",
+        message: "Too many engine connects are running on this runner right now; try again in a minute.",
       });
       return true;
     }
@@ -156,15 +176,26 @@ export class EngineConnectManager {
       return;
     }
 
+    // ADR-136 sign-in box: a workspace account or nothing.
+    if (
+      this.options.workspaceOnly &&
+      (label === undefined || scope === undefined || scope === HOST_ACCOUNT_SCOPE)
+    ) {
+      this.finish(
+        operation,
+        false,
+        "The Uai Cloud sign-in box connects workspace accounts only.",
+      );
+      return;
+    }
     // ADR-116 labeled extra account — the sink validates kind support.
     if (label !== undefined && secret !== undefined) {
-      const added = addEngineAccount(
-        engine,
-        label,
-        { token: secret },
-        {},
-        scope ?? HOST_ACCOUNT_SCOPE,
-      );
+      const sink =
+        this.options.addLabeledAccount ??
+        ((kind, accountLabel, value, accountScope) =>
+          addEngineAccount(kind, accountLabel, { token: value }, {}, accountScope));
+      const added = await sink(engine, label, secret, scope ?? HOST_ACCOUNT_SCOPE);
+      if (operation.done) return;
       if (added.ok) this.afterMutation(engine, false);
       this.finish(operation, added.ok, added.message, added.id);
       return;

package/lib/engine-login.ts

@@ -64,7 +64,13 @@ export const ENGINE_LOGIN_TIMEOUT_MS = 10 * 60_000;
 export const SUBMIT_KEYSTROKE_DELAY_MS = 300;
 // Global serialization keeps a failed per-operation stale-resource sweep from
 // ever deleting another live login's labeled container or marked temp dir.
-export const MAX_CONCURRENT_ENGINE_LOGINS = 1;
+/**
+ * Concurrent login containers per runner. Workspace sign-ins run side by
+ * side (ADR-136 sign-in box: a user is never told to wait for someone else's
+ * login); only the host's DEFAULT slot is exclusive, per engine. Bounded so
+ * a burst cannot fork containers without limit.
+ */
+export const MAX_CONCURRENT_ENGINE_LOGINS = 16;
 
 const LOGIN_MOUNT = "/run/uai-engine-login";
 const LOGIN_HOME = `${LOGIN_MOUNT}/home`;
@@ -136,6 +142,12 @@ export interface EngineLoginTimers {
   clearTimeout(timer: unknown): void;
 }
 
+export interface AccountAddOutcome {
+  ok: boolean;
+  message: string;
+  id?: string;
+}
+
 export interface EngineLoginSeams {
   createTempDir(): Promise<string>;
   removeTempDir(path: string): Promise<void>;
@@ -158,22 +170,24 @@ export interface EngineLoginSeams {
   readTranscript(tempDir: string): Promise<string | null>;
   persistClaudeToken(token: string): Promise<void>;
   persistCodexAuth(sourceFile: string): Promise<void>;
-  /** ADR-116: labeled extra-account captures (never the default slots). */
+  /** ADR-116: labeled extra-account captures (never the default slots).
+   *  Sync on a host that seals the capture locally; a promise on the ADR-136
+   *  sign-in box, whose sink awaits the credential store's write. */
   addClaudeAccount(
     label: string,
     token: string,
     scope: string,
-  ): { ok: boolean; message: string; id?: string };
+  ): AccountAddOutcome | Promise<AccountAddOutcome>;
   addCodexAccount(
     label: string,
     authJson: string,
     scope: string,
-  ): { ok: boolean; message: string; id?: string };
+  ): AccountAddOutcome | Promise<AccountAddOutcome>;
   addGrokAccount(
     label: string,
     authJson: string,
     scope: string,
-  ): { ok: boolean; message: string; id?: string };
+  ): AccountAddOutcome | Promise<AccountAddOutcome>;
   persistGrokAuth(sourceFile: string): Promise<void>;
   /** Optional engines ride the standard image only when configured; a fresh
    * account may be the first configuration → rebuild (queue-deduped). */
@@ -197,6 +211,9 @@ export interface EngineLoginManagerOptions {
   tempRoot?: string;
   /** Defer Docker inventory until the first start when no runtime is selected. */
   reconcileOnCreate?: boolean;
+  /** ADR-136 sign-in box: only labeled, workspace-scoped sign-ins are
+   *  admitted — the default slots are the host owner's and the box has none. */
+  workspaceOnly?: boolean;
   seams?: Partial<EngineLoginSeams>;
   /** Rebuild the standard image after a successful capture (optional engines). */
   ensureStandardImage?: () => Promise<unknown>;
@@ -389,12 +406,21 @@ function withDefaults(options: EngineLoginManagerOptions): EngineLoginSeams {
  */
 export class EngineLoginManager {
   private readonly seams: EngineLoginSeams;
+  private readonly workspaceOnly: boolean;
   private readonly operations = new Map<string, LoginOperation>();
-  private readonly engineOperations = new Map<EngineLoginKind, LoginOperation>();
+  /**
+   * The DEFAULT-SLOT lock: one unlabeled capture per engine at a time, since
+   * two of them would race on the host's own `~/.codex`-style slot. Labeled
+   * (workspace) captures land in isolated accounts and never take it — on
+   * the ADR-136 sign-in box every workspace's sign-in runs alongside every
+   * other's; a user is never told to wait for someone else's login.
+   */
+  private readonly defaultSlotOperations = new Map<EngineLoginKind, LoginOperation>();
   private reconciliation: Promise<boolean>;
 
   constructor(options: EngineLoginManagerOptions) {
     this.seams = withDefaults(options);
+    this.workspaceOnly = options.workspaceOnly === true;
     this.reconciliation =
       options.reconcileOnCreate === false
         ? Promise.resolve(false)
@@ -449,6 +475,23 @@ export class EngineLoginManager {
       );
       return false;
     }
+    // ADR-136 sign-in box: nothing here may write a default slot, and a
+    // host-scope account would belong to a runner that owns no credential.
+    if (
+      this.workspaceOnly &&
+      (scope === undefined || scope === HOST_ACCOUNT_SCOPE || label === undefined)
+    ) {
+      safeEmit(
+        emit,
+        failedEvent(
+          opId,
+          engine,
+          "start_failed",
+          "The Uai Cloud sign-in box signs in workspace accounts only.",
+        ),
+      );
+      return false;
+    }
     // A workspace's sign-in is always a labeled account: the default slot is
     // the host owner's and must never be written on a tenant's behalf.
     if (scope !== undefined && scope !== HOST_ACCOUNT_SCOPE && label === undefined) {
@@ -469,7 +512,7 @@ export class EngineLoginManager {
       safeEmit(emit, failedEvent(opId, engine, "unavailable", "Login operation already exists."));
       return false;
     }
-    if (this.engineOperations.has(engine)) {
+    if (label === undefined && this.defaultSlotOperations.has(engine)) {
       safeEmit(
         emit,
         failedEvent(
@@ -481,10 +524,16 @@ export class EngineLoginManager {
       );
       return false;
     }
+    // Every login is a container; bound the fan-out without serialising it.
     if (this.operations.size >= MAX_CONCURRENT_ENGINE_LOGINS) {
       safeEmit(
         emit,
-        failedEvent(opId, engine, "unavailable", "Too many login operations are active."),
+        failedEvent(
+          opId,
+          engine,
+          "unavailable",
+          "Too many sign-ins are running on this runner right now; try again in a minute.",
+        ),
       );
       return false;
     }
@@ -516,7 +565,7 @@ export class EngineLoginManager {
       postInputOutputSeen: false,
     };
     this.operations.set(opId, operation);
-    this.engineOperations.set(engine, operation);
+    if (label === undefined) this.defaultSlotOperations.set(engine, operation);
     operation.timer = this.seams.timers.setTimeout(() => {
       void this.timeout(operation);
     }, ENGINE_LOGIN_TIMEOUT_MS);
@@ -1043,7 +1092,7 @@ export class EngineLoginManager {
       // ADR-116: labeled capture — an extra account, not the default slot.
       // Extras are picked up at the next agent spawn / rotation, so no
       // running-agent refresh is needed (mirrors the local accounts API).
-      const added = this.seams.addClaudeAccount(
+      const added = await this.seams.addClaudeAccount(
         operation.accountLabel,
         token,
         operation.accountScope,
@@ -1118,10 +1167,10 @@ export class EngineLoginManager {
     if (operation.accountLabel !== null) {
       // ADR-116: labeled capture — the auth.json this login produced becomes
       // an isolated extra account instead of overwriting ~/.codex.
-      let added: { ok: boolean; message: string; id?: string };
+      let added: AccountAddOutcome;
       try {
         const contents = await readFile(authFile, "utf8");
-        added = grok
+        added = await (grok
           ? this.seams.addGrokAccount(
               operation.accountLabel,
               contents,
@@ -1131,7 +1180,7 @@ export class EngineLoginManager {
               operation.accountLabel,
               contents,
               operation.accountScope,
-            );
+            ));
       } catch {
         added = {
           ok: false,
@@ -1279,8 +1328,8 @@ export class EngineLoginManager {
       if (this.operations.get(operation.opId) === operation) {
         this.operations.delete(operation.opId);
       }
-      if (this.engineOperations.get(operation.engine) === operation) {
-        this.engineOperations.delete(operation.engine);
+      if (this.defaultSlotOperations.get(operation.engine) === operation) {
+        this.defaultSlotOperations.delete(operation.engine);
       }
     });
     return operation.settlementPromise;

package/lib/env-file.ts

@@ -79,6 +79,36 @@ export function writeEnvValuesAtomic(
   replaceEnvFileAtomic(file, `${kept.join("\n")}\n`);
 }
 
+/**
+ * Atomically drop `keys` from a dotenv file (a missing file or key is fine).
+ * The sign-in box (ADR-136) strips engine credentials from `.env.local` at
+ * start so no default-slot secret survives on that machine.
+ */
+export function removeEnvValuesAtomic(
+  file: string,
+  keys: readonly string[],
+): string[] {
+  if (keys.length === 0 || !existsSync(file)) return [];
+  for (const key of keys) {
+    if (!ENV_KEY.test(key)) throw new Error(`invalid environment key: ${key}`);
+  }
+  const drop = new Set(keys);
+  const removed: string[] = [];
+  const current = readFileSync(file, "utf8");
+  const kept = current.split(/\r?\n/).filter((line, index, lines) => {
+    if (index === lines.length - 1 && line === "") return false;
+    const equals = line.indexOf("=");
+    if (equals <= 0) return true;
+    const key = line.slice(0, equals);
+    if (!drop.has(key)) return true;
+    removed.push(key);
+    return false;
+  });
+  if (removed.length === 0) return [];
+  replaceEnvFileAtomic(file, kept.length === 0 ? "" : `${kept.join("\n")}\n`);
+  return [...new Set(removed)];
+}
+
 /** Capture the exact bytes needed to roll back a multi-store config write. */
 export function readEnvFileSnapshot(file: string): EnvFileSnapshot {
   return existsSync(file)