windmill-components 1.687.0 → 1.695.1

package/package/components/triggers/azure/AzureTriggerEditorInner.svelte

@@ -0,0 +1,422 @@
+<script lang="ts">import { Alert, Button } from '../../common';
+import Drawer from '../../common/drawer/Drawer.svelte';
+import DrawerContent from '../../common/drawer/DrawerContent.svelte';
+import Path from '../../Path.svelte';
+import { usedTriggerKinds, userStore, workspaceStore } from '../../../stores';
+import { canWrite, capitalize, emptyString, sendUserToast } from '../../../utils';
+import { withForkConflictRetry } from '../../../utils/forkConflict';
+import { Loader2 } from 'lucide-svelte';
+import Label from '../../Label.svelte';
+import { AzureTriggerService } from '../../../gen';
+import Section from '../../Section.svelte';
+import ScriptPicker from '../../ScriptPicker.svelte';
+import Required from '../../Required.svelte';
+import AzureTriggerEditorConfigSection from './AzureTriggerEditorConfigSection.svelte';
+import { untrack } from 'svelte';
+import TriggerEditorToolbar from '../TriggerEditorToolbar.svelte';
+import PermissionedAsLine from '../PermissionedAsLine.svelte';
+import { saveAzureTriggerFromCfg } from './utils';
+import { getHandlerType, handleConfigChange } from '../utils';
+import { deepEqual } from 'fast-equals';
+import TriggerSuspendedJobsAlert from '../TriggerSuspendedJobsAlert.svelte';
+import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte';
+import { base } from '../../../base';
+import Tabs from '../../common/tabs/Tabs.svelte';
+import Tab from '../../common/tabs/Tab.svelte';
+import TriggerRetriesAndErrorHandler from '../TriggerRetriesAndErrorHandler.svelte';
+import TriggerAdvancedBadges from '../TriggerAdvancedBadges.svelte';
+let drawer = $state(undefined);
+let initialPath = $state('');
+let edit = $state(true);
+let itemKind = $state('script');
+let script_path = $state('');
+let initialScriptPath = $state('');
+let fixedScriptPath = $state('');
+let path = $state('');
+let pathError = $state('');
+let mode = $state('enabled');
+let dirtyPath = $state(false);
+let can_write = $state(true);
+let drawerLoading = $state(true);
+let azure_resource_path = $state('');
+let azure_mode = $state('namespace_pull');
+let scope_resource_id = $state('');
+let topic_name = $state(undefined);
+let subscription_name = $state('');
+let event_type_filters = $state(undefined);
+let isValid = $state(false);
+let initialConfig = undefined;
+let deploymentLoading = $state(false);
+let permissionedAs = $state(undefined);
+let selectedPermissionedAs = $state(undefined);
+let preservePermissionedAs = $state(false);
+let base_endpoint = $derived(`${window.location.origin}${base}`);
+let optionTabSelected = $state('error_handler');
+let errorHandlerSelected = $state('slack');
+let error_handler_path = $state();
+let error_handler_args = $state({});
+let retry = $state();
+let suspendedJobsModal = $state(null);
+let originalConfig = $state(undefined);
+let { useDrawer = true, description = undefined, hideTarget = false, hideTooltips = false, isEditor = false, allowDraft = false, trigger = undefined, isDeployed = false, customLabel = undefined, onConfigChange = undefined, onCaptureConfigChange = undefined, onUpdate = undefined, onDelete = undefined, onReset = undefined, cloudDisabled = false } = $props();
+let hasChanged = $derived(!deepEqual(getAzureConfig(), originalConfig ?? {}));
+const azureConfig = $derived.by(getAzureConfig);
+const saveDisabled = $derived(pathError != '' || emptyString(script_path) || !isValid || !can_write || !hasChanged);
+const captureConfig = $derived.by(untrack(() => isEditor) ? getAzureCaptureConfig : () => ({}));
+export async function openEdit(ePath, isFlow, defaultValues) {
+    drawerLoading = true;
+    try {
+        drawer?.openDrawer();
+        initialPath = ePath;
+        itemKind = isFlow ? 'flow' : 'script';
+        edit = true;
+        dirtyPath = false;
+        await loadTrigger(defaultValues);
+        originalConfig = structuredClone($state.snapshot(getAzureConfig()));
+    }
+    catch (err) {
+        sendUserToast(`Could not load Azure trigger: ${err.body}`, true);
+    }
+    finally {
+        drawerLoading = false;
+        if (!defaultValues) {
+            initialConfig = structuredClone($state.snapshot(getAzureConfig()));
+        }
+    }
+}
+export async function openNew(nis_flow, fixedScriptPath_, defaultValues) {
+    drawerLoading = true;
+    try {
+        drawer?.openDrawer();
+        itemKind = nis_flow ? 'flow' : 'script';
+        initialScriptPath = '';
+        fixedScriptPath = fixedScriptPath_ ?? '';
+        script_path = fixedScriptPath;
+        azure_resource_path = defaultValues?.azure_resource_path ?? '';
+        azure_mode = defaultValues?.azure_mode ?? 'namespace_pull';
+        scope_resource_id = defaultValues?.scope_resource_id ?? '';
+        topic_name = defaultValues?.topic_name ?? undefined;
+        subscription_name = defaultValues?.subscription_name ?? '';
+        event_type_filters = defaultValues?.event_type_filters ?? undefined;
+        path = defaultValues?.path ?? '';
+        initialPath = '';
+        edit = false;
+        dirtyPath = false;
+        mode = defaultValues?.mode ?? 'enabled';
+        error_handler_path = defaultValues?.error_handler_path ?? undefined;
+        error_handler_args = defaultValues?.error_handler_args ?? {};
+        retry = defaultValues?.retry ?? undefined;
+        errorHandlerSelected = getHandlerType(error_handler_path ?? '');
+        permissionedAs = undefined;
+        selectedPermissionedAs = undefined;
+        preservePermissionedAs = false;
+        originalConfig = undefined;
+    }
+    finally {
+        drawerLoading = false;
+    }
+}
+async function loadTrigger(defaultConfig) {
+    if (defaultConfig) {
+        loadTriggerConfig(defaultConfig);
+        return;
+    }
+    try {
+        const s = await AzureTriggerService.getAzureTrigger({
+            workspace: $workspaceStore,
+            path: initialPath
+        });
+        loadTriggerConfig(s);
+    }
+    catch (error) {
+        sendUserToast(`Could not load Azure trigger: ${error.body}`, true);
+    }
+}
+async function loadTriggerConfig(cfg) {
+    script_path = cfg?.script_path;
+    initialScriptPath = cfg?.script_path;
+    azure_resource_path = cfg?.azure_resource_path;
+    azure_mode = cfg?.azure_mode;
+    scope_resource_id = cfg?.scope_resource_id;
+    topic_name = cfg?.topic_name ?? undefined;
+    subscription_name = cfg?.subscription_name;
+    event_type_filters = cfg?.event_type_filters;
+    path = cfg?.path;
+    mode = cfg?.mode ?? 'enabled';
+    can_write = canWrite(cfg?.path, cfg?.extra_perms, $userStore);
+    error_handler_path = cfg?.error_handler_path;
+    error_handler_args = cfg?.error_handler_args ?? {};
+    retry = cfg?.retry;
+    errorHandlerSelected = getHandlerType(error_handler_path ?? '');
+    permissionedAs = cfg?.permissioned_as;
+    selectedPermissionedAs = cfg?.permissioned_as;
+    preservePermissionedAs = !!cfg?.permissioned_as;
+}
+async function updateTrigger() {
+    deploymentLoading = true;
+    const cfg = azureConfig;
+    if (!cfg)
+        return;
+    const isSaved = await saveAzureTriggerFromCfg(initialPath, cfg, edit, $workspaceStore, usedTriggerKinds);
+    if (isSaved) {
+        onUpdate?.(cfg.path);
+        originalConfig = structuredClone($state.snapshot(getAzureConfig()));
+        initialPath = cfg.path;
+        initialScriptPath = cfg.script_path;
+        if (mode !== 'suspended')
+            drawer?.closeDrawer();
+    }
+    deploymentLoading = false;
+}
+function getAzureConfig() {
+    return {
+        azure_resource_path,
+        azure_mode,
+        scope_resource_id,
+        topic_name,
+        subscription_name,
+        event_type_filters,
+        base_endpoint,
+        path,
+        script_path,
+        mode,
+        is_flow: itemKind === 'flow',
+        error_handler_path,
+        error_handler_args,
+        retry,
+        permissioned_as: selectedPermissionedAs,
+        preserve_permissioned_as: preservePermissionedAs || undefined
+    };
+}
+function getAzureCaptureConfig() {
+    return {
+        azure_resource_path,
+        azure_mode,
+        scope_resource_id,
+        topic_name,
+        subscription_name,
+        event_type_filters,
+        base_endpoint,
+        path
+    };
+}
+async function handleToggleMode(newMode) {
+    const previousMode = mode;
+    mode = newMode;
+    if (!trigger?.draftConfig) {
+        const ok = await withForkConflictRetry((force) => AzureTriggerService.setAzureTriggerMode({
+            path: initialPath,
+            workspace: $workspaceStore ?? '',
+            requestBody: { mode: newMode, force }
+        }), 'Azure trigger');
+        if (!ok) {
+            mode = previousMode;
+            return;
+        }
+        sendUserToast(`${capitalize(newMode)} Azure trigger ${initialPath}`);
+        onUpdate?.(initialPath);
+    }
+    if (originalConfig)
+        originalConfig['mode'] = newMode;
+}
+$effect(() => {
+    if (!drawerLoading) {
+        handleConfigChange(azureConfig, initialConfig, saveDisabled, edit, onConfigChange);
+    }
+});
+$effect(() => {
+    const args = [captureConfig, isValid];
+    untrack(() => onCaptureConfigChange?.(...args));
+});
+</script>
+
+{#if mode === 'suspended'}
+	<TriggerSuspendedJobsModal
+		bind:this={suspendedJobsModal}
+		triggerPath={path}
+		triggerKind="azure"
+		{hasChanged}
+		onToggleMode={handleToggleMode}
+		runnableConfig={{
+			path: script_path,
+			kind: itemKind,
+			retry,
+			errorHandlerPath: error_handler_path,
+			errorHandlerArgs: error_handler_args
+		}}
+	/>
+{/if}
+
+{#if useDrawer}
+	<Drawer size="800px" bind:this={drawer}>
+		<DrawerContent
+			title={edit
+				? can_write
+					? `Edit Azure trigger ${initialPath}`
+					: `Azure trigger ${initialPath}`
+				: 'New Azure trigger'}
+			on:close={drawer?.closeDrawer}
+		>
+			{#snippet actions()}
+				{@render actionsButtons()}
+			{/snippet}
+			{@render config()}
+		</DrawerContent>
+	</Drawer>
+{:else}
+	<Section
+		label={!customLabel ? 'Azure Event Grid trigger' : ''}
+		headerClass="grow min-w-0 h-[30px]"
+	>
+		{#snippet header()}
+			{#if customLabel}
+				{@render customLabel()}
+			{/if}
+		{/snippet}
+		{#snippet action()}
+			{@render actionsButtons()}
+		{/snippet}
+		{@render config()}
+	</Section>
+{/if}
+
+{#snippet actionsButtons()}
+	{#if !drawerLoading && can_write}
+		<TriggerEditorToolbar
+			permissions={drawerLoading || !can_write ? 'none' : 'create'}
+			{saveDisabled}
+			{mode}
+			isLoading={deploymentLoading}
+			{edit}
+			{allowDraft}
+			{isDeployed}
+			onUpdate={updateTrigger}
+			{onReset}
+			{onDelete}
+			onToggleMode={handleToggleMode}
+			{cloudDisabled}
+			{trigger}
+			{suspendedJobsModal}
+		/>
+	{/if}
+{/snippet}
+
+{#snippet config()}
+	{#if drawerLoading}
+		<div class="flex flex-col items-center justify-center h-full w-full">
+			<Loader2 size="50" class="animate-spin" />
+			<p>Loading...</p>
+		</div>
+	{:else}
+		<PermissionedAsLine
+			{permissionedAs}
+			{path}
+			onPermissionedAsChange={(pa, preserve) => {
+				selectedPermissionedAs = pa
+				preservePermissionedAs = preserve
+			}}
+		/>
+		<div class="flex flex-col gap-5">
+			{#if mode === 'suspended'}
+				<TriggerSuspendedJobsAlert {suspendedJobsModal} />
+			{/if}
+			{#if description}
+				{@render description()}
+			{/if}
+			{#if !hideTooltips}
+				<Alert title="Info" type="info">
+					{#if edit}
+						Changes can take up to 30 seconds to take effect.
+					{:else}
+						New Azure triggers can take up to 30 seconds to start listening.
+					{/if}
+				</Alert>
+			{/if}
+		</div>
+		<div class="flex flex-col gap-12 mt-6">
+			<div class="flex flex-col gap-4">
+				<Label label="Path">
+					<Path
+						bind:dirty={dirtyPath}
+						bind:error={pathError}
+						bind:path
+						{initialPath}
+						checkInitialPathExistence={!edit}
+						namePlaceholder="azure_trigger"
+						kind="azure_trigger"
+						disabled={!can_write}
+						disableEditing={!can_write}
+					/>
+				</Label>
+			</div>
+
+			{#if !hideTarget}
+				<Section label="Runnable">
+					<p class="text-xs mb-1 text-primary">
+						Pick a script or flow to be triggered <Required required={true} />
+					</p>
+					<div class="flex flex-row mb-2">
+						<ScriptPicker
+							disabled={fixedScriptPath != '' || !can_write}
+							initialPath={fixedScriptPath || initialScriptPath}
+							kinds={['script']}
+							allowFlow={true}
+							bind:itemKind
+							bind:scriptPath={script_path}
+							allowRefresh={can_write}
+							allowEdit={!$userStore?.operator}
+							clearable
+						/>
+						{#if emptyString(script_path)}
+							<Button
+								btnClasses="ml-4"
+								variant="default"
+								unifiedSize="md"
+								disabled={!can_write}
+								href={itemKind === 'flow' ? '/flows/add?hub=81' : '/scripts/add?hub=hub%2F28214'}
+								target="_blank">Create from template</Button
+							>
+						{/if}
+					</div>
+				</Section>
+			{/if}
+
+			<AzureTriggerEditorConfigSection
+				bind:isValid
+				bind:azure_resource_path
+				bind:azure_mode
+				bind:scope_resource_id
+				bind:topic_name
+				bind:subscription_name
+				bind:event_type_filters
+				{path}
+				{can_write}
+				headless={true}
+			/>
+
+			<Section label="Advanced" collapsable>
+				{#snippet header()}
+					<TriggerAdvancedBadges {error_handler_path} {retry} />
+				{/snippet}
+				<div class="min-h-96">
+					<Tabs bind:selected={optionTabSelected}>
+						<Tab value="error_handler" label="Error Handler" />
+						<Tab value="retries" label="Retries" />
+					</Tabs>
+					<div class="mt-4">
+						<TriggerRetriesAndErrorHandler
+							{optionTabSelected}
+							{itemKind}
+							{can_write}
+							bind:errorHandlerSelected
+							bind:error_handler_path
+							bind:error_handler_args
+							bind:retry
+						/>
+					</div>
+				</div>
+			</Section>
+			<div class="pb-8" />
+		</div>
+	{/if}
+{/snippet}

package/package/components/triggers/azure/AzureTriggerEditorInner.svelte.d.ts

@@ -0,0 +1,25 @@
+import { type Snippet } from 'svelte';
+import { type Trigger } from '../utils';
+type $$ComponentProps = {
+    useDrawer?: boolean;
+    description?: Snippet | undefined;
+    hideTarget?: boolean;
+    hideTooltips?: boolean;
+    isEditor?: boolean;
+    allowDraft?: boolean;
+    trigger?: Trigger;
+    isDeployed?: boolean;
+    customLabel?: Snippet;
+    onConfigChange?: (cfg: Record<string, any>, saveDisabled: boolean, updated: boolean) => void;
+    onCaptureConfigChange?: (cfg: Record<string, any>, isValid: boolean) => void;
+    onUpdate?: (path?: string) => void;
+    onDelete?: () => void;
+    onReset?: () => void;
+    cloudDisabled?: boolean;
+};
+declare const AzureTriggerEditorInner: import("svelte").Component<$$ComponentProps, {
+    openEdit: (ePath: string, isFlow: boolean, defaultValues?: Record<string, any>) => Promise<void>;
+    openNew: (nis_flow: boolean, fixedScriptPath_?: string, defaultValues?: Record<string, any>) => Promise<void>;
+}, "">;
+type AzureTriggerEditorInner = ReturnType<typeof AzureTriggerEditorInner>;
+export default AzureTriggerEditorInner;

package/package/components/triggers/azure/AzureTriggerPanel.svelte

@@ -0,0 +1,55 @@
+<script lang="ts">import { isCloudHosted } from '../../../cloud';
+import { Alert } from '../../common';
+import Description from '../../Description.svelte';
+import { enterpriseLicense } from '../../../stores';
+import AzureTriggerEditorInner from './AzureTriggerEditorInner.svelte';
+import { onMount } from 'svelte';
+let { selectedTrigger, isFlow, path, isDeployed = false, defaultValues = undefined, customLabel = undefined, ...restProps } = $props();
+let azureTriggerEditor = $state(undefined);
+async function openAzureTriggerEditor(isFlow, isDraft) {
+    if (isDraft) {
+        azureTriggerEditor?.openNew(isFlow, path, defaultValues);
+    }
+    else {
+        azureTriggerEditor?.openEdit(selectedTrigger.path, isFlow, defaultValues);
+    }
+}
+onMount(() => {
+    azureTriggerEditor && openAzureTriggerEditor(isFlow, selectedTrigger.isDraft ?? false);
+});
+const cloudDisabled = $derived(isCloudHosted());
+</script>
+
+{#if !$enterpriseLicense}
+	<Alert title="EE Only" type="warning" size="xs">
+		Azure Event Grid triggers are an enterprise only feature.
+	</Alert>
+{:else}
+	<div class="flex flex-col gap-4">
+		<AzureTriggerEditorInner
+			bind:this={azureTriggerEditor}
+			useDrawer={false}
+			hideTarget
+			hideTooltips={!isDeployed || cloudDisabled}
+			allowDraft={true}
+			trigger={selectedTrigger}
+			{customLabel}
+			{isDeployed}
+			{cloudDisabled}
+			{...restProps}
+		>
+			{#snippet description()}
+				{#if cloudDisabled}
+					<Alert title="Not compatible with multi-tenant cloud" type="warning" size="xs">
+						Azure Event Grid triggers are disabled in the multi-tenant cloud.
+					</Alert>
+				{:else}
+					<Description link="https://www.windmill.dev/docs/core_concepts/azure_triggers">
+						Azure Event Grid triggers execute scripts and flows in response to events from Azure
+						Event Grid (basic) or Event Grid Namespaces (push or pull).
+					</Description>
+				{/if}
+			{/snippet}
+		</AzureTriggerEditorInner>
+	</div>
+{/if}

package/package/components/triggers/azure/AzureTriggerPanel.svelte.d.ts

@@ -0,0 +1,10 @@
+declare const AzureTriggerPanel: import("svelte").Component<{
+    selectedTrigger: any;
+    isFlow: any;
+    path: any;
+    isDeployed?: boolean;
+    defaultValues?: any;
+    customLabel?: any;
+} & Record<string, any>, {}, "">;
+type AzureTriggerPanel = ReturnType<typeof AzureTriggerPanel>;
+export default AzureTriggerPanel;

package/{dist/sharedUtils/components/triggers/kafka → package/components/triggers/azure}/utils.d.ts

@@ -1,2 +1,2 @@
 import { type Writable } from 'svelte/store';
-export declare function saveKafkaTriggerFromCfg(initialPath: string, cfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;
+export declare function saveAzureTriggerFromCfg(initialPath: string, cfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;

package/package/components/triggers/azure/utils.js

@@ -0,0 +1,56 @@
+import { AzureTriggerService } from '../../../gen';
+import { sendUserToast } from '../../../toast';
+import { get } from 'svelte/store';
+export async function saveAzureTriggerFromCfg(initialPath, cfg, edit, workspace, usedTriggerKinds) {
+    try {
+        const errorHandlerAndRetries = !cfg.is_flow
+            ? {
+                error_handler_path: cfg.error_handler_path,
+                error_handler_args: cfg.error_handler_path ? cfg.error_handler_args : undefined,
+                retry: cfg.retry
+            }
+            : {};
+        const requestBody = {
+            azure_resource_path: cfg.azure_resource_path,
+            azure_mode: cfg.azure_mode,
+            scope_resource_id: cfg.scope_resource_id,
+            topic_name: cfg.topic_name,
+            subscription_name: cfg.subscription_name,
+            base_endpoint: cfg.base_endpoint,
+            event_type_filters: cfg.event_type_filters,
+            path: cfg.path,
+            script_path: cfg.script_path,
+            mode: cfg.mode,
+            is_flow: cfg.is_flow,
+            permissioned_as: cfg.permissioned_as,
+            preserve_permissioned_as: cfg.preserve_permissioned_as,
+            ...errorHandlerAndRetries
+        };
+        if (edit) {
+            await AzureTriggerService.updateAzureTrigger({
+                workspace,
+                path: initialPath,
+                requestBody
+            });
+            sendUserToast(`Azure Event Grid trigger ${cfg.path} updated`);
+        }
+        else {
+            await AzureTriggerService.createAzureTrigger({
+                workspace,
+                requestBody: {
+                    ...requestBody,
+                    mode: 'enabled'
+                }
+            });
+            sendUserToast(`Azure Event Grid trigger ${cfg.path} created`);
+        }
+        if (!get(usedTriggerKinds).includes('azure')) {
+            usedTriggerKinds.update((t) => [...t, 'azure']);
+        }
+        return true;
+    }
+    catch (error) {
+        sendUserToast(error.body || error.message, true);
+        return false;
+    }
+}

package/package/components/triggers/email/EmailTriggerEditorInner.svelte

@@ -207,6 +207,8 @@ function getEmailTriggerConfig() {
 async function handleToggleMode(newMode) {
     mode = newMode;
     if (!trigger?.draftConfig) {
+        // Email addresses are always workspace-prefixed (clone filter
+        // excludes workspaced_local_part=false) — no fork-conflict warning.
         await EmailTriggerService.setEmailTriggerMode({
             path: initialPath,
             workspace: $workspaceStore ?? '',

package/package/components/triggers/gcp/GcpTriggerEditorInner.svelte

@@ -4,6 +4,7 @@ import DrawerContent from '../../common/drawer/DrawerContent.svelte';
 import Path from '../../Path.svelte';
 import { usedTriggerKinds, userStore, workspaceStore } from '../../../stores';
 import { canWrite, capitalize, emptyString, sendUserToast } from '../../../utils';
+import { withForkConflictRetry } from '../../../utils/forkConflict';
 import { Loader2 } from 'lucide-svelte';
 import Label from '../../Label.svelte';
 import { GcpTriggerService } from '../../../gen';
@@ -216,13 +217,18 @@ function getGcpCaptureConfig() {
     };
 }
 async function handleToggleMode(newMode) {
+    const previousMode = mode;
     mode = newMode;
     if (!trigger?.draftConfig) {
-        await GcpTriggerService.setGcpTriggerMode({
+        const ok = await withForkConflictRetry((force) => GcpTriggerService.setGcpTriggerMode({
             path: initialPath,
             workspace: $workspaceStore ?? '',
-            requestBody: { mode: newMode }
-        });
+            requestBody: { mode: newMode, force }
+        }), 'GCP Pub/Sub trigger');
+        if (!ok) {
+            mode = previousMode;
+            return;
+        }
         sendUserToast(`${capitalize(newMode)} GCP Pub/Sub trigger ${initialPath}`);
         onUpdate?.(initialPath);
     }

package/package/components/triggers/http/RouteEditorInner.svelte

@@ -331,6 +331,8 @@ function getRouteConfig() {
 async function handleToggleMode(newMode) {
     mode = newMode;
     if (!trigger?.draftConfig) {
+        // HTTP routes are always workspace-prefixed at runtime, so fork
+        // and parent live at distinct URLs — no fork-conflict warning.
         await HttpTriggerService.setHttpTriggerMode({
             path: initialPath,
             workspace: $workspaceStore ?? '',

package/package/components/triggers/kafka/KafkaTriggerEditorInner.svelte

@@ -8,6 +8,7 @@ import ScriptPicker from '../../ScriptPicker.svelte';
 import { KafkaTriggerService } from '../../../gen';
 import { usedTriggerKinds, userStore, workspaceStore } from '../../../stores';
 import { canWrite, capitalize, emptyString, sendUserToast } from '../../../utils';
+import { withForkConflictRetry } from '../../../utils/forkConflict';
 import Section from '../../Section.svelte';
 import { Loader2, RotateCcw } from 'lucide-svelte';
 import Label from '../../Label.svelte';
@@ -252,13 +253,18 @@ async function resetOffsets() {
     }
 }
 async function handleToggleMode(newMode) {
+    const previousMode = mode;
     mode = newMode;
     if (!trigger?.draftConfig) {
-        await KafkaTriggerService.setKafkaTriggerMode({
+        const ok = await withForkConflictRetry((force) => KafkaTriggerService.setKafkaTriggerMode({
             path: initialPath,
             workspace: $workspaceStore ?? '',
-            requestBody: { mode: newMode }
-        });
+            requestBody: { mode: newMode, force }
+        }), 'Kafka trigger');
+        if (!ok) {
+            mode = previousMode;
+            return;
+        }
         sendUserToast(`${capitalize(newMode)} Kafka trigger ${initialPath}`);
         onUpdate?.(initialPath);
     }

package/package/components/triggers/mqtt/MqttTriggerEditorInner.svelte

@@ -7,6 +7,7 @@ import Required from '../../Required.svelte';
 import ScriptPicker from '../../ScriptPicker.svelte';
 import { usedTriggerKinds, userStore, workspaceStore } from '../../../stores';
 import { canWrite, capitalize, emptyString, sendUserToast } from '../../../utils';
+import { withForkConflictRetry } from '../../../utils/forkConflict';
 import Section from '../../Section.svelte';
 import { Loader2 } from 'lucide-svelte';
 import Label from '../../Label.svelte';
@@ -231,13 +232,18 @@ async function updateTrigger() {
     deploymentLoading = false;
 }
 async function handleToggleMode(newMode) {
+    const previousMode = mode;
     mode = newMode;
     if (!trigger?.draftConfig) {
-        await MqttTriggerService.setMqttTriggerMode({
+        const ok = await withForkConflictRetry((force) => MqttTriggerService.setMqttTriggerMode({
             path: initialPath,
             workspace: $workspaceStore ?? '',
-            requestBody: { mode: newMode }
-        });
+            requestBody: { mode: newMode, force }
+        }), 'MQTT trigger');
+        if (!ok) {
+            mode = previousMode;
+            return;
+        }
         sendUserToast(`${capitalize(newMode)} MQTT trigger ${initialPath}`);
         onUpdate?.(initialPath);
     }