@wingman-ai/gateway 0.4.0 → 0.4.2

package/dist/gateway/types.d.ts

@@ -2,7 +2,7 @@ import type { ServerWebSocket } from "bun";
 /**
  * Message types for gateway communication
  */
-export type MessageType = "connect" | "res" | "req:agent" | "req:agent:cancel" | "event:agent" | "session_subscribe" | "session_unsubscribe" | "register" | "registered" | "unregister" | "join_group" | "leave_group" | "broadcast" | "direct" | "ping" | "pong" | "error" | "ack" | "upgrade";
+export type MessageType = "connect" | "res" | "req:agent" | "req:agent:cancel" | "event:agent" | "req:node" | "event:node" | "session_subscribe" | "session_unsubscribe" | "register" | "registered" | "unregister" | "join_group" | "leave_group" | "broadcast" | "direct" | "ping" | "pong" | "error" | "ack" | "upgrade";
 /**
  * Gateway message structure
  */
@@ -87,6 +87,7 @@ export interface RoutingInfo {
 export interface NodeMetadata {
     id: string;
     name: string;
+    clientId?: string;
     capabilities?: string[];
     groups: Set<string>;
     connectedAt: number;
@@ -102,6 +103,10 @@ export interface NodeMetadata {
 export interface Node extends NodeMetadata {
     ws: ServerWebSocket<{
         nodeId: string;
+        clientId?: string;
+        clientType?: string;
+        authenticated?: boolean;
+        tailscaleUser?: string;
     }>;
 }
 /**

package/dist/gateway/validation.cjs

@@ -44,6 +44,8 @@ const MessageTypeSchema = external_zod_namespaceObject["enum"]([
     "req:agent",
     "req:agent:cancel",
     "event:agent",
+    "req:node",
+    "event:node",
     "session_subscribe",
     "session_unsubscribe",
     "register",

package/dist/gateway/validation.d.ts

@@ -10,6 +10,8 @@ export declare const MessageTypeSchema: z.ZodEnum<{
     "req:agent": "req:agent";
     "req:agent:cancel": "req:agent:cancel";
     "event:agent": "event:agent";
+    "req:node": "req:node";
+    "event:node": "event:node";
     session_subscribe: "session_subscribe";
     session_unsubscribe: "session_unsubscribe";
     register: "register";
@@ -34,6 +36,8 @@ export declare const GatewayMessageSchema: z.ZodObject<{
         "req:agent": "req:agent";
         "req:agent:cancel": "req:agent:cancel";
         "event:agent": "event:agent";
+        "req:node": "req:node";
+        "event:node": "event:node";
         session_subscribe: "session_subscribe";
         session_unsubscribe: "session_unsubscribe";
         register: "register";

package/dist/gateway/validation.js

@@ -5,6 +5,8 @@ const MessageTypeSchema = external_zod_enum([
     "req:agent",
     "req:agent:cancel",
     "event:agent",
+    "req:node",
+    "event:node",
     "session_subscribe",
     "session_unsubscribe",
     "register",

package/dist/skills/activation.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveSkillActivation: ()=>resolveSkillActivation
+});
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_path_namespaceObject = require("node:path");
+const external_bin_requirements_cjs_namespaceObject = require("./bin-requirements.cjs");
+const external_metadata_cjs_namespaceObject = require("./metadata.cjs");
+const resolveSkillActivation = async (skillsRoot, checkBin = external_bin_requirements_cjs_namespaceObject.isBinAvailable)=>{
+    const activeSkillNames = [];
+    const inactiveSkills = [];
+    let entries = [];
+    try {
+        entries = await promises_namespaceObject.readdir(skillsRoot, {
+            withFileTypes: true,
+            encoding: "utf8"
+        });
+    } catch  {
+        return {
+            activeSkillNames,
+            inactiveSkills
+        };
+    }
+    for (const entry of entries){
+        if (!entry.isDirectory()) continue;
+        const skillName = entry.name;
+        const skillMdPath = (0, external_node_path_namespaceObject.join)(skillsRoot, skillName, "SKILL.md");
+        let content;
+        try {
+            content = await promises_namespaceObject.readFile(skillMdPath, "utf-8");
+        } catch  {
+            continue;
+        }
+        try {
+            const parsed = (0, external_metadata_cjs_namespaceObject.parseSkillFrontmatter)(content);
+            const runtime = parsed.runtimeMetadata;
+            const requiredBins = runtime?.requires.bins || [];
+            if (!runtime || 0 === requiredBins.length) {
+                activeSkillNames.push(skillName);
+                continue;
+            }
+            const missingBins = (0, external_bin_requirements_cjs_namespaceObject.findMissingBins)(requiredBins, checkBin);
+            if (0 === missingBins.length) {
+                activeSkillNames.push(skillName);
+                continue;
+            }
+            inactiveSkills.push({
+                name: skillName,
+                namespace: runtime.namespace,
+                requiredBins,
+                missingBins
+            });
+        } catch  {
+            activeSkillNames.push(skillName);
+        }
+    }
+    return {
+        activeSkillNames,
+        inactiveSkills
+    };
+};
+exports.resolveSkillActivation = __webpack_exports__.resolveSkillActivation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveSkillActivation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/skills/activation.d.ts

@@ -0,0 +1,12 @@
+import { type BinAvailabilityChecker } from "./bin-requirements.js";
+export interface InactiveSkill {
+    name: string;
+    namespace: "wingman" | "openclaw";
+    requiredBins: string[];
+    missingBins: string[];
+}
+export interface SkillActivationResult {
+    activeSkillNames: string[];
+    inactiveSkills: InactiveSkill[];
+}
+export declare const resolveSkillActivation: (skillsRoot: string, checkBin?: BinAvailabilityChecker) => Promise<SkillActivationResult>;

package/dist/skills/activation.js

@@ -0,0 +1,58 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { findMissingBins, isBinAvailable } from "./bin-requirements.js";
+import { parseSkillFrontmatter } from "./metadata.js";
+const resolveSkillActivation = async (skillsRoot, checkBin = isBinAvailable)=>{
+    const activeSkillNames = [];
+    const inactiveSkills = [];
+    let entries = [];
+    try {
+        entries = await readdir(skillsRoot, {
+            withFileTypes: true,
+            encoding: "utf8"
+        });
+    } catch  {
+        return {
+            activeSkillNames,
+            inactiveSkills
+        };
+    }
+    for (const entry of entries){
+        if (!entry.isDirectory()) continue;
+        const skillName = entry.name;
+        const skillMdPath = join(skillsRoot, skillName, "SKILL.md");
+        let content;
+        try {
+            content = await readFile(skillMdPath, "utf-8");
+        } catch  {
+            continue;
+        }
+        try {
+            const parsed = parseSkillFrontmatter(content);
+            const runtime = parsed.runtimeMetadata;
+            const requiredBins = runtime?.requires.bins || [];
+            if (!runtime || 0 === requiredBins.length) {
+                activeSkillNames.push(skillName);
+                continue;
+            }
+            const missingBins = findMissingBins(requiredBins, checkBin);
+            if (0 === missingBins.length) {
+                activeSkillNames.push(skillName);
+                continue;
+            }
+            inactiveSkills.push({
+                name: skillName,
+                namespace: runtime.namespace,
+                requiredBins,
+                missingBins
+            });
+        } catch  {
+            activeSkillNames.push(skillName);
+        }
+    }
+    return {
+        activeSkillNames,
+        inactiveSkills
+    };
+};
+export { resolveSkillActivation };

package/dist/skills/bin-requirements.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isBinAvailable: ()=>isBinAvailable,
+    findMissingBins: ()=>findMissingBins
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const SAFE_BIN_REGEX = /^[A-Za-z0-9._-]+$/;
+const isBinAvailable = (binName)=>{
+    const normalized = binName.trim();
+    if (!normalized || !SAFE_BIN_REGEX.test(normalized)) return false;
+    const lookupCommand = "win32" === process.platform ? "where" : "which";
+    const result = (0, external_node_child_process_namespaceObject.spawnSync)(lookupCommand, [
+        normalized
+    ], {
+        stdio: "ignore"
+    });
+    return 0 === result.status;
+};
+const findMissingBins = (bins, checkBin = isBinAvailable)=>{
+    const seen = new Set();
+    const missing = [];
+    for (const bin of bins){
+        const normalized = bin.trim();
+        if (!(!normalized || seen.has(normalized))) {
+            seen.add(normalized);
+            if (!checkBin(normalized)) missing.push(normalized);
+        }
+    }
+    return missing;
+};
+exports.findMissingBins = __webpack_exports__.findMissingBins;
+exports.isBinAvailable = __webpack_exports__.isBinAvailable;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "findMissingBins",
+    "isBinAvailable"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/skills/bin-requirements.d.ts

@@ -0,0 +1,3 @@
+export type BinAvailabilityChecker = (binName: string) => boolean;
+export declare const isBinAvailable: BinAvailabilityChecker;
+export declare const findMissingBins: (bins: string[], checkBin?: BinAvailabilityChecker) => string[];

package/dist/skills/bin-requirements.js

@@ -0,0 +1,26 @@
+import { spawnSync } from "node:child_process";
+const SAFE_BIN_REGEX = /^[A-Za-z0-9._-]+$/;
+const isBinAvailable = (binName)=>{
+    const normalized = binName.trim();
+    if (!normalized || !SAFE_BIN_REGEX.test(normalized)) return false;
+    const lookupCommand = "win32" === process.platform ? "where" : "which";
+    const result = spawnSync(lookupCommand, [
+        normalized
+    ], {
+        stdio: "ignore"
+    });
+    return 0 === result.status;
+};
+const findMissingBins = (bins, checkBin = isBinAvailable)=>{
+    const seen = new Set();
+    const missing = [];
+    for (const bin of bins){
+        const normalized = bin.trim();
+        if (!(!normalized || seen.has(normalized))) {
+            seen.add(normalized);
+            if (!checkBin(normalized)) missing.push(normalized);
+        }
+    }
+    return missing;
+};
+export { findMissingBins, isBinAvailable };

package/dist/skills/metadata.cjs

@@ -0,0 +1,141 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    parseSkillRuntimeMetadata: ()=>parseSkillRuntimeMetadata,
+    parseSkillFrontmatter: ()=>parseSkillFrontmatter
+});
+const external_js_yaml_namespaceObject = require("js-yaml");
+const FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---/;
+const SKILL_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const SUPPORTED_SKILL_METADATA_NAMESPACES = [
+    "wingman",
+    "openclaw"
+];
+const toRecord = (value)=>{
+    if (!value || "object" != typeof value || Array.isArray(value)) return null;
+    return value;
+};
+const toTrimmedString = (value)=>{
+    if ("string" != typeof value) return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+};
+const toStringArray = (value)=>{
+    if (Array.isArray(value)) {
+        const normalized = value.map((entry)=>"string" == typeof entry ? entry.trim() : "").filter(Boolean);
+        return Array.from(new Set(normalized));
+    }
+    if ("string" == typeof value) {
+        const normalized = value.split(/[\s,]+/).map((entry)=>entry.trim()).filter(Boolean);
+        return Array.from(new Set(normalized));
+    }
+    return [];
+};
+const parseInstallRecipe = (value)=>{
+    const recipe = toRecord(value);
+    if (!recipe) return null;
+    const kind = toTrimmedString(recipe.kind);
+    if (!kind) return null;
+    const id = toTrimmedString(recipe.id) || kind;
+    const label = toTrimmedString(recipe.label);
+    const formula = toTrimmedString(recipe.formula);
+    return {
+        id,
+        kind,
+        ...label ? {
+            label
+        } : {},
+        ...formula ? {
+            formula
+        } : {},
+        bins: toStringArray(recipe.bins)
+    };
+};
+const parseSkillRuntimeMetadata = (value)=>{
+    const metadata = toRecord(value);
+    if (!metadata) return null;
+    for (const namespace of SUPPORTED_SKILL_METADATA_NAMESPACES){
+        const namespaceConfig = toRecord(metadata[namespace]);
+        if (!namespaceConfig) continue;
+        const requires = toRecord(namespaceConfig.requires);
+        const installRaw = Array.isArray(namespaceConfig.install) ? namespaceConfig.install : [];
+        const emoji = toTrimmedString(namespaceConfig.emoji);
+        return {
+            namespace,
+            ...emoji ? {
+                emoji
+            } : {},
+            requires: {
+                bins: toStringArray(requires?.bins)
+            },
+            install: installRaw.map(parseInstallRecipe).filter((recipe)=>Boolean(recipe))
+        };
+    }
+    return null;
+};
+const parseAllowedTools = (frontmatter)=>{
+    if (void 0 !== frontmatter["allowed-tools"]) return toStringArray(frontmatter["allowed-tools"]);
+    if (void 0 !== frontmatter.allowedTools) return toStringArray(frontmatter.allowedTools);
+    return [];
+};
+const parseSkillFrontmatter = (content)=>{
+    const match = content.match(FRONTMATTER_REGEX);
+    if (!match) throw new Error("Invalid SKILL.md format: missing YAML frontmatter");
+    const frontmatterRaw = match[1];
+    const parsed = external_js_yaml_namespaceObject.load(frontmatterRaw);
+    const frontmatter = toRecord(parsed);
+    if (!frontmatter) throw new Error("Invalid SKILL.md: frontmatter must be a YAML object");
+    const name = toTrimmedString(frontmatter.name);
+    if (!name) throw new Error("Invalid SKILL.md: missing required field 'name'");
+    if (!SKILL_NAME_REGEX.test(name)) throw new Error(`Invalid skill name '${name}': must be lowercase alphanumeric with hyphens only`);
+    const description = toTrimmedString(frontmatter.description);
+    if (!description) throw new Error("Invalid SKILL.md: missing required field 'description'");
+    const metadata = toRecord(frontmatter.metadata) || void 0;
+    const license = toTrimmedString(frontmatter.license);
+    const compatibility = toTrimmedString(frontmatter.compatibility);
+    return {
+        name,
+        description,
+        ...license ? {
+            license
+        } : {},
+        ...compatibility ? {
+            compatibility
+        } : {},
+        allowedTools: parseAllowedTools(frontmatter),
+        metadata,
+        runtimeMetadata: parseSkillRuntimeMetadata(metadata)
+    };
+};
+exports.parseSkillFrontmatter = __webpack_exports__.parseSkillFrontmatter;
+exports.parseSkillRuntimeMetadata = __webpack_exports__.parseSkillRuntimeMetadata;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseSkillFrontmatter",
+    "parseSkillRuntimeMetadata"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/skills/metadata.d.ts

@@ -0,0 +1,29 @@
+declare const SUPPORTED_SKILL_METADATA_NAMESPACES: readonly ["wingman", "openclaw"];
+export type SupportedSkillMetadataNamespace = (typeof SUPPORTED_SKILL_METADATA_NAMESPACES)[number];
+export interface SkillInstallRecipe {
+    id: string;
+    kind: string;
+    label?: string;
+    formula?: string;
+    bins: string[];
+}
+export interface SkillRuntimeMetadata {
+    namespace: SupportedSkillMetadataNamespace;
+    emoji?: string;
+    requires: {
+        bins: string[];
+    };
+    install: SkillInstallRecipe[];
+}
+export interface ParsedSkillFrontmatter {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    allowedTools: string[];
+    metadata?: Record<string, unknown>;
+    runtimeMetadata: SkillRuntimeMetadata | null;
+}
+export declare const parseSkillRuntimeMetadata: (value: unknown) => SkillRuntimeMetadata | null;
+export declare const parseSkillFrontmatter: (content: string) => ParsedSkillFrontmatter;
+export {};

package/dist/skills/metadata.js

@@ -0,0 +1,104 @@
+import { load } from "js-yaml";
+const FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---/;
+const SKILL_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const SUPPORTED_SKILL_METADATA_NAMESPACES = [
+    "wingman",
+    "openclaw"
+];
+const toRecord = (value)=>{
+    if (!value || "object" != typeof value || Array.isArray(value)) return null;
+    return value;
+};
+const toTrimmedString = (value)=>{
+    if ("string" != typeof value) return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+};
+const toStringArray = (value)=>{
+    if (Array.isArray(value)) {
+        const normalized = value.map((entry)=>"string" == typeof entry ? entry.trim() : "").filter(Boolean);
+        return Array.from(new Set(normalized));
+    }
+    if ("string" == typeof value) {
+        const normalized = value.split(/[\s,]+/).map((entry)=>entry.trim()).filter(Boolean);
+        return Array.from(new Set(normalized));
+    }
+    return [];
+};
+const parseInstallRecipe = (value)=>{
+    const recipe = toRecord(value);
+    if (!recipe) return null;
+    const kind = toTrimmedString(recipe.kind);
+    if (!kind) return null;
+    const id = toTrimmedString(recipe.id) || kind;
+    const label = toTrimmedString(recipe.label);
+    const formula = toTrimmedString(recipe.formula);
+    return {
+        id,
+        kind,
+        ...label ? {
+            label
+        } : {},
+        ...formula ? {
+            formula
+        } : {},
+        bins: toStringArray(recipe.bins)
+    };
+};
+const parseSkillRuntimeMetadata = (value)=>{
+    const metadata = toRecord(value);
+    if (!metadata) return null;
+    for (const namespace of SUPPORTED_SKILL_METADATA_NAMESPACES){
+        const namespaceConfig = toRecord(metadata[namespace]);
+        if (!namespaceConfig) continue;
+        const requires = toRecord(namespaceConfig.requires);
+        const installRaw = Array.isArray(namespaceConfig.install) ? namespaceConfig.install : [];
+        const emoji = toTrimmedString(namespaceConfig.emoji);
+        return {
+            namespace,
+            ...emoji ? {
+                emoji
+            } : {},
+            requires: {
+                bins: toStringArray(requires?.bins)
+            },
+            install: installRaw.map(parseInstallRecipe).filter((recipe)=>Boolean(recipe))
+        };
+    }
+    return null;
+};
+const parseAllowedTools = (frontmatter)=>{
+    if (void 0 !== frontmatter["allowed-tools"]) return toStringArray(frontmatter["allowed-tools"]);
+    if (void 0 !== frontmatter.allowedTools) return toStringArray(frontmatter.allowedTools);
+    return [];
+};
+const parseSkillFrontmatter = (content)=>{
+    const match = content.match(FRONTMATTER_REGEX);
+    if (!match) throw new Error("Invalid SKILL.md format: missing YAML frontmatter");
+    const frontmatterRaw = match[1];
+    const parsed = load(frontmatterRaw);
+    const frontmatter = toRecord(parsed);
+    if (!frontmatter) throw new Error("Invalid SKILL.md: frontmatter must be a YAML object");
+    const name = toTrimmedString(frontmatter.name);
+    if (!name) throw new Error("Invalid SKILL.md: missing required field 'name'");
+    if (!SKILL_NAME_REGEX.test(name)) throw new Error(`Invalid skill name '${name}': must be lowercase alphanumeric with hyphens only`);
+    const description = toTrimmedString(frontmatter.description);
+    if (!description) throw new Error("Invalid SKILL.md: missing required field 'description'");
+    const metadata = toRecord(frontmatter.metadata) || void 0;
+    const license = toTrimmedString(frontmatter.license);
+    const compatibility = toTrimmedString(frontmatter.compatibility);
+    return {
+        name,
+        description,
+        ...license ? {
+            license
+        } : {},
+        ...compatibility ? {
+            compatibility
+        } : {},
+        allowedTools: parseAllowedTools(frontmatter),
+        metadata,
+        runtimeMetadata: parseSkillRuntimeMetadata(metadata)
+    };
+};
+export { parseSkillFrontmatter, parseSkillRuntimeMetadata };

package/dist/skills/overlay.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createSkillOverlayDirectory: ()=>createSkillOverlayDirectory,
+    removeSkillOverlayDirectory: ()=>removeSkillOverlayDirectory
+});
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_os_namespaceObject = require("node:os");
+const uniqueSkillNames = (skills)=>{
+    const seen = new Set();
+    const unique = [];
+    for (const skill of skills){
+        const normalized = skill.trim();
+        if (!(!normalized || seen.has(normalized))) {
+            seen.add(normalized);
+            unique.push(normalized);
+        }
+    }
+    return unique;
+};
+const createSkillOverlayDirectory = async (skillsRoot, activeSkillNames)=>{
+    const overlayRoot = await promises_namespaceObject.mkdtemp((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-skill-overlay-"));
+    for (const skillName of uniqueSkillNames(activeSkillNames)){
+        const source = (0, external_node_path_namespaceObject.join)(skillsRoot, skillName);
+        const destination = (0, external_node_path_namespaceObject.join)(overlayRoot, skillName);
+        try {
+            await promises_namespaceObject.symlink(source, destination, "win32" === process.platform ? "junction" : "dir");
+        } catch  {
+            await promises_namespaceObject.cp(source, destination, {
+                recursive: true,
+                force: true
+            });
+        }
+    }
+    return overlayRoot;
+};
+const removeSkillOverlayDirectory = async (overlayPath)=>{
+    await promises_namespaceObject.rm(overlayPath, {
+        recursive: true,
+        force: true
+    });
+};
+exports.createSkillOverlayDirectory = __webpack_exports__.createSkillOverlayDirectory;
+exports.removeSkillOverlayDirectory = __webpack_exports__.removeSkillOverlayDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSkillOverlayDirectory",
+    "removeSkillOverlayDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/skills/overlay.d.ts

@@ -0,0 +1,2 @@
+export declare const createSkillOverlayDirectory: (skillsRoot: string, activeSkillNames: string[]) => Promise<string>;
+export declare const removeSkillOverlayDirectory: (overlayPath: string) => Promise<void>;