openmausbot 0.1.55 → 0.1.57

package/dist-server/pair-cli.js

@@ -1100,12 +1100,12 @@ var require_main = __commonJS({
 
 // server/cli.ts
 var import_qrcode_terminal = __toESM(require_main(), 1);
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // server/tailscale.ts
 import { execFile } from "node:child_process";
@@ -1214,12 +1214,12 @@ async function tailscaleServeOff(status, httpsPort = 443) {
 }
 
 // server/tunnel.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { hostname } from "node:os";
 import { dirname, join as join2, resolve } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath } from "node:url";
 
 // electron/control-plane-client.mjs
 var INSTALLATION_CREDENTIAL = /^omb_install_[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}$/;
@@ -1348,10 +1348,10 @@ function createControlPlaneClient({
 }) {
   const origin = normalizeControlPlaneURL(baseURL);
   if (!origin) throw new ControlPlaneError("control_plane_unavailable");
-  const request = async (path4, { method = "GET", token, body, allowEmpty = false, deadlineMs = timeoutMs } = {}) => {
+  const request = async (path3, { method = "GET", token, body, allowEmpty = false, deadlineMs = timeoutMs } = {}) => {
     const headers = new Headers({ accept: "application/json" });
     if (token) headers.set("authorization", `Bearer ${token}`);
-    if (path4.startsWith("/api/auth/")) headers.set("origin", origin);
+    if (path3.startsWith("/api/auth/")) headers.set("origin", origin);
     if (body !== void 0) {
       headers.set("content-type", "application/json");
     }
@@ -1364,7 +1364,7 @@ function createControlPlaneClient({
         signal: timeoutSignal(deadlineMs)
       };
       if (body !== void 0) init.body = JSON.stringify(body);
-      response = await fetchImpl(`${origin}${path4}`, init);
+      response = await fetchImpl(`${origin}${path3}`, init);
     } catch {
       throw new ControlPlaneError("network_unavailable");
     }
@@ -1530,19 +1530,17 @@ function createControlPlaneClient({
 }
 
 // electron/managed-companion-tunnel.mjs
-import { spawn as spawn2 } from "node:child_process";
+import { spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import fs2 from "node:fs";
 import os2 from "node:os";
-import path3 from "node:path";
+import path2 from "node:path";
 
 // electron/companion-origin-gateway.mjs
 import fs from "node:fs";
-import http from "node:http";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-var MANAGED_COMPANION_ORIGIN_HOST = "127.0.0.1";
 var MANAGED_COMPANION_ORIGIN_PORT = 8812;
 var RUNTIME_PREFIX = "omb-companion-origin-";
 var SOCKET_NAME = "origin.sock";
@@ -1620,210 +1618,8 @@ function cleanupCompanionOriginEndpoint(endpoint, { platform = process.platform,
   } catch {
   }
 }
-function unavailable(response) {
-  if (response.headersSent) return response.destroy();
-  const body = JSON.stringify({ error: "companion origin unavailable" });
-  response.writeHead(503, {
-    "cache-control": "private, no-store",
-    "content-length": Buffer.byteLength(body),
-    "content-type": "application/json"
-  });
-  response.end(body);
-}
-var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "proxy-connection",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-]);
-function endToEndHeaders(headers = {}) {
-  const blocked = new Set(HOP_BY_HOP_HEADERS);
-  const connection = Array.isArray(headers.connection) ? headers.connection.join(",") : String(headers.connection ?? "");
-  for (const name of connection.split(",")) blocked.add(name.trim().toLowerCase());
-  return Object.fromEntries(
-    Object.entries(headers).filter(([name, value]) => value !== void 0 && !blocked.has(name.toLowerCase()))
-  );
-}
-function upgradeHeaders(headers = {}) {
-  if (String(headers.upgrade ?? "").toLowerCase() !== "websocket") return null;
-  return {
-    ...endToEndHeaders(headers),
-    connection: "Upgrade",
-    upgrade: "websocket"
-  };
-}
-function writeUpgrade(socket, response) {
-  const lines = [];
-  for (const name of [
-    "upgrade",
-    "connection",
-    "sec-websocket-accept",
-    "sec-websocket-protocol",
-    "sec-websocket-extensions"
-  ]) {
-    const value = response.headers[name];
-    if (typeof value === "string") lines.push(`${name}: ${value}`);
-  }
-  socket.write(
-    `HTTP/1.1 ${response.statusCode ?? 101} ${response.statusMessage ?? "Switching Protocols"}\r
-${lines.join("\r\n")}\r
-\r
-`
-  );
-}
-function destroySockets(sockets) {
-  for (const socket of sockets) socket.destroy();
-  sockets.clear();
-}
-function createCompanionOriginGateway({
-  target,
-  originHost = MANAGED_COMPANION_ORIGIN_HOST,
-  originPort = MANAGED_COMPANION_ORIGIN_PORT,
-  isTargetAlive = () => true,
-  createServer = http.createServer,
-  request = http.request,
-  upstreamTimeoutMs = 3e4
-} = {}) {
-  if (!validCompanionOriginTarget(target)) {
-    throw new Error("The companion origin target is invalid");
-  }
-  let accepting = true;
-  let listening = false;
-  let transition = Promise.resolve();
-  const upgradedSockets = /* @__PURE__ */ new Set();
-  const server = createServer((incoming, outgoing) => {
-    if (!accepting || !isTargetAlive(target)) return unavailable(outgoing);
-    const upstream = request(
-      {
-        headers: endToEndHeaders(incoming.headers),
-        method: incoming.method,
-        path: incoming.url,
-        socketPath: target.socketPath,
-        timeout: upstreamTimeoutMs
-      },
-      (response) => {
-        upstream.setTimeout(0);
-        if (!accepting || !isTargetAlive(target)) {
-          response.destroy();
-          return unavailable(outgoing);
-        }
-        outgoing.writeHead(response.statusCode ?? 502, endToEndHeaders(response.headers));
-        response.once("error", () => outgoing.destroy());
-        response.once("aborted", () => outgoing.destroy());
-        response.once("close", () => {
-          if (!response.complete) outgoing.destroy();
-        });
-        response.pipe(outgoing);
-      }
-    );
-    upstream.once("timeout", () => upstream.destroy(new Error("companion origin timed out")));
-    upstream.once("error", () => unavailable(outgoing));
-    incoming.once("aborted", () => upstream.destroy());
-    outgoing.once("close", () => upstream.destroy());
-    incoming.pipe(upstream);
-  });
-  server.on("upgrade", (incoming, socket, head) => {
-    if (!accepting || !isTargetAlive(target)) return socket.destroy();
-    const headers = upgradeHeaders(incoming.headers);
-    if (!headers || incoming.method !== "GET") return socket.destroy();
-    upgradedSockets.add(socket);
-    let remoteSocket = null;
-    const release = () => {
-      upgradedSockets.delete(socket);
-      if (remoteSocket) upgradedSockets.delete(remoteSocket);
-    };
-    socket.once("close", release);
-    const upstream = request({
-      headers,
-      method: "GET",
-      path: incoming.url,
-      socketPath: target.socketPath,
-      timeout: upstreamTimeoutMs
-    });
-    upstream.once("timeout", () => upstream.destroy(new Error("companion origin upgrade timed out")));
-    upstream.once("upgrade", (response, remote, remoteHead) => {
-      upstream.setTimeout(0);
-      remote.setTimeout(0);
-      if (!accepting || !isTargetAlive(target)) {
-        remote.destroy();
-        socket.destroy();
-        return;
-      }
-      writeUpgrade(socket, response);
-      remoteSocket = remote;
-      upgradedSockets.add(remote);
-      remote.once("close", release);
-      if (head.length) remote.write(head);
-      if (remoteHead.length) socket.write(remoteHead);
-      socket.pipe(remote).pipe(socket);
-    });
-    upstream.once("response", (response) => {
-      response.resume();
-      socket.destroy();
-    });
-    upstream.once("error", () => socket.destroy());
-    socket.once("close", () => upstream.destroy());
-    upstream.end();
-  });
-  server.on("clientError", (_error, socket) => socket.destroy());
-  const serialize = (work) => {
-    const next = transition.then(work, work);
-    transition = next.then(
-      () => {
-      },
-      () => {
-      }
-    );
-    return next;
-  };
-  return Object.freeze({
-    start() {
-      return serialize(async () => {
-        if (listening) return server.address();
-        await new Promise((resolve3, reject) => {
-          const onError = (error) => {
-            server.off("listening", onListening);
-            reject(error);
-          };
-          const onListening = () => {
-            server.off("error", onError);
-            resolve3();
-          };
-          server.once("error", onError);
-          server.once("listening", onListening);
-          server.listen({ exclusive: true, host: originHost, port: originPort });
-        });
-        listening = true;
-        return server.address();
-      });
-    },
-    invalidate() {
-      accepting = false;
-      server.closeAllConnections?.();
-      destroySockets(upgradedSockets);
-    },
-    close() {
-      return serialize(async () => {
-        accepting = false;
-        server.closeAllConnections?.();
-        destroySockets(upgradedSockets);
-        if (!listening) return;
-        await new Promise((resolve3) => server.close(() => resolve3()));
-        listening = false;
-      });
-    }
-  });
-}
 
 // electron/managed-companion-guardian.mjs
-import { spawn } from "node:child_process";
-import path2 from "node:path";
-import { fileURLToPath } from "node:url";
 var copyEnvironmentValue = (source, target, names) => {
   const entries = Object.entries(source);
   for (const name of names) {
@@ -1845,147 +1641,6 @@ function minimalGuardianEnvironment(environment = process.env, platform = proces
     ELECTRON_RUN_AS_NODE: "1"
   };
 }
-function processIsAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code !== "ESRCH";
-  }
-}
-var delay = (milliseconds) => new Promise((resolve3) => {
-  const timer = setTimeout(resolve3, milliseconds);
-  timer.unref?.();
-});
-async function terminateConnector(child, graceMs = 250) {
-  if (!child || child.exitCode !== null || child.signalCode !== null) return;
-  let exited = false;
-  const exit = new Promise((resolve3) => {
-    const finish = () => {
-      if (exited) return;
-      exited = true;
-      resolve3();
-    };
-    child.once("exit", finish);
-    child.once("error", () => {
-      if (!Number.isSafeInteger(child.pid)) finish();
-    });
-  });
-  try {
-    child.kill("SIGTERM");
-  } catch {
-  }
-  await Promise.race([exit, delay(graceMs)]);
-  if (exited || child.exitCode !== null || child.signalCode !== null) return;
-  try {
-    child.kill("SIGKILL");
-  } catch {
-  }
-  await exit;
-}
-function ownerLoss(ownerInput, signalSource) {
-  return new Promise((resolve3) => {
-    let settled = false;
-    const finish = () => {
-      if (settled) return;
-      settled = true;
-      resolve3({ kind: "owner" });
-    };
-    ownerInput.once("end", finish);
-    ownerInput.once("close", finish);
-    ownerInput.once("error", finish);
-    signalSource.once("SIGINT", finish);
-    signalSource.once("SIGTERM", finish);
-    ownerInput.resume?.();
-  });
-}
-async function runManagedCompanionGuardian({
-  cloudflaredBinary,
-  tokenFile,
-  target,
-  originPort = MANAGED_COMPANION_ORIGIN_PORT,
-  environment = process.env,
-  platform = process.platform,
-  ownerInput = process.stdin,
-  signalSource = process,
-  spawnProcess = spawn,
-  isTargetAlive = ({ pid }) => processIsAlive(pid),
-  createGateway = createCompanionOriginGateway
-} = {}) {
-  if (!path2.isAbsolute(cloudflaredBinary ?? "") || !path2.isAbsolute(tokenFile ?? "")) {
-    throw new Error("The managed connector paths are invalid");
-  }
-  if (!validCompanionOriginTarget(target, platform)) {
-    throw new Error("The managed companion origin target is invalid");
-  }
-  if (!Number.isInteger(originPort) || originPort < 1 || originPort > 65535) {
-    throw new Error("The managed companion origin port is invalid");
-  }
-  const gateway = createGateway({
-    target,
-    originPort,
-    isTargetAlive
-  });
-  await gateway.start();
-  let connector;
-  try {
-    connector = spawnProcess(
-      cloudflaredBinary,
-      [
-        "tunnel",
-        "--no-autoupdate",
-        "--loglevel",
-        "info",
-        "--output",
-        "json",
-        "run",
-        "--token-file",
-        tokenFile
-      ],
-      {
-        env: minimalCloudflaredEnvironment(environment, platform),
-        shell: false,
-        windowsHide: true,
-        stdio: ["ignore", "ignore", "ignore"]
-      }
-    );
-  } catch (error) {
-    gateway.invalidate();
-    await gateway.close();
-    throw error;
-  }
-  const connectorExit = new Promise((resolve3) => {
-    connector.once("exit", (code) => resolve3({ kind: "connector", code: code ?? 1 }));
-    connector.once("error", () => {
-      if (!Number.isSafeInteger(connector.pid)) {
-        resolve3({ kind: "connector", code: 1 });
-      }
-    });
-  });
-  const outcome = await Promise.race([connectorExit, ownerLoss(ownerInput, signalSource)]);
-  gateway.invalidate();
-  if (outcome.kind === "owner") await terminateConnector(connector);
-  await gateway.close();
-  return outcome.kind === "connector" ? outcome.code : 0;
-}
-function guardianArguments(argv) {
-  if (argv.length !== 5) throw new Error("The managed companion guardian arguments are invalid");
-  const [cloudflaredBinary, tokenFile, socketPath, rawPid, rawPort] = argv;
-  const pid = Number(rawPid);
-  const originPort = Number(rawPort);
-  const target = { pid, socketPath };
-  if (!validCompanionOriginTarget(target)) {
-    throw new Error("The managed companion guardian target is invalid");
-  }
-  return { cloudflaredBinary, tokenFile, target, originPort };
-}
-var isDirectExecution = process.argv[1] && path2.resolve(process.argv[1]) === path2.resolve(fileURLToPath(import.meta.url));
-if (isDirectExecution) {
-  runManagedCompanionGuardian(guardianArguments(process.argv.slice(2))).then(
-    (code) => process.exit(code),
-    () => process.exit(1)
-  );
-}
 
 // electron/managed-companion-tunnel.mjs
 var MANAGED_COMPANION_ENDPOINT_FIELD = "managedCompanionEndpointUrl";
@@ -2058,11 +1713,11 @@ function resolveCloudflaredBinary({
   exists = fs2.existsSync
 } = {}) {
   const executable = platform === "win32" ? "cloudflared.exe" : "cloudflared";
-  const bundled = path3.join(String(resourcesPath ?? ""), "cloudflared", executable);
+  const bundled = path2.join(String(resourcesPath ?? ""), "cloudflared", executable);
   if (isPackaged) return exists(bundled) ? bundled : null;
   const override = environment.OMB_CLOUDFLARED_PATH?.trim();
-  if (override) return path3.isAbsolute(override) && exists(override) ? override : null;
-  const staged = path3.join(
+  if (override) return path2.isAbsolute(override) && exists(override) ? override : null;
+  const staged = path2.join(
     String(appPath ?? ""),
     "dist-native",
     "cloudflared",
@@ -2075,8 +1730,8 @@ function resolveCloudflaredBinary({
   if (!pathValue) return null;
   const delimiter2 = platform === "win32" ? ";" : ":";
   for (const directory of pathValue.split(delimiter2)) {
-    if (!directory || !path3.isAbsolute(directory)) continue;
-    const candidate = path3.join(directory, executable);
+    if (!directory || !path2.isAbsolute(directory)) continue;
+    const candidate = path2.join(directory, executable);
     if (exists(candidate)) return candidate;
   }
   return null;
@@ -2092,7 +1747,7 @@ function ensurePrivateDirectory(directory, fileSystem, currentUid) {
   }
   fileSystem.chmodSync(directory, 448);
 }
-function processIsAlive2(pid) {
+function processIsAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -2104,7 +1759,7 @@ var currentUserId2 = () => process.platform === "win32" ? void 0 : process.getui
 function cleanupStaleManagedCompanionTokens(runtimeRoot, {
   fileSystem = fs2,
   currentUid = currentUserId2(),
-  isProcessAlive = processIsAlive2
+  isProcessAlive = processIsAlive
 } = {}) {
   let entries;
   try {
@@ -2119,7 +1774,7 @@ function cleanupStaleManagedCompanionTokens(runtimeRoot, {
     if (!match || !entry.isFile() || entry.isSymbolicLink()) continue;
     const ownerPid = Number(match[1]);
     if (!Number.isSafeInteger(ownerPid) || isProcessAlive(ownerPid)) continue;
-    const file = path3.join(runtimeRoot, entry.name);
+    const file = path2.join(runtimeRoot, entry.name);
     try {
       const stat = fileSystem.lstatSync(file);
       if (!stat.isFile() || stat.isSymbolicLink() || currentUid !== void 0 && stat.uid !== currentUid || process.platform !== "win32" && (stat.mode & 63) !== 0) {
@@ -2134,7 +1789,7 @@ function cleanupStaleManagedCompanionTokens(runtimeRoot, {
 }
 function writePrivateToken(runtimeRoot, token, { fileSystem, processId, identifier, currentUid }) {
   ensurePrivateDirectory(runtimeRoot, fileSystem, currentUid);
-  const file = path3.join(runtimeRoot, `connector-${processId}-${identifier()}.token`);
+  const file = path2.join(runtimeRoot, `connector-${processId}-${identifier()}.token`);
   let descriptor;
   try {
     descriptor = fileSystem.openSync(file, "wx", 384);
@@ -2211,13 +1866,13 @@ function createManagedCompanionTunnel({
   runtimeRoot,
   environment = process.env,
   fileSystem = fs2,
-  spawnProcess = spawn2,
+  spawnProcess = spawn,
   fetchImpl = globalThis.fetch,
   timeoutSignal = (milliseconds) => AbortSignal.timeout(milliseconds),
   identifier = randomUUID2,
   processId = process.pid,
   currentUid = currentUserId2(),
-  isProcessAlive = processIsAlive2,
+  isProcessAlive = processIsAlive,
   verifyTimeoutMs = 15e3,
   verifyRequestTimeoutMs = 2500,
   verifyIntervalMs = 250,
@@ -2277,19 +1932,19 @@ function createManagedCompanionTunnel({
   };
   const scheduleRetry = (reason, ownedGeneration) => {
     if (!desired || ownedGeneration !== generation || retryTimer) return;
-    const delay2 = Math.min(1e3 * 2 ** retryAttempt, maxRetryMs);
+    const delay = Math.min(1e3 * 2 ** retryAttempt, maxRetryMs);
     retryAttempt += 1;
-    publish({ status: "retrying", ready: false, error: reason, retryInMs: delay2 });
+    publish({ status: "retrying", ready: false, error: reason, retryInMs: delay });
     retryTimer = setTimeout(() => {
       retryTimer = null;
       if (!desired || ownedGeneration !== generation) return;
       void serialize(() => attempt(ownedGeneration));
-    }, delay2);
+    }, delay);
     retryTimer.unref?.();
   };
   const attempt = async (ownedGeneration) => {
     if (!desired || ownedGeneration !== generation || !access) return state;
-    if (!binaryPath || !path3.isAbsolute(binaryPath) || !guardianEntry2 || !path3.isAbsolute(guardianEntry2) || !path3.isAbsolute(runtimeExecutable) || !validCompanionOriginTarget(originTarget)) {
+    if (!binaryPath || !path2.isAbsolute(binaryPath) || !guardianEntry2 || !path2.isAbsolute(guardianEntry2) || !path2.isAbsolute(runtimeExecutable) || !validCompanionOriginTarget(originTarget)) {
       publish({
         status: "unavailable",
         ready: false,
@@ -3056,8 +2711,8 @@ function createSecureCredentialState(initialCredentials, persist, { writable = t
 // server/atomic.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-function writeFileAtomic(path4, data, options = {}) {
-  const tmp = `${path4}.${process.pid}.${randomUUID3()}.tmp`;
+function writeFileAtomic(path3, data, options = {}) {
+  const tmp = `${path3}.${process.pid}.${randomUUID3()}.tmp`;
   let fd = null;
   try {
     fd = openSync(tmp, "w", options.mode);
@@ -3065,7 +2720,7 @@ function writeFileAtomic(path4, data, options = {}) {
     fsyncSync(fd);
     closeSync(fd);
     fd = null;
-    renameSync(tmp, path4);
+    renameSync(tmp, path3);
   } catch (e) {
     if (fd !== null) {
       try {
@@ -3082,7 +2737,7 @@ function writeFileAtomic(path4, data, options = {}) {
 }
 
 // server/tunnel.ts
-var HERE = dirname(fileURLToPath2(import.meta.url));
+var HERE = dirname(fileURLToPath(import.meta.url));
 var TUNNEL_CREDENTIALS_FILE = "tunnel-account.json";
 var TUNNEL_RUNTIME_DIR = "tunnel-runtime";
 function plainDocument(value) {
@@ -3160,7 +2815,7 @@ function prepareEntry(here = HERE) {
 function guardianEntry(here = HERE) {
   const bundled = join2(here, "tunnel-guardian.js");
   if (existsSync(bundled)) return bundled;
-  const source = resolve(here, "..", "electron", "managed-companion-guardian.mjs");
+  const source = resolve(here, "..", "electron", "managed-companion-guardian-main.mjs");
   return existsSync(source) ? source : null;
 }
 async function ensureCloudflared(options) {
@@ -3169,7 +2824,7 @@ async function ensureCloudflared(options) {
   if (found) return found;
   options.log(`downloading cloudflared once (pinned version and digest, about 40 MB) into ${options.dataDir}`);
   await new Promise((done, fail) => {
-    const child = spawn3(process.execPath, [prepareEntry(options.here), "--current", "--root", options.dataDir], {
+    const child = spawn2(process.execPath, [prepareEntry(options.here), "--current", "--root", options.dataDir], {
       env,
       stdio: ["ignore", "inherit", "inherit"]
     });
@@ -3228,7 +2883,7 @@ function describeTunnelState(state, address) {
 }
 
 // server/cli.ts
-var HERE2 = dirname2(fileURLToPath3(import.meta.url));
+var HERE2 = dirname2(fileURLToPath2(import.meta.url));
 var COMMANDS = ["serve", "pair", "sessions", "status", "login", "logout", "help", "--help", "-h"];
 function parseArgs(argv, env = process.env) {
   const [command = "help", ...rest] = argv;
@@ -3324,8 +2979,8 @@ function serverVersion(here = HERE2) {
   }
 }
 var message = (error) => error instanceof Error ? error.message : String(error);
-async function api(port, path4, init = {}) {
-  const res = await fetch(`http://127.0.0.1:${port}${path4}`, { method: init.method, body: init.body, headers: { "content-type": "application/json" } });
+async function api(port, path3, init = {}) {
+  const res = await fetch(`http://127.0.0.1:${port}${path3}`, { method: init.method, body: init.body, headers: { "content-type": "application/json" } });
   const body = await res.json().catch(() => ({}));
   return { status: res.status, body };
 }
@@ -3575,7 +3230,7 @@ async function runServe(options, log = console.log) {
     log(`tailscale: serving https://${tailscale.dnsName} \u2192 http://127.0.0.1:${options.port} (only your tailnet can reach it)`);
   }
   if (publicUrl) env.OMB_PUBLIC_URL = publicUrl;
-  const child = spawn4(entry.command, entry.args, { env, stdio: ["ignore", "inherit", "inherit"] });
+  const child = spawn3(entry.command, entry.args, { env, stdio: ["ignore", "inherit", "inherit"] });
   let exited = null;
   child.on("exit", (code) => {
     exited = code ?? 1;
@@ -3661,11 +3316,15 @@ ${USAGE}`);
   }
 }
 
+// server/exit.ts
+function exitAfterFlush(code) {
+  process.exitCode = code;
+  const flushed = (stream) => new Promise((done) => stream.write("", () => done()));
+  void Promise.all([flushed(process.stdout), flushed(process.stderr)]).then(() => process.exit(code));
+}
+
 // server/pair-cli.ts
-main(["pair", ...process.argv.slice(2)]).then(
-  (code) => process.exit(code),
-  (error) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  }
-);
+main(["pair", ...process.argv.slice(2)]).then(exitAfterFlush, (error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  exitAfterFlush(1);
+});

package/dist-server/server/auto-approve.js

@@ -11,6 +11,30 @@
 // backstop for the obvious catastrophes. Real containment is the
 // sandbox and the bot's own computer, not a regex.
 import { approvalModeFor } from "../shared/approval-mode.js";
+/** The mode a turn actually runs under, given where the turn came from.
+ *
+ * Full and Custom are Codex's: on any other engine they fall to Ask, so a
+ * hand-edited record cannot hand Claude a bypass it was never granted.
+ *
+ * And Full is a decision the person made about THEIR OWN sessions with a
+ * bot — "run without asking me". A turn started by another bot is not one
+ * of those: the person never saw the request, and the sender may itself be
+ * unattended or working off a page it just read. A Full target reached that
+ * way runs as Approve for me instead — ordinary requests still flow, the
+ * destructive and sensitive guards card, an unattended sender's block holds,
+ * and every answer goes through the fold and into the decision log, where a
+ * driver-side Full accept never appears. A webhook or scheduled turn on a
+ * Full bot is unchanged: the person opted into that, and the docs say so. */
+export function approvalModeForOrigin(mode, origin) {
+    // Provider support is settled by supportsApprovalMode at the call site;
+    // this only answers who STARTED the turn. A permissive mode is the
+    // person's grant to the bot they talk to, not to every teammate that can
+    // reach it, so a peer-started turn runs one notch down and still gets the
+    // unattended downgrade after this.
+    if ((mode === "full" || mode === "custom") && origin.peerInitiated)
+        return "auto";
+    return mode;
+}
 const DESTRUCTIVE = [
     /\brm\s+(-[a-z]*\s+)*-[a-z]*[rf]/i, // rm -rf, rm -fr, rm -r -f
     /\bmkfs\b|\bdiskutil\s+erase|\bdd\s+[^|]*\bof=\/dev\//i,
@@ -160,3 +184,27 @@ export function autoVerdict(bot, tool, summary, context) {
 export function autoDecision(bot, tool, summary, context) {
     return autoVerdict(bot, tool, summary, context).approve;
 }
+/** The note a card shows above its buttons, explaining why the bot stopped
+ * rather than answering for itself.
+ *
+ * The unattended case is the one users misread. A turn a webhook or another
+ * bot started never runs Auto at all — approvalModeForTurn downgrades it to
+ * Ask before the provider spawns — so "this action needs you" would name the
+ * wrong cause and imply the next action might pass. It will not: with a fleet
+ * delegating between bots, every card looks like this until someone answers.
+ * Say that plainly, and name the mode that keeps running. */
+export function approvalHeldReason(context) {
+    if (context.source === "native-approval")
+        return "The provider requires your approval for this action.";
+    if (!context.permission)
+        return undefined;
+    if (context.requiresExplicitApproval) {
+        return "This changes the provider sandbox, so only Full access can approve it automatically.";
+    }
+    if (context.mode !== "auto")
+        return undefined;
+    if (!context.unattended)
+        return "This action needs you, so Approve for me stopped to ask.";
+    const hint = context.fullAccessAvailable ? " Full access keeps working unattended." : "";
+    return `A webhook or another bot started this turn, so Approve for me is paused and every action asks.${hint}`;
+}