@agent-nexus/csreg 0.1.5 → 0.1.7

package/dist/chunk-VTCXMN4H.js

@@ -0,0 +1,725 @@
+// src/commands/push.ts
+import { Command as Command2 } from "commander";
+import { resolve as resolve3, join as join6, basename as basename3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, statSync as statSync3, readdirSync as readdirSync3, lstatSync as lstatSync2 } from "fs";
+import { createHash as createHash2 } from "crypto";
+
+// src/commands/validate.ts
+import { Command } from "commander";
+import { resolve as resolve2, join as join3, basename } from "path";
+import { existsSync as existsSync3, statSync, readdirSync as readdirSync2, lstatSync } from "fs";
+
+// src/lib/manifest.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+
+// 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/lib/manifest.ts
+var SKILL_FILE = "SKILL.md";
+function parseManifest(dir) {
+  const skillPath = join(dir, SKILL_FILE);
+  if (!existsSync(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 = readFileSync(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, join as join2, dirname } from "path";
+import { existsSync as existsSync2, readdirSync } from "fs";
+function findClaudeSkillsDir() {
+  let dir = resolve(".");
+  const parts = dir.split("/");
+  const claudeIdx = parts.lastIndexOf(".claude");
+  if (claudeIdx >= 0) {
+    const claudeRoot = parts.slice(0, claudeIdx + 1).join("/");
+    return join2(claudeRoot, "skills");
+  }
+  while (dir !== dirname(dir)) {
+    const claudeDir = join2(dir, ".claude");
+    if (existsSync2(claudeDir)) {
+      return join2(claudeDir, "skills");
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+function discoverSkillDirs(parentDir) {
+  if (!existsSync2(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 = join2(parentDir, entry.name, "SKILL.md");
+    if (existsSync2(skillMd)) {
+      dirs.push(join2(parentDir, entry.name));
+    }
+  }
+  return dirs.sort();
+}
+
+// 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/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 = join3(dir, entry.name);
+    const lstat = lstatSync(fullPath);
+    if (lstat.isSymbolicLink()) continue;
+    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 (!existsSync3(join3(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 Command("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 = resolve2(dir);
+    if (!existsSync3(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/lib/archive.ts
+import { statSync as statSync2 } from "fs";
+import { readFile } from "fs/promises";
+import { createHash } from "crypto";
+import { join as join4, basename as basename2 } from "path";
+import { create as tarCreate, extract as tarExtract } from "tar";
+var MAX_ARCHIVE_SIZE = 10 * 1024 * 1024;
+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 ?? join4(dir, "..", `${dirName}.tar.gz`);
+  await tarCreate(
+    {
+      gzip: true,
+      file: archivePath,
+      cwd: join4(dir, "..")
+    },
+    [dirName]
+  );
+  const sha256 = await computeSha256(archivePath);
+  const stat = statSync2(archivePath);
+  if (stat.size > MAX_ARCHIVE_SIZE) {
+    throw new CliError(
+      `Archive size ${(stat.size / 1024 / 1024).toFixed(1)}MB exceeds the 10MB limit.`,
+      ["Remove unnecessary files or assets to reduce the package size."]
+    );
+  }
+  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,
+    filter: (path) => !path.includes("..")
+  });
+}
+
+// src/config.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join5(homedir(), ".config", "csreg");
+var CONFIG_PATH = join5(CONFIG_DIR, "config.json");
+function getConfig() {
+  if (!existsSync4(CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync2(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, mode: 448 });
+  writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+}
+function getApiUrl() {
+  return process.env.CSREG_API_URL ?? getConfig().apiUrl ?? "https://www.csreg.nexus";
+}
+function getAuthToken() {
+  return process.env.CSREG_TOKEN ?? getConfig().token;
+}
+
+// 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((resolve4) => setTimeout(resolve4, 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((resolve4) => setTimeout(resolve4, 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/commands/push.ts
+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 = join6(dir, entry.name);
+    const lstat = lstatSync2(fullPath);
+    if (lstat.isSymbolicLink()) continue;
+    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 uploadHeaders = {
+    "Content-Type": "application/gzip",
+    "Content-Length": String(archive.size)
+  };
+  let uploadResponse = await fetch(prepared.uploadUrl, {
+    method: "PUT",
+    headers: uploadHeaders,
+    body: archiveData,
+    redirect: "manual"
+  });
+  if (uploadResponse.status === 301 || uploadResponse.status === 302 || uploadResponse.status === 307 || uploadResponse.status === 308) {
+    let redirectUrl = uploadResponse.headers.get("location");
+    if (!redirectUrl) {
+      const body = await uploadResponse.text();
+      const endpointMatch = body.match(/<Endpoint>([^<]+)<\/Endpoint>/);
+      if (endpointMatch) {
+        const url = new URL(prepared.uploadUrl);
+        url.hostname = endpointMatch[1];
+        redirectUrl = url.toString();
+      }
+    }
+    if (!redirectUrl) {
+      spin.fail("Upload failed.");
+      throw new CliError("S3 returned a redirect but no usable endpoint.", [
+        "This may be a region mismatch. Contact support."
+      ]);
+    }
+    uploadResponse = await fetch(redirectUrl, {
+      method: "PUT",
+      headers: uploadHeaders,
+      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 Command2("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 = resolve3(dir);
+    if (!existsSync5(resolved)) {
+      throw new CliError(`Directory not found: ${resolved}`);
+    }
+    const ref = await pushSingle(resolved);
+    console.log("");
+    success(`Published ${ref}`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+export {
+  setConfig,
+  getApiUrl,
+  getAuthToken,
+  CliError,
+  handleError,
+  ApiClient,
+  formatTable,
+  spinner,
+  success,
+  warn,
+  info,
+  parseManifest,
+  findClaudeSkillsDir,
+  runValidation,
+  validateCommand,
+  MAX_ARCHIVE_SIZE,
+  pack,
+  extract,
+  pushCommand
+};