feat(frontend): update sonner dark theme

Merge branch 'main' into sonner-toast
chore(main): release 1.327.0 (#3715 )
2024-05-13 14:15:09 +02:00 · 2024-05-13 13:38:33 +02:00 · 2024-05-13 08:30:37 +02:00 · 2024-05-13 08:26:03 +02:00 · 2024-05-12 21:23:23 +02:00 · 2024-05-12 21:16:02 +02:00
247 changed files with 63500 additions and 3346 deletions
--- a/.github/change-versions.sh
+++ b/.github/change-versions.sh
@@ -12,6 +12,7 @@ sed -i -e "/^export const VERSION =/s/= .*/= \"v$VERSION\";/" ${root_dirpath}/be
 sed -i -e "/version: /s/: .*/: $VERSION/" ${root_dirpath}/backend/windmill-api/openapi.yaml
 sed -i -e "/version: /s/: .*/: $VERSION/" ${root_dirpath}/openflow.openapi.yaml
 sed -i -e "/\"version\": /s/: .*,/: \"$VERSION\",/" ${root_dirpath}/typescript-client/package.json
+sed -i -e "/\"version\": /s/: .*,/: \"$VERSION\",/" ${root_dirpath}/typescript-client/jsr.json
 sed -i -e "/\"version\": /s/: .*,/: \"$VERSION\",/" ${root_dirpath}/frontend/package.json
 sed -i -e "/^version =/s/= .*/= \"$VERSION\"/" ${root_dirpath}/python-client/wmill/pyproject.toml
 sed -i -e "/^windmill-api =/s/= .*/= \"\\^$VERSION\"/" ${root_dirpath}/python-client/wmill/pyproject.toml
--- a/.github/workflows/docker-image.yml
+++ b/.github/workflows/docker-image.yml
@@ -136,7 +136,7 @@ jobs:
          platforms: linux/amd64,linux/arm64
          push: true
          build-args: |
-            features=enterprise,enterprise_saml,stripe,embedding,parquet,prometheus,openidconnect
+            features=enterprise,enterprise_saml,stripe,embedding,parquet,prometheus,openidconnect,cloud
          tags: |
            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-ee:dev
            ${{ steps.meta-ee-public.outputs.tags }}
@@ -199,7 +199,7 @@ jobs:
          platforms: linux/amd64
          push: true
          build-args: |
-            features=enterprise,enterprise_saml,stripe,embedding,parquet,prometheus,openidconnect
+            features=enterprise,enterprise_saml,stripe,embedding,parquet,prometheus,openidconnect,cloud
            PYTHON_IMAGE=python:3.12.2-slim-bookworm
          tags: |
            ${{ steps.meta-ee-public-py312.outputs.tags }}
--- a/.github/workflows/jsr_on_release.yml
+++ b/.github/workflows/jsr_on_release.yml
@@ -0,0 +1,16 @@
+name: Publish typescript-client on JSR
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - run: cd typescript-client && ./publish.jsr.sh
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,285 @@
 # Changelog

+## [1.327.0](https://github.com/windmill-labs/windmill/compare/v1.326.1...v1.327.0) (2024-05-13)
+
+
+### Features
+
+* nativets can use the wmill library + setClient not required anymore ([#3714](https://github.com/windmill-labs/windmill/issues/3714)) ([8b21f08](https://github.com/windmill-labs/windmill/commit/8b21f0812c939542ed84863de029b60f94526417))
+
+## [1.326.1](https://github.com/windmill-labs/windmill/compare/v1.326.0...v1.326.1) (2024-05-12)
+
+
+### Bug Fixes
+
+* un-inline monaco editor workers for faster initial load ([e2991ef](https://github.com/windmill-labs/windmill/commit/e2991ef9237d17de5e6ef8074387998a96785396))
+
+## [1.326.0](https://github.com/windmill-labs/windmill/compare/v1.325.2...v1.326.0) (2024-05-12)
+
+
+### Features
+
+* logs can be downloaded directly from server/frontend if using shared volume ([a3a66d0](https://github.com/windmill-labs/windmill/commit/a3a66d0577f57cae6e0de5a942a35d45cc8e9472))
+
+## [1.325.2](https://github.com/windmill-labs/windmill/compare/v1.325.1...v1.325.2) (2024-05-11)
+
+
+### Bug Fixes
+
+* improve status exit dedicated workers ([12e302a](https://github.com/windmill-labs/windmill/commit/12e302a309ee8148d2a9d4a168807b97f5fd1709))
+
+## [1.325.1](https://github.com/windmill-labs/windmill/compare/v1.325.0...v1.325.1) (2024-05-11)
+
+
+### Bug Fixes
+
+* **cli:** support whileloop in flow cli sync ([d0a6dda](https://github.com/windmill-labs/windmill/commit/d0a6ddab94dfae4d6fab40c4d41acb85dab18183))
+* improve nodejs mode after esm update ([87add79](https://github.com/windmill-labs/windmill/commit/87add79de2e4df38e59d2e334bba0487c8ff4ecc))
+* selectedRow for a table is set on table actions ([447e2d7](https://github.com/windmill-labs/windmill/commit/447e2d7742edcd0af7184f6e8e5e67cf99f8103b))
+
+## [1.325.0](https://github.com/windmill-labs/windmill/compare/v1.324.2...v1.325.0) (2024-05-10)
+
+
+### Features
+
+* worker metrics ([#3697](https://github.com/windmill-labs/windmill/issues/3697)) ([696a561](https://github.com/windmill-labs/windmill/commit/696a5612f8551066b7b833ba555bd006914faff6))
+
+
+### Bug Fixes
+
+* **backend:** return flow result if flow fails or stops before early return ([#3704](https://github.com/windmill-labs/windmill/issues/3704)) ([67f4a4a](https://github.com/windmill-labs/windmill/commit/67f4a4afeec79daa81930124594ecf3131c18133))
+
+## [1.324.2](https://github.com/windmill-labs/windmill/compare/v1.324.1...v1.324.2) (2024-05-09)
+
+
+### Bug Fixes
+
+* fix build ([20dfbda](https://github.com/windmill-labs/windmill/commit/20dfbda69e643753b1ff17137ce18ed23ff45dd1))
+
+## [1.324.1](https://github.com/windmill-labs/windmill/compare/v1.324.0...v1.324.1) (2024-05-09)
+
+
+### Bug Fixes
+
+* **cli:** narrow codebases to bun ([252ac18](https://github.com/windmill-labs/windmill/commit/252ac18d477742d93a2004a0976a809d10bff3d1))
+
+## [1.324.0](https://github.com/windmill-labs/windmill/compare/v1.323.6...v1.324.0) (2024-05-09)
+
+
+### Features
+
+* critical error side channel ([#3625](https://github.com/windmill-labs/windmill/issues/3625)) ([29b1e6f](https://github.com/windmill-labs/windmill/commit/29b1e6f6a28ac9d9c014e4da2e23c9f2e45e1628))
+* disable response logs based on env var ([#3685](https://github.com/windmill-labs/windmill/issues/3685)) ([cd1711c](https://github.com/windmill-labs/windmill/commit/cd1711cf03894e65e81ee74631b0e04d7dae76d2))
+* **frontend:** Add a button tocopy the path of a subflow ([#3691](https://github.com/windmill-labs/windmill/issues/3691)) ([630ae7e](https://github.com/windmill-labs/windmill/commit/630ae7ec4b243e41d841bdae41c1c87b0fda5a82))
+* **frontend:** add missing date in the previous run panel ([#3693](https://github.com/windmill-labs/windmill/issues/3693)) ([49867c0](https://github.com/windmill-labs/windmill/commit/49867c06e63b5fc7b73031d946effb88c1ad1d1e))
+* **frontend:** Improve app components ([#3672](https://github.com/windmill-labs/windmill/issues/3672)) ([ee2a193](https://github.com/windmill-labs/windmill/commit/ee2a193958b87a7557eadfd7ea8231d109b9d41c))
+* import export all worker groups config ([#3667](https://github.com/windmill-labs/windmill/issues/3667)) ([c1a4a82](https://github.com/windmill-labs/windmill/commit/c1a4a8284387f381a5882b1fb6ebd73c9ec6b1ba))
+* local typescript codebase as bundle ([#3694](https://github.com/windmill-labs/windmill/issues/3694)) ([11b3ea3](https://github.com/windmill-labs/windmill/commit/11b3ea3ac86a34ab1beaab98ea43f6a64879f0fb))
+
+
+### Bug Fixes
+
+* can cancel only if can disable schedule + stop worker on force cancel + soft cancel job parent on job cancel ([#3670](https://github.com/windmill-labs/windmill/issues/3670)) ([010662d](https://github.com/windmill-labs/windmill/commit/010662d3d0d05a7f6167ceeb592c97cec4c9e804))
+* **frontend:** Fix subflow viewer ([#3674](https://github.com/windmill-labs/windmill/issues/3674)) ([47ee6c9](https://github.com/windmill-labs/windmill/commit/47ee6c90998840889c44df28a25967cef6c8bd59))
+* improve conditional wrapper for app editor ([ea4165d](https://github.com/windmill-labs/windmill/commit/ea4165d58bb11fb4409242bb597f4b7514d1bd60))
+* load large args of previous runs dynamically ([#3688](https://github.com/windmill-labs/windmill/issues/3688)) ([d1f58f1](https://github.com/windmill-labs/windmill/commit/d1f58f10371dfce5e037f03b43aad9f530d7ae6a))
+
+## [1.323.6](https://github.com/windmill-labs/windmill/compare/v1.323.5...v1.323.6) (2024-05-02)
+
+
+### Bug Fixes
+
+* **frontend:** Handle empty error message in toast + hide GridEditorM… ([#3664](https://github.com/windmill-labs/windmill/issues/3664)) ([5bae66a](https://github.com/windmill-labs/windmill/commit/5bae66aec3f00e2096ba06220ca2705488e4dfec))
+
+## [1.323.5](https://github.com/windmill-labs/windmill/compare/v1.323.4...v1.323.5) (2024-05-01)
+
+
+### Bug Fixes
+
+* re-release nit ([caa11c6](https://github.com/windmill-labs/windmill/commit/caa11c6506656e451352a4d437813ddfd2893225))
+
+## [1.323.4](https://github.com/windmill-labs/windmill/compare/v1.323.3...v1.323.4) (2024-05-01)
+
+
+### Bug Fixes
+
+* handle list of errors for schedule error handler ([96760b2](https://github.com/windmill-labs/windmill/commit/96760b296462855c2819d559687fa8b12c6336b0))
+* improve schedule editor UX ([774a35f](https://github.com/windmill-labs/windmill/commit/774a35f223b86444877f04b1a18b2f138ed75420))
+
+## [1.323.3](https://github.com/windmill-labs/windmill/compare/v1.323.2...v1.323.3) (2024-05-01)
+
+
+### Bug Fixes
+
+* add WM_WORKER_GROUP to get worker group from script ([0855cdd](https://github.com/windmill-labs/windmill/commit/0855cdd946e55b8f394a7721ed424bc66702691c))
+
+## [1.323.2](https://github.com/windmill-labs/windmill/compare/v1.323.1...v1.323.2) (2024-05-01)
+
+
+### Bug Fixes
+
+* **frontend:** Disable the insert button when required fields are empty strings ([#3659](https://github.com/windmill-labs/windmill/issues/3659)) ([7df4f02](https://github.com/windmill-labs/windmill/commit/7df4f02529de6e0d37135c9bef3da528be3e21a2))
+* **frontend:** use normal password mask for the sensitive fields of the resource editor ([c8b439d](https://github.com/windmill-labs/windmill/commit/c8b439df5b6f1e48cced5f9cc2fd7882fc88d407))
+
+## [1.323.1](https://github.com/windmill-labs/windmill/compare/v1.323.0...v1.323.1) (2024-05-01)
+
+
+### Bug Fixes
+
+* **cli:** improve generate metadata lock for new scripts ([54acc22](https://github.com/windmill-labs/windmill/commit/54acc22a271c26ea5e47f0adcf0bcc083064f434))
+* **frontend:** improve default select styling for apps ([#3656](https://github.com/windmill-labs/windmill/issues/3656)) ([2b34730](https://github.com/windmill-labs/windmill/commit/2b3473093aaeb7f78a8eaaf8d50021937acb6a50))
+* **frontend:** Restore AgGrid borders and remove the outer border pro… ([#3658](https://github.com/windmill-labs/windmill/issues/3658)) ([92492ab](https://github.com/windmill-labs/windmill/commit/92492ab6b7c579bf01043e422b5c768099ff3120))
+
+## [1.323.0](https://github.com/windmill-labs/windmill/compare/v1.322.0...v1.323.0) (2024-05-01)
+
+
+### Features
+
+* **frontend:** Improve inputs ([#3651](https://github.com/windmill-labs/windmill/issues/3651)) ([790f263](https://github.com/windmill-labs/windmill/commit/790f263e561917ccb8b68d26a2b1bae8f5a17fea))
+
+
+### Bug Fixes
+
+* **frontend:** improve result, flow status and log components ([#3653](https://github.com/windmill-labs/windmill/issues/3653)) ([aa6204f](https://github.com/windmill-labs/windmill/commit/aa6204ff99f78c8f5936701649d2829bd7e0afff))
+* **frontend:** remove red from autodatable badges ([#3652](https://github.com/windmill-labs/windmill/issues/3652)) ([d7d2f03](https://github.com/windmill-labs/windmill/commit/d7d2f03e2328e63bc460048570c26389a7d0d5e0))
+* **frontend:** sync columnDefs + improve columnDefs management ([#3632](https://github.com/windmill-labs/windmill/issues/3632)) ([ca209e9](https://github.com/windmill-labs/windmill/commit/ca209e9c48990dfd0c4c8085d74c5d7ba14b466b))
+
+## [1.322.0](https://github.com/windmill-labs/windmill/compare/v1.321.6...v1.322.0) (2024-04-30)
+
+
+### Features
+
+* import export worker group config ([#3649](https://github.com/windmill-labs/windmill/issues/3649)) ([df586fc](https://github.com/windmill-labs/windmill/commit/df586fc68e6d39ce84dce6c65354ab7cbcf2cdb0))
+
+
+### Bug Fixes
+
+* improve password ui ([0b23d90](https://github.com/windmill-labs/windmill/commit/0b23d90f6015e27203be64ccf3801938ce745648))
+
+## [1.321.6](https://github.com/windmill-labs/windmill/compare/v1.321.5...v1.321.6) (2024-04-30)
+
+
+### Bug Fixes
+
+* fix aggrid table actions ([c1f582f](https://github.com/windmill-labs/windmill/commit/c1f582f6e4a32bd7a3ee5be3824678d72fe71881))
+
+## [1.321.5](https://github.com/windmill-labs/windmill/compare/v1.321.4...v1.321.5) (2024-04-30)
+
+
+### Bug Fixes
+
+* fix console logs in REST scripts ([1f983c2](https://github.com/windmill-labs/windmill/commit/1f983c241404715e71ddc05cae5630a7696d590e))
+* make sure folder updater keep write permissions if not admin ([ae165b9](https://github.com/windmill-labs/windmill/commit/ae165b9f878a6960901026412e9dc815ebd2c472))
+* prevent overflowing for long description and default in schema ([450201d](https://github.com/windmill-labs/windmill/commit/450201deb8f4cd1ef426d0ff6987615f6fbbf5df))
+* **python:** supports folders starting with numbers for execution ([cf6ffef](https://github.com/windmill-labs/windmill/commit/cf6ffef48af5508a219048f0885001ed59c1bf06))
+
+## [1.321.4](https://github.com/windmill-labs/windmill/compare/v1.321.3...v1.321.4) (2024-04-29)
+
+
+### Bug Fixes
+
+* **cli:** handle better missing lockfile for generating metadata ([5315726](https://github.com/windmill-labs/windmill/commit/53157262bdb38d7b83d94ff9df02322bb0ab06c7))
+
+## [1.321.3](https://github.com/windmill-labs/windmill/compare/v1.321.2...v1.321.3) (2024-04-29)
+
+
+### Bug Fixes
+
+* **cli:** skip deleting script when lockfile delete ([959ae8d](https://github.com/windmill-labs/windmill/commit/959ae8d2526d631a14b91a8657ef6957355467b3))
+
+## [1.321.2](https://github.com/windmill-labs/windmill/compare/v1.321.1...v1.321.2) (2024-04-29)
+
+
+### Bug Fixes
+
+* **cli:** improve lockfile support on cli ([b7f9ecb](https://github.com/windmill-labs/windmill/commit/b7f9ecbda1e481191aac90497c850da533a55732))
+* **cli:** improve lockfile support on cli ([35b2423](https://github.com/windmill-labs/windmill/commit/35b2423fe193a5425f2fa9d940d9ca15b8a5b33c))
+* **cli:** improve lockfile support on cli ([05e70a8](https://github.com/windmill-labs/windmill/commit/05e70a849ea1ade6a2652d73ea1dcaaad3e2f6ce))
+
+## [1.321.1](https://github.com/windmill-labs/windmill/compare/v1.321.0...v1.321.1) (2024-04-29)
+
+
+### Bug Fixes
+
+* pg types conversion dbstudio ([#3636](https://github.com/windmill-labs/windmill/issues/3636)) ([f6e8f45](https://github.com/windmill-labs/windmill/commit/f6e8f45af1df9009a6086ee76b7a7cfa9845ff17))
+
+## [1.321.0](https://github.com/windmill-labs/windmill/compare/v1.320.3...v1.321.0) (2024-04-29)
+
+
+### Features
+
+* add resource and variable picker for rest scripts ([#3628](https://github.com/windmill-labs/windmill/issues/3628)) ([3956d01](https://github.com/windmill-labs/windmill/commit/3956d012ad08e37062f24823dbc0d7ca1bb564ef))
+
+
+### Bug Fixes
+
+* **python-client:** improve error message for wait_job ([0e022c9](https://github.com/windmill-labs/windmill/commit/0e022c9e4edc0d03abe2325c87546a8244434a5f))
+* toggle comment shortcut on some EU keyboards ([#3630](https://github.com/windmill-labs/windmill/issues/3630)) ([b529784](https://github.com/windmill-labs/windmill/commit/b5297846fea880c18f4895010aad3c39e5f582b1))
+
+## [1.320.3](https://github.com/windmill-labs/windmill/compare/v1.320.2...v1.320.3) (2024-04-28)
+
+
+### Bug Fixes
+
+* **cli:** improve support for frontend scripts cli sync ([82e628a](https://github.com/windmill-labs/windmill/commit/82e628a11185b2af27d2cd53aa4619b413ee0e6a))
+
+## [1.320.2](https://github.com/windmill-labs/windmill/compare/v1.320.1...v1.320.2) (2024-04-28)
+
+
+### Bug Fixes
+
+* bump git sync script version ([e8dcd5b](https://github.com/windmill-labs/windmill/commit/e8dcd5b4956ce06047b74486eabccd5d5d4380fc))
+
+## [1.320.1](https://github.com/windmill-labs/windmill/compare/v1.320.0...v1.320.1) (2024-04-28)
+
+
+### Bug Fixes
+
+* add button to easily bump git sync version ([0fcd54b](https://github.com/windmill-labs/windmill/commit/0fcd54bc070483dafdbbc0f592e090d0b71361c3))
+
+## [1.320.0](https://github.com/windmill-labs/windmill/compare/v1.319.1...v1.320.0) (2024-04-28)
+
+
+### Features
+
+* **cli:** split inline sscripts for apps like for flows ([22226e8](https://github.com/windmill-labs/windmill/commit/22226e883e89199a1d1c5095e87fc8c6f90b252d))
+* **cli:** split lockfiles from script metadata ([c39f3a8](https://github.com/windmill-labs/windmill/commit/c39f3a84d645caee345c3274b37d6b81f653fede))
+* **cli:** use separate lockfiles for rawscipt of flows ([6c69889](https://github.com/windmill-labs/windmill/commit/6c698898741982d8f01fa8d5a47a2da46ad361e0))
+
+## [1.319.1](https://github.com/windmill-labs/windmill/compare/v1.319.0...v1.319.1) (2024-04-26)
+
+
+### Bug Fixes
+
+* improve dnd on app editor for large screens ([3875eec](https://github.com/windmill-labs/windmill/commit/3875eec46fde26f108f3ba0ad17d9e5005208cea))
+
+## [1.319.0](https://github.com/windmill-labs/windmill/compare/v1.318.0...v1.319.0) (2024-04-26)
+
+
+### Features
+
+* add distributed global cache for go ([c73e7db](https://github.com/windmill-labs/windmill/commit/c73e7dbd8c3aa2f749176b6478a2bb351b39d210))
+* add distributed global cache for go ([4188383](https://github.com/windmill-labs/windmill/commit/4188383d3ede69fd3d320f187ef18072aa888f01))
+* pg add json support ([#3620](https://github.com/windmill-labs/windmill/issues/3620)) ([fee22fc](https://github.com/windmill-labs/windmill/commit/fee22fc060b3cfc2e6a30badb907ae828fc6272f))
+
+
+### Bug Fixes
+
+* make configurable footer for aggrid in apps ([41f6bcd](https://github.com/windmill-labs/windmill/commit/41f6bcdaa154bd2d21a65b26455802cdbafe5dc1))
+
+## [1.318.0](https://github.com/windmill-labs/windmill/compare/v1.317.1...v1.318.0) (2024-04-25)
+
+
+### Features
+
+* app select policy ([#3610](https://github.com/windmill-labs/windmill/issues/3610)) ([c09ae3e](https://github.com/windmill-labs/windmill/commit/c09ae3ebc6eab23434e74aadae887536e8f97c4d))
+
+
+### Bug Fixes
+
+* **frontend:** Improve AgGrid Infinite table default codes + deprecat… ([#3609](https://github.com/windmill-labs/windmill/issues/3609)) ([f26d3e6](https://github.com/windmill-labs/windmill/commit/f26d3e62f6d9b8d80c4e4d555c94b9b213e7c362))
+* support all pg types from db studio ([#3613](https://github.com/windmill-labs/windmill/issues/3613)) ([5def8cb](https://github.com/windmill-labs/windmill/commit/5def8cb52c24b5bf877275964aec35c05c91d7b6))
+
 ## [1.317.1](https://github.com/windmill-labs/windmill/compare/v1.317.0...v1.317.1) (2024-04-24)


--- a/2
+++ b/2
@@ -171,7 +171,7 @@ COPY --from=builder /windmill/target/release/windmill ${APP}/windmill

 COPY --from=downloader --chmod=755 /deno /usr/bin/deno

-COPY --from=oven/bun:1.1.0 /usr/local/bin/bun /usr/bin/bun
+COPY --from=oven/bun:1.1.7 /usr/local/bin/bun /usr/bin/bun

 # add the docker client to call docker from a worker if enabled
 COPY --from=docker:dind /usr/local/bin/docker /usr/local/bin/
--- a/README.md
+++ b/README.md
@@ -352,6 +352,7 @@ you to have it being synced automatically everyday.
 | TIMEOUT_WAIT_RESULT       | 20                     | The number of seconds to wait before timeout on the 'run_wait_result' endpoint                                                                                                                     | Worker                |
 | QUEUE_LIMIT_WAIT_RESULT   | None                   | The number of max jobs in the queue before rejecting immediately the request in 'run_wait_result' endpoint. Takes precedence on the query arg. If none is specified, there are no limit.           | Worker                |
 | DENO_AUTH_TOKENS          | None                   | Custom DENO_AUTH_TOKENS to pass to worker to allow the use of private modules                                                                                                                      | Worker                |
+| DISABLE_RESPONSE_LOGS          | false                   | Disable response logs                                                   | Server                |

 ## Run a local dev setup
 ### only Frontend
--- a/backend/.sqlx/query-021be0f26ea87e587e656b24a9a94538efbf54a1447a3898e19773789cfc9063.json
+++ b/backend/.sqlx/query-021be0f26ea87e587e656b24a9a94538efbf54a1447a3898e19773789cfc9063.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT created_at FROM metrics WHERE id = 'author_count' ORDER BY created_at DESC LIMIT 1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "created_at",
+        "type_info": "Timestamptz"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "021be0f26ea87e587e656b24a9a94538efbf54a1447a3898e19773789cfc9063"
+}
--- a/backend/.sqlx/query-02b516dac764662194db1bc33e365c01f40bae70af3683f1f09748f6020f0d49.json
+++ b/backend/.sqlx/query-02b516dac764662194db1bc33e365c01f40bae70af3683f1f09748f6020f0d49.json
@@ -1,6 +1,6 @@
 {
  "db_name": "PostgreSQL",
-  "query": "SELECT tag, count(*) as count FROM queue WHERE\n        scheduled_for <= now() - ('3 seconds')::interval AND running = false\n        GROUP BY tag",
+  "query": "SELECT tag, count(*) as count FROM queue WHERE\n                scheduled_for <= now() - ('3 seconds')::interval AND running = false\n                GROUP BY tag",
  "describe": {
    "columns": [
      {
@@ -22,5 +22,5 @@
      null
    ]
  },
-  "hash": "3e0e5e0076ae0f7771abd64f8c5bb7e003e3f85351c946a012037e0c874acf1a"
+  "hash": "02b516dac764662194db1bc33e365c01f40bae70af3683f1f09748f6020f0d49"
 }
--- a/backend/.sqlx/query-3667d72d23e8c35ab96d5e5d1fbfd94a8a9f74b6398e21f13c206c3f9427c6a9.json
+++ b/backend/.sqlx/query-3667d72d23e8c35ab96d5e5d1fbfd94a8a9f74b6398e21f13c206c3f9427c6a9.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM metrics \n                WHERE (id = 'author_count' OR id = 'operator_count' OR id = 'worker_usage') AND created_at < NOW() - INTERVAL '6 month'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": []
+  },
+  "hash": "3667d72d23e8c35ab96d5e5d1fbfd94a8a9f74b6398e21f13c206c3f9427c6a9"
+}
--- a/backend/.sqlx/query-4887db074e9058bc0c1887428d6b2a897fe4b30c83f2aa5e9464c156f08f1c3a.json
+++ b/backend/.sqlx/query-4887db074e9058bc0c1887428d6b2a897fe4b30c83f2aa5e9464c156f08f1c3a.json
@@ -0,0 +1,38 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT worker, worker_instance, vcpus, memory FROM worker_ping WHERE ping_at > NOW() - INTERVAL '2 minutes'",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "worker",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "worker_instance",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "vcpus",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 3,
+        "name": "memory",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "4887db074e9058bc0c1887428d6b2a897fe4b30c83f2aa5e9464c156f08f1c3a"
+}
--- a/backend/.sqlx/query-54fef88cc6b9e8db7c07fccbaa845edfefa339153a32e468faad9f063008863d.json
+++ b/backend/.sqlx/query-54fef88cc6b9e8db7c07fccbaa845edfefa339153a32e468faad9f063008863d.json
@@ -1,16 +1,17 @@
 {
  "db_name": "PostgreSQL",
-  "query": "UPDATE worker_ping SET ping_at = now(), jobs_executed = $1, custom_tags = $2 WHERE worker = $3",
+  "query": "UPDATE worker_ping SET ping_at = now(), jobs_executed = $1, custom_tags = $2, occupancy_rate = $3, current_job_id = NULL, current_job_workspace_id = NULL WHERE worker = $4",
  "describe": {
    "columns": [],
    "parameters": {
      "Left": [
        "Int4",
        "TextArray",
+        "Float4",
        "Text"
      ]
    },
    "nullable": []
  },
-  "hash": "47beea5cd6324b53bfb349665fb215280f32b70a617fde87f70ea53ca9ade39f"
+  "hash": "54fef88cc6b9e8db7c07fccbaa845edfefa339153a32e468faad9f063008863d"
 }
--- a/backend/.sqlx/query-5ce9a9e0669b299b998bc9080d24f8d6f56eb049bec2e0745d27ca3a4fc0c296.json
+++ b/backend/.sqlx/query-5ce9a9e0669b299b998bc9080d24f8d6f56eb049bec2e0745d27ca3a4fc0c296.json
@@ -0,0 +1,14 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO metrics (id, value) VALUES ('worker_usage', $1)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Jsonb"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "5ce9a9e0669b299b998bc9080d24f8d6f56eb049bec2e0745d27ca3a4fc0c296"
+}
--- a/backend/.sqlx/query-661f472ff3860983322162420457f5033b9c9afc344d9c3e385ba20a3ad2197a.json
+++ b/backend/.sqlx/query-661f472ff3860983322162420457f5033b9c9afc344d9c3e385ba20a3ad2197a.json
@@ -5,7 +5,7 @@
    "columns": [
      {
        "ordinal": 0,
-        "name": "?column?",
+        "name": "bool",
        "type_info": "Bool"
      }
    ],
--- a/backend/.sqlx/query-6afc5c7cbb3abe11ade0cedf1f7328005ce4de3165cdd998e5a0d27e044c7153.json
+++ b/backend/.sqlx/query-6afc5c7cbb3abe11ade0cedf1f7328005ce4de3165cdd998e5a0d27e044c7153.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO worker_ping (worker_instance, worker, ip, custom_tags, worker_group, dedicated_worker, wm_version, vcpus, memory) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) ON CONFLICT (worker) DO UPDATE set ip = $3, custom_tags = $4, worker_group = $5",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "TextArray",
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Int8",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "6afc5c7cbb3abe11ade0cedf1f7328005ce4de3165cdd998e5a0d27e044c7153"
+}
--- a/backend/.sqlx/query-7b609ed87f974dfe887778746230b40b485658a75a1186c6ebb4c2de1b52a2fa.json
+++ b/backend/.sqlx/query-7b609ed87f974dfe887778746230b40b485658a75a1186c6ebb4c2de1b52a2fa.json
@@ -1,20 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "INSERT INTO worker_ping (worker_instance, worker, ip, custom_tags, worker_group, dedicated_worker, wm_version) VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (worker) DO UPDATE set ip = $3, custom_tags = $4, worker_group = $5",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Varchar",
-        "Varchar",
-        "Varchar",
-        "TextArray",
-        "Varchar",
-        "Varchar",
-        "Varchar"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "7b609ed87f974dfe887778746230b40b485658a75a1186c6ebb4c2de1b52a2fa"
-}
--- a/backend/.sqlx/query-7c95f3652de4561b18c1a340db3e0113a4777d38de4468fc41b22ce5b6fd1db7.json
+++ b/backend/.sqlx/query-7c95f3652de4561b18c1a340db3e0113a4777d38de4468fc41b22ce5b6fd1db7.json
@@ -0,0 +1,26 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "WITH queue_metrics as (\n            SELECT id, value, created_at\n            FROM metrics\n            WHERE id LIKE 'queue_%'\n                AND created_at > now() - interval '14 day'\n            ORDER BY created_at ASC\n        )\n        SELECT id, array_agg(json_build_object('value', value, 'created_at', created_at)) as \"values!\"\n        FROM queue_metrics\n        GROUP BY id\n        ORDER BY id ASC",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "id",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "values!",
+        "type_info": "JsonArray"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      false,
+      null
+    ]
+  },
+  "hash": "7c95f3652de4561b18c1a340db3e0113a4777d38de4468fc41b22ce5b6fd1db7"
+}
--- a/backend/.sqlx/query-7c9a464ac807051b99fe37f2078f1b17f824e6d9b1124db618855a15a98e31f6.json
+++ b/backend/.sqlx/query-7c9a464ac807051b99fe37f2078f1b17f824e6d9b1124db618855a15a98e31f6.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM metrics WHERE id LIKE 'queue_%' AND created_at < NOW() - INTERVAL '14 day'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": []
+  },
+  "hash": "7c9a464ac807051b99fe37f2078f1b17f824e6d9b1124db618855a15a98e31f6"
+}
--- a/backend/.sqlx/query-82f6674f19e8ad51a992505a46f46fc4a48172f104e9e849f755ac041c3eef92.json
+++ b/backend/.sqlx/query-82f6674f19e8ad51a992505a46f46fc4a48172f104e9e849f755ac041c3eef92.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT created_at FROM metrics WHERE id LIKE 'queue_count_%' ORDER BY created_at DESC LIMIT 1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "created_at",
+        "type_info": "Timestamptz"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "82f6674f19e8ad51a992505a46f46fc4a48172f104e9e849f755ac041c3eef92"
+}
--- a/backend/.sqlx/query-8824b382c4e98dfa17b4aa656af3a6c1ff99973e778d71bd598a50d022da8f15.json
+++ b/backend/.sqlx/query-8824b382c4e98dfa17b4aa656af3a6c1ff99973e778d71bd598a50d022da8f15.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO metrics (id, value) VALUES ($1, $2)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Jsonb"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "8824b382c4e98dfa17b4aa656af3a6c1ff99973e778d71bd598a50d022da8f15"
+}
--- a/backend/.sqlx/query-8c62e3bb264c7336b3b3a68677993ba3b729c7358cc3da14513d8b447ce65aaf.json
+++ b/backend/.sqlx/query-8c62e3bb264c7336b3b3a68677993ba3b729c7358cc3da14513d8b447ce65aaf.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE worker_ping SET ping_at = now(), current_job_id = $1, current_job_workspace_id = $2 WHERE worker = $3",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Varchar",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "8c62e3bb264c7336b3b3a68677993ba3b729c7358cc3da14513d8b447ce65aaf"
+}
--- a/backend/.sqlx/query-8e7ff45c5378c3a3406ba94dc0653afa5d28c072203617c598caefaaf1bafcfb.json
+++ b/backend/.sqlx/query-8e7ff45c5378c3a3406ba94dc0653afa5d28c072203617c598caefaaf1bafcfb.json
@@ -1,6 +1,6 @@
 {
  "db_name": "PostgreSQL",
-  "query": "INSERT INTO script (workspace_id, hash, path, parent_hashes, summary, description, content, created_by, schema, is_template, extra_perms, lock, language, kind, tag, draft_only, envs, concurrent_limit, concurrency_time_window_s, cache_ttl, dedicated_worker, ws_error_handler_muted, priority, restart_unless_cancelled, delete_after_use, timeout, concurrency_key, visible_to_runner_only, no_main_func) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::text::json, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29)",
+  "query": "INSERT INTO script (workspace_id, hash, path, parent_hashes, summary, description, content, created_by, schema, is_template, extra_perms, lock, language, kind, tag, draft_only, envs, concurrent_limit, concurrency_time_window_s, cache_ttl, dedicated_worker, ws_error_handler_muted, priority, restart_unless_cancelled, delete_after_use, timeout, concurrency_key, visible_to_runner_only, no_main_func, codebase) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::text::json, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30)",
  "describe": {
    "columns": [],
    "parameters": {
@@ -67,10 +67,11 @@
        "Int4",
        "Varchar",
        "Bool",
-        "Bool"
+        "Bool",
+        "Varchar"
      ]
    },
    "nullable": []
  },
-  "hash": "92d00c6a1f4c40f2a23c9ba758a59597deabd7ca93653ad72d2cdc37efefc9d4"
+  "hash": "8e7ff45c5378c3a3406ba94dc0653afa5d28c072203617c598caefaaf1bafcfb"
 }
--- a/backend/.sqlx/query-9bf41c3161a02b7d0731c4e1d79519cef5255f5df1b759af3aa4985bb64313e5.json
+++ b/backend/.sqlx/query-9bf41c3161a02b7d0731c4e1d79519cef5255f5df1b759af3aa4985bb64313e5.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO metrics (id, value)\n                            VALUES ($1, to_jsonb((SELECT EXTRACT(EPOCH FROM now() - scheduled_for)\n                            FROM queue WHERE tag = $2 AND running = false AND scheduled_for <= now() - ('3 seconds')::interval\n                            ORDER BY priority DESC NULLS LAST, scheduled_for, created_at LIMIT 1)))",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "9bf41c3161a02b7d0731c4e1d79519cef5255f5df1b759af3aa4985bb64313e5"
+}
--- a/backend/.sqlx/query-bbd5f968d7b62a55a7ebf7b98cfd411678ce544fdb9472d8d223235fb2818aaf.json
+++ b/backend/.sqlx/query-bbd5f968d7b62a55a7ebf7b98cfd411678ce544fdb9472d8d223235fb2818aaf.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT args FROM completed_job WHERE id = $1 AND workspace_id = $2 UNION ALL SELECT args FROM input WHERE id = $1 AND workspace_id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "args",
+        "type_info": "Jsonb"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "bbd5f968d7b62a55a7ebf7b98cfd411678ce544fdb9472d8d223235fb2818aaf"
+}
--- a/backend/.sqlx/query-c584aeec21716f7405c355d5684ff3ac1be3f70849d67b8c2d4787e809b7ea2b.json
+++ b/backend/.sqlx/query-c584aeec21716f7405c355d5684ff3ac1be3f70849d67b8c2d4787e809b7ea2b.json
@@ -0,0 +1,26 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "WITH all_users as (SELECT count(*)::INT as count FROM usr WHERE disabled IS false),\n                authors as (SELECT count(distinct email)::INT as count FROM usr WHERE usr.operator IS false AND disabled IS false)\n                SELECT authors.count as author_count, all_users.count - authors.count as operator_count FROM all_users, authors",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "author_count",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 1,
+        "name": "operator_count",
+        "type_info": "Int4"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      null,
+      null
+    ]
+  },
+  "hash": "c584aeec21716f7405c355d5684ff3ac1be3f70849d67b8c2d4787e809b7ea2b"
+}
--- a/backend/.sqlx/query-c6b2791dd109c7bf40a40b557d9d5a140e70c49718fcb3a776b77f8f2ab901d4.json
+++ b/backend/.sqlx/query-c6b2791dd109c7bf40a40b557d9d5a140e70c49718fcb3a776b77f8f2ab901d4.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO metrics (id, value) VALUES ('author_count', $1), ('operator_count', $2)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Jsonb",
+        "Jsonb"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "c6b2791dd109c7bf40a40b557d9d5a140e70c49718fcb3a776b77f8f2ab901d4"
+}
--- a/backend/.sqlx/query-c9d97800eb0ec87df8e8959b283dacb2c6cce422365ed394375641488ceb6b65.json
+++ b/backend/.sqlx/query-c9d97800eb0ec87df8e8959b283dacb2c6cce422365ed394375641488ceb6b65.json
@@ -1,14 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "UPDATE worker_ping SET ping_at = now() WHERE worker = $1",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Text"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "c9d97800eb0ec87df8e8959b283dacb2c6cce422365ed394375641488ceb6b65"
-}
--- a/backend/.sqlx/query-e00171cc3fc8f32922562d4fc4d3db56955fbc6ee9872d4b2e99157ebed131e0.json
+++ b/backend/.sqlx/query-e00171cc3fc8f32922562d4fc4d3db56955fbc6ee9872d4b2e99157ebed131e0.json
@@ -1,6 +1,6 @@
 {
  "db_name": "PostgreSQL",
-  "query": "SELECT worker, worker_instance,  EXTRACT(EPOCH FROM (now() - ping_at))::integer as last_ping, started_at, ip, jobs_executed, custom_tags, worker_group, wm_version FROM worker_ping\n         WHERE ($1::integer IS NULL AND ping_at > now() - interval '5 minute') OR (ping_at > now() - ($1 || ' seconds')::interval)\n         ORDER BY ping_at desc LIMIT $2 OFFSET $3",
+  "query": "SELECT worker, worker_instance,  EXTRACT(EPOCH FROM (now() - ping_at))::integer as last_ping, started_at, ip, jobs_executed, CASE WHEN $4 IS TRUE THEN current_job_id ELSE NULL END as current_job_id, CASE WHEN $4 IS TRUE THEN current_job_workspace_id ELSE NULL END as current_job_workspace_id, custom_tags, worker_group, wm_version, occupancy_rate\n        FROM worker_ping\n        WHERE ($1::integer IS NULL AND ping_at > now() - interval '5 minute') OR (ping_at > now() - ($1 || ' seconds')::interval)\n        ORDER BY ping_at desc LIMIT $2 OFFSET $3",
  "describe": {
    "columns": [
      {
@@ -35,25 +35,41 @@
      },
      {
        "ordinal": 6,
-        "name": "custom_tags",
-        "type_info": "TextArray"
+        "name": "current_job_id",
+        "type_info": "Uuid"
      },
      {
        "ordinal": 7,
-        "name": "worker_group",
+        "name": "current_job_workspace_id",
        "type_info": "Varchar"
      },
      {
        "ordinal": 8,
+        "name": "custom_tags",
+        "type_info": "TextArray"
+      },
+      {
+        "ordinal": 9,
+        "name": "worker_group",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 10,
        "name": "wm_version",
        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 11,
+        "name": "occupancy_rate",
+        "type_info": "Float4"
      }
    ],
    "parameters": {
      "Left": [
        "Int4",
        "Int8",
-        "Int8"
+        "Int8",
+        "Bool"
      ]
    },
    "nullable": [
@@ -63,10 +79,13 @@
      false,
      false,
      false,
+      null,
+      null,
      true,
      false,
-      false
+      false,
+      true
    ]
  },
-  "hash": "b38044d94e2ab03167c2f6fbb553ab3c19930ed11abf51763cd3ee378229443d"
+  "hash": "e00171cc3fc8f32922562d4fc4d3db56955fbc6ee9872d4b2e99157ebed131e0"
 }
--- a/backend/Cargo.lock
+++ b/backend/Cargo.lock
--- a/backend/Cargo.toml
+++ b/backend/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "windmill"
-version = "1.317.1"
+version = "1.327.0"
 authors.workspace = true
 edition.workspace = true

@@ -24,7 +24,7 @@ members = [
 ]

 [workspace.package]
-version = "1.317.1"
+version = "1.327.0"
 authors = ["Ruben Fiszel <ruben@windmill.dev>"]
 edition = "2021"

@@ -50,6 +50,7 @@ parquet = ["windmill-api/parquet", "windmill-common/parquet", "windmill-worker/p
 prometheus = ["windmill-common/prometheus", "windmill-api/prometheus", "windmill-worker/prometheus", "windmill-queue/prometheus"]
 flow_testing = ["windmill-worker/flow_testing"]
 openidconnect = ["windmill-api/openidconnect"]
+cloud = ["windmill-queue/cloud"]

 [dependencies]
 anyhow.workspace = true
@@ -108,7 +109,7 @@ windmill-parser-sql = { path = "./parsers/windmill-parser-sql" }
 windmill-parser-graphql = { path = "./parsers/windmill-parser-graphql" }
 windmill-api-client = { path = "./windmill-api-client" }

-axum = { version = "^0.7" } 
+axum = { version = "^0.7", features = ["multipart"] } 
 headers = "^0"
 hyper = { version = "^1", features = ["full"] }
 tokio = { version = "^1", features = ["full", "tracing"] }
--- a/backend/ee-repo-ref.txt
+++ b/backend/ee-repo-ref.txt
@@ -1 +1 @@
-66d9cbb158ab9a5869a45ba253bf57f2cbb5ecb6
+644b6f49f087790a728a7a0a82525997b1742738
--- a/backend/migrations/20240430005030_add_codebases.down.sql
+++ b/backend/migrations/20240430005030_add_codebases.down.sql
@@ -0,0 +1,2 @@
+-- Add down migration script here
+ALTER TABLE script DROP COLUMN codebase;
--- a/backend/migrations/20240430005030_add_codebases.up.sql
+++ b/backend/migrations/20240430005030_add_codebases.up.sql
@@ -0,0 +1,3 @@
+-- Add up migration script here
+
+ALTER TABLE script ADD COLUMN codebase VARCHAR(255);
--- a/backend/migrations/20240506085935_add_worker_ping_metrics.down.sql
+++ b/backend/migrations/20240506085935_add_worker_ping_metrics.down.sql
@@ -0,0 +1 @@
+-- Add down migration script here
--- a/backend/migrations/20240506085935_add_worker_ping_metrics.up.sql
+++ b/backend/migrations/20240506085935_add_worker_ping_metrics.up.sql
@@ -0,0 +1,7 @@
+-- Add up migration script here
+ALTER TABLE worker_ping 
+ADD COLUMN current_job_id UUID,
+ADD COLUMN current_job_workspace_id VARCHAR(50),
+ADD COLUMN vcpus BIGINT,
+ADD COLUMN memory BIGINT,
+ADD COLUMN occupancy_rate REAL;
--- a/backend/migrations/20240506114033_add_metrics_table.down.sql
+++ b/backend/migrations/20240506114033_add_metrics_table.down.sql
@@ -0,0 +1 @@
+-- Add down migration script here
--- a/backend/migrations/20240506114033_add_metrics_table.up.sql
+++ b/backend/migrations/20240506114033_add_metrics_table.up.sql
@@ -0,0 +1,8 @@
+-- Add up migration script here
+CREATE TABLE metrics (
+  id VARCHAR(255) NOT NULL,
+  value JSONB NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL
+);
+CREATE INDEX metrics_key_idx ON metrics(id);
+CREATE INDEX metrics_sort_idx ON metrics(created_at DESC);
--- a/backend/parsers/windmill-parser-py-imports/src/lib.rs
+++ b/backend/parsers/windmill-parser-py-imports/src/lib.rs
@@ -52,6 +52,7 @@ static PYTHON_IMPORTS_REPLACEMENT: phf::Map<&'static str, &'static str> = phf_ma
    "ns1" => "ns1-python",
    "pymsql" => "PyMySQL",
    "haystack" => "haystack-ai",
+    "github" => "PyGithub",
 };

 fn replace_import(x: String) -> String {
--- a/backend/parsers/windmill-parser-sql/src/lib.rs
+++ b/backend/parsers/windmill-parser-sql/src/lib.rs
@@ -298,6 +298,7 @@ pub fn parse_pg_typ(typ: &str) -> Typ {
            "bigint" => Typ::Int,
            "bool" | "boolean" => Typ::Bool,
            "char" | "character" => Typ::Str(None),
+            "json" | "jsonb" => Typ::Object(vec![]),
            "smallint" | "int2" => Typ::Int,
            "smallserial" | "serial2" => Typ::Int,
            "serial" | "serial4" => Typ::Int,
--- a/backend/parsers/windmill-parser-wasm/pkg/package.json
+++ b/backend/parsers/windmill-parser-wasm/pkg/package.json
@@ -3,7 +3,7 @@
  "collaborators": [
    "Ruben Fiszel <ruben@windmill.dev>"
  ],
-  "version": "1.317.1",
+  "version": "1.318.0",
  "files": [
    "windmill_parser_wasm_bg.wasm",
    "windmill_parser_wasm.js",
--- a/backend/parsers/windmill-parser-wasm/pkg/windmill_parser_wasm.js
+++ b/backend/parsers/windmill-parser-wasm/pkg/windmill_parser_wasm.js
@@ -97,15 +97,6 @@ function getInt32Memory0() {
    return cachedInt32Memory0;
 }

-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
 const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );

 if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
@@ -115,6 +106,15 @@ function getStringFromWasm0(ptr, len) {
    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }

+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
 let cachedFloat64Memory0 = null;

 function getFloat64Memory0() {
@@ -561,10 +561,6 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
    const imports = {};
    imports.wbg = {};
-    imports.wbg.__wbg_eval_2b43744c6689f0c5 = function(arg0, arg1) {
-        const ret = eval(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
        takeObject(arg0);
    };
@@ -576,6 +572,10 @@ function __wbg_get_imports() {
        getInt32Memory0()[arg0 / 4 + 1] = len1;
        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
    };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
    imports.wbg.__wbindgen_boolean_get = function(arg0) {
        const v = getObject(arg0);
        const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
@@ -597,10 +597,6 @@ function __wbg_get_imports() {
        const ret = BigInt.asUintN(64, arg0);
        return addHeapObject(ret);
    };
-    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
    imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
        const obj = getObject(arg1);
        const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -616,6 +612,10 @@ function __wbg_get_imports() {
        const ret = getObject(arg0) in getObject(arg1);
        return ret;
    };
+    imports.wbg.__wbg_eval_33c4985197d1feaf = function(arg0, arg1) {
+        const ret = eval(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
    imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
        const ret = getObject(arg0) == getObject(arg1);
        return ret;
--- a/backend/parsers/windmill-parser-wasm/pkg/windmill_parser_wasm_bg.wasm
+++ b/backend/parsers/windmill-parser-wasm/pkg/windmill_parser_wasm_bg.wasm
--- a/backend/src/main.rs
+++ b/backend/src/main.rs
@@ -18,11 +18,11 @@ use tokio::fs::DirBuilder;
 use windmill_api::HTTP_CLIENT;
 use windmill_common::{
    global_settings::{
-        BASE_URL_SETTING, BUNFIG_INSTALL_SCOPES_SETTING, CUSTOM_TAGS_SETTING,
-        DEFAULT_TAGS_PER_WORKSPACE_SETTING, ENV_SETTINGS, EXPOSE_DEBUG_METRICS_SETTING,
-        EXPOSE_METRICS_SETTING, EXTRA_PIP_INDEX_URL_SETTING, HUB_BASE_URL_SETTING,
-        JOB_DEFAULT_TIMEOUT_SECS_SETTING, KEEP_JOB_DIR_SETTING, LICENSE_KEY_SETTING,
-        NPM_CONFIG_REGISTRY_SETTING, OAUTH_SETTING, PIP_INDEX_URL_SETTING,
+        BASE_URL_SETTING, BUNFIG_INSTALL_SCOPES_SETTING, CRITICAL_ERROR_CHANNELS_SETTING,
+        CUSTOM_TAGS_SETTING, DEFAULT_TAGS_PER_WORKSPACE_SETTING, ENV_SETTINGS,
+        EXPOSE_DEBUG_METRICS_SETTING, EXPOSE_METRICS_SETTING, EXTRA_PIP_INDEX_URL_SETTING,
+        HUB_BASE_URL_SETTING, JOB_DEFAULT_TIMEOUT_SECS_SETTING, KEEP_JOB_DIR_SETTING,
+        LICENSE_KEY_SETTING, NPM_CONFIG_REGISTRY_SETTING, OAUTH_SETTING, PIP_INDEX_URL_SETTING,
        REQUEST_SIZE_LIMIT_SETTING, REQUIRE_PREEXISTING_USER_FOR_OAUTH_SETTING,
        RETENTION_PERIOD_SECS_SETTING, SAML_METADATA_SETTING, SCIM_TOKEN_SETTING,
    },
@@ -47,10 +47,11 @@ use windmill_worker::{
 use crate::monitor::{
    initial_load, load_keep_job_dir, load_require_preexisting_user, load_tag_per_workspace_enabled,
    monitor_db, monitor_pool, reload_base_url_setting, reload_bunfig_install_scopes_setting,
-    reload_extra_pip_index_url_setting, reload_hub_base_url_setting,
-    reload_job_default_timeout_setting, reload_license_key, reload_npm_config_registry_setting,
-    reload_pip_index_url_setting, reload_retention_period_setting, reload_scim_token_setting,
-    reload_server_config, reload_worker_config,
+    reload_critical_error_channels_setting, reload_extra_pip_index_url_setting,
+    reload_hub_base_url_setting, reload_job_default_timeout_setting, reload_license_key,
+    reload_npm_config_registry_setting, reload_pip_index_url_setting,
+    reload_retention_period_setting, reload_scim_token_setting, reload_server_config,
+    reload_worker_config,
 };

 #[cfg(feature = "parquet")]
@@ -503,6 +504,11 @@ Windmill Community Edition {GIT_VERSION}
                                                        tracing::error!(error = %e, "Could not reload hub base url setting");
                                                    }
                                                },
+                                                CRITICAL_ERROR_CHANNELS_SETTING => {
+                                                    if let Err(e) = reload_critical_error_channels_setting(&db).await {
+                                                        tracing::error!(error = %e, "Could not reload critical error emails setting");
+                                                    }
+                                                },
                                                a @_ => {
                                                    tracing::info!("Unrecognized Global Setting Change Payload: {:?}", a);
                                                }
--- a/backend/src/monitor.rs
+++ b/backend/src/monitor.rs
@@ -8,7 +8,7 @@ use std::{
 };

 use rsmq_async::MultiplexedRsmq;
-use serde::de::DeserializeOwned;
+use serde::{de::DeserializeOwned, Serialize};
 use sqlx::{Pool, Postgres};
 use tokio::{
    join,
@@ -22,15 +22,17 @@ use windmill_api::{
    DEFAULT_BODY_LIMIT, IS_SECURE, OAUTH_CLIENTS, REQUEST_SIZE_LIMIT, SAML_METADATA, SCIM_TOKEN,
 };
 use windmill_common::{
+    ee::CriticalErrorChannel,
    error,
    flow_status::FlowStatusModule,
    global_settings::{
-        BASE_URL_SETTING, BUNFIG_INSTALL_SCOPES_SETTING, DEFAULT_TAGS_PER_WORKSPACE_SETTING,
-        EXPOSE_DEBUG_METRICS_SETTING, EXPOSE_METRICS_SETTING, EXTRA_PIP_INDEX_URL_SETTING,
-        HUB_BASE_URL_SETTING, JOB_DEFAULT_TIMEOUT_SECS_SETTING, KEEP_JOB_DIR_SETTING,
-        LICENSE_KEY_SETTING, NPM_CONFIG_REGISTRY_SETTING, OAUTH_SETTING, PIP_INDEX_URL_SETTING,
-        REQUEST_SIZE_LIMIT_SETTING, REQUIRE_PREEXISTING_USER_FOR_OAUTH_SETTING,
-        RETENTION_PERIOD_SECS_SETTING, SAML_METADATA_SETTING, SCIM_TOKEN_SETTING,
+        BASE_URL_SETTING, BUNFIG_INSTALL_SCOPES_SETTING, CRITICAL_ERROR_CHANNELS_SETTING,
+        DEFAULT_TAGS_PER_WORKSPACE_SETTING, EXPOSE_DEBUG_METRICS_SETTING, EXPOSE_METRICS_SETTING,
+        EXTRA_PIP_INDEX_URL_SETTING, HUB_BASE_URL_SETTING, JOB_DEFAULT_TIMEOUT_SECS_SETTING,
+        KEEP_JOB_DIR_SETTING, LICENSE_KEY_SETTING, NPM_CONFIG_REGISTRY_SETTING, OAUTH_SETTING,
+        PIP_INDEX_URL_SETTING, REQUEST_SIZE_LIMIT_SETTING,
+        REQUIRE_PREEXISTING_USER_FOR_OAUTH_SETTING, RETENTION_PERIOD_SECS_SETTING,
+        SAML_METADATA_SETTING, SCIM_TOKEN_SETTING,
    },
    jobs::QueuedJob,
    oauth2::REQUIRE_PREEXISTING_USER_FOR_OAUTH,
@@ -40,7 +42,8 @@ use windmill_common::{
        load_worker_config, reload_custom_tags_setting, DEFAULT_TAGS_PER_WORKSPACE, SERVER_CONFIG,
        WORKER_CONFIG,
    },
-    BASE_URL, DB, DEFAULT_HUB_BASE_URL, HUB_BASE_URL, METRICS_DEBUG_ENABLED, METRICS_ENABLED,
+    BASE_URL, CRITICAL_ERROR_CHANNELS, DB, DEFAULT_HUB_BASE_URL, HUB_BASE_URL,
+    METRICS_DEBUG_ENABLED, METRICS_ENABLED,
 };
 use windmill_queue::cancel_job;
 use windmill_worker::{
@@ -143,6 +146,10 @@ pub async fn initial_load(
        tracing::error!("Error reloading hub base url: {:?}", e)
    }

+    if let Err(e) = reload_critical_error_channels_setting(&db).await {
+        tracing::error!("Could not reload critical error emails setting: {:?}", e);
+    }
+
    #[cfg(feature = "parquet")]
    if !_is_agent {
        reload_s3_cache_setting(&db).await;
@@ -671,39 +678,182 @@ pub async fn monitor_db(
    };

    let expose_queue_metrics_f = async {
-        if !initial_load
-            && METRICS_ENABLED.load(std::sync::atomic::Ordering::Relaxed)
-            && server_mode
-        {
+        if !initial_load && server_mode {
            expose_queue_metrics(&db).await;
        }
    };
+
+    let save_usage_metrics_f = async {
+        if !initial_load && server_mode {
+            save_usage_metrics(&db).await;
+        }
+    };
+
    join!(
        expired_items_f,
        zombie_jobs_f,
        expose_queue_metrics_f,
+        save_usage_metrics_f,
        verify_license_key_f
    );
 }

 pub async fn expose_queue_metrics(db: &Pool<Postgres>) {
-    let queue_counts = sqlx::query!(
-        "SELECT tag, count(*) as count FROM queue WHERE
-        scheduled_for <= now() - ('3 seconds')::interval AND running = false
-        GROUP BY tag"
-    )
-    .fetch_all(db)
-    .await
-    .ok()
-    .unwrap_or_else(|| vec![]);
-    for q in queue_counts {
-        let count = q.count.unwrap_or(0);
-        let tag = q.tag;
-        let metric = (*QUEUE_COUNT).with_label_values(&[&tag]);
-        metric.set(count as i64);
+    let tx = db.begin().await;
+    if let Ok(mut tx) = tx {
+        let last_check = sqlx::query_scalar!(
+            "SELECT created_at FROM metrics WHERE id LIKE 'queue_count_%' ORDER BY created_at DESC LIMIT 1"
+        )
+        .fetch_optional(db)
+        .await
+        .unwrap_or(Some(chrono::Utc::now()));
+
+        let metrics_enabled = METRICS_ENABLED.load(std::sync::atomic::Ordering::Relaxed);
+        let save_metrics = last_check
+            .map(|last_check| chrono::Utc::now() - last_check > chrono::Duration::seconds(25))
+            .unwrap_or(true);
+
+        if metrics_enabled || save_metrics {
+
+            let queue_counts = sqlx::query!(
+                "SELECT tag, count(*) as count FROM queue WHERE
+                scheduled_for <= now() - ('3 seconds')::interval AND running = false
+                GROUP BY tag"
+            )
+            .fetch_all(&mut *tx)
+            .await
+            .ok()
+            .unwrap_or_else(|| vec![]);
+
+            for q in queue_counts {
+                let count = q.count.unwrap_or(0);
+                let tag = q.tag;
+                if metrics_enabled {
+                    let metric = (*QUEUE_COUNT).with_label_values(&[&tag]);
+                    metric.set(count as i64);
+                }
+
+                // save queue_count and delay metrics per tag
+                if save_metrics {
+                    sqlx::query!(
+                        "INSERT INTO metrics (id, value) VALUES ($1, $2)",
+                        format!("queue_count_{}", tag),
+                        serde_json::json!(count)
+                    )
+                    .execute(&mut *tx)
+                    .await
+                    .ok();
+                    if count > 0 {
+                        sqlx::query!(
+                            "INSERT INTO metrics (id, value)
+                            VALUES ($1, to_jsonb((SELECT EXTRACT(EPOCH FROM now() - scheduled_for)
+                            FROM queue WHERE tag = $2 AND running = false AND scheduled_for <= now() - ('3 seconds')::interval
+                            ORDER BY priority DESC NULLS LAST, scheduled_for, created_at LIMIT 1)))",
+                            format!("queue_delay_{}", tag),
+                            tag
+                        ).execute(&mut *tx).await.ok();
+                    }
+                }
+            }
+        }
+
+        // clean queue metrics older than 14 days
+        sqlx::query!(
+            "DELETE FROM metrics WHERE id LIKE 'queue_%' AND created_at < NOW() - INTERVAL '14 day'"
+        ).execute(&mut *tx).await.ok();
+
+        tx.commit().await.ok();
    }
 }

+
+#[derive(Serialize)]
+struct WorkerUsage {
+    worker: String,
+    worker_instance: String,
+    vcpus: Option<i64>,
+    memory: Option<i64>,
+
+}
+
+pub async fn save_usage_metrics(db: &Pool<Postgres>) {
+    let tx = db.begin().await;
+
+    if let Ok(mut tx) = tx {
+        let last_check = sqlx::query_scalar!(
+            "SELECT created_at FROM metrics WHERE id = 'author_count' ORDER BY created_at DESC LIMIT 1"
+        )
+        .fetch_optional(db)
+        .await
+        .unwrap_or(Some(chrono::Utc::now()));
+
+        let random_nb = rand::random::<i64>();
+
+        // save author and operator count every ~24 hours
+        if last_check
+            .map(|last_check| chrono::Utc::now() - last_check > chrono::Duration::hours(24) - chrono::Duration::minutes(random_nb % 60))
+            .unwrap_or(true)
+        {
+            let counts = sqlx::query!(
+                "WITH all_users as (SELECT count(*)::INT as count FROM usr WHERE disabled IS false),
+                authors as (SELECT count(distinct email)::INT as count FROM usr WHERE usr.operator IS false AND disabled IS false)
+                SELECT authors.count as author_count, all_users.count - authors.count as operator_count FROM all_users, authors"
+            )
+            .fetch_one(&mut *tx)
+            .await
+            .ok();
+
+            if let Some(counts) = counts {
+                sqlx::query!(
+                    "INSERT INTO metrics (id, value) VALUES ('author_count', $1), ('operator_count', $2)",
+                    serde_json::json!(counts.author_count), 
+                    serde_json::json!(counts.operator_count)
+                )
+                .execute(&mut *tx)
+                .await
+                .ok();
+            }
+
+
+            // clean metrics older than 6 months (including worker usage)
+            sqlx::query!(
+                "DELETE FROM metrics 
+                WHERE (id = 'author_count' OR id = 'operator_count' OR id = 'worker_usage') AND created_at < NOW() - INTERVAL '6 month'"
+            )
+            .execute(&mut *tx)
+            .await
+            .ok();
+        }
+
+        // save worker usage every ~60 minutes
+        if last_check
+            .map(|last_check| chrono::Utc::now() - last_check > chrono::Duration::minutes(60) - chrono::Duration::seconds(random_nb % 300))
+            .unwrap_or(true)
+        {
+            let worker_usage = sqlx::query_as!(
+                WorkerUsage,
+                "SELECT worker, worker_instance, vcpus, memory FROM worker_ping WHERE ping_at > NOW() - INTERVAL '2 minutes'"
+            )
+            .fetch_all(&mut *tx)
+            .await
+            .ok();
+
+            if let Some(worker_usage) = worker_usage {
+                sqlx::query!(
+                    "INSERT INTO metrics (id, value) VALUES ('worker_usage', $1)",
+                    serde_json::json!(worker_usage)
+                )
+                .execute(&mut *tx)
+                .await
+                .ok();
+            }
+        }
+
+        tx.commit().await.ok();
+    }
+
+}
+
 pub async fn reload_server_config(db: &Pool<Postgres>) {
    let config = load_server_config(&db).await;
    if let Err(e) = config {
@@ -1074,3 +1224,27 @@ pub async fn reload_hub_base_url_setting(db: &DB, server_mode: bool) -> error::R

    Ok(())
 }
+
+pub async fn reload_critical_error_channels_setting(db: &DB) -> error::Result<()> {
+    let critical_error_channels =
+        load_value_from_global_settings(db, CRITICAL_ERROR_CHANNELS_SETTING).await?;
+
+    let critical_error_channels = if let Some(q) = critical_error_channels {
+        if let Ok(v) = serde_json::from_value::<Vec<CriticalErrorChannel>>(q.clone()) {
+            v
+        } else {
+            tracing::error!(
+                "Could not parse critical_error_emails setting as an array of channels, found: {:#?}",
+                &q
+            );
+            vec![]
+        }
+    } else {
+        vec![]
+    };
+
+    let mut l = CRITICAL_ERROR_CHANNELS.write().await;
+    *l = critical_error_channels;
+
+    Ok(())
+}
--- a/backend/tests/worker.rs
+++ b/backend/tests/worker.rs
@@ -1663,6 +1663,7 @@ func main(derp string) (string, error) {
    .to_owned();

    let result = RunJob::from(JobPayload::Code(RawCode {
+        hash: None,
        content,
        path: None,
        lock: None,
@@ -1694,6 +1695,7 @@ echo "hello $msg"
    .to_owned();

    let job = RunJob::from(JobPayload::Code(RawCode {
+        hash: None,
        content,
        path: None,
        lock: None,
@@ -1722,6 +1724,7 @@ def main():
    .to_owned();

    let job = JobPayload::Code(RawCode {
+        hash: None,
        content,
        path: None,
        language: ScriptLang::Python3,
@@ -1756,6 +1759,7 @@ def main():
    .to_owned();

    let job = JobPayload::Code(RawCode {
+        hash: None,
        content,
        path: None,
        language: ScriptLang::Python3,
@@ -1789,6 +1793,7 @@ def main():
    .to_owned();

    let job = JobPayload::Code(RawCode {
+        hash: None,
        content,
        path: None,
        language: ScriptLang::Python3,
@@ -3165,6 +3170,7 @@ async fn run_deployed_relative_imports(db: &Pool<Postgres>, script_content: Stri
            concurrency_key: None,
            visible_to_runner_only: None,
            no_main_func: None,
+            codebase: None
        },
    ).await.unwrap();

@@ -3212,6 +3218,7 @@ async fn run_preview_relative_imports(db: &Pool<Postgres>, script_content: Strin
    let db2 = db.clone();
    in_test_worker(&db, async move {
        let job = RunJob::from(JobPayload::Code(RawCode {
+            hash: None,
            content: script_content,
            path: Some("f/system/test_import".to_string()),
            language,
--- a/backend/windmill-api/Cargo.toml
+++ b/backend/windmill-api/Cargo.toml
@@ -72,7 +72,6 @@ async_zip.workspace = true
 rsmq_async.workspace = true
 regex.workspace = true
 bytes.workspace = true
-mail-send.workspace = true
 samael = { workspace = true, optional = true }
 async-recursion.workspace = true
 rsa.workspace = true
--- a/backend/windmill-api/openapi.yaml
+++ b/backend/windmill-api/openapi.yaml
@@ -1,7 +1,7 @@
 openapi: "3.0.3"

 info:
-  version: 1.317.1
+  version: 1.327.0
  title: Windmill API

  contact:
@@ -6959,6 +6959,40 @@ paths:
              schema:
                type: boolean

+  /workers/queue_metrics:
+    get:
+      summary: get queue metrics
+      operationId: getQueueMetrics
+      tags:
+        - worker
+      responses:
+        "200":
+          description: metrics
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: object
+                  properties:
+                    id:
+                      type: string
+                    values: 
+                      type: array
+                      items:
+                        type: object
+                        properties:
+                          created_at:
+                            type: string
+                          value:
+                            type: number
+                        required:
+                          - created_at
+                          - value
+                  required:
+                    - id
+                    - values
+
  /configs/list_worker_groups:
    get:
      summary: list worker groups
@@ -7271,6 +7305,26 @@ paths:
                items:
                  $ref: "#/components/schemas/Input"

+  /w/{workspace}/inputs/{jobOrInputId}/args:
+    get:
+      summary: Get args from history or saved input
+      operationId: getArgsFromHistoryOrSavedInput
+      tags:
+        - input
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+        - name: jobOrInputId
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        "200":
+          description: args
+          content:
+            application/json:
+              schema: {}
+
  /w/{workspace}/inputs/list:
    get:
      summary: List saved Inputs for a Runnable
@@ -8390,6 +8444,9 @@ components:
          type: boolean
        no_main_func:
          type: boolean
+        codebase:
+          type: string
+
      required:
        - hash
        - path
@@ -8407,6 +8464,7 @@ components:
        - starred
        - no_main_func

+
    NewScript:
      type: object
      properties:
@@ -8481,6 +8539,8 @@ components:
          type: boolean
        no_main_func:
          type: boolean
+        codebase:
+          type: string
      required:
        - path
        - summary
@@ -9678,6 +9738,12 @@ components:
          type: string
        wm_version:
          type: string
+        current_job_id:
+          type: string
+        current_job_workspace_id:
+          type: string
+        occupancy_rate:
+          type: number
      required:
        - worker
        - worker_instance
--- a/backend/windmill-api/src/flows.rs
+++ b/backend/windmill-api/src/flows.rs
@@ -543,7 +543,7 @@ async fn update_flow(
        clear_schedule(tx.transaction_mut(), &schedule.path, &w_id).await?;

        if schedule.enabled {
-            tx = push_scheduled_job(&db, tx, schedule).await?;
+            tx = push_scheduled_job(&db, tx, &schedule).await?;
        }
    }

@@ -955,7 +955,7 @@ mod tests {
                    continue_on_error: None,
                },
            ],
-            failure_module: Some(FlowModule {
+            failure_module: Some(Box::new(FlowModule {
                id: "d".to_string(),
                value: FlowModuleValue::Script {
                    path: "test".to_string(),
@@ -977,7 +977,7 @@ mod tests {
                priority: None,
                delete_after_use: None,
                continue_on_error: None,
-            }),
+            })),
            same_worker: false,
            concurrent_limit: None,
            concurrency_time_window_s: None,
--- a/backend/windmill-api/src/folders.rs
+++ b/backend/windmill-api/src/folders.rs
@@ -271,7 +271,7 @@ async fn update_folder(
    Extension(user_db): Extension<UserDB>,
    Extension(webhook): Extension<WebhookShared>,
    Path((w_id, name)): Path<(String, String)>,
-    Json(ng): Json<UpdateFolder>,
+    Json(mut ng): Json<UpdateFolder>,
 ) -> Result<String> {
    use sql_builder::prelude::*;

@@ -282,6 +282,25 @@ async fn update_folder(
    if let Some(display_name) = ng.display_name {
        sqlb.set("display_name", "?".bind(&display_name));
    }
+
+    if !authed.is_admin {
+        let prefixed_username = format!("u/{}", authed.username);
+        if ng.owners.as_ref().is_some_and(|x| {
+            !x.contains(&prefixed_username)
+                && !authed.groups.iter().any(|g| x.contains(&format!("g/{g}")))
+        }) {
+            ng.owners.as_mut().unwrap().push(prefixed_username.clone());
+            if ng.extra_perms.is_none() {
+                ng.extra_perms = Some(serde_json::Value::Object(serde_json::Map::new()));
+            }
+            ng.extra_perms
+                .as_mut()
+                .unwrap()
+                .as_object_mut()
+                .unwrap()
+                .insert(prefixed_username, serde_json::json!(true));
+        }
+    }
    if let Some(owners) = ng.owners {
        sqlb.set(
            "owners",
@@ -310,9 +329,16 @@ async fn update_folder(
        .sql()
        .map_err(|e| error::Error::InternalErr(e.to_string()))?;
    let nfolder = sqlx::query_as::<_, Folder>(&sql)
-        .fetch_one(&mut *tx)
+        .fetch_optional(&mut *tx)
        .await?;

+    let nfolder = nfolder.ok_or_else(|| {
+        windmill_common::error::Error::NotAuthorized(format!(
+            "You are not an owner of {} and hence cannot modify it",
+            name
+        ))
+    })?;
+
    if let Some(extra_perms) = nfolder.extra_perms.as_object() {
        for o in nfolder.owners {
            if !extra_perms
--- a/backend/windmill-api/src/inputs.rs
+++ b/backend/windmill-api/src/inputs.rs
@@ -25,7 +25,7 @@ use windmill_common::{
    error::JsonResult,
    jobs::JobKind,
    scripts::to_i64,
-    utils::{paginate, Pagination},
+    utils::{not_found_if_none, paginate, Pagination},
 };
 pub fn workspaced_service() -> Router {
    Router::new()
@@ -34,6 +34,10 @@ pub fn workspaced_service() -> Router {
        .route("/create", post(create_input))
        .route("/update", post(update_input))
        .route("/delete/:id", post(delete_input))
+        .route(
+            "/:job_or_input_id/args",
+            get(get_args_from_history_or_saved_input),
+        )
 }

 #[derive(Debug, sqlx::FromRow, Serialize, Deserialize)]
@@ -123,7 +127,7 @@ async fn get_input_history(
    let mut tx = user_db.begin(&authed).await?;

    let sql = &format!(
-        "select id, created_at, created_by, args, success from completed_job \
+        "select id, created_at, created_by, CASE WHEN args is null or pg_column_size(args) < 40000 THEN args ELSE '\"WINDMILL_TOO_BIG\"'::jsonb END as args, success from completed_job \
        where {} = $1 and job_kind = $2 and workspace_id = $3 \
        order by created_at desc limit $4 offset $5",
        r.runnable_type.column_name()
@@ -167,6 +171,27 @@ async fn get_input_history(
    Ok(Json(inputs))
 }

+async fn get_args_from_history_or_saved_input(
+    authed: ApiAuthed,
+    Extension(user_db): Extension<UserDB>,
+    Path((w_id, job_or_input_id)): Path<(String, Uuid)>,
+) -> JsonResult<Option<Value>> {
+    let mut tx = user_db.begin(&authed).await?;
+    let result_o = sqlx::query_scalar!(
+        "SELECT args FROM completed_job WHERE id = $1 AND workspace_id = $2 UNION ALL SELECT args FROM input WHERE id = $1 AND workspace_id = $2",
+        job_or_input_id,
+        w_id
+    )
+    .fetch_optional(&mut *tx)
+    .await?;
+
+    tx.commit().await?;
+
+    let result = not_found_if_none(result_o, "Input args", job_or_input_id.to_string())?;
+
+    Ok(Json(result))
+}
+
 async fn list_saved_inputs(
    authed: ApiAuthed,
    Extension(user_db): Extension<UserDB>,
@@ -179,7 +204,7 @@ async fn list_saved_inputs(
    let mut tx = user_db.begin(&authed).await?;

    let rows = sqlx::query_as::<_, InputRow>(
-        "select * from input \
+        "select id, workspace_id, runnable_id, runnable_type, name, CASE WHEN pg_column_size(args) < 40000 THEN args ELSE '\"WINDMILL_TOO_BIG\"'::jsonb END as args, created_at, created_by, is_public from input \
         where runnable_id = $1 and runnable_type = $2 and workspace_id = $3 \
         and (is_public IS true OR created_by = $4) \
         order by created_at desc limit $5 offset $6",
--- a/backend/windmill-api/src/jobs.rs
+++ b/backend/windmill-api/src/jobs.rs
@@ -12,6 +12,7 @@ use serde_json::value::RawValue;
 use std::collections::HashMap;
 #[cfg(feature = "prometheus")]
 use std::sync::atomic::Ordering;
+use tokio::io::AsyncReadExt;
 #[cfg(feature = "prometheus")]
 use tokio::time::Instant;
 use windmill_common::flow_status::{JobResult, RestartedFrom};
@@ -19,6 +20,10 @@ use windmill_common::jobs::{
    format_completed_job_result, format_result, CompletedJobWithFormattedResult, FormattedResult,
    ENTRYPOINT_OVERRIDE,
 };
+use windmill_common::worker::TMP_DIR;
+
+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+use windmill_common::scripts::PREVIEW_IS_CODEBASE_HASH;
 use windmill_common::variables::get_workspace_key;

 use crate::db::ApiAuthed;
@@ -163,6 +168,7 @@ pub fn workspaced_service() -> Router {
                .layer(cors.clone()),
        )
        .route("/run/preview", post(run_preview_script))
+        .route("/run/preview_bundle", post(run_bundle_preview_script))
        .route("/add_batch_jobs/:n", post(add_batch_jobs))
        .route("/run/preview_flow", post(run_preview_flow_job))
        .route(
@@ -660,17 +666,17 @@ async fn get_job_internal(
 async fn get_logs_from_store(
    log_offset: i32,
    logs: &str,
-    log_file_index: Option<Vec<String>>,
+    log_file_index: &Option<Vec<String>>,
 ) -> Option<error::Result<Body>> {
    if log_offset > 0 {
-        if let Some(file_index) = log_file_index {
+        if let Some(file_index) = log_file_index.clone() {
            tracing::debug!("Getting logs from store: {file_index:?}");
            if let Some(os) = OBJECT_STORE_CACHE_SETTINGS.read().await.clone() {
                tracing::debug!("object store client present, streaming from there");

                let logs = logs.to_string();
                let stream = async_stream::stream! {
-                    for file_p in file_index {
+                    for file_p in file_index.clone() {
                        let file_p_2 = file_p.clone();
                        let file = os.get(&object_store::path::Path::from(file_p)).await;
                        if let Ok(file) = file {
@@ -692,6 +698,40 @@ async fn get_logs_from_store(
    }
    return None;
 }
+
+async fn get_logs_from_disk(
+    log_offset: i32,
+    logs: &str,
+    log_file_index: &Option<Vec<String>>,
+) -> Option<error::Result<Body>> {
+    if log_offset > 0 {
+        if let Some(file_index) = log_file_index.clone() {
+            for file_p in &file_index {
+                if !tokio::fs::metadata(format!("{TMP_DIR}/{file_p}"))
+                    .await
+                    .is_ok()
+                {
+                    return None;
+                }
+            }
+
+            let logs = logs.to_string();
+            let stream = async_stream::stream! {
+                for file_p in file_index.clone() {
+                    let mut file = tokio::fs::File::open(format!("{TMP_DIR}/{file_p}")).await.map_err(to_anyhow)?;
+                    let mut buffer = Vec::new();
+                    file.read_to_end(&mut buffer).await.map_err(to_anyhow)?;
+                    yield Ok(bytes::Bytes::from(buffer)) as anyhow::Result<bytes::Bytes>;
+                }
+
+                yield Ok(bytes::Bytes::from(logs))
+            };
+            return Some(Ok(Body::from_stream(stream)));
+        }
+    }
+    return None;
+}
+
 async fn get_job_logs(
    Extension(db): Extension<DB>,
    Path((w_id, id)): Path<(String, Uuid)>,
@@ -710,7 +750,11 @@ async fn get_job_logs(
    if let Some(record) = record {
        let logs = record.logs.unwrap_or_default();
        #[cfg(all(feature = "enterprise", feature = "parquet"))]
-        if let Some(r) = get_logs_from_store(record.log_offset, &logs, record.log_file_index).await
+        if let Some(r) = get_logs_from_store(record.log_offset, &logs, &record.log_file_index).await
+        {
+            return r;
+        }
+        if let Some(r) = get_logs_from_disk(record.log_offset, &logs, &record.log_file_index).await
        {
            return r;
        }
@@ -730,7 +774,10 @@ async fn get_job_logs(

        let logs = text.logs.unwrap_or_default();
        #[cfg(all(feature = "enterprise", feature = "parquet"))]
-        if let Some(r) = get_logs_from_store(text.log_offset, &logs, text.log_file_index).await {
+        if let Some(r) = get_logs_from_store(text.log_offset, &logs, &text.log_file_index).await {
+            return r;
+        }
+        if let Some(r) = get_logs_from_disk(text.log_offset, &logs, &text.log_file_index).await {
            return r;
        }
        Ok(Body::from(logs))
@@ -2077,7 +2124,9 @@ enum PreviewKind {
    Identity,
    Http,
    Noop,
+    Bundle,
 }
+
 #[derive(Deserialize)]
 struct Preview {
    content: Option<String>,
@@ -2420,6 +2469,7 @@ pub async fn run_workflow_as_code(
    let (job_payload, tag, _delete_after_use, timeout) = match job.job_kind {
        JobKind::Preview => (
            JobPayload::Code(RawCode {
+                hash: None,
                content: job.raw_code.unwrap_or_default(),
                path: job.script_path,
                language: job.language.unwrap_or_else(|| ScriptLang::Deno),
@@ -2521,7 +2571,7 @@ async fn run_wait_result(
    w_id: String,
    node_id_for_empty_return: Option<String>,
 ) -> error::Result<Response> {
-    let mut result;
+    let mut result = None;
    let timeout = SERVER_CONFIG.read().await.timeout_wait_result.clone();
    let timeout_ms = if timeout <= 0 {
        2000
@@ -2545,7 +2595,9 @@ async fn run_wait_result(
            )
            .await
            .ok();
-        } else {
+        }
+
+        if result.is_none() {
            let row = sqlx::query(
                "SELECT result, language, flow_status FROM completed_job WHERE id = $1 AND workspace_id = $2",
            )
@@ -2563,8 +2615,6 @@ async fn run_wait_result(
                    FormattedResult::RawValue(rv) => rv,
                    FormattedResult::Vec(v) => Some(to_raw_value(&v)),
                };
-            } else {
-                result = None;
            }
        }

@@ -3083,6 +3133,7 @@ async fn run_preview_script(
            Some(PreviewKind::Identity) => JobPayload::Identity,
            Some(PreviewKind::Noop) => JobPayload::Noop,
            _ => JobPayload::Code(RawCode {
+                hash: None,
                content: preview.content.unwrap_or_default(),
                path: preview.path,
                language: preview.language.unwrap_or(ScriptLang::Deno),
@@ -3117,6 +3168,136 @@ async fn run_preview_script(
    Ok((StatusCode::CREATED, uuid.to_string()))
 }

+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+async fn run_bundle_preview_script(
+    authed: ApiAuthed,
+    Extension(db): Extension<DB>,
+    Extension(user_db): Extension<UserDB>,
+    Extension(rsmq): Extension<Option<rsmq_async::MultiplexedRsmq>>,
+    Path(w_id): Path<String>,
+    Query(run_query): Query<RunJobQuery>,
+    mut multipart: axum::extract::Multipart,
+) -> error::Result<(StatusCode, String)> {
+    check_license_key_valid().await?;
+
+    check_scopes(&authed, || format!("runscript"))?;
+    if authed.is_operator {
+        return Err(error::Error::NotAuthorized(
+            "Operators cannot run preview jobs for security reasons".to_string(),
+        ));
+    }
+
+    let mut job_id = None;
+    let mut tx = None;
+    let mut uploaded = false;
+    while let Some(field) = multipart.next_field().await.unwrap() {
+        let name = field.name().unwrap().to_string();
+        let data = field.bytes().await.unwrap();
+        if name == "preview" {
+            let preview: Preview = serde_json::from_slice(&data).map_err(to_anyhow)?;
+
+            let scheduled_for = run_query.get_scheduled_for(&db).await?;
+            let tag = run_query.tag.clone().or(preview.tag.clone());
+            check_tag_available_for_workspace(&w_id, &tag).await?;
+            let ltx =
+                PushIsolationLevel::Isolated(user_db.clone(), authed.clone().into(), rsmq.clone());
+
+            let args = preview.args.unwrap_or_default();
+
+            // hmap.insert("")
+            let (uuid, ntx) = push(
+                &db,
+                ltx,
+                &w_id,
+                match preview.kind {
+                    Some(PreviewKind::Identity) => JobPayload::Identity,
+                    Some(PreviewKind::Noop) => JobPayload::Noop,
+                    _ => JobPayload::Code(RawCode {
+                        hash: Some(PREVIEW_IS_CODEBASE_HASH),
+                        content: preview.content.unwrap_or_default(),
+                        path: preview.path,
+                        language: preview.language.unwrap_or(ScriptLang::Deno),
+                        lock: preview.lock,
+                        concurrent_limit: None, // TODO(gbouv): once I find out how to store limits in the content of a script, should be easy to plug limits here
+                        concurrency_time_window_s: None, // TODO(gbouv): same as above
+                        cache_ttl: None,
+                        dedicated_worker: preview.dedicated_worker,
+                    }),
+                },
+                args,
+                authed.display_username(),
+                &authed.email,
+                username_to_permissioned_as(&authed.username),
+                scheduled_for,
+                None,
+                None,
+                None,
+                run_query.job_id,
+                false,
+                false,
+                None,
+                true,
+                tag,
+                run_query.timeout,
+                None,
+                None,
+            )
+            .await?;
+            job_id = Some(uuid);
+            tx = Some(ntx);
+        }
+        if name == "file" {
+            let id = job_id
+                .as_ref()
+                .ok_or_else(|| {
+                    Error::BadRequest(
+                        "script need to be passed first in the multipart upload".to_string(),
+                    )
+                })?
+                .to_string();
+
+            uploaded = true;
+
+            if let Some(os) = windmill_common::s3_helpers::OBJECT_STORE_CACHE_SETTINGS
+                .read()
+                .await
+                .clone()
+            {
+                let path = windmill_common::s3_helpers::bundle(&w_id, &id);
+                if let Err(e) = os
+                    .put(&object_store::path::Path::from(path.clone()), data)
+                    .await
+                {
+                    tracing::info!("Failed to put snapshot to s3 at {path}: {:?}", e);
+                    return Err(Error::ExecutionErr(format!("Failed to put {path} to s3")));
+                }
+            } else {
+                return Err(Error::BadConfig("Object store is required for snapshot script and is not configured for servers".to_string()));
+            }
+        }
+        // println!("Length of `{}` is {} bytes", name, data.len());
+    }
+    if !uploaded {
+        return Err(Error::BadRequest("No file uploaded".to_string()));
+    }
+    if job_id.is_none() {
+        return Err(Error::BadRequest(
+            "No script found in the uploaded file".to_string(),
+        ));
+    }
+
+    tx.unwrap().commit().await?;
+
+    Ok((StatusCode::CREATED, job_id.unwrap().to_string()))
+}
+
+#[cfg(not(all(feature = "enterprise", feature = "parquet")))]
+async fn run_bundle_preview_script() -> error::Result<(StatusCode, String)> {
+    return Err(Error::BadRequest(
+        "bundle preview is an ee feature".to_string(),
+    ));
+}
+
 #[derive(Deserialize)]
 pub struct RunDependenciesRequest {
    pub raw_scripts: Vec<RawScriptForDependencies>,
@@ -3511,45 +3692,20 @@ pub struct JobUpdate {
    pub flow_status: Option<serde_json::Value>,
 }

-// #[cfg(all(feature = "enterprise", feature = "parquet"))]
-// async fn get_logs_from_store(
-//     log_offset: i32,
-//     logs: &str,
-//     log_file_index: Option<Vec<String>>,
-// ) -> Option<error::Result<Body>> {
-//     if log_offset > 0 {
-//         if let Some(file_index) = log_file_index {
-//             tracing::debug!("Getting logs from store: {file_index:?}");
-//             if let Some(os) = OBJECT_STORE_CACHE_SETTINGS.read().await.clone() {
-//                 tracing::debug!("object store client present, streaming from there");
-
-//                 let logs = logs.to_string();
-//                 let stream = async_stream::stream! {
-//                     for file_p in file_index {
-//                         let file_p_2 = file_p.clone();
-//                         let file = os.get(&object_store::path::Path::from(file_p)).await;
-//                         if let Ok(file) = file {
-//                             if let Ok(bytes) = file.bytes().await {
-//                                 yield Ok(bytes::Bytes::from(bytes)) as object_store::Result<bytes::Bytes>;
-//                             }
-//                         } else {
-//                             tracing::debug!("error getting file from store: {file_p_2}: {}", file.err().unwrap());
-//                         }
-//                     }
-
-//                     yield Ok(bytes::Bytes::from(logs))
-//                 };
-//                 return Some(Ok(Body::from_stream(stream)));
-//             } else {
-//                 tracing::debug!("object store client not present, cannot stream logs from store");
-//             }
-//         }
-//     }
-//     return None;
-// }
-
-#[cfg(all(feature = "enterprise", feature = "parquet"))]
 async fn get_log_file(Path((_w_id, file_p)): Path<(String, String)>) -> error::Result<Response> {
+    let local_file = format!("{TMP_DIR}/logs/{file_p}");
+    if tokio::fs::metadata(&local_file).await.is_ok() {
+        let mut file = tokio::fs::File::open(local_file).await.map_err(to_anyhow)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer).await.map_err(to_anyhow)?;
+        let res = Response::builder()
+            .header(http::header::CONTENT_TYPE, "text/plain")
+            .body(Body::from(bytes::Bytes::from(buffer)))
+            .unwrap();
+        return Ok(res);
+    }
+
+    #[cfg(all(feature = "enterprise", feature = "parquet"))]
    if let Some(os) = OBJECT_STORE_CACHE_SETTINGS.read().await.clone() {
        let file = os
            .get(&object_store::path::Path::from(format!("logs/{file_p}")))
@@ -3579,12 +3735,9 @@ async fn get_log_file(Path((_w_id, file_p)): Path<(String, String)>) -> error::R
            "Object store client not present, cannot stream logs from store".to_string(),
        ));
    }
-}

-#[cfg(not(all(feature = "enterprise", feature = "parquet")))]
-async fn get_log_file(Path((_w_id, file_p)): Path<(String, String)>) -> error::Result<Response> {
    return Err(error::Error::NotFound(format!(
-        "Get log file is an EE feature: {}",
+        "File not found on server logs volume /tmp/windmill/logs and no distributed logs s3 storage for {}",
        file_p
    )));
 }
--- a/backend/windmill-api/src/lib.rs
+++ b/backend/windmill-api/src/lib.rs
@@ -25,6 +25,7 @@ use db::DB;
 use git_version::git_version;
 use reqwest::Client;
 use std::collections::HashMap;
+use std::time::Duration;
 use std::{net::SocketAddr, sync::Arc};
 use tokio::sync::RwLock;
 use tower::ServiceBuilder;
@@ -104,6 +105,8 @@ lazy_static::lazy_static! {

    pub static ref HTTP_CLIENT: Client = reqwest::ClientBuilder::new()
        .user_agent("windmill/beta")
+        .connect_timeout(Duration::from_secs(10))
+        .timeout(Duration::from_secs(30))
        .danger_accept_invalid_certs(std::env::var("ACCEPT_INVALID_CERTS").is_ok())
        .build().unwrap();

@@ -141,14 +144,12 @@ pub async fn run_server(
    ));
    let argon2 = Arc::new(Argon2::default());

+    let disable_response_logs = std::env::var("DISABLE_RESPONSE_LOGS")
+        .ok()
+        .map(|x| x == "true")
+        .unwrap_or(false);
+
    let middleware_stack = ServiceBuilder::new()
-        .layer(
-            TraceLayer::new_for_http()
-                .on_response(MyOnResponse {})
-                .make_span_with(MyMakeSpan {})
-                .on_request(())
-                .on_failure(MyOnFailure {}),
-        )
        .layer(Extension(db.clone()))
        .layer(Extension(rsmq))
        .layer(Extension(user_db))
@@ -285,6 +286,18 @@ pub async fn run_server(
        .fallback(static_assets::static_handler)
        .layer(middleware_stack);

+    let app = if disable_response_logs {
+        app
+    } else {
+        app.layer(
+            TraceLayer::new_for_http()
+                .on_response(MyOnResponse {})
+                .make_span_with(MyMakeSpan {})
+                .on_request(())
+                .on_failure(MyOnFailure {}),
+        )
+    };
+
    let instance_name = rd_string(5);

    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
@@ -320,6 +333,7 @@ async fn is_up_to_date() -> Result<String, AppError> {
    let error_reading_version = || anyhow::anyhow!("Error reading latest released version");
    let version = HTTP_CLIENT
        .get("https://api.github.com/repos/windmill-labs/windmill/releases/latest")
+        .timeout(Duration::from_secs(10))
        .send()
        .await
        .context("Impossible to reach api.github")?
--- a/backend/windmill-api/src/schedule.rs
+++ b/backend/windmill-api/src/schedule.rs
@@ -221,7 +221,7 @@ async fn create_schedule(
    .await?;

    if ns.enabled.unwrap_or(true) {
-        tx = push_scheduled_job(&db, tx, schedule).await?
+        tx = push_scheduled_job(&db, tx, &schedule).await?
    }
    tx.commit().await?;

@@ -303,7 +303,7 @@ async fn edit_schedule(
    .await?;

    if schedule.enabled {
-        tx = push_scheduled_job(&db, tx, schedule).await?;
+        tx = push_scheduled_job(&db, tx, &schedule).await?;
    }
    tx.commit().await?;

@@ -512,7 +512,7 @@ pub async fn set_enabled(
    .await?;

    if payload.enabled {
-        tx = push_scheduled_job(&db, tx, schedule).await?;
+        tx = push_scheduled_job(&db, tx, &schedule).await?;
    }
    tx.commit().await?;

@@ -560,7 +560,7 @@ pub async fn set_enabled(
 //     .await?;

 //     if payload.enabled {
-//         tx = push_scheduled_job(&db, tx, schedule).await?;
+//         tx = push_scheduled_job(&db, tx, &schedule).await?;
 //     }
 //     tx.commit().await?;

--- a/backend/windmill-api/src/scripts.rs
+++ b/backend/windmill-api/src/scripts.rs
@@ -13,6 +13,9 @@ use crate::{
    webhook_util::{WebhookMessage, WebhookShared},
    HTTP_CLIENT,
 };
+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+use axum::extract::Multipart;
+
 use axum::{
    extract::{Extension, Path, Query},
    response::IntoResponse,
@@ -31,6 +34,10 @@ use std::{
 };
 use windmill_audit::audit_ee::audit_log;
 use windmill_audit::ActionKind;
+
+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+use windmill_common::error::to_anyhow;
+
 use windmill_common::{
    db::UserDB,
    error::{Error, JsonResult, Result},
@@ -116,6 +123,7 @@ pub fn workspaced_service() -> Router {
        .route("/list", get(list_scripts))
        .route("/list_search", get(list_search_scripts))
        .route("/create", post(create_script))
+        .route("/create_snapshot", post(create_snapshot_script))
        .route("/archive/p/*path", post(archive_script_by_path))
        .route("/get/draft/*path", get(get_script_by_path_w_draft))
        .route("/get/p/*path", get(get_script_by_path))
@@ -196,6 +204,7 @@ async fn list_scripts(
            "draft_only",
            "ws_error_handler_muted",
            "no_main_func",
+            "codebase IS NOT NULL as use_codebase"
        ])
        .left()
        .join("favorite")
@@ -312,6 +321,82 @@ fn hash_script(ns: &NewScript) -> i64 {
    dh.finish() as i64
 }

+#[cfg(not(all(feature = "enterprise", feature = "parquet")))]
+async fn create_snapshot_script() -> Result<(StatusCode, String)> {
+    Err(Error::BadRequest("Upgrade to EE to use bundle".to_string()))
+}
+
+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+async fn create_snapshot_script(
+    authed: ApiAuthed,
+    Extension(user_db): Extension<UserDB>,
+    Extension(rsmq): Extension<Option<rsmq_async::MultiplexedRsmq>>,
+    Extension(webhook): Extension<WebhookShared>,
+    Extension(db): Extension<DB>,
+    Path(w_id): Path<String>,
+    mut multipart: Multipart,
+) -> Result<(StatusCode, String)> {
+    let mut script_hash = None;
+    let mut tx = None;
+    let mut uploaded = false;
+    while let Some(field) = multipart.next_field().await.unwrap() {
+        let name = field.name().unwrap().to_string();
+        let data = field.bytes().await.unwrap();
+        if name == "script" {
+            let ns = Some(serde_json::from_slice(&data).map_err(to_anyhow)?);
+            let (new_hash, ntx) = create_script_internal(
+                ns.unwrap(),
+                w_id.clone(),
+                authed.clone(),
+                db.clone(),
+                rsmq.clone(),
+                user_db.clone(),
+                webhook.clone(),
+            )
+            .await?;
+            script_hash = Some(new_hash.to_string());
+            tx = Some(ntx);
+        }
+        if name == "file" {
+            let hash = script_hash.as_ref().ok_or_else(|| {
+                Error::BadRequest(
+                    "script need to be passed first in the multipart upload".to_string(),
+                )
+            })?;
+
+            uploaded = true;
+            if let Some(os) = windmill_common::s3_helpers::OBJECT_STORE_CACHE_SETTINGS
+                .read()
+                .await
+                .clone()
+            {
+                let path = windmill_common::s3_helpers::bundle(&w_id, &hash);
+                if let Err(e) = os
+                    .put(&object_store::path::Path::from(path.clone()), data)
+                    .await
+                {
+                    tracing::info!("Failed to put snapshot to s3 at {path}: {:?}", e);
+                    return Err(Error::ExecutionErr(format!("Failed to put {path} to s3")));
+                }
+            } else {
+                return Err(Error::BadConfig("Object store is required for snapshot script and is not configured for servers".to_string()));
+            }
+        }
+        // println!("Length of `{}` is {} bytes", name, data.len());
+    }
+    if !uploaded {
+        return Err(Error::BadRequest("No file uploaded".to_string()));
+    }
+    if script_hash.is_none() {
+        return Err(Error::BadRequest(
+            "No script found in the uploaded file".to_string(),
+        ));
+    }
+
+    tx.unwrap().commit().await?;
+    return Ok((StatusCode::CREATED, format!("{}", script_hash.unwrap())));
+}
+
 async fn create_script(
    authed: ApiAuthed,
    Extension(user_db): Extension<UserDB>,
@@ -321,6 +406,24 @@ async fn create_script(
    Path(w_id): Path<String>,
    Json(ns): Json<NewScript>,
 ) -> Result<(StatusCode, String)> {
+    let (hash, tx) = create_script_internal(ns, w_id, authed, db, rsmq, user_db, webhook).await?;
+    tx.commit().await?;
+    Ok((StatusCode::CREATED, format!("{}", hash)))
+}
+
+async fn create_script_internal<'c>(
+    ns: NewScript,
+    w_id: String,
+    authed: ApiAuthed,
+    db: sqlx::Pool<Postgres>,
+    rsmq: Option<rsmq_async::MultiplexedRsmq>,
+    user_db: UserDB,
+    webhook: WebhookShared,
+) -> Result<(
+    ScriptHash,
+    QueueTransaction<'c, rsmq_async::MultiplexedRsmq>,
+)> {
+    let codebase = ns.codebase.as_ref();
    #[cfg(not(feature = "enterprise"))]
    if ns.ws_error_handler_muted.is_some_and(|val| val) {
        return Err(Error::BadRequest(
@@ -328,12 +431,10 @@ async fn create_script(
                .to_string(),
        ));
    }
-
    let script_path = ns.path.clone();
    let hash = ScriptHash(hash_script(&ns));
    let authed = maybe_refresh_folders(&ns.path, &w_id, authed, &db).await;
    let mut tx: QueueTransaction<'_, _> = (rsmq.clone(), user_db.begin(&authed).await?).into();
-
    if sqlx::query_scalar!(
        "SELECT 1 FROM script WHERE hash = $1 AND workspace_id = $2",
        hash.0,
@@ -349,7 +450,6 @@ async fn create_script(
                .to_owned(),
        ));
    };
-
    let clashing_script = sqlx::query_as::<_, Script>(
        "SELECT * FROM script WHERE path = $1 AND archived = false AND workspace_id = $2",
    )
@@ -357,7 +457,6 @@ async fn create_script(
    .bind(&w_id)
    .fetch_optional(&mut tx)
    .await?;
-
    struct ParentInfo {
        p_hashes: Vec<i64>,
        perms: serde_json::Value,
@@ -450,13 +549,11 @@ async fn create_script(
            r
        }
    }?;
-
    let p_hashes = parent_hashes_and_perms.as_ref().map(|v| &v.p_hashes[..]);
    let extra_perms = parent_hashes_and_perms
        .as_ref()
        .map(|v| v.perms.clone())
        .unwrap_or(json!({}));
-
    let lock = if !(ns.language == ScriptLang::Python3
        || ns.language == ScriptLang::Go
        || ns.language == ScriptLang::Bun
@@ -467,23 +564,20 @@ async fn create_script(
        ns.lock
            .and_then(|e| if e.is_empty() { None } else { Some(e) })
    };
-
    let needs_lock_gen = lock.is_none();
-
    let envs = ns.envs.as_ref().map(|x| x.as_slice());
    let envs = if ns.envs.is_none() || ns.envs.as_ref().unwrap().is_empty() {
        None
    } else {
        envs
    };
-    //::text::json is to ensure we use serde_json with preserve order
    sqlx::query!(
        "INSERT INTO script (workspace_id, hash, path, parent_hashes, summary, description, \
         content, created_by, schema, is_template, extra_perms, lock, language, kind, tag, \
         draft_only, envs, concurrent_limit, concurrency_time_window_s, cache_ttl, \
         dedicated_worker, ws_error_handler_muted, priority, restart_unless_cancelled, \
-         delete_after_use, timeout, concurrency_key, visible_to_runner_only, no_main_func) \
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::text::json, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29)",
+         delete_after_use, timeout, concurrency_key, visible_to_runner_only, no_main_func, codebase) \
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::text::json, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30)",
        &w_id,
        &hash.0,
        ns.path,
@@ -512,11 +606,11 @@ async fn create_script(
        ns.timeout,
        ns.concurrency_key,
        ns.visible_to_runner_only,
-        ns.no_main_func
+        ns.no_main_func,
+        codebase
    )
    .execute(&mut tx)
    .await?;
-
    let p_path_opt = parent_hashes_and_perms.as_ref().map(|x| x.p_path.clone());
    if let Some(ref p_path) = p_path_opt {
        sqlx::query!(
@@ -554,7 +648,7 @@ async fn create_script(
            clear_schedule(tx.transaction_mut(), &schedule.path, &w_id).await?;

            if schedule.enabled {
-                tx = push_scheduled_job(&db, tx, schedule).await?;
+                tx = push_scheduled_job(&db, tx, &schedule).await?;
            }
        }
    } else {
@@ -566,7 +660,6 @@ async fn create_script(
        .execute(&mut tx)
        .await?;
    }
-
    if p_hashes.is_some() && !p_hashes.unwrap().is_empty() {
        audit_log(
            &mut tx,
@@ -612,7 +705,6 @@ async fn create_script(
            },
        );
    }
-
    let permissioned_as = username_to_permissioned_as(&authed.username);
    if needs_lock_gen {
        let tag = if ns.dedicated_worker.is_some_and(|x| x) {
@@ -661,7 +753,7 @@ async fn create_script(
            None,
        )
        .await?;
-        new_tx.commit().await?;
+        Ok((hash, new_tx))
    } else {
        handle_deployment_metadata(
            &authed.email,
@@ -678,10 +770,8 @@ async fn create_script(
            false,
        )
        .await?;
-        tx.commit().await?;
+        Ok((hash, tx))
    }
-
-    Ok((StatusCode::CREATED, format!("{}", hash)))
 }

 pub async fn get_hub_script_by_path(
--- a/backend/windmill-api/src/settings.rs
+++ b/backend/windmill-api/src/settings.rs
@@ -21,15 +21,17 @@ use axum::{
    Json, Router,
 };

-use mail_send::{mail_builder::MessageBuilder, SmtpClientBuilder};
 use serde::Deserialize;
-use tokio::time::timeout;
 use windmill_common::{
-    error::{self, to_anyhow, JsonResult, Result},
+    error::{self, JsonResult, Result},
    global_settings::{AUTOMATE_USERNAME_CREATION_SETTING, ENV_SETTINGS, HUB_BASE_URL_SETTING},
    server::Smtp,
+    utils::send_email,
 };

+#[cfg(feature = "parquet")]
+use windmill_common::error::to_anyhow;
+
 pub fn global_service() -> Router {
    #[warn(unused_mut)]
    let r = Router::new()
@@ -67,34 +69,17 @@ pub async fn test_email(
    require_super_admin(&db, &authed.email).await?;
    let smtp = test_email.smtp;
    let to = test_email.to;
-    let mut client = SmtpClientBuilder::new(smtp.host, smtp.port)
-        .implicit_tls(smtp.tls_implicit.unwrap_or(false));
-    if std::env::var("ACCEPT_INVALID_CERTS").is_ok() {
-        client = client.allow_invalid_certs();
-    }
-    let client = if let (Some(username), Some(password)) = (smtp.username, smtp.password) {
-        if !username.is_empty() {
-            client.credentials((username, password))
-        } else {
-            client
-        }
-    } else {
-        client
-    };
-    let message = MessageBuilder::new()
-        .from(("Windmill", smtp.from.as_str()))
-        .to(to.clone())
-        .subject("Test email from Windmill")
-        .text_body("Test email content");
-    let dur = Duration::from_secs(3);
-    timeout(dur, client.connect())
-        .await
-        .map_err(to_anyhow)?
-        .map_err(to_anyhow)?
-        .send(message)
-        .await
-        .map_err(to_anyhow)?;
-    tracing::info!("Sent test email to {to}");
+
+    let client_timeout = Duration::from_secs(3);
+    send_email(
+        "Test email from Windmill",
+        "Test email content",
+        vec![to],
+        smtp,
+        Some(client_timeout),
+    )
+    .await?;
+
    Ok("Sent test email".to_string())
 }

--- a/backend/windmill-api/src/users.rs
+++ b/backend/windmill-api/src/users.rs
@@ -32,8 +32,6 @@ use axum::{
 };
 use hyper::{header::LOCATION, StatusCode};
 use lazy_static::lazy_static;
-use mail_send::mail_builder::MessageBuilder;
-use mail_send::SmtpClientBuilder;
 use quick_cache::sync::Cache;
 use rand::rngs::OsRng;
 use regex::Regex;
@@ -46,10 +44,11 @@ use windmill_audit::audit_ee::audit_log;
 use windmill_audit::ActionKind;
 use windmill_common::global_settings::AUTOMATE_USERNAME_CREATION_SETTING;
 use windmill_common::users::truncate_token;
+use windmill_common::utils::send_email;
 use windmill_common::worker::{CLOUD_HOSTED, SERVER_CONFIG};
 use windmill_common::{
    db::UserDB,
-    error::{self, to_anyhow, Error, JsonResult, Result},
+    error::{self, Error, JsonResult, Result},
    users::SUPERADMIN_SECRET_EMAIL,
    utils::{not_found_if_none, rd_string, require_admin, Pagination, StripPath},
 };
@@ -1824,41 +1823,15 @@ pub fn send_email_if_possible(subject: &str, content: &str, to: &str) {
    let content = content.to_string();
    let to = to.to_string();
    tokio::spawn(async move {
-        if let Err(e) = send_email_if_possible_intern(&subject, &content, &to).await {
-            tracing::error!("Failed to send email to {}: {}", &to, e);
+        if let Err(e) = send_email_if_possible_intern(&subject, &content, to.clone()).await {
+            tracing::error!("Failed to send email to {}: {}", to, e);
        }
    });
 }

-pub async fn send_email_if_possible_intern(subject: &str, content: &str, to: &str) -> Result<()> {
+pub async fn send_email_if_possible_intern(subject: &str, content: &str, to: String) -> Result<()> {
    if let Some(smtp) = SERVER_CONFIG.read().await.smtp.clone() {
-        let mut client = SmtpClientBuilder::new(smtp.host, smtp.port)
-            .implicit_tls(smtp.tls_implicit.unwrap_or(false));
-        if std::env::var("ACCEPT_INVALID_CERTS").is_ok() {
-            client = client.allow_invalid_certs();
-        }
-        let client = if let (Some(username), Some(password)) = (smtp.username, smtp.password) {
-            if !username.is_empty() {
-                client.credentials((username, password))
-            } else {
-                client
-            }
-        } else {
-            client
-        };
-        let message = MessageBuilder::new()
-            .from(("Windmill", smtp.from.as_str()))
-            .to(to)
-            .subject(subject)
-            .text_body(content);
-        client
-            .connect()
-            .await
-            .map_err(to_anyhow)?
-            .send(message)
-            .await
-            .map_err(to_anyhow)?;
-        tracing::info!("Sent email to {to}: {subject}");
+        send_email(subject, content, vec![to], smtp, None).await?;
    }
    return Ok(());
 }
--- a/backend/windmill-api/src/webhook_util.rs
+++ b/backend/windmill-api/src/webhook_util.rs
@@ -71,6 +71,7 @@ impl WebhookShared {
        let (tx, mut rx) = mpsc::unbounded_channel::<WebhookPayload>();
        let _process = tokio::spawn(async move {
            let client = reqwest::Client::builder()
+                .connect_timeout(Duration::from_secs(5))
                // TODO: investigate pool timeouts and such if TCP load is high
                .timeout(Duration::from_secs(5))
                .build()
--- a/backend/windmill-api/src/workers.rs
+++ b/backend/windmill-api/src/workers.rs
@@ -14,14 +14,16 @@ use axum::{

 use serde::{Deserialize, Serialize};
 use sqlx::FromRow;
+use uuid::Uuid;
 use windmill_common::{
    db::UserDB,
    error::JsonResult,
    utils::{paginate, Pagination},
    worker::{ALL_TAGS, DEFAULT_TAGS, DEFAULT_TAGS_PER_WORKSPACE},
+    DB,
 };

-use crate::db::ApiAuthed;
+use crate::{db::ApiAuthed, utils::require_super_admin};

 pub fn global_service() -> Router {
    Router::new()
@@ -33,6 +35,7 @@ pub fn global_service() -> Router {
            get(get_default_tags_per_workspace),
        )
        .route("/get_default_tags", get(get_default_tags))
+        .route("/queue_metrics", get(get_queue_metrics))
 }

 #[derive(FromRow, Serialize, Deserialize)]
@@ -43,9 +46,12 @@ struct WorkerPing {
    started_at: chrono::DateTime<chrono::Utc>,
    ip: String,
    jobs_executed: i32,
+    current_job_id: Option<Uuid>,
+    current_job_workspace_id: Option<String>,
    custom_tags: Option<Vec<String>>,
    worker_group: String,
    wm_version: String,
+    occupancy_rate: Option<f32>,
 }

 #[derive(Serialize, Deserialize)]
@@ -62,21 +68,25 @@ pub struct ListWorkerQuery {

 async fn list_worker_pings(
    authed: ApiAuthed,
+    Extension(db): Extension<DB>,
    Extension(user_db): Extension<UserDB>,
    Query(query): Query<ListWorkerQuery>,
 ) -> JsonResult<Vec<WorkerPing>> {
+    let is_super_admin = require_super_admin(&db, &authed.email).await.is_ok();
    let mut tx = user_db.begin(&authed).await?;

    let (per_page, offset) = paginate(Pagination { page: query.page, per_page: query.per_page });

    let rows = sqlx::query_as!(
        WorkerPing,
-        "SELECT worker, worker_instance,  EXTRACT(EPOCH FROM (now() - ping_at))::integer as last_ping, started_at, ip, jobs_executed, custom_tags, worker_group, wm_version FROM worker_ping
-         WHERE ($1::integer IS NULL AND ping_at > now() - interval '5 minute') OR (ping_at > now() - ($1 || ' seconds')::interval)
-         ORDER BY ping_at desc LIMIT $2 OFFSET $3",
+        "SELECT worker, worker_instance,  EXTRACT(EPOCH FROM (now() - ping_at))::integer as last_ping, started_at, ip, jobs_executed, CASE WHEN $4 IS TRUE THEN current_job_id ELSE NULL END as current_job_id, CASE WHEN $4 IS TRUE THEN current_job_workspace_id ELSE NULL END as current_job_workspace_id, custom_tags, worker_group, wm_version, occupancy_rate
+        FROM worker_ping
+        WHERE ($1::integer IS NULL AND ping_at > now() - interval '5 minute') OR (ping_at > now() - ($1 || ' seconds')::interval)
+        ORDER BY ping_at desc LIMIT $2 OFFSET $3",
        query.ping_since,
        per_page as i64,
-        offset as i64
+        offset as i64,
+        is_super_admin
    )
    .fetch_all(&mut *tx)
    .await?;
@@ -118,3 +128,35 @@ async fn get_default_tags_per_workspace() -> JsonResult<bool> {
 async fn get_default_tags() -> JsonResult<Vec<String>> {
    Ok(Json(DEFAULT_TAGS.clone()))
 }
+
+#[derive(Serialize)]
+struct QueueMetric {
+    id: String,
+    values: Vec<serde_json::Value>,
+}
+
+async fn get_queue_metrics(
+    authed: ApiAuthed,
+    Extension(db): Extension<DB>,
+) -> JsonResult<Vec<QueueMetric>> {
+    require_super_admin(&db, &authed.email).await?;
+
+    let queue_metrics = sqlx::query_as!(
+        QueueMetric,
+        "WITH queue_metrics as (
+            SELECT id, value, created_at
+            FROM metrics
+            WHERE id LIKE 'queue_%'
+                AND created_at > now() - interval '14 day'
+            ORDER BY created_at ASC
+        )
+        SELECT id, array_agg(json_build_object('value', value, 'created_at', created_at)) as \"values!\"
+        FROM queue_metrics
+        GROUP BY id
+        ORDER BY id ASC"
+    )
+    .fetch_all(&db)
+    .await?;
+
+    Ok(Json(queue_metrics))
+}
--- a/backend/windmill-api/src/workspaces.rs
+++ b/backend/windmill-api/src/workspaces.rs
@@ -53,7 +53,6 @@ use windmill_common::{
    variables::ExportableListableVariable,
 };
 use windmill_git_sync::handle_deployment_metadata;
-use windmill_queue::QueueTransaction;

 use crate::oauth2_ee::InstanceEvent;
 use crate::variables::{decrypt, encrypt};
@@ -488,25 +487,25 @@ async fn run_slack_message_test_job(
        json!(format!("$res:{WORKSPACE_SLACK_BOT_TOKEN_PATH}")),
    );

-    let tx: QueueTransaction<'_, _> = (rsmq.clone(), db.begin().await?).into();
-    let (uuid, tx) = windmill_queue::handle_on_failure(
+    let uuid = windmill_queue::push_error_handler(
        &db,
-        tx,
+        rsmq,
        Uuid::parse_str("00000000-0000-0000-0000-000000000000")?,
-        "slack_message_test",
-        "slack_message_test",
+        None,
+        Some("slack_message_test".to_string()),
        false,
        w_id.as_str(),
        &format!("script/{}", req.hub_script_path.as_str()),
        sqlx::types::Json(&fake_result),
-        0,
-        Utc::now(),
+        None,
+        Some(Utc::now()),
        Some(json!(extra_args)),
        authed.email.as_str(),
+        false,
+        false,
        None, // Note: we could mark it as high priority to return result quickly to the user
    )
    .await?;
-    tx.commit().await?;

    Ok(Json(RunSlackMessageTestJobResponse {
        job_uuid: uuid.to_string(),
@@ -2219,6 +2218,8 @@ struct ScriptMetadata {
    pub visible_to_runner_only: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub no_main_func: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub codebase: Option<String>,
 }

 pub fn is_none_or_false(val: &Option<bool>) -> bool {
@@ -2496,6 +2497,7 @@ async fn tarball_workspace(
                restart_unless_cancelled: script.restart_unless_cancelled,
                visible_to_runner_only: script.visible_to_runner_only,
                no_main_func: script.no_main_func,
+                codebase: script.codebase,
            };
            let metadata_str = serde_json::to_string_pretty(&metadata).unwrap();
            archive
--- a/backend/windmill-common/Cargo.toml
+++ b/backend/windmill-common/Cargo.toml
@@ -10,7 +10,7 @@ enterprise = []
 prometheus = ["dep:prometheus"]
 flamegraph = ["dep:tracing-flame"]
 loki = ["dep:tracing-loki"]
-parquet = ["dep:object_store", "dep:aws-config", "dep:aws-sdk-sts"]
+parquet = ["dep:object_store", "dep:aws-config", "dep:aws-sdk-sts", "dep:bytes"]

 [lib]
 name = "windmill_common"
@@ -46,4 +46,6 @@ object_store = { workspace = true, optional = true }
 prometheus = { workspace = true, optional = true }
 aws-config = { workspace = true, optional = true }
 aws-sdk-sts = { workspace = true, optional = true }
-indexmap.workspace = true
+indexmap.workspace = true
+bytes = { workspace = true, optional = true }
+mail-send.workspace = true
--- a/backend/windmill-common/src/ee.rs
+++ b/backend/windmill-common/src/ee.rs
@@ -1,4 +1,5 @@
 use crate::ee::LicensePlan::Community;
+use serde::Deserialize;
 use std::sync::Arc;
 use tokio::sync::RwLock;

@@ -18,3 +19,9 @@ pub async fn get_license_plan() -> LicensePlan {
    // Implementation is not open source
    return Community;
 }
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum CriticalErrorChannel {}
+
+pub async fn trigger_critical_error_channels(_error_message: String) {}
--- a/backend/windmill-common/src/error.rs
+++ b/backend/windmill-common/src/error.rs
@@ -8,10 +8,7 @@

 use axum::body::Body;
 use axum::response::Response;
-use axum::{
-    response::IntoResponse,
-    response::Json,
-};
+use axum::{response::IntoResponse, response::Json};

 use hyper::StatusCode;
 use sqlx::migrate::MigrateError;
@@ -45,6 +42,8 @@ pub enum Error {
    SqlErr(#[from] sqlx::Error),
    #[error("Bad request: {0}")]
    BadRequest(String),
+    #[error("Quota exceeded: {0}")]
+    QuotaExceeded(String),
    #[error("Internal: {0}")]
    InternalErr(String),
    #[error("Hexadecimal decoding error: {0}")]
@@ -59,6 +58,8 @@ pub enum Error {
    JsonErr(serde_json::Value),
    #[error("{0}")]
    OpenAIError(String),
+    #[error("{0}")]
+    AlreadyCompleted(String),
 }

 impl Error {
@@ -81,9 +82,10 @@ impl IntoResponse for Error {
            Self::NotFound(_) => axum::http::StatusCode::NOT_FOUND,
            Self::NotAuthorized(_) => axum::http::StatusCode::UNAUTHORIZED,
            Self::RequireAdmin(_) => axum::http::StatusCode::FORBIDDEN,
-            Self::SqlErr(_) | Self::BadRequest(_) | Self::OpenAIError(_) => {
-                axum::http::StatusCode::BAD_REQUEST
-            }
+            Self::SqlErr(_)
+            | Self::BadRequest(_)
+            | Self::OpenAIError(_)
+            | Self::QuotaExceeded(_) => axum::http::StatusCode::BAD_REQUEST,
            _ => axum::http::StatusCode::INTERNAL_SERVER_ERROR,
        };

--- a/backend/windmill-common/src/external_ip.rs
+++ b/backend/windmill-common/src/external_ip.rs
@@ -13,16 +13,19 @@

 use std::time::Duration;

-use reqwest::Result;
-
-pub async fn get_ip() -> Result<String> {
-    reqwest::ClientBuilder::new()
-        .timeout(Duration::from_secs(3))
+pub async fn get_ip() -> anyhow::Result<String> {
+    tokio::select! {
+        biased;
+        _ = tokio::time::sleep(Duration::from_secs(10)) => {
+            return Err(anyhow::anyhow!("Expected to get ip under 10s"))
+        },
+        ip = reqwest::ClientBuilder::new()
+        .connect_timeout(Duration::from_secs(5))
+        .timeout(Duration::from_secs(5))
        .build()?
        .get("https://hub.windmill.dev/getip")
-        .send()
-        .await?
-        .error_for_status()?
-        .text()
-        .await
+        .send() => Ok(ip?
+            .error_for_status()?
+            .text().await?),
+    }
 }
--- a/backend/windmill-common/src/flow_status.rs
+++ b/backend/windmill-common/src/flow_status.rs
@@ -29,7 +29,7 @@ pub fn is_retry_default(v: &RetryStatus) -> bool {
 pub struct FlowStatus {
    pub step: i32,
    pub modules: Vec<FlowStatusModule>,
-    pub failure_module: FlowStatusModuleWParent,
+    pub failure_module: Box<FlowStatusModuleWParent>,

    #[serde(skip_serializing_if = "HashMap::is_empty")]
    #[serde(default)]
@@ -227,7 +227,7 @@ impl FlowStatus {
                .iter()
                .map(|m| FlowStatusModule::WaitingForPriorSteps { id: m.id.clone() })
                .collect(),
-            failure_module: FlowStatusModuleWParent {
+            failure_module: Box::new(FlowStatusModuleWParent {
                parent_module: None,
                module_status: FlowStatusModule::WaitingForPriorSteps {
                    id: f
@@ -236,7 +236,7 @@ impl FlowStatus {
                        .map(|x| x.id.clone())
                        .unwrap_or_else(|| "failure".to_string()),
                },
-            },
+            }),
            cleanup_module: FlowCleanupModule { flow_jobs_to_clean: vec![] },
            retry: RetryStatus { fail_count: 0, failed_jobs: vec![] },
            restarted_from: None,
--- a/backend/windmill-common/src/flows.rs
+++ b/backend/windmill-common/src/flows.rs
@@ -87,7 +87,7 @@ pub struct FlowValue {
    pub modules: Vec<FlowModule>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(default)]
-    pub failure_module: Option<FlowModule>,
+    pub failure_module: Option<Box<FlowModule>>,
    #[serde(default)]
    #[serde(skip_serializing_if = "is_default")]
    pub same_worker: bool,
--- a/backend/windmill-common/src/global_settings.rs
+++ b/backend/windmill-common/src/global_settings.rs
@@ -24,6 +24,7 @@ pub const OBJECT_STORE_CACHE_CONFIG_SETTING: &str = "object_store_cache_config";

 pub const AUTOMATE_USERNAME_CREATION_SETTING: &str = "automate_username_creation";
 pub const HUB_BASE_URL_SETTING: &str = "hub_base_url";
+pub const CRITICAL_ERROR_CHANNELS_SETTING: &str = "critical_error_channels";

 pub const ENV_SETTINGS: [&str; 50] = [
    "DISABLE_NSJAIL",
--- a/backend/windmill-common/src/jobs.rs
+++ b/backend/windmill-common/src/jobs.rs
@@ -345,6 +345,7 @@ pub enum JobPayload {
 pub struct RawCode {
    pub content: String,
    pub path: Option<String>,
+    pub hash: Option<i64>,
    pub language: ScriptLang,
    pub lock: Option<String>,
    pub concurrent_limit: Option<i32>,
--- a/backend/windmill-common/src/lib.rs
+++ b/backend/windmill-common/src/lib.rs
@@ -11,6 +11,7 @@ use std::{
    sync::{atomic::AtomicBool, Arc},
 };

+use ee::CriticalErrorChannel;
 use error::Error;
 use scripts::ScriptLang;
 use sqlx::{Pool, Postgres};
@@ -44,7 +45,7 @@ pub mod workspaces;
 pub mod tracing_init;

 pub const DEFAULT_MAX_CONNECTIONS_SERVER: u32 = 50;
-pub const DEFAULT_MAX_CONNECTIONS_WORKER: u32 = 4;
+pub const DEFAULT_MAX_CONNECTIONS_WORKER: u32 = 5;

 pub const DEFAULT_HUB_BASE_URL: &str = "https://hub.windmill.dev";

@@ -73,6 +74,9 @@ lazy_static::lazy_static! {
    pub static ref IS_READY: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);

    pub static ref HUB_BASE_URL: Arc<RwLock<String>> = Arc::new(RwLock::new(DEFAULT_HUB_BASE_URL.to_string()));
+
+
+    pub static ref CRITICAL_ERROR_CHANNELS: Arc<RwLock<Vec<CriticalErrorChannel>>> = Arc::new(RwLock::new(vec![]));
 }

 pub async fn shutdown_signal(
--- a/backend/windmill-common/src/s3_helpers.rs
+++ b/backend/windmill-common/src/s3_helpers.rs
@@ -177,6 +177,48 @@ pub fn build_object_store_client(
    }
 }

+#[cfg(feature = "parquet")]
+pub async fn attempt_fetch_bytes(
+    client: Arc<dyn ObjectStore>,
+    path: &str,
+) -> error::Result<bytes::Bytes> {
+    use object_store::path::Path;
+
+    let object = client.get(&Path::from(path)).await;
+    if let Err(e) = object {
+        tracing::info!(
+            "Failed to pull bytes from object store at path {path}. Error: {:?}",
+            e
+        );
+        return Err(error::Error::ExecutionErr(format!(
+            "Failed to pull bytes from object store: {path}"
+        )));
+    }
+
+    let bytes = object.unwrap().bytes().await;
+    if bytes.is_err() {
+        tracing::info!(
+            "Failed to read bytes from object store: {path}. Error: {:?}",
+            bytes.err()
+        );
+        return Err(error::Error::ExecutionErr(format!(
+            "Failed to read bytes from object store: {path}"
+        )));
+    }
+    let bytes = bytes.unwrap();
+
+    tracing::info!("{path} len: {}", bytes.len());
+
+    if bytes.len() == 0 {
+        tracing::info!("object {path} not found in bucket, bytes empty",);
+        return Err(error::Error::ExecutionErr(format!(
+            "object {path} does not exist in bucket"
+        )));
+    }
+
+    return Ok(bytes);
+}
+
 #[cfg(feature = "parquet")]
 use aws_config::{default_provider::credentials::DefaultCredentialsChain, Region};
 #[cfg(feature = "parquet")]
@@ -408,3 +450,7 @@ impl CredentialProvider for AwsCredentialAdapter {
        }))
    }
 }
+
+pub fn bundle(w_id: &str, hash: &str) -> String {
+    format!("script_bundle/{}/{}", w_id, hash)
+}
--- a/backend/windmill-common/src/scripts.rs
+++ b/backend/windmill-common/src/scripts.rs
@@ -128,6 +128,8 @@ impl Display for ScriptKind {
    }
 }

+pub const PREVIEW_IS_CODEBASE_HASH: i64 = -42;
+
 #[derive(Serialize, sqlx::FromRow)]
 pub struct Script {
    pub workspace_id: String,
@@ -177,6 +179,8 @@ pub struct Script {
    pub visible_to_runner_only: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub no_main_func: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub codebase: Option<String>,
 }

 #[derive(Serialize, sqlx::FromRow)]
@@ -198,6 +202,12 @@ pub struct ListableScript {
    pub ws_error_handler_muted: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub no_main_func: Option<bool>,
+    #[serde(skip_serializing_if = "is_false")]
+    pub use_codebase: bool,
+}
+
+fn is_false(x: &bool) -> bool {
+    return !x;
 }

 #[derive(Serialize)]
@@ -256,6 +266,7 @@ pub struct NewScript {
    pub concurrency_key: Option<String>,
    pub visible_to_runner_only: Option<bool>,
    pub no_main_func: Option<bool>,
+    pub codebase: Option<String>,
 }

 fn lock_deserialize<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
--- a/backend/windmill-common/src/utils.rs
+++ b/backend/windmill-common/src/utils.rs
@@ -6,11 +6,16 @@
 * LICENSE-AGPL for a copy of the license.
 */

+#[cfg(feature = "enterprise")]
+use crate::ee::trigger_critical_error_channels;
 use crate::ee::LICENSE_KEY_ID;
 use crate::error::{to_anyhow, Error, Result};
 use crate::global_settings::UNIQUE_ID_SETTING;
+use crate::server::Smtp;
 use crate::DB;
 use git_version::git_version;
+use mail_send::mail_builder::MessageBuilder;
+use mail_send::SmtpClientBuilder;
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
@@ -85,12 +90,20 @@ pub async fn query_elems_from_hub(
    url: &str,
    query_params: Option<Vec<(&str, String)>>,
    db: &DB,
-) -> Result<(reqwest::StatusCode, reqwest::header::HeaderMap, axum::body::Body)> {
+) -> Result<(
+    reqwest::StatusCode,
+    reqwest::header::HeaderMap,
+    axum::body::Body,
+)> {
    let response = http_get_from_hub(http_client, url, false, query_params, db).await?;

    let status = response.status();

-    Ok((status, response.headers().clone(), axum::body::Body::from_stream(response.bytes_stream())))
+    Ok((
+        status,
+        response.headers().clone(),
+        axum::body::Body::from_stream(response.bytes_stream()),
+    ))
 }

 pub async fn http_get_from_hub(
@@ -167,3 +180,61 @@ pub enum Mode {
    Server,
    Standalone,
 }
+
+pub async fn send_email(
+    subject: &str,
+    content: &str,
+    to: Vec<String>,
+    smtp: Smtp,
+    client_timeout: Option<tokio::time::Duration>,
+) -> Result<()> {
+    let mut client = SmtpClientBuilder::new(smtp.host, smtp.port)
+        .implicit_tls(smtp.tls_implicit.unwrap_or(false));
+    if std::env::var("ACCEPT_INVALID_CERTS").is_ok() {
+        client = client.allow_invalid_certs();
+    }
+    let client = if let (Some(username), Some(password)) = (smtp.username, smtp.password) {
+        if !username.is_empty() {
+            client.credentials((username, password))
+        } else {
+            client
+        }
+    } else {
+        client
+    };
+    let message = MessageBuilder::new()
+        .from(("Windmill", smtp.from.as_str()))
+        .to(to.clone())
+        .subject(subject)
+        .text_body(content);
+
+    match client_timeout {
+        Some(timeout) => {
+            tokio::time::timeout(timeout, client.connect())
+                .await
+                .map_err(to_anyhow)?
+                .map_err(to_anyhow)?
+                .send(message)
+                .await
+                .map_err(to_anyhow)?;
+        }
+        None => {
+            client
+                .connect()
+                .await
+                .map_err(to_anyhow)?
+                .send(message)
+                .await
+                .map_err(to_anyhow)?;
+        }
+    }
+    tracing::info!("Sent email to {:#?}: {subject}", to);
+
+    return Ok(());
+}
+
+pub async fn report_critical_error(error_message: String) -> () {
+    tracing::error!("CRITICAL ERROR: {error_message}");
+    #[cfg(feature = "enterprise")]
+    trigger_critical_error_channels(error_message).await;
+}
--- a/backend/windmill-common/src/variables.rs
+++ b/backend/windmill-common/src/variables.rs
@@ -10,7 +10,7 @@ use magic_crypt::{MagicCrypt256, MagicCryptTrait};
 use serde::{Deserialize, Serialize};
 use sqlx::{Postgres, Transaction};

-use crate::{BASE_URL, DB};
+use crate::{worker::WORKER_GROUP, BASE_URL, DB};

 lazy_static::lazy_static! {
    pub static ref SECRET_SALT: Option<String> = std::env::var("SECRET_SALT").ok();
@@ -276,12 +276,6 @@ pub async fn get_reserved_variables(
            description: "State resource path unique to a script and its trigger".to_string(),
            is_custom: false,
        },
-        ContextualVariable {
-            name: "WM_STATE_PATH_NEW".to_string(),
-            value: state_path,
-            description: "State resource path unique to a script and its trigger (legacy)".to_string(),
-            is_custom: false,
-        },
        ContextualVariable {
            name: "WM_FLOW_STEP_ID".to_string(),
            value: step_id.unwrap_or_else(|| "".to_string()),
@@ -300,6 +294,12 @@ pub async fn get_reserved_variables(
            description: "OIDC JWT token (EE only)".to_string(),
            is_custom: false,
        },
+        ContextualVariable {
+            name: "WM_WORKER_GROUP".to_string(),
+            value: WORKER_GROUP.clone(),
+            description: "name of the worker group the job is running on".to_string(),
+            is_custom: false,
+        },
    ].into_iter().chain( sqlx::query_as::<_, (String, String)>(
        "SELECT name, value FROM workspace_env WHERE workspace_id = $1",
    )
--- a/backend/windmill-common/src/worker.rs
+++ b/backend/windmill-common/src/worker.rs
@@ -70,6 +70,8 @@ lazy_static::lazy_static! {

 }

+pub const TMP_DIR: &str = "/tmp/windmill";
+
 pub async fn reload_custom_tags_setting(db: &DB) -> error::Result<()> {
    let q = sqlx::query!(
        "SELECT value FROM global_settings WHERE name = $1",
@@ -140,15 +142,54 @@ pub async fn update_ping(worker_instance: &str, worker_name: &str, ip: &str, db:
                .map(|x| format!("{}:{}", x.workspace_id, x.path)),
        )
    };
+    let mut vcpus = std::process::Command::new("cat")
+        .args(["/sys/fs/cgroup/cpu.max"])
+        .output()
+        .ok()
+        .map(|o| {
+            String::from_utf8_lossy(&o.stdout)
+                .to_string()
+                .split(" ")
+                .map(|s| s.to_string())
+                .collect::<Vec<String>>()
+                .get(0)
+                .map(|s| s.to_string())
+        })
+        .flatten();
+
+    if vcpus.is_none() {
+        vcpus = std::process::Command::new("cat")
+            .args(["/sys/fs/cgroup/cpu/cpu.cfs_quota_us"])
+            .output()
+            .ok()
+            .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
+    }
+
+    let mut memory = std::process::Command::new("cat")
+        .args(["/sys/fs/cgroup/memory.max"])
+        .output()
+        .ok()
+        .map(|o| String::from_utf8_lossy(&o.stdout).to_string());
+
+    if memory.is_none() {
+        memory = std::process::Command::new("cat")
+            .args(["/sys/fs/cgroup/memory/memory.limit_in_bytes"])
+            .output()
+            .ok()
+            .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
+    }
+
    sqlx::query!(
-        "INSERT INTO worker_ping (worker_instance, worker, ip, custom_tags, worker_group, dedicated_worker, wm_version) VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (worker) DO UPDATE set ip = $3, custom_tags = $4, worker_group = $5",
+        "INSERT INTO worker_ping (worker_instance, worker, ip, custom_tags, worker_group, dedicated_worker, wm_version, vcpus, memory) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) ON CONFLICT (worker) DO UPDATE set ip = $3, custom_tags = $4, worker_group = $5",
        worker_instance,
        worker_name,
        ip,
        tags.as_slice(),
        *WORKER_GROUP,
        dw,
-        crate::utils::GIT_VERSION
+        crate::utils::GIT_VERSION,
+        vcpus.map(|x| x.parse::<i64>().ok()).flatten(),
+        memory.map(|x| x.parse::<i64>().ok()).flatten()
    )
    .execute(db)
    .await
--- a/backend/windmill-queue/Cargo.toml
+++ b/backend/windmill-queue/Cargo.toml
@@ -11,6 +11,7 @@ path = "src/lib.rs"
 [features]
 default = []
 enterprise = ["windmill-common/enterprise"]
+cloud = []
 benchmark = []
 prometheus = ["dep:prometheus"]

--- a/backend/windmill-queue/src/jobs.rs
+++ b/backend/windmill-queue/src/jobs.rs
--- a/backend/windmill-queue/src/schedule.rs
+++ b/backend/windmill-queue/src/schedule.rs
@@ -26,9 +26,9 @@ use windmill_common::{
 pub async fn push_scheduled_job<'c, R: rsmq_async::RsmqConnection + Send + 'c>(
    db: &DB,
    mut tx: QueueTransaction<'c, R>,
-    schedule: Schedule,
+    schedule: &Schedule,
 ) -> Result<QueueTransaction<'c, R>> {
-    let sched = cron::Schedule::from_str(&schedule.schedule)
+    let sched = cron::Schedule::from_str(schedule.schedule.as_ref())
        .map_err(|e| error::Error::BadRequest(e.to_string()))?;

    let tz = chrono_tz::Tz::from_str(&schedule.timezone)
@@ -68,9 +68,9 @@ pub async fn push_scheduled_job<'c, R: rsmq_async::RsmqConnection + Send + 'c>(

    let mut args: serde_json::Map<String, serde_json::Value> = serde_json::Map::new();

-    if let Some(args_v) = schedule.args {
+    if let Some(args_v) = &schedule.args {
        if let serde_json::Value::Object(args_m) = args_v {
-            args = args_m
+            args = args_m.clone()
        } else {
            return Err(error::Error::ExecutionErr(
                "args of scripts needs to be dict".to_string(),
@@ -90,7 +90,7 @@ pub async fn push_scheduled_job<'c, R: rsmq_async::RsmqConnection + Send + 'c>(
            .map(|x| (x.tag, x.dedicated_worker))
            .unwrap_or_else(|| (None, None));
        (
-            JobPayload::Flow { path: schedule.script_path, dedicated_worker },
+            JobPayload::Flow { path: schedule.script_path.clone(), dedicated_worker },
            tag,
            None,
        )
@@ -113,8 +113,8 @@ pub async fn push_scheduled_job<'c, R: rsmq_async::RsmqConnection + Send + 'c>(
        .await?;

        if schedule.retry.is_some() {
-            let parsed_retry =
-                serde_json::from_value::<Retry>(schedule.retry.unwrap()).map_err(|err| {
+            let parsed_retry = serde_json::from_value::<Retry>(schedule.retry.clone().unwrap())
+                .map_err(|err| {
                    error::Error::InternalErr(format!(
                        "Unable to parse retry information from schedule: {}",
                        err.to_string(),
@@ -127,7 +127,7 @@ pub async fn push_scheduled_job<'c, R: rsmq_async::RsmqConnection + Send + 'c>(
            // if retry is set, we wrap the script into a one step flow with a retry on the module
            (
                JobPayload::SingleScriptFlow {
-                    path: schedule.script_path,
+                    path: schedule.script_path.clone(),
                    hash: hash,
                    retry: parsed_retry,
                    args: static_args,
@@ -144,7 +144,7 @@ pub async fn push_scheduled_job<'c, R: rsmq_async::RsmqConnection + Send + 'c>(
            (
                JobPayload::ScriptHash {
                    hash,
-                    path: schedule.script_path,
+                    path: schedule.script_path.clone(),
                    concurrent_limit: concurrent_limit,
                    concurrency_time_window_s: concurrency_time_window_s,
                    cache_ttl: cache_ttl,
@@ -153,7 +153,7 @@ pub async fn push_scheduled_job<'c, R: rsmq_async::RsmqConnection + Send + 'c>(
                    priority,
                },
                if schedule.tag.as_ref().is_some_and(|x| x != "") {
-                    schedule.tag
+                    schedule.tag.clone()
                } else {
                    tag
                },
--- a/backend/windmill-worker/loader.bun.js
+++ b/backend/windmill-worker/loader.bun.js
@@ -27,7 +27,7 @@ const p = {
    const cdir = resolve("./");
    const cdirNoPrivate = cdir.replace(/^\/private/, ""); // for macos
    const filter = new RegExp(
-      `^(?!\\.\/main\\.ts)(?!${cdir}\/main\\.ts)(?!(?:/private)?${cdirNoPrivate}\/wrapper\\.ts).*\\.ts$`
+      `^(?!\\.\/main\\.ts)(?!${cdir}\/main\\.ts)(?!(?:/private)?${cdirNoPrivate}\/wrapper\\.mjs).*\\.ts$`
    );
    build.onResolve({ filter }, (args) => {
      const file_path =
--- a/backend/windmill-worker/loader_builder.bun.js
+++ b/backend/windmill-worker/loader_builder.bun.js
@@ -21,7 +21,7 @@ if (!bo.success) {
    content.replaceAll("__require", "require")
  );

-  const dependencies: Record<string, string[]> = {};
+  const dependencies = {};
  for (const i of imports) {
    let [_, name, version] = i.path.match(captureVersion) ?? [];
    if (name == undefined) {
@@ -46,7 +46,7 @@ if (!bo.success) {
      }
    }
  }
-  const resolvedDeps: Record<string, string> = {};
+  const resolvedDeps = {};
  for (const i in dependencies) {
    const versions = dependencies[i];
    resolvedDeps[i] =
@@ -61,7 +61,7 @@ if (!bo.success) {
    JSON.stringify({ dependencies: resolvedDeps }, null, 2)
  );

-  function reduceIntersect(versions: string[], name: string): string {
+  function reduceIntersect(versions, name) {
    console.log(
      `multiple versions detected for ${name}: ${versions.join(", ")}`
    );
--- a/backend/windmill-worker/nsjail/run.bun.config.proto
+++ b/backend/windmill-worker/nsjail/run.bun.config.proto
@@ -66,7 +66,7 @@ mount {
    src: "{JOB_DIR}/package.json"
    dst: "/tmp/{LANG}/package.json"
    is_bind: true
-    mandatory: true
+    mandatory: false
 }

 mount {
@@ -77,13 +77,6 @@ mount {
 }


-mount {
-    src: "{JOB_DIR}/wrapper.ts"
-    dst: "/tmp/{LANG}/wrapper.ts"
-    is_bind: true
-    mandatory: false
-}
-
 mount {
    src: "{JOB_DIR}/wrapper.mjs"
    dst: "/tmp/{LANG}/wrapper.mjs"
@@ -114,6 +107,13 @@ mount {
    mandatory: false
 }

+mount {
+    src: "{JOB_DIR}/main.js"
+    dst: "/tmp/{LANG}/main.js"
+    is_bind: true
+    mandatory: false
+}
+

 mount {
    src: "{JOB_DIR}/args.json"
--- a/backend/windmill-worker/src/bun_executor.rs
+++ b/backend/windmill-worker/src/bun_executor.rs
@@ -35,11 +35,15 @@ use windmill_common::{
    error::{self, to_anyhow, Result},
    jobs::QueuedJob,
 };
+
+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+use windmill_common::s3_helpers::attempt_fetch_bytes;
+
 use windmill_parser::Typ;

-const RELATIVE_BUN_LOADER: &str = include_str!("../loader.bun.ts");
+const RELATIVE_BUN_LOADER: &str = include_str!("../loader.bun.js");

-const RELATIVE_BUN_BUILDER: &str = include_str!("../loader_builder.bun.ts");
+const RELATIVE_BUN_BUILDER: &str = include_str!("../loader_builder.bun.js");

 const NSJAIL_CONFIG_RUN_BUN_CONTENT: &str = include_str!("../nsjail/run.bun.config.proto");

@@ -76,7 +80,7 @@ pub async fn gen_lockfile(
    } else {
        let _ = write_file(
            &job_dir,
-            "build.ts",
+            "build.js",
            &format!(
                r#"
 {}
@@ -100,7 +104,7 @@ pub async fn gen_lockfile(
            .current_dir(job_dir)
            .env_clear()
            .envs(common_bun_proc_envs.clone())
-            .args(vec!["run", "build.ts"])
+            .args(vec!["run", "build.js"])
            .stdout(Stdio::piped())
            .stderr(Stdio::piped());
        let child_process = start_child_process(child_cmd, &*BUN_PATH).await?;
@@ -338,9 +342,158 @@ fn get_annotation(inner_content: &str) -> Annotations {
    Annotations { npm_mode, nodejs_mode }
 }

+pub async fn build_loader(
+    job_dir: &str,
+    base_internal_url: &str,
+    token: &str,
+    w_id: &str,
+    current_path: &str,
+    nodejs_mode: bool,
+) -> Result<()> {
+    let loader = RELATIVE_BUN_LOADER
+        .replace("W_ID", w_id)
+        .replace("BASE_INTERNAL_URL", base_internal_url)
+        .replace("TOKEN", token)
+        .replace("CURRENT_PATH", current_path)
+        .replace("RAW_GET_ENDPOINT", "raw_unpinned");
+    if nodejs_mode {
+        write_file(
+            &job_dir,
+            "node_builder.ts",
+            &format!(
+                r#"
+{}
+
+import {{ readdir }} from "node:fs/promises";
+
+let fileNames = []
+try {{
+    fileNames = await readdir("{job_dir}/node_modules")
+}} catch (e) {{
+
+}}
+
+const bo = await Bun.build({{
+    entrypoints: ["{job_dir}/wrapper.mjs"],
+    outdir: "./",
+    target: "node",
+    plugins: [p],
+    external: fileNames,
+  }});
+
+if (!bo.success) {{
+    bo.logs.forEach((l) => console.log(l));
+    process.exit(1);
+}}
+"#,
+                loader
+            ),
+        )
+        .await?;
+    } else {
+        write_file(
+            &job_dir,
+            "loader.bun.js",
+            &format!(
+                r#"
+import {{ plugin }} from "bun";
+
+{}
+
+plugin(p)
+"#,
+                loader
+            ),
+        )
+        .await?;
+    };
+    Ok(())
+}
+
+pub async fn generate_wrapper_mjs(
+    job_dir: &str,
+    w_id: &str,
+    job_id: &Uuid,
+    worker_name: &str,
+    db: &sqlx::Pool<sqlx::Postgres>,
+    timeout: Option<i32>,
+    mem_peak: &mut i32,
+    canceled_by: &mut Option<CanceledBy>,
+    common_bun_proc_envs: &HashMap<String, String>,
+) -> Result<()> {
+    let mut child = Command::new(&*BUN_PATH);
+    child
+        .current_dir(job_dir)
+        .env_clear()
+        .envs(common_bun_proc_envs.clone())
+        .env("PATH", PATH_ENV.as_str())
+        .args(vec!["run", "node_builder.ts"])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+    let child_process = start_child_process(child, &*BUN_PATH).await?;
+    handle_child(
+        job_id,
+        db,
+        mem_peak,
+        canceled_by,
+        child_process,
+        false,
+        worker_name,
+        w_id,
+        "bun build",
+        timeout,
+        false,
+    )
+    .await?;
+    tokio::fs::rename(
+        format!("{job_dir}/wrapper.js"),
+        format!("{job_dir}/wrapper.mjs"),
+    )
+    .await
+    .map_err(|e| error::Error::InternalErr(format!("Could not move wrapper to mjs: {e}")))?;
+    Ok(())
+}
+
+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+pub async fn pull_codebase(w_id: &str, id: &str, job_dir: &str) -> Result<()> {
+    let path = windmill_common::s3_helpers::bundle(&w_id, &id);
+    let bun_cache_path = format!("{}/{}", BUN_CACHE_DIR, path);
+    let dst = format!("{job_dir}/main.js");
+    let dirs_splitted = bun_cache_path.split("/").collect_vec();
+    tokio::fs::create_dir_all(dirs_splitted[..dirs_splitted.len() - 1].join("/")).await?;
+    if tokio::fs::metadata(&bun_cache_path).await.is_ok() {
+        tracing::info!("loading {bun_cache_path} from cache");
+        tokio::fs::symlink(&bun_cache_path, dst).await?;
+    } else if let Some(os) = windmill_common::s3_helpers::OBJECT_STORE_CACHE_SETTINGS
+        .read()
+        .await
+        .clone()
+    {
+        let bytes = attempt_fetch_bytes(os, &path).await?;
+        if *windmill_common::worker::CLOUD_HOSTED {
+            tokio::fs::write(dst, &bytes).await?;
+        } else {
+            tokio::fs::write(&bun_cache_path, &bytes).await?;
+            tokio::fs::symlink(bun_cache_path, dst).await?;
+        }
+
+        // extract_tar(bytes, job_dir).await?;
+    }
+
+    return Ok(());
+}
+
+#[cfg(not(all(feature = "enterprise", feature = "parquet")))]
+pub async fn pull_codebase(_w_id: &str, _id: &str, _job_dir: &str) -> Result<()> {
+    return Err(error::Error::ExecutionErr(
+        "codebase is an EE feature".to_string(),
+    ));
+}
+
 #[tracing::instrument(level = "trace", skip_all)]
 pub async fn handle_bun_job(
    requirements_o: Option<String>,
+    codebase: Option<String>,
    mem_peak: &mut i32,
    canceled_by: &mut Option<CanceledBy>,
    job: &QueuedJob,
@@ -353,13 +506,20 @@ pub async fn handle_bun_job(
    envs: HashMap<String, String>,
    shared_mount: &str,
 ) -> error::Result<Box<RawValue>> {
-    let _ = write_file(job_dir, "main.ts", inner_content).await?;
+    if !codebase.is_some() {
+        let _ = write_file(job_dir, "main.ts", inner_content).await?;
+    } else {
+        let _ = write_file(job_dir, "package.json", r#"{ "type": "module" }"#).await?;
+    }

    let common_bun_proc_envs: HashMap<String, String> =
        get_common_bun_proc_envs(&base_internal_url).await;

-    let annotation = get_annotation(inner_content);
+    let mut annotation = get_annotation(inner_content);

+    if codebase.is_some() {
+        annotation.nodejs_mode = true
+    }
    let main_override = get_main_override(job.args.as_ref());

    #[cfg(not(feature = "enterprise"))]
@@ -369,7 +529,9 @@ pub async fn handle_bun_job(
        ));
    }

-    if let Some(reqs) = requirements_o {
+    if let Some(codebase) = codebase.as_ref() {
+        pull_codebase(&job.workspace_id, codebase, job_dir).await?;
+    } else if let Some(reqs) = requirements_o {
        let splitted = reqs.split(BUN_LOCKB_SPLIT).collect::<Vec<&str>>();
        if splitted.len() != 2 {
            return Err(error::Error::ExecutionErr(
@@ -435,10 +597,11 @@ pub async fn handle_bun_job(
        // }
    }

-    let main_code = remove_pinned_imports(inner_content)?;
-    let _ = write_file(job_dir, "main.ts", &main_code).await?;
+    let _ = write_file(job_dir, "main.ts", &remove_pinned_imports(inner_content)?).await?;

-    let init_logs = if annotation.nodejs_mode {
+    let init_logs = if codebase.is_some() {
+        "\n\n--- NODE SNAPSHOT EXECUTION ---\n".to_string()
+    } else if annotation.nodejs_mode {
        "\n\n--- NODE CODE EXECUTION ---\n".to_string()
    } else {
        "\n\n--- BUN CODE EXECUTION ---\n".to_string()
@@ -469,11 +632,17 @@ pub async fn handle_bun_job(
        // we cannot use Bun.read and Bun.write because it results in an EBADF error on cloud
        let main_name = main_override.unwrap_or("main".to_string());

+        let main_import = if codebase.is_some() {
+            "./main.js"
+        } else {
+            "./main.ts"
+        };
+
        let wrapper_content: String = format!(
            r#"
-import {{ {main_name} }} from "./main.ts";
+import * as Main from "{main_import}";

-const fs = require('fs/promises');
+import * as fs from "fs/promises";

 const args = await fs.readFile('args.json', {{ encoding: 'utf8' }}).then(JSON.parse)
    .then(({{ {spread} }}) => [ {spread} ])
@@ -484,7 +653,7 @@ BigInt.prototype.toJSON = function () {{

 {dates}
 async function run() {{
-    let res: any = await {main_name}(...args);
+    let res = await Main.{main_name}(...args);
    const res_json = JSON.stringify(res ?? null, (key, value) => typeof value === 'undefined' ? null : value);
    await fs.writeFile("result.json", res_json);
    process.exit(0);
@@ -502,7 +671,7 @@ try {{
 }}
    "#,
        );
-        write_file(job_dir, "wrapper.ts", &wrapper_content).await?;
+        write_file(job_dir, "wrapper.mjs", &wrapper_content).await?;
        Ok(()) as error::Result<()>
    };

@@ -520,65 +689,19 @@ try {{
        Ok(reserved_variables) as error::Result<HashMap<String, String>>
    };

-    let loader = RELATIVE_BUN_LOADER
-        .replace("W_ID", &job.workspace_id)
-        .replace("BASE_INTERNAL_URL", base_internal_url)
-        .replace("TOKEN", &client.get_token().await)
-        .replace("CURRENT_PATH", job.script_path())
-        .replace("RAW_GET_ENDPOINT", "raw_unpinned");
-    let write_loader_f = async move {
-        if annotation.nodejs_mode {
-            write_file(
-                &job_dir,
-                "node_builder.ts",
-                &format!(
-                    r#"
-{}
-
-import {{ readdir }} from "node:fs/promises";
-
-let fileNames = []
-try {{
-    fileNames = await readdir("{job_dir}/node_modules")
-}} catch (e) {{
-
-}}
-
-const bo = await Bun.build({{
-    entrypoints: ["{job_dir}/wrapper.ts"],
-    outdir: "./",
-    target: "node",
-    plugins: [p],
-    external: fileNames,
-  }});
-
-if (!bo.success) {{
-    bo.logs.forEach((l) => console.log(l));
-    process.exit(1);
-}}
-"#,
-                    loader
-                ),
+    let write_loader_f = async {
+        if !codebase.is_some() {
+            build_loader(
+                job_dir,
+                base_internal_url,
+                &client.get_token().await,
+                &job.workspace_id,
+                &job.script_path(),
+                annotation.nodejs_mode,
            )
-            .await?;
-            Ok(()) as error::Result<()>
+            .await
        } else {
-            write_file(
-                &job_dir,
-                "loader.bun.ts",
-                &format!(
-                    r#"
-import {{ plugin }} from "bun";
-
-{}
-
-plugin(p)
-"#,
-                    loader
-                ),
-            )
-            .await?;
-            Ok(()) as error::Result<()>
+            Ok(())
        }
    };

@@ -588,37 +711,19 @@ plugin(p)
        write_loader_f
    )?;

-    if annotation.nodejs_mode {
-        let mut child = Command::new(&*BUN_PATH);
-        child
-            .current_dir(job_dir)
-            .env_clear()
-            .envs(common_bun_proc_envs.clone())
-            .env("PATH", PATH_ENV.as_str())
-            .args(vec!["run", "node_builder.ts"])
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
-        let child_process = start_child_process(child, &*BUN_PATH).await?;
-        handle_child(
+    if annotation.nodejs_mode && !codebase.is_some() {
+        generate_wrapper_mjs(
+            job_dir,
+            &job.workspace_id,
            &job.id,
+            worker_name,
            db,
+            job.timeout,
            mem_peak,
            canceled_by,
-            child_process,
-            false,
-            worker_name,
-            &job.workspace_id,
-            "bun build",
-            job.timeout,
-            false,
+            &common_bun_proc_envs,
        )
        .await?;
-        tokio::fs::rename(
-            format!("{job_dir}/wrapper.js"),
-            format!("{job_dir}/wrapper.mjs"),
-        )
-        .await
-        .map_err(|e| error::Error::InternalErr(format!("Could not move wrapper to mjs: {e}")))?;
    }

    //do not cache local dependencies
@@ -661,6 +766,15 @@ plugin(p)
                &NODE_PATH,
                "/tmp/nodejs/wrapper.mjs",
            ]
+        } else if codebase.is_some() {
+            vec![
+                "--config",
+                "run.config.proto",
+                "--",
+                &BUN_PATH,
+                "run",
+                "/tmp/bun/wrapper.mjs",
+            ]
        } else {
            vec![
                "--config",
@@ -671,8 +785,8 @@ plugin(p)
                "-i",
                "--prefer-offline",
                "-r",
-                "/tmp/bun/loader.bun.ts",
-                "/tmp/bun/wrapper.ts",
+                "/tmp/bun/loader.bun.js",
+                "/tmp/bun/wrapper.mjs",
            ]
        };
        nsjail_cmd
@@ -702,23 +816,28 @@ plugin(p)
                .stderr(Stdio::piped());
            bun_cmd
        } else {
-            let script_path = format!("{job_dir}/wrapper.ts");
+            let script_path = format!("{job_dir}/wrapper.mjs");

            let mut bun_cmd = Command::new(&*BUN_PATH);
+            let args = if codebase.is_some() {
+                vec!["run", &script_path]
+            } else {
+                vec![
+                    "run",
+                    "-i",
+                    "--prefer-offline",
+                    "-r",
+                    "./loader.bun.js",
+                    &script_path,
+                ]
+            };
            bun_cmd
                .current_dir(job_dir)
                .env_clear()
                .envs(envs)
                .envs(reserved_variables)
                .envs(common_bun_proc_envs)
-                .args(vec![
-                    "run",
-                    "-i",
-                    "--prefer-offline",
-                    "-r",
-                    "./loader.bun.ts",
-                    &script_path,
-                ])
+                .args(args)
                .stdout(Stdio::piped())
                .stderr(Stdio::piped());
            bun_cmd
@@ -780,6 +899,7 @@ use std::sync::Arc;
 #[cfg(feature = "enterprise")]
 pub async fn start_worker(
    requirements_o: Option<String>,
+    codebase: Option<String>,
    db: &sqlx::Pool<sqlx::Postgres>,
    inner_content: &str,
    base_internal_url: &str,
@@ -796,10 +916,21 @@ pub async fn start_worker(
    let mut logs = "".to_string();
    let mut mem_peak: i32 = 0;
    let mut canceled_by: Option<CanceledBy> = None;
-    let _ = write_file(job_dir, "main.ts", inner_content).await?;
+    tracing::info!("Starting worker {w_id};{script_path} (codebase: {codebase:?}");
+    if !codebase.is_some() {
+        let _ = write_file(job_dir, "main.ts", inner_content).await?;
+    } else {
+        let _ = write_file(job_dir, "package.json", r#"{ "type": "module" }"#).await?;
+    }
+
    let common_bun_proc_envs: HashMap<String, String> =
        get_common_bun_proc_envs(&base_internal_url).await;

+    let mut annotation = get_annotation(inner_content);
+
+    //TODO: remove this when bun dedicated workers work without issues
+    annotation.nodejs_mode = true;
+
    let context = variables::get_reserved_variables(
        db,
        w_id,
@@ -818,8 +949,10 @@ pub async fn start_worker(
    )
    .await;
    let context_envs = build_envs_map(context.to_vec()).await;
-    let annotation = get_annotation(inner_content);
-    if let Some(reqs) = requirements_o {
+
+    if let Some(codebase) = codebase.as_ref() {
+        pull_codebase(w_id, codebase, job_dir).await?;
+    } else if let Some(reqs) = requirements_o {
        let splitted = reqs.split(BUN_LOCKB_SPLIT).collect::<Vec<&str>>();
        if splitted.len() != 2 {
            return Err(error::Error::ExecutionErr(
@@ -902,9 +1035,23 @@ pub async fn start_worker(
        let spread = args.into_iter().map(|x| x.name).join(",");
        // logs.push_str(format!("infer args: {:?}\n", start.elapsed().as_micros()).as_str());
        // we cannot use Bun.read and Bun.write because it results in an EBADF error on cloud
+
+        let is_debug = std::env::var("RUST_LOG").is_ok_and(|x| x == "windmill=debug");
+        let print_lines = if is_debug {
+            r#"console.log(line);"#
+        } else {
+            ""
+        };
+
+        let main_import = if codebase.is_some() {
+            "./main.js"
+        } else {
+            "./main.ts"
+        };
        let wrapper_content: String = format!(
            r#"
-import {{ main }} from "./main.ts";
+import * as Main from "{main_import}";
+import * as Readline from "node:readline"

 BigInt.prototype.toJSON = function () {{
    return this.toString();
@@ -912,77 +1059,100 @@ BigInt.prototype.toJSON = function () {{

 {dates}

-let stdout = Bun.stdout.writer();
-stdout.write('start\n'); 
+console.log('start'); 

-for await (const chunk of Bun.stdin.stream()) {{
-    const lines = Buffer.from(chunk).toString();
-    let exit = false;
-    for (const line of lines.trim().split("\n")) {{
-        if (line === "end") {{
-            exit = true;
-            break;
-        }}
-        try {{
-            let {{ {spread} }} = JSON.parse(line) 
-            let res: any = await main(...[ {spread} ]);
-            stdout.write("wm_res[success]:" + JSON.stringify(res ?? null, (key, value) => typeof value === 'undefined' ? null : value) + '\n');
-        }} catch (e) {{
-            stdout.write("wm_res[error]:" + JSON.stringify({{ message: e.message, name: e.name, stack: e.stack, line: line }}) + '\n');
-        }}
-        stdout.flush();
+for await (const line of Readline.createInterface({{ input: process.stdin }})) {{
+    {print_lines}
+
+    if (line === "end") {{
+        process.exit(0);
    }}
-    if (exit) {{
-        break;
+    try {{
+        let {{ {spread} }} = JSON.parse(line) 
+        let res = await Main.main(...[ {spread} ]);
+        console.log("wm_res[success]:" + JSON.stringify(res ?? null, (key, value) => typeof value === 'undefined' ? null : value));
+    }} catch (e) {{
+        console.log("wm_res[error]:" + JSON.stringify({{ message: e.message, name: e.name, stack: e.stack, line: line }}));
    }}
 }}
 "#,
        );
-        write_file(job_dir, "wrapper.ts", &wrapper_content).await?;
+        write_file(job_dir, "wrapper.mjs", &wrapper_content).await?;
    }

-    let _ = write_file(
-        &job_dir,
-        "loader.bun.ts",
-        &format!(
-            r#"
-import {{ plugin }} from "bun";
+    if !codebase.is_some() {
+        build_loader(
+            job_dir,
+            base_internal_url,
+            token,
+            w_id,
+            script_path,
+            annotation.nodejs_mode,
+        )
+        .await?;
+    }

-{}
+    if annotation.nodejs_mode && !codebase.is_some() {
+        generate_wrapper_mjs(
+            job_dir,
+            w_id,
+            &Uuid::nil(),
+            worker_name,
+            db,
+            None,
+            &mut mem_peak,
+            &mut canceled_by,
+            &common_bun_proc_envs,
+        )
+        .await?;
+    }

-plugin(p)
-"#,
-            RELATIVE_BUN_LOADER
-                .replace("W_ID", &w_id)
-                .replace("BASE_INTERNAL_URL", base_internal_url)
-                .replace("TOKEN", token)
-                .replace("CURRENT_PATH", script_path)
-                .replace("RAW_GET_ENDPOINT", "raw_unpinned")
-        ),
-    )
-    .await?;
+    if annotation.nodejs_mode {
+        let script_path = format!("{job_dir}/wrapper.mjs");

-    handle_dedicated_process(
-        &*BUN_PATH,
-        job_dir,
-        context_envs,
-        envs,
-        context,
-        common_bun_proc_envs,
-        vec![
-            "run",
-            "-i",
-            "--prefer-offline",
-            "-r",
-            "./loader.bun.ts",
-            &format!("{job_dir}/wrapper.ts"),
-        ],
-        killpill_rx,
-        job_completed_tx,
-        token,
-        jobs_rx,
-        worker_name,
-        db,
-    )
-    .await
+        handle_dedicated_process(
+            &*NODE_PATH,
+            job_dir,
+            context_envs,
+            envs,
+            context,
+            common_bun_proc_envs,
+            vec![&script_path],
+            killpill_rx,
+            job_completed_tx,
+            token,
+            jobs_rx,
+            worker_name,
+            db,
+            &script_path,
+            "nodejs",
+        )
+        .await
+    } else {
+        handle_dedicated_process(
+            &*BUN_PATH,
+            job_dir,
+            context_envs,
+            envs,
+            context,
+            common_bun_proc_envs,
+            vec![
+                "run",
+                "-i",
+                "--prefer-offline",
+                "-r",
+                "./loader.bun.js",
+                &format!("{job_dir}/wrapper.mjs"),
+            ],
+            killpill_rx,
+            job_completed_tx,
+            token,
+            jobs_rx,
+            worker_name,
+            db,
+            script_path,
+            "bun",
+        )
+        .await
+    }
 }
--- a/backend/windmill-worker/src/common.rs
+++ b/backend/windmill-worker/src/common.rs
@@ -26,7 +26,7 @@ use windmill_common::s3_helpers::OBJECT_STORE_CACHE_SETTINGS;
 use windmill_common::s3_helpers::{
    get_etag_or_empty, LargeFileStorage, ObjectStoreResource, S3Object,
 };
-use windmill_common::worker::{CLOUD_HOSTED, WORKER_CONFIG};
+use windmill_common::worker::{CLOUD_HOSTED, TMP_DIR, WORKER_CONFIG};
 use windmill_common::{
    error::{self, Error},
    jobs::QueuedJob,
@@ -39,6 +39,7 @@ use windmill_queue::{append_logs, CanceledBy};
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 use std::os::unix::process::ExitStatusExt;

+use std::process::ExitStatus;
 use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 use std::{
@@ -69,7 +70,7 @@ use futures::{

 use crate::{
    AuthedClient, AuthedClientBackgroundTask, JOB_DEFAULT_TIMEOUT, MAX_RESULT_SIZE,
-    MAX_TIMEOUT_DURATION, MAX_WAIT_FOR_SIGINT, MAX_WAIT_FOR_SIGTERM, ROOT_CACHE_DIR, TMP_DIR,
+    MAX_TIMEOUT_DURATION, MAX_WAIT_FOR_SIGINT, MAX_WAIT_FOR_SIGTERM, ROOT_CACHE_DIR,
 };

 pub async fn build_args_map<'a>(
@@ -482,7 +483,7 @@ pub async fn run_future_with_polling_update_job_poller<Fut, T>(
    result_f: Fut,
    worker_name: &str,
    w_id: &str,
-) -> anyhow::Result<T>
+) -> error::Result<T>
 where
    Fut: Future<Output = anyhow::Result<T>>,
 {
@@ -514,12 +515,22 @@ where
            tracing::error!("Query timeout: {}", e);
            Error::ExecutionErr(format!("Query timeout after (>{}s)", timeout_ms/1000))
        })?,
-        _ = update_job, if job_id != Uuid::nil() => Err(Error::ExecutionErr("Job cancelled".to_string())).map_err(to_anyhow)?,
+        ex = update_job, if job_id != Uuid::nil() => {
+            match ex {
+                UpdateJobPollingExit::Done => Err(Error::ExecutionErr("Job cancelled".to_string())).map_err(to_anyhow)?,
+                UpdateJobPollingExit::AlreadyCompleted => Err(Error::AlreadyCompleted("Job already completed".to_string())).map_err(to_anyhow)?,
+            }
+        }
    }?;
    drop(tx);
    Ok(rows)
 }

+pub enum UpdateJobPollingExit {
+    Done,
+    AlreadyCompleted,
+}
+
 pub async fn update_job_poller<F, Fut>(
    job_id: Uuid,
    db: &DB,
@@ -529,13 +540,14 @@ pub async fn update_job_poller<F, Fut>(
    worker_name: &str,
    w_id: &str,
    mut rx: broadcast::Receiver<()>,
-) where
+) -> UpdateJobPollingExit
+where
    F: Fn() -> Fut,
    Fut: Future<Output = i32>,
 {
    let update_job_interval = Duration::from_millis(500);
    if job_id == Uuid::nil() {
-        return;
+        return UpdateJobPollingExit::Done;
    }
    let db = db.clone();

@@ -556,7 +568,9 @@ pub async fn update_job_poller<F, Fut>(
                i+=1;
                if i % 10 == 0 {
                    sqlx::query!(
-                        "UPDATE worker_ping SET ping_at = now() WHERE worker = $1",
+                        "UPDATE worker_ping SET ping_at = now(), current_job_id = $1, current_job_workspace_id = $2 WHERE worker = $3",
+                        &job_id,
+                        &w_id,
                        &worker_name
                    )
                    .execute(&db)
@@ -593,28 +607,36 @@ pub async fn update_job_poller<F, Fut>(
                    }
                }

-                let (canceled, canceled_by, canceled_reason) = sqlx::query_as::<_, (bool, Option<String>, Option<String>)>("UPDATE queue SET mem_peak = $1, last_ping = now() WHERE id = $2 RETURNING canceled, canceled_by, canceled_reason")
+                let (canceled, canceled_by, canceled_reason, already_completed) = sqlx::query_as::<_, (bool, Option<String>, Option<String>, bool)>("UPDATE queue SET mem_peak = $1, last_ping = now() WHERE id = $2 RETURNING canceled, canceled_by, canceled_reason, false")
                    .bind(*mem_peak)
                    .bind(job_id)
                    .fetch_optional(&db)
                    .await
                    .unwrap_or_else(|e| {
                        tracing::error!(%e, "error updating job {job_id}: {e}");
-                        Some((false, None, None))
+                        Some((false, None, None, false))
                    })
-                    .unwrap_or((false, None, None));
+                    .unwrap_or_else(|| {
+                        // if the job is not in queue, it can only be in the completed_job so it is already complete
+                        (false, None, None, true)
+                    });
+                if already_completed {
+                    return UpdateJobPollingExit::AlreadyCompleted
+                }
                if canceled {
                    canceled_by_ref.replace(CanceledBy {
                        username: canceled_by.clone(),
                        reason: canceled_reason.clone(),
                    });
-                    break;
+                    break
                }
            }
            },
        );
    }
    tracing::info!("job {job_id} finished");
+
+    UpdateJobPollingExit::Done
 }

 pub enum CompactLogs {
@@ -630,7 +652,7 @@ async fn compact_logs(
    nlogs: String,
    total_size: Arc<AtomicU32>,
    compact_kind: CompactLogs,
-    worker_name: &str,
+    _worker_name: &str,
 ) -> error::Result<(String, String)> {
    let size = sqlx::query_scalar!(
        "SELECT char_length(logs) FROM job_logs WHERE job_id = $1 AND workspace_id = $2",
@@ -695,9 +717,9 @@ async fn compact_logs(
    );

    let mut new_current_logs = match compact_kind {
-        CompactLogs::NoS3 => format!("[windmill] worker {worker_name}: Logs length has exceeded a threshold\n[windmill] Previous logs have been saved to disk at {path}, add object storage in the instance settings to save it on distributed storage and allow direct download from Windmill\n"),
+        CompactLogs::NoS3 => format!("[windmill] No object storage set in instance settings. Previous logs have been saved to disk at {path}\n"),
        CompactLogs::S3 => format!("[windmill] Previous logs have been saved to object storage at {path}\n"),
-        CompactLogs::NotEE => format!("[windmill] worker {worker_name}: Logs length has exceeded a threshold\n[windmill] Previous logs have been saved to disk at {path}\n[windmill] Upgrade to EE and add object storage to save it persistentely on distributed storage and allow direct download from Windmill\n"),
+        CompactLogs::NotEE => format!("[windmill] Previous logs have been saved to disk at {path}\n"),
    };
    new_current_logs.push_str(&current_logs);

@@ -897,6 +919,7 @@ pub async fn handle_child(
        TooManyLogs,
        Timeout,
        Cancelled,
+        AlreadyCompleted,
    }

    let (timeout_duration, timeout_warn_msg) =
@@ -914,7 +937,10 @@ pub async fn handle_child(
            result = child.wait() => return result.map(Ok),
            Ok(()) = too_many_logs.changed() => KillReason::TooManyLogs,
            _ = sleep(timeout_duration) => KillReason::Timeout,
-            _ = update_job, if job_id != Uuid::nil() => KillReason::Cancelled,
+            ex = update_job, if job_id != Uuid::nil() => match ex {
+                UpdateJobPollingExit::Done => KillReason::Cancelled,
+                UpdateJobPollingExit::AlreadyCompleted => KillReason::AlreadyCompleted,
+            },
        };
        tx.send(()).expect("rx should never be dropped");
        drop(tx);
@@ -1120,26 +1146,7 @@ pub async fn handle_child(
        _ if *too_many_logs.borrow() => Err(Error::ExecutionErr(format!(
            "logs or result reached limit. (current max size: {MAX_RESULT_SIZE} characters)"
        ))),
-        Ok(Ok(status)) => {
-            if status.success() {
-                Ok(())
-            } else if let Some(code) = status.code() {
-                Err(error::Error::ExitStatus(code))
-            } else {
-                #[cfg(any(target_os = "linux", target_os = "macos"))]
-                return Err(error::Error::ExecutionErr(format!(
-                    "process terminated by signal: {:#?}, stopped_signal: {:#?}, core_dumped: {}",
-                    status.signal(),
-                    status.stopped_signal(),
-                    status.core_dumped()
-                )));
-
-                #[cfg(not(any(target_os = "linux", target_os = "macos")))]
-                return Err(error::Error::ExecutionErr(String::from(
-                    "process terminated by signal",
-                )));
-            }
-        }
+        Ok(Ok(status)) => process_status(status),
        Ok(Err(kill_reason)) => Err(Error::ExecutionErr(format!(
            "job process killed because {kill_reason:#?}"
        ))),
@@ -1147,6 +1154,26 @@ pub async fn handle_child(
    }
 }

+pub fn process_status(status: ExitStatus) -> error::Result<()> {
+    if status.success() {
+        Ok(())
+    } else if let Some(code) = status.code() {
+        Err(error::Error::ExitStatus(code))
+    } else {
+        #[cfg(any(target_os = "linux", target_os = "macos"))]
+        return Err(error::Error::ExecutionErr(format!(
+            "process terminated by signal: {:#?}, stopped_signal: {:#?}, core_dumped: {}",
+            status.signal(),
+            status.stopped_signal(),
+            status.core_dumped()
+        )));
+
+        #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+        return Err(error::Error::ExecutionErr(String::from(
+            "process terminated by signal",
+        )));
+    }
+}
 pub async fn start_child_process(mut cmd: Command, executable: &str) -> Result<Child, Error> {
    return cmd
        .spawn()
@@ -1160,7 +1187,7 @@ pub async fn resolve_job_timeout(
    custom_timeout_secs: Option<i32>,
 ) -> (Duration, Option<String>) {
    let mut warn_msg: Option<String> = None;
-    #[cfg(feature = "enterprise")]
+    #[cfg(feature = "cloud")]
    let cloud_premium_workspace = *CLOUD_HOSTED
        && sqlx::query_scalar!("SELECT premium FROM workspace WHERE id = $1", _w_id)
            .fetch_one(_db)
@@ -1169,7 +1196,7 @@ pub async fn resolve_job_timeout(
                tracing::error!(%e, "error getting premium workspace for job {_job_id}: {e}");
            })
            .unwrap_or(false);
-    #[cfg(not(feature = "enterprise"))]
+    #[cfg(not(feature = "cloud"))]
    let cloud_premium_workspace = false;

    // compute global max timeout
--- a/backend/windmill-worker/src/dedicated_worker.rs
+++ b/backend/windmill-worker/src/dedicated_worker.rs
@@ -16,7 +16,8 @@ use std::{collections::VecDeque, process::Stdio, sync::Arc};
 use anyhow::Context;

 use crate::{
-    common::start_child_process, JobCompleted, JobCompletedSender, MAX_BUFFERED_DEDICATED_JOBS,
+    common::{process_status, start_child_process},
+    JobCompleted, JobCompletedSender, MAX_BUFFERED_DEDICATED_JOBS,
 };

 use futures::{future, Future};
@@ -58,6 +59,8 @@ pub async fn handle_dedicated_process(
    mut jobs_rx: Receiver<Arc<QueuedJob>>,
    worker_name: &str,
    db: &DB,
+    script_path: &str,
+    mode: &str,
 ) -> std::result::Result<(), error::Error> {
    //do not cache local dependencies
    let mut child = {
@@ -106,7 +109,11 @@ pub async fn handle_dedicated_process(
            .wait()
            .await
            .expect("child process encountered an error");
-        tracing::info!("child status was: {}", status);
+        if let Err(e) = process_status(status) {
+            tracing::error!("child exit status was not success: {e}");
+        } else {
+            tracing::info!("child exist status was success");
+        }
    });

    let mut jobs = VecDeque::with_capacity(MAX_BUFFERED_DEDICATED_JOBS);
@@ -114,7 +121,7 @@ pub async fn handle_dedicated_process(
    // let mut j = 0;
    let mut alive = true;

-    let init_log = format!("dedicated worker: {worker_name}\n\n");
+    let init_log = format!("dedicated worker {mode}: {worker_name}\n\n");
    let mut logs = init_log.clone();
    loop {
        tokio::select! {
@@ -125,9 +132,11 @@ pub async fn handle_dedicated_process(
                if let Err(e) = write_stdin(&mut stdin, "end").await {
                    tracing::info!("Could not write end message to stdin: {e:?}")
                }
+                stdin.flush().await.context("stdin flush")?;
            },
            line = err_reader.next_line() => {
                if let Some(line) = line.expect("line is ok") {
+                    tracing::debug!("stderr dedicated worker: {line}");
                    logs.push_str("[stderr] ");
                    logs.push_str(&line);
                    logs.push_str("\n");
@@ -144,9 +153,10 @@ pub async fn handle_dedicated_process(
                        tracing::info!("dedicated worker process started");
                        continue;
                    }
-                    tracing::debug!("processed job: {line}");
+                    tracing::debug!("processed job: |{line}|");
                    if line.starts_with("wm_res[") {
                        let job: Arc<QueuedJob> = jobs.pop_front().expect("pop");
+                        tracing::info!("job completed on dedicated worker {script_path}: {}", job.id);
                        match serde_json::from_str::<Box<serde_json::value::RawValue>>(&line.replace("wm_res[success]:", "").replace("wm_res[error]:", "")) {
                            Ok(result) => {
                                append_logs(job.id, job.workspace_id.clone(),  logs.clone(), db).await;
@@ -174,8 +184,9 @@ pub async fn handle_dedicated_process(
            job = conditional_polling(jobs_rx.recv(), alive && jobs.len() < MAX_BUFFERED_DEDICATED_JOBS) => {
                // i += 1;
                if let Some(job) = job {
-                    tracing::debug!("received job");
                    jobs.push_back(job.clone());
+                    tracing::info!("received job and adding to queue on dedicated worker for {script_path}: {} (queue_size: {})", job.id, jobs.len());
+
                    // write_stdin(&mut stdin, &serde_json::to_string(&job.args.unwrap_or_else(|| serde_json::json!({"x": job.id}))).expect("serialize")).await?;
                    write_stdin(&mut stdin, &serde_json::to_string(&job.args).expect("serialize")).await?;
                    stdin.flush().await.context("stdin flush")?;
--- a/backend/windmill-worker/src/deno_executor.rs
+++ b/backend/windmill-worker/src/deno_executor.rs
@@ -527,6 +527,8 @@ for await (const chunk of Deno.stdin.readable) {{
        jobs_rx,
        worker_name,
        db,
+        script_path,
+        "deno",
    )
    .await
 }
--- a/backend/windmill-worker/src/global_cache.rs
+++ b/backend/windmill-worker/src/global_cache.rs
@@ -73,47 +73,19 @@ pub async fn build_tar_and_push(

 #[cfg(all(feature = "enterprise", feature = "parquet"))]
 pub async fn pull_from_tar(client: Arc<dyn ObjectStore>, folder: String) -> error::Result<()> {
-    use object_store::path::Path;
+    use windmill_common::s3_helpers::attempt_fetch_bytes;
+
    let folder_name = folder.split("/").last().unwrap();

    tracing::info!("Attempting to pull piptar {folder_name} from bucket");

    let start = Instant::now();
    let tar_path = format!("tar/pip/{folder_name}.tar");
+    let bytes = attempt_fetch_bytes(client, &tar_path).await?;

-    let object = client.get(&Path::from(tar_path.clone())).await;
-    if let Err(e) = object {
-        tracing::info!("Failed to pull tar from s3: {tar_path}. Error: {:?}", e);
-        return Err(error::Error::ExecutionErr(format!(
-            "Failed to pull tar from s3: {tar_path}"
-        )));
-    }
-
-    let bytes = object.unwrap().bytes().await;
-    if bytes.is_err() {
-        tracing::info!(
-            "Failed to read tar from s3: {tar_path}. Error: {:?}",
-            bytes.err()
-        );
-        return Err(error::Error::ExecutionErr(format!(
-            "Failed to read tar from s3: {tar_path}"
-        )));
-    }
-    let bytes = bytes.unwrap();
-    tracing::info!("{tar_path} len: {}", bytes.len());
-
-    if bytes.len() == 0 {
-        tracing::info!(
-            "piptar {folder_name} not found in bucket. Took {:?}ms",
-            start.elapsed().as_millis()
-        );
-        return Err(error::Error::ExecutionErr(format!(
-            "tar {folder_name} does not exist in bucket"
-        )));
-    }
    // tracing::info!("B: {target} {folder}");

-    extract_pip_tar(bytes, &folder).await.map_err(|e| {
+    extract_tar(bytes, &folder).await.map_err(|e| {
        tracing::error!("Failed to extract piptar {folder_name}. Error: {:?}", e);
        e
    })?;
@@ -127,7 +99,7 @@ pub async fn pull_from_tar(client: Arc<dyn ObjectStore>, folder: String) -> erro
 }

 #[cfg(all(feature = "enterprise", feature = "parquet"))]
-pub async fn extract_pip_tar(tar: bytes::Bytes, folder: &str) -> error::Result<()> {
+pub async fn extract_tar(tar: bytes::Bytes, folder: &str) -> error::Result<()> {
    use bytes::Buf;
    use tokio::fs::{self};

@@ -137,14 +109,14 @@ pub async fn extract_pip_tar(tar: bytes::Bytes, folder: &str) -> error::Result<(
    let mut ar = tar::Archive::new(tar.reader());

    if let Err(e) = ar.unpack(folder) {
-        tracing::info!("Failed to untar piptar. Error: {:?}", e);
+        tracing::info!("Failed to untar to {folder}. Error: {:?}", e);
        fs::remove_dir_all(&folder).await?;
        return Err(error::Error::ExecutionErr(format!(
            "Failed to untar piptar {folder}"
        )));
    }
    tracing::info!(
-        "Finished extracting pip tar {folder}. Took {}ms",
+        "Finished extracting tar to {folder}. Took {}ms",
        start.elapsed().as_millis(),
    );
    Ok(())
--- a/backend/windmill-worker/src/go_executor.rs
+++ b/backend/windmill-worker/src/go_executor.rs
@@ -33,6 +33,111 @@ lazy_static::lazy_static! {
    static ref GO_PATH: String = std::env::var("GO_PATH").unwrap_or_else(|_| "/usr/bin/go".to_string());
 }

+pub async fn save_cache(
+    bin_path: &str,
+    job_dir: &str,
+    _hash: &str,
+    job: &QueuedJob,
+    db: &sqlx::Pool<sqlx::Postgres>,
+) -> windmill_common::error::Result<()> {
+    let job_main_path = format!("{job_dir}/main");
+    let mut _cached_to_s3 = false;
+    #[cfg(all(feature = "enterprise", feature = "parquet"))]
+    if let Some(os) = windmill_common::s3_helpers::OBJECT_STORE_CACHE_SETTINGS
+        .read()
+        .await
+        .clone()
+    {
+        use object_store::path::Path;
+
+        let hash_path = hash_to_os_path(_hash);
+        if let Err(e) = os
+            .put(
+                &Path::from(hash_path.clone()),
+                bytes::Bytes::from(std::fs::read(&job_main_path)?),
+            )
+            .await
+        {
+            tracing::error!(
+                "Failed to put go bin to object store: {hash_path}. Error: {:?}",
+                e
+            );
+        } else {
+            _cached_to_s3 = true;
+        }
+    }
+
+    if !*CLOUD_HOSTED {
+        tokio::fs::copy(&job_main_path, bin_path).await?;
+        append_logs(
+            job.id.clone(),
+            job.workspace_id.to_string(),
+            format!(
+                "\nwrite cached binary: {} (backed by object store: {_cached_to_s3})\n",
+                bin_path
+            ),
+            db,
+        )
+        .await;
+    } else if _cached_to_s3 {
+        append_logs(
+            job.id.clone(),
+            job.workspace_id.to_string(),
+            format!("write cached binary to object store {}\n", bin_path),
+            db,
+        )
+        .await;
+    }
+
+    Ok(())
+}
+
+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+async fn write_binary_file(main_path: &str, byts: &mut bytes::Bytes) -> error::Result<()> {
+    use std::fs::Permissions;
+    use std::os::unix::fs::PermissionsExt;
+    use tokio::io::AsyncWriteExt;
+
+    let mut file = File::create(main_path).await?;
+    file.write_buf(byts).await?;
+    file.set_permissions(Permissions::from_mode(0o755)).await?;
+    file.flush().await?;
+    Ok(())
+}
+
+#[cfg(all(feature = "enterprise", feature = "parquet"))]
+fn hash_to_os_path(hash: &str) -> String {
+    format!("gobin/{hash}")
+}
+
+async fn load_cache(bin_path: &str, _hash: &str) -> (bool, String) {
+    if tokio::fs::metadata(&bin_path).await.is_ok() {
+        (true, format!("loaded bin from local cache: {}\n", bin_path))
+    } else {
+        #[cfg(all(feature = "enterprise", feature = "parquet"))]
+        if let Some(os) = windmill_common::s3_helpers::OBJECT_STORE_CACHE_SETTINGS
+            .read()
+            .await
+            .clone()
+        {
+            use windmill_common::s3_helpers::attempt_fetch_bytes;
+
+            if let Ok(mut x) = attempt_fetch_bytes(os, &hash_to_os_path(_hash)).await {
+                if let Err(e) = write_binary_file(bin_path, &mut x).await {
+                    tracing::error!("could not write binary file: {e:?}");
+                    return (
+                        false,
+                        "error writing binary file from object store".to_string(),
+                    );
+                }
+                tracing::info!("loaded bin from object store {}", bin_path);
+                return (true, format!("loaded bin from object store {}", bin_path));
+            }
+        }
+        (false, "".to_string())
+    }
+}
+
 #[tracing::instrument(level = "trace", skip_all)]
 pub async fn handle_go_job(
    mem_peak: &mut i32,
@@ -50,21 +155,19 @@ pub async fn handle_go_job(
 ) -> Result<Box<RawValue>, Error> {
    //go does not like executing modules at temp root
    let job_dir = &format!("{job_dir}/go");
-    let bin_path = format!(
-        "{}/{}",
-        GO_BIN_CACHE_DIR,
-        calculate_hash(&format!(
-            "{}{}",
-            inner_content,
-            requirements_o
-                .as_ref()
-                .map(|x| x.to_string())
-                .unwrap_or_default()
-        ))
-    );
-    let bin_exists = !*CLOUD_HOSTED && tokio::fs::metadata(&bin_path).await.is_ok();
+    let hash = calculate_hash(&format!(
+        "{}{}v2",
+        inner_content,
+        requirements_o
+            .as_ref()
+            .map(|x| x.to_string())
+            .unwrap_or_default()
+    ));
+    let bin_path = format!("{}/{hash}", GO_BIN_CACHE_DIR,);

-    let (skip_go_mod, skip_tidy) = if bin_exists {
+    let (cache, cache_logs) = load_cache(&bin_path, &hash).await;
+
+    let (skip_go_mod, skip_tidy) = if cache {
        create_dir(job_dir).await?;
        (true, true)
    } else if let Some(requirements) = requirements_o {
@@ -73,8 +176,8 @@ pub async fn handle_go_job(
        (false, false)
    };

-    if !bin_exists {
-        let logs1 = "\n\n--- GO DEPENDENCIES SETUP ---\n".to_string();
+    let cache_logs = if !cache {
+        let logs1 = format!("{cache_logs}\n\n--- GO DEPENDENCIES SETUP ---\n");
        append_logs(job.id.clone(), job.workspace_id.to_string(), logs1, db).await;

        install_go_dependencies(
@@ -92,9 +195,6 @@ pub async fn handle_go_job(
        )
        .await?;

-        let logs2 = "\n\n--- GO CODE EXECUTION ---\n".to_string();
-        append_logs(job.id.clone(), job.workspace_id.to_string(), logs2, db).await;
-
        create_args_and_out_file(client, job, job_dir, db).await?;
        {
            let sig = windmill_parser_go::parse_go_sig(&inner_content)?;
@@ -209,33 +309,24 @@ func Run(req Req) (interface{{}}, error){{
        )
        .await?;

-        if !*CLOUD_HOSTED {
-            create_dir(&bin_path).await?;
-            let target = format!("{bin_path}/main");
-            tokio::fs::copy(format!("{job_dir}/main"), &target).await?;
-            append_logs(
-                job.id.clone(),
-                job.workspace_id.to_string(),
-                format!("write cached binary: {}\n", bin_path),
-                db,
-            )
-            .await;
+        if let Err(e) = save_cache(&bin_path, &job_dir, &hash, &job, db).await {
+            tracing::error!("could not save {bin_path} to go cache: {e:?}");
        }
+        "".to_string()
    } else {
-        let path = format!("{bin_path}/main");
-        let mut logs2 = "".to_string();
-        logs2.push_str(&format!("found cached binary: {path}\n"));
        let target = format!("{job_dir}/main");
-        tokio::fs::symlink(&path, &target).await.map_err(|e| {
+        tokio::fs::symlink(&bin_path, &target).await.map_err(|e| {
            Error::ExecutionErr(format!(
-                "could not copy cached binary from {path} to {job_dir}/main: {e:?}"
+                "could not copy cached binary from {bin_path} to {job_dir}/main: {e:?}"
            ))
        })?;

-        logs2.push_str("\n\n--- GO CODE EXECUTION ---\n");
-        append_logs(job.id.clone(), job.workspace_id.to_string(), logs2, db).await;
        create_args_and_out_file(client, job, job_dir, db).await?;
-    }
+        cache_logs
+    };
+
+    let logs2 = format!("{cache_logs}\n\n--- GO CODE EXECUTION ---\n");
+    append_logs(job.id.clone(), job.workspace_id.to_string(), logs2, db).await;

    let client = &client.get_authed().await;

@@ -303,6 +394,13 @@ func Run(req Req) (interface{{}}, error){{
        false,
    )
    .await?;
+
+    if cache && *CLOUD_HOSTED {
+        //do not keep the binary in the cache if it is cloud hosted to avoid filling up the disk
+        if let Err(e) = tokio::fs::remove_file(&bin_path).await {
+            tracing::error!("could not remove {bin_path} from go cache: {e:?}");
+        }
+    }
    read_result(job_dir).await
 }

--- a/backend/windmill-worker/src/js_eval.rs
+++ b/backend/windmill-worker/src/js_eval.rs
@@ -139,14 +139,18 @@ pub async fn eval_timeout(
        }
    }

-    let p_id = by_id.as_ref().map(|x| format!("results.{}", x.previous_id));
-    let p_id2 = by_id
-        .as_ref()
-        .map(|x| format!("results[\"{}\"]", x.previous_id));
+    let p_ids = by_id.as_ref().map(|x| {
+        [
+            format!("results.{}", x.previous_id),
+            format!("results?.{}", x.previous_id),
+            format!("results[\"{}\"]", x.previous_id),
+            format!("results?.[\"{}\"]", x.previous_id),
+        ]
+    });

-    if p_id.is_some()
+    if p_ids.is_some()
        && transform_context.contains_key("previous_result")
-        && &expr == p_id.as_ref().unwrap()
+        && p_ids.as_ref().unwrap().iter().any(|x| x == &expr)
    {
        // tracing::error!("PREVIOUS_RESULT");
        return Ok(transform_context
@@ -156,17 +160,6 @@ pub async fn eval_timeout(
            .clone());
    }

-    if p_id2.is_some()
-        && transform_context.contains_key("previous_result")
-        && &expr == p_id2.as_ref().unwrap()
-    {
-        return Ok(transform_context
-            .get("previous_result")
-            .unwrap()
-            .as_ref()
-            .clone());
-    }
-
    if by_id.is_some() && authed_client.is_some() {
        if let Some(x) = RE_FULL
            .captures(&expr)
@@ -227,10 +220,10 @@ pub async fn eval_timeout(
                .collect_vec();

            if !context_keys.contains(&"previous_result".to_string())
-                && (p_id.is_some() && expr.contains(p_id.as_ref().unwrap()))
+                && (p_ids.is_some() && p_ids.as_ref().unwrap().iter().any(|x| expr.contains(x)))
                || expr.contains("error")
-                || (p_id2.is_some() && expr.contains(p_id2.as_ref().unwrap()))
            {
+                // tracing::error!("PREVIOUS_RESULT");
                context_keys.push("previous_result".to_string());
            }
            let has_flow_input = expr.contains("flow_input");
@@ -586,6 +579,7 @@ pub struct LogString {
 }

 pub async fn eval_fetch_timeout(
+    env_code: String,
    ts_expr: String,
    js_expr: String,
    args: Option<&Json<HashMap<String, Box<RawValue>>>>,
@@ -688,7 +682,7 @@ pub async fn eval_fetch_timeout(

        let future = async {
            tokio::select! {
-                r = eval_fetch(&mut js_runtime, &js_expr) => Ok(r),
+                r = eval_fetch(&mut js_runtime, &js_expr, Some(env_code)) => Ok(r),
                _ = memory_limit_rx.recv() => Err(Error::ExecutionErr("Memory limit reached, killing isolate".to_string()))
            }
        };
@@ -729,11 +723,26 @@ pub async fn eval_fetch_timeout(
    Ok(r)
 }

-async fn eval_fetch(js_runtime: &mut JsRuntime, expr: &str) -> anyhow::Result<Box<RawValue>> {
+const WINDMILL_CLIENT: &str = include_str!("./windmill-client.js");
+
+async fn eval_fetch(
+    js_runtime: &mut JsRuntime,
+    expr: &str,
+    env_code: Option<String>,
+) -> anyhow::Result<Box<RawValue>> {
+    if let Some(env_code) = env_code.as_ref() {
+        let _ = js_runtime
+            .load_side_module(
+                &deno_core::resolve_url("file:///windmill.ts")?,
+                Some(format!("{env_code}\n{}", WINDMILL_CLIENT.to_string()).into()),
+            )
+            .await?;
+    }
+
    let _ = js_runtime
        .load_side_module(
            &deno_core::resolve_url("file:///eval.ts")?,
-            Some(expr.to_string().into()),
+            Some(format!("{}\n{expr}", env_code.unwrap_or_default()).into()),
        )
        .await?;

@@ -774,6 +783,7 @@ fn op_get_static_args(op_state: Rc<RefCell<OpState>>) -> Vec<Option<String>> {

 #[op2(fast)]
 fn op_log(op_state: Rc<RefCell<OpState>>, #[string] log: &str) {
+    // tracing::error!("log: |{}|", log);
    op_state
        .borrow_mut()
        .borrow_mut::<LogString>()
--- a/backend/windmill-worker/src/pg_executor.rs
+++ b/backend/windmill-worker/src/pg_executor.rs
@@ -342,6 +342,7 @@ enum PgType {
    Timestamp(chrono::NaiveDateTime),
    None(Option<bool>),
    Array(Vec<PgType>),
+    Json(serde_json::Value),
 }

 impl ToSql for PgType {
@@ -367,6 +368,7 @@ impl ToSql for PgType {
            PgType::Timestamp(ref val) => val.to_sql(ty, out),
            PgType::None(ref val) => val.to_sql(ty, out),
            PgType::Array(ref val) => val.to_sql(ty, out),
+            PgType::Json(ref val) => val.to_sql(ty, out),
        }
    }

@@ -429,7 +431,7 @@ fn convert_val(value: &Value, arg_t: &String, typ: &Typ) -> windmill_common::err
                chrono::NaiveDate::parse_from_str(s, "%Y-%m-%dT%H:%M:%S.%3fZ").unwrap_or_default();
            Ok(PgType::Date(date))
        }
-        Value::String(s) if arg_t == "time" => {
+        Value::String(s) if arg_t == "time" || arg_t == "timetz" => {
            let time =
                chrono::NaiveTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S.%3fZ").unwrap_or_default();
            Ok(PgType::Time(time))
@@ -439,6 +441,7 @@ fn convert_val(value: &Value, arg_t: &String, typ: &Typ) -> windmill_common::err
                .unwrap_or_default();
            Ok(PgType::Timestamp(datetime))
        }
+        Value::Object(_) => Ok(PgType::Json(value.clone())),
        Value::String(s) => Ok(PgType::String(s.clone())),
        _ => Err(Error::ExecutionErr(format!(
            "Unsupported type in query: {:?} and signature {arg_t:?}",
--- a/backend/windmill-worker/src/python_executor.rs
+++ b/backend/windmill-worker/src/python_executor.rs
@@ -472,7 +472,13 @@ async fn prepare_wrapper(

    let relative_imports = RELATIVE_IMPORT_REGEX.is_match(&inner_content);

-    let script_path_splitted = script_path.split("/");
+    let script_path_splitted = script_path.split("/").map(|x| {
+        if x.starts_with(|x: char| x.is_ascii_digit()) {
+            format!("_{}", x)
+        } else {
+            x.to_string()
+        }
+    });
    let dirs_full = script_path_splitted
        .clone()
        .take(script_path_splitted.clone().count() - 1)
@@ -497,12 +503,6 @@ async fn prepare_wrapper(
    let module_dir = format!("{}/{}", job_dir, dirs);
    tokio::fs::create_dir_all(format!("{module_dir}/")).await?;

-    let last = if last.starts_with(|x: char| x.is_ascii_digit()) {
-        format!("_{}", last)
-    } else {
-        last
-    };
-
    let _ = write_file(&module_dir, &format!("{last}.py"), inner_content).await?;
    if relative_imports {
        let _ = write_file(job_dir, "loader.py", RELATIVE_PYTHON_LOADER).await?;
@@ -1178,6 +1178,10 @@ for line in sys.stdin:
    proc_envs.insert("PYTHONPATH".to_string(), additional_python_paths_folders);
    proc_envs.insert("PATH".to_string(), PATH_ENV.to_string());
    proc_envs.insert("TZ".to_string(), TZ_ENV.to_string());
+    proc_envs.insert(
+        "BASE_INTERNAL_URL".to_string(),
+        base_internal_url.to_string(),
+    );
    proc_envs.insert("BASE_URL".to_string(), base_internal_url.to_string());
    handle_dedicated_process(
        &*PYTHON_PATH,
@@ -1193,6 +1197,8 @@ for line in sys.stdin:
        jobs_rx,
        worker_name,
        db,
+        script_path,
+        "python",
    )
    .await
 }
--- a/backend/windmill-worker/src/runtime.js
+++ b/backend/windmill-worker/src/runtime.js
@@ -34,8 +34,10 @@ globalThis.URLSearchParams = url.URLSearchParams;
 globalThis.Headers = headers.Headers;
 globalThis.FileReader = fileReader.FileReader;
 globalThis.console = new console.Console((msg, level) =>
-  globalThis.Deno.core.ops.op_log([msg])
+  globalThis.Deno.core.ops.op_log(msg)
 );
+globalThis.AbortController = abortSignal.AbortController;
+globalThis.AbortSignal = abortSignal.AbortSignal;
 // Object.assign(globalThis, {
 //   console: nonEnumerable(
 //     new console.Console((msg, level) => core.print(msg, level > 1))
@@ -122,8 +124,8 @@ globalThis.console = new console.Console((msg, level) =>
 //   FormData: nonEnumerable(formData.FormData),

 //   // abort signal
-//   AbortController: nonEnumerable(abortSignal.AbortController),
-//   AbortSignal: nonEnumerable(abortSignal.AbortSignal),
+// AbortController: nonEnumerable(abortSignal.AbortController),
+// AbortSignal: nonEnumerable(abortSignal.AbortSignal),

 //   //   // web sockets
 //   //   WebSocket: nonEnumerable(webSocket.WebSocket),
--- a/backend/windmill-worker/src/windmill-client.js
+++ b/backend/windmill-worker/src/windmill-client.js
--- a/backend/windmill-worker/src/worker.rs
+++ b/backend/windmill-worker/src/worker.rs
@@ -6,6 +6,8 @@
 * LICENSE-AGPL for a copy of the license.
 */

+use windmill_common::worker::TMP_DIR;
+
 use anyhow::Result;
 use const_format::concatcp;
 #[cfg(feature = "prometheus")]
@@ -41,7 +43,7 @@ use windmill_common::{
    flows::{FlowModule, FlowModuleValue, FlowValue},
    get_latest_deployed_hash_for_path,
    jobs::{JobKind, JobPayload, QueuedJob},
-    scripts::{get_full_hub_script_by_path, ScriptHash, ScriptLang},
+    scripts::{get_full_hub_script_by_path, ScriptHash, ScriptLang, PREVIEW_IS_CODEBASE_HASH},
    users::{SUPERADMIN_NOTIFICATION_EMAIL, SUPERADMIN_SECRET_EMAIL, SUPERADMIN_SYNC_EMAIL},
    utils::{rd_string, StripPath},
    worker::{
@@ -89,8 +91,8 @@ use crate::{
    bash_executor::{handle_bash_job, handle_powershell_job, ANSI_ESCAPE_RE},
    bun_executor::{gen_lockfile, get_trusted_deps, handle_bun_job},
    common::{
-        build_args_map, get_cached_resource_value_if_valid, hash_args, read_result, save_in_cache,
-        write_file, NO_LOGS_AT_ALL, SLOW_LOGS,
+        build_args_map, get_cached_resource_value_if_valid, get_reserved_variables, hash_args,
+        read_result, save_in_cache, write_file, NO_LOGS_AT_ALL, SLOW_LOGS,
    },
    deno_executor::{generate_deno_lock, handle_deno_job},
    go_executor::{handle_go_job, install_go_dependencies},
@@ -185,10 +187,9 @@ pub async fn create_token_for_owner(
    Ok(token)
 }

-pub const TMP_DIR: &str = "/tmp/windmill";
-pub const TMP_LOGS_DIR: &str = "/tmp/windmill/logs";
+pub const TMP_LOGS_DIR: &str = concatcp!(TMP_DIR, "/logs");

-pub const ROOT_CACHE_DIR: &str = "/tmp/windmill/cache/";
+pub const ROOT_CACHE_DIR: &str = concatcp!(TMP_DIR, "/cache/");
 pub const LOCK_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "lock");
 pub const PIP_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "pip");
 pub const TAR_PIP_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "tar/pip");
@@ -198,6 +199,7 @@ pub const DENO_CACHE_DIR_NPM: &str = concatcp!(ROOT_CACHE_DIR, "deno/npm");

 pub const GO_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "go");
 pub const BUN_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "bun");
+
 pub const HUB_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "hub");
 pub const GO_BIN_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "gobin");
 pub const POWERSHELL_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "powershell");
@@ -606,7 +608,6 @@ pub async fn run_worker<R: rsmq_async::RsmqConnection + Send + Sync + Clone + 's
        );
    }

-    #[cfg(feature = "prometheus")]
    let start_time = Instant::now();

    let worker_dir = format!("{TMP_DIR}/{worker_name}");
@@ -918,6 +919,8 @@ pub async fn run_worker<R: rsmq_async::RsmqConnection + Send + Sync + Clone + 's
            None
        };

+    let mut worker_code_execution_metric: f32 = 0.0;
+
    let mut jobs_executed = 0;

    #[cfg(feature = "prometheus")]
@@ -1038,7 +1041,7 @@ pub async fn run_worker<R: rsmq_async::RsmqConnection + Send + Sync + Clone + 's
                    let same_worker_tx2 = same_worker_tx2.clone();
                    let rsmq2 = rsmq2.clone();
                    let worker_name = worker_name2.clone();
-                    if matches!(jc.job.job_kind, JobKind::Noop) || is_dedicated_worker {
+                    if matches!(jc.job.job_kind, JobKind::Noop) {
                        thread_count.fetch_add(1, Ordering::SeqCst);
                        let thread_count = thread_count.clone();

@@ -1130,15 +1133,19 @@ pub async fn run_worker<R: rsmq_async::RsmqConnection + Send + Sync + Clone + 's
                            .await
                            .expect("update config to trigger restart of all dedicated workers at that config");
                                killpill_tx.send(()).unwrap_or_default();
+
                            }
                        });
                    } else {
                        let is_init_script_and_failure =
                            !jc.success && jc.job.tag.as_str() == INIT_SCRIPT_TAG;
+                        let is_dependency_job = matches!(
+                            jc.job.job_kind,
+                            JobKind::Dependencies | JobKind::FlowDependencies);
                        handle_receive_completed_job(
                            jc,
                            base_internal_url2,
-                            db2,
+                            db2.clone(),
                            worker_dir2,
                            same_worker_tx2,
                            rsmq2,
@@ -1152,6 +1159,15 @@ pub async fn run_worker<R: rsmq_async::RsmqConnection + Send + Sync + Clone + 's
                            tracing::error!("init script errored, exiting");
                            killpill_tx2.send(()).unwrap_or_default();
                        }
+                        if is_dependency_job && is_dedicated_worker {
+                            tracing::error!("Dedicated worker executed a dependency job, a new script has been deployed. Exiting expecting to be restarted.");
+                            sqlx::query!("UPDATE config SET config = config WHERE name = $1", format!("worker__{}", *WORKER_GROUP))
+                        .execute(&db2)
+                        .await
+                        .expect("update config to trigger restart of all dedicated workers at that config");
+                            killpill_tx2.send(()).unwrap_or_default();
+
+                        }
                    }
                }
                SendResult::UpdateFlow {
@@ -1373,14 +1389,12 @@ pub async fn run_worker<R: rsmq_async::RsmqConnection + Send + Sync + Clone + 's
            let tags = WORKER_CONFIG.read().await.worker_tags.clone();

            if let Err(e) = sqlx::query!(
-                "UPDATE worker_ping SET ping_at = now(), jobs_executed = $1, custom_tags = $2 WHERE worker = $3",
+                "UPDATE worker_ping SET ping_at = now(), jobs_executed = $1, custom_tags = $2, occupancy_rate = $3, current_job_id = NULL, current_job_workspace_id = NULL WHERE worker = $4",
                jobs_executed,
                tags.as_slice(),
+                worker_code_execution_metric / start_time.elapsed().as_secs_f32(),
                &worker_name
-            )
-            .execute(db)
-            .await
-            {
+            ).execute(db).await {
                tracing::error!("failed to update worker ping, exiting: {}", e);
                killpill_tx.send(()).unwrap_or_default();
            }
@@ -1671,7 +1685,7 @@ pub async fn run_worker<R: rsmq_async::RsmqConnection + Send + Sync + Clone + 's
                    let tag = job.tag.clone();

                    let arc_job = Arc::new(job);
-                    if let Some(err) = handle_queued_job(
+                    if let Err(err) = handle_queued_job(
                        arc_job.clone(),
                        db,
                        &authed_client,
@@ -1682,11 +1696,11 @@ pub async fn run_worker<R: rsmq_async::RsmqConnection + Send + Sync + Clone + 's
                        base_internal_url,
                        rsmq.clone(),
                        job_completed_tx.clone(),
+                        &mut worker_code_execution_metric,
                        worker_flow_initial_transition_duration.clone(),
                        worker_code_execution_duration.clone(),
                    )
                    .await
-                    .err()
                    {
                        let is_init_script = arc_job.tag.as_str() == INIT_SCRIPT_TAG;
                        handle_job_error(
@@ -2026,18 +2040,21 @@ async fn spawn_dedicated_worker(
            SpawnWorker::RawScript { path, .. } => path.to_string(),
            SpawnWorker::Script { path, .. } => path.to_string(),
        };
+
        let path2 = path.clone();
        let w_id = w_id.to_string();

-        let (content, lock, language, envs) = match sw {
+        let (content, lock, language, envs, codebase) = match sw {
            SpawnWorker::Script { path, hash } => {
                let q = if let Some(hash) = hash {
                    get_script_content_by_hash(&hash, &w_id, &db).await.map(
-                        |r: ContentReqLangEnvs| Some((r.content, r.lockfile, r.language, r.envs)),
+                        |r: ContentReqLangEnvs| {
+                            Some((r.content, r.lockfile, r.language, r.envs, r.codebase))
+                        },
                    )
                } else {
-                    sqlx::query_as::<_, (String, Option<String>, Option<ScriptLang>, Option<Vec<String>>)>(
-                        "SELECT content, lock, language, envs FROM script WHERE path = $1 AND workspace_id = $2 AND
+                    sqlx::query_as::<_, (String, Option<String>, Option<ScriptLang>, Option<Vec<String>>, bool, Option<ScriptHash>)>(
+                        "SELECT content, lock, language, envs, codebase IS NOT NULL, hash FROM script WHERE path = $1 AND workspace_id = $2 AND
                            created_at = (SELECT max(created_at) FROM script WHERE path = $1 AND workspace_id = $2 AND
                            deleted = false AND lock IS not NULL AND lock_error_logs IS NULL)",
                    )
@@ -2046,6 +2063,7 @@ async fn spawn_dedicated_worker(
                    .fetch_optional(&db)
                    .await
                    .map_err(|e| Error::InternalErr(format!("expected content and lock: {e}")))
+                    .map(|x| x.map(|y| (y.0, y.1, y.2, y.3, if y.4 { y.5.map(|z| z.to_string()) } else { None })))
                };
                if let Ok(q) = q {
                    if let Some(wp) = q {
@@ -2064,7 +2082,9 @@ async fn spawn_dedicated_worker(
                    return None;
                }
            }
-            SpawnWorker::RawScript { content, lock, lang, .. } => (content, lock, Some(lang), None),
+            SpawnWorker::RawScript { content, lock, lang, .. } => {
+                (content, lock, Some(lang), None, None)
+            }
        };

        match language {
@@ -2119,6 +2139,7 @@ async fn spawn_dedicated_worker(
                Some(ScriptLang::Bun) => {
                    crate::bun_executor::start_worker(
                        lock,
+                        codebase,
                        &db,
                        &content,
                        &base_internal_url,
@@ -2155,6 +2176,9 @@ async fn spawn_dedicated_worker(
            } {
                tracing::error!("error in dedicated worker: {:?}", e);
            };
+            if let Err(e) = killpill_tx.clone().send(()) {
+                tracing::error!("failed to send final killpill to dedicated worker: {:?}", e);
+            }
        });
        return Some((node_id.unwrap_or(path2), dedicated_worker_tx, Some(handle)));
        // (Some(dedi_path), Some(dedicated_worker_tx), Some(handle))
@@ -2174,6 +2198,7 @@ async fn queue_init_bash_maybe<'c, R: rsmq_async::RsmqConnection + Send + 'c>(
            tx,
            "admins",
            windmill_common::jobs::JobPayload::Code(windmill_common::jobs::RawCode {
+                hash: None,
                content: content.clone(),
                path: Some(format!("init_script_{worker_name}")),
                language: ScriptLang::Bash,
@@ -2532,6 +2557,7 @@ pub struct JobCompleted {
 async fn do_nativets(
    job: &QueuedJob,
    client: &AuthedClientBackgroundTask,
+    env_code: String,
    code: String,
    db: &Pool<Postgres>,
    mem_peak: &mut i32,
@@ -2546,6 +2572,7 @@ async fn do_nativets(
    };

    let result = eval_fetch_timeout(
+        env_code,
        code.clone(),
        transpile_ts(code)?,
        job_args,
@@ -2579,6 +2606,7 @@ async fn handle_queued_job<R: rsmq_async::RsmqConnection + Send + Sync + Clone>(
    base_internal_url: &str,
    rsmq: Option<R>,
    job_completed_tx: JobCompletedSender,
+    worker_code_execution_metric: &mut f32,
    _worker_flow_initial_transition_duration: Option<Histo>,
    _worker_code_execution_duration: Option<Histo>,
 ) -> windmill_common::error::Result<()> {
@@ -2805,6 +2833,7 @@ async fn handle_queued_job<R: rsmq_async::RsmqConnection + Send + Sync + Clone>(
            _ => {
                #[cfg(feature = "prometheus")]
                let timer = _worker_code_execution_duration.map(|x| x.start_timer());
+                let metric_timer = Instant::now();
                let r = handle_code_execution_job(
                    job.as_ref(),
                    db,
@@ -2818,6 +2847,7 @@ async fn handle_queued_job<R: rsmq_async::RsmqConnection + Send + Sync + Clone>(
                    &mut column_order,
                )
                .await;
+                *worker_code_execution_metric += metric_timer.elapsed().as_secs_f32();
                #[cfg(feature = "prometheus")]
                timer.map(|x| x.stop_and_record());
                r
@@ -2828,6 +2858,14 @@ async fn handle_queued_job<R: rsmq_async::RsmqConnection + Send + Sync + Clone>(
        if job.as_ref().workspace_id == "" {
            return Ok(());
        }
+
+        if result
+            .as_ref()
+            .is_err_and(|err| matches!(err, &Error::AlreadyCompleted(_)))
+        {
+            return Ok(());
+        }
+
        process_result(
            job,
            result,
@@ -2972,6 +3010,7 @@ struct ContentReqLangEnvs {
    lockfile: Option<String>,
    language: Option<ScriptLang>,
    envs: Option<Vec<String>>,
+    codebase: Option<String>,
 }

 async fn get_hub_script_content_and_requirements(
@@ -3008,6 +3047,7 @@ async fn get_hub_script_content_and_requirements(
        lockfile: script.lockfile,
        language: Some(script.language),
        envs: None,
+        codebase: None,
    })
 }

@@ -3040,16 +3080,27 @@ async fn get_script_content_by_hash(
            Option<String>,
            Option<ScriptLang>,
            Option<Vec<String>>,
+            bool,
        ),
    >(
-        "SELECT content, lock, language, envs FROM script WHERE hash = $1 AND workspace_id = $2",
+        "SELECT content, lock, language, envs, codebase IS NOT NULL FROM script WHERE hash = $1 AND workspace_id = $2",
    )
    .bind(script_hash.0)
    .bind(w_id)
    .fetch_optional(db)
    .await?
    .ok_or_else(|| Error::InternalErr(format!("expected content and lock")))?;
-    Ok(ContentReqLangEnvs { content: r.0, lockfile: r.1, language: r.2, envs: r.3 })
+    Ok(ContentReqLangEnvs {
+        content: r.0,
+        lockfile: r.1,
+        language: r.2,
+        envs: r.3,
+        codebase: if r.4 {
+            Some(script_hash.to_string())
+        } else {
+            None
+        },
+    })
 }

 #[tracing::instrument(level = "trace", skip_all)]
@@ -3065,35 +3116,48 @@ async fn handle_code_execution_job(
    worker_name: &str,
    column_order: &mut Option<Vec<String>>,
 ) -> error::Result<Box<RawValue>> {
-    let ContentReqLangEnvs { content: inner_content, lockfile: requirements_o, language, envs } =
-        match job.job_kind {
-            JobKind::Preview => ContentReqLangEnvs {
-                content: job
-                    .raw_code
-                    .clone()
-                    .unwrap_or_else(|| "no raw code".to_owned()),
-                lockfile: job.raw_lock.clone(),
-                language: job.language.to_owned(),
-                envs: None,
+    let ContentReqLangEnvs {
+        content: inner_content,
+        lockfile: requirements_o,
+        language,
+        envs,
+        codebase,
+    } = match job.job_kind {
+        JobKind::Preview => ContentReqLangEnvs {
+            content: job
+                .raw_code
+                .clone()
+                .unwrap_or_else(|| "no raw code".to_owned()),
+            lockfile: job.raw_lock.clone(),
+            language: job.language.to_owned(),
+            envs: None,
+            codebase: if job
+                .script_hash
+                .is_some_and(|y| y.0 == PREVIEW_IS_CODEBASE_HASH)
+            {
+                Some(job.id.to_string())
+            } else {
+                None
            },
-            JobKind::Script_Hub => {
-                get_hub_script_content_and_requirements(job.script_path.clone(), db).await?
-            }
-            JobKind::Script => {
-                get_script_content_by_hash(
-                    &job.script_hash.unwrap_or(ScriptHash(0)),
-                    &job.workspace_id,
-                    db,
-                )
-                .await?
-            }
-            JobKind::DeploymentCallback => {
-                get_script_content_by_path(job.script_path.clone(), &job.workspace_id, db).await?
-            }
-            _ => unreachable!(
-                "handle_code_execution_job should never be reachable with a non-code execution job"
-            ),
-        };
+        },
+        JobKind::Script_Hub => {
+            get_hub_script_content_and_requirements(job.script_path.clone(), db).await?
+        }
+        JobKind::Script => {
+            get_script_content_by_hash(
+                &job.script_hash.unwrap_or(ScriptHash(0)),
+                &job.workspace_id,
+                db,
+            )
+            .await?
+        }
+        JobKind::DeploymentCallback => {
+            get_script_content_by_path(job.script_path.clone(), &job.workspace_id, db).await?
+        }
+        _ => unreachable!(
+            "handle_code_execution_job should never be reachable with a non-code execution job"
+        ),
+    };

    if language == Some(ScriptLang::Postgresql) {
        return do_postgresql(
@@ -3203,13 +3267,27 @@ async fn handle_code_execution_job(
            db,
        )
        .await;
-        let code = format!(
-            "const BASE_URL = '{base_internal_url}';\nconst WM_TOKEN = '{}';\n{}",
-            &client.get_token().await,
-            inner_content
-        );
-        let (result, ts_logs) =
-            do_nativets(job, &client, code, db, mem_peak, canceled_by, worker_name).await?;
+
+        let reserved_variables = get_reserved_variables(job, &client.get_token().await, db).await?;
+
+        let env_code = format!(
+            "const process = {{ env: {{}} }};\nconst BASE_URL = '{base_internal_url}';\nconst BASE_INTERNAL_URL = '{base_internal_url}';\nprocess.env['BASE_URL'] = BASE_URL;process.env['BASE_INTERNAL_URL'] = BASE_INTERNAL_URL;\n{}",
+            reserved_variables
+                .iter()
+                .map(|(k, v)| format!("const {} = '{}';\nprocess.env['{}'] = '{}';\n", k, v, k, v))
+                .collect::<Vec<String>>()
+                .join("\n"));
+        let (result, ts_logs) = do_nativets(
+            job,
+            &client,
+            env_code,
+            inner_content,
+            db,
+            mem_peak,
+            canceled_by,
+            worker_name,
+        )
+        .await?;
        append_logs(job.id, job.workspace_id.clone(), ts_logs, db).await;
        return Ok(result);
    }
@@ -3289,6 +3367,7 @@ mount {{
        Some(ScriptLang::Bun) => {
            handle_bun_job(
                requirements_o,
+                codebase,
                mem_peak,
                canceled_by,
                job,
@@ -3938,6 +4017,14 @@ async fn lock_modules_app(
                                .unwrap_or_default()
                                .to_string();
                            let mut logs = "".to_string();
+                            if v.get("lock")
+                                .is_some_and(|x| !x.as_str().unwrap().trim().is_empty())
+                            {
+                                logs.push_str(
+                                    "Found already locked inline script. Skipping lock...\n",
+                                );
+                                return Ok(Value::Object(m.clone()));
+                            }
                            logs.push_str("Found lockable inline script. Generating lock...\n");
                            let new_lock = capture_dependency_job(
                                &job.id,
--- a/backend/windmill-worker/src/worker_flow.rs
+++ b/backend/windmill-worker/src/worker_flow.rs
@@ -42,6 +42,7 @@ use windmill_common::{
    },
    flows::{FlowModule, FlowModuleValue, FlowValue, InputTransform, Retry, Suspend},
 };
+use windmill_queue::schedule::get_schedule_opt;
 use windmill_queue::{
    add_completed_job, add_completed_job_error, append_logs, get_queued_job,
    handle_maybe_scheduled_job, CanceledBy, PushIsolationLevel, WrappedError,
@@ -931,7 +932,7 @@ fn get_module(flow_job: &QueuedJob, module_index: Option<usize>) -> Option<FlowM
            if let Some(module) = raw_flow.modules.get(i) {
                Some(module.clone())
            } else {
-                raw_flow.failure_module
+                raw_flow.failure_module.map(|x| *x.clone())
            }
        } else {
            None
@@ -1201,23 +1202,37 @@ pub async fn handle_flow<R: rsmq_async::RsmqConnection + Send + Sync + Clone>(
        && flow_job.script_path.is_some()
        && status.step == 0
    {
-        let tx: QueueTransaction<'_, R> = (rsmq.clone(), db.begin().await?).into();
+        let mut tx: QueueTransaction<'_, R> = (rsmq.clone(), db.begin().await?).into();

-        match handle_maybe_scheduled_job(
-            tx,
-            db,
-            flow_job.schedule_path.as_ref().unwrap(),
-            flow_job.script_path.as_ref().unwrap(),
-            &flow_job.workspace_id,
-        )
-        .await
-        {
-            Ok(tx) => {
-                tx.commit().await?;
-            }
-            Err(e) => {
-                tracing::error!("Error during handle_maybe_scheduled_job: {e}");
-            }
+        let schedule_path = flow_job.schedule_path.as_ref().unwrap();
+
+        let schedule =
+            get_schedule_opt(tx.transaction_mut(), &flow_job.workspace_id, schedule_path).await?;
+
+        tx.commit().await?;
+
+        if let Some(schedule) = schedule {
+            if let Err(err) = handle_maybe_scheduled_job(
+                rsmq.clone(),
+                db,
+                flow_job,
+                &schedule,
+                flow_job.script_path.as_ref().unwrap(),
+                &flow_job.workspace_id,
+            )
+            .await
+            {
+                match err {
+                    Error::QuotaExceeded(_) => return Err(err.into()),
+                    // scheduling next job failed and could not disable schedule => make zombie job to retry
+                    _ => return Ok(()),
+                }
+            };
+        } else {
+            tracing::error!(
+                "Schedule {schedule_path} in {} not found. Impossible to schedule again",
+                &flow_job.workspace_id
+            );
        }
    }

@@ -1674,7 +1689,7 @@ async fn push_next_flow_job<R: rsmq_async::RsmqConnection + Send + Sync + Clone>
    let mut module: &FlowModule = flow
        .modules
        .get(i)
-        .or_else(|| flow.failure_module.as_ref())
+        .or_else(|| flow.failure_module.as_deref())
        .with_context(|| format!("no module at index {}", status.step))?;

    let current_id = &module.id;
@@ -3109,6 +3124,7 @@ fn raw_script_to_payload(
 ) -> JobPayloadWithTag {
    JobPayloadWithTag {
        payload: JobPayload::Code(RawCode {
+            hash: None,
            path,
            content: content.clone(),
            language: language.clone(),
--- a/benchmarks/lib.ts
+++ b/benchmarks/lib.ts
@@ -2,7 +2,7 @@ import { sleep } from "https://deno.land/x/sleep@v1.2.1/mod.ts";
 import * as windmill from "https://deno.land/x/windmill@v1.174.0/mod.ts";
 import * as api from "https://deno.land/x/windmill@v1.174.0/windmill-api/index.ts";

-export const VERSION = "v1.317.1";
+export const VERSION = "v1.327.0";

 export async function login(email: string, password: string): Promise<string> {
  return await windmill.UserService.login({
--- a/cli/apps.ts
+++ b/cli/apps.ts
@@ -5,15 +5,13 @@ import {
  colors,
  Command,
  ListableApp,
+  log,
  Policy,
+  SEP,
  Table,
+  yamlParse,
 } from "./deps.ts";
-import {
-  GlobalOptions,
-  isSuperset,
-  parseFromFile,
-  removeType,
-} from "./types.ts";
+import { GlobalOptions, isSuperset } from "./types.ts";

 export interface AppFile {
  value: any;
@@ -21,14 +19,20 @@ export interface AppFile {
  policy: Policy;
 }

+const alreadySynced: string[] = [];
+
 export async function pushApp(
  workspace: string,
-  filePath: string,
-  app: AppFile | undefined,
-  newApp: AppFile,
+  remotePath: string,
+  localPath: string,
  message?: string
 ): Promise<void> {
-  const remotePath = removeType(filePath, "app");
+  if (alreadySynced.includes(localPath)) {
+    return;
+  }
+  alreadySynced.push(localPath);
+
+  let app: any = undefined;
  // deleting old app if it exists in raw mode
  try {
    app = await AppService.getAppByPath({
@@ -39,28 +43,61 @@ export async function pushApp(
    //ignore
  }

-  if (app) {
-    if (isSuperset(newApp, app)) {
+  if (!localPath.endsWith(SEP)) {
+    localPath += SEP;
+  }
+  const localAppRaw = await Deno.readTextFile(localPath + "app.yaml");
+  const localApp = yamlParse(localAppRaw) as AppFile;
+
+  function replaceInlineScripts(rec: any) {
+    if (!rec) {
      return;
    }
+    if (typeof rec == "object") {
+      return Object.entries(rec).flatMap(([k, v]) => {
+        if (k == "inlineScript" && typeof v == "object") {
+          const o: Record<string, any> = v as any;
+          if (o["content"] && o["content"].startsWith("!inline")) {
+            const basePath = localPath + o["content"].split(" ")[1];
+            o["content"] = Deno.readTextFileSync(basePath);
+          }
+          if (o["lock"] && o["lock"].startsWith("!inline")) {
+            const basePath = localPath + o["lock"].split(" ")[1];
+            o["lock"] = Deno.readTextFileSync(basePath);
+          }
+        } else {
+          replaceInlineScripts(v);
+        }
+      });
+    }
+    return [];
+  }
+
+  replaceInlineScripts(localApp.value);
+
+  if (app) {
+    if (isSuperset(localApp, app)) {
+      log.info(colors.green(`App ${remotePath} is up to date`));
+      return;
+    }
+    log.info(colors.bold.yellow(`Updating app ${remotePath}...`));
    await AppService.updateApp({
      workspace,
      path: remotePath.replaceAll("\\", "/"),
      requestBody: {
        deployment_message: message,
-        ...newApp,
+        ...localApp,
      },
    });
  } else {
-    console.log(colors.yellow.bold("Creating new app..."));
+    log.info(colors.yellow.bold("Creating new app..."));

-    console.log(message);
    await AppService.createApp({
      workspace,
      requestBody: {
        path: remotePath.replaceAll("\\", "/"),
        deployment_message: message,
-        ...newApp,
+        ...localApp,
      },
    });
  }
@@ -94,32 +131,22 @@ async function list(opts: GlobalOptions) {
    .render();
 }

-async function push(opts: GlobalOptions, filePath: string) {
-  const remotePath = filePath.split(".")[0];
+async function push(opts: GlobalOptions, filePath: string, remotePath: string) {
  if (!validatePath(remotePath)) {
    return;
  }
  const workspace = await resolveWorkspace(opts);
  await requireLogin(opts);

-<<<<<<< Updated upstream
-  await pushApp(
-    workspace.workspaceId,
-    filePath,
-    undefined,
-    parseFromFile(filePath)
-  );
-=======
-  await pushApp(workspace.workspaceId, filePath, parseFromFile(filePath));
->>>>>>> Stashed changes
-  console.log(colors.bold.underline.green("App pushed"));
+  await pushApp(workspace.workspaceId, remotePath, filePath);
+  log.info(colors.bold.underline.green("Flow pushed"));
 }

 const command = new Command()
  .description("app related commands")
  .action(list as any)
  .command("push", "push a local app ")
-  .arguments("<file_path:file>")
+  .arguments("<file_path:string> <remote_path:string>")
  .action(push as any);

 export default command;
--- a/cli/codebase.ts
+++ b/cli/codebase.ts
@@ -0,0 +1,21 @@
+import { Codebase, SyncOptions } from "./conf.ts";
+import { log } from "./deps.ts";
+import { digestDir } from "./utils.ts";
+
+export type SyncCodebase = Codebase & { digest: string };
+export async function listSyncCodebases(
+  options: SyncOptions
+): Promise<SyncCodebase[]> {
+  const res: SyncCodebase[] = [];
+  const nb_codebase = options?.codebases?.length ?? 0;
+  if (nb_codebase > 0) {
+    log.info(`Found ${nb_codebase} codebases:`);
+  }
+  for (const codebase of options?.codebases ?? []) {
+    const digest = await digestDir(codebase.relative_path);
+    log.info(`Codebase ${codebase.relative_path}, digest: ${digest}`);
+    res.push({ ...codebase, digest });
+  }
+
+  return res;
+}
--- a/cli/conf.ts
+++ b/cli/conf.ts
@@ -20,6 +20,13 @@ export interface SyncOptions {
  extraIncludes?: string[];
  excludes?: string[];
  defaultTs?: "bun" | "deno";
+  codebases?: Codebase[];
+}
+
+export interface Codebase {
+  relative_path: string;
+  includes?: string[];
+  excludes?: string[];
 }

 export async function readConfigFile(): Promise<SyncOptions> {
--- a/cli/deps.ts
+++ b/cli/deps.ts
@@ -1,6 +1,5 @@
 // windmill
-export { setClient } from "npm:windmill-client@1.304.2";
-export * from "npm:windmill-client@1.304.2";
+export * from "npm:windmill-client@1.319.1";

 // cliffy
 export { Command } from "https://deno.land/x/cliffy@v1.0.0-rc.4/command/mod.ts";
@@ -28,6 +27,11 @@ export { DelimiterStream } from "https://deno.land/std@0.207.0/streams/mod.ts";
 export { iterateReader } from "https://deno.land/std@0.207.0/streams/iterate_reader.ts";
 export { writeAllSync } from "https://deno.land/std@0.207.0/streams/mod.ts";
 export { encodeHex } from "https://deno.land/std@0.207.0/encoding/hex.ts";
+export * as log from "https://deno.land/std@0.207.0/log/mod.ts";
+export {
+  stringify as yamlStringify,
+  parse as yamlParse,
+} from "https://deno.land/std@0.207.0/yaml/mod.ts";

 // other
 export { Application, Router } from "https://deno.land/x/oak@v12.5.0/mod.ts";
@@ -43,10 +47,6 @@ export { default as microdiff } from "https://deno.land/x/microdiff@v1.3.1/index
 export { default as objectHash } from "https://deno.land/x/object_hash@2.0.3.1/mod.ts";
 export { minimatch } from "npm:minimatch";
 export { default as JSZip } from "npm:jszip@3.7.1";
-export * as log from "https://deno.land/std@0.186.0/log/mod.ts";
-export {
-  stringify as yamlStringify,
-  parse as yamlParse,
-} from "https://deno.land/std@0.184.0/yaml/mod.ts";
+
 export { open } from "https://deno.land/x/open@v0.0.5/index.ts";
 export { default as gitignore_parser } from "npm:gitignore-parser";
--- a/cli/flow.ts
+++ b/cli/flow.ts
@@ -27,13 +27,13 @@ const alreadySynced: string[] = [];
 export async function pushFlow(
  workspace: string,
  remotePath: string,
-  localFlowPath: string,
+  localPath: string,
  message?: string
 ): Promise<void> {
-  if (alreadySynced.includes(localFlowPath)) {
+  if (alreadySynced.includes(localPath)) {
    return;
  }
-  alreadySynced.push(localFlowPath);
+  alreadySynced.push(localPath);
  let flow: Flow | undefined = undefined;
  try {
    flow = await FlowService.getFlowByPath({
@@ -44,19 +44,35 @@ export async function pushFlow(
    // flow doesn't exist
  }

-  if (!localFlowPath.endsWith(SEP)) {
-    localFlowPath += SEP;
+  if (!localPath.endsWith(SEP)) {
+    localPath += SEP;
  }
-  const localFlowRaw = await Deno.readTextFile(localFlowPath + "flow.yaml");
+  const localFlowRaw = await Deno.readTextFile(localPath + "flow.yaml");
  const localFlow = yamlParse(localFlowRaw) as FlowFile;

  function replaceInlineScripts(modules: FlowModule[]) {
    modules.forEach((m) => {
      if (m.value.type == "rawscript") {
        const path = m.value.content.split(" ")[1];
-        m.value.content = Deno.readTextFileSync(localFlowPath + path);
+        m.value.content = Deno.readTextFileSync(localPath + path);
+        const lock = m.value.lock;
+
+        if (
+          lock &&
+          typeof lock == "string" &&
+          lock.trimStart().startsWith("!inline ")
+        ) {
+          const path = lock.split(" ")[1];
+          try {
+            m.value.lock = Deno.readTextFileSync(localPath + path);
+          } catch {
+            log.error(`Lock file ${path} not found`);
+          }
+        }
      } else if (m.value.type == "forloopflow") {
        replaceInlineScripts(m.value.modules);
+      } else if (m.value.type == "whileloopflow") {
+        replaceInlineScripts(m.value.modules);
      } else if (m.value.type == "branchall") {
        m.value.branches.forEach((b) => replaceInlineScripts(b.modules));
      } else if (m.value.type == "branchone") {
@@ -194,12 +210,15 @@ async function run(
  log.info(jobInfo.result ?? {});
 }

-export function bootstrap(opts: GlobalOptions & {summary: string, description: string}, flowPath: string) {
+export function bootstrap(
+  opts: GlobalOptions & { summary: string; description: string },
+  flowPath: string
+) {
  if (!validatePath(flowPath)) {
    return;
  }

-  const flowDirFullPath = `${flowPath}.flow`
+  const flowDirFullPath = `${flowPath}.flow`;
  Deno.mkdirSync(flowDirFullPath, { recursive: false });

  const newFlowDefinition = defaultFlowDefinition();
@@ -210,13 +229,12 @@ export function bootstrap(opts: GlobalOptions & {summary: string, description: s
    newFlowDefinition.description = opts.description;
  }

-  const newFlowDefinitionYaml = yamlStringify(newFlowDefinition as Record<string, any>);
+  const newFlowDefinitionYaml = yamlStringify(
+    newFlowDefinition as Record<string, any>
+  );

  const flowYamlPath = `${flowDirFullPath}/flow.yaml`;
-  Deno.writeTextFile(
-    flowYamlPath,
-    newFlowDefinitionYaml,
-    { createNew: true });
+  Deno.writeTextFile(flowYamlPath, newFlowDefinitionYaml, { createNew: true });
 }

 const command = new Command()
--- a/cli/hub.ts
+++ b/cli/hub.ts
@@ -17,16 +17,16 @@ async function pull(opts: GlobalOptions) {

  const userInfo = await requireLogin(opts);

-  const uid = await SettingService.getGlobal({
+  const uid = (await SettingService.getGlobal({
    key: "uid",
-  });
+  })) as string;

  const hubBaseUrl =
    (await SettingService.getGlobal({
      key: "hubBaseUrl",
    })) ?? "https://hub.windmill.dev";

-  const headers = {
+  const headers: Record<string, string> = {
    Accept: "application/json",
    "X-email": userInfo.email,
  };
@@ -99,8 +99,7 @@ async function pull(opts: GlobalOptions) {
      workspace.workspaceId,
      x.name + ".resource-type.json",
      undefined,
-      x,
-      true
+      x
    );
  }
 }
--- a/cli/main.ts
+++ b/cli/main.ts
@@ -3,7 +3,9 @@ import {
  CompletionsCommand,
  DenoLandProvider,
  UpgradeCommand,
+  colors,
  log,
+  yamlStringify,
 } from "./deps.ts";
 import flow from "./flow.ts";
 import app from "./apps.ts";
@@ -31,7 +33,7 @@ addEventListener("error", (event) => {
  }
 });

-export const VERSION = "v1.317.1";
+export const VERSION = "v1.327.0";

 let command: any = new Command()
  .name("wmill")
@@ -58,6 +60,23 @@ let command: any = new Command()
    "Specify headers to use for all requests. e.g: \"HEADERS='h1: v1, h2: v2'\""
  )
  .version(VERSION)
+  .command("init", "Bootstrap a windmill project with a wmill.yaml file")
+  .action(async () => {
+    if (await Deno.stat("wmill.yaml").catch(() => null)) {
+      log.error(colors.red("wmill.yaml already exists"));
+      return;
+    }
+    await Deno.writeTextFile(
+      "wmill.yaml",
+      yamlStringify({
+        defaultTs: "bun",
+        includes: [],
+        excludes: [],
+        codebases: [],
+      })
+    );
+    log.info(colors.green("wmill.yaml created"));
+  })
  .command("app", app)
  .command("flow", flow)
  .command("script", script)
@@ -70,6 +89,7 @@ let command: any = new Command()
  .command("schedule", schedule)
  .command("dev", dev)
  .command("sync", sync)
+
  .command("version", "Show version information")
  .action(async (opts) => {
    console.log("CLI build against " + VERSION);
--- a/cli/metadata.ts
+++ b/cli/metadata.ts
@@ -1,6 +1,6 @@
 // deno-lint-ignore-file no-explicit-any
 import { GlobalOptions } from "./types.ts";
-import { colors, encodeHex, log, yamlParse, yamlStringify } from "./deps.ts";
+import { colors, log, yamlParse, yamlStringify } from "./deps.ts";
 import {
  ScriptMetadata,
  defaultScriptMetadata,
@@ -25,6 +25,7 @@ import { ScriptLanguage } from "./script_common.ts";
 import { inferContentTypeFromFilePath } from "./script_common.ts";
 import { GlobalDeps } from "./script.ts";
 import { yamlOptions } from "./sync.ts";
+import { generateHash } from "./utils.ts";

 export async function generateAllMetadata() {}

@@ -178,6 +179,16 @@ async function updateScriptLock(
  metadataContent: Record<string, any>,
  rawDeps: string | undefined
 ): Promise<void> {
+  if (
+    !(
+      language == "bun" ||
+      language == "python3" ||
+      language == "go" ||
+      language == "deno"
+    )
+  ) {
+    return;
+  }
  // generate the script lock running a dependency job in Windmill and update it inplace
  // TODO: update this once the client is released
  const rawResponse = await fetch(
@@ -214,7 +225,9 @@ async function updateScriptLock(
        )}`
      );
    }
-    metadataContent.lock = lock;
+    const lockPath = remotePath + ".script.lock";
+    await Deno.writeTextFile(lockPath, lock);
+    metadataContent.lock = "!inline " + lockPath;
  } catch (e) {
    throw new Error(
      `Failed to generate lockfile. Status was: ${rawResponse.statusText}, ${responseText}, ${e}`
@@ -426,10 +439,30 @@ function argSigToJsonSchemaType(
 // end of refactoring TODO                                                                //
 ////////////////////////////////////////////////////////////////////////////////////////////

+export async function replaceLock(o?: { lock?: string | string[] }) {
+  if (Array.isArray(o?.lock)) {
+    o.lock = o.lock.join("\n");
+  }
+  if (o?.lock?.startsWith("!inline ")) {
+    try {
+      const lockPath = o?.lock?.split(" ")[1];
+      o.lock = await Deno.readTextFile(lockPath);
+    } catch (e) {
+      log.info(
+        colors.yellow(`Failed to read lockfile, doing as if it was empty: ${e}`)
+      );
+      o.lock = "";
+    }
+  }
+}
 export async function parseMetadataFile(
  scriptPath: string,
  generateMetadataIfMissing:
-    | (GlobalOptions & { path: string; workspaceRemote: Workspace })
+    | (GlobalOptions & {
+        path: string;
+        workspaceRemote: Workspace;
+        schemaOnly?: boolean;
+      })
    | undefined,
  globalDeps: GlobalDeps
 ): Promise<{ isJson: boolean; payload: any; path: string }> {
@@ -446,9 +479,8 @@ export async function parseMetadataFile(
      metadataFilePath = scriptPath + ".script.yaml";
      await Deno.stat(metadataFilePath);
      const payload: any = yamlParse(await Deno.readTextFile(metadataFilePath));
-      if (Array.isArray(payload?.["lock"])) {
-        payload["lock"] = payload["lock"].join("\n");
-      }
+      await replaceLock(payload);
+
      return {
        path: metadataFilePath,
        payload,
@@ -465,7 +497,7 @@ export async function parseMetadataFile(
        scriptInitialMetadata as Record<string, any>,
        yamlOptions
      );
-      Deno.writeTextFile(metadataFilePath, scriptInitialMetadataYaml, {
+      await Deno.writeTextFile(metadataFilePath, scriptInitialMetadataYaml, {
        createNew: true,
      });

@@ -482,10 +514,10 @@ export async function parseMetadataFile(
            false,
            globalDeps
          );
-
          scriptInitialMetadata = yamlParse(
            await Deno.readTextFile(metadataFilePath)
          ) as ScriptMetadata;
+          await replaceLock(scriptInitialMetadata);
        } catch (e) {
          log.info(
            colors.yellow(
@@ -524,12 +556,6 @@ export async function readLockfile(): Promise<Lock> {
  }
 }

-async function generateHash(content: string): Promise<string> {
-  const messageBuffer = new TextEncoder().encode(content);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", messageBuffer);
-  return encodeHex(hashBuffer);
-}
-
 export async function checkifMetadataUptodate(
  path: string,
  requirement: string
--- a/Show More
+++ b/Show More