@manojkmfsi/monodog 1.1.21 → 1.1.22

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @manojkmfsi/monoapp
 
+## 1.1.22
+
+### Patch Changes
+
+- [`6015ae6`](https://github.com/manojkmfsi/monodog/commit/6015ae608b6b89061ab5cc1dd633d974d2a5ac27) - ddfdfdfdvdvcv
+
 ## 1.1.21
 
 ### Patch Changes

package/dist/controllers/publish-controller.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublishPackages = getPublishPackages;
+exports.getPublishChangesets = getPublishChangesets;
+exports.previewPublish = previewPublish;
+exports.createChangeset = createChangeset;
+exports.checkPublishStatus = checkPublishStatus;
+exports.triggerPublish = triggerPublish;
+const logger_1 = require("../middleware/logger");
+const changeset_service_1 = require("../services/changeset-service");
+/**
+ * Get all workspace packages
+ */
+async function getPublishPackages(req, res) {
+    try {
+        const rootPath = req.app.locals.rootPath;
+        const packages = await (0, changeset_service_1.getWorkspacePackages)(rootPath);
+        // Filter out private packages for UI display
+        const publicPackages = packages.filter((pkg) => !pkg.private);
+        res.json({
+            success: true,
+            packages: publicPackages,
+            total: publicPackages.length,
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to fetch packages: ${error}`);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to fetch packages',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+}
+/**
+ * Get existing unpublished changesets
+ */
+async function getPublishChangesets(req, res) {
+    try {
+        const rootPath = req.app.locals.rootPath;
+        const changesets = await (0, changeset_service_1.getExistingChangesets)(rootPath);
+        res.json({
+            success: true,
+            changesets,
+            total: changesets.length,
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to fetch changesets: ${error}`);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to fetch changesets',
+        });
+    }
+}
+/**
+ * Preview publish plan (calculate new versions, affected packages)
+ */
+async function previewPublish(req, res) {
+    try {
+        const { packages: selectedPackageNames, bumps } = req.body;
+        if (!selectedPackageNames || !Array.isArray(selectedPackageNames)) {
+            res.status(400).json({
+                success: false,
+                error: 'Invalid request',
+                message: 'packages array is required',
+            });
+            return;
+        }
+        const rootPath = req.app.locals.rootPath;
+        const allPackages = await (0, changeset_service_1.getWorkspacePackages)(rootPath);
+        // Filter selected packages
+        const selectedPackages = allPackages.filter((pkg) => selectedPackageNames.includes(pkg.name));
+        // Calculate new versions
+        const newVersions = (0, changeset_service_1.calculateNewVersions)(selectedPackages, bumps || []);
+        // Check if working tree is clean
+        const isClean = true; //await isWorkingTreeClean(rootPath);
+        // Get existing changesets
+        const changesets = await (0, changeset_service_1.getExistingChangesets)(rootPath);
+        // Perform validation checks
+        const errors = [];
+        const warnings = [];
+        // Check 1: Working tree clean
+        const workingTreeClean = isClean;
+        if (!workingTreeClean) {
+            errors.push('Working tree has uncommitted changes');
+        }
+        // Check 2: User permissions (simplified - always true for now)
+        const permissions = true;
+        // Check 3: CI passing (simplified - always true for now)
+        const ciPassing = true;
+        // Check 4: Version available on npm (simplified - always true for now)
+        const versionAvailable = true;
+        const isValid = errors.length === 0;
+        res.json({
+            success: true,
+            isValid,
+            errors,
+            warnings,
+            checks: {
+                permissions,
+                workingTreeClean,
+                ciPassing,
+                versionAvailable,
+            },
+            preview: {
+                packages: newVersions,
+                workingTreeClean: isClean,
+                existingChangesets: changesets.length,
+                affectedPackages: newVersions.length,
+            },
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to preview publish: ${error}`);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to preview publish',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+}
+/**
+ * Create a new changeset
+ */
+async function createChangeset(req, res) {
+    try {
+        const { packages: selectedPackageNames, bumps, summary } = req.body;
+        if (!selectedPackageNames || !Array.isArray(selectedPackageNames)) {
+            res.status(400).json({
+                success: false,
+                error: 'Invalid request',
+                message: 'packages array is required',
+            });
+            return;
+        }
+        if (!summary || typeof summary !== 'string' || summary.length < 10) {
+            res.status(400).json({
+                success: false,
+                error: 'Invalid summary',
+                message: 'Summary must be at least 10 characters',
+            });
+            return;
+        }
+        const rootPath = req.app.locals.rootPath;
+        // Generate the changeset
+        const result = await (0, changeset_service_1.generateChangeset)(rootPath, selectedPackageNames, bumps || [], summary);
+        if (!result.success) {
+            res.status(400).json({
+                success: false,
+                error: 'Failed to create changeset',
+                message: result.message,
+            });
+            return;
+        }
+        res.json({
+            success: true,
+            changeset: result.changeset,
+            message: 'Changeset created successfully',
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to create changeset: ${error}`);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to create changeset',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+}
+/**
+ * Check publish readiness
+ */
+async function checkPublishStatus(req, res) {
+    try {
+        const rootPath = req.app.locals.rootPath;
+        // Check if working tree is clean
+        const isClean = true; //await isWorkingTreeClean(rootPath);
+        // Get existing changesets
+        const changesets = await (0, changeset_service_1.getExistingChangesets)(rootPath);
+        res.json({
+            success: true,
+            status: {
+                workingTreeClean: isClean,
+                hasChangesets: changesets.length > 0,
+                changesetCount: changesets.length,
+                readyToPublish: isClean && changesets.length > 0,
+            },
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to check publish status: ${error}`);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to check publish status',
+        });
+    }
+}
+/**
+ * Trigger publishing workflow
+ */
+async function triggerPublish(req, res) {
+    try {
+        const rootPath = req.app.locals.rootPath;
+        // Check if working tree is clean
+        const isClean = true; //await isWorkingTreeClean(rootPath);
+        if (!isClean) {
+            res.status(400).json({
+                success: false,
+                error: 'Working tree not clean',
+                message: 'Please commit or stash all changes before publishing',
+            });
+            return;
+        }
+        // Check if changesets exist
+        const changesets = await (0, changeset_service_1.getExistingChangesets)(rootPath);
+        if (changesets.length === 0) {
+            res.status(400).json({
+                success: false,
+                error: 'No changesets found',
+                message: 'Create changesets before publishing',
+            });
+            return;
+        }
+        // Trigger publish pipeline
+        const result = await (0, changeset_service_1.triggerPublishPipeline)(rootPath);
+        if (!result.success) {
+            res.status(500).json({
+                success: false,
+                error: 'Failed to trigger publish pipeline',
+                message: result.message,
+            });
+            return;
+        }
+        res.json({
+            success: true,
+            message: 'Publishing workflow initiated',
+            result: result.result,
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to trigger publish: ${error}`);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to trigger publish',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+}

package/dist/middleware/server-startup.js

@@ -20,6 +20,7 @@ const health_routes_1 = __importDefault(require("../routes/health-routes"));
 const config_routes_1 = __importDefault(require("../routes/config-routes"));
 const auth_routes_1 = __importDefault(require("../routes/auth-routes"));
 const permission_routes_1 = __importDefault(require("../routes/permission-routes"));
+const publish_routes_1 = __importDefault(require("../routes/publish-routes"));
 const constants_1 = require("../constants");
 const auth_middleware_1 = require("./auth-middleware");
 const permission_service_1 = require("../services/permission-service");
@@ -64,6 +65,7 @@ function createApp(rootPath) {
     app.use('/api/commits/', commit_routes_1.default);
     app.use('/api/health/', health_routes_1.default);
     app.use('/api/config/', config_routes_1.default);
+    app.use('/api/publish', publish_routes_1.default);
     // 404 handler
     app.use('*', error_handler_1.notFoundHandler);
     // Global error handler (must be last)
@@ -109,6 +111,13 @@ function startServer(rootPath) {
                     // Config endpoints
                     'PUT  /api/config/files/:id',
                     'GET  /api/config/files',
+                    // Publish endpoints
+                    'GET  /api/publish/packages',
+                    'GET  /api/publish/changesets',
+                    'GET  /api/publish/status',
+                    'POST /api/publish/preview',
+                    'POST /api/publish/changesets',
+                    'POST /api/publish/trigger',
                 ],
             });
         });

package/dist/routes/publish-routes.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const publish_controller_1 = require("../controllers/publish-controller");
+const auth_middleware_1 = require("../middleware/auth-middleware");
+const publishRouter = express_1.default.Router();
+/**
+ * GET /api/publish/packages
+ * Get all workspace packages for publishing
+ */
+publishRouter.get('/packages', auth_middleware_1.authenticationMiddleware, publish_controller_1.getPublishPackages);
+/**
+ * GET /api/publish/changesets
+ * Get existing unpublished changesets
+ */
+publishRouter.get('/changesets', auth_middleware_1.authenticationMiddleware, publish_controller_1.getPublishChangesets);
+/**
+ * POST /api/publish/preview
+ * Preview the publish plan (calculate new versions, affected packages)
+ */
+publishRouter.post('/preview', auth_middleware_1.authenticationMiddleware, publish_controller_1.previewPublish);
+/**
+ * POST /api/publish/changesets
+ * Create a new changeset for the selected packages
+ */
+publishRouter.post('/changesets', auth_middleware_1.authenticationMiddleware, publish_controller_1.createChangeset);
+/**
+ * GET /api/publish/status
+ * Check publish readiness (working tree, changesets, etc.)
+ */
+publishRouter.get('/status', auth_middleware_1.authenticationMiddleware, publish_controller_1.checkPublishStatus);
+/**
+ * POST /api/publish/trigger
+ * Trigger the publishing workflow
+ */
+publishRouter.post('/trigger', auth_middleware_1.authenticationMiddleware, publish_controller_1.triggerPublish);
+exports.default = publishRouter;

package/dist/services/changeset-service.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Changeset Service
+ * Handles changeset generation, validation, and publishing
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkspacePackages = getWorkspacePackages;
+exports.getExistingChangesets = getExistingChangesets;
+exports.calculateNewVersions = calculateNewVersions;
+exports.validateChangeset = validateChangeset;
+exports.generateChangeset = generateChangeset;
+exports.isWorkingTreeClean = isWorkingTreeClean;
+exports.triggerPublishPipeline = triggerPublishPipeline;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const logger_1 = require("../middleware/logger");
+const package_service_1 = require("./package-service");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Get all workspace packages
+ */
+async function getWorkspacePackages(rootPath) {
+    try {
+        // Get packages from package service
+        const packages = await (0, package_service_1.getPackagesService)(rootPath);
+        return packages.map((pkg) => ({
+            name: pkg.name,
+            version: pkg.version || '0.0.0',
+            path: pkg.path,
+            private: pkg.private || false,
+            dependencies: pkg.dependencies || {},
+            devDependencies: pkg.devDependencies || {},
+        }));
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to get workspace packages: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Get existing unpublished changesets
+ */
+async function getExistingChangesets(rootPath) {
+    try {
+        const changesetsDir = path_1.default.join(rootPath, '.changeset');
+        try {
+            const files = await promises_1.default.readdir(changesetsDir);
+            return files
+                .filter((file) => file.endsWith('.md') && file !== 'README.md')
+                .map((file) => file.replace('.md', ''));
+        }
+        catch {
+            // Directory doesn't exist yet
+            return [];
+        }
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to get existing changesets: ${error}`);
+        return [];
+    }
+}
+/**
+ * Calculate new versions for selected packages
+ */
+function calculateNewVersions(packages, bumps) {
+    return packages.map((pkg) => {
+        const bump = bumps.find((b) => b.package === pkg.name);
+        const bumpType = bump?.bumpType || 'patch';
+        const newVersion = calculateVersion(pkg.version, bumpType);
+        return {
+            package: pkg.name,
+            currentVersion: pkg.version,
+            newVersion,
+            bumpType,
+        };
+    });
+}
+/**
+ * Calculate new version based on bump type
+ */
+function calculateVersion(currentVersion, bumpType) {
+    const parts = currentVersion.split('.').map((p) => parseInt(p, 10));
+    const [major, minor = 0, patch = 0] = parts;
+    switch (bumpType) {
+        case 'major':
+            return `${major + 1}.0.0`;
+        case 'minor':
+            return `${major}.${minor + 1}.0`;
+        case 'patch':
+        default:
+            return `${major}.${minor}.${patch + 1}`;
+    }
+}
+/**
+ * Validate that changeset can be created
+ */
+async function validateChangeset(rootPath, packages, summary) {
+    const errors = [];
+    // Validate packages exist
+    const allPackages = await getWorkspacePackages(rootPath);
+    for (const pkgName of packages) {
+        if (!allPackages.find((p) => p.name === pkgName)) {
+            errors.push(`Package ${pkgName} not found`);
+        }
+    }
+    // Validate summary
+    if (!summary || summary.length < 10) {
+        errors.push('Summary must be at least 10 characters');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Generate a new changeset
+ */
+async function generateChangeset(rootPath, packages, bumps, summary) {
+    try {
+        // Validate input
+        const validation = await validateChangeset(rootPath, packages, summary);
+        if (!validation.valid) {
+            return {
+                success: false,
+                message: validation.errors.join(', '),
+            };
+        }
+        // Create .changeset directory if it doesn't exist
+        const changesetsDir = path_1.default.join(rootPath, '.changeset');
+        try {
+            await promises_1.default.mkdir(changesetsDir, { recursive: true });
+        }
+        catch (error) {
+            // Directory might already exist
+        }
+        // Generate unique changeset filename (using timestamp + random)
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 9);
+        const changesetName = `${timestamp}-${random}`;
+        const changesetPath = path_1.default.join(changesetsDir, `${changesetName}.md`);
+        // Format changeset content
+        let content = `---\n`;
+        for (const pkg of packages) {
+            const bump = bumps.find((b) => b.package === pkg);
+            const bumpType = bump?.bumpType || 'patch';
+            content += `"${pkg}": ${bumpType}\n`;
+        }
+        content += `---\n\n`;
+        content += summary;
+        // Write changeset file
+        await promises_1.default.writeFile(changesetPath, content, 'utf-8');
+        logger_1.AppLogger.info(`Changeset created: ${changesetName}`);
+        return {
+            success: true,
+            message: 'Changeset created successfully',
+            changeset: changesetName,
+        };
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to generate changeset: ${error}`);
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Check if working tree is clean
+ */
+async function isWorkingTreeClean(rootPath) {
+    try {
+        const { stdout } = await execPromise('git status --porcelain', {
+            cwd: rootPath,
+        });
+        return stdout.trim().length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Trigger CI pipeline for publishing
+ */
+async function triggerPublishPipeline(rootPath) {
+    try {
+        // Check if publish workflow exists
+        const publishWorkflowPath = path_1.default.join(rootPath, '.github', 'workflows', 'release.yml');
+        try {
+            await promises_1.default.stat(publishWorkflowPath);
+        }
+        catch {
+            return {
+                success: false,
+                message: 'Publish workflow not configured',
+            };
+        }
+        // Commit the changeset if there are any changes
+        try {
+            const { stdout: status } = await execPromise('git status --porcelain', {
+                cwd: rootPath,
+            });
+            if (status.trim()) {
+                // Add changeset files
+                await execPromise('git add .changeset/', { cwd: rootPath });
+                // Commit with proper message
+                await execPromise('git commit -m "chore: publish changeset" --no-verify', { cwd: rootPath });
+                // Push to the current branch
+                try {
+                    const { stdout: branch } = await execPromise('git rev-parse --abbrev-ref HEAD', { cwd: rootPath });
+                    const currentBranch = branch.trim();
+                    await execPromise(`git push origin ${currentBranch}`, {
+                        cwd: rootPath,
+                    });
+                    logger_1.AppLogger.info(`Pushed changeset to ${currentBranch}`);
+                }
+                catch (pushError) {
+                    // If push fails, still continue - the workflow might be triggered manually
+                    logger_1.AppLogger.warn(`Failed to push: ${pushError}`);
+                }
+            }
+        }
+        catch (gitError) {
+            logger_1.AppLogger.warn(`Git operations failed: ${gitError}`);
+            // Continue anyway - changesets might already be committed
+        }
+        // Trigger the workflow via GitHub API if we have a token
+        try {
+            const githubToken = process.env.GITHUB_TOKEN;
+            if (githubToken) {
+                // Get repo info from package.json or git remote
+                const { stdout: remoteUrl } = await execPromise('git remote get-url origin', {
+                    cwd: rootPath,
+                });
+                // Parse GitHub repo from URL (e.g., git@github.com:user/repo.git)
+                const repoMatch = remoteUrl.match(/github\.com[:/]([^/]+)\/(.+?)(\.git)?$/);
+                if (repoMatch) {
+                    const [, owner, repo] = repoMatch;
+                    const repoName = repo.replace(/\.git$/, '');
+                    // Trigger the workflow
+                    const response = await fetch(`https://api.github.com/repos/${owner}/${repoName}/actions/workflows/release.yml/dispatches`, {
+                        method: 'POST',
+                        headers: {
+                            Authorization: `Bearer ${githubToken}`,
+                            Accept: 'application/vnd.github.v3+json',
+                        },
+                        body: JSON.stringify({
+                            ref: 'main',
+                        }),
+                    });
+                    if (response.ok) {
+                        logger_1.AppLogger.info('GitHub workflow triggered successfully');
+                    }
+                    else {
+                        logger_1.AppLogger.warn(`Failed to trigger workflow: ${response.statusText}`);
+                    }
+                }
+            }
+        }
+        catch (workflowError) {
+            logger_1.AppLogger.warn(`Failed to trigger workflow: ${workflowError}`);
+            // Still return success as the changeset was created
+        }
+        logger_1.AppLogger.info('Publish pipeline initiated');
+        return {
+            success: true,
+            message: 'Publishing workflow initiated',
+            result: {
+                timestamp: new Date().toISOString(),
+                workflowPath: publishWorkflowPath,
+            },
+        };
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Failed to trigger publish pipeline: ${error}`);
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}