ocx 1.0.5 → 1.0.6

package/dist/index.js

@@ -13082,7 +13082,8 @@ var componentManifestSchema = exports_external.object({
   npmDependencies: exports_external.array(exports_external.string()).optional(),
   npmDevDependencies: exports_external.array(exports_external.string()).optional(),
   mcpServers: exports_external.record(mcpServerSchema).optional(),
-  mcpScope: exports_external.enum(["agent", "global"]).default("agent")
+  mcpScope: exports_external.enum(["agent", "global"]).default("agent"),
+  disabledTools: exports_external.array(exports_external.string()).optional()
 });
 var semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
 var registrySchema = exports_external.object({
@@ -13251,6 +13252,93 @@ async function fetchFileContent(baseUrl, componentName, filePath) {
   return response.text();
 }
 
+// src/registry/resolver.ts
+async function resolveDependencies(registries, componentNames) {
+  const resolved = new Map;
+  const visiting = new Set;
+  const mcpServers = {};
+  const agentMcpBindings = [];
+  const npmDeps = new Set;
+  const npmDevDeps = new Set;
+  const disabledTools = new Set;
+  async function resolve2(name, path3 = []) {
+    if (resolved.has(name)) {
+      return;
+    }
+    if (visiting.has(name)) {
+      const cycle = [...path3, name].join(" \u2192 ");
+      throw new ValidationError(`Circular dependency detected: ${cycle}`);
+    }
+    visiting.add(name);
+    let component = null;
+    let foundRegistry = null;
+    const registryEntries = Object.entries(registries);
+    for (const [regName, regConfig] of registryEntries) {
+      try {
+        const manifest = await fetchComponent(regConfig.url, name);
+        component = manifest;
+        foundRegistry = { name: regName, url: regConfig.url };
+        break;
+      } catch (_err) {}
+    }
+    if (!component || !foundRegistry) {
+      throw new OCXError(`Component '${name}' not found in any configured registry.`, "NOT_FOUND");
+    }
+    for (const dep of component.dependencies) {
+      await resolve2(dep, [...path3, name]);
+    }
+    resolved.set(name, {
+      ...component,
+      registryName: foundRegistry.name,
+      baseUrl: foundRegistry.url
+    });
+    visiting.delete(name);
+    if (component.mcpServers) {
+      const serverNames = [];
+      for (const [serverName, config2] of Object.entries(component.mcpServers)) {
+        mcpServers[serverName] = config2;
+        serverNames.push(serverName);
+      }
+      const scope = component.mcpScope ?? "agent";
+      if (component.type === "ocx:agent" && scope === "agent" && serverNames.length > 0) {
+        agentMcpBindings.push({
+          agentName: component.name,
+          serverNames
+        });
+      }
+    }
+    if (component.npmDependencies) {
+      for (const dep of component.npmDependencies) {
+        npmDeps.add(dep);
+      }
+    }
+    if (component.npmDevDependencies) {
+      for (const dep of component.npmDevDependencies) {
+        npmDevDeps.add(dep);
+      }
+    }
+    if (component.disabledTools) {
+      for (const tool of component.disabledTools) {
+        disabledTools.add(tool);
+      }
+    }
+  }
+  for (const name of componentNames) {
+    await resolve2(name);
+  }
+  const components = Array.from(resolved.values());
+  const installOrder = Array.from(resolved.keys());
+  return {
+    components,
+    installOrder,
+    mcpServers,
+    agentMcpBindings,
+    npmDependencies: Array.from(npmDeps),
+    npmDevDependencies: Array.from(npmDevDeps),
+    disabledTools: Array.from(disabledTools)
+  };
+}
+
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text2, ignoreTrivia = false) {
   const len = text2.length;
@@ -13699,6 +13787,249 @@ var cachedBreakLinesWithSpaces = {
     })
   }
 };
