openmausbot 0.1.92 → 0.1.94

package/dist-server/src/lib/thread-refs.js

@@ -0,0 +1,406 @@
+// "#QA PR 245" in prose becomes a link to that thread. Bots are asked to
+// write a thread's title as #Title when they mention one, and the person
+// may type the same. Resolution mirrors @mention resolution for bots:
+// word-start, longest known title first, case-insensitive — titles hold
+// spaces, so the longest known title following the "#" wins. Nothing else
+// is a link: "#123" issue numbers, "# Heading" markers (the parser never
+// hands those here) and unknown titles all stay plain text.
+const WORD_CHAR = /[\p{L}\p{N}_]/u;
+/** a "#" glued to one of these is not a word start: C#Title, ', ##x */
+const NOT_WORD_START = /[\p{L}\p{N}_#&]/u;
+/** Spacing a pasted thread token needs on each side: a lead space after
+ * any char the resolver refuses as a word start — word chars, but also #
+ * and &, so a paste after them cannot glue into ##Title — and a trail
+ * space before a plain word char. */
+export function threadTokenSpacing(text, start, end) {
+    return {
+        lead: start > 0 && NOT_WORD_START.test(text[start - 1] ?? "") ? " " : "",
+        trail: end < text.length && WORD_CHAR.test(text[end] ?? "") ? " " : "",
+    };
+}
+/** Only a title that is a real name can be linked: "123" would turn every
+ * issue number into a thread link. */
+function linkable(title) {
+    return title.length > 0 && !/^\d+$/.test(title);
+}
+/** Known titles, longest first, each with every thread that carries it in
+ * the caller's (recency) order. */
+function groupTitles(threads) {
+    const groups = new Map();
+    const seen = new Set();
+    for (const thread of threads) {
+        const title = thread.title.trim();
+        const key = `${thread.botId}/${thread.threadId}`;
+        if (!linkable(title) || seen.has(key))
+            continue;
+        seen.add(key);
+        const lower = title.toLowerCase();
+        const group = groups.get(lower);
+        if (group)
+            group.candidates.push({ ...thread, title });
+        else
+            groups.set(lower, { lower, candidates: [{ ...thread, title }] });
+    }
+    return [...groups.values()].sort((a, b) => b.lower.length - a.lower.length);
+}
+/** Which of several same-titled threads a mention means: the current
+ * bot's, else the most recently active, else the first — flagged so the
+ * link can say which bot it landed on. */
+function pick(candidates, currentBotId) {
+    const resolved = (thread, ambiguous) => ({
+        botId: thread.botId, botName: thread.botName, threadId: thread.threadId, title: thread.title, ambiguous,
+    });
+    if (candidates.length === 1)
+        return resolved(candidates[0], false);
+    const own = candidates.filter((thread) => thread.botId === currentBotId);
+    if (own.length === 1)
+        return resolved(own[0], false);
+    const pool = own.length > 1 ? own : candidates;
+    const stamps = pool.map((thread) => thread.activeAt);
+    if (stamps.every((stamp) => typeof stamp === "number")) {
+        const newest = Math.max(...stamps);
+        const latest = pool.filter((thread) => thread.activeAt === newest);
+        if (latest.length === 1)
+            return resolved(latest[0], false);
+    }
+    return resolved(pool[0], true);
+}
+/** Split `text` into plain runs and linked "#Title" runs. The linked run
+ * keeps the person's own spelling ("#qa pr 245" stays as typed). */
+export function resolveThreadRefs(text, threads, currentBotId) {
+    const groups = groupTitles(threads);
+    if (!groups.length || !text.includes("#"))
+        return [{ text }];
+    const spans = [];
+    let last = 0;
+    let at = text.indexOf("#");
+    while (at !== -1) {
+        const before = at > 0 ? text[at - 1] : "";
+        const start = at + 1;
+        let matched = null;
+        if (!before || !NOT_WORD_START.test(before)) {
+            for (const group of groups) {
+                const end = start + group.lower.length;
+                if (text.slice(start, end).toLowerCase() !== group.lower)
+                    continue;
+                const after = text[end] ?? "";
+                if (after && WORD_CHAR.test(after))
+                    continue;
+                matched = { end, ref: pick(group.candidates, currentBotId) };
+                break;
+            }
+        }
+        if (matched) {
+            if (at > last)
+                spans.push({ text: text.slice(last, at) });
+            spans.push({ text: text.slice(at, matched.end), ref: matched.ref });
+            last = matched.end;
+            at = text.indexOf("#", matched.end);
+        }
+        else {
+            at = text.indexOf("#", at + 1);
+        }
+    }
+    if (last < text.length)
+        spans.push({ text: text.slice(last) });
+    return spans.length ? spans : [{ text }];
+}
+const THREAD_URL_PREFIX = "openmausbot://thread/";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const ID_LIMIT = 256;
+const plainId = (value) => {
+    // oxlint-disable-next-line no-control-regex -- a thread id never carries control characters
+    if (!value || value.length > ID_LIMIT || /[\u0000-\u001f]/.test(value))
+        return null;
+    return value;
+};
+/** The canonical link for a thread a person can copy. */
+export function threadRefUrl(ref) {
+    return THREAD_URL_PREFIX + encodeURIComponent(ref.threadId) + "?bot=" + encodeURIComponent(ref.botId);
+}
+/** Parse a canonical thread link; null for anything else, including
+ * near-misses with extra path, extra query or a foreign scheme. */
+export function parseThreadRefUrl(value) {
+    const raw = value.trim();
+    if (!raw.toLowerCase().startsWith(THREAD_URL_PREFIX))
+        return null;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    if (url.username || url.password || url.port || url.hash)
+        return null;
+    if (url.hostname.toLowerCase() !== "thread")
+        return null;
+    let threadId;
+    try {
+        threadId = decodeURIComponent(url.pathname.slice(1));
+    }
+    catch {
+        return null;
+    }
+    if (!threadId || threadId.includes("/") || url.pathname.slice(1) !== encodeURIComponent(threadId))
+        return null;
+    const keys = [...url.searchParams.keys()];
+    if (keys.some((key) => key !== "bot"))
+        return null;
+    const bot = url.searchParams.get("bot");
+    if (keys.length > 1 || (bot !== null && !bot))
+        return null;
+    const thread = plainId(threadId);
+    const owner = bot === null ? undefined : plainId(bot);
+    if (!thread || owner === null)
+        return null;
+    return owner ? { threadId: thread, botId: owner } : { threadId: thread };
+}
+/** Whether a value is shaped like a thread link at all — even one that
+ * fails strict parsing. Markdown must never hand such a URL to the shell
+ * as an external link, live or dead. */
+export function looksLikeThreadRefUrl(value) {
+    return value.trim().toLowerCase().startsWith(THREAD_URL_PREFIX);
+}
+/** A raw thread id on its own: the UUID form the server mints. */
+export function isThreadUuid(value) {
+    return UUID.test(value.trim());
+}
+/** Resolve an address (or bare UUID) against the visible threads. The
+ * link's own bot wins when it names one; otherwise the same preference a
+ * #Title mention uses: the open bot's thread, then the newest, then a
+ * deterministic first — flagged ambiguous so the chip can name the bot. */
+export function resolveThreadRefAddress(threads, address, currentBotId) {
+    const candidates = threads.filter((thread) => thread.threadId === address.threadId);
+    if (!candidates.length)
+        return null;
+    const pinned = address.botId ? candidates.filter((thread) => thread.botId === address.botId) : [];
+    if (pinned.length === 1)
+        return { ...pinned[0], title: pinned[0].title.trim(), ambiguous: false };
+    if (pinned.length > 1)
+        return pick(pinned, currentBotId);
+    // a pinned owner missing from the visible threads is a dead reference:
+    // never fall through to another bot's same-id thread
+    if (address.botId)
+        return null;
+    return pick(candidates, currentBotId);
+}
+// ── sent-message serialization ─────────────────────────────────────────
+// A resolvable #Title becomes a markdown link whose URL carries the thread
+// id, so bots and API consumers keep the machine-readable reference. The
+// label keeps the title readable; escapes keep brackets in titles parseable.
+const escapeThreadLabel = (title) => title.replace(/[[\]\\]/g, "\\$&");
+const unescapeThreadLabel = (label) => label.replace(/\\(.)/g, "$1");
+/** The markdown shape a thread reference is sent as. */
+export function threadRefMarkdown(ref) {
+    return "[" + escapeThreadLabel(ref.title) + "](" + threadRefUrl(ref) + ")";
+}
+const MARKDOWN_LINK_LABEL = /\[((?:\\.|[^\\\]])*)\]\(/y;
+const INLINE_LINK_SPACE = " \t\n\r";
+/** The CommonMark inline-link tail after "[label](": optional whitespace,
+ * an angle-bracket destination (spaces allowed) or a bare destination with
+ * balanced parentheses, optional whitespace, an optional quoted title, and
+ * the closing ")". Returns the tail length plus the bare destination for
+ * resolution, or null when no complete link closes here. */
+function inlineLinkTail(rest, from) {
+    let at = from;
+    while (at < rest.length && INLINE_LINK_SPACE.includes(rest.charAt(at)))
+        at += 1;
+    const destStart = at;
+    let destination = "";
+    if (rest.charAt(at) === "<") {
+        const close = rest.indexOf(">", at + 1);
+        if (close === -1)
+            return null;
+        destination = rest.slice(at + 1, close);
+        at = close + 1;
+    }
+    else {
+        let depth = 0;
+        while (at < rest.length) {
+            const ch = rest.charAt(at);
+            if (ch === "(")
+                depth += 1;
+            else if (ch === ")") {
+                if (depth === 0)
+                    break;
+                depth -= 1;
+            }
+            else if (INLINE_LINK_SPACE.includes(ch))
+                break;
+            at += 1;
+        }
+        if (depth !== 0)
+            return null;
+        destination = rest.slice(destStart, at);
+    }
+    while (at < rest.length && INLINE_LINK_SPACE.includes(rest.charAt(at)))
+        at += 1;
+    const titleQuote = rest.charAt(at);
+    if (titleQuote === '"' || titleQuote === "'") {
+        const close = rest.indexOf(titleQuote, at + 1);
+        if (close === -1)
+            return null;
+        at = close + 1;
+    }
+    else if (titleQuote === "(") {
+        let depth = 1;
+        at += 1;
+        while (at < rest.length && depth > 0) {
+            const ch = rest.charAt(at);
+            if (ch === "(")
+                depth += 1;
+            else if (ch === ")")
+                depth -= 1;
+            at += 1;
+        }
+        if (depth !== 0)
+            return null;
+    }
+    while (at < rest.length && INLINE_LINK_SPACE.includes(rest.charAt(at)))
+        at += 1;
+    if (rest.charAt(at) !== ")")
+        return null;
+    return { tail: at + 1 - from, destination };
+}
+/** Split text into plain runs and the spans resolution must never touch.
+ * Every markdown link is kept verbatim — a #Title inside a label would
+ * nest links — and so is code: inline backticks and fenced blocks quote
+ * their contents, so only plain runs carry #Title mentions. */
+function splitThreadLinkMarkdown(text) {
+    if (!text.includes("](") && !text.includes("`"))
+        return [{ raw: text }];
+    const spans = [];
+    let plain = "";
+    const flush = () => {
+        if (plain)
+            spans.push({ raw: plain });
+        plain = "";
+    };
+    let at = 0;
+    while (at < text.length) {
+        const rest = text.slice(at);
+        const guarded = (end) => {
+            flush();
+            spans.push({ raw: text.slice(at, end), code: true });
+            at = end;
+        };
+        if (rest.startsWith("```")) {
+            const close = rest.indexOf("```", 3);
+            guarded(close === -1 ? text.length : at + close + 3);
+            continue;
+        }
+        const ticks = /^`+/.exec(rest)?.[0];
+        if (ticks) {
+            const close = rest.indexOf(ticks, ticks.length);
+            guarded(close === -1 ? text.length : at + close + ticks.length);
+            continue;
+        }
+        MARKDOWN_LINK_LABEL.lastIndex = 0;
+        const open = MARKDOWN_LINK_LABEL.exec(rest);
+        const tail = open && inlineLinkTail(rest, open[0].length);
+        if (open && tail) {
+            flush();
+            const raw = rest.slice(0, open[0].length + tail.tail);
+            spans.push({ raw, link: { label: open[1], address: parseThreadRefUrl(tail.destination) } });
+            at += raw.length;
+            continue;
+        }
+        plain += text[at];
+        at += 1;
+    }
+    flush();
+    return spans.length ? spans : [{ raw: text }];
+}
+/** The text a send carries: resolvable #Title runs become canonical links;
+ * existing links and unknown titles pass through untouched. */
+export function serializeThreadRefs(text, threads, currentBotId) {
+    if (!groupTitles(threads).length)
+        return text;
+    return splitThreadLinkMarkdown(text)
+        .map((span) => (span.link || span.code) ? span.raw : resolveThreadRefs(span.raw, threads, currentBotId)
+        .map((run) => run.ref ? threadRefMarkdown(run.ref) : run.text)
+        .join(""))
+        .join("");
+}
+export function splitThreadRefsForDisplay(text, threads, currentBotId) {
+    const spans = [];
+    for (const span of splitThreadLinkMarkdown(text)) {
+        if (span.link) {
+            const ref = span.link.address ? resolveThreadRefAddress(threads, span.link.address, currentBotId) : null;
+            spans.push(ref ? { text: unescapeThreadLabel(span.link.label), ref } : { text: span.raw });
+        }
+        else if (span.code) {
+            spans.push({ text: span.raw });
+        }
+        else {
+            spans.push(...resolveThreadRefs(span.raw, threads, currentBotId));
+        }
+    }
+    return spans.length ? spans : [{ text }];
+}
+/** The whole paste is one thread reference — a canonical link, the markdown
+ * link shape messages carry, or a raw UUID — and it resolves to a visible
+ * thread: the #Title token the composer holds, plus what it resolved to.
+ * null when the paste is not a reference or names no known thread, so an
+ * unknown id stays plain text. */
+export function threadTokenFromPaste(pasted, threads, currentBotId) {
+    const trimmed = pasted.trim();
+    if (!trimmed)
+        return null;
+    const wrapped = /^\[((?:\\.|[^\\\]])*)\]\((openmausbot:\/\/thread\/[^()\s]*)\)$/.exec(trimmed);
+    const address = wrapped
+        ? parseThreadRefUrl(wrapped[2])
+        : parseThreadRefUrl(trimmed) ?? (isThreadUuid(trimmed) ? { threadId: trimmed } : null);
+    if (!address)
+        return null;
+    const ref = resolveThreadRefAddress(threads, address, currentBotId);
+    if (!ref)
+        return null;
+    // '#Title' is the token of choice, but a numeric or '#' prefixed title
+    // can never re-resolve through that spelling — those pastes hold the
+    // canonical markdown link instead, which sends and displays the same.
+    const title = ref.title.trim();
+    const token = linkable(title) && !title.startsWith("#") ? `#${title}` : threadRefMarkdown(ref);
+    return { token, ref };
+}
+const OPAQUE = new Set(["link", "linkReference", "image", "imageReference", "definition", "html", "mention"]);
+export const THREAD_REF_NODE = "threadRef";
+function linkNode(text, ref) {
+    return {
+        type: THREAD_REF_NODE,
+        data: {
+            hName: "span",
+            hProperties: {
+                "data-thread-bot": ref.botId,
+                "data-thread-bot-name": ref.botName,
+                "data-thread-id": ref.threadId,
+                "data-thread-title": ref.title,
+                "data-thread-ambiguous": ref.ambiguous ? "true" : "false",
+            },
+        },
+        children: [{ type: "text", value: text }],
+    };
+}
+/** A unified attacher: `remarkPlugins={[remarkThreadRefs(threads, botId)]}`. */
+export function remarkThreadRefs(threads, currentBotId) {
+    return () => (tree) => {
+        if (!threads.length)
+            return;
+        const visit = (node) => {
+            if (!node.children || OPAQUE.has(node.type))
+                return;
+            node.children = node.children.flatMap((child) => {
+                if (child.type !== "text" || typeof child.value !== "string") {
+                    visit(child);
+                    return [child];
+                }
+                const spans = resolveThreadRefs(child.value, threads, currentBotId);
+                if (!spans.some((span) => span.ref))
+                    return [child];
+                return spans.map((span) => (span.ref ? linkNode(span.text, span.ref) : { type: "text", value: span.text }));
+            });
+        };
+        visit(tree);
+    };
+}

package/dist-server/vps-container-mcp.js

@@ -136,6 +136,8 @@ function windowsKnownDirs() {
     // x.ai installer
     join(localAppData, "agy", "bin"),
     // Antigravity installer
+    // Cursor installer: cursor-agent.* and its `agent` copies (MOCA-272)
+    join(localAppData, "cursor-agent"),
     join(home, ".local", "bin"),
     // claude native installer
     join(home, ".claude", "local"),
@@ -143,7 +145,9 @@ function windowsKnownDirs() {
     // Factory droid installer (%USERPROFILE%\bin)
     join(home, ".bun", "bin"),
     join(home, ".deno", "bin"),
-    join(home, "go", "bin")
+    join(home, "go", "bin"),
+    join(process.env.ProgramFiles ?? "C:\\Program Files", "Docker", "Docker", "resources", "bin")
+    // Docker Desktop installer
   ];
 }
 var cached = null;
@@ -624,7 +628,7 @@ import { promisify } from "node:util";
 
 // server/config.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join2 } from "node:path";
 
 // node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -15926,6 +15930,48 @@ function normalizeCronSchedule(value, after = Date.now()) {
   return schedule;
 }
 
+// shared/tool-scope.ts
+var SERVER_NAME = /^[a-z][a-z0-9_-]{0,31}$/;
+var CONTROL_CHARACTER = /[\x00-\x1f\x7f]/;
+var MAX_SELECTORS = 256;
+var MAX_SELECTOR_LENGTH = 1024;
+function validName(name) {
+  return typeof name === "string" && name.trim().length > 0 && name.length <= MAX_SELECTOR_LENGTH && !CONTROL_CHARACTER.test(name) && !name.includes("*");
+}
+function selectorIdentity(selector) {
+  if (selector.length > MAX_SELECTOR_LENGTH || CONTROL_CHARACTER.test(selector)) return;
+  if (selector.startsWith("native:")) {
+    const name = selector.slice(7);
+    if (name === "*" || validName(name)) return { kind: "native", name };
+  } else if (selector.startsWith("mcp:")) {
+    const separator = selector.indexOf(":", 4);
+    if (separator < 0) return;
+    const server = selector.slice(4, separator);
+    const name = selector.slice(separator + 1);
+    if (SERVER_NAME.test(server) && (name === "*" || validName(name))) {
+      return { kind: "mcp", server, name };
+    }
+  }
+}
+function parseToolScope(value) {
+  if (value === void 0) return { ok: true, scope: void 0 };
+  const invalid = { ok: false, error: "Tool selection must contain only valid allow and deny lists." };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return invalid;
+  const scope = {};
+  for (const key of Reflect.ownKeys(value)) {
+    if (key !== "allow" && key !== "deny") return invalid;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor)) return invalid;
+    const list = descriptor.value;
+    if (!Array.isArray(list) || list.length > MAX_SELECTORS) return invalid;
+    if (!Array.from(list).every((entry) => typeof entry === "string" && selectorIdentity(entry))) return invalid;
+    scope[key] = [...new Set(list)];
+  }
+  return { ok: true, scope };
+}
+
 // server/new-bot-defaults.ts
 var strings = (max, length) => external_exports.array(external_exports.string().max(length)).max(max);
 var clock = external_exports.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/);
