skillverse 0.1.0 → 0.1.2

package/dist/index.js

@@ -0,0 +1,1907 @@
+// src/index.ts
+import express from "express";
+import cors from "cors";
+import dotenv2 from "dotenv";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join6 } from "path";
+import { mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+
+// src/routes/skills.ts
+import { Router } from "express";
+import multer from "multer";
+import { join as join4 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir3, rm as rm3 } from "fs/promises";
+
+// src/services/skillService.ts
+import { join as join2, basename } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, rm, cp, readFile, unlink } from "fs/promises";
+import matter from "gray-matter";
+import simpleGit from "simple-git";
+import AdmZip from "adm-zip";
+
+// src/config.ts
+import { join, dirname } from "path";
+import { existsSync, mkdirSync } from "fs";
+import { fileURLToPath } from "url";
+import dotenv from "dotenv";
+dotenv.config();
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function setupEnvironment() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const skillverseHome = process.env.SKILLVERSE_HOME || join(home, ".skillverse");
+  const dbUrl = process.env.DATABASE_URL;
+  if (!existsSync(skillverseHome)) {
+    try {
+      mkdirSync(skillverseHome, { recursive: true });
+    } catch (error) {
+      console.error("Failed to create .skillverse directory:", error);
+    }
+  }
+  if (!dbUrl) {
+    const dbPath = join(skillverseHome, "skillverse.db");
+    process.env.DATABASE_URL = `file:${dbPath}`;
+  }
+  return {
+    skillverseHome,
+    databaseUrl: process.env.DATABASE_URL
+  };
+}
+var config = setupEnvironment();
+
+// src/lib/db.ts
+import { PrismaClient } from "@prisma/client";
+var globalForPrisma = globalThis;
+var prisma = globalForPrisma.prisma ?? new PrismaClient({
+  log: process.env.NODE_ENV === "development" ? ["error", "warn"] : ["error"]
+});
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+
+// ../shared/dist/index.js
+var WORKSPACE_SKILLS_PATHS = {
+  vscode: {
+    project: ".github/skills",
+    global: "~/.copilot/skills"
+  },
+  cursor: {
+    project: ".cursor/skills",
+    global: "~/.cursor/skills"
+  },
+  "claude-desktop": {
+    project: ".claude/skills",
+    global: "~/.claude/skills"
+  },
+  codex: {
+    project: ".codex/skills",
+    global: "~/.codex/skills"
+  },
+  antigravity: {
+    project: ".agent/skills",
+    global: "~/.agent/skills"
+  },
+  custom: {
+    project: "skills",
+    global: ""
+  }
+};
+var ErrorCode = {
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  NOT_FOUND: "NOT_FOUND",
+  ALREADY_EXISTS: "ALREADY_EXISTS",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  GIT_ERROR: "GIT_ERROR",
+  FILE_SYSTEM_ERROR: "FILE_SYSTEM_ERROR",
+  PERMISSION_ERROR: "PERMISSION_ERROR",
+  SYMLINK_ERROR: "SYMLINK_ERROR"
+};
+
+// src/middleware/errorHandler.ts
+var AppError = class extends Error {
+  constructor(code, message, statusCode = 500, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "AppError";
+  }
+};
+function errorHandler(err, req, res, next) {
+  console.error("Error:", err);
+  if (err instanceof AppError) {
+    return res.status(err.statusCode).json({
+      success: false,
+      error: err.message,
+      code: err.code,
+      details: err.details
+    });
+  }
+  return res.status(500).json({
+    success: false,
+    error: "Internal server error",
+    code: ErrorCode.INTERNAL_ERROR,
+    message: process.env.NODE_ENV === "development" ? err.message : void 0
+  });
+}
+
+// src/services/skillService.ts
+var SKILLVERSE_HOME = process.env.SKILLVERSE_HOME || join2(process.env.HOME || "", ".skillverse");
+var SKILLS_DIR = process.env.SKILLS_DIR || join2(SKILLVERSE_HOME, "skills");
+var TEMP_DIR = process.env.TEMP_DIR || join2(SKILLVERSE_HOME, "temp");
+function parseGitUrl(url) {
+  if (!url.includes("/tree/")) {
+    const urlParts = url.split("/");
+    const repoName = urlParts[urlParts.length - 1].replace(".git", "");
+    return { repoUrl: url, skillName: repoName };
+  }
+  const parts = url.split("/tree/");
+  const repoUrl = parts[0] + (parts[0].endsWith(".git") ? "" : ".git");
+  const pathParts = parts[1].split("/");
+  const branch = pathParts[0];
+  const subdir = pathParts.slice(1).join("/");
+  const skillName = pathParts[pathParts.length - 1];
+  return { repoUrl, subdir, skillName };
+}
+var SkillService = class {
+  async getAllSkills() {
+    const skills = await prisma.skill.findMany({
+      include: {
+        linkedWorkspaces: {
+          include: {
+            workspace: true
+          }
+        },
+        marketplaceEntry: true
+      },
+      orderBy: {
+        installDate: "desc"
+      }
+    });
+    return skills;
+  }
+  async getSkillById(id) {
+    const skill = await prisma.skill.findUnique({
+      where: { id },
+      include: {
+        linkedWorkspaces: {
+          include: {
+            workspace: true
+          }
+        },
+        marketplaceEntry: true
+      }
+    });
+    if (!skill) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Skill not found", 404);
+    }
+    return skill;
+  }
+  async getSkillByName(name) {
+    const skill = await prisma.skill.findUnique({
+      where: { name },
+      include: {
+        linkedWorkspaces: {
+          include: {
+            workspace: true
+          }
+        },
+        marketplaceEntry: true
+      }
+    });
+    if (!skill) {
+      throw new AppError(ErrorCode.NOT_FOUND, `Skill "${name}" not found`, 404);
+    }
+    return skill;
+  }
+  async parseSkillMetadata(skillPath) {
+    try {
+      const skillMdPath = join2(skillPath, "SKILL.md");
+      let description = "";
+      let metadata = {};
+      if (existsSync2(skillMdPath)) {
+        const fileContent = await readFile(skillMdPath, "utf-8");
+        const parsed = matter(fileContent);
+        description = parsed.data.description || "";
+        metadata = parsed.data;
+      }
+      if (!description) {
+        const packageJsonPath = join2(skillPath, "package.json");
+        const skillJsonPath = join2(skillPath, "skill.json");
+        if (existsSync2(skillJsonPath)) {
+          const content = await readFile(skillJsonPath, "utf-8");
+          const json = JSON.parse(content);
+          description = json.description || "";
+          metadata = { ...metadata, ...json };
+        } else if (existsSync2(packageJsonPath)) {
+          const content = await readFile(packageJsonPath, "utf-8");
+          const pkg = JSON.parse(content);
+          description = pkg.description || "";
+          metadata = { ...metadata, name: pkg.name, version: pkg.version };
+        }
+      }
+      return { description, metadata };
+    } catch (error) {
+      console.warn("Failed to parse skill metadata:", error);
+      return { description: "", metadata: {} };
+    }
+  }
+  async createSkillFromGit(gitUrl, description) {
+    let tempPath = null;
+    try {
+      const { repoUrl, subdir, skillName } = parseGitUrl(gitUrl);
+      const existingSkill = await prisma.skill.findUnique({
+        where: { name: skillName }
+      });
+      if (existingSkill) {
+        throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${skillName}" already exists`, 409);
+      }
+      const skillPath = join2(SKILLS_DIR, skillName);
+      if (existsSync2(skillPath)) {
+        throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+      }
+      let commitHash = "";
+      if (subdir) {
+        tempPath = join2(TEMP_DIR, `git-clone-${Date.now()}`);
+        await mkdir(tempPath, { recursive: true });
+        console.log(`Cloning ${repoUrl} to temp path for extraction...`);
+        const git = simpleGit();
+        await git.clone(repoUrl, tempPath);
+        try {
+          commitHash = await simpleGit(tempPath).revparse(["HEAD"]);
+          console.log(`Captured commit hash: ${commitHash}`);
+        } catch (e) {
+          console.warn("Failed to capture commit hash:", e);
+        }
+        const sourcePath = join2(tempPath, subdir);
+        if (!existsSync2(sourcePath)) {
+          throw new AppError(
+            ErrorCode.GIT_ERROR,
+            `Subdirectory "${subdir}" not found in repository`,
+            400
+          );
+        }
+        const hasSkillMd = existsSync2(join2(sourcePath, "SKILL.md"));
+        const hasSkillJson = existsSync2(join2(sourcePath, "skill.json"));
+        const hasPackageJson = existsSync2(join2(sourcePath, "package.json"));
+        if (!hasSkillMd && !hasSkillJson && !hasPackageJson) {
+          throw new AppError(
+            ErrorCode.VALIDATION_ERROR,
+            `Invalid skill structure: "${subdir}" does not contain SKILL.md, skill.json, or package.json`,
+            400
+          );
+        }
+        await mkdir(skillPath, { recursive: true });
+        await cp(sourcePath, skillPath, { recursive: true });
+      } else {
+        if (!existsSync2(skillPath)) {
+          await mkdir(skillPath, { recursive: true });
+        }
+        const git = simpleGit();
+        console.log(`Cloning ${gitUrl} to ${skillPath}...`);
+        await git.clone(gitUrl, skillPath);
+        try {
+          commitHash = await git.cwd(skillPath).revparse(["HEAD"]);
+          console.log(`Captured commit hash: ${commitHash}`);
+        } catch (e) {
+          console.warn("Failed to capture commit hash:", e);
+        }
+      }
+      const parsed = await this.parseSkillMetadata(skillPath);
+      const skill = await prisma.skill.create({
+        data: {
+          name: skillName,
+          source: "git",
+          sourceUrl: gitUrl,
+          repoUrl,
+          commitHash,
+          description: description || parsed.description || "",
+          storagePath: skillPath,
+          metadata: JSON.stringify(parsed.metadata)
+        }
+      });
+      return skill;
+    } catch (error) {
+      throw error;
+    } finally {
+      if (tempPath && existsSync2(tempPath)) {
+        await rm(tempPath, { recursive: true, force: true }).catch(console.error);
+      }
+    }
+  }
+  async createSkillFromDirectory(path, name, description) {
+    if (!existsSync2(path)) {
+      throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Source path not found: ${path}`, 400);
+    }
+    const skillName = name || basename(path);
+    const skillPath = join2(SKILLS_DIR, skillName);
+    const existingSkill = await prisma.skill.findUnique({
+      where: { name: skillName }
+    });
+    if (existingSkill) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${skillName}" already exists`, 409);
+    }
+    if (existsSync2(skillPath)) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+    }
+    try {
+      await mkdir(skillPath, { recursive: true });
+      await cp(path, skillPath, { recursive: true });
+      const parsed = await this.parseSkillMetadata(skillPath);
+      const skill = await prisma.skill.create({
+        data: {
+          name: skillName,
+          source: "local",
+          description: description || parsed.description || "",
+          storagePath: skillPath,
+          metadata: JSON.stringify(parsed.metadata)
+        }
+      });
+      return skill;
+    } catch (error) {
+      if (existsSync2(skillPath)) {
+        await rm(skillPath, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      throw error;
+    }
+  }
+  /**
+   * Helper to handle cases where the archive contains a single top-level directory.
+   * Moves contents up one level if that's the case.
+   */
+  async stripTopLevelDirectory(targetPath) {
+    const { readdir: readdir2, rename, rmdir, stat: stat2 } = await import("fs/promises");
+    const items = await readdir2(targetPath);
+    const validItems = items.filter((i) => i !== ".DS_Store" && i !== "__MACOSX");
+    if (validItems.length === 1) {
+      const topLevelItem = validItems[0];
+      const topLevelPath = join2(targetPath, topLevelItem);
+      const stats = await stat2(topLevelPath);
+      if (stats.isDirectory()) {
+        console.log(`Striping top-level directory: ${topLevelItem}`);
+        const subItems = await readdir2(topLevelPath);
+        for (const item of subItems) {
+          await rename(join2(topLevelPath, item), join2(targetPath, item));
+        }
+        await rmdir(topLevelPath);
+      }
+    }
+  }
+  async createSkillFromLocal(name, zipPath, description) {
+    const skillPath = join2(SKILLS_DIR, name);
+    const existingSkill = await prisma.skill.findUnique({
+      where: { name }
+    });
+    if (existingSkill) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${name}" already exists`, 409);
+    }
+    if (existsSync2(skillPath)) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
+    }
+    const extractPath = join2(TEMP_DIR, `extract-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+    await mkdir(extractPath, { recursive: true });
+    try {
+      const zip = new AdmZip(zipPath);
+      zip.extractAllTo(extractPath, true);
+      await this.stripTopLevelDirectory(extractPath);
+      const parsed = await this.parseSkillMetadata(extractPath);
+      if (existsSync2(skillPath)) {
+        throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
+      }
+      await import("fs/promises").then((fs) => fs.rename(extractPath, skillPath));
+      const skill = await prisma.skill.create({
+        data: {
+          name,
+          source: "local",
+          description: description || parsed.description || "",
+          storagePath: skillPath,
+          metadata: JSON.stringify(parsed.metadata)
+        }
+      });
+      return skill;
+    } catch (error) {
+      if (existsSync2(skillPath)) {
+        await rm(skillPath, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      if (existsSync2(extractPath)) {
+        await rm(extractPath, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      throw error;
+    }
+  }
+  /**
+   * Create a skill from a tar.gz bundle (marketplace install)
+   * @param bundlePath - Path to the .tar.gz bundle
+   * @param originalName - Original skill name
+   * @param description - Optional skill description
+   */
+  async createSkillFromBundle(bundlePath, originalName, description) {
+    let name = originalName;
+    let counter = 1;
+    while (await prisma.skill.findUnique({ where: { name } })) {
+      name = `${originalName}-${counter}`;
+      counter++;
+    }
+    const skillPath = join2(SKILLS_DIR, name);
+    const extractPath = join2(TEMP_DIR, `extract-bundle-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+    await mkdir(extractPath, { recursive: true });
+    try {
+      const { createReadStream: createReadStream2 } = await import("fs");
+      const { createGunzip: createGunzip2 } = await import("zlib");
+      const tar = await import("tar");
+      const { pipeline: pipeline2 } = await import("stream/promises");
+      await pipeline2(
+        createReadStream2(bundlePath),
+        createGunzip2(),
+        tar.extract({ cwd: extractPath })
+      );
+      await this.stripTopLevelDirectory(extractPath);
+      const parsed = await this.parseSkillMetadata(extractPath);
+      if (existsSync2(skillPath)) {
+        throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
+      }
+      await import("fs/promises").then((fs) => fs.rename(extractPath, skillPath));
+      const skill = await prisma.skill.create({
+        data: {
+          name,
+          source: "local",
+          description: description || parsed.description || "",
+          storagePath: skillPath,
+          metadata: JSON.stringify(parsed.metadata)
+        }
+      });
+      console.log(`\u{1F4E6} Installed skill "${name}" from bundle`);
+      return skill;
+    } catch (error) {
+      if (existsSync2(skillPath)) {
+        await rm(skillPath, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      if (existsSync2(extractPath)) {
+        await rm(extractPath, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      throw error;
+    }
+  }
+  async updateSkill(id, data) {
+    const skill = await this.getSkillById(id);
+    const updatedSkill = await prisma.skill.update({
+      where: { id },
+      data: {
+        ...data.name && { name: data.name },
+        ...data.description !== void 0 && { description: data.description },
+        ...data.metadata && { metadata: JSON.stringify(data.metadata) }
+      }
+    });
+    return updatedSkill;
+  }
+  async deleteSkill(id, removeFiles = true) {
+    const skill = await this.getSkillById(id);
+    if (skill.linkedWorkspaces && skill.linkedWorkspaces.length > 0) {
+      for (const link of skill.linkedWorkspaces) {
+        try {
+          const workspacePath = link.workspace.path;
+          const symlinkPath = join2(workspacePath, skill.name);
+          if (existsSync2(symlinkPath)) {
+            const stats = await import("fs/promises").then((fs) => fs.lstat(symlinkPath));
+            if (stats.isSymbolicLink()) {
+              await unlink(symlinkPath);
+              console.log(`Removed symlink for ${skill.name} in workspace ${workspacePath}`);
+            }
+          }
+        } catch (error) {
+          console.warn(`Failed to remove symlink for ${skill.name} in workspace ${link.workspace.path}:`, error);
+        }
+      }
+    }
+    await prisma.skill.delete({
+      where: { id }
+    });
+    if (removeFiles && skill.storagePath) {
+      await rm(skill.storagePath, { recursive: true, force: true }).catch((err) => {
+        console.warn(`Failed to delete skill directory ${skill.storagePath}:`, err);
+      });
+    }
+    return { success: true, message: "Skill deleted successfully" };
+  }
+  // Check for updates
+  async checkForUpdate(id) {
+    const skill = await this.getSkillById(id);
+    if (skill.source !== "git" || !skill.repoUrl) {
+      return {
+        hasUpdate: false,
+        currentHash: skill.commitHash,
+        remoteHash: null,
+        message: "Not a git skill or missing repo URL"
+      };
+    }
+    const tempPath = join2(TEMP_DIR, `check-update-${Date.now()}`);
+    await mkdir(tempPath, { recursive: true });
+    try {
+      const git = simpleGit();
+      console.log(`Checking updates for ${skill.name} from ${skill.repoUrl}...`);
+      const remote = await git.listRemote([skill.repoUrl, "HEAD"]);
+      if (!remote) {
+        throw new Error("Failed to get remote HEAD");
+      }
+      const remoteHash = remote.split("	")[0];
+      const hasUpdate = remoteHash !== skill.commitHash;
+      await prisma.skill.update({
+        where: { id },
+        data: {
+          lastUpdateCheck: /* @__PURE__ */ new Date(),
+          updateAvailable: hasUpdate
+        }
+      });
+      return {
+        hasUpdate,
+        currentHash: skill.commitHash,
+        remoteHash
+      };
+    } catch (error) {
+      console.error("Update check error:", error);
+      throw new AppError(ErrorCode.GIT_ERROR, `Failed to check for updates: ${error.message}`, 500);
+    } finally {
+      await rm(tempPath, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+  async checkUpdates(ids) {
+    const whereClause = {
+      source: "git",
+      repoUrl: { not: null }
+    };
+    if (ids && ids.length > 0) {
+      whereClause.id = { in: ids };
+    }
+    const skills = await prisma.skill.findMany({ where: whereClause });
+    const results = {};
+    console.log(`Checking updates for ${skills.length} skills...`);
+    await Promise.all(skills.map(async (skill) => {
+      try {
+        const result = await this.checkForUpdate(skill.id);
+        results[skill.id] = result;
+      } catch (e) {
+        results[skill.id] = { error: e.message };
+      }
+    }));
+    return results;
+  }
+  async refreshMetadata(id) {
+    const skill = await this.getSkillById(id);
+    const parsed = await this.parseSkillMetadata(skill.storagePath);
+    const updated = await prisma.skill.update({
+      where: { id },
+      data: {
+        description: parsed.description,
+        metadata: JSON.stringify(parsed.metadata)
+      }
+    });
+    return updated;
+  }
+  async upgradeSkill(id) {
+    const skill = await this.getSkillById(id);
+    if (skill.source !== "git" || !skill.sourceUrl) {
+      throw new AppError(ErrorCode.VALIDATION_ERROR, "Cannot upgrade non-git skill", 400);
+    }
+    let tempPath = null;
+    let tempSkillPath = null;
+    try {
+      const { repoUrl, subdir } = parseGitUrl(skill.sourceUrl);
+      tempPath = join2(TEMP_DIR, `upgrade-${Date.now()}`);
+      await mkdir(tempPath, { recursive: true });
+      const git = simpleGit();
+      console.log(`Cloning ${repoUrl} to temp for upgrade...`);
+      await git.clone(repoUrl, tempPath);
+      let commitHash = "";
+      try {
+        commitHash = await simpleGit(tempPath).revparse(["HEAD"]);
+      } catch (e) {
+        console.warn("Failed to capture commit hash during upgrade:", e);
+      }
+      let sourcePath = tempPath;
+      if (subdir) {
+        sourcePath = join2(tempPath, subdir);
+        if (!existsSync2(sourcePath)) {
+          throw new AppError(ErrorCode.GIT_ERROR, `Subdirectory "${subdir}" not found`, 400);
+        }
+      }
+      const hasSkillMd = existsSync2(join2(sourcePath, "SKILL.md"));
+      const hasSkillJson = existsSync2(join2(sourcePath, "skill.json"));
+      const hasPackageJson = existsSync2(join2(sourcePath, "package.json"));
+      if (!hasSkillMd && !hasSkillJson && !hasPackageJson) {
+        throw new AppError(ErrorCode.VALIDATION_ERROR, "Invalid skill structure in new version", 400);
+      }
+      const files = await import("fs/promises").then((fs) => fs.readdir(skill.storagePath));
+      for (const file of files) {
+        await rm(join2(skill.storagePath, file), { recursive: true, force: true });
+      }
+      await cp(sourcePath, skill.storagePath, { recursive: true });
+      const parsed = await this.parseSkillMetadata(skill.storagePath);
+      const updatedSkill = await prisma.skill.update({
+        where: { id },
+        data: {
+          commitHash,
+          updateAvailable: false,
+          lastUpdateCheck: /* @__PURE__ */ new Date(),
+          installDate: /* @__PURE__ */ new Date(),
+          // Considering upgrade as reinstall? Or user prefer generic updatedAt
+          // Keeping installDate as "last installed/upgraded"
+          description: parsed.description,
+          metadata: JSON.stringify(parsed.metadata)
+        }
+      });
+      return updatedSkill;
+    } catch (error) {
+      console.error("Upgrade error:", error);
+      throw new AppError(ErrorCode.GIT_ERROR, `Failed to upgrade skill: ${error.message}`, 500);
+    } finally {
+      if (tempPath) await rm(tempPath, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+};
+var skillService = new SkillService();
+
+// src/services/workspaceService.ts
+import { join as join3 } from "path";
+import { homedir } from "os";
+import { symlink, unlink as unlink2, rm as rm2, mkdir as mkdir2, appendFile, readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync3, lstatSync } from "fs";
+function computeSkillsPath(projectPath, type, scope) {
+  const pathConfig = WORKSPACE_SKILLS_PATHS[type];
+  if (scope === "global") {
+    return pathConfig.global.replace("~", homedir());
+  }
+  return join3(projectPath, pathConfig.project);
+}
+var WorkspaceService = class {
+  /**
+   * Helper to get expected skills path for a project
+   */
+  getSkillsPath(projectPath, type, scope) {
+    return computeSkillsPath(projectPath, type, scope);
+  }
+  /**
+   * Sync database links with filesystem state
+   * Removes links from DB if the symlink is missing from the workspace
+   */
+  async syncLinks(workspace) {
+    if (!workspace.linkedSkills || workspace.linkedSkills.length === 0) return;
+    for (const link of workspace.linkedSkills) {
+      if (!link.skill) continue;
+      const linkPath = join3(workspace.path, link.skill.name);
+      if (!existsSync3(linkPath)) {
+        console.log(`Link missing for skill "${link.skill.name}" in workspace "${workspace.name}". Removing from DB.`);
+        try {
+          await prisma.skillWorkspace.delete({
+            where: { id: link.id }
+          });
+          workspace.linkedSkills = workspace.linkedSkills.filter((l) => l.id !== link.id);
+        } catch (err) {
+          console.error(`Failed to sync link for ${link.skill.name}:`, err);
+        }
+      }
+    }
+  }
+  async findWorkspaceByPath(path) {
+    const workspace = await prisma.workspace.findUnique({
+      where: { path },
+      include: {
+        linkedSkills: {
+          include: {
+            skill: true
+          }
+        }
+      }
+    });
+    return workspace;
+  }
+  async getAllWorkspaces() {
+    const workspaces = await prisma.workspace.findMany({
+      include: {
+        linkedSkills: {
+          include: {
+            skill: true
+          }
+        }
+      },
+      orderBy: {
+        createdAt: "desc"
+      }
+    });
+    await Promise.all(workspaces.map((w) => this.syncLinks(w)));
+    return workspaces.map((workspace) => ({
+      ...workspace,
+      isPathValid: existsSync3(workspace.path)
+    }));
+  }
+  async getWorkspaceById(id) {
+    const workspace = await prisma.workspace.findUnique({
+      where: { id },
+      include: {
+        linkedSkills: {
+          include: {
+            skill: true
+          }
+        }
+      }
+    });
+    if (!workspace) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Workspace not found", 404);
+    }
+    await this.syncLinks(workspace);
+    return {
+      ...workspace,
+      isPathValid: existsSync3(workspace.path)
+    };
+  }
+  async createWorkspace(name, projectPath, type, scope) {
+    const skillsPath = computeSkillsPath(projectPath, type, scope);
+    if (scope === "project" && projectPath && !existsSync3(projectPath)) {
+      throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Project path does not exist: ${projectPath}`, 400);
+    }
+    if (!existsSync3(skillsPath)) {
+      try {
+        await mkdir2(skillsPath, { recursive: true });
+      } catch (err) {
+        throw new AppError(
+          ErrorCode.FILE_SYSTEM_ERROR,
+          `Failed to create skills directory: ${err.message}`,
+          500
+        );
+      }
+    }
+    const existingWorkspace = await prisma.workspace.findUnique({
+      where: { path: skillsPath }
+    });
+    if (existingWorkspace) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, "Workspace already exists at this path", 409);
+    }
+    const workspace = await prisma.workspace.create({
+      data: {
+        name,
+        path: skillsPath,
+        type,
+        scope
+      }
+    });
+    if (scope === "project" && projectPath && existsSync3(projectPath)) {
+      try {
+        const gitignorePath = join3(projectPath, ".gitignore");
+        const relativeSkillsPath = WORKSPACE_SKILLS_PATHS[type].project;
+        let shouldAppend = false;
+        if (existsSync3(gitignorePath)) {
+          const content = await readFile2(gitignorePath, "utf-8");
+          if (!content.includes(relativeSkillsPath)) {
+            shouldAppend = true;
+          }
+        } else {
+          shouldAppend = true;
+        }
+        if (shouldAppend) {
+          const ignoreEntry = `
+
+# SkillVerse
+${relativeSkillsPath}/
+`;
+          await appendFile(gitignorePath, ignoreEntry);
+          console.log(`Added ${relativeSkillsPath}/ to .gitignore in ${projectPath}`);
+        }
+      } catch (err) {
+        console.warn("Failed to update .gitignore:", err);
+      }
+    }
+    return {
+      ...workspace,
+      isPathValid: true
+    };
+  }
+  async updateWorkspace(id, data) {
+    await this.getWorkspaceById(id);
+    const workspace = await prisma.workspace.update({
+      where: { id },
+      data
+    });
+    return {
+      ...workspace,
+      isPathValid: existsSync3(workspace.path)
+    };
+  }
+  async deleteWorkspace(id) {
+    const workspace = await this.getWorkspaceById(id);
+    const links = await prisma.skillWorkspace.findMany({
+      where: { workspaceId: id },
+      include: { skill: true }
+    });
+    for (const link of links) {
+      try {
+        const linkPath = join3(workspace.path, link.skill.name);
+        if (existsSync3(linkPath)) {
+          await rm2(linkPath, { recursive: true, force: true });
+        }
+      } catch (error) {
+        console.error(`Failed to remove symlink for ${link.skill.name}:`, error);
+      }
+    }
+    await prisma.workspace.delete({ where: { id } });
+    return { success: true, message: "Workspace deleted successfully" };
+  }
+  async linkSkillToWorkspace(skillId, workspaceId) {
+    const skill = await prisma.skill.findUnique({ where: { id: skillId } });
+    const workspace = await prisma.workspace.findUnique({ where: { id: workspaceId } });
+    if (!skill) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Skill not found", 404);
+    }
+    if (!workspace) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Workspace not found", 404);
+    }
+    if (!existsSync3(workspace.path)) {
+      throw new AppError(
+        ErrorCode.FILE_SYSTEM_ERROR,
+        `Workspace skills directory does not exist: ${workspace.path}. The folder may have been deleted. Please recreate it or remove this workspace.`,
+        400
+      );
+    }
+    const existingLink = await prisma.skillWorkspace.findFirst({
+      where: {
+        skillId,
+        workspaceId
+      }
+    });
+    if (existingLink) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, "Skill is already linked to this workspace", 409);
+    }
+    const targetPath = join3(workspace.path, skill.name);
+    try {
+      if (existsSync3(targetPath)) {
+        const stats = lstatSync(targetPath);
+        if (stats.isSymbolicLink()) {
+          await unlink2(targetPath);
+        } else {
+          throw new AppError(
+            ErrorCode.FILE_SYSTEM_ERROR,
+            `A file or directory already exists at ${targetPath}`,
+            409
+          );
+        }
+      }
+      await symlink(skill.storagePath, targetPath, "dir");
+      const link = await prisma.skillWorkspace.create({
+        data: {
+          skillId,
+          workspaceId
+        },
+        include: {
+          skill: true,
+          workspace: true
+        }
+      });
+      return link;
+    } catch (error) {
+      if (error instanceof AppError) throw error;
+      console.error("Symlink creation error:", error);
+      throw new AppError(
+        ErrorCode.SYMLINK_ERROR,
+        `Failed to create symlink: ${error.message}`,
+        500,
+        error
+      );
+    }
+  }
+  async unlinkSkillFromWorkspace(skillId, workspaceId) {
+    const link = await prisma.skillWorkspace.findFirst({
+      where: {
+        skillId,
+        workspaceId
+      },
+      include: {
+        skill: true,
+        workspace: true
+      }
+    });
+    if (!link) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Link not found", 404);
+    }
+    const linkPath = join3(link.workspace.path, link.skill.name);
+    try {
+      if (existsSync3(linkPath)) {
+        await rm2(linkPath, { recursive: true, force: true });
+      }
+      await prisma.skillWorkspace.delete({
+        where: { id: link.id }
+      });
+      return { success: true, message: "Skill unlinked successfully" };
+    } catch (error) {
+      console.error("Unlink error:", error);
+      throw new AppError(
+        ErrorCode.FILE_SYSTEM_ERROR,
+        `Failed to unlink skill: ${error.message}`,
+        500,
+        error
+      );
+    }
+  }
+  /**
+   * Detect existing skills in a workspace skills directory
+   * Returns list of skill names that could be migrated
+   */
+  async detectExistingSkills(skillsPath) {
+    if (!existsSync3(skillsPath)) {
+      return [];
+    }
+    const { readdir: readdir2, stat: stat2, readFile: readFile3 } = await import("fs/promises");
+    const items = await readdir2(skillsPath);
+    const existingSkills = [];
+    for (const item of items) {
+      if (item.startsWith(".")) continue;
+      const itemPath = join3(skillsPath, item);
+      try {
+        const itemStat = await stat2(itemPath);
+        const lstats = lstatSync(itemPath);
+        if (lstats.isSymbolicLink()) continue;
+        if (itemStat.isDirectory()) {
+          const hasSkillMd = existsSync3(join3(itemPath, "SKILL.md"));
+          const hasSkillJson = existsSync3(join3(itemPath, "skill.json"));
+          const hasPackageJson = existsSync3(join3(itemPath, "package.json"));
+          if (hasSkillMd || hasSkillJson || hasPackageJson) {
+            existingSkills.push({
+              name: item,
+              hasSkillMd,
+              path: itemPath
+            });
+          }
+        }
+      } catch (error) {
+        console.warn(`Failed to check ${itemPath}:`, error);
+      }
+    }
+    return existingSkills;
+  }
+  /**
+   * Migrate existing skills from workspace to unified storage
+   * 1. Move skills to ~/.skillverse/skills/
+   * 2. Register in database
+   * 3. Create symlinks back to workspace
+   */
+  async migrateExistingSkills(workspaceId, skillNames) {
+    const workspace = await this.getWorkspaceById(workspaceId);
+    const SKILLVERSE_HOME2 = process.env.SKILLVERSE_HOME || join3(homedir(), ".skillverse");
+    const SKILLS_DIR2 = process.env.SKILLS_DIR || join3(SKILLVERSE_HOME2, "skills");
+    if (!existsSync3(SKILLS_DIR2)) {
+      await mkdir2(SKILLS_DIR2, { recursive: true });
+    }
+    const { rename, readFile: readFile3, cp: cp2 } = await import("fs/promises");
+    const migrated = [];
+    const errors = [];
+    for (const skillName of skillNames) {
+      const sourcePath = join3(workspace.path, skillName);
+      const targetPath = join3(SKILLS_DIR2, skillName);
+      try {
+        if (!existsSync3(sourcePath)) {
+          errors.push(`${skillName}: Source path not found`);
+          continue;
+        }
+        const lstats = lstatSync(sourcePath);
+        if (lstats.isSymbolicLink()) {
+          errors.push(`${skillName}: Already a symlink, skipping`);
+          continue;
+        }
+        if (existsSync3(targetPath)) {
+          errors.push(`${skillName}: Already exists in unified storage`);
+          continue;
+        }
+        const existingSkill = await prisma.skill.findUnique({
+          where: { name: skillName }
+        });
+        if (existingSkill) {
+          errors.push(`${skillName}: Already registered in database`);
+          continue;
+        }
+        const skillMdPath = join3(sourcePath, "SKILL.md");
+        let description = "";
+        let metadata = {};
+        if (existsSync3(skillMdPath)) {
+          try {
+            const matter2 = await import("gray-matter");
+            const fileContent = await readFile3(skillMdPath, "utf-8");
+            const parsed = matter2.default(fileContent);
+            description = parsed.data.description || "";
+            metadata = parsed.data;
+          } catch (e) {
+            console.warn(`Failed to parse SKILL.md for ${skillName}:`, e);
+          }
+        }
+        await cp2(sourcePath, targetPath, { recursive: true });
+        await rm2(sourcePath, { recursive: true, force: true });
+        const skill = await prisma.skill.create({
+          data: {
+            name: skillName,
+            source: "local",
+            description,
+            storagePath: targetPath,
+            metadata: JSON.stringify(metadata)
+          }
+        });
+        await symlink(targetPath, sourcePath, "dir");
+        await prisma.skillWorkspace.create({
+          data: {
+            skillId: skill.id,
+            workspaceId: workspace.id
+          }
+        });
+        migrated.push(skillName);
+        console.log(`\u2705 Migrated skill "${skillName}" to unified storage`);
+      } catch (error) {
+        console.error(`Failed to migrate ${skillName}:`, error);
+        errors.push(`${skillName}: ${error.message}`);
+      }
+    }
+    return {
+      success: errors.length === 0,
+      migrated,
+      errors
+    };
+  }
+};
+var workspaceService = new WorkspaceService();
+
+// src/routes/skills.ts
+var router = Router();
+var TEMP_DIR2 = process.env.TEMP_DIR || join4(process.env.HOME || "", ".skillverse", "temp");
+if (!existsSync4(TEMP_DIR2)) {
+  mkdir3(TEMP_DIR2, { recursive: true });
+}
+var storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, TEMP_DIR2);
+  },
+  filename: (req, file, cb) => {
+    const uniqueSuffix = Date.now() + "-" + Math.round(Math.random() * 1e9);
+    cb(null, uniqueSuffix + "-" + file.originalname);
+  }
+});
+var upload = multer({
+  storage,
+  limits: {
+    fileSize: 100 * 1024 * 1024
+    // 100MB limit
+  },
+  fileFilter: (req, file, cb) => {
+    if (file.mimetype === "application/zip" || file.originalname.endsWith(".zip")) {
+      cb(null, true);
+    } else {
+      cb(new Error("Only ZIP files are allowed"));
+    }
+  }
+});
+router.get("/", async (req, res, next) => {
+  try {
+    const skills = await skillService.getAllSkills();
+    res.json({
+      success: true,
+      data: skills
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.get("/:id", async (req, res, next) => {
+  try {
+    const skill = await skillService.getSkillById(req.params.id);
+    res.json({
+      success: true,
+      data: skill
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.post("/from-git", async (req, res, next) => {
+  try {
+    const { gitUrl, description } = req.body;
+    if (!gitUrl) {
+      return res.status(400).json({
+        success: false,
+        error: "gitUrl is required"
+      });
+    }
+    const skill = await skillService.createSkillFromGit(gitUrl, description);
+    res.status(201).json({
+      success: true,
+      data: skill,
+      message: "Skill created successfully from Git repository"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.post(
+  "/from-local",
+  upload.single("file"),
+  async (req, res, next) => {
+    try {
+      const { name, description } = req.body;
+      const file = req.file;
+      if (!name) {
+        if (file) {
+          await rm3(file.path, { force: true });
+        }
+        return res.status(400).json({
+          success: false,
+          error: "name is required"
+        });
+      }
+      if (!file) {
+        return res.status(400).json({
+          success: false,
+          error: "ZIP file is required"
+        });
+      }
+      const skill = await skillService.createSkillFromLocal(name, file.path, description);
+      await rm3(file.path, { force: true });
+      res.status(201).json({
+        success: true,
+        data: skill,
+        message: "Skill created successfully from local file"
+      });
+    } catch (error) {
+      if (req.file) {
+        await rm3(req.file.path, { force: true }).catch(() => {
+        });
+      }
+      next(error);
+    }
+  }
+);
+router.put("/:id", async (req, res, next) => {
+  try {
+    const { name, description, metadata } = req.body;
+    const skill = await skillService.updateSkill(req.params.id, {
+      name,
+      description,
+      metadata
+    });
+    res.json({
+      success: true,
+      data: skill,
+      message: "Skill updated successfully"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.delete("/:id", async (req, res, next) => {
+  try {
+    const removeFiles = req.query.removeFiles !== "false";
+    const result = await skillService.deleteSkill(req.params.id, removeFiles);
+    res.json(result);
+  } catch (error) {
+    next(error);
+  }
+});
+router.post("/:id/link", async (req, res, next) => {
+  try {
+    const { workspaceId } = req.body;
+    if (!workspaceId) {
+      return res.status(400).json({
+        success: false,
+        error: "workspaceId is required"
+      });
+    }
+    const link = await workspaceService.linkSkillToWorkspace(req.params.id, workspaceId);
+    res.status(201).json({
+      success: true,
+      data: link,
+      message: "Skill linked to workspace successfully"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.delete(
+  "/:id/unlink/:workspaceId",
+  async (req, res, next) => {
+    try {
+      const result = await workspaceService.unlinkSkillFromWorkspace(
+        req.params.id,
+        req.params.workspaceId
+      );
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+router.get("/:id/check-update", async (req, res, next) => {
+  try {
+    const result = await skillService.checkForUpdate(req.params.id);
+    res.json({
+      success: true,
+      data: result
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.post("/:id/upgrade", async (req, res, next) => {
+  try {
+    const skill = await skillService.upgradeSkill(req.params.id);
+    res.json({
+      success: true,
+      data: skill,
+      message: "Skill upgraded successfully"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.post("/check-updates", async (req, res, next) => {
+  try {
+    const { ids } = req.body;
+    const results = await skillService.checkUpdates(ids);
+    res.json({
+      success: true,
+      data: results
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.post("/:id/refresh-metadata", async (req, res, next) => {
+  try {
+    const skill = await skillService.refreshMetadata(req.params.id);
+    res.json({
+      success: true,
+      data: skill,
+      message: "Metadata refreshed successfully"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router.get("/:id/skill-md", async (req, res, next) => {
+  try {
+    const { readFile: readFile3 } = await import("fs/promises");
+    const skill = await skillService.getSkillById(req.params.id);
+    const skillMdPath = join4(skill.storagePath, "SKILL.md");
+    if (!existsSync4(skillMdPath)) {
+      return res.json({
+        success: true,
+        data: {
+          exists: false,
+          content: null
+        }
+      });
+    }
+    const content = await readFile3(skillMdPath, "utf-8");
+    res.json({
+      success: true,
+      data: {
+        exists: true,
+        content
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+var skills_default = router;
+
+// src/routes/workspaces.ts
+import { Router as Router2 } from "express";
+var router2 = Router2();
+router2.get("/", async (req, res, next) => {
+  try {
+    const workspaces = await workspaceService.getAllWorkspaces();
+    res.json({
+      success: true,
+      data: workspaces
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router2.get("/:id", async (req, res, next) => {
+  try {
+    const workspace = await workspaceService.getWorkspaceById(req.params.id);
+    res.json({
+      success: true,
+      data: workspace
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router2.post("/", async (req, res, next) => {
+  try {
+    const { name, projectPath, type, scope } = req.body;
+    if (!name || !type || !scope) {
+      return res.status(400).json({
+        success: false,
+        error: "name, type, and scope are required"
+      });
+    }
+    if (scope === "project" && !projectPath) {
+      return res.status(400).json({
+        success: false,
+        error: "projectPath is required for project scope"
+      });
+    }
+    const validTypes = ["vscode", "cursor", "claude-desktop", "codex", "antigravity", "custom"];
+    if (!validTypes.includes(type)) {
+      return res.status(400).json({
+        success: false,
+        error: `type must be one of: ${validTypes.join(", ")}`
+      });
+    }
+    const validScopes = ["project", "global"];
+    if (!validScopes.includes(scope)) {
+      return res.status(400).json({
+        success: false,
+        error: `scope must be one of: ${validScopes.join(", ")}`
+      });
+    }
+    const workspace = await workspaceService.createWorkspace(name, projectPath || "", type, scope);
+    res.status(201).json({
+      success: true,
+      data: workspace,
+      message: "Workspace created successfully"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router2.put("/:id", async (req, res, next) => {
+  try {
+    const { name, path, type, scope } = req.body;
+    if (type) {
+      const validTypes = ["vscode", "cursor", "claude-desktop", "codex", "antigravity", "custom"];
+      if (!validTypes.includes(type)) {
+        return res.status(400).json({
+          success: false,
+          error: `type must be one of: ${validTypes.join(", ")}`
+        });
+      }
+    }
+    if (scope) {
+      const validScopes = ["project", "global"];
+      if (!validScopes.includes(scope)) {
+        return res.status(400).json({
+          success: false,
+          error: `scope must be one of: ${validScopes.join(", ")}`
+        });
+      }
+    }
+    const workspace = await workspaceService.updateWorkspace(req.params.id, {
+      name,
+      path,
+      type,
+      scope
+    });
+    res.json({
+      success: true,
+      data: workspace,
+      message: "Workspace updated successfully"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router2.delete("/:id", async (req, res, next) => {
+  try {
+    const result = await workspaceService.deleteWorkspace(req.params.id);
+    res.json(result);
+  } catch (error) {
+    next(error);
+  }
+});
+router2.post("/:id/detect-skills", async (req, res, next) => {
+  try {
+    const workspace = await workspaceService.getWorkspaceById(req.params.id);
+    const existingSkills = await workspaceService.detectExistingSkills(workspace.path);
+    res.json({
+      success: true,
+      data: existingSkills
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router2.post("/:id/migrate-skills", async (req, res, next) => {
+  try {
+    const { skillNames } = req.body;
+    if (!skillNames || !Array.isArray(skillNames) || skillNames.length === 0) {
+      return res.status(400).json({
+        success: false,
+        error: "skillNames array is required"
+      });
+    }
+    const result = await workspaceService.migrateExistingSkills(req.params.id, skillNames);
+    res.json({
+      success: true,
+      data: result
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+var workspaces_default = router2;
+
+// src/routes/marketplace.ts
+import { Router as Router3 } from "express";
+
+// src/services/bundleService.ts
+import { createWriteStream, existsSync as existsSync5, createReadStream } from "fs";
+import { mkdir as mkdir4, rm as rm4, readdir, stat } from "fs/promises";
+import { join as join5 } from "path";
+import { pipeline } from "stream/promises";
+import archiver from "archiver";
+import { createGunzip } from "zlib";
+import { extract } from "tar";
+var BUNDLES_DIR = join5(
+  process.env.SKILLVERSE_HOME || join5(process.env.HOME || "", ".skillverse"),
+  "bundles"
+);
+async function ensureBundlesDir() {
+  if (!existsSync5(BUNDLES_DIR)) {
+    await mkdir4(BUNDLES_DIR, { recursive: true });
+  }
+}
+async function createBundle(skillPath, skillName) {
+  await ensureBundlesDir();
+  const bundleName = `${skillName}-${Date.now()}.tar.gz`;
+  const bundlePath = join5(BUNDLES_DIR, bundleName);
+  return new Promise((resolve, reject) => {
+    const output = createWriteStream(bundlePath);
+    const archive = archiver("tar", {
+      gzip: true,
+      gzipOptions: { level: 9 }
+    });
+    output.on("close", () => {
+      console.log(`\u{1F4E6} Bundle created: ${bundlePath} (${archive.pointer()} bytes)`);
+      resolve(bundlePath);
+    });
+    archive.on("error", (err) => {
+      reject(err);
+    });
+    archive.pipe(output);
+    archive.directory(skillPath, false);
+    archive.finalize();
+  });
+}
+async function extractBundle(bundlePath, targetDir) {
+  if (!existsSync5(bundlePath)) {
+    throw new Error(`Bundle not found: ${bundlePath}`);
+  }
+  if (!existsSync5(targetDir)) {
+    await mkdir4(targetDir, { recursive: true });
+  }
+  await pipeline(
+    createReadStream(bundlePath),
+    createGunzip(),
+    extract({ cwd: targetDir })
+  );
+  console.log(`\u{1F4C2} Bundle extracted to: ${targetDir}`);
+}
+async function deleteBundle(bundlePath) {
+  if (existsSync5(bundlePath)) {
+    await rm4(bundlePath);
+    console.log(`\u{1F5D1}\uFE0F Bundle deleted: ${bundlePath}`);
+  }
+}
+async function getBundleSize(bundlePath) {
+  if (!existsSync5(bundlePath)) {
+    return 0;
+  }
+  const stats = await stat(bundlePath);
+  return stats.size;
+}
+async function listBundles() {
+  await ensureBundlesDir();
+  const files = await readdir(BUNDLES_DIR);
+  return files.filter((f) => f.endsWith(".tar.gz")).map((f) => join5(BUNDLES_DIR, f));
+}
+var bundleService = {
+  createBundle,
+  extractBundle,
+  deleteBundle,
+  getBundleSize,
+  listBundles,
+  BUNDLES_DIR
+};
+
+// src/routes/marketplace.ts
+import { existsSync as existsSync6 } from "fs";
+var router3 = Router3();
+router3.get("/skills", async (req, res, next) => {
+  try {
+    const { search, page = "1", pageSize = "20" } = req.query;
+    const where = {};
+    if (search) {
+      where.skill = {
+        OR: [
+          { name: { contains: search } },
+          { description: { contains: search } }
+        ]
+      };
+    }
+    const [items, total] = await Promise.all([
+      prisma.marketplaceSkill.findMany({
+        where,
+        include: {
+          skill: true
+        },
+        orderBy: {
+          downloads: "desc"
+        },
+        skip: (parseInt(page) - 1) * parseInt(pageSize),
+        take: parseInt(pageSize)
+      }),
+      prisma.marketplaceSkill.count({ where })
+    ]);
+    res.json({
+      success: true,
+      data: {
+        items,
+        total,
+        page: parseInt(page),
+        pageSize: parseInt(pageSize)
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router3.get("/skills/:id", async (req, res, next) => {
+  try {
+    const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+      where: { id: req.params.id },
+      include: {
+        skill: true
+      }
+    });
+    if (!marketplaceSkill) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Marketplace skill not found", 404);
+    }
+    res.json({
+      success: true,
+      data: marketplaceSkill
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router3.get("/download/:id", async (req, res, next) => {
+  try {
+    const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+      where: { id: req.params.id },
+      include: {
+        skill: true
+      }
+    });
+    if (!marketplaceSkill) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Marketplace skill not found", 404);
+    }
+    if (marketplaceSkill.skill.source === "git" && marketplaceSkill.skill.sourceUrl) {
+      return res.json({
+        success: true,
+        data: {
+          type: "git",
+          sourceUrl: marketplaceSkill.skill.sourceUrl
+        }
+      });
+    }
+    if (marketplaceSkill.bundlePath && existsSync6(marketplaceSkill.bundlePath)) {
+      res.setHeader("Content-Type", "application/gzip");
+      res.setHeader(
+        "Content-Disposition",
+        `attachment; filename="${marketplaceSkill.skill.name}.tar.gz"`
+      );
+      return res.sendFile(marketplaceSkill.bundlePath);
+    }
+    throw new AppError(ErrorCode.NOT_FOUND, "Bundle not available for this skill", 404);
+  } catch (error) {
+    next(error);
+  }
+});
+router3.post("/publish", async (req, res, next) => {
+  try {
+    const { skillId, publisherName } = req.body;
+    if (!skillId) {
+      return res.status(400).json({
+        success: false,
+        error: "skillId is required"
+      });
+    }
+    const skill = await prisma.skill.findUnique({
+      where: { id: skillId }
+    });
+    if (!skill) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Skill not found", 404);
+    }
+    const existingEntry = await prisma.marketplaceSkill.findUnique({
+      where: { skillId }
+    });
+    if (existingEntry) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, "Skill is already published to marketplace", 409);
+    }
+    let bundlePath = null;
+    let bundleSize = null;
+    if (skill.source === "local" && existsSync6(skill.storagePath)) {
+      bundlePath = await bundleService.createBundle(skill.storagePath, skill.name);
+      bundleSize = await bundleService.getBundleSize(bundlePath);
+    }
+    const marketplaceSkill = await prisma.marketplaceSkill.create({
+      data: {
+        skillId,
+        publisherName: publisherName || "Anonymous",
+        bundlePath,
+        bundleSize
+      },
+      include: {
+        skill: true
+      }
+    });
+    res.status(201).json({
+      success: true,
+      data: marketplaceSkill,
+      message: "Skill published to marketplace successfully"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router3.post("/install/:id", async (req, res, next) => {
+  try {
+    const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+      where: { id: req.params.id },
+      include: {
+        skill: true
+      }
+    });
+    if (!marketplaceSkill) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Marketplace skill not found", 404);
+    }
+    const sourceSkill = marketplaceSkill.skill;
+    if (sourceSkill.source === "git" && sourceSkill.sourceUrl) {
+      const newSkill = await skillService.createSkillFromGit(
+        sourceSkill.sourceUrl,
+        sourceSkill.description || void 0
+      );
+      await prisma.marketplaceSkill.update({
+        where: { id: req.params.id },
+        data: { downloads: { increment: 1 } }
+      });
+      return res.status(201).json({
+        success: true,
+        data: newSkill,
+        message: "Skill installed from marketplace successfully"
+      });
+    }
+    if (sourceSkill.source === "local" && marketplaceSkill.bundlePath && existsSync6(marketplaceSkill.bundlePath)) {
+      const newSkill = await skillService.createSkillFromBundle(
+        marketplaceSkill.bundlePath,
+        sourceSkill.name,
+        sourceSkill.description || void 0
+      );
+      await prisma.marketplaceSkill.update({
+        where: { id: req.params.id },
+        data: { downloads: { increment: 1 } }
+      });
+      return res.status(201).json({
+        success: true,
+        data: newSkill,
+        message: "Skill installed from marketplace successfully"
+      });
+    }
+    return res.status(400).json({
+      success: false,
+      error: "Cannot install this skill. Bundle not available."
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router3.delete("/unpublish/:skillId", async (req, res, next) => {
+  try {
+    const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+      where: { skillId: req.params.skillId }
+    });
+    if (!marketplaceSkill) {
+      throw new AppError(ErrorCode.NOT_FOUND, "Skill is not published to marketplace", 404);
+    }
+    await prisma.marketplaceSkill.delete({
+      where: { id: marketplaceSkill.id }
+    });
+    res.json({
+      success: true,
+      message: "Skill unpublished from marketplace successfully"
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+var marketplace_default = router3;
+
+// src/routes/dashboard.ts
+import { Router as Router4 } from "express";
+var router4 = Router4();
+router4.get("/stats", async (req, res, next) => {
+  try {
+    const [totalSkills, totalWorkspaces, totalLinks, marketplaceSkills, recentSkills] = await Promise.all([
+      prisma.skill.count(),
+      prisma.workspace.count(),
+      prisma.skillWorkspace.count(),
+      prisma.marketplaceSkill.count(),
+      prisma.skill.findMany({
+        orderBy: { installDate: "desc" },
+        take: 5,
+        include: {
+          linkedWorkspaces: {
+            include: {
+              workspace: true
+            }
+          }
+        }
+      })
+    ]);
+    res.json({
+      success: true,
+      data: {
+        totalSkills,
+        totalWorkspaces,
+        totalLinks,
+        marketplaceSkills,
+        recentSkills
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router4.get("/activity", async (req, res, next) => {
+  try {
+    const [recentSkills, recentLinks, recentPublished] = await Promise.all([
+      prisma.skill.findMany({
+        orderBy: { createdAt: "desc" },
+        take: 10,
+        select: {
+          id: true,
+          name: true,
+          source: true,
+          createdAt: true
+        }
+      }),
+      prisma.skillWorkspace.findMany({
+        orderBy: { linkedAt: "desc" },
+        take: 10,
+        include: {
+          skill: { select: { name: true } },
+          workspace: { select: { name: true } }
+        }
+      }),
+      prisma.marketplaceSkill.findMany({
+        orderBy: { publishDate: "desc" },
+        take: 10,
+        include: {
+          skill: { select: { name: true } }
+        }
+      })
+    ]);
+    const activities = [
+      ...recentSkills.map((s) => ({
+        type: "skill_added",
+        date: s.createdAt,
+        data: { skillName: s.name, source: s.source }
+      })),
+      ...recentLinks.map((l) => ({
+        type: "skill_linked",
+        date: l.linkedAt,
+        data: { skillName: l.skill.name, workspaceName: l.workspace.name }
+      })),
+      ...recentPublished.map((p) => ({
+        type: "skill_published",
+        date: p.publishDate,
+        data: { skillName: p.skill.name }
+      }))
+    ].sort((a, b) => b.date.getTime() - a.date.getTime());
+    res.json({
+      success: true,
+      data: activities.slice(0, 20)
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+var dashboard_default = router4;
+
+// src/middleware/logger.ts
+function requestLogger(req, res, next) {
+  const start = Date.now();
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    console.log(`${req.method} ${req.path} - ${res.statusCode} - ${duration}ms`);
+  });
+  next();
+}
+
+// src/index.ts
+dotenv2.config();
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var app = express();
+var PORT = process.env.PORT || 3001;
+app.use(cors());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(requestLogger);
+var possiblePublicDirs = [
+  join6(__dirname2, "../public"),
+  // Production: dist/index.js -> public
+  join6(__dirname2, "../../public"),
+  // Dev tsx might resolve here 
+  join6(process.cwd(), "public"),
+  // Fallback: relative to cwd
+  join6(process.cwd(), "server/public")
+  // Fallback: from root
+];
+var publicDir = possiblePublicDirs.find((dir) => existsSync7(dir));
+if (publicDir) {
+  app.use(express.static(publicDir));
+  console.log(`\u{1F4C2} Serving static files from: ${publicDir}`);
+} else {
+  console.warn('\u26A0\uFE0F  No public directory found. Run "npm run build" in client first.');
+}
+app.use("/api/skills", skills_default);
+app.use("/api/workspaces", workspaces_default);
+app.use("/api/marketplace", marketplace_default);
+app.use("/api/dashboard", dashboard_default);
+app.get("/health", (req, res) => {
+  res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+});
+if (publicDir && existsSync7(publicDir)) {
+  app.get("*", (req, res) => {
+    res.sendFile(join6(publicDir, "index.html"));
+  });
+}
+app.use(errorHandler);
+async function initializeStorage() {
+  const skillverseHome = process.env.SKILLVERSE_HOME || join6(process.env.HOME || "", ".skillverse");
+  const skillsDir = process.env.SKILLS_DIR || join6(skillverseHome, "skills");
+  const marketplaceDir = process.env.MARKETPLACE_DIR || join6(skillverseHome, "marketplace");
+  const dirs = [skillverseHome, skillsDir, marketplaceDir];
+  for (const dir of dirs) {
+    if (!existsSync7(dir)) {
+      await mkdir5(dir, { recursive: true });
+      console.log(`Created directory: ${dir}`);
+    }
+  }
+}
+async function startServer(port = parseInt(process.env.PORT || "3001")) {
+  try {
+    await initializeStorage();
+    return new Promise((resolve) => {
+      app.listen(port, () => {
+        console.log(`\u{1F680} SkillVerse server running on http://localhost:${port}`);
+        console.log(`\u{1F4C1} Storage: ${process.env.SKILLVERSE_HOME || join6(process.env.HOME || "", ".skillverse")}`);
+        resolve();
+      });
+    });
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+}
+if (process.argv[1] === fileURLToPath2(import.meta.url)) {
+  startServer();
+}
+export {
+  startServer
+};
+//# sourceMappingURL=index.js.map