@sstar/skill-install 1.0.0

package/dist/cli.js

@@ -0,0 +1,459 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const readline_1 = __importDefault(require("readline"));
+const install_service_1 = require("./installer/install-service");
+const skills_manager_1 = require("./skills/skills-manager");
+const logger_1 = require("./core/logger");
+const program = new commander_1.Command();
+const skillsManager = new skills_manager_1.SkillsManager();
+program
+    .name('skill-install')
+    .description('Agent Skill installation tool - download, extract, validate, and install skills')
+    .version('1.0.0')
+    .option('-t, --tool <tool>', 'AI tool: claude or codex (skip prompt if specified)')
+    .option('-s, --skills-dir <path>', 'Custom skills directory')
+    .option('-v, --verbose', 'Enable verbose logging');
+// Install command
+program
+    .command('install <source>')
+    .description('Install a skill from URL or local archive file')
+    .option('-u, --username <username>', 'Wiki username (for wiki URLs)')
+    .option('-p, --password <password>', 'Wiki password (not recommended, use interactive input instead)')
+    .option('--allow-self-signed', 'Allow self-signed SSL certificates (default: true)', true)
+    .option('-f, --force', 'Reinstall if skill already exists')
+    .option('-g, --global', 'Install to global directory')
+    .option('-l, --local', 'Install to local directory')
+    .action(async (source, options, cmd) => {
+    const globalOpts = cmd.parent.opts();
+    const logger = new logger_1.Logger('CLI');
+    if (globalOpts.verbose) {
+        logger_1.Logger.setLevel('debug');
+    }
+    try {
+        // Determine AI tool - prompt if not specified
+        let aiTool;
+        if (globalOpts.tool) {
+            aiTool = globalOpts.tool;
+        }
+        else {
+            aiTool = await promptAiTool();
+        }
+        // Determine skills directory
+        let skillsDir = globalOpts.skillsDir;
+        // If neither --global nor --local nor explicit --skills-dir, prompt interactively
+        if (!skillsDir && !options.global && !options.local) {
+            skillsDir = await promptSkillsDir(aiTool);
+        }
+        else if (options.global) {
+            skillsDir = skillsManager.getGlobalSkillsDir(aiTool);
+        }
+        else if (options.local) {
+            skillsDir = skillsManager.getLocalSkillsDir(aiTool);
+        }
+        console.log(`AI Tool: ${aiTool}`);
+        console.log(`Installing to: ${skillsDir}`);
+        console.log('');
+        // Get username/password for wiki URLs
+        let username = options.username || process.env.WIKI_USERNAME || '';
+        let password = options.password || process.env.WIKI_PASSWORD || '';
+        // Check if source appears to be a wiki URL
+        const needsAuth = source.includes('/download/attachments/') ||
+            source.includes('/wiki/download/') ||
+            source.includes('/confluence/download/');
+        if (needsAuth && !username) {
+            console.error('Error: Wiki URL detected. Username is required. Use -u option or set WIKI_USERNAME environment variable.');
+            process.exit(1);
+        }
+        if (needsAuth && !password) {
+            password = await promptPassword();
+        }
+        console.log(`Installing skill from: ${source}`);
+        if (needsAuth) {
+            console.log(`Username: ${username}`);
+        }
+        console.log('');
+        const installer = new install_service_1.InstallService();
+        const result = await installer.install({
+            source,
+            skillsDir,
+            username,
+            password,
+            allowSelfSigned: options.allowSelfSigned,
+            force: options.force
+        });
+        console.log('');
+        if (result.success) {
+            console.log(`✓ Skill installed successfully!`);
+            console.log(`  Name: ${result.skillName}`);
+            console.log(`  Path: ${result.skillPath}`);
+            process.exit(0);
+        }
+        else {
+            console.error(`✗ Installation failed!`);
+            console.error(`  Error: ${result.error || 'Unknown error'}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${errorMsg}`);
+        if (globalOpts.verbose) {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+});
+// List command
+program
+    .command('list')
+    .description('List installed skills')
+    .option('-a, --all', 'List skills from both global and local directories')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.parent.opts();
+    if (globalOpts.verbose) {
+        logger_1.Logger.setLevel('debug');
+    }
+    try {
+        // Determine AI tool - prompt if not specified
+        let aiTool;
+        if (globalOpts.tool) {
+            aiTool = globalOpts.tool;
+        }
+        else {
+            aiTool = await promptAiTool();
+        }
+        // If no specific directory and --all flag, show both directories
+        if (!globalOpts.skillsDir && options.all) {
+            await listSkillsFromBothDirectories(aiTool);
+            process.exit(0);
+        }
+        const skillsDir = skillsManager.getEffectiveSkillsDir(globalOpts.skillsDir, aiTool);
+        console.log(`AI Tool: ${aiTool}`);
+        console.log(`Skills directory: ${skillsDir}`);
+        console.log('');
+        const skills = await skillsManager.listInstalled(globalOpts.skillsDir, aiTool);
+        if (skills.length === 0) {
+            console.log('No skills installed.');
+            process.exit(0);
+        }
+        console.log(`Installed skills (${skills.length}):`);
+        console.log('');
+        for (const skill of skills) {
+            console.log(`  ${skill.name}`);
+            console.log(`    Description: ${skill.description}`);
+            console.log(`    Path: ${skill.path}`);
+            console.log('');
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${errorMsg}`);
+        if (globalOpts.verbose) {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+});
+// Uninstall command
+program
+    .command('uninstall [name]')
+    .description('Uninstall a skill (leave empty to select from list)')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .action(async (name, options, cmd) => {
+    const globalOpts = cmd.parent.opts();
+    if (globalOpts.verbose) {
+        logger_1.Logger.setLevel('debug');
+    }
+    try {
+        // Determine AI tool - prompt if not specified
+        let aiTool;
+        if (globalOpts.tool) {
+            aiTool = globalOpts.tool;
+        }
+        else {
+            aiTool = await promptAiTool();
+        }
+        const skills = await skillsManager.listInstalled(globalOpts.skillsDir, aiTool);
+        if (skills.length === 0) {
+            console.log('No skills installed.');
+            process.exit(0);
+        }
+        // If no name provided, prompt to select from list
+        if (!name) {
+            const selectedIndices = await promptSkillSelection(skills);
+            if (selectedIndices.length === 0) {
+                console.log('No skills selected.');
+                process.exit(0);
+            }
+            // Uninstall each selected skill
+            let successCount = 0;
+            let failCount = 0;
+            for (const index of selectedIndices) {
+                const skill = skills[index];
+                try {
+                    // Confirm uninstall unless --yes flag is provided
+                    if (!options.yes) {
+                        const confirmed = await confirm(`Uninstall skill "${skill.name}" from ${aiTool}?`);
+                        if (!confirmed) {
+                            console.log(`Skipped: ${skill.name}`);
+                            continue;
+                        }
+                    }
+                    await skillsManager.uninstall(skill.name, globalOpts.skillsDir, aiTool);
+                    console.log(`✓ Skill "${skill.name}" uninstalled successfully.`);
+                    successCount++;
+                }
+                catch (error) {
+                    console.error(`✗ Failed to uninstall "${skill.name}": ${error.message}`);
+                    failCount++;
+                }
+            }
+            console.log('');
+            console.log(`Uninstall complete: ${successCount} succeeded, ${failCount} failed.`);
+            process.exit(0);
+        }
+        // Single skill uninstall (existing behavior)
+        const skill = skills.find(s => s.name === name);
+        if (!skill) {
+            console.error(`Error: Skill "${name}" not found.`);
+            const availableSkills = skills.map(s => s.name).join(', ');
+            if (availableSkills) {
+                console.log(`Available skills: ${availableSkills}`);
+            }
+            process.exit(1);
+        }
+        // Confirm uninstall unless --yes flag is provided
+        if (!options.yes) {
+            const confirmed = await confirm(`Uninstall skill "${name}" from ${aiTool}?`);
+            if (!confirmed) {
+                console.log('Uninstall cancelled.');
+                process.exit(0);
+            }
+        }
+        await skillsManager.uninstall(name, globalOpts.skillsDir, aiTool);
+        console.log(`✓ Skill "${name}" uninstalled successfully.`);
+        process.exit(0);
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${errorMsg}`);
+        if (globalOpts.verbose) {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+});
+function promptPassword() {
+    return new Promise((resolve, reject) => {
+        // Check if setRawMode is available (TTY required)
+        if (typeof process.stdin.setRawMode !== 'function') {
+            console.error('\nError: Interactive password input requires a TTY.');
+            console.error('Please use -p option or WIKI_PASSWORD environment variable.');
+            reject(new Error('TTY not available for interactive password input'));
+            return;
+        }
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        // Turn off echo
+        process.stdout.write('Password: ');
+        process.stdin.setRawMode(true);
+        let password = '';
+        const onData = (char) => {
+            const str = char.toString();
+            if (str === '\n' || str === '\r' || str === '\u0004') {
+                // Enter or Ctrl-D
+                process.stdin.setRawMode(false);
+                process.stdin.removeListener('data', onData);
+                process.stdout.write('\n');
+                rl.close();
+                resolve(password);
+            }
+            else if (str === '\u0003') {
+                // Ctrl-C
+                process.stdout.write('\n');
+                process.exit(1);
+            }
+            else if (str === '\u007f') {
+                // Backspace
+                if (password.length > 0) {
+                    password = password.slice(0, -1);
+                }
+            }
+            else {
+                // Regular character
+                password += str;
+            }
+        };
+        process.stdin.on('data', onData);
+        process.stdin.setRawMode(true);
+    });
+}
+function confirm(message) {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(`${message} (y/N): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+function promptSkillsDir(aiTool) {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const globalDir = skillsManager.getGlobalSkillsDir(aiTool);
+        const localDir = skillsManager.getLocalSkillsDir(aiTool);
+        console.log('');
+        console.log('Select installation directory:');
+        console.log(`  1. Global: ${globalDir}`);
+        console.log(`  2. Local:  ${localDir}`);
+        console.log('');
+        rl.question('Choose [1/2] (default: 1): ', (answer) => {
+            rl.close();
+            const choice = answer.trim() || '1';
+            if (choice === '1') {
+                resolve(globalDir);
+            }
+            else if (choice === '2') {
+                resolve(localDir);
+            }
+            else {
+                console.log('Invalid choice, using global directory.');
+                resolve(globalDir);
+            }
+        });
+    });
+}
+function promptAiTool() {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        console.log('');
+        console.log('Select AI tool:');
+        console.log('  1. Claude Code (~/.claude/skills/)');
+        console.log('  2. Codex      (~/.codex/skills/)');
+        console.log('');
+        rl.question('Choose [1/2] (default: 1): ', (answer) => {
+            rl.close();
+            const choice = answer.trim() || '1';
+            if (choice === '1') {
+                resolve('claude');
+            }
+            else if (choice === '2') {
+                resolve('codex');
+            }
+            else {
+                console.log('Invalid choice, using claude.');
+                resolve('claude');
+            }
+        });
+    });
+}
+function promptSkillSelection(skills) {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        console.log('');
+        console.log('Installed skills:');
+        console.log('');
+        for (let i = 0; i < skills.length; i++) {
+            const skill = skills[i];
+            console.log(`  [${i + 1}] ${skill.name}`);
+            console.log(`      ${skill.description}`);
+            console.log('');
+        }
+        console.log('Enter the numbers of the skills to uninstall (separated by spaces, e.g., "1 3 5"):');
+        console.log('Press Enter to cancel:');
+        rl.question('Your choice: ', (answer) => {
+            rl.close();
+            const input = answer.trim();
+            if (!input) {
+                resolve([]);
+                return;
+            }
+            // Parse the input and extract valid indices
+            const selectedNumbers = input.split(/\s+/).map(s => parseInt(s, 10));
+            const validIndices = [];
+            for (const num of selectedNumbers) {
+                if (isNaN(num)) {
+                    console.log(`Skipping invalid number: ${input}`);
+                    continue;
+                }
+                if (num < 1 || num > skills.length) {
+                    console.log(`Skipping out of range number: ${num}`);
+                    continue;
+                }
+                validIndices.push(num - 1); // Convert to 0-based index
+            }
+            // Remove duplicates
+            const uniqueIndices = [...new Set(validIndices)];
+            if (uniqueIndices.length === 0) {
+                console.log('No valid skills selected.');
+                resolve([]);
+                return;
+            }
+            console.log('');
+            console.log(`Selected skills: ${uniqueIndices.map(i => skills[i].name).join(', ')}`);
+            resolve(uniqueIndices);
+        });
+    });
+}
+async function listSkillsFromBothDirectories(aiTool) {
+    const globalDir = skillsManager.getGlobalSkillsDir(aiTool);
+    const localDir = skillsManager.getLocalSkillsDir(aiTool);
+    const globalSkills = await skillsManager.listInstalled(globalDir, aiTool);
+    const localSkills = await skillsManager.listInstalled(localDir, aiTool);
+    let hasAny = false;
+    console.log(`AI Tool: ${aiTool}`);
+    console.log('');
+    // Global skills
+    console.log(`Global skills (${globalDir}):`);
+    console.log('');
+    if (globalSkills.length === 0) {
+        console.log('  No skills installed.');
+    }
+    else {
+        hasAny = true;
+        for (const skill of globalSkills) {
+            console.log(`  ${skill.name}`);
+            console.log(`    Description: ${skill.description}`);
+            console.log('');
+        }
+    }
+    console.log('');
+    // Local skills
+    console.log(`Local skills (${localDir}):`);
+    console.log('');
+    if (localSkills.length === 0) {
+        console.log('  No skills installed.');
+    }
+    else {
+        hasAny = true;
+        for (const skill of localSkills) {
+            console.log(`  ${skill.name}`);
+            console.log(`    Description: ${skill.description}`);
+            console.log('');
+        }
+    }
+    if (!hasAny) {
+        console.log('No skills installed in either location.');
+    }
+}
+program.parse();

package/dist/core/errors.d.ts

@@ -0,0 +1,19 @@
+export declare enum ErrorType {
+    AUTHENTICATION = "AUTHENTICATION",
+    ACCESS_DENIED = "ACCESS_DENIED",
+    INVALID_INPUT = "INVALID_INPUT",
+    NETWORK = "NETWORK",
+    NOT_FOUND = "NOT_FOUND",
+    CONTENT_VALIDATION = "CONTENT_VALIDATION",
+    ATTACHMENT = "ATTACHMENT",
+    INVALID_SKILL = "INVALID_SKILL",
+    EXTRACTION_FAILED = "EXTRACTION_FAILED",
+    ALREADY_INSTALLED = "ALREADY_INSTALLED",
+    UNKNOWN = "UNKNOWN"
+}
+export declare class WikiError extends Error {
+    readonly type: ErrorType;
+    readonly cause?: unknown | undefined;
+    constructor(type: ErrorType, message: string, cause?: unknown | undefined);
+    static is(error: unknown): error is WikiError;
+}

package/dist/core/errors.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WikiError = exports.ErrorType = void 0;
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["AUTHENTICATION"] = "AUTHENTICATION";
+    ErrorType["ACCESS_DENIED"] = "ACCESS_DENIED";
+    ErrorType["INVALID_INPUT"] = "INVALID_INPUT";
+    ErrorType["NETWORK"] = "NETWORK";
+    ErrorType["NOT_FOUND"] = "NOT_FOUND";
+    ErrorType["CONTENT_VALIDATION"] = "CONTENT_VALIDATION";
+    ErrorType["ATTACHMENT"] = "ATTACHMENT";
+    ErrorType["INVALID_SKILL"] = "INVALID_SKILL";
+    ErrorType["EXTRACTION_FAILED"] = "EXTRACTION_FAILED";
+    ErrorType["ALREADY_INSTALLED"] = "ALREADY_INSTALLED";
+    ErrorType["UNKNOWN"] = "UNKNOWN";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));
+class WikiError extends Error {
+    constructor(type, message, cause) {
+        super(message);
+        this.type = type;
+        this.cause = cause;
+        this.name = 'WikiError';
+    }
+    static is(error) {
+        return error instanceof WikiError;
+    }
+}
+exports.WikiError = WikiError;

package/dist/core/logger.d.ts

@@ -0,0 +1,14 @@
+export type LogLevelName = 'debug' | 'info' | 'warn' | 'error';
+export declare class Logger {
+    private readonly scope;
+    private static globalLevel;
+    constructor(scope: string);
+    static setLevel(level: LogLevelName): void;
+    private shouldLog;
+    private format;
+    private stringify;
+    debug(message: string, ...extra: unknown[]): void;
+    info(message: string, ...extra: unknown[]): void;
+    warn(message: string, ...extra: unknown[]): void;
+    error(message: string, ...extra: unknown[]): void;
+}

package/dist/core/logger.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const levelWeights = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40
+};
+class Logger {
+    constructor(scope) {
+        this.scope = scope;
+    }
+    static setLevel(level) {
+        if (levelWeights[level] !== undefined) {
+            Logger.globalLevel = level;
+        }
+    }
+    shouldLog(level) {
+        return levelWeights[level] >= levelWeights[Logger.globalLevel];
+    }
+    format(level, message, extra) {
+        const timestamp = new Date().toISOString();
+        const context = extra && extra.length ? ' ' + extra.map(this.stringify).join(' ') : '';
+        return `[${timestamp}] [${level.toUpperCase()}] [${this.scope}] ${message}${context}`;
+    }
+    stringify(value) {
+        if (typeof value === 'string') {
+            if (value.length > 400) {
+                return `${value.slice(0, 400)}…`;
+            }
+            return value;
+        }
+        try {
+            return JSON.stringify(value, (key, val) => {
+                if (typeof key === 'string' && key.toLowerCase().includes('password')) {
+                    return '[REDACTED]';
+                }
+                return val;
+            });
+        }
+        catch {
+            return String(value);
+        }
+    }
+    debug(message, ...extra) {
+        if (this.shouldLog('debug')) {
+            process.stderr.write(this.format('debug', message, extra) + '\n');
+        }
+    }
+    info(message, ...extra) {
+        if (this.shouldLog('info')) {
+            process.stderr.write(this.format('info', message, extra) + '\n');
+        }
+    }
+    warn(message, ...extra) {
+        if (this.shouldLog('warn')) {
+            process.stderr.write(this.format('warn', message, extra) + '\n');
+        }
+    }
+    error(message, ...extra) {
+        if (this.shouldLog('error')) {
+            process.stderr.write(this.format('error', message, extra) + '\n');
+        }
+    }
+}
+exports.Logger = Logger;
+Logger.globalLevel = 'info';

package/dist/download/download-manager.d.ts

@@ -0,0 +1,41 @@
+export interface DownloadOptions {
+    url: string;
+    outputPath: string;
+    username?: string;
+    password?: string;
+    baseUrl?: string;
+    allowSelfSigned?: boolean;
+    requireAuth?: boolean;
+}
+export interface DownloadResult {
+    success: boolean;
+    filepath: string;
+    size: number;
+    error?: string;
+}
+/**
+ * Download Manager with support for both authenticated (wiki) and public downloads
+ */
+export declare class DownloadManager {
+    private readonly logger;
+    private http?;
+    private auth?;
+    /**
+     * Download a file from a URL
+     * If requireAuth is true, use the AuthService for authentication
+     */
+    download(options: DownloadOptions): Promise<DownloadResult>;
+    /**
+     * Download with authentication (for wiki URLs)
+     */
+    private downloadWithAuth;
+    /**
+     * Direct download without authentication (for public URLs)
+     */
+    private downloadDirect;
+    private formatSize;
+    /**
+     * Extract filename from URL
+     */
+    extractFilenameFromUrl(url: string): string | null;
+}