ocx 1.0.13 → 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),
@@ -13266,7 +13275,7 @@ Diff for ${res.name}:`));
 
 // src/commands/init.ts
 import { existsSync as existsSync2 } from "fs";
-import { writeFile as writeFile2 } from "fs/promises";
+import { cp, mkdir as mkdir3, readdir, readFile, rm, writeFile as writeFile2 } from "fs/promises";
 import { join as join4 } from "path";
 
 // src/constants.ts
@@ -13274,10 +13283,16 @@ var OCX_DOMAIN = "ocx.kdco.dev";
 var OCX_SCHEMA_URL = `https://${OCX_DOMAIN}/schema.json`;
 
 // src/commands/init.ts
+var TEMPLATE_REPO = "kdcokenny/ocx";
+var TEMPLATE_PATH = "examples/registry-starter";
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize OCX configuration in your project").option("-y, --yes", "Skip prompts and use defaults").option("--cwd <path>", "Working directory", process.cwd()).option("-q, --quiet", "Suppress output").option("-v, --verbose", "Verbose output").option("--json", "Output as JSON").action(async (options2) => {
+  program2.command("init [directory]").description("Initialize OCX configuration in your project").option("-y, --yes", "Skip prompts and use defaults").option("--cwd <path>", "Working directory", process.cwd()).option("-q, --quiet", "Suppress output").option("-v, --verbose", "Verbose output").option("--json", "Output as JSON").option("--registry", "Scaffold a new OCX registry project").option("--namespace <name>", "Registry namespace (e.g., my-org)").option("--author <name>", "Author name for the registry").option("--canary", "Use canary (main branch) instead of latest release").option("--local <path>", "Use local template directory instead of fetching").action(async (directory, options2) => {
     try {
-      await runInit(options2);
+      if (options2.registry) {
+        await runInitRegistry(directory, options2);
+      } else {
+        await runInit(options2);
+      }
     } catch (error) {
       handleError(error, { json: options2.json });
     }
@@ -13322,6 +13337,116 @@ async function runInit(options2) {
     throw error;
   }
 }
+async function runInitRegistry(directory, options2) {
+  const cwd = directory ?? options2.cwd ?? process.cwd();
+  const namespace = options2.namespace ?? "my-registry";
+  const author = options2.author ?? "Your Name";
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(namespace)) {
+    throw new ValidationError("Invalid namespace format: must start with letter/number, use hyphens only between segments (e.g., 'my-registry')");
+  }
+  const existingFiles = await readdir(cwd).catch(() => []);
+  const hasVisibleFiles = existingFiles.some((f) => !f.startsWith("."));
+  if (hasVisibleFiles && !options2.yes) {
+    throw new ConflictError("Directory is not empty. Use --yes to overwrite existing files.");
+  }
+  const spin = options2.quiet ? null : createSpinner({ text: "Scaffolding registry..." });
+  spin?.start();
+  try {
+    if (spin)
+      spin.text = options2.local ? "Copying template..." : "Fetching template...";
+    if (options2.local) {
+      await mkdir3(cwd, { recursive: true });
+      await copyDir(options2.local, cwd);
+    } else {
+      const version = options2.canary ? "main" : await getLatestVersion();
+      await fetchAndExtractTemplate(cwd, version, options2.verbose);
+    }
+    if (spin)
+      spin.text = "Configuring project...";
+    await replacePlaceholders(cwd, { namespace, author });
+    spin?.succeed(`Created registry: ${namespace}`);
+    if (options2.json) {
+      console.log(JSON.stringify({ success: true, namespace, path: cwd }));
+    } else if (!options2.quiet) {
+      logger.info("");
+      logger.info("Next steps:");
+      logger.info("  1. bun install");
+      logger.info("  2. Edit registry.json with your components");
+      logger.info("  3. bun run build");
+      logger.info("");
+      logger.info("Deploy to:");
+      logger.info("  Cloudflare: bunx wrangler deploy");
+      logger.info("  Vercel:     vercel");
+      logger.info("  Netlify:    netlify deploy");
+    }
+  } catch (error) {
+    spin?.fail("Failed to scaffold registry");
+    throw error;
+  }
+}
+async function copyDir(src, dest) {
+  await cp(src, dest, { recursive: true });
+}
+async function getLatestVersion() {
+  const pkgPath = new URL("../../package.json", import.meta.url);
+  const pkgContent = await readFile(pkgPath);
+  const pkg = JSON.parse(pkgContent.toString());
+  return `v${pkg.version}`;
+}
+async function fetchAndExtractTemplate(destDir, version, verbose) {
+  const ref = version === "main" ? "heads/main" : `tags/${version}`;
+  const tarballUrl = `https://github.com/${TEMPLATE_REPO}/archive/refs/${ref}.tar.gz`;
+  if (verbose) {
+    logger.info(`Fetching ${tarballUrl}`);
+  }
+  const response = await fetch(tarballUrl);
+  if (!response.ok || !response.body) {
+    throw new NetworkError(`Failed to fetch template from ${tarballUrl}: ${response.statusText}`);
+  }
+  const tempDir = join4(destDir, ".ocx-temp");
+  await mkdir3(tempDir, { recursive: true });
+  try {
+    const tarPath = join4(tempDir, "template.tar.gz");
+    const arrayBuffer = await response.arrayBuffer();
+    await writeFile2(tarPath, Buffer.from(arrayBuffer));
+    const proc = Bun.spawn(["tar", "-xzf", tarPath, "-C", tempDir], {
+      stdout: "ignore",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      throw new Error(`Failed to extract template: ${stderr}`);
+    }
+    const extractedDirs = await readdir(tempDir);
+    const extractedDir = extractedDirs.find((d) => d.startsWith("ocx-"));
+    if (!extractedDir) {
+      throw new Error("Failed to find extracted template directory");
+    }
+    const templateDir = join4(tempDir, extractedDir, TEMPLATE_PATH);
+    await copyDir(templateDir, destDir);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+async function replacePlaceholders(dir, values) {
+  const filesToProcess = [
+    "registry.json",
+    "package.json",
+    "wrangler.jsonc",
+    "README.md",
+    "AGENTS.md"
+  ];
+  for (const file of filesToProcess) {
+    const filePath = join4(dir, file);
+    if (!existsSync2(filePath))
+      continue;
+    let content2 = await readFile(filePath).then((b) => b.toString());
+    content2 = content2.replace(/my-registry/g, values.namespace);
+    content2 = content2.replace(/Your Name/g, values.author);
+    await writeFile2(filePath, content2);
+  }
+}
 
 // src/commands/registry.ts
 function registerRegistryCommand(program2) {
@@ -13519,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.13";
+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);
@@ -13545,4 +13950,4 @@ export {
   buildRegistry
 };
 
-//# debugId=2D4B3AD90B25BFD964756E2164756E21
+//# debugId=0C10B0E363D77B8C64756E2164756E21