ocx 1.0.10 → 1.0.12

package/dist/index.js

@@ -8486,76 +8486,7 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// src/utils/errors.ts
-var EXIT_CODES = {
-  SUCCESS: 0,
-  GENERAL: 1,
-  NOT_FOUND: 66,
-  NETWORK: 69,
-  CONFIG: 78,
-  INTEGRITY: 1
-};
-
-class OCXError extends Error {
-  code;
-  exitCode;
-  constructor(message, code, exitCode = EXIT_CODES.GENERAL) {
-    super(message);
-    this.code = code;
-    this.exitCode = exitCode;
-    this.name = "OCXError";
-  }
-}
-
-class NotFoundError extends OCXError {
-  constructor(message) {
-    super(message, "NOT_FOUND", EXIT_CODES.NOT_FOUND);
-    this.name = "NotFoundError";
-  }
-}
-
-class NetworkError extends OCXError {
-  constructor(message) {
-    super(message, "NETWORK_ERROR", EXIT_CODES.NETWORK);
-    this.name = "NetworkError";
-  }
-}
-
-class ConfigError extends OCXError {
-  constructor(message) {
-    super(message, "CONFIG_ERROR", EXIT_CODES.CONFIG);
-    this.name = "ConfigError";
-  }
-}
-
-class ValidationError extends OCXError {
-  constructor(message) {
-    super(message, "VALIDATION_ERROR", EXIT_CODES.GENERAL);
-    this.name = "ValidationError";
-  }
-}
-
-class ConflictError extends OCXError {
-  constructor(message) {
-    super(message, "CONFLICT", EXIT_CODES.GENERAL);
-    this.name = "ConflictError";
-  }
-}
-
-class IntegrityError extends OCXError {
-  constructor(component, expected, found) {
-    const message = `Integrity verification failed for "${component}"
-` + `  Expected: ${expected}
-` + `  Found:    ${found}
-
-` + `The registry content has changed since this component was locked.
-` + `This could indicate tampering or an unauthorized update.`;
-    super(message, "INTEGRITY_ERROR", EXIT_CODES.INTEGRITY);
-    this.name = "IntegrityError";
-  }
-}
-
-// src/schemas/registry.ts
+// ../schemas/dist/registry.js
 var openCodeNameSchema = exports_external.string().min(1, "Name cannot be empty").max(64, "Name cannot exceed 64 characters").regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, {
   message: "Must be lowercase alphanumeric with single hyphen separators (e.g., 'my-component', 'my-plugin'). Cannot start/end with hyphen or have consecutive hyphens."
 });
@@ -8565,11 +8496,11 @@ var qualifiedComponentSchema = exports_external.string().regex(/^[a-z0-9]+(-[a-z
 });
 function parseQualifiedComponent(ref) {
   if (!ref.includes("/")) {
-    throw new ValidationError(`Invalid component reference: "${ref}". Use format: namespace/component`);
+    throw new Error(`Invalid component reference: "${ref}". Use format: namespace/component`);
   }
   const [namespace, component] = ref.split("/");
   if (!namespace || !component) {
-    throw new ValidationError(`Invalid component reference: "${ref}". Both namespace and component are required.`);
+    throw new Error(`Invalid component reference: "${ref}". Both namespace and component are required.`);
   }
   return { namespace, component };
 }
@@ -8602,9 +8533,6 @@ var targetPathSchema = exports_external.string().refine((path) => path.startsWit
 }, {
   message: 'Target must be in a valid directory: ".opencode/{agent|skill|plugin|command|tool|philosophy}/..."'
 });
