openmausbot 0.1.92 → 0.1.94

package/dist-server/server/provider-key-check.js

@@ -1,4 +1,4 @@
-export const PROVIDER_KEY_KINDS = ["anthropic", "openai", "openrouter", "openaiCompat", "xai", "mistral"];
+export const PROVIDER_KEY_KINDS = ["anthropic", "openai", "openrouter", "openaiCompat", "xai", "mistral", "cerebras"];
 const DEFAULT_URLS = {
     anthropic: "https://api.anthropic.com",
     openai: "https://api.openai.com/v1",
@@ -6,6 +6,7 @@ const DEFAULT_URLS = {
     openaiCompat: "https://openrouter.ai/api/v1",
     xai: "https://api.x.ai/v1",
     mistral: "https://api.mistral.ai/v1",
+    cerebras: "https://api.cerebras.ai/v1",
 };
 const MAX_MODELS = 5;
 function isLoopback(hostname) {

package/dist-server/server/proxy-paths.js

@@ -40,6 +40,7 @@ export const SPAWNED_PROXIES = {
     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

package/dist-server/server/redact.js

@@ -18,6 +18,8 @@ const SECRET_KEY_PARTS = ["token", "secret", "password", "passwd", "apikey", "ap
  * every real one is spelled (API_KEY, consumer-key, xai_key). */
 function isSecretName(name) {
     const lower = name.toLowerCase();
+    if (lower === "omb_gate_upstream" || lower === "omb_remote_mcp_server")
+        return true;
     if (SECRET_KEY_PARTS.some((part) => lower.includes(part)))
         return true;
     return /(^|[_.-])keys?$/.test(lower);

package/dist-server/server/request-auth.js

@@ -1,6 +1,6 @@
 import { timingSafeEqual } from "node:crypto";
 import { isIP } from "node:net";
-import { denyReason as companionDenial } from "../companion/src/routes.js";
+import { denyReason as companionDenial, isCompanionNotice } from "../companion/src/routes.js";
 const LOOPBACK_SCOPES = ["admin", "client"];
 const SERVICE_SCOPES = ["client"];
 /** What a `service`-trust loopback caller may reach, and nothing else:
@@ -442,7 +442,8 @@ export function resolveRequestAuth(req, options) {
             if (!secureTokenMatch(companionToken, options.companionMutationToken ?? "") ||
                 req.headers["x-openmausbot-companion"] !== "1" ||
                 !/^[\w-]{1,128}$/.test(headerValue(req.headers["x-openmausbot-companion-device"]) ?? "") ||
-                companionDenial({ path, method, authenticated: true }))
+                // a phone's allowlisted route, or the companion's own notice (an unpaired phone)
+                (companionDenial({ path, method, authenticated: true }) && !isCompanionNotice(method, path)))
                 return deny(403, "forbidden: invalid companion request");
             return { auth: { kind: "loopback", scopes: LOOPBACK_SCOPES }, status: 401, error: "" };
         }

package/dist-server/server/routes/desktop-viewer.js

@@ -10,6 +10,8 @@ const ROUTE = /^\/api\/desktop-viewer\/(local\/(?:shared|bot-[a-f0-9]{64}|pool-\
 const HANDSHAKE_MS = 10_000;
 const RECHECK_MS = 5_000;
 const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+const BOT_ID = /^[\w-]+$/;
+const CONTROL_LEASE = /^[A-Za-z0-9_-]{16,120}$/;
 export function desktopViewerUrl(target, threadId) {
     const params = new URLSearchParams({ target, ...(threadId ? { threadId } : {}) });
     return `/desktop-viewer#${params}`;
@@ -67,7 +69,7 @@ export function createDesktopViewer(deps) {
             }).finally(() => clearTimeout(timeout));
         });
     }
-    const route = async ({ req, res, path, method, auth, json }) => {
+    const route = async ({ req, res, url, path, method, auth, json }) => {
         const match = ROUTE.exec(path);
         if (!match)
             return PASS;
@@ -78,12 +80,39 @@ export function createDesktopViewer(deps) {
         // to admin, like the existing Local VM status and control endpoints.
         if (!auth.scopes.includes("admin") || !isSameOrigin(req))
             return json(res, 403, { error: "forbidden" });
+        // A viewer bound to a control lease: both names or neither, well formed,
+        // and holding before anything is inspected. Checked again with every
+        // liveness pass, so handing back closes the desktop within seconds. The
+        // conversation, when named, picks the VM seat the join picked.
+        const botId = url.searchParams.get("botId");
+        const controlLeaseId = url.searchParams.get("controlLeaseId");
+        const threadId = url.searchParams.get("threadId") ?? undefined;
+        if ((botId === null) !== (controlLeaseId === null)) {
+            return json(res, 400, { error: "botId and controlLeaseId go together" });
+        }
+        if (botId !== null && (!BOT_ID.test(botId) || !CONTROL_LEASE.test(controlLeaseId) || !deps.lease
+            || (threadId !== undefined && !BOT_ID.test(threadId)))) {
+            return json(res, 400, { error: "botId, threadId or controlLeaseId is not valid" });
+        }
+        if (botId === null && threadId !== undefined)
+            return json(res, 400, { error: "threadId needs botId and controlLeaseId" });
+        // Do not let a saved or constructed socket URL bypass the join refusal:
+        // a bot's control lease does not exclude other users of a shared desktop.
+        if (botId !== null && (match[1] === "local/shared" || match[1].startsWith("local/pool-"))) {
+            return json(res, 409, { error: "Phone control requires a per-bot Local VM. Select per-bot mode in Settings → Computers." });
+        }
+        const bound = botId === null ? undefined : deps.lease(match[1], botId, controlLeaseId, threadId);
+        if (botId !== null && !bound)
+            return json(res, 409, { error: "Take control of this computer first" });
+        const holds = () => bound?.() ?? true;
         const target = deps.target(match[1]);
         if (!target)
             return json(res, 404, { error: "Desktop not found" });
         const upgrade = upgrades.get(req);
         if (upgrade && auth.kind === "session")
             upgrade.owner = auth.session.id;
+        if (upgrade && botId !== null)
+            upgrade.botId = botId;
         let connection;
         try {
             connection = await target.resolve();
@@ -98,6 +127,8 @@ export function createDesktopViewer(deps) {
         const live = () => deps.live(auth) && deps.target(match[1])?.key === target.key && (connection.live?.() ?? true);
         if (!live())
             return json(res, 401, { error: "Viewer access expired" });
+        if (!holds())
+            return json(res, 409, { error: "Take control of this computer first" });
         if (!Number.isInteger(connection.port) || connection.port < 1 || connection.port > 65535) {
             return json(res, 409, { error: "The desktop viewer is not available." });
         }
@@ -150,7 +181,7 @@ export function createDesktopViewer(deps) {
         upstream.once("response", (answer) => { answer.resume(); fail(); });
         upstream.once("upgrade", (answer, remote, remoteHead) => {
             const accept = createHash("sha1").update(key + WS_GUID).digest("base64");
-            if (!live() || socket.destroyed || answer.headers["sec-websocket-accept"] !== accept
+            if (!live() || !holds() || socket.destroyed || answer.headers["sec-websocket-accept"] !== accept
                 || answer.headers.upgrade?.toLowerCase() !== "websocket") {
                 remote.destroy();
                 fail();
@@ -171,7 +202,7 @@ export function createDesktopViewer(deps) {
             socket.pipe(remote).pipe(socket);
             connection.touch?.();
             recheck = setInterval(() => {
-                if (!live())
+                if (!live() || !holds())
                     upgrade.close();
                 else
                     connection.touch?.();
@@ -182,9 +213,22 @@ export function createDesktopViewer(deps) {
     };
     return {
         route, attach,
-        closeForOwner: (owner) => { for (const upgrade of upgrades.values())
-            if (upgrade.owner === owner)
-                upgrade.close(); },
+        /** Close a session's viewers: all of them (sign-out, revocation), or only
+         * those it opened under a lease on one bot (that bot's hand-back). */
+        closeForOwner: (owner, botId) => {
+            let closed = 0;
+            for (const upgrade of upgrades.values()) {
+                if (upgrade.owner !== owner || (botId !== undefined && upgrade.botId !== botId))
+                    continue;
+                // A viewer already closed stays listed until its socket's close
+                // event, which arrives later on Windows: not closed or counted again.
+                if (upgrade.socket.destroyed)
+                    continue;
+                upgrade.close();
+                closed++;
+            }
+            return closed;
+        },
         closeAll: () => {
             stopped = true;
             for (const upgrade of upgrades.values())

package/dist-server/server/routes/live.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { LiveSessionError, MAX_SDP_BYTES } from "../live-call.js";
+import { LiveCallBusyError } from "../live-call-controller.js";
+import { PASS } from "./table.js";
+const id = z.string().regex(/^[\w-]{1,120}$/);
+const sessionBody = z.object({
+    botId: id,
+    threadId: id.optional(),
+    // Not trimmed: the SDP offer goes to OpenAI byte for byte.
+    sdp: z.string().min(1).refine((sdp) => Buffer.byteLength(sdp) <= MAX_SDP_BYTES),
+    client: z.enum(["desktop", "ios", "android"]),
+}).strict();
+const endBody = z.object({ callId: z.string().min(1).max(120) }).strict();
+// Strict, so `key` (or anything else) is refused rather than ignored: the key
+// is only ever set on the computer that runs the harness.
+const settingsBody = z.object({
+    voice: z.string().trim().max(40).regex(/^[a-z]*$/).optional(),
+    readTypedReplies: z.boolean().optional(),
+    idleMinutes: z.number().int().min(1).max(60).optional(),
+}).strict();
+const DEVICE_ID = /^[\w-]{1,128}$/;
+/** The paired phone the companion vouched for, or undefined. The companion
+ * sends its own id for the phone that authenticated (never one the phone
+ * chose); in the desktop app the harness has already checked the companion's
+ * private token before this runs (server/request-auth.ts). */
+function companionDevice(req) {
+    if (req.headers["x-openmausbot-companion"] !== "1")
+        return undefined;
+    const device = req.headers["x-openmausbot-companion-device"];
+    return typeof device === "string" && DEVICE_ID.test(device) ? device : undefined;
+}
+/** The parsed JSON body, or undefined when it is not JSON (the schema then refuses it). */
+async function bodyOf(req, readBody) {
+    try {
+        return await readBody(req);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createLiveRoutes(deps) {
+    return async ({ req, res, path, method, auth, json, readBody }) => {
+        if (!path.startsWith("/api/live/"))
+            return PASS;
+        if (method === "POST" && path === "/api/live/session") {
+            const parsed = sessionBody.safeParse(await bodyOf(req, readBody));
+            if (!parsed.success)
+                return json(res, 400, { error: "The call request was not valid." });
+            const target = deps.resolveTarget(parsed.data.botId, parsed.data.threadId);
+            if (!target)
+                return json(res, 404, { error: "That bot or chat does not exist." });
+            try {
+                // A phone's call is bound to the phone, so unpairing it ends the call.
+                const device = companionDevice(req);
+                const { call, sdp } = await deps.calls.start({ auth, ...(device ? { device } : {}), ...target, client: parsed.data.client, sdp: parsed.data.sdp });
+                return json(res, 201, { call, transport: { type: "webrtc", sdp } });
+            }
+            catch (error) {
+                if (error instanceof LiveCallBusyError)
+                    return json(res, 409, { error: error.message, activeCall: error.call });
+                if (error instanceof LiveSessionError) {
+                    // The one 409 a session refuses with is a missing key.
+                    return json(res, error.status, error.status === 409 ? { error: error.message, needsKey: true } : { error: error.message });
+                }
+                throw error;
+            }
+        }
+        if (method === "POST" && path === "/api/live/call/end") {
+            const parsed = endBody.safeParse(await bodyOf(req, readBody));
+            if (!parsed.success)
+                return json(res, 400, { error: "The request was not valid." });
+            const call = await deps.calls.end(parsed.data.callId);
+            return call ? json(res, 200, { call }) : json(res, 404, { error: "That call is not running." });
+        }
+        if (method === "GET" && path === "/api/live/call")
+            return json(res, 200, { call: deps.calls.current() });
+        // The companion unpaired a phone: end the call that phone holds, if any.
+        if (method === "POST" && path === "/api/live/device-revoked") {
+            if (req.headers["x-openmausbot-companion"] !== "1")
+                return json(res, 403, { error: "Only the phone companion can report an unpaired phone." });
+            const device = companionDevice(req);
+            if (!device)
+                return json(res, 400, { error: "The unpaired phone was not named." });
+            return json(res, 200, { call: deps.calls.deviceRevoked(device) });
+        }
+        if (method === "PATCH" && path === "/api/live/settings") {
+            const parsed = settingsBody.safeParse(await bodyOf(req, readBody));
+            if (!parsed.success) {
+                return json(res, 400, { error: "Those Live settings are not valid. The OpenAI key can only be changed on the computer that runs OpenMausBot." });
+            }
+            // as PUT /api/config: an empty patch is not saved (or broadcast)
+            if (!Object.keys(parsed.data).length)
+                return json(res, 400, { error: "nothing to save" });
+            return json(res, 200, { live: await deps.saveSettings(parsed.data) });
+        }
+        return PASS;
+    };
+}

package/dist-server/server/routines.js

@@ -1286,14 +1286,17 @@ export class RoutineManager {
                 // A webhook is an incoming message, so make its task the bot's live
                 // chat immediately. Scheduled work stays in its own task unless the
                 // workspace has asked for runs to join the conversation they report to.
+                const startedAt = this.now();
+                const suffix = ` · ${new Date(startedAt).toLocaleString("en-US", { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" })}`;
+                const title = `${run.routineName.slice(0, 80 - suffix.length).trimEnd()}${suffix}`;
                 const joined = run.target === "room-goal" ? null : this.options.joinConversation?.(run) || null;
                 const task = joined
                     ? { threadId: joined }
                     : run.target === "room-goal"
                         ? run.groupId
-                            ? this.options.createGoalTask?.(run.groupId, run.routineName) ?? null
+                            ? this.options.createGoalTask?.(run.groupId, title) ?? null
                             : null
-                        : this.options.createTask(run.botId, run.routineName, run.triggerSource === "webhook", run.routineId);
+                        : this.options.createTask(run.botId, title, run.triggerSource === "webhook", run.routineId);
                 if (!task) {
                     this.failRun(run, run.target === "room-goal"
                         ? "Could not create a room task for this goal"
@@ -1301,7 +1304,7 @@ export class RoutineManager {
                     continue;
                 }
                 run.threadId = task.threadId;
-                run.startedAt = this.now();
+                run.startedAt = startedAt;
                 run.status = "running";
                 this.save();
                 this.emitRun(run);

package/dist-server/server/skill-library.js

@@ -4,6 +4,13 @@
 // declared trigger terms and mounted capabilities.
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join } from "node:path";
+import { createHash } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { mkdirSync } from "node:fs";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
+import { DATA_DIR } from "./config.js";
+import { isSkillName, parseSkillMd, SKILL_FILE_MAX_BYTES } from "../shared/skill-md.js";
 const SAFE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function strings(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string" && item.trim())
@@ -114,3 +121,203 @@ export function renderSkillInstructions(selected, { includeRoot = false } = {})
         return "";
     return selected.map(({ manifest, instructions, directory }) => `\n\n<openmaus-skill id=${JSON.stringify(manifest.id)} version=${JSON.stringify(manifest.version)}${includeRoot ? ` root=${JSON.stringify(directory)}` : ""}>\n${instructions}\n</openmaus-skill>`).join("");
 }
+const skillLibraryEntrySchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    source: z.string(),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    importedAt: z.string(),
+    reviewState: z.enum(["approved", "disabled"]),
+    license: z.string().optional(),
+    compatibility: z.string().optional(),
+    tags: z.array(z.string().regex(/^[a-z0-9][a-z0-9-]{0,23}$/)).max(8).optional(),
+    warnings: z.array(z.string()),
+    skippedFiles: z.array(z.string()),
+    package: z.object({
+        installId: z.string().regex(/^[a-f0-9]{32}$/),
+        key: z.string().min(1).max(64),
+        release: z.string().min(1).max(40),
+        r: z.string().regex(/^[a-f0-9]{64}$/),
+        w: z.string().regex(/^[a-f0-9]{64}$/),
+        via: z.literal("preset").optional(),
+    }).optional(),
+});
+const skillLibraryIndexSchema = z.record(z.string(), skillLibraryEntrySchema);
+/** Every library write emits here so later skills-lane consumers can drop
+ * caches without polling. The payload names what changed. */
+export const skillLibraryEvents = new EventEmitter();
+export function skillsLibraryRoot(dataDir = DATA_DIR) {
+    return join(dataDir, "skills-library");
+}
+function libraryIndexPath(root) {
+    return join(root, "index.json");
+}
+export function librarySkillDirectory(root, name) {
+    return join(root, "skills", name);
+}
+/** The path agents are told to read for an assigned library skill. */
+export function librarySkillFilePath(name, root = skillsLibraryRoot()) {
+    return join(root, "skills", name, "SKILL.md");
+}
+/** Where a migrated per-bot copy is preserved. Archives are write-once:
+ * migration never deletes the original bytes, it moves them here. */
+export function libraryArchiveDirectory(root, botId, name) {
+    return join(root, "archive", botId, name);
+}
+/** A missing index is a legitimate empty library; an index that exists but
+ * cannot be read or validated is not, and writers must refuse rather than
+ * replace it and strand every stored skill. */
+function readSkillLibraryIndexState(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(libraryIndexPath(root), "utf8"));
+        const result = skillLibraryIndexSchema.safeParse(parsed);
+        return result.success
+            ? { index: result.data }
+            : { error: "the skills library index is invalid" };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { index: {} };
+        return { error: "the skills library index could not be read" };
+    }
+}
+export function readSkillLibraryIndex(root = skillsLibraryRoot()) {
+    const result = readSkillLibraryIndexState(root);
+    return "error" in result ? {} : result.index;
+}
+function writeSkillLibraryIndex(root, index) {
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    writeFileAtomic(libraryIndexPath(root), `${JSON.stringify(index, null, 2)}\n`, { mode: 0o600 });
+}
+function sha256Hex(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+function libraryContentMatches(root, entry) {
+    try {
+        const file = join(librarySkillDirectory(root, entry.name), "SKILL.md");
+        if (!existsSync(file))
+            return false;
+        return sha256Hex(readFileSync(file, "utf8")) === entry.sha256;
+    }
+    catch {
+        return false;
+    }
+}
+function librarySkillListing(root, entry) {
+    const intact = libraryContentMatches(root, entry);
+    return {
+        name: entry.name,
+        description: entry.description,
+        enabled: entry.reviewState === "approved" && intact,
+        editable: false,
+        source: entry.source,
+        sha256: entry.sha256,
+        importedAt: entry.importedAt,
+        ...(entry.license ? { license: entry.license } : {}),
+        ...(entry.compatibility ? { compatibility: entry.compatibility } : {}),
+        tags: entry.tags ?? [],
+        warnings: intact
+            ? entry.warnings
+            : [...entry.warnings, "stored SKILL.md changed after review — enablement is blocked"],
+        skippedFiles: entry.skippedFiles,
+    };
+}
+export function listLibrarySkills(root = skillsLibraryRoot()) {
+    return Object.values(readSkillLibraryIndex(root))
+        .map((entry) => librarySkillListing(root, entry))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Put a skill in the library. Installing the same name with the same
+ * SKILL.md bytes is idempotent (the existing entry wins); the same name
+ * with different bytes is refused, mirroring the per-bot import rule.
+ * Every failure returns `{ error }` — callers fall back. */
+export function installLibrarySkill(input) {
+    const root = input.root ?? skillsLibraryRoot();
+    if (!isSkillName(input.name))
+        return { error: "invalid skill name" };
+    if (Buffer.byteLength(input.instructions, "utf8") > SKILL_FILE_MAX_BYTES) {
+        return { error: `SKILL.md is larger than ${SKILL_FILE_MAX_BYTES / 1024}KB` };
+    }
+    const parsed = parseSkillMd(input.instructions);
+    if ("error" in parsed)
+        return parsed;
+    if (parsed.name !== input.name)
+        return { error: `the skill is named "${parsed.name}", not "${input.name}"` };
+    const sha256 = sha256Hex(input.instructions);
+    const indexRead = readSkillLibraryIndexState(root);
+    if ("error" in indexRead)
+        return indexRead;
+    const index = indexRead.index;
+    const existing = index[input.name];
+    if (existing) {
+        if (existing.sha256 === sha256)
+            return librarySkillListing(root, existing);
+        return { error: `a skill named "${input.name}" is already in the library — choose a different name` };
+    }
+    // Callers such as the library migration do not pass tags; frontmatter
+    // tags parsed from the instructions are the source of record then.
+    const tags = input.tags?.length ? input.tags : parsed.tags;
+    const entry = {
+        name: input.name,
+        description: input.description?.trim() || parsed.description,
+        source: input.source,
+        sha256,
+        importedAt: new Date().toISOString(),
+        reviewState: input.reviewState ?? "disabled",
+        ...(input.license ? { license: input.license } : {}),
+        ...(input.compatibility ? { compatibility: input.compatibility } : {}),
+        ...(tags?.length ? { tags } : {}),
+        warnings: input.warnings ?? [],
+        skippedFiles: [],
+        ...(input.package ? { package: { ...input.package } } : {}),
+    };
+    // Bytes first, index second: the index is the commit point, so a crash
+    // between the two leaves unreferenced bytes, never a dangling entry.
+    mkdirSync(librarySkillDirectory(root, input.name), { recursive: true, mode: 0o700 });
+    writeFileAtomic(join(librarySkillDirectory(root, input.name), "SKILL.md"), input.instructions, { mode: 0o600 });
+    index[input.name] = entry;
+    writeSkillLibraryIndex(root, index);
+    skillLibraryEvents.emit("invalidate", { kind: "install", name: input.name });
+    return librarySkillListing(root, entry);
+}
+export function readLibrarySkillFile(name, root = skillsLibraryRoot()) {
+    if (!isSkillName(name))
+        return null;
+    const entry = readSkillLibraryIndex(root)[name];
+    if (!entry)
+        return null;
+    try {
+        const text = readFileSync(join(librarySkillDirectory(root, name), "SKILL.md"), "utf8");
+        return sha256Hex(text) === entry.sha256 ? text : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function setLibrarySkillReviewState(name, reviewState, root = skillsLibraryRoot()) {
+    if (!isSkillName(name))
+        return { error: "invalid skill name" };
+    const index = readSkillLibraryIndex(root);
+    const entry = index[name];
+    if (!entry)
+        return { error: `no library skill named "${name}"` };
+    if (reviewState === "approved" && !libraryContentMatches(root, entry)) {
+        return { error: "stored SKILL.md changed after review — the library entry cannot be approved" };
+    }
+    entry.reviewState = reviewState;
+    writeSkillLibraryIndex(root, index);
+    skillLibraryEvents.emit("invalidate", { kind: "review-state", name });
+    return librarySkillListing(root, entry);
+}
+/** The lane's one resolution rule, stated once: a skill name means the
+ * bot-private copy when one exists, else the library entry, else the
+ * bundled skill. Later slices route every lookup through this order. */
+export function resolveSkillSourceOrder(name, sources) {
+    if (sources.private !== undefined)
+        return { source: "private", name, value: sources.private };
+    if (sources.library !== undefined)
+        return { source: "library", name, value: sources.library };
+    if (sources.bundled !== undefined)
+        return { source: "bundled", name, value: sources.bundled };
+    return null;
+}