@sstar/skill-install 1.0.0

package/dist/auth/auth-service.js

@@ -0,0 +1,260 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const cheerio = __importStar(require("cheerio"));
+const errors_1 = require("../core/errors");
+const logger_1 = require("../core/logger");
+class AuthService {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        this.logger = new logger_1.Logger('AuthService');
+        this.authInFlight = null;
+        this.session = {
+            cookies: [],
+            isAuthenticated: false,
+            lastAuthTime: 0
+        };
+    }
+    async ensureAuthenticated() {
+        try {
+            const isValid = await this.isSessionValid();
+            if (!isValid) {
+                this.logger.info('Session invalid, attempting to re-authenticate');
+                if (!this.authInFlight) {
+                    this.authInFlight = this.authenticate().finally(() => {
+                        this.authInFlight = null;
+                    });
+                }
+                const success = await this.authInFlight;
+                if (!success) {
+                    throw new errors_1.WikiError(errors_1.ErrorType.AUTHENTICATION, 'Failed to authenticate with Confluence');
+                }
+                this.logger.info('Re-authentication successful');
+            }
+            else {
+                this.logger.debug('Session is valid, no re-authentication needed');
+            }
+        }
+        catch (error) {
+            this.logger.error('Authentication check failed:', error);
+            throw new errors_1.WikiError(errors_1.ErrorType.AUTHENTICATION, `Authentication failed: ${error.message}`, error);
+        }
+    }
+    async authenticate() {
+        try {
+            this.logger.info('Starting authentication process');
+            const isValid = await this.isSessionValid();
+            if (isValid) {
+                this.logger.info('Existing session is still valid');
+                return true;
+            }
+            this.logger.info('Performing fresh authentication');
+            const loginData = await this.getLoginFormData();
+            const success = await this.performLogin(loginData);
+            if (success) {
+                this.session.isAuthenticated = true;
+                this.session.lastAuthTime = Date.now();
+                this.session.cookies = this.http.getCookies();
+                this.logger.info('Authentication successful');
+                return true;
+            }
+            this.logger.error('Authentication failed');
+            return false;
+        }
+        catch (error) {
+            this.logger.error('Authentication error:', error);
+            this.session.isAuthenticated = false;
+            throw error;
+        }
+    }
+    async getLoginFormData() {
+        try {
+            this.logger.debug('Fetching login page');
+            const response = await this.http.get('/login.action');
+            const $ = cheerio.load(response.data);
+            const loginData = {
+                username: this.config.username,
+                password: this.config.password
+            };
+            // Extract CSRF token
+            const csrfToken = $('meta[name="ajs-atl-token"]').attr('content') ||
+                $('meta[name="atlassian-token"]').attr('content') ||
+                $('input[name="atl_token"]').attr('value') ||
+                $('meta[name="_token"]').attr('content');
+            if (csrfToken) {
+                loginData.csrfToken = csrfToken;
+                loginData['atl_token'] = csrfToken;
+                this.logger.debug('Found CSRF token');
+            }
+            else {
+                this.logger.warn('No CSRF token found in login page');
+            }
+            // Extract all hidden fields from the login form
+            $('form#loginform input[type="hidden"], form[name="loginform"] input[type="hidden"]').each((_, element) => {
+                const name = $(element).attr('name');
+                const value = $(element).attr('value');
+                if (name && value && !loginData[name]) {
+                    loginData[name] = value;
+                    this.logger.debug(`Found hidden field: ${name}`);
+                }
+            });
+            // Extract destination field
+            const destination = $('input[name="os_destination"]').attr('value');
+            if (destination) {
+                loginData['os_destination'] = destination;
+                this.logger.debug('Found destination:', destination);
+            }
+            return loginData;
+        }
+        catch (error) {
+            this.logger.error('Failed to retrieve login form data:', error);
+            throw new errors_1.WikiError(errors_1.ErrorType.AUTHENTICATION, 'Failed to retrieve login form data', error);
+        }
+    }
+    async performLogin(loginData) {
+        try {
+            this.logger.debug('Submitting login form');
+            // Format login data - use correct field names for Confluence
+            const formData = {
+                'os_username': loginData.username,
+                'os_password': loginData.password,
+                'os_cookie': 'true',
+                'login': 'Log in'
+            };
+            // Add CSRF token
+            if (loginData.csrfToken) {
+                formData['atl_token'] = loginData.csrfToken;
+            }
+            // Add any additional hidden fields
+            Object.keys(loginData).forEach(key => {
+                if (key !== 'username' && key !== 'password' && key !== 'csrfToken' && !formData[key]) {
+                    const value = loginData[key];
+                    if (value) {
+                        formData[key] = value;
+                    }
+                }
+            });
+            const response = await this.http.post('/dologin.action', new URLSearchParams(formData).toString(), {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Referer': `${this.config.baseUrl}/login.action`
+                },
+                maxRedirects: 0,
+                validateStatus: (status) => status >= 200 && status < 400
+            });
+            const isSuccess = this.checkLoginSuccess(response.data, response.status);
+            if (isSuccess) {
+                this.logger.info('Login successful');
+                return true;
+            }
+            this.logger.warn('Login failed - invalid credentials or form submission');
+            return false;
+        }
+        catch (error) {
+            if (error.response?.status === 302) {
+                const location = error.response.headers.location;
+                this.logger.debug('Redirect response:', { status: 302, location });
+                if (location && !location.includes('login') && !location.includes('error')) {
+                    this.logger.info('Login successful (redirect detected)');
+                    return true;
+                }
+            }
+            this.logger.error('Login request failed:', error);
+            throw new errors_1.WikiError(errors_1.ErrorType.AUTHENTICATION, 'Login request failed', error);
+        }
+    }
+    checkLoginSuccess(responseData, statusCode) {
+        if (statusCode === 302) {
+            return true;
+        }
+        const $ = cheerio.load(responseData);
+        const hasLoginError = $('.error').length > 0 ||
+            $('.aui-message-error').length > 0 ||
+            $('#loginform').length > 0;
+        const hasSuccessIndicators = $('.aui-nav-heading').length > 0 ||
+            $('#header').length > 0 ||
+            $('[data-aui-component="navigation"]').length > 0;
+        return !hasLoginError && hasSuccessIndicators;
+    }
+    async isSessionValid() {
+        if (!this.session.isAuthenticated) {
+            return false;
+        }
+        const sessionAge = Date.now() - this.session.lastAuthTime;
+        const maxAge = 30 * 60 * 1000; // 30 minutes
+        if (sessionAge > maxAge) {
+            this.logger.debug('Session expired due to age');
+            this.session.isAuthenticated = false;
+            return false;
+        }
+        try {
+            this.logger.debug('Validating session by accessing dashboard');
+            const response = await this.http.get('/dashboard.action');
+            const $ = cheerio.load(response.data);
+            // Check if we're on a login page
+            const isLoginPage = $('#loginform').length > 0 ||
+                response.data.includes('Log in - Confluence') ||
+                response.data.includes('class="login');
+            // Check for authenticated user indicators
+            const isLoggedIn = !isLoginPage && ($('.aui-nav-heading').length > 0 ||
+                $('[data-aui-component="navigation"]').length > 0 ||
+                $('.aui-header').length > 0);
+            if (!isLoggedIn) {
+                this.logger.debug('Session validation failed - not logged in');
+                this.session.isAuthenticated = false;
+                return false;
+            }
+            this.logger.debug('Session is valid');
+            return true;
+        }
+        catch (error) {
+            this.logger.warn('Session validation failed:', error);
+            this.session.isAuthenticated = false;
+            return false;
+        }
+    }
+    clearSession() {
+        this.session = {
+            cookies: [],
+            isAuthenticated: false,
+            lastAuthTime: 0
+        };
+        this.http.clearCookies();
+        this.logger.info('Session cleared');
+    }
+}
+exports.AuthService = AuthService;

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};