@@ -15960,6 +16006,10 @@ var botDefaultsProfileSchema = profilePatchSchema.extend({
   browser: external_exports.boolean().optional(),
   browserProfile: external_exports.string().max(100).nullable().optional(),
   mcpServers: strings(100, 100).nullable().optional(),
+  toolScope: external_exports.custom((value) => value !== void 0 && parseToolScope(value).ok, "Invalid tool selection").transform((value) => {
+    const parsed = parseToolScope(value);
+    return parsed.ok ? parsed.scope : value;
+  }).nullable().optional(),
   parkDirectMessages: external_exports.boolean().optional()
 }).strict();
 var scheduleSchema = external_exports.discriminatedUnion("type", [
@@ -16156,76 +16206,6 @@ var remoteMutationSchema = remoteEntrySchema.extend({
 var CLOUD_SEAT_IDLE_STOP_MS = 5 * 6e4;
 var CLOUD_SEAT_SLEEP_RETRY_MAX_MS = 10 * 6e4;
 
-// server/proxy-paths.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
-import { fileURLToPath } from "node:url";
-var SERVER_ROOT = dirname2(fileURLToPath(import.meta.url));
-function resolveProxy(relative) {
-  const source = join2(SERVER_ROOT, `${relative}.ts`);
-  return existsSync2(source) ? source : join2(SERVER_ROOT, `${relative}.js`);
-}
-var SPAWNED_PROXIES = {
-  browser: resolveProxy("browser-proxy"),
-  localComputer: resolveProxy("local-computer-proxy"),
-  permission: resolveProxy("permission-proxy"),
-  containerMcp: resolveProxy("container-mcp"),
-  vpsContainerMcp: resolveProxy("vps-container-mcp"),
-  agents: resolveProxy("drivers/agents-proxy"),
-  dweb: resolveProxy("drivers/dweb-proxy"),
-  connectors: resolveProxy("connector-proxy"),
-  mcpGate: resolveProxy("mcp-gate"),
-  phone: resolveProxy("drivers/phone-proxy"),
-  hook: resolveProxy("hooks/omb-hook"),
-  // Loaded by the external `pi` process via `-e`, not by this server — but
-  // resolved through the same single source of truth so the packaged layout
-  // check can assert it ships.
-  piMcpExtension: resolveProxy("drivers/pi-mcp-extension")
-};
-
-// server/enterprise.ts
-var layerSchema = external_exports.object({
-  customer: external_exports.string().min(1),
-  features: external_exports.array(external_exports.string().min(1)),
-  expiresAt: external_exports.string().nullable()
-});
-var DAY_MS = 24 * 60 * 6e4;
-
-// server/sessions.ts
-var PAIRING_CODE_TTL_MS = 5 * 6e4;
-function daysMs(value, fallbackDays) {
-  const days = Number(value);
-  const ok = Number.isInteger(days) && days >= 1 && days <= 3650;
-  return (ok ? days : fallbackDays) * 24 * 60 * 6e4;
-}
-var SESSION_TTL_MS = daysMs(process.env.OMB_SESSION_TTL_DAYS, 30);
-var SESSION_MAX_AGE_MS = daysMs(process.env.OMB_SESSION_MAX_DAYS, 180);
-var SESSION_RENEW_WHEN_LEFT_MS = SESSION_TTL_MS / 2;
-var STREAM_TICKET_TTL_MS = 5 * 6e4;
-var scopeSchema = external_exports.enum(["admin", "client"]);
-var sessionSchema = external_exports.object({
-  id: external_exports.string().min(1),
-  tokenHash: external_exports.string().length(64),
-  label: external_exports.string().max(80),
-  scopes: external_exports.array(scopeSchema).min(1),
-  createdAt: external_exports.number(),
-  lastSeenAt: external_exports.number(),
-  expiresAt: external_exports.number(),
-  /** Set when the session came from an account sign-in rather than a code. */
-  userId: external_exports.string().max(256).optional(),
-  email: external_exports.string().max(320).optional(),
-  /** Set only by the internal verified-portal issuance path, never by email or pairing input. */
-  membershipAuthority: external_exports.literal("portal").optional(),
-  /** A browser sign-in (PairingCode `browser`): accepted only as its browser's cookie, never as a bearer token. */
-  cookieOnly: external_exports.literal(true).optional(),
-  /** Whose OMB Cloud a browser sign-in signed in to (its PairingCode `owner`). */
-  owner: external_exports.string().max(254).optional()
-});
-var fileSchema = external_exports.object({ version: external_exports.literal(1), sessions: external_exports.array(sessionSchema) });
-
-// server/cloud-home.ts
-var CLOUD_PAIRING_NONCE_MS = 10 * 6e4;
-
 // server/config.ts
 var optionalText = external_exports.string().optional();
 var SSH_ALIAS = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
@@ -16433,7 +16413,11 @@ var featureConfigSchema = external_exports.object({
    * may offer a per-second-billed cloud seat, but only through an explicit
    * consent card or a configured allowlist — never a silent Auto default.
    * Off until baked; see cloudOverflowEnabled for how to enable it by hand. */
-  cloudOverflow: external_exports.boolean().optional()
+  cloudOverflow: external_exports.boolean().optional(),
+  /** Opt-in shared skills library: one store at the data dir that bots
+   * read by assignment instead of per-workspace copies. Off until
+   * explicitly enabled — see skillsLibraryEnabled. */
+  skillsLibrary: external_exports.boolean().optional()
 });
 var onboardingConfigSchema = external_exports.object({
   /** ISO timestamp of finishing (or skipping to the end of) the welcome flow. */
@@ -16515,6 +16499,7 @@ var appConfigSchema = external_exports.object({
     phone: external_exports.enum(["ios", "android"]).optional()
   }).optional(),
   mistral: external_exports.object({ key: optionalText }).optional(),
+  cerebras: external_exports.object({ key: optionalText }).optional(),
   xai: external_exports.object({ key: optionalText, url: optionalText }).optional(),
   /** Anthropic API key for Claude Code billed per token, handed only to
    * Claude instances; `url` only for a proxy or a test double. Never a
@@ -16585,6 +16570,15 @@ var appConfigSchema = external_exports.object({
     baseUrl: external_exports.string().trim().max(2048).refine((value) => !value || /^https?:\/\//i.test(value), "the decision model address must start with http:// or https://").optional(),
     jobs: external_exports.object({ roomRouting: external_exports.boolean().optional() }).optional()
   }).optional(),
+  /** Live calls: an OpenAI project key for GPT-Live, kept apart from every
+   * other OpenAI credential so a Live call never bills an image or engine key
+   * the user did not hand to it. `voice` is a GPT-Live built-in voice name. */
+  live: external_exports.object({
+    key: optionalText,
+    voice: external_exports.string().trim().max(40).regex(/^[a-z]*$/, "a Live voice is a lowercase built-in voice name").optional(),
+    readTypedReplies: external_exports.boolean().optional(),
+    idleMinutes: external_exports.number().int().min(1).max(60).optional()
+  }).optional(),
   /** Avatar provider credentials stay separate; choosing a router never reuses a cloud key. */
   imageGen: external_exports.object({
     provider: external_exports.enum(["openai", "xai", "custom"]).optional(),
@@ -16654,10 +16648,10 @@ var storedAppConfigSchema = appConfigSchema.extend({
 var appConfigPatchSchema = appConfigSchema.omit({ instances: true, mcpServers: true, cliStartup: true, customDomain: true }).extend({ threads: threadsPatchSchema.optional(), newBots: newBotsPatchSchema.optional() });
 var jsonObjectSchema = external_exports.record(external_exports.string(), external_exports.json());
 var DEFAULT_CAPTURE_QUIET_MS = 2 * 6e4;
-var DATA_DIR = process.env.OMB_DATA_DIR ?? join3(homedir2(), ".openmausbot");
-var LEGACY_DATA_DIR = join3(homedir2(), ".opengrokbot");
-var EVENTS_DIR = join3(DATA_DIR, "events");
-var NATIVE_DIR = join3(DATA_DIR, "native");
+var DATA_DIR = process.env.OMB_DATA_DIR ?? join2(homedir2(), ".openmausbot");
+var LEGACY_DATA_DIR = join2(homedir2(), ".opengrokbot");
+var EVENTS_DIR = join2(DATA_DIR, "events");
+var NATIVE_DIR = join2(DATA_DIR, "native");
 var OPENAI_API_INSTANCE = "openai";
 var OPENROUTER_API_INSTANCE = "openrouter";
 var XAI_API_INSTANCE = "xaiApi";
@@ -16687,6 +16681,34 @@ var API_KEY_FLEET = {
   }
 };
 
+// server/proxy-paths.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+var SERVER_ROOT = dirname2(fileURLToPath(import.meta.url));
+function resolveProxy(relative) {
+  const source = join3(SERVER_ROOT, `${relative}.ts`);
+  return existsSync2(source) ? source : join3(SERVER_ROOT, `${relative}.js`);
+}
+var SPAWNED_PROXIES = {
+  browser: resolveProxy("browser-proxy"),
+  localComputer: resolveProxy("local-computer-proxy"),
+  permission: resolveProxy("permission-proxy"),
+  containerMcp: resolveProxy("container-mcp"),
+  vpsContainerMcp: resolveProxy("vps-container-mcp"),
+  agents: resolveProxy("drivers/agents-proxy"),
+  dweb: resolveProxy("drivers/dweb-proxy"),
+  connectors: resolveProxy("connector-proxy"),
+  mcpGate: resolveProxy("mcp-gate"),
+  mcpRemote: resolveProxy("mcp-remote-proxy"),
+  phone: resolveProxy("drivers/phone-proxy"),
+  hook: resolveProxy("hooks/omb-hook"),
+  // Loaded by the external `pi` process via `-e`, not by this server — but
+  // resolved through the same single source of truth so the packaged layout
+  // check can assert it ships.
+  piMcpExtension: resolveProxy("drivers/pi-mcp-extension")
+};
+
 // server/container-computer.ts
 var run = promisify(execFile2);
 var CUA_DRIVER_VERSION = "0.20.0";