skillverse 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,38 +1,35 @@
-// src/index.ts
-import express from "express";
-import cors from "cors";
-import dotenv2 from "dotenv";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname3, join as join7 } from "path";
-import { mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync8 } 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";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/config.ts
 import { join, dirname } from "path";
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync, readFileSync } 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 defaultHome = join(home, ".skillverse");
+  const bootstrapConfigPath = join(defaultHome, "config.json");
+  let skillverseHome = process.env.SKILLVERSE_HOME || defaultHome;
+  if (existsSync(bootstrapConfigPath)) {
+    try {
+      const config3 = JSON.parse(readFileSync(bootstrapConfigPath, "utf-8"));
+      if (config3.skillverseHome) {
+        skillverseHome = config3.skillverseHome;
+        process.env.SKILLVERSE_HOME = skillverseHome;
+        console.log(`Common config found. Using custom home: ${skillverseHome}`);
+      }
+    } catch (e) {
+      console.warn("Failed to read bootstrap config:", e);
+    }
+  }
   const dbUrl = process.env.DATABASE_URL;
   if (!existsSync(skillverseHome)) {
     try {
@@ -41,73 +38,99 @@ function setupEnvironment() {
       console.error("Failed to create .skillverse directory:", error);
     }
   }
-  if (!dbUrl) {
+  if (!dbUrl || skillverseHome !== defaultHome) {
     const dbPath = join(skillverseHome, "skillverse.db");
     process.env.DATABASE_URL = `file:${dbPath}`;
+    console.log(`Using database at: ${dbPath}`);
   }
+  process.env.SKILLS_DIR = join(skillverseHome, "skills");
+  process.env.MARKETPLACE_DIR = join(skillverseHome, "marketplace");
+  process.env.TEMP_DIR = join(skillverseHome, "temp");
   return {
     skillverseHome,
     databaseUrl: process.env.DATABASE_URL
   };
 }
-var config = setupEnvironment();
+var __filename, __dirname, config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    dotenv.config();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    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"]
+var config2, globalForPrisma, currentDbUrl, prisma;
+var init_db = __esm({
+  "src/lib/db.ts"() {
+    "use strict";
+    init_config();
+    config2 = setupEnvironment();
+    globalForPrisma = globalThis;
+    currentDbUrl = process.env.DATABASE_URL;
+    console.log(`\u{1F4CA} DB connection target: ${currentDbUrl}`);
+    if (globalForPrisma.prisma && globalForPrisma.lastDbUrl !== currentDbUrl) {
+      console.log(`\u{1F504} DATABASE_URL changed from ${globalForPrisma.lastDbUrl} to ${currentDbUrl}, reconnecting...`);
+      globalForPrisma.prisma.$disconnect().catch(console.error);
+      globalForPrisma.prisma = void 0;
+    }
+    prisma = globalForPrisma.prisma ?? new PrismaClient({
+      log: process.env.NODE_ENV === "development" ? ["error", "warn"] : ["error"]
+    });
+    globalForPrisma.prisma = prisma;
+    globalForPrisma.lastDbUrl = currentDbUrl;
+  }
 });
-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 WORKSPACE_SKILLS_PATHS, ErrorCode;
+var init_dist = __esm({
+  "../shared/dist/index.js"() {
+    "use strict";
+    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: ""
+      }
+    };
+    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"
+    };
   }
-};
-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) {
@@ -125,11 +148,35 @@ function errorHandler(err, req, res, next) {
     message: process.env.NODE_ENV === "development" ? err.message : void 0
   });
 }
+var AppError;
+var init_errorHandler = __esm({
+  "src/middleware/errorHandler.ts"() {
+    "use strict";
+    init_dist();
+    AppError = class extends Error {
+      constructor(code, message, statusCode = 500, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = "AppError";
+      }
+    };
+  }
+});
 
 // 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");