+var supportedEols = [`
+`, "\r", `\r
+`];
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options2) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options2);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options2, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options2.insertSpaces) {
+    indentValue = cachedSpaces[options2.tabSize || 4] ?? repeat(cachedSpaces[1], options2.tabSize || 4);
+  } else {
+    indentValue = "\t";
+  }
+  const indentType = indentValue === "\t" ? "\t" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options2.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text2, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text2) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text2 });
+    }
+  }
+  let firstToken = scanNext();
+  if (options2.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options2.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      if (options2.keepLines && numberLineBreaks > 0 || !options2.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options2.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      if (options2.keepLines && numberLineBreaks > 0 || !options2.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options2.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options2.keepLines && numberLineBreaks > 0 || !options2.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options2.keepLines && numberLineBreaks > 0 || !options2.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options2.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options2.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options2.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options2.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options2.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s2, count) {
+  let result = "";
+  for (let i2 = 0;i2 < count; i2++) {
+    result += s2;
+  }
+  return result;
+}
+function computeIndentLevel(content, options2) {
+  let i2 = 0;
+  let nChars = 0;
+  const tabSize = options2.tabSize || 4;
+  while (i2 < content.length) {
+    let ch = content.charAt(i2);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "\t") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i2++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options2, text2) {
+  for (let i2 = 0;i2 < text2.length; i2++) {
+    const ch = text2.charAt(i2);
+    if (ch === "\r") {
+      if (i2 + 1 < text2.length && text2.charAt(i2 + 1) === `
+`) {
+        return `\r
+`;
+      }
+      return "\r";
+    } else if (ch === `
+`) {
+      return `
+`;
+    }
+  }
+  return options2 && options2.eol || `
+`;
+}
+function isEOL(text2, offset) {
+  return `\r
+`.indexOf(text2.charAt(offset)) !== -1;
+}
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
 var ParseOptions;
@@ -13750,6 +14081,95 @@ function parse(text2, errors2 = [], options2 = ParseOptions.DEFAULT) {
   visit(text2, visitor, options2);
   return currentParent[0];
 }
+function parseTree(text2, errors2 = [], options2 = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors2.push({ error, offset, length });
+    }
+  };
+  visit(text2, visitor, options2);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path3) {
+  if (!root) {
+    return;
+  }
+  let node = root;
+  for (let segment of path3) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
 function visit(text2, visitor, options2 = ParseOptions.DEFAULT) {
   const _scanner = createScanner(text2, false);
   const _jsonPath = [];
@@ -14002,6 +14422,170 @@ function visit(text2, visitor, options2 = ParseOptions.DEFAULT) {
   }
   return true;
 }
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text2, originalPath, value, options2) {
+  const path3 = originalPath.slice();
+  const errors2 = [];
+  const root = parseTree(text2, errors2);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path3.length > 0) {
+    lastSegment = path3.pop();
+    parent = findNodeAtLocation(root, path3);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text2, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options2);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text2, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options2);
+      } else {
+        return withFormatting(text2, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options2);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options2.getInsertionIndex ? options2.getInsertionIndex(parent.children.map((p2) => p2.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text2, edit, options2);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text2, edit, options2);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text2, edit, options2);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options2.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text2, edit, options2);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options2.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text2, edit, options2) {
+  if (!options2.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text2, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options2.formattingOptions, keepLines: false });
+  for (let i2 = edits.length - 1;i2 >= 0; i2--) {
+    const edit2 = edits[i2];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text2.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text2, edit) {
+  return text2.substring(0, edit.offset) + edit.content + text2.substring(edit.offset + edit.length);
+}
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
 var ScanError;
@@ -14054,158 +14638,28 @@ var ParseErrorCode;
   ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
   ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
 })(ParseErrorCode || (ParseErrorCode = {}));
