@rudderhq/server 0.2.0-canary.9 → 0.2.0

package/dist/routes/issues.js

@@ -1,12 +1,12 @@
 import { Router } from "express";
 import multer from "multer";
 import { buildIssueDocumentsPrompt } from "@rudderhq/agent-runtime-utils/server-utils";
-import { addIssueCommentSchema, createIssueAttachmentMetadataSchema, createIssueWorkspaceAttachmentSchema, createIssueWorkProductSchema, createIssueLabelSchema, checkoutIssueSchema, createIssueSchema, linkIssueApprovalSchema, issueDocumentKeySchema, reorderIssueSchema, updateIssueLabelSchema, updateIssueWorkProductSchema, upsertIssueDocumentSchema, updateIssueSchema, } from "@rudderhq/shared";
+import { addIssueCommentSchema, createIssueAttachmentMetadataSchema, createIssueWorkspaceAttachmentSchema, createIssueWorkProductSchema, createIssueLabelSchema, checkoutIssueSchema, createIssueSchema, linkIssueApprovalSchema, reportIssueCommitSchema, issueDocumentKeySchema, reorderIssueSchema, updateIssueLabelSchema, updateIssueWorkProductSchema, upsertIssueDocumentSchema, updateIssueSchema, isUuidLike, } from "@rudderhq/shared";
 import { validate } from "../middleware/validate.js";
 import { accessService, agentService, executionWorkspaceService, goalService, heartbeatService, issueApprovalService, issueService, documentService, logActivity, projectService, automationService, workProductService, } from "../services/index.js";
 import { organizationWorkspaceBrowserService } from "../services/organization-workspace-browser.js";
 import { logger } from "../middleware/logger.js";
-import { forbidden, HttpError, unauthorized } from "../errors.js";
+import { forbidden, HttpError, unauthorized, unprocessable } from "../errors.js";
 import { assertBoard, assertCompanyAccess, getActorInfo } from "./authz.js";
 import { shouldWakeAssigneeOnCheckout } from "./issues-checkout-wakeup.js";
 import { isAllowedContentType, MAX_ATTACHMENT_BYTES } from "../attachment-types.js";
@@ -139,6 +139,41 @@ export function issueRoutes(db, storage) {
         }
         return true;
     }
