@sstar/skill-install 1.0.0

package/dist/download/download-manager.js

@@ -0,0 +1,184 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadManager = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const promises_2 = require("stream/promises");
+const axios_1 = __importDefault(require("axios"));
+const http_client_1 = require("../http/http-client");
+const auth_service_1 = require("../auth/auth-service");
+const logger_1 = require("../core/logger");
+const errors_1 = require("../core/errors");
+/**
+ * Download Manager with support for both authenticated (wiki) and public downloads
+ */
+class DownloadManager {
+    constructor() {
+        this.logger = new logger_1.Logger('DownloadManager');
+    }
+    /**
+     * Download a file from a URL
+     * If requireAuth is true, use the AuthService for authentication
+     */
+    async download(options) {
+        try {
+            // Ensure parent directory exists
+            const dir = path_1.default.dirname(options.outputPath);
+            await (0, promises_1.mkdir)(dir, { recursive: true });
+            this.logger.info(`Downloading: ${options.url} -> ${options.outputPath}`);
+            if (options.requireAuth) {
+                return await this.downloadWithAuth(options);
+            }
+            else {
+                return await this.downloadDirect(options);
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Download failed: ${errorMsg}`);
+            return {
+                success: false,
+                filepath: options.outputPath,
+                size: 0,
+                error: errorMsg
+            };
+        }
+    }
+    /**
+     * Download with authentication (for wiki URLs)
+     */
+    async downloadWithAuth(options) {
+        if (!options.username || !options.password || !options.baseUrl) {
+            throw new errors_1.WikiError(errors_1.ErrorType.AUTHENTICATION, 'Username, password, and baseUrl are required for authenticated downloads');
+        }
+        // Initialize HTTP client and auth service if not already done
+        if (!this.http || !this.auth) {
+            this.http = new http_client_1.HttpClient({
+                baseUrl: options.baseUrl,
+                allowSelfSigned: options.allowSelfSigned ?? true,
+                timeoutMs: 60000
+            });
+            this.auth = new auth_service_1.AuthService(this.http, {
+                baseUrl: options.baseUrl,
+                username: options.username,
+                password: options.password
+            });
+        }
+        // Ensure authenticated before downloading
+        await this.auth.ensureAuthenticated();
+        this.logger.info('Authentication successful, starting download');
+        // Perform streaming download
+        const response = await this.http.get(options.url, {
+            responseType: 'stream'
+        });
+        // Save file
+        const writer = (0, fs_1.createWriteStream)(options.outputPath);
+        await (0, promises_2.pipeline)(response.data, writer);
+        // Get file size
+        const stats = await Promise.resolve().then(() => __importStar(require('fs'))).then(fs => fs.promises.stat(options.outputPath));
+        this.logger.info(`Download complete: ${options.outputPath} (${this.formatSize(stats.size)})`);
+        return {
+            success: true,
+            filepath: options.outputPath,
+            size: stats.size
+        };
+    }
+    /**
+     * Direct download without authentication (for public URLs)
+     */
+    async downloadDirect(options) {
+        const response = await (0, axios_1.default)({
+            method: 'GET',
+            url: options.url,
+            responseType: 'stream',
+            timeout: 60000,
+            maxRedirects: 5,
+            headers: {
+                'User-Agent': 'Skill-Install/1.0.0'
+            }
+        });
+        // Save file
+        const writer = (0, fs_1.createWriteStream)(options.outputPath);
+        await (0, promises_2.pipeline)(response.data, writer);
+        // Get file size
+        const stats = await Promise.resolve().then(() => __importStar(require('fs'))).then(fs => fs.promises.stat(options.outputPath));
+        this.logger.info(`Download complete: ${options.outputPath} (${this.formatSize(stats.size)})`);
+        return {
+            success: true,
+            filepath: options.outputPath,
+            size: stats.size
+        };
+    }
+    formatSize(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return `${(bytes / Math.pow(k, i)).toFixed(i === 0 ? 0 : 2)} ${sizes[i]}`;
+    }
+    /**
+     * Extract filename from URL
+     */
+    extractFilenameFromUrl(url) {
+        try {
+            const urlObj = new URL(url);
+            const pathname = urlObj.pathname;
+            const parts = pathname.split('/');
+            const lastPart = parts[parts.length - 1];
+            // Remove query parameters
+            const filename = lastPart.split('?')[0];
+            if (filename && filename !== '' && filename !== 'attachments') {
+                return decodeURIComponent(filename);
+            }
+            // Try to find filename in query parameters
+            const params = new URLSearchParams(urlObj.search);
+            const fileNameParam = params.get('fileName') || params.get('filename');
+            if (fileNameParam) {
+                return decodeURIComponent(fileNameParam);
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.DownloadManager = DownloadManager;

package/dist/downloader.d.ts

@@ -0,0 +1,29 @@
+export interface DownloadOptions {
+    url: string;
+    username: string;
+    password: string;
+    baseUrl: string;
+    output?: string;
+    allowSelfSigned?: boolean;
+}
+export interface DownloadResult {
+    success: boolean;
+    filepath: string;
+    size: number;
+    error?: string;
+}
+export declare class Downloader {
+    private readonly logger;
+    private readonly http;
+    private readonly auth;
+    constructor(options: {
+        baseUrl: string;
+        username: string;
+        password: string;
+        allowSelfSigned?: boolean;
+    });
+    download(options: DownloadOptions): Promise<DownloadResult>;
+    private extractFilenameFromUrl;
+    private pathExists;
+    private formatSize;
+}

package/dist/downloader.js

@@ -0,0 +1,163 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Downloader = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const promises_2 = require("stream/promises");
+const http_client_1 = require("./http/http-client");
+const auth_service_1 = require("./auth/auth-service");
+const logger_1 = require("./core/logger");
+class Downloader {
+    constructor(options) {
+        this.logger = new logger_1.Logger('Downloader');
+        this.http = new http_client_1.HttpClient({
+            baseUrl: options.baseUrl,
+            allowSelfSigned: options.allowSelfSigned ?? true,
+            timeoutMs: 60000
+        });
+        this.auth = new auth_service_1.AuthService(this.http, {
+            baseUrl: options.baseUrl,
+            username: options.username,
+            password: options.password
+        });
+    }
+    async download(options) {
+        try {
+            // Ensure authenticated before downloading
+            await this.auth.ensureAuthenticated();
+            this.logger.info('Authentication successful, starting download');
+            // Determine output path
+            let outputPath;
+            if (options.output) {
+                // If output is a directory, use filename from URL
+                const stat = await this.pathExists(options.output);
+                if (stat === 'dir') {
+                    const filename = this.extractFilenameFromUrl(options.url) || 'download';
+                    outputPath = path_1.default.join(options.output, filename);
+                }
+                else {
+                    // Create parent directory if needed
+                    const dir = path_1.default.dirname(options.output);
+                    await (0, promises_1.mkdir)(dir, { recursive: true });
+                    outputPath = options.output;
+                }
+            }
+            else {
+                // Use current directory with filename from URL
+                const filename = this.extractFilenameFromUrl(options.url) || 'download';
+                outputPath = path_1.default.join(process.cwd(), filename);
+            }
+            // Ensure parent directory exists
+            const dir = path_1.default.dirname(outputPath);
+            await (0, promises_1.mkdir)(dir, { recursive: true });
+            this.logger.info(`Downloading: ${options.url} -> ${outputPath}`);
+            // Perform streaming download
+            const response = await this.http.get(options.url, {
+                responseType: 'stream'
+            });
+            // Save file
+            const writer = (0, fs_1.createWriteStream)(outputPath);
+            await (0, promises_2.pipeline)(response.data, writer);
+            // Get file size
+            const stats = await Promise.resolve().then(() => __importStar(require('fs'))).then(fs => fs.promises.stat(outputPath));
+            this.logger.info(`Download complete: ${outputPath} (${this.formatSize(stats.size)})`);
+            return {
+                success: true,
+                filepath: outputPath,
+                size: stats.size
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Download failed: ${errorMsg}`);
+            return {
+                success: false,
+                filepath: options.output || options.url,
+                size: 0,
+                error: errorMsg
+            };
+        }
+    }
+    extractFilenameFromUrl(url) {
+        try {
+            // Parse URL to extract filename
+            const urlObj = new URL(url);
+            const pathname = urlObj.pathname;
+            // Handle typical Confluence attachment URLs
+            // e.g., /download/attachments/12345/filename.pdf?api=v2
+            const parts = pathname.split('/');
+            const lastPart = parts[parts.length - 1];
+            // Remove query parameters
+            const filename = lastPart.split('?')[0];
+            // Handle versioning parameter like filename.pdf?version=1
+            if (filename && filename !== '' && filename !== 'attachments') {
+                return decodeURIComponent(filename);
+            }
+            // Try to find filename in query parameters
+            const params = new URLSearchParams(urlObj.search);
+            const fileNameParam = params.get('fileName') || params.get('filename');
+            if (fileNameParam) {
+                return decodeURIComponent(fileNameParam);
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async pathExists(p) {
+        try {
+            const stat = await Promise.resolve().then(() => __importStar(require('fs'))).then(fs => fs.promises.stat(p));
+            return stat.isDirectory() ? 'dir' : 'file';
+        }
+        catch {
+            return null;
+        }
+    }
+    formatSize(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return `${(bytes / Math.pow(k, i)).toFixed(i === 0 ? 0 : 2)} ${sizes[i]}`;
+    }
+}
+exports.Downloader = Downloader;

package/dist/http/http-client.d.ts

@@ -0,0 +1,25 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+export interface HttpClientOptions {
+    baseUrl: string;
+    allowSelfSigned: boolean;
+    timeoutMs?: number;
+}
+export declare class HttpClient {
+    private readonly options;
+    private readonly client;
+    private readonly logger;
+    private cookieStore;
+    constructor(options: HttpClientOptions);
+    private setupInterceptors;
+    private extractCookies;
+    private normalizeError;
+    get<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    getCookies(): string[];
+    setCookies(cookies: string[]): void;
+    clearCookies(): void;
+    private addCookieHeader;
+    setHeader(name: string, value: string): void;
+    removeHeader(name: string): void;
+    getBaseURL(): string;
+}

package/dist/http/http-client.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const https_1 = __importDefault(require("https"));
+const logger_1 = require("../core/logger");
+const errors_1 = require("../core/errors");
+class HttpClient {
+    constructor(options) {
+        this.options = options;
+        this.logger = new logger_1.Logger('HttpClient');
+        this.cookieStore = new Map();
+        // 设置环境变量来忽略证书验证（必须在创建axios实例之前）
+        this.logger.info(`HTTP Client config: baseUrl=${options.baseUrl}, allowSelfSigned=${options.allowSelfSigned}`);
+        if (options.baseUrl.startsWith('https://') && options.allowSelfSigned) {
+            process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
+            this.logger.warn('SSL certificate verification disabled for self-signed certificates');
+        }
+        // 配置axios实例
+        const axiosConfig = {
+            baseURL: options.baseUrl,
+            timeout: options.timeoutMs ?? 30000,
+            withCredentials: true,
+            maxRedirects: 5,
+            validateStatus: (status) => status >= 200 && status < 400,
+            headers: {
+                'User-Agent': 'Wiki-Download-Tool/1.0.0',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                'Accept-Language': 'en-US,en;q=0.5',
+                'Accept-Encoding': 'gzip, deflate',
+                'Connection': 'keep-alive',
+                'Upgrade-Insecure-Requests': '1'
+            }
+        };
+        // 如果需要支持自签名证书，使用自定义https agent
+        if (options.baseUrl.startsWith('https://') && options.allowSelfSigned) {
+            axiosConfig.httpsAgent = new https_1.default.Agent({
+                rejectUnauthorized: false
+            });
+        }
+        this.client = axios_1.default.create(axiosConfig);
+        this.setupInterceptors();
+    }
+    setupInterceptors() {
+        this.client.interceptors.request.use((config) => {
+            this.logger.debug(`HTTP ${config.method?.toUpperCase()} ${config.url}`);
+            this.addCookieHeader(config);
+            return config;
+        });
+        this.client.interceptors.response.use((response) => {
+            this.logger.debug(`HTTP ${response.status} ${response.config.url}`);
+            this.extractCookies(response);
+            return response;
+        }, (error) => {
+            throw this.normalizeError(error);
+        });
+    }
+    extractCookies(response) {
+        const setCookieHeader = response.headers['set-cookie'];
+        if (setCookieHeader) {
+            const cookies = Array.isArray(setCookieHeader) ? setCookieHeader : [setCookieHeader];
+            cookies.forEach(cookie => {
+                const cookieParts = cookie.split(';');
+                if (cookieParts.length > 0) {
+                    const cookiePart = cookieParts[0];
+                    if (cookiePart) {
+                        const [name, value] = cookiePart.split('=');
+                        if (name && value) {
+                            this.cookieStore.set(name.trim(), `${name.trim()}=${value}`);
+                        }
+                    }
+                }
+            });
+        }
+    }
+    normalizeError(error) {
+        this.logger.error('HTTP Error details:', {
+            message: error.message,
+            code: error.code,
+            status: error.response?.status,
+            statusText: error.response?.statusText,
+            url: error.config?.url,
+            responseData: error.response?.data ? String(error.response.data).substring(0, 500) : undefined
+        });
+        if (error.response) {
+            const status = error.response.status;
+            const statusText = error.response.statusText;
+            switch (status) {
+                case 401:
+                    return new errors_1.WikiError(errors_1.ErrorType.AUTHENTICATION, 'Authentication failed. Please check your credentials.', error);
+                case 403:
+                    return new errors_1.WikiError(errors_1.ErrorType.ACCESS_DENIED, 'Access denied. You may not have permission to access this resource.', error);
+                case 404:
+                    return new errors_1.WikiError(errors_1.ErrorType.NOT_FOUND, 'The requested page or resource was not found.', error);
+                default:
+                    return new errors_1.WikiError(errors_1.ErrorType.NETWORK, `HTTP Error ${status}: ${statusText}`, error);
+            }
+        }
+        else if (error.request) {
+            return new errors_1.WikiError(errors_1.ErrorType.NETWORK, 'Network error: Unable to reach the server. Please check your internet connection.', error);
+        }
+        else {
+            return new errors_1.WikiError(errors_1.ErrorType.UNKNOWN, `Request setup error: ${error.message}`, error);
+        }
+    }
+    async get(url, config) {
+        try {
+            return await this.client.get(url, config);
+        }
+        catch (error) {
+            throw this.normalizeError(error);
+        }
+    }
+    async post(url, data, config) {
+        try {
+            return await this.client.post(url, data, config);
+        }
+        catch (error) {
+            throw this.normalizeError(error);
+        }
+    }
+    getCookies() {
+        try {
+            return Array.from(this.cookieStore.values());
+        }
+        catch (error) {
+            this.logger.error('Error getting cookies:', error);
+            return [];
+        }
+    }
+    setCookies(cookies) {
+        try {
+            cookies.forEach(cookie => {
+                const [name, value] = cookie.split('=');
+                if (name && value) {
+                    this.cookieStore.set(name.trim(), `${name.trim()}=${value}`);
+                }
+            });
+        }
+        catch (error) {
+            this.logger.error('Error setting cookies:', error);
+        }
+    }
+    clearCookies() {
+        try {
+            this.cookieStore.clear();
+        }
+        catch (error) {
+            this.logger.error('Error clearing cookies:', error);
+        }
+    }
+    addCookieHeader(config) {
+        const cookies = this.getCookies();
+        if (cookies.length > 0) {
+            config.headers = config.headers || {};
+            config.headers['Cookie'] = cookies.join('; ');
+        }
+    }
+    setHeader(name, value) {
+        this.client.defaults.headers.common[name] = value;
+    }
+    removeHeader(name) {
+        delete this.client.defaults.headers.common[name];
+    }
+    getBaseURL() {
+        return this.options.baseUrl;
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Downloader, DownloadOptions, DownloadResult } from './downloader';
+export { HttpClient, HttpClientOptions } from './http/http-client';
+export { AuthService, AuthConfig } from './auth/auth-service';
+export { Logger, LogLevelName } from './core/logger';
+export { WikiError, ErrorType } from './core/errors';

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorType = exports.WikiError = exports.Logger = exports.AuthService = exports.HttpClient = exports.Downloader = void 0;
+var downloader_1 = require("./downloader");
+Object.defineProperty(exports, "Downloader", { enumerable: true, get: function () { return downloader_1.Downloader; } });
+var http_client_1 = require("./http/http-client");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return http_client_1.HttpClient; } });
+var auth_service_1 = require("./auth/auth-service");
+Object.defineProperty(exports, "AuthService", { enumerable: true, get: function () { return auth_service_1.AuthService; } });
+var logger_1 = require("./core/logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+var errors_1 = require("./core/errors");
+Object.defineProperty(exports, "WikiError", { enumerable: true, get: function () { return errors_1.WikiError; } });
+Object.defineProperty(exports, "ErrorType", { enumerable: true, get: function () { return errors_1.ErrorType; } });

package/dist/installer/install-service.d.ts

@@ -0,0 +1,40 @@
+export interface InstallOptions {
+    source: string;
+    skillsDir?: string;
+    username?: string;
+    password?: string;
+    allowSelfSigned?: boolean;
+    force?: boolean;
+}
+export interface InstallResult {
+    success: boolean;
+    skillName?: string;
+    skillPath?: string;
+    error?: string;
+}
+export declare class InstallService {
+    private readonly logger;
+    private readonly sourceDetector;
+    private readonly downloadManager;
+    private readonly extractor;
+    private readonly validator;
+    private readonly skillsManager;
+    /**
+     * Install a skill from a source (URL or local file)
+     */
+    install(options: InstallOptions): Promise<InstallResult>;
+    /**
+     * Find the skill directory in the extracted files
+     * The archive may contain a single root directory or have SKILL.md at root
+     */
+    private findSkillDirectory;
+    /**
+     * Move a directory from one location to another
+     * Handles cross-device moves by copying and then deleting
+     */
+    private moveDirectory;
+    /**
+     * Recursively copy a directory
+     */
+    private copyDirectory;
+}