-
-// src/registry/opencode-config.ts
-async function readOpencodeConfig(cwd) {
-  const jsonPath = `${cwd}/opencode.json`;
-  const jsoncPath = `${cwd}/opencode.jsonc`;
-  for (const configPath of [jsoncPath, jsonPath]) {
-    const file = Bun.file(configPath);
-    if (await file.exists()) {
-      const content = await file.text();
-      return {
-        config: parse2(content, [], { allowTrailingComma: true }),
-        path: configPath
-      };
-    }
-  }
-  return null;
-}
-async function writeOpencodeConfig(path3, config2) {
-  const content = JSON.stringify(config2, null, 2);
-  await Bun.write(path3, content);
-}
-function applyMcpServers(config2, mcpServers) {
-  const added = [];
-  const skipped = [];
-  if (!config2.mcp) {
-    config2.mcp = {};
-  }
-  for (const [name, server] of Object.entries(mcpServers)) {
-    if (config2.mcp[name]) {
-      skipped.push(name);
-    } else {
-      const serverConfig = {
-        type: server.type,
-        enabled: server.enabled
-      };
-      if (server.type === "remote" && server.url) {
-        serverConfig.url = server.url;
-      }
-      if (server.type === "local" && server.command) {
-        serverConfig.command = server.command;
-      }
-      if (server.headers) {
-        serverConfig.headers = server.headers;
-      }
-      config2.mcp[name] = serverConfig;
-      added.push(name);
-    }
-  }
-  return { config: config2, added, skipped };
-}
-async function updateOpencodeConfig(cwd, options2) {
-  const existing = await readOpencodeConfig(cwd);
-  let config2;
-  let configPath;
-  let created = false;
-  if (existing) {
-    config2 = existing.config;
-    configPath = existing.path;
-  } else {
-    config2 = {
-      $schema: "https://opencode.ai/config.json"
-    };
-    configPath = `${cwd}/opencode.json`;
-    created = true;
-  }
-  let mcpAdded = [];
-  let mcpSkipped = [];
-  if (options2.mcpServers && Object.keys(options2.mcpServers).length > 0) {
-    const result = applyMcpServers(config2, options2.mcpServers);
-    config2 = result.config;
-    mcpAdded = result.added;
-    mcpSkipped = result.skipped;
-  }
-  if (options2.defaultAgent && !config2.default_agent) {
-    config2.default_agent = options2.defaultAgent;
-  }
-  await writeOpencodeConfig(configPath, config2);
-  return {
-    path: configPath,
-    created,
-    mcpAdded,
-    mcpSkipped
-  };
+function modify(text2, path3, value, options2) {
+  return setProperty(text2, path3, value, options2);
 }
-
-// src/registry/resolver.ts
-async function resolveDependencies(registries, componentNames) {
-  const resolved = new Map;
-  const visiting = new Set;
-  const mcpServers = {};
-  const npmDeps = new Set;
-  const npmDevDeps = new Set;
-  async function resolve2(name, path3 = []) {
-    if (resolved.has(name)) {
-      return;
+function applyEdits(text2, edits) {
+  let sortedEdits = edits.slice(0).sort((a3, b2) => {
+    const diff = a3.offset - b2.offset;
+    if (diff === 0) {
+      return a3.length - b2.length;
     }
-    if (visiting.has(name)) {
-      const cycle = [...path3, name].join(" \u2192 ");
-      throw new ValidationError(`Circular dependency detected: ${cycle}`);
-    }
-    visiting.add(name);
-    let component = null;
-    let foundRegistry = null;
-    const registryEntries = Object.entries(registries);
-    for (const [regName, regConfig] of registryEntries) {
-      try {
-        const manifest = await fetchComponent(regConfig.url, name);
-        component = manifest;
-        foundRegistry = { name: regName, url: regConfig.url };
-        break;
-      } catch (_err) {}
-    }
-    if (!component || !foundRegistry) {
-      throw new OCXError(`Component '${name}' not found in any configured registry.`, "NOT_FOUND");
-    }
-    for (const dep of component.dependencies) {
-      await resolve2(dep, [...path3, name]);
-    }
-    resolved.set(name, {
-      ...component,
-      registryName: foundRegistry.name,
-      baseUrl: foundRegistry.url
-    });
-    visiting.delete(name);
-    if (component.mcpServers) {
-      for (const [serverName, config2] of Object.entries(component.mcpServers)) {
-        mcpServers[serverName] = config2;
-      }
-    }
-    if (component.npmDependencies) {
-      for (const dep of component.npmDependencies) {
-        npmDeps.add(dep);
-      }
-    }
-    if (component.npmDevDependencies) {
-      for (const dep of component.npmDevDependencies) {
-        npmDevDeps.add(dep);
-      }
+    return diff;
+  });
+  let lastModifiedOffset = text2.length;
+  for (let i2 = sortedEdits.length - 1;i2 >= 0; i2--) {
+    let e2 = sortedEdits[i2];
+    if (e2.offset + e2.length <= lastModifiedOffset) {
+      text2 = applyEdit(text2, e2);
+    } else {
+      throw new Error("Overlapping edit");
     }
+    lastModifiedOffset = e2.offset;
   }
-  for (const name of componentNames) {
-    await resolve2(name);
-  }
-  const components = Array.from(resolved.values());
-  const installOrder = Array.from(resolved.keys());
-  return {
-    components,
-    installOrder,
-    mcpServers,
-    npmDependencies: Array.from(npmDeps),
-    npmDevDependencies: Array.from(npmDevDeps)
-  };
+  return text2;
 }
 
 // src/schemas/config.ts
@@ -14274,6 +14728,158 @@ async function readOcxLock(cwd) {
   return ocxLockSchema.parse(json);
 }
 
+// src/updaters/update-opencode-config.ts
+var JSONC_OPTIONS = {
+  formattingOptions: {
+    tabSize: 2,
+    insertSpaces: false,
+    eol: `
+`
+  }
+};
+async function readOpencodeConfig(cwd) {
+  const jsonPath = `${cwd}/opencode.json`;
+  const jsoncPath = `${cwd}/opencode.jsonc`;
+  for (const configPath of [jsoncPath, jsonPath]) {
+    const file = Bun.file(configPath);
+    if (await file.exists()) {
+      const content = await file.text();
+      return {
+        config: parse2(content, [], { allowTrailingComma: true }),
+        content,
+        path: configPath
+      };
+    }
+  }
+  return null;
+}
+async function writeOpencodeConfig(path3, content) {
+  await Bun.write(path3, content);
+}
+function applyMcpServers(content, config2, mcpServers) {
+  const added = [];
+  const skipped = [];
+  let updatedContent = content;
+  const existingMcp = config2.mcp ?? {};
+  for (const [name, server] of Object.entries(mcpServers)) {
+    if (existingMcp[name]) {
+      skipped.push(name);
+      continue;
+    }
+    const serverConfig = {
+      type: server.type
+    };
+    if (server.type === "remote" && server.url) {
+      serverConfig.url = server.url;
+    }
+    if (server.type === "local" && server.command) {
+      serverConfig.command = server.command;
+    }
+    if (server.headers) {
+      serverConfig.headers = server.headers;
+    }
+    if (server.enabled !== undefined) {
+      serverConfig.enabled = server.enabled;
+    }
+    const edits = modify(updatedContent, ["mcp", name], serverConfig, JSONC_OPTIONS);
+    updatedContent = applyEdits(updatedContent, edits);
+    added.push(name);
+  }
+  return { content: updatedContent, added, skipped };
+}
+function applyGlobalToolDisables(content, serverNames) {
+  let updatedContent = content;
+  for (const name of serverNames) {
+    const toolPattern = `${name}_*`;
+    const edits = modify(updatedContent, ["tools", toolPattern], false, JSONC_OPTIONS);
+    updatedContent = applyEdits(updatedContent, edits);
+  }
+  return updatedContent;
+}
+function applyDisabledTools(content, toolNames) {
+  let updatedContent = content;
+  for (const name of toolNames) {
+    const edits = modify(updatedContent, ["tools", name], false, JSONC_OPTIONS);
+    updatedContent = applyEdits(updatedContent, edits);
+  }
+  return updatedContent;
+}
+function applyAgentToolEnables(content, bindings) {
+  let updatedContent = content;
+  const agentsConfigured = [];
+  for (const binding of bindings) {
+    for (const serverName of binding.serverNames) {
+      const toolPattern = `${serverName}_*`;
+      const edits = modify(updatedContent, ["agent", binding.agentName, "tools", toolPattern], true, JSONC_OPTIONS);
+      updatedContent = applyEdits(updatedContent, edits);
+    }
+    if (binding.serverNames.length > 0) {
+      agentsConfigured.push(binding.agentName);
+    }
+  }
+  return { content: updatedContent, agentsConfigured: [...new Set(agentsConfigured)] };
+}
+function applyDefaultAgent(content, config2, defaultAgent) {
+  if (config2.default_agent) {
+    return content;
+  }
+  const edits = modify(content, ["default_agent"], defaultAgent, JSONC_OPTIONS);
+  return applyEdits(content, edits);
+}
+async function updateOpencodeConfig(cwd, options2) {
+  const existing = await readOpencodeConfig(cwd);
+  let content;
+  let config2;
+  let configPath;
+  let created = false;
+  if (existing) {
+    content = existing.content;
+    config2 = existing.config;
+    configPath = existing.path;
+  } else {
+    config2 = { $schema: "https://opencode.ai/config.json" };
+    content = JSON.stringify(config2, null, "\t");
+    configPath = `${cwd}/opencode.json`;
+    created = true;
+  }
+  let mcpAdded = [];
+  let mcpSkipped = [];
+  let agentsConfigured = [];
+  let toolsDisabled = [];
+  if (options2.mcpServers && Object.keys(options2.mcpServers).length > 0) {
+    const result = applyMcpServers(content, config2, options2.mcpServers);
+    content = result.content;
+    mcpAdded = result.added;
+    mcpSkipped = result.skipped;
+  }
+  if (options2.agentMcpBindings && options2.agentMcpBindings.length > 0) {
+    const allScopedServers = [...new Set(options2.agentMcpBindings.flatMap((b2) => b2.serverNames))];
+    if (allScopedServers.length > 0) {
+      content = applyGlobalToolDisables(content, allScopedServers);
+      const agentResult = applyAgentToolEnables(content, options2.agentMcpBindings);
+      content = agentResult.content;
+      agentsConfigured = agentResult.agentsConfigured;
+    }
+  }
+  if (options2.defaultAgent) {
+    const updatedConfig = parse2(content, [], { allowTrailingComma: true });
+    content = applyDefaultAgent(content, updatedConfig, options2.defaultAgent);
+  }
+  if (options2.disabledTools && options2.disabledTools.length > 0) {
+    content = applyDisabledTools(content, options2.disabledTools);
+    toolsDisabled = options2.disabledTools;
+  }
+  await writeOpencodeConfig(configPath, content);
+  return {
+    path: configPath,
+    created,
+    mcpAdded,
+    mcpSkipped,
+    agentsConfigured,
+    toolsDisabled
+  };
+}
+
 // src/utils/env.ts
 var isCI = Boolean(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.JENKINS_URL || process.env.BUILDKITE);
 var isTTY = Boolean(process.stdout.isTTY && !isCI);
@@ -15863,9 +16469,13 @@ async function runAdd(componentNames, options3) {
       };
     }
     installSpin?.succeed(`Installed ${resolved.components.length} components`);
-    if (Object.keys(resolved.mcpServers).length > 0) {
+    const hasMcpChanges = Object.keys(resolved.mcpServers).length > 0 || resolved.agentMcpBindings.length > 0;
+    const hasDisabledTools = resolved.disabledTools.length > 0;
+    if (hasMcpChanges || hasDisabledTools) {
       const result = await updateOpencodeConfig(cwd, {
-        mcpServers: resolved.mcpServers
+        mcpServers: resolved.mcpServers,
+        agentMcpBindings: resolved.agentMcpBindings,
+        disabledTools: resolved.disabledTools
       });
       if (result.mcpSkipped.length > 0 && !options3.quiet) {
         for (const name of result.mcpSkipped) {
@@ -15874,6 +16484,12 @@ async function runAdd(componentNames, options3) {
       }
       if (!options3.quiet && result.mcpAdded.length > 0) {
         logger.info(`Configured ${result.mcpAdded.length} MCP servers`);
+        for (const binding of resolved.agentMcpBindings) {
+          logger.info(`  Scoped to agent "${binding.agentName}": ${binding.serverNames.join(", ")}`);
+        }
+      }
+      if (!options3.quiet && result.toolsDisabled.length > 0) {
+        logger.info(`Disabled ${result.toolsDisabled.length} tools: ${result.toolsDisabled.join(", ")}`);
       }
     }
     const hasNpmDeps = resolved.npmDependencies.length > 0;
@@ -17229,7 +17845,7 @@ function registerSearchCommand(program2) {
 }
 
 // src/index.ts
-var version2 = "1.0.5";
+var version2 = "1.0.6";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version2);
   registerInitCommand(program2);
@@ -17244,4 +17860,4 @@ main2().catch((err) => {
   handleError(err);
 });
 
-//# debugId=D94D02DC5FA0777E64756E2164756E21
+//# debugId=1145245802C7C7C964756E2164756E21