-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 mcpServerObjectSchema = exports_external.object({
   type: exports_external.enum(["remote", "local"]),
   url: exports_external.string().url().optional(),
@@ -8640,11 +8568,18 @@ var agentConfigSchema = exports_external.object({
   prompt: exports_external.string().optional(),
   permission: exports_external.record(exports_external.enum(["allow", "deny"])).optional()
 });
+var permissionConfigSchema = exports_external.object({
+  bash: exports_external.union([exports_external.enum(["ask", "allow", "deny"]), exports_external.record(exports_external.enum(["ask", "allow", "deny"]))]).optional(),
+  edit: exports_external.union([exports_external.enum(["ask", "allow", "deny"]), exports_external.record(exports_external.enum(["ask", "allow", "deny"]))]).optional(),
+  mcp: exports_external.record(exports_external.enum(["ask", "allow", "deny"])).optional()
+});
 var opencodeConfigSchema = exports_external.object({
-  plugins: exports_external.array(exports_external.string()).optional(),
+  mcp: exports_external.record(mcpServerRefSchema).optional(),
+  plugin: 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()
+  instructions: exports_external.array(exports_external.string()).optional(),
+  permission: permissionConfigSchema.optional()
 });
 var componentManifestSchema = exports_external.object({
   name: openCodeNameSchema,
@@ -8654,10 +8589,7 @@ var componentManifestSchema = exports_external.object({
   dependencies: exports_external.array(dependencyRefSchema).default([]),
   npmDependencies: exports_external.array(exports_external.string()).optional(),
   npmDevDependencies: exports_external.array(exports_external.string()).optional(),
-  mcpServers: exports_external.record(mcpServerRefSchema).optional(),
-  mcpScope: exports_external.enum(["agent", "global"]).default("agent"),
-  opencode: opencodeConfigSchema.optional(),
-  disabledTools: exports_external.array(exports_external.string()).optional()
+  opencode: opencodeConfigSchema.optional()
 });
 function inferTargetPath(sourcePath) {
   return `.opencode/${sourcePath}`;
@@ -8682,13 +8614,20 @@ function normalizeMcpServer(server) {
   return server;
 }
 function normalizeComponentManifest(manifest) {
+  let normalizedOpencode;
+  if (manifest.opencode) {
+    const { mcp, ...rest } = manifest.opencode;
+    normalizedOpencode = {
+      ...rest,
+      ...mcp && {
+        mcp: Object.fromEntries(Object.entries(mcp).map(([name, server]) => [name, normalizeMcpServer(server)]))
+      }
+    };
+  }
   return {
     ...manifest,
     files: manifest.files.map(normalizeFile),
-    mcpServers: manifest.mcpServers ? Object.fromEntries(Object.entries(manifest.mcpServers).map(([name, server]) => [
-      name,
-      normalizeMcpServer(server)
-    ])) : undefined
+    opencode: normalizedOpencode
   };
 }
 var semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
@@ -8732,6 +8671,97 @@ var registryIndexSchema = exports_external.object({
   }))
 });
 
+// ../schemas/dist/config.js
+var registryConfigSchema = exports_external.object({
+  url: exports_external.string().url("Registry URL must be a valid URL"),
+  version: exports_external.string().optional(),
+  headers: exports_external.record(exports_external.string()).optional()
+});
+var ocxConfigSchema = exports_external.object({
+  $schema: exports_external.string().optional(),
+  registries: exports_external.record(registryConfigSchema).default({}),
+  lockRegistries: exports_external.boolean().default(false)
+});
+var installedComponentSchema = exports_external.object({
+  registry: exports_external.string(),
+  version: exports_external.string(),
+  hash: exports_external.string(),
+  files: exports_external.array(exports_external.string()),
+  installedAt: exports_external.string()
+});
+var ocxLockSchema = exports_external.object({
+  lockVersion: exports_external.literal(1),
+  installed: exports_external.record(qualifiedComponentSchema, installedComponentSchema).default({})
+});
+// src/utils/errors.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL: 1,
+  NOT_FOUND: 66,
+  NETWORK: 69,
+  CONFIG: 78,
+  INTEGRITY: 1
+};
+
+class OCXError extends Error {
+  code;
+  exitCode;
+  constructor(message, code, exitCode = EXIT_CODES.GENERAL) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.name = "OCXError";
+  }
+}
+
+class NotFoundError extends OCXError {
+  constructor(message) {
+    super(message, "NOT_FOUND", EXIT_CODES.NOT_FOUND);
+    this.name = "NotFoundError";
+  }
+}
+
+class NetworkError extends OCXError {
+  constructor(message) {
+    super(message, "NETWORK_ERROR", EXIT_CODES.NETWORK);
+    this.name = "NetworkError";
+  }
+}
+
+class ConfigError extends OCXError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR", EXIT_CODES.CONFIG);
+    this.name = "ConfigError";
+  }
+}
+
+class ValidationError extends OCXError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR", EXIT_CODES.GENERAL);
+    this.name = "ValidationError";
+  }
+}
+
+class ConflictError extends OCXError {
+  constructor(message) {
+    super(message, "CONFLICT", EXIT_CODES.GENERAL);
+    this.name = "ConflictError";
+  }
+}
+
+class IntegrityError extends OCXError {
+  constructor(component, expected, found) {
+    const message = `Integrity verification failed for "${component}"
+` + `  Expected: ${expected}
+` + `  Found:    ${found}
+
+` + `The registry content has changed since this component was locked.
+` + `This could indicate tampering or an unauthorized update.`;
+    super(message, "INTEGRITY_ERROR", EXIT_CODES.INTEGRITY);
+    this.name = "IntegrityError";
+  }
+}
+
 // src/registry/fetcher.ts
 var cache = new Map;
 async function fetchWithCache(url, parse) {
@@ -8835,6 +8865,18 @@ function r(e3, n2) {
   return i;
 }
 
+// src/registry/merge.ts
+function mergeOpencodeConfig(target, source) {
+  const merged = n(target, source);
+  if (target.plugin && source.plugin) {
+    merged.plugin = Array.from(new Set([...target.plugin, ...source.plugin]));
+  }
+  if (target.instructions && source.instructions) {
+    merged.instructions = Array.from(new Set([...target.instructions, ...source.instructions]));
+  }
+  return merged;
+}
+
 // src/registry/resolver.ts
 function parseComponentRef(ref, defaultNamespace) {
   if (ref.includes("/")) {
@@ -8848,14 +8890,9 @@ function parseComponentRef(ref, defaultNamespace) {
 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;
+  let opencode = {};
   async function resolve(componentNamespace, componentName, path = []) {
     const qualifiedName = createQualifiedComponent(componentNamespace, componentName);
     if (resolved.has(qualifiedName)) {
@@ -8889,20 +8926,6 @@ async function resolveDependencies(registries, componentNames) {
       qualifiedName
     });
     visiting.delete(qualifiedName);
-    if (normalizedComponent.mcpServers) {
-      const serverNames = [];
-      for (const [serverName, config] of Object.entries(normalizedComponent.mcpServers)) {
-        mcpServers[serverName] = config;
-        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);
@@ -8913,34 +8936,8 @@ async function resolveDependencies(registries, componentNames) {
         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, config] of Object.entries(component.opencode.agent)) {
-          agentConfigs[agentName] = n(agentConfigs[agentName] ?? {}, config);
-        }
-      }
-      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);
-          }
-        }
-      }
+    if (normalizedComponent.opencode) {
+      opencode = mergeOpencodeConfig(opencode, normalizedComponent.opencode);
     }
   }
   for (const name of componentNames) {
@@ -8952,14 +8949,9 @@ async function resolveDependencies(registries, componentNames) {
   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)
+    opencode
   };
 }
 
