ocx 1.0.14 → 1.0.16

package/dist/index.js

@@ -8492,7 +8492,7 @@ var openCodeNameSchema = exports_external.string().min(1, "Name cannot be empty"
 });
 var namespaceSchema = openCodeNameSchema;
 var qualifiedComponentSchema = exports_external.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*\/[a-z0-9]+(-[a-z0-9]+)*$/, {
-  message: 'Must be in format "namespace/component" (e.g., "kdco/librarian"). Both parts must be lowercase alphanumeric with hyphens.'
+  message: 'Must be in format "namespace/component" (e.g., "kdco/researcher"). Both parts must be lowercase alphanumeric with hyphens.'
 });
 function parseQualifiedComponent(ref) {
   if (!ref.includes("/")) {
@@ -8533,14 +8533,19 @@ 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 oauthConfigSchema = exports_external.object({
+  clientId: exports_external.string().optional(),
+  scopes: exports_external.array(exports_external.string()).optional(),
+  authUrl: exports_external.string().optional(),
+  tokenUrl: exports_external.string().optional()
+});
 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(),
+  url: exports_external.string().optional(),
+  command: exports_external.union([exports_external.string(), 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(),
+  oauth: exports_external.union([exports_external.boolean(), oauthConfigSchema]).optional(),
   enabled: exports_external.boolean().default(true)
 }).refine((data) => {
   if (data.type === "remote" && !data.url) {
@@ -8553,7 +8558,7 @@ var mcpServerObjectSchema = exports_external.object({
 }, {
   message: "Remote MCP servers require 'url', local servers require 'command'"
 });
-var mcpServerRefSchema = exports_external.union([exports_external.string().url(), mcpServerObjectSchema]);
+var mcpServerRefSchema = exports_external.union([exports_external.string(), mcpServerObjectSchema]);
 var componentFileObjectSchema = exports_external.object({
   path: exports_external.string().min(1, "File path cannot be empty"),
   target: targetPathSchema
@@ -8562,24 +8567,81 @@ var componentFileSchema = exports_external.union([
   exports_external.string().min(1, "File path cannot be empty"),
   componentFileObjectSchema
 ]);
+var providerConfigSchema = exports_external.object({
+  api: exports_external.string().optional(),
+  headers: exports_external.record(exports_external.string()).optional(),
+  env: exports_external.record(exports_external.string()).optional(),
+  enabled: exports_external.boolean().optional()
+}).passthrough();
+var lspConfigSchema = exports_external.object({
+  command: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+  enabled: exports_external.boolean().optional()
+}).passthrough();
+var formatterConfigSchema = exports_external.object({
+  command: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+  glob: exports_external.string().optional()
+}).passthrough();
+var commandConfigSchema = exports_external.object({
+  description: exports_external.string().optional(),
+  run: exports_external.string().optional()
+}).passthrough();
+var tuiConfigSchema = exports_external.object({
+  disabled: exports_external.boolean().optional()
+}).passthrough();
+var serverConfigSchema = exports_external.object({
+  host: exports_external.string().optional(),
+  port: exports_external.number().optional()
+}).passthrough();
+var keybindConfigSchema = exports_external.record(exports_external.string());
+var watcherConfigSchema = exports_external.object({
+  include: exports_external.array(exports_external.string()).optional(),
+  exclude: exports_external.array(exports_external.string()).optional()
+}).passthrough();
 var agentConfigSchema = exports_external.object({
+  model: exports_external.string().optional(),
+  description: exports_external.string().optional(),
+  steps: exports_external.number().int().positive().optional(),
+  maxSteps: exports_external.number().int().positive().optional(),
+  mode: exports_external.enum(["primary", "subagent", "all"]).optional(),
   tools: exports_external.record(exports_external.boolean()).optional(),
-  temperature: exports_external.number().min(0).max(2).optional(),
+  temperature: exports_external.number().optional(),
+  top_p: exports_external.number().optional(),
   prompt: exports_external.string().optional(),
-  permission: exports_external.record(exports_external.enum(["allow", "deny"])).optional()
+  permission: exports_external.record(exports_external.union([exports_external.enum(["ask", "allow", "deny"]), exports_external.record(exports_external.enum(["ask", "allow", "deny"]))])).optional(),
+  color: exports_external.string().optional(),
+  disable: exports_external.boolean().optional(),
+  options: exports_external.record(exports_external.any()).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()
-});
+}).catchall(exports_external.union([exports_external.enum(["ask", "allow", "deny"]), exports_external.record(exports_external.enum(["ask", "allow", "deny"]))]));
 var opencodeConfigSchema = exports_external.object({
+  $schema: exports_external.string().optional(),
+  theme: exports_external.string().optional(),
+  logLevel: exports_external.string().optional(),
+  username: exports_external.string().optional(),
+  model: exports_external.string().optional(),
+  small_model: exports_external.string().optional(),
+  default_agent: 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(),
-  permission: permissionConfigSchema.optional()
+  permission: permissionConfigSchema.optional(),
+  provider: exports_external.record(providerConfigSchema).optional(),
+  lsp: exports_external.record(lspConfigSchema).optional(),
+  formatter: exports_external.record(formatterConfigSchema).optional(),
+  command: exports_external.record(commandConfigSchema).optional(),
+  tui: tuiConfigSchema.optional(),
+  server: serverConfigSchema.optional(),
+  keybind: keybindConfigSchema.optional(),
+  watcher: watcherConfigSchema.optional(),
+  auto_update: exports_external.boolean().optional(),
+  auto_compact: exports_external.boolean().optional(),
+  share: exports_external.union([exports_external.boolean(), exports_external.string()]).optional()
 });
 var componentManifestSchema = exports_external.object({
   name: openCodeNameSchema,
@@ -8734,7 +8796,7 @@ class IntegrityError extends OCXError {
 ` + `  Found:    ${found}
 
 ` + `The registry content has changed since this component was locked.
-` + `This could indicate tampering or an unauthorized update.`;
+` + `Use 'ocx update ${component}' to intentionally update this component.`;
     super(message, "INTEGRITY_ERROR", EXIT_CODES.INTEGRITY);
     this.name = "IntegrityError";
   }
@@ -8773,23 +8835,31 @@ async function fetchRegistryIndex(baseUrl) {
   });
 }
 async function fetchComponent(baseUrl, name) {
+  const result = await fetchComponentVersion(baseUrl, name);
+  return result.manifest;
+}
+async function fetchComponentVersion(baseUrl, name, version) {
   const url = `${baseUrl.replace(/\/$/, "")}/components/${name}.json`;
-  return fetchWithCache(url, (data) => {
+  return fetchWithCache(`${url}#v=${version ?? "latest"}`, (data) => {
     const packumentResult = packumentSchema.safeParse(data);
     if (!packumentResult.success) {
       throw new ValidationError(`Invalid packument format for "${name}": ${packumentResult.error.message}`);
     }
     const packument = packumentResult.data;
-    const latestVersion = packument["dist-tags"].latest;
-    const manifest = packument.versions[latestVersion];
+    const resolvedVersion = version ?? packument["dist-tags"].latest;
+    const manifest = packument.versions[resolvedVersion];
     if (!manifest) {
-      throw new ValidationError(`Component "${name}" has no manifest for latest version ${latestVersion}`);
+      if (version) {
+        const availableVersions = Object.keys(packument.versions).join(", ");
+        throw new ValidationError(`Component "${name}" has no version "${version}". Available: ${availableVersions}`);
+      }
+      throw new ValidationError(`Component "${name}" has no manifest for latest version ${resolvedVersion}`);
     }
     const manifestResult = componentManifestSchema.safeParse(manifest);
     if (!manifestResult.success) {
-      throw new ValidationError(`Invalid component manifest for "${name}@${latestVersion}": ${manifestResult.error.message}`);
+      throw new ValidationError(`Invalid component manifest for "${name}@${resolvedVersion}": ${manifestResult.error.message}`);
     }
-    return manifestResult.data;
+    return { manifest: manifestResult.data, version: resolvedVersion };
   });
 }
 async function fetchFileContent(baseUrl, componentName, filePath) {
@@ -10272,7 +10342,8 @@ var installedComponentSchema = exports_external.object({
   version: exports_external.string(),
   hash: exports_external.string(),
   files: exports_external.array(exports_external.string()),
-  installedAt: exports_external.string()
+  installedAt: exports_external.string(),
+  updatedAt: exports_external.string().optional()
 });
 var ocxLockSchema = exports_external.object({
   lockVersion: exports_external.literal(1),
@@ -10339,11 +10410,28 @@ async function readOpencodeJsonConfig(cwd) {
 async function writeOpencodeJsonConfig(path, content) {
   await Bun.write(path, content);
 }
+function getValueAtPath(content, path) {
+  const parsed = parse2(content, [], { allowTrailingComma: true });
+  let current = parsed;
+  for (const segment of path) {
+    if (current === null || current === undefined)
+      return;
+    if (typeof current !== "object")
+      return;
+    current = current[segment];
+  }
+  return current;
+}
 function applyValueAtPath(content, path, value) {
   if (value === null || value === undefined) {
     return content;
   }
   if (typeof value === "object" && !Array.isArray(value)) {
+    const existingValue = getValueAtPath(content, path);
+    if (existingValue !== undefined && (existingValue === null || typeof existingValue !== "object")) {
+      const edits2 = modify(content, path, value, JSONC_OPTIONS);
+      return applyEdits(content, edits2);
+    }
     let updatedContent = content;
     for (const [key, val] of Object.entries(value)) {
       updatedContent = applyValueAtPath(updatedContent, [...path, key], val);
@@ -13635,12 +13723,292 @@ function registerSearchCommand(program2) {
     }
   });
 }
+
+// src/commands/update.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join5 } from "path";
+function registerUpdateCommand(program2) {
+  program2.command("update [components...]").description("Update installed components (use @version suffix to pin, e.g., kdco/agents@1.2.0)").option("--all", "Update all installed components").option("--registry <name>", "Update all components from a specific registry").option("--dry-run", "Preview changes without applying").option("--cwd <path>", "Working directory", process.cwd()).option("-q, --quiet", "Suppress output").option("-v, --verbose", "Verbose output").option("--json", "Output as JSON").action(async (components, options2) => {
+    try {
+      await runUpdate(components, options2);
+    } catch (error) {
+      handleError(error, { json: options2.json });
+    }
+  });
+}
+async function runUpdate(componentNames, options2) {
+  const cwd = options2.cwd ?? process.cwd();
+  const lockPath = join5(cwd, "ocx.lock");
+  const config = await readOcxConfig(cwd);
+  if (!config) {
+    throw new ConfigError("No ocx.jsonc found. Run 'ocx init' first.");
+  }
+  const lock = await readOcxLock(cwd);
+  if (!lock || Object.keys(lock.installed).length === 0) {
+    throw new ConfigError("Nothing installed yet. Run 'ocx add <component>' first.");
+  }
+  const hasComponents = componentNames.length > 0;
+  const hasAll = options2.all === true;
+  const hasRegistry = options2.registry !== undefined;
+  if (!hasComponents && !hasAll && !hasRegistry) {
+    throw new ValidationError(`Specify components, use --all, or use --registry <name>.
+
+` + `Examples:
+` + `  ocx update kdco/agents           # Update specific component
+` + `  ocx update --all                 # Update all installed components
+` + "  ocx update --registry kdco       # Update all from a registry");
+  }
+  if (hasAll && hasComponents) {
+    throw new ValidationError(`Cannot specify components with --all.
+` + "Use either 'ocx update --all' or 'ocx update <components>'.");
+  }
+  if (hasRegistry && hasComponents) {
+    throw new ValidationError(`Cannot specify components with --registry.
+` + "Use either 'ocx update --registry <name>' or 'ocx update <components>'.");
+  }
+  if (hasAll && hasRegistry) {
+    throw new ValidationError(`Cannot use --all with --registry.
+` + "Use either 'ocx update --all' or 'ocx update --registry <name>'.");
+  }
+  const parsedComponents = componentNames.map(parseComponentSpec);
+  for (const spec of parsedComponents) {
+    if (spec.version !== undefined && spec.version === "") {
+      throw new ValidationError(`Invalid version specifier in '${spec.component}@'.` + `
+Version cannot be empty. Use 'kdco/agents@1.2.0' or omit the version for latest.`);
+    }
+  }
+  const componentsToUpdate = resolveComponentsToUpdate(lock, parsedComponents, options2);
+  if (componentsToUpdate.length === 0) {
+    if (hasRegistry) {
+      throw new NotFoundError(`No installed components from registry '${options2.registry}'.`);
+    }
+    throw new NotFoundError("No matching components found to update.");
+  }
+  const spin = options2.quiet ? null : createSpinner({ text: "Checking for updates..." });
+  spin?.start();
+  const results = [];
+  const updates = [];
+  try {
+    for (const spec of componentsToUpdate) {
+      const qualifiedName = spec.component;
+      const lockEntry = lock.installed[qualifiedName];
+      if (!lockEntry) {
+        throw new NotFoundError(`Component '${qualifiedName}' not found in lock file.`);
+      }
+      const { namespace, component: componentName } = parseQualifiedComponent(qualifiedName);
+      const regConfig = config.registries[namespace];
+      if (!regConfig) {
+        throw new ConfigError(`Registry '${namespace}' not configured. Component '${qualifiedName}' cannot be updated.`);
+      }
+      const fetchResult = await fetchComponentVersion(regConfig.url, componentName, spec.version);
+      const manifest = fetchResult.manifest;
+      const version = fetchResult.version;
+      const normalizedManifest = normalizeComponentManifest(manifest);
+      const files = [];
+      for (const file of normalizedManifest.files) {
+        const content2 = await fetchFileContent(regConfig.url, componentName, file.path);
+        files.push({ path: file.path, content: Buffer.from(content2) });
+      }
+      const newHash = await hashBundle2(files);
+      if (newHash === lockEntry.hash) {
+        results.push({
+          qualifiedName,
+          oldVersion: lockEntry.version,
+          newVersion: version,
+          status: "up-to-date"
+        });
+      } else if (options2.dryRun) {
+        results.push({
+          qualifiedName,
+          oldVersion: lockEntry.version,
+          newVersion: version,
+          status: "would-update"
+        });
+      } else {
+        results.push({
+          qualifiedName,
+          oldVersion: lockEntry.version,
+          newVersion: version,
+          status: "updated"
+        });
+        updates.push({
+          qualifiedName,
+          component: normalizedManifest,
+          files,
+          newHash,
+          newVersion: version,
+          baseUrl: regConfig.url
+        });
+      }
+    }
+    spin?.succeed(`Checked ${componentsToUpdate.length} component(s)`);
+    if (options2.dryRun) {
+      outputDryRun(results, options2);
+      return;
+    }
+    if (updates.length === 0) {
+      if (!options2.quiet && !options2.json) {
+        logger.info("");
+        logger.success("All components are up to date.");
+      }
+      if (options2.json) {
+        console.log(JSON.stringify({ success: true, updated: [], upToDate: results }, null, 2));
+      }
+      return;
+    }
+    const installSpin = options2.quiet ? null : createSpinner({ text: "Updating components..." });
+    installSpin?.start();
+    for (const update of updates) {
+      for (const file of update.files) {
+        const fileObj = update.component.files.find((f) => f.path === file.path);
+        if (!fileObj)
+          continue;
+        const targetPath = join5(cwd, fileObj.target);
+        const targetDir = dirname3(targetPath);
+        if (!existsSync3(targetDir)) {
+          await mkdir4(targetDir, { recursive: true });
+        }
+        await writeFile3(targetPath, file.content);
+        if (options2.verbose) {
+          logger.info(`  \u2713 Updated ${fileObj.target}`);
+        }
+      }
+      const existingEntry = lock.installed[update.qualifiedName];
+      if (!existingEntry) {
+        throw new NotFoundError(`Component '${update.qualifiedName}' not found in lock file.`);
+      }
+      lock.installed[update.qualifiedName] = {
+        registry: existingEntry.registry,
+        version: update.newVersion,
+        hash: update.newHash,
+        files: existingEntry.files,
+        installedAt: existingEntry.installedAt,
+        updatedAt: new Date().toISOString()
+      };
+    }
+    installSpin?.succeed(`Updated ${updates.length} component(s)`);
+    await writeFile3(lockPath, JSON.stringify(lock, null, 2), "utf-8");
+    if (options2.json) {
+      console.log(JSON.stringify({
+        success: true,
+        updated: results.filter((r2) => r2.status === "updated"),
+        upToDate: results.filter((r2) => r2.status === "up-to-date")
+      }, null, 2));
+    } else if (!options2.quiet) {
+      logger.info("");
+      for (const result of results) {
+        if (result.status === "updated") {
+          logger.info(`  \u2713 ${result.qualifiedName} (${result.oldVersion} \u2192 ${result.newVersion})`);
+        } else if (result.status === "up-to-date" && options2.verbose) {
+          logger.info(`  \u25CB ${result.qualifiedName} (already up to date)`);
+        }
+      }
+      logger.info("");
+      logger.success(`Done! Updated ${updates.length} component(s).`);
+    }
+  } catch (error) {
+    spin?.fail("Failed to check for updates");
+    throw error;
+  }
+}
+function parseComponentSpec(spec) {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex <= 0) {
+    return { component: spec };
+  }
+  return {
+    component: spec.slice(0, atIndex),
+    version: spec.slice(atIndex + 1)
+  };
+}
+function resolveComponentsToUpdate(lock, parsedComponents, options2) {
+  const installedComponents = Object.keys(lock.installed);
+  if (options2.all) {
+    return installedComponents.map((c) => ({ component: c }));
+  }
+  if (options2.registry) {
+    return installedComponents.filter((name) => {
+      const entry = lock.installed[name];
+      return entry?.registry === options2.registry;
+    }).map((c) => ({ component: c }));
+  }
+  const result = [];
+  for (const spec of parsedComponents) {
+    const name = spec.component;
+    if (!name.includes("/")) {
+      const suggestions = installedComponents.filter((installed) => installed.endsWith(`/${name}`));
+      if (suggestions.length === 1) {
+        throw new ValidationError(`Ambiguous component '${name}'. Did you mean '${suggestions[0]}'?`);
+      }
+      if (suggestions.length > 1) {
+        throw new ValidationError(`Ambiguous component '${name}'. Found in multiple registries:
+` + suggestions.map((s) => `  - ${s}`).join(`
+`) + `
+
+Please use a fully qualified name (registry/component).`);
+      }
+      throw new ValidationError(`Component '${name}' must include a registry prefix (e.g., 'kdco/${name}').`);
+    }
+    if (!lock.installed[name]) {
+      throw new NotFoundError(`Component '${name}' is not installed.
+Run 'ocx add ${name}' to install it first.`);
+    }
+    result.push(spec);
+  }
+  return result;
+}
+function outputDryRun(results, options2) {
+  const wouldUpdate = results.filter((r2) => r2.status === "would-update");
+  const upToDate = results.filter((r2) => r2.status === "up-to-date");
+  if (options2.json) {
+    console.log(JSON.stringify({ dryRun: true, wouldUpdate, upToDate }, null, 2));
+    return;
+  }
+  if (!options2.quiet) {
+    logger.info("");
+    if (wouldUpdate.length > 0) {
+      logger.info("Would update:");
+      for (const result of wouldUpdate) {
+        logger.info(`  ${result.qualifiedName} (${result.oldVersion} \u2192 ${result.newVersion})`);
+      }
+    }
+    if (upToDate.length > 0 && options2.verbose) {
+      logger.info("");
+      logger.info("Already up to date:");
+      for (const result of upToDate) {
+        logger.info(`  ${result.qualifiedName}`);
+      }
+    }
+    if (wouldUpdate.length > 0) {
+      logger.info("");
+      logger.info("Run without --dry-run to apply changes.");
+    } else {
+      logger.info("All components are up to date.");
+    }
+  }
+}
+async function hashContent2(content2) {
+  return createHash2("sha256").update(content2).digest("hex");
+}
+async function hashBundle2(files) {
+  const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+  const manifestParts = [];
+  for (const file of sorted) {
+    const hash = await hashContent2(file.content);
+    manifestParts.push(`${file.path}:${hash}`);
+  }
+  return hashContent2(manifestParts.join(`
+`));
+}
 // src/index.ts
-var version = "1.0.14";
+var version = "1.0.16";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version);
   registerInitCommand(program2);
   registerAddCommand(program2);
+  registerUpdateCommand(program2);
   registerDiffCommand(program2);
   registerSearchCommand(program2);
   registerRegistryCommand(program2);
@@ -13661,4 +14029,4 @@ export {
   buildRegistry
 };
 
-//# debugId=8679B4448163A59C64756E2164756E21
+//# debugId=2706150244B1090964756E2164756E21