skillverse 0.1.4 → 0.1.6

package/dist/bin.js

@@ -11,12 +11,26 @@ var __export = (target, all) => {
 
 // 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";
 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 {
@@ -25,10 +39,14 @@ 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
@@ -47,16 +65,25 @@ var init_config = __esm({
 
 // src/lib/db.ts
 import { PrismaClient } from "@prisma/client";
-var globalForPrisma, prisma;
+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"]
     });
-    if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+    globalForPrisma.prisma = prisma;
+    globalForPrisma.lastDbUrl = currentDbUrl;
   }
 });
 
@@ -211,6 +238,11 @@ var init_errorHandler = __esm({
 });
 
 // src/services/skillService.ts
+var skillService_exports = {};
+__export(skillService_exports, {
+  SkillService: () => SkillService,
+  skillService: () => skillService
+});
 import { join as join3, basename } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { mkdir, rm, cp, readFile, unlink } from "fs/promises";
@@ -231,16 +263,21 @@ function parseGitUrl(url) {
   const skillName = pathParts[pathParts.length - 1];
   return { repoUrl, subdir, skillName };
 }
-var SKILLVERSE_HOME, SKILLS_DIR, TEMP_DIR, SkillService, skillService;
+var getPaths, SkillService, skillService;
 var init_skillService = __esm({
   "src/services/skillService.ts"() {
     "use strict";
     init_db();
     init_errorHandler();
     init_dist();
-    SKILLVERSE_HOME = process.env.SKILLVERSE_HOME || join3(process.env.HOME || "", ".skillverse");
-    SKILLS_DIR = process.env.SKILLS_DIR || join3(SKILLVERSE_HOME, "skills");
-    TEMP_DIR = process.env.TEMP_DIR || join3(SKILLVERSE_HOME, "temp");
+    getPaths = () => {
+      const home = process.env.SKILLVERSE_HOME || join3(process.env.HOME || "", ".skillverse");
+      return {
+        home,
+        skills: process.env.SKILLS_DIR || join3(home, "skills"),
+        temp: process.env.TEMP_DIR || join3(home, "temp")
+      };
+    };
     SkillService = class {
       async getAllSkills() {
         const skills = await prisma.skill.findMany({
@@ -334,13 +371,14 @@ var init_skillService = __esm({
           if (existingSkill) {
             throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${skillName}" already exists`, 409);
           }
-          const skillPath = join3(SKILLS_DIR, skillName);
+          const { skills: skillsDir, temp: tempDir } = getPaths();
+          const skillPath = join3(skillsDir, skillName);
           if (existsSync3(skillPath)) {
             throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
           }
           let commitHash = "";
           if (subdir) {
-            tempPath = join3(TEMP_DIR, `git-clone-${Date.now()}`);
+            tempPath = join3(tempDir, `git-clone-${Date.now()}`);
             await mkdir(tempPath, { recursive: true });
             console.log(`Cloning ${repoUrl} to temp path for extraction...`);
             const git = simpleGit();
@@ -411,8 +449,9 @@ var init_skillService = __esm({
         if (!existsSync3(path)) {
           throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Source path not found: ${path}`, 400);
         }
+        const { skills: skillsDir } = getPaths();
         const skillName = name || basename(path);
-        const skillPath = join3(SKILLS_DIR, skillName);
+        const skillPath = join3(skillsDir, skillName);
         const existingSkill = await prisma.skill.findUnique({
           where: { name: skillName }
         });
@@ -467,7 +506,8 @@ var init_skillService = __esm({
         }
       }
       async createSkillFromLocal(name, zipPath, description) {
-        const skillPath = join3(SKILLS_DIR, name);
+        const { skills: skillsDir, temp: tempDir } = getPaths();
+        const skillPath = join3(skillsDir, name);
         const existingSkill = await prisma.skill.findUnique({
           where: { name }
         });
@@ -477,7 +517,7 @@ var init_skillService = __esm({
         if (existsSync3(skillPath)) {
           throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
         }
-        const extractPath = join3(TEMP_DIR, `extract-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+        const extractPath = join3(tempDir, `extract-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
         await mkdir(extractPath, { recursive: true });
         try {
           const zip = new AdmZip(zipPath);
@@ -523,8 +563,9 @@ var init_skillService = __esm({
           name = `${originalName}-${counter}`;
           counter++;
         }
-        const skillPath = join3(SKILLS_DIR, name);
-        const extractPath = join3(TEMP_DIR, `extract-bundle-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+        const { skills: skillsDir, temp: tempDir } = getPaths();
+        const skillPath = join3(skillsDir, name);
+        const extractPath = join3(tempDir, `extract-bundle-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
         await mkdir(extractPath, { recursive: true });
         try {
           const { createReadStream: createReadStream2 } = await import("fs");
@@ -617,7 +658,8 @@ var init_skillService = __esm({
             message: "Not a git skill or missing repo URL"
           };
         }
-        const tempPath = join3(TEMP_DIR, `check-update-${Date.now()}`);
+        const { temp: tempDir } = getPaths();
+        const tempPath = join3(tempDir, `check-update-${Date.now()}`);
         await mkdir(tempPath, { recursive: true });
         try {
           const git = simpleGit();
@@ -690,7 +732,8 @@ var init_skillService = __esm({
         let tempSkillPath = null;
         try {
           const { repoUrl, subdir } = parseGitUrl(skill.sourceUrl);
-          tempPath = join3(TEMP_DIR, `upgrade-${Date.now()}`);
+          const { temp: tempDir } = getPaths();
+          tempPath = join3(tempDir, `upgrade-${Date.now()}`);
           await mkdir(tempPath, { recursive: true });
           const git = simpleGit();
           console.log(`Cloning ${repoUrl} to temp for upgrade...`);
@@ -742,6 +785,99 @@ var init_skillService = __esm({
           });
         }
       }
+      /**
+       * Sync skills between filesystem and database:
+       * 1. Remove orphaned database records (skills in DB but not on disk)
+       * 2. Import new skills from disk (skills on disk but not in DB)
+       */
+      async syncSkillsWithFileSystem() {
+        const { skills: skillsDir } = getPaths();
+        const dbSkills = await prisma.skill.findMany();
+        let removedCount = 0;
+        for (const skill of dbSkills) {
+          if (!existsSync3(skill.storagePath)) {
+            console.log(`\u{1F5D1}\uFE0F Removing orphaned skill from database: ${skill.name} (path: ${skill.storagePath})`);
+            try {
+              await prisma.skill.delete({ where: { id: skill.id } });
+              removedCount++;
+            } catch (error) {
+              console.error(`Failed to remove orphaned skill ${skill.name}:`, error);
+            }
+          }
+        }
+        if (removedCount > 0) {
+          console.log(`\u2705 Removed ${removedCount} orphaned skill(s) from database.`);
+        }
+        const importedCount = await this.scanForSkills();
+        return { removedCount, importedCount: importedCount || 0 };
+      }
+      async scanForSkills() {
+        const { skills: skillsDir } = getPaths();
+        console.log(`Scanning for skills in ${skillsDir}...`);
+        if (!existsSync3(skillsDir)) {
+          console.log("Skills directory does not exist, skipping scan.");
+          return;
+        }
+        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 = join3(skillsDir, dirName);
+          const existingSkill = await prisma.skill.findUnique({
+            where: { name: dirName }
+          });
+          if (existingSkill) {
+            continue;
+          }
+          const hasSkillMd = existsSync3(join3(skillPath, "SKILL.md"));
+          const hasPackageJson = existsSync3(join3(skillPath, "package.json"));
+          const hasSkillJson = existsSync3(join3(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 (existsSync3(join3(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;
+      }
     };
     skillService = new SkillService();
   }
@@ -1077,17 +1213,17 @@ ${relativeSkillsPath}/
        */
       async migrateExistingSkills(workspaceId, skillNames) {
         const workspace = await this.getWorkspaceById(workspaceId);
-        const SKILLVERSE_HOME3 = process.env.SKILLVERSE_HOME || join4(homedir(), ".skillverse");
-        const SKILLS_DIR2 = process.env.SKILLS_DIR || join4(SKILLVERSE_HOME3, "skills");
-        if (!existsSync4(SKILLS_DIR2)) {
-          await mkdir2(SKILLS_DIR2, { recursive: true });
+        const SKILLVERSE_HOME2 = process.env.SKILLVERSE_HOME || join4(homedir(), ".skillverse");
+        const SKILLS_DIR = process.env.SKILLS_DIR || join4(SKILLVERSE_HOME2, "skills");
+        if (!existsSync4(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 = join4(workspace.path, skillName);
-          const targetPath = join4(SKILLS_DIR2, skillName);
+          const targetPath = join4(SKILLS_DIR, skillName);
           try {
             if (!existsSync4(sourcePath)) {
               errors.push(`${skillName}: Source path not found`);
@@ -1165,20 +1301,20 @@ import multer from "multer";
 import { join as join5 } from "path";
 import { existsSync as existsSync5 } from "fs";
 import { mkdir as mkdir3, rm as rm3 } from "fs/promises";
-var router, TEMP_DIR2, storage, upload, skills_default;
+var router, TEMP_DIR, storage, upload, skills_default;
 var init_skills = __esm({
   "src/routes/skills.ts"() {
     "use strict";
     init_skillService();
     init_workspaceService();
     router = Router();
-    TEMP_DIR2 = process.env.TEMP_DIR || join5(process.env.HOME || "", ".skillverse", "temp");
-    if (!existsSync5(TEMP_DIR2)) {
-      mkdir3(TEMP_DIR2, { recursive: true });
+    TEMP_DIR = process.env.TEMP_DIR || join5(process.env.HOME || "", ".skillverse", "temp");
+    if (!existsSync5(TEMP_DIR)) {
+      mkdir3(TEMP_DIR, { recursive: true });
     }
     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);
@@ -1210,6 +1346,18 @@ var init_skills = __esm({
         next(error);
       }
     });
+    router.post("/sync", async (req, res, next) => {
+      try {
+        const result = await skillService.syncSkillsWithFileSystem();
+        res.json({
+          success: true,
+          data: result,
+          message: `Synced: removed ${result.removedCount} orphan(s), imported ${result.importedCount} new skill(s)`
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
     router.get("/:id", async (req, res, next) => {
       try {
         const skill = await skillService.getSkillById(req.params.id);
@@ -1980,6 +2128,156 @@ var init_dashboard = __esm({
   }
 });
 
+// src/routes/config.ts
+import { Router as Router5 } from "express";
+import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync2, writeFileSync } from "fs";
+function readConfig() {
+  if (existsSync8(CONFIG_FILE)) {
+    try {
+      return JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
+    } catch (e) {
+      console.error("Failed to read config.json:", e);
+      return {};
+    }
+  }
+  return {};
+}
+var router5, HOME, BOOTSTRAP_HOME, CONFIG_FILE, config_default;
+var init_config2 = __esm({
+  "src/routes/config.ts"() {
+    "use strict";
+    router5 = Router5();
+    HOME = process.env.HOME || process.env.USERPROFILE || "";
+    BOOTSTRAP_HOME = join7(HOME, ".skillverse");
+    CONFIG_FILE = join7(BOOTSTRAP_HOME, "config.json");
+    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 (!existsSync8(skillverseHome)) {
+            const { mkdir: mkdir6 } = await import("fs/promises");
+            await mkdir6(skillverseHome, { recursive: true });
+          }
+          const copyDir = async (srcName) => {
+            const src = join7(oldHome, srcName);
+            const dest = join7(skillverseHome, srcName);
+            if (existsSync8(src)) {
+              console.log(`Copying ${srcName}...`);
+              await cp2(src, dest, { recursive: true, force: true });
+            }
+          };
+          await copyDir("skills");
+          await copyDir("marketplace");
+          const dbSrc = join7(oldHome, "skillverse.db");
+          const dbDest = join7(skillverseHome, "skillverse.db");
+          if (existsSync8(dbSrc)) {
+            console.log("Copying database...");
+            await cp2(dbSrc, dbDest, { force: true });
+            const walSrc = dbSrc + "-wal";
+            if (existsSync8(walSrc)) await cp2(walSrc, dbDest + "-wal", { force: true });
+            const shmSrc = dbSrc + "-shm";
+            if (existsSync8(shmSrc)) await cp2(shmSrc, dbDest + "-shm", { force: true });
+            console.log("Updating skill paths in new database...");
+            const { execSync } = await import("child_process");
+            const oldSkillsPath = join7(oldHome, "skills");
+            const newSkillsPath = join7(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);
+      }
+    });
+    router5.get("/version", async (req, res, next) => {
+      try {
+        const { dirname: dirname4, join: pathJoin } = await import("path");
+        const { fileURLToPath: fileURLToPath4 } = await import("url");
+        const __filename4 = fileURLToPath4(import.meta.url);
+        const __dirname4 = dirname4(__filename4);
+        const packageJsonPath = pathJoin(__dirname4, "..", "..", "package.json");
+        let currentVersion = "0.0.0";
+        if (existsSync8(packageJsonPath)) {
+          const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+          currentVersion = pkg.version || "0.0.0";
+        }
+        let latestVersion = currentVersion;
+        let hasUpdate = false;
+        try {
+          const response = await fetch("https://registry.npmjs.org/skillverse/latest");
+          if (response.ok) {
+            const data = await response.json();
+            latestVersion = data.version || currentVersion;
+            const parseVersion = (v) => v.split(".").map((n) => parseInt(n, 10) || 0);
+            const current = parseVersion(currentVersion);
+            const latest = parseVersion(latestVersion);
+            for (let i = 0; i < 3; i++) {
+              if (latest[i] > current[i]) {
+                hasUpdate = true;
+                break;
+              } else if (latest[i] < current[i]) {
+                break;
+              }
+            }
+          }
+        } catch (fetchError) {
+          console.warn("Failed to check npm registry for updates:", fetchError);
+        }
+        res.json({
+          success: true,
+          data: {
+            currentVersion,
+            latestVersion,
+            hasUpdate
+          }
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    config_default = router5;
+  }
+});
+
 // src/middleware/logger.ts
 function requestLogger(req, res, next) {
   const start = Date.now();
@@ -2004,16 +2302,16 @@ 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 { dirname as dirname3, join as join8 } from "path";
 import { mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 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}`);
     }
@@ -2023,10 +2321,13 @@ async function startServer(port = 3001) {
   try {
     await initializeStorage();
     await ensureDatabaseInitialized();
+    console.log("\u{1F50D} Syncing skills with filesystem...");
+    const { skillService: skillService2 } = await Promise.resolve().then(() => (init_skillService(), skillService_exports));
+    await skillService2.syncSkillsWithFileSystem();
     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();
       });
     });
@@ -2043,6 +2344,7 @@ var init_index = __esm({
     init_workspaces();
     init_marketplace();
     init_dashboard();
+    init_config2();
     init_errorHandler();
     init_logger();
     init_initDb();
@@ -2056,16 +2358,16 @@ var init_index = __esm({
     app.use(express.urlencoded({ extended: true }));
     app.use(requestLogger);
     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
     ];
-    publicDir = possiblePublicDirs.find((dir) => existsSync8(dir));
+    publicDir = possiblePublicDirs.find((dir) => existsSync9(dir));
     if (publicDir) {
       app.use(express.static(publicDir));
       console.log(`\u{1F4C2} Serving static files from: ${publicDir}`);
@@ -2076,12 +2378,13 @@ var init_index = __esm({
     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);
@@ -2098,33 +2401,33 @@ init_skillService();
 init_workspaceService();
 import { program } from "commander";
 import open from "open";
-import { existsSync as existsSync9, readFileSync, writeFileSync } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join9 } from "path";
 import readline from "readline";
-var { skillverseHome: SKILLVERSE_HOME2 } = config;
-var AUTH_FILE = join8(SKILLVERSE_HOME2, "auth.json");
-var CONFIG_FILE = join8(SKILLVERSE_HOME2, "config.json");
+var { skillverseHome: SKILLVERSE_HOME } = config;
+var AUTH_FILE = join9(SKILLVERSE_HOME, "auth.json");
+var CONFIG_FILE2 = join9(SKILLVERSE_HOME, "config.json");
 program.hook("preAction", async (thisCommand, actionCommand) => {
   if (["list", "start", "install", "add", "remove", "import", "search"].includes(actionCommand.name())) {
     await ensureDatabaseInitialized();
   }
 });
 function getRegistryUrl() {
-  if (existsSync9(CONFIG_FILE)) {
-    const config2 = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-    return config2.registryUrl || "http://localhost:4000";
+  if (existsSync10(CONFIG_FILE2)) {
+    const config3 = JSON.parse(readFileSync3(CONFIG_FILE2, "utf-8"));
+    return config3.registryUrl || "http://localhost:4000";
   }
   return process.env.SKILLVERSE_REGISTRY || "http://localhost:4000";
 }
 function getAuthToken() {
-  if (existsSync9(AUTH_FILE)) {
-    const auth = JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+  if (existsSync10(AUTH_FILE)) {
+    const auth = JSON.parse(readFileSync3(AUTH_FILE, "utf-8"));
     return auth.token || null;
   }
   return null;
 }
 function saveAuth(token, user) {
-  writeFileSync(AUTH_FILE, JSON.stringify({ token, user }, null, 2));
+  writeFileSync2(AUTH_FILE, JSON.stringify({ token, user }, null, 2));
 }
 async function prompt(question, hidden = false) {
   const rl = readline.createInterface({
@@ -2215,7 +2518,7 @@ program.command("publish [path]").description("Publish a skill to the Registry")
   }
   const targetPath = skillPath || process.cwd();
   const registryUrl = options.registry || getRegistryUrl();
-  if (!existsSync9(targetPath)) {
+  if (!existsSync10(targetPath)) {
     console.error(`
 \u274C Path not found: ${targetPath}`);
     process.exit(1);
@@ -2230,7 +2533,7 @@ program.command("publish [path]").description("Publish a skill to the Registry")
     const form = new FormData();
     form.append("name", skillName);
     if (options.description) form.append("description", options.description);
-    form.append("bundle", readFileSync(bundlePath), {
+    form.append("bundle", readFileSync3(bundlePath), {
       filename: `${skillName}.tar.gz`,
       contentType: "application/gzip"
     });
@@ -2289,14 +2592,14 @@ program.command("search <query>").description("Search for skills in the Registry
   }
 });
 program.command("config").description("Configure SkillVerse settings").option("-r, --registry <url>", "Set default registry URL").action((options) => {
-  const config2 = existsSync9(CONFIG_FILE) ? JSON.parse(readFileSync(CONFIG_FILE, "utf-8")) : {};
+  const config3 = existsSync10(CONFIG_FILE2) ? JSON.parse(readFileSync3(CONFIG_FILE2, "utf-8")) : {};
   if (options.registry) {
-    config2.registryUrl = options.registry;
-    writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
+    config3.registryUrl = options.registry;
+    writeFileSync2(CONFIG_FILE2, JSON.stringify(config3, null, 2));
     console.log(`\u2705 Registry URL set to: ${options.registry}`);
   } else {
     console.log("\nCurrent Configuration:");
-    console.log(`  Registry: ${config2.registryUrl || getRegistryUrl()}`);
+    console.log(`  Registry: ${config3.registryUrl || getRegistryUrl()}`);
   }
 });
 program.command("install [gitUrl]").description("Install a skill from Git URL").option("-a, --agent <agent>", "Link to agent workspace (vscode, cursor, etc.)").action(async (gitUrl, options) => {
@@ -2342,8 +2645,8 @@ program.command("install [gitUrl]").description("Install a skill from Git URL").
   }
 });
 program.command("add").description("Add a local skill").requiredOption("-p, --path <path>", "Path to skill directory").option("-a, --agent <agent>", "Link to agent workspace").action(async (options) => {
-  const sourcePath = options.path.startsWith("/") ? options.path : join8(process.cwd(), options.path);
-  if (!existsSync9(sourcePath)) {
+  const sourcePath = options.path.startsWith("/") ? options.path : join9(process.cwd(), options.path);
+  if (!existsSync10(sourcePath)) {
     console.error(`\u274C Source path not found: ${sourcePath}`);
     process.exit(1);
   }