+    function readIssueIdFromRunContext(contextSnapshot) {
+        if (!contextSnapshot || typeof contextSnapshot !== "object")
+            return null;
+        const issueId = contextSnapshot.issueId;
+        return typeof issueId === "string" && issueId.trim() ? issueId.trim() : null;
+    }
+    async function resolveAgentCommitRunId(req, res, issue) {
+        if (req.actor.type !== "agent")
+            return { ok: true, runId: null };
+        const actorAgentId = req.actor.agentId;
+        if (!actorAgentId) {
+            res.status(403).json({ error: "Agent authentication required" });
+            return { ok: false };
+        }
+        const runId = req.actor.runId?.trim();
+        if (!runId)
+            return { ok: true, runId: null };
+        if (!isUuidLike(runId)) {
+            res.status(403).json({ error: "Run context is not valid for this issue" });
+            return { ok: false };
+        }
+        const run = await heartbeat.getRun(runId);
+        const runIssueId = readIssueIdFromRunContext(run?.contextSnapshot);
+        const runBoundToIssue = issue.checkoutRunId === runId ||
+            issue.executionRunId === runId ||
+            runIssueId === issue.id;
+        if (!run ||
+            run.orgId !== issue.orgId ||
+            run.agentId !== actorAgentId ||
+            !runBoundToIssue) {
+            res.status(403).json({ error: "Run context is not valid for this issue" });
+            return { ok: false };
+        }
+        return { ok: true, runId };
+    }
     async function normalizeIssueIdentifier(rawId) {
         if (/^[A-Z]+-\d+$/i.test(rawId)) {
             const issue = await svc.getByIdentifier(rawId);
@@ -158,6 +193,29 @@ export function issueRoutes(db, storage) {
     function isReviewerAgentForIssue(actor, issue) {
         return actor.actorType === "agent" && Boolean(actor.agentId) && actor.agentId === issue.reviewerAgentId;
     }
+    function statusForReviewDecision(decision) {
+        switch (decision) {
+            case "approve":
+                return "done";
+            case "request_changes":
+                return "in_progress";
+            case "blocked":
+                return "blocked";
+            case "needs_followup":
+                return null;
+            default:
+                return null;
+        }
+    }
+    function statusAcceptsReviewerDecision(status) {
+        return status === "in_review" || status === "blocked";
+    }
+    function reviewerDecisionRequiresHumanHandoff(decision) {
+        return decision === "blocked";
+    }
+    function commitSubject(message) {
+        return message.split(/\r?\n/, 1)[0]?.trim() || message.trim();
+    }
     // Resolve issue identifiers (e.g. "PAP-39") to UUIDs for all /issues/:id routes
     router.param("id", async (req, res, next, rawId) => {
         try {
@@ -866,10 +924,18 @@ export function issueRoutes(db, storage) {
             await assertCanAssignTasks(req, orgId);
         }
         const actor = getActorInfo(req);
-        const issue = await svc.create(orgId, {
+        const createInput = {
             ...req.body,
             createdByAgentId: actor.agentId,
             createdByUserId: actor.actorType === "user" ? actor.actorId : null,
+        };
+        const hasExplicitAssignee = Object.prototype.hasOwnProperty.call(req.body, "assigneeAgentId") ||
+            Object.prototype.hasOwnProperty.call(req.body, "assigneeUserId");
+        if (actor.actorType === "agent" && actor.agentId && !hasExplicitAssignee) {
+            createInput.assigneeAgentId = actor.agentId;
+        }
+        const issue = await svc.create(orgId, {
+            ...createInput,
         });
         await logActivity(db, {
             orgId,
@@ -933,18 +999,36 @@ export function issueRoutes(db, storage) {
             return;
         const actor = getActorInfo(req);
         const isClosed = existing.status === "done" || existing.status === "cancelled";
-        const { comment: commentBody, reopen: reopenRequested, hiddenAt: hiddenAtRaw, ...updateFields } = req.body;
+        const { comment: commentBody, reopen: reopenRequested, hiddenAt: hiddenAtRaw, reviewDecision, ...updateFields } = req.body;
         if (hiddenAtRaw !== undefined) {
             updateFields.hiddenAt = hiddenAtRaw ? new Date(hiddenAtRaw) : null;
         }
         if (commentBody && reopenRequested === true && isClosed && updateFields.status === undefined) {
             updateFields.status = "todo";
         }
+        if (reviewDecision !== undefined) {
+            if (!commentBody) {
+                throw unprocessable("Reviewer decisions require a comment");
+            }
+            if (!statusAcceptsReviewerDecision(existing.status)) {
+                throw unprocessable("Reviewer decisions can only be recorded while the issue is in_review or blocked");
+            }
+            if (actor.actorType === "agent" && !isReviewerAgentForIssue(actor, existing)) {
+                throw forbidden("Only the reviewer agent can record a reviewer decision");
+            }
+            const decisionStatus = statusForReviewDecision(reviewDecision);
+            if (decisionStatus) {
+                updateFields.status = decisionStatus;
+            }
+            else {
+                delete updateFields.status;
+            }
+        }
         let reviewedCompletionNormalized = false;
         if (updateFields.status === "done" &&
             issueHasReviewer(existing) &&
             actor.actorType === "agent" &&
-            !(existing.status === "in_review" && isReviewerAgentForIssue(actor, existing))) {
+            !(statusAcceptsReviewerDecision(existing.status) && isReviewerAgentForIssue(actor, existing))) {
             updateFields.status = "in_review";
             reviewedCompletionNormalized = true;
         }
@@ -1045,20 +1129,66 @@ export function issueRoutes(db, storage) {
                 },
             });
         }
+        if (reviewDecision !== undefined) {
+            const reviewOutcome = reviewDecision === "blocked" ? "human_handoff" : "review_closed";
+            await logActivity(db, {
+                orgId: issue.orgId,
+                actorType: actor.actorType,
+                actorId: actor.actorId,
+                agentId: actor.agentId,
+                runId: actor.runId,
+                action: "issue.review_decision_recorded",
+                entityType: "issue",
+                entityId: issue.id,
+                details: {
+                    decision: reviewDecision,
+                    outcome: reviewOutcome,
+                    operatorActionRequired: reviewOutcome === "human_handoff",
+                    status: issue.status,
+                    identifier: issue.identifier,
+                    commentId: comment?.id ?? null,
+                },
+            });
+            if (reviewerDecisionRequiresHumanHandoff(reviewDecision)) {
+                await logActivity(db, {
+                    orgId: issue.orgId,
+                    actorType: actor.actorType,
+                    actorId: actor.actorId,
+                    agentId: actor.agentId,
+                    runId: actor.runId,
+                    action: "issue.human_intervention_required",
+                    entityType: "issue",
+                    entityId: issue.id,
+                    details: {
+                        decision: reviewDecision,
+                        status: issue.status,
+                        identifier: issue.identifier,
+                        issueTitle: issue.title,
+                        commentId: comment?.id ?? null,
+                        previousReviewerAgentId: existing.reviewerAgentId,
+                        previousReviewerUserId: existing.reviewerUserId,
+                        nextAction: "Human/operator intervention is required before agent review can continue.",
+                    },
+                });
+            }
+        }
         const assigneeChanged = assigneeWillChange;
         const reviewerChanged = reviewerWillChange;
         const statusChangedFromBacklog = existing.status === "backlog" &&
             issue.status !== "backlog" &&
-            req.body.status !== undefined;
+            updateFields.status !== undefined;
         const statusChangedToInReview = existing.status !== "in_review" &&
             issue.status === "in_review" &&
-            req.body.status !== undefined;
-        const statusChangedFromReviewToInProgress = existing.status === "in_review" &&
-            issue.status === "in_progress" &&
-            req.body.status !== undefined;
-        const reviewerChangedInReview = reviewerChanged &&
-            existing.status === "in_review" &&
-            issue.status === "in_review";
+            updateFields.status !== undefined;
+        const statusChangedToBlocked = existing.status !== "blocked" &&
+            issue.status === "blocked" &&
+            updateFields.status !== undefined;
+        const statusReturnedFromReviewToAssignee = statusAcceptsReviewerDecision(existing.status) &&
+            (issue.status === "in_progress" || issue.status === "todo") &&
+            updateFields.status !== undefined;
+        const reviewerChangedInReviewableStatus = reviewerChanged &&
+            statusAcceptsReviewerDecision(existing.status) &&
+            statusAcceptsReviewerDecision(issue.status);
         // Merge all wakeups from this update into one enqueue per agent to avoid duplicate runs.
         void (async () => {
             const wakeups = new Map();
@@ -1108,16 +1238,33 @@ export function issueRoutes(db, storage) {
                     },
                 });
             }
-            if (!assigneeChanged && statusChangedFromReviewToInProgress && issue.assigneeAgentId) {
+            if (!assigneeChanged && statusReturnedFromReviewToAssignee && issue.assigneeAgentId) {
+                const commentContext = comment
+                    ? {
+                        commentId: comment.id,
+                        wakeCommentId: comment.id,
+                        comment: {
+                            id: comment.id,
+                            body: comment.body,
+                            authorAgentId: comment.authorAgentId,
+                            authorUserId: comment.authorUserId,
+                        },
+                    }
+                    : {};
                 wakeups.set(issue.assigneeAgentId, {
                     source: "assignment",
                     triggerDetail: "system",
                     reason: "issue_changes_requested",
-                    payload: { issueId: issue.id, mutation: "review_changes_requested" },
+                    payload: {
+                        issueId: issue.id,
+                        mutation: "review_changes_requested",
+                        ...(comment ? { commentId: comment.id } : {}),
+                    },
                     requestedByActorType: actor.actorType,
                     requestedByActorId: actor.actorId,
                     contextSnapshot: {
                         issueId: issue.id,
+                        taskId: issue.id,
                         source: "issue.review_changes_requested",
                         wakeSource: "assignment",
                         wakeReason: "issue_changes_requested",
@@ -1128,19 +1275,26 @@ export function issueRoutes(db, storage) {
                             status: issue.status,
                             priority: issue.priority,
                         },
+                        ...commentContext,
                     },
                 });
             }
-            if ((statusChangedToInReview || reviewerChangedInReview) && issue.reviewerAgentId) {
-                const mutation = statusChangedToInReview ? "status_to_in_review" : "reviewer_changed_in_review";
+            if ((statusChangedToInReview || statusChangedToBlocked || reviewerChangedInReviewableStatus) && issue.reviewerAgentId) {
+                const mutation = statusChangedToInReview
+                    ? "status_to_in_review"
+                    : statusChangedToBlocked
+                        ? "status_to_blocked"
+                        : issue.status === "blocked"
+                            ? "reviewer_changed_blocked"
+                            : "reviewer_changed_in_review";
                 const actorIsReviewerAgent = actor.actorType === "agent" && actor.actorId === issue.reviewerAgentId;
                 const actorIsAssigneeAgent = actor.actorType === "agent" && actor.actorId === issue.assigneeAgentId;
-                const assigneeHandoffToReview = statusChangedToInReview && actorIsAssigneeAgent;
+                const assigneeHandoffToReview = (statusChangedToInReview || statusChangedToBlocked) && actorIsAssigneeAgent;
                 if (!actorIsReviewerAgent || assigneeHandoffToReview) {
                     wakeups.set(issue.reviewerAgentId, buildIssueReviewWakeupOptions({
                         issue,
                         mutation,
-                        contextSource: statusChangedToInReview ? "issue.status_change" : "issue.reviewer_change",
+                        contextSource: statusChangedToInReview || statusChangedToBlocked ? "issue.status_change" : "issue.reviewer_change",
                         requestedByActorType: actor.actorType,
                         requestedByActorId: actor.actorId,
                     }));
@@ -1324,6 +1478,62 @@ export function issueRoutes(db, storage) {
         });
         res.json(released);
     });
+    router.post("/issues/:id/commit", validate(reportIssueCommitSchema), async (req, res) => {
+        const id = req.params.id;
+        const issue = await svc.getById(id);
+        if (!issue) {
+            res.status(404).json({ error: "Issue not found" });
+            return;
+        }
+        assertCompanyAccess(req, issue.orgId);
+        if (req.actor.type !== "agent") {
+            res.status(403).json({ error: "Agent authentication required" });
+            return;
+        }
+        if (!(await assertAgentRunCheckoutOwnership(req, res, issue)))
+            return;
+        const actor = getActorInfo(req);
+        const commitRun = await resolveAgentCommitRunId(req, res, issue);
+        if (!commitRun.ok)
+            return;
+        const sha = req.body.sha.trim().toLowerCase();
+        const subject = commitSubject(req.body.message);
+        const shortSha = sha.slice(0, 7);
+        if (commitRun.runId) {
+            await heartbeat.reportRunActivity(commitRun.runId).catch((err) => logger.warn({ err, runId: commitRun.runId }, "failed to clear detached run warning after issue commit activity"));
+        }
+        await logActivity(db, {
+            orgId: issue.orgId,
+            actorType: actor.actorType,
+            actorId: actor.actorId,
+            agentId: actor.agentId,
+            runId: commitRun.runId,
+            action: "issue.code_committed",
+            entityType: "issue",
+            entityId: issue.id,
+            details: {
+                sha,
+                shortSha,
+                message: req.body.message,
+                subject,
+                identifier: issue.identifier,
+                issueTitle: issue.title,
+                branch: req.body.branch ?? null,
+                repoPath: req.body.repoPath ?? null,
+                workspacePath: req.body.workspacePath ?? null,
+                commitCount: req.body.commitCount ?? 1,
+            },
+        });
+        res.status(201).json({
+            ok: true,
+            issueId: issue.id,
+            sha,
+            shortSha,
+            message: req.body.message,
+            subject,
+            runId: commitRun.runId,
+        });
+    });
     router.get("/issues/:id/comments", async (req, res) => {
         const id = req.params.id;
         const issue = await svc.getById(id);