ocx 1.0.14 → 1.0.15

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("/")) {
@@ -8734,7 +8734,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 +8773,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 +10280,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),
@@ -13635,12 +13644,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.15";
 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 +13950,4 @@ export {
   buildRegistry
 };
 
-//# debugId=8679B4448163A59C64756E2164756E21
+//# debugId=0C10B0E363D77B8C64756E2164756E21