Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

fix(embed): approval links use the platform's embed subdomain (GIT-2025) (#17153)

lina-alomarif81ae8e341e8
diff --git a/packages/core/execution/package.json b/packages/core/execution/package.json
index 923e7cb07e5..013fe38422d 100644
--- a/packages/core/execution/package.json
+++ b/packages/core/execution/package.json
@@ -1,6 +1,6 @@
{
"name": "@activepieces/core-execution",
- "version": "0.29.0",
+ "version": "0.29.1",
"type": "commonjs",
"main": "./dist/src/index.js",
"scripts": {
diff --git a/packages/core/execution/src/lib/flow-run/waitpoint/index.ts b/packages/core/execution/src/lib/flow-run/waitpoint/index.ts
index a08d71f58d5..53c62999b78 100644
--- a/packages/core/execution/src/lib/flow-run/waitpoint/index.ts
+++ b/packages/core/execution/src/lib/flow-run/waitpoint/index.ts
@@ -87,6 +87,7 @@ export type BarrierCreatedState = z.infer<typeof BarrierCreatedState>
export const CreateWaitpointResponse = z.object({
id: z.string(),
resumeUrl: z.string(),
+ publicResumeUrl: z.string(),
barrier: BarrierCreatedState.optional(),
})
export type CreateWaitpointResponse = z.infer<typeof CreateWaitpointResponse>
diff --git a/packages/pieces/community/discord/package.json b/packages/pieces/community/discord/package.json
index 4c910fb771e..5a4250a5d3e 100644
--- a/packages/pieces/community/discord/package.json
+++ b/packages/pieces/community/discord/package.json
@@ -1,6 +1,6 @@
{
"name": "@activepieces/piece-discord",
- "version": "0.8.2",
+ "version": "0.8.3",
"main": "./dist/src/index.js",
"types": "./dist/src/index.d.ts",
"scripts": {
diff --git a/packages/pieces/community/discord/src/lib/actions/send-approval-message.ts b/packages/pieces/community/discord/src/lib/actions/send-approval-message.ts
index 67b97b8f3e9..f272690f609 100644
--- a/packages/pieces/community/discord/src/lib/actions/send-approval-message.ts
+++ b/packages/pieces/community/discord/src/lib/actions/send-approval-message.ts
@@ -49,7 +49,7 @@ export const discordSendApprovalMessage = createAction({
type: 'WEBHOOK',
});
- const confirmationLink = `${waitpoint.resumeUrl}/confirm`;
+ const confirmationLink = `${waitpoint.publicResumeUrl ?? waitpoint.resumeUrl}/confirm`;
const request: HttpRequest = {
method: HttpMethod.POST,
diff --git a/packages/pieces/community/discord/test/send-approval-message.test.ts b/packages/pieces/community/discord/test/send-approval-message.test.ts
new file mode 100644
index 00000000000..b822ebad48f
--- /dev/null
+++ b/packages/pieces/community/discord/test/send-approval-message.test.ts
@@ -0,0 +1,51 @@
+/// <reference types="vitest/globals" />
+
+import { createMockActionContext } from '@activepieces/pieces-framework';
+
+const { sendRequestMock } = vi.hoisted(() => ({ sendRequestMock: vi.fn().mockResolvedValue({ status: 200, body: {} }) }));
+
+vi.mock('@activepieces/pieces-common', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@activepieces/pieces-common')>();
+ return { ...actual, httpClient: { sendRequest: sendRequestMock } };
+});
+
+import { discordSendApprovalMessage } from '../src/lib/actions/send-approval-message';
+
+const RESUME_URL = 'https://cloud.activepieces.com/api/v1/flow-runs/run-1/waitpoints/wp-1';
+const PUBLIC_RESUME_URL = 'https://embed.example.com/api/v1/flow-runs/run-1/waitpoints/wp-1';
+
+function buildContext({ publicResumeUrl }: { publicResumeUrl?: string }) {
+ const context = createMockActionContext({
+ propsValue: { channel: 'channel-1', content: 'Please approve' },
+ });
+ return {
+ ...context,
+ auth: { secret_text: 'bot-token' },
+ run: {
+ ...context.run,
+ createWaitpoint: async () => ({ id: 'wp-1', resumeUrl: RESUME_URL, publicResumeUrl, buildResumeUrl: () => RESUME_URL }),
+ waitForWaitpoint: () => undefined,
+ },
+ };
+}
+
+function sentButtonUrl(): string {
+ expect(sendRequestMock).toHaveBeenCalledTimes(1);
+ return sendRequestMock.mock.calls[0][0].body.components[0].components[0].url;
+}
+
+describe('discord send approval message', () => {
+ beforeEach(() => {
+ sendRequestMock.mockClear();
+ });
+
+ test('links the button to the public resume url', async () => {
+ await discordSendApprovalMessage.run(buildContext({ publicResumeUrl: PUBLIC_RESUME_URL }));
+ expect(sentButtonUrl()).toBe(`${PUBLIC_RESUME_URL}/confirm`);
+ });
+
+ test('falls back to the resume url when the server sends no public one', async () => {
+ await discordSendApprovalMessage.run(buildContext({}));
+ expect(sentButtonUrl()).toBe(`${RESUME_URL}/confirm`);
+ });
+});
diff --git a/packages/pieces/community/gmail/package.json b/packages/pieces/community/gmail/package.json
index 6df78c7fbb3..acd903c7907 100644
--- a/packages/pieces/community/gmail/package.json
+++ b/packages/pieces/community/gmail/package.json
@@ -1,6 +1,6 @@
{
"name": "@activepieces/piece-gmail",
- "version": "0.18.4",
+ "version": "0.18.5",
"main": "./dist/src/index.js",
"types": "./dist/src/index.d.ts",
"dependencies": {
diff --git a/packages/pieces/community/gmail/src/lib/actions/request-approval-in-email.ts b/packages/pieces/community/gmail/src/lib/actions/request-approval-in-email.ts
index b959d2caf98..f44af0e72a6 100644
--- a/packages/pieces/community/gmail/src/lib/actions/request-approval-in-email.ts
+++ b/packages/pieces/community/gmail/src/lib/actions/request-approval-in-email.ts
@@ -146,7 +146,9 @@ export const requestApprovalInEmail = createAction({
type: 'WEBHOOK',
});
- const confirmationLink = `${waitpoint.resumeUrl}/confirm`;
+ const confirmationLink = `${
+ waitpoint.publicResumeUrl ?? waitpoint.resumeUrl
+ }/confirm`;
const bodyHtml =
context.propsValue.body_type === 'plain_text'
diff --git a/packages/pieces/community/gmail/test/request-approval-body.test.ts b/packages/pieces/community/gmail/test/request-approval-body.test.ts
index 06efcc65bfb..68b71edbbc5 100644
--- a/packages/pieces/community/gmail/test/request-approval-body.test.ts
+++ b/packages/pieces/community/gmail/test/request-approval-body.test.ts
@@ -22,10 +22,11 @@ vi.mock('../src/lib/auth', () => ({
import { requestApprovalInEmail } from '../src/lib/actions/request-approval-in-email';
const RESUME_URL = 'https://ap.test/resume';
+const PUBLIC_RESUME_URL = 'https://embed.example.com/resume';
type ApprovalContext = Parameters<typeof requestApprovalInEmail.run>[0];
-function buildContext(propsValue: Record<string, unknown>): ApprovalContext {
+function buildContext(propsValue: Record<string, unknown>, publicResumeUrl?: string): ApprovalContext {
const context = createMockActionContext({
propsValue: {
receiver: '[email protected]',
@@ -38,7 +39,7 @@ function buildContext(propsValue: Record<string, unknown>): ApprovalContext {
...context,
run: {
...context.run,
- createWaitpoint: async () => ({ id: 'waitpoint-1', resumeUrl: RESUME_URL }),
+ createWaitpoint: async () => ({ id: 'waitpoint-1', resumeUrl: RESUME_URL, publicResumeUrl }),
waitForWaitpoint: () => undefined,
},
} as unknown as ApprovalContext;
@@ -78,4 +79,14 @@ describe('request approval in email — body type', () => {
expect(html).toContain('<p><strong>bold</strong></p>');
expect(html).toContain(`${RESUME_URL}/confirm`);
});
+
+ test('the email links to the public resume url when the server sends one', async () => {
+ await requestApprovalInEmail.run(
+ buildContext({ body_type: 'plain_text', body: 'Please approve' }, PUBLIC_RESUME_URL)
+ );
+
+ const html = await sentHtml();
+ expect(html).toContain(`${PUBLIC_RESUME_URL}/confirm`);
+ expect(html).not.toContain(`${RESUME_URL}/confirm`);
+ });
});
diff --git a/packages/pieces/community/microsoft-outlook/package.json b/packages/pieces/community/microsoft-outlook/package.json
index 951932017ec..3340d7996e8 100644
--- a/packages/pieces/community/microsoft-outlook/package.json
+++ b/packages/pieces/community/microsoft-outlook/package.json
@@ -1,6 +1,6 @@
{
"name": "@activepieces/piece-microsoft-outlook",
- "version": "0.7.4",
+ "version": "0.7.5",
"main": "./dist/src/index.js",
"types": "./dist/src/index.d.ts",
"dependencies": {
diff --git a/packages/pieces/community/microsoft-outlook/src/lib/actions/request-approval-send-email.ts b/packages/pieces/community/microsoft-outlook/src/lib/actions/request-approval-send-email.ts
index 2f0aac0b6ff..4bef0604696 100644
--- a/packages/pieces/community/microsoft-outlook/src/lib/actions/request-approval-send-email.ts
+++ b/packages/pieces/community/microsoft-outlook/src/lib/actions/request-approval-send-email.ts
@@ -51,7 +51,7 @@ export const requestApprovalInMail = createAction({
const waitpoint = await context.run.createWaitpoint({
type: 'WEBHOOK',
});
- const confirmationLink = `${waitpoint.resumeUrl}/confirm`;
+ const confirmationLink = `${waitpoint.publicResumeUrl ?? waitpoint.resumeUrl}/confirm`;
const htmlBody = `
<div>
diff --git a/packages/pieces/community/microsoft-outlook/test/request-approval-send-email.test.ts b/packages/pieces/community/microsoft-outlook/test/request-approval-send-email.test.ts
new file mode 100644
index 00000000000..f069735d67f
--- /dev/null
+++ b/packages/pieces/community/microsoft-outlook/test/request-approval-send-email.test.ts
@@ -0,0 +1,53 @@
+/// <reference types="vitest/globals" />
+
+import { createMockActionContext } from '@activepieces/pieces-framework';
+
+const postMock = vi.fn().mockResolvedValue({});
+
+vi.mock('../src/lib/common/client', () => ({
+ outlookCommon: {
+ createClient: () => ({ api: () => ({ post: postMock }) }),
+ mailboxPrefix: () => '/me',
+ },
+}));
+
+import { requestApprovalInMail } from '../src/lib/actions/request-approval-send-email';
+
+const RESUME_URL = 'https://cloud.activepieces.com/api/v1/flow-runs/run-1/waitpoints/wp-1';
+const PUBLIC_RESUME_URL = 'https://embed.example.com/api/v1/flow-runs/run-1/waitpoints/wp-1';
+
+function buildContext({ publicResumeUrl }: { publicResumeUrl?: string }) {
+ const context = createMockActionContext({
+ propsValue: { recipients: '[email protected]', subject: 'Please approve', body: 'Order A-1' },
+ });
+ return {
+ ...context,
+ auth: { access_token: 'access-token' },
+ run: {
+ ...context.run,
+ createWaitpoint: async () => ({ id: 'wp-1', resumeUrl: RESUME_URL, publicResumeUrl, buildResumeUrl: () => RESUME_URL }),
+ waitForWaitpoint: () => undefined,
+ },
+ };
+}
+
+function sentHtml(): string {
+ expect(postMock).toHaveBeenCalledTimes(1);
+ return postMock.mock.calls[0][0].message.body.content;
+}
+
+describe('outlook request approval email', () => {
+ beforeEach(() => {
+ postMock.mockClear();
+ });
+
+ test('links the email button to the public resume url', async () => {
+ await requestApprovalInMail.run(buildContext({ publicResumeUrl: PUBLIC_RESUME_URL }));
+ expect(sentHtml()).toContain(`href="${PUBLIC_RESUME_URL}/confirm"`);
+ });
+
+ test('falls back to the resume url when the server sends no public one', async () => {
+ await requestApprovalInMail.run(buildContext({}));
+ expect(sentHtml()).toContain(`href="${RESUME_URL}/confirm"`);
+ });
+});
diff --git a/packages/pieces/community/microsoft-teams/package.json b/packages/pieces/community/microsoft-teams/package.json
index 578aba4d99a..bb34a186123 100644
--- a/packages/pieces/community/microsoft-teams/package.json
+++ b/packages/pieces/community/microsoft-teams/package.json
@@ -1,6 +1,6 @@
{
"name": "@activepieces/piece-microsoft-teams",
- "version": "0.8.0",
+ "version": "0.8.1",
"main": "./dist/src/index.js",
"types": "./dist/src/index.d.ts",
"dependencies": {
diff --git a/packages/pieces/community/microsoft-teams/src/lib/actions/request-approval-channel-message.ts b/packages/pieces/community/microsoft-teams/src/lib/actions/request-approval-channel-message.ts
index 3704f87f175..cc2b7422914 100644
--- a/packages/pieces/community/microsoft-teams/src/lib/actions/request-approval-channel-message.ts
+++ b/packages/pieces/community/microsoft-teams/src/lib/actions/request-approval-channel-message.ts
@@ -41,7 +41,7 @@ export const requestApprovalInChannel = createAction({
const waitpoint = await context.run.createWaitpoint({
type: 'WEBHOOK',
});
- const confirmationLink = `${waitpoint.resumeUrl}/confirm`;
+ const confirmationLink = `${waitpoint.publicResumeUrl ?? waitpoint.resumeUrl}/confirm`;
const chatMessage: ChatMessage = {
body: {
diff --git a/packages/pieces/community/microsoft-teams/src/lib/actions/request-approval-direct-message.ts b/packages/pieces/community/microsoft-teams/src/lib/actions/request-approval-direct-message.ts
index b5326e6593d..2c798046880 100644
--- a/packages/pieces/community/microsoft-teams/src/lib/actions/request-approval-direct-message.ts
+++ b/packages/pieces/community/microsoft-teams/src/lib/actions/request-approval-direct-message.ts
@@ -38,7 +38,7 @@ export const requestApprovalDirectMessage = createAction({
const waitpoint = await context.run.createWaitpoint({
type: 'WEBHOOK',
});
- const confirmationLink = `${waitpoint.resumeUrl}/confirm`;
+ const confirmationLink = `${waitpoint.publicResumeUrl ?? waitpoint.resumeUrl}/confirm`;
const chatMessage = {
body: {
diff --git a/packages/pieces/community/telegram-bot/package.json b/packages/pieces/community/telegram-bot/package.json
index 9ec1a6b6257..08f84b4cf03 100644
--- a/packages/pieces/community/telegram-bot/package.json
+++ b/packages/pieces/community/telegram-bot/package.json
@@ -1,6 +1,6 @@
{
"name": "@activepieces/piece-telegram-bot",
- "version": "0.9.1",
+ "version": "0.9.2",
"main": "./dist/src/index.js",
"types": "./dist/src/index.d.ts",
"scripts": {
diff --git a/packages/pieces/community/telegram-bot/src/lib/action/request-approval-message.test.ts b/packages/pieces/community/telegram-bot/src/lib/action/request-approval-message.test.ts
new file mode 100644
index 00000000000..a66527eb2e3
--- /dev/null
+++ b/packages/pieces/community/telegram-bot/src/lib/action/request-approval-message.test.ts
@@ -0,0 +1,52 @@
+/// <reference types="vitest/globals" />
+
+import { createMockActionContext } from '@activepieces/pieces-framework';
+
+const { sendRequestMock } = vi.hoisted(() => ({ sendRequestMock: vi.fn().mockResolvedValue({ status: 200, body: { ok: true, result: { message_id: 7 } } }) }));
+
+vi.mock('@activepieces/pieces-common', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@activepieces/pieces-common')>();
+ return { ...actual, httpClient: { sendRequest: sendRequestMock } };
+});
+
+import '../../index';
+import { telegramRequestApprovalMessageAction } from './request-approval-message';
+
+const RESUME_URL = 'https://cloud.activepieces.com/api/v1/flow-runs/run-1/waitpoints/wp-1';
+const PUBLIC_RESUME_URL = 'https://embed.example.com/api/v1/flow-runs/run-1/waitpoints/wp-1';
+
+function buildContext({ publicResumeUrl }: { publicResumeUrl?: string }) {
+ const context = createMockActionContext({
+ propsValue: { chat_id: '12345', message: 'Please approve' },
+ });
+ return {
+ ...context,
+ auth: { secret_text: 'bot-token' },
+ run: {
+ ...context.run,
+ createWaitpoint: async () => ({ id: 'wp-1', resumeUrl: RESUME_URL, publicResumeUrl, buildResumeUrl: () => RESUME_URL }),
+ waitForWaitpoint: () => undefined,
+ },
+ };
+}
+
+function sentButtonUrl(): string {
+ expect(sendRequestMock).toHaveBeenCalledTimes(1);
+ return sendRequestMock.mock.calls[0][0].body.reply_markup.inline_keyboard[0][0].url;
+}
+
+describe('telegram request approval message', () => {
+ beforeEach(() => {
+ sendRequestMock.mockClear();
+ });
+
+ test('links the button to the public resume url and keeps the chat id', async () => {
+ await telegramRequestApprovalMessageAction.run(buildContext({ publicResumeUrl: PUBLIC_RESUME_URL }));
+ expect(sentButtonUrl()).toBe(`${PUBLIC_RESUME_URL}/confirm?chat_id=12345`);
+ });
+
+ test('falls back to the resume url when the server sends no public one', async () => {
+ await telegramRequestApprovalMessageAction.run(buildContext({}));
+ expect(sentButtonUrl()).toBe(`${RESUME_URL}/confirm?chat_id=12345`);
+ });
+});
diff --git a/packages/pieces/community/telegram-bot/src/lib/action/request-approval-message.ts b/packages/pieces/community/telegram-bot/src/lib/action/request-approval-message.ts
index 32e4ad42d19..b23951b4538 100644
--- a/packages/pieces/community/telegram-bot/src/lib/action/request-approval-message.ts
+++ b/packages/pieces/community/telegram-bot/src/lib/action/request-approval-message.ts
@@ -44,7 +44,7 @@ export const telegramRequestApprovalMessageAction = createAction({
const waitpoint = await context.run.createWaitpoint({
type: 'WEBHOOK',
});
- const confirmationLink = `${waitpoint.resumeUrl}/confirm?chat_id=${encodeURIComponent(chat_id)}`;
+ const confirmationLink = `${waitpoint.publicResumeUrl ?? waitpoint.resumeUrl}/confirm?chat_id=${encodeURIComponent(chat_id)}`;
// Send message with a single button opening the confirmation page (the recipient
// chooses Approve/Disapprove there). A single link keeps the message-preview
diff --git a/packages/pieces/core/approval/package.json b/packages/pieces/core/approval/package.json
index 56521287ae2..11ac8c54e55 100644
--- a/packages/pieces/core/approval/package.json
+++ b/packages/pieces/core/approval/package.json
@@ -1,6 +1,6 @@
{
"name": "@activepieces/piece-approval",
- "version": "0.2.0",
+ "version": "0.2.1",
"main": "./dist/src/index.js",
"types": "./dist/src/index.d.ts",
"scripts": {
diff --git a/packages/pieces/core/approval/src/lib/actions/create-approval-link.ts b/packages/pieces/core/approval/src/lib/actions/create-approval-link.ts
index 1d7e7baf60b..6da1f3181f8 100644
--- a/packages/pieces/core/approval/src/lib/actions/create-approval-link.ts
+++ b/packages/pieces/core/approval/src/lib/actions/create-approval-link.ts
@@ -30,7 +30,7 @@ export const createApprovalLink = createAction({
const waitpoint = await ctx.run.createWaitpoint({
type: 'WEBHOOK',
});
- const confirmationLink = `${waitpoint.resumeUrl}/confirm`;
+ const confirmationLink = `${waitpoint.publicResumeUrl ?? waitpoint.resumeUrl}/confirm`;
return {
approvalLink: confirmationLink,
disapprovalLink: confirmationLink,
diff --git a/packages/pieces/core/approval/test/create-approval-link.test.ts b/packages/pieces/core/approval/test/create-approval-link.test.ts
index dccb5f4c1d8..7c1108cb480 100644
--- a/packages/pieces/core/approval/test/create-approval-link.test.ts
+++ b/packages/pieces/core/approval/test/create-approval-link.test.ts
@@ -5,6 +5,8 @@ import { createApprovalLink } from '../src/lib/actions/create-approval-link';
const RESUME_URL =
'https://cloud.activepieces.com/api/v1/flow-runs/run-id/waitpoints/wp-id';
+const PUBLIC_RESUME_URL =
+ 'https://embed.example.com/api/v1/flow-runs/run-id/waitpoints/wp-id';
function mockContext() {
const ctx = createMockActionContext({ propsValue: {} });
@@ -29,4 +31,17 @@ describe('createApprovalLink', () => {
expect(result.approvalLink).not.toContain('?action=');
expect(result.disapprovalLink).not.toContain('?action=');
});
+
+ test('links to the public resume url when the server sends one', async () => {
+ const ctx = mockContext();
+ ctx.run.createWaitpoint = async () => ({
+ id: 'wp-id',
+ resumeUrl: RESUME_URL,
+ publicResumeUrl: PUBLIC_RESUME_URL,
+ buildResumeUrl: () => RESUME_URL,
+ });
+ const result = await createApprovalLink.run(ctx);
+ expect(result.approvalLink).toBe(`${PUBLIC_RESUME_URL}/confirm`);
+ expect(result.disapprovalLink).toBe(`${PUBLIC_RESUME_URL}/confirm`);
+ });
});
diff --git a/packages/pieces/framework/src/lib/context/index.ts b/packages/pieces/framework/src/lib/context/index.ts
index 12770382b8c..95980fd4232 100644
--- a/packages/pieces/framework/src/lib/context/index.ts
+++ b/packages/pieces/framework/src/lib/context/index.ts
@@ -202,6 +202,7 @@ export type CreateWaitpointParams = {
export type CreateWaitpointResult = {
id: string;
resumeUrl: string;
+ publicResumeUrl?: string;
buildResumeUrl: (params: { queryParams: Record<string, string>, sync?: boolean }) => string;
};
diff --git a/packages/server/api/src/app/app.ts b/packages/server/api/src/app/app.ts
index 0d6feb9a167..41ba999670d 100644
--- a/packages/server/api/src/app/app.ts
+++ b/packages/server/api/src/app/app.ts
@@ -51,6 +51,7 @@ import { rbacMiddleware } from './ee/authentication/project-role/rbac-middleware
import { authnSsoSamlModule } from './ee/authentication/saml-authn/authn-sso-saml-module'
import { authnSsoSamlService } from './ee/authentication/saml-authn/authn-sso-saml-service'
import { embedSubdomainModule } from './ee/embed-subdomain/embed-subdomain.module'
+import { embedSubdomainService } from './ee/embed-subdomain/embed-subdomain.service'
import { enterpriseFlagsHooks } from './ee/flags/enterprise-flags.hooks'
import { flowApprovalModule } from './ee/flows/flow-approval/flow-approval.module'
import { eeFlowPublishHook } from './ee/flows/flow-approval/flow-publish-hook'
@@ -401,7 +402,10 @@ export const setupApp = async (app: FastifyInstance): Promise<FastifyInstance> =
billingProvider.set(autumnBillingProvider)
await aiUsageJobs.register(app.log)
await app.register(aiUsageModule)
- resumePageHooks.set((log) => ({ getTheme: (params) => appearanceHelper.getTheme({ ...params, log }) }))
+ resumePageHooks.set((log) => ({
+ getTheme: (params) => appearanceHelper.getTheme({ ...params, log }),
+ getPublicApiBaseUrl: (params) => embedSubdomainService(log).getPublicApiBaseUrl(params),
+ }))
verifiedDomainHooks.set(authnSsoSamlService)
flowPublishHooks.set((log) => ({ assertReferencesResolve: assertAgentsResolveInProject, findMissingRequiredActions: (params) => pieceSetRequiredActions(log).findMissing(params) }))
aiUsageHooks.set(agentConversationCreditsHooks)
@@ -448,7 +452,10 @@ export const setupApp = async (app: FastifyInstance): Promise<FastifyInstance> =
billingProvider.set(autumnBillingProvider)
await aiUsageJobs.register(app.log)
await app.register(aiUsageModule)
- resumePageHooks.set((log) => ({ getTheme: (params) => appearanceHelper.getTheme({ ...params, log }) }))
+ resumePageHooks.set((log) => ({
+ getTheme: (params) => appearanceHelper.getTheme({ ...params, log }),
+ getPublicApiBaseUrl: (params) => embedSubdomainService(log).getPublicApiBaseUrl(params),
+ }))
flowPublishHooks.set((log) => ({ assertReferencesResolve: assertAgentsResolveInProject, findMissingRequiredActions: (params) => pieceSetRequiredActions(log).findMissing(params) }))
aiUsageHooks.set(agentConversationCreditsHooks)
eventDestinationHooks.set(eventDestinationEntitlementHooks)
diff --git a/packages/server/api/src/app/ee/embed-subdomain/embed-subdomain.service.ts b/packages/server/api/src/app/ee/embed-subdomain/embed-subdomain.service.ts
index 1bc9ec91ce8..20a532392a6 100644
--- a/packages/server/api/src/app/ee/embed-subdomain/embed-subdomain.service.ts
+++ b/packages/server/api/src/app/ee/embed-subdomain/embed-subdomain.service.ts
@@ -2,6 +2,8 @@ import { ActivepiecesError, apId, ErrorCode, isNil, tryCatch } from '@activepiec
import { EmbedSubdomain, EmbedSubdomainStatus } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { repoFactory } from '../../core/db/repo-factory'
+import { domainHelper } from '../../helper/domain-helper'
+import { networkUtils } from '../../helper/network-utils'
import { cloudflareService } from './cloudflare.service'
import { EmbedSubdomainEntity } from './embed-subdomain.entity'
@@ -104,6 +106,14 @@ export const embedSubdomainService = (log: FastifyBaseLogger) => ({
return `https://${record.hostname}`
},
+ async getPublicApiBaseUrl({ platformId }: { platformId: string }): Promise<string> {
+ const subdomainUrl = await embedSubdomainService(log).getActiveSubdomainUrl({ platformId })
+ if (isNil(subdomainUrl)) {
+ return domainHelper.getPublicApiUrl({ path: '' })
+ }
+ return networkUtils.combineUrl(subdomainUrl, 'api')
+ },
+
async getByHostname({ hostname }: { hostname: string }): Promise<EmbedSubdomain | null> {
return repo().findOneBy({ hostname })
},
diff --git a/packages/server/api/src/app/waitpoints/resume-page-hooks.ts b/packages/server/api/src/app/waitpoints/resume-page-hooks.ts
index 833cb4cb534..1ec17282886 100644
--- a/packages/server/api/src/app/waitpoints/resume-page-hooks.ts
+++ b/packages/server/api/src/app/waitpoints/resume-page-hooks.ts
@@ -1,14 +1,19 @@
import { defaultTheme, generateTheme } from '../flags/theme'
+import { domainHelper } from '../helper/domain-helper'
import { hooksFactory } from '../helper/hooks-factory'
export const resumePageHooks = hooksFactory.create<ResumePageHooks>(() => ({
async getTheme(): Promise<ResumePageTheme> {
return defaultTheme
},
+ async getPublicApiBaseUrl(): Promise<string> {
+ return domainHelper.getPublicApiUrl({ path: '' })
+ },
}))
export type ResumePageTheme = ReturnType<typeof generateTheme>
export type ResumePageHooks = {
getTheme(params: { platformId: string | null }): Promise<ResumePageTheme>
+ getPublicApiBaseUrl(params: { platformId: string }): Promise<string>
}
diff --git a/packages/server/api/src/app/waitpoints/waitpoint-controller.ts b/packages/server/api/src/app/waitpoints/waitpoint-controller.ts
index f6b643ef3ac..380555f02b3 100644
--- a/packages/server/api/src/app/waitpoints/waitpoint-controller.ts
+++ b/packages/server/api/src/app/waitpoints/waitpoint-controller.ts
@@ -4,21 +4,24 @@ import { FastifyPluginAsyncZod } from 'fastify-type-provider-zod'
import { StatusCodes } from 'http-status-codes'
import { securityAccess } from '../core/security/authorization/fastify-security'
import { domainHelper } from '../helper/domain-helper'
-import { projectService } from '../project/project-service'
+import { networkUtils } from '../helper/network-utils'
import { barrierService, CreateBarrierResult } from './barrier-service'
+import { resumePageHooks } from './resume-page-hooks'
import { waitpointService } from './waitpoint-service'
import { WaitpointSignal } from './waitpoint-types'
export const waitpointController: FastifyPluginAsyncZod = async (app) => {
app.post('/', CreateWaitpointParams, async (request, reply) => {
const { flowRunId, projectId, stepName, type, version, resumeDateTime, responseToSend, workerHandlerId, httpRequestId, barrier } = request.body
+ const platformId = request.principal.platform.id
+ const publicApiUrl = await resumePageHooks.get(request.log).getPublicApiBaseUrl({ platformId })
if (type === PauseType.BARRIER) {
assertBarrierCarriesNoDeadline({ resumeDateTime })
const created = await barrierService(request.log).create({
flowRunId,
projectId,
- platformId: await projectService(request.log).getPlatformId(projectId),
+ platformId,
stepName,
version,
responseToSend: responseToSend ?? undefined,
@@ -30,8 +33,8 @@ export const waitpointController: FastifyPluginAsyncZod = async (app) => {
})
return reply.status(StatusCodes.CREATED).send({
id: created.barrier.id,
- resumeUrl: await buildResumeUrl({ flowRunId, waitpointId: created.barrier.id }),
- barrier: await buildBarrierState({ flowRunId, created }),
+ ...await buildResumeUrls({ flowRunId, waitpointId: created.barrier.id, publicApiUrl }),
+ barrier: buildBarrierState({ flowRunId, created, publicApiUrl }),
})
}
@@ -48,30 +51,34 @@ export const waitpointController: FastifyPluginAsyncZod = async (app) => {
})
return reply.status(StatusCodes.CREATED).send({
id: waitpoint.id,
- resumeUrl: await buildResumeUrl({ flowRunId, waitpointId: waitpoint.id }),
+ ...await buildResumeUrls({ flowRunId, waitpointId: waitpoint.id, publicApiUrl }),
})
})
}
-async function buildResumeUrl({ flowRunId, waitpointId }: { flowRunId: string, waitpointId: string }): Promise<string> {
- return domainHelper.getPublicApiUrl({ path: `v1/flow-runs/${flowRunId}/waitpoints/${waitpointId}` })
+async function buildResumeUrls({ flowRunId, waitpointId, publicApiUrl }: BuildResumeUrlsParams): Promise<Pick<CreateWaitpointResponse, 'resumeUrl' | 'publicResumeUrl'>> {
+ const path = `v1/flow-runs/${flowRunId}/waitpoints/${waitpointId}`
+ return {
+ resumeUrl: await domainHelper.getPublicApiUrl({ path }),
+ publicResumeUrl: networkUtils.combineUrl(publicApiUrl, path),
+ }
}
-async function buildBarrierState({ flowRunId, created }: BuildBarrierStateParams): Promise<BarrierCreatedState> {
+function buildBarrierState({ flowRunId, created, publicApiUrl }: BuildBarrierStateParams): BarrierCreatedState {
const inlineable = created.signals.length > 0 && created.signals.length <= MAX_INLINE_BARRIER_SIGNALS && created.signals.every((signal) => isNil(signal.sequence))
const truncatedForSize = created.signals.length > MAX_INLINE_BARRIER_SIGNALS
return {
signalCount: created.signalCount,
batchSize: created.batchSize,
...(truncatedForSize ? { signalsTruncated: true } : {}),
- ...(inlineable ? { signals: await Promise.all(created.signals.map((signal) => toSignalLink({ flowRunId, signal }))) } : {}),
+ ...(inlineable ? { signals: created.signals.map((signal) => toSignalLink({ flowRunId, signal, publicApiUrl })) } : {}),
}
}
-async function toSignalLink({ flowRunId, signal }: { flowRunId: string, signal: WaitpointSignal }): Promise<{ label: string | null, confirmUrl: string }> {
+function toSignalLink({ flowRunId, signal, publicApiUrl }: { flowRunId: string, signal: WaitpointSignal, publicApiUrl: string }): { label: string | null, confirmUrl: string } {
return {
label: signal.label,
- confirmUrl: await domainHelper.getPublicApiUrl({ path: `v1/flow-runs/${flowRunId}/signals/${signal.id}/confirm` }),
+ confirmUrl: networkUtils.combineUrl(publicApiUrl, `v1/flow-runs/${flowRunId}/signals/${signal.id}/confirm`),
}
}
@@ -100,4 +107,11 @@ const CreateWaitpointParams = {
type BuildBarrierStateParams = {
flowRunId: string
created: CreateBarrierResult
+ publicApiUrl: string
+}
+
+type BuildResumeUrlsParams = {
+ flowRunId: string
+ waitpointId: string
+ publicApiUrl: string
}
diff --git a/packages/server/api/test/integration/ce/flows/flow-run/waitpoint.test.ts b/packages/server/api/test/integration/ce/flows/flow-run/waitpoint.test.ts
index 8fbc5b9ed8b..a2bc6935470 100644
--- a/packages/server/api/test/integration/ce/flows/flow-run/waitpoint.test.ts
+++ b/packages/server/api/test/integration/ce/flows/flow-run/waitpoint.test.ts
@@ -1,5 +1,5 @@
import { apId } from '@activepieces/core-utils'
-import { FlowRunStatus, FlowVersionState, PauseType, RunEnvironment } from '@activepieces/shared'
+import { FlowRunStatus, FlowVersionState, PauseType, PrincipalType, RunEnvironment } from '@activepieces/shared'
import { FastifyInstance } from 'fastify'
import { systemJobIds } from '../../../../../src/app/helper/system-jobs/common'
import * as systemJobModule from '../../../../../src/app/helper/system-jobs/system-job'
@@ -7,6 +7,7 @@ import { barrierService } from '../../../../../src/app/waitpoints/barrier-servic
import { handleResumeDelayWaitpoint } from '../../../../../src/app/waitpoints/resume-delay-handler'
import { waitpointService } from '../../../../../src/app/waitpoints/waitpoint-service'
import { WaitpointStatus } from '../../../../../src/app/waitpoints/waitpoint-types'
+import { generateMockToken } from '../../../../helpers/auth'
import { db } from '../../../../helpers/db'
import { createMockFlow, createMockFlowRun, createMockFlowVersion, mockAndSaveBasicSetup } from '../../../../helpers/mocks'
import { createTestContext, TestContext } from '../../../../helpers/test-context'
@@ -1064,4 +1065,27 @@ describe('Waitpoint service', () => {
expect(result).toBeNull()
})
})
+
+ describe('POST /v1/waitpoints', () => {
+ it('gives the instance url as the public resume url when the edition has no embed subdomain', async () => {
+ const { flowRun } = await createFlowRun()
+ const engineToken = await generateMockToken({
+ type: PrincipalType.ENGINE,
+ id: apId(),
+ projectId: ctx.project.id,
+ platform: { id: ctx.platform.id },
+ })
+
+ const response = await app.inject({
+ method: 'POST',
+ url: '/api/v1/waitpoints',
+ headers: { authorization: `Bearer ${engineToken}` },
+ body: { flowRunId: flowRun.id, projectId: ctx.project.id, stepName: 'approval', type: PauseType.WEBHOOK, version: 'V1' },
+ })
+
+ expect(response.statusCode).toBe(201)
+ const body = response.json()
+ expect(body.publicResumeUrl).toBe(body.resumeUrl)
+ })
+ })
})
diff --git a/packages/server/api/test/integration/ee/embed-subdomain/embed-subdomain-resume.test.ts b/packages/server/api/test/integration/ee/embed-subdomain/embed-subdomain-resume.test.ts
new file mode 100644
index 00000000000..bc030849186
--- /dev/null
+++ b/packages/server/api/test/integration/ee/embed-subdomain/embed-subdomain-resume.test.ts
@@ -0,0 +1,138 @@
+import { apId } from '@activepieces/core-utils'
+import { EmbedSubdomainStatus, FlowRunStatus, FlowVersionState, PauseType, PrincipalType, RunEnvironment } from '@activepieces/shared'
+import { FastifyInstance } from 'fastify'
+import { StatusCodes } from 'http-status-codes'
+import { databaseConnection } from '../../../../src/app/database/database-connection'
+import { domainHelper } from '../../../../src/app/helper/domain-helper'
+import { generateMockToken } from '../../../helpers/auth'
+import { db } from '../../../helpers/db'
+import { createMockFlow, createMockFlowRun, createMockFlowVersion } from '../../../helpers/mocks'
+import { createTestContext, TestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+let app: FastifyInstance
+let ctx: TestContext
+
+beforeAll(async () => {
+ app = await setupTestEnvironment()
+})
+
+afterAll(async () => {
+ await teardownTestEnvironment()
+})
+
+beforeEach(async () => {
+ ctx = await createTestContext(app, { plan: { embeddingEnabled: true } })
+})
+
+describe('Resume links on an embed subdomain', () => {
+ it('gives a public resume url on the active subdomain that resumes the run', async () => {
+ const hostname = await saveEmbedSubdomain({ status: EmbedSubdomainStatus.ACTIVE })
+ const flowRunId = await saveFlowRun()
+
+ const created = await createWaitpoint({ flowRunId, type: PauseType.WEBHOOK })
+
+ expect(created.statusCode).toBe(StatusCodes.CREATED)
+ const { id: waitpointId, resumeUrl, publicResumeUrl } = created.json()
+ const publicUrl = new URL(publicResumeUrl)
+ expect(publicUrl.origin).toBe(`https://${hostname}`)
+ expect(new URL(resumeUrl).origin).toBe(await instanceOrigin())
+ expect(publicUrl.pathname).toBe(new URL(resumeUrl).pathname)
+
+ const page = await app.inject({
+ method: 'GET',
+ url: `${publicUrl.pathname}/confirm`,
+ headers: { host: hostname, accept: 'text/html' },
+ })
+ expect(page.statusCode).toBe(StatusCodes.OK)
+ expect(readFormActions(page.body)).toContain(`${publicUrl.pathname}/confirm?action=approve`)
+
+ const approve = await app.inject({
+ method: 'POST',
+ url: `${publicUrl.pathname}/confirm?action=approve`,
+ headers: { host: hostname, accept: 'application/json' },
+ body: {},
+ })
+ expect(approve.statusCode).toBe(StatusCodes.OK)
+ expect(approve.json().message).toBe('Your response has been recorded. You can close this page now.')
+ expect(await databaseConnection().getRepository('waitpoint').findOneBy({ id: waitpointId })).toBeNull()
+ })
+
+ it('gives barrier confirm links on the active subdomain', async () => {
+ const hostname = await saveEmbedSubdomain({ status: EmbedSubdomainStatus.ACTIVE })
+ const flowRunId = await saveFlowRun()
+
+ const created = await createWaitpoint({ flowRunId, type: PauseType.BARRIER, barrier: { signals: [{ label: 'Manager' }] } })
+
+ expect(created.statusCode).toBe(StatusCodes.CREATED)
+ const [signal] = created.json().barrier.signals
+ expect(new URL(signal.confirmUrl).origin).toBe(`https://${hostname}`)
+ })
+
+ it('keeps the instance url while the subdomain is not active', async () => {
+ await saveEmbedSubdomain({ status: EmbedSubdomainStatus.PENDING_VERIFICATION })
+ const flowRunId = await saveFlowRun()
+
+ const created = await createWaitpoint({ flowRunId, type: PauseType.WEBHOOK })
+
+ expect(created.statusCode).toBe(StatusCodes.CREATED)
+ const { resumeUrl, publicResumeUrl } = created.json()
+ expect(publicResumeUrl).toBe(resumeUrl)
+ })
+})
+
+async function saveEmbedSubdomain({ status }: { status: EmbedSubdomainStatus }): Promise<string> {
+ const hostname = `embed-${apId().slice(0, 8).toLowerCase()}.example.com`
+ await databaseConnection().getRepository('embed_subdomain').save({
+ id: apId(),
+ created: new Date().toISOString(),
+ updated: new Date().toISOString(),
+ platformId: ctx.platform.id,
+ hostname,
+ status,
+ cloudflareId: `cf-${apId()}`,
+ verificationRecords: [],
+ })
+ return hostname
+}
+
+async function saveFlowRun(): Promise<string> {
+ const flow = createMockFlow({ projectId: ctx.project.id })
+ await db.save('flow', flow)
+ const flowVersion = createMockFlowVersion({ flowId: flow.id, state: FlowVersionState.LOCKED })
+ await db.save('flow_version', flowVersion)
+ const flowRun = createMockFlowRun({
+ projectId: ctx.project.id,
+ flowId: flow.id,
+ flowVersionId: flowVersion.id,
+ status: FlowRunStatus.PAUSED,
+ environment: RunEnvironment.PRODUCTION,
+ })
+ await db.save('flow_run', flowRun)
+ return flowRun.id
+}
+
+async function createWaitpoint({ flowRunId, type, barrier }: { flowRunId: string, type: PauseType, barrier?: Record<string, unknown> }): Promise<Awaited<ReturnType<FastifyInstance['inject']>>> {
+ const engineToken = await generateMockToken({
+ type: PrincipalType.ENGINE,
+ id: apId(),
+ projectId: ctx.project.id,
+ platform: { id: ctx.platform.id },
+ })
+ return app.inject({
+ method: 'POST',
+ url: '/api/v1/waitpoints',
+ headers: { authorization: `Bearer ${engineToken}` },
+ body: { flowRunId, projectId: ctx.project.id, stepName: 'approval', type, version: 'V1', barrier },
+ })
+}
+
+function readFormActions(html: string): string[] {
+ return [...html.matchAll(/formaction="([^"]*)"/g)].map(([, encoded]) => encoded
+ .replace(/&#x([0-9a-f]+);/gi, (_, hex: string) => String.fromCharCode(parseInt(hex, 16)))
+ .replace(/&amp;/g, '&'))
+}
+
+async function instanceOrigin(): Promise<string> {
+ return new URL(await domainHelper.getPublicApiUrl({ path: '' })).origin
+}
diff --git a/packages/server/engine/test/handler/waitpoint-resume-urls.test.ts b/packages/server/engine/test/handler/waitpoint-resume-urls.test.ts
new file mode 100644
index 00000000000..659a8e4e039
--- /dev/null
+++ b/packages/server/engine/test/handler/waitpoint-resume-urls.test.ts
@@ -0,0 +1,102 @@
+import { FlowRunStatus, StreamStepProgress } from '@activepieces/shared'
+import { describe, expect, it, vi } from 'vitest'
+
+const INSTANCE_RESUME_URL = 'https://cloud.activepieces.com/api/v1/flow-runs/run-1/waitpoints/wp-1'
+const PUBLIC_RESUME_URL = 'https://embed.example.com/api/v1/flow-runs/run-1/waitpoints/wp-1'
+
+const { mockCreate, mockGetPieceAndAction } = vi.hoisted(() => ({
+ mockCreate: vi.fn(),
+ mockGetPieceAndAction: vi.fn(),
+}))
+
+vi.mock('../../src/lib/api/engine-run-api', () => ({
+ engineRunApi: {
+ updateRunProgress: vi.fn().mockResolvedValue(undefined),
+ updateStepProgress: vi.fn(),
+ uploadRunLog: vi.fn(),
+ sendFlowResponse: vi.fn(),
+ },
+}))
+
+vi.mock('../../src/lib/piece-context/waitpoint-client', () => ({
+ waitpointClient: { create: mockCreate },
+}))
+
+vi.mock('../../src/lib/helper/piece-loader', () => ({
+ pieceLoader: {
+ getPieceAndActionOrThrow: mockGetPieceAndAction,
+ loadPieceOrThrow: vi.fn(),
+ getPackageAlias: vi.fn(),
+ getPiecePath: vi.fn(),
+ getPropOrThrow: vi.fn(),
+ },
+}))
+
+import { FlowExecutorContext } from '../../src/lib/handler/context/flow-execution-context'
+import { flowExecutor } from '../../src/lib/handler/flow-executor'
+import { buildPieceAction, generateMockEngineConstants } from './test-helper'
+
+describe('waitpoint links handed to a piece', () => {
+ it('keeps resumeUrl and buildResumeUrl on the instance while passing publicResumeUrl through', async () => {
+ mockCreate.mockResolvedValue({ id: 'wp-1', resumeUrl: INSTANCE_RESUME_URL, publicResumeUrl: PUBLIC_RESUME_URL })
+ mockGetPieceAndAction.mockResolvedValue(pieceThatReportsItsLinks())
+
+ const output = await runStep()
+
+ expect(output).toEqual({
+ resumeUrl: INSTANCE_RESUME_URL,
+ publicResumeUrl: PUBLIC_RESUME_URL,
+ builtResumeUrl: `${INSTANCE_RESUME_URL}?action=approve`,
+ builtSyncResumeUrl: `${INSTANCE_RESUME_URL}/sync?action=approve`,
+ })
+ })
+
+ it('leaves publicResumeUrl undefined when the server sends none', async () => {
+ mockCreate.mockResolvedValue({ id: 'wp-1', resumeUrl: INSTANCE_RESUME_URL })
+ mockGetPieceAndAction.mockResolvedValue(pieceThatReportsItsLinks())
+
+ const output = await runStep()
+
+ expect(output).toEqual({
+ resumeUrl: INSTANCE_RESUME_URL,
+ builtResumeUrl: `${INSTANCE_RESUME_URL}?action=approve`,
+ builtSyncResumeUrl: `${INSTANCE_RESUME_URL}/sync?action=approve`,
+ })
+ })
+})
+
+function pieceThatReportsItsLinks() {
+ return {
+ piece: { auth: undefined },
+ pieceAction: {
+ name: 'report_links',
+ props: {},
+ requireAuth: false,
+ run: async (context: { run: { createWaitpoint: (p: unknown) => Promise<ReportedWaitpoint> } }) => {
+ const waitpoint = await context.run.createWaitpoint({ type: 'WEBHOOK' })
+ return {
+ resumeUrl: waitpoint.resumeUrl,
+ publicResumeUrl: waitpoint.publicResumeUrl,
+ builtResumeUrl: waitpoint.buildResumeUrl({ queryParams: { action: 'approve' } }),
+ builtSyncResumeUrl: waitpoint.buildResumeUrl({ queryParams: { action: 'approve' }, sync: true }),
+ }
+ },
+ },
+ }
+}
+
+async function runStep(): Promise<unknown> {
+ const result = await flowExecutor.execute({
+ action: buildPieceAction({ name: 'reporter', pieceName: '@activepieces/piece-under-test', actionName: 'report_links', input: {} }),
+ executionState: FlowExecutorContext.empty(),
+ constants: generateMockEngineConstants({ streamStepProgress: StreamStepProgress.NONE, internalApiUrl: 'http://127.0.0.1:1/' }),
+ })
+ expect(result.verdict, JSON.stringify(result.steps?.reporter?.errorMessage ?? null)).not.toBe(FlowRunStatus.FAILED)
+ return result.steps.reporter.output
+}
+
+type ReportedWaitpoint = {
+ resumeUrl: string
+ publicResumeUrl?: string
+ buildResumeUrl: (params: { queryParams: Record<string, string>, sync?: boolean }) => string
+}