@wingman-ai/gateway 0.4.1 → 0.4.2

package/dist/cli/services/skillRepository.js

@@ -1,4 +1,5 @@
 import { createLogger } from "../../logger.js";
+import { parseSkillFrontmatter } from "../../skills/metadata.js";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -35,7 +36,8 @@ class SkillRepository {
     async listAvailableSkills() {
         try {
             if ("clawhub" === this.provider) return await this.listSkillsFromClawhub();
-            return await this.listSkillsFromGitHub();
+            if ("github" === this.provider) return await this.listSkillsFromGitHub();
+            return await this.listSkillsFromHybrid();
         } catch (error) {
             if (error instanceof Error) throw new Error(`Failed to list skills: ${error.message}`);
             throw error;
@@ -57,19 +59,39 @@ class SkillRepository {
         return Buffer.from(arrayBuffer);
     }
     async getSkillMetadata(skillName) {
-        if ("clawhub" === this.provider) return await this.getClawhubSkillMetadata(skillName);
         try {
-            const skillMdPath = `/repos/${this.owner}/${this.repo}/contents/skills/${skillName}/SKILL.md`;
-            const skillMd = await this.fetchGitHub(skillMdPath);
-            if ("file" !== skillMd.type || !skillMd.content) throw new Error("SKILL.md not found or invalid");
-            const content = Buffer.from(skillMd.content, "base64").toString("utf-8");
-            const metadata = this.parseSkillMetadata(content);
-            return metadata;
+            if ("clawhub" === this.provider) return await this.getClawhubSkillMetadata(skillName);
+            if ("github" === this.provider) {
+                const repository = await this.resolveGitHubRepositoryForSkill(skillName);
+                return await this.getGitHubSkillMetadata(skillName, repository);
+            }
+            return await this.getHybridSkillMetadata(skillName);
         } catch (error) {
             if (error instanceof Error) throw new Error(`Failed to fetch skill metadata for ${skillName}: ${error.message}`);
             throw error;
         }
     }
+    async getGitHubSkillMetadata(skillName, repository) {
+        const skillMdPath = `/repos/${repository.owner}/${repository.name}/contents/skills/${skillName}/SKILL.md`;
+        const skillMd = await this.fetchGitHub(skillMdPath);
+        if ("file" !== skillMd.type || !skillMd.content) throw new Error(`SKILL.md not found or invalid in ${repository.owner}/${repository.name}`);
+        const content = Buffer.from(skillMd.content, "base64").toString("utf-8");
+        return this.parseSkillMetadata(content);
+    }
+    async resolveGitHubRepositoryForSkill(skillName) {
+        const repositories = this.getGitHubRepositories();
+        for(let index = repositories.length - 1; index >= 0; index -= 1){
+            const repository = repositories[index];
+            try {
+                await this.fetchGitHub(`/repos/${repository.owner}/${repository.name}/contents/skills/${skillName}/SKILL.md`);
+                return repository;
+            } catch (error) {
+                if (error instanceof Error && error.message.includes("Resource not found")) continue;
+                throw error;
+            }
+        }
+        throw new Error(`Skill '${skillName}' not found in configured GitHub repositories: ${repositories.map((repository)=>`${repository.owner}/${repository.name}`).join(", ")}`);
+    }
     async getClawhubSkillMetadata(skillName) {
         try {
             const detail = await this.fetchJson(`${this.clawhubBaseUrl}/api/v1/skills/${encodeURIComponent(skillName)}`, {
@@ -99,51 +121,50 @@ class SkillRepository {
             throw error;
         }
     }
+    async getHybridSkillMetadata(skillName) {
+        let githubError;
+        try {
+            const repository = await this.resolveGitHubRepositoryForSkill(skillName);
+            return await this.getGitHubSkillMetadata(skillName, repository);
+        } catch (error) {
+            githubError = error;
+            logger.debug(`Falling back to ClawHub metadata lookup for '${skillName}' after GitHub error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        try {
+            return await this.getClawhubSkillMetadata(skillName);
+        } catch (clawhubError) {
+            throw new Error(`GitHub error: ${githubError instanceof Error ? githubError.message : String(githubError)}; ClawHub error: ${clawhubError instanceof Error ? clawhubError.message : String(clawhubError)}`);
+        }
+    }
     parseSkillMetadata(content) {
-        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---/;
-        const match = content.match(frontmatterRegex);
-        if (!match) throw new Error("Invalid SKILL.md format: missing YAML frontmatter");
-        const frontmatter = match[1];
-        const metadata = {
-            name: "",
-            description: ""
+        const parsed = parseSkillFrontmatter(content);
+        return {
+            name: parsed.name,
+            description: parsed.description,
+            ...parsed.license ? {
+                license: parsed.license
+            } : {},
+            ...parsed.compatibility ? {
+                compatibility: parsed.compatibility
+            } : {},
+            ...parsed.allowedTools.length > 0 ? {
+                allowedTools: parsed.allowedTools
+            } : {},
+            ...parsed.metadata ? {
+                metadata: parsed.metadata
+            } : {}
         };
-        const lines = frontmatter.split("\n");
-        for (const line of lines){
-            const colonIndex = line.indexOf(":");
-            if (-1 === colonIndex) continue;
-            const key = line.substring(0, colonIndex).trim();
-            const value = line.substring(colonIndex + 1).trim();
-            switch(key){
-                case "name":
-                    metadata.name = value;
-                    break;
-                case "description":
-                    metadata.description = value;
-                    break;
-                case "license":
-                    metadata.license = value;
-                    break;
-                case "compatibility":
-                    metadata.compatibility = value;
-                    break;
-                case "allowed-tools":
-                    metadata.allowedTools = value;
-                    break;
-            }
-        }
-        if (!metadata.name) throw new Error("Invalid SKILL.md: missing required field 'name'");
-        if (!metadata.description) throw new Error("Invalid SKILL.md: missing required field 'description'");
-        const nameRegex = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-        if (!nameRegex.test(metadata.name)) throw new Error(`Invalid skill name '${metadata.name}': must be lowercase alphanumeric with hyphens only`);
-        return metadata;
     }
     async downloadSkill(skillName) {
-        if ("clawhub" === this.provider) return await this.downloadSkillFromClawhub(skillName);
         try {
-            const files = new Map();
-            await this.downloadDirectory(`skills/${skillName}`, files, skillName);
-            return files;
+            if ("clawhub" === this.provider) return await this.downloadSkillFromClawhub(skillName);
+            if ("github" === this.provider) {
+                const repository = await this.resolveGitHubRepositoryForSkill(skillName);
+                const files = new Map();
+                await this.downloadDirectory(`skills/${skillName}`, files, skillName, repository);
+                return files;
+            }
+            return await this.downloadHybridSkill(skillName);
         } catch (error) {
             if (error instanceof Error) throw new Error(`Failed to download skill ${skillName}: ${error.message}`);
             throw error;
@@ -186,8 +207,25 @@ class SkillRepository {
             throw error;
         }
     }
-    async downloadDirectory(path, files, skillName) {
-        const contents = await this.fetchGitHub(`/repos/${this.owner}/${this.repo}/contents/${path}`);
+    async downloadHybridSkill(skillName) {
+        let githubError;
+        try {
+            const repository = await this.resolveGitHubRepositoryForSkill(skillName);
+            const files = new Map();
+            await this.downloadDirectory(`skills/${skillName}`, files, skillName, repository);
+            return files;
+        } catch (error) {
+            githubError = error;
+            logger.debug(`Falling back to ClawHub download for '${skillName}' after GitHub error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        try {
+            return await this.downloadSkillFromClawhub(skillName);
+        } catch (clawhubError) {
+            throw new Error(`GitHub error: ${githubError instanceof Error ? githubError.message : String(githubError)}; ClawHub error: ${clawhubError instanceof Error ? clawhubError.message : String(clawhubError)}`);
+        }
+    }
+    async downloadDirectory(path, files, skillName, repository) {
+        const contents = await this.fetchGitHub(`/repos/${repository.owner}/${repository.name}/contents/${path}`);
         for (const item of contents)if ("file" === item.type) if (item.content) {
             const content = Buffer.from(item.content, "base64");
             const relativePath = item.path.replace(`skills/${skillName}/`, "");
@@ -200,7 +238,7 @@ class SkillRepository {
                 files.set(relativePath, content);
             }
         }
-        else if ("dir" === item.type) await this.downloadDirectory(item.path, files, skillName);
+        else if ("dir" === item.type) await this.downloadDirectory(item.path, files, skillName, repository);
     }
     async listSkillsFromClawhub() {
         const allSkills = [];
@@ -229,32 +267,80 @@ class SkillRepository {
         }while (cursor);
         return allSkills;
     }
-    async listSkillsFromGitHub() {
-        const contents = await this.fetchGitHub(`/repos/${this.owner}/${this.repo}/contents/skills`);
-        const skills = [];
-        for (const item of contents)if ("dir" === item.type) try {
-            const metadata = await this.getSkillMetadata(item.name);
-            skills.push({
-                name: item.name,
-                description: metadata.description || "No description",
-                path: item.path,
-                metadata
-            });
+    async listSkillsFromHybrid() {
+        let clawhubSkills = [];
+        let githubSkills = [];
+        let clawhubError;
+        let githubError;
+        try {
+            clawhubSkills = await this.listSkillsFromClawhub();
         } catch (error) {
-            logger.warn(`Could not read skill ${item.name}`, error instanceof Error ? error.message : String(error));
+            clawhubError = error;
+            logger.warn(`Failed to list ClawHub skills in hybrid mode: ${error instanceof Error ? error.message : String(error)}`);
         }
-        return skills;
+        try {
+            githubSkills = await this.listSkillsFromGitHub();
+        } catch (error) {
+            githubError = error;
+            logger.warn(`Failed to list GitHub skills in hybrid mode: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (0 === clawhubSkills.length && 0 === githubSkills.length) throw new Error(`No skill sources available. ClawHub error: ${clawhubError instanceof Error ? clawhubError.message : "none"}; GitHub error: ${githubError instanceof Error ? githubError.message : "none"}`);
+        const mergedSkills = new Map();
+        for (const skill of clawhubSkills)mergedSkills.set(skill.name, skill);
+        for (const skill of githubSkills){
+            if (mergedSkills.has(skill.name)) mergedSkills.delete(skill.name);
+            mergedSkills.set(skill.name, skill);
+        }
+        return [
+            ...mergedSkills.values()
+        ];
+    }
+    async listSkillsFromGitHub() {
+        const mergedSkills = new Map();
+        for (const repository of this.getGitHubRepositories()){
+            const contents = await this.fetchGitHub(`/repos/${repository.owner}/${repository.name}/contents/skills`);
+            for (const item of contents)if ("dir" === item.type) try {
+                const metadata = await this.getGitHubSkillMetadata(item.name, repository);
+                if (mergedSkills.has(item.name)) mergedSkills.delete(item.name);
+                mergedSkills.set(item.name, {
+                    name: item.name,
+                    description: metadata.description || "No description",
+                    path: item.path,
+                    metadata
+                });
+            } catch (error) {
+                logger.warn(`Could not read skill ${item.name} from ${repository.owner}/${repository.name}`, error instanceof Error ? error.message : String(error));
+            }
+        }
+        return [
+            ...mergedSkills.values()
+        ];
+    }
+    getGitHubRepositories() {
+        if (this.repositories.length > 0) return this.repositories;
+        throw new Error("No GitHub skill repositories configured. Set skills.repositories or the legacy skills.repositoryOwner + skills.repositoryName fields.");
     }
     constructor(options = {}){
         _define_property(this, "githubBaseUrl", "https://api.github.com");
-        _define_property(this, "owner", void 0);
-        _define_property(this, "repo", void 0);
+        _define_property(this, "repositories", void 0);
         _define_property(this, "token", void 0);
         _define_property(this, "provider", void 0);
         _define_property(this, "clawhubBaseUrl", void 0);
-        this.provider = options.provider || "github";
-        this.owner = options.repositoryOwner || "anthropics";
-        this.repo = options.repositoryName || "skills";
+        this.provider = options.provider || "hybrid";
+        const normalizedRepositories = (options.repositories || []).map((repository)=>({
+                owner: repository.owner.trim(),
+                name: repository.name.trim()
+            })).filter((repository)=>repository.owner && repository.name);
+        const legacyOwner = options.repositoryOwner?.trim();
+        const legacyName = options.repositoryName?.trim();
+        if (normalizedRepositories.length > 0) this.repositories = normalizedRepositories;
+        else if (legacyOwner && legacyName) this.repositories = [
+            {
+                owner: legacyOwner,
+                name: legacyName
+            }
+        ];
+        else this.repositories = [];
         this.token = options.githubToken || process.env.GITHUB_TOKEN || void 0;
         this.clawhubBaseUrl = (options.clawhubBaseUrl || "https://clawhub.ai").replace(/\/+$/, "");
     }

package/dist/cli/services/skillService.cjs

@@ -26,12 +26,15 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     SkillService: ()=>SkillService
 });
+const external_node_child_process_namespaceObject = require("node:child_process");
 const promises_namespaceObject = require("node:fs/promises");
 const external_node_os_namespaceObject = require("node:os");
 const external_node_path_namespaceObject = require("node:path");
 const external_node_readline_promises_namespaceObject = require("node:readline/promises");
 const external_logger_cjs_namespaceObject = require("../../logger.cjs");
 const external_skillSecurityScanner_cjs_namespaceObject = require("./skillSecurityScanner.cjs");
+const bin_requirements_cjs_namespaceObject = require("../../skills/bin-requirements.cjs");
+const metadata_cjs_namespaceObject = require("../../skills/metadata.cjs");
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -146,13 +149,24 @@ class SkillService {
                 recursive: true,
                 force: true
             });
-            if ("interactive" === this.outputManager.getMode()) console.log(`\n✓ Successfully installed skill ${skillName} to ${skillPath}`);
-            else this.outputManager.emitEvent({
-                type: "skill-install-complete",
-                skill: skillName,
-                path: skillPath,
-                timestamp: new Date().toISOString()
-            });
+            const dependencyStatus = await this.handlePostInstallDependencyActivation(skillPath);
+            if ("interactive" === this.outputManager.getMode()) {
+                console.log(`\n✓ Successfully installed skill ${skillName} to ${skillPath}`);
+                if (dependencyStatus) console.log(`\n${dependencyStatus}`);
+            } else {
+                this.outputManager.emitEvent({
+                    type: "skill-install-complete",
+                    skill: skillName,
+                    path: skillPath,
+                    timestamp: new Date().toISOString()
+                });
+                if (dependencyStatus) this.outputManager.emitEvent({
+                    type: "log",
+                    level: "info",
+                    message: dependencyStatus,
+                    timestamp: new Date().toISOString()
+                });
+            }
         } catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);
             const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
@@ -304,6 +318,75 @@ class SkillService {
             rl.close();
         }
     }
+    async loadSkillFrontmatter(skillPath) {
+        const skillMdPath = external_node_path_namespaceObject.join(skillPath, "SKILL.md");
+        const content = await promises_namespaceObject.readFile(skillMdPath, "utf-8");
+        return (0, metadata_cjs_namespaceObject.parseSkillFrontmatter)(content);
+    }
+    resolveMissingRequiredBins(skill) {
+        const requiredBins = skill.runtimeMetadata?.requires.bins || [];
+        return (0, bin_requirements_cjs_namespaceObject.findMissingBins)(requiredBins);
+    }
+    selectInstallRecipe(skill, missingBins) {
+        const installRecipes = skill.runtimeMetadata?.install || [];
+        if (0 === installRecipes.length) return null;
+        const missing = new Set(missingBins);
+        const withMatchingBins = installRecipes.find((recipe)=>recipe.bins.some((bin)=>missing.has(bin)));
+        return withMatchingBins || installRecipes[0] || null;
+    }
+    async promptForDependencyInstall(skillName, missingBins, recipe) {
+        const commandPreview = this.getInstallCommandPreview(recipe);
+        if (!commandPreview) return false;
+        console.log(`Skill '${skillName}' is installed but inactive. Missing required binaries: ${missingBins.join(", ")}`);
+        console.log(`Install option (${recipe.kind}): ${commandPreview}`);
+        const rl = external_node_readline_promises_namespaceObject.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        try {
+            const answer = await rl.question("Run install command now? (y/N): ");
+            const normalized = answer.trim().toLowerCase();
+            return "y" === normalized || "yes" === normalized;
+        } finally{
+            rl.close();
+        }
+    }
+    getInstallCommandPreview(recipe) {
+        if ("brew" === recipe.kind && recipe.formula) return `brew install ${recipe.formula}`;
+        return null;
+    }
+    async runInstallRecipe(recipe) {
+        if ("brew" !== recipe.kind || !recipe.formula) throw new Error(`Unsupported install recipe kind '${recipe.kind}'. Currently supported: brew`);
+        await new Promise((resolve, reject)=>{
+            const child = (0, external_node_child_process_namespaceObject.spawn)("brew", [
+                "install",
+                recipe.formula
+            ], {
+                cwd: this.workspace,
+                stdio: "inherit"
+            });
+            child.on("error", (error)=>reject(error));
+            child.on("exit", (code)=>{
+                if (0 === code) return void resolve();
+                reject(new Error(`Install command exited with code ${code}`));
+            });
+        });
+    }
+    async handlePostInstallDependencyActivation(skillPath) {
+        const skill = await this.loadSkillFrontmatter(skillPath);
+        if (!skill.runtimeMetadata) return null;
+        const missingBins = this.resolveMissingRequiredBins(skill);
+        if (0 === missingBins.length) return `Skill '${skill.name}' is active.`;
+        const installRecipe = this.selectInstallRecipe(skill, missingBins);
+        const outputMode = this.outputManager.getMode();
+        if (!installRecipe || "interactive" !== outputMode) return `Skill '${skill.name}' remains inactive until required binaries are available: ${missingBins.join(", ")}`;
+        const confirmed = await this.promptForDependencyInstall(skill.name, missingBins, installRecipe);
+        if (!confirmed) return `Skill '${skill.name}' remains inactive until required binaries are available: ${missingBins.join(", ")}`;
+        await this.runInstallRecipe(installRecipe);
+        const remainingMissingBins = this.resolveMissingRequiredBins(skill);
+        if (0 === remainingMissingBins.length) return `Skill '${skill.name}' is now active.`;
+        return `Skill '${skill.name}' is still inactive. Missing binaries: ${remainingMissingBins.join(", ")}`;
+    }
     async validateSkillMd(skillPath) {
         const skillMdPath = external_node_path_namespaceObject.join(skillPath, "SKILL.md");
         try {
@@ -322,26 +405,10 @@ class SkillService {
         return filePath;
     }
     parseSkillMetadata(content) {
-        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---/;
-        const match = content.match(frontmatterRegex);
-        if (!match) throw new Error("Invalid SKILL.md format: missing YAML frontmatter");
-        const frontmatter = match[1];
-        let name = "";
-        let description = "";
-        const lines = frontmatter.split("\n");
-        for (const line of lines){
-            const colonIndex = line.indexOf(":");
-            if (-1 === colonIndex) continue;
-            const key = line.substring(0, colonIndex).trim();
-            const value = line.substring(colonIndex + 1).trim();
-            if ("name" === key) name = value;
-            else if ("description" === key) description = value;
-        }
-        if (!name) throw new Error("missing required field 'name'");
-        if (!description) throw new Error("missing required field 'description'");
+        const parsed = (0, metadata_cjs_namespaceObject.parseSkillFrontmatter)(content);
         return {
-            name,
-            description
+            name: parsed.name,
+            description: parsed.description
         };
     }
     constructor(repository, outputManager, logger, options){

package/dist/cli/services/skillService.d.ts

@@ -38,6 +38,13 @@ export declare class SkillService {
      * Prompt user for overwrite confirmation
      */
     private promptForOverwrite;
+    private loadSkillFrontmatter;
+    private resolveMissingRequiredBins;
+    private selectInstallRecipe;
+    private promptForDependencyInstall;
+    private getInstallCommandPreview;
+    private runInstallRecipe;
+    private handlePostInstallDependencyActivation;
     /**
      * Validate SKILL.md file
      */

package/dist/cli/services/skillService.js

@@ -1,9 +1,12 @@
+import { spawn } from "node:child_process";
 import { access, cp, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join, posix, resolve, sep } from "node:path";
+import { dirname, join, posix, resolve as external_node_path_resolve, sep } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { getLogFilePath } from "../../logger.js";
 import { scanSkillDirectory } from "./skillSecurityScanner.js";
+import { findMissingBins } from "../../skills/bin-requirements.js";
+import { parseSkillFrontmatter } from "../../skills/metadata.js";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -118,13 +121,24 @@ class SkillService {
                 recursive: true,
                 force: true
             });
-            if ("interactive" === this.outputManager.getMode()) console.log(`\n✓ Successfully installed skill ${skillName} to ${skillPath}`);
-            else this.outputManager.emitEvent({
-                type: "skill-install-complete",
-                skill: skillName,
-                path: skillPath,
-                timestamp: new Date().toISOString()
-            });
+            const dependencyStatus = await this.handlePostInstallDependencyActivation(skillPath);
+            if ("interactive" === this.outputManager.getMode()) {
+                console.log(`\n✓ Successfully installed skill ${skillName} to ${skillPath}`);
+                if (dependencyStatus) console.log(`\n${dependencyStatus}`);
+            } else {
+                this.outputManager.emitEvent({
+                    type: "skill-install-complete",
+                    skill: skillName,
+                    path: skillPath,
+                    timestamp: new Date().toISOString()
+                });
+                if (dependencyStatus) this.outputManager.emitEvent({
+                    type: "log",
+                    level: "info",
+                    message: dependencyStatus,
+                    timestamp: new Date().toISOString()
+                });
+            }
         } catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);
             const logFile = getLogFilePath();
@@ -276,6 +290,75 @@ class SkillService {
             rl.close();
         }
     }
+    async loadSkillFrontmatter(skillPath) {
+        const skillMdPath = join(skillPath, "SKILL.md");
+        const content = await readFile(skillMdPath, "utf-8");
+        return parseSkillFrontmatter(content);
+    }
+    resolveMissingRequiredBins(skill) {
+        const requiredBins = skill.runtimeMetadata?.requires.bins || [];
+        return findMissingBins(requiredBins);
+    }
+    selectInstallRecipe(skill, missingBins) {
+        const installRecipes = skill.runtimeMetadata?.install || [];
+        if (0 === installRecipes.length) return null;
+        const missing = new Set(missingBins);
+        const withMatchingBins = installRecipes.find((recipe)=>recipe.bins.some((bin)=>missing.has(bin)));
+        return withMatchingBins || installRecipes[0] || null;
+    }
+    async promptForDependencyInstall(skillName, missingBins, recipe) {
+        const commandPreview = this.getInstallCommandPreview(recipe);
+        if (!commandPreview) return false;
+        console.log(`Skill '${skillName}' is installed but inactive. Missing required binaries: ${missingBins.join(", ")}`);
+        console.log(`Install option (${recipe.kind}): ${commandPreview}`);
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        try {
+            const answer = await rl.question("Run install command now? (y/N): ");
+            const normalized = answer.trim().toLowerCase();
+            return "y" === normalized || "yes" === normalized;
+        } finally{
+            rl.close();
+        }
+    }
+    getInstallCommandPreview(recipe) {
+        if ("brew" === recipe.kind && recipe.formula) return `brew install ${recipe.formula}`;
+        return null;
+    }
+    async runInstallRecipe(recipe) {
+        if ("brew" !== recipe.kind || !recipe.formula) throw new Error(`Unsupported install recipe kind '${recipe.kind}'. Currently supported: brew`);
+        await new Promise((resolve, reject)=>{
+            const child = spawn("brew", [
+                "install",
+                recipe.formula
+            ], {
+                cwd: this.workspace,
+                stdio: "inherit"
+            });
+            child.on("error", (error)=>reject(error));
+            child.on("exit", (code)=>{
+                if (0 === code) return void resolve();
+                reject(new Error(`Install command exited with code ${code}`));
+            });
+        });
+    }
+    async handlePostInstallDependencyActivation(skillPath) {
+        const skill = await this.loadSkillFrontmatter(skillPath);
+        if (!skill.runtimeMetadata) return null;
+        const missingBins = this.resolveMissingRequiredBins(skill);
+        if (0 === missingBins.length) return `Skill '${skill.name}' is active.`;
+        const installRecipe = this.selectInstallRecipe(skill, missingBins);
+        const outputMode = this.outputManager.getMode();
+        if (!installRecipe || "interactive" !== outputMode) return `Skill '${skill.name}' remains inactive until required binaries are available: ${missingBins.join(", ")}`;
+        const confirmed = await this.promptForDependencyInstall(skill.name, missingBins, installRecipe);
+        if (!confirmed) return `Skill '${skill.name}' remains inactive until required binaries are available: ${missingBins.join(", ")}`;
+        await this.runInstallRecipe(installRecipe);
+        const remainingMissingBins = this.resolveMissingRequiredBins(skill);
+        if (0 === remainingMissingBins.length) return `Skill '${skill.name}' is now active.`;
+        return `Skill '${skill.name}' is still inactive. Missing binaries: ${remainingMissingBins.join(", ")}`;
+    }
     async validateSkillMd(skillPath) {
         const skillMdPath = join(skillPath, "SKILL.md");
         try {
@@ -288,32 +371,16 @@ class SkillService {
     resolveSafeInstallPath(root, relativePath) {
         const normalized = posix.normalize(relativePath.replace(/\\/g, "/")).replace(/^\/+/, "");
         if (!normalized || "." === normalized || normalized.startsWith("../")) throw new Error(`Unsafe skill file path '${relativePath}' rejected during installation`);
-        const rootResolved = resolve(root);
-        const filePath = resolve(rootResolved, normalized);
+        const rootResolved = external_node_path_resolve(root);
+        const filePath = external_node_path_resolve(rootResolved, normalized);
         if (filePath !== rootResolved && !filePath.startsWith(rootResolved + sep)) throw new Error(`Unsafe skill file path '${relativePath}' rejected during installation`);
         return filePath;
     }
     parseSkillMetadata(content) {
-        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---/;
-        const match = content.match(frontmatterRegex);
-        if (!match) throw new Error("Invalid SKILL.md format: missing YAML frontmatter");
-        const frontmatter = match[1];
-        let name = "";
-        let description = "";
-        const lines = frontmatter.split("\n");
-        for (const line of lines){
-            const colonIndex = line.indexOf(":");
-            if (-1 === colonIndex) continue;
-            const key = line.substring(0, colonIndex).trim();
-            const value = line.substring(colonIndex + 1).trim();
-            if ("name" === key) name = value;
-            else if ("description" === key) description = value;
-        }
-        if (!name) throw new Error("missing required field 'name'");
-        if (!description) throw new Error("missing required field 'description'");
+        const parsed = parseSkillFrontmatter(content);
         return {
-            name,
-            description
+            name: parsed.name,
+            description: parsed.description
         };
     }
     constructor(repository, outputManager, logger, options){

package/dist/cli/types/skill.d.ts

@@ -8,8 +8,8 @@ export interface SkillMetadata {
     description: string;
     license?: string;
     compatibility?: string;
-    metadata?: Record<string, string>;
-    allowedTools?: string;
+    metadata?: Record<string, unknown>;
+    allowedTools?: string[];
 }
 /**
  * Skill information with additional context
@@ -57,12 +57,17 @@ export interface SkillCommandArgs {
  * Options for skill repository operations
  */
 export interface SkillRepositoryOptions {
-    provider?: "github" | "clawhub";
+    provider?: "github" | "clawhub" | "hybrid";
     repositoryOwner?: string;
     repositoryName?: string;
+    repositories?: SkillGitHubRepository[];
     githubToken?: string;
     clawhubBaseUrl?: string;
 }
+export interface SkillGitHubRepository {
+    owner: string;
+    name: string;
+}
 export interface SkillSecurityOptions {
     scanOnInstall?: boolean;
     scannerCommand?: string;