@manojkmfsi/monodog 1.1.21 → 1.1.23

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @manojkmfsi/monoapp
 
+## 1.1.23
+
+### Patch Changes
+
+- [`b90aa90`](https://github.com/manojkmfsi/monodog/commit/b90aa90bfbf516128af033c883a21ca4d09f713d) - dcdsdsvdvdvxvcxvxvx
+
+## 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,311 @@
+"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 auth_middleware_1 = require("../middleware/auth-middleware");
+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 = [];
+        // Get authenticated user
+        const session = (0, auth_middleware_1.getSessionFromRequest)(req);
+        const authUser = req.user;
+        const userPermission = req.permission.permission || 'read';
+        // Check 1: Working tree clean
+        const workingTreeClean = isClean;
+        if (!workingTreeClean) {
+            errors.push('Working tree has uncommitted changes');
+        }
+        // Check 2: User permissions
+        const permissionHierarchy = {
+            admin: 4,
+            maintain: 3,
+            write: 2,
+            read: 1,
+            none: 0,
+        };
+        const userLevel = permissionHierarchy[userPermission] || 0;
+        const requiredLevel = permissionHierarchy['write'] || 0;
+        const permissions = userLevel >= requiredLevel;
+        if (!permissions) {
+            errors.push(`Insufficient permissions. Required: write, Got: ${userPermission}`);
+        }
+        // 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;
+        logger_1.AppLogger.info(`Publishing preview for user: ${authUser?.login} (permission: ${userPermission})`);
+        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;
+        const authUser = req.user;
+        const userPermission = req.permission.permission || 'read';
+        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;
+        }
+        // Check permissions
+        const permissionHierarchy = {
+            admin: 4,
+            maintain: 3,
+            write: 2,
+            read: 1,
+            none: 0,
+        };
+        const userLevel = permissionHierarchy[userPermission] || 0;
+        const requiredLevel = permissionHierarchy['write'] || 0;
+        if (userLevel < requiredLevel) {
+            logger_1.AppLogger.warn(`User ${authUser?.login} attempted to create changeset without write permission`);
+            res.status(403).json({
+                success: false,
+                error: 'Forbidden',
+                message: `This action requires write permission. You have: ${userPermission}`,
+            });
+            return;
+        }
+        const rootPath = req.app.locals.rootPath;
+        logger_1.AppLogger.info(`Creating changeset for user: ${authUser?.login} (permission: ${userPermission})`);
+        // Generate the changeset
+        const result = await (0, changeset_service_1.generateChangeset)(rootPath, selectedPackageNames, bumps || [], summary, authUser?.login);
+        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;
+        const authUser = req.user;
+        const userPermission = req.permission.permission || 'read';
+        // Check permissions
+        const permissionHierarchy = {
+            admin: 4,
+            maintain: 3,
+            write: 2,
+            read: 1,
+            none: 0,
+        };
+        const userLevel = permissionHierarchy[userPermission] || 0;
+        const requiredLevel = permissionHierarchy['maintain'] || 0;
+        if (userLevel < requiredLevel) {
+            logger_1.AppLogger.warn(`User ${authUser?.login} attempted to trigger publish without maintain permission`);
+            res.status(403).json({
+                success: false,
+                error: 'Forbidden',
+                message: `This action requires maintain permission. You have: ${userPermission}`,
+            });
+            return;
+        }
+        // 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;
+        }
+        logger_1.AppLogger.info(`Triggering publish for user: ${authUser?.login} (permission: ${userPermission})`);
+        // Trigger publish pipeline with user context
+        const result = await (0, changeset_service_1.triggerPublishPipeline)(rootPath, authUser?.login);
+        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/auth-middleware.js

@@ -90,9 +90,30 @@ function authenticationMiddleware(req, res, next) {
         });
         return;
     }
-    // Attach session to request
+    // Attach session and user info to request
     req.session = session;
