usebeeline 0.0.117 → 0.0.120

package/dist/usebeeline.mjs

@@ -17439,6 +17439,22 @@ function isAgentCommand(value) {
 }
 
 // packages/api-contract/dist/artifacts.js
+var ARTIFACT_EXTENSIONS_BY_MIME = {
+  "text/html": [".html", ".htm"],
+  "image/svg+xml": [".svg"],
+  "application/pdf": [".pdf"],
+  "text/markdown": [".md"],
+  "image/png": [".png"],
+  "image/jpeg": [".jpg", ".jpeg"],
+  "image/gif": [".gif"],
+  "image/webp": [".webp"],
+  "text/plain": [".txt", ".log"],
+  "application/json": [".json"],
+  "text/csv": [".csv"],
+  "application/zip": [".zip"],
+  "application/octet-stream": []
+};
+var ARTIFACT_MIME_BY_EXTENSION = Object.fromEntries(Object.entries(ARTIFACT_EXTENSIONS_BY_MIME).flatMap(([mime, extensions]) => extensions.map((extension2) => [extension2, mime])));
 var ARTIFACT_MAXIMUM_BYTES = 25 * 1024 * 1024;
 
 // packages/api-contract/dist/system-events.js
@@ -28433,6 +28449,155 @@ function parse5(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
   return res;
 }
 
+// node_modules/smol-toml/dist/stringify.js
+var BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+  let type = typeof obj;
+  if (type === "object") {
+    if (Array.isArray(obj))
+      return "array";
+    if (typeof obj?.getUTCDate === "function" && obj instanceof Date)
+      return "date";
+    if (globalThis.Temporal && // check for the 'since' property as an early bailout that avoids running all 5 instanceof checks
+    typeof obj?.since === "function" && (obj instanceof Temporal.Instant || obj instanceof Temporal.PlainDate || obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainTime || obj instanceof Temporal.ZonedDateTime)) {
+      return "temporal";
+    }
+  }
+  return type;
+}
+function isArrayOfTables(obj) {
+  for (let i3 = 0; i3 < obj.length; i3++) {
+    if (extendedTypeOf(obj[i3]) !== "object")
+      return false;
+  }
+  return obj.length != 0;
+}
+function formatString(s) {
+  return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+function stringifyTemporal(temporal) {
+  return temporal.toString({
+    calendarName: "never",
+    timeZoneName: "never"
+  });
+}
+function stringifyValue(val, type, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  switch (type) {
+    // @ts-expect-error -- intentional fallthrough case
+    case "number":
+      if (isNaN(val))
+        return "nan";
+      if (val === Infinity)
+        return "inf";
+      if (val === -Infinity)
+        return "-inf";
+      if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
+        return val.toFixed(1);
+    case "bigint":
+    case "boolean":
+      return val.toString();
+    case "string":
+      return formatString(val);
+    case "date":
+      if (isNaN(val.getTime()))
+        throw new TypeError("cannot serialize invalid date");
+      return val.toISOString();
+    case "object":
+      return stringifyInlineTable(val, depth, numberAsFloat);
+    case "array":
+      return stringifyArray(val, depth, numberAsFloat);
+    case "temporal":
+      return stringifyTemporal(val);
+  }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0)
+    return "{}";
+  let res = "{ ";
+  for (let i3 = 0; i3 < keys.length; i3++) {
+    let k = keys[i3];
+    if (i3)
+      res += ", ";
+    res += BARE_KEY.test(k) ? k : formatString(k);
+    res += " = ";
+    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+  }
+  return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat) {
+  if (array.length === 0)
+    return "[]";
+  let res = "[ ";
+  for (let i3 = 0; i3 < array.length; i3++) {
+    if (i3)
+      res += ", ";
+    if (array[i3] === null || array[i3] === void 0) {
+      throw new TypeError("arrays cannot contain null or undefined values");
+    }
+    res += stringifyValue(array[i3], extendedTypeOf(array[i3]), depth - 1, numberAsFloat);
+  }
+  return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let res = "";
+  for (let i3 = 0; i3 < array.length; i3++) {
+    res += `${res && "\n"}[[${key}]]
+`;
+    res += stringifyTable(0, array[i3], key, depth, numberAsFloat);
+  }
+  return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i3 = 0; i3 < keys.length; i3++) {
+    let k = keys[i3];
+    if (obj[k] !== null && obj[k] !== void 0) {
+      let type = extendedTypeOf(obj[k]);
+      if (type === "symbol" || type === "function") {
+        throw new TypeError(`cannot serialize values of type '${type}'`);
+      }
+      let key = BARE_KEY.test(k) ? k : formatString(k);
+      if (type === "array" && isArrayOfTables(obj[k])) {
+        tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+      } else if (type === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+        preamble += "\n";
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables))
+    preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") {
+    throw new TypeError("stringify can only be called with an object");
+  }
+  let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+  if (str[str.length - 1] !== "\n")
+    return str + "\n";
+  return str;
+}
+
 // apps/body/dist/agent-home.js
 import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
 import { chmod as chmod3, copyFile, lstat as lstat2, mkdir as mkdir6, readFile as readFile6, readdir as readdir2, realpath, rename as rename3, rm as rm2, symlink, unlink as unlink3, writeFile as writeFile7 } from "node:fs/promises";
