@rudderhq/server 0.2.5-canary.9 → 0.2.5

package/dist/services/goals.d.ts

@@ -6,16 +6,16 @@ type GoalRow = typeof goals.$inferSelect;
 type GoalInput = Omit<typeof goals.$inferInsert, "orgId">;
 type GoalPatch = Partial<typeof goals.$inferInsert>;
 export declare function getDefaultCompanyGoal(db: GoalReader, orgId: string): Promise<{
-    title: string;
-    description: string | null;
-    id: string;
+    createdAt: Date;
     status: string;
+    id: string;
+    description: string | null;
     updatedAt: Date;
+    level: string;
     orgId: string;
+    title: string;
     parentId: string | null;
-    createdAt: Date;
     ownerAgentId: string | null;
-    level: string;
 }>;
 export declare function getGoalDependencies(db: Db, goal: GoalRow): Promise<GoalDependencies>;
 export declare function goalService(db: Db): {
@@ -191,16 +191,16 @@ export declare function goalService(db: Db): {
             generated: undefined;
         }, {}, {}>;
     }, "single", Record<"goals", "not-null">, false, "where", {
-        title: string;
-        description: string | null;
-        id: string;
+        createdAt: Date;
         status: string;
+        id: string;
+        description: string | null;
         updatedAt: Date;
+        level: string;
         orgId: string;
+        title: string;
         parentId: string | null;
-        createdAt: Date;
         ownerAgentId: string | null;
-        level: string;
     }[], {
         id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
@@ -374,41 +374,41 @@ export declare function goalService(db: Db): {
         }, {}, {}>;
     }>, "where">;
     getById: (id: string) => Promise<{
-        title: string;
-        description: string | null;
-        id: string;
+        createdAt: Date;
         status: string;
+        id: string;
+        description: string | null;
         updatedAt: Date;
+        level: string;
         orgId: string;
+        title: string;
         parentId: string | null;
-        createdAt: Date;
         ownerAgentId: string | null;
-        level: string;
     }>;
     getDefaultCompanyGoal: (orgId: string) => Promise<{
-        title: string;
-        description: string | null;
-        id: string;
+        createdAt: Date;
         status: string;
+        id: string;
+        description: string | null;
         updatedAt: Date;
+        level: string;
         orgId: string;
+        title: string;
         parentId: string | null;
-        createdAt: Date;
         ownerAgentId: string | null;
-        level: string;
     }>;
     dependencies: (goal: GoalRow) => Promise<GoalDependencies>;
     create: (orgId: string, data: GoalInput) => Promise<{
-        title: string;
-        description: string | null;
-        id: string;
+        createdAt: Date;
         status: string;
+        id: string;
+        description: string | null;
         updatedAt: Date;
+        level: string;
         orgId: string;
+        title: string;
         parentId: string | null;
-        createdAt: Date;
         ownerAgentId: string | null;
-        level: string;
     }>;
     update: (id: string, data: GoalPatch) => Promise<{
         id: string;
@@ -423,16 +423,16 @@ export declare function goalService(db: Db): {
         updatedAt: Date;
     } | null>;
     remove: (id: string) => Promise<{
-        title: string;
-        description: string | null;
-        id: string;
+        createdAt: Date;
         status: string;
+        id: string;
+        description: string | null;
         updatedAt: Date;
+        level: string;
         orgId: string;
+        title: string;
         parentId: string | null;
-        createdAt: Date;
         ownerAgentId: string | null;
-        level: string;
     } | null>;
 };
 export {};

package/dist/services/heartbeat.d.ts

