windmill-components 1.677.1 → 1.695.0

package/package/components/DatatableSchemaDiff.svelte

@@ -0,0 +1,531 @@
+<script module lang="ts">import { diffTableEditorValues, makeAlterTableQueries } from './apps/components/display/dbtable/queries/alterTable';
+import { renderForeignKey } from './apps/components/display/dbtable/queries/dbQueriesUtils';
+export function apiSchemaToEditorSchema(apiSchema) {
+    const result = {};
+    for (const [schemaName, tables] of Object.entries(apiSchema)) {
+        result[schemaName] = {};
+        for (const [tableName, table] of Object.entries(tables)) {
+            if (!table || typeof table !== 'object')
+                continue;
+            result[schemaName][tableName] = {
+                name: table.name ?? tableName,
+                columns: (table.columns ?? []).map((c) => ({
+                    name: c.name,
+                    datatype: c.datatype,
+                    primaryKey: c.primary_key ?? c.primaryKey,
+                    defaultValue: c.default_value ?? c.defaultValue,
+                    nullable: c.nullable
+                })),
+                foreignKeys: (table.foreign_keys ?? table.foreignKeys ?? []).map((fk) => ({
+                    targetTable: fk.target_table ?? fk.targetTable,
+                    columns: (fk.columns ?? []).map((col) => ({
+                        sourceColumn: col.source_column ?? col.sourceColumn,
+                        targetColumn: col.target_column ?? col.targetColumn
+                    })),
+                    onDelete: (fk.on_delete ?? fk.onDelete ?? 'NO ACTION'),
+                    onUpdate: (fk.on_update ?? fk.onUpdate ?? 'NO ACTION'),
+                    fk_constraint_name: fk.fk_constraint_name
+                })),
+                pk_constraint_name: table.pk_constraint_name
+            };
+        }
+    }
+    return result;
+}
+export function diffDatabaseSchemas(original, current) {
+    const diffs = [];
+    const allSchemas = new Set([...Object.keys(original), ...Object.keys(current)]);
+    for (const schemaName of allSchemas) {
+        const origTables = original[schemaName] ?? {};
+        const currTables = current[schemaName] ?? {};
+        const allTables = new Set([...Object.keys(origTables), ...Object.keys(currTables)]);
+        for (const tableName of allTables) {
+            const origTable = origTables[tableName];
+            const currTable = currTables[tableName];
+            if (!origTable && currTable) {
+                diffs.push({ schemaName, tableName, kind: 'added' });
+            }
+            else if (origTable && !currTable) {
+                diffs.push({ schemaName, tableName, kind: 'removed' });
+            }
+            else if (origTable && currTable) {
+                const currWithInitial = {
+                    ...currTable,
+                    columns: currTable.columns.map((col) => ({
+                        ...col,
+                        initialName: col.name,
+                        defaultValue: col.defaultValue ? `{${col.defaultValue}}` : undefined
+                    }))
+                };
+                const origTableTransformed = {
+                    ...origTable,
+                    columns: origTable.columns.map((col) => ({
+                        ...col,
+                        defaultValue: col.defaultValue ? `{${col.defaultValue}}` : undefined
+                    }))
+                };
+                const diff = diffTableEditorValues(origTableTransformed, currWithInitial);
+                if (diff.operations.length > 0) {
+                    diffs.push({ schemaName, tableName, kind: 'modified', operations: diff });
+                }
+            }
+        }
+    }
+    return diffs;
+}
+export function computeDatatableDiff(datatableName, originalSchema, parentSchema, forkSchema) {
+    return {
+        datatableName,
+        behindChanges: diffDatabaseSchemas(originalSchema, parentSchema),
+        aheadChanges: diffDatabaseSchemas(originalSchema, forkSchema),
+        originalSchema,
+        parentSchema,
+        forkSchema
+    };
+}
+/** Detect PostgreSQL auto-increment columns and return the serial type + cleaned props.
+ *  e.g. bigint + nextval('seq'::regclass) → BIGSERIAL (no DEFAULT needed) */
+function resolveColumnType(c) {
+    const dv = c.defaultValue ?? '';
+    if (/^{?nextval\(/.test(dv)) {
+        const dt = c.datatype?.toLowerCase() ?? '';
+        if (dt === 'bigint')
+            return { datatype: 'BIGSERIAL', defaultValue: undefined };
+        if (dt === 'integer' || dt === 'int')
+            return { datatype: 'SERIAL', defaultValue: undefined };
+        if (dt === 'smallint')
+            return { datatype: 'SMALLSERIAL', defaultValue: undefined };
+    }
+    return { datatype: c.datatype, defaultValue: c.defaultValue };
+}
+export function generateMigrationSql(change, sourceSchema) {
+    if (change.kind === 'modified' && change.operations) {
+        const queries = makeAlterTableQueries(change.operations, 'postgresql', change.schemaName);
+        if (queries.length === 0)
+            return '';
+        return 'BEGIN;\n' + queries.join('\n') + '\nCOMMIT;';
+    }
+    if (change.kind === 'added') {
+        const table = sourceSchema[change.schemaName]?.[change.tableName];
+        if (!table)
+            return '';
+        const colDefs = table.columns
+            .map((c) => {
+            const { datatype, defaultValue } = resolveColumnType(c);
+            let def = `"${c.name}" ${datatype}`;
+            if (c.nullable === false)
+                def += ' NOT NULL';
+            if (defaultValue)
+                def += ` DEFAULT ${defaultValue}`;
+            return def;
+        })
+            .join(',\n  ');
+        const pkCols = table.columns.filter((c) => c.primaryKey).map((c) => `"${c.name}"`);
+        const pkLine = pkCols.length > 0 ? `,\n  PRIMARY KEY (${pkCols.join(', ')})` : '';
+        const qualifiedName = `"${change.schemaName}"."${change.tableName}"`;
+        let sql = `BEGIN;\nCREATE TABLE ${qualifiedName} (\n  ${colDefs}${pkLine}\n);`;
+        for (const fk of table.foreignKeys ?? []) {
+            const fkSql = renderForeignKey(fk, {
+                useSchema: true,
+                dbType: 'postgresql',
+                tableName: change.tableName
+            });
+            sql += `\nALTER TABLE ${qualifiedName} ADD ${fkSql};`;
+        }
+        sql += '\nCOMMIT;';
+        return sql;
+    }
+    if (change.kind === 'removed') {
+        return `BEGIN;\nDROP TABLE IF EXISTS "${change.schemaName}"."${change.tableName}";\nCOMMIT;`;
+    }
+    return '';
+}
+</script>
+
+<script lang="ts">import { WorkspaceService } from '../gen';
+import { Loader2, ChevronDown, ChevronRight, Plus, Minus, Pencil, Eye } from 'lucide-svelte';
+import { Button } from './common';
+import Drawer from './common/drawer/Drawer.svelte';
+import SimpleEditor from './SimpleEditor.svelte';
+import { sendUserToast } from '../toast';
+import { runScriptAndPollResult } from './jobs/utils';
+import YAML from 'yaml';
+import DrawerContent from './common/drawer/DrawerContent.svelte';
+import ConfirmationModal from './common/confirmationModal/ConfirmationModal.svelte';
+import Alert from './common/alert/Alert.svelte';
+import ResizeTransitionWrapper from './common/ResizeTransitionWrapper.svelte';
+let { currentWorkspaceId, parentWorkspaceId } = $props();
+let loading = $state(true);
+let error = $state(undefined);
+let diffs = $state([]);
+let expandedDatatables = $state(new Set());
+// Drawer state
+let drawerOpen = $state(false);
+let drawerChange = $state(undefined);
+let drawerDiff = $state(undefined);
+let drawerDirection = $state(undefined);
+let migrationSql = $state('');
+let migrationRunning = $state(false);
+let confirmDeployOpen = $state(false);
+async function loadDiffs() {
+    loading = true;
+    error = undefined;
+    diffs = [];
+    try {
+        const forkSettings = await WorkspaceService.getPublicSettings({
+            workspace: currentWorkspaceId
+        });
+        const datatables = forkSettings.datatable?.datatables ?? {};
+        const forkedEntries = Object.entries(datatables).filter(([_, dt]) => dt.forked_from != null);
+        if (forkedEntries.length === 0) {
+            loading = false;
+            return;
+        }
+        const results = [];
+        for (const [dtName, dt] of forkedEntries) {
+            try {
+                const originalSchema = apiSchemaToEditorSchema(dt.forked_from?.schema ?? {});
+                const [parentSchemaRaw, forkSchemaRaw] = await Promise.all([
+                    WorkspaceService.getDatatableFullSchema({
+                        workspace: parentWorkspaceId,
+                        requestBody: { source: `datatable://${dtName}` }
+                    }),
+                    WorkspaceService.getDatatableFullSchema({
+                        workspace: currentWorkspaceId,
+                        requestBody: { source: `datatable://${dtName}` }
+                    })
+                ]);
+                const parentSchema = apiSchemaToEditorSchema(parentSchemaRaw);
+                const forkSchema = apiSchemaToEditorSchema(forkSchemaRaw);
+                const diff = computeDatatableDiff(dtName, originalSchema, parentSchema, forkSchema);
+                if (diff.aheadChanges.length > 0 || diff.behindChanges.length > 0) {
+                    results.push(diff);
+                }
+            }
+            catch (e) {
+                console.error(`Failed to diff datatable ${dtName}:`, e);
+            }
+        }
+        diffs = results;
+    }
+    catch (e) {
+        error = e?.body ?? e?.message ?? String(e);
+    }
+    finally {
+        loading = false;
+    }
+}
+$effect(() => {
+    void [currentWorkspaceId, parentWorkspaceId];
+    loadDiffs();
+});
+function toggleExpanded(name) {
+    const next = new Set(expandedDatatables);
+    if (next.has(name))
+        next.delete(name);
+    else
+        next.add(name);
+    expandedDatatables = next;
+}
+function operationSummary(d) {
+    if (d.kind === 'added')
+        return 'New table';
+    if (d.kind === 'removed')
+        return 'Deleted table';
+    const ops = d.operations?.operations ?? [];
+    const parts = [];
+    const adds = ops.filter((o) => o.kind === 'addColumn').length;
+    const drops = ops.filter((o) => o.kind === 'dropColumn').length;
+    const alters = ops.filter((o) => o.kind === 'alterColumn').length;
+    const renames = ops.filter((o) => o.kind === 'renameTable').length;
+    const fkAdds = ops.filter((o) => o.kind === 'addForeignKey').length;
+    const fkDrops = ops.filter((o) => o.kind === 'dropForeignKey').length;
+    const pkChanges = ops.filter((o) => o.kind === 'addPrimaryKey' || o.kind === 'dropPrimaryKey').length;
+    if (adds)
+        parts.push(`+${adds} col`);
+    if (drops)
+        parts.push(`-${drops} col`);
+    if (alters)
+        parts.push(`~${alters} col`);
+    if (renames)
+        parts.push('renamed');
+    if (fkAdds)
+        parts.push(`+${fkAdds} FK`);
+    if (fkDrops)
+        parts.push(`-${fkDrops} FK`);
+    if (pkChanges)
+        parts.push('PK changed');
+    return parts.join(', ') || 'Modified';
+}
+function openReview(change, diff, direction) {
+    drawerChange = change;
+    drawerDiff = diff;
+    drawerDirection = direction;
+    // ahead = fork changed → migration runs on parent to deploy
+    // behind = parent changed → migration runs on fork to update
+    const sourceSchema = direction === 'ahead' ? diff.forkSchema : diff.parentSchema;
+    migrationSql =
+        '-- Migration is auto-generated on a best-effort basis. You can adjust it here \n\n' +
+            generateMigrationSql(change, sourceSchema);
+    drawerOpen = true;
+}
+function getDiffYaml() {
+    if (!drawerChange || !drawerDiff || !drawerDirection)
+        return { original: '', modified: '' };
+    const { schemaName, tableName } = drawerChange;
+    const origTable = drawerDiff.originalSchema[schemaName]?.[tableName];
+    // ahead = fork changed → show original vs fork
+    // behind = parent changed → show original vs parent
+    const changedSchema = drawerDirection === 'ahead' ? drawerDiff.forkSchema : drawerDiff.parentSchema;
+    const changedTable = changedSchema[schemaName]?.[tableName];
+    return {
+        original: origTable ? YAML.stringify(origTable) : '# table does not exist',
+        modified: changedTable ? YAML.stringify(changedTable) : '# table does not exist'
+    };
+}
+async function runMigration() {
+    if (!drawerDiff || !drawerChange || !drawerDirection)
+        return;
+    migrationRunning = true;
+    // ahead → run on parent; behind → run on fork
+    const targetWorkspace = drawerDirection === 'ahead' ? parentWorkspaceId : currentWorkspaceId;
+    const dtName = drawerDiff.datatableName;
+    try {
+        await runScriptAndPollResult({
+            workspace: targetWorkspace,
+            requestBody: {
+                args: { database: `datatable://${dtName}` },
+                language: 'postgresql',
+                content: migrationSql
+            }
+        });
+    }
+    catch (e) {
+        sendUserToast(e?.body ?? e?.message ?? String(e), true);
+        migrationRunning = false;
+        return;
+    }
+    // Update forked_from.schema for the migrated table
+    try {
+        const sourceSchema = drawerDirection === 'ahead' ? drawerDiff.forkSchema : drawerDiff.parentSchema;
+        const { schemaName, tableName } = drawerChange;
+        const newTableDef = sourceSchema[schemaName]?.[tableName];
+        const forkSettings = await WorkspaceService.getPublicSettings({
+            workspace: currentWorkspaceId
+        });
+        const datatableConfig = forkSettings.datatable ?? { datatables: {} };
+        const dtConfig = datatableConfig.datatables[dtName];
+        if (dtConfig?.forked_from) {
+            const forkedFrom = dtConfig.forked_from;
+            if (!forkedFrom.schema)
+                forkedFrom.schema = {};
+            if (!forkedFrom.schema[schemaName])
+                forkedFrom.schema[schemaName] = {};
+            if (newTableDef) {
+                forkedFrom.schema[schemaName][tableName] = newTableDef;
+            }
+            else {
+                delete forkedFrom.schema[schemaName][tableName];
+            }
+            await WorkspaceService.editDataTableConfig({
+                workspace: currentWorkspaceId,
+                requestBody: { settings: datatableConfig }
+            });
+        }
+    }
+    catch (e) {
+        console.error('Failed to update forked_from schema:', e);
+    }
+    migrationRunning = false;
+    drawerOpen = false;
+    sendUserToast('Migration applied successfully');
+    await loadDiffs();
+}
+</script>
+
+<h3 class="text-sm font-semibold">Datatable schema changes</h3>
+{#if loading}
+	<div class="flex items-center gap-2 text-xs text-tertiary py-2">
+		<Loader2 class="w-4 h-4 animate-spin" /> Loading datatable diffs...
+	</div>
+{:else if error}
+	<div class="text-xs text-red-500 py-2">Failed to load datatable diffs: {error}</div>
+{:else if diffs.length > 0}
+	<div class="flex flex-col gap-2 mt-3 mb-1">
+		{#each diffs as diff}
+			<ResizeTransitionWrapper class="border rounded-md" innerClass="w-full" vertical>
+				<button
+					class="w-full flex items-center justify-between px-3 py-2 hover:bg-surface-hover"
+					onclick={() => toggleExpanded(diff.datatableName)}
+				>
+					<span class="text-xs font-medium">{diff.datatableName}</span>
+					<div class="flex items-center gap-2 text-2xs text-tertiary">
+						{#if diff.aheadChanges.length > 0}
+							<span class="text-blue-500">{diff.aheadChanges.length} ahead</span>
+						{/if}
+						{#if diff.behindChanges.length > 0}
+							<span class="text-orange-500">{diff.behindChanges.length} behind</span>
+						{/if}
+						{#if expandedDatatables.has(diff.datatableName)}
+							<ChevronDown class="w-3 h-3" />
+						{:else}
+							<ChevronRight class="w-3 h-3" />
+						{/if}
+					</div>
+				</button>
+
+				{#if expandedDatatables.has(diff.datatableName)}
+					<div class="border-t divide-y">
+						{#if diff.aheadChanges.length > 0}
+							<div class="px-3 py-1.5">
+								<div class="text-2xs font-semibold text-blue-500 mb-1">Fork changes (ahead)</div>
+								{#each diff.aheadChanges as change}
+									<div class="flex items-center gap-2 text-xs py-0.5">
+										{#if change.kind === 'added'}
+											<Plus class="w-3 h-3 text-green-500 shrink-0" />
+										{:else if change.kind === 'removed'}
+											<Minus class="w-3 h-3 text-red-500 shrink-0" />
+										{:else}
+											<Pencil class="w-3 h-3 text-yellow-500 shrink-0" />
+										{/if}
+										<span class="text-tertiary">{change.schemaName}.</span>
+										<span class="font-medium">{change.tableName}</span>
+										<span class="text-tertiary text-2xs grow">{operationSummary(change)}</span>
+										<Button
+											size="xs"
+											variant="subtle"
+											startIcon={{ icon: Eye }}
+											onclick={() => openReview(change, diff, 'ahead')}
+										>
+											Review
+										</Button>
+									</div>
+								{/each}
+							</div>
+						{/if}
+						{#if diff.behindChanges.length > 0}
+							<div class="px-3 py-1.5">
+								<div class="text-2xs font-semibold text-orange-500 mb-1">
+									Parent changes (behind)
+								</div>
+								{#each diff.behindChanges as change}
+									<div class="flex items-center gap-2 text-xs py-0.5">
+										{#if change.kind === 'added'}
+											<Plus class="w-3 h-3 text-green-500 shrink-0" />
+										{:else if change.kind === 'removed'}
+											<Minus class="w-3 h-3 text-red-500 shrink-0" />
+										{:else}
+											<Pencil class="w-3 h-3 text-yellow-500 shrink-0" />
+										{/if}
+										<span class="text-tertiary">{change.schemaName}.</span>
+										<span class="font-medium">{change.tableName}</span>
+										<span class="text-tertiary text-2xs grow">{operationSummary(change)}</span>
+										<Button
+											size="xs"
+											variant="subtle"
+											startIcon={{ icon: Eye }}
+											onclick={() => openReview(change, diff, 'behind')}
+										>
+											Review
+										</Button>
+									</div>
+								{/each}
+							</div>
+						{/if}
+					</div>
+				{/if}
+			</ResizeTransitionWrapper>
+		{/each}
+	</div>
+{:else}
+	<span class="text-xs text-secondary"> No changes detected </span>
+{/if}
+
+<Drawer bind:open={drawerOpen} size="900px">
+	{#if drawerChange && drawerDiff && drawerDirection}
+		{@const yaml = getDiffYaml()}
+		<DrawerContent
+			on:close={() => (drawerOpen = false)}
+			title="{drawerChange.schemaName}.{drawerChange.tableName} ({drawerDirection === 'ahead'
+				? 'Fork → Parent'
+				: 'Parent → Fork'})"
+		>
+			{#snippet actions()}
+				<Button
+					variant="accent"
+					loading={migrationRunning}
+					onclick={() => {
+						if (drawerDirection === 'ahead') {
+							confirmDeployOpen = true
+						} else {
+							runMigration()
+						}
+					}}
+				>
+					Run migration
+				</Button>
+			{/snippet}
+			<div class="flex flex-col h-full">
+				<Alert title="Changes to {drawerChange.tableName}" type="info">
+					{#if drawerDirection == 'ahead'}
+						You have made these changes in {currentWorkspaceId} that are not yet deployed in {parentWorkspaceId}.
+					{:else if drawerDirection == 'behind'}
+						These changes were made in {parentWorkspaceId} but the current workspace is not up to date.
+					{/if}
+				</Alert>
+				<!-- Diff section -->
+				<div style="height: 45%;">
+					<div class="py-1.5 text-2xs font-semibold text-secondary">
+						Schema diff (parent ↔ fork)
+					</div>
+					<div class="h-[calc(100%-28px)] border rounded-md overflow-clip">
+						{#await import('./DiffEditor.svelte')}
+							<div class="flex items-center justify-center h-full">
+								<Loader2 class="w-5 h-5 animate-spin" />
+							</div>
+						{:then Module}
+							<Module.default
+								open={true}
+								automaticLayout
+								className="h-full"
+								defaultLang="yaml"
+								defaultOriginal={yaml.original}
+								defaultModified={yaml.modified}
+								readOnly
+							/>
+						{/await}
+					</div>
+				</div>
+
+				<!-- SQL migration section -->
+				<div class="flex flex-col grow overflow-hidden mt-4">
+					<div class="py-1.5 text-2xs font-semibold text-secondary"> SQL migration </div>
+					<div class="grow overflow-clip rounded-md border">
+						<SimpleEditor class="h-full" lang="sql" bind:code={migrationSql} />
+					</div>
+				</div>
+			</div>
+		</DrawerContent>
+	{/if}
+</Drawer>
+
+<ConfirmationModal
+	open={confirmDeployOpen}
+	title="Deploy to parent workspace"
+	confirmationText="Run migration"
+	onConfirmed={async () => {
+		confirmDeployOpen = false
+		await runMigration()
+	}}
+	onCanceled={() => {
+		confirmDeployOpen = false
+	}}
+>
+	<p class="text-sm">
+		This will run the following SQL on workspace <b>{parentWorkspaceId}</b>:
+	</p>
+	<pre
+		class="mt-2 p-3 bg-surface-secondary rounded text-xs font-mono whitespace-pre-wrap max-h-60 overflow-auto"
+		>{migrationSql}</pre
+	>
+</ConfirmationModal>

package/package/components/DatatableSchemaDiff.svelte.d.ts

@@ -0,0 +1,29 @@
+import type { TableEditorValues } from './apps/components/display/dbtable/tableEditor';
+import { type AlterTableValues } from './apps/components/display/dbtable/queries/alterTable';
+import type { GetDatatableFullSchemaResponse } from '../gen';
+export type DatabaseSchema = Record<string, Record<string, TableEditorValues>>;
+export declare function apiSchemaToEditorSchema(apiSchema: GetDatatableFullSchemaResponse): DatabaseSchema;
+export type TableDiff = {
+    schemaName: string;
+    tableName: string;
+    kind: 'added' | 'removed' | 'modified';
+    operations?: AlterTableValues;
+};
+export type DatatableDiff = {
+    datatableName: string;
+    aheadChanges: TableDiff[];
+    behindChanges: TableDiff[];
+    originalSchema: DatabaseSchema;
+    parentSchema: DatabaseSchema;
+    forkSchema: DatabaseSchema;
+};
+export declare function diffDatabaseSchemas(original: DatabaseSchema, current: DatabaseSchema): TableDiff[];
+export declare function computeDatatableDiff(datatableName: string, originalSchema: DatabaseSchema, parentSchema: DatabaseSchema, forkSchema: DatabaseSchema): DatatableDiff;
+export declare function generateMigrationSql(change: TableDiff, sourceSchema: DatabaseSchema): string;
+interface Props {
+    currentWorkspaceId: string;
+    parentWorkspaceId: string;
+}
+declare const DatatableSchemaDiff: import("svelte").Component<Props, {}, "">;
+type DatatableSchemaDiff = ReturnType<typeof DatatableSchemaDiff>;
+export default DatatableSchemaDiff;

package/package/components/DedicatedWorkersSelector.svelte

@@ -224,12 +224,14 @@ $effect(() => {
     loadSelectedTagsInfo(selectedTags);
 });
 $effect(() => {
-    loadWorkspaces();
+    if (!disabled) {
+        loadWorkspaces();
+    }
 });
 async function loadWorkspaces() {
     try {
         workspacesLoading = true;
-        const ws = await WorkspaceService.listWorkspaces();
+        const ws = await WorkspaceService.listWorkspacesAsSuperAdmin();
         workspaces = ws.map((w) => ({ id: w.id, name: w.name }));
     }
     catch (e) {

package/package/components/DefaultTagsInner.svelte

@@ -3,25 +3,30 @@ import { ExternalLink, Loader2, Save } from 'lucide-svelte';
 import { SettingService, WorkerService, WorkspaceService } from '../gen';
 import { sendUserToast } from '../toast';
 import { enterpriseLicense, superadmin } from '../stores';
-import { DEFAULT_TAGS_PER_WORKSPACE_SETTING, DEFAULT_TAGS_WORKSPACES_SETTING, PREVIEW_TAGS_OVERRIDE_SETTING } from '../consts';
+import { DEFAULT_TAGS_PER_WORKSPACE_SETTING, DEFAULT_TAGS_WORKSPACES_SETTING, FORK_WORKSPACE_TAG_APPEND_FORK_SUFFIX_SETTING, PREVIEW_TAGS_OVERRIDE_SETTING } from '../consts';
 import Toggle from './Toggle.svelte';
 import MultiSelect from './select/MultiSelect.svelte';
 import { safeSelectItems } from './select/utils.svelte';
 import Badge from './common/badge/Badge.svelte';
 import Section from './Section.svelte';
+import ToggleButtonGroup from './common/toggleButton-v2/ToggleButtonGroup.svelte';
+import ToggleButton from './common/toggleButton-v2/ToggleButton.svelte';
 let { defaultTagPerWorkspace = $bindable(undefined), defaultTagWorkspaces = $bindable([]) } = $props();
 let defaultTags = $state(undefined);
 let limitToWorkspaces = $state(false);
 let previewTagsOverride = $state(false);
+let forkAppendForkSuffix = $state(false);
 // Change detection
 let originalDefaultTagPerWorkspace = $state(defaultTagPerWorkspace);
 let originalDefaultTagWorkspaces = $state(defaultTagWorkspaces);
 let originalPreviewTagsOverride = $state(false);
+let originalForkAppendForkSuffix = $state(false);
 // Detect changes
 let hasChanges = $derived(originalDefaultTagPerWorkspace !== defaultTagPerWorkspace ||
     JSON.stringify($state.snapshot(originalDefaultTagWorkspaces)?.sort() || []) !==
         JSON.stringify($state.snapshot(defaultTagWorkspaces)?.sort() || []) ||
-    originalPreviewTagsOverride !== previewTagsOverride);
+    originalPreviewTagsOverride !== previewTagsOverride ||
+    originalForkAppendForkSuffix !== forkAppendForkSuffix);
 let workspaces = $state([]);
 async function loadWorkspaces() {
     workspaces = (await WorkspaceService.listWorkspacesAsSuperAdmin()).map((m) => m.id);
@@ -39,6 +44,11 @@ async function loadDefaultTags() {
                 key: PREVIEW_TAGS_OVERRIDE_SETTING
             })) ?? false;
         originalPreviewTagsOverride = previewTagsOverride;
+        const forkSetting = (await SettingService.getGlobal({
+            key: FORK_WORKSPACE_TAG_APPEND_FORK_SUFFIX_SETTING
+        }));
+        forkAppendForkSuffix = forkSetting ?? false;
+        originalForkAppendForkSuffix = forkAppendForkSuffix;
     }
     catch (err) {
         sendUserToast(`Could not load default tags: ${err}`, true);
@@ -65,10 +75,17 @@ async function handleSave() {
             value: previewTagsOverride
         }
     });
+    await SettingService.setGlobal({
+        key: FORK_WORKSPACE_TAG_APPEND_FORK_SUFFIX_SETTING,
+        requestBody: {
+            value: forkAppendForkSuffix
+        }
+    });
     // Update original state after save
     originalDefaultTagPerWorkspace = defaultTagPerWorkspace;
     originalDefaultTagWorkspaces = [...(defaultTagWorkspaces || [])];
     originalPreviewTagsOverride = previewTagsOverride;
+    originalForkAppendForkSuffix = forkAppendForkSuffix;
     loadDefaultTags();
     sendUserToast('Saved');
 }
@@ -126,6 +143,29 @@ loadWorkspaces();
 				/>
 			</div>
 			{#if defaultTagPerWorkspace}
+				<div class="flex flex-col gap-1">
+					<span class="text-xs font-semibold">Fork workspace behavior</span>
+					<ToggleButtonGroup
+						selected={forkAppendForkSuffix ? 'parent-fork' : 'parent'}
+						onSelected={(v) => (forkAppendForkSuffix = v === 'parent-fork')}
+						disabled={!$enterpriseLicense}
+					>
+						{#snippet children({ item })}
+							<ToggleButton
+								value="parent"
+								label="Use parent workspace tag"
+								tooltip={'Fork jobs are tagged with the parent workspace id (e.g. python3-{parent_id}), so they are picked up by workers assigned to the parent workspace.'}
+								{item}
+							/>
+							<ToggleButton
+								value="parent-fork"
+								label="Use parent workspace tag + -fork suffix"
+								tooltip={'Fork jobs are tagged with the parent workspace id and a "-fork" suffix (e.g. python3-{parent_id}-fork), so all forks of a given parent share a dedicated tag. Route these jobs to workers provisioned specifically for forks of the parent.'}
+								{item}
+							/>
+						{/snippet}
+					</ToggleButtonGroup>
+				</div>
 				<Toggle
 					bind:checked={limitToWorkspaces}
 					options={{ right: 'only for some workspaces' }}

package/package/components/DeployWorkspaceDrawer.svelte

@@ -17,7 +17,7 @@ export async function openDrawer(initialPath_l, kind_l, additionalInformation_l)
 }
 </script>
 
-<Drawer bind:this={drawer} size="900px">
+<Drawer bind:this={drawer} size="1200px">
 	<DrawerContent title="Deploy {initialPath}" on:close={drawer.closeDrawer}>
 		{#if (kind != 'trigger' && kind != undefined && initialPath != undefined) || (kind === 'trigger' && initialPath != undefined && additionalInformation?.triggers != undefined)}
 			<DeployWorkspace