@@ -10287,44 +10279,6 @@ function applyEdits(text, edits) {
 }
 
 // src/schemas/config.ts
-var registryConfigSchema = exports_external.object({
-  url: exports_external.string().url("Registry URL must be a valid URL"),
-  version: exports_external.string().optional(),
-  headers: exports_external.record(exports_external.string()).optional()
-});
-var ocxConfigSchema = exports_external.object({
-  $schema: exports_external.string().optional(),
-  registries: exports_external.record(registryConfigSchema).default({}),
-  lockRegistries: exports_external.boolean().default(false)
-});
-var installedComponentSchema = exports_external.object({
-  registry: exports_external.string(),
-  version: exports_external.string(),
-  hash: exports_external.string(),
-  files: exports_external.array(exports_external.string()),
-  installedAt: exports_external.string(),
-  alias: exports_external.string().optional()
-});
-var ocxLockSchema = exports_external.object({
-  lockVersion: exports_external.literal(1),
-  installed: exports_external.record(qualifiedComponentSchema, installedComponentSchema).default({})
-});
-var opencodeMcpSchema = exports_external.record(mcpServerRefSchema);
-var opencodeAgentSchema = exports_external.object({
-  disable: 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(),
-  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";
 async function readOcxConfig(cwd) {
@@ -10342,9 +10296,9 @@ async function readOcxConfig(cwd) {
     throw error;
   }
 }
-async function writeOcxConfig(cwd, config) {
+async function writeOcxConfig(cwd, config2) {
   const configPath = `${cwd}/${CONFIG_FILE}`;
-  const content = JSON.stringify(config, null, 2);
+  const content = JSON.stringify(config2, null, 2);
   await Bun.write(configPath, content);
 }
 async function readOcxLock(cwd) {
@@ -10367,7 +10321,7 @@ var JSONC_OPTIONS = {
 `
   }
 };
-async function readOpencodeConfig(cwd) {
+async function readOpencodeJsonConfig(cwd) {
   const jsonPath = `${cwd}/opencode.json`;
   const jsoncPath = `${cwd}/opencode.jsonc`;
   for (const configPath of [jsoncPath, jsonPath]) {
@@ -10383,224 +10337,62 @@ async function readOpencodeConfig(cwd) {
   }
   return null;
 }
-async function writeOpencodeConfig(path, content) {
+async function writeOpencodeJsonConfig(path, content) {
   await Bun.write(path, content);
 }
-function applyMcpServers(content, config, mcpServers) {
-  const added = [];
-  const skipped = [];
-  let updatedContent = content;
-  const existingMcp = config.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.args) {
-      serverConfig.args = server.args;
-    }
-    if (server.headers) {
-      serverConfig.headers = server.headers;
-    }
-    if (server.oauth !== undefined) {
-      serverConfig.oauth = server.oauth;
-    }
-    if (server.enabled !== undefined) {
-      serverConfig.enabled = server.enabled;
-    }
-    if (server.environment) {
-      serverConfig.environment = server.environment;
-    }
-    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, config, defaultAgent) {
-  if (config.default_agent) {
+function applyValueAtPath(content, path, value) {
+  if (value === null || value === undefined) {
     return content;
   }
-  const edits = modify(content, ["default_agent"], defaultAgent, JSONC_OPTIONS);
-  return applyEdits(content, edits);
-}
-function applyPlugins(content, config, plugins) {
-  const added = [];
-  let updatedContent = content;
-  const existingPlugins = config.plugin ?? [];
-  for (const plugin of plugins) {
-    if (existingPlugins.includes(plugin)) {
-      continue;
+  if (typeof value === "object" && !Array.isArray(value)) {
+    let updatedContent = content;
+    for (const [key, val] of Object.entries(value)) {
+      updatedContent = applyValueAtPath(updatedContent, [...path, key], val);
     }
-    const newIndex = existingPlugins.length + added.length;
-    const edits = modify(updatedContent, ["plugin", newIndex], plugin, JSONC_OPTIONS);
-    updatedContent = applyEdits(updatedContent, edits);
-    added.push(plugin);
+    return updatedContent;
   }
-  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 = n(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, config, instructions) {
-  const added = [];
-  let updatedContent = content;
-  const existingInstructions = config.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);
+  if (Array.isArray(value)) {
+    const edits2 = modify(content, path, value, JSONC_OPTIONS);
+    return applyEdits(content, edits2);
   }
-  return { content: updatedContent, added };
+  const edits = modify(content, path, value, JSONC_OPTIONS);
+  return applyEdits(content, edits);
 }
-async function updateOpencodeConfig(cwd, options) {
-  const existing = await readOpencodeConfig(cwd);
+async function updateOpencodeJsonConfig(cwd, opencode) {
+  const existing = await readOpencodeJsonConfig(cwd);
   let content;
-  let config;
   let configPath;
   let created = false;
   if (existing) {
     content = existing.content;
-    config = existing.config;
     configPath = existing.path;
   } else {
-    config = { $schema: "https://opencode.ai/config.json" };
-    content = JSON.stringify(config, null, "\t");
-    configPath = `${cwd}/opencode.json`;
+    const config2 = { $schema: "https://opencode.ai/config.json" };
+    content = JSON.stringify(config2, null, "\t");
+    configPath = `${cwd}/opencode.jsonc`;
     created = true;
   }
-  let mcpAdded = [];
-  let mcpSkipped = [];
-  let agentsConfigured = [];
-  let toolsDisabled = [];
-  let pluginsAdded = [];
-  let instructionsAdded = [];
-  if (options.mcpServers && Object.keys(options.mcpServers).length > 0) {
-    const result = applyMcpServers(content, config, options.mcpServers);
-    content = result.content;
-    mcpAdded = result.added;
-    mcpSkipped = result.skipped;
-  }
-  if (options.agentMcpBindings && options.agentMcpBindings.length > 0) {
-    const allScopedServers = [...new Set(options.agentMcpBindings.flatMap((b) => b.serverNames))];
-    if (allScopedServers.length > 0) {
-      content = applyGlobalToolDisables(content, allScopedServers);
-      const agentResult = applyAgentToolEnables(content, options.agentMcpBindings);
-      content = agentResult.content;
-      agentsConfigured = agentResult.agentsConfigured;
-    }
-  }
-  if (options.defaultAgent) {
-    const updatedConfig = parse2(content, [], { allowTrailingComma: true });
-    content = applyDefaultAgent(content, updatedConfig, options.defaultAgent);
-  }
-  if (options.disabledTools && options.disabledTools.length > 0) {
-    content = applyDisabledTools(content, options.disabledTools);
-    toolsDisabled = options.disabledTools;
-  }
-  if (options.plugins && options.plugins.length > 0) {
-    const updatedConfig = parse2(content, [], { allowTrailingComma: true });
-    const result = applyPlugins(content, updatedConfig, options.plugins);
-    content = result.content;
-    pluginsAdded = result.added;
-  }
-  if (options.agentConfigs && Object.keys(options.agentConfigs).length > 0) {
-    const updatedConfig = parse2(content, [], { allowTrailingComma: true });
-    const result = applyAgentConfigs(content, updatedConfig, options.agentConfigs);
-    content = result.content;
-    agentsConfigured = [...new Set([...agentsConfigured, ...result.agentsConfigured])];
-  }
-  if (options.instructions && options.instructions.length > 0) {
-    const updatedConfig = parse2(content, [], { allowTrailingComma: true });
-    const result = applyInstructions(content, updatedConfig, options.instructions);
-    content = result.content;
-    instructionsAdded = result.added;
-  }
-  await writeOpencodeConfig(configPath, content);
+  const originalContent = content;
+  content = applyValueAtPath(content, [], opencode);
+  const changed = content !== originalContent;
+  if (changed) {
+    await writeOpencodeJsonConfig(configPath, content);
+  }
   return {
     path: configPath,
     created,
-    mcpAdded,
-    mcpSkipped,
-    agentsConfigured,
-    toolsDisabled,
-    pluginsAdded,
-    instructionsAdded
+    changed
   };
 }
 
+// src/utils/content.ts
+function normalizeContent(content) {
+  return content.replace(/\r\n/g, `
+`).trim();
+}
+function isContentIdentical(existing, incoming) {
+  return normalizeContent(existing) === normalizeContent(incoming);
+}
 // 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);
@@ -12140,8 +11932,8 @@ function registerAddCommand(program2) {
 async function runAdd(componentNames, options2) {
   const cwd = options2.cwd ?? process.cwd();
   const lockPath = join(cwd, "ocx.lock");
-  const config = await readOcxConfig(cwd);
-  if (!config) {
+  const config2 = await readOcxConfig(cwd);
+  if (!config2) {
     throw new ConfigError("No ocx.jsonc found. Run 'ocx init' first.");
   }
   let lock = { lockVersion: 1, installed: {} };
@@ -12152,7 +11944,7 @@ async function runAdd(componentNames, options2) {
   const spin = options2.quiet ? null : createSpinner({ text: "Resolving dependencies..." });
   spin?.start();
   try {
-    const resolved = await resolveDependencies(config.registries, componentNames);
+    const resolved = await resolveDependencies(config2.registries, componentNames);
     spin?.succeed(`Resolved ${resolved.components.length} components`);
     if (options2.verbose) {
       logger.info("Install order:");
@@ -12166,17 +11958,19 @@ async function runAdd(componentNames, options2) {
       logResolved(resolved);
       return;
     }
-    const installSpin = options2.quiet ? null : createSpinner({ text: "Installing components..." });
-    installSpin?.start();
+    const fetchSpin = options2.quiet ? null : createSpinner({ text: "Fetching components..." });
+    fetchSpin?.start();
+    const componentBundles = [];
     for (const component of resolved.components) {
       const files = [];
       for (const file of component.files) {
-        const content = await fetchFileContent(component.baseUrl, component.name, file.path);
-        files.push({ path: file.path, content: Buffer.from(content) });
+        const content2 = await fetchFileContent(component.baseUrl, component.name, file.path);
+        files.push({ path: file.path, content: Buffer.from(content2) });
       }
       const computedHash = await hashBundle(files);
       const existingEntry = lock.installed[component.qualifiedName];
       if (existingEntry && existingEntry.hash !== computedHash) {
+        fetchSpin?.fail("Integrity check failed");
         throw new IntegrityError(component.qualifiedName, existingEntry.hash, computedHash);
       }
       for (const file of component.files) {
@@ -12184,6 +11978,7 @@ async function runAdd(componentNames, options2) {
         if (existsSync(targetPath)) {
           const conflictingComponent = findComponentByFile(lock, file.target);
           if (conflictingComponent && conflictingComponent !== component.qualifiedName) {
+            fetchSpin?.fail("File conflict detected");
             throw new ConflictError(`File conflict: ${file.target} already exists (installed by '${conflictingComponent}').
 
 ` + `To resolve:
@@ -12193,7 +11988,54 @@ async function runAdd(componentNames, options2) {
           }
         }
       }
-      await installComponent(component, files, cwd);
+      componentBundles.push({ component, files, computedHash });
+    }
+    fetchSpin?.succeed(`Fetched ${resolved.components.length} components`);
+    const allConflicts = [];
+    for (const { component, files } of componentBundles) {
+      for (const file of files) {
+        const componentFile = component.files.find((f) => f.path === file.path);
+        if (!componentFile)
+          continue;
+        const targetPath = join(cwd, componentFile.target);
+        if (existsSync(targetPath)) {
+          const existingContent = await Bun.file(targetPath).text();
+          const incomingContent = file.content.toString("utf-8");
+          if (!isContentIdentical(existingContent, incomingContent) && !options2.yes) {
+            allConflicts.push(componentFile.target);
+          }
+        }
+      }
+    }
+    if (allConflicts.length > 0) {
+      logger.error("");
+      logger.error("File conflicts detected:");
+      for (const conflict of allConflicts) {
+        logger.error(`  \u2717 ${conflict}`);
+      }
+      logger.error("");
+      logger.error("These files have been modified since installation.");
+      logger.error("Use --yes to overwrite, or review the changes first.");
+      throw new ConflictError(`${allConflicts.length} file(s) have conflicts. Use --yes to overwrite.`);
+    }
+    const installSpin = options2.quiet ? null : createSpinner({ text: "Installing components..." });
+    installSpin?.start();
+    for (const { component, files, computedHash } of componentBundles) {
+      const installResult = await installComponent(component, files, cwd, {
+        yes: options2.yes,
+        verbose: options2.verbose
+      });
+      if (options2.verbose) {
+        for (const f of installResult.skipped) {
+          logger.info(`  \u25CB Skipped ${f} (unchanged)`);
+        }
+        for (const f of installResult.overwritten) {
+          logger.info(`  \u2713 Overwrote ${f}`);
+        }
+        for (const f of installResult.written) {
+          logger.info(`  \u2713 Wrote ${f}`);
+        }
+      }
       const index = await fetchRegistryIndex(component.baseUrl);
       lock.installed[component.qualifiedName] = {
         registry: component.registryName,
@@ -12204,43 +12046,15 @@ async function runAdd(componentNames, options2) {
       };
     }
     installSpin?.succeed(`Installed ${resolved.components.length} components`);
-    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,
-        agentMcpBindings: resolved.agentMcpBindings,
-        disabledTools: resolved.disabledTools,
-        plugins: resolved.plugins,
-        agentConfigs: resolved.agentConfigs,
-        instructions: resolved.instructions
-      });
-      if (result.mcpSkipped.length > 0 && !options2.quiet) {
-        for (const name of result.mcpSkipped) {
-          logger.warn(`MCP server "${name}" already configured, skipped`);
-        }
-      }
-      if (!options2.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 (resolved.opencode && Object.keys(resolved.opencode).length > 0) {
+      const result = await updateOpencodeJsonConfig(cwd, resolved.opencode);
+      if (!options2.quiet && result.changed) {
+        if (result.created) {
+          logger.info("Created opencode.jsonc");
+        } else {
+          logger.info("Updated opencode.jsonc");
         }
       }
-      if (!options2.quiet && result.toolsDisabled.length > 0) {
-        logger.info(`Disabled ${result.toolsDisabled.length} tools: ${result.toolsDisabled.join(", ")}`);
-      }
-      if (!options2.quiet && result.pluginsAdded.length > 0) {
-        logger.info(`Added ${result.pluginsAdded.length} plugins: ${result.pluginsAdded.join(", ")}`);
-      }
-      if (!options2.quiet && result.agentsConfigured.length > 0) {
-        logger.info(`Configured ${result.agentsConfigured.length} agents: ${result.agentsConfigured.join(", ")}`);
-      }
-      if (!options2.quiet && result.instructionsAdded.length > 0) {
-        logger.info(`Added ${result.instructionsAdded.length} instructions`);
-      }
     }
     const hasNpmDeps = resolved.npmDependencies.length > 0;
     const hasNpmDevDeps = resolved.npmDevDependencies.length > 0;
@@ -12261,32 +12075,51 @@ async function runAdd(componentNames, options2) {
       console.log(JSON.stringify({
         success: true,
         installed: resolved.installOrder,
-        mcpServers: Object.keys(resolved.mcpServers)
+        opencode: !!resolved.opencode
       }, null, 2));
     } else if (!options2.quiet) {
       logger.info("");
       logger.success(`Done! Installed ${resolved.components.length} components.`);
     }
   } catch (error) {
-    spin?.fail("Failed to resolve dependencies");
+    if (spin && !spin.isSpinning) {} else {
+      spin?.fail("Failed to add components");
+    }
     throw error;
   }
 }