+var skillService_exports = {};
+__export(skillService_exports, {
+  SkillService: () => SkillService,
+  skillService: () => skillService
+});
+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";
 function parseGitUrl(url) {
   if (!url.includes("/tree/")) {
     const urlParts = url.split("/");
@@ -144,511 +191,621 @@ function parseGitUrl(url) {
   const skillName = pathParts[pathParts.length - 1];
   return { repoUrl, subdir, skillName };
 }
-var SkillService = class {
-  async getAllSkills() {
-    const skills = await prisma.skill.findMany({
-      include: {
-        linkedWorkspaces: {
+var getPaths, SkillService, skillService;
+var init_skillService = __esm({
+  "src/services/skillService.ts"() {
+    "use strict";
+    init_db();
+    init_errorHandler();
+    init_dist();
+    getPaths = () => {
+      const home = process.env.SKILLVERSE_HOME || join2(process.env.HOME || "", ".skillverse");
+      return {
+        home,
+        skills: process.env.SKILLS_DIR || join2(home, "skills"),
+        temp: process.env.TEMP_DIR || join2(home, "temp")
+      };
+    };
+    SkillService = class {
+      async getAllSkills() {
+        const skills = await prisma.skill.findMany({
           include: {
-            workspace: true
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: true
+          },
+          orderBy: {
+            installDate: "desc"
           }
-        },
-        marketplaceEntry: true
-      },
-      orderBy: {
-        installDate: "desc"
+        });
+        return skills;
       }
-    });
-    return skills;
-  }
-  async getSkillById(id) {
-    const skill = await prisma.skill.findUnique({
-      where: { id },
-      include: {
-        linkedWorkspaces: {
+      async getSkillById(id) {
+        const skill = await prisma.skill.findUnique({
+          where: { id },
           include: {
-            workspace: true
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: true
           }
-        },
-        marketplaceEntry: true
+        });
+        if (!skill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Skill not found", 404);
+        }
+        return skill;
       }
-    });
-    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: {
+      async getSkillByName(name) {
+        const skill = await prisma.skill.findUnique({
+          where: { name },
           include: {
-            workspace: true
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: 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 };
+        });
+        if (!skill) {
+          throw new AppError(ErrorCode.NOT_FOUND, `Skill "${name}" not found`, 404);
         }
+        return skill;
       }
-      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);
+      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: {} };
+        }
       }
-      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);
+      async createSkillFromGit(gitUrl, description) {
+        let tempPath = null;
         try {
-          commitHash = await simpleGit(tempPath).revparse(["HEAD"]);
-          console.log(`Captured commit hash: ${commitHash}`);
-        } catch (e) {
-          console.warn("Failed to capture commit hash:", e);
+          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 { skills: skillsDir, temp: tempDir } = getPaths();
+          const skillPath = join2(skillsDir, skillName);
+          if (existsSync2(skillPath)) {
+            throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+          }
+          let commitHash = "";
+          if (subdir) {
+            tempPath = join2(tempDir, `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);
+          }
         }
-        const sourcePath = join2(tempPath, subdir);
-        if (!existsSync2(sourcePath)) {
-          throw new AppError(
-            ErrorCode.GIT_ERROR,
-            `Subdirectory "${subdir}" not found in repository`,
-            400
-          );
+      }
+      async createSkillFromDirectory(path, name, description) {
+        if (!existsSync2(path)) {
+          throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Source path not found: ${path}`, 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
-          );
+        const { skills: skillsDir } = getPaths();
+        const skillName = name || basename(path);
+        const skillPath = join2(skillsDir, skillName);
+        const existingSkill = await prisma.skill.findUnique({
+          where: { name: skillName }
+        });
+        if (existingSkill) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${skillName}" already exists`, 409);
         }
-        await mkdir(skillPath, { recursive: true });
-        await cp(sourcePath, skillPath, { recursive: true });
-      } else {
-        if (!existsSync2(skillPath)) {
-          await mkdir(skillPath, { recursive: true });
+        if (existsSync2(skillPath)) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
         }
-        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);
+          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;
         }
       }
-      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)
+      /**
+       * 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);
+          }
         }
-      });
-      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(() => {
+      async createSkillFromLocal(name, zipPath, description) {
+        const { skills: skillsDir, temp: tempDir } = getPaths();
+        const skillPath = join2(skillsDir, name);
+        const existingSkill = await prisma.skill.findUnique({
+          where: { name }
         });
-      }
-      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));
+        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(tempDir, `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;
         }
-        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)
+      /**
+       * 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++;
         }
-      });
-      return skill;
-    } catch (error) {
-      if (existsSync2(skillPath)) {
-        await rm(skillPath, { recursive: true, force: true }).catch(() => {
+        const { skills: skillsDir, temp: tempDir } = getPaths();
+        const skillPath = join2(skillsDir, name);
+        const extractPath = join2(tempDir, `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;
       }
-      if (existsSync2(extractPath)) {
-        await rm(extractPath, { recursive: true, force: true }).catch(() => {
+      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" };
       }
-      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);
+      // 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 { temp: tempDir } = getPaths();
+        const tempPath = join2(tempDir, `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(() => {
+          });
+        }
       }
-      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)
+      async checkUpdates(ids) {
+        const whereClause = {
+          source: "git",
+          repoUrl: { not: null }
+        };
+        if (ids && ids.length > 0) {
+          whereClause.id = { in: ids };
         }
-      });
-      console.log(`\u{1F4E6} Installed skill "${name}" from bundle`);
-      return skill;
-    } catch (error) {
-      if (existsSync2(skillPath)) {
-        await rm(skillPath, { recursive: true, force: true }).catch(() => {
-        });
+        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;
       }
-      if (existsSync2(extractPath)) {
-        await rm(extractPath, { recursive: true, force: true }).catch(() => {
+      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;
       }
-      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) {
+      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 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}`);
+          const { repoUrl, subdir } = parseGitUrl(skill.sourceUrl);
+          const { temp: tempDir } = getPaths();
+          tempPath = join2(tempDir, `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.warn(`Failed to remove symlink for ${skill.name} in workspace ${link.workspace.path}:`, 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(() => {
+          });
         }
       }
-    }
-    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
+      async scanForSkills() {
+        const { skills: skillsDir } = getPaths();
+        console.log(`Scanning for skills in ${skillsDir}...`);
+        if (!existsSync2(skillsDir)) {
+          console.log("Skills directory does not exist, skipping scan.");
+          return;
         }
-      });
-      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 entries = await import("fs/promises").then((fs) => fs.readdir(skillsDir, { withFileTypes: true }));
+        const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        console.log(`Found ${directories.length} directories in skills folder.`);
+        let importedCount = 0;
+        for (const dirName of directories) {
+          const skillPath = join2(skillsDir, dirName);
+          const existingSkill = await prisma.skill.findUnique({
+            where: { name: dirName }
+          });
+          if (existingSkill) {
+            continue;
+          }
+          const hasSkillMd = existsSync2(join2(skillPath, "SKILL.md"));
+          const hasPackageJson = existsSync2(join2(skillPath, "package.json"));
+          const hasSkillJson = existsSync2(join2(skillPath, "skill.json"));
+          if (!hasSkillMd && !hasPackageJson && !hasSkillJson) {
+            console.log(`Skipping ${dirName}: No skill metadata found.`);
+            continue;
+          }
+          try {
+            console.log(`Importing skill: ${dirName}`);
+            const parsed = await this.parseSkillMetadata(skillPath);
+            let source = "local";
+            let sourceUrl = void 0;
+            let repoUrl = void 0;
+            let commitHash = void 0;
+            if (existsSync2(join2(skillPath, ".git"))) {
+              source = "git";
+              try {
+                const git = simpleGit(skillPath);
+                const remotes = await git.getRemotes(true);
+                if (remotes.length > 0) {
+                  sourceUrl = remotes[0].refs.fetch;
+                  repoUrl = sourceUrl;
+                }
+                commitHash = await git.revparse(["HEAD"]);
+              } catch (e) {
+                console.warn(`Failed to read git info for ${dirName}:`, e);
+              }
+            }
+            await prisma.skill.create({
+              data: {
+                name: dirName,
+                source,
+                sourceUrl,
+                repoUrl,
+                commitHash,
+                description: parsed.description,
+                storagePath: skillPath,
+                metadata: JSON.stringify(parsed.metadata)
+              }
+            });
+            importedCount++;
+          } catch (error) {
+            console.error(`Failed to import skill ${dirName}:`, error);
+          }
         }
+        console.log(`Scan complete. Imported ${importedCount} new skills.`);
+        return importedCount;
       }
-      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(() => {
-      });
-    }
+    };
+    skillService = new SkillService();
   }
-};
-var skillService = new SkillService();
+});
+
+// src/index.ts
+import express from "express";
+import cors from "cors";
+import dotenv2 from "dotenv";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname3, join as join8 } from "path";
+import { mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+
+// src/routes/skills.ts
+init_skillService();
+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/workspaceService.ts
+init_db();
+init_errorHandler();
+init_dist();
 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";
@@ -971,17 +1128,17 @@ ${relativeSkillsPath}/
    */
   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 SKILLVERSE_HOME = process.env.SKILLVERSE_HOME || join3(homedir(), ".skillverse");
+    const SKILLS_DIR = process.env.SKILLS_DIR || join3(SKILLVERSE_HOME, "skills");
+    if (!existsSync3(SKILLS_DIR)) {
+      await mkdir2(SKILLS_DIR, { 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);
+      const targetPath = join3(SKILLS_DIR, skillName);
       try {
         if (!existsSync3(sourcePath)) {
           errors.push(`${skillName}: Source path not found`);
@@ -1053,13 +1210,13 @@ 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 TEMP_DIR = process.env.TEMP_DIR || join4(process.env.HOME || "", ".skillverse", "temp");
+if (!existsSync4(TEMP_DIR)) {
+  mkdir3(TEMP_DIR, { recursive: true });
 }
 var storage = multer.diskStorage({
   destination: (req, file, cb) => {
-    cb(null, TEMP_DIR2);
+    cb(null, TEMP_DIR);
   },
   filename: (req, file, cb) => {
     const uniqueSuffix = Date.now() + "-" + Math.round(Math.random() * 1e9);
@@ -1434,6 +1591,8 @@ router2.post("/:id/migrate-skills", async (req, res, next) => {
 var workspaces_default = router2;
 
 // src/routes/marketplace.ts
+init_db();
+init_skillService();
 import { Router as Router3 } from "express";
 
 // src/services/bundleService.ts
@@ -1517,6 +1676,8 @@ var bundleService = {
 };
 
 // src/routes/marketplace.ts
+init_errorHandler();
+init_dist();
 import { existsSync as existsSync6 } from "fs";
 var router3 = Router3();
 router3.get("/skills", async (req, res, next) => {
@@ -1730,6 +1891,7 @@ router3.delete("/unpublish/:skillId", async (req, res, next) => {
 var marketplace_default = router3;
 
 // src/routes/dashboard.ts
+init_db();
 import { Router as Router4 } from "express";
 var router4 = Router4();
 router4.get("/stats", async (req, res, next) => {
@@ -1821,6 +1983,107 @@ router4.get("/activity", async (req, res, next) => {
 });
 var dashboard_default = router4;
 
+// src/routes/config.ts
+import { Router as Router5 } from "express";
+import { join as join6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync2, writeFileSync } from "fs";
+var router5 = Router5();
+var HOME = process.env.HOME || process.env.USERPROFILE || "";
+var BOOTSTRAP_HOME = join6(HOME, ".skillverse");
+var CONFIG_FILE = join6(BOOTSTRAP_HOME, "config.json");
+function readConfig() {
+  if (existsSync7(CONFIG_FILE)) {
+    try {
+      return JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
+    } catch (e) {
+      console.error("Failed to read config.json:", e);
+      return {};
+    }
+  }
+  return {};
+}
+router5.get("/", (req, res, next) => {
+  try {
+    const fileConfig = readConfig();
+    const config3 = {
+      // Show saved preference if available, otherwise current env/default
+      skillverseHome: fileConfig.skillverseHome || process.env.SKILLVERSE_HOME || BOOTSTRAP_HOME,
+      // registryUrl is potentially in config.json already
+      registryUrl: fileConfig.registryUrl || process.env.SKILLVERSE_REGISTRY || "http://localhost:4000"
+      // ... add other configurable items
+    };
+    res.json({
+      success: true,
+      data: config3
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router5.post("/", async (req, res, next) => {
+  try {
+    const { skillverseHome, registryUrl, migrate } = req.body;
+    const currentConfig = readConfig();
+    const oldHome = process.env.SKILLVERSE_HOME || BOOTSTRAP_HOME;
+    if (migrate && skillverseHome && skillverseHome !== oldHome) {
+      console.log(`Migrating data from ${oldHome} to ${skillverseHome}...`);
+      const { cp: cp2 } = await import("fs/promises");
+      if (!existsSync7(skillverseHome)) {
+        const { mkdir: mkdir6 } = await import("fs/promises");
+        await mkdir6(skillverseHome, { recursive: true });
+      }
+      const copyDir = async (srcName) => {
+        const src = join6(oldHome, srcName);
+        const dest = join6(skillverseHome, srcName);
+        if (existsSync7(src)) {
+          console.log(`Copying ${srcName}...`);
+          await cp2(src, dest, { recursive: true, force: true });
+        }
+      };
+      await copyDir("skills");
+      await copyDir("marketplace");
+      const dbSrc = join6(oldHome, "skillverse.db");
+      const dbDest = join6(skillverseHome, "skillverse.db");
+      if (existsSync7(dbSrc)) {
+        console.log("Copying database...");
+        await cp2(dbSrc, dbDest, { force: true });
+        const walSrc = dbSrc + "-wal";
+        if (existsSync7(walSrc)) await cp2(walSrc, dbDest + "-wal", { force: true });
+        const shmSrc = dbSrc + "-shm";
+        if (existsSync7(shmSrc)) await cp2(shmSrc, dbDest + "-shm", { force: true });
+        console.log("Updating skill paths in new database...");
+        const { execSync } = await import("child_process");
+        const oldSkillsPath = join6(oldHome, "skills");
+        const newSkillsPath = join6(skillverseHome, "skills");
+        const updateQuery = `UPDATE Skill SET storagePath = replace(storagePath, '${oldSkillsPath}', '${newSkillsPath}') WHERE storagePath LIKE '${oldSkillsPath}%';`;
+        try {
+          execSync(`sqlite3 "${dbDest}" "${updateQuery}"`, { encoding: "utf-8" });
+          console.log("\u2705 Updated skill paths in new database");
+        } catch (sqlErr) {
+          console.error("Failed to update skill paths:", sqlErr);
+        }
+      }
+    }
+    const newConfig = {
+      ...currentConfig,
+      ...skillverseHome && { skillverseHome },
+      ...registryUrl && { registryUrl }
+    };
+    writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+    res.json({
+      success: true,
+      data: newConfig,
+      message: "Configuration saved. Restart server for changes to take effect."
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+var config_default = router5;
+
+// src/index.ts
+init_errorHandler();
+
 // src/middleware/logger.ts
 function requestLogger(req, res, next) {
   const start = Date.now();
@@ -1832,8 +2095,9 @@ function requestLogger(req, res, next) {
 }
 
 // src/lib/initDb.ts
-import { existsSync as existsSync7 } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
+init_db();
+import { existsSync as existsSync8 } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { spawnSync } from "child_process";
 var __filename2 = fileURLToPath2(import.meta.url);
@@ -1841,15 +2105,15 @@ var __dirname2 = dirname2(__filename2);
 function getSchemaPath() {
   const possiblePaths = [
     // Prod: dist/bin.js -> dist/../prisma/schema.prisma (i.e. ROOT/prisma/schema.prisma)
-    join6(__dirname2, "../prisma/schema.prisma"),
+    join7(__dirname2, "../prisma/schema.prisma"),
     // Dev: src/lib/initDb.ts -> src/prisma/schema.prisma ? No, src/../prisma -> server/prisma
     // If __dirname is src/lib: ../../prisma/schema.prisma
-    join6(__dirname2, "../../prisma/schema.prisma"),
+    join7(__dirname2, "../../prisma/schema.prisma"),
     // Fallbacks
-    join6(process.cwd(), "prisma/schema.prisma"),
-    join6(process.cwd(), "server/prisma/schema.prisma")
+    join7(process.cwd(), "prisma/schema.prisma"),
+    join7(process.cwd(), "server/prisma/schema.prisma")
   ];
-  return possiblePaths.find((p) => existsSync7(p)) || null;
+  return possiblePaths.find((p) => existsSync8(p)) || null;
 }
 async function ensureDatabaseInitialized() {
   try {
@@ -1874,12 +2138,12 @@ async function initializeDatabase() {
     throw new Error("Could not find schema.prisma");
   }
   const possiblePrismaBins = [
-    join6(__dirname2, "../node_modules/.bin/prisma"),
-    join6(__dirname2, "../../node_modules/.bin/prisma"),
-    join6(__dirname2, "../../../node_modules/.bin/prisma"),
-    join6(process.cwd(), "node_modules/.bin/prisma")
+    join7(__dirname2, "../node_modules/.bin/prisma"),
+    join7(__dirname2, "../../node_modules/.bin/prisma"),
+    join7(__dirname2, "../../../node_modules/.bin/prisma"),
+    join7(process.cwd(), "node_modules/.bin/prisma")
   ];
-  const prismaBin = possiblePrismaBins.find((p) => existsSync7(p)) || "prisma";
+  const prismaBin = possiblePrismaBins.find((p) => existsSync8(p)) || "prisma";
   console.log(`   Using schema: ${schemaPath}`);
   const result = spawnSync(prismaBin, ["db", "push", "--schema", schemaPath], {
     stdio: "inherit",
@@ -1906,16 +2170,16 @@ app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 app.use(requestLogger);
 var possiblePublicDirs = [
-  join7(__dirname3, "../public"),
+  join8(__dirname3, "../public"),
   // Production: dist/index.js -> public
-  join7(__dirname3, "../../public"),
+  join8(__dirname3, "../../public"),
   // Dev tsx might resolve here 
-  join7(process.cwd(), "public"),
+  join8(process.cwd(), "public"),
   // Fallback: relative to cwd
-  join7(process.cwd(), "server/public")
+  join8(process.cwd(), "server/public")
   // Fallback: from root
 ];
-var publicDir = possiblePublicDirs.find((dir) => existsSync8(dir));
+var publicDir = possiblePublicDirs.find((dir) => existsSync9(dir));
 if (publicDir) {
   app.use(express.static(publicDir));
   console.log(`\u{1F4C2} Serving static files from: ${publicDir}`);
@@ -1926,35 +2190,39 @@ 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.use("/api/config", config_default);
 app.get("/health", (req, res) => {
   res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
 });
-if (publicDir && existsSync8(publicDir)) {
+if (publicDir && existsSync9(publicDir)) {
   app.get("*", (req, res) => {
-    res.sendFile(join7(publicDir, "index.html"));
+    res.sendFile(join8(publicDir, "index.html"));
   });
 }
 app.use(errorHandler);
 async function initializeStorage() {
-  const skillverseHome = process.env.SKILLVERSE_HOME || join7(process.env.HOME || "", ".skillverse");
-  const skillsDir = process.env.SKILLS_DIR || join7(skillverseHome, "skills");
-  const marketplaceDir = process.env.MARKETPLACE_DIR || join7(skillverseHome, "marketplace");
+  const skillverseHome = process.env.SKILLVERSE_HOME || join8(process.env.HOME || "", ".skillverse");
+  const skillsDir = process.env.SKILLS_DIR || join8(skillverseHome, "skills");
+  const marketplaceDir = process.env.MARKETPLACE_DIR || join8(skillverseHome, "marketplace");
   const dirs = [skillverseHome, skillsDir, marketplaceDir];
   for (const dir of dirs) {
-    if (!existsSync8(dir)) {
+    if (!existsSync9(dir)) {
       await mkdir5(dir, { recursive: true });
       console.log(`Created directory: ${dir}`);
     }
   }
 }
-async function startServer(port = parseInt(process.env.PORT || "3001")) {
+async function startServer(port = 3001) {
   try {
     await initializeStorage();
     await ensureDatabaseInitialized();
+    console.log("\u{1F50D} Scanning for existing skills...");
+    const { skillService: skillService2 } = await Promise.resolve().then(() => (init_skillService(), skillService_exports));
+    await skillService2.scanForSkills();
     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 || join7(process.env.HOME || "", ".skillverse")}`);
+        console.log(`\u{1F4C1} Storage: ${process.env.SKILLVERSE_HOME || join8(process.env.HOME || "", ".skillverse")}`);
         resolve();
       });
     });