diff --git a/server/src/__tests__/issue-thread-interactions-service.test.ts b/server/src/__tests__/issue-thread-interactions-service.test.ts index 1cd08259319..0c892ed8820 100644 --- a/server/src/__tests__/issue-thread-interactions-service.test.ts +++ b/server/src/__tests__/issue-thread-interactions-service.test.ts @@ -3478,6 +3478,88 @@ describeEmbeddedPostgres("issueThreadInteractionService", () => { expect(listed[0]?.status).toBe("cancelled"); }); + it("reads an old authorization target and saves follow-up comments without resolving the request", async () => { + const { companyId, issueId } = await seedConfirmationIssue("Saved authorization target"); + const key = `connection:https://mcp.example.test/${"connection/".repeat(25)}:user:local-board`; + const [card] = await db.insert(issueThreadInteractions).values({ + companyId, issueId, kind: "request_confirmation", status: "pending", + continuationPolicy: "wake_assignee", requestedResolverPolicy: "human_only", + effectiveResolverPolicy: "human_only", createdByUserId: "local-board", + payload: { version: 1, prompt: "Connect your account to continue", + target: { type: "custom", key, label: "Personal connection ".repeat(10), href: "/apps/example/permissions" } }, + }).returning(); + + expect((await interactionsSvc.listForIssue(issueId))[0]).toMatchObject({ + id: card.id, status: "pending", effectiveResolverPolicy: "human_only", + payload: { target: { key } }, + }); + for (const body of ["How do I connect it?", "Please explain the next step."]) { + const saved = await issuesSvc.addComment(issueId, body, { userId: "local-board" }, { + clientRequestId: randomUUID(), + }); + expect(await db.select().from(issueComments).where(eq(issueComments.id, saved.id))) + .toMatchObject([{ body }]); + } + // Reconstruct the reader as a reload would. A comment never supplies consent. + expect((await issueThreadInteractionService(db).listForIssue(issueId))[0]).toMatchObject({ + id: card.id, status: "pending", result: null, payload: { target: { key } }, + }); + await expect(interactionsSvc.create({ id: issueId, companyId }, { + kind: "request_confirmation", payload: { version: 1, prompt: "New request", + target: { type: "custom", key } }, + }, { userId: "local-board" })).rejects.toThrow(); + await expect(interactionsSvc.acceptInteraction({ id: issueId, companyId: randomUUID(), projectId: null, goalId: null }, card.id, {}, { userId: "local-board" })) + .rejects.toMatchObject({ status: 404 }); + }); + + it.each([ + { type: "custom", key: "" }, + { type: "custom", key: "authorization", href: "javascript:alert(1)" }, + { type: "issue_document", key: "plan", revisionId: "invalid" }, + ] as const)("keeps invalid stored target structure protected: %j", async target => { + const { companyId, issueId } = await seedConfirmationIssue("Invalid target structure"); + const [card] = await db.insert(issueThreadInteractions).values({ + companyId, issueId, kind: "request_confirmation", status: "pending", + continuationPolicy: "none", createdByUserId: "local-board", + payload: { version: 1, prompt: "Review this request", target }, + }).returning(); + await expect(interactionsSvc.listForIssue(issueId)).rejects.toThrow(); + await expect(interactionsSvc.acceptInteraction({ id: issueId, companyId, projectId: null, goalId: null }, card.id, {}, { userId: "local-board" })) + .rejects.toThrow(); + await expect(issuesSvc.addComment(issueId, "This request needs repair", { userId: "local-board" })) + .resolves.toMatchObject({ body: "This request needs repair" }); + expect((await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.id, card.id)))[0]) + .toMatchObject({ status: "pending", result: null }); + }); + + it.each(["request_confirmation", "ask_user_questions"] as const)( + "keeps a malformed %s pending while saving a comment and superseding a valid sibling", async kind => { + const { companyId, issueId } = await seedConfirmationIssue("Malformed saved request"); + const [malformed] = await db.insert(issueThreadInteractions).values({ + companyId, issueId, kind, status: "pending", continuationPolicy: "wake_assignee", + createdByUserId: "local-board", + payload: sql`${JSON.stringify({ version: 1, prompt: null, supersedeOnUserComment: true })}::jsonb`, + }).returning(); + const [valid] = await db.insert(issueThreadInteractions).values({ + companyId, issueId, kind: "request_confirmation", status: "pending", + continuationPolicy: "none", createdByUserId: "local-board", + payload: { version: 1, prompt: "An optional question", supersedeOnUserComment: true }, + createdAt: new Date(Date.now() - 1000), + }).returning(); + const saved = await issuesSvc.addComment(issueId, "I need help with this request", { userId: "local-board" }); + expect((await db.select().from(issueComments).where(eq(issueComments.id, saved.id)))[0].body) + .toBe("I need help with this request"); + expect((await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.id, malformed.id)))[0]) + .toMatchObject({ status: "pending", result: null }); + expect((await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.id, valid.id)))[0]) + .toMatchObject({ status: "expired", result: { outcome: "superseded_by_comment", commentId: saved.id } }); + await expect(interactionsSvc.expireRequestConfirmationsSupersededByHistoricalComments({ id: issueId, companyId })) + .resolves.toEqual([]); + await expect(interactionsSvc.acceptInteraction({ id: issueId, companyId, projectId: null, goalId: null }, malformed.id, {}, { userId: "local-board" })) + .rejects.toThrow(); + }, + ); + it("derives legacy pending interactions as expired on closed issues without mutating the GET", async () => { const { companyId, issueId } = await seedConfirmationIssue("Legacy pending interaction on closed issue"); const created = await interactionsSvc.create({ id: issueId, companyId }, { diff --git a/server/src/__tests__/tool-gateway.test.ts b/server/src/__tests__/tool-gateway.test.ts index 1fc5b2701c1..09c5491da4d 100644 --- a/server/src/__tests__/tool-gateway.test.ts +++ b/server/src/__tests__/tool-gateway.test.ts @@ -7,6 +7,7 @@ import { join } from "node:path"; import express from "express"; import { and, eq, sql } from "drizzle-orm"; import type { LiveEvent } from "@paperclipai/shared"; +import { requestConfirmationPayloadSchema } from "@paperclipai/shared"; import { subscribeCompanyLiveEvents } from "../services/live-events.js"; import { assignedToolName as nativeAssignedToolName } from "../services/native-runtime/assigned-mcp-tools.js"; import request from "supertest"; @@ -2824,7 +2825,11 @@ rl.on("line", (line) => { } }); - it("starts with another user's personal app and requests authorization only when used", async () => { + it.each([ + { longIdentity: false, existing: false }, + { longIdentity: true, existing: false }, + { longIdentity: true, existing: true }, + ])("requests another user's personal authorization only when used (long: $longIdentity, existing: $existing)", async ({ longIdentity, existing }) => { const originalApiUrl = process.env.PAPERCLIP_API_URL; process.env.PAPERCLIP_API_URL = "http://paperclip.example.test"; const company = await createCompany(db); @@ -2849,6 +2854,7 @@ rl.on("line", (line) => { // may be unable to authenticate even though this user's grant is valid. // The cached catalog must remain visible so grant resolution can happen. await db.update(toolConnections).set({ + ...(longIdentity ? { uid: `https://mcp.example.test/${"connection/".repeat(25)}`, name: "Personal connection ".repeat(10) } : {}), credentialPolicy: "per_user", healthStatus: "error", healthMessage: "This app needs you to sign in.", @@ -2882,7 +2888,7 @@ rl.on("line", (line) => { const call = () => request(app).post(endpoint).set("authorization", `Bearer ${runtime[0]!.token}`) .send({ jsonrpc: "2.0", id: "call", method: "tools/call", params: { name: tool.name, arguments: {} } }); - await db.insert(issueThreadInteractions).values({ + if (existing) await db.insert(issueThreadInteractions).values({ companyId: company.id, issueId: issue.id, kind: "request_confirmation", @@ -2913,10 +2919,14 @@ rl.on("line", (line) => { effectiveResolverPolicy: "human_only", addresseeUserId: "carol", }); - expect(interaction!.payload).toMatchObject({ - prompt: `Connect your ${connection.name} account to continue`, - target: { key: `connection:${connection.uid}:user:carol` }, - }); + const payload = requestConfirmationPayloadSchema.parse(interaction!.payload); + expect(payload.target?.type).toBe("custom"); + expect(payload.target && "key" in payload.target && payload.target.key.length).toBeLessThanOrEqual(120); + // A repeated refused call refreshes the same request, with a stable target. + await call().expect(409); + const cards = await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.issueId, issue.id)); + expect(cards).toHaveLength(1); + expect(cards[0].payload).toEqual(interaction!.payload); await db.insert(connectionGrants).values({ companyId: company.id, diff --git a/server/src/services/issue-thread-interactions.ts b/server/src/services/issue-thread-interactions.ts index 82f721a5fb8..ee14f32e8d4 100644 --- a/server/src/services/issue-thread-interactions.ts +++ b/server/src/services/issue-thread-interactions.ts @@ -107,6 +107,9 @@ import { requestCheckboxConfirmationPayloadSchema, requestCheckboxConfirmationResultSchema, requestConfirmationPayloadSchema, + requestConfirmationCustomTargetSchema, + requestConfirmationIssueAttachmentTargetSchema, + requestConfirmationIssueDocumentTargetSchema, requestConfirmationResultSchema, requestItemVerdictsPayloadSchema, requestItemVerdictsResultSchema, @@ -117,6 +120,7 @@ import { withdrawIssueThreadInteractionSchema, } from "@paperclipai/shared"; import { z } from "zod"; +import { logger } from "../middleware/logger.js"; import { conflict, forbidden, notFound, unprocessable } from "../errors.js"; import { getTelemetryClient } from "../telemetry.js"; import { authorizationService } from "./authorization.js"; @@ -703,6 +707,21 @@ function parseStoredInteractionResult( return null; } +// Older internal writers persisted custom identity and display text without the +// input length limits. Read those exact values across upgrades; never truncate +// an identity or relax target types, URLs, revisions, or resolution authority. +// New writes still use the strict shared payload schema. +const storedRequestConfirmationPayloadSchema = requestConfirmationPayloadSchema.extend({ + target: z.discriminatedUnion("type", [ + requestConfirmationIssueDocumentTargetSchema, + requestConfirmationIssueAttachmentTargetSchema, + requestConfirmationCustomTargetSchema.extend({ + key: z.string().trim().min(1), + label: z.string().trim().min(1).nullable().optional(), + }), + ]).nullable().optional(), +}); + function hydrateInteraction( row: IssueThreadInteractionRow, ): IssueThreadInteraction { @@ -774,7 +793,7 @@ function hydrateInteraction( ), } satisfies AskUserQuestionsInteraction; case "request_confirmation": { - const payload = requestConfirmationPayloadSchema.parse(row.payload); + const payload = storedRequestConfirmationPayloadSchema.parse(row.payload); return { ...base, kind: "request_confirmation", @@ -824,6 +843,23 @@ function hydrateInteraction( } } +function interactionForCommentSupersession(row: IssueThreadInteractionRow) { + try { + return hydrateInteraction(row) as UserCommentSupersedableInteraction; + } catch (error) { + if (!(error instanceof z.ZodError)) throw error; + // The comment is useful even when a saved request cannot be decoded. Keep + // that gate pending, refuse its normal resolution, and report only schema + // locations, never payload/credential values. Valid siblings still expire. + logger.warn({ + companyId: row.companyId, issueId: row.issueId, interactionId: row.id, + kind: row.kind, + validationIssues: error.issues.map(issue => ({ code: issue.code, path: issue.path })), + }, "Saved interaction is invalid; leaving it pending while saving a comment"); + return null; + } +} + async function touchIssue(db: IssueTouchDb, issueId: string, companyId: string) { await db.transaction(async tx => { await notifyStatusCardIssueChange(tx, companyId); @@ -4962,10 +4998,9 @@ export function issueThreadInteractionService( const superseded = rows.filter((row) => { if (row.kind === "ask_user_questions" && scope?.conversationAgentId && scope.conversationUserId) return false; if (!isUserCommentSupersedableKind(row.kind)) return false; - const interaction = hydrateInteraction( - row, - ) as UserCommentSupersedableInteraction; + const interaction = interactionForCommentSupersession(row); return ( + interaction !== null && shouldSupersedeInteractionOnUserComment(interaction) && isCommentAtOrAfterInteraction({ commentCreatedAt: comment.createdAt, @@ -5071,9 +5106,8 @@ export function issueThreadInteractionService( >(); for (const row of rows) { if (!isUserCommentSupersedableKind(row.kind)) continue; - const interaction = hydrateInteraction( - row, - ) as UserCommentSupersedableInteraction; + const interaction = interactionForCommentSupersession(row); + if (!interaction) continue; if (!shouldSupersedeInteractionOnUserComment(interaction)) continue; const supersedingComment = comments.find((comment) => diff --git a/server/src/services/tool-gateway.ts b/server/src/services/tool-gateway.ts index 9a2adc2011b..ffaed9849d3 100644 --- a/server/src/services/tool-gateway.ts +++ b/server/src/services/tool-gateway.ts @@ -75,6 +75,7 @@ import { } from "./mcp-tasks.js"; import { logger } from "../middleware/logger.js"; import { getAppDefinitionForApplicationKey, isConnectorFeatureEnabled } from "@paperclipai/shared"; +import { requestConfirmationPayloadSchema } from "@paperclipai/shared"; import { instanceSettingsService } from "./instance-settings.js"; import { redactSensitiveText } from "../redaction.js"; import { spawn } from "node:child_process"; @@ -4797,7 +4798,7 @@ export function createToolGatewayService( .limit(1); const href = `/${company?.issuePrefix ?? ""}/apps/${connection.id}/permissions`; const idempotencyKey = `connection-authorization:${connection.id}:${userId}`; - const payload = { + const payload = requestConfirmationPayloadSchema.parse({ version: 1 as const, prompt: grantKind === "organization" @@ -4814,12 +4815,12 @@ export function createToolGatewayService( : "This run needs your personal authorization. Paperclip will not use another user's identity.", target: { type: "custom" as const, - key: `connection:${connection.uid}:user:${userId}`, + key: `connection-authorization:${createHash("sha256").update(idempotencyKey).digest("hex")}`, revisionId: connection.updatedAt.toISOString(), - label: `Connect ${connection.name}`, + label: `Connect ${connection.name}`.slice(0, 120), href, }, - }; + }); const [existing] = await db .select({ id: issueThreadInteractions.id }) .from(issueThreadInteractions)