-async function installComponent(component, files, cwd) {
+async function installComponent(component, files, cwd, _options) {
+  const result = {
+    written: [],
+    skipped: [],
+    overwritten: []
+  };
   for (const file of files) {
     const componentFile = component.files.find((f) => f.path === file.path);
     if (!componentFile)
       continue;
     const targetPath = join(cwd, componentFile.target);
     const targetDir = dirname(targetPath);
+    if (existsSync(targetPath)) {
+      const existingContent = await Bun.file(targetPath).text();
+      const incomingContent = file.content.toString("utf-8");
+      if (isContentIdentical(existingContent, incomingContent)) {
+        result.skipped.push(componentFile.target);
+        continue;
+      }
+      result.overwritten.push(componentFile.target);
+    } else {
+      result.written.push(componentFile.target);
+    }
     if (!existsSync(targetDir)) {
       await mkdir(targetDir, { recursive: true });
     }
     await writeFile(targetPath, file.content);
   }
+  return result;
 }
-async function hashContent(content) {
-  return createHash("sha256").update(content).digest("hex");
+async function hashContent(content2) {
+  return createHash("sha256").update(content2).digest("hex");
 }
 async function hashBundle(files) {
   const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
@@ -12304,11 +12137,11 @@ function logResolved(resolved) {
   for (const component of resolved.components) {
     logger.info(`  ${component.name} (${component.type}) from ${component.registryName}`);
   }
-  if (Object.keys(resolved.mcpServers).length > 0) {
+  if (resolved.opencode && Object.keys(resolved.opencode).length > 0) {
     logger.info("");
-    logger.info("Would configure MCP servers:");
-    for (const name of Object.keys(resolved.mcpServers)) {
-      logger.info(`  ${name}`);
+    logger.info("Would update opencode.json with:");
+    for (const key of Object.keys(resolved.opencode)) {
+      logger.info(`  ${key}`);
     }
   }
   if (resolved.npmDependencies.length > 0) {
@@ -12360,8 +12193,8 @@ async function readOpencodePackageJson(opencodeDir) {
     return { ...DEFAULT_PACKAGE_JSON };
   }
   try {
-    const content = await Bun.file(pkgPath).text();
-    return JSON.parse(content);
+    const content2 = await Bun.file(pkgPath).text();
+    return JSON.parse(content2);
   } catch (e3) {
     const message = e3 instanceof Error ? e3.message : String(e3);
     throw new ConfigError(`Invalid .opencode/package.json: ${message}`);
@@ -12373,8 +12206,8 @@ async function ensureManifestFilesAreTracked(opencodeDir) {
   const requiredIgnores = ["node_modules"];
   let lines = [];
   if (existsSync(gitignorePath)) {
-    const content = await Bun.file(gitignorePath).text();
-    lines = content.split(`
+    const content2 = await Bun.file(gitignorePath).text();
+    lines = content2.split(`
 `).map((l) => l.trim()).filter(Boolean);
   }
   lines = lines.filter((line) => !filesToTrack.has(line));
@@ -12441,18 +12274,18 @@ function registerBuildCommand(program2) {
         }
         process.exit(1);
       }
-      const registry = parseResult.data;
+      const registry2 = parseResult.data;
       const validationErrors = [];
       const componentsDir = join2(outPath, "components");
       await mkdir2(componentsDir, { recursive: true });
-      for (const component of registry.components) {
+      for (const component of registry2.components) {
         const packument = {
           name: component.name,
           versions: {
-            [registry.version]: component
+            [registry2.version]: component
           },
           "dist-tags": {
-            latest: registry.version
+            latest: registry2.version
           }
         };
         const packumentPath = join2(componentsDir, `${component.name}.json`);
@@ -12481,31 +12314,35 @@ function registerBuildCommand(program2) {
         process.exit(1);
       }
       const index = {
-        name: registry.name,
-        namespace: registry.namespace,
-        version: registry.version,
-        author: registry.author,
-        components: registry.components.map((c) => ({
+        name: registry2.name,
+        namespace: registry2.namespace,
+        version: registry2.version,
+        author: registry2.author,
+        components: registry2.components.map((c) => ({
           name: c.name,
           type: c.type,
           description: c.description
         }))
       };
       await Bun.write(join2(outPath, "index.json"), JSON.stringify(index, null, 2));
+      const wellKnownDir = join2(outPath, ".well-known");
+      await mkdir2(wellKnownDir, { recursive: true });
+      const discovery = { registry: "/index.json" };
+      await Bun.write(join2(wellKnownDir, "ocx.json"), JSON.stringify(discovery, null, 2));
       if (!options2.json) {
-        const msg = `Built ${registry.components.length} components to ${relative(options2.cwd, outPath)}`;
+        const msg = `Built ${registry2.components.length} components to ${relative(options2.cwd, outPath)}`;
         spinner2.succeed(msg);
         if (!process.stdout.isTTY) {
-          logger.success(`Built ${registry.components.length} components`);
+          logger.success(`Built ${registry2.components.length} components`);
         }
       }
       if (options2.json) {
         outputJson({
           success: true,
           data: {
-            name: registry.name,
-            version: registry.version,
-            components: registry.components.length,
+            name: registry2.name,
+            version: registry2.version,
+            components: registry2.components.length,
             output: outPath
           }
         });
@@ -13320,8 +13157,8 @@ function registerDiffCommand(program2) {
         }
         return;
       }
-      const config = await readOcxConfig(options2.cwd);
-      if (!config) {
+      const config2 = await readOcxConfig(options2.cwd);
+      if (!config2) {
         if (options2.json) {
           outputJson({
             success: false,
@@ -13361,7 +13198,7 @@ function registerDiffCommand(program2) {
           continue;
         }
         const localContent = await localFile.text();
-        const registryConfig = config.registries[installed.registry];
+        const registryConfig = config2.registries[installed.registry];
         if (!registryConfig) {
           logger.warn(`Registry '${installed.registry}' not configured for component '${name}'.`);
           continue;
@@ -13413,12 +13250,7 @@ import { join as join3 } from "path";
 
 // src/constants.ts
 var OCX_DOMAIN = "ocx.kdco.dev";
-var GITHUB_REPO = "kdcokenny/ocx";
 var OCX_SCHEMA_URL = `https://${OCX_DOMAIN}/schema.json`;
-var OCX_LOCK_SCHEMA_URL = `https://${OCX_DOMAIN}/lock.schema.json`;
-var OCX_INSTALL_URL = `https://${OCX_DOMAIN}/install.sh`;
-var GITHUB_RELEASES_URL = `https://github.com/${GITHUB_REPO}/releases`;
-var GITHUB_RAW_URL = `https://raw.githubusercontent.com/${GITHUB_REPO}/main`;
 
 // src/commands/init.ts
 function registerInitCommand(program2) {
@@ -13448,9 +13280,9 @@ async function runInit(options2) {
       $schema: OCX_SCHEMA_URL,
       registries: {}
     };
-    const config = ocxConfigSchema.parse(rawConfig);
-    const content = JSON.stringify(config, null, 2);
-    await writeFile2(configPath, content, "utf-8");
+    const config2 = ocxConfigSchema.parse(rawConfig);
+    const content2 = JSON.stringify(config2, null, 2);
+    await writeFile2(configPath, content2, "utf-8");
     if (!options2.quiet && !options2.json) {
       logger.success("Initialized OCX configuration");
     }
@@ -13472,28 +13304,28 @@ async function runInit(options2) {
 
 // src/commands/registry.ts
 function registerRegistryCommand(program2) {
-  const registry = program2.command("registry").description("Manage registries");
-  registry.command("add").description("Add a registry").argument("<url>", "Registry URL").option("--name <name>", "Registry alias (defaults to hostname)").option("--version <version>", "Pin to specific version").option("--cwd <path>", "Working directory", process.cwd()).option("--json", "Output as JSON", false).option("-q, --quiet", "Suppress output", false).action(async (url, options2) => {
+  const registry2 = program2.command("registry").description("Manage registries");
+  registry2.command("add").description("Add a registry").argument("<url>", "Registry URL").option("--name <name>", "Registry alias (defaults to hostname)").option("--version <version>", "Pin to specific version").option("--cwd <path>", "Working directory", process.cwd()).option("--json", "Output as JSON", false).option("-q, --quiet", "Suppress output", false).action(async (url, options2) => {
     try {
-      const config = await readOcxConfig(options2.cwd);
-      if (!config) {
+      const config2 = await readOcxConfig(options2.cwd);
+      if (!config2) {
         logger.error("No ocx.jsonc found. Run 'ocx init' first.");
         process.exit(1);
       }
-      if (config.lockRegistries) {
+      if (config2.lockRegistries) {
         logger.error("Registries are locked. Cannot add.");
         process.exit(1);
       }
       const name = options2.name || new URL(url).hostname.replace(/\./g, "-");
-      if (config.registries[name]) {
+      if (config2.registries[name]) {
         logger.warn(`Registry '${name}' already exists. Use a different name.`);
         return;
       }
-      config.registries[name] = {
+      config2.registries[name] = {
         url,
         version: options2.version
       };
-      await writeOcxConfig(options2.cwd, config);
+      await writeOcxConfig(options2.cwd, config2);
       if (options2.json) {
         outputJson({ success: true, data: { name, url } });
       } else {
@@ -13503,23 +13335,23 @@ function registerRegistryCommand(program2) {
       handleError(error);
     }
   });
-  registry.command("remove").description("Remove a registry").argument("<name>", "Registry name").option("--cwd <path>", "Working directory", process.cwd()).option("--json", "Output as JSON", false).option("-q, --quiet", "Suppress output", false).action(async (name, options2) => {
+  registry2.command("remove").description("Remove a registry").argument("<name>", "Registry name").option("--cwd <path>", "Working directory", process.cwd()).option("--json", "Output as JSON", false).option("-q, --quiet", "Suppress output", false).action(async (name, options2) => {
     try {
-      const config = await readOcxConfig(options2.cwd);
-      if (!config) {
+      const config2 = await readOcxConfig(options2.cwd);
+      if (!config2) {
         logger.error("No ocx.jsonc found. Run 'ocx init' first.");
         process.exit(1);
       }
-      if (config.lockRegistries) {
+      if (config2.lockRegistries) {
         logger.error("Registries are locked. Cannot remove.");
         process.exit(1);
       }
-      if (!config.registries[name]) {
+      if (!config2.registries[name]) {
         logger.warn(`Registry '${name}' not found.`);
         return;
       }
-      delete config.registries[name];
-      await writeOcxConfig(options2.cwd, config);
+      delete config2.registries[name];
+      await writeOcxConfig(options2.cwd, config2);
       if (options2.json) {
         outputJson({ success: true, data: { removed: name } });
       } else {
@@ -13529,14 +13361,14 @@ function registerRegistryCommand(program2) {
       handleError(error);
     }
   });
-  registry.command("list").description("List configured registries").option("--cwd <path>", "Working directory", process.cwd()).option("--json", "Output as JSON", false).option("-q, --quiet", "Suppress output", false).action(async (options2) => {
+  registry2.command("list").description("List configured registries").option("--cwd <path>", "Working directory", process.cwd()).option("--json", "Output as JSON", false).option("-q, --quiet", "Suppress output", false).action(async (options2) => {
     try {
-      const config = await readOcxConfig(options2.cwd);
-      if (!config) {
+      const config2 = await readOcxConfig(options2.cwd);
+      if (!config2) {
         logger.warn("No ocx.jsonc found. Run 'ocx init' first.");
         return;
       }
-      const registries = Object.entries(config.registries).map(([name, cfg]) => ({
+      const registries = Object.entries(config2.registries).map(([name, cfg]) => ({
         name,
         url: cfg.url,
         version: cfg.version || "latest"
@@ -13546,14 +13378,14 @@ function registerRegistryCommand(program2) {
           success: true,
           data: {
             registries,
-            locked: config.lockRegistries
+            locked: config2.lockRegistries
           }
         });
       } else {
         if (registries.length === 0) {
           logger.info("No registries configured.");
         } else {
-          logger.info(`Configured registries${config.lockRegistries ? kleur_default.yellow(" (locked)") : ""}:`);
+          logger.info(`Configured registries${config2.lockRegistries ? kleur_default.yellow(" (locked)") : ""}:`);
           for (const reg of registries) {
             console.log(`  ${kleur_default.cyan(reg.name)}: ${reg.url} ${kleur_default.dim(`(${reg.version})`)}`);
           }
@@ -13597,13 +13429,13 @@ function registerSearchCommand(program2) {
         }
         return;
       }
-      const config = await readOcxConfig(options2.cwd);
-      if (!config) {
+      const config2 = await readOcxConfig(options2.cwd);
+      if (!config2) {
         logger.warn("No ocx.jsonc found. Run 'ocx init' first.");
         return;
       }
       if (options2.verbose) {
-        logger.info(`Searching in ${Object.keys(config.registries).length} registries...`);
+        logger.info(`Searching in ${Object.keys(config2.registries).length} registries...`);
       }
       const allComponents = [];
       const spinner2 = createSpinner({
@@ -13613,7 +13445,7 @@ function registerSearchCommand(program2) {
       if (!options2.json && !options2.verbose) {
         spinner2.start();
       }
-      for (const [registryName, registryConfig] of Object.entries(config.registries)) {
+      for (const [registryName, registryConfig] of Object.entries(config2.registries)) {
         try {
           if (options2.verbose) {
             logger.info(`Fetching index from ${registryName} (${registryConfig.url})...`);
@@ -13668,7 +13500,7 @@ function registerSearchCommand(program2) {
 }
 
 // src/index.ts
-var version = "1.0.10";
+var version = "1.0.12";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version);
   registerInitCommand(program2);
@@ -13683,4 +13515,4 @@ main2().catch((err) => {
   handleError(err);
 });
 
-//# debugId=D9C733580818864264756E2164756E21
+//# debugId=12A4C4DB6A9FC8A464756E2164756E21