-    logger_1.AppLogger.debug(`Authenticated request from user: ${session.user.login}`);
+    req.user = {
+        login: session.user.login,
+        id: session.user.id,
+    };
+    // Attach permission from session (if available)
+    if (session.permission) {
+        req.permission = session.permission;
+    }
+    else {
+        // Default to 'read' if no permission fetched
+        req.permission = {
+            permission: 'read',
+            role: 'Denied',
+            userId: session.user.id,
+            username: session.user.login,
+            owner: '',
+            repo: '',
+            cachedAt: Date.now(),
+            ttl: 0,
+        };
+    }
+    logger_1.AppLogger.debug(`Authenticated request from user: ${session.user.login} with permission: ${req.permission?.permission || 'unknown'}`);
     next();
 }
 /**
@@ -124,10 +145,12 @@ function repositoryPermissionMiddleware(requiredPermission) {
             read: 1,
             none: 0,
         };
-        const userLevel = permissionHierarchy[permission.permission] || 0;
+        // Handle both string and object formats for permission
+        const userPermissionString = typeof permission === 'string' ? permission : (permission.permission || 'none');
+        const userLevel = permissionHierarchy[userPermissionString] || 0;
         const requiredLevel = permissionHierarchy[requiredPermission] || 0;
         if (userLevel < requiredLevel) {
-            logger_1.AppLogger.warn(`User ${session.user.login} lacks permission for action requiring ${requiredPermission}`);
+            logger_1.AppLogger.warn(`User ${session.user.login} lacks permission for action requiring ${requiredPermission} (has ${userPermissionString})`);
             res.status(403).json({
                 error: 'Forbidden',
                 message: `This action requires ${requiredPermission} permission`,

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/auth-routes.js

@@ -7,7 +7,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const github_oauth_service_1 = require("../services/github-oauth-service");
 const auth_middleware_1 = require("../middleware/auth-middleware");
+const permission_service_1 = require("../services/permission-service");
 const logger_1 = require("../middleware/logger");
+const utilities_1 = require("../utils/utilities");
 const router = (0, express_1.Router)();
 // OAuth configuration (should come from environment variables)
 // const GITHUB_CLIENT_ID = process.env.GITHUB_CLIENT_ID || '';
@@ -138,13 +140,34 @@ router.get('/callback', async (req, res) => {
         // Get user information
         logger_1.AppLogger.debug('Retrieving authenticated user information');
         const user = await (0, github_oauth_service_1.getAuthenticatedUser)(tokenResponse.access_token);
-        // Create session
+        // Fetch user's repository permission
+        let permission = null;
+        try {
+            logger_1.AppLogger.debug(`Fetching repository permission for user ${user.login}`);
+            // Extract repository info from git remote
+            const repoInfo = await (0, utilities_1.getRepositoryInfoFromGit)();
+            if (!repoInfo) {
+                logger_1.AppLogger.warn('Could not extract repository info from git remote - permission fetch skipped');
+            }
+            else {
+                const { owner, repo } = repoInfo;
+                permission = await (0, permission_service_1.getUserRepositoryPermission)(tokenResponse.access_token, user.id, user.login, owner, repo);
+                logger_1.AppLogger.info(`User ${user.login} has ${permission.permission} permission on ${owner}/${repo}`);
+            }
+        }
+        catch (permError) {
+            logger_1.AppLogger.error(`Failed to fetch repository permission: ${permError}`);
+            // Continue without permission - will be checked on protected routes
+            permission = null;
+        }
+        // Create session with permission
         const session = {
             accessToken: tokenResponse.access_token,
             expiresIn: 3600, // 1 hour default
             expiresAt: Date.now() + 24 * 60 * 60 * 1000, // 24 hours
             user,
             scopes: tokenResponse.scope.split(','),
+            permission, // Include fetched permission in session
         };
         // Store session and get token
         const sessionToken = (0, auth_middleware_1.storeSession)(session);
@@ -152,7 +175,7 @@ router.get('/callback', async (req, res) => {
         const redirectUrl = getRedirectUrl(state) || '/';
         // Clear state
         clearState(state);
-        logger_1.AppLogger.info(`User authenticated: ${user.login}`);
+        logger_1.AppLogger.info(`User authenticated: ${user.login} with permission: ${permission?.permission || 'unknown'}`);
         res.json({
             success: true,
             message: 'Authentication successful',
@@ -164,6 +187,10 @@ router.get('/callback', async (req, res) => {
                 name: user.name,
                 avatar_url: user.avatar_url,
             },
+            permission: permission ? {
+                level: permission.permission,
+                role: permission.role,
+            } : null,
         });
     }
     catch (error) {
@@ -203,6 +230,7 @@ router.get('/me', auth_middleware_1.authenticationMiddleware, (req, res) => {
             },
             scopes: session.scopes,
             expiresAt: session.expiresAt,
+            permission: session.permission || null,
         });
     }
     catch (error) {

package/dist/routes/publish-routes.js

@@ -0,0 +1,46 @@
+"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
+ * Requires: read permission
+ */
+publishRouter.get('/packages', auth_middleware_1.authenticationMiddleware, publish_controller_1.getPublishPackages);
+/**
+ * GET /api/publish/changesets
+ * Get existing unpublished changesets
+ * Requires: read permission
+ */
+publishRouter.get('/changesets', auth_middleware_1.authenticationMiddleware, publish_controller_1.getPublishChangesets);
+/**
+ * POST /api/publish/preview
+ * Preview the publish plan (calculate new versions, affected packages)
+ * Requires: read permission
+ */
+publishRouter.post('/preview', auth_middleware_1.authenticationMiddleware, publish_controller_1.previewPublish);
+/**
+ * POST /api/publish/changesets
+ * Create a new changeset for the selected packages
+ * Requires: write permission
+ */
+publishRouter.post('/changesets', auth_middleware_1.authenticationMiddleware, (0, auth_middleware_1.repositoryPermissionMiddleware)('write'), publish_controller_1.createChangeset);
+/**
+ * GET /api/publish/status
+ * Check publish readiness (working tree, changesets, etc.)
+ * Requires: read permission
+ */
+publishRouter.get('/status', auth_middleware_1.authenticationMiddleware, publish_controller_1.checkPublishStatus);
+/**
+ * POST /api/publish/trigger
+ * Trigger the publishing workflow
+ * Requires: maintain permission
+ */
+publishRouter.post('/trigger', auth_middleware_1.authenticationMiddleware, (0, auth_middleware_1.repositoryPermissionMiddleware)('maintain'), publish_controller_1.triggerPublish);
+exports.default = publishRouter;