skillverse 0.1.0

package/server/src/services/skillService.ts

@@ -0,0 +1,722 @@
+import { join, basename } from 'path';
+import { existsSync } 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';
+import { prisma } from '../lib/db.js';
+import { AppError } from '../middleware/errorHandler.js';
+import { ErrorCode } from '@skillverse/shared';
+
+const SKILLVERSE_HOME = process.env.SKILLVERSE_HOME || join(process.env.HOME || '', '.skillverse');
+const SKILLS_DIR = process.env.SKILLS_DIR || join(SKILLVERSE_HOME, 'skills');
+const TEMP_DIR = process.env.TEMP_DIR || join(SKILLVERSE_HOME, 'temp');
+
+// Helper to parse Git URL and subdirectory
+function parseGitUrl(url: string): { repoUrl: string; subdir?: string; skillName: string } {
+  // Handle simple URL: https://github.com/owner/repo
+  if (!url.includes('/tree/')) {
+    const urlParts = url.split('/');
+    const repoName = urlParts[urlParts.length - 1].replace('.git', '');
+    return { repoUrl: url, skillName: repoName };
+  }
+
+  // Handle URL with tree/subdir: https://github.com/owner/repo/tree/main/path/to/skill
+  // Note: This logic is specific to GitHub URLs structure
+  const parts = url.split('/tree/');
+  const repoUrl = parts[0] + (parts[0].endsWith('.git') ? '' : '.git');
+
+  // parts[1] is like "main/path/to/skill"
+  // We need to support branch names that might contain slashes, but for MVP standard GitHub URLs
+  // usually have the branch as the first segment after /tree/
+  const pathParts = parts[1].split('/');
+  const branch = pathParts[0]; // Assume first part is branch for now
+  const subdir = pathParts.slice(1).join('/');
+  const skillName = pathParts[pathParts.length - 1];
+
+  return { repoUrl, subdir, skillName };
+}
+
+export class SkillService {
+  async getAllSkills() {
+    const skills = await prisma.skill.findMany({
+      include: {
+        linkedWorkspaces: {
+          include: {
+            workspace: true,
+          },
+        },
+        marketplaceEntry: true,
+      },
+      orderBy: {
+        installDate: 'desc',
+      },
+    });
+
+    return skills;
+  }
+
+  async getSkillById(id: string) {
+    const skill = await prisma.skill.findUnique({
+      where: { id },
+      include: {
+        linkedWorkspaces: {
+          include: {
+            workspace: true,
+          },
+        },
+        marketplaceEntry: true,
+      },
+    });
+
+    if (!skill) {
+      throw new AppError(ErrorCode.NOT_FOUND, 'Skill not found', 404);
+    }
+
+    return skill;
+  }
+
+  async getSkillByName(name: string) {
+    const skill = await prisma.skill.findUnique({
+      where: { name },
+      include: {
+        linkedWorkspaces: {
+          include: {
+            workspace: true,
+          },
+        },
+        marketplaceEntry: true,
+      },
+    });
+
+    if (!skill) {
+      throw new AppError(ErrorCode.NOT_FOUND, `Skill "${name}" not found`, 404);
+    }
+
+    return skill;
+  }
+
+  private async parseSkillMetadata(skillPath: string): Promise<{ description: string; metadata: any }> {
+    try {
+      const skillMdPath = join(skillPath, 'SKILL.md');
+
+      let description = '';
+      let metadata: any = {};
+
+      if (existsSync(skillMdPath)) {
+        const fileContent = await readFile(skillMdPath, 'utf-8');
+        const parsed = matter(fileContent);
+
+        // Use description from frontmatter or from first paragraph of body?
+        // Prioritize frontmatter
+        description = parsed.data.description || '';
+        metadata = parsed.data;
+      }
+
+      // Fallback to package.json or skill.json if no description
+      if (!description) {
+        const packageJsonPath = join(skillPath, 'package.json');
+        const skillJsonPath = join(skillPath, 'skill.json');
+
+        if (existsSync(skillJsonPath)) {
+          const content = await readFile(skillJsonPath, 'utf-8');
+          const json = JSON.parse(content);
+          description = json.description || '';
+          metadata = { ...metadata, ...json };
+        } else if (existsSync(packageJsonPath)) {
+          const content = await readFile(packageJsonPath, 'utf-8');
+          const pkg = JSON.parse(content);
+          description = pkg.description || '';
+          metadata = { ...metadata, name: pkg.name, version: pkg.version };
+        }
+      }
+
+      return { description, metadata };
+    } catch (error) {
+      console.warn('Failed to parse skill metadata:', error);
+      return { description: '', metadata: {} };
+    }
+  }
+
+  async createSkillFromGit(gitUrl: string, description?: string) {
+    let tempPath: string | null = null;
+
+    try {
+      // Parse URL
+      const { repoUrl, subdir, skillName } = parseGitUrl(gitUrl);
+
+      // Check if skill already exists
+      const existingSkill = await prisma.skill.findUnique({
+        where: { name: skillName },
+      });
+
+      if (existingSkill) {
+        throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${skillName}" already exists`, 409);
+      }
+
+      // Prepare directories
+      const skillPath = join(SKILLS_DIR, skillName);
+      if (existsSync(skillPath)) {
+        throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+      }
+
+      let commitHash = '';
+
+      if (subdir) {
+        // Clone to temp directory first for subdirectory extraction
+        tempPath = join(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);
+
+        // Get commit hash
+        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 = join(tempPath, subdir);
+        if (!existsSync(sourcePath)) {
+          throw new AppError(
+            ErrorCode.GIT_ERROR,
+            `Subdirectory "${subdir}" not found in repository`,
+            400
+          );
+        }
+
+        // Validate skill structure (must have SKILL.md, skill.json, or package.json)
+        const hasSkillMd = existsSync(join(sourcePath, 'SKILL.md'));
+        const hasSkillJson = existsSync(join(sourcePath, 'skill.json'));
+        const hasPackageJson = existsSync(join(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
+          );
+        }
+
+        // Move subdir content to final skill path
+        await mkdir(skillPath, { recursive: true });
+        await cp(sourcePath, skillPath, { recursive: true });
+
+      } else {
+        // Direct clone to skill path
+        if (!existsSync(skillPath)) {
+          await mkdir(skillPath, { recursive: true });
+        }
+
+        const git = simpleGit();
+        console.log(`Cloning ${gitUrl} to ${skillPath}...`);
+        await git.clone(gitUrl, skillPath);
+
+        // Get commit hash
+        try {
+          commitHash = await git.cwd(skillPath).revparse(['HEAD']);
+          console.log(`Captured commit hash: ${commitHash}`);
+        } catch (e) {
+          console.warn('Failed to capture commit hash:', e);
+        }
+      }
+
+      // Read metadata
+      const parsed = await this.parseSkillMetadata(skillPath);
+
+      // Save to database
+      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: any) {
+      // Cleanup on error (only if we created files but failed DB)
+      // Actually we check DB first so if we fail here it's likely during git/fs ops
+      // The implementation already has cleanup for tempPath in finally
+      throw error;
+    } finally {
+      if (tempPath && existsSync(tempPath)) {
+        await rm(tempPath, { recursive: true, force: true }).catch(console.error);
+      }
+    }
+  }
+
+
+
+  async createSkillFromDirectory(path: string, name?: string, description?: string) {
+    if (!existsSync(path)) {
+      throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Source path not found: ${path}`, 400);
+    }
+
+    const skillName = name || basename(path);
+    const skillPath = join(SKILLS_DIR, skillName);
+
+    // Check if skill already exists
+    const existingSkill = await prisma.skill.findUnique({
+      where: { name: skillName },
+    });
+
+    if (existingSkill) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${skillName}" already exists`, 409);
+    }
+
+    if (existsSync(skillPath)) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+    }
+
+    try {
+      // Create skill directory
+      await mkdir(skillPath, { recursive: true });
+
+      // Copy files
+      await cp(path, skillPath, { recursive: true });
+
+      // Read metadata
+      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) {
+      // Clean up
+      if (existsSync(skillPath)) {
+        await rm(skillPath, { recursive: true, force: true }).catch(() => { });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Helper to handle cases where the archive contains a single top-level directory.
+   * Moves contents up one level if that's the case.
+   */
+  private async stripTopLevelDirectory(targetPath: string) {
+    const { readdir, rename, rmdir, stat } = await import('fs/promises');
+
+    const items = await readdir(targetPath);
+
+    // Ignore system files like .DS_Store
+    const validItems = items.filter(i => i !== '.DS_Store' && i !== '__MACOSX');
+
+    if (validItems.length === 1) {
+      const topLevelItem = validItems[0];
+      const topLevelPath = join(targetPath, topLevelItem);
+      const stats = await stat(topLevelPath);
+
+      if (stats.isDirectory()) {
+        console.log(`Striping top-level directory: ${topLevelItem}`);
+
+        // Move all items from subdirectory to targetPath
+        const subItems = await readdir(topLevelPath);
+        for (const item of subItems) {
+          await rename(join(topLevelPath, item), join(targetPath, item));
+        }
+
+        // Remove the empty subdirectory
+        await rmdir(topLevelPath);
+      }
+    }
+  }
+
+  async createSkillFromLocal(name: string, zipPath: string, description?: string) {
+    const skillPath = join(SKILLS_DIR, name);
+
+    // Check if skill already exists
+    const existingSkill = await prisma.skill.findUnique({
+      where: { name },
+    });
+
+    if (existingSkill) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${name}" already exists`, 409);
+    }
+
+    if (existsSync(skillPath)) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
+    }
+
+    // Use a temp path for extraction to verify structure before determining final path
+    const extractPath = join(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);
+
+      // Fix nested directory structure if present
+      await this.stripTopLevelDirectory(extractPath);
+
+      // Read metadata from the extracted files
+      const parsed = await this.parseSkillMetadata(extractPath);
+
+      // Now move to final destination
+      // Check again to be safe against race conditions
+      if (existsSync(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) {
+      // Clean up final path if it was created but DB failed
+      if (existsSync(skillPath)) {
+        await rm(skillPath, { recursive: true, force: true }).catch(() => { });
+      }
+      // Clean up temp path if it still exists
+      if (existsSync(extractPath)) {
+        await rm(extractPath, { recursive: true, force: true }).catch(() => { });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Create a skill from a tar.gz bundle (marketplace install)
+   * @param bundlePath - Path to the .tar.gz bundle
+   * @param originalName - Original skill name
+   * @param description - Optional skill description
+   */
+  async createSkillFromBundle(bundlePath: string, originalName: string, description?: string) {
+    // Generate a unique name to avoid conflicts
+    let name = originalName;
+    let counter = 1;
+    while (await prisma.skill.findUnique({ where: { name } })) {
+      name = `${originalName}-${counter}`;
+      counter++;
+    }
+
+    const skillPath = join(SKILLS_DIR, name);
+
+    // Use a temp path for extraction
+    const extractPath = join(TEMP_DIR, `extract-bundle-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+    await mkdir(extractPath, { recursive: true });
+
+    try {
+      // Extract bundle using tar
+      const { createReadStream } = await import('fs');
+      const { createGunzip } = await import('zlib');
+      const tar = await import('tar');
+      const { pipeline } = await import('stream/promises');
+
+      await pipeline(
+        createReadStream(bundlePath),
+        createGunzip(),
+        tar.extract({ cwd: extractPath })
+      );
+
+      // Fix nested directory structure if present
+      await this.stripTopLevelDirectory(extractPath);
+
+      // Read metadata from extracted files
+      const parsed = await this.parseSkillMetadata(extractPath);
+
+      // Check again for existence before moving
+      if (existsSync(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(`📦 Installed skill "${name}" from bundle`);
+      return skill;
+    } catch (error) {
+      // Clean up final path if it was created but DB failed
+      if (existsSync(skillPath)) {
+        await rm(skillPath, { recursive: true, force: true }).catch(() => { });
+      }
+      // Clean up temp path if it still exists
+      if (existsSync(extractPath)) {
+        await rm(extractPath, { recursive: true, force: true }).catch(() => { });
+      }
+      throw error;
+    }
+  }
+
+  async updateSkill(id: string, data: { name?: string; description?: string; metadata?: any }) {
+    const skill = await this.getSkillById(id);
+
+    const updatedSkill = await prisma.skill.update({
+      where: { id },
+      data: {
+        ...(data.name && { name: data.name }),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(data.metadata && { metadata: JSON.stringify(data.metadata) }),
+      },
+    });
+
+    return updatedSkill;
+  }
+
+  async deleteSkill(id: string, removeFiles: boolean = true) {
+    const skill = await this.getSkillById(id);
+
+    // Remove symlinks from linked workspaces
+    if (skill.linkedWorkspaces && skill.linkedWorkspaces.length > 0) {
+      for (const link of skill.linkedWorkspaces) {
+        try {
+          const workspacePath = link.workspace.path;
+          const symlinkPath = join(workspacePath, skill.name);
+
+          if (existsSync(symlinkPath)) {
+            // Check if it is indeed a symlink to be safe
+            const stats = await import('fs/promises').then(fs => fs.lstat(symlinkPath));
+            if (stats.isSymbolicLink()) {
+              await unlink(symlinkPath);
+              console.log(`Removed symlink for ${skill.name} in workspace ${workspacePath}`);
+            }
+          }
+        } catch (error) {
+          console.warn(`Failed to remove symlink for ${skill.name} in workspace ${link.workspace.path}:`, error);
+        }
+      }
+    }
+
+    await prisma.skill.delete({
+      where: { id },
+    });
+
+    if (removeFiles && skill.storagePath) {
+      await rm(skill.storagePath, { recursive: true, force: true }).catch(err => {
+        console.warn(`Failed to delete skill directory ${skill.storagePath}:`, err);
+      });
+    }
+
+    return { success: true, message: 'Skill deleted successfully' };
+  }
+
+  // Check for updates
+  async checkForUpdate(id: string) {
+    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 = join(TEMP_DIR, `check-update-${Date.now()}`);
+    await mkdir(tempPath, { recursive: true });
+
+    try {
+      const git = simpleGit();
+      // We only need to check the remote HEAD, no need to full clone
+      // But ls-remote might require authentication or be tricky with some hosts
+      // Safer to shallow clone to temp
+      console.log(`Checking updates for ${skill.name} from ${skill.repoUrl}...`);
+
+      // Parse original git URL to get branch if possible, or just HEAD
+      // For now, assume main/HEAD of the repoUrl
+      const remote = await git.listRemote([skill.repoUrl, 'HEAD']);
+      if (!remote) {
+        throw new Error('Failed to get remote HEAD');
+      }
+
+      // remote is like "hash\tHEAD"
+      const remoteHash = remote.split('\t')[0];
+      const hasUpdate = remoteHash !== skill.commitHash;
+
+      // Update DB with check result
+      await prisma.skill.update({
+        where: { id },
+        data: {
+          lastUpdateCheck: new Date(),
+          updateAvailable: hasUpdate,
+        },
+      });
+
+      return {
+        hasUpdate,
+        currentHash: skill.commitHash,
+        remoteHash,
+      };
+    } catch (error: any) {
+      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?: string[]) {
+    // Check all git skills
+    const whereClause: any = {
+      source: 'git',
+      repoUrl: { not: null },
+    };
+
+    if (ids && ids.length > 0) {
+      whereClause.id = { in: ids };
+    }
+
+    const skills = await prisma.skill.findMany({ where: whereClause });
+    const results: Record<string, any> = {};
+
+    // Limit concurrency to avoid hammering network/git
+    // For now simple serial or Promise.all
+    console.log(`Checking updates for ${skills.length} skills...`);
+
+    await Promise.all(skills.map(async (skill: any) => {
+      try {
+        const result = await this.checkForUpdate(skill.id);
+        results[skill.id] = result;
+      } catch (e) {
+        results[skill.id] = { error: (e as Error).message };
+      }
+    }));
+
+    return results;
+  }
+
+  async refreshMetadata(id: string) {
+    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: string) {
+    const skill = await this.getSkillById(id);
+
+    if (skill.source !== 'git' || !skill.sourceUrl) {
+      throw new AppError(ErrorCode.VALIDATION_ERROR, 'Cannot upgrade non-git skill', 400);
+    }
+
+    // Reuse createSkillFromGit logic but force update
+    // Since createSkillFromGit checks for existing skill, we need to adapt it
+    // Or just manually do the steps here:
+    // 1. Download new version to temp
+    // 2. Validate
+    // 3. Replace files
+    // 4. Update DB
+
+    let tempPath: string | null = null;
+    let tempSkillPath: string | null = null;
+
+    try {
+      const { repoUrl, subdir } = parseGitUrl(skill.sourceUrl);
+
+      tempPath = join(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 = join(tempPath, subdir);
+        if (!existsSync(sourcePath)) {
+          throw new AppError(ErrorCode.GIT_ERROR, `Subdirectory "${subdir}" not found`, 400);
+        }
+      }
+
+      // Validate structure
+      const hasSkillMd = existsSync(join(sourcePath, 'SKILL.md'));
+      const hasSkillJson = existsSync(join(sourcePath, 'skill.json'));
+      const hasPackageJson = existsSync(join(sourcePath, 'package.json'));
+
+      if (!hasSkillMd && !hasSkillJson && !hasPackageJson) {
+        throw new AppError(ErrorCode.VALIDATION_ERROR, 'Invalid skill structure in new version', 400);
+      }
+
+      // Validated. Now replace files.
+      // We should be careful not to delete user configs if any, but for now we do full replace
+      // except maybe keeping some local files? For MVP, full replace.
+
+      // Clear existing directory content
+      const files = await import('fs/promises').then(fs => fs.readdir(skill.storagePath));
+      for (const file of files) {
+        await rm(join(skill.storagePath, file), { recursive: true, force: true });
+      }
+
+      // Copy new files
+      await cp(sourcePath, skill.storagePath, { recursive: true });
+
+      // Parse new metadata after upgrade
+      const parsed = await this.parseSkillMetadata(skill.storagePath);
+
+      // Update DB
+      const updatedSkill = await prisma.skill.update({
+        where: { id },
+        data: {
+          commitHash,
+          updateAvailable: false,
+          lastUpdateCheck: new Date(),
+          installDate: 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: any) {
+      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(() => { });
+    }
+  }
+}
+
+export const skillService = new SkillService();