cowork-os 0.3.21

package/dist/electron/electron/agent/custom-skill-loader.js

@@ -0,0 +1,566 @@
+"use strict";
+/**
+ * Custom Skill Loader
+ *
+ * Loads skills from multiple sources with precedence:
+ * - Bundled skills (resources/skills/) - lowest precedence
+ * - Managed skills (~/Library/Application Support/cowork-os/skills/) - medium precedence
+ * - Workspace skills (workspace/skills/) - highest precedence
+ *
+ * Skills with the same ID from higher precedence sources override lower ones.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSkillLoader = void 0;
+exports.getCustomSkillLoader = getCustomSkillLoader;
+exports.resetCustomSkillLoader = resetCustomSkillLoader;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const electron_1 = require("electron");
+const skill_eligibility_1 = require("./skill-eligibility");
+const security_1 = require("./security");
+const SKILLS_FOLDER_NAME = 'skills';
+const SKILL_FILE_EXTENSION = '.json';
+const RELOAD_DEBOUNCE_MS = 100; // Debounce rapid reload calls
+class CustomSkillLoader {
+    constructor(config) {
+        this.workspaceSkillsDir = null;
+        this.skills = new Map();
+        this.initialized = false;
+        // Debounce state for reloadSkills
+        this.reloadDebounceTimer = null;
+        this.reloadPromise = null;
+        this.isReloading = false;
+        // Bundled skills directory
+        const isDev = process.env.NODE_ENV === 'development';
+        if (config?.bundledSkillsDir) {
+            this.bundledSkillsDir = config.bundledSkillsDir;
+        }
+        else if (isDev) {
+            this.bundledSkillsDir = path.join(process.cwd(), 'resources', SKILLS_FOLDER_NAME);
+        }
+        else {
+            this.bundledSkillsDir = path.join(process.resourcesPath || '', SKILLS_FOLDER_NAME);
+        }
+        // Managed skills directory (from registry)
+        this.managedSkillsDir =
+            config?.managedSkillsDir ||
+                path.join(electron_1.app.getPath('userData'), SKILLS_FOLDER_NAME);
+        // Workspace skills directory (set later when workspace is loaded)
+        this.workspaceSkillsDir = config?.workspaceSkillsDir || null;
+        // Skills config
+        this.skillsConfig = config?.skillsConfig;
+        // Initialize eligibility checker
+        this.eligibilityChecker = (0, skill_eligibility_1.getSkillEligibilityChecker)(this.skillsConfig);
+    }
+    /**
+     * Initialize the skill loader - loads all skills from all sources
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        // Ensure managed skills directory exists
+        if (!fs.existsSync(this.managedSkillsDir)) {
+            fs.mkdirSync(this.managedSkillsDir, { recursive: true });
+        }
+        // Load all skills
+        await this.reloadSkills();
+        this.initialized = true;
+        console.log(`[CustomSkillLoader] Initialized with ${this.skills.size} skills`);
+        console.log(`[CustomSkillLoader] Bundled: ${this.bundledSkillsDir}`);
+        console.log(`[CustomSkillLoader] Managed: ${this.managedSkillsDir}`);
+        if (this.workspaceSkillsDir) {
+            console.log(`[CustomSkillLoader] Workspace: ${this.workspaceSkillsDir}`);
+        }
+    }
+    /**
+     * Set the workspace skills directory
+     */
+    setWorkspaceSkillsDir(workspacePath) {
+        this.workspaceSkillsDir = path.join(workspacePath, SKILLS_FOLDER_NAME);
+    }
+    /**
+     * Get directory paths
+     */
+    getBundledSkillsDir() {
+        return this.bundledSkillsDir;
+    }
+    getManagedSkillsDir() {
+        return this.managedSkillsDir;
+    }
+    getWorkspaceSkillsDir() {
+        return this.workspaceSkillsDir;
+    }
+    /**
+     * Get the skills directory path (for backward compatibility)
+     */
+    getSkillsDirectory() {
+        return this.bundledSkillsDir;
+    }
+    /**
+     * Load skills from a directory
+     */
+    loadSkillsFromDir(dir, source) {
+        const skills = [];
+        if (!fs.existsSync(dir)) {
+            return skills;
+        }
+        try {
+            const files = fs.readdirSync(dir);
+            const skillFiles = files.filter((f) => f.endsWith(SKILL_FILE_EXTENSION));
+            for (const file of skillFiles) {
+                try {
+                    const filePath = path.join(dir, file);
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const skill = JSON.parse(content);
+                    // Add metadata
+                    skill.filePath = filePath;
+                    skill.source = source;
+                    // Validate skill has required fields
+                    if (this.validateSkill(skill)) {
+                        skills.push(skill);
+                    }
+                    else {
+                        console.warn(`[CustomSkillLoader] Invalid skill file: ${file}`);
+                    }
+                }
+                catch (error) {
+                    console.error(`[CustomSkillLoader] Failed to load skill file ${file}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[CustomSkillLoader] Failed to read directory ${dir}:`, error);
+        }
+        return skills;
+    }
+    /**
+     * Reload all skills from all sources
+     * Precedence: workspace > managed > bundled
+     * Uses debouncing to prevent rapid consecutive calls
+     */
+    async reloadSkills() {
+        // If already reloading, return the existing promise
+        if (this.isReloading && this.reloadPromise) {
+            return this.reloadPromise;
+        }
+        // Clear any pending debounce timer
+        if (this.reloadDebounceTimer) {
+            clearTimeout(this.reloadDebounceTimer);
+            this.reloadDebounceTimer = null;
+        }
+        // Create a debounced reload promise
+        this.reloadPromise = new Promise((resolve) => {
+            this.reloadDebounceTimer = setTimeout(async () => {
+                this.isReloading = true;
+                try {
+                    const result = await this.doReloadSkills();
+                    resolve(result);
+                }
+                finally {
+                    this.isReloading = false;
+                    this.reloadPromise = null;
+                    this.reloadDebounceTimer = null;
+                }
+            }, RELOAD_DEBOUNCE_MS);
+        });
+        return this.reloadPromise;
+    }
+    /**
+     * Internal method to actually reload skills
+     */
+    async doReloadSkills() {
+        this.skills.clear();
+        // Load from all sources
+        const bundledSkills = this.loadSkillsFromDir(this.bundledSkillsDir, 'bundled');
+        const managedSkills = this.loadSkillsFromDir(this.managedSkillsDir, 'managed');
+        const workspaceSkills = this.workspaceSkillsDir
+            ? this.loadSkillsFromDir(this.workspaceSkillsDir, 'workspace')
+            : [];
+        // Merge with precedence: bundled < managed < workspace
+        for (const skill of bundledSkills) {
+            this.skills.set(skill.id, skill);
+        }
+        for (const skill of managedSkills) {
+            this.skills.set(skill.id, skill);
+        }
+        for (const skill of workspaceSkills) {
+            this.skills.set(skill.id, skill);
+        }
+        const counts = {
+            bundled: bundledSkills.length,
+            managed: managedSkills.length,
+            workspace: workspaceSkills.length,
+            total: this.skills.size,
+        };
+        console.log(`[CustomSkillLoader] Loaded ${counts.total} skills ` +
+            `(bundled: ${counts.bundled}, managed: ${counts.managed}, workspace: ${counts.workspace})`);
+        return this.listSkills();
+    }
+    /**
+     * Validate a skill has all required fields
+     */
+    validateSkill(skill) {
+        return !!(skill.id &&
+            skill.name &&
+            skill.description &&
+            skill.prompt &&
+            typeof skill.id === 'string' &&
+            typeof skill.name === 'string' &&
+            typeof skill.description === 'string' &&
+            typeof skill.prompt === 'string');
+    }
+    /**
+     * List all loaded skills
+     */
+    listSkills() {
+        return Array.from(this.skills.values()).sort((a, b) => {
+            // Sort by priority first (lower = higher priority, default 100)
+            const priorityA = a.priority ?? 100;
+            const priorityB = b.priority ?? 100;
+            if (priorityA !== priorityB) {
+                return priorityA - priorityB;
+            }
+            // Then by category
+            if (a.category && b.category && a.category !== b.category) {
+                return a.category.localeCompare(b.category);
+            }
+            // Finally by name
+            return a.name.localeCompare(b.name);
+        });
+    }
+    /**
+     * List skills by source
+     */
+    listSkillsBySource(source) {
+        return this.listSkills().filter((skill) => skill.source === source);
+    }
+    /**
+     * List only task skills (excludes guideline skills)
+     * Used for the skill dropdown in UI
+     */
+    listTaskSkills() {
+        return this.listSkills().filter((skill) => skill.type !== 'guideline');
+    }
+    /**
+     * List only guideline skills
+     */
+    listGuidelineSkills() {
+        return this.listSkills().filter((skill) => skill.type === 'guideline');
+    }
+    /**
+     * Get enabled guideline skills for system prompt injection
+     * Returns the combined prompt content of all enabled guideline skills
+     * Guidelines are validated and sanitized to prevent injection attacks
+     */
+    getEnabledGuidelinesPrompt() {
+        const enabledGuidelines = this.listGuidelineSkills().filter((skill) => skill.enabled !== false);
+        if (enabledGuidelines.length === 0) {
+            return '';
+        }
+        // Validate and sanitize each guideline before injection
+        return enabledGuidelines.map((skill) => {
+            const validation = security_1.InputSanitizer.validateSkillGuidelines(skill.prompt);
+            if (!validation.valid) {
+                console.warn(`[CustomSkillLoader] Security: Skill "${skill.id}" guidelines contain suspicious patterns:`, validation.issues);
+                return validation.sanitized;
+            }
+            return skill.prompt;
+        }).join('\n\n');
+    }
+    /**
+     * List skills that can be automatically invoked by the model
+     * Excludes guidelines and skills with disableModelInvocation set
+     */
+    listModelInvocableSkills() {
+        return this.listSkills().filter((skill) => {
+            // Exclude guideline skills
+            if (skill.type === 'guideline')
+                return false;
+            // Exclude disabled skills
+            if (skill.enabled === false)
+                return false;
+            // Exclude skills that explicitly disable model invocation
+            if (skill.invocation?.disableModelInvocation === true)
+                return false;
+            return true;
+        });
+    }
+    /**
+     * Get formatted skill descriptions for the model's system prompt
+     * Groups skills by category and includes parameter info
+     */
+    getSkillDescriptionsForModel() {
+        const skills = this.listModelInvocableSkills();
+        if (skills.length === 0) {
+            return '';
+        }
+        // Group skills by category
+        const byCategory = {};
+        for (const skill of skills) {
+            const category = skill.category || 'General';
+            if (!byCategory[category]) {
+                byCategory[category] = [];
+            }
+            byCategory[category].push(skill);
+        }
+        // Format descriptions
+        const lines = [];
+        for (const [category, categorySkills] of Object.entries(byCategory).sort()) {
+            lines.push(`\n${category}:`);
+            for (const skill of categorySkills) {
+                const paramInfo = skill.parameters?.length
+                    ? ` (params: ${skill.parameters.map(p => p.name + (p.required ? '*' : '')).join(', ')})`
+                    : '';
+                lines.push(`- ${skill.id}: ${skill.description}${paramInfo}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get a specific skill by ID
+     */
+    getSkill(id) {
+        return this.skills.get(id);
+    }
+    /**
+     * Expand a skill's prompt template with parameter values
+     */
+    expandPrompt(skill, parameterValues) {
+        let prompt = skill.prompt;
+        // Replace {{param}} placeholders with values
+        if (skill.parameters) {
+            for (const param of skill.parameters) {
+                const value = parameterValues[param.name] ?? param.default ?? '';
+                const placeholder = new RegExp(`\\{\\{${param.name}\\}\\}`, 'g');
+                prompt = prompt.replace(placeholder, String(value));
+            }
+        }
+        // Remove any remaining unreplaced placeholders
+        prompt = prompt.replace(/\{\{[^}]+\}\}/g, '');
+        return prompt.trim();
+    }
+    /**
+     * Get eligible skills (those that meet all requirements)
+     */
+    async getEligibleSkills() {
+        const statusEntries = await this.getSkillStatus();
+        return statusEntries.skills
+            .filter((entry) => entry.eligible)
+            .map((entry) => this.getSkill(entry.id))
+            .filter(Boolean);
+    }
+    /**
+     * Get skill status with eligibility information
+     */
+    async getSkillStatus() {
+        const skills = this.listSkills();
+        const statusEntries = await this.eligibilityChecker.buildStatusEntries(skills);
+        const summary = {
+            total: statusEntries.length,
+            eligible: statusEntries.filter((s) => s.eligible).length,
+            disabled: statusEntries.filter((s) => s.disabled).length,
+            missingRequirements: statusEntries.filter((s) => !s.eligible && !s.disabled && !s.blockedByAllowlist).length,
+        };
+        return {
+            workspaceDir: this.workspaceSkillsDir || '',
+            managedSkillsDir: this.managedSkillsDir,
+            bundledSkillsDir: this.bundledSkillsDir,
+            skills: statusEntries,
+            summary,
+        };
+    }
+    /**
+     * Get status for a single skill
+     */
+    async getSkillStatusEntry(skillId) {
+        const skill = this.getSkill(skillId);
+        if (!skill)
+            return null;
+        return this.eligibilityChecker.buildStatusEntry(skill);
+    }
+    /**
+     * Update skills config
+     */
+    updateConfig(config) {
+        this.skillsConfig = config;
+        this.eligibilityChecker.updateConfig(config);
+    }
+    /**
+     * Clear eligibility cache (useful after installing dependencies)
+     */
+    clearEligibilityCache() {
+        this.eligibilityChecker.clearCache();
+    }
+    /**
+     * Create a skill in the workspace directory
+     */
+    async createWorkspaceSkill(skill) {
+        if (!this.workspaceSkillsDir) {
+            throw new Error('Workspace skills directory not set');
+        }
+        // Ensure workspace skills directory exists
+        if (!fs.existsSync(this.workspaceSkillsDir)) {
+            fs.mkdirSync(this.workspaceSkillsDir, { recursive: true });
+        }
+        const filePath = path.join(this.workspaceSkillsDir, `${skill.id}.json`);
+        const fullSkill = {
+            ...skill,
+            source: 'workspace',
+            filePath,
+        };
+        fs.writeFileSync(filePath, JSON.stringify(fullSkill, null, 2), 'utf-8');
+        // Reload skills to pick up the new one
+        await this.reloadSkills();
+        return fullSkill;
+    }
+    /**
+     * Update a skill
+     */
+    async updateSkill(skillId, updates) {
+        const skill = this.getSkill(skillId);
+        if (!skill || !skill.filePath) {
+            return null;
+        }
+        // Only allow updating workspace and managed skills
+        if (skill.source === 'bundled') {
+            throw new Error('Cannot update bundled skills');
+        }
+        const updatedSkill = {
+            ...skill,
+            ...updates,
+        };
+        fs.writeFileSync(skill.filePath, JSON.stringify(updatedSkill, null, 2), 'utf-8');
+        // Reload skills to pick up the update
+        await this.reloadSkills();
+        return updatedSkill;
+    }
+    /**
+     * Delete a workspace skill
+     */
+    async deleteWorkspaceSkill(skillId) {
+        const skill = this.getSkill(skillId);
+        if (!skill || !skill.filePath || skill.source !== 'workspace') {
+            return false;
+        }
+        try {
+            fs.unlinkSync(skill.filePath);
+            await this.reloadSkills();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Delete a managed skill (from registry)
+     */
+    async deleteManagedSkill(skillId) {
+        const skill = this.getSkill(skillId);
+        if (!skill || !skill.filePath || skill.source !== 'managed') {
+            return false;
+        }
+        try {
+            fs.unlinkSync(skill.filePath);
+            await this.reloadSkills();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Open the managed skills folder in the system file browser
+     */
+    async openSkillsFolder() {
+        const { shell } = await Promise.resolve().then(() => __importStar(require('electron')));
+        // Ensure directory exists
+        if (!fs.existsSync(this.managedSkillsDir)) {
+            fs.mkdirSync(this.managedSkillsDir, { recursive: true });
+        }
+        await shell.openPath(this.managedSkillsDir);
+    }
+    // === Backward compatibility aliases ===
+    /**
+     * Create a skill (alias for createWorkspaceSkill)
+     * @deprecated Use createWorkspaceSkill instead
+     */
+    async createSkill(skill) {
+        // For backward compatibility, if no workspace is set, create in managed dir
+        if (!this.workspaceSkillsDir) {
+            const filePath = path.join(this.managedSkillsDir, `${skill.id}.json`);
+            const fullSkill = {
+                ...skill,
+                source: 'managed',
+                filePath,
+            };
+            fs.writeFileSync(filePath, JSON.stringify(fullSkill, null, 2), 'utf-8');
+            await this.reloadSkills();
+            return fullSkill;
+        }
+        return this.createWorkspaceSkill(skill);
+    }
+    /**
+     * Delete a skill (checks both workspace and managed)
+     * @deprecated Use deleteWorkspaceSkill or deleteManagedSkill instead
+     */
+    async deleteSkill(skillId) {
+        const skill = this.getSkill(skillId);
+        if (!skill)
+            return false;
+        if (skill.source === 'workspace') {
+            return this.deleteWorkspaceSkill(skillId);
+        }
+        if (skill.source === 'managed') {
+            return this.deleteManagedSkill(skillId);
+        }
+        return false;
+    }
+}
+exports.CustomSkillLoader = CustomSkillLoader;
+// Singleton instance
+let instance = null;
+function getCustomSkillLoader(config) {
+    if (!instance) {
+        instance = new CustomSkillLoader(config);
+    }
+    return instance;
+}
+/**
+ * Reset the singleton instance (useful for testing)
+ */
+function resetCustomSkillLoader() {
+    instance = null;
+}