10 Commits

Author	SHA1	Message	Date
Guilhem Lemouel	d64d055018	Merge remote-tracking branch 'origin/main' into gl/layout-ai	2026-05-20 18:38:26 +02:00
Diego Imbert	0f7dd86e5c	feat: persistent in-editor drafts via UserDraft (#9121) ... * refactor(frontend): remove localStorage-backed autosave drafts Strip the per-editor localStorage autosave for flows, apps and raw apps, along with the associated restore toasts and diff actions, so we can replace them with a unified UserDraft service in a follow-up. The backend DraftService (DB-backed drafts) is untouched. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): add UserDraft service for per-workspace local drafts Introduces UserDraft, a key-value store keyed by `{workspace}/{itemKind}/{path}` and backed by localStorage. Supports save/get/remove plus a reactive use() handle so multiple component instances observing the same draft stay in sync via a shared $state loaded through useLocalStorageValue. Designed to host drafts for scripts, flows, apps, raw apps, resources, variables, and all trigger kinds. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * tests * nit schedule_ prefix * feat(frontend): persist deep mutations in useLocalStorageValue Track the serialized value alongside the $state and add an $effect that deep-reads it (via readFieldsRecursively). When a deep mutation produces a serialization that differs from the last persisted blob, write it to localStorage. The setter keeps writing synchronously so callers reading localStorage right after assignment still see the new value; the effect no-ops on those because lastSerialized was already updated by the setter. Undefined values are persisted as a removal. UserDraft no longer needs its own removeItem workarounds for undefined values — useLocalStorageValue handles that uniformly now. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): add defaultValue + empty-path handling to UserDraft UserDraft.use() accepts an opts.defaultValue used when no localStorage entry exists yet. It is not persisted on first read — only an actual mutation writes through. Empty paths (new items) bypass localStorage entirely. The entry still lives in the in-memory Map so multiple components on the same /add page share state, but save/get/remove/use never read or write localStorage with an empty path. Once the item is saved and the route navigates to its new URL, a fresh use() on the non-empty path takes over. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire script editor to UserDraft The script editor's top-level state now lives in UserDraft.use(), keyed on the route's path (page.params.path on /scripts/edit, '' on /scripts/add). Deep edits inside ScriptBuilder persist automatically; deploy and draft restore now call UserDraft.remove to clear the local autosave alongside the backend draft. Replaces the URL-hash autosave that ScriptBuilder used to write via replaceStateFn — that prop is now gone, the encodeScriptState debounce is gone, and Triggers no longer takes a saveSessionDraft callback. Viewing a specific historical hash (?hash=...) is kept draft-free by passing '' as the path. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire flow editor to UserDraft flows/add and flows/edit drive the flow value through a StateStore adapter backed by UserDraft.use, so every edit auto-persists at userdraft/w/{ws}/flow/{path} without touching FlowBuilder's internal .val convention. On returning visits the local autosave wins and a toast offers a diff against the latest backend draft/deployed version; on a fresh visit the backend value is written into the handle. Deploy, save-as-draft rename, restore-draft and restore-deployed each call UserDraft.remove on the route path so the local autosave doesn't outlive the action. Adds UserDraft.has() for "is there already a local draft?" detection in the load path. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire app editor to UserDraft AppEditor registers a UserDraft.use<App> handle for its current path (empty path for /apps/add stays in-memory) and a single $effect deep-tracks the internal stateApp and forwards every mutation to the handle. useLocalStorageValue's lastSerialized check then dedupes the actual localStorage writes per tick, so even fast drag/resize loops only persist when the JSON output really changes. /apps/edit overlays a local autosave from UserDraft.get on top of the backend value when one exists, with the existing "Discard / Show diff" toast wired to UserDraft.remove. Deploy, save-as-draft, restore-draft and restore-deployed all call UserDraft.remove on the relevant path, including the JSON editor save paths. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire raw app editor to UserDraft /apps_raw/edit owns the canonical raw-app state (files, runnables, data, summary) in four $state vars; a single $effect deep-tracks them and forwards the bundle to a UserDraft.use<RawAppDraft> handle so each mutation tick persists at userdraft/w/{ws}/raw_app/{path} (deduped by useLocalStorageValue's serialized check). On load the route overlays the local autosave on top of backend.draft/deployed and offers a "Discard / Show diff" toast when they diverge; matching local entries are silently dropped. Deploy, save-as-draft rename, restore-draft and restore-deployed each call UserDraft.remove on the route path. /apps_raw/add keeps the same shape (UserDraft.use with empty path) so the draft is in-memory only and we drop it explicitly when the initial save creates the real path. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire resource editor to UserDraft ResourceEditor registers a UserDraft.use<ResourceState> handle keyed on the initialPath (empty for new resources, in-memory only). A $effect deep-tracks the current workspace's edit state and forwards mutations to the handle; on bootstrap and lazy backend-fetch the local autosave wins over the backend value when they diverge. After a successful save() we call UserDraft.remove so the local autosave doesn't outlive the deploy. Cross-workspace deploys always start from the live backend value rather than the local draft. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire variable editor to UserDraft VariableEditor persists the current workspace's edit state via UserDraft.save on every mutation, keyed on editPath ('' for new variables → in-memory only). Backend fetches now overlay a matching local autosave when one exists, and initNew() rehydrates from the in-memory empty-path entry so opening a fresh "Add variable" drawer keeps any unsaved work from the previous open. After a successful save we drop the corresponding entry. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * editor external changes sync * fix(frontend): don't UserDraft.remove flows while route is still mounted The /flows/add and /flows/edit routes drive FlowBuilder from a flowStore whose getter reads flowHandle.draft directly. Calling UserDraft.remove synchronously before goto() therefore wiped the in-memory entry, made flowStore.val collapse to emptyFlow(), and tripped UnsavedConfirmationModal against the just-saved value — even though the deploy/save-draft itself succeeded. Drop those explicit removes in onSaveInitial, /add onDeploy, and /edit onDeploy. The empty-path entry self-cleans on unmount via onDestroy ref counting; for the non-empty edit path the next visit's load-time diff will silently overwrite localStorage when the local autosave matches the deployed value. Restore-draft/restore-deployed keep their explicit remove because they navigate to the same route (no modal) and loadFlow immediately rehydrates the handle. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * Revert "fix(frontend): don't UserDraft.remove flows while route is still mounted" This reverts commit 079ebef72b. * Only remove from localStorage * feat(frontend): saveInitialValue option on useLocalStorageValue The first time a value flows into a UserDraft.use() handle — typically the editor route loading the backend value via flowHandle.draft = backendFlow — is the baseline, not a user edit. Persisting it on the spot puts a copy of the backend into localStorage on every page open and produces spurious "local autosave" toasts on next visit when the serialization round-trips differently. useLocalStorageValue now takes options.saveInitialValue (default true, backward compatible). When false, the first time the serialised form of the state changes — via the setter or via a deep mutation — the lastSerialized cache is updated but localStorage is not touched. Every write after that persists normally. UserDraft.use() passes false. Tests updated to reflect the new contract (first write is the baseline) and a regression test added for the second-write-persists behaviour. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(frontend): persist full multi-workspace bundle for resources/variables ResourceEditor and VariableEditor can stage edits for several target workspaces in a single drawer session (see deployTo / states[ws] map). The previous UserDraft wiring only persisted states[$workspaceStore] — the user's session workspace — so any edit made under a different target workspace tab disappeared on refresh. Persist the entire `states: Record<wsId, State>` bundle as the draft value instead. On lazy-fetch we pick the local state for that ws if present and divergent from the backend; on bootstrap for new resources/variables we restore states for every workspace the user had staged. The localStorage key still lives under the user's session workspace via UserDraft, but its contents now cover all target workspaces from that session. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(frontend): bake parent_hash into the initial script load loadScript() assigned the backend value to scriptHandle.draft and then deep-mutated parent_hash on the next line. Under useLocalStorageValue's saveInitialValue=false contract only the very first write is the baseline — the parent_hash mutation right after counted as a second write and was persisted to localStorage, so opening an existing script would silently write a draft entry even though the user hadn't touched anything. Combine `parent_hash` (and the topHash override) into a single bakedBaseline so each branch of loadScript performs exactly one assignment to scriptHandle.draft. Mirrored across the local-autosave branch's discard callbacks too. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire SqsTrigger editor to UserDraft Persist the trigger's getSaveCfg() output to userdraft/w/{ws}/schedule_sqs/{path} on every edit, overlay any existing local autosave on top of the backend value when openEdit loads the trigger, and clear the entry on successful update. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire KafkaTrigger editor to UserDraft Same pattern as the Sqs trigger: persist getSaveCfg() on every edit, overlay any local autosave on top of the backend value when openEdit loads the trigger, drop the entry on successful update. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire NatsTrigger editor to UserDraft Same pattern as the Kafka trigger: persist getSaveCfg() on every edit, overlay any local autosave on top of the backend value when openEdit loads the trigger (with initialConfig/originalConfig snapshotted from backend first so hasChanged correctly reports the overlay as unsaved), drop the entry on successful update. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire MqttTrigger editor to UserDraft Same pattern: persist getSaveCfg() on edits, overlay local autosave in openEdit (with initialConfig/originalConfig snapshotted from backend first), drop the entry on successful update. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire GcpTrigger editor to UserDraft Same pattern as the other triggers. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire AzureTrigger editor to UserDraft Same pattern as the other triggers. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire WebsocketTrigger editor to UserDraft Same pattern as the other triggers. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire PostgresTrigger editor to UserDraft Same pattern as the other triggers. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire EmailTrigger editor to UserDraft Same pattern as the other triggers. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire HTTP RouteEditor to UserDraft Same pattern as the other triggers, keyed on schedule_http. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): wire ScheduleEditor to UserDraft Same pattern, keyed on schedule_schedule. ScheduleEditor doesn't track an originalConfig (its saveDisabled doesn't compare against a baseline) so ordering is simpler — initialConfig snapshotted from backend, local autosave overlaid after. This completes UserDraft wiring across all 11 trigger editors. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * refactor(frontend): rename schedule_* UserDraft kinds to trigger_* The schedule_ prefix grouped all the trigger editors under what looked like a "scheduler" namespace; trigger_ is what these actually are (triggers — including the cron-style schedule). Mechanical rename across UserDraftItemKind, every trigger editor's UserDraft.save/get/ remove calls, and the one test that asserted on the localStorage key. Behaviour-only impact: existing localStorage keys under userdraft/w/{ws}/schedule_{kind}/{path} from older builds will be ignored on next open (no schema migration). Users will lose any unsaved trigger drafts persisted before this change. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * refactor(frontend): wrap UserDraft localStorage payload as { value } localStorage entries now look like {"value": <draft>} instead of just <draft>. The wrapping is invisible at the API boundary — UserDraft.use, .save, .get, .remove all still operate on the unwrapped draft value — but it leaves room to add metadata (timestamps, originating user, schema version, ...) later without breaking existing entries. Internals: - StoredDraft<V> = { value: V } is what we serialise to localStorage and what useLocalStorageValue's $state holds. - wrap()/unwrap() helpers gate the boundary; the handle returned by use() unwraps on get and wraps on set. - readPersisted() defensively drops entries whose payload isn't a { value: ... } object, so pre-migration drafts written by earlier commits on this branch are simply ignored (has() returns false, get() returns undefined) rather than confusingly surfacing as undefined-shaped drafts. Test data switched from { value: X } (which collides confusingly with the wrapper shape) to plain primitives / objects, plus a regression test for the pre-migration ignore behaviour. 28 tests pass. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(backend): expose freshness for UserDraft staleness check Variable - Add `edited_at TIMESTAMPTZ NOT NULL DEFAULT now()` + `edited_by VARCHAR(50)` to the `variable` table (parity with `resource`); set them on INSERT and on every UPDATE. - Surface them on `ListableVariable` so `getVariable` / `listVariable` return them. DB drafts (script, flow, app/raw_app) - The `*WithDraft` endpoints now also return `draft.created_at` as `draft_created_at`. The draft value alone wasn't enough to tell whether a teammate (or another tab) had pushed a fresh draft while local autosave was in flight; the new field is the staleness signal. - Wired in `get_script_by_path_w_draft` (`ScriptWDraft.draft_created_at`, including the `prefetch_cached` forwarding), `get_flow_by_path_w_draft` (`FlowWDraft.draft_created_at`), and `get_app_w_draft` (`AppWithLastVersionAndDraft.draft_created_at`). OpenAPI updated to match. The frontend will read these in a follow-up to implement the local-draft staleness check; this commit only widens the API surface. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): track remote rev metadata on UserDraft entries Extends StoredDraft<V> with two optional rev fields used by the forthcoming staleness modal: - remoteRev — the deployed version's id/hash/timestamp at the moment the local draft was created. Compared against the latest deployed rev on reload. - remoteDraftRev — the DB-draft created_at at the moment the local draft was created. Only meaningful for kinds that have a DB draft (script, flow, app, raw_app). Checked first so a teammate's draft push is detected before the "deployed version moved" case. API additions on the handle returned by UserDraft.use(): - handle.meta — read the rev metadata currently stored. - handle.setDraftAndMeta(value, meta) — atomic write of value + meta in a single state.val assignment. Editor routes use this on load so the baseline rev rides along with the value without consuming the saveInitialValue=false dedup slot twice. - handle.setMeta(meta) — update just the rev metadata after the user picks "Keep current draft" in the staleness modal. - handle.draft = X — unchanged surface; now preserves existing rev metadata across user edits. Plus UserDraft.getMeta() and UserDraft.save() preserves any persisted rev metadata when called without a live handle. 7 new tests cover the metadata surface; all 35 pass. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(frontend): staleness modal for the script editor's local autosave Replace the script editor's toast-based "Discard / Show diff" pattern with a dedicated modal that surfaces *why* the local autosave is out of date: a new DB draft on the server, or a new deployed version. Adds `checkStaleness` (UserDraftMeta vs current backend revs, draft-rev priority) and a `setMeta({ force: true })` mode so the "Keep current draft" acknowledgement persists even when it happens to be the entry's first state mutation — under `saveInitialValue: false` an ack-only setMeta would otherwise be skipped and the modal would re-fire on next mount. The modal lives at LocalDraftStaleModal.svelte; the script editor wires it as a template for the remaining editors. Other editors (flows, apps, raw_apps, resources, variables, triggers) still use the previous toast pattern and will be migrated in follow-up commits. * feat(frontend): staleness modal for flow, app, and raw-app editors Migrates the flow, app, and raw_app editor routes to the same `LocalDraftStaleModal` flow already used by scripts: compare the recorded meta against the current `version` / `versions[last]` and `draft_created_at`; on mismatch, surface the choice in a modal. Adds `UserDraft.saveMeta` for routes that don't hold a live handle (the app editor reads via `UserDraft.get` and the handle lives in the child `AppEditor` component). It writes meta directly to localStorage and tolerates the no-entry case. * feat(frontend): migrate legacy localStorage autosave entries Apps and flows used to autosave under un-scoped keys (`flow`/`flow-{path}`, `app`/`app-{path}`, `rawapp`/`rawapp-{path}`) with a base64-encoded state envelope. This adds a one-off migration that rewrites surviving legacy entries under the workspace-scoped `userdraft/w/{ws}/{kind}/{path}` keys with the new `{ value }` wrapper, transforms the payload where the shape differs (drops the flow view-state envelope, defaults the new raw-app `summary` field), and drops the source key. The migration lives in its own file (`userDraftLegacyMigration.ts`) so the new UserDraft service stays free of legacy decoders. Idempotent via a `userdraft/legacy_migrated_v1` sentinel; runs from the logged-in root layout once a workspace is known. Defensive shape checks avoid clobbering co-resident apps that happen to use the same key prefixes. * nit remove comments * refactor(frontend): per-workspace UserDraft handles in Resource/Variable editors Earlier commits in this PR wired the resource and variable editors to a single multi-workspace bundle stored under the user's session workspace key — which mixed workspaces in one localStorage entry and required a custom multi-key fix-up pass to persist edits for other workspaces. Reset both editors to their pre-PR shape and apply the minimal change: the per-workspace `Record<string, ResourceState>` (resp. `VariableState`) becomes `Record<string, UserDraftHandle<…>>`, with one handle per workspace created via `UserDraft.use(…, { workspace: ws })`. The handle keys its own localStorage entry under that workspace, so cross-workspace edits stay cleanly separated and reactivity flows through the handle's `draft` accessor — `bind:` on form fields just works. Adds `manualRelease: true` + `handle.release()` to `UserDraft.use` so the editors can register handles lazily inside an effect (Svelte 5 forbids `onDestroy` outside component init). The editors register a single top-level `onDestroy` that releases every collected handle. After a successful save, the per-workspace autosave is cleared via `UserDraft.remove(itemKind, path, { workspace })`. * refactor(frontend): seed per-workspace handles via UserDraft.use defaultValue ensureHandle was doing a post-hoc `if (h.draft === undefined) h.draft = baseline`, which relies on the saveInitialValue=false skip to swallow that seeding write. Hand the baseline to `UserDraft.use({ defaultValue })` instead — useLocalStorageValue uses it as the initial $state value when localStorage is empty, so lastSerialized is correct out of the gate and no setter call is needed. * feat(frontend): persist empty-path drafts across reloads Empty paths used to be in-memory only (via the `isLocalOnly` short-circuit) because we worried about collisions between concurrent /add tabs. The user asked for the trade-off to flip: a /flows/add or /scripts/add reload should restore the user's work, while explicitly clicking "+ Flow / + Script / …" should always open a clean editor. - Drop `isLocalOnly` from UserDraft so empty-path entries persist under `userdraft/w/{ws}/{kind}/` like any other path. The existing per-kind refcounting and saveInitialValue=false behavior already handle them correctly — the change is just lifting the bypass. - Each /add page now calls `UserDraft.remove(kind, '')` synchronously when `?nodraft=true` is present in the URL, before the handle is created. - The two "+" entry points that lacked the `?nodraft=true` flag (CreateActionsScript's plain `<a href>` and CreateActionsFlow's YAML/JSON import paths) now include it, so every fresh-start path goes through the wipe. - Tests updated: the "empty path (in-memory only)" block becomes "empty path (persists across reloads)" and asserts the new behavior. * refactor(frontend): drop legacy-migration shape guard We assume Windmill is the only app on the origin, so the isPlausibleLegacyValue per-kind shape check was just dead weight. Keep the cheap "decoded is an object" guard for malformed payloads. * docs(frontend): refresh stale "in-memory only" comments around empty paths Empty-path UserDraft entries persist now. Drop the leftover "in-memory only" comments on the /add pages' handle creation, and rewrite the EditorHeader save-initial-draft comments to describe why the UserDraft.remove call is still needed: the draft was promoted to a real path on the backend, so the prior-path autosave must not shadow a future "+ App" / "+ Flow" / … visit. * fix(frontend): strip ?nodraft=true from /add URLs synchronously The previous cleanup ran in afterNavigate, which (a) fires asynchronously — a quick reload between mount and the callback would re-wipe the freshly-started draft — and (b) did `url.search = ''`, nuking sibling params like ?template, ?hub, and ?wac. Move the URL cleanup to the same synchronous block that calls UserDraft.remove on nodraft, using `window.history.replaceState` so it lands before paint. Only the `nodraft` key is removed — other params survive. * feat(frontend): toast when editor opens on a local autosave When a route loads its local autosave (differs from backend, no staleness alarm), surface "Restored from local storage" with up to two reset actions: - "Reset to saved draft": drop the autosave, reapply the backend DB draft. Only shown when the backend has a DB draft. - "Reset to deployed": drop the autosave, delete the DB draft on the backend (if any), reload from the deployed version. Only shown when the item has a deployed version. The toast title + label wording + per-state inclusion live in a single helper (`$lib/userDraftToast`). Each editor passes its own reset callbacks since the side effects differ per route (handle vs UserDraft.get/save, redraw counters, loadXxx helpers). Wired to scripts/edit, flows/edit, apps/edit, apps_raw/edit. Resource and variable editors don't have DB drafts and use per-workspace handles — a follow-up will tailor a single-action version. * feat(frontend): load URL-encoded scripts on /scripts/add The "Fork" action on run/[...run] and several workspace-settings helper-script templates base64-JSON-encode a NewScript into the URL hash on `/scripts/add#...`. Until now /scripts/add silently dropped that payload — both call sites landed on a blank editor. Decode `page.url.hash` at module top, and if it parses to an object, apply it as `scriptHandle.draft` and surface "Loaded from URL". The URL value wins over local autosave, ?template, ?hub, and YAML imports because the hash represents an explicit "open this script" intent. Parsing is inlined rather than reusing `decodeState` so an unrelated hash (e.g. a future route anchor) doesn't fire its default "Impossible to parse state" error toast. * feat(frontend): strip URL hash from /scripts/add after consumption The URL-encoded script is a one-shot seed (Fork preview, workspace handler templates, hub publish) — keeping the hash in the bar after loading meant a reload would re-apply the original payload and wipe whatever the user edited since landing. After applying `urlScript` and firing the "Loaded from URL" toast, clear `location.hash` via `window.history.replaceState`. The user's edits then flow into the normal autosave path (UserDraft empty-path entry), and a reload restores those edits instead of the seed. * feat(frontend): load URL-encoded scripts on /scripts/edit + consume-once Mirror the URL-hash seed mechanism from /scripts/add to /scripts/edit for parity: decode the base64-JSON-encoded NewScript payload from the URL hash, apply it over the bakedBaseline as the editor's initial state, send "Loaded from URL", and strip the hash immediately via window.history.replaceState so a reload restores the user's autosave rather than re-injecting the seed. The seed wins over local autosave + backend draft + deployed — UserDraft.remove(script, draftPath) drops the stale autosave on disk before setDraftAndMeta writes the seeded value, so the user's subsequent edits will overwrite cleanly. Skipped when ?hash= is in the URL (historical-version view, which is read-only relative to drafts) and when the hash fragment isn't a parseable encoded payload. No callers build /scripts/edit#<encoded> URLs today — this lands the mechanism for future symmetry with /scripts/add. * fix(frontend): "Reset to deployed" loop on Restored-from-local toast UserDraft.remove only clears localStorage — the entry's reactive cell stays alive as long as some component holds a handle. The toast callback was relying on remove+loadXxx to reset state, but loadXxx then read the *in-memory* autosave through the still-alive entry, matched it against the now-deployed reference, and re-fired the same toast. Forever. Drop the in-memory state explicitly before the load: - scripts/flows/apps_raw (route-level handle): `handle.setDraftAndMeta(undefined, {})` - apps (handle lives in the AppEditor child): set `app = undefined` to unmount AppEditor — its onDestroy releases the handle and the entry's refcount drops to 0, destroying the entry. ScriptBuilder / FlowBuilder / RawAppEditor briefly unmount while the reload fetches; the flash is the user-visible "loading" cue. * fix(backend): convert draft.created_at to TIMESTAMPTZ The new `*WithDraft` endpoints surface `draft.created_at` as `Option<chrono::DateTime<Utc>>` for the frontend's staleness check, which requires `TIMESTAMPTZ`. The column was originally created as plain `TIMESTAMP`, so SQLx fails to deserialize any row that has a non-null draft and the handler returns HTTP 400 instead of 200 — caught by `test_draft_endpoints` in the integration tests. Migrate the column to `TIMESTAMPTZ`, interpreting existing values as UTC (matching `now()`'s behaviour on a UTC server). No compile-time sqlx queries reference the column, so the offline cache stays valid. * fix(frontend): settings drawer auto-opening on /scripts/edit ScriptBuilder's metadataOpen flag fires when `initialPath == ''` (the heuristic for "new script, expected on /scripts/add"). The route's `let initialPath = $state('')` left it empty until applyBaseline ran later inside loadScript. Pre-PR, the editor was gated on a route-level `script` $state that started undefined, so ScriptBuilder didn't mount until loadScript's synchronous block set both `script` and `initialPath` in the same tick. With UserDraft.use reading localStorage synchronously, the gate (`scriptHandle.draft`) is satisfied at mount time and ScriptBuilder mounts with the still-empty initialPath, popping the drawer open. Seed initialPath from page.params.path synchronously so ScriptBuilder sees the path on its first render. Falls back to '' for the historical `?hash=` view to preserve the existing behaviour there. * fix(backend): refresh draft.created_at on every upsert The draft upsert was `ON CONFLICT (...) DO UPDATE SET value = EXCLUDED.value`, so subsequent draft writes left `created_at` frozen at the first INSERT. The frontend's UserDraft staleness check reads that timestamp as `remoteDraftRev`; with it frozen, an updated remote draft looked identical to the originally-baselined one and the "newer draft was saved on the server" modal never fired. Touch `created_at` on conflict too. The column's semantic widens from "first write time" to "last write time", which is what every reader of the field actually wants — the staleness signal is the only consumer. SQLx offline cache regenerated to match the new query text. * fix(frontend): persist trigger drafts in script-editor autosave The triggers in ScriptBuilder live in a dedicated `triggersState` $state, separate from the `script` object that the UserDraft handle deep-tracks. Pre-PR the per-builder localStorage autosave bridged the two by snapshotting `triggersState.getDraftTriggersSnapshot()` into the payload on every write — that bridge was dropped when we removed the per-builder autosave in favour of UserDraft. Add an $effect that deep-reads triggersState and mirrors the snapshot back into `script.draft_triggers`. The UserDraft handle (already deep-tracking `script`) then persists the trigger drafts as part of the script autosave, restoring the prior behaviour. * feat(frontend): debounce option on useLocalStorageValue + 500 ms in UserDraft.use Adds `debounce: number` to `useLocalStorageValue`'s options. When set, repeated mutations within the window collapse into a single localStorage write fired by a plain `setTimeout`. The in-memory `$state` is updated on every change so readers of `.val` always see the latest value; only the persistence side-effect is deferred. No `onDestroy` flush — the timer is independent of the Svelte lifecycle, so SPA route teardown doesn't drop the pending write (the callback still fires later as long as the JS context is alive). A hard browser tab close within the window does drop it; that's an acceptable trade-off vs the complexity of `beforeunload` listeners and the leak/refcount issues they create alongside `useLocalStorageValue`'s keyed instances. `UserDraft.use` opts in with `debounce: 500` so a typing storm in the script/flow/app editor produces one localStorage write per 500 ms instead of one per keystroke. Tests switch to `vi.useFakeTimers()` and a `flushPersist()` helper to keep the synchronous `expect(localStorage…)` assertions working. New test verifies the coalescing behaviour end-to-end. * fix(frontend): tighten legacy-migration key matching The legacy migration was consuming any localStorage key starting with `app-`, `flow-`, or `rawapp-`, with no constraint on what followed and no shape check on the decoded payload. Two failure modes called out in review: 1. A future feature (or third-party extension) picking a name like `app-recent` would silently lose data on first migration run. 2. A stray key that happened to base64-decode to valid JSON but wasn't a real legacy draft would still get promoted to the new format, surfacing later as a phantom "Restored from local storage" toast on the next edit. Two guards: - `LEGACY_PATH_SHAPE = /^[uf]\/[^/]+\/.+$/`: after a `<prefix>-` match, the remainder must look like a Windmill item path (`u/owner/name` or `f/folder/name`, possibly with deeper segments). Bare-prefix empty-path entries (`app` / `flow` / `rawapp` for `/add` autosaves) still match the exact branch and don't go through the shape gate. - `isPlausibleLegacyValue`: after decode, require the payload to carry the field the legacy writers actually produced (`flow.flow` for flows, any of `summary|value|policy|path` for apps, any of `files|runnables|data` for raw apps). Both are belt-and-suspenders: nothing else currently uses these key prefixes, but enforcing the shape locally keeps the migration safe against future namespace collisions. * fix(backend): drop AT TIME ZONE 'UTC' from draft.created_at migration The original migration forced `USING created_at AT TIME ZONE 'UTC'`, which tags every existing wall-clock value as UTC. That matches the common case (Postgres on a UTC server, which the Docker image and most managed offerings default to), but on a non-UTC operator's deployment it shifts all pre-migration timestamps by the server's tz offset. Drop the USING clause. Postgres's default `TIMESTAMP -> TIMESTAMPTZ` cast reinterprets each existing value in the session's current timezone — which is the same timezone under which the original `INSERT ... DEFAULT now()` values were truncated to TIMESTAMP, so the conversion correctly recovers the original instant regardless of the operator's timezone. Same semantics on UTC servers, correct semantics on non-UTC servers. Down migration updated symmetrically. * docs(frontend): clarify staleness modal copy The four route-level editors (scripts/flows/apps/apps_raw) keep the user's local draft visible behind the modal so they can glance at it before choosing. The old body text described the situation (server has moved on, local autosave is behind) but didn't say what's actually on screen or how each action maps to it. New body leads with "The editor is showing your local autosave" and spells out each action: "Load latest replaces what's on screen; Keep current leaves it alone." Same copy for both `cause = 'draft'` and `cause = 'version'`, branching only on what the user is "behind" relative to. * refactor(frontend): drop dead updateDraftCallback from Triggers constructor None of the eight `new Triggers(...)` call sites pass an update callback any more — the bridge was a leftover from the pre-UserDraft era when ScriptBuilder ran its own localStorage autosave and had to be notified on every triggers mutation. The unified UserDraft handle now deep-tracks `script.draft_triggers` via the $effect in ScriptBuilder, so the callback channel is dead weight. Removes the third constructor parameter, the private field, and the six `this.#updateDraftCallback?.()` invocations across setters and mutators. * docs: review nits — variable.edited_at backfill, UserDraft toast/modal headers Three low-priority callouts: - Document the variable.edited_at backfill in the migration. All existing rows get a single `now()` timestamp from the column DEFAULT; the staleness check only consumes the field as an opaque rev string and never displays/sorts on it, so the collision is harmless — but worth saying out loud. - Add module headers to userDraftToast.ts and LocalDraftStaleModal.svelte explaining how this layer sits above the per-browser UserDraft autosave and is distinct from the backend DraftService (the server-side "Save as draft" feature surfaced as `*.draft`). * refactor(frontend): replace UserDraft.release() with useMany() Public surface change: - New `UserDraft.useMany(getSpecs: () => UserDraftSpec<V>[])` returns a reactive array of handles. The reconcile loop acquires entries for added specs, releases entries for removed specs, and re-uses cached handles for unchanged keys so caller-captured references stay stable. - `UserDraft.use(kind, path, opts?)` becomes a 1-len wrapper around `useMany`. The spec getter is `untrack`ed so reactive opts (`$workspaceStore` etc.) are still captured-once — current `use()` semantics unchanged. - `UserDraftHandle.release()` and the `manualRelease` option are gone. Component teardown is handled by a single internal `onDestroy` that releases every entry `useMany` acquired. ResourceEditor + VariableEditor migrated: - Replaced `Record<ws, Handle>` + manual `ensureHandle`/`release` with a `workspaceSpecs: $state<Array<{ws, defaultValue}>>` plus a derived `Record<ws, Handle>` that pairs each ws with its parallel handle from `useMany`. `ensureHandle(ws)` is now just a push to the specs array; `VariableEditor.reset()` clears it. The reconcile loop handles acquisition/release end-to-end. Tests: - Dropped the `manualRelease`/`release` test; the option no longer exists. - Added a `useMany` test asserting per-spec entries, isolated workspace-scoped localStorage keys, and a single onDestroy registration covering every acquired entry. Implementation note: I tried wrapping `useLocalStorageValue` in `$effect.root` to give the entry's `$state`/`$effect` an independent scope (in case `useMany`'s reconcile effect tore down nested effects across cycles). But `$effect.root`'s callback wasn't running synchronously in the test runtime (vitest + svelte-vite plugin), and the original `use()` implementation called `useLocalStorageValue` directly without issue. Reverted to the direct call; the nested-scope concern stays theoretical. * fix(frontend): isolate UserDraft entries via $effect.root The previous commit landed `useMany` calling `useLocalStorageValue` directly. That works for the `use()` 1-spec wrapper (whose getter is untracked, so the reconcile `$effect` never re-runs), but for dynamic specs (ResourceEditor / VariableEditor) it leaks the persist `$effect` into the reconcile `$effect`'s scope — meaning the second spec change would destroy the first entry's deep-mutation persist loop. Wrap the `useLocalStorageValue` creation in `$effect.root` so the entry's reactivity lives in its own scope. Stash the returned disposer on the entry and invoke it when the refcount hits 0. The vitest runtime's `$effect.root` returns its disposer but never runs the callback (a test-env quirk, not a production behaviour). Kept a documented fallback that calls `useLocalStorageValue` directly when the callback doesn't populate `stateRef`. In tests that path parents the persist `$effect` to the test scope and lives long enough; in production `$effect.root` runs the callback synchronously per the Svelte 5 spec and the fallback is unreachable. * chore(frontend): drop leftover console.log in setDraftConfig Co-authored-by: Diego Imbert <diegoimbert@users.noreply.github.com> Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * fix(frontend): wire ?nodraft=true to actually skip the local autosave on /edit The flows/apps/apps_raw `/edit` routes had a `?nodraft=true` handler that just stripped the param from the URL via `afterNavigate` — nothing behind it. The original pre-PR semantics (and what every caller assumes) was "skip the localStorage autosave on this load." Mirror the synchronous wipe pattern already in /add: when nodraft is present, call `UserDraft.remove(kind, path)` and strip the flag from the URL via `window.history.replaceState`, before the UserDraft handle is created. The handle then reads an empty entry and the editor opens on the backend version. A plain reload (no nodraft) restores the autosave normally. Removed the redundant `afterNavigate` blocks. Dropped the now-unused `afterNavigate` import in all three; apps/edit still imports `replaceState` (used downstream), so only that name stayed. * feat(frontend): GC UserDraft entries older than 30 days Without a sweep, a heavy user accumulates one localStorage entry per (workspace, kind, path) they ever touched. The pre-PR single-key autosave self-capped at one entry per editor; this one needs an explicit GC pass. Mechanism: - Stamp every persist with `lastWrittenAt: Date.now()`. Added at four sites: `useLocalStorageValue`'s new `transformBeforePersist` option (covers both setter and deep-mutation persists), `UserDraft.save`'s no-handle fallback, `persistDirect` (force-meta writes), and the legacy migration. Done at persist time, not in `wrap()`, so deep mutations bump the clock too — `wrap()` runs only on `.draft =` assignments, which would leave the timestamp stale for bind-mutated editor sessions. - `gcUserDrafts(maxAgeMs = 30d)` walks every `userdraft/w/...` key, removes the ones older than the cutoff. Entries written before this field existed (pre-PR or pre-this-commit) get backfilled with the current time on first sweep so a 30-day clock starts fresh; the alternative — sweeping on sight — would wipe work that the legacy migration just rescued. - Wired into the logged-in layout: runs once on mount and every 30 min via `setInterval` (cleaned up in the effect's return). Tests use `vi.setSystemTime` to drive the clock; assertions on the stored payload now go through a `storedShape` helper that strips `lastWrittenAt` before string-comparing, so the existing `expect(...).toBe(wrapped(...))` style still reads cleanly. New tests cover the sweep, the backfill behaviour, the default 30d window, and a custom `maxAgeMs`. * fix(frontend): break useMany reconcile feedback loop The reconcile effect read `handles.length` / `handles[i]` for the "unchanged?" early-exit optimisation and then `handles.splice(...)` to publish the new array. Reading `handles` inside the effect registered it as a dependency; the subsequent splice re-fired the effect; ad infinitum (Svelte threw `effect_update_depth_exceeded`). Wrap the comparison reads in `untrack` so the effect's only tracked dependency stays `getSpecs()`. The splice still fires the downstream readers of `handles` (the whole point of `useMany`'s reactivity); it just doesn't re-enter its own producer. * fix(frontend): untrack the splice's own .length read in useMany reconcile The previous fix wrapped only the comparison reads in `untrack`, but `handles.splice(0, handles.length, ...next)` still reads `.length` under the effect's tracking scope — same feedback loop, same `effect_update_depth_exceeded`. Move the whole "compare + splice" block inside `untrack`. The downstream notification on splice still fires (untrack suppresses dependency subscriptions on the producer side, not write notifications), so consumers of `handles` still re-render. * nit * fix(frontend): drop in-memory handle before reloading after DB-draft discard When the "Script/flow loaded from latest saved draft" toast's "Reset to deployed" action ran, it: 1. Deleted the DB draft via DraftService.deleteDraft. 2. Called UserDraft.remove (clears localStorage only). 3. Called goto + loadScript / loadFlow. But the handle's in-memory state still held the now-deleted DB draft and its meta (remoteDraftRev pointing at the gone draft's created_at). On the reload, the editor's loadScript/loadFlow saw `localDraft != undefined` and ran the staleness check, which compared `meta.remoteDraftRev = <old timestamp>` against `currentDraftRev = undefined`. Verdict: "version" stale → spurious "A newer version was deployed on the server" modal, even though nothing on the server actually moved. The editor visibly froze behind the modal because the in-memory state wasn't refreshed. Drop the in-memory state with `handle.setDraftAndMeta(undefined, {})` before the reload — same fix already applied to the "Restored from local storage > Reset to deployed" toast action. apps/edit and apps_raw/edit's "discard draft" actions don't call DraftService.deleteDraft (they just swap the in-memory view to the deployed branch), so they don't hit this codepath. * fix(frontend): drop in-memory handle in DiffDrawer restoreDraft/restoreDeployed Same UserDraft.remove-without-clearing-in-memory bug as the previous two commits, this time in the DiffDrawer's "Restore to draft" / "Restore to deployed" buttons on all four /edit routes. The handler deletes the DB draft (in the deployed case), wipes the localStorage entry, navigates, and reloads — but the route's UserDraft handle still holds the old draft + meta in memory, so the reload's staleness check compares the stale meta against the freshly fetched backend and surfaces a spurious "newer version was deployed" modal. - scripts/edit, flows/edit, apps_raw/edit: route-level handle — `handle.setDraftAndMeta(undefined, {})` before the reload. - apps/edit: the handle lives in the AppEditor child, so force a remount by setting `app = undefined; redraw++` before goto/loadApp (matches the existing pattern from the toast's onResetToDeployed). * fix(frontend): legacy app migration matches actual stored shape Legacy AppEditor wrote `encodeState($appStore)` — the inner App value (grid/fullscreen/theme/unusedInlineScripts/hiddenInlineScripts), not the wrapping AppWithLastVersion. The plausibility check was matching the wrapping fields, so real legacy app entries were filtered out and never migrated to the new userdraft/w/{ws}/app/{path} keys. * fix(frontend): untrack meta-preservation reads in UserDraft setters `set draft`, `setMeta`, `UserDraft.save`, and `UserDraft.saveMeta` all read `state.val` before writing it (to preserve existing rev metadata). When called from inside a `$effect` — as AppEditor does to mirror its reactive `$state` into the handle — the read subscribes the effect to the entry's `$state` cell that the write then mutates, producing an `effect_update_depth_exceeded` loop. Wrap the reads in `untrack` so mirrors don't self-trigger. * fix(frontend): apps detect drift + restore on /apps/add reload Two related issues in the app editor's UserDraft wiring: 1. Drift wasn't detected on first deploy/draft after starting an autosave. The route only backfilled meta on a reload that found a local diff — so the first external change after editing slipped through with empty `previousMeta`. AppEditor now receives the load-time revs as `initialRevs` and seeds them into the handle's meta on the first mirror, capturing the rev at autosave-creation time. 2. /apps/add didn't restore from LS on plain reload. The route always initialised `value` to `emptyApp()` and the AppEditor's `stateApp` captured the prop unconditionally, so the LS autosave was shadowed. `stateApp` now falls back to `appDraftHandle.draft` when present; the template/hub/import branches explicitly `UserDraft.remove('app', '')` to keep "start fresh from this content" semantics. Also work around `useLocalStorageValue`'s `saveInitialValue: false` skip slot — in the mirror pattern the slot survived past mount and swallowed the user's first edit. Consume it up-front with a wipe-then-restore pair so subsequent edits persist normally. * feat(frontend): restored-from-local toast in resource/variable editors Resource and variable editors silently loaded LS autosaves over the backend value, leaving users with no signal that the form wasn't reflecting deployed state. Both now fire the standard `notifyRestoredFromLocal` toast (with a "Reset to deployed" action that re-seeds the handle from the just-fetched backend) the first time a lazy-fetch finds the local draft diverging from the remote. * fix(frontend): add UserDraft.discard so "Reset to deployed" doesn't re-persist The "Reset to deployed" toast action in resource/variable editors called UserDraft.save with the backend value to repaint the form. That left a duplicate-of-backend autosave in localStorage which would silently restore on every subsequent reload, defeating the reset. New UserDraft.discard(itemKind, path, fallback) clears LS AND resets any live handle's in-memory state to the fallback, skipping the next persist so the fallback doesn't round-trip back into storage. Backed by a new `skipNextWriteOnce()` method on useLocalStorageValue's return. * fix(frontend): use UserDraft.discard in apps reset flows The apps editor route doesn't hold the UserDraft handle — AppEditor (the child remounted by {#key redraw}) does. When a reset action ran `UserDraft.remove` + `redraw++`, Svelte could mount the new AppEditor before the old one's onDestroy released its handle, leaving the entry's in-memory state.val populated with the stale autosave. The new AppEditor would then re-acquire that entry and shadow the just-emptied localStorage. Switch every reset path (stale modal Load latest, restored-from-local toast, DiffDrawer restoreDraft/restoreDeployed) to `UserDraft.discard` so the in-memory cell is cleared synchronously alongside LS. Also plumb `currentRevs` updates so the next mount's initialRevs reflects the acked state. * fix(frontend): /flows/add restores autosave on plain reload `loadFlow()` initialised the local `flow` variable to `emptyFlow()`, then passed it to `initFlow` which writes it to `flowStore.val` (= `flowHandle.draft = flow`). On a bare /flows/add reload (no template/hub/import/fork/urlHash) the assignment overwrote the persisted autosave with the empty baseline. Seed `flow` from `flowHandle.draft` instead, and keep `emptyFlow()` as the explicit "start fresh" baseline for template/hub branches. * nit rename * fix(frontend): snapshot UserDraft proxy before structuredClone in resource save `states[ws].draft` is now a Svelte $state proxy (it flows through UserDraft's useLocalStorageValue cell). `structuredClone` can't clone a proxy and threw "Failed to execute 'structuredClone' on 'Window'", blocking resource saves. Snapshot to a plain object via `$state.snapshot` before assigning the dirty baseline. * fix(frontend): raw app deploy toast crash + harden Toast against bad type RawAppEditorHeader's catch blocks called `sendUserToast(msg, e)`, passing an Error as the `_type` arg. `classes[<Error>]` is undefined so `color.descriptionClass` threw — and because the toast renders in the root layout, it crashed the whole page on raw app deploy/create. Fixed both call sites to the proper `(msg, true)` error form. Also hardened Toast.svelte: coerce any non-AlertType `type` to 'error' so a future miscall degrades to a plain error toast instead of taking down the page. * fix(frontend): /apps_raw/add restores autosave on plain reload The route initialised files/runnables/data/summary to hardcoded defaults, and the $effect mirror then wrote those defaults over the persisted empty-path autosave. Seed the $state from `draftHandle.draft` instead; import/template/hub branches `UserDraft.remove('raw_app', '')` for explicit "start fresh" semantics. Also consume useLocalStorageValue's saveInitialValue=false skip slot (wipe-then-restore) so the user's first edit isn't dropped. * feat(frontend): staleness modal in resource/variable editors Resource/variable editors only showed the restored-from-local toast; they never surfaced the staleness modal when the backend item moved on since the local autosave was written. Wire LocalDraftStaleModal + checkStaleness using the backend `edited_at` as `remoteRev` (these items have no DB-draft concept). Meta is backfilled on reload for legacy autosaves and seeded on the first real edit via a guarded effect, so an external edit is detectable as drift. Per-workspace detection; the modal is a singleton driven by `pendingStale`. * feat(frontend): restored-from-local toast in standalone trigger editors The schedule/postgres/http/kafka/websocket/email/sqs/nats/gcp/azure/ mqtt editors silently overlaid the local UserDraft autosave on top of the backend config in `openEdit`, with no signal that the form wasn't showing deployed state. Each now snapshots the just-loaded backend config, then fires `notifyRestoredFromLocal` with a "Reset to deployed" action that drops the LS entry and re-applies the snapshot. * fix(frontend): trigger autosave no longer false-restores on plain open Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * refactor(frontend): live UserDraft handle for trigger editors Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * refactor(frontend): live UserDraft sync for raw app editors Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * refactor(frontend): extract useTriggerDraftSync composable Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * docs(frontend): trim rot-prone comments in UserDraft Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * in /script, put code state in URL --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com> Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com> Co-authored-by: Diego Imbert <diegoimbert@users.noreply.github.com>	2026-05-20 14:58:26 +00:00
Guilhem Lemouel	7e38c01e64	feat(sessions): chat + editor side-by-side with multi-session state ... Introduces the Sessions feature: a workspace where the AI chat and an editor (flow / script / app / raw-app) sit side-by-side, with each session having its own AIChatManager instance, history, and target item. Sessions are persisted across reloads and can be staged into forks for review. Key pieces: - sessions/ — SessionWrapper (the split-pane shell), SessionPicker (sidebar list), SessionForkBar, SessionWorkspaceBar, FlowEditorView / ScriptEditorView / AppEditorView / RawAppEditorView, ForkDiffDrawer, sessionRuntime (per-session AIChatManager + draft state), sessionState (in-memory + persisted index), sessionUnread, sessionScope, appDraftCodec / flowDraftCodec, forkEditUrl, /sessions route. - WorkspaceItemDrillPicker refactor — extracts WorkspaceItemRow + adds surfaceAI drafts, stale-while-revalidate. workspacePicker.ts drops explicit invalidate() in favor of always re-fetching in the background. - ForkDiffDrawer + WorkspaceItemDiffViewer — per-kind diff bodies reusable from the compare page. FlowGraphDiffViewer / FlowGraphV2 gain inlineDiff forwarding + onHeight callback for equal-height layout. - Global AI chat sessions plumbing — AIChatManager exports the class + adds disabledModes, beforeSend hook, scoped instance context. AIChat / AIChatDisplay accept session-only props (wideLayout, emptyHint, inputPreface, hideHeader, hideModeSelector, forceDisabled). Chat preserved across /flows/add → /flows/edit, /scripts/add → /scripts/edit. - Draft-first loaders — sessions open drafts when present, otherwise seed a draft from the last deployed value via globalDraftStore. RawAppEditor / AppEditor / AppEditorHeaderDeploy get newApp prop + fixes so draft-only apps can deploy. - Compare page (/forks/compare) — bigger overhaul to plug into the new drawer. - Sidebar — Sessions entry + unread badge + status dot in SidebarContent / MenuButton / SideBarNotification. - Misc fixes — chat group color palette constraint, deploy_workspace_item confirmation dropped, open_preview tool, picker drafts surfacing, fork archive/delete buttons on compare page. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-05-20 15:58:20 +02:00
Guilhem	d0f23cc523	feat(frontend): unified EditorHeader with file picker for flow/script/app editors (#9047) ... * feat: add EditableInput component * feat: add EditorHeader for flow editor with file picker entry point * feat: WorkspaceItemPicker for editor header navigation * feat: clickable breadcrumb in EditorHeader, scoped picker keyboard nav * fix: reload flow on URL change and reset highlight in search mode * feat: editor header layout polish and trigger removal * feat: apply EditorHeader to script, app, and raw app editors * fix: show generated initial path for new apps in EditorHeader * fix: align EditorHeader new-app path with draft drawer's Path component * fix: read page.params.path in loadApp to reload on URL change * fix: remount AppEditor when navigating between apps * fix: clear app/files on URL change so editor remounts with fresh data * fix: route picker selections to /apps/edit or /apps_raw/edit based on raw_app * fix: drop Save button from path popover; defer rename to deploy * refactor: drop pathPopoverContent snippet, bind newEditedPath directly * refactor: dedupe editor header plumbing (editPathFor, userPathPrefix, breadcrumb snippet) * fix: freeze breadcrumb during path edit so popover doesn't drift * fix: drop spinner from path dependency-check; render nothing when no usages * fix: swallow 404 in checkFlowOnBehalfOf so renaming a flow doesn't toast * Revert "fix: swallow 404 in checkFlowOnBehalfOf so renaming a flow doesn't toast" This reverts commit 82dec462ae. * refactor: drop moveRenameManager dep from EditorHeader; pass onBehalfOfEmail as prop * refactor: replace breadcrumb-snapshot effect with open/close setter * refactor: drop unused dirtyPath state from EditorHeader * fix: surface Path validation error in pen popover * fix: decouple Path validation error from hideFullPath toggle * refactor: use InputError for path validation message (slide transition) * fix: re-derive Path meta from external path changes (sibling sync) * docs: note Path's meta could be replaced with function-form bindings * fix: 'Exit & see details' uses deployed path, not live store * fix: undo/redo shortcut uses shiftKey instead of fragile case-match * fix: type errors and keep edit pen visible while popover is open * chore: remove unused meltComponents/Accordion wrapper * fix: focus search input on picker open via popover openFocus selector * fix: refocus picker search input on every popover open * fix: pre-seed picker loaded state from cache so accordion opens at the right place * fix: breadcrumb and picker track savedPath, not draft-renamed live path * fix: inject current draft item into picker so breadcrumb scope isn't empty * docs: add component-level and prop-level docs to EditableInput * feat: warn that a deploy is needed when path is edited on a saved item * feat: show same path-change-needs-deploy message in flow/script settings * fix(flows): persist draft-renamed path through reload and dirty check * fix: include path in unsaved-changes diff so renames trigger the modal * feat: nested folders in picker tree and breadcrumb * fix: per-segment popover state so switching breadcrumbs closes the previous one * refactor: replace accordion picker with drill-through picker * refactor(picker): review fixes, drill polish, and breadcrumb collapse * fix(picker): review fixes — banned bindable, drop sibling-sync, load races, mouse highlight * fix(picker): smooth-scroll highlighted row into view on open * fix(picker): second-pass review fixes — load races, cache invalidation, breadcrumb/picker a11y, raw_app routing * fix(RowIcon): apply size prop to resource_type and fallback divs * feat(picker): add cross-kind 'All' root; deeper breadcrumb segments open there * fix(picker,editor): third-pass review — search loading state, pen autofocus, allow empty summary, a11y * fix(picker,editor): fourth-pass review — own check, flowbuilder arrows, editableinput double-save, customui.path gate, invalidate races * fix(editor,picker): codex review — fresh URL state per load, granular whitelabel topBar gates * fix(flows): clear localStorage in auto-reload to break URL-state loop	2026-05-12 14:33:21 +00:00
Ruben Fiszel	c57c769dea	feat: add CI test scripts with auto-trigger on deploy (#8736) ... * feat: add CI test scripts with auto-trigger on deploy Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: fix annotation parser early return and handle renames correctly Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: move CI test results to top of script/flow detail pages Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: improve CI test results spacing, icon, and remove pass label Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat: support one-line annotation and use script/path format Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat: move CI test trigger logic to EE Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat: move CI badge next to New badge and add deduplicated CI summary Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat: add CI test e2e tests and fix nullable column annotations Add integration tests for CI test annotation parsing (creates/removes ci_test_reference rows) and the CI test results API (single + batch endpoints). Add backend test for auto-trigger on deploy (private+python). Fix sqlx LEFT JOIN LATERAL nullable column annotations in get_ci_test_results and get_ci_test_results_batch queries — sqlx cannot infer nullability from LATERAL subqueries, causing runtime decode errors when no matching job exists. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix build/sqlx * fix * feat: CI test improvements and templates - Fix windmill-dep-map/private feature propagation in worker, api-scripts, and api-flows Cargo.toml so CI test triggers actually fire in EE mode - Clone ci_test_reference rows during workspace fork - Add polling to CiTestResults component (refetch every 3s while running) - Add running state and auto-refresh to ForkWorkspaceBanner CI summary - Add yellow "CI test" badge on script list rows and detail page - Fix Library badge border color (remove indigo border override) - Add CI Test TypeScript and CI Test Python templates in ScriptBuilder - Update sqlx offline cache - Add debug tracing for CI test trigger in worker_lockfiles Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: add missing children prop to WorkspaceDeployLayout Fixes svelte-fast-check type error when passing named snippets as children content inside the component tag. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: address PR review feedback - Remove empty wrapper divs around CiTestResults, move mb-4 into component - Add batch endpoint size cap (max 200 items) - Add ON DELETE CASCADE to ci_test_reference workspace FK (new migration) - Downgrade CI test trigger logs from info to debug - Fix false-positive polling: only treat status='running' as running, not null status (CiTestResults, CompareWorkspaces, ForkWorkspaceBanner) - Fix test numbering in integration tests Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * chore: update ee-repo-ref to latest EE commit Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * chore: update ee-repo-ref to d9d68c2406df0b59f413ea0b2cb24780a9817d04 This commit updates the EE repository reference after PR #516 was merged in windmill-ee-private. Previous ee-repo-ref: d7ccd9b86da99ec056a0e8708e3637d64290387a New ee-repo-ref: d9d68c2406df0b59f413ea0b2cb24780a9817d04 Automated by sync-ee-ref workflow. * fix: treat queued jobs (job_id set, null status) as running Jobs that have been pushed but not yet picked up by a worker have a job_id but null status. Treat these as 'running' to avoid showing misleading 'pass' badges or '0 passing'. Tests that were never triggered (no job_id, null status) remain neutral/hidden. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> Co-authored-by: hugocasa <hugo@casademont.ch> Co-authored-by: windmill-internal-app[bot] <windmill-internal-app[bot]@users.noreply.github.com>	2026-04-09 17:21:36 +00:00
Ruben Fiszel	31d6660d56	feat: script module mode with CLI sync, preview, and WAC UI improvements (#8380) ... * feat: add script module mode with folder model for Bun and Python Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix: add missing modules field to RawCode in bun_executor Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * sqlx * feat: enrich WAC templates with checkpoint and replay semantics Add prominent comments explaining that all computation must happen inside task/step/taskScript or it will be replayed on resume/retry. Clarify that waitForApproval does not hold a worker and that approve/reject URLs are available in the timeline step details. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(cli): script module sync idempotency, per-module hash tracking, and preview support - Fix pull→push idempotency: use `??` instead of `||` for module lock field so empty strings are preserved (matches API's `lock: ""`) - Add per-module hash tracking in wmill-lock.yaml following the flow inline script pattern (SCRIPT_TOP_HASH + per-module subpath hashes) - Selective module lock regeneration: only regenerate locks for modules whose content actually changed, not all modules - Use unfiltered rawWorkspaceDependencies for module hashes to match what updateModuleLocks passes to fetchScriptLock - Show changed module names in stale script output for clarity - Add module support to `script preview` command: read modules from __mod/ folder and pass them in the preview API request - Add preview tests for taskScript pattern (flat and folder layout) - Update test assertion for module stale detection output Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat(frontend): WAC UI improvements — reorder templates, module tab rename, import consolidation - Reorder WAC template buttons: TypeScript before Python in ScriptBuilder, CreateActionsScript, and CreateActionsFlow - Remove dropdown items from +Script button (simplify to direct link) - Move "Import Workflow-as-Code" to +Flow dropdown with dedicated drawer - Add module tab rename: pencil icon on hover opens popover with validation, fixed-width icon container prevents layout shift Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat: remaining module-mode changes from working branch - Backend parser updates for WAC detection - CLI sync/types updates for raw app path and module support - Frontend UI polish (Dev.svelte, ScriptRow, script hash page) - Test fixture updates Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * test(cli): add test for module modification detection in generate-metadata Verifies that modifying a single module file re-triggers stale detection and only the changed module is listed, not all modules. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): critical fixes from PR review - Fix hardcoded dev path in bun_executor.rs WAC v2 wrapper — use "windmill-client" import instead of absolute filesystem path - Fix missed no_main_func → auto_kind rename in parser TS test - Add modules column to clone_script SQL (windmill-common and windmill-api-workspaces) so cloned scripts retain their modules - Add modules: None to RawCode structs in worker tests - Restore complete sqlx cache (merge main's cache + our new queries) Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): fix clone warning treated as error in CI Change `.clone()` on double reference to `*k` dereference in scripts.rs hash implementation. Update sqlx cache with new query hashes from modified clone_script SQL. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(frontend): use published parser wasm versions for CI build The local file:// paths for windmill-parser-wasm-py and windmill-parser-wasm-ts don't exist in the Cloudflare Pages build environment. Revert to published npm versions (1.655.0). Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(frontend): update parser wasm packages to 1.657.2 Use newly published windmill-parser-wasm-ts and windmill-parser-wasm-py v1.657.2 which include auto_kind/WAC detection changes. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(frontend): regenerate package-lock.json for npm ci compatibility Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(frontend): use main's lockfile as base, update only parser wasm packages Regenerating package-lock.json from scratch pulled different dependency versions causing svelte-check type errors. Instead, start from main's lockfile and only update the two changed packages. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): add modules column to fetch_script_for_update query The Script<SR> struct has a modules field (FromRow), but fetch_script_for_update didn't SELECT modules, causing a runtime error "no column found for name: modules" when the worker processed dependency jobs. This was the root cause of the relock_skip test timeout. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): fix script module execution for Python and Bun - Fix modules not passed through job queue: inject _MODULES into PushArgs.extra when pushing Code jobs so worker can extract them - Fix Python module imports: use relative imports (from .helper) and add sys.path.insert for module directory in wrapper - Fix Python tests: use relative imports and empty lock to prevent pip from resolving module names as packages - Add local file check in Bun loader for module resolution - Ignore Bun module test (bundle mode loader integration tracked separately) - Add missing modules column to fetch_script_for_update query Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): remove unnecessary empty lock in Python module tests Relative imports (from .helper) are not parsed as pip packages, so the empty lock workaround is not needed. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): fix module execution for Python and Bun — all tests pass Python modules: - Use relative imports (from .helper import greet) since scripts run as packages - Add sys.path.insert for module directory in wrapper to ensure local modules take precedence over pip packages with same name Bun modules: - Use bundled output (./out/main.js) as wrapper import when modules are present — the bundled output has module content inlined by Bun.build, avoiding runtime loader resolution issues - Add local file check in loader.bun.js onResolve to short-circuit API URL resolution for module files on disk Job queue: - Inject _MODULES into PushArgs.extra when pushing Code jobs so the worker can extract them at execution time Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * refactor: address PR review — simplify, fix correctness, remove dead code Critical fixes: - Replace all CLI `no_main_func` references with `auto_kind` (string) to match the backend migration and API changes - Remove duplicated `compute_python_module_dir` in worker.rs, use the canonical version from python_executor.rs High priority: - Auto-create `__init__.py` in intermediate directories for nested Python modules so imports like `from .utils.math import add` work without users manually creating __init__.py files - Remove redundant `sys_path_insert` — relative imports use Python's package system, not sys.path Medium: - Fix lock file base name extraction: use regex to strip only the final extension (`.replace(/\.[^.]+$/, '')`) instead of `indexOf(".")` which breaks for files like `helper.test.ts` Simplification: - Remove dead `{#if false}` Popover block in ScriptEditor.svelte - Guard loader.bun.js local file check to only run for relative paths (matching the Windows loader pattern) - Add clarifying comment on Bun dual mechanism (build + run phases) - Add maintenance comment on manual Hash impl for NewScript Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: final review fixes — stale cleanup, baseName, auto_kind export - Fix sync.ts baseName extraction using indexOf(".") → regex (same fix as script.ts/metadata.ts, missed this instance) - Add stale module file cleanup in writeModulesToDisk: removes files from __mod/ that are no longer in the modules map before writing, fixing the pull→push cycle that couldn't delete modules - Log warning when _MODULES serialization fails in job push instead of silently dropping modules - Use strict equality (===) for auto_kind comparison - Exclude auto_kind from workspace export — it is auto-detected by the parser at deploy time from script content Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(cli): remove auto_kind from push, comparison, and metadata auto_kind is auto-detected by the parser at deploy time, so the CLI should not send it, compare it, or write it to script.yaml. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: remove erroneously added backend/backend/.sqlx directory Duplicate .sqlx cache was committed at the wrong nested path. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: address PR review feedback + fix CI dead_code warning Frontend (ScriptEditor.svelte): - Fix switchToMain() missing lastSyncedCode update — prevents stale code sync on external changes while editing a module tab - Fix formatAction saving module code to main script's localStorage draft — now saves main code when on a module tab - Fix non-null assertion on inferModuleLang in renameModule — fall back to original language instead of force unwrap - Remove redundant activeModuleTab truthy check in runTest CLI (script.ts): - Clean up empty directories after removing stale module files in writeModulesToDisk Backend: - Add path traversal guard in write_module_files — reject module paths containing ".." - Fix dead_code warning on auto_kind field in workspace export struct Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat(frontend): improve auto_kind UX + address review findings - Rename "Include without main function" toggle to "Include library scripts" in script list (ItemsList.svelte) - Update NoMainFuncBadge: "No main" → "Library" with clearer tooltip - Filter module file extensions by main script language — Python scripts only allow .py modules, TypeScript only .ts, etc. - Split flushModuleState into flushModuleContent (no UI side-effect) and flushModuleState (flush + reset tab), reducing duplication - Dynamic placeholder and hint text in add module popover based on main script language Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-17 01:20:09 +00:00
Ruben Fiszel	5f0ef936d1	feat: add sandbox annotations, volume mounts, for AI sandbox starting with claude (#8058)	2026-03-05 06:19:51 +00:00
Diego Imbert	2ab5345e61	Assets refactor (#6217) ... * Moved logic to FlowAssetsProvider * Remove assetsMap in flow * do not parse everything on mount + only check for missing assets fields * add assets field in backend * remove fallbackAccessTypes * better structure and less queries / parsing * Fix assets not showing when pulling raw_flow from jobs * flow assets ctx for job run * Fix transitive assets fetching * Fix input args asset node * enablePathScriptAndFlowAssets flag * edit btn for variable * untrack refresh * move parseInputArgsAssets * Assets tab in runs * Update FlowStatusViewerInner to svelte 5 + fix asset sync bug * avoid toast error on bad resource * fetch res metadata for input arg asset * Job assets viewer in run page * r/w selector * remove indigo badge * store alt_access_type state in ScriptEditor * Don't parse assets in flow script editor * Add alt_access_type in backend * show Read as selected by default to avoid giving the feeling of having made a decision * keep alt_access_type when reparsing in flow raw scripts * Remove variable asset kind, and save assets for scripts * remove all backend asset parsing * R/W/RW selector button nits * fix insert into assets not saving alt access type * support named arguments in python asset parser * improve asset usage drawer R/W indicator * update legacy $res: syntax * reactivity issue * remove last variable asset stuff * sqlx prepare * tooltip explainer * deprecated variable asset nit	2025-07-17 22:15:01 +00:00
Diego Imbert	433341b295	feat: assets as a primary concept (#6125) ... * assets migration * parse assets (duckdb) * iterate on assets * S3 object Preview * remove pagination * filterText * better occurence list * tweak * assets in JobPreview * clone impl * AssetsDetectedBadge * improve DbManagerButton + asset dropdown button * edit resource btn * warning when incorrect resource * +Resource in DuckDB * +S3 Object editor bar * nit fix rename * flow asset badge * More Generic OnChange * Highlight assets used in modules * Show occurence count in flow * Better UX, avoid moving parts * nit * Asset nodes * move to dedicated Asset ctx * fix layoutNodes not handling first assetsMap * explore asset btn in flow asset node * correct offset * single computeAssetNodes function * Fix y positioning of nodes with assets * resource editor * write mode node (ui) * accessType in ctx + fix insert button positioning * right positioning when mixing read and write nodes * right positioning when mixing R and W assets * Better layout fix algorithm * listAssetsByUsage and asset nodes on transitive usages * refactor + remove linkAssets * Refactor to allow for custom R/W modes * AssetsDropdownButton in flow script editor * R/W/RW selection and changes node pos in flow * layoutNodes doesnt need recompute now * fix wrong assumption that nodes recompute when assets change * r/w/rw multi toggle * MultiToggle cool animation + clearable * rename + 1px nit * remove mini toggle button group, use ToggleButtonGroup * Combinator parser that detects R / W asset context * nit fix missing flex-1 * missing order by * better ui indication for access type * special x offset case when only one asset node for clarity * parse getResource in TS with swc ecma parser * support load and write s3 detection in TS * Python asset parser * support wmill api calls without special $res: or s3:// syntax * detect out of context asset uris python * do not use access type override when not ambiguous in flow graph * parse_assets match case in rust * AsRef<str> refactor * From impl * Save flow assets * Save script asset usages + fixes + save fallback access types * asset sub icon * max total asset node width to avoid overlap * small refactor * don't parse comments in duckdb assets * fix assets clearing on parse error * fix script asset save in wrong place * load initial asset fallback access types * support variables * ui fixes * Support S3Object as URI in TS client * support new syntax in python client * Support +S3Object in EditorBar for TS and python * Reduce resource requests in assets page * import windmill client when necessary * update s3Types.d.ts * nit fix * Show input resources and s3 objects as assets * improve asset icons * DarkModeObserver refactor * asset page tabs * Moved resource variables and s3object pages to assets tabs * fetch resource usages * Get variables usages * move assets usage dropdown to component * Revert "move assets usage dropdown to component" This reverts commit 622ea4ab12. * Revert "Get variables usages" This reverts commit b11ced4e29. * Revert "fetch resource usages" This reverts commit aa5187ad4b. * Revert "Moved resource variables and s3object pages to assets tabs" This reverts commit 4430487be4. * Revert "asset page tabs" This reverts commit dacc2f0da5. * move assets usage dropdown to component * asset icon in asset pages * tooltip * details * Storage selector in S3 File Picker * make edge less opaque * Refactor computeAssetNodes to separate in and out nodes * AssetsOverflowedNode * nits * fix assets not being parsed in flows sometimes * show asset kind and resource_type * ui nits * support res:// in duckdb * add banner for old deployments * Fix permissionning * fix broken disable /enable all * assets page view permission for operators * Disable ExploreAssetButton for operators * asset kind as subtitle * do not spam getResource in assets page. prob. revert fail * update assets page on workspace change * reload storage names on ws change * delete assets on archive / deletion * sqlx prepare * missing update when updating user * add indexes on asset * better message * missing loadInit: false * dead code * use transaction * typo * update package.json * update package.json --------- Co-authored-by: Ruben Fiszel <ruben@windmill.dev>	2025-07-11 09:56:53 +00:00
Ruben Fiszel	3fbd3ec4f9	fix: tag select in script builder top bar (#6136) ... * all * update * react 18 * update * update * update	2025-07-07 10:27:09 +00:00