@@ -1,2 +1,4 @@
-export { buildExplicitResumeSessionOverride, buildHeartbeatAdapterInvokePayload, buildHeartbeatRuntimeTraceMetadata, buildIssueRunTraceName, formatRuntimeWorkspaceWarningLog, heartbeatService, heartbeatService as heartbeatOrchestrator, parseSessionCompactionPolicy, prioritizeProjectWorkspaceCandidatesForRun, resolveHeartbeatObservabilitySurface, resolveRuntimeSessionParamsForWorkspace, shouldResetTaskSessionForWake, type ResolvedWorkspaceForRun, } from "./runtime-kernel/heartbeat.js";
+export { heartbeatService, heartbeatService as heartbeatOrchestrator, prioritizeProjectWorkspaceCandidatesForRun, type ResolvedWorkspaceForRun, } from "./runtime-kernel/heartbeat.js";
+export { buildHeartbeatAdapterInvokePayload, buildHeartbeatRuntimeTraceMetadata, buildIssueRunTraceName, resolveHeartbeatObservabilitySurface, } from "./runtime-kernel/heartbeat.core.js";
+export { buildExplicitResumeSessionOverride, formatRuntimeWorkspaceWarningLog, parseSessionCompactionPolicy, resolveRuntimeSessionParamsForWorkspace, shouldResetTaskSessionForWake, } from "./runtime-kernel/heartbeat.sessions.js";
 //# sourceMappingURL=heartbeat.d.ts.map

package/dist/services/heartbeat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../src/services/heartbeat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kCAAkC,EAClC,kCAAkC,EAClC,kCAAkC,EAClC,sBAAsB,EACtB,gCAAgC,EAChC,gBAAgB,EAChB,gBAAgB,IAAI,qBAAqB,EACzC,4BAA4B,EAC5B,0CAA0C,EAC1C,oCAAoC,EACpC,uCAAuC,EACvC,6BAA6B,EAC7B,KAAK,uBAAuB,GAC7B,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../src/services/heartbeat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,IAAI,qBAAqB,EACzC,0CAA0C,EAC1C,KAAK,uBAAuB,GAC7B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EACL,kCAAkC,EAClC,kCAAkC,EAClC,sBAAsB,EACtB,oCAAoC,GACrC,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EACL,kCAAkC,EAClC,gCAAgC,EAChC,4BAA4B,EAC5B,uCAAuC,EACvC,6BAA6B,GAC9B,MAAM,wCAAwC,CAAC"}

package/dist/services/heartbeat.js

@@ -1,2 +1,4 @@
-export { buildExplicitResumeSessionOverride, buildHeartbeatAdapterInvokePayload, buildHeartbeatRuntimeTraceMetadata, buildIssueRunTraceName, formatRuntimeWorkspaceWarningLog, heartbeatService, heartbeatService as heartbeatOrchestrator, parseSessionCompactionPolicy, prioritizeProjectWorkspaceCandidatesForRun, resolveHeartbeatObservabilitySurface, resolveRuntimeSessionParamsForWorkspace, shouldResetTaskSessionForWake, } from "./runtime-kernel/heartbeat.js";
+export { heartbeatService, heartbeatService as heartbeatOrchestrator, prioritizeProjectWorkspaceCandidatesForRun, } from "./runtime-kernel/heartbeat.js";
+export { buildHeartbeatAdapterInvokePayload, buildHeartbeatRuntimeTraceMetadata, buildIssueRunTraceName, resolveHeartbeatObservabilitySurface, } from "./runtime-kernel/heartbeat.core.js";
+export { buildExplicitResumeSessionOverride, formatRuntimeWorkspaceWarningLog, parseSessionCompactionPolicy, resolveRuntimeSessionParamsForWorkspace, shouldResetTaskSessionForWake, } from "./runtime-kernel/heartbeat.sessions.js";
 //# sourceMappingURL=heartbeat.js.map

package/dist/services/heartbeat.js.map

