psadk 1.3.3 → 1.3.5

package/build/module/lib/skills/utils.js

@@ -4,10 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = getSlingshotDirectories;
+exports.validateSkillName = validateSkillName;
+exports.validateSkillSource = validateSkillSource;
+exports.ensureSkillsDirectory = ensureSkillsDirectory;
+exports.getSkillFilePath = getSkillFilePath;
+exports.skillExists = skillExists;
+exports.readSkillContent = readSkillContent;
+exports.scanInstalledSkills = scanInstalledSkills;
+exports.normalizeSkillSource = normalizeSkillSource;
+exports.extractSkillName = extractSkillName;
+exports.installSkill = installSkill;
+exports.convertSkillsToSystemPromptXml = convertSkillsToSystemPromptXml;
+exports.getSkillsSystemPromptFromDirectory = getSkillsSystemPromptFromDirectory;
+exports.setupSkillsAndGetPrompt = setupSkillsAndGetPrompt;
+const fs_1 = require("fs");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const debuglogger_1 = __importDefault(require("../utils/debuglogger"));
 const constants_1 = __importDefault(require("./constants"));
+const skillParser_1 = require("./skillParser");
+const skillsXMLMetaDataGenerator_1 = __importDefault(require("./skillsXMLMetaDataGenerator"));
 /**
  * Gets the slingshot directories for both workspace and user levels.
  * Creates the directories if they don't exist.
@@ -45,4 +63,325 @@ function getSlingshotDirectories(repoRoot) {
         return result;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NraWxscy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQVlBLDBDQThDQztBQTFERCxzREFBeUI7QUFDekIsc0RBQXlCO0FBQ3pCLDBEQUE2QjtBQUU3Qiw0REFBMEM7QUFFMUM7Ozs7O0dBS0c7QUFDSCxTQUF3Qix1QkFBdUIsQ0FBQyxRQUFnQjtJQUM5RCxNQUFNLE1BQU0sR0FHUjtRQUNGLDBCQUEwQixFQUFFLElBQUk7UUFDaEMscUJBQXFCLEVBQUUsSUFBSTtLQUM1QixDQUFDO0lBRUYsSUFBSSxDQUFDO1FBQ0gsMkNBQTJDO1FBQzNDLElBQUksUUFBUSxFQUFFLENBQUM7WUFDYixNQUFNLHFCQUFxQixHQUFHLG1CQUFJLENBQUMsSUFBSSxDQUNyQyxRQUFRLEVBQ1IsbUJBQWUsQ0FBQyxhQUFhLENBQzlCLENBQUM7WUFFRix1REFBdUQ7WUFDdkQsSUFBSSxDQUFDLGlCQUFFLENBQUMsVUFBVSxDQUFDLHFCQUFxQixDQUFDLEVBQUUsQ0FBQztnQkFDMUMsaUJBQUUsQ0FBQyxTQUFTLENBQUMscUJBQXFCLEVBQUUsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUMzRCxDQUFDO1lBRUQsTUFBTSxDQUFDLDBCQUEwQixHQUFHLHFCQUFxQixDQUFDO1FBQzVELENBQUM7UUFFRCxxRUFBcUU7UUFDckUsTUFBTSxXQUFXLEdBQUcsaUJBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUVqQyxNQUFNLGdCQUFnQixHQUFHLG1CQUFJLENBQUMsSUFBSSxDQUNoQyxXQUFXLEVBQ1gsbUJBQWUsQ0FBQyxhQUFhLENBQzlCLENBQUM7UUFFRixrREFBa0Q7UUFDbEQsSUFBSSxDQUFDLGlCQUFFLENBQUMsVUFBVSxDQUFDLGdCQUFnQixDQUFDLEVBQUUsQ0FBQztZQUNyQyxpQkFBRSxDQUFDLFNBQVMsQ0FBQyxnQkFBZ0IsRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQ3RELENBQUM7UUFFRCxNQUFNLENBQUMscUJBQXFCLEdBQUcsZ0JBQWdCLENBQUM7UUFFaEQsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDZiwrREFBK0Q7UUFDL0QsT0FBTyxDQUFDLEtBQUssQ0FBQyx1Q0FBdUMsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUM5RCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0FBQ0gsQ0FBQyJ9
+const dlog = (0, debuglogger_1.default)('PSAI:SkillUtils:');
+// Extract skill-related constants from centralized constants
+const { AGENTS_DIR, SKILLS_DIR, SKILL_DEFINITION_FILE } = constants_1.default;
+// Map to track ongoing installations to prevent race conditions
+const ongoingInstallations = new Map();
+/**
+ * Validates skill name for security (prevents path traversal)
+ */
+function validateSkillName(skillName) {
+    // Skill name should not contain path separators or special characters
+    const validPattern = /^[a-zA-Z0-9_-]+$/;
+    return validPattern.test(skillName) && !skillName.includes('..');
+}
+/**
+ * Validates skill source URL for security (prevents command injection)
+ */
+function validateSkillSource(source) {
+    if (!source || typeof source !== 'string') {
+        return false;
+    }
+    const trimmed = source.trim();
+    // Check for common malicious patterns
+    const dangerousPatterns = [
+        /[;&|`$(){}[\]\\]/, // Shell metacharacters
+        /\.\./, // Path traversal
+        /^-/, // Starting with dash (could be interpreted as flag)
+        /\s/, // Whitespace (could break command parsing)
+        // eslint-disable-next-line no-control-regex
+        /[\x00-\x1f\x7f]/, // Control characters
+    ];
+    for (const pattern of dangerousPatterns) {
+        if (pattern.test(trimmed)) {
+            return false;
+        }
+    }
+    // Only allow specific URL patterns
+    const allowedPatterns = [
+        /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+(@[a-zA-Z0-9_-]+)?$/, // owner/repo@skill
+        /^github\.com\/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+(@[a-zA-Z0-9_-]+)?$/, // github.com/owner/repo@skill
+        /^https:\/\/github\.com\/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+(@[a-zA-Z0-9_-]+)?$/, // Full GitHub URL
+    ];
+    return allowedPatterns.some((pattern) => pattern.test(trimmed));
+}
+/**
+ * Ensures skills directory exists
+ */
+async function ensureSkillsDirectory(skillsPath) {
+    await fs_1.promises.mkdir(skillsPath, { recursive: true });
+}
+/**
+ * Gets the path to a skill's SKILL.md file
+ * Skills are stored in the .agents/skills subdirectory as created by npx skills CLI
+ */
+function getSkillFilePath(skillsPath, skillName) {
+    if (!validateSkillName(skillName)) {
+        throw new Error(`Invalid skill name: ${skillName}`);
+    }
+    return node_path_1.default.join(skillsPath, AGENTS_DIR, SKILLS_DIR, skillName, SKILL_DEFINITION_FILE);
+}
+/**
+ * Checks if a skill exists locally
+ */
+function skillExists(skillsPath, skillName) {
+    const skillFilePath = getSkillFilePath(skillsPath, skillName);
+    return node_fs_1.default.existsSync(skillFilePath);
+}
+/**
+ * Reads skill content and parses frontmatter using skillParser
+ */
+async function readSkillContent(skillsPath, skillName) {
+    const skillFilePath = getSkillFilePath(skillsPath, skillName);
+    const rawContent = await fs_1.promises.readFile(skillFilePath, 'utf-8');
+    const parsed = (0, gray_matter_1.default)(rawContent);
+    // Create SkillFrontmatter with user-friendly defaults (different from SkillMetadata)
+    const metadata = {
+        name: parsed.data.name || skillName,
+        description: parsed.data.description || 'No description provided',
+        version: parsed.data.version || '1.0.0',
+        author: parsed.data.author || 'Unknown',
+        dependencies: parsed.data.dependencies || [],
+    };
+    return {
+        metadata,
+        content: parsed.content,
+        rawContent,
+    };
+}
+/**
+ * Scans a directory for installed skills and returns metadata
+ */
+async function scanInstalledSkills(skillsPath) {
+    const installedSkills = new Map();
+    try {
+        await fs_1.promises.access(skillsPath);
+    }
+    catch {
+        return installedSkills;
+    }
+    try {
+        // Skills are located in .agents/skills directory (created by npx skills CLI)
+        const skillsDir = node_path_1.default.join(skillsPath, AGENTS_DIR, SKILLS_DIR);
+        dlog.info(`Scanning skills directory: ${skillsDir}`);
+        try {
+            await fs_1.promises.access(skillsDir);
+        }
+        catch {
+            dlog.info(`Skills directory does not exist: ${skillsDir}`);
+            return installedSkills;
+        }
+        const entries = await fs_1.promises.readdir(skillsDir, {
+            withFileTypes: true,
+        });
+        dlog.info(`Found entries:`, entries.map((e) => `${e.name} (${e.isDirectory() ? 'dir' : 'file'})`));
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skillDir = node_path_1.default.join(skillsDir, entry.name);
+                dlog.info(`Checking skill directory: ${skillDir}`);
+                const metadata = await loadSkillMetadata(skillDir);
+                dlog.info(`Metadata loaded:`, metadata ? 'success' : 'failed');
+                if (metadata) {
+                    metadata.path = skillDir;
+                    installedSkills.set(entry.name, metadata);
+                    dlog.info(`Added skill: ${entry.name}`);
+                }
+            }
+        }
+        dlog.info(`Total skills found: ${installedSkills.size}`);
+        dlog.info(`Skill names:`, Array.from(installedSkills.keys()));
+    }
+    catch (error) {
+        dlog.error(`Error scanning skills:`, error);
+    }
+    return installedSkills;
+}
+/**
+ * Load skill metadata from SKILL.md file using skillParser
+ */
+async function loadSkillMetadata(skillDir) {
+    const skillMdPath = node_path_1.default.join(skillDir, SKILL_DEFINITION_FILE);
+    try {
+        const fileContent = await fs_1.promises.readFile(skillMdPath, 'utf-8');
+        return (0, skillParser_1.parseSkillMetadataFromContent)(fileContent, skillDir);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Normalizes skill source URLs to handle common formatting issues
+ */
+function normalizeSkillSource(source) {
+    // Validate input first for security
+    if (!validateSkillSource(source)) {
+        throw new Error(`Invalid or potentially unsafe skill source: ${source}`);
+    }
+    let normalized = source.trim();
+    // Remove .git suffix if present (common mistake)
+    normalized = normalized.replace(/\.git$/, '');
+    // Remove https:// prefix if present (npx skills prefers short format)
+    normalized = normalized.replace(/^https:\/\//, '');
+    // Remove github.com/ prefix (npx skills prefers owner/repo format)
+    normalized = normalized.replace(/^github\.com\//, '');
+    return normalized;
+}
+/**
+ * Extract skill name from source URL
+ */
+function extractSkillName(source) {
+    // Handle formats like:
+    // - github.com/owner/repo@skill
+    // - owner/repo@skill
+    // - github.com/owner/repo (use repo name)
+    const normalized = source.replace(/^github\.com\//, '');
+    let skillName;
+    if (normalized.includes('@')) {
+        skillName = normalized.split('@')[1];
+    }
+    else {
+        // Use repo name if no skill specified
+        skillName = normalized.split('/')[1] || 'unknown-skill';
+    }
+    // Validate the extracted skill name for security
+    if (!validateSkillName(skillName)) {
+        throw new Error(`Invalid skill name extracted from source: ${skillName}`);
+    }
+    return skillName;
+}
+/**
+ * Install a skill using npx skills command (simplified)
+ */
+async function installSkill(options) {
+    const { source, skillsPath, timeout = 60000 } = options;
+    if (!source || typeof source !== 'string') {
+        throw new Error('Invalid skill source provided');
+    }
+    const normalizedSource = normalizeSkillSource(source);
+    const skillName = extractSkillName(normalizedSource);
+    if (!validateSkillName(skillName)) {
+        throw new Error(`Invalid skill name derived from source: ${skillName}`);
+    }
+    // Check if there's already an ongoing installation for this skill
+    if (ongoingInstallations.has(skillName)) {
+        dlog.info(`Installation for ${skillName} already in progress, waiting...`);
+        return ongoingInstallations.get(skillName);
+    }
+    // Check if already installed
+    if (skillExists(skillsPath, skillName)) {
+        const skillDir = node_path_1.default.join(skillsPath, AGENTS_DIR, SKILLS_DIR, skillName);
+        const metadata = await loadSkillMetadata(skillDir);
+        if (metadata) {
+            dlog.info(`Skill ${skillName} already installed`);
+            return metadata;
+        }
+    }
+    // Create installation promise and track it
+    const installationPromise = performSimpleInstallation(normalizedSource, skillName, skillsPath, timeout);
+    ongoingInstallations.set(skillName, installationPromise);
+    try {
+        return await installationPromise;
+    }
+    finally {
+        ongoingInstallations.delete(skillName);
+    }
+}
+/**
+ * Simple skill installation - just run npx skills add and check result
+ */
+async function performSimpleInstallation(normalizedSource, skillName, skillsPath, timeout) {
+    await ensureSkillsDirectory(skillsPath);
+    try {
+        // Run the installation command safely with spawn to prevent command injection
+        const command = 'npx';
+        const args = ['skills', 'add', normalizedSource, '--yes'];
+        dlog.info(`Installing skill: ${command} ${args.join(' ')}`);
+        const { spawnSync } = await import('child_process');
+        const result = spawnSync(command, args, {
+            cwd: skillsPath,
+            timeout,
+            stdio: 'inherit', // Show output directly
+            encoding: 'utf8',
+        });
+        // Check if the command failed
+        if (result.error) {
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            throw new Error(`Installation process exited with code ${result.status}`);
+        }
+        // Check if installation succeeded by looking for the skill
+        const skillDir = node_path_1.default.join(skillsPath, AGENTS_DIR, SKILLS_DIR, skillName);
+        const metadata = await loadSkillMetadata(skillDir);
+        if (metadata) {
+            dlog.info(`Successfully installed skill: ${skillName}`);
+            return metadata;
+        }
+        else {
+            throw new Error(`Skill installation completed but no SKILL.md found at ${skillDir}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to install skill ${skillName}: ${error}`);
+    }
+}
+/**
+ * Converts skill metadata to XML format for system prompts
+ */
+function convertSkillsToSystemPromptXml(skills) {
+    const skillsList = skills.map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+    }));
+    return (0, skillsXMLMetaDataGenerator_1.default)(skillsList);
+}
+/**
+ * Get skills XML from a skills directory scan
+ */
+async function getSkillsSystemPromptFromDirectory(skillsPath) {
+    const installedSkills = await scanInstalledSkills(skillsPath);
+    const skillsArray = Array.from(installedSkills.values());
+    return convertSkillsToSystemPromptXml(skillsArray);
+}
+/**
+ * Setup skills directory and get system prompt
+ * Accepts skill sources as an object mapping skill names to source configurations
+ */
+async function setupSkillsAndGetPrompt(skillsPath, sources, log) {
+    await ensureSkillsDirectory(skillsPath);
+    if (sources) {
+        const skillEntries = Object.entries(sources);
+        if (skillEntries.length > 0) {
+            log?.info?.(`🚀 Installing ${skillEntries.length} skills from configuration...`);
+            await Promise.all(skillEntries.map(async ([skillName, config]) => {
+                try {
+                    // Validate the source
+                    if (!config.source || !validateSkillSource(config.source)) {
+                        throw new Error(`Invalid source URL: ${config.source}`);
+                    }
+                    const normalizedSource = normalizeSkillSource(config.source);
+                    // For object format, we use the key as the skill name
+                    // Append it to the source if not already present
+                    let sourceWithSkill = normalizedSource;
+                    if (!normalizedSource.includes('@')) {
+                        sourceWithSkill = `${normalizedSource}@${skillName}`;
+                    }
+                    log?.info?.(`⬇️ Installing skill "${skillName}" from ${config.source} (${config.sourceType || 'git'})`);
+                    await installSkill({
+                        source: sourceWithSkill,
+                        skillsPath,
+                        timeout: 60000,
+                    });
+                    log?.info?.(`✅ Successfully installed skill: ${skillName}`);
+                }
+                catch (error) {
+                    log?.error?.(`❌ Failed to install skill "${skillName}":`, error);
+                    // Continue with other skills even if one fails
+                }
+            }));
+        }
+    }
+    return await getSkillsSystemPromptFromDirectory(skillsPath);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/skills/utils.ts"],"names":[],"mappings":"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"}

package/build/module/lib/tools/PSSkillTool.d.ts

@@ -0,0 +1,14 @@
+import { PSAgentLogger } from '../PSAgentLogger';
+import { PSAgentTool } from '../PSAgentTool';
+import { PSSkillToolExecutionConfig, SkillExecutionResult } from '../skills/types';
+export declare class PSSkillTool extends PSAgentTool {
+    static readonly toolName = "skill";
+    private skillsPath;
+    private allowedSkills?;
+    constructor(config: PSSkillToolExecutionConfig);
+    /**
+     * Validates if a skill is allowed to be executed
+     */
+    private isSkillAllowed;
+    run(input: Record<string, any>, log?: PSAgentLogger): Promise<SkillExecutionResult>;
+}

package/build/module/lib/tools/PSSkillTool.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSSkillTool = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const v4_1 = require("zod/v4");
+const PSAgentTool_1 = require("../PSAgentTool");
+const utils_1 = require("../skills/utils");
+const debuglogger_1 = __importDefault(require("../utils/debuglogger"));
+const dlog = (0, debuglogger_1.default)('PSAI:SkillTool:');
+//@todo arguments implementations, templated variable values expected in the arguments
+class PSSkillTool extends PSAgentTool_1.PSAgentTool {
+    static toolName = 'skill';
+    skillsPath;
+    allowedSkills;
+    constructor(config) {
+        super({
+            name: PSSkillTool.toolName,
+            description: 'Execute skills by reading their markdown content and injecting it as context. ' +
+                'Skills are reusable knowledge modules that provide specialized guidance and instructions.',
+            type: 'API',
+            local_execution: true,
+            hitl: true,
+            inputschema: {
+                url: `http://localhost/${PSSkillTool.toolName}`,
+                method: 'POST',
+                requestBody: v4_1.z.toJSONSchema(v4_1.z
+                    .object({
+                    skill_name: v4_1.z.string().meta({
+                        title: 'Skill_Name',
+                        description: 'The name of the skill to execute. Must be a valid skill name installed in the skills directory.',
+                    }),
+                    arguments: v4_1.z.string().optional().meta({
+                        title: 'Arguments',
+                        description: 'Optional arguments or context to provide to the skill. This will be included with the skill content.',
+                    }),
+                })
+                    .meta({
+                    title: `${PSSkillTool.toolName}_request_body`,
+                    description: `The request body parameters for the ${PSSkillTool.toolName} tool.`,
+                }), { io: 'input' }),
+            },
+        });
+        this.skillsPath = config.skillsPath;
+        this.allowedSkills = config.allowedSkills;
+    }
+    /**
+     * Validates if a skill is allowed to be executed
+     */
+    isSkillAllowed(skillName) {
+        if (!this.allowedSkills) {
+            return true; // No restrictions
+        }
+        return this.allowedSkills.includes(skillName);
+    }
+    async run(input, log) {
+        const logger = log || dlog;
+        // Debug logging
+        logger.info(`🔍 PSSkillTool received input:`, input);
+        // Access properties from request_body (the actual skill parameters are nested)
+        const requestBody = input?.request_body || input;
+        const skill_name = requestBody?.skill_name;
+        // Validate input
+        if (!skill_name || typeof skill_name !== 'string') {
+            throw new Error('Invalid skill name provided.');
+        }
+        // Validate skill name for security
+        if (!(0, utils_1.validateSkillName)(skill_name)) {
+            throw new Error(`Invalid skill name format: ${skill_name}. Skill names must contain only alphanumeric characters, hyphens, and underscores.`);
+        }
+        // Check if skill is allowed
+        if (!this.isSkillAllowed(skill_name)) {
+            throw new Error(`Skill not allowed: ${skill_name}. This agent is restricted to specific skills only.`);
+        }
+        // Check if skill exists on filesystem
+        if (!(0, utils_1.skillExists)(this.skillsPath, skill_name)) {
+            throw new Error(`Skill not found: ${skill_name}. Please ensure the skill is installed in ${this.skillsPath}.`);
+        }
+        try {
+            // Read skill content
+            const skillContent = await (0, utils_1.readSkillContent)(this.skillsPath, skill_name);
+            logger.info(`✅ Skill executed successfully: ${skill_name}`);
+            return {
+                status: 'success',
+                skill_name,
+                content: skillContent.content,
+                message: `Skill '${skill_name}' has been loaded and its content is now available in your context.`,
+            };
+        }
+        catch (error) {
+            logger.error(`❌ Failed to execute skill ${skill_name}:`, error);
+            if (error instanceof Error) {
+                throw new Error(`Failed to execute skill '${skill_name}': ${error.message}`);
+            }
+            throw new Error(`Unknown error occurred while executing skill '${skill_name}'`);
+        }
+    }
+}
+exports.PSSkillTool = PSSkillTool;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "psadk",
   "email": "rakesh.ravuri@publicissapient.com",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "ps adk adapter",
   "main": "build/main/index.js",
   "typings": "build/main/index.d.ts",
@@ -53,6 +53,7 @@
     "debug": "^4.4.3",
     "express": "^5.2.1",
     "fetch-retry": "^6.0.0",
+    "gray-matter": "^4.0.3",
     "jsonwebtoken": "^9.0.3",
     "uuid": "^13.0.0",
     "yaml": "^2.8.3",