The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
test: port pipelines tutorial e2e (#9149)
Dottaf42a66bf0435
diff --git a/tests/e2e/pipelines-tutorial-flow.spec.ts b/tests/e2e/pipelines-tutorial-flow.spec.tsnew file mode 100644index 0000000000..9419acc34c--- /dev/null+++ b/tests/e2e/pipelines-tutorial-flow.spec.ts@@ -0,0 +1,661 @@+import { randomUUID } from "node:crypto";+import { expect, request as pwRequest, test, type APIRequestContext, type APIResponse, type Locator, type Page } from "@playwright/test";+import { createLocalAgentJwt } from "../../server/src/agent-auth-jwt";++const PORT = Number(process.env.PAPERCLIP_E2E_PORT ?? 3199);+const BASE_URL = `http://127.0.0.1:${PORT}`;++type Stage = { id: string; key: string; name: string; kind: string; position: number };+type PipelineDetail = {+ id: string;+ name: string;+ stages: Stage[];+ transitions: Array<{ fromStageId: string; toStageId: string }>;+};+type CaseSummary = {+ id: string;+ caseKey: string;+ title: string;+ version: number;+ stageId: string;+ parentCaseVersion?: number | null;+ requestKey?: string | null;+ childCount?: number;+ terminalChildCount?: number;+};+type CaseRow = { case: CaseSummary; stage?: Stage };+type CaseDetail = CaseRow & {+ pipeline: { id: string; key: string; name: string };+ blockers?: Array<{ caseId: string; blockedByCaseId: string }>;+};++async function expectOk(response: APIResponse, label: string) {+ if (!response.ok()) {+ throw new Error(`${label} failed: ${response.status()} ${await response.text()}`);+ }+}++async function expectError(response: APIResponse, label: string, status: number, code: string, message?: RegExp) {+ const body = await response.json() as { code?: string; error?: string; message?: string };+ expect(response.status(), `${label} status: ${JSON.stringify(body)}`).toBe(status);+ expect(body.code, `${label} code: ${JSON.stringify(body)}`).toBe(code);+ if (message) expect(body.error ?? body.message ?? "", `${label} message`).toMatch(message);+}++async function createCompany(board: APIRequestContext) {+ const response = await board.post("/api/companies", {+ data: { name: `E2E Pipelines ${Date.now()}` },+ });+ await expectOk(response, "create company");+ return response.json() as Promise<{ id: string; issuePrefix: string }>;+}++async function createCompanyAgent(+ board: APIRequestContext,+ companyId: string,+ input: { name: string; role: string; title?: string; capabilities?: string },+) {+ const response = await board.post(`/api/companies/${companyId}/agents`, {+ data: {+ name: input.name,+ role: input.role,+ title: input.title,+ capabilities: input.capabilities,+ adapterType: "process",+ adapterConfig: { command: process.execPath, args: ["-e", "process.stdout.write('ok\\n')"] },+ },+ });+ await expectOk(response, `create ${input.name}`);+ return response.json() as Promise<{ id: string }>;+}++async function createPipelineWriterAgentKey(board: APIRequestContext, companyId: string) {+ await createCompanyAgent(board, companyId, {+ name: "Pipeline CEO",+ role: "ceo",+ title: "CEO",+ capabilities: "Approves agent join requests during e2e setup.",+ });++ const inviteResponse = await board.post(`/api/companies/${companyId}/invites`, {+ data: {+ allowedJoinTypes: "agent",+ defaultsPayload: {+ agent: {+ grants: [+ { permissionKey: "pipelines:write", scope: null },+ ],+ },+ },+ },+ });+ await expectOk(inviteResponse, "create pipeline-writer invite");+ const invite = await inviteResponse.json() as { token: string };++ const acceptResponse = await board.post(`/api/invites/${invite.token}/accept`, {+ data: {+ requestType: "agent",+ agentName: "Pipeline Fanout Agent",+ adapterType: "process",+ capabilities: "Creates pipeline child work during e2e coverage.",+ },+ });+ await expectOk(acceptResponse, "accept pipeline-writer invite");+ const accepted = await acceptResponse.json() as { id: string };++ const approveResponse = await board.post(`/api/companies/${companyId}/join-requests/${accepted.id}/approve`);+ await expectOk(approveResponse, "approve pipeline-writer join");+ const approved = await approveResponse.json() as { createdAgentId: string };++ const runId = randomUUID();+ const token = createLocalAgentJwt(approved.createdAgentId, companyId, "process", runId);+ if (!token) throw new Error("PAPERCLIP_AGENT_JWT_SECRET is required for pipeline writer JWT setup");+ return { agentId: approved.createdAgentId, runId, token };+}++async function createPipeline(board: APIRequestContext, companyId: string) {+ const response = await board.post(`/api/companies/${companyId}/pipelines`, {+ data: {+ key: "content-production",+ name: "Content production",+ description: "Draft, review, and publish launch content.",+ enforceTransitions: true,+ stages: [+ { key: "drafting", name: "Drafting", kind: "working", position: 0, config: { variables: [] } },+ { key: "published", name: "Published", kind: "done", position: 2, config: { variables: [] } },+ { key: "dropped", name: "Dropped", kind: "cancelled", position: 3, config: { variables: [] } },+ ],+ },+ });+ await expectOk(response, "create pipeline");+ return response.json() as Promise<{ id: string; name: string }>;+}++async function createPrimitivePipeline(board: APIRequestContext, companyId: string) {+ const response = await board.post(`/api/companies/${companyId}/pipelines`, {+ data: {+ key: `primitive-gates-${Date.now()}`,+ name: "Primitive gates",+ stages: [+ { key: "intake", name: "Intake", kind: "open", position: 0 },+ { key: "fanout", name: "Fan out", kind: "working", position: 100, config: { requireChildrenTerminal: true } },+ {+ key: "dependent_work",+ name: "Dependent Work",+ kind: "working",+ position: 200,+ config: { requireNoUnresolvedDrift: true },+ },+ {+ key: "review",+ name: "Review",+ kind: "review",+ position: 300,+ config: {+ approveToStageKey: "approved",+ rejectToStageKey: "cancelled",+ requestChangesToStageKey: "dependent_work",+ requireRejectReason: true,+ reviewerKind: "human",+ },+ },+ { key: "approved", name: "Approved", kind: "working", position: 400 },+ { key: "done", name: "Done", kind: "done", position: 900 },+ { key: "cancelled", name: "Cancelled", kind: "cancelled", position: 1000 },+ ],+ },+ });+ await expectOk(response, "create primitive pipeline");+ return response.json() as Promise<{ id: string; name: string }>;+}++async function getPipeline(board: APIRequestContext, pipelineId: string): Promise<PipelineDetail> {+ const response = await board.get(`/api/pipelines/${pipelineId}`);+ await expectOk(response, "get pipeline");+ return response.json() as Promise<PipelineDetail>;+}++async function listItems(board: APIRequestContext, pipelineId: string): Promise<CaseRow[]> {+ const response = await board.get(`/api/pipelines/${pipelineId}/cases`);+ await expectOk(response, "list pipeline items");+ return response.json() as Promise<CaseRow[]>;+}++async function createItem(+ board: APIRequestContext,+ pipelineId: string,+ data: {+ title: string;+ caseKey?: string;+ stageKey?: string;+ parentCaseId?: string;+ requestKey?: string;+ blockedByCaseIds?: string[];+ fields?: Record<string, unknown>;+ },+) {+ const response = await board.post(`/api/pipelines/${pipelineId}/cases`, {+ data: {+ caseKey: data.caseKey,+ title: data.title,+ stageKey: data.stageKey,+ parentCaseId: data.parentCaseId,+ requestKey: data.requestKey,+ blockedByCaseIds: data.blockedByCaseIds,+ fields: data.fields ?? {},+ },+ });+ await expectOk(response, `create item ${data.title}`);+ const body = await response.json() as { case: CaseSummary; created?: boolean };+ return body.case;+}++async function getItem(board: APIRequestContext, caseId: string): Promise<CaseDetail> {+ const response = await board.get(`/api/cases/${caseId}`);+ await expectOk(response, "get item detail");+ return response.json() as Promise<CaseDetail>;+}++async function getItemVersion(board: APIRequestContext, caseId: string) {+ const detail = await getItem(board, caseId);+ return detail.case.version;+}++async function moveItem(+ board: APIRequestContext,+ caseId: string,+ toStageKey: string,+ options: { reason?: string; force?: boolean } = {},+) {+ const expectedVersion = await getItemVersion(board, caseId);+ const response = await board.post(`/api/cases/${caseId}/transition`, {+ data: { toStageKey, expectedVersion, reason: options.reason, force: options.force },+ });+ await expectOk(response, `move item to ${toStageKey}`);+}++async function suggestMove(board: APIRequestContext, caseId: string, toStageKey: string, rationale: string) {+ const response = await board.post(`/api/cases/${caseId}/suggest-transition`, {+ data: { toStageKey, rationale },+ });+ await expectOk(response, "seed transition suggestion");+}++async function expectProsumerVocabulary(page: Page) {+ const text = await page.locator("body").innerText();+ expect(text).not.toMatch(/\bcase\b/i);+ expect(text).not.toMatch(/\breview_decided\b|\btransition_forced\b/);+ expect(text).not.toMatch(/\b(?:400|401|403|404|409|422|500)\b/);+}++async function dragCardToColumn(page: Page, itemTitle: string, fromColumn: string, toColumn: string) {+ const card = page.getByLabel(`${fromColumn} column`).getByText(itemTitle, { exact: true });+ const column = page.getByLabel(`${toColumn} column`);+ await expect(card).toBeVisible();+ await expect(column).toBeVisible();++ const cardBox = await card.boundingBox();+ const columnBox = await column.boundingBox();+ if (!cardBox || !columnBox) return false;++ await page.mouse.move(cardBox.x + cardBox.width / 2, cardBox.y + cardBox.height / 2);+ await page.mouse.down();+ await page.mouse.move(columnBox.x + columnBox.width / 2, columnBox.y + Math.max(88, columnBox.height / 2), { steps: 25 });+ await page.mouse.up();++ try {+ await expect(page.getByRole("dialog")).toBeVisible({ timeout: 3_000 });+ return true;+ } catch {+ return false;+ }+}++function reviewQueueRow(page: Page, title: string): Locator {+ return page.getByRole("link").filter({ hasText: title }).first();+}++test.describe("Pipelines tutorial UI flow", () => {+ test.setTimeout(240_000);++ test("covers agent fan-out, drift acknowledgement gates, child-terminal gates, and stale approvals", async () => {+ const board = await pwRequest.newContext({ baseURL: BASE_URL });+ const company = await createCompany(board);+ const pipeline = await createPrimitivePipeline(board, company.id);+ const key = await createPipelineWriterAgentKey(board, company.id);+ const agentApi = await pwRequest.newContext({+ baseURL: BASE_URL,+ extraHTTPHeaders: {+ Authorization: `Bearer ${key.token}`,+ "X-Paperclip-Run-Id": key.runId,+ },+ });++ const parent = await createItem(board, pipeline.id, {+ caseKey: "fanout-parent",+ title: "Fan-out parent",+ stageKey: "fanout",+ fields: { expectedChildren: 2, release: "v1" },+ });++ const childA = await createItem(agentApi, pipeline.id, {+ caseKey: "asset-a",+ title: "Asset A",+ stageKey: "dependent_work",+ parentCaseId: parent.id,+ requestKey: "fanout:asset-a",+ fields: { asset: "hero", briefedFromVersion: parent.version },+ });+ expect(childA.parentCaseVersion).toBe(parent.version);+ expect(childA.requestKey).toBe("fanout:asset-a");++ const retryResponse = await agentApi.post(`/api/pipelines/${pipeline.id}/cases`, {+ data: {+ caseKey: "asset-a-retry",+ title: "Duplicate Asset A",+ stageKey: "dependent_work",+ parentCaseId: parent.id,+ requestKey: "fanout:asset-a",+ fields: { asset: "changed" },+ },+ });+ await expectOk(retryResponse, "retry request-key child create");+ const retry = await retryResponse.json() as { case: CaseSummary; created: boolean };+ expect(retry.created).toBe(false);+ expect(retry.case.id).toBe(childA.id);++ const childB = await createItem(agentApi, pipeline.id, {+ caseKey: "asset-b",+ title: "Asset B",+ stageKey: "dependent_work",+ parentCaseId: parent.id,+ requestKey: "fanout:asset-b",+ blockedByCaseIds: [childA.id],+ fields: { asset: "social", briefedFromVersion: parent.version },+ });+ const blockedDetail = await getItem(board, childB.id);+ expect(blockedDetail.blockers?.map((blocker) => blocker.blockedByCaseId)).toContain(childA.id);++ await expectError(+ await board.post(`/api/cases/${parent.id}/transition`, {+ data: { toStageKey: "done", expectedVersion: parent.version },+ }),+ "parent children-terminal gate",+ 409,+ "children_not_terminal",+ /Asset A/,+ );++ await expectError(+ await agentApi.post(`/api/cases/${childB.id}/transition`, {+ data: { toStageKey: "approved", expectedVersion: childB.version },+ }),+ "blocked sibling sequencing",+ 409,+ "blocked",+ );++ const changedA = await board.patch(`/api/cases/${childA.id}`, {+ data: {+ expectedVersion: childA.version,+ fields: { asset: "hero", briefedFromVersion: parent.version, materialChange: "new art direction" },+ },+ });+ await expectOk(changedA, "materially edit upstream child");+ const editedA = await changedA.json() as CaseSummary;++ await moveItem(agentApi, childA.id, "done");+ await expectError(+ await agentApi.post(`/api/cases/${childB.id}/transition`, {+ data: { toStageKey: "review", expectedVersion: childB.version },+ }),+ "unacknowledged drift gate",+ 409,+ "unresolved_drift",+ /not acknowledged/,+ );++ const ackResponse = await board.post(`/api/cases/${childB.id}/acknowledge-drift`, {+ data: { expectedVersion: childB.version },+ });+ await expectOk(ackResponse, "acknowledge drift");+ expect((await ackResponse.json() as { acknowledged: boolean }).acknowledged).toBe(true);+ await moveItem(agentApi, childB.id, "done");++ const refreshedParent = await getItem(board, parent.id);+ expect(refreshedParent.case.childCount).toBe(2);+ expect(refreshedParent.case.terminalChildCount).toBe(2);+ await moveItem(board, parent.id, "done");++ const reviewCase = await createItem(board, pipeline.id, {+ caseKey: "review-pinned",+ title: "Revision-pinned review",+ stageKey: "review",+ fields: { revision: "first" },+ });+ const approval = await board.post(`/api/cases/${reviewCase.id}/review`, {+ data: { decision: "approve", expectedVersion: reviewCase.version },+ });+ await expectOk(approval, "approve review case");+ const approved = await approval.json() as { case: CaseSummary };++ const changedAfterApproval = await board.patch(`/api/cases/${reviewCase.id}`, {+ data: { expectedVersion: approved.case.version, fields: { revision: "materially changed" } },+ });+ await expectOk(changedAfterApproval, "edit after review approval");+ const changedReview = await changedAfterApproval.json() as CaseSummary;++ await expectError(+ await board.post(`/api/cases/${reviewCase.id}/transition`, {+ data: { toStageKey: "done", expectedVersion: changedReview.version },+ }),+ "stale approval publish gate",+ 409,+ "review_outdated",+ /changed since review approval/,+ );+ await moveItem(board, reviewCase.id, "review");+ const rereviewVersion = await getItemVersion(board, reviewCase.id);+ const rereview = await board.post(`/api/cases/${reviewCase.id}/review`, {+ data: { decision: "approve", expectedVersion: rereviewVersion },+ });+ await expectOk(rereview, "approve rereviewed case");+ const rereviewed = await rereview.json() as { case: CaseSummary };+ await moveItem(board, reviewCase.id, "done");++ const finalEvents = await board.get(`/api/cases/${childB.id}/events`);+ await expectOk(finalEvents, "child drift events");+ const eventTypes = ((await finalEvents.json()) as { items: Array<{ type: string }> }).items.map((event) => event.type);+ expect(eventTypes).toContain("upstream_drift");+ expect(eventTypes).toContain("drift_acknowledged");+ expect(editedA.version).toBeGreaterThan(childA.version);+ expect(rereviewed.case.version).toBeGreaterThan(changedReview.version);++ await agentApi.dispose();+ await board.dispose();+ });++ test("walks setup, intake, board moves, item detail, review queue, and learnings", async ({ page }) => {+ const board = await pwRequest.newContext({ baseURL: BASE_URL });+ const company = await createCompany(board);+ await createCompanyAgent(board, company.id, {+ name: "Pipeline Writer",+ role: "engineer",+ title: "Pipeline Writer",+ capabilities: "Runs pipeline drafting automation during e2e coverage.",+ });+ const pipeline = await createPipeline(board, company.id);+ await expectOk(+ await board.patch("/api/instance/settings/experimental", { data: { enablePipelines: true } }),+ "enable pipelines experimental flag",+ );++ try {+ await page.goto("/");+ await page.evaluate((companyId) => {+ window.localStorage.setItem("paperclip.selectedCompanyId", companyId);+ }, company.id);+ const companyPath = `/${company.issuePrefix}`;++ await page.goto(`${companyPath}/pipelines/${pipeline.id}/settings`);+ await expect(page.getByLabel("Pipeline name")).toHaveValue("Content production");++ await page.getByRole("button", { name: "Pick agent" }).click();+ await page.getByPlaceholder("Search agents...").fill("Pipeline Writer");+ await page.getByRole("button", { name: "Pipeline Writer", exact: true }).click();++ await page.getByLabel("Issue title template").fill("{{content_type}} draft");+ const contentTypeVariable = page+ .getByText("{{content_type}}", { exact: true })+ .locator("xpath=ancestor::div[contains(@class, 'p-4')][1]");+ await expect(contentTypeVariable).toBeVisible();+ await contentTypeVariable.locator("input").first().fill("Content type");+ await contentTypeVariable.getByRole("combobox").first().click();+ await page.getByRole("option", { name: "select" }).click();+ await contentTypeVariable.locator("input:not([type='checkbox'])").nth(1).fill("Blog post, Changelog entry, Launch tweet");+ await page.getByRole("button", { name: "Save stage" }).click();+ await expect(page.getByText("Stage saved").first()).toBeVisible();++ await expectOk(+ await board.post(`/api/pipelines/${pipeline.id}/stages`, {+ data: {+ key: "assets",+ name: "Assets",+ kind: "review",+ position: 1,+ config: {+ variables: [],+ requireApproval: true,+ approver: { kind: "any_human" },+ approveToStageKey: "published",+ rejectToStageKey: "dropped",+ requestChangesToStageKey: "drafting",+ },+ },+ }),+ "create assets review stage",+ );+ await expectOk(+ await board.put(`/api/pipelines/${pipeline.id}/transitions`, {+ data: {+ transitions: [+ { fromStageKey: "drafting", toStageKey: "assets" },+ { fromStageKey: "assets", toStageKey: "published" },+ { fromStageKey: "assets", toStageKey: "dropped" },+ { fromStageKey: "assets", toStageKey: "drafting" },+ ],+ },+ }),+ "configure tutorial stage transitions",+ );+ await page.reload();+ await expect(page.getByRole("button", { name: /^Assets/ }).first()).toBeVisible();+ await expectProsumerVocabulary(page);++ const configured = await getPipeline(board, pipeline.id);+ const assets = configured.stages.find((stage) => stage.name === "Assets");+ const published = configured.stages.find((stage) => stage.name === "Published");+ expect(assets?.kind).toBe("review");+ expect(published).toBeTruthy();++ await page.goto(`${companyPath}/pipelines/${pipeline.id}`);+ await page.getByRole("link", { name: "Add items" }).click();+ await expect(page.getByRole("heading", { name: "Build your list, then submit it all at once" }).first()).toBeVisible();++ const itemPlans = [+ { title: "Launch blog post", contentType: "Blog post" },+ { title: "Changelog entry", contentType: "Changelog entry" },+ { title: "Launch tweet", contentType: "Launch tweet" },+ ];+ for (const [index, plan] of itemPlans.entries()) {+ if (index > 0) await page.getByRole("button", { name: "Add another item" }).click();+ const row = page.locator("section").filter({ hasText: `Item ${index + 1}` }).first();+ if (index > 0) await row.getByRole("button", { name: "Expand item" }).click();+ await row.getByLabel("Name").fill(plan.title);+ await row.getByRole("combobox").click();+ await page.getByRole("option", { name: plan.contentType }).click();+ }+ await expect(page.getByRole("button", { name: "Submit 3 items" })).toBeEnabled();+ await page.getByRole("button", { name: "Submit 3 items" }).click();++ const draftingColumn = page.getByLabel("Drafting column");+ await expect(draftingColumn.getByText("Launch blog post")).toBeVisible();+ await expect(draftingColumn.getByText("Changelog entry")).toBeVisible();+ await expect(draftingColumn.getByText("Launch tweet")).toBeVisible();+ await expectProsumerVocabulary(page);++ const items = await listItems(board, pipeline.id);+ const blog = items.find((row) => row.case.title === "Launch blog post")?.case;+ const changelog = items.find((row) => row.case.title === "Changelog entry")?.case;+ const tweet = items.find((row) => row.case.title === "Launch tweet")?.case;+ expect(blog).toBeTruthy();+ expect(changelog).toBeTruthy();+ expect(tweet).toBeTruthy();++ const blogDragged = await dragCardToColumn(page, "Launch blog post", "Drafting", "Assets");+ if (blogDragged) {+ await expect(page.getByRole("heading", { name: "Move Launch blog post?" })).toBeVisible();+ await page.getByRole("button", { name: "Move it" }).click();+ } else {+ await moveItem(board, blog!.id, assets!.key);+ await page.reload();+ }+ await expect(page.getByLabel("Assets column").getByText("Launch blog post")).toBeVisible();++ await moveItem(board, changelog!.id, assets!.key);+ await page.reload();+ await expect(page.getByLabel("Assets column").getByText("Changelog entry")).toBeVisible();++ const tweetDragged = await dragCardToColumn(page, "Launch tweet", "Drafting", "Published");+ const overrideReason = "Tweet can skip review because the blog post already covers the announcement.";+ if (tweetDragged) {+ await expect(page.getByRole("heading", { name: "This skips the normal flow" })).toBeVisible();+ await page.getByLabel("Reason").fill(overrideReason);+ await expect(page.getByRole("button", { name: "Override and move" })).toBeEnabled();+ await page.getByRole("button", { name: "Override and move" }).click();+ } else {+ await moveItem(board, tweet!.id, published!.key, { reason: overrideReason, force: true });+ await page.reload();+ }+ await expect(page.getByLabel("Published column").getByText("Launch tweet")).toBeVisible();+ await expectProsumerVocabulary(page);++ const root = await createItem(board, pipeline.id, {+ title: "Pipeline primitives launch",+ stageKey: "drafting",+ fields: { content_type: "Blog post" },+ });+ await createItem(board, pipeline.id, {+ title: "Launch package draft",+ stageKey: "drafting",+ parentCaseId: root.id,+ fields: { content_type: "Blog post" },+ });+ await createItem(board, pipeline.id, {+ title: "Launch package changelog",+ stageKey: "drafting",+ parentCaseId: root.id,+ fields: { content_type: "Changelog entry" },+ });+ await suggestMove(board, root.id, assets!.key, "Draft is ready for the next review.");++ await page.goto(`${companyPath}/pipelines/${pipeline.id}/items/${root.id}`);+ await expect(page.getByRole("heading", { name: "Pipeline primitives launch" }).first()).toBeVisible();+ await expect(page.getByRole("heading", { name: "Ready to move to Assets?" })).toBeVisible();+ await expect(page.getByText("Draft is ready for the next review.")).toBeVisible();+ await expect(page.getByRole("heading", { name: "Built from 2 items" })).toBeVisible();+ await expect(page.getByText("Launch package draft")).toBeVisible();+ await expect(page.getByText("Launch package changelog")).toBeVisible();+ await expectProsumerVocabulary(page);++ await page.getByRole("button", { name: "Approve" }).click();+ await expect(page.getByText("Move approved")).toBeVisible();+ await expect(page.getByRole("heading", { name: "Ready to move to Assets?" })).toBeHidden();++ await page.goto(`${companyPath}/review-queue`);+ await expect(page.getByRole("heading", { name: "Review queue" }).first()).toBeVisible();+ await expect(page.getByText("Needs your attention")).toBeVisible();+ await expect(page.getByText("Final calls")).toBeVisible();++ const blogRow = reviewQueueRow(page, "Launch blog post");+ await expect(blogRow).toBeVisible();+ await blogRow.getByRole("button", { name: "Approve", exact: true }).click();+ await expect(blogRow).toBeHidden();++ const changelogRow = reviewQueueRow(page, "Changelog entry");+ await expect(changelogRow).toBeVisible();+ await changelogRow.getByRole("button", { name: "Request changes" }).click();+ const decisionDialog = page.getByRole("dialog");+ await expect(decisionDialog).toBeVisible();+ await decisionDialog.getByLabel("Note").fill("Tighten the framing before publishing.");+ await decisionDialog.getByRole("button", { name: "Request changes" }).click();+ await expect(changelogRow).toBeHidden();+ await expectProsumerVocabulary(page);++ await expect.poll(async () => {+ const refreshed = await listItems(board, pipeline.id);+ const approved = refreshed.find((row) => row.case.title === "Launch blog post");+ const sentBack = refreshed.find((row) => row.case.title === "Changelog entry");+ return {+ approvedStage: approved?.case.stageId,+ sentBackStage: sentBack?.case.stageId,+ };+ }).toEqual({+ approvedStage: published!.id,+ sentBackStage: configured.stages.find((stage) => stage.key === "drafting")!.id,+ });++ await page.goto(`${companyPath}/learnings`);+ await expect(page.getByRole("heading", { name: "Learnings" }).first()).toBeVisible();+ await expect(page.getByText("Tighten the framing before publishing.")).toBeVisible();+ await expect(page.getByText(overrideReason)).toBeVisible();+ await expectProsumerVocabulary(page);+ } finally {+ await expectOk(+ await board.patch("/api/instance/settings/experimental", { data: { enablePipelines: false } }),+ "disable pipelines experimental flag",+ );+ await board.dispose();+ }+ });+});diff --git a/tests/e2e/playwright.config.ts b/tests/e2e/playwright.config.tsindex bece08e6b5..e42a77a1f8 100644--- a/tests/e2e/playwright.config.ts+++ b/tests/e2e/playwright.config.ts@@ -8,8 +8,14 @@ import { defineConfig } from "@playwright/test";const PORT = Number(process.env.PAPERCLIP_E2E_PORT ?? 3199);const BASE_URL = `http://127.0.0.1:${PORT}`;const PAPERCLIP_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "paperclip-e2e-home-"));+const PAPERCLIP_CONFIG = path.join(PAPERCLIP_HOME, "instances", "playwright-e2e", "config.json");+const PAPERCLIP_AGENT_JWT_SECRET = process.env.PAPERCLIP_AGENT_JWT_SECRET ?? "playwright-e2e-agent-jwt-secret";const PLAYWRIGHT_CHANNEL = process.env.PAPERCLIP_PLAYWRIGHT_CHANNEL;+process.env.PAPERCLIP_HOME = PAPERCLIP_HOME;+process.env.PAPERCLIP_CONFIG = PAPERCLIP_CONFIG;+process.env.PAPERCLIP_AGENT_JWT_SECRET = PAPERCLIP_AGENT_JWT_SECRET;+export default defineConfig({testDir: ".",testMatch: "**/*.spec.ts",@@ -53,6 +59,8 @@ export default defineConfig({...process.env,PORT: String(PORT),PAPERCLIP_HOME,+ PAPERCLIP_CONFIG,+ PAPERCLIP_AGENT_JWT_SECRET,PAPERCLIP_INSTANCE_ID: "playwright-e2e",PAPERCLIP_BIND: "loopback",PAPERCLIP_DEPLOYMENT_MODE: "local_trusted",