@@ -1 +1 @@
-{"version":3,"file":"heartbeat.js","sourceRoot":"","sources":["../../src/services/heartbeat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kCAAkC,EAClC,kCAAkC,EAClC,kCAAkC,EAClC,sBAAsB,EACtB,gCAAgC,EAChC,gBAAgB,EAChB,gBAAgB,IAAI,qBAAqB,EACzC,4BAA4B,EAC5B,0CAA0C,EAC1C,oCAAoC,EACpC,uCAAuC,EACvC,6BAA6B,GAE9B,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"heartbeat.js","sourceRoot":"","sources":["../../src/services/heartbeat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,IAAI,qBAAqB,EACzC,0CAA0C,GAE3C,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EACL,kCAAkC,EAClC,kCAAkC,EAClC,sBAAsB,EACtB,oCAAoC,GACrC,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EACL,kCAAkC,EAClC,gCAAgC,EAChC,4BAA4B,EAC5B,uCAAuC,EACvC,6BAA6B,GAC9B,MAAM,wCAAwC,CAAC"}

package/dist/services/issue-approvals.d.ts

@@ -27,11 +27,11 @@ export declare function issueApprovalService(db: Db): {
     }[]>;
     listIssuesForApproval: (approvalId: string) => Promise<{
         labels: {
+            createdAt: Date;
             id: string;
+            name: string;
             updatedAt: Date;
             orgId: string;
-            createdAt: Date;
-            name: string;
             color: string;
         }[];
         labelIds: string[];
@@ -59,8 +59,8 @@ export declare function issueApprovalService(db: Db): {
         updatedAt: Date;
     }[]>;
     link: (issueId: string, approvalId: string, actor?: LinkActor) => Promise<{
-        orgId: string;
         createdAt: Date;
+        orgId: string;
         issueId: string;
         approvalId: string;
         linkedByAgentId: string | null;
@@ -68,8 +68,8 @@ export declare function issueApprovalService(db: Db): {
     }>;
     unlink: (issueId: string, approvalId: string) => Promise<void>;
     linkManyForApproval: (approvalId: string, issueIds: string[], actor?: LinkActor) => Promise<{
-        orgId: string;
         createdAt: Date;
+        orgId: string;
         issueId: string;
         approvalId: string;
         linkedByAgentId: string | null;

package/dist/services/issue-review-wakeup.d.ts

@@ -36,7 +36,7 @@ export declare function buildIssueReviewWakeupOptions(input: {
         issueId: string;
         mutation: IssueReviewWakeupMutation;
     };
-    requestedByActorType: "system" | "user" | "agent" | undefined;
+    requestedByActorType: "agent" | "user" | "system" | undefined;
     requestedByActorId: string | null;
     contextSnapshot: {
         issueId: string;
@@ -77,7 +77,7 @@ export declare function buildIssueConvergenceReviewWakeupOptions(input: {
         attempts: number;
         maxAttempts: number;
     };
-    requestedByActorType: "system" | "user" | "agent" | undefined;
+    requestedByActorType: "agent" | "user" | "system" | undefined;
     requestedByActorId: string | null;
     contextSnapshot: {
         issueId: string;
@@ -124,7 +124,7 @@ export declare function buildIssueReviewCloseoutWakeupOptions(input: {
         attempts: number;
         maxAttempts: number;
     };
-    requestedByActorType: "system" | "user" | "agent" | undefined;
+    requestedByActorType: "agent" | "user" | "system" | undefined;
     requestedByActorId: string | null;
     contextSnapshot: {
         issueId: string;

package/dist/services/issues.comments-attachments.d.ts

@@ -0,0 +1,141 @@
+import type { Db } from "@rudderhq/db";
+import { instanceSettingsService } from "./instance-settings.js";
+type IssueCommentAttachmentMethodContext = {
+    db: Db;
+    instanceSettings: ReturnType<typeof instanceSettingsService>;
+    redactIssueComment: <T extends {
+        body: string;
+    }>(comment: T, censorUsernameInLogs: boolean) => T;
+};
+export declare function createIssueCommentAttachmentMethods(ctx: IssueCommentAttachmentMethodContext): {
+    findMentionedAgents: (orgId: string, body: string) => Promise<string[]>;
+    findMentionedProjectIds: (issueId: string) => Promise<string[]>;
+    listComments: (issueId: string, opts?: {
+        afterCommentId?: string | null;
+        order?: "asc" | "desc";
+        limit?: number | null;
+    }) => Promise<{
+        createdAt: Date;
+        body: string;
+        id: string;
+        updatedAt: Date;
+        orgId: string;
+        issueId: string;
+        authorAgentId: string | null;
+        authorUserId: string | null;
+    }[]>;
+    getCommentCursor: (issueId: string) => Promise<{
+        totalComments: number;
+        latestCommentId: string;
+        latestCommentAt: Date;
+    }>;
+    getComment: (commentId: string) => Promise<{
+        createdAt: Date;
+        body: string;
+        id: string;
+        updatedAt: Date;
+        orgId: string;
+        issueId: string;
+        authorAgentId: string | null;
+        authorUserId: string | null;
+    } | null>;
+    addComment: (issueId: string, body: string, actor: {
+        agentId?: string;
+        userId?: string;
+    }) => Promise<{
+        createdAt: Date;
+        body: string;
+        id: string;
+        updatedAt: Date;
+        orgId: string;
+        issueId: string;
+        authorAgentId: string | null;
+        authorUserId: string | null;
+    }>;
+    createAttachment: (input: {
+        issueId: string;
+        issueCommentId?: string | null;
+        usage?: string;
+        provider: string;
+        objectKey: string;
+        contentType: string;
+        byteSize: number;
+        sha256: string;
+        originalFilename?: string | null;
+        createdByAgentId?: string | null;
+        createdByUserId?: string | null;
+    }) => Promise<{
+        id: string;
+        orgId: string;
+        issueId: string;
+        issueCommentId: string | null;
+        assetId: string;
+        usage: string;
+        provider: string;
+        objectKey: string;
+        contentType: string;
+        byteSize: number;
+        sha256: string;
+        originalFilename: string | null;
+        createdByAgentId: string | null;
+        createdByUserId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    listAttachments: (issueId: string) => Promise<{
+        id: string;
+        orgId: string;
+        issueId: string;
+        issueCommentId: string | null;
+        assetId: string;
+        usage: string;
+        provider: string;
+        objectKey: string;
+        contentType: string;
+        byteSize: number;
+        sha256: string;
+        originalFilename: string | null;
+        createdByAgentId: string | null;
+        createdByUserId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    getAttachmentById: (id: string) => Promise<{
+        id: string;
+        orgId: string;
+        issueId: string;
+        issueCommentId: string | null;
+        assetId: string;
+        usage: string;
+        provider: string;
+        objectKey: string;
+        contentType: string;
+        byteSize: number;
+        sha256: string;
+        originalFilename: string | null;
+        createdByAgentId: string | null;
+        createdByUserId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    removeAttachment: (id: string) => Promise<{
+        id: string;
+        orgId: string;
+        issueId: string;
+        issueCommentId: string | null;
+        assetId: string;
+        usage: string;
+        provider: string;
+        objectKey: string;
+        contentType: string;
+        byteSize: number;
+        sha256: string;
+        originalFilename: string | null;
+        createdByAgentId: string | null;
+        createdByUserId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=issues.comments-attachments.d.ts.map

package/dist/services/issues.comments-attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issues.comments-attachments.d.ts","sourceRoot":"","sources":["../../src/services/issues.comments-attachments.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,cAAc,CAAC;AAkCvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAOjE,KAAK,mCAAmC,GAAG;IACzC,EAAE,EAAE,EAAE,CAAC;IACP,gBAAgB,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;IAC7D,kBAAkB,EAAE,CAAC,CAAC,SAAS;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,OAAO,EAAE,CAAC,EAAE,oBAAoB,EAAE,OAAO,KAAK,CAAC,CAAC;CAClG,CAAC;AAEF,wBAAgB,mCAAmC,CAAC,GAAG,EAAE,mCAAmC;iCAGrD,MAAM,QAAQ,MAAM;uCAoBd,MAAM;4BA6CpC,MAAM,SACR;QACL,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;QACvB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACvB;;;;;;;;;;gCAmD+B,MAAM;;;;;4BA4BhB,MAAM;;;;;;;;;;0BAWF,MAAM,QAAQ,MAAM,SAAS;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;8BAiC9D;QAC9B,OAAO,EAAE,MAAM,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACjC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACjC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACjC;;;;;;;;;;;;;;;;;;+BAoEgC,MAAM;;;;;;;;;;;;;;;;;;4BAyBT,MAAM;;;;;;;;;;;;;;;;;;2BAyBP,MAAM;;;;;;;;;;;;;;;;;;EAgCtC"}

package/dist/services/issues.comments-attachments.js

@@ -0,0 +1,313 @@
+import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
+import { agents, assets, issueAttachments, issueComments, issues, projects, } from "@rudderhq/db";
+import { extractAgentMentionIds, extractProjectMentionIds, isUuidLike, } from "@rudderhq/shared";
+import { notFound, unprocessable } from "../errors.js";
+import { redactCurrentUserText } from "../log-redaction.js";
+import { MAX_ISSUE_COMMENT_PAGE_LIMIT } from "./issues.helpers.js";
+export function createIssueCommentAttachmentMethods(ctx) {
+    const { db, instanceSettings, redactIssueComment } = ctx;
+    return {
+        findMentionedAgents: async (orgId, body) => {
+            const re = /\B@([^\s@,!?.]+)/g;
+            const tokens = new Set();
+            let m;
+            while ((m = re.exec(body)) !== null)
+                tokens.add(m[1].toLowerCase());
+            const explicitAgentMentionIds = extractAgentMentionIds(body).filter(isUuidLike);
+            if (tokens.size === 0 && explicitAgentMentionIds.length === 0)
+                return [];
+            const rows = await db.select({ id: agents.id, name: agents.name })
+                .from(agents).where(eq(agents.orgId, orgId));
+            const resolved = new Set(explicitAgentMentionIds);
+            for (const agent of rows) {
+                if (tokens.has(agent.name.toLowerCase())) {
+                    resolved.add(agent.id);
+                }
+            }
+            return [...resolved];
+        },
+        findMentionedProjectIds: async (issueId) => {
+            const issue = await db
+                .select({
+                orgId: issues.orgId,
+                title: issues.title,
+                description: issues.description,
+            })
+                .from(issues)
+                .where(eq(issues.id, issueId))
+                .then((rows) => rows[0] ?? null);
+            if (!issue)
+                return [];
+            const comments = await db
+                .select({ body: issueComments.body })
+                .from(issueComments)
+                .where(eq(issueComments.issueId, issueId));
+            const mentionedIds = new Set();
+            for (const source of [
+                issue.title,
+                issue.description ?? "",
+                ...comments.map((comment) => comment.body),
+            ]) {
+                for (const projectId of extractProjectMentionIds(source)) {
+                    mentionedIds.add(projectId);
+                }
+            }
+            if (mentionedIds.size === 0)
+                return [];
+            const validMentionedIds = [...mentionedIds].filter(isUuidLike);
+            if (validMentionedIds.length === 0)
+                return [];
+            const rows = await db
+                .select({ id: projects.id })
+                .from(projects)
+                .where(and(eq(projects.orgId, issue.orgId), inArray(projects.id, validMentionedIds)));
+            const valid = new Set(rows.map((row) => row.id));
+            return validMentionedIds.filter((projectId) => valid.has(projectId));
+        },
+        listComments: async (issueId, opts) => {
+            const order = opts?.order === "asc" ? "asc" : "desc";
+            const afterCommentId = opts?.afterCommentId?.trim() || null;
+            const limit = opts?.limit && opts.limit > 0
+                ? Math.min(Math.floor(opts.limit), MAX_ISSUE_COMMENT_PAGE_LIMIT)
+                : null;
+            const conditions = [eq(issueComments.issueId, issueId)];
+            if (afterCommentId) {
+                const anchor = await db
+                    .select({
+                    id: issueComments.id,
+                    createdAt: issueComments.createdAt,
+                })
+                    .from(issueComments)
+                    .where(and(eq(issueComments.issueId, issueId), eq(issueComments.id, afterCommentId)))
+                    .then((rows) => rows[0] ?? null);
+                if (!anchor)
+                    return [];
+                const anchorCreatedAt = anchor.createdAt instanceof Date
+                    ? anchor.createdAt.toISOString()
+                    : new Date(anchor.createdAt).toISOString();
+                conditions.push(order === "asc"
+                    ? sql `(
+                ${issueComments.createdAt} > ${anchorCreatedAt}
+                OR (${issueComments.createdAt} = ${anchorCreatedAt} AND ${issueComments.id} > ${anchor.id})
+              )`
+                    : sql `(
+                ${issueComments.createdAt} < ${anchorCreatedAt}
+                OR (${issueComments.createdAt} = ${anchorCreatedAt} AND ${issueComments.id} < ${anchor.id})
+              )`);
+            }
+            const query = db
+                .select()
+                .from(issueComments)
+                .where(and(...conditions))
+                .orderBy(order === "asc" ? asc(issueComments.createdAt) : desc(issueComments.createdAt), order === "asc" ? asc(issueComments.id) : desc(issueComments.id));
+            const comments = limit ? await query.limit(limit) : await query;
+            const { censorUsernameInLogs } = await instanceSettings.getGeneral();
+            return comments.map((comment) => redactIssueComment(comment, censorUsernameInLogs));
+        },
+        getCommentCursor: async (issueId) => {
+            const [latest, countRow] = await Promise.all([
+                db
+                    .select({
+                    latestCommentId: issueComments.id,
+                    latestCommentAt: issueComments.createdAt,
+                })
+                    .from(issueComments)
+                    .where(eq(issueComments.issueId, issueId))
+                    .orderBy(desc(issueComments.createdAt), desc(issueComments.id))
+                    .limit(1)
+                    .then((rows) => rows[0] ?? null),
+                db
+                    .select({
+                    totalComments: sql `count(*)::int`,
+                })
+                    .from(issueComments)
+                    .where(eq(issueComments.issueId, issueId))
+                    .then((rows) => rows[0] ?? null),
+            ]);
+            return {
+                totalComments: Number(countRow?.totalComments ?? 0),
+                latestCommentId: latest?.latestCommentId ?? null,
+                latestCommentAt: latest?.latestCommentAt ?? null,
+            };
+        },
+        getComment: (commentId) => instanceSettings.getGeneral().then(({ censorUsernameInLogs }) => db
+            .select()
+            .from(issueComments)
+            .where(eq(issueComments.id, commentId))
+            .then((rows) => {
+            const comment = rows[0] ?? null;
+            return comment ? redactIssueComment(comment, censorUsernameInLogs) : null;
+        })),
+        addComment: async (issueId, body, actor) => {
+            const issue = await db
+                .select({ orgId: issues.orgId })
+                .from(issues)
+                .where(eq(issues.id, issueId))
+                .then((rows) => rows[0] ?? null);
+            if (!issue)
+                throw notFound("Issue not found");
+            const currentUserRedactionOptions = {
+                enabled: (await instanceSettings.getGeneral()).censorUsernameInLogs,
+            };
+            const redactedBody = redactCurrentUserText(body, currentUserRedactionOptions);
+            const [comment] = await db
+                .insert(issueComments)
+                .values({
+                orgId: issue.orgId,
+                issueId,
+                authorAgentId: actor.agentId ?? null,
+                authorUserId: actor.userId ?? null,
+                body: redactedBody,
+            })
+                .returning();
+            // Update issue's updatedAt so comment activity is reflected in recency sorting
+            await db
+                .update(issues)
+                .set({ updatedAt: new Date() })
+                .where(eq(issues.id, issueId));
+            return redactIssueComment(comment, currentUserRedactionOptions.enabled);
+        },
+        createAttachment: async (input) => {
+            const issue = await db
+                .select({ id: issues.id, orgId: issues.orgId })
+                .from(issues)
+                .where(eq(issues.id, input.issueId))
+                .then((rows) => rows[0] ?? null);
+            if (!issue)
+                throw notFound("Issue not found");
+            if (input.issueCommentId) {
+                const comment = await db
+                    .select({ id: issueComments.id, orgId: issueComments.orgId, issueId: issueComments.issueId })
+                    .from(issueComments)
+                    .where(eq(issueComments.id, input.issueCommentId))
+                    .then((rows) => rows[0] ?? null);
+                if (!comment)
+                    throw notFound("Issue comment not found");
+                if (comment.orgId !== issue.orgId || comment.issueId !== issue.id) {
+                    throw unprocessable("Attachment comment must belong to same issue and organization");
+                }
+            }
+            return db.transaction(async (tx) => {
+                const [asset] = await tx
+                    .insert(assets)
+                    .values({
+                    orgId: issue.orgId,
+                    provider: input.provider,
+                    objectKey: input.objectKey,
+                    contentType: input.contentType,
+                    byteSize: input.byteSize,
+                    sha256: input.sha256,
+                    originalFilename: input.originalFilename ?? null,
+                    createdByAgentId: input.createdByAgentId ?? null,
+                    createdByUserId: input.createdByUserId ?? null,
+                })
+                    .returning();
+                const [attachment] = await tx
+                    .insert(issueAttachments)
+                    .values({
+                    orgId: issue.orgId,
+                    issueId: issue.id,
+                    assetId: asset.id,
+                    issueCommentId: input.issueCommentId ?? null,
+                    usage: input.usage ?? "issue",
+                })
+                    .returning();
+                return {
+                    id: attachment.id,
+                    orgId: attachment.orgId,
+                    issueId: attachment.issueId,
+                    issueCommentId: attachment.issueCommentId,
+                    assetId: attachment.assetId,
+                    usage: attachment.usage,
+                    provider: asset.provider,
+                    objectKey: asset.objectKey,
+                    contentType: asset.contentType,
+                    byteSize: asset.byteSize,
+                    sha256: asset.sha256,
+                    originalFilename: asset.originalFilename,
+                    createdByAgentId: asset.createdByAgentId,
+                    createdByUserId: asset.createdByUserId,
+                    createdAt: attachment.createdAt,
+                    updatedAt: attachment.updatedAt,
+                };
+            });
+        },
+        listAttachments: async (issueId) => db
+            .select({
+            id: issueAttachments.id,
+            orgId: issueAttachments.orgId,
+            issueId: issueAttachments.issueId,
+            issueCommentId: issueAttachments.issueCommentId,
+            assetId: issueAttachments.assetId,
+            usage: issueAttachments.usage,
+            provider: assets.provider,
+            objectKey: assets.objectKey,
+            contentType: assets.contentType,
+            byteSize: assets.byteSize,
+            sha256: assets.sha256,
+            originalFilename: assets.originalFilename,
+            createdByAgentId: assets.createdByAgentId,
+            createdByUserId: assets.createdByUserId,
+            createdAt: issueAttachments.createdAt,
+            updatedAt: issueAttachments.updatedAt,
+        })
+            .from(issueAttachments)
+            .innerJoin(assets, eq(issueAttachments.assetId, assets.id))
+            .where(and(eq(issueAttachments.issueId, issueId), eq(issueAttachments.usage, "issue")))
+            .orderBy(desc(issueAttachments.createdAt)),
+        getAttachmentById: async (id) => db
+            .select({
+            id: issueAttachments.id,
+            orgId: issueAttachments.orgId,
+            issueId: issueAttachments.issueId,
+            issueCommentId: issueAttachments.issueCommentId,
+            assetId: issueAttachments.assetId,
+            usage: issueAttachments.usage,
+            provider: assets.provider,
+            objectKey: assets.objectKey,
+            contentType: assets.contentType,
+            byteSize: assets.byteSize,
+            sha256: assets.sha256,
+            originalFilename: assets.originalFilename,
+            createdByAgentId: assets.createdByAgentId,
+            createdByUserId: assets.createdByUserId,
+            createdAt: issueAttachments.createdAt,
+            updatedAt: issueAttachments.updatedAt,
+        })
+            .from(issueAttachments)
+            .innerJoin(assets, eq(issueAttachments.assetId, assets.id))
+            .where(eq(issueAttachments.id, id))
+            .then((rows) => rows[0] ?? null),
+        removeAttachment: async (id) => db.transaction(async (tx) => {
+            const existing = await tx
+                .select({
+                id: issueAttachments.id,
+                orgId: issueAttachments.orgId,
+                issueId: issueAttachments.issueId,
+                issueCommentId: issueAttachments.issueCommentId,
+                assetId: issueAttachments.assetId,
+                usage: issueAttachments.usage,
+                provider: assets.provider,
+                objectKey: assets.objectKey,
+                contentType: assets.contentType,
+                byteSize: assets.byteSize,
+                sha256: assets.sha256,
+                originalFilename: assets.originalFilename,
+                createdByAgentId: assets.createdByAgentId,
+                createdByUserId: assets.createdByUserId,
+                createdAt: issueAttachments.createdAt,
+                updatedAt: issueAttachments.updatedAt,
+            })
+                .from(issueAttachments)
+                .innerJoin(assets, eq(issueAttachments.assetId, assets.id))
+                .where(eq(issueAttachments.id, id))
+                .then((rows) => rows[0] ?? null);
+            if (!existing)
+                return null;
+            await tx.delete(issueAttachments).where(eq(issueAttachments.id, id));
+            await tx.delete(assets).where(eq(assets.id, existing.assetId));
+            return existing;
+        }),
+    };
+}
+//# sourceMappingURL=issues.comments-attachments.js.map