svamp-cli 0.1.87 → 0.1.89

package/dist/commands-DJoYOM_1.mjs

@@ -0,0 +1,531 @@
+import os__default from 'os';
+import fs__default from 'fs';
+import { join, resolve, relative } from 'path';
+
+const SKILLS_SERVER = process.env.HYPHA_SKILLS_SERVER || "https://hypha.aicell.io";
+const SKILLS_WORKSPACE = process.env.HYPHA_SKILLS_WORKSPACE || "hypha-cloud";
+const SKILLS_COLLECTION = process.env.HYPHA_SKILLS_COLLECTION || "marketplace";
+const SKILLS_DIR = join(os__default.homedir(), ".claude", "skills");
+function getArtifactBaseUrl() {
+  return `${SKILLS_SERVER}/${SKILLS_WORKSPACE}/artifacts`;
+}
+async function fetchWithTimeout(url, options = {}, timeoutMs = 3e4) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } catch (err) {
+    if (err.name === "AbortError") throw new Error(`Request timed out after ${timeoutMs}ms: ${url}`);
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const yaml = match[1];
+  const result = {};
+  let currentKey = null;
+  let nestedObj = null;
+  for (const line of yaml.split("\n")) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const indentMatch = line.match(/^(\s*)/);
+    const indent = indentMatch ? indentMatch[1].length : 0;
+    if (indent > 0 && currentKey && nestedObj !== null) {
+      const kvMatch2 = line.trim().match(/^([^:]+):\s*(.*)$/);
+      if (kvMatch2) {
+        nestedObj[kvMatch2[1].trim()] = kvMatch2[2].trim().replace(/^["']|["']$/g, "");
+      }
+      continue;
+    }
+    if (nestedObj !== null && currentKey) {
+      result[currentKey] = nestedObj;
+      nestedObj = null;
+      currentKey = null;
+    }
+    const kvMatch = line.match(/^([^:]+):\s*(.*)$/);
+    if (!kvMatch) continue;
+    const key = kvMatch[1].trim();
+    const value = kvMatch[2].trim();
+    if (!value) {
+      currentKey = key;
+      nestedObj = {};
+    } else {
+      result[key] = value.replace(/^["']|["']$/g, "");
+    }
+  }
+  if (nestedObj !== null && currentKey) {
+    result[currentKey] = nestedObj;
+  }
+  if (!result.name || typeof result.name !== "string") return null;
+  if (!result.description || typeof result.description !== "string") return null;
+  return result;
+}
+async function searchSkills(query) {
+  const base = getArtifactBaseUrl();
+  const filters = encodeURIComponent(JSON.stringify({ type: "skill" }));
+  const url = `${base}/${SKILLS_COLLECTION}/children?keywords=${encodeURIComponent(query)}&filters=${filters}&limit=50`;
+  const resp = await fetchWithTimeout(url);
+  if (!resp.ok) {
+    if (resp.status === 404) return [];
+    throw new Error(`Search failed: ${resp.status} ${resp.statusText}`);
+  }
+  const data = await resp.json();
+  return normalizeSkillList(Array.isArray(data) ? data : data.items || []);
+}
+async function getSkillInfo(skillAlias) {
+  const base = getArtifactBaseUrl();
+  const url = `${base}/${skillAlias}`;
+  const resp = await fetchWithTimeout(url);
+  if (!resp.ok) {
+    if (resp.status === 404) return null;
+    throw new Error(`Get skill failed: ${resp.status} ${resp.statusText}`);
+  }
+  const data = await resp.json();
+  return normalizeSkill(data);
+}
+async function listSkillFiles(skillAlias, dir = "") {
+  const base = getArtifactBaseUrl();
+  const pathPart = dir ? `/${dir}/` : "/";
+  const url = `${base}/${skillAlias}/files${pathPart}`;
+  const resp = await fetchWithTimeout(url);
+  if (!resp.ok) {
+    throw new Error(`List files failed: ${resp.status} ${resp.statusText}`);
+  }
+  const data = await resp.json();
+  return Array.isArray(data) ? data : data.items || [];
+}
+async function downloadSkillFile(skillAlias, filePath) {
+  const base = getArtifactBaseUrl();
+  const url = `${base}/${skillAlias}/files/${filePath}`;
+  const resp = await fetchWithTimeout(url, { redirect: "follow" }, 6e4);
+  if (!resp.ok) {
+    throw new Error(`Download failed for ${filePath}: ${resp.status} ${resp.statusText}`);
+  }
+  return await resp.text();
+}
+function normalizeSkillList(items) {
+  return items.map(normalizeSkill).filter((s) => s !== null);
+}
+function normalizeSkill(item) {
+  if (!item) return null;
+  const manifest = item.manifest || {};
+  return {
+    alias: item.alias || manifest.name || item.id || "unknown",
+    name: manifest.name || item.alias || "unknown",
+    description: manifest.description || "",
+    author: manifest.metadata?.author || manifest.author,
+    version: manifest.metadata?.version || manifest.version,
+    tags: manifest.tags,
+    created_at: item.created_at,
+    last_modified: item.last_modified,
+    versions: item.versions,
+    git_url: item.git_url
+  };
+}
+
+const SVAMP_HOME = process.env.SVAMP_HOME || join(os__default.homedir(), ".svamp");
+const ENV_FILE = join(SVAMP_HOME, ".env");
+function loadDotEnv() {
+  if (!fs__default.existsSync(ENV_FILE)) return;
+  const lines = fs__default.readFileSync(ENV_FILE, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+function ensureSkillsDir() {
+  fs__default.mkdirSync(SKILLS_DIR, { recursive: true });
+}
+function formatTable(rows, widths) {
+  if (rows.length === 0) return "";
+  const cols = rows[0].length;
+  const w = widths || Array.from(
+    { length: cols },
+    (_, i) => Math.min(Math.max(...rows.map((r) => (r[i] || "").length), 4), 50)
+  );
+  return rows.map(
+    (row) => row.map((cell, i) => (cell || "").padEnd(w[i])).join("  ")
+  ).join("\n");
+}
+function isValidSkillName(name) {
+  return /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(name) && !name.includes("--") && name.length <= 64;
+}
+async function skillsFind(query, opts) {
+  let results;
+  try {
+    results = await searchSkills(query);
+  } catch (err) {
+    console.error(`Failed to search skills: ${err.message}`);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log(`No skills found matching "${query}".`);
+    return;
+  }
+  if (opts?.json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  const header = ["NAME", "DESCRIPTION", "AUTHOR", "VERSION"];
+  const rows = results.map((s) => [
+    s.alias,
+    s.description.length > 50 ? s.description.slice(0, 47) + "..." : s.description,
+    s.author || "-",
+    s.version || "-"
+  ]);
+  console.log(formatTable([header, ...rows], [25, 50, 20, 10]));
+}
+async function skillsInstall(skillName, opts) {
+  if (!isValidSkillName(skillName)) {
+    console.error(`Invalid skill name "${skillName}". Must be lowercase alphanumeric with hyphens, no consecutive hyphens, max 64 chars.`);
+    process.exit(1);
+  }
+  const targetDir = join(SKILLS_DIR, skillName);
+  if (fs__default.existsSync(targetDir) && !opts?.force) {
+    console.error(`Skill "${skillName}" is already installed at ${targetDir}`);
+    console.error("Use --force to overwrite.");
+    process.exit(1);
+  }
+  let info;
+  try {
+    info = await getSkillInfo(skillName);
+  } catch (err) {
+    console.error(`Failed to fetch skill info: ${err.message}`);
+    process.exit(1);
+  }
+  if (!info) {
+    console.error(`Skill "${skillName}" not found in the marketplace.`);
+    process.exit(1);
+  }
+  console.log(`Installing skill "${info.name}"...`);
+  let files;
+  try {
+    files = await collectAllFiles(skillName);
+  } catch (err) {
+    console.error(`Failed to list skill files: ${err.message}`);
+    process.exit(1);
+  }
+  if (files.length === 0) {
+    console.error("Skill has no files.");
+    process.exit(1);
+  }
+  if (!files.includes("SKILL.md")) {
+    console.error("Skill is missing a SKILL.md file. The skill may be malformed.");
+    process.exit(1);
+  }
+  ensureSkillsDir();
+  if (fs__default.existsSync(targetDir) && opts?.force) {
+    fs__default.rmSync(targetDir, { recursive: true, force: true });
+  }
+  fs__default.mkdirSync(targetDir, { recursive: true });
+  let downloaded = 0;
+  const errors = [];
+  for (const filePath of files) {
+    try {
+      const content = await downloadSkillFile(skillName, filePath);
+      const localPath = join(targetDir, filePath);
+      if (!localPath.startsWith(targetDir + "/")) {
+        errors.push(`  ${filePath}: path outside skill directory (blocked)`);
+        continue;
+      }
+      fs__default.mkdirSync(join(localPath, ".."), { recursive: true });
+      fs__default.writeFileSync(localPath, content, "utf-8");
+      downloaded++;
+    } catch (err) {
+      errors.push(`  ${filePath}: ${err.message}`);
+    }
+  }
+  if (errors.length > 0) {
+    fs__default.rmSync(targetDir, { recursive: true, force: true });
+    console.error(`Installation failed \u2014 ${errors.length} file(s) could not be downloaded:`);
+    errors.forEach((e) => console.error(e));
+    console.error("Partial installation cleaned up. Run the command again to retry.");
+    process.exit(1);
+  }
+  const skillMdPath = join(targetDir, "SKILL.md");
+  if (fs__default.existsSync(skillMdPath)) {
+    const content = fs__default.readFileSync(skillMdPath, "utf-8");
+    const fm = parseFrontmatter(content);
+    if (!fm) {
+      console.error("Warning: Installed SKILL.md has invalid or missing frontmatter (name/description).");
+    }
+  }
+  console.log(`Installed ${downloaded} file(s) to ${targetDir}`);
+  if (info.git_url) {
+    console.log(`  Git: ${info.git_url}`);
+  }
+}
+async function collectAllFiles(skillAlias, dir = "") {
+  const entries = await listSkillFiles(skillAlias, dir);
+  const result = [];
+  for (const entry of entries) {
+    const entryPath = dir ? `${dir}/${entry.name}` : entry.name;
+    if (entry.type === "directory") {
+      const sub = await collectAllFiles(skillAlias, entryPath);
+      result.push(...sub);
+    } else {
+      result.push(entryPath);
+    }
+  }
+  return result;
+}
+async function skillsList() {
+  ensureSkillsDir();
+  const entries = fs__default.readdirSync(SKILLS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory());
+  if (entries.length === 0) {
+    console.log("No skills installed.");
+    console.log(`Install one with: svamp skills install <name>`);
+    return;
+  }
+  const header = ["NAME", "DESCRIPTION", "STATUS"];
+  const rows = [];
+  for (const entry of entries) {
+    const skillDir = join(SKILLS_DIR, entry.name);
+    const skillMd = join(skillDir, "SKILL.md");
+    let description = "-";
+    let status = "ok";
+    if (!fs__default.existsSync(skillMd)) {
+      status = "missing SKILL.md";
+    } else {
+      try {
+        const content = fs__default.readFileSync(skillMd, "utf-8");
+        const fm = parseFrontmatter(content);
+        if (fm) {
+          description = fm.description.length > 45 ? fm.description.slice(0, 42) + "..." : fm.description;
+        } else {
+          status = "invalid frontmatter";
+        }
+      } catch (err) {
+        status = "read error";
+      }
+    }
+    rows.push([entry.name, description, status]);
+  }
+  console.log(formatTable([header, ...rows], [25, 45, 20]));
+}
+async function skillsRemove(name) {
+  if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
+    console.error(`Invalid skill name "${name}".`);
+    process.exit(1);
+  }
+  const targetDir = join(SKILLS_DIR, name);
+  if (!fs__default.existsSync(targetDir)) {
+    console.error(`Skill "${name}" is not installed.`);
+    process.exit(1);
+  }
+  if (!fs__default.statSync(targetDir).isDirectory()) {
+    console.error(`"${name}" is not a skill directory.`);
+    process.exit(1);
+  }
+  fs__default.rmSync(targetDir, { recursive: true, force: true });
+  console.log(`Removed skill "${name}" from ${targetDir}`);
+}
+async function skillsPublish(skillPath, opts) {
+  const absPath = resolve(skillPath);
+  if (!fs__default.existsSync(absPath)) {
+    console.error(`Path does not exist: ${absPath}`);
+    process.exit(1);
+  }
+  if (!fs__default.statSync(absPath).isDirectory()) {
+    console.error(`Not a directory: ${absPath}`);
+    process.exit(1);
+  }
+  const skillMdPath = join(absPath, "SKILL.md");
+  if (!fs__default.existsSync(skillMdPath)) {
+    console.error(`No SKILL.md found in ${absPath}`);
+    console.error("A valid skill must contain a SKILL.md file with name and description frontmatter.");
+    process.exit(1);
+  }
+  const skillMdContent = fs__default.readFileSync(skillMdPath, "utf-8");
+  const manifest = parseFrontmatter(skillMdContent);
+  if (!manifest) {
+    console.error('SKILL.md must have YAML frontmatter with "name" and "description" fields.');
+    process.exit(1);
+  }
+  if (!isValidSkillName(manifest.name)) {
+    console.error(`Invalid skill name "${manifest.name}".`);
+    console.error("Must be lowercase alphanumeric with hyphens, no consecutive hyphens, 1-64 chars.");
+    process.exit(1);
+  }
+  if (!manifest.description.trim()) {
+    console.error("SKILL.md description cannot be empty.");
+    process.exit(1);
+  }
+  const filesToUpload = collectLocalFiles(absPath);
+  if (filesToUpload.length === 0) {
+    console.error("No files to upload.");
+    process.exit(1);
+  }
+  const versionTag = opts?.version || null;
+  console.log(`Publishing skill "${manifest.name}"${versionTag ? ` (version: ${versionTag})` : ""}...`);
+  loadDotEnv();
+  const token = process.env.HYPHA_TOKEN;
+  if (!token) {
+    console.error('Not logged in. Run "svamp login <url>" first.');
+    process.exit(1);
+  }
+  const serverUrl = process.env.HYPHA_SERVER_URL || SKILLS_SERVER;
+  let server;
+  try {
+    const mod = await import('hypha-rpc');
+    const connectToServer = mod.connectToServer || mod.default?.connectToServer;
+    server = await connectToServer({
+      server_url: serverUrl,
+      token,
+      workspace: SKILLS_WORKSPACE
+    });
+  } catch (err) {
+    console.error(`Failed to connect to Hypha: ${err.message}`);
+    process.exit(1);
+  }
+  let am;
+  try {
+    am = await server.getService("public/artifact-manager");
+  } catch (err) {
+    console.error(`Failed to get artifact-manager service: ${err.message}`);
+    await server.disconnect();
+    process.exit(1);
+  }
+  let artifactId;
+  let isUpdate = false;
+  let existingArtifact = null;
+  try {
+    existingArtifact = await am.read({
+      artifact_id: `${SKILLS_WORKSPACE}/${manifest.name}`,
+      _rkwargs: true
+    });
+  } catch {
+  }
+  if (existingArtifact) {
+    artifactId = existingArtifact.id;
+    isUpdate = true;
+    console.log(`Updating existing skill "${manifest.name}"...`);
+    try {
+      await am.edit({
+        artifact_id: artifactId,
+        manifest: {
+          name: manifest.name,
+          description: manifest.description,
+          ...manifest.metadata && { metadata: manifest.metadata }
+        },
+        stage: true,
+        _rkwargs: true
+      });
+    } catch (err) {
+      console.error(`Failed to stage skill artifact for editing: ${err.message}`);
+      await server.disconnect();
+      process.exit(1);
+    }
+  } else {
+    try {
+      const created = await am.create({
+        alias: manifest.name,
+        type: "skill",
+        parent_id: `${SKILLS_WORKSPACE}/${SKILLS_COLLECTION}`,
+        manifest: {
+          name: manifest.name,
+          description: manifest.description,
+          ...manifest.metadata && { metadata: manifest.metadata }
+        },
+        config: {
+          storage: "git"
+        },
+        version: "stage",
+        _rkwargs: true
+      });
+      artifactId = created.id;
+      console.log(`Created new skill artifact with git storage.`);
+    } catch (err) {
+      console.error(`Failed to create skill artifact: ${err.message}`);
+      await server.disconnect();
+      process.exit(1);
+    }
+  }
+  let uploaded = 0;
+  const uploadErrors = [];
+  for (const relPath of filesToUpload) {
+    try {
+      const fullPath = join(absPath, relPath);
+      const content = fs__default.readFileSync(fullPath);
+      const putUrl = await am.put_file({
+        artifact_id: artifactId,
+        file_path: relPath,
+        _rkwargs: true
+      });
+      if (!putUrl || typeof putUrl !== "string") {
+        uploadErrors.push(`${relPath}: failed to get upload URL`);
+        continue;
+      }
+      const resp = await fetchWithTimeout(putUrl, {
+        method: "PUT",
+        body: content,
+        headers: { "Content-Type": "application/octet-stream" }
+      }, 12e4);
+      if (!resp.ok) {
+        uploadErrors.push(`${relPath}: upload returned ${resp.status}`);
+        continue;
+      }
+      uploaded++;
+    } catch (err) {
+      uploadErrors.push(`${relPath}: ${err.message}`);
+    }
+  }
+  if (uploadErrors.length > 0) {
+    console.error(`Warning: ${uploadErrors.length} file(s) failed to upload:`);
+    uploadErrors.forEach((e) => console.error(`  ${e}`));
+  }
+  if (uploaded === 0) {
+    console.error("No files were uploaded. Publish aborted.");
+    await server.disconnect();
+    process.exit(1);
+  }
+  try {
+    const commitOpts = {
+      artifact_id: artifactId,
+      _rkwargs: true
+    };
+    if (versionTag) {
+      commitOpts.version = versionTag;
+      commitOpts.comment = `Release ${versionTag}`;
+    }
+    await am.commit(commitOpts);
+  } catch (err) {
+    console.error(`Failed to commit: ${err.message}`);
+    await server.disconnect();
+    process.exit(1);
+  }
+  console.log(`Published "${manifest.name}" (${uploaded} files)${versionTag ? ` as ${versionTag}` : ""}`);
+  console.log(`  View: ${SKILLS_SERVER}/${SKILLS_WORKSPACE}/artifacts/${manifest.name}`);
+  const gitUrl = `${SKILLS_SERVER}/${SKILLS_WORKSPACE}/git/${manifest.name}`;
+  console.log(`  Git:  ${gitUrl}`);
+  if (isUpdate) {
+    console.log(`  Tip: Use --version <tag> to publish a named version.`);
+  }
+  await server.disconnect();
+}
+function collectLocalFiles(dir, base) {
+  const root = base || dir;
+  const result = [];
+  const entries = fs__default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    if (entry.isDirectory()) {
+      result.push(...collectLocalFiles(fullPath, root));
+    } else {
+      result.push(relative(root, fullPath));
+    }
+  }
+  return result;
+}
+
+export { skillsFind, skillsInstall, skillsList, skillsPublish, skillsRemove };