ocx 1.0.5 → 1.0.7

package/dist/index.js

@@ -4533,32 +4533,32 @@ var require_fuzzysort = __commonJS((exports, module) => {
     noResults.total = 0;
     var NULL = null;
     var noTarget = prepare("");
-    var fastpriorityqueue = (r2) => {
-      var e2 = [], o2 = 0, a3 = {}, v2 = (r3) => {
-        for (var a4 = 0, v3 = e2[a4], c2 = 1;c2 < o2; ) {
+    var fastpriorityqueue = (r3) => {
+      var e4 = [], o2 = 0, a3 = {}, v2 = (r4) => {
+        for (var a4 = 0, v3 = e4[a4], c2 = 1;c2 < o2; ) {
           var s2 = c2 + 1;
-          a4 = c2, s2 < o2 && e2[s2]._score < e2[c2]._score && (a4 = s2), e2[a4 - 1 >> 1] = e2[a4], c2 = 1 + (a4 << 1);
+          a4 = c2, s2 < o2 && e4[s2]._score < e4[c2]._score && (a4 = s2), e4[a4 - 1 >> 1] = e4[a4], c2 = 1 + (a4 << 1);
         }
-        for (var f2 = a4 - 1 >> 1;a4 > 0 && v3._score < e2[f2]._score; f2 = (a4 = f2) - 1 >> 1)
-          e2[a4] = e2[f2];
-        e2[a4] = v3;
+        for (var f2 = a4 - 1 >> 1;a4 > 0 && v3._score < e4[f2]._score; f2 = (a4 = f2) - 1 >> 1)
+          e4[a4] = e4[f2];
+        e4[a4] = v3;
       };
-      return a3.add = (r3) => {
+      return a3.add = (r4) => {
         var a4 = o2;
-        e2[o2++] = r3;
-        for (var v3 = a4 - 1 >> 1;a4 > 0 && r3._score < e2[v3]._score; v3 = (a4 = v3) - 1 >> 1)
-          e2[a4] = e2[v3];
-        e2[a4] = r3;
-      }, a3.poll = (r3) => {
+        e4[o2++] = r4;
+        for (var v3 = a4 - 1 >> 1;a4 > 0 && r4._score < e4[v3]._score; v3 = (a4 = v3) - 1 >> 1)
+          e4[a4] = e4[v3];
+        e4[a4] = r4;
+      }, a3.poll = (r4) => {
         if (o2 !== 0) {
-          var a4 = e2[0];
-          return e2[0] = e2[--o2], v2(), a4;
+          var a4 = e4[0];
+          return e4[0] = e4[--o2], v2(), a4;
         }
-      }, a3.peek = (r3) => {
+      }, a3.peek = (r4) => {
         if (o2 !== 0)
-          return e2[0];
-      }, a3.replaceTop = (r3) => {
-        e2[0] = r3, v2();
+          return e4[0];
+      }, a3.replaceTop = (r4) => {
+        e4[0] = r4, v2();
       }, a3;
     };
     var q2 = fastpriorityqueue();
@@ -13052,11 +13052,14 @@ var targetPathSchema = exports_external.string().refine((path3) => path3.startsW
 var skillTargetSchema = exports_external.string().regex(/^\.opencode\/skill\/[a-z0-9]+(-[a-z0-9]+)*\/SKILL\.md$/, {
   message: 'Skill target must match pattern ".opencode/skill/<name>/SKILL.md" where name follows OpenCode naming rules'
 });
-var mcpServerSchema = exports_external.object({
+var mcpServerObjectSchema = exports_external.object({
   type: exports_external.enum(["remote", "local"]),
   url: exports_external.string().url().optional(),
   command: exports_external.array(exports_external.string()).optional(),
+  args: exports_external.array(exports_external.string()).optional(),
+  environment: exports_external.record(exports_external.string()).optional(),
   headers: exports_external.record(exports_external.string()).optional(),
+  oauth: exports_external.boolean().optional(),
   enabled: exports_external.boolean().default(true)
 }).refine((data) => {
   if (data.type === "remote" && !data.url) {
@@ -13069,10 +13072,27 @@ var mcpServerSchema = exports_external.object({
 }, {
   message: "Remote MCP servers require 'url', local servers require 'command'"
 });
-var componentFileSchema = exports_external.object({
+var mcpServerSchema = exports_external.union([exports_external.string().url(), mcpServerObjectSchema]);
+var componentFileObjectSchema = exports_external.object({
   path: exports_external.string().min(1, "File path cannot be empty"),
   target: targetPathSchema
 });
+var componentFileSchema = exports_external.union([
+  exports_external.string().min(1, "File path cannot be empty"),
+  componentFileObjectSchema
+]);
+var agentConfigSchema = exports_external.object({
+  tools: exports_external.record(exports_external.boolean()).optional(),
+  temperature: exports_external.number().min(0).max(2).optional(),
+  prompt: exports_external.string().optional(),
+  permission: exports_external.record(exports_external.enum(["allow", "deny"])).optional()
+});
+var opencodeConfigSchema = exports_external.object({
+  plugins: exports_external.array(exports_external.string()).optional(),
+  tools: exports_external.record(exports_external.boolean()).optional(),
+  agent: exports_external.record(agentConfigSchema).optional(),
+  instructions: exports_external.array(exports_external.string()).optional()
+});
 var componentManifestSchema = exports_external.object({
   name: openCodeNameSchema,
   type: componentTypeSchema,
@@ -13082,8 +13102,42 @@ 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"),
+  opencode: opencodeConfigSchema.optional(),
+  disabledTools: exports_external.array(exports_external.string()).optional()
 });
+function inferTargetPath(sourcePath) {
+  return `.opencode/${sourcePath}`;
+}
+function normalizeFile(file) {
+  if (typeof file === "string") {
+    return {
+      path: file,
+      target: inferTargetPath(file)
+    };
+  }
+  return file;
+}
+function normalizeMcpServer(server) {
+  if (typeof server === "string") {
+    return {
+      type: "remote",
+      url: server,
+      enabled: true
+    };
+  }
+  return server;
+}
+function normalizeComponentManifest(manifest) {
+  return {
+    ...manifest,
+    files: manifest.files.map(normalizeFile),
+    mcpServers: manifest.mcpServers ? Object.fromEntries(Object.entries(manifest.mcpServers).map(([name, server]) => [
+      name,
+      normalizeMcpServer(server)
+    ])) : undefined
+  };
+}
 var semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
 var registrySchema = exports_external.object({
   name: exports_external.string().min(1, "Registry name cannot be empty"),
@@ -13251,6 +13305,166 @@ async function fetchFileContent(baseUrl, componentName, filePath) {
   return response.text();
 }
 
+// ../../node_modules/.bun/remeda@2.33.0/node_modules/remeda/dist/lazyDataLastImpl-DtF3cihj.js
+function e2(e3, t2, n2) {
+  let r2 = (n3) => e3(n3, ...t2);
+  return n2 === undefined ? r2 : Object.assign(r2, { lazy: n2, lazyArgs: t2 });
+}
+
+// ../../node_modules/.bun/remeda@2.33.0/node_modules/remeda/dist/purry-GjwKKIlp.js
+function t2(t3, n2, r2) {
+  let i2 = t3.length - n2.length;
+  if (i2 === 0)
+    return t3(...n2);
+  if (i2 === 1)
+    return e2(t3, n2, r2);
+  throw Error(`Wrong number of arguments`);
+}
+
+// ../../node_modules/.bun/remeda@2.33.0/node_modules/remeda/dist/isPlainObject.js
+function e3(e4) {
+  if (typeof e4 != `object` || !e4)
+    return false;
+  let t3 = Object.getPrototypeOf(e4);
+  return t3 === null || t3 === Object.prototype;
+}
+
+// ../../node_modules/.bun/remeda@2.33.0/node_modules/remeda/dist/mergeDeep.js
+function n2(...t3) {
+  return t2(r2, t3);
+}
+function r2(e4, n3) {
+  let i2 = { ...e4, ...n3 };
+  for (let a3 in n3) {
+    if (!(a3 in e4))
+      continue;
+    let { [a3]: o2 } = e4;
+    if (!e3(o2))
+      continue;
+    let { [a3]: s2 } = n3;
+    e3(s2) && (i2[a3] = r2(o2, s2));
+  }
+  return i2;
+}
+
+// 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;
+  const plugins = new Set;
+  const agentConfigs = {};
+  const instructionsSet = 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]);
+    }
+    const normalizedComponent = normalizeComponentManifest(component);
+    resolved.set(name, {
+      ...normalizedComponent,
+      registryName: foundRegistry.name,
+      baseUrl: foundRegistry.url
+    });
+    visiting.delete(name);
+    if (normalizedComponent.mcpServers) {
+      const serverNames = [];
+      for (const [serverName, config2] of Object.entries(normalizedComponent.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);
+      }
+    }
+    if (component.opencode) {
+      if (component.opencode.plugins) {
+        for (const plugin of component.opencode.plugins) {
+          plugins.add(plugin);
+        }
+      }
+      if (component.opencode.agent) {
+        for (const [agentName, config2] of Object.entries(component.opencode.agent)) {
+          agentConfigs[agentName] = n2(agentConfigs[agentName] ?? {}, config2);
+        }
+      }
+      if (component.opencode.instructions) {
+        for (const instruction of component.opencode.instructions) {
+          instructionsSet.add(instruction);
+        }
+      }
+      if (component.opencode.tools) {
+        for (const [tool, enabled] of Object.entries(component.opencode.tools)) {
+          if (enabled === false) {
+            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),
+    plugins: Array.from(plugins),
+    agentConfigs,
+    instructions: Array.from(instructionsSet)
+  };
+}
+
 // ../../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 +13913,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 +14207,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 +14548,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 +14764,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 modify(text2, path3, value, options2) {
+  return setProperty(text2, path3, value, options2);
 }
-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);
+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;
     }
-  }
-  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
-  };
-}
-
-// 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;
-    }
-    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 e4 = sortedEdits[i2];
+    if (e4.offset + e4.length <= lastModifiedOffset) {
+      text2 = applyEdit(text2, e4);
+    } else {
+      throw new Error("Overlapping edit");
     }
+    lastModifiedOffset = e4.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
@@ -14233,13 +14813,18 @@ var ocxLockSchema = exports_external.object({
 var opencodeMcpSchema = exports_external.record(mcpServerSchema);
 var opencodeAgentSchema = exports_external.object({
   disable: exports_external.boolean().optional(),
-  tools: exports_external.record(exports_external.boolean()).optional()
+  tools: exports_external.record(exports_external.boolean()).optional(),
+  temperature: exports_external.number().min(0).max(2).optional(),
+  prompt: exports_external.string().optional(),
+  permission: exports_external.record(exports_external.enum(["allow", "deny"])).optional()
 });
 var opencodeConfigPatchSchema = exports_external.object({
   default_agent: exports_external.string().optional(),
   mcp: opencodeMcpSchema.optional(),
   tools: exports_external.record(exports_external.boolean()).optional(),
-  agent: exports_external.record(opencodeAgentSchema).optional()
+  agent: exports_external.record(opencodeAgentSchema).optional(),
+  plugin: exports_external.array(exports_external.string()).optional(),
+  instructions: exports_external.array(exports_external.string()).optional()
 });
 var CONFIG_FILE = "ocx.jsonc";
 var LOCK_FILE = "ocx.lock";
@@ -14274,6 +14859,240 @@ 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);
+}
+function applyPlugins(content, config2, plugins) {
+  const added = [];
+  let updatedContent = content;
+  const existingPlugins = config2.plugin ?? [];
+  for (const plugin of plugins) {
+    if (existingPlugins.includes(plugin)) {
+      continue;
+    }
+    const newIndex = existingPlugins.length + added.length;
+    const edits = modify(updatedContent, ["plugin", newIndex], plugin, JSONC_OPTIONS);
+    updatedContent = applyEdits(updatedContent, edits);
+    added.push(plugin);
+  }
+  return { content: updatedContent, added };
+}
+function applyAgentConfigs(content, existingConfig, agentConfigs) {
+  let updatedContent = content;
+  const agentsConfigured = [];
+  for (const [agentName, componentAgentConfig] of Object.entries(agentConfigs)) {
+    const existingAgentConfig = existingConfig.agent?.[agentName] ?? {};
+    const merged = n2(componentAgentConfig, existingAgentConfig);
+    if (merged.tools) {
+      for (const [toolPattern, enabled] of Object.entries(merged.tools)) {
+        const edits = modify(updatedContent, ["agent", agentName, "tools", toolPattern], enabled, JSONC_OPTIONS);
+        updatedContent = applyEdits(updatedContent, edits);
+      }
+    }
+    if (merged.temperature !== undefined) {
+      const edits = modify(updatedContent, ["agent", agentName, "temperature"], merged.temperature, JSONC_OPTIONS);
+      updatedContent = applyEdits(updatedContent, edits);
+    }
+    if (merged.prompt) {
+      const edits = modify(updatedContent, ["agent", agentName, "prompt"], merged.prompt, JSONC_OPTIONS);
+      updatedContent = applyEdits(updatedContent, edits);
+    }
+    if (merged.permission) {
+      for (const [pattern, permission] of Object.entries(merged.permission)) {
+        const edits = modify(updatedContent, ["agent", agentName, "permission", pattern], permission, JSONC_OPTIONS);
+        updatedContent = applyEdits(updatedContent, edits);
+      }
+    }
+    agentsConfigured.push(agentName);
+  }
+  return { content: updatedContent, agentsConfigured };
+}
+function applyInstructions(content, config2, instructions) {
+  const added = [];
+  let updatedContent = content;
+  const existingInstructions = config2.instructions ?? [];
+  for (const instruction of instructions) {
+    if (existingInstructions.includes(instruction)) {
+      continue;
+    }
+    const newIndex = existingInstructions.length + added.length;
+    const edits = modify(updatedContent, ["instructions", newIndex], instruction, JSONC_OPTIONS);
+    updatedContent = applyEdits(updatedContent, edits);
+    added.push(instruction);
+  }
+  return { content: updatedContent, added };
+}
+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 = [];
+  let pluginsAdded = [];
+  let instructionsAdded = [];
+  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;
+  }
+  if (options2.plugins && options2.plugins.length > 0) {
+    const updatedConfig = parse2(content, [], { allowTrailingComma: true });
+    const result = applyPlugins(content, updatedConfig, options2.plugins);
+    content = result.content;
+    pluginsAdded = result.added;
+  }
+  if (options2.agentConfigs && Object.keys(options2.agentConfigs).length > 0) {
+    const updatedConfig = parse2(content, [], { allowTrailingComma: true });
+    const result = applyAgentConfigs(content, updatedConfig, options2.agentConfigs);
+    content = result.content;
+    agentsConfigured = [...new Set([...agentsConfigured, ...result.agentsConfigured])];
+  }
+  if (options2.instructions && options2.instructions.length > 0) {
+    const updatedConfig = parse2(content, [], { allowTrailingComma: true });
+    const result = applyInstructions(content, updatedConfig, options2.instructions);
+    content = result.content;
+    instructionsAdded = result.added;
+  }
+  await writeOpencodeConfig(configPath, content);
+  return {
+    path: configPath,
+    created,
+    mcpAdded,
+    mcpSkipped,
+    agentsConfigured,
+    toolsDisabled,
+    pluginsAdded,
+    instructionsAdded
+  };
+}
+
 // 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 +16682,19 @@ 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;
+    const hasPlugins = resolved.plugins.length > 0;
+    const hasAgentConfigs = Object.keys(resolved.agentConfigs).length > 0;
+    const hasInstructions = resolved.instructions.length > 0;
+    if (hasMcpChanges || hasDisabledTools || hasPlugins || hasAgentConfigs || hasInstructions) {
       const result = await updateOpencodeConfig(cwd, {
-        mcpServers: resolved.mcpServers
+        mcpServers: resolved.mcpServers,
+        agentMcpBindings: resolved.agentMcpBindings,
+        disabledTools: resolved.disabledTools,
+        plugins: resolved.plugins,
+        agentConfigs: resolved.agentConfigs,
+        instructions: resolved.instructions
       });
       if (result.mcpSkipped.length > 0 && !options3.quiet) {
         for (const name of result.mcpSkipped) {
@@ -15874,6 +16703,21 @@ 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(", ")}`);
+      }
+      if (!options3.quiet && result.pluginsAdded.length > 0) {
+        logger.info(`Added ${result.pluginsAdded.length} plugins: ${result.pluginsAdded.join(", ")}`);
+      }
+      if (!options3.quiet && result.agentsConfigured.length > 0) {
+        logger.info(`Configured ${result.agentsConfigured.length} agents: ${result.agentsConfigured.join(", ")}`);
+      }
+      if (!options3.quiet && result.instructionsAdded.length > 0) {
+        logger.info(`Added ${result.instructionsAdded.length} instructions`);
       }
     }
     const hasNpmDeps = resolved.npmDependencies.length > 0;
@@ -15920,7 +16764,8 @@ async function installComponent(component, files, cwd) {
   }
 }
 function getTargetPath(component) {
-  return component.files[0]?.target ?? `.opencode/${component.type}/${component.name}`;
+  const typeDir = component.type.replace(/^ocx:/, "");
+  return component.files[0]?.target ?? `.opencode/${typeDir}/${component.name}`;
 }
 async function hashContent(content) {
   return createHash("sha256").update(content).digest("hex");
@@ -16003,7 +16848,7 @@ function registerBuildCommand(program2) {
       if (!parseResult.success) {
         if (!options3.json) {
           spinner2.fail("Registry validation failed");
-          const errors3 = parseResult.error.errors.map((e2) => `  ${e2.path.join(".")}: ${e2.message}`);
+          const errors3 = parseResult.error.errors.map((e4) => `  ${e4.path.join(".")}: ${e4.message}`);
           for (const err of errors3) {
             console.log(kleur_default.red(err));
           }
@@ -16026,7 +16871,8 @@ function registerBuildCommand(program2) {
         };
         const packumentPath = join3(componentsDir, `${component.name}.json`);
         await Bun.write(packumentPath, JSON.stringify(packument, null, 2));
-        for (const file of component.files) {
+        for (const rawFile of component.files) {
+          const file = normalizeFile(rawFile);
           const sourceFilePath = join3(sourcePath, "files", file.path);
           const destFilePath = join3(componentsDir, component.name, file.path);
           const destFileDir = dirname3(destFilePath);
@@ -16932,11 +17778,12 @@ function registerDiffCommand(program2) {
         }
         try {
           const upstream = await fetchComponent(registryConfig.url, name);
-          const upstreamFile = upstream.files[0];
-          if (!upstreamFile) {
+          const rawUpstreamFile = upstream.files[0];
+          if (!rawUpstreamFile) {
             results.push({ name, hasChanges: false });
             continue;
           }
+          const upstreamFile = normalizeFile(rawUpstreamFile);
           const upstreamContent = await fetchFileContent(registryConfig.url, name, upstreamFile.path);
           if (localContent === upstreamContent) {
             results.push({ name, hasChanges: false });
@@ -17206,7 +18053,7 @@ function registerSearchCommand(program2) {
           keys: ["name", "description"],
           limit
         });
-        results = fuzzyResults.map((r2) => r2.obj);
+        results = fuzzyResults.map((r3) => r3.obj);
       } else {
         results = results.slice(0, limit);
       }
@@ -17229,7 +18076,7 @@ function registerSearchCommand(program2) {
 }
 
 // src/index.ts
-var version2 = "1.0.5";
+var version2 = "1.0.7";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version2);
   registerInitCommand(program2);
@@ -17244,4 +18091,4 @@ main2().catch((err) => {
   handleError(err);
 });
 
-//# debugId=D94D02DC5FA0777E64756E2164756E21
+//# debugId=787522CA1BFEEB9464756E2164756E21