@agent-nexus/csreg 0.1.0

package/dist/index.js

@@ -0,0 +1,1179 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command12 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import { input } from "@inquirer/prompts";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".config", "csreg");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function getConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function setConfig(updates) {
+  const current = getConfig();
+  const merged = { ...current, ...updates };
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+}
+function getApiUrl() {
+  return process.env.CSREG_API_URL ?? getConfig().apiUrl ?? "http://localhost:3000";
+}
+function getAuthToken() {
+  return process.env.CSREG_TOKEN ?? getConfig().token;
+}
+
+// src/lib/errors.ts
+import chalk from "chalk";
+var CliError = class extends Error {
+  suggestions;
+  constructor(message, suggestions = []) {
+    super(message);
+    this.name = "CliError";
+    this.suggestions = suggestions;
+  }
+};
+function handleError(err) {
+  if (err instanceof CliError) {
+    console.error(chalk.red("Error:") + " " + err.message);
+    if (err.suggestions.length > 0) {
+      console.error("");
+      console.error(chalk.yellow("Suggestions:"));
+      for (const suggestion of err.suggestions) {
+        console.error("  " + chalk.dim("-") + " " + suggestion);
+      }
+    }
+  } else if (err instanceof Error) {
+    console.error(chalk.red("Error:") + " " + err.message);
+  } else {
+    console.error(chalk.red("Error:") + " " + String(err));
+  }
+  process.exit(1);
+}
+
+// src/api-client.ts
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 500;
+var ApiClient = class {
+  baseUrl;
+  token;
+  constructor() {
+    this.baseUrl = getApiUrl();
+    this.token = getAuthToken();
+  }
+  buildUrl(path, query) {
+    const url = new URL(path, this.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(extra) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...extra
+    };
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    return headers;
+  }
+  async handleResponse(response) {
+    if (response.ok) {
+      if (response.status === 204) {
+        return void 0;
+      }
+      return response.json();
+    }
+    let errorBody;
+    try {
+      errorBody = await response.json();
+    } catch {
+    }
+    const detail = errorBody?.detail ?? response.statusText;
+    const title = errorBody?.title ?? `HTTP ${response.status}`;
+    const suggestions = [];
+    if (response.status === 401) {
+      suggestions.push("Run `csreg login` to authenticate.");
+    } else if (response.status === 403) {
+      suggestions.push("You may not have permission for this action.");
+    } else if (response.status === 404) {
+      suggestions.push("Check that the skill name and scope are correct.");
+    }
+    throw new CliError(`${title}: ${detail}`, suggestions);
+  }
+  async requestWithRetry(method, path, opts) {
+    const url = this.buildUrl(path, opts?.query);
+    const headers = this.buildHeaders(opts?.headers);
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0
+        });
+        if (response.status >= 500 && attempt < MAX_RETRIES - 1) {
+          const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+          await new Promise((resolve7) => setTimeout(resolve7, delay));
+          continue;
+        }
+        return await this.handleResponse(response);
+      } catch (error2) {
+        lastError = error2;
+        if (error2 instanceof CliError) {
+          throw error2;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+          await new Promise((resolve7) => setTimeout(resolve7, delay));
+          continue;
+        }
+      }
+    }
+    throw lastError instanceof CliError ? lastError : new CliError(`Request failed: ${String(lastError)}`, [
+      "Check your internet connection.",
+      "The API server may be unavailable."
+    ]);
+  }
+  async get(path, opts) {
+    return this.requestWithRetry("GET", path, opts);
+  }
+  async post(path, opts) {
+    return this.requestWithRetry("POST", path, opts);
+  }
+  async put(path, opts) {
+    return this.requestWithRetry("PUT", path, opts);
+  }
+  async patch(path, opts) {
+    return this.requestWithRetry("PATCH", path, opts);
+  }
+  async delete(path, opts) {
+    return this.requestWithRetry("DELETE", path, opts);
+  }
+};
+
+// src/lib/output.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import Table from "cli-table3";
+function formatTable(headers, rows) {
+  const table = new Table({
+    head: headers.map((h) => chalk2.bold.cyan(h)),
+    style: { head: [], border: [] }
+  });
+  for (const row of rows) {
+    table.push(row);
+  }
+  return table.toString();
+}
+function spinner(text) {
+  return ora({ text, color: "cyan" }).start();
+}
+function success(msg) {
+  console.log(chalk2.green("\u2713") + " " + msg);
+}
+function error(msg) {
+  console.error(chalk2.red("\u2717") + " " + msg);
+}
+function warn(msg) {
+  console.log(chalk2.yellow("!") + " " + msg);
+}
+function info(msg) {
+  console.log(chalk2.blue("i") + " " + msg);
+}
+
+// src/commands/login.ts
+var loginCommand = new Command("login").description("Authenticate with the Skills Registry").option("--token <token>", "Provide auth token directly").action(async (opts) => {
+  try {
+    let token = opts.token;
+    if (!token) {
+      const apiUrl = getApiUrl();
+      info(`Open this URL to authenticate:`);
+      console.log(`  ${apiUrl}/cli/auth`);
+      console.log("");
+      token = await input({
+        message: "Paste your auth token:",
+        validate: (value) => {
+          if (!value.trim()) return "Token is required.";
+          return true;
+        }
+      });
+      token = token.trim();
+    }
+    setConfig({ token });
+    const client = new ApiClient();
+    const user = await client.get(
+      "/api/v1/users/me"
+    );
+    success(`Logged in as ${user.displayName} (${user.email})`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+var logoutCommand = new Command2("logout").description("Remove stored authentication credentials").action(async () => {
+  try {
+    setConfig({ token: void 0 });
+    success("Logged out successfully.");
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/whoami.ts
+import { Command as Command3 } from "commander";
+var whoamiCommand = new Command3("whoami").description("Display the currently authenticated user").action(async () => {
+  try {
+    if (!getAuthToken()) {
+      throw new CliError("Not logged in.", ["Run `csreg login` to authenticate."]);
+    }
+    const client = new ApiClient();
+    const user = await client.get(
+      "/api/v1/users/me"
+    );
+    success(`Logged in as ${user.displayName} (${user.email})`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command4 } from "commander";
+import { input as input2, confirm } from "@inquirer/prompts";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2, resolve } from "path";
+var initCommand = new Command4("init").description("Initialize a new skill project").argument("[dir]", "Directory to initialize the skill in").action(async (dir) => {
+  try {
+    const name = await input2({
+      message: "Skill name:",
+      validate: (value) => {
+        if (!value.trim()) return "Name is required.";
+        if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(value.trim())) {
+          return "Must be lowercase alphanumeric with hyphens (e.g., my-skill).";
+        }
+        if (value.trim().length > 64) {
+          return "Name must be at most 64 characters.";
+        }
+        if (value.includes("--")) {
+          return "Name must not contain consecutive hyphens (--).";
+        }
+        return true;
+      }
+    });
+    const description = await input2({
+      message: "Description (what this skill does and when to use it):",
+      validate: (value) => {
+        if (!value.trim()) return "Description is required \u2014 Claude uses it to decide when to invoke the skill.";
+        return true;
+      }
+    });
+    const scope = await input2({
+      message: "Scope (your team/username, for registry publishing):",
+      validate: (value) => {
+        if (!value.trim()) return "Scope is required for publishing.";
+        return true;
+      }
+    });
+    const userInvocable = await confirm({
+      message: "User-invocable (show in /slash command menu)?",
+      default: true
+    });
+    const targetDir = resolve(dir ?? name.trim());
+    if (existsSync2(targetDir)) {
+      throw new CliError(`Directory already exists: ${targetDir}`, [
+        "Choose a different name or directory."
+      ]);
+    }
+    mkdirSync2(targetDir, { recursive: true });
+    const frontmatterLines = [
+      "---",
+      `name: ${name.trim()}`,
+      `description: ${description.trim()}`,
+      `version: "0.1.0"`,
+      `scope: ${scope.trim()}`
+    ];
+    if (!userInvocable) {
+      frontmatterLines.push("user-invocable: false");
+    }
+    frontmatterLines.push("---");
+    const skillContent = `${frontmatterLines.join("\n")}
+
+# ${name.trim()}
+
+${description.trim()}
+
+## Instructions
+
+Add your skill instructions here. This is the prompt that Claude will follow
+when this skill is invoked.
+
+You can use \`$ARGUMENTS\` to reference arguments passed by the user.
+For example: \`/my-skill some-argument\` makes \`$ARGUMENTS\` = "some-argument".
+`;
+    writeFileSync2(
+      join2(targetDir, "SKILL.md"),
+      skillContent,
+      "utf-8"
+    );
+    console.log("");
+    success(`Created skill "${scope.trim()}/${name.trim()}" in ${targetDir}`);
+    info("Files created:");
+    console.log("  - SKILL.md");
+    console.log("");
+    info("Next steps:");
+    console.log("  1. Edit SKILL.md with your skill instructions");
+    console.log("  2. Run `csreg validate` to check your skill");
+    console.log("  3. Run `csreg push` to publish to the registry");
+    console.log("");
+    info("To use locally without publishing:");
+    console.log(`  cp -r ${targetDir} .claude/skills/${name.trim()}`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/validate.ts
+import { Command as Command5 } from "commander";
+import { resolve as resolve3, join as join5, basename } from "path";
+import { existsSync as existsSync5, statSync, readdirSync as readdirSync2 } from "fs";
+
+// src/lib/manifest.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { parse as parseYaml } from "yaml";
+var SKILL_FILE = "SKILL.md";
+function parseManifest(dir) {
+  const skillPath = join3(dir, SKILL_FILE);
+  if (!existsSync3(skillPath)) {
+    throw new CliError(`No ${SKILL_FILE} found in ${dir}`, [
+      "Run `csreg init` to create a new skill.",
+      "A valid skill requires a SKILL.md file with YAML frontmatter."
+    ]);
+  }
+  const raw = readFileSync2(skillPath, "utf-8");
+  const frontmatterMatch = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    throw new CliError(`${SKILL_FILE} is missing YAML frontmatter.`, [
+      "SKILL.md must start with --- delimited YAML frontmatter.",
+      "Example:\n  ---\n  name: my-skill\n  description: Does something\n  ---\n  \n  Your instructions here."
+    ]);
+  }
+  const [, frontmatterRaw, body] = frontmatterMatch;
+  let parsed;
+  try {
+    parsed = parseYaml(frontmatterRaw);
+  } catch (err) {
+    throw new CliError(`Failed to parse ${SKILL_FILE} frontmatter: ${String(err)}`, [
+      "Check that the YAML between --- delimiters is valid."
+    ]);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new CliError(`${SKILL_FILE} frontmatter is empty or not an object.`, [
+      'Add at least a "name" and "description" field.'
+    ]);
+  }
+  return { ...parsed, _body: body.trim() };
+}
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest.name || typeof manifest.name !== "string") {
+    errors.push('Missing or invalid "name" field in frontmatter.');
+  } else {
+    if (manifest.name.length > 64) {
+      errors.push('"name" must be at most 64 characters.');
+    }
+    if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(manifest.name)) {
+      errors.push('"name" must be lowercase alphanumeric with hyphens, not starting or ending with a hyphen.');
+    }
+    if (manifest.name.includes("--")) {
+      errors.push('"name" must not contain consecutive hyphens (--).');
+    }
+  }
+  if (!manifest.description || typeof manifest.description !== "string") {
+    errors.push('Missing "description" field. Claude uses this to decide when to invoke the skill.');
+  } else if (manifest.description.length > 1024) {
+    errors.push('"description" must be at most 1024 characters.');
+  }
+  if (manifest.version !== void 0) {
+    const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?(\+[a-zA-Z0-9.]+)?$/;
+    if (!semverRegex.test(manifest.version)) {
+      errors.push('"version" must be valid semver (e.g., 1.0.0).');
+    }
+  }
+  if (manifest.scope !== void 0 && typeof manifest.scope === "string") {
+    if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(manifest.scope)) {
+      errors.push('"scope" must be lowercase alphanumeric with hyphens.');
+    }
+  }
+  if (manifest["allowed-tools"] !== void 0 && typeof manifest["allowed-tools"] !== "string") {
+    errors.push('"allowed-tools" must be a string (space-delimited list of tools).');
+  }
+  if (manifest["disable-model-invocation"] !== void 0 && typeof manifest["disable-model-invocation"] !== "boolean") {
+    errors.push('"disable-model-invocation" must be a boolean.');
+  }
+  if (manifest["user-invocable"] !== void 0 && typeof manifest["user-invocable"] !== "boolean") {
+    errors.push('"user-invocable" must be a boolean.');
+  }
+  return errors;
+}
+
+// src/lib/discovery.ts
+import { resolve as resolve2, join as join4, dirname } from "path";
+import { existsSync as existsSync4, readdirSync } from "fs";
+function findClaudeSkillsDir() {
+  let dir = resolve2(".");
+  const parts = dir.split("/");
+  const claudeIdx = parts.lastIndexOf(".claude");
+  if (claudeIdx >= 0) {
+    const claudeRoot = parts.slice(0, claudeIdx + 1).join("/");
+    return join4(claudeRoot, "skills");
+  }
+  while (dir !== dirname(dir)) {
+    const claudeDir = join4(dir, ".claude");
+    if (existsSync4(claudeDir)) {
+      return join4(claudeDir, "skills");
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+function discoverSkillDirs(parentDir) {
+  if (!existsSync4(parentDir)) return [];
+  const dirs = [];
+  const entries = readdirSync(parentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".")) continue;
+    const skillMd = join4(parentDir, entry.name, "SKILL.md");
+    if (existsSync4(skillMd)) {
+      dirs.push(join4(parentDir, entry.name));
+    }
+  }
+  return dirs.sort();
+}
+
+// src/commands/validate.ts
+var MAX_FILE_COUNT = 100;
+var MAX_FILE_SIZE = 500 * 1024;
+var MAX_TOTAL_SIZE = 2 * 1024 * 1024;
+function collectFiles(dir, prefix = "") {
+  const files = [];
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const fullPath = join5(dir, entry.name);
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath, relativePath));
+    } else {
+      const stat = statSync(fullPath);
+      files.push({ path: relativePath, size: stat.size });
+    }
+  }
+  return files;
+}
+function runValidation(dir) {
+  const errors = [];
+  const warnings = [];
+  if (!existsSync5(join5(dir, "SKILL.md"))) {
+    errors.push("Missing SKILL.md \u2014 every skill must have a SKILL.md file with YAML frontmatter.");
+    return { valid: false, errors, warnings };
+  }
+  const manifest = parseManifest(dir);
+  const manifestErrors = validateManifest(manifest);
+  errors.push(...manifestErrors);
+  if (!manifest._body) {
+    warnings.push("SKILL.md has no instructions body after the frontmatter. Add skill instructions below the --- delimiter.");
+  }
+  if (!manifest.version) {
+    warnings.push('No "version" in frontmatter. Required for publishing to the registry (e.g., version: "1.0.0").');
+  }
+  if (!manifest.scope) {
+    warnings.push('No "scope" in frontmatter. Required for publishing to the registry (e.g., scope: my-team).');
+  }
+  const dirName = dir.split("/").pop();
+  if (manifest.name && dirName && dirName !== manifest.name) {
+    warnings.push(`Directory name "${dirName}" doesn't match skill name "${manifest.name}". They should match per the Agent Skills spec.`);
+  }
+  const files = collectFiles(dir);
+  if (files.length > MAX_FILE_COUNT) {
+    errors.push(`Too many files: ${files.length} (max ${MAX_FILE_COUNT}).`);
+  }
+  let totalSize = 0;
+  for (const file of files) {
+    totalSize += file.size;
+    if (file.size > MAX_FILE_SIZE) {
+      errors.push(`File too large: ${file.path} (${(file.size / 1024).toFixed(1)}KB, max 500KB).`);
+    }
+  }
+  if (totalSize > MAX_TOTAL_SIZE) {
+    errors.push(`Total size too large: ${(totalSize / 1024 / 1024).toFixed(2)}MB (max 2MB).`);
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+var validateCommand = new Command5("validate").description("Validate a skill package").argument("[dir]", "Skill directory", ".").option("--all", "Validate all skills in .claude/skills/").action(async (dir, opts) => {
+  try {
+    if (opts.all) {
+      const skillsDir = findClaudeSkillsDir();
+      if (!skillsDir) {
+        throw new CliError("Cannot find .claude/skills/ directory.", [
+          "Run this from a project with a .claude/ directory."
+        ]);
+      }
+      const skillDirs = discoverSkillDirs(skillsDir);
+      if (skillDirs.length === 0) {
+        throw new CliError(`No skills found in ${skillsDir}/`, [
+          "Skills must be directories containing a SKILL.md file."
+        ]);
+      }
+      console.log(`Validating ${skillDirs.length} skill(s) in ${skillsDir}/
+`);
+      let passed = 0;
+      let failed = 0;
+      for (const skillDir of skillDirs) {
+        const name = basename(skillDir);
+        const result2 = runValidation(skillDir);
+        if (result2.valid) {
+          success(`${name}`);
+          passed++;
+        } else {
+          error(`${name}`);
+          for (const e of result2.errors) {
+            console.error(`    ${e}`);
+          }
+          failed++;
+        }
+        for (const w of result2.warnings) {
+          warn(`  ${name}: ${w}`);
+        }
+      }
+      console.log("");
+      if (failed === 0) {
+        success(`All ${passed} skill(s) are valid.`);
+      } else {
+        throw new CliError(`${failed}/${passed + failed} skill(s) failed validation.`);
+      }
+      return;
+    }
+    const resolved = resolve3(dir);
+    if (!existsSync5(resolved)) {
+      throw new CliError(`Directory not found: ${resolved}`);
+    }
+    const result = runValidation(resolved);
+    for (const w of result.warnings) {
+      warn(w);
+    }
+    if (result.valid) {
+      success("Skill is valid.");
+    } else {
+      for (const e of result.errors) {
+        error(e);
+      }
+      throw new CliError("Validation failed.", [
+        "Fix the errors above and try again."
+      ]);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/pack.ts
+import { Command as Command6 } from "commander";
+import { resolve as resolve4 } from "path";
+import { existsSync as existsSync6 } from "fs";
+
+// src/lib/archive.ts
+import { statSync as statSync2 } from "fs";
+import { readFile } from "fs/promises";
+import { createHash } from "crypto";
+import { join as join6, basename as basename2 } from "path";
+import { create as tarCreate, extract as tarExtract } from "tar";
+async function computeSha256(filePath) {
+  const data = await readFile(filePath);
+  return createHash("sha256").update(data).digest("hex");
+}
+async function pack(dir, outputPath) {
+  const dirName = basename2(dir);
+  const archivePath = outputPath ?? join6(dir, "..", `${dirName}.tar.gz`);
+  await tarCreate(
+    {
+      gzip: true,
+      file: archivePath,
+      cwd: join6(dir, "..")
+    },
+    [dirName]
+  );
+  const sha256 = await computeSha256(archivePath);
+  const stat = statSync2(archivePath);
+  return {
+    path: archivePath,
+    sha256,
+    size: stat.size
+  };
+}
+async function extract(archivePath, outputDir, expectedSha256) {
+  const actualSha256 = await computeSha256(archivePath);
+  if (actualSha256 !== expectedSha256) {
+    throw new CliError(
+      `SHA-256 mismatch: expected ${expectedSha256}, got ${actualSha256}`,
+      ["The archive may be corrupted or tampered with.", "Try downloading again."]
+    );
+  }
+  await tarExtract({
+    file: archivePath,
+    cwd: outputDir
+  });
+}
+
+// src/commands/pack.ts
+var packCommand = new Command6("pack").description("Pack a skill into a tarball").argument("[dir]", "Skill directory", ".").action(async (dir) => {
+  try {
+    const resolved = resolve4(dir);
+    if (!existsSync6(resolved)) {
+      throw new CliError(`Directory not found: ${resolved}`);
+    }
+    const validation = runValidation(resolved);
+    if (!validation.valid) {
+      for (const e of validation.errors) {
+        console.error(e);
+      }
+      throw new CliError("Validation failed. Fix errors before packing.", [
+        "Run `csreg validate` for details."
+      ]);
+    }
+    const result = await pack(resolved);
+    console.log("");
+    success("Skill packed successfully.");
+    info(`Archive: ${result.path}`);
+    info(`Size: ${(result.size / 1024).toFixed(1)}KB`);
+    info(`SHA-256: ${result.sha256}`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/push.ts
+import { Command as Command7 } from "commander";
+import { resolve as resolve5, join as join7, basename as basename3 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync3, statSync as statSync3, readdirSync as readdirSync3 } from "fs";
+import { createHash as createHash2 } from "crypto";
+function collectFileTree(dir, prefix = "") {
+  const files = [];
+  const entries = readdirSync3(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const fullPath = join7(dir, entry.name);
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...collectFileTree(fullPath, relativePath));
+    } else {
+      const stat = statSync3(fullPath);
+      const content = readFileSync3(fullPath);
+      const sha256 = createHash2("sha256").update(content).digest("hex");
+      files.push({ path: relativePath, size: stat.size, sha256 });
+    }
+  }
+  return files;
+}
+async function pushSingle(resolved) {
+  const spin = spinner("Validating skill...");
+  const validation = runValidation(resolved);
+  if (!validation.valid) {
+    spin.fail("Validation failed.");
+    for (const e of validation.errors) {
+      console.error("  " + e);
+    }
+    throw new CliError("Fix validation errors before pushing.");
+  }
+  spin.succeed("Validation passed.");
+  const manifest = parseManifest(resolved);
+  if (!manifest.version) {
+    throw new CliError('Missing "version" in SKILL.md frontmatter.', [
+      'Add a version field: version: "1.0.0"'
+    ]);
+  }
+  if (!manifest.scope) {
+    throw new CliError('Missing "scope" in SKILL.md frontmatter.', [
+      "Add a scope field: scope: my-team"
+    ]);
+  }
+  spin.start("Packing skill...");
+  const archive = await pack(resolved);
+  spin.succeed(`Packed (${(archive.size / 1024).toFixed(1)}KB).`);
+  const client = new ApiClient();
+  spin.start("Checking registry...");
+  try {
+    await client.get(`/api/v1/skills/${manifest.scope}/${manifest.name}`);
+    spin.succeed("Skill found in registry.");
+  } catch {
+    spin.start(`Creating skill ${manifest.scope}/${manifest.name}...`);
+    await client.post("/api/v1/skills", {
+      body: {
+        scope: manifest.scope,
+        slug: manifest.name,
+        displayName: manifest.name,
+        description: manifest.description || "",
+        tags: manifest.tags || []
+      }
+    });
+    spin.succeed(`Created skill ${manifest.scope}/${manifest.name}.`);
+  }
+  spin.start("Preparing version...");
+  const fileTree = collectFileTree(resolved);
+  const prepared = await client.post(
+    `/api/v1/skills/${manifest.scope}/${manifest.name}/versions`,
+    {
+      body: {
+        version: manifest.version,
+        fileTree,
+        archiveSha256: archive.sha256,
+        archiveSize: archive.size,
+        entryPoint: "SKILL.md",
+        manifestJson: {
+          name: manifest.name,
+          description: manifest.description,
+          version: manifest.version,
+          scope: manifest.scope,
+          "allowed-tools": manifest["allowed-tools"],
+          "argument-hint": manifest["argument-hint"],
+          "disable-model-invocation": manifest["disable-model-invocation"],
+          "user-invocable": manifest["user-invocable"],
+          tags: manifest.tags
+        }
+      }
+    }
+  );
+  spin.succeed("Version prepared.");
+  spin.start("Uploading archive...");
+  const archiveData = readFileSync3(archive.path);
+  const uploadResponse = await fetch(prepared.uploadUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/gzip",
+      "Content-Length": String(archive.size)
+    },
+    body: archiveData
+  });
+  if (!uploadResponse.ok) {
+    spin.fail("Upload failed.");
+    throw new CliError(`Upload failed with status ${uploadResponse.status}.`, [
+      "Try again. If the problem persists, contact support."
+    ]);
+  }
+  spin.succeed("Archive uploaded.");
+  spin.start("Finalizing version...");
+  await client.post(
+    `/api/v1/skills/${manifest.scope}/${manifest.name}/versions/${manifest.version}/finalize`,
+    {
+      body: { status: "published" }
+    }
+  );
+  spin.succeed("Version finalized.");
+  return `${manifest.scope}/${manifest.name}@${manifest.version}`;
+}
+var pushCommand = new Command7("push").description("Publish a skill to the registry").argument("[dir]", "Skill directory", ".").option("--all", "Push all skills in .claude/skills/").action(async (dir, opts) => {
+  try {
+    if (!getAuthToken()) {
+      throw new CliError("Not logged in.", ["Run `csreg login` to authenticate."]);
+    }
+    if (opts.all) {
+      const skillsDir = findClaudeSkillsDir();
+      if (!skillsDir) {
+        throw new CliError("Cannot find .claude/skills/ directory.", [
+          "Run this from a project with a .claude/ directory."
+        ]);
+      }
+      const skillDirs = discoverSkillDirs(skillsDir);
+      if (skillDirs.length === 0) {
+        throw new CliError(`No skills found in ${skillsDir}/`, [
+          "Skills must be directories containing a SKILL.md file."
+        ]);
+      }
+      console.log(`Pushing ${skillDirs.length} skill(s) from ${skillsDir}/
+`);
+      let published = 0;
+      let failed = 0;
+      for (const skillDir of skillDirs) {
+        const name = basename3(skillDir);
+        console.log(`
+--- ${name} ---
+`);
+        try {
+          const ref2 = await pushSingle(skillDir);
+          success(`Published ${ref2}`);
+          published++;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          warn(`Failed to push ${name}: ${msg}`);
+          failed++;
+        }
+      }
+      console.log(`
+${"\u2500".repeat(40)}
+`);
+      if (failed === 0) {
+        success(`All ${published} skill(s) published.`);
+      } else {
+        success(`Published ${published}/${published + failed} skill(s).`);
+        if (failed > 0) {
+          warn(`${failed} skill(s) failed. Check the errors above.`);
+        }
+      }
+      return;
+    }
+    const resolved = resolve5(dir);
+    if (!existsSync7(resolved)) {
+      throw new CliError(`Directory not found: ${resolved}`);
+    }
+    const ref = await pushSingle(resolved);
+    console.log("");
+    success(`Published ${ref}`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/pull.ts
+import { Command as Command8 } from "commander";
+import { resolve as resolve6, join as join8, dirname as dirname2 } from "path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, existsSync as existsSync8, readFileSync as readFileSync4, renameSync } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { confirm as confirm2 } from "@inquirer/prompts";
+function parseSkillRef(ref) {
+  const cleaned = ref.startsWith("@") ? ref.slice(1) : ref;
+  const atIndex = cleaned.lastIndexOf("@");
+  let scopeAndName;
+  let version;
+  if (atIndex > 0) {
+    scopeAndName = cleaned.slice(0, atIndex);
+    version = cleaned.slice(atIndex + 1);
+  } else {
+    scopeAndName = cleaned;
+  }
+  const slashIndex = scopeAndName.indexOf("/");
+  if (slashIndex < 0) {
+    throw new CliError(`Invalid skill reference: ${ref}`, [
+      "Use the format: @scope/name or @scope/name@version"
+    ]);
+  }
+  return {
+    scope: scopeAndName.slice(0, slashIndex),
+    name: scopeAndName.slice(slashIndex + 1),
+    version
+  };
+}
+function readSkillsConfig() {
+  let dir = resolve6(".");
+  while (dir !== dirname2(dir)) {
+    const configPath = join8(dir, ".claude", "skills.json");
+    if (existsSync8(configPath)) {
+      try {
+        const raw = readFileSync4(configPath, "utf-8");
+        return JSON.parse(raw);
+      } catch {
+        throw new CliError("Failed to parse .claude/skills.json", [
+          "Check that the file is valid JSON."
+        ]);
+      }
+    }
+    dir = dirname2(dir);
+  }
+  return null;
+}
+async function pullSkill(scope, name, version, targetDir) {
+  const spin = spinner(`Fetching ${scope}/${name}${version ? `@${version}` : ""}...`);
+  const client = new ApiClient();
+  const query = {};
+  if (version) {
+    query.version = version;
+  }
+  const downloadInfo = await client.get(
+    `/api/v1/skills/${scope}/${name}/download`,
+    { query }
+  );
+  spin.succeed(`Found ${scope}/${name}@${downloadInfo.version}`);
+  spin.start("Downloading archive...");
+  const response = await fetch(downloadInfo.downloadUrl);
+  if (!response.ok) {
+    spin.fail("Download failed.");
+    throw new CliError(`Download failed with status ${response.status}.`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const archiveData = Buffer.from(arrayBuffer);
+  const actualSha = createHash3("sha256").update(archiveData).digest("hex");
+  if (actualSha !== downloadInfo.archiveSha256) {
+    spin.fail("Integrity check failed.");
+    throw new CliError(
+      `SHA-256 mismatch: expected ${downloadInfo.archiveSha256}, got ${actualSha}`,
+      ["The archive may be corrupted. Try again."]
+    );
+  }
+  spin.succeed("Downloaded and verified.");
+  mkdirSync3(targetDir, { recursive: true });
+  spin.start("Installing...");
+  const tempDir = join8(dirname2(targetDir), `.csreg-tmp-${Date.now()}`);
+  mkdirSync3(tempDir, { recursive: true });
+  const tempArchive = join8(tempDir, `${name}.tar.gz`);
+  writeFileSync3(tempArchive, archiveData);
+  try {
+    await extract(tempArchive, tempDir, downloadInfo.archiveSha256);
+    const extractedDir = join8(tempDir, name);
+    const finalDir = join8(targetDir, name);
+    if (existsSync8(finalDir)) {
+      const { rmSync } = await import("fs");
+      rmSync(finalDir, { recursive: true });
+    }
+    renameSync(extractedDir, finalDir);
+    spin.succeed(`Installed to ${finalDir}`);
+    return { version: downloadInfo.version };
+  } finally {
+    try {
+      const { rmSync } = await import("fs");
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+var pullCommand = new Command8("pull").description("Download and install a skill").argument("[ref]", "Skill reference (@scope/name[@version])").option("--all", "Pull all skills listed in .claude/skills.json").option("--path <dir>", "Custom install directory (overrides auto-detection)").action(async (ref, opts) => {
+  try {
+    if (opts.all) {
+      const config = readSkillsConfig();
+      if (!config) {
+        throw new CliError("No .claude/skills.json found.", [
+          'Create .claude/skills.json with a "skills" array.',
+          'Example:\n  {\n    "skills": [\n      { "ref": "@nexus/newsletter" },\n      { "ref": "@nexus/code-review", "version": "1.2.0" }\n    ]\n  }'
+        ]);
+      }
+      if (!config.skills || config.skills.length === 0) {
+        info("No skills listed in .claude/skills.json. Nothing to pull.");
+        return;
+      }
+      const skillsDir = opts.path ? resolve6(opts.path) : findClaudeSkillsDir();
+      if (!skillsDir) {
+        throw new CliError("Cannot find .claude/ directory.", [
+          "Run this from a project with a .claude/ directory, or use --path."
+        ]);
+      }
+      console.log(`Installing ${config.skills.length} skill(s) to ${skillsDir}/
+`);
+      let installed = 0;
+      for (const entry of config.skills) {
+        try {
+          const { scope: scope2, name: name2, version: version2 } = parseSkillRef(entry.ref);
+          const ver = entry.version || version2;
+          await pullSkill(scope2, name2, ver, skillsDir);
+          installed++;
+          console.log("");
+        } catch (err) {
+          warn(`Failed to pull ${entry.ref}: ${err instanceof Error ? err.message : String(err)}`);
+          console.log("");
+        }
+      }
+      console.log("");
+      success(`Installed ${installed}/${config.skills.length} skill(s).`);
+      return;
+    }
+    if (!ref) {
+      throw new CliError("Missing skill reference.", [
+        "Usage: csreg pull @scope/name[@version]",
+        "Or use: csreg pull --all  (to pull from .claude/skills.json)"
+      ]);
+    }
+    const { scope, name, version } = parseSkillRef(ref);
+    let targetDir;
+    if (opts.path) {
+      targetDir = resolve6(opts.path);
+    } else {
+      const detected = findClaudeSkillsDir();
+      if (detected) {
+        targetDir = detected;
+        const finalPath = join8(detected, name);
+        const ok = await confirm2({
+          message: `Install to ${finalPath}?`,
+          default: true
+        });
+        if (!ok) {
+          const { input: input3 } = await import("@inquirer/prompts");
+          const custom = await input3({
+            message: "Custom install path:",
+            default: join8(".", ".claude", "skills")
+          });
+          targetDir = resolve6(custom);
+        }
+      } else {
+        targetDir = join8(resolve6("."), ".claude", "skills");
+        info(`No .claude/ directory found. Will create ${targetDir}/`);
+        const ok = await confirm2({
+          message: `Install to ${join8(targetDir, name)}?`,
+          default: true
+        });
+        if (!ok) {
+          const { input: input3 } = await import("@inquirer/prompts");
+          const custom = await input3({
+            message: "Custom install path:",
+            default: targetDir
+          });
+          targetDir = resolve6(custom);
+        }
+      }
+    }
+    const result = await pullSkill(scope, name, version, targetDir);
+    console.log("");
+    success(`Pulled ${scope}/${name}@${result.version}`);
+    info(`Skill is ready at ${join8(targetDir, name)}/SKILL.md`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/info.ts
+import { Command as Command9 } from "commander";
+import chalk3 from "chalk";
+var infoCommand = new Command9("info").description("Display details about a skill").argument("<ref>", "Skill reference (scope/name)").action(async (ref) => {
+  try {
+    const cleaned = ref.startsWith("@") ? ref.slice(1) : ref;
+    const slashIndex = cleaned.indexOf("/");
+    if (slashIndex < 0) {
+      throw new CliError(`Invalid skill reference: ${ref}`, [
+        "Use the format: @scope/name"
+      ]);
+    }
+    const scope = cleaned.slice(0, slashIndex);
+    const name = cleaned.slice(slashIndex + 1);
+    const client = new ApiClient();
+    const skill = await client.get(`/api/v1/skills/${scope}/${name}`);
+    console.log("");
+    console.log(chalk3.bold(`${skill.scope}/${skill.name}`) + chalk3.dim(` @ ${skill.latestVersion}`));
+    console.log("");
+    if (skill.description) {
+      console.log(skill.description);
+      console.log("");
+    }
+    const fields = [
+      ["Type", skill.type],
+      ["Latest Version", skill.latestVersion],
+      ["Downloads", String(skill.totalDownloads)],
+      ["Created", new Date(skill.createdAt).toLocaleDateString()],
+      ["Updated", new Date(skill.updatedAt).toLocaleDateString()]
+    ];
+    if (skill.author) {
+      fields.push(["Author", `${skill.author.displayName} (${skill.author.email})`]);
+    }
+    if (skill.tags.length > 0) {
+      fields.push(["Tags", skill.tags.join(", ")]);
+    }
+    const maxLabel = Math.max(...fields.map(([label]) => label.length));
+    for (const [label, value] of fields) {
+      console.log(`  ${chalk3.cyan(label.padEnd(maxLabel + 2))}${value}`);
+    }
+    console.log("");
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/versions.ts
+import { Command as Command10 } from "commander";
+var versionsCommand = new Command10("versions").description("List all versions of a skill").argument("<ref>", "Skill reference (scope/name)").action(async (ref) => {
+  try {
+    const cleaned = ref.startsWith("@") ? ref.slice(1) : ref;
+    const slashIndex = cleaned.indexOf("/");
+    if (slashIndex < 0) {
+      throw new CliError(`Invalid skill reference: ${ref}`, [
+        "Use the format: @scope/name"
+      ]);
+    }
+    const scope = cleaned.slice(0, slashIndex);
+    const name = cleaned.slice(slashIndex + 1);
+    const client = new ApiClient();
+    const data = await client.get(
+      `/api/v1/skills/${scope}/${name}/versions`
+    );
+    if (data.versions.length === 0) {
+      console.log("No versions found.");
+      return;
+    }
+    const rows = data.versions.map((v) => [
+      v.version,
+      v.status,
+      new Date(v.createdAt).toLocaleDateString(),
+      String(v.fileCount)
+    ]);
+    console.log("");
+    console.log(formatTable(["Version", "Status", "Published", "Files"], rows));
+    console.log("");
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/commands/search.ts
+import { Command as Command11 } from "commander";
+var searchCommand = new Command11("search").description("Search for skills in the registry").argument("<query>", "Search query").option("-t, --type <type>", "Filter by skill type").option("-l, --limit <limit>", "Max results", "20").action(async (query, opts) => {
+  try {
+    const client = new ApiClient();
+    const queryParams = {
+      q: query,
+      limit: opts.limit
+    };
+    if (opts.type) {
+      queryParams.type = opts.type;
+    }
+    const data = await client.get("/api/v1/skills", {
+      query: queryParams
+    });
+    if (data.skills.length === 0) {
+      info(`No skills found for "${query}".`);
+      return;
+    }
+    const rows = data.skills.map((s) => [
+      `${s.scope}/${s.name}`,
+      s.description?.slice(0, 50) ?? "",
+      String(s.totalDownloads),
+      s.latestVersion
+    ]);
+    console.log("");
+    console.log(formatTable(["Skill", "Description", "Downloads", "Version"], rows));
+    console.log("");
+    info(`Showing ${data.skills.length} of ${data.total} results.`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/index.ts
+var program = new Command12();
+program.name("csreg").description("Claude Skills Registry CLI").version("0.1.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(initCommand);
+program.addCommand(validateCommand);
+program.addCommand(packCommand);
+program.addCommand(pushCommand);
+program.addCommand(pullCommand);
+program.addCommand(infoCommand);
+program.addCommand(versionsCommand);
+program.addCommand(searchCommand);
+program.parse();