@manojkmfsi/monodog 1.1.28 → 1.1.30

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # @manojkmfsi/monoapp
 
+## 1.1.30
+
+### Patch Changes
+
+- [`f27db43`](https://github.com/manojkmfsi/monodog/commit/f27db43277895381dbf239ffd57ebb17e7fd6e13) - sasasasasasasas
+
+## 1.1.29
+
+### Patch Changes
+
+- [`8600e0c`](https://github.com/manojkmfsi/monodog/commit/8600e0c636f76c8b9dcc8fbf7a2617d355f2d0e5) - fsfyfhfhfjjh,m
+
+- [`188bcf2`](https://github.com/manojkmfsi/monodog/commit/188bcf2ab06b5fe58b2cea5915a7751cba3a68d2) - cxzcxvxcbvcbnb,m
+
+- [`cfb03da`](https://github.com/manojkmfsi/monodog/commit/cfb03da50efd0b829bf4a8b4c5c2ae68c4d1a4ce) - mkjmnmnmnmnnmnm
+
+- [`d95b183`](https://github.com/manojkmfsi/monodog/commit/d95b183ea3aa3a60f153d40d1db4049565ecaffa) - m nm nm nm nm mn nm mmm nm mn mm
+
+- [`8abe3fb`](https://github.com/manojkmfsi/monodog/commit/8abe3fb09b2608696e6960ac0fdb8e0a9112dfa7) - xzdfdguiulmn cxdtyj
+
+- [`9add854`](https://github.com/manojkmfsi/monodog/commit/9add854171041d38161916c2ce5ed34af471614a) - hbmjnbmm,n,,m,
+
+- [`5f9b61e`](https://github.com/manojkmfsi/monodog/commit/5f9b61e73c8d1c460dac445aa9c5ae52ed053883) - cxgfhgjmnmnm,k,m
+
+- [`bde7bfb`](https://github.com/manojkmfsi/monodog/commit/bde7bfb74376917ab590c8f0d831c3aa0a9e0482) - vnmn,nkjlkn,mnm,
+
+- [`e67b026`](https://github.com/manojkmfsi/monodog/commit/e67b02689d82fb4cae0ca917fdb829c3d23d3b9d) - drkjk,,kjudscxvxvvvvnm
+
+- [`6b78e09`](https://github.com/manojkmfsi/monodog/commit/6b78e09e6e090ece45485b0e43b1b6e5a537e4eb) - fcdgcbvnkmkllml.m.
+
+- [`1a74552`](https://github.com/manojkmfsi/monodog/commit/1a74552277f8deaef831649ad424ea41c77fd467) - nhuyfgxbvnbmklm, .,nmkn,
+
+- [`fe566fd`](https://github.com/manojkmfsi/monodog/commit/fe566fdb7041ce079e8afe78ebdb4b477f0cae44) - fghjvvnvnbn
+
+- [`79566ae`](https://github.com/manojkmfsi/monodog/commit/79566ae23e3f30a03482134f35b5491e289d2775) - adssdxvcvbcbvcxvcbvcb
+
+- [`804ddf2`](https://github.com/manojkmfsi/monodog/commit/804ddf22cf845aa2c980bff9488a04e251be119a) - fxcbcvcxcbvnbvnb
+
+- [`07e1878`](https://github.com/manojkmfsi/monodog/commit/07e18786e6f3d8dad57f90822af93bd578c9c3ae) - bvcghmjnm,nmnmhkjhn,mn
+
+- [`faa4e0c`](https://github.com/manojkmfsi/monodog/commit/faa4e0cb48e0b1f8eae6aa93f104924452076b94) - mnmmmmnmnmn,mn,mnmn,
+
+- [`4ed3483`](https://github.com/manojkmfsi/monodog/commit/4ed34834edea9c6789ffbf93c1354f9752b59b8b) - n,mnmnmnmn,mnm,,m
+
+- [`dd47e0b`](https://github.com/manojkmfsi/monodog/commit/dd47e0b8480f14a78b958f3ff68d3b41082f3465) - mnn,mn,mn,n,mn,,
+
+- [`621bee1`](https://github.com/manojkmfsi/monodog/commit/621bee11b6194ee56fd90c130a4b3c83b386831a) - kmmnmmn,n,m,m, n,m
+
+- [`ec7e1b0`](https://github.com/manojkmfsi/monodog/commit/ec7e1b0817ae540ece67576fbceb7486dcadc48f) - mnm,n,n,mn,mn,m,m,m,
+
+- [`411523b`](https://github.com/manojkmfsi/monodog/commit/411523b813a96fcfd46c3e459bcd887c255fd2e7) - mnmn,mn,mn,m.,m.,m.,m,m.,
+
+- [`ec19a7c`](https://github.com/manojkmfsi/monodog/commit/ec19a7ccff425f7319c24d0506a147fcfdd0e9ca) - vbcbvbnvnmbnmbnmnm
+
+- [`6818670`](https://github.com/manojkmfsi/monodog/commit/6818670424be6bdb98e1fd2e04f1fe985638e67e) - cxxvcvcbvbnvnbvnmnm
+
+- [`10eac2e`](https://github.com/manojkmfsi/monodog/commit/10eac2ee72753474d4ec0d9ba2ba3ebdd4639c96) - sdhgjhkjhkjjkkkjn
+
+- [`4c924c9`](https://github.com/manojkmfsi/monodog/commit/4c924c918f93cbd54c1c752060a6bdaab45e987d) - wdassdsfddfsdffdgfdsgfsgfg
+
+- [`a9e5e26`](https://github.com/manojkmfsi/monodog/commit/a9e5e2680f49c448c49e3a1c414d5c2533a5e9cf) - nnknknnnknkn,,mnm,
+
+- [`d559595`](https://github.com/manojkmfsi/monodog/commit/d559595e3b56371a102a21244d0d6c5696541bd3) - dsdsmnd,mns,mnd,msnd,msn,md
+
 ## 1.1.28
 
 ### Patch Changes

package/check-db.js

@@ -0,0 +1,58 @@
+const { PrismaClient } = require('@prisma/client');
+const path = require('path');
+const fs = require('fs');
+
+// Load config similar to the app
+let databasePath = 'file:./monodog.db'; // default
+
+// Try to read monodog-config.json
+try {
+  const configPath = path.join(__dirname, 'monodog-config.json');
+  if (fs.existsSync(configPath)) {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    databasePath = config.database?.path || databasePath;
+  }
+} catch (e) {
+  console.warn('Could not read config:', e.message);
+}
+
+console.log(`Database URL: ${databasePath}\n`);
+
+async function checkDatabase() {
+  const prisma = new PrismaClient({
+    datasources: {
+      db: {
+        url: databasePath,
+      },
+    },
+  });
+
+  try {
+    console.log('=== Database Status ===\n');
+
+    // Check ReleasePipeline count
+    const pipelineCount = await prisma.releasePipeline.count();
+    console.log(`Total pipelines in database: ${pipelineCount}\n`);
+
+    if (pipelineCount > 0) {
+      const pipelines = await prisma.releasePipeline.findMany({
+        take: 5,
+        orderBy: { createdAt: 'desc' },
+      });
+      console.log('Latest pipelines:');
+      pipelines.forEach(p => {
+        console.log(`  - ${p.packageName} v${p.releaseVersion} (${p.currentStatus})`);
+        console.log(`    Triggered by: ${p.triggeredBy} at ${p.triggeredAt}`);
+        console.log(`    Owner/Repo: ${p.owner}/${p.repo}`);
+        console.log('');
+      });
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+checkDatabase();

package/create-test-session.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+/**
+ * This script creates a test session by directly calling the auth middleware's storeSession function
+ * It simulates what happens after a successful GitHub OAuth login
+ */
+
+const { storeSession } = require('./dist/middleware/auth-middleware');
+
+// Create a mock session
+const mockSession = {
+  accessToken: 'gho_test_token_' + Math.random().toString(36).substr(2, 9),
+  expiresIn: 3600,
+  expiresAt: Date.now() + 24 * 60 * 60 * 1000,
+  user: {
+    id: 12345,
+    login: 'testuser',
+    name: 'Test User',
+    email: 'test@example.com',
+    avatar_url: 'https://avatars.githubusercontent.com/u/12345?v=4',
+    public_repos: 5,
+    followers: 10,
+    following: 5,
+  },
+  scopes: ['repo', 'read:user'],
+  permission: {
+    permission: 'maintain',
+    role: 'Maintainer',
+    userId: 12345,
+    username: 'testuser',
+    owner: 'manojkmfsi',
+    repo: 'MonoDog',
+    cachedAt: Date.now(),
+    ttl: 3600000,
+  },
+};
+
+try {
+  const token = storeSession(mockSession);
+  console.log('✅ Test session created successfully!');
+  console.log(`\nSession Token: ${token}`);
+  console.log(`User: ${mockSession.user.login}`);
+  console.log(`Permission: ${mockSession.permission.permission}`);
+  console.log(`Expires at: ${new Date(mockSession.expiresAt).toISOString()}`);
+  console.log(`\nYou can use this token in API requests:`);
+  console.log(`curl -H "Authorization: Bearer ${token}" http://localhost:8999/api/publish/trigger`);
+} catch (error) {
+  console.error('❌ Failed to create session:', error.message);
+  process.exit(1);
+}

package/dev-server.pid

@@ -0,0 +1 @@
+22401

package/dist/controllers/pipeline-controller.js

@@ -0,0 +1,329 @@
+"use strict";
+/**
+ * Pipeline Controller
+ * Handles HTTP requests and responses for pipeline operations
+ * Delegates business logic to pipeline service
+ */
+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.getRecentPipelines = getRecentPipelines;
+exports.updatePipelineStatus = updatePipelineStatus;
+exports.listAvailableWorkflows = listAvailableWorkflows;
+exports.getWorkflowRuns = getWorkflowRuns;
+exports.getWorkflowRunWithJobs = getWorkflowRunWithJobs;
+exports.getJobLogs = getJobLogs;
+exports.triggerWorkflow = triggerWorkflow;
+exports.getPipelineAuditLogs = getPipelineAuditLogs;
+exports.cancelWorkflowRun = cancelWorkflowRun;
+exports.rerunWorkflow = rerunWorkflow;
+const logger_1 = require("../middleware/logger");
+const pipelineService = __importStar(require("../services/pipeline-service"));
+const githubActionsService = __importStar(require("../services/github-actions-service"));
+/**
+ * Get recent pipelines for the dashboard
+ * GET /api/pipelines
+ */
+async function getRecentPipelines(req, res) {
+    try {
+        if (!req.user) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const limit = Math.min(parseInt(req.query.limit) || 20, 100);
+        const offset = parseInt(req.query.offset) || 0;
+        const pipelines = await pipelineService.getRecentPipelines(limit, offset);
+        res.json(pipelines);
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error getting pipelines: ${error}`);
+        res.status(500).json({ error: 'Failed to get pipelines' });
+    }
+}
+/**
+ * Update pipeline status based on latest workflow run
+ * PUT /api/pipelines/:pipelineId/status
+ */
+async function updatePipelineStatus(req, res) {
+    try {
+        if (!req.user) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { pipelineId } = req.params;
+        const { currentStatus, currentConclusion, lastRunId } = req.body;
+        if (!currentStatus) {
+            return res.status(400).json({ error: 'currentStatus is required' });
+        }
+        const updatedPipeline = await pipelineService.updatePipelineStatus(pipelineId, currentStatus, currentConclusion || null, lastRunId ? String(lastRunId) : undefined);
+        res.json({
+            success: true,
+            pipeline: updatedPipeline,
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error updating pipeline status: ${error}`);
+        res.status(500).json({ error: 'Failed to update pipeline status' });
+    }
+}
+/**
+ * Get available workflows in a repository
+ * GET /api/workflows/:owner/:repo/available
+ */
+async function listAvailableWorkflows(req, res) {
+    try {
+        if (!req.user || !req.accessToken) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { owner, repo } = req.params;
+        const result = await githubActionsService.listWorkflows(owner, repo, req.accessToken);
+        res.json(result);
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error listing workflows: ${error}`);
+        res.status(500).json({ error: 'Failed to list workflows' });
+    }
+}
+/**
+ * Get workflow runs for a repository
+ * GET /api/workflows/:owner/:repo
+ */
+async function getWorkflowRuns(req, res) {
+    try {
+        if (!req.user || !req.accessToken) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { owner, repo } = req.params;
+        const workflowId = req.query.workflow_id;
+        const workflowPath = req.query.workflow_path;
+        const status = req.query.status;
+        const page = parseInt(req.query.page) || 1;
+        const per_page = parseInt(req.query.per_page) || 30;
+        logger_1.AppLogger.info(`GET /workflows/${owner}/${repo}: workflowId=${workflowId}, workflowPath=${workflowPath}, status=${status}, page=${page}, per_page=${per_page}`);
+        const result = await githubActionsService.getWorkflowRuns(owner, repo, req.accessToken, {
+            workflowId,
+            workflowPath,
+            status,
+            page,
+            per_page,
+        });
+        logger_1.AppLogger.info(`GET /workflows/${owner}/${repo}: Returned ${result.runs.length} runs (total: ${result.totalCount})`);
+        res.json(result);
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error getting workflows: ${error}`);
+        res.status(500).json({ error: 'Failed to get workflows' });
+    }
+}
+/**
+ * Get specific workflow run with jobs
+ * GET /api/workflows/:owner/:repo/runs/:runId
+ */
+async function getWorkflowRunWithJobs(req, res) {
+    try {
+        if (!req.user || !req.accessToken) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { owner, repo, runId } = req.params;
+        const page = parseInt(req.query.page) || 1;
+        // Get run details
+        const { run, rateLimit: runRateLimit } = await githubActionsService.getWorkflowRun(owner, repo, parseInt(runId), req.accessToken);
+        // Get jobs
+        const { jobs, totalCount, rateLimit: jobsRateLimit } = await githubActionsService.getWorkflowRunJobs(owner, repo, parseInt(runId), req.accessToken, page);
+        // Transform jobs to match frontend expectations
+        const transformedJobs = jobs.map((job) => ({
+            id: job.id,
+            gitHubJobId: job.id,
+            name: job.name,
+            status: job.status,
+            conclusion: job.conclusion || null,
+            htmlUrl: job.html_url,
+            startedAt: job.started_at,
+            completedAt: job.completed_at,
+        }));
+        res.json({
+            run,
+            jobs: transformedJobs,
+            pagination: {
+                page,
+                totalCount,
+                pageSize: transformedJobs.length,
+            },
+            rateLimit: {
+                limit: runRateLimit?.limit,
+                remaining: runRateLimit?.remaining,
+                reset: runRateLimit?.reset,
+            },
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error getting workflow run: ${error}`);
+        res.status(500).json({ error: 'Failed to get workflow run' });
+    }
+}
+/**
+ * Get job logs
+ * GET /api/workflows/:owner/:repo/jobs/:jobId/logs
+ */
+async function getJobLogs(req, res) {
+    try {
+        if (!req.user || !req.accessToken) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { owner, repo, jobId } = req.params;
+        logger_1.AppLogger.info(`[LOGS] Fetching job logs: owner=${owner}, repo=${repo}, jobId=${jobId}, user=${req.user?.login}`);
+        const { logs, rateLimit } = await githubActionsService.getJobLogs(owner, repo, parseInt(jobId), req.accessToken);
+        logger_1.AppLogger.info(`[LOGS] Successfully fetched ${logs.length} characters of logs`);
+        res.json({
+            logs: logs || '',
+            rateLimit,
+            meta: {
+                size: logs.length,
+                isEmpty: !logs || logs.trim().length === 0,
+            },
+        });
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+        logger_1.AppLogger.error(`[LOGS ERROR] Failed to fetch job logs: ${errorMsg}`);
+        res.status(500).json({
+            error: 'Failed to get job logs',
+            details: errorMsg,
+            jobId: req.params.jobId,
+        });
+    }
+}
+/**
+ * Trigger a workflow run
+ * POST /api/workflows/:owner/:repo/trigger
+ */
+async function triggerWorkflow(req, res) {
+    try {
+        if (!req.user || !req.accessToken) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { owner, repo } = req.params;
+        const { pipelineId, workflowId, ref, inputs } = req.body;
+        if (!workflowId || !ref) {
+            return res.status(400).json({
+                error: 'Missing required fields: workflowId, ref',
+            });
+        }
+        const result = await githubActionsService.triggerWorkflow(req.accessToken, {
+            owner,
+            repo,
+            workflow: workflowId,
+            ref,
+            inputs,
+        });
+        if (pipelineId) {
+            await pipelineService.createAuditLog(pipelineId, req.user.id, req.user.login, 'trigger', 'workflow', String(workflowId), `Trigger workflow`, {}, result.response.success ? 'success' : 'failure');
+        }
+        res.json({
+            success: result.response.success,
+            message: result.response.message,
+            rateLimit: result.rateLimit,
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error triggering workflow: ${error}`);
+        res.status(500).json({ error: 'Failed to trigger workflow' });
+    }
+}
+/**
+ * Get pipeline audit logs
+ * GET /api/pipelines/:pipelineId/audit
+ */
+async function getPipelineAuditLogs(req, res) {
+    try {
+        if (!req.user) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { pipelineId } = req.params;
+        const limit = Math.min(parseInt(req.query.limit) || 50, 500);
+        const offset = parseInt(req.query.offset) || 0;
+        const logs = await pipelineService.getPipelineAuditLogs(pipelineId, limit, offset);
+        res.json({
+            success: true,
+            logs,
+            count: logs.length,
+        });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error getting audit logs: ${error}`);
+        res.status(500).json({ error: 'Failed to get audit logs' });
+    }
+}
+/**
+ * Cancel a workflow run
+ * POST /api/workflows/:owner/:repo/runs/:runId/cancel
+ */
+async function cancelWorkflowRun(req, res) {
+    try {
+        if (!req.user || !req.accessToken) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { owner, repo, runId } = req.params;
+        const { pipelineId } = req.body;
+        const { success, rateLimit } = await githubActionsService.cancelWorkflowRun(owner, repo, parseInt(runId), req.accessToken);
+        if (pipelineId) {
+            await pipelineService.createAuditLog(pipelineId, req.user.id, req.user.login, 'cancel', 'workflow_run', String(runId), `Cancel workflow run ${runId}`, {}, success ? 'success' : 'failure');
+        }
+        res.json({ success, rateLimit });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error cancelling workflow: ${error}`);
+        res.status(500).json({ error: 'Failed to cancel workflow' });
+    }
+}
+/**
+ * Rerun a workflow
+ * POST /api/workflows/:owner/:repo/runs/:runId/rerun
+ */
+async function rerunWorkflow(req, res) {
+    try {
+        if (!req.user || !req.accessToken) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { owner, repo, runId } = req.params;
+        const { failedOnly = false, pipelineId } = req.body;
+        const { success, rateLimit } = await githubActionsService.rerunWorkflow(owner, repo, parseInt(runId), req.accessToken, failedOnly);
+        if (pipelineId) {
+            await pipelineService.createAuditLog(pipelineId, req.user.id, req.user.login, 'rerun', 'workflow_run', String(runId), `Rerun workflow ${failedOnly ? '(failed jobs only)' : ''}`, { failedOnly }, success ? 'success' : 'failure');
+        }
+        res.json({ success, rateLimit });
+    }
+    catch (error) {
+        logger_1.AppLogger.error(`Error rerunning workflow: ${error}`);
+        res.status(500).json({ error: 'Failed to rerun workflow' });
+    }
+}