@@ -28751,6 +28916,68 @@ var SQUIRE_GOVERNED_TOOLS = [
 ];
 var SQUIRE_GOVERNED_TOOL_SET = new Set(SQUIRE_GOVERNED_TOOLS);
 
+// apps/body/dist/mcp-route-class.js
+var CODE_OWNED_HOST_MCP_NAMES = ["squire"];
+var MCP_ROUTE_CLASS_KEY = "beeline_route";
+var MCP_ROUTE_HOST = "host";
+function isCodeOwnedHostMcpName(name) {
+  return CODE_OWNED_HOST_MCP_NAMES.includes(name.trim().toLowerCase());
+}
+function classifyImportedMcpServer(input) {
+  const name = input.name.trim();
+  if (isCodeOwnedHostMcpName(name))
+    return "host";
+  const command = input.command ?? mcpLaunchCommand(input.declaration);
+  const args = input.args ?? mcpLaunchArgs(input.declaration);
+  if (command && isTrustySquireMcpLaunch(command, args))
+    return "host";
+  if (operatorMarkedHost(input.declaration))
+    return "host";
+  return "local";
+}
+function hostMcpIdentityPrefixes(name) {
+  const lower = name.trim().toLowerCase();
+  const normalized = lower.replace(/[^a-z0-9]+/g, "_");
+  return [
+    `mcp__${lower}__`,
+    `mcp__${normalized}__`,
+    `mcp.${lower}.`,
+    `${lower}.`,
+    `${lower}/`,
+    `${lower}__`
+  ];
+}
+function isHostMcpIdentity(candidate, hostNames = CODE_OWNED_HOST_MCP_NAMES) {
+  const lowered = candidate.trim().toLowerCase();
+  if (!lowered)
+    return false;
+  return hostNames.some((name) => {
+    const n3 = name.trim().toLowerCase();
+    if (!n3)
+      return false;
+    if (lowered === n3)
+      return true;
+    return hostMcpIdentityPrefixes(n3).some((prefix) => lowered.startsWith(prefix));
+  });
+}
+function operatorMarkedHost(declaration) {
+  return declaration?.[MCP_ROUTE_CLASS_KEY] === MCP_ROUTE_HOST;
+}
+function mcpLaunchCommand(declaration) {
+  if (!declaration)
+    return void 0;
+  return stringField(declaration.command) ?? stringField(declaration.cmd);
+}
+function mcpLaunchArgs(declaration) {
+  return stringArray(declaration?.args);
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : [];
+}
+
 // apps/body/dist/openrouter-routing.js
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile6 } from "node:fs/promises";
 import { resolve as resolve13 } from "node:path";
@@ -29434,7 +29661,7 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
     try {
       const source = resolve14(operatorHome, config.toml);
       const target = resolve14(root, config.dir, "config.toml");
-      const mcpSection = existsSync4(source) ? filteredHarnessMcpToml(readFileSync7(source, "utf8")) : void 0;
+      const mcpSection = existsSync4(source) ? localHarnessMcpToml(readFileSync7(source, "utf8")) : void 0;
       const section = config.dir === "codex" ? [CODEX_ROOM_AGENT_LOCKDOWN_TOML, CODEX_ROOM_WEB_SEARCH_TOML, mcpSection].filter(Boolean).join("\n") : mcpSection;
       if (!section) {
         await unlink3(target).catch(() => void 0);
@@ -29454,7 +29681,8 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
       const source = resolve14(operatorHome, ".config", "goose", name);
       const target = resolve14(gooseConfigDir, name);
       if (existsSync4(source)) {
-        await writeIsolatedHarnessFile(target, readFileSync7(source, "utf8"));
+        const body = readFileSync7(source, "utf8");
+        await writeIsolatedHarnessFile(target, name === "config.yaml" ? localGooseConfig(body) : body);
       } else {
         await unlink3(target).catch(() => void 0);
       }
@@ -29538,27 +29766,62 @@ async function provisionPiCustomModelConfig(root, operatorHome, failClosed, open
 function readClaudeUserScopeMcpServers(path) {
   try {
     const parsed = JSON.parse(readFileSync7(path, "utf8"));
-    if (parsed && typeof parsed.mcpServers === "object" && parsed.mcpServers !== null) {
-      return Object.fromEntries(Object.entries(parsed.mcpServers).filter(([name, value]) => {
-        if (name === "squire")
-          return false;
-        const server = value;
-        if (!server || typeof server.command !== "string")
-          return true;
-        const args = Array.isArray(server.args) && server.args.every((arg) => typeof arg === "string") ? server.args : [];
-        return !isTrustySquireMcpLaunch(server.command, args);
-      }));
-    }
+    const servers = recordValue(parsed.mcpServers);
+    if (servers)
+      return localMcpServers(servers);
   } catch {
   }
   return void 0;
 }
-function filteredHarnessMcpToml(source) {
-  const excluded = tomlChildTableNames(source, ["mcp_servers"]).filter((name) => {
-    const section = extractTomlSections(source, ["mcp_servers", name]);
-    return name === "squire" || Boolean(section && isTrustySquireMcpLaunch(section));
-  });
-  return extractTomlSections(source, ["mcp_servers"], excluded);
+function localHarnessMcpToml(source) {
+  let servers;
+  try {
+    servers = recordValue(parse5(source).mcp_servers);
+  } catch {
+    return void 0;
+  }
+  if (!servers)
+    return void 0;
+  const hostNames = hostMcpServerNames(servers);
+  const childTables = tomlChildTableNames(source, ["mcp_servers"]);
+  if (hostNames.every((name) => childTables.includes(name))) {
+    return extractTomlSections(source, ["mcp_servers"], hostNames);
+  }
+  const bareLocal = Object.fromEntries(Object.entries(servers).filter(([name]) => !childTables.includes(name) && !hostNames.includes(name)));
+  const sections = [
+    Object.keys(bareLocal).length > 0 ? stringify({ mcp_servers: bareLocal }) : void 0,
+    ...childTables.filter((name) => !hostNames.includes(name)).map((name) => extractTomlSections(source, ["mcp_servers", name]))
+  ].filter((section) => section !== void 0).map((section) => section.endsWith("\n") ? section : `${section}
+`);
+  return sections.length > 0 ? sections.join("\n") : void 0;
+}
+function localGooseConfig(source) {
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(source);
+  } catch {
+    return source;
+  }
+  const document = recordValue(parsed);
+  const extensions = recordValue(document?.extensions);
+  if (!document || !extensions)
+    return source;
+  const local = localMcpServers(extensions);
+  if (Object.keys(local).length === Object.keys(extensions).length)
+    return source;
+  return (0, import_yaml.stringify)({ ...document, extensions: local });
+}
+function isHostMcpDeclaration(name, value) {
+  return classifyImportedMcpServer({ name, declaration: recordValue(value) ?? {} }) === "host";
+}
+function hostMcpServerNames(servers) {
+  return Object.entries(servers).filter(([name, value]) => isHostMcpDeclaration(name, value)).map(([name]) => name);
+}
+function localMcpServers(servers) {
+  return Object.fromEntries(Object.entries(servers).filter(([name, value]) => !isHostMcpDeclaration(name, value)));
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function mountedImportedMcpServerNames(input = {}) {
   const names = /* @__PURE__ */ new Set();
@@ -29567,13 +29830,13 @@ function mountedImportedMcpServerNames(input = {}) {
     const home = env.HOME ?? input.operatorHome ?? homedir6();
     const kind = input.agentKind;
     if (!kind || kind === "codex") {
-      addTomlMcpNames(names, resolve14(env.CODEX_HOME ?? resolve14(home, ".codex"), "config.toml"), "all");
+      addTomlMcpNames(names, resolve14(env.CODEX_HOME ?? resolve14(home, ".codex"), "config.toml"));
     }
     if (!kind || kind === "grok") {
-      addTomlMcpNames(names, resolve14(env.GROK_HOME ?? resolve14(home, ".grok"), "config.toml"), "all");
+      addTomlMcpNames(names, resolve14(env.GROK_HOME ?? resolve14(home, ".grok"), "config.toml"));
     }
     if (!kind || kind === "claude") {
-      addClaudeMcpNames(names, resolve14(env.CLAUDE_CONFIG_DIR ?? home, ".claude.json"), "all");
+      addClaudeMcpNames(names, resolve14(env.CLAUDE_CONFIG_DIR ?? home, ".claude.json"));
     }
     if (!kind || kind === "goose") {
       addGooseExtensionNames(names, env.GOOSE_PATH_ROOT ? resolve14(env.GOOSE_PATH_ROOT, "config/config.yaml") : resolve14(home, ".config/goose/config.yaml"));
@@ -29583,63 +29846,87 @@ function mountedImportedMcpServerNames(input = {}) {
   }
   return [...names].sort((left, right) => left.localeCompare(right));
 }
-function collectImportedMcpNames(operatorHome, names, kind) {
+function hostImportedMcpServerNames(input = {}) {
+  const operatorHome = input.operatorHome ?? homedir6();
+  const kind = input.agentKind;
+  const names = /* @__PURE__ */ new Set();
   if (!kind || kind === "codex") {
-    addTomlMcpNames(names, resolve14(operatorHome, ".codex/config.toml"), "imported");
+    addHostMcpNames(names, readTomlMcpServers(resolve14(operatorHome, ".codex/config.toml")));
   }
   if (!kind || kind === "grok") {
-    addTomlMcpNames(names, resolve14(operatorHome, ".grok/config.toml"), "imported");
+    addHostMcpNames(names, readTomlMcpServers(resolve14(operatorHome, ".grok/config.toml")));
   }
   if (!kind || kind === "claude") {
-    addClaudeMcpNames(names, resolve14(operatorHome, ".claude.json"), "imported");
+    addHostMcpNames(names, recordValue(readJsonObject(resolve14(operatorHome, ".claude.json"))?.mcpServers));
   }
   if (!kind || kind === "goose") {
-    addGooseExtensionNames(names, resolve14(operatorHome, ".config/goose/config.yaml"));
+    addHostMcpNames(names, readGooseExtensions(resolve14(operatorHome, ".config/goose/config.yaml")));
   }
+  return [...names].sort((left, right) => left.localeCompare(right));
 }
-function addTomlMcpNames(names, path, mode) {
-  const source = readExistingText(path);
-  if (source === void 0)
-    return;
-  const mountedSource = mode === "imported" ? filteredHarnessMcpToml(source) : source;
-  if (!mountedSource)
-    return;
-  let servers;
-  try {
-    servers = parse5(mountedSource).mcp_servers;
-  } catch {
-    return;
+function collectImportedMcpNames(operatorHome, names, kind) {
+  if (!kind || kind === "codex") {
+    addLocalMcpNames(names, readTomlMcpServers(resolve14(operatorHome, ".codex/config.toml")));
+  }
+  if (!kind || kind === "grok") {
+    addLocalMcpNames(names, readTomlMcpServers(resolve14(operatorHome, ".grok/config.toml")));
+  }
+  if (!kind || kind === "claude") {
+    addLocalMcpNames(names, recordValue(readJsonObject(resolve14(operatorHome, ".claude.json"))?.mcpServers));
+  }
+  if (!kind || kind === "goose") {
+    addLocalMcpNames(names, readGooseExtensions(resolve14(operatorHome, ".config/goose/config.yaml")));
   }
-  if (!servers || typeof servers !== "object" || Array.isArray(servers))
+}
+function addLocalMcpNames(names, servers) {
+  if (!servers)
     return;
-  for (const name of Object.keys(servers))
+  for (const name of Object.keys(localMcpServers(servers)))
     names.add(name);
 }
-function addClaudeMcpNames(names, path, mode) {
-  const servers = mode === "imported" ? readClaudeUserScopeMcpServers(path) : readJsonObject(path)?.mcpServers;
-  if (!servers || typeof servers !== "object" || Array.isArray(servers))
+function addHostMcpNames(names, servers) {
+  if (!servers)
     return;
-  for (const name of Object.keys(servers))
+  for (const name of hostMcpServerNames(servers))
     names.add(name);
 }
-function addGooseExtensionNames(names, path) {
+function addTomlMcpNames(names, path) {
+  addMcpNamesFromMap(names, readTomlMcpServers(path));
+}
+function addClaudeMcpNames(names, path) {
+  addMcpNamesFromMap(names, recordValue(readJsonObject(path)?.mcpServers));
+}
+function readTomlMcpServers(path) {
   const source = readExistingText(path);
   if (source === void 0)
-    return;
+    return void 0;
+  try {
+    return recordValue(parse5(source).mcp_servers);
+  } catch {
+    return void 0;
+  }
+}
+function readGooseExtensions(path) {
+  const source = readExistingText(path);
+  if (source === void 0)
+    return void 0;
   let parsed;
   try {
     parsed = (0, import_yaml.parse)(source);
   } catch {
-    return;
+    return void 0;
   }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-    return;
-  const extensions = parsed.extensions;
-  if (!extensions || typeof extensions !== "object" || Array.isArray(extensions))
+  return recordValue(recordValue(parsed)?.extensions);
+}
+function addMcpNamesFromMap(names, servers) {
+  if (!servers)
     return;
-  for (const name of Object.keys(extensions))
+  for (const name of Object.keys(servers))
     names.add(name);
 }
+function addGooseExtensionNames(names, path) {
+  addMcpNamesFromMap(names, readGooseExtensions(path));
+}
 function readExistingText(path) {
   if (!existsSync4(path))
     return void 0;
@@ -30794,22 +31081,14 @@ var AGENT_SURFACE_TOOL_NAMES = [
   "write_scratch_file",
   "fetch_image"
 ];
-var SQUIRE_TITLE_PREFIXES = [
-  "mcp__squire__",
-  "mcp.squire.",
-  "squire.",
-  "squire/",
-  // grok's qualified `<server>__<tool>` spelling, inside `use_tool` or as the
-  // relabelled title.
-  "squire__"
-];
-function isSquireMcpPermissionRequest(request) {
+function isHostMcpPermissionRequest(request, hostServers = CODE_OWNED_HOST_MCP_NAMES) {
   const rawInput = request.toolCall?.rawInput;
   if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
-    if (rawInput.server === "squire")
+    const server = rawInput.server;
+    if (typeof server === "string" && isHostMcpIdentity(server, hostServers))
       return true;
   }
-  return toolIdentityCandidates(request.toolCall).some((candidate) => SQUIRE_TITLE_PREFIXES.some((prefix) => candidate.toLowerCase().startsWith(prefix)));
+  return toolIdentityCandidates(request.toolCall).some((candidate) => isHostMcpIdentity(candidate, hostServers));
 }
 function isBeelineAgentMcpPermissionRequest(request) {
   const toolCall = request.toolCall;
@@ -32087,8 +32366,8 @@ var SCHEDULE_RAN_VERB = "ran a schedule for";
 
 // apps/body/dist/monolith-room-turn.js
 var ROOM_PROMPT_INACTIVITY_TIMEOUT_MS = 18e4;
-function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
-  if (isSquireMcpPermissionRequest(request))
+function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS, hostServers = CODE_OWNED_HOST_MCP_NAMES) {
+  if (isHostMcpPermissionRequest(request, hostServers))
     return false;
   return isMountedMcpToolPermissionRequest(request, mountedServers);
 }
@@ -32453,6 +32732,10 @@ var MonolithRoomTurnLoop = class {
       servers
     });
     const mountedServers = servers.map((server) => server.name);
+    const hostServers = hostImportedMcpServerNames({
+      operatorHome: this.options.config.operatorHome,
+      agentKind: this.options.config.agentKind
+    });
     const clientOptions = {
       agentCommand: spawnCommand.command,
       agentArgs: spawnCommand.args,
@@ -32463,7 +32746,7 @@ var MonolithRoomTurnLoop = class {
       // (`config.ts`), which is exactly when `wrapAgentCommand` above wraps.
       osSandbox: Boolean(this.options.config.bwrapPath),
       autoApprovePermissions: false,
-      permissionAllowlist: (request) => isRoomMcpPermissionRequest(request, mountedServers)
+      permissionAllowlist: (request) => isRoomMcpPermissionRequest(request, mountedServers, hostServers)
     };
     this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
     await this.client.start();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usebeeline",
-  "version": "0.0.117",
+  "version": "0.0.120",
   "description": "Connect an AI coding agent to Beeline with one command.",
   "homepage": "https://usebeeline.app",
   "bugs": {