inline script drawer

.env

@@ -1,7 +1,2 @@
 DB_PASSWORD=changeme
-
-# this is the url that your instance is publicly exposed to
-WM_BASE_URL=http://localhost
-
-# this is the url that caddy will reverse proxy from. It might be different than WM_BASE_URL if you re using a second proxy/load balancer in front
-CADDY_REVERSE_PROXY=http://localhost
+WM_BASE_URL=localhost

.github/change-versions.sh

@@ -4,7 +4,7 @@ VERSION=$1
 echo "Updating versions to: $VERSION"
 
 sed -i -e "/^version =/s/= .*/= \"$VERSION\"/" backend/Cargo.toml
-sed -i -e "/^export const VERSION =/s/= .*/= \"v$VERSION\";/" cli/main.ts
+sed -i -e "/^const VERSION =/s/= .*/= \"v$VERSION\";/" cli/main.ts
 sed -i -e "/version: /s/: .*/: $VERSION/" backend/windmill-api/openapi.yaml
 sed -i -e "/version: /s/: .*/: $VERSION/" openflow.openapi.yaml
 sed -i -e "/\"version\": /s/: .*,/: \"$VERSION\",/" frontend/package.json

.github/workflows/deploy_to_windmill.yml

@@ -0,0 +1,20 @@
+name: Deploy to windmill.dev
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "community/**"
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Deploy to windmill.dev
+        uses: windmill-labs/windmill-gh-action-deploy@v2.0.0
+        with:
+          dry_run: false
+          input_dir: community
+          windmill_workspace: starter
+          windmill_token: ${{ secrets.WINDMILL_API_TOKEN }}

.github/workflows/docker-image.yml

@@ -18,7 +18,7 @@ permissions:
   contents: read
   id-token: write
   packages: write
-
+  
 jobs:
   build:
     runs-on: ubuntu-22.04
@@ -50,6 +50,7 @@ jobs:
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}
 
+
       - name: Build and push publicly
         uses: depot/build-push-action@v1
         with:
@@ -62,7 +63,7 @@ jobs:
           labels: |
             ${{ steps.meta-public.outputs.labels }}
             org.opencontainers.image.licenses=AGPLv3
-
+   
   build_ee:
     runs-on: ubuntu-22.04
     steps:
@@ -108,61 +109,40 @@ jobs:
             ${{ steps.meta-ee-public.outputs.labels }}
             org.opencontainers.image.licenses=Windmill-Enterprise-License
 
-  # disabled until we make it 100% reliable and add more meaningful tests
-  # playwright:
-  #   runs-on: [self-hosted, new]
-  #   needs: [build]
-  #   services:
-  #     postgres:
-  #       image: postgres
-  #       env:
-  #         POSTGRES_DB: windmill
-  #         POSTGRES_USER: admin
-  #         POSTGRES_PASSWORD: changeme
-  #       ports:
-  #         - 5432:5432
-  #       options: >-
-  #         --health-cmd pg_isready
-  #         --health-interval 10s
-  #         --health-timeout 5s
-  #         --health-retries 5
-  #   steps:
-  #     - uses: actions/checkout@v3
-  #     - name: "Docker"
-  #       run: echo "::set-output name=id::$(docker run --network=host --rm -d -p 8000:8000 --privileged -it -e DATABASE_URL=postgres://admin:changeme@localhost:5432/windmill -e BASE_INTERNAL_URL=http://localhost:8000 ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest)"
-  #       id: docker-container
-  #     - uses: actions/setup-node@v3
-  #       with:
-  #         node-version: 16
-  #     - name: "Playwright run"
-  #       timeout-minutes: 2
-  #       run: cd frontend && npm ci @playwright/test && npx playwright install && export BASE_URL=http://localhost:8000 && npm run test
-  #     - name: "Clean up"
-  #       run: docker kill ${{ steps.docker-container.outputs.id }}
-  #       if: always()
 
-  deploy_s3:
-    needs: [build_ee]
-    runs-on: ubuntu-latest
-    env:
-      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+  playwright:
+    runs-on: [self-hosted, new]
+    needs: [build]
+    services:
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_DB: windmill
+          POSTGRES_USER: admin
+          POSTGRES_PASSWORD: changeme
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
     steps:
       - uses: actions/checkout@v3
+      - name: "Docker"
+        run: echo "::set-output name=id::$(docker run --network=host --rm -d -p 8000:8000 --privileged -it -e DATABASE_URL=postgres://admin:changeme@localhost:5432/windmill -e BASE_INTERNAL_URL=http://localhost:8000 ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest)"
+        id: docker-container
       - uses: actions/setup-node@v3
         with:
-          node-version: 18
-      - uses: shrink/actions-docker-extract@v2
-        id: extract
-        with:
-          image: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-ee:latest
-          path: "/static_frontend/."
+          node-version: 16
+      - name: "Playwright run"
+        timeout-minutes: 2
+        run: cd frontend && npm ci @playwright/test && npx playwright install && export BASE_URL=http://localhost:8000 && npm run test
+      - name: "Clean up"
+        run: docker kill ${{ steps.docker-container.outputs.id }}
+        if: always()
+
 
-      - uses: reggionick/s3-deploy@v3
-        with:
-          folder: ${{ steps.extract.outputs.destination }}
-          bucket: windmill-frontend
-          bucket-region: us-east-1
   publish_privately_heavy:
     needs: [build_ee]
     runs-on: [self-hosted, new]
@@ -211,12 +191,8 @@ jobs:
           tags: |
             ${{ steps.meta-heavy.outputs.tags }}
           labels: ${{ steps.meta-heavy.outputs.labels }}
-          cache-from:
-            type=registry,ref=${{ env.LOCAL_REGISTRY }}/${{ env.IMAGE_NAME
-            }}-heavy:buildcache
-          cache-to:
-            type=registry,ref=${{ env.LOCAL_REGISTRY }}/${{ env.IMAGE_NAME
-            }}-heavy:buildcache,mode=max
+          cache-from: type=registry,ref=${{ env.LOCAL_REGISTRY }}/${{ env.IMAGE_NAME }}-heavy:buildcache
+          cache-to: type=registry,ref=${{ env.LOCAL_REGISTRY }}/${{ env.IMAGE_NAME }}-heavy:buildcache,mode=max
 
   publish_privately_helm:
     runs-on: [self-hosted, new]
@@ -228,6 +204,7 @@ jobs:
           fetch-depth: 0
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
+ 
 
       - name: Login to registry
         uses: docker/login-action@v2
@@ -243,7 +220,7 @@ jobs:
           registry: ${{ env.ECR_REGISTRY }}
           username: ${{ secrets.AWS_ACCESS_KEY_ID }}
           password: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-
+          
       - name: Build and push privately
         uses: docker/build-push-action@v4
         if: github.event_name != 'pull_request'
@@ -253,9 +230,5 @@ jobs:
           file: ./docker/DockerfileHelm
           tags: |
             ${{ env.ECR_REGISTRY }}/${{ env.IMAGE_NAME }}:helm
-          cache-from:
-            type=registry,ref=${{ env.LOCAL_REGISTRY }}/${{ env.IMAGE_NAME
-            }}-helm:buildcache
-          cache-to:
-            type=registry,ref=${{ env.LOCAL_REGISTRY }}/${{ env.IMAGE_NAME
-            }}-helm:buildcache,mode=max
+          cache-from: type=registry,ref=${{ env.LOCAL_REGISTRY }}/${{ env.IMAGE_NAME }}-helm:buildcache
+          cache-to: type=registry,ref=${{ env.LOCAL_REGISTRY }}/${{ env.IMAGE_NAME }}-helm:buildcache,mode=max

.github/workflows/go_on_release.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v3
       - name: generate_go
         run: |
           go install github.com/deepmap/oapi-codegen/cmd/oapi-codegen@v1.11.0

CHANGELOG.md

@@ -1,358 +1,6 @@
 # Changelog
 
 
-## [1.86.0](https://github.com/windmill-labs/windmill/compare/v1.85.0...v1.86.0) (2023-04-08)
-
-
-### Features
-
-* **backend:** add /ready endpoint for workers ([94eecea](https://github.com/windmill-labs/windmill/commit/94eecea02b6295ad5674db4b010bf6ab7984fa17))
-* **backend:** add GET endpoint to trigger scripts ([15c75d9](https://github.com/windmill-labs/windmill/commit/15c75d9d00a69ae97123ed371b9657e298345bdb))
-* **backend:** lowercase all emails in relevant endpoints ([#1361](https://github.com/windmill-labs/windmill/issues/1361)) ([7f9050b](https://github.com/windmill-labs/windmill/commit/7f9050b285cf8f7f6baf05452b673f58988c452c))
-* **cli:** add getFullResource ([3a232db](https://github.com/windmill-labs/windmill/commit/3a232dbb5792c28b26747e1ba260fffcdd4a8416))
-* do cache bucket syncing in background + check tar before pushing it ([#1360](https://github.com/windmill-labs/windmill/issues/1360)) ([3e5ff86](https://github.com/windmill-labs/windmill/commit/3e5ff8682a298ba9e59b2662c4c04c5698447204))
-* **frontend:** add flow expand button ([34a8b01](https://github.com/windmill-labs/windmill/commit/34a8b01b762c0b210d76101e7da7bd2397258e8d))
-* **frontend:** add impersonate api + local resolution of import by lsp v0 ([7675f08](https://github.com/windmill-labs/windmill/commit/7675f08b7bfe319e496a86a7ef1ab7cc8c1d12d2))
-* **frontend:** add workspace to ctx ([8f7a11b](https://github.com/windmill-labs/windmill/commit/8f7a11b8964e2c3405ce3689f9cf2298f9e71c75))
-* **frontend:** Improve login + toasts ([#1363](https://github.com/windmill-labs/windmill/issues/1363)) ([92be102](https://github.com/windmill-labs/windmill/commit/92be102a070b1f17b9d3e40524cd21b54301b5a7))
-* **frontend:** make script editor a single page ([b84be60](https://github.com/windmill-labs/windmill/commit/b84be60c53ca1ef65826123f39099d33c1f549c0))
-* **frontend:** Tone down text + display whole text ([#1366](https://github.com/windmill-labs/windmill/issues/1366)) ([f214d5f](https://github.com/windmill-labs/windmill/commit/f214d5f96b6ac26cd3ef90a6ab696a6dfe02b3f0))
-* improved cron/schedule editor ([#1362](https://github.com/windmill-labs/windmill/issues/1362)) ([17176bb](https://github.com/windmill-labs/windmill/commit/17176bb8d112b35228ce9183f4b2f81abe9e5b6e))
-
-
-### Bug Fixes
-
-* **backend:** allow cors ([8a594a8](https://github.com/windmill-labs/windmill/commit/8a594a89adba9915508884f900f58c4ab53cdfec))
-* **backend:** allow longer name/company ([eff61bb](https://github.com/windmill-labs/windmill/commit/eff61bb8d3496bc1c5be4b1051f99ed4470a47ff))
-* **backend:** always flush bash output ([517b2c9](https://github.com/windmill-labs/windmill/commit/517b2c9cca54628c8ee692d65c05bc2513eaaf22))
-* **backend:** always flush bash output ([7a9091f](https://github.com/windmill-labs/windmill/commit/7a9091fed6aa99201b75bab88d4faddbe041eee4))
-* **backend:** inline script app python fix ([8c72722](https://github.com/windmill-labs/windmill/commit/8c72722710db8e3720b01180b504cbc66e79f5ca))
-* **frontend:** Add FlowGraph display on Safari ([#1351](https://github.com/windmill-labs/windmill/issues/1351)) ([2819b09](https://github.com/windmill-labs/windmill/commit/2819b09ce5011a467e994ee8b1f09cf33145003d))
-* **frontend:** Fix button poppup ([#1368](https://github.com/windmill-labs/windmill/issues/1368)) ([a344928](https://github.com/windmill-labs/windmill/commit/a344928f251d697f53e40c517b0b86bd90e0ad52))
-* **frontend:** Fix connected property ([#1371](https://github.com/windmill-labs/windmill/issues/1371)) ([4af39f0](https://github.com/windmill-labs/windmill/commit/4af39f081bf3d07aaade39e5a5a221741fe8f973))
-* **frontend:** Fix flow templateEditor ([#1367](https://github.com/windmill-labs/windmill/issues/1367)) ([51fc436](https://github.com/windmill-labs/windmill/commit/51fc436456104c2d6a3cd6f6d62f08929e40d450))
-* **frontend:** make croninput a builder rather than a tab ([266b5b0](https://github.com/windmill-labs/windmill/commit/266b5b00da3bd7643eaa5dba1b8c1456f11c5e30))
-* **frontend:** Minor fixes ([#1374](https://github.com/windmill-labs/windmill/issues/1374)) ([76a2a1d](https://github.com/windmill-labs/windmill/commit/76a2a1db363facbaf9a0e9618f169d6cc66e946f))
-* no need to map internal ports to hosts ([#1365](https://github.com/windmill-labs/windmill/issues/1365)) ([4ec035b](https://github.com/windmill-labs/windmill/commit/4ec035b09a58f8859bc576b03c24cc73f335f32d))
-
-## [1.85.0](https://github.com/windmill-labs/windmill/compare/v1.84.1...v1.85.0) (2023-04-03)
-
-
-### Features
-
-* add local cache for folder path used + invalidate cache on folder creation ([018b051](https://github.com/windmill-labs/windmill/commit/018b051781e3f40b9d1da8ccdd5edb1cd49877ba))
-* **frontend:** add agGrid api hooks + ready ([de1e294](https://github.com/windmill-labs/windmill/commit/de1e29492c9aefdfc59f605ba81f7c51a96bf2f3))
-* **frontend:** Add ID renaming popup ([#1344](https://github.com/windmill-labs/windmill/issues/1344)) ([0b8a08c](https://github.com/windmill-labs/windmill/commit/0b8a08cb49644da7c354c3631751e925ac5353b9))
-
-
-### Bug Fixes
-
-* **backend:** improve handling subflow with many depth using tailrec ([8c53598](https://github.com/windmill-labs/windmill/commit/8c53598aba3fb89f4174d1c0ab3912096ac07c96))
-* **backend:** improve subflow processing ([390a988](https://github.com/windmill-labs/windmill/commit/390a988d4c96256a4fbd6a9302fc47a5648c2c43))
-* **frontend:** PDF reader header positioning ([#1350](https://github.com/windmill-labs/windmill/issues/1350)) ([daf8276](https://github.com/windmill-labs/windmill/commit/daf827666b13917f8c9abeab5bb2b072bd0fef0b))
-
-## [1.84.1](https://github.com/windmill-labs/windmill/compare/v1.84.0...v1.84.1) (2023-03-31)
-
-
-### Bug Fixes
-
-* **cli:** overwrite instead of smart diff ([b6d5eef](https://github.com/windmill-labs/windmill/commit/b6d5eef5479e38cc36af2db67d4c45f78c622b9a))
-
-## [1.84.0](https://github.com/windmill-labs/windmill/compare/v1.83.1...v1.84.0) (2023-03-31)
-
-
-### Features
-
-* add force cancel ([fbe5c18](https://github.com/windmill-labs/windmill/commit/fbe5c18da02763371e6f32c898b31a6a29984b45))
-* add the ability to edit previous versions ([2368da2](https://github.com/windmill-labs/windmill/commit/2368da214660ff1835b49b4c2c87256c9bd565cf))
-* **backend:** reduce memory allocation for big forloops of flows ([c7506e4](https://github.com/windmill-labs/windmill/commit/c7506e4daec5b12bf908e6954bf6f3521a97b3ba))
-* **frontend:** App component style input grouping ([#1334](https://github.com/windmill-labs/windmill/issues/1334)) ([01564f0](https://github.com/windmill-labs/windmill/commit/01564f0a1c26ee9f065bb0adeb7d5e8df0b2e5b5))
-* **frontend:** Display frontend execution result in Debug Runs ([#1341](https://github.com/windmill-labs/windmill/issues/1341)) ([57f8dd9](https://github.com/windmill-labs/windmill/commit/57f8dd9570577a58fe91d93c7a9d1a9b4dc69598))
-* **frontend:** improve input connection UI ([#1333](https://github.com/windmill-labs/windmill/issues/1333)) ([5ac646e](https://github.com/windmill-labs/windmill/commit/5ac646e859a07efb65542aae9365aa7791ce1097))
-
-
-### Bug Fixes
-
-* **backend:** add a refresh button to workspace script/hub ([bb61cef](https://github.com/windmill-labs/windmill/commit/bb61cef0e56bf7fa7f8a5f91dabd590afd5db791))
-* **backend:** backend compatability on macos ([#1340](https://github.com/windmill-labs/windmill/issues/1340)) ([dfd2abc](https://github.com/windmill-labs/windmill/commit/dfd2abc76466cddca98f93fd82be91ba5d3076e0))
-* **frontend:** Export python code as string ([#1339](https://github.com/windmill-labs/windmill/issues/1339)) ([2779891](https://github.com/windmill-labs/windmill/commit/277989141100b033b26b496b8a55d97d48cf7e81))
-* **frontend:** improve app tables ([cd1f9b6](https://github.com/windmill-labs/windmill/commit/cd1f9b6baa0dadfb14fee3a586a4b6b164e5e402))
-* **frontend:** improve loading of big args in job details ([71619ac](https://github.com/windmill-labs/windmill/commit/71619acdfac010822c1eac496a6f3f869e6ca6fb))
-* **frontend:** improve loading of big jobs in run form ([b325493](https://github.com/windmill-labs/windmill/commit/b3254938fe58d8c00a0c4347e7ef519e3a6e4031))
-
-## [1.83.1](https://github.com/windmill-labs/windmill/compare/v1.83.0...v1.83.1) (2023-03-28)
-
-
-### Bug Fixes
-
-* **cli:** plain secrets might be undefined ([569a55e](https://github.com/windmill-labs/windmill/commit/569a55e45b34641b0fb4569387166f3aa89ce35f))
-
-## [1.83.0](https://github.com/windmill-labs/windmill/compare/v1.82.0...v1.83.0) (2023-03-28)
-
-
-### Features
-
-* **backend:** allow relative imports for python ([a5500ea](https://github.com/windmill-labs/windmill/commit/a5500ea40a77b2e0408e2a644190a8f65b18cd1d))
-* **backend:** execute /bin/bash instead of /bin/sh for bash scripts ([021fa23](https://github.com/windmill-labs/windmill/commit/021fa23f9ffcd11548977a4589eb9bc2815243cf))
-* **backend:** improve relative importsfor deno ([eaac598](https://github.com/windmill-labs/windmill/commit/eaac598af308cedea8f0f8fc7c189a4640b4366b))
-* **backend:** increase timeout for premium workspace ([00b70d9](https://github.com/windmill-labs/windmill/commit/00b70d9aaac8ae979782492d7754060a3c2c9567))
-* **frontend:** add pagination ([33c07d3](https://github.com/windmill-labs/windmill/commit/33c07d3e63f96673719ecb15e45f4cd9e18be80e))
-* **frontend:** Add quick style settings to app editor ([#1308](https://github.com/windmill-labs/windmill/issues/1308)) ([ac24862](https://github.com/windmill-labs/windmill/commit/ac2486219cd91df3a7fe11d37894797a881cac6c))
-* **frontend:** add recompute as a primitive ([449d3ae](https://github.com/windmill-labs/windmill/commit/449d3ae5ddeceef3fbcb7a815a4dba16c9639fb3))
-* **frontend:** add textareacomponent + fix multiselect style + select multi components ([2b31653](https://github.com/windmill-labs/windmill/commit/2b31653a8aa06807678e8609cfa62cf0f2f55dce))
-* **frontend:** multiselect components for apps ([577dec5](https://github.com/windmill-labs/windmill/commit/577dec5c5733cdf88e8586ce6c27159920c69c8a))
-* **frontend:** use rich json editor for arrays of objects and for object in ArgInput ([b95afaa](https://github.com/windmill-labs/windmill/commit/b95afaa9bb41b102181657453a564f44f4511983))
-
-
-### Bug Fixes
-
-* **apps:** improve app table actionButtons behavior under many clicks ([8e3d8ac](https://github.com/windmill-labs/windmill/commit/8e3d8acc80de971ee115d6903d24864d8263f08b))
-* **cli:** add --plain-secrets ([98d51e2](https://github.com/windmill-labs/windmill/commit/98d51e219df1680507114f9b57ec0b0a4a234b5c))
-* **frontend:** add a modal that is always mounted to make sure compon… ([#1328](https://github.com/windmill-labs/windmill/issues/1328)) ([a527cb8](https://github.com/windmill-labs/windmill/commit/a527cb8222a2ff80dae38ebae7dc5ea0979d74c5))
-* **frontend:** Disable app keyboard navigation on focused inputs ([#1326](https://github.com/windmill-labs/windmill/issues/1326)) ([da24e9a](https://github.com/windmill-labs/windmill/commit/da24e9ab0625a7503c498c179022ea4011a03170))
-* **frontend:** persist description for schemas ([1a48673](https://github.com/windmill-labs/windmill/commit/1a4867302f72aaae8f422ac8f53812c116cc383d))
-* **frontend:** Revert app upload input ([#1330](https://github.com/windmill-labs/windmill/issues/1330)) ([fa457bb](https://github.com/windmill-labs/windmill/commit/fa457bb7099bd31c2315eaf7f7f2c40900b2ae39))
-* **frontend:** Small app fixes ([#1331](https://github.com/windmill-labs/windmill/issues/1331)) ([75306c8](https://github.com/windmill-labs/windmill/commit/75306c831616d9a01cc3a4681732aab93153f1a9))
-
-## [1.82.0](https://github.com/windmill-labs/windmill/compare/v1.81.0...v1.82.0) (2023-03-24)
-
-
-### Features
-
-* **backend:** introduce RESTART_ZOMBIE_JOBS and ZOMBIE_JOB_TIMEOUT ([47a7f71](https://github.com/windmill-labs/windmill/commit/47a7f7163aae3fe807e766c824085b4d1b75c8c8))
-
-
-### Bug Fixes
-
-* **backend:** do not consider FlowPreview as potential zombie job ([f7c30b5](https://github.com/windmill-labs/windmill/commit/f7c30b5d2f16e15f36208e07126557fd7ed84801))
-* **backend:** increase dynamic js timeout + improve client passing ([34e25f0](https://github.com/windmill-labs/windmill/commit/34e25f0f96fe637cc42f4017a064c40def5d67ef))
-* **cli:** improve diff speed + fix replacing cli ([b999c98](https://github.com/windmill-labs/windmill/commit/b999c9894b4011b735f37df485fe403c22c00512))
-* **frontend:** Fix AppTable error display + clear errors when removing a component + properly detect that latest component run had an error ([#1322](https://github.com/windmill-labs/windmill/issues/1322)) ([c15bc8a](https://github.com/windmill-labs/windmill/commit/c15bc8a7bfb3bef2634e6093088967137cd06239))
-* **frontend:** fix refresh with manual dependencies ([#1319](https://github.com/windmill-labs/windmill/issues/1319)) ([a47031a](https://github.com/windmill-labs/windmill/commit/a47031a41e6a3392101e280dcd1aea098f898447))
-* **frontend:** fix settings panel ([#1323](https://github.com/windmill-labs/windmill/issues/1323)) ([30b8e47](https://github.com/windmill-labs/windmill/commit/30b8e474df5b71b7e7b36d3fe5974a289cf0dfae))
-* **frontend:** Fix transformer ([#1321](https://github.com/windmill-labs/windmill/issues/1321)) ([addabcc](https://github.com/windmill-labs/windmill/commit/addabcceb0c90782ba4a934bb3822f8cc9865069))
-* **frontend:** remove unnecessary div ([#1318](https://github.com/windmill-labs/windmill/issues/1318)) ([e193a0b](https://github.com/windmill-labs/windmill/commit/e193a0bcdf6690b007594d2f1325a7ec26603129))
-
-## [1.81.0](https://github.com/windmill-labs/windmill/compare/v1.80.1...v1.81.0) (2023-03-21)
-
-
-### Features
-
-* **apps:** add action on form/button/formbutton ([2593218](https://github.com/windmill-labs/windmill/commit/2593218cbf07c05521a270797055ddb22dc22b8d))
-
-
-### Bug Fixes
-
-* **frontend:** Remove action outline on preview mode ([#1313](https://github.com/windmill-labs/windmill/issues/1313)) ([a7c4f1a](https://github.com/windmill-labs/windmill/commit/a7c4f1a12e02e8627a5955b75d572e9cf11d8122))
-
-## [1.80.1](https://github.com/windmill-labs/windmill/compare/v1.80.0...v1.80.1) (2023-03-21)
-
-
-### Bug Fixes
-
-* **cli:** add support for non metadataed scripts ([42f6d2e](https://github.com/windmill-labs/windmill/commit/42f6d2e0ee6294f8a1d97f5f62f2adb6edfd2fed))
-
-## [1.80.0](https://github.com/windmill-labs/windmill/compare/v1.79.0...v1.80.0) (2023-03-20)
-
-
-### Features
-
-* **apps:** add transformers for data sources ([0abacac](https://github.com/windmill-labs/windmill/commit/0abacac06c7dd586b48c66ff47b7589fe692205b))
-* **frontend:** App set tab ([#1307](https://github.com/windmill-labs/windmill/issues/1307)) ([48413a7](https://github.com/windmill-labs/windmill/commit/48413a78c5e7e0ee8208711f15135d81136b7386))
-
-
-### Bug Fixes
-
-* **frontend:** add missing optional chaining ([#1306](https://github.com/windmill-labs/windmill/issues/1306)) ([29b1cc6](https://github.com/windmill-labs/windmill/commit/29b1cc6ff0ebc5edcad24a1780113889c507075d))
-* **frontend:** App button triggered by ([#1304](https://github.com/windmill-labs/windmill/issues/1304)) ([cf2d031](https://github.com/windmill-labs/windmill/commit/cf2d031e8e89faa2cd7fa58436cbe7cf4d9045f9))
-
-## [1.79.0](https://github.com/windmill-labs/windmill/compare/v1.78.0...v1.79.0) (2023-03-17)
-
-
-### Features
-
-* **frontend:** add listeners for frontend scripts ([597e38e](https://github.com/windmill-labs/windmill/commit/597e38ef367d38fa97fc443ccb2c721e5964fece))
-* **frontend:** add table actions navigation ([#1298](https://github.com/windmill-labs/windmill/issues/1298)) ([c3ba1a6](https://github.com/windmill-labs/windmill/commit/c3ba1a6ab97484a08a5a20187bb858a5af7025cb))
-* **frontend:** App component triggers ([#1303](https://github.com/windmill-labs/windmill/issues/1303)) ([078cb1b](https://github.com/windmill-labs/windmill/commit/078cb1bf3e4de08cb018578f04d24392a6462f69))
-* **frontend:** Component control ([#1293](https://github.com/windmill-labs/windmill/issues/1293)) ([bd927a2](https://github.com/windmill-labs/windmill/commit/bd927a27ed9581dbf67ea3694f9d989f8d71d2ed))
-
-
-### Bug Fixes
-
-* **frontend:** App panel styling ([#1284](https://github.com/windmill-labs/windmill/issues/1284)) ([c1dd35c](https://github.com/windmill-labs/windmill/commit/c1dd35c3f0fcbc1be43273f82a873c3c07863417))
-* **frontend:** Display app context search on top ([#1300](https://github.com/windmill-labs/windmill/issues/1300)) ([bd3ee81](https://github.com/windmill-labs/windmill/commit/bd3ee81b14846f16ccd16461de99b46fe68be6ba))
-* **frontend:** fix horizontal splitpanes ([#1301](https://github.com/windmill-labs/windmill/issues/1301)) ([ea3dab4](https://github.com/windmill-labs/windmill/commit/ea3dab411b3d5dd772e04c8831e789e2470aaf28))
-* **frontend:** fix map render ([#1297](https://github.com/windmill-labs/windmill/issues/1297)) ([0092721](https://github.com/windmill-labs/windmill/commit/00927210fd68c31cb793ef4f0efea05711ebcf00))
-* **frontend:** Hide archive toggle with empty list ([#1296](https://github.com/windmill-labs/windmill/issues/1296)) ([bac831b](https://github.com/windmill-labs/windmill/commit/bac831b23ce85a683ddbd4537900670a0b7d12a8))
-
-## [1.78.0](https://github.com/windmill-labs/windmill/compare/v1.77.0...v1.78.0) (2023-03-16)
-
-
-### Features
-
-* **frontend:** app textcomponent editable + tooltip ([11567d6](https://github.com/windmill-labs/windmill/commit/11567d6280ea60f1a8c3c6607c724179775cbbe3))
-
-
-### Bug Fixes
-
-* **backend:** whitelist for include_header was ignored in some cases ([183a459](https://github.com/windmill-labs/windmill/commit/183a4591df700ab4720de6e92a83631256940089))
-* **frontend:** improve rendering performance after component moving ([6f890f2](https://github.com/windmill-labs/windmill/commit/6f890f2120885f90d986fbd655096b45bf9de539))
-* **frontend:** remove staticOutputs from apps ([dbdfd62](https://github.com/windmill-labs/windmill/commit/dbdfd626386398180ecba7976714f86365eeccd8))
-
-## [1.77.0](https://github.com/windmill-labs/windmill/compare/v1.76.0...v1.77.0) (2023-03-14)
-
-
-### Features
-
-* **apps:** state can be used as input in apps ([2f0acb9](https://github.com/windmill-labs/windmill/commit/2f0acb9ffa8dace4a886527dcee49809d019b271))
-* **apps:** tabs can be made pages or invisible + better frontend scripts reactivity ([cd645d0](https://github.com/windmill-labs/windmill/commit/cd645d0935f2d06e0ff71f14d2cf63accd378ff3))
-* **deno:** add support for custom npm repo ([#1291](https://github.com/windmill-labs/windmill/issues/1291)) ([944795f](https://github.com/windmill-labs/windmill/commit/944795f6eeaa7d01ab1a35a80570a55c363723e6))
-* **frontend:** add setTab to frontend scripts ([c2a97c5](https://github.com/windmill-labs/windmill/commit/c2a97c53cfff0fdb35dd8bc249490566eebdc1a9))
-* **frontend:** app components output panel ([#1283](https://github.com/windmill-labs/windmill/issues/1283)) ([751edcf](https://github.com/windmill-labs/windmill/commit/751edcf9b8e0976a1d073603c9eff5dc6e714490))
-
-
-### Bug Fixes
-
-* **backend:** do not cache reference to workspace scripts ([eb73f2a](https://github.com/windmill-labs/windmill/commit/eb73f2a687f6faad301b9038ab8585450bec7481))
-* **frontend:** fix app tabs ([#1288](https://github.com/windmill-labs/windmill/issues/1288)) ([c71a577](https://github.com/windmill-labs/windmill/commit/c71a577fead90c9cd01a736b54d859ec4f0b7807))
-* **frontend:** fix container deletion ([#1287](https://github.com/windmill-labs/windmill/issues/1287)) ([bc870bd](https://github.com/windmill-labs/windmill/commit/bc870bd03eb76cb8bc0e0c861f6cd8a9c661186b))
-* **frontend:** Update setting accordion ([#1285](https://github.com/windmill-labs/windmill/issues/1285)) ([dea12e8](https://github.com/windmill-labs/windmill/commit/dea12e8870ece998bb6607723cbaab9b9a958f22))
-
-## [1.76.0](https://github.com/windmill-labs/windmill/compare/v1.75.0...v1.76.0) (2023-03-13)
-
-
-### Features
-
-* **frontend:** add frontend (JS)  scripts to apps ([f0b1b1f](https://github.com/windmill-labs/windmill/commit/f0b1b1f752731ba434b960a75624118152f53c00))
-* **frontend:** Copy, Cut and Paste ([#1279](https://github.com/windmill-labs/windmill/issues/1279)) ([82c139e](https://github.com/windmill-labs/windmill/commit/82c139ed0992be401e250cfb7ecc0fca61b76772))
-* **frontend:** disabled for action buttons can now depend on row ([75f87e7](https://github.com/windmill-labs/windmill/commit/75f87e7e1117a9c12afcf626379e94b134a9a493))
-* **frontend:** improve drag-n-drop behavior ([cfd489a](https://github.com/windmill-labs/windmill/commit/cfd489a55059e7b6843f99bab261c70b3852e6a2))
-
-
-### Bug Fixes
-
-* **backend:** improve worker ping api ([c958480](https://github.com/windmill-labs/windmill/commit/c958480ce83844a989f58dd5a70eb288582e2194))
-* **frontend:** General fixes and updates ([#1281](https://github.com/windmill-labs/windmill/issues/1281)) ([3e5a179](https://github.com/windmill-labs/windmill/commit/3e5a179eb8cd8001f49c92305141dade1571e20f))
-
-## [1.75.0](https://github.com/windmill-labs/windmill/compare/v1.74.2...v1.75.0) (2023-03-11)
-
-
-### Features
-
-* add filter jobs by args or result ([3b44f9a](https://github.com/windmill-labs/windmill/commit/3b44f9a72ca0466a44963a4b9657a0ee59b44753))
-* **apps:** add resource picker ([8681e83](https://github.com/windmill-labs/windmill/commit/8681e83b574141acbf7e5a389a9e8a4f340336d1))
-* **bash:** add default argument handling for bash ([1d5c194](https://github.com/windmill-labs/windmill/commit/1d5c194f09ffba963d52e418c5954843d84ae337))
-* **frontend-apps:** add variable picker for static string input on apps ([bc440f8](https://github.com/windmill-labs/windmill/commit/bc440f8d4154ce464c0e027d93b7a0a3b76d782e))
-* **frontend:** make runs filters synced with query args ([61a5e1f](https://github.com/windmill-labs/windmill/commit/61a5e1f1accc988628b785b3b9be04c4ea719874))
-
-
-### Bug Fixes
-
-* **backend:** add killpill for lines reading ([7c825c2](https://github.com/windmill-labs/windmill/commit/7c825c212dd0f1e8be427eabd9a9756303241d1b))
-* **cli:** many small fixes ([ce32370](https://github.com/windmill-labs/windmill/commit/ce323709a94d27fb24214719180ea1aafc66d646))
-
-## [1.74.2](https://github.com/windmill-labs/windmill/compare/v1.74.1...v1.74.2) (2023-03-09)
-
-
-### Bug Fixes
-
-* **frontend:** fix splitpanes navigation ([#1276](https://github.com/windmill-labs/windmill/issues/1276)) ([8d5c5b8](https://github.com/windmill-labs/windmill/commit/8d5c5b88a35d7a3bad1d8ddf2d940026825241eb))
-
-## [1.74.1](https://github.com/windmill-labs/windmill/compare/v1.74.0...v1.74.1) (2023-03-09)
-
-
-### Bug Fixes
-
-* **apps:** proper reactivity for non rendered static components ([ae53baf](https://github.com/windmill-labs/windmill/commit/ae53bafaf6777f928113f84b2c6ed6a2ed341844))
-* **ci:** make windmill compile again by pinning swc deps ([2ea15d5](https://github.com/windmill-labs/windmill/commit/2ea15d5035e5e15473968db3c0501a4dddff5cd0))
-
-## [1.74.0](https://github.com/windmill-labs/windmill/compare/v1.73.1...v1.74.0) (2023-03-09)
-
-
-### Features
-
-* add delete by path for scripts ([0c2cf92](https://github.com/windmill-labs/windmill/commit/0c2cf92dd3df9610e649f15e23921a4ca0d94e6a))
-* **frontend:** Add color picker input to app ([#1270](https://github.com/windmill-labs/windmill/issues/1270)) ([88e537a](https://github.com/windmill-labs/windmill/commit/88e537ad1fb4c207f38fbe951c82106bef6491a3))
-* **frontend:** add expand ([#1268](https://github.com/windmill-labs/windmill/issues/1268)) ([b854ee3](https://github.com/windmill-labs/windmill/commit/b854ee34393534bde104e2e6f606108fd66d38dc))
-* **frontend:** add hash to ctx in apps ([b1a45b1](https://github.com/windmill-labs/windmill/commit/b1a45b1e708aa6f19f8be9c949507083e044f2d8))
-* **frontend:** Add key navigation in app editor ([#1273](https://github.com/windmill-labs/windmill/issues/1273)) ([6b0fb75](https://github.com/windmill-labs/windmill/commit/6b0fb75d23e2151c88b07814139d203c1bd0578d))
-
-
-### Bug Fixes
-
-* **cli:** improve visibility of the active workspace ([e6344da](https://github.com/windmill-labs/windmill/commit/e6344dac6d1be04b46231fa8ef8579fd12ca8f37))
-* **frontend:** add confirmation modal to delete script/flow/app ([a4adcb5](https://github.com/windmill-labs/windmill/commit/a4adcb5192c11f7bf47a0d259825e474779378d7))
-* **frontend:** Clean up app editor ([#1267](https://github.com/windmill-labs/windmill/issues/1267)) ([0a5e181](https://github.com/windmill-labs/windmill/commit/0a5e181a3aa966fb8211bee0d9174fc16353b31f))
-* **frontend:** Minor changes ([#1272](https://github.com/windmill-labs/windmill/issues/1272)) ([3b6ae0c](https://github.com/windmill-labs/windmill/commit/3b6ae0cc49461b858d9cfff79eae9a7569465235))
-* **frontend:** simplify input bindings ([b2de531](https://github.com/windmill-labs/windmill/commit/b2de531a46e4b120d7106d361b727746bec516dd))
-
-## [1.73.1](https://github.com/windmill-labs/windmill/compare/v1.73.0...v1.73.1) (2023-03-07)
-
-
-### Bug Fixes
-
-* **frontend:** load flow is not initialized ([719d475](https://github.com/windmill-labs/windmill/commit/719d4752621d462b1cfaa0d27930fba7586be779))
-
-## [1.73.0](https://github.com/windmill-labs/windmill/compare/v1.72.0...v1.73.0) (2023-03-07)
-
-
-### Features
-
-* **frontend:** add a way to automatically resize ([#1259](https://github.com/windmill-labs/windmill/issues/1259)) ([24f58ef](https://github.com/windmill-labs/windmill/commit/24f58efd9994a2201c1b1d9bbfb11734c57068e3))
-* **frontend:** add ability to move nodes ([614fb50](https://github.com/windmill-labs/windmill/commit/614fb5022aa7d5428fb96b7ee3a20794edd1e9d3))
-* **frontend:** Add app PDF viewer ([#1254](https://github.com/windmill-labs/windmill/issues/1254)) ([3e5d09e](https://github.com/windmill-labs/windmill/commit/3e5d09ef0b5619186bee5ec6d442cbfd12a6e8d5))
-* **frontend:** add fork/save buttons + consistent styling for slider/range ([9e9f8ef](https://github.com/windmill-labs/windmill/commit/9e9f8efb8ee389ea75e99b67ef720756959ca737))
-* **frontend:** add history to flows and apps ([9e4d90a](https://github.com/windmill-labs/windmill/commit/9e4d90ad37a57ff1f515eea0c82cf603649e915d))
-* **frontend:** Fix object viewer style ([#1255](https://github.com/windmill-labs/windmill/issues/1255)) ([94f1aad](https://github.com/windmill-labs/windmill/commit/94f1aadef2b09ac1962478f11b27cc708b8328f1))
-* **frontend:** refactor entire flow builder UX ([2ac51b0](https://github.com/windmill-labs/windmill/commit/2ac51b0af08bdef7ce3c7e874e9983b9fc00478a))
-
-
-### Bug Fixes
-
-* **frontend:** arginput + apppreview fixes ([e2c4545](https://github.com/windmill-labs/windmill/commit/e2c45452401022b00285b21551ffaf35a114be33))
-* **frontend:** fix app map reactivity ([#1260](https://github.com/windmill-labs/windmill/issues/1260)) ([2557e13](https://github.com/windmill-labs/windmill/commit/2557e136bd0df1a023819b7d9b2235e30d7140b6))
-* **frontend:** fix branch deletion ([#1261](https://github.com/windmill-labs/windmill/issues/1261)) ([a999eb2](https://github.com/windmill-labs/windmill/commit/a999eb21121a7c0010621448324e0c77caf2b3f6))
-* **frontend:** Side menu z-index issue ([#1265](https://github.com/windmill-labs/windmill/issues/1265)) ([c638897](https://github.com/windmill-labs/windmill/commit/c638897fdcd58f55b0929f91641b21a6f9d25ead))
-
-## [1.72.0](https://github.com/windmill-labs/windmill/compare/v1.71.0...v1.72.0) (2023-03-02)
-
-
-### Features
-
-* **backend:** get_result_by_id do a downward pass to find node at any depth ([#1249](https://github.com/windmill-labs/windmill/issues/1249)) ([4c913dc](https://github.com/windmill-labs/windmill/commit/4c913dc4b6be03571a015c97a13829adffb61479))
-* **frontend:** Add app map component ([#1251](https://github.com/windmill-labs/windmill/issues/1251)) ([ed25d9f](https://github.com/windmill-labs/windmill/commit/ed25d9f186d9925f75404cb193a025d8a41c4540))
-* **frontend:** app splitpanes ([#1248](https://github.com/windmill-labs/windmill/issues/1248)) ([f4d79ee](https://github.com/windmill-labs/windmill/commit/f4d79ee2633e6cdab0fa2410108b31cfa77e10da))
-
-
-### Bug Fixes
-
-* **backend:** improve result retrieval ([c4463bb](https://github.com/windmill-labs/windmill/commit/c4463bb029907f3c8d77abb194f872aae7876bf6))
-* **backend:** incorrect get_result_by_id for  list_result job ([2a75cd2](https://github.com/windmill-labs/windmill/commit/2a75cd250ea5e01849fc8bbb69bf44f147d0acb8))
-* **cli:** fix workspace option + run script/flow + whoami ([35ea2b2](https://github.com/windmill-labs/windmill/commit/35ea2b27b12159c68c8507ec1f8686028c975387))
-* **frontend:** background script not showing inputs ([55eb48c](https://github.com/windmill-labs/windmill/commit/55eb48c55332431304cedbf3bcbbbcff61ec3645))
-* **frontend:** fix table bindings ([2679386](https://github.com/windmill-labs/windmill/commit/2679386bf87a56352269911bd89e52df5ee9f314))
-* **frontend:** rework app reactivity ([94b20d2](https://github.com/windmill-labs/windmill/commit/94b20d2f5e3b551974c57ea82b6e3dc16e97b9b8))
-* **frontend:** rework app reactivity ([1753cb7](https://github.com/windmill-labs/windmill/commit/1753cb7da658f47be974c15da82c71a8e19309a6))
-
-## [1.71.0](https://github.com/windmill-labs/windmill/compare/v1.70.1...v1.71.0) (2023-02-28)
-
-
-### Features
-
-* **backend:** use counter for sleep/execution/pull durations ([e568690](https://github.com/windmill-labs/windmill/commit/e56869092a03fec4703ddd9ef65c89edb8122962))
-* **cli:** add autocompletions ([287b2db](https://github.com/windmill-labs/windmill/commit/287b2db22f7b56e90bcd0c4727c00096695c2e0d))
-* **frontend:** App drawer ([#1246](https://github.com/windmill-labs/windmill/issues/1246)) ([8a0d115](https://github.com/windmill-labs/windmill/commit/8a0d1158c4d7e970cb91e1adf4838e5efdbb39ff))
-* **frontend:** drawer for editing workspace scripts in flows ([6adc875](https://github.com/windmill-labs/windmill/commit/6adc87561070d8aceaba1838008cd7e6be2e2660))
-
-
-### Bug Fixes
-
-* **frontend:** Add more app custom css ([#1229](https://github.com/windmill-labs/windmill/issues/1229)) ([a4e4d18](https://github.com/windmill-labs/windmill/commit/a4e4d188ad10443dd0b7f104389594efc768dc59))
-* **frontend:** Add more app custom css ([#1247](https://github.com/windmill-labs/windmill/issues/1247)) ([1bb5ed9](https://github.com/windmill-labs/windmill/commit/1bb5ed9ae01fd7998b06833b6222e5dd5d774d35))
-* **frontend:** display currently selected filter even if not in list ([42d1cd6](https://github.com/windmill-labs/windmill/commit/42d1cd6456620ba917c560c87d736dc93634adff))
-* **frontend:** Fix deeply nested move ([#1245](https://github.com/windmill-labs/windmill/issues/1245)) ([a67f10e](https://github.com/windmill-labs/windmill/commit/a67f10eeb6fdb44bbb3a510badcc5ad0ae187a2b))
-* **frontend:** invisible subgrids have h-0 + app policies fix ([2244e83](https://github.com/windmill-labs/windmill/commit/2244e83b9da803a4cf46ab0825d7cb6cb0e24872))
-
 ## [1.70.1](https://github.com/windmill-labs/windmill/compare/v1.70.0...v1.70.1) (2023-02-27)
 
 

Caddyfile

@@ -1,5 +1,15 @@
-{$BASE_URL} {
+{
+        auto_https off
+}
+
+http://{$BASE_URL} {
+        bind {$ADDRESS}
         reverse_proxy /ws/* http://lsp:3001
         reverse_proxy /* http://windmill_server:8000
 }
-}
+
+https://{$BASE_URL}  {  
+  bind {$ADDRESS}
+  reverse_proxy /ws/* http://localhost:3001
+}
+}

Dockerfile

@@ -73,7 +73,7 @@ ARG features=""
 
 COPY --from=planner /windmill/recipe.json recipe.json
 
-RUN CARGO_NET_GIT_FETCH_WITH_CLI=true RUST_BACKTRACE=1 cargo chef cook --release --features "$features" --recipe-path recipe.json
+RUN CARGO_NET_GIT_FETCH_WITH_CLI=true cargo chef cook --release --features "$features" --recipe-path recipe.json
 
 COPY ./openflow.openapi.yaml /openflow.openapi.yaml
 COPY ./backend ./
@@ -86,7 +86,6 @@ RUN CARGO_NET_GIT_FETCH_WITH_CLI=true cargo build --release --features "$feature
 
 
 FROM python:3.11.2-slim-buster
-ARG TARGETPLATFORM
 
 ARG APP=/usr/src/app
 
@@ -124,17 +123,12 @@ ENV TZ=Etc/UTC
 
 RUN /usr/local/bin/python3 -m pip install pip-tools
 
-COPY --from=frontend /frontend/build /static_frontend
 COPY --from=builder /windmill/target/release/windmill ${APP}/windmill
 
 COPY --from=nsjail /nsjail/nsjail /bin/nsjail
 
 COPY --from=denoland/deno:latest /usr/bin/deno /usr/bin/deno
 
-# docker does not support conditional COPY and we want to use the same Dockerfile for both amd64 and arm64 and privilege the official image
-COPY --from=lukechannings/deno:latest /usr/bin/deno /usr/bin/deno-arm
-RUN if [ "$TARGETPLATFORM" = "linux/amd64" ]; then rm /usr/bin/deno-arm; elif [ "$TARGETPLATFORM" = "linux/arm64" ]; then mv /usr/bin/deno-arm /usr/bin/deno; fi
-
 RUN mkdir -p ${APP}
 
 WORKDIR ${APP}

LICENSE

@@ -8,9 +8,5 @@ or belonging to one of the below cases:
 
 The files under backend/ are AGPL Licensed.
 The files under frontend/ are AGPL Licensed.
-The files under python-client/ deno-client/ go-client/ are Apache 2.0 Licensed.
-
-The openapi files, including the OpenFlow spec is Apache 2.0 Licensed.
-
-All third party components incorporated into the Windmill Software are licensed under the
-original license provided by the owner of the applicable component.
+The files under python-client/ are Apache 2.0 Licensed.
+The files under community/ are Apache 2.0 Licensed.

README.md

@@ -26,8 +26,7 @@ Open-source developer infrastructure for internal tools. Self-hostable alternati
 
 # Windmill - Turn scripts into workflows and UIs that you can share and run at scale
 
-Windmill is <b>fully open-sourced (AGPLv3)</b> and Windmill Labs offers
-dedicated instance and commercial support and licenses.
+Windmill is <b>fully open-sourced (AGPLv3)</b> and Windmill Labs offers dedicated instance and commercial support and licenses.
 
 ![Windmill Diagram](/imgs/stacks.svg)
 
@@ -75,7 +74,7 @@ https://user-images.githubusercontent.com/275584/218350457-bc2fdc3b-e667-4da5-a2
 4. Build complex UI on top of your scripts and flows.
    ![Step 5](./imgs/windmill-builder.png)
 
-Scripts and flows can also be triggered by a cron schedule '_/5 _ \* \* \*' or
+Scripts and flows can also be triggered by a cron schedule '*/5 * * * *' or
 through webhooks.
 
 You can build your entire infra on top of Windmill!
@@ -83,49 +82,46 @@ You can build your entire infra on top of Windmill!
 ## Show me some actual script code
 
 ```typescript
-import * as wmill from "https://deno.land/x/windmill@v1.62.0/mod.ts";
+import * as wmill from "https://deno.land/x/windmill@v1.62.0/mod.ts"
 //import any dependency  from npm
 
-import cowsay from "npm:cowsay@1.5.0";
+import cowsay from 'npm:cowsay@1.5.0'
 
 export async function main(
-  a: number,
-  // unions generate enums
-  b: "my" | "enum",
-  // default parameters prefill the field
-  d = "default arg",
-  // nested objects work c = { nested: "object" },
-  // permissioned and typed json
-  db: wmill.Resource<"postgresql">
-) {
-  const email = Deno.env.get("WM_EMAIL");
-  // variables are permissioned and by path
-  let variable = await wmill.getVariable("f/company-folder/my_secret");
-  const lastTimeRun = await wmill.getState();
-  // logs are printed and always inspectable
-  console.log(cowsay.say({ text: "hello " + email + " " + lastTimeRun }));
-  await wmill.setState(Date.now());
+    a: number,
+    // unions generate enums
+    b: "my" | "enum",
+    // default parameters prefill the field 
+    d = "default arg",
+    // nested objects work c = { nested: "object" }, 
+    // permissioned and typed json
+    db: wmill.Resource<"postgresql">) {
 
-  // return is serialized as JSON
-  return { foo: d, variable };
+    const email = Deno.env.get('WM_EMAIL')
+    // variables are permissioned and by path
+    let variable = await wmill.getVariable('f/company-folder/my_secret')
+    const lastTimeRun = await wmill.getState()
+    // logs are printed and always inspectable
+    console.log(cowsay.say({ text: "hello " + email + " " + lastTimeRun }))
+    await wmill.setState(Date.now())
+
+    // return is serialized as JSON
+    return { foo: d, variable };
 }
 ```
 
 ## CLI
 
 We have a powerful CLI to interact with the windmill platform and sync your
-scripts from local files, github repos and to run scripts and flows on the
-instance from local commands. See
+scripts from local files, github repos and to run scripts and flows on the instance from local commands. See
 [more details](https://github.com/windmill-labs/windmill/tree/main/cli)
 
 ![CLI Screencast](./cli/vhs/output/setup.gif)
 
+
 ### Running scripts locally
 
-You can run your script locally easily, you simply need to pass the right
-environment variables for the `wmill` client library to fetch resource and
-variables from your instance if necessary. See more:
-<https://docs.windmill.dev/docs/advanced/local_development/>
+You can run your script locally easily, you simply need to pass the right environment variables for the `wmill` client library to fetch resource and variables from your instance if necessary. See more: <https://docs.windmill.dev/docs/advanced/local_development/>
 
 ## Stack
 
@@ -186,19 +182,15 @@ compiling from source or using without a postgres super user, see
 
 ### Docker compose
 
-```
-curl https://github.com/windmill-labs/windmill/blob/main/docker-compose.yml -o docker-compose.yml
-curl https://github.com/windmill-labs/windmill/blob/main/CaddyFile -o Caddyfile
-curl https://github.com/windmill-labs/windmill/blob/main/.env -o .env
-
-docker compose up -d --pull always
-```
+`docker compose up` with the following docker-compose is sufficient:
+<https://github.com/windmill-labs/windmill/blob/main/docker-compose.yml>
 
 Go to http://localhost et voilà :)
 
+
 The default super-admin user is: admin@windmill.dev / changeme
 
-From there, you can follow the setup app and creat other users.
+From there, you can create other users (do not forget to change the password!)
 
 ### Kubernetes (k8s) and Helm charts
 
@@ -207,9 +199,9 @@ We publish helm charts at:
 
 ### Postgres without superuser
 
-If you do not want, or cannot (for instance, in AWS Aurora or Cloud sql) use a
-postgres superuser, you can run `./init-db-as-superuser.sql` to init the
-required users for windmill.
+If you do not want, or cannot (for instance, in AWS Aurora or Cloud sql) use a postgres superuser,
+you can run `./init-db-as-superuser.sql` to init the required users for windmill.
+
 
 ### Commercial license
 
@@ -283,8 +275,8 @@ You may also add your own custom OAuth2 IdP and OAuth2 Resource provider:
 ### Resource types
 
 You will also want to import all the approved resource types from
-[WindmillHub](https://hub.windmill.dev). A setup script will prompt you to have
-it being synced automatically everyday.
+[WindmillHub](https://hub.windmill.dev). A setup script will prompt
+you to have it being synced automatically everyday.
 
 ## Environment Variables
 
@@ -292,17 +284,14 @@ it being synced automatically everyday.
 | ------------------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
 | DATABASE_URL              |                        | The Postgres database url.                                                                                                                                                                         | All                   |
 | DISABLE_NSJAIL            | true                   | Disable Nsjail Sandboxing                                                                                                                                                                          | Worker                |
-| SERVER_BIND_ADDR          | 0.0.0.0                | IP Address on which to bind listening socket                                                                                                                                                       | Server                |
-| PORT                      | 8000                   | Exposed port                                                                                                                                                                                       | Server                |
+| PORT                      | 8000                   | Exposed port                                                                                                                                                                                       | Server                |  |
 | NUM_WORKERS               | 3                      | The number of worker per Worker instance (set to 1 on Eks to have 1 pod = 1 worker, set to 0 for an API only instance)                                                                             | Worker                |
 | DISABLE_SERVER            | false                  | Binary would operate as a worker only instance                                                                                                                                                     | Worker                |
 | METRICS_ADDR              | None                   | The socket addr at which to expose Prometheus metrics at the /metrics path. Set to "true" to expose it on port 8001                                                                                | All                   |
 | JSON_FMT                  | false                  | Output the logs in json format instead of logfmt                                                                                                                                                   | All                   |
 | BASE_URL                  | http://localhost:8000  | The base url that is exposed publicly to access your instance                                                                                                                                      | Server                |
 | BASE_INTERNAL_URL         | http://localhost:8000  | The base url that is reachable by your workers to talk to the Servers. This help avoiding going through the external load balancer for VPC-internal requests.                                      | Worker                |
-| TIMEOUT                   | 300                    | The maximum time of execution of a script. When reached, the job is failed as having timedout.                                                                                                     | Worker                |
-| ZOMBIE_JOB_TIMEOUT        | 30                     | The timeout after which a job is considered to be zombie if the worker did not send pings about processing the job (every server check for zombie jobs every 30s)                                  | Server                |
-| RESTART_ZOMBIE_JOBS       | true                   | If true then a zombie job is restarted (in-place with the same uuid and some logs), if false the zombie job is failed                                                                              | Server                |
+| TIMEOUT                   | 300                    | The timeout in seconds for the execution of a script                                                                                                                                               | Worker                |
 | SLEEP_QUEUE               | 50                     | The number of ms to sleep in between the last check for new jobs in the DB. It is multiplied by NUM_WORKERS such that in average, for one worker instance, there is one pull every SLEEP_QUEUE ms. | Worker                |
 | MAX_LOG_SIZE              | 500000                 | The maximum number of characters a job can emit (log + result)                                                                                                                                     | Worker                |
 | DISABLE_NUSER             | false                  | If Nsjail is enabled, disable the nsjail's `clone_newuser` setting                                                                                                                                 | Worker                |
@@ -311,7 +300,7 @@ it being synced automatically everyday.
 | S3_CACHE_BUCKET (EE only) | None                   | The S3 bucket to sync the cache of the workers to                                                                                                                                                  | Worker                |
 | TAR_CACHE_RATE (EE only)  | 100                    | The rate at which to tar the cache of the workers. 100 means every 100th job in average (uniformly randomly distributed).                                                                          | Worker                |
 | SLACK_SIGNING_SECRET      | None                   | The signing secret of your Slack app. See [Slack documentation](https://api.slack.com/authentication/verifying-requests-from-slack)                                                                | Server                |
-| COOKIE_DOMAIN             | None                   | The domain of the cookie. If not set, the cookie will be set by the browser based on the full origin                                                                                               | Server                |
+| COOKIE_DOMAIN             | None                   | The domain of the cookie. If not set, the cookie will be set by the browser based on the full origin                                                                                               | Server                |  |
 | DENO_PATH                 | /usr/bin/deno          | The path to the deno binary.                                                                                                                                                                       | Worker                |
 | PYTHON_PATH               | /usr/local/bin/python3 | The path to the python binary.                                                                                                                                                                     | Worker                |
 | GO_PATH                   | /usr/bin/go            | The path to the go binary.                                                                                                                                                                         | Worker                |
@@ -326,7 +315,6 @@ it being synced automatically everyday.
 | 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                |
 | DENO_FLAGS                | None                   | Override the flags passed to deno (default --allow-all) to tighten permissions. Minimum permissions needed are "--allow-read=args.json --allow-write=result.json"                                  | Worker                |
-| NPM_CONFIG_REGISTRY       | None                   | Registry to use for NPM dependencies, set if you have a private repository you need to use instead of the default public NPM registry                                                              | Worker                |
 | PIP_LOCAL_DEPENDENCIES    | None                   | Specify dependencies that are installed locally and do not need to be solved nor installed again                                                                                                   |                       |
 | ADDITIONAL_PYTHON_PATHS   | None                   | Specify python paths (separated by a :) to be appended to the PYTHONPATH of the python jobs. To be used with PIP_LOCAL_DEPENDENCIES to use python codebases within Windmill                        | Worker                |
 | INCLUDE_HEADERS           | None                   | Whitelist of headers that are passed to jobs as args (separated by a comma)                                                                                                                        | Server                |

backend/.cargo/config.toml

@@ -8,14 +8,3 @@ rustflags = [
 ]
 incremental = true
 
-[target.x86_64-apple-darwin]
-rustflags = [
-    "-C", "link-arg=-undefined",
-    "-C", "link-arg=dynamic_lookup",
-]
-
-[target.aarch64-apple-darwin]
-rustflags = [
-    "-C", "link-arg=-undefined",
-    "-C", "link-arg=dynamic_lookup",
-]

backend/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "windmill"
-version = "1.86.0"
+version = "1.70.1"
 authors.workspace = true
 edition.workspace = true
 
@@ -19,7 +19,7 @@ members = [
 ]
 
 [workspace.package]
-version = "1.86.0"
+version = "1.70.1"
 authors = ["Ruben Fiszel <ruben@windmill.dev>"]
 edition = "2021"
 
@@ -76,7 +76,7 @@ headers = "^0"
 hyper = { version = "^0", features = ["full"] }
 tokio = { version = "^1", features = ["full", "tracing"] }
 tower = "^0"
-tower-http = { version = "^0", features = ["trace", "cors"] }
+tower-http = { version = "^0", features = ["trace"] }
 tower-cookies = "^0"
 serde = "^1"
 serde_json = { version = "^1", features = ["preserve_order"] }
@@ -84,7 +84,6 @@ uuid = { version = "^1", features = ["serde", "v4"] }
 thiserror = "^1"
 anyhow = "^1"
 chrono = { version = "^0", features = ["serde"] }
-chrono-tz = "^0"
 tracing = "^0"
 tracing-subscriber = { version = "^0", features = ["env-filter", "json"] }
 prometheus = { version = "^0", default-features = false }
@@ -123,9 +122,9 @@ itertools = "^0"
 regex = "^1"
 deno_core = "^0"
 async-recursion = "^1"
-swc_common = "0.29.39"
-swc_ecma_parser = "0.128.2"
-swc_ecma_ast = "0.98.1"
+swc_common = "^0"
+swc_ecma_parser = "^0"
+swc_ecma_ast = "^0"
 base64 = "0.21.0"
 unicode-general-category = "^0"
 hmac = "0.12.1"
@@ -154,4 +153,3 @@ async-stripe = { version = "0.14", features = [
     "checkout",
 ] }
 async_zip = { version = "0.0.11", features = ["full"] }
-once_cell = "1.17.1"

backend/migrations/20230303064952_add_root_leaf_jobs.down.sql

@@ -1 +0,0 @@
--- Add down migration script here

backend/migrations/20230303064952_add_root_leaf_jobs.up.sql

@@ -1,3 +0,0 @@
--- Add up migration script here
-ALTER TABLE queue ADD COLUMN root_job uuid;
-ALTER TABLE queue ADD COLUMN leaf_jobs jsonb;

backend/migrations/20230327115727_update_app_setup.down.sql

@@ -1 +0,0 @@
--- Add down migration script here

backend/migrations/20230327201258_add_granular_share_apps.down.sql

@@ -1 +0,0 @@
--- Add down migration script here

backend/migrations/20230327201258_add_granular_share_apps.up.sql

@@ -1,11 +0,0 @@
--- Add up migration script here
-CREATE POLICY see_extra_perms_user ON app FOR ALL
-USING (extra_perms ? CONCAT('u/', current_setting('session.user')))
-WITH CHECK ((extra_perms ->> CONCAT('u/', current_setting('session.user')))::boolean);
-
-CREATE POLICY see_extra_perms_groups ON app FOR ALL
-USING (extra_perms ?| regexp_split_to_array(current_setting('session.pgroups'), ',')::text[])
-WITH CHECK (exists(
-    SELECT key, value FROM jsonb_each_text(extra_perms) 
-    WHERE SPLIT_PART(key, '/', 1) = 'g' AND key = ANY(regexp_split_to_array(current_setting('session.pgroups'), ',')::text[])
-    AND value::boolean));

backend/migrations/20230405071524_schedule_timezone.down.sql

@@ -1,2 +0,0 @@
-ALTER TABLE schedule DROP COLUMN timezone;
-ALTER TABLE schedule ADD COLUMN offset_ INTEGER NOT NULL DEFAULT 0;

backend/migrations/20230405071524_schedule_timezone.up.sql

@@ -1,26 +0,0 @@
-ALTER TABLE schedule ADD COLUMN timezone VARCHAR(255) NOT NULL DEFAULT 'UTC';
-
--- INSERT the correct IANA timezone string for each offset value
-
-UPDATE schedule SET timezone = 'Pacific/Honolulu' WHERE offset_ = 600;
-UPDATE schedule SET timezone = 'America/Anchorage' WHERE offset_ = 540;
-UPDATE schedule SET timezone = 'America/Los_Angeles' WHERE offset_ = 480;
-UPDATE schedule SET timezone = 'America/Chicago' WHERE offset_ = 360;
-UPDATE schedule SET timezone = 'America/New_York' WHERE offset_ = 300;
-UPDATE schedule SET timezone = 'America/Halifax' WHERE offset_ = 240;
-UPDATE schedule SET timezone = 'America/Sao_Paulo' WHERE offset_ = 180;
-UPDATE schedule SET timezone = 'Atlantic/South_Georgia' WHERE offset_ = 120;
-UPDATE schedule SET timezone = 'Atlantic/Cape_Verde' WHERE offset_ = 60;
-UPDATE schedule SET timezone = 'Europe/London' WHERE offset_ = 0;
-UPDATE schedule SET timezone = 'Europe/Berlin' WHERE offset_ = -60;
-UPDATE schedule SET timezone = 'Europe/Athens' WHERE offset_ = -120;
-UPDATE schedule SET timezone = 'Europe/Moscow' WHERE offset_ = -180;
-UPDATE schedule SET timezone = 'Asia/Dubai' WHERE offset_ = -240;
-UPDATE schedule SET timezone = 'Asia/Aqtau' WHERE offset_ = -300;
-UPDATE schedule SET timezone = 'Asia/Almaty' WHERE offset_ = -360;
-UPDATE schedule SET timezone = 'Asia/Bangkok' WHERE offset_ = -420;
-UPDATE schedule SET timezone = 'Asia/Hong_Kong' WHERE offset_ = -480;
-UPDATE schedule SET timezone = 'Asia/Tokyo' WHERE offset_ = -540;
-UPDATE schedule SET timezone = 'Australia/Sydney' WHERE offset_ = -600;
-
-ALTER TABLE schedule DROP COLUMN offset_;

backend/migrations/20230405195753_relax_varchar_restrictions.down.sql

@@ -1 +0,0 @@
--- Add down migration script here

backend/migrations/20230405195753_relax_varchar_restrictions.up.sql

@@ -1,3 +0,0 @@
--- Add up migration script here
-ALTER TABLE password ALTER COLUMN company TYPE VARCHAR(255);
-ALTER TABLE password ALTER COLUMN name TYPE VARCHAR(255);

backend/parsers/windmill-parser-bash/Cargo.toml

@@ -16,5 +16,4 @@ unicode-general-category.workspace = true
 itertools.workspace = true
 anyhow.workspace = true
 regex.workspace = true
-lazy_static.workspace = true
-serde_json.workspace = true
+lazy_static.workspace = true

backend/parsers/windmill-parser-bash/src/lib.rs

@@ -1,8 +1,6 @@
 #![allow(non_snake_case)] // TODO: switch to parse_* function naming
 
-use anyhow::anyhow;
 use regex::Regex;
-use serde_json::json;
 
 use std::collections::HashMap;
 use windmill_parser::{Arg, MainArgSignature, Typ};
@@ -19,32 +17,19 @@ pub fn parse_bash_sig(code: &str) -> windmill_common::error::Result<MainArgSigna
     }
 }
 
-lazy_static::lazy_static! {
-    static ref RE: Regex = Regex::new(r#"(?m)^(\w+)="\$(?:(\d+)|\{(\d+):-(.*)\})"$"#).unwrap();
-}
-
 fn parse_file(code: &str) -> anyhow::Result<Option<Vec<Arg>>> {
-    let mut hm: HashMap<i32, (String, Option<String>)> = HashMap::new();
-    for cap in RE.captures_iter(code) {
-        hm.insert(
-            cap.get(2)
-                .or(cap.get(3))
-                .and_then(|x| x.as_str().parse::<i32>().ok())
-                .ok_or_else(|| anyhow!("Impossible to parse arg digit"))?,
-            (
-                cap[1].to_string(),
-                cap.get(4).map(|x| x.as_str().to_string()),
-            ),
-        );
+    let mut hm = HashMap::new();
+    let re = Regex::new(r#"(?m)^(\w+)="\$(\d+)"$"#).unwrap();
+    for cap in re.captures_iter(code) {
+        hm.insert(cap[2].parse::<i32>()?, cap[1].to_string());
     }
     let mut args = vec![];
     for i in 1..20 {
         if hm.contains_key(&i) {
-            let (name, default) = hm.get(&i).unwrap();
             args.push(Arg {
-                name: name.clone(),
+                name: hm[&i].clone(),
                 typ: Typ::Str(None),
-                default: default.clone().map(|x| json!(x)),
+                default: None,
                 otyp: None,
                 has_default: false,
             });
@@ -58,8 +43,6 @@ fn parse_file(code: &str) -> anyhow::Result<Option<Vec<Arg>>> {
 #[cfg(test)]
 mod tests {
 
-    use serde_json::json;
-
     use super::*;
 
     #[test]
@@ -67,7 +50,8 @@ mod tests {
         let code = r#"
 token="$1"
 image="$2"
-digest="${3:-latest with spaces}"
+digest="${3:-latest}"
+foo="$4"
 
 "#;
         //println!("{}", serde_json::to_string()?);
@@ -90,13 +74,6 @@ digest="${3:-latest with spaces}"
                         typ: Typ::Str(None),
                         default: None,
                         has_default: false
-                    },
-                    Arg {
-                        otyp: None,
-                        name: "digest".to_string(),
-                        typ: Typ::Str(None),
-                        default: Some(json!("latest with spaces")),
-                        has_default: false
                     }
                 ]
             }

backend/parsers/windmill-parser-go/src/lib.rs

@@ -58,9 +58,6 @@ fn parse_go_typ(typ: &parser_go_ast::Expr) -> (Option<String>, Typ) {
             Some((*name).to_string()),
             match *name {
                 "int" => Typ::Int,
-                "int16" => Typ::Int,
-                "int32" => Typ::Int,
-                "int64" => Typ::Int,
                 "string" => Typ::Str(None),
                 "bool" => Typ::Bool,
                 _ => Typ::Unknown,

backend/parsers/windmill-parser-py/src/lib.rs

@@ -181,7 +181,6 @@ static PYTHON_IMPORTS_REPLACEMENT: phf::Map<&'static str, &'static str> = phf_ma
     "git" => "GitPython",
     "u" => "requests",
     "f" => "requests",
-    "." => "requests",
     "shopify" => "ShopifyAPI",
     "seleniumwire" => "selenium-wire",
     "openbb-terminal" => "openbb[all]",
@@ -225,22 +224,13 @@ pub fn parse_python_imports(code: &str) -> error::Result<Vec<String>> {
                     StmtKind::Import { names } => Some(
                         names
                             .into_iter()
-                            .map(|x| {
-                                let name = x.node.name;
-                                if name.starts_with('.') {
-                                    ".".to_string()
-                                } else {
-                                    name.split('.').next().unwrap_or("").to_string()
-                                }
-                            })
+                            .map(|x| x.node.name.split('.').next().unwrap_or("").to_string())
                             .map(replace_import)
                             .collect::<Vec<String>>(),
                     ),
-                    StmtKind::ImportFrom { level: Some(i), .. } if i > 0 => {
-                        Some(vec!["requests".to_string()])
-                    }
                     StmtKind::ImportFrom { level: _, module: Some(mod_), names: _ } => {
                         let imprt = mod_.split('.').next().unwrap_or("").replace("_", "-");
+
                         Some(vec![replace_import(imprt)])
                     }
                     _ => None,
@@ -452,7 +442,6 @@ import os
 import wmill
 from zanzibar.estonie import talin
 import matplotlib.pyplot as plt
-from . import tests
 
 def main():
     pass
@@ -460,7 +449,7 @@ def main():
 ";
         let r = parse_python_imports(code)?;
         // println!("{}", serde_json::to_string(&r)?);
-        assert_eq!(r, vec!["wmill", "zanzibar", "matplotlib", "requests"]);
+        assert_eq!(r, vec!["wmill", "zanzibar", "matplotlib"]);
         Ok(())
     }
 

backend/parsers/windmill-parser-ts/src/lib.rs

@@ -246,7 +246,7 @@ fn tstype_to_typ(ts_type: &TsType) -> (Typ, bool) {
 pub fn eval_sync(code: &str) -> Result<serde_json::Value, String> {
     let mut context = JsRuntime::new(RuntimeOptions::default());
     let code = format!("let x = {}; x", code);
-    let res = context.execute_script("<anon>", code);
+    let res = context.execute_script("<anon>", &code);
     match res {
         Ok(global) => {
             let scope = &mut context.handle_scope();

backend/src/ee.rs

@@ -1,6 +1,4 @@
 #[cfg(feature = "enterprise")]
-use base64::Engine;
-#[cfg(feature = "enterprise")]
 use rsa::{pkcs8::DecodePublicKey, signature::Verifier};
 #[cfg(feature = "enterprise")]
 use sha2::Sha256;
@@ -13,9 +11,9 @@ pub fn verify_license_key(license_key: Option<String>) -> anyhow::Result<()> {
             .expect("license_key can be splitted with a .");
 
         let pub_key = rsa::RsaPublicKey::from_public_key_der(
-    &base64::engine::general_purpose::STANDARD.decode("MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDgVShzcLSPiOi+8ET8fggob1kmi47/cE12JaidPkwfGnScZItghkqtiLsct0U4kJhlp5gO89DYTBmIKadvxwY7kMsLlZzmi2emVH7c27cByGASY8QmWDNdG4Ggy/NDflGGBdAtN6gHawZAg4zHv3qpbPQGHH1/6sXIohcXhOnouwIDAQAB")?)?;
-        let msg = base64::engine::general_purpose::STANDARD.decode(splitted_lk.0)?;
-        let signature = base64::engine::general_purpose::STANDARD.decode(splitted_lk.1)?;
+    &base64::decode("MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDgVShzcLSPiOi+8ET8fggob1kmi47/cE12JaidPkwfGnScZItghkqtiLsct0U4kJhlp5gO89DYTBmIKadvxwY7kMsLlZzmi2emVH7c27cByGASY8QmWDNdG4Ggy/NDflGGBdAtN6gHawZAg4zHv3qpbPQGHH1/6sXIohcXhOnouwIDAQAB")?)?;
+        let msg = base64::decode(splitted_lk.0)?;
+        let signature = base64::decode(splitted_lk.1)?;
         rsa::pss::VerifyingKey::<Sha256>::new(pub_key)
             .verify(&msg, &rsa::pss::Signature::from(signature))
             .map_err(|_| anyhow::anyhow!("Invalid license key".to_string()))?;

backend/src/main.rs

@@ -6,7 +6,7 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::net::SocketAddr;
 
 use git_version::git_version;
 use sqlx::{Pool, Postgres};
@@ -15,7 +15,6 @@ use windmill_common::utils::rd_string;
 const GIT_VERSION: &str = git_version!(args = ["--tag", "--always"], fallback = "unknown-version");
 const DEFAULT_NUM_WORKERS: usize = 3;
 const DEFAULT_PORT: u16 = 8000;
-const DEFAULT_SERVER_BIND_ADDR: Ipv4Addr = Ipv4Addr::new(0, 0, 0, 0);
 
 mod ee;
 
@@ -40,11 +39,6 @@ async fn main() -> anyhow::Result<()> {
         .transpose()?
         .flatten();
 
-    let server_bind_address: IpAddr = std::env::var("SERVER_BIND_ADDR")
-        .ok()
-        .and_then(|x| x.parse().ok())
-        .unwrap_or(IpAddr::from(DEFAULT_SERVER_BIND_ADDR));
-
     let port: u16 = std::env::var("PORT")
         .ok()
         .and_then(|x| x.parse::<u16>().ok())
@@ -66,66 +60,8 @@ async fn main() -> anyhow::Result<()> {
     let (tx, rx) = tokio::sync::broadcast::channel::<()>(3);
     let shutdown_signal = windmill_common::shutdown_signal(tx);
 
-    #[cfg(feature = "enterprise")]
-    tracing::info!(
-        "
-##############################
-Windmill Enterprise Edition {GIT_VERSION}
-##############################"
-    );
-
-    #[cfg(not(feature = "enterprise"))]
-    tracing::info!(
-        "
-##############################
-Windmill Community Edition {GIT_VERSION}
-##############################"
-    );
-
-    display_config(vec![
-        "DISABLE_NSJAIL",
-        "DISABLE_SERVER",
-        "NUM_WORKERS",
-        "METRICS_ADDR",
-        "JSON_FMT",
-        "BASE_URL",
-        "BASE_INTERNAL_URL",
-        "TIMEOUT",
-        "ZOMBIE_JOB_TIMEOUT",
-        "RESTART_ZOMBIE_JOBS",
-        "SLEEP_QUEUE",
-        "MAX_LOG_SIZE",
-        "SERVER_BIND_ADDR",
-        "PORT",
-        "KEEP_JOB_DIR",
-        "S3_CACHE_BUCKET",
-        "TAR_CACHE_RATE",
-        "COOKIE_DOMAIN",
-        "PYTHON_PATH",
-        "DENO_PATH",
-        "GO_PATH",
-        "PIP_INDEX_URL",
-        "PIP_EXTRA_INDEX_URL",
-        "PIP_TRUSTED_HOST",
-        "PATH",
-        "HOME",
-        "DATABASE_CONNECTIONS",
-        "TIMEOUT_WAIT_RESULT",
-        "QUEUE_LIMIT_WAIT_RESULT",
-        "DENO_AUTH_TOKENS",
-        "DENO_FLAGS",
-        "NPM_CONFIG_REGISTRY",
-        "PIP_LOCAL_DEPENDENCIES",
-        "ADDITIONAL_PYTHON_PATHS",
-        "INCLUDE_HEADERS",
-        "WHITELIST_WORKSPACES",
-        "BLACKLIST_WORKSPACES",
-        "NEW_USER_WEBHOOK",
-        "CLOUD_HOSTED",
-    ]);
-
     if server_mode || num_workers > 0 {
-        let addr = SocketAddr::from((server_bind_address, port));
+        let addr = SocketAddr::from(([0, 0, 0, 0], port));
 
         let server_f = async {
             if server_mode {
@@ -136,6 +72,60 @@ Windmill Community Edition {GIT_VERSION}
 
         let workers_f = async {
             if num_workers > 0 {
+                #[cfg(feature = "enterprise")]
+                tracing::info!(
+                    "
+##############################
+Windmill Enterprise Edition {GIT_VERSION}
+##############################"
+                );
+
+                #[cfg(not(feature = "enterprise"))]
+                tracing::info!(
+                    "
+##############################
+Windmill Community Edition {GIT_VERSION}
+##############################"
+                );
+
+                display_config(vec![
+                    "DISABLE_NSJAIL",
+                    "DISABLE_SERVER",
+                    "NUM_WORKERS",
+                    "METRICS_ADDR",
+                    "JSON_FMT",
+                    "BASE_URL",
+                    "BASE_INTERNAL_URL",
+                    "TIMEOUT",
+                    "SLEEP_QUEUE",
+                    "MAX_LOG_SIZE",
+                    "PORT",
+                    "KEEP_JOB_DIR",
+                    "S3_CACHE_BUCKET",
+                    "TAR_CACHE_RATE",
+                    "COOKIE_DOMAIN",
+                    "PYTHON_PATH",
+                    "DENO_PATH",
+                    "GO_PATH",
+                    "PIP_INDEX_URL",
+                    "PIP_EXTRA_INDEX_URL",
+                    "PIP_TRUSTED_HOST",
+                    "PATH",
+                    "HOME",
+                    "DATABASE_CONNECTIONS",
+                    "TIMEOUT_WAIT_RESULT",
+                    "QUEUE_LIMIT_WAIT_RESULT",
+                    "DENO_AUTH_TOKENS",
+                    "DENO_FLAGS",
+                    "PIP_LOCAL_DEPENDENCIES",
+                    "ADDITIONAL_PYTHON_PATHS",
+                    "INCLUDE_HEADERS",
+                    "WHITELIST_WORKSPACES",
+                    "BLACKLIST_WORKSPACES",
+                    "NEW_USER_WEBHOOK",
+                    "CLOUD_HOSTED",
+                ]);
+
                 run_workers(
                     db.clone(),
                     rx.resubscribe(),
@@ -156,18 +146,14 @@ Windmill Community Edition {GIT_VERSION}
 
         let metrics_f = async {
             match metrics_addr {
-                Some(addr) => {
-                    windmill_common::serve_metrics(addr, rx.resubscribe(), num_workers > 0)
-                        .await
-                        .map_err(anyhow::Error::from)
-                }
+                Some(addr) => windmill_common::serve_metrics(addr, rx.resubscribe())
+                    .await
+                    .map_err(anyhow::Error::from),
                 None => Ok(()),
             }
         };
 
         futures::try_join!(shutdown_signal, server_f, metrics_f, workers_f, monitor_f)?;
-    } else {
-        tracing::info!("Nothing to do, exiting.");
     }
     Ok(())
 }

backend/tests/worker.rs

@@ -154,12 +154,12 @@ mod suspend_resume {
         serde_json::from_value(serde_json::json!({
                 "modules": [{
                     "id": "a",
+                    "input_transform": {
+                        "n": { "type": "javascript", "expr": "flow_input.n", },
+                        "port": { "type": "javascript", "expr": "flow_input.port", },
+                        "op": { "type": "javascript", "expr": "flow_input.op ?? 'resume'", },
+                    },
                     "value": {
-                        "input_transforms": {
-                            "n": { "type": "javascript", "expr": "flow_input.n", },
-                            "port": { "type": "javascript", "expr": "flow_input.port", },
-                            "op": { "type": "javascript", "expr": "flow_input.op ?? 'resume'", },
-                        },
                         "type": "rawscript",
                         "language": "deno",
                         "content": "\
@@ -193,12 +193,12 @@ mod suspend_resume {
                     },
                 }, {
                     "id": "b",
+                    "input_transform": {
+                        "n": { "type": "javascript", "expr": "results.a", },
+                        "resume": { "type": "javascript", "expr": "resume", },
+                        "resumes": { "type": "javascript", "expr": "resumes", },
+                    },
                     "value": {
-                        "input_transforms": {
-                            "n": { "type": "javascript", "expr": "results.a", },
-                            "resume": { "type": "javascript", "expr": "resume", },
-                            "resumes": { "type": "javascript", "expr": "resumes", },
-                        },
                         "type": "rawscript",
                         "language": "deno",
                         "content": "export function main(n, resume, resumes) { return { n: n + 1, resume, resumes } }"
@@ -207,12 +207,12 @@ mod suspend_resume {
                         "required_events": 1
                     },
                 }, {
+                    "input_transform": {
+                        "last": { "type": "javascript", "expr": "results.b", },
+                        "resume": { "type": "javascript", "expr": "resume", },
+                        "resumes": { "type": "javascript", "expr": "resumes", },
+                    },
                     "value": {
-                        "input_transforms": {
-                            "last": { "type": "javascript", "expr": "results.b", },
-                            "resume": { "type": "javascript", "expr": "resume", },
-                            "resumes": { "type": "javascript", "expr": "resumes", },
-                        },
                         "type": "rawscript",
                         "language": "deno",
                         "content": "export function main(last, resume, resumes) { return { last, resume, resumes } }"
@@ -477,11 +477,11 @@ def main(last, port):
                     "iterator": { "type": "javascript", "expr": "flow_input.items" },
                     "skip_failures": false,
                     "modules": [{
+                        "input_transform": {
+                            "index": { "type": "javascript", "expr": "flow_input.iter.index" },
+                            "port": { "type": "javascript", "expr": "flow_input.port" },
+                        },
                         "value": {
-                            "input_transforms": {
-                                "index": { "type": "javascript", "expr": "flow_input.iter.index" },
-                                "port": { "type": "javascript", "expr": "flow_input.port" },
-                            },
                             "type": "rawscript",
                             "language": "deno",
                             "content": inner_step(),
@@ -490,11 +490,11 @@ def main(last, port):
                 },
                 "retry": { "constant": { "attempts": 2, "seconds": 0 } },
             }, {
+                "input_transform": {
+                    "last": { "type": "javascript", "expr": "results.a" },
+                    "port": { "type": "javascript", "expr": "flow_input.port" },
+                },
                 "value": {
-                    "input_transforms": {
-                        "last": { "type": "javascript", "expr": "results.a" },
-                        "port": { "type": "javascript", "expr": "flow_input.port" },
-                    },
                     "type": "rawscript",
                     "language": "python3",
                     "content": last_step(),
@@ -632,7 +632,7 @@ def main(last, port):
             "modules": [{
                 "id": "a",
                 "value": {
-                    "input_transforms": { "port": { "type": "javascript", "expr": "flow_input.port" } },
+                    "input_transform": { "port": { "type": "javascript", "expr": "flow_input.port" } },
                     "type": "rawscript",
                     "language": "python3",
                     "content": r#"
@@ -645,7 +645,7 @@ def main(port):
             }],
             "failure_module": {
                 "value": {
-                    "input_transforms": { "error": { "type": "javascript", "expr": "previous_result", },
+                    "input_transform": { "error": { "type": "javascript", "expr": "previous_result", },
                         "port": { "type": "javascript", "expr": "flow_input.port" } },
                     "type": "rawscript",
                     "language": "python3",
@@ -686,7 +686,7 @@ def main(error, port):
             result,
             json!({
                 "recv": 42,
-                "from failure module": {"error": {"name": "IndexError", "stack": "  File \"/tmp/tmp/main/step_0.py\", line 5, in main\n    return sock.recv(1)[0]\n", "message": "index out of range"}},
+                "from failure module": {"error": {"name": "IndexError", "stack": "  File \"/tmp/inner.py\", line 5, in main\n    return sock.recv(1)[0]\n", "message": "index out of range"}},
             })
         );
     }
@@ -705,13 +705,13 @@ async fn test_iteration(db: Pool<Postgres>) {
                 "iterator": { "type": "javascript", "expr": "result.items" },
                 "skip_failures": false,
                 "modules": [{
-                    "value": {
-                        "input_transforms": {
-                            "n": {
-                                "type": "javascript",
-                                "expr": "flow_input.iter.value",
-                            },
+                    "input_transform": {
+                        "n": {
+                            "type": "javascript",
+                            "expr": "flow_input.iter.value",
                         },
+                    },
+                    "value": {
                         "type": "rawscript",
                         "language": "python3",
                         "content": "def main(n):\n    if 1 < n:\n        raise StopIteration(n)",
@@ -762,13 +762,13 @@ async fn test_iteration_parallel(db: Pool<Postgres>) {
                 "skip_failures": false,
                 "parallel": true,
                 "modules": [{
-                    "value": {
-                        "input_transforms": {
-                            "n": {
-                                "type": "javascript",
-                                "expr": "flow_input.iter.value",
-                            },
+                    "input_transform": {
+                        "n": {
+                            "type": "javascript",
+                            "expr": "flow_input.iter.value",
                         },
+                    },
+                    "value": {
                         "type": "rawscript",
                         "language": "python3",
                         "content": "def main(n):\n    if 1 < n:\n        raise StopIteration(n)",
@@ -836,7 +836,6 @@ impl RunJob {
             /* scheduled_for_o */ None,
             /* schedule_path */ None,
             /* parent_job */ None,
-            /* root job  */ None,
             /* is_flow_step */ false,
             /* running */ false,
             None,
@@ -1001,6 +1000,7 @@ async fn test_deno_flow(db: Pool<Postgres>) {
                         path: None,
                         lock: None,
                     },
+                    input_transforms: Default::default(),
                     stop_after_if: Default::default(),
                     summary: Default::default(),
                     suspend: Default::default(),
@@ -1028,6 +1028,7 @@ async fn test_deno_flow(db: Pool<Postgres>) {
                                 path: None,
                                 lock: None,
                             },
+                            input_transforms: Default::default(),
                             stop_after_if: Default::default(),
                             summary: Default::default(),
                             suspend: Default::default(),
@@ -1035,6 +1036,7 @@ async fn test_deno_flow(db: Pool<Postgres>) {
                             sleep: None,
                         }],
                     },
+                    input_transforms: Default::default(),
                     stop_after_if: Default::default(),
                     summary: Default::default(),
                     suspend: Default::default(),
@@ -1128,6 +1130,7 @@ async fn test_deno_flow_same_worker(db: Pool<Postgres>) {
                         path: None,
                         lock: None,
                     },
+                    input_transforms: Default::default(),
                     stop_after_if: Default::default(),
                     summary: Default::default(),
                     suspend: Default::default(),
@@ -1143,24 +1146,25 @@ async fn test_deno_flow_same_worker(db: Pool<Postgres>) {
                         modules: vec![
                             FlowModule {
                                 id: "d".to_string(),
+                                input_transforms: [
+                                (
+                                    "i".to_string(),
+                                    InputTransform::Javascript {
+                                        expr: "flow_input.iter.value".to_string(),
+                                    },
+                                ),
+                                (
+                                    "loop".to_string(),
+                                    InputTransform::Static { value: json!(true) },
+                                ),
+                                (
+                                    "path".to_string(),
+                                    InputTransform::Static { value: json!("inner.txt") },
+                                ),
+                            ]
+                            .into(),
                                 value: FlowModuleValue::RawScript {
-                                    input_transforms: [
-                                        (
-                                            "i".to_string(),
-                                            InputTransform::Javascript {
-                                                expr: "flow_input.iter.value".to_string(),
-                                            },
-                                        ),
-                                        (
-                                            "loop".to_string(),
-                                            InputTransform::Static { value: json!(true) },
-                                        ),
-                                        (
-                                            "path".to_string(),
-                                            InputTransform::Static { value: json!("inner.txt") },
-                                        ),
-                                    ]
-                                    .into(),
+                                    input_transforms: [].into(),
                                     language: ScriptLang::Deno,
                                     content: write_file,
                                     path: None,
@@ -1191,6 +1195,7 @@ async fn test_deno_flow_same_worker(db: Pool<Postgres>) {
                                     path: None,
                                     lock: None,
                                 },
+                                input_transforms: [].into(),
                                 stop_after_if: Default::default(),
                                 summary: Default::default(),
                                 suspend: Default::default(),
@@ -1199,6 +1204,7 @@ async fn test_deno_flow_same_worker(db: Pool<Postgres>) {
                             },
                         ],
                     },
+                    input_transforms: Default::default(),
                     stop_after_if: Default::default(),
                     summary: Default::default(),
                     suspend: Default::default(),
@@ -1233,6 +1239,7 @@ async fn test_deno_flow_same_worker(db: Pool<Postgres>) {
                         path: None,
                         lock: None,
                     },
+                    input_transforms: [].into(),
                     stop_after_if: Default::default(),
                     summary: Default::default(),
                     suspend: Default::default(),
@@ -1429,6 +1436,7 @@ async fn test_python_flow(db: Pool<Postgres>) {
     let doubles = "def main(n): return n * 2";
 
     let flow: FlowValue = serde_json::from_value(serde_json::json!( {
+        "input_transform": {},
         "modules": [
             {
                 "value": {
@@ -1444,16 +1452,16 @@ async fn test_python_flow(db: Pool<Postgres>) {
                     "skip_failures": false,
                     "modules": [{
                         "value": {
-                            "input_transforms": {
-                                "n": {
-                                    "type": "javascript",
-                                    "expr": "flow_input.iter.value",
-                                },
-                            },
                             "type": "rawscript",
                             "language": "python3",
                             "content": doubles,
                         },
+                        "input_transform": {
+                            "n": {
+                                "type": "javascript",
+                                "expr": "flow_input.iter.value",
+                            },
+                        },
                     }],
                 },
             },
@@ -1486,11 +1494,11 @@ async fn test_python_flow_2(db: Pool<Postgres>) {
             "modules": [
                 {
                     "value": {
-                        "input_transforms": {},
                         "type": "rawscript",
                         "content": "import wmill\ndef main():  return \"Hello\"",
                         "language": "python3"
                     },
+                    "input_transform": {}
                 }
             ]
     }))
@@ -1669,7 +1677,7 @@ async fn test_empty_loop(db: Pool<Postgres>) {
                     "modules": [
                         {
                             "value": {
-                                "input_transforms": {
+                                "input_transform": {
                                     "n": {
                                         "type": "javascript",
                                         "expr": "flow_input.iter.value",
@@ -1685,7 +1693,7 @@ async fn test_empty_loop(db: Pool<Postgres>) {
             },
             {
                 "value": {
-                    "input_transforms": {
+                    "input_transform": {
                         "items": {
                             "type": "javascript",
                             "expr": "results.a",
@@ -1762,13 +1770,13 @@ async fn test_empty_loop_2(db: Pool<Postgres>) {
                     "iterator": { "type": "static", "value": [] },
                     "modules": [
                         {
-                            "value": {
-                                "input_transforms": {
-                                    "n": {
-                                        "type": "javascript",
-                                        "expr": "flow_input.iter.value",
-                                    },
+                            "input_transform": {
+                                "n": {
+                                    "type": "javascript",
+                                    "expr": "flow_input.iter.value",
                                 },
+                            },
+                            "value": {
                                 "type": "rawscript",
                                 "language": "python3",
                                 "content": "def main(n): return n",
@@ -1804,13 +1812,13 @@ async fn test_step_after_loop(db: Pool<Postgres>) {
                     "iterator": { "type": "static", "value": [2,3,4] },
                     "modules": [
                         {
-                            "value": {
-                                "input_transforms": {
-                                    "n": {
-                                        "type": "javascript",
-                                        "expr": "flow_input.iter.value",
-                                    },
+                            "input_transform": {
+                                "n": {
+                                    "type": "javascript",
+                                    "expr": "flow_input.iter.value",
                                 },
+                            },
+                            "value": {
                                 "type": "rawscript",
                                 "language": "python3",
                                 "content": "def main(n): return n",
@@ -1820,13 +1828,13 @@ async fn test_step_after_loop(db: Pool<Postgres>) {
                 },
             },
             {
-                "value": {
-                    "input_transforms": {
-                        "items": {
-                            "type": "javascript",
-                            "expr": "results.a",
-                        },
+                "input_transform": {
+                    "items": {
+                        "type": "javascript",
+                        "expr": "results.a",
                     },
+                },
+                "value": {
                     "type": "rawscript",
                     "language": "python3",
                     "content": "def main(items): return sum(items)",
@@ -1848,17 +1856,17 @@ async fn test_step_after_loop(db: Pool<Postgres>) {
 fn module_add_item_to_list(i: i32, id: &str) -> serde_json::Value {
     json!({
         "id": format!("id_{}", i.to_string().replace("-", "_")),
-        "value": {
-            "input_transforms": {
-                "array": {
-                    "type": "javascript",
-                    "expr": format!("results.{id}"),
-                },
-                "i": {
-                    "type": "static",
-                    "value": json!(i),
-                }
+        "input_transform": {
+            "array": {
+                "type": "javascript",
+                "expr": format!("results.{id}"),
             },
+            "i": {
+                "type": "static",
+                "value": json!(i),
+            }
+        },
+        "value": {
             "type": "rawscript",
             "language": "deno",
             "content": "export function main(array, i){ array.push(i); return array }",
@@ -1868,8 +1876,8 @@ fn module_add_item_to_list(i: i32, id: &str) -> serde_json::Value {
 
 fn module_failure() -> serde_json::Value {
     json!({
+        "input_transform": {},
         "value": {
-            "input_transforms": {},
             "type": "rawscript",
             "language": "deno",
             "content": "export function main(){ throw Error('failure') }",
@@ -2060,7 +2068,7 @@ async fn test_branchall_skip_failure(db: Pool<Postgres>) {
 
     assert_eq!(
         result,
-        serde_json::json!([{"error": {"name": "Error", "stack": "Error: failure\n    at main (file:///tmp/main.ts:1:31)\n    at run (file:///tmp/wrapper.ts:9:26)\n    at file:///tmp/wrapper.ts:14:1", "message": "failure"}}, [1,3]])
+        serde_json::json!([{"error": {"name": "Error", "stack": "Error: failure\n    at main (file:///tmp/inner.ts:1:31)\n    at run (file:///tmp/main.ts:9:26)\n    at file:///tmp/main.ts:14:1", "message": "failure"}}, [1,3]])
     );
 
     let flow: FlowValue = serde_json::from_value(json!({
@@ -2094,7 +2102,7 @@ async fn test_branchall_skip_failure(db: Pool<Postgres>) {
 
     assert_eq!(
         result,
-        serde_json::json!([ {"error": {"name": "Error", "stack": "Error: failure\n    at main (file:///tmp/main.ts:1:31)\n    at run (file:///tmp/wrapper.ts:9:26)\n    at file:///tmp/wrapper.ts:14:1", "message": "failure"}}, [1, 2]])
+        serde_json::json!([ {"error": {"name": "Error", "stack": "Error: failure\n    at main (file:///tmp/inner.ts:1:31)\n    at run (file:///tmp/main.ts:9:26)\n    at file:///tmp/main.ts:14:1", "message": "failure"}}, [1, 2]])
     );
 }
 
@@ -2227,7 +2235,7 @@ async fn test_failure_module(db: Pool<Postgres>) {
             "modules": [{
                 "id": "a",
                 "value": {
-                    "input_transforms": {
+                    "input_transform": {
                         "l": { "type": "javascript", "expr": "[]", },
                         "n": { "type": "javascript", "expr": "flow_input.n", },
                     },
@@ -2238,7 +2246,7 @@ async fn test_failure_module(db: Pool<Postgres>) {
             }, {
                 "id": "b",
                 "value": {
-                    "input_transforms": {
+                    "input_transform": {
                         "l": { "type": "javascript", "expr": "results.a.l", },
                         "n": { "type": "javascript", "expr": "flow_input.n", },
                     },
@@ -2248,7 +2256,7 @@ async fn test_failure_module(db: Pool<Postgres>) {
                 },
             }, {
                 "value": {
-                    "input_transforms": {
+                    "input_transform": {
                         "l": { "type": "javascript", "expr": "results.b.l", },
                         "n": { "type": "javascript", "expr": "flow_input.n", },
                     },
@@ -2258,8 +2266,8 @@ async fn test_failure_module(db: Pool<Postgres>) {
                 },
             }],
             "failure_module": {
+                "input_transform": { "error": { "type": "javascript", "expr": "previous_result", } },
                 "value": {
-                    "input_transforms": { "error": { "type": "javascript", "expr": "previous_result", } },
                     "type": "rawscript",
                     "language": "deno",
                     "content": "export function main(error) { return { 'from failure module': error } }",

backend/windmill-api/Cargo.toml

@@ -47,7 +47,6 @@ tracing.workspace = true
 sql-builder.workspace = true
 serde_json.workspace = true
 chrono.workspace = true
-chrono-tz.workspace = true
 hex.workspace = true
 base64.workspace = true
 serde_urlencoded.workspace = true
@@ -70,4 +69,3 @@ async-stripe = { workspace = true, optional = true }
 lazy_static.workspace = true
 prometheus.workspace = true
 async_zip.workspace = true
-regex.workspace = true

backend/windmill-api/openapi.yaml

@@ -1,7 +1,7 @@
 openapi: "3.0.3"
 
 info:
-  version: 1.86.0
+  version: 1.70.1
   title: Windmill API
 
   contact:
@@ -117,10 +117,9 @@ paths:
       responses:
         "200":
           description: >
-            Successfully authenticated. The session ID is returned in a cookie
-            named `token` and as plaintext response. Preferred method of
-            authorization is through the bearer token. The cookie is only for
-            browser convenience.
+            Successfully authenticated.
+            The session ID is returned in a cookie named `token` and as plaintext response.
+            Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
 
           headers:
             Set-Cookie:
@@ -205,6 +204,7 @@ paths:
               schema:
                 type: string
 
+
   /w/{workspace}/users/is_owner/{path}:
     get:
       summary: is owner of path
@@ -1048,27 +1048,6 @@ paths:
               schema:
                 type: string
 
-  /users/tokens/impersonate:
-    post:
-      summary: create token to impersonate a user (require superadmin)
-      operationId: createTokenImpersonate
-      tags:
-        - user
-      requestBody:
-        description: new token
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: "#/components/schemas/NewTokenImpersonate"
-      responses:
-        "201":
-          description: token created
-          content:
-            text/plain:
-              schema:
-                type: string
-
   /users/tokens/delete/{token_prefix}:
     delete:
       summary: delete token
@@ -1279,10 +1258,9 @@ paths:
       responses:
         "200":
           description: >
-            Successfully authenticated. The session ID is returned in a cookie
-            named `token` and as plaintext response. Preferred method of
-            authorization is through the bearer token. The cookie is only for
-            browser convenience.
+            Successfully authenticated.
+            The session ID is returned in a cookie named `token` and as plaintext response.
+            Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
 
           headers:
             Set-Cookie:
@@ -1571,7 +1549,7 @@ paths:
         required: true
         content:
           application/json:
-            schema:
+            schema: 
               type: object
               properties:
                 value: {}
@@ -2125,6 +2103,7 @@ paths:
                 items:
                   type: string
 
+
   /w/{workspace}/scripts/create:
     post:
       summary: create script
@@ -2299,7 +2278,7 @@ paths:
 
   /w/{workspace}/scripts/delete/h/{hash}:
     post:
-      summary: delete script by hash (erase content but keep hash, require admin)
+      summary: delete script by hash (erase content but keep hash)
       operationId: deleteScriptByHash
       tags:
         - script
@@ -2314,23 +2293,6 @@ paths:
               schema:
                 $ref: "#/components/schemas/Script"
 
-  /w/{workspace}/scripts/delete/p/{path}:
-    post:
-      summary: delete all scripts at a given path (require admin)
-      operationId: deleteScriptByPath
-      tags:
-        - script
-      parameters:
-        - $ref: "#/components/parameters/WorkspaceId"
-        - $ref: "#/components/parameters/ScriptPath"
-      responses:
-        "200":
-          description: script path
-          content:
-            application/json:
-              schema:
-                type: string
-
   /w/{workspace}/scripts/get/p/{path}:
     get:
       summary: get script by path
@@ -2365,24 +2327,6 @@ paths:
               schema:
                 type: string
 
-  /scripts_u/tokened_raw/{workspace}/{token}/{path}:
-    get:
-      summary: raw script by path with a token (mostly used by lsp to be used with import maps to resolve scripts)
-      operationId: rawScriptByPathTokened
-      tags:
-        - script
-      parameters:
-        - $ref: "#/components/parameters/WorkspaceId"
-        - $ref: "#/components/parameters/Token"
-        - $ref: "#/components/parameters/ScriptPath"
-      responses:
-        "200":
-          description: script content
-          content:
-            text/plain:
-              schema:
-                type: string
-
   /w/{workspace}/scripts/exists/p/{path}:
     get:
       summary: exists script by path
@@ -2508,6 +2452,17 @@ paths:
       parameters:
         - $ref: "#/components/parameters/WorkspaceId"
         - $ref: "#/components/parameters/ScriptPath"
+        - name: scheduled_for
+          description: when to schedule this job (leave empty for immediate run)
+          in: query
+          schema:
+            type: string
+            format: date-time
+        - name: scheduled_in_secs
+          description: schedule the script to execute in the number of seconds starting now
+          in: query
+          schema:
+            type: integer
         - $ref: "#/components/parameters/ParentJob"
         - $ref: "#/components/parameters/IncludeHeader"
         - $ref: "#/components/parameters/QueueLimit"
@@ -2527,26 +2482,6 @@ paths:
             application/json:
               schema: {}
 
-    get:
-      summary: run script by path with get
-      operationId: runWaitResultScriptByPathGet
-      tags:
-        - job
-      parameters:
-        - $ref: "#/components/parameters/WorkspaceId"
-        - $ref: "#/components/parameters/ScriptPath"
-        - $ref: "#/components/parameters/ParentJob"
-        - $ref: "#/components/parameters/IncludeHeader"
-        - $ref: "#/components/parameters/QueueLimit"
-        - $ref: "#/components/parameters/Payload"
-
-      responses:
-        "200":
-          description: job result
-          content:
-            application/json:
-              schema: {}
-
   /w/{workspace}/jobs/run_wait_result/f/{path}:
     post:
       summary: run flow by path and wait until completion
@@ -2556,6 +2491,17 @@ paths:
       parameters:
         - $ref: "#/components/parameters/WorkspaceId"
         - $ref: "#/components/parameters/ScriptPath"
+        - name: scheduled_for
+          description: when to schedule this job (leave empty for immediate run)
+          in: query
+          schema:
+            type: string
+            format: date-time
+        - name: scheduled_in_secs
+          description: schedule the script to execute in the number of seconds starting now
+          in: query
+          schema:
+            type: integer
         - $ref: "#/components/parameters/IncludeHeader"
         - $ref: "#/components/parameters/QueueLimit"
 
@@ -2592,6 +2538,11 @@ paths:
           required: true
           schema:
             type: string
+        - name: skip_direct
+          description: Skip checking that the node is part of the given flow.
+          in: query
+          schema:
+            type: boolean
       responses:
         "200":
           description: job result
@@ -2872,6 +2823,7 @@ paths:
               schema:
                 $ref: "#/components/schemas/AppWithLastVersion"
 
+
   /w/{workspace}/apps/secret_of/{path}:
     get:
       summary: get public secret of app
@@ -3204,14 +3156,12 @@ paths:
         - $ref: "#/components/parameters/ScriptExactPath"
         - $ref: "#/components/parameters/ScriptStartPath"
         - $ref: "#/components/parameters/ScriptExactHash"
-        - $ref: "#/components/parameters/StartedBefore"
-        - $ref: "#/components/parameters/StartedAfter"
+        - $ref: "#/components/parameters/CreatedBefore"
+        - $ref: "#/components/parameters/CreatedAfter"
         - $ref: "#/components/parameters/Success"
         - $ref: "#/components/parameters/JobKinds"
         - $ref: "#/components/parameters/Suspended"
         - $ref: "#/components/parameters/Running"
-        - $ref: "#/components/parameters/ArgsFilter"
-        - $ref: "#/components/parameters/ResultFilter"
       responses:
         "200":
           description: All available queued jobs
@@ -3236,12 +3186,10 @@ paths:
         - $ref: "#/components/parameters/ScriptExactPath"
         - $ref: "#/components/parameters/ScriptStartPath"
         - $ref: "#/components/parameters/ScriptExactHash"
-        - $ref: "#/components/parameters/StartedBefore"
-        - $ref: "#/components/parameters/StartedAfter"
+        - $ref: "#/components/parameters/CreatedBefore"
+        - $ref: "#/components/parameters/CreatedAfter"
         - $ref: "#/components/parameters/Success"
         - $ref: "#/components/parameters/JobKinds"
-        - $ref: "#/components/parameters/ArgsFilter"
-        - $ref: "#/components/parameters/ResultFilter"
         - name: is_skipped
           description: is the job skipped
           in: query
@@ -3275,11 +3223,9 @@ paths:
         - $ref: "#/components/parameters/ScriptExactPath"
         - $ref: "#/components/parameters/ScriptStartPath"
         - $ref: "#/components/parameters/ScriptExactHash"
-        - $ref: "#/components/parameters/StartedBefore"
-        - $ref: "#/components/parameters/StartedAfter"
+        - $ref: "#/components/parameters/CreatedBefore"
+        - $ref: "#/components/parameters/CreatedAfter"
         - $ref: "#/components/parameters/JobKinds"
-        - $ref: "#/components/parameters/ArgsFilter"
-        - $ref: "#/components/parameters/ResultFilter"
         - name: is_skipped
           description: is the job skipped
           in: query
@@ -3391,22 +3337,6 @@ paths:
               schema:
                 $ref: "#/components/schemas/CompletedJob"
 
-  /w/{workspace}/jobs/completed/get_result/{id}:
-    get:
-      summary: get completed job result
-      operationId: getCompletedJobResult
-      tags:
-        - job
-      parameters:
-        - $ref: "#/components/parameters/WorkspaceId"
-        - $ref: "#/components/parameters/JobId"
-      responses:
-        "200":
-          description: result
-          content:
-            application/json:
-              schema: {}
-
   /w/{workspace}/jobs/completed/delete/{id}:
     post:
       summary: delete completed job (erase content but keep run id)
@@ -3424,7 +3354,7 @@ paths:
               schema:
                 $ref: "#/components/schemas/CompletedJob"
 
-  /w/{workspace}/jobs_u/queue/cancel/{id}:
+  /w/{workspace}/jobs/queue/cancel/{id}:
     post:
       summary: cancel queued job
       operationId: cancelQueuedJob
@@ -3452,34 +3382,6 @@ paths:
               schema:
                 type: string
 
-  /w/{workspace}/jobs_u/queue/force_cancel/{id}:
-    post:
-      summary: force cancel queued job
-      operationId: forceCancelQueuedJob
-      tags:
-        - job
-      parameters:
-        - $ref: "#/components/parameters/WorkspaceId"
-        - $ref: "#/components/parameters/JobId"
-      requestBody:
-        description: reason
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                reason:
-                  type: string
-
-      responses:
-        "200":
-          description: job canceled
-          content:
-            text/plain:
-              schema:
-                type: string
-
   /w/{workspace}/jobs/job_signature/{id}/{resume_id}:
     get:
       summary: create an HMac signature given a job id and a resume id
@@ -3508,7 +3410,7 @@ paths:
 
   /w/{workspace}/jobs/resume_urls/{id}/{resume_id}:
     get:
-      summary: get resume urls given a job_id, resume_id and a nonce to resume a flow
+      summary:  get resume urls given a job_id, resume_id and a nonce to resume a flow
       operationId: getResumeUrls
       tags:
         - job
@@ -3534,7 +3436,7 @@ paths:
                 properties:
                   approvalPage:
                     type: string
-                  resume:
+                  resume: 
                     type: string
                   cancel:
                     type: string
@@ -3552,7 +3454,6 @@ paths:
       parameters:
         - $ref: "#/components/parameters/WorkspaceId"
         - $ref: "#/components/parameters/JobId"
-        - $ref: "#/components/parameters/Payload"
         - name: resume_id
           in: path
           required: true
@@ -3766,14 +3667,13 @@ paths:
               properties:
                 schedule:
                   type: string
-                timezone:
-                  type: string
+                offset:
+                  type: integer
               required:
                 - schedule
-                - timezone
       responses:
         "200":
-          description: List of 5 estimated upcoming execution events (in UTC)
+          description: the preview of the next 10 time this schedule would apply to
           content:
             application/json:
               schema:
@@ -4181,7 +4081,7 @@ paths:
                   type: string
                 owners:
                   type: array
-                  items:
+                  items: 
                     type: string
                 extra_perms:
                   additionalProperties:
@@ -4215,7 +4115,7 @@ paths:
               properties:
                 owners:
                   type: array
-                  items:
+                  items: 
                     type: string
                 extra_perms:
                   additionalProperties:
@@ -4386,8 +4286,7 @@ paths:
           required: true
           schema:
             type: string
-            enum:
-              [script, group_, resource, schedule, variable, flow, folder, app]
+            enum: [script, group_, resource, schedule, variable, flow, folder, app]
       responses:
         "200":
           description: acls
@@ -4412,8 +4311,7 @@ paths:
           required: true
           schema:
             type: string
-            enum:
-              [script, group_, resource, schedule, variable, flow, folder, app]
+            enum: [script, group_, resource, schedule, variable, flow, folder, app]
       requestBody:
         description: acl to add
         required: true
@@ -4449,8 +4347,7 @@ paths:
           required: true
           schema:
             type: string
-            enum:
-              [script, group_, resource, schedule, variable, flow, folder, app]
+            enum: [script, group_, resource, schedule, variable, flow, folder, app]
       requestBody:
         description: acl to add
         required: true
@@ -4470,18 +4367,19 @@ paths:
               schema:
                 type: string
 
+
   /w/{workspace}/capture_u/{path}:
-    post:
-      summary: update flow preview capture
-      operationId: updateCapture
-      tags:
-        - capture
-      parameters:
-        - $ref: "#/components/parameters/WorkspaceId"
-        - $ref: "#/components/parameters/Path"
-      responses:
-        "204":
-          description: flow preview captured
+      post:
+        summary: update flow preview capture
+        operationId: updateCapture
+        tags:
+          - capture
+        parameters:
+          - $ref: "#/components/parameters/WorkspaceId"
+          - $ref: "#/components/parameters/Path"
+        responses:
+          "204":
+            description: flow preview captured
 
   /w/{workspace}/capture/{path}:
     put:
@@ -4574,12 +4472,6 @@ components:
       required: true
       schema:
         type: string
-    Token:
-      name: token
-      in: path
-      required: true
-      schema:
-        type: string
     AccountId:
       name: id
       in: path
@@ -4655,9 +4547,7 @@ components:
         type: string
     ParentJob:
       name: parent_job
-      description:
-        The parent job that is at the origin and responsible for the execution
-        of this script if any
+      description: The parent job that is at the origin and responsible for the execution of this script if any
       in: query
       schema:
         type: string
@@ -4677,14 +4567,6 @@ components:
       in: query
       schema:
         type: string
-    Payload:
-      name: payload
-      description: |
-        The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
-        `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
-      in: query
-      schema:
-        type: string
 
     ScriptStartPath:
       name: script_path_start
@@ -4704,15 +4586,15 @@ components:
       in: query
       schema:
         type: string
-    StartedBefore:
-      name: started_before
+    CreatedBefore:
+      name: created_before
       description: filter on created before (inclusive) timestamp
       in: query
       schema:
         type: string
         format: date-time
-    StartedAfter:
-      name: started_after
+    CreatedAfter:
+      name: created_after
       description: filter on created after (exclusive) timestamp
       in: query
       schema:
@@ -4736,19 +4618,6 @@ components:
       in: query
       schema:
         type: boolean
-    ArgsFilter:
-      name: args
-      description: filter on jobs containing those args as a json subset (@> in postgres)
-      in: query
-      schema:
-        type: string
-
-    ResultFilter:
-      name: result
-      description: filter on jobs containing those result as a json subset (@> in postgres)
-      in: query
-      schema:
-        type: string
     After:
       name: after
       description: filter on created after (exclusive) timestamp
@@ -4790,9 +4659,7 @@ components:
         enum: [Create, Update, Delete, Execute]
     JobKinds:
       name: job_kinds
-      description:
-        filter on job kind (values 'preview', 'script', 'dependencies', 'flow')
-        separated by,
+      description: filter on job kind (values 'preview', 'script', 'dependencies', 'flow') separated by,
       in: query
       schema:
         type: string
@@ -5177,19 +5044,6 @@ components:
           type: string
           format: date-time
 
-    NewTokenImpersonate:
-      type: object
-      properties:
-        label:
-          type: string
-        expiration:
-          type: string
-          format: date-time
-        impersonate_email:
-          type: string
-      required:
-        - impersonate_email
-
     ListableVariable:
       type: object
       properties:
@@ -5315,11 +5169,6 @@ components:
     MainArgSignature:
       type: object
       properties:
-        type:
-          type: string
-          enum: ["Valid", "Invalid"]
-        error:
-          type: string
         star_args:
           type: boolean
         star_kwargs:
@@ -5429,8 +5278,6 @@ components:
         - star_args
         - start_kwargs
         - args
-        - type
-        - error
 
     Preview:
       type: object
@@ -5565,8 +5412,8 @@ components:
           format: date-time
         schedule:
           type: string
-        timezone:
-          type: string
+        offset_:
+          type: integer
         enabled:
           type: boolean
         script_path:
@@ -5589,7 +5436,7 @@ components:
         - edited_at
         - schedule
         - script_path
-        - timezone
+        - offset_
         - extra_perms
         - is_flow
         - enabled
@@ -5602,8 +5449,8 @@ components:
           type: string
         schedule:
           type: string
-        timezone:
-          type: string
+        offset:
+          type: integer
         script_path:
           type: string
         is_flow:
@@ -5615,7 +5462,6 @@ components:
       required:
         - path
         - schedule
-        - timezone
         - script_path
         - is_flow
         - args
@@ -5625,13 +5471,10 @@ components:
       properties:
         schedule:
           type: string
-        timezone:
-          type: string
         args:
           $ref: "#/components/schemas/ScriptArgs"
       required:
         - schedule
-        - timezone
         - script_path
         - is_flow
         - args
@@ -5679,8 +5522,9 @@ components:
           type: string
         worker_instance:
           type: string
-        last_ping:
-          type: number
+        ping_at:
+          type: string
+          format: date-time
         started_at:
           type: string
           format: date-time

backend/windmill-api/src/apps.rs

@@ -313,17 +313,10 @@ async fn create_app(
     Extension(user_db): Extension<UserDB>,
     Extension(webhook): Extension<WebhookShared>,
     Path(w_id): Path<String>,
-    Json(mut app): Json<CreateApp>,
+    Json(app): Json<CreateApp>,
 ) -> Result<(StatusCode, String)> {
     let mut tx = user_db.begin(&authed).await?;
 
-    app.policy.on_behalf_of = Some(username_to_permissioned_as(&authed.username));
-    app.policy.on_behalf_of_email = Some(authed.email);
-
-    if &app.path == "" {
-        return Err(Error::BadRequest("App path cannot be empty".to_string()));
-    }
-
     let id = sqlx::query_scalar!(
         "INSERT INTO app
             (workspace_id, path, summary, policy, versions)
@@ -470,9 +463,7 @@ async fn update_app(
             sqlb.set_str("summary", nsummary);
         }
 
-        if let Some(mut npolicy) = ns.policy {
-            npolicy.on_behalf_of = Some(username_to_permissioned_as(&authed.username));
-            npolicy.on_behalf_of_email = Some(authed.email);
+        if let Some(npolicy) = ns.policy {
             sqlb.set(
                 "policy",
                 &format!(
@@ -679,7 +670,6 @@ async fn execute_component(
         None,
         None,
         None,
-        None,
         false,
         false,
         None,
@@ -737,9 +727,6 @@ fn build_args(
     path: String,
     args: &Map<String, Value>,
 ) -> Result<Map<String, Value>> {
-    // disallow var and res access in args coming from the user for security reasons
-    args.into_iter()
-        .try_for_each(|x| disallow_var_res_access(x.1))?;
     let static_args = policy
         .triggerables
         .get(&path)
@@ -760,20 +747,3 @@ fn build_args(
     }
     Ok(args)
 }
-
-fn disallow_var_res_access(args: &serde_json::Value) -> Result<()> {
-    match args {
-        Value::Object(v) => v.into_iter().try_for_each(|x| disallow_var_res_access(x.1)),
-        Value::Array(arr) => arr.into_iter().try_for_each(|v| disallow_var_res_access(v)),
-        Value::String(s) => {
-            if s.starts_with("$var:") || s.starts_with("$res:") {
-                Err(Error::BadRequest(format!(
-                    "For security reasons, variable or resource access is not allowed as dynamic argument"
-                )))
-            } else {
-                Ok(())
-            }
-        }
-        _ => Ok(()),
-    }
-}

backend/windmill-api/src/capture.rs

@@ -7,12 +7,11 @@
  */
 
 use axum::{
-    extract::{Extension, Path, Query},
+    extract::{Extension, Path},
     routing::{get, post, put},
     Json, Router,
 };
-use hyper::{HeaderMap, StatusCode};
-use serde::Deserialize;
+use hyper::StatusCode;
 use windmill_common::{
     error::{JsonResult, Result},
     utils::{not_found_if_none, StripPath},
@@ -20,7 +19,6 @@ use windmill_common::{
 
 use crate::{
     db::{UserDB, DB},
-    jobs::add_include_headers,
     users::Authed,
 };
 
@@ -85,21 +83,13 @@ pub async fn new_payload(
     Ok(StatusCode::CREATED)
 }
 
-#[derive(Deserialize, Clone)]
-pub struct IncludeHeaderQuery {
-    include_header: Option<String>,
-}
-
 pub async fn update_payload(
     Extension(db): Extension<DB>,
     Path((w_id, path)): Path<(String, StripPath)>,
-    Query(run_query): Query<IncludeHeaderQuery>,
-    headers: HeaderMap,
-    Json(args): Json<Option<serde_json::Map<String, serde_json::Value>>>,
+    Json(payload): Json<serde_json::Value>,
 ) -> Result<StatusCode> {
     let mut tx = db.begin().await?;
 
-    let args = add_include_headers(&run_query.include_header, headers, args.unwrap_or_default());
     sqlx::query!(
         "
        UPDATE capture
@@ -109,7 +99,7 @@ pub async fn update_payload(
         ",
         &w_id,
         &path.to_path(),
-        serde_json::json!(args),
+        &payload,
     )
     .execute(&mut tx)
     .await?;

backend/windmill-api/src/flows.rs

@@ -30,7 +30,7 @@ use windmill_queue::{push, schedule::push_scheduled_job, JobPayload};
 use crate::{
     db::{UserDB, DB},
     schedule::clear_schedule,
-    users::{maybe_refresh_folders, require_owner_of_path, Authed},
+    users::{require_owner_of_path, Authed},
     webhook_util::{WebhookMessage, WebhookShared},
     HTTP_CLIENT,
 };
@@ -178,15 +178,12 @@ async fn check_path_conflict<'c>(
 
 async fn create_flow(
     authed: Authed,
-    Extension(db): Extension<DB>,
     Extension(user_db): Extension<UserDB>,
     Extension(webhook): Extension<WebhookShared>,
     Path(w_id): Path<String>,
     Json(nf): Json<NewFlow>,
 ) -> Result<(StatusCode, String)> {
     // cron::Schedule::from_str(&ns.schedule).map_err(|e| error::Error::BadRequest(e.to_string()))?;
-    let authed = maybe_refresh_folders(&nf.path, &w_id, authed, &db).await;
-
     let mut tx = user_db.clone().begin(&authed).await?;
 
     check_path_conflict(&mut tx, &w_id, &nf.path).await?;
@@ -240,7 +237,6 @@ async fn create_flow(
         None,
         None,
         None,
-        None,
         false,
         false,
         None,
@@ -291,11 +287,9 @@ async fn update_flow(
     Path((w_id, flow_path)): Path<(String, StripPath)>,
     Json(nf): Json<NewFlow>,
 ) -> Result<String> {
-    let flow_path = flow_path.to_path();
-    let authed = maybe_refresh_folders(&flow_path, &w_id, authed, &db).await;
-
     let mut tx = user_db.clone().begin(&authed).await?;
 
+    let flow_path = flow_path.to_path();
     check_schedule_conflict(&mut tx, &w_id, flow_path).await?;
 
     let schema = nf.schema.map(|x| x.0);
@@ -399,7 +393,6 @@ async fn update_flow(
         None,
         None,
         None,
-        None,
         false,
         false,
         None,
@@ -557,6 +550,7 @@ mod tests {
             modules: vec![
                 FlowModule {
                     id: "a".to_string(),
+                    input_transforms: [].into(),
                     value: FlowModuleValue::Script {
                         path: "test".to_string(),
                         input_transforms: [(
@@ -574,6 +568,7 @@ mod tests {
                 },
                 FlowModule {
                     id: "b".to_string(),
+                    input_transforms: HashMap::new(),
                     value: FlowModuleValue::RawScript {
                         input_transforms: HashMap::new(),
                         content: "test".to_string(),
@@ -592,6 +587,7 @@ mod tests {
                 },
                 FlowModule {
                     id: "c".to_string(),
+                    input_transforms: HashMap::new(),
                     value: FlowModuleValue::ForloopFlow {
                         iterator: InputTransform::Static { value: serde_json::json!([1, 2, 3]) },
                         modules: vec![],
@@ -610,6 +606,7 @@ mod tests {
             ],
             failure_module: Some(FlowModule {
                 id: "d".to_string(),
+                input_transforms: HashMap::new(),
                 value: FlowModuleValue::Script {
                     path: "test".to_string(),
                     input_transforms: HashMap::new(),
@@ -630,6 +627,7 @@ mod tests {
           "modules": [
             {
               "id": "a",
+              "input_transforms": {},
               "value": {
                 "input_transforms": {
                     "test": {
@@ -640,22 +638,29 @@ mod tests {
                 "type": "script",
                 "path": "test"
               },
+              "stop_after_if": null,
+              "summary": null
             },
             {
               "id": "b",
+              "input_transforms": {},
               "value": {
                 "input_transforms": {},
                 "type": "rawscript",
                 "content": "test",
+                "lock": null,
+                "path": null,
                 "language": "deno"
               },
               "stop_after_if": {
                   "expr": "foo = 'bar'",
                   "skip_if_stopped": false
-              }
+              },
+              "summary": null
             },
             {
               "id": "c",
+              "input_transforms": {},
               "value": {
                 "type": "forloopflow",
                 "iterator": {
@@ -673,11 +678,13 @@ mod tests {
               "stop_after_if": {
                   "expr": "previous.isEmpty()",
                   "skip_if_stopped": false,
-              }
+              },
+              "summary": null
             }
           ],
           "failure_module": {
             "id": "d",
+            "input_transforms": {},
             "value": {
               "input_transforms": {},
               "type": "script",
@@ -686,12 +693,38 @@ mod tests {
             "stop_after_if": {
                 "expr": "previous.isEmpty()",
                 "skip_if_stopped": false
-            }
+            },
+            "summary": null
           }
         });
         assert_eq!(dbg!(serde_json::json!(fv)), dbg!(expect));
     }
 
+    #[test]
+    fn test_back_compat() {
+        /* renamed input_transform -> input_transforms but should deserialize old name */
+        let s = r#"
+        {
+            "value": {
+                "type": "rawscript",
+                "content": "def main(n): return",
+                "language": "python3"
+            },
+            "input_transform": {
+                "n": {
+                    "expr": "flow_input.iter.value",
+                    "type": "javascript"
+                }
+            }
+        }
+        "#;
+        let module: FlowModule = serde_json::from_str(s).unwrap();
+        assert_eq!(
+            module.input_transforms["n"],
+            InputTransform::Javascript { expr: "flow_input.iter.value".to_string() }
+        );
+    }
+
     #[test]
     fn retry_serde() {
         assert_eq!(Retry::default(), serde_json::from_str(r#"{}"#).unwrap());

backend/windmill-api/src/folders.rs

@@ -6,11 +6,9 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-use std::sync::Arc;
-
 use crate::{
     db::{UserDB, DB},
-    users::{AuthCache, Authed, Tokened},
+    users::Authed,
     webhook_util::{WebhookMessage, WebhookShared},
 };
 use axum::{
@@ -18,11 +16,10 @@ use axum::{
     routing::{delete, get, post},
     Json, Router,
 };
-use lazy_static::lazy_static;
-use regex::Regex;
+use itertools::Itertools;
 use windmill_audit::{audit_log, ActionKind};
 use windmill_common::{
-    error::{self, to_anyhow, Error, JsonResult, Result},
+    error::{self, Error, JsonResult, Result},
     users::username_to_permissioned_as,
     utils::{not_found_if_none, paginate, Pagination},
 };
@@ -140,28 +137,16 @@ async fn check_name_conflict<'c>(
     return Ok(());
 }
 
-lazy_static! {
-    static ref VALID_FOLDER_NAME: Regex = Regex::new(r#"^[a-zA-Z_0-9]+$"#).unwrap();
-}
-
 async fn create_folder(
     authed: Authed,
-    Tokened { token }: Tokened,
     Extension(user_db): Extension<UserDB>,
     Extension(webhook): Extension<WebhookShared>,
-    Extension(cache): Extension<Arc<AuthCache>>,
     Path(w_id): Path<String>,
     Json(ng): Json<NewFolder>,
 ) -> Result<String> {
     let mut tx = user_db.begin(&authed).await?;
 
-    if !VALID_FOLDER_NAME.is_match(&ng.name) {
-        return Err(windmill_common::error::Error::BadRequest(format!(
-            "Folder name can only contain alphanumeric characters, underscores"
-        )));
-    }
     check_name_conflict(&mut tx, &w_id, &ng.name).await?;
-    cache.invalidate(&w_id, token).await;
     let owner = username_to_permissioned_as(&authed.username);
     let owners = &ng.owners.unwrap_or(vec![owner.clone()]);
 
@@ -277,26 +262,13 @@ async fn update_folder(
     sqlb.and_where_eq("workspace_id", "?".bind(&w_id));
 
     if let Some(display_name) = ng.display_name {
-        sqlb.set("display_name", "?".bind(&display_name));
+        sqlb.set("display_name", display_name);
     }
     if let Some(owners) = ng.owners {
-        sqlb.set(
-            "owners",
-            "?".bind(&format!(
-                "{{{}}}",
-                owners
-                    .iter()
-                    .map(|x| format!("\"{x}\""))
-                    .collect::<Vec<_>>()
-                    .join(","),
-            )),
-        );
+        sqlb.set_str("owners", format!("{{{}}}", owners.into_iter().join(",")));
     }
     if let Some(extra_perms) = ng.extra_perms {
-        sqlb.set(
-            "extra_perms",
-            "?".bind(&serde_json::to_string(&extra_perms).map_err(to_anyhow)?),
-        );
+        sqlb.set_str("extra_perms", extra_perms.to_string());
     }
 
     sqlb.returning("*");

backend/windmill-api/src/jobs.rs

@@ -34,7 +34,7 @@ use windmill_queue::{get_queued_job, push, JobKind, JobPayload, QueuedJob, RawCo
 
 use crate::{
     db::{UserDB, DB},
-    users::{require_owner_of_path, Authed, OptAuthed},
+    users::{require_owner_of_path, Authed},
     variables::get_workspace_key,
     BASE_URL,
 };
@@ -47,10 +47,6 @@ pub fn workspaced_service() -> Router {
             "/run_wait_result/p/*script_path",
             post(run_wait_result_job_by_path),
         )
-        .route(
-            "/run_wait_result/p/*script_path",
-            get(run_wait_result_job_by_path_get),
-        )
         .route(
             "/run_wait_result/h/:hash",
             post(run_wait_result_job_by_hash),
@@ -64,6 +60,7 @@ pub fn workspaced_service() -> Router {
         .route("/run/preview_flow", post(run_preview_flow_job))
         .route("/list", get(list_jobs))
         .route("/queue/list", get(list_queue_jobs))
+        .route("/queue/cancel/:id", post(cancel_job_api))
         .route("/completed/list", get(list_completed_jobs))
         .route("/completed/get/:id", get(get_completed_job))
         .route("/completed/get_result/:id", get(get_completed_job_result))
@@ -101,38 +98,32 @@ pub fn global_service() -> Router {
         )
         .route("/get/:id", get(get_job))
         .route("/getupdate/:id", get(get_job_update))
-        .route("/queue/cancel/:id", post(cancel_job_api))
-        .route("/queue/force_cancel/:id", post(force_cancel))
 }
 
 async fn get_result_by_id(
     Extension(db): Extension<DB>,
-    Path((w_id, flow_id, node_id)): Path<(String, Uuid, String)>,
+    Query(ResultByIdQuery { skip_direct }): Query<ResultByIdQuery>,
+    Path((w_id, flow_id, node_id)): Path<(String, String, String)>,
 ) -> windmill_common::error::JsonResult<serde_json::Value> {
-    let res = windmill_queue::get_result_by_id(db, w_id, flow_id, node_id).await?;
+    let res = windmill_queue::get_result_by_id(db, skip_direct, w_id, flow_id, node_id).await?;
     Ok(Json(res))
 }
 
 async fn cancel_job_api(
-    OptAuthed(opt_authed): OptAuthed,
-    Extension(db): Extension<DB>,
+    authed: Authed,
+    Extension(user_db): Extension<UserDB>,
     Path((w_id, id)): Path<(String, Uuid)>,
     Json(CancelJob { reason }): Json<CancelJob>,
 ) -> error::Result<String> {
-    let tx = db.begin().await?;
-
-    let username = match opt_authed {
-        Some(authed) => authed.username,
-        None => "anonymous".to_string(),
-    };
+    let tx = user_db.begin(&authed).await?;
 
     let (mut tx, job_option) =
-        windmill_queue::cancel_job(&username, reason, id, &w_id, tx, false).await?;
+        windmill_queue::cancel_job(&authed.username, reason, id, &w_id, tx).await?;
 
     if let Some(id) = job_option {
         audit_log(
             &mut tx,
-            &username,
+            &authed.username,
             "jobs.cancel",
             ActionKind::Delete,
             &w_id,
@@ -155,48 +146,6 @@ async fn cancel_job_api(
     }
 }
 
-async fn force_cancel(
-    OptAuthed(opt_authed): OptAuthed,
-    Extension(db): Extension<DB>,
-    Path((w_id, id)): Path<(String, Uuid)>,
-    Json(CancelJob { reason }): Json<CancelJob>,
-) -> error::Result<String> {
-    let tx = db.begin().await?;
-
-    let username = match opt_authed {
-        Some(authed) => authed.username,
-        None => "anonymous".to_string(),
-    };
-
-    let (mut tx, job_option) =
-        windmill_queue::cancel_job(&username, reason, id, &w_id, tx, true).await?;
-
-    if let Some(id) = job_option {
-        audit_log(
-            &mut tx,
-            &username,
-            "jobs.force_cancel",
-            ActionKind::Delete,
-            &w_id,
-            Some(&id.to_string()),
-            None,
-        )
-        .await?;
-        tx.commit().await?;
-        Ok(id.to_string())
-    } else {
-        let (job_o, tx) = get_job_by_id(tx, &w_id, id).await?;
-        tx.commit().await?;
-        let err = match job_o {
-            Some(Job::CompletedJob(_)) => {
-                return Ok(format!("queued job id {} is already completed", id))
-            }
-            _ => error::Error::NotFound(format!("queued job id {} does not exist", id)),
-        };
-        Err(err)
-    }
-}
-
 pub async fn get_path_for_hash<'c>(
     db: &mut Transaction<'c, Postgres>,
     w_id: &str,
@@ -228,6 +177,11 @@ async fn get_job(
     Ok(Json(job))
 }
 
+#[derive(Deserialize)]
+pub struct ResultByIdQuery {
+    pub skip_direct: bool,
+}
+
 pub async fn get_job_by_id<'c>(
     mut tx: Transaction<'c, Postgres>,
     w_id: &str,
@@ -313,7 +267,6 @@ pub struct RunJobQuery {
     include_header: Option<String>,
     invisible_to_owner: Option<bool>,
     queue_limit: Option<i64>,
-    payload: Option<String>,
 }
 
 lazy_static::lazy_static! {
@@ -342,51 +295,41 @@ impl RunJobQuery {
     fn add_include_headers(
         &self,
         headers: HeaderMap,
-        args: serde_json::Map<String, serde_json::Value>,
+        mut args: serde_json::Map<String, serde_json::Value>,
     ) -> serde_json::Map<String, serde_json::Value> {
-        return add_include_headers(&self.include_header, headers, args);
+        let whitelist = self
+            .include_header
+            .as_ref()
+            .map(|s| s.split(",").map(|s| s.to_string()).collect::<Vec<_>>())
+            .unwrap_or_default();
+        whitelist
+            .iter()
+            .chain(INCLUDE_HEADERS.iter())
+            .for_each(|h| {
+                if let Some(v) = headers.get(h) {
+                    args.insert(
+                        h.to_string().to_lowercase().replace('-', "_"),
+                        serde_json::Value::String(v.to_str().unwrap().to_string()),
+                    );
+                }
+            });
+        args
     }
 }
 
-pub fn add_include_headers(
-    include_header: &Option<String>,
-    headers: HeaderMap,
-    mut args: serde_json::Map<String, serde_json::Value>,
-) -> serde_json::Map<String, serde_json::Value> {
-    let whitelist = include_header
-        .as_ref()
-        .map(|s| s.split(",").map(|s| s.to_string()).collect::<Vec<_>>())
-        .unwrap_or_default();
-
-    whitelist
-        .iter()
-        .chain(INCLUDE_HEADERS.iter())
-        .for_each(|h| {
-            if let Some(v) = headers.get(h) {
-                args.insert(
-                    h.to_string().to_lowercase().replace('-', "_"),
-                    serde_json::Value::String(v.to_str().unwrap().to_string()),
-                );
-            }
-        });
-    args
-}
-
 #[derive(Deserialize)]
 pub struct ListQueueQuery {
     pub script_path_start: Option<String>,
     pub script_path_exact: Option<String>,
     pub script_hash: Option<String>,
     pub created_by: Option<String>,
-    pub started_before: Option<chrono::DateTime<chrono::Utc>>,
-    pub started_after: Option<chrono::DateTime<chrono::Utc>>,
+    pub created_before: Option<chrono::DateTime<chrono::Utc>>,
+    pub created_after: Option<chrono::DateTime<chrono::Utc>>,
     pub running: Option<bool>,
     pub parent_job: Option<String>,
     pub order_desc: Option<bool>,
     pub job_kinds: Option<String>,
     pub suspended: Option<bool>,
-    // filter by matching a subset of the args using base64 encoded json subset
-    pub args: Option<String>,
 }
 
 fn list_queue_jobs_query(w_id: &str, lq: &ListQueueQuery, fields: &[&str]) -> SqlBuilder {
@@ -415,11 +358,11 @@ fn list_queue_jobs_query(w_id: &str, lq: &ListQueueQuery, fields: &[&str]) -> Sq
     if let Some(pj) = &lq.parent_job {
         sqlb.and_where_eq("parent_job", "?".bind(pj));
     }
-    if let Some(dt) = &lq.started_before {
-        sqlb.and_where_le("started_at", format!("to_timestamp({})", dt.timestamp()));
+    if let Some(dt) = &lq.created_before {
+        sqlb.and_where_lt("created_at", format!("to_timestamp({})", dt.timestamp()));
     }
-    if let Some(dt) = &lq.started_after {
-        sqlb.and_where_ge("started_at", format!("to_timestamp({})", dt.timestamp()));
+    if let Some(dt) = &lq.created_after {
+        sqlb.and_where_gt("created_at", format!("to_timestamp({})", dt.timestamp()));
     }
 
     if let Some(s) = &lq.suspended {
@@ -429,7 +372,6 @@ fn list_queue_jobs_query(w_id: &str, lq: &ListQueueQuery, fields: &[&str]) -> Sq
             sqlb.and_where_eq("suspend", 0);
         }
     }
-
     if let Some(jk) = &lq.job_kinds {
         sqlb.and_where_in(
             "job_kind",
@@ -437,10 +379,6 @@ fn list_queue_jobs_query(w_id: &str, lq: &ListQueueQuery, fields: &[&str]) -> Sq
         );
     }
 
-    if let Some(args) = &lq.args {
-        sqlb.and_where("args @> ?".bind(&args.replace("'", "''")));
-    }
-
     sqlb
 }
 
@@ -513,14 +451,13 @@ async fn list_jobs(
             script_path_exact: lq.script_path_exact,
             script_hash: lq.script_hash,
             created_by: lq.created_by,
-            started_before: lq.started_before,
-            started_after: lq.started_after,
+            created_before: lq.created_before,
+            created_after: lq.created_after,
             running: None,
             parent_job: lq.parent_job,
             order_desc: Some(true),
             job_kinds: lq.job_kinds,
             suspended: lq.suspended,
-            args: lq.args,
         },
         &[
             "'QueuedJob' as typ",
@@ -815,7 +752,6 @@ pub async fn cancel_suspended_job(
         parent_flow,
         &w_id,
         tx,
-        false,
     )
     .await?;
     if job.is_some() {
@@ -1132,8 +1068,6 @@ impl From<UnifiedJob> for Job {
                 visible_to_owner: uj.visible_to_owner,
                 suspend: uj.suspend,
                 mem_peak: uj.mem_peak,
-                root_job: None,
-                leaf_jobs: None,
             }),
             t => panic!("job type {} not valid", t),
         }
@@ -1196,14 +1130,14 @@ where
         struct InPayload {
             payload: Option<String>,
         }
-    }
-}
 
-fn decode_payload<D: DeserializeOwned>(t: String) -> anyhow::Result<D> {
-    let vec = base64::engine::general_purpose::URL_SAFE
-        .decode(t)
-        .context("invalid base64")?;
-    serde_json::from_slice(vec.as_slice()).context("invalid json")
+        fn decode_payload<D: DeserializeOwned, T: AsRef<[u8]>>(t: T) -> anyhow::Result<D> {
+            let vec = base64::engine::general_purpose::URL_SAFE
+                .decode(t)
+                .context("invalid base64")?;
+            serde_json::from_slice(vec.as_slice()).context("invalid json")
+        }
+    }
 }
 pub async fn run_flow_by_path(
     authed: Authed,
@@ -1229,7 +1163,6 @@ pub async fn run_flow_by_path(
         scheduled_for,
         None,
         run_query.parent_job,
-        run_query.parent_job,
         false,
         false,
         None,
@@ -1265,7 +1198,6 @@ pub async fn run_job_by_path(
         scheduled_for,
         None,
         run_query.parent_job,
-        run_query.parent_job,
         false,
         false,
         None,
@@ -1390,60 +1322,6 @@ lazy_static::lazy_static! {
         .and_then(|x| x.parse().ok())
         .unwrap_or(20);
 }
-
-pub async fn run_wait_result_job_by_path_get(
-    authed: Authed,
-    Extension(user_db): Extension<UserDB>,
-    Extension(db): Extension<DB>,
-    Path((w_id, script_path)): Path<(String, StripPath)>,
-    Query(run_query): Query<RunJobQuery>,
-) -> error::JsonResult<serde_json::Value> {
-    let payload_r = run_query
-        .payload
-        .map(decode_payload)
-        .map(|x| x.map_err(|e| Error::InternalErr(e.to_string())));
-
-    let args = if let Some(payload) = payload_r {
-        payload?
-    } else {
-        serde_json::Map::new()
-    };
-
-    check_queue_too_long(db, QUEUE_LIMIT_WAIT_RESULT.or(run_query.queue_limit)).await?;
-    let script_path = script_path.to_path();
-    let mut tx = user_db.clone().begin(&authed).await?;
-    let job_payload = script_path_to_payload(script_path, &mut tx, &w_id).await?;
-
-    let (uuid, tx) = push(
-        tx,
-        &w_id,
-        job_payload,
-        args,
-        &authed.username,
-        &authed.email,
-        username_to_permissioned_as(&authed.username),
-        None,
-        None,
-        run_query.parent_job,
-        run_query.parent_job,
-        false,
-        false,
-        None,
-        !run_query.invisible_to_owner.unwrap_or(false),
-    )
-    .await?;
-    tx.commit().await?;
-
-    run_wait_result(
-        authed,
-        Extension(user_db),
-        *TIMEOUT_WAIT_RESULT,
-        uuid,
-        Path((w_id, script_path)),
-    )
-    .await
-}
-
 pub async fn run_wait_result_job_by_path(
     authed: Authed,
     Extension(user_db): Extension<UserDB>,
@@ -1457,6 +1335,7 @@ pub async fn run_wait_result_job_by_path(
     let script_path = script_path.to_path();
     let mut tx = user_db.clone().begin(&authed).await?;
     let job_payload = script_path_to_payload(script_path, &mut tx, &w_id).await?;
+    let scheduled_for = run_query.get_scheduled_for(&mut tx).await?;
 
     let args = run_query.add_include_headers(headers, args.unwrap_or_default());
 
@@ -1468,9 +1347,8 @@ pub async fn run_wait_result_job_by_path(
         &authed.username,
         &authed.email,
         username_to_permissioned_as(&authed.username),
+        scheduled_for,
         None,
-        None,
-        run_query.parent_job,
         run_query.parent_job,
         false,
         false,
@@ -1504,6 +1382,7 @@ pub async fn run_wait_result_job_by_hash(
     let hash = script_hash.0;
     let mut tx = user_db.clone().begin(&authed).await?;
     let path = get_path_for_hash(&mut tx, &w_id, hash).await?;
+    let scheduled_for = run_query.get_scheduled_for(&mut tx).await?;
     let args = run_query.add_include_headers(headers, args.unwrap_or_default());
 
     let (uuid, tx) = push(
@@ -1514,9 +1393,8 @@ pub async fn run_wait_result_job_by_hash(
         &authed.username,
         &authed.email,
         username_to_permissioned_as(&authed.username),
+        scheduled_for,
         None,
-        None,
-        run_query.parent_job,
         run_query.parent_job,
         false,
         false,
@@ -1563,7 +1441,6 @@ pub async fn run_wait_result_flow_by_path(
         scheduled_for,
         None,
         run_query.parent_job,
-        run_query.parent_job,
         false,
         false,
         None,
@@ -1626,7 +1503,6 @@ async fn run_preview_job(
         scheduled_for,
         None,
         None,
-        None,
         false,
         false,
         None,
@@ -1660,7 +1536,6 @@ async fn run_preview_flow_job(
         scheduled_for,
         None,
         None,
-        None,
         false,
         false,
         None,
@@ -1696,7 +1571,6 @@ pub async fn run_job_by_hash(
         scheduled_for,
         None,
         run_query.parent_job,
-        run_query.parent_job,
         false,
         false,
         None,
@@ -1799,11 +1673,11 @@ fn list_completed_jobs_query(
     if let Some(pj) = &lq.parent_job {
         sqlb.and_where_eq("parent_job", "?".bind(pj));
     }
-    if let Some(dt) = &lq.started_before {
-        sqlb.and_where_le("started_at", format!("to_timestamp({})", dt.timestamp()));
+    if let Some(dt) = &lq.created_before {
+        sqlb.and_where_lt("created_at", format!("to_timestamp({})", dt.timestamp()));
     }
-    if let Some(dt) = &lq.started_after {
-        sqlb.and_where_ge("started_at", format!("to_timestamp({})", dt.timestamp()));
+    if let Some(dt) = &lq.created_after {
+        sqlb.and_where_gt("created_at", format!("to_timestamp({})", dt.timestamp()));
     }
     if let Some(sk) = &lq.is_skipped {
         sqlb.and_where_eq("is_skipped", sk);
@@ -1818,14 +1692,6 @@ fn list_completed_jobs_query(
         );
     }
 
-    if let Some(args) = &lq.args {
-        sqlb.and_where("args @> ?".bind(&args.replace("'", "''")));
-    }
-
-    if let Some(result) = &lq.result {
-        sqlb.and_where("result @> ?".bind(&result.replace("'", "''")));
-    }
-
     sqlb
 }
 #[derive(Deserialize, Clone)]
@@ -1834,8 +1700,8 @@ pub struct ListCompletedQuery {
     pub script_path_exact: Option<String>,
     pub script_hash: Option<String>,
     pub created_by: Option<String>,
-    pub started_before: Option<chrono::DateTime<chrono::Utc>>,
-    pub started_after: Option<chrono::DateTime<chrono::Utc>>,
+    pub created_before: Option<chrono::DateTime<chrono::Utc>>,
+    pub created_after: Option<chrono::DateTime<chrono::Utc>>,
     pub success: Option<bool>,
     pub parent_job: Option<String>,
     pub order_desc: Option<bool>,
@@ -1843,10 +1709,6 @@ pub struct ListCompletedQuery {
     pub is_skipped: Option<bool>,
     pub is_flow_step: Option<bool>,
     pub suspended: Option<bool>,
-    // filter by matching a subset of the args using base64 encoded json subset
-    pub args: Option<String>,
-    // filter by matching a subset of the result using base64 encoded json subset
-    pub result: Option<String>,
 }
 
 async fn list_completed_jobs(
@@ -1913,7 +1775,6 @@ async fn get_completed_job(
     .fetch_optional(&db)
     .await?;
 
-    tracing::info!("job_o: {:?}", job_o);
     let job = not_found_if_none(job_o, "Completed Job", id.to_string())?;
     Ok(Json(job))
 }

backend/windmill-api/src/lib.rs

@@ -11,15 +11,11 @@ use argon2::Argon2;
 use axum::{middleware::from_extractor, routing::get, Extension, Router};
 use db::DB;
 use git_version::git_version;
-use hyper::Method;
 use reqwest::Client;
 use std::{net::SocketAddr, sync::Arc};
 use tower::ServiceBuilder;
 use tower_cookies::CookieManagerLayer;
-use tower_http::{
-    cors::{Any, CorsLayer},
-    trace::TraceLayer,
-};
+use tower_http::trace::TraceLayer;
 use windmill_common::utils::rd_string;
 
 use crate::{
@@ -104,11 +100,6 @@ pub async fn run_server(
         .layer(Extension(auth_cache.clone()))
         .layer(CookieManagerLayer::new())
         .layer(Extension(WebhookShared::new(rx.resubscribe(), db.clone())));
-
-    let cors = CorsLayer::new()
-        .allow_methods([Method::GET, Method::POST])
-        .allow_origin(Any);
-
     // build our application with a route
     let app = Router::new()
         .nest(
@@ -118,7 +109,7 @@ pub async fn run_server(
                     "/w/:workspace_id",
                     Router::new()
                         .nest("/scripts", scripts::workspaced_service())
-                        .nest("/jobs", jobs::workspaced_service().layer(cors.clone()))
+                        .nest("/jobs", jobs::workspaced_service())
                         .nest(
                             "/users",
                             users::workspaced_service().layer(Extension(argon2.clone())),
@@ -145,25 +136,16 @@ pub async fn run_server(
                 .nest("/workers", worker_ping::global_service())
                 .nest("/scripts", scripts::global_service())
                 .nest("/flows", flows::global_service())
-                .nest("/apps", apps::global_service().layer(cors.clone()))
+                .nest("/apps", apps::global_service())
                 .nest("/schedules", schedule::global_service())
                 .route_layer(from_extractor::<Authed>())
                 .route_layer(from_extractor::<users::Tokened>())
-                .nest("/scripts_u", scripts::global_unauthed_service())
                 .nest(
                     "/w/:workspace_id/apps_u",
-                    apps::unauthed_service()
-                        .layer(from_extractor::<OptAuthed>())
-                        .layer(cors.clone()),
-                )
-                .nest(
-                    "/w/:workspace_id/jobs_u",
-                    jobs::global_service().layer(cors.clone()),
-                )
-                .nest(
-                    "/w/:workspace_id/capture_u",
-                    capture::global_service().layer(cors),
+                    apps::unauthed_service().layer(from_extractor::<OptAuthed>()),
                 )
+                .nest("/w/:workspace_id/jobs_u", jobs::global_service())
+                .nest("/w/:workspace_id/capture_u", capture::global_service())
                 .nest(
                     "/auth",
                     users::make_unauthed_service().layer(Extension(argon2)),

backend/windmill-api/src/oauth2.rs

@@ -734,10 +734,14 @@ async fn slack_command(
         .map_err(|_| error::Error::BadRequest("invalid payload".to_string()))?;
 
     let body = String::from_utf8_lossy(&body);
-    if let Some(sv) = SLACK_SIGNING_SECRET.as_ref() {
-        if sv.verify(&ts, &body, &sig).ok().is_none() {
-            return Err(error::Error::BadRequest("verification failed".to_owned()));
-        }
+    if SLACK_SIGNING_SECRET
+        .as_ref()
+        .as_ref()
+        .map(|sv| sv.verify(&ts, &body, &sig).ok())
+        .flatten()
+        .is_none()
+    {
+        return Err(error::Error::BadRequest("verification failed".to_owned()));
     }
 
     let mut tx = db.begin().await?;
@@ -781,7 +785,6 @@ async fn slack_command(
                 None,
                 None,
                 None,
-                None,
                 false,
                 false,
                 None,
@@ -849,8 +852,7 @@ async fn login_callback(
             _ => user.email.ok_or_else(|| {
                 error::Error::BadRequest("email address not fetchable from user info".to_string())
             })?,
-        }
-        .to_lowercase();
+        };
 
         if let Some(domains) = &client_w_config.allowed_domains {
             if !domains.iter().any(|d| email.ends_with(d)) {

backend/windmill-api/src/resources.rs

@@ -8,7 +8,7 @@
 
 use crate::{
     db::{UserDB, DB},
-    users::{maybe_refresh_folders, require_owner_of_path, Authed},
+    users::{require_owner_of_path, Authed},
     webhook_util::{WebhookMessage, WebhookShared},
 };
 use axum::{
@@ -264,12 +264,9 @@ async fn create_resource(
     authed: Authed,
     Extension(user_db): Extension<UserDB>,
     Extension(webhook): Extension<WebhookShared>,
-    Extension(db): Extension<DB>,
     Path(w_id): Path<String>,
     Json(resource): Json<CreateResource>,
 ) -> Result<(StatusCode, String)> {
-    let authed = maybe_refresh_folders(&resource.path, &w_id, authed, &db).await;
-
     let mut tx = user_db.begin(&authed).await?;
 
     check_path_conflict(&mut tx, &w_id, &resource.path).await?;
@@ -378,7 +375,6 @@ async fn update_resource(
     }
 
     sqlb.returning("path");
-    let authed = maybe_refresh_folders(path, &w_id, authed, &db).await;
 
     let mut tx = user_db.begin(&authed).await?;
 

backend/windmill-api/src/schedule.rs

@@ -6,19 +6,20 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
+use std::str::FromStr;
+
 use crate::{
     db::{UserDB, DB},
-    users::{maybe_refresh_folders, Authed},
+    users::Authed,
 };
 use axum::{
     extract::{Extension, Path, Query},
     routing::{delete, get, post},
     Json, Router,
 };
-use chrono::{DateTime, Utc};
+use chrono::{DateTime, FixedOffset};
 use serde::Deserialize;
 use sqlx::{Postgres, Transaction};
-use std::str::FromStr;
 use windmill_audit::{audit_log, ActionKind};
 use windmill_common::{
     error::{Error, JsonResult, Result},
@@ -46,7 +47,7 @@ pub fn global_service() -> Router {
 pub struct NewSchedule {
     pub path: String,
     pub schedule: String,
-    pub timezone: String,
+    pub offset: i32,
     pub script_path: String,
     pub is_flow: bool,
     pub args: Option<serde_json::Value>,
@@ -77,13 +78,10 @@ async fn check_path_conflict<'c>(
 
 async fn create_schedule(
     authed: Authed,
-    Extension(db): Extension<DB>,
     Extension(user_db): Extension<UserDB>,
     Path(w_id): Path<String>,
     Json(ns): Json<NewSchedule>,
 ) -> Result<String> {
-    let authed = maybe_refresh_folders(&ns.path, &w_id, authed, &db).await;
-
     let mut tx = user_db.begin(&authed).await?;
     cron::Schedule::from_str(&ns.schedule).map_err(|e| Error::BadRequest(e.to_string()))?;
     check_path_conflict(&mut tx, &w_id, &ns.path).await?;
@@ -91,12 +89,12 @@ async fn create_schedule(
 
     let schedule = sqlx::query_as!(
         Schedule,
-        "INSERT INTO schedule (workspace_id, path, schedule, timezone, edited_by, script_path, \
+        "INSERT INTO schedule (workspace_id, path, schedule, offset_, edited_by, script_path, \
          is_flow, args, enabled, email) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING *",
         w_id,
         ns.path,
         ns.schedule,
-        ns.timezone,
+        ns.offset,
         &authed.username,
         ns.script_path,
         ns.is_flow,
@@ -137,16 +135,12 @@ async fn create_schedule(
 
 async fn edit_schedule(
     authed: Authed,
-    Extension(db): Extension<DB>,
     Extension(user_db): Extension<UserDB>,
     Path((w_id, path)): Path<(String, StripPath)>,
     Json(es): Json<EditSchedule>,
 ) -> Result<String> {
-    let path = path.to_path();
-
-    let authed = maybe_refresh_folders(&path, &w_id, authed, &db).await;
-
     let mut tx = user_db.begin(&authed).await?;
+    let path = path.to_path();
 
     cron::Schedule::from_str(&es.schedule).map_err(|e| Error::BadRequest(e.to_string()))?;
 
@@ -161,10 +155,9 @@ async fn edit_schedule(
     clear_schedule(&mut tx, path, is_flow).await?;
     let schedule = sqlx::query_as!(
         Schedule,
-        "UPDATE schedule SET schedule = $1, timezone = $2, args = $3 WHERE path \
-         = $4 AND workspace_id = $5 RETURNING *",
+        "UPDATE schedule SET schedule = $1, args = $2 WHERE path \
+         = $3 AND workspace_id = $4 RETURNING *",
         es.schedule,
-        es.timezone,
         es.args,
         path,
         w_id,
@@ -242,26 +235,15 @@ async fn exists_schedule(
     Ok(Json(res))
 }
 
-#[derive(Deserialize)]
-pub struct PreviewPayload {
-    pub schedule: String,
-    pub timezone: String,
-}
-
 pub async fn preview_schedule(
     Json(payload): Json<PreviewPayload>,
-) -> JsonResult<Vec<DateTime<Utc>>> {
+) -> JsonResult<Vec<DateTime<chrono::Utc>>> {
     let schedule = cron::Schedule::from_str(&payload.schedule)
         .map_err(|e| Error::BadRequest(e.to_string()))?;
-
-    let tz =
-        chrono_tz::Tz::from_str(&payload.timezone).map_err(|e| Error::BadRequest(e.to_string()))?;
-
-    let upcoming: Vec<DateTime<Utc>> = schedule
-        .upcoming(tz)
-        .take(5)
-        // Convert back to UTC for a standardised API response. The client will convert to the local timezone.
-        .map(|x| x.with_timezone(&Utc))
+    let upcoming: Vec<DateTime<chrono::Utc>> = schedule
+        .upcoming(get_offset(payload.offset))
+        .take(10)
+        .map(|x| x.into())
         .collect();
 
     Ok(Json(upcoming))
@@ -371,7 +353,6 @@ async fn check_flow_conflict<'c>(
 #[derive(Deserialize)]
 pub struct EditSchedule {
     pub schedule: String,
-    pub timezone: String,
     pub args: Option<serde_json::Value>,
 }
 
@@ -395,6 +376,16 @@ pub async fn clear_schedule<'c>(
     Ok(())
 }
 
+#[derive(Deserialize)]
+pub struct PreviewPayload {
+    pub schedule: String,
+    pub offset: Option<i32>,
+}
+
+fn get_offset(offset: Option<i32>) -> FixedOffset {
+    FixedOffset::west_opt(offset.unwrap_or(0) * 60).expect("Invalid offset")
+}
+
 #[derive(Deserialize)]
 pub struct SetEnabled {
     pub enabled: bool,

backend/windmill-api/src/scripts.rs

@@ -8,12 +8,11 @@
 
 use sql_builder::prelude::*;
 use windmill_audit::{audit_log, ActionKind};
-use windmill_parser::MainArgSignature;
 
 use crate::{
     db::{UserDB, DB},
     schedule::clear_schedule,
-    users::{maybe_refresh_folders, require_owner_of_path, AuthCache, Authed},
+    users::{require_owner_of_path, Authed},
     webhook_util::{WebhookMessage, WebhookShared},
     HTTP_CLIENT,
 };
@@ -30,7 +29,6 @@ use sqlx::{FromRow, Postgres, Transaction};
 use std::{
     collections::hash_map::DefaultHasher,
     hash::{Hash, Hasher},
-    sync::Arc,
 };
 use windmill_common::{
     error::{Error, JsonResult, Result},
@@ -62,13 +60,6 @@ pub fn global_service() -> Router {
         .route("/hub/get_full/*path", get(get_full_hub_script_by_path))
 }
 
-pub fn global_unauthed_service() -> Router {
-    Router::new().route(
-        "/tokened_raw/:workspace/:token/*path",
-        get(get_tokened_raw_script_by_path),
-    )
-}
-
 pub fn workspaced_service() -> Router {
     Router::new()
         .route("/list", get(list_scripts))
@@ -79,7 +70,6 @@ pub fn workspaced_service() -> Router {
         .route("/exists/p/*path", get(exists_script_by_path))
         .route("/archive/h/:hash", post(archive_script_by_hash))
         .route("/delete/h/:hash", post(delete_script_by_hash))
-        .route("/delete/p/*path", post(delete_script_by_path))
         .route("/get/h/:hash", get(get_script_by_hash))
         .route("/raw/h/:hash", get(raw_script_by_hash))
         .route("/deployment_status/h/:hash", get(get_deployment_status))
@@ -133,7 +123,6 @@ async fn list_scripts(
             AND workspace_id = ?)"
                 .bind(&w_id),
         );
-        sqlb.and_where_eq("archived", true);
     } else {
         sqlb.and_where_eq("archived", false);
     }
@@ -199,7 +188,6 @@ async fn create_script(
     Json(ns): Json<NewScript>,
 ) -> Result<(StatusCode, String)> {
     let hash = ScriptHash(hash_script(&ns));
-    let authed = maybe_refresh_folders(&ns.path, &w_id, authed, &db).await;
     let mut tx = user_db.begin(&authed).await?;
 
     if sqlx::query_scalar!(
@@ -389,7 +377,6 @@ async fn create_script(
             None,
             None,
             None,
-            None,
             false,
             false,
             None,
@@ -506,18 +493,6 @@ async fn list_paths(
     Ok(Json(scripts))
 }
 
-async fn get_tokened_raw_script_by_path(
-    Extension(user_db): Extension<UserDB>,
-    Path((w_id, token, path)): Path<(String, String, StripPath)>,
-    Extension(cache): Extension<Arc<AuthCache>>,
-) -> Result<String> {
-    let authed = cache
-        .get_authed(Some(w_id.clone()), &token)
-        .await
-        .ok_or_else(|| Error::NotAuthorized("Invalid token".to_string()))?;
-    return raw_script_by_path(authed, Extension(user_db), Path((w_id, path))).await;
-}
-
 async fn raw_script_by_path(
     authed: Authed,
     Extension(user_db): Extension<UserDB>,
@@ -578,10 +553,11 @@ async fn get_script_by_hash_internal<'c>(
 }
 
 async fn get_script_by_hash(
-    Extension(db): Extension<DB>,
+    authed: Authed,
+    Extension(user_db): Extension<UserDB>,
     Path((w_id, hash)): Path<(String, ScriptHash)>,
 ) -> JsonResult<Script> {
-    let mut tx = db.begin().await?;
+    let mut tx = user_db.begin(&authed).await?;
     let r = get_script_by_hash_internal(&mut tx, &w_id, &hash).await?;
     tx.commit().await?;
 
@@ -589,10 +565,11 @@ async fn get_script_by_hash(
 }
 
 async fn raw_script_by_hash(
-    Extension(db): Extension<DB>,
+    authed: Authed,
+    Extension(user_db): Extension<UserDB>,
     Path((w_id, hash_str)): Path<(String, String)>,
 ) -> Result<String> {
-    let mut tx = db.begin().await?;
+    let mut tx = user_db.begin(&authed).await?;
     let hash = ScriptHash(to_i64(hash_str.strip_suffix(".ts").ok_or_else(|| {
         Error::BadRequest("Raw script path must end with .ts".to_string())
     })?)?);
@@ -608,10 +585,11 @@ struct DeploymentStatus {
     lock_error_logs: Option<String>,
 }
 async fn get_deployment_status(
-    Extension(db): Extension<DB>,
+    authed: Authed,
+    Extension(user_db): Extension<UserDB>,
     Path((w_id, hash)): Path<(String, ScriptHash)>,
 ) -> JsonResult<DeploymentStatus> {
-    let mut tx = db.begin().await?;
+    let mut tx = user_db.begin(&authed).await?;
     let status_o: Option<DeploymentStatus> = sqlx::query_as!(
         DeploymentStatus,
         "SELECT lock, lock_error_logs FROM script WHERE hash = $1 AND workspace_id = $2",
@@ -740,71 +718,25 @@ async fn delete_script_by_hash(
     Ok(Json(script))
 }
 
-async fn delete_script_by_path(
-    authed: Authed,
-    Extension(user_db): Extension<UserDB>,
-    Extension(webhook): Extension<WebhookShared>,
-    Extension(db): Extension<DB>,
-    Path((w_id, path)): Path<(String, StripPath)>,
-) -> JsonResult<String> {
-    let mut tx = user_db.begin(&authed).await?;
-    let path = path.to_path();
-
-    require_admin(authed.is_admin, &authed.username)?;
-    let script = sqlx::query_scalar!(
-        "DELETE FROM script WHERE path = $1 AND workspace_id = $2 RETURNING path",
-        path,
-        w_id
-    )
-    .fetch_one(&db)
-    .await
-    .map_err(|e| Error::InternalErr(format!("deleting script by path {w_id}: {e}")))?;
-
-    audit_log(
-        &mut tx,
-        &authed.username,
-        "scripts.delete",
-        ActionKind::Delete,
-        &w_id,
-        Some(&path),
-        Some([("workspace", w_id.as_str())].into()),
-    )
-    .await?;
-    tx.commit().await?;
-
-    webhook.send_message(
-        w_id.clone(),
-        WebhookMessage::DeleteScriptPath { workspace: w_id, path: path.to_string() },
-    );
-
-    Ok(Json(script))
+async fn parse_python_code_to_jsonschema(
+    Json(code): Json<String>,
+) -> JsonResult<windmill_parser::MainArgSignature> {
+    windmill_parser_py::parse_python_signature(&code).map(Json)
 }
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "type")]
-enum SigParsing {
-    Valid(MainArgSignature),
-    Invalid { error: String },
+async fn parse_deno_code_to_jsonschema(
+    Json(code): Json<String>,
+) -> JsonResult<windmill_parser::MainArgSignature> {
+    windmill_parser_ts::parse_deno_signature(&code).map(Json)
+}
+async fn parse_go_code_to_jsonschema(
+    Json(code): Json<String>,
+) -> JsonResult<windmill_parser::MainArgSignature> {
+    windmill_parser_go::parse_go_sig(&code).map(Json)
 }
 
-fn result_to_sig_parsing(result: Result<MainArgSignature>) -> Json<SigParsing> {
-    match result {
-        Ok(sig) => Json(SigParsing::Valid(sig)),
-        Err(e) => Json(SigParsing::Invalid { error: e.to_string() }),
-    }
-}
-
-async fn parse_python_code_to_jsonschema(Json(code): Json<String>) -> Json<SigParsing> {
-    result_to_sig_parsing(windmill_parser_py::parse_python_signature(&code))
-}
-
-async fn parse_deno_code_to_jsonschema(Json(code): Json<String>) -> Json<SigParsing> {
-    result_to_sig_parsing(windmill_parser_ts::parse_deno_signature(&code))
-}
-async fn parse_go_code_to_jsonschema(Json(code): Json<String>) -> Json<SigParsing> {
-    result_to_sig_parsing(windmill_parser_go::parse_go_sig(&code))
-}
-
-async fn parse_bash_code_to_jsonschema(Json(code): Json<String>) -> Json<SigParsing> {
-    result_to_sig_parsing(windmill_parser_bash::parse_bash_sig(&code))
+async fn parse_bash_code_to_jsonschema(
+    Json(code): Json<String>,
+) -> JsonResult<windmill_parser::MainArgSignature> {
+    windmill_parser_bash::parse_bash_sig(&code).map(Json)
 }

backend/windmill-api/src/users.rs

@@ -25,9 +25,7 @@ use axum::{
     Json, Router,
 };
 use hyper::{header::LOCATION, StatusCode};
-use lazy_static::lazy_static;
 use rand::rngs::OsRng;
-use regex::Regex;
 use retainer::Cache;
 use serde::{Deserialize, Serialize};
 use sqlx::FromRow;
@@ -37,7 +35,6 @@ use tracing::{Instrument, Span};
 use windmill_audit::{audit_log, ActionKind};
 use windmill_common::{
     error::{self, Error, JsonResult, Result},
-    users::SUPERADMIN_SECRET_EMAIL,
     utils::{not_found_if_none, rd_string, require_admin, Pagination, StripPath},
 };
 use windmill_queue::CLOUD_HOSTED;
@@ -76,7 +73,6 @@ pub fn global_service() -> Router {
         .route("/tokens/create", post(create_token))
         .route("/tokens/delete/:token_prefix", delete(delete_token))
         .route("/tokens/list", get(list_tokens))
-        .route("/tokens/impersonate", post(impersonate))
         .route("/usage", get(get_usage))
     // .route("/list_invite_codes", get(list_invite_codes))
     // .route("/create_invite_code", post(create_invite_code))
@@ -103,10 +99,6 @@ impl AuthCache {
         AuthCache { cache: Cache::new(), db, superadmin_secret }
     }
 
-    pub async fn invalidate(&self, w_id: &str, token: String) {
-        self.cache.remove(&(w_id.to_string(), token)).await;
-    }
-
     pub async fn get_authed(&self, w_id: Option<String>, token: &str) -> Option<Authed> {
         let key = (
             w_id.as_ref().unwrap_or(&"".to_string()).to_string(),
@@ -274,7 +266,7 @@ impl AuthCache {
                     .unwrap_or(false)
                 {
                     Some(Authed {
-                        email: SUPERADMIN_SECRET_EMAIL.to_string(),
+                        email: "superadmin_secret@windmill.dev".to_string(),
                         username: "superadmin_secret".to_string(),
                         is_admin: true,
                         groups: Vec::new(),
@@ -361,31 +353,6 @@ pub struct Authed {
     pub folders: Vec<(String, bool)>,
 }
 
-pub async fn maybe_refresh_folders(path: &str, w_id: &str, authed: Authed, db: &DB) -> Authed {
-    if authed.is_admin {
-        return authed;
-    }
-    let splitted = path.split('/').collect::<Vec<_>>();
-    if splitted.len() >= 2
-        && splitted[0] == "f"
-        && !authed.folders.iter().any(|(f, _)| f == splitted[1])
-    {
-        let name = &authed.username;
-        let groups = get_groups_for_user(w_id, name, db)
-            .await
-            .ok()
-            .unwrap_or_default();
-
-        let folders = get_folders_for_user(w_id, name, &groups, db)
-            .await
-            .ok()
-            .unwrap_or_default();
-        Authed { folders, ..authed }
-    } else {
-        authed
-    }
-}
-
 #[async_trait]
 impl<S> FromRequestParts<S> for Authed
 where
@@ -594,7 +561,6 @@ pub struct TruncatedToken {
 pub struct NewToken {
     pub label: Option<String>,
     pub expiration: Option<chrono::DateTime<chrono::Utc>>,
-    pub impersonate_email: Option<String>,
 }
 
 #[derive(Deserialize)]
@@ -1031,21 +997,14 @@ async fn decline_invite(
     }
 }
 
-lazy_static! {
-    pub static ref VALID_USERNAME: Regex = Regex::new(r#"^[a-zA-Z_0-9]+$"#).unwrap();
-}
-
 async fn accept_invite(
     Authed { email, .. }: Authed,
     Extension(db): Extension<DB>,
     Json(nu): Json<AcceptInvite>,
 ) -> Result<(StatusCode, String)> {
-    if !VALID_USERNAME.is_match(&nu.username) {
-        return Err(windmill_common::error::Error::BadRequest(format!(
-            "Usermame can only contain alphanumeric characters and underscores"
-        )));
+    if &nu.username == "bot" {
+        return Err(Error::BadRequest("bot is a reserved username".to_string()));
     }
-
     let mut tx = db.begin().await?;
 
     let r = sqlx::query!(
@@ -1118,12 +1077,6 @@ async fn add_user_to_workspace<'c>(
         )));
     }
 
-    if !VALID_USERNAME.is_match(username) {
-        return Err(windmill_common::error::Error::BadRequest(format!(
-            "Usermame can only contain alphanumeric characters and underscores"
-        )));
-    }
-
     let already_exists_email = sqlx::query_scalar!(
         "SELECT EXISTS(SELECT 1 FROM usr WHERE workspace_id = $1 AND email = $2)",
         &w_id,
@@ -1323,18 +1276,11 @@ async fn create_user(
     Authed { email, .. }: Authed,
     Extension(db): Extension<DB>,
     Extension(argon2): Extension<Arc<Argon2<'_>>>,
-    Json(mut nu): Json<NewUser>,
+    Json(nu): Json<NewUser>,
 ) -> Result<(StatusCode, String)> {
     let mut tx = db.begin().await?;
 
     require_super_admin(&mut tx, &email).await?;
-    nu.email = nu.email.to_lowercase();
-
-    if nu.email == SUPERADMIN_SECRET_EMAIL {
-        return Err(Error::BadRequest(
-            "The superadmin email is a reserved email".into(),
-        ));
-    }
 
     sqlx::query!(
         "INSERT INTO password(email, verified, password_hash, login_type, super_admin, name, \
@@ -1365,9 +1311,7 @@ async fn create_user(
     if let Some(new_user_webhook) = NEW_USER_WEBHOOK.clone() {
         let _ = HTTP_CLIENT
             .post(&new_user_webhook)
-            .json(
-                &serde_json::json!({"email" : &nu.email, "name": &nu.name, "event": "global_add"}),
-            )
+            .json(&serde_json::json!({"email" : &nu.email, "name": &nu.name, "event": "new_user"}))
             .send()
             .await
             .map_err(|e| tracing::error!("Error sending new user webhook: {}", e.to_string()));
@@ -1620,7 +1564,7 @@ async fn login(
     Json(Login { email, password }): Json<Login>,
 ) -> Result<String> {
     let mut tx = db.begin().await?;
-    let email = email.to_lowercase();
+
     let email_w_h: Option<(String, String, bool, bool)> = sqlx::query_as(
         "SELECT email, password_hash, super_admin, first_time_user FROM password WHERE email = $1 AND login_type = \
          'password'",
@@ -1742,58 +1686,6 @@ async fn create_token(
     Ok((StatusCode::CREATED, token))
 }
 
-async fn impersonate(
-    Extension(db): Extension<DB>,
-    Authed { email, username, .. }: Authed,
-    Json(new_token): Json<NewToken>,
-) -> Result<(StatusCode, String)> {
-    let token = rd_string(30);
-    let mut tx = db.begin().await?;
-    require_super_admin(&mut tx, &email).await?;
-
-    if new_token.impersonate_email.is_none() {
-        return Err(Error::BadRequest(
-            "impersonate_username is required".to_string(),
-        ));
-    }
-
-    let impersonated = new_token.impersonate_email.unwrap();
-
-    let is_super_admin = sqlx::query_scalar!(
-        "SELECT super_admin FROM password WHERE email = $1",
-        impersonated
-    )
-    .fetch_optional(&mut tx)
-    .await?
-    .unwrap_or(false);
-    sqlx::query!(
-        "INSERT INTO token
-            (token, email, label, expiration, super_admin)
-            VALUES ($1, $2, $3, $4, $5)",
-        token,
-        impersonated,
-        new_token.label,
-        new_token.expiration,
-        is_super_admin
-    )
-    .execute(&mut tx)
-    .await?;
-
-    audit_log(
-        &mut tx,
-        &username,
-        "users.impersonate",
-        ActionKind::Delete,
-        &"global",
-        Some(&token[0..10]),
-        Some([("impersonated", &format!("{impersonated}")[..])].into()),
-    )
-    .instrument(tracing::info_span!("token", email = &impersonated))
-    .await?;
-    tx.commit().await?;
-    Ok((StatusCode::CREATED, token))
-}
-
 async fn list_tokens(
     Extension(db): Extension<DB>,
     Authed { email, .. }: Authed,

backend/windmill-api/src/utils.rs

@@ -7,24 +7,16 @@
  */
 
 use sqlx::{Postgres, Transaction};
-use windmill_common::{
-    error::{self, Error},
-    users::SUPERADMIN_SECRET_EMAIL,
-};
+use windmill_common::error::{self, Error};
 
 pub async fn require_super_admin<'c>(
     db: &mut Transaction<'c, Postgres>,
     email: &str,
 ) -> error::Result<()> {
-    if email == SUPERADMIN_SECRET_EMAIL {
-        return Ok(());
-    }
     let is_admin = sqlx::query_scalar!("SELECT super_admin FROM password WHERE email = $1", email)
-        .fetch_optional(db)
+        .fetch_one(db)
         .await
-        .map_err(|e| Error::InternalErr(format!("fetching super admin: {e}")))?
-        .unwrap_or(false);
-
+        .map_err(|e| Error::InternalErr(format!("fetching super admin: {e}")))?;
     if !is_admin {
         Err(Error::NotAuthorized(
             "This endpoint require caller to be a super admin".to_owned(),

backend/windmill-api/src/variables.rs

@@ -9,7 +9,7 @@
 use crate::{
     db::{UserDB, DB},
     oauth2::_refresh_token,
-    users::{maybe_refresh_folders, require_owner_of_path, Authed},
+    users::{require_owner_of_path, Authed},
     webhook_util::{WebhookMessage, WebhookShared},
 };
 /*
@@ -26,7 +26,6 @@ use axum::{
     Json, Router,
 };
 use hyper::StatusCode;
-use serde_json::Value;
 use windmill_audit::{audit_log, ActionKind};
 use windmill_common::{
     error::{Error, JsonResult, Result},
@@ -206,15 +205,12 @@ async fn check_path_conflict<'c>(
 
 async fn create_variable(
     authed: Authed,
-    Extension(db): Extension<DB>,
     Extension(user_db): Extension<UserDB>,
     Extension(webhook): Extension<WebhookShared>,
     Path(w_id): Path<String>,
     Query(AlreadyEncrypted { already_encrypted }): Query<AlreadyEncrypted>,
     Json(variable): Json<CreateVariable>,
 ) -> Result<(StatusCode, String)> {
-    let authed = maybe_refresh_folders(&variable.path, &w_id, authed, &db).await;
-
     let mut tx = user_db.begin(&authed).await?;
 
     check_path_conflict(&mut tx, &w_id, &variable.path).await?;
@@ -333,7 +329,6 @@ async fn update_variable(
     use sql_builder::prelude::*;
 
     let path = path.to_path();
-    let authed = maybe_refresh_folders(&path, &w_id, authed, &db).await;
 
     let mut tx = user_db.begin(&authed).await?;
 
@@ -383,27 +378,9 @@ async fn update_variable(
             if !authed.is_admin {
                 require_owner_of_path(&w_id, &authed.username, &authed.groups, &path, &db).await?;
             }
-            let mut v = sqlx::query_scalar!(
-                "SELECT value FROM resource  WHERE path = $1 AND workspace_id = $2",
-                path,
-                w_id
-            )
-            .fetch_optional(&mut tx)
-            .await?
-            .flatten();
-
-            if let Some(old_v) = v {
-                v = Some(replace_path(
-                    old_v,
-                    &format!("$var:{path}"),
-                    &format!("$var:{npath}"),
-                ))
-            }
-
             sqlx::query!(
-                "UPDATE resource SET path = $1, value = $2 WHERE path = $3 AND workspace_id = $4",
+                "UPDATE resource SET path = $1 WHERE path = $2 AND workspace_id = $3",
                 npath,
-                v,
                 path,
                 w_id
             )
@@ -442,23 +419,6 @@ async fn update_variable(
     Ok(format!("variable {} updated (npath: {:?})", path, npath))
 }
 
-fn replace_path(v: serde_json::Value, path: &str, npath: &str) -> Value {
-    match v {
-        Value::Object(v) => Value::Object(
-            v.into_iter()
-                .map(|(k, v)| (k, replace_path(v, path, npath)))
-                .collect(),
-        ),
-        Value::Array(arr) => Value::Array(
-            arr.into_iter()
-                .map(|v| replace_path(v, path, npath))
-                .collect(),
-        ),
-        Value::String(s) if s == path => Value::String(npath.to_owned()),
-        _ => v,
-    }
-}
-
 pub async fn build_crypt<'c>(
     db: &mut Transaction<'c, Postgres>,
     w_id: &str,

backend/windmill-api/src/webhook_util.rs

@@ -37,7 +37,6 @@ pub enum WebhookMessage {
     CreateScript { workspace: String, path: String, hash: String },
     UpdateScript { workspace: String, path: String, hash: String },
     DeleteScript { workspace: String, hash: String },
-    DeleteScriptPath { workspace: String, path: String },
     CreateVariable { workspace: String, path: String },
     UpdateVariable { workspace: String, old_path: String, new_path: String },
     DeleteVariable { workspace: String, path: String },

backend/windmill-api/src/worker_ping.rs

@@ -28,7 +28,7 @@ pub fn global_service() -> Router {
 struct WorkerPing {
     worker: String,
     worker_instance: String,
-    last_ping: Option<i32>,
+    ping_at: chrono::DateTime<chrono::Utc>,
     started_at: chrono::DateTime<chrono::Utc>,
     ip: String,
     jobs_executed: i32,
@@ -45,7 +45,7 @@ async fn list_worker_pings(
 
     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 FROM worker_ping ORDER BY ping_at desc LIMIT $1 OFFSET $2",
+        "SELECT * FROM worker_ping ORDER BY ping_at desc LIMIT $1 OFFSET $2",
         per_page as i64,
         offset as i64
     )

backend/windmill-api/src/workspaces.rs

@@ -16,9 +16,8 @@ use crate::{
     db::{UserDB, DB},
     folders::Folder,
     resources::{Resource, ResourceType},
-    users::{Authed, WorkspaceInvite, NEW_USER_WEBHOOK, VALID_USERNAME},
+    users::{Authed, WorkspaceInvite, NEW_USER_WEBHOOK},
     utils::require_super_admin,
-    variables::build_crypt,
     HTTP_CLIENT,
 };
 #[cfg(feature = "enterprise")]
@@ -31,7 +30,6 @@ use axum::{
     routing::{delete, get, post},
     Json, Router,
 };
-use magic_crypt::MagicCryptTrait;
 #[cfg(feature = "enterprise")]
 use stripe::CustomerId;
 use windmill_audit::{audit_log, ActionKind};
@@ -944,12 +942,10 @@ async fn invite_user(
     Authed { username, is_admin, .. }: Authed,
     Extension(db): Extension<DB>,
     Path(w_id): Path<String>,
-    Json(mut nu): Json<NewWorkspaceInvite>,
+    Json(nu): Json<NewWorkspaceInvite>,
 ) -> Result<(StatusCode, String)> {
     require_admin(is_admin, &username)?;
 
-    nu.email = nu.email.to_lowercase();
-
     let mut tx = db.begin().await?;
 
     sqlx::query!(
@@ -969,7 +965,7 @@ async fn invite_user(
     if let Some(new_user_webhook) = NEW_USER_WEBHOOK.clone() {
         let _ = &HTTP_CLIENT
             .post(&new_user_webhook)
-            .json(&serde_json::json!({"email" : &nu.email, "event": "workspace_invite"}))
+            .json(&serde_json::json!({"email" : &nu.email, "event": "new_invite"}))
             .send()
             .await
             .map_err(|e| tracing::error!("Error sending new user webhook: {}", e.to_string()));
@@ -985,17 +981,11 @@ async fn add_user(
     Authed { username, is_admin, .. }: Authed,
     Extension(db): Extension<DB>,
     Path(w_id): Path<String>,
-    Json(mut nu): Json<NewWorkspaceUser>,
+    Json(nu): Json<NewWorkspaceUser>,
 ) -> Result<(StatusCode, String)> {
     require_admin(is_admin, &username)?;
-    nu.email = nu.email.to_lowercase();
 
     let mut tx = db.begin().await?;
-    if !VALID_USERNAME.is_match(&nu.username) {
-        return Err(windmill_common::error::Error::BadRequest(format!(
-            "Usermame can only contain alphanumeric characters and underscores"
-        )));
-    }
 
     sqlx::query!(
         "INSERT INTO usr
@@ -1010,27 +1000,8 @@ async fn add_user(
     .execute(&mut tx)
     .await?;
 
-    sqlx::query_as!(
-        Group,
-        "INSERT INTO usr_to_group (workspace_id, usr, group_) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING",
-        &w_id,
-        nu.username,
-        "all",
-    )
-    .execute(&mut tx)
-    .await?;
-
     tx.commit().await?;
 
-    if let Some(new_user_webhook) = NEW_USER_WEBHOOK.clone() {
-        let _ = HTTP_CLIENT
-            .post(&new_user_webhook)
-            .json(&serde_json::json!({"email" : &nu.email, "event": "workspace_add"}))
-            .send()
-            .await
-            .map_err(|e| tracing::error!("Error sending new user webhook: {}", e.to_string()));
-    }
-
     Ok((
         StatusCode::CREATED,
         format!("user with email {} added", nu.email),
@@ -1093,7 +1064,6 @@ struct ScriptMetadata {
     schema: Option<Schema>,
     is_template: bool,
     lock: Vec<String>,
-    kind: String,
 }
 
 enum ArchiveImpl {
@@ -1145,7 +1115,6 @@ impl ArchiveImpl {
 #[derive(Deserialize)]
 struct ArchiveQueryParams {
     archive_type: Option<String>,
-    plain_secret: Option<bool>,
 }
 
 #[inline]
@@ -1191,7 +1160,7 @@ async fn tarball_workspace(
     authed: Authed,
     Extension(db): Extension<DB>,
     Path(w_id): Path<String>,
-    Query(ArchiveQueryParams { archive_type, plain_secret }): Query<ArchiveQueryParams>,
+    Query(ArchiveQueryParams { archive_type }): Query<ArchiveQueryParams>,
 ) -> Result<([(headers::HeaderName, String); 2], impl IntoResponse)> {
     require_admin(authed.is_admin, &authed.username)?;
 
@@ -1257,7 +1226,6 @@ async fn tarball_workspace(
                 description: script.description,
                 schema: script.schema,
                 is_template: script.is_template,
-                kind: script.kind.to_string(),
                 lock,
             };
             let metadata_str = serde_json::to_string_pretty(&metadata).unwrap();
@@ -1328,15 +1296,7 @@ async fn tarball_workspace(
         .fetch_all(&db)
         .await?;
 
-        let mc = build_crypt(&mut db.begin().await?, &w_id).await?;
-
-        for mut var in variables {
-            if plain_secret.unwrap_or(false) && var.value.is_some() && var.is_secret {
-                var.value = Some(
-                    mc.decrypt_base64_to_string(var.value.unwrap())
-                        .map_err(|e| Error::InternalErr(e.to_string()))?,
-                );
-            }
+        for var in variables {
             let var_str = &to_string_without_metadata(&var, false).unwrap();
             archive
                 .write_to_archive(&var_str, &format!("{}.variable.json", var.path))

backend/windmill-common/src/flow_status.rs

@@ -125,7 +125,7 @@ pub enum FlowStatusModule {
     },
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub enum JobResult {
     SingleJob(Uuid),
     ListJob(Vec<Uuid>),

backend/windmill-common/src/flows.rs

@@ -6,12 +6,9 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-use std::{
-    collections::{BTreeMap, HashMap},
-    time::Duration,
-};
+use std::{collections::HashMap, time::Duration};
 
-use serde::{self, Deserialize, Serialize, Serializer};
+use serde::{self, Deserialize, Serialize};
 
 use crate::{
     more_serde::{
@@ -152,6 +149,9 @@ pub struct Suspend {
 pub struct FlowModule {
     #[serde(default = "default_id")]
     pub id: String,
+    #[serde(default)]
+    #[serde(alias = "input_transform")]
+    pub input_transforms: HashMap<String, InputTransform>,
     pub value: FlowModuleValue,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub stop_after_if: Option<StopAfterIf>,
@@ -245,7 +245,7 @@ pub enum FlowModuleValue {
     },
     RawScript {
         #[serde(default)]
-        #[serde(alias = "input_transform", serialize_with = "ordered_map")]
+        #[serde(alias = "input_transform")]
         input_transforms: HashMap<String, InputTransform>,
         content: String,
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -257,14 +257,6 @@ pub enum FlowModuleValue {
     Identity,
 }
 
-fn ordered_map<S>(value: &HashMap<String, InputTransform>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let ordered: BTreeMap<_, _> = value.iter().collect();
-    ordered.serialize(serializer)
-}
-
 #[derive(Deserialize)]
 pub struct ListFlowQuery {
     pub path_start: Option<String>,

backend/windmill-common/src/jobs.rs

@@ -1 +0,0 @@
-

backend/windmill-common/src/lib.rs

@@ -6,7 +6,7 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-use std::{net::SocketAddr, sync::Arc};
+use std::net::SocketAddr;
 
 use error::Error;
 
@@ -31,7 +31,6 @@ pub const DEFAULT_MAX_CONNECTIONS_WORKER: u32 = 3;
 
 lazy_static::lazy_static! {
     pub static ref BASE_URL: String = std::env::var("BASE_URL").unwrap_or_else(|_| "http://localhost".to_string());
-    pub static ref IS_READY: Arc<std::sync::atomic::AtomicBool> = Arc::new(std::sync::atomic::AtomicBool::new(false));
 }
 
 #[cfg(feature = "tokio")]
@@ -59,31 +58,14 @@ pub async fn shutdown_signal(tx: tokio::sync::broadcast::Sender<()>) -> anyhow::
 pub async fn serve_metrics(
     addr: SocketAddr,
     mut rx: tokio::sync::broadcast::Receiver<()>,
-    ready_worker_endpoint: bool,
 ) -> Result<(), hyper::Error> {
-    use std::sync::atomic::Ordering;
-
     use axum::{routing::get, Router};
-    use hyper::StatusCode;
-    let router = Router::new().route("/metrics", get(metrics));
-
-    let router = if ready_worker_endpoint {
-        router.route(
-            "/ready",
-            get(|| async {
-                if IS_READY.load(Ordering::Relaxed) {
-                    (StatusCode::OK, "ready")
-                } else {
-                    (StatusCode::INTERNAL_SERVER_ERROR, "not ready")
-                }
-            }),
-        )
-    } else {
-        router
-    };
-
     axum::Server::bind(&addr)
-        .serve(router.into_make_service())
+        .serve(
+            Router::new()
+                .route("/metrics", get(metrics))
+                .into_make_service(),
+        )
         .with_graceful_shutdown(async {
             rx.recv().await.ok();
             println!("Graceful shutdown of metrics");

backend/windmill-common/src/schedule.rs

@@ -17,7 +17,7 @@ pub struct Schedule {
     pub edited_by: String,
     pub edited_at: DateTime<chrono::Utc>,
     pub schedule: String,
-    pub timezone: String,
+    pub offset_: i32,
     pub enabled: bool,
     pub script_path: String,
     pub is_flow: bool,

backend/windmill-common/src/scripts.rs

@@ -7,7 +7,7 @@
  */
 
 use std::{
-    fmt::{self, Display},
+    fmt::Display,
     hash::{Hash, Hasher},
 };
 
@@ -103,18 +103,6 @@ pub enum ScriptKind {
     Approval,
 }
 
-impl Display for ScriptKind {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.write_str(match self {
-            ScriptKind::Trigger => "trigger",
-            ScriptKind::Failure => "failure",
-            ScriptKind::Script => "script",
-            ScriptKind::Approval => "approval",
-        })?;
-        Ok(())
-    }
-}
-
 #[derive(Serialize)]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 pub struct Script {

backend/windmill-common/src/users.rs

@@ -6,8 +6,6 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-pub const SUPERADMIN_SECRET_EMAIL: &str = "superadmin_secret@windmill.dev";
-
 pub fn username_to_permissioned_as(user: &str) -> String {
     if user.contains('@') {
         user.to_string()

backend/windmill-queue/Cargo.toml

@@ -25,7 +25,6 @@ serde_json.workspace = true
 ulid.workspace = true
 uuid.workspace = true
 chrono.workspace = true
-chrono-tz.workspace = true
 hex.workspace = true
 reqwest.workspace = true
 lazy_static.workspace = true

backend/windmill-queue/src/jobs.rs

@@ -6,7 +6,7 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-use std::collections::HashMap;
+use std::{collections::HashMap, str::FromStr};
 
 use anyhow::Context;
 use reqwest::Client;
@@ -58,14 +58,12 @@ pub async fn cancel_job<'c>(
     id: Uuid,
     w_id: &str,
     mut tx: Transaction<'c, Postgres>,
-    force_rerun: bool,
 ) -> error::Result<(Transaction<'c, Postgres>, Option<Uuid>)> {
     let job_option = sqlx::query_scalar!(
-        "UPDATE queue SET  canceled = true, canceled_by = $1, canceled_reason = $2, scheduled_for = now(), suspend = 0, running = CASE WHEN $3 THEN false ELSE running END  WHERE id = $4 \
-         AND workspace_id = $5 RETURNING id",
+        "UPDATE queue SET canceled = true, canceled_by = $1, canceled_reason = $2, scheduled_for = now(), suspend = 0 WHERE id = $3 \
+         AND workspace_id = $4 RETURNING id",
         username,
         reason,
-        force_rerun,
         id,
         w_id
     )
@@ -75,11 +73,10 @@ pub async fn cancel_job<'c>(
     while !jobs.is_empty() {
         let p_job = jobs.pop();
         let new_jobs = sqlx::query_scalar!(
-            "UPDATE queue SET canceled = true, canceled_by = $1, canceled_reason = $2, running = CASE WHEN $3 THEN false ELSE running END WHERE parent_job = $4 \
-             AND workspace_id = $5 RETURNING id",
+            "UPDATE queue SET canceled = true, canceled_by = $1, canceled_reason = $2 WHERE parent_job = $3 \
+             AND workspace_id = $4 RETURNING id",
             username,
             reason,
-            force_rerun,
             p_job,
             w_id
         )
@@ -155,24 +152,55 @@ pub async fn pull(
 
 pub async fn get_result_by_id(
     db: Pool<Postgres>,
+    mut skip_direct: bool,
     w_id: String,
-    flow_id: Uuid,
+    flow_id: String,
     node_id: String,
 ) -> error::Result<serde_json::Value> {
-    let job_result: Option<JobResult> = sqlx::query_scalar!(
-        "SELECT leaf_jobs->$1::text FROM queue WHERE COALESCE((SELECT root_job FROM queue WHERE id = $2), $2) = id AND workspace_id = $3",
-        node_id,
-        flow_id,
-        w_id,
-    )
-    .fetch_optional(&db)
-    .await?
-    .flatten()
-    .map(|x| serde_json::from_value(x).ok())
-    .flatten();
-
+    let mut result_id: Option<JobResult> = None;
+    let mut parent_id = Uuid::from_str(&flow_id).ok();
+    while result_id.is_none() && parent_id.is_some() {
+        if !skip_direct {
+            let r = sqlx::query!(
+                "SELECT flow_status, parent_job FROM completed_job WHERE id = $1 AND workspace_id = $2 UNION ALL SELECT flow_status, parent_job FROM queue WHERE id = $1 AND workspace_id = $2 ",
+                parent_id.unwrap(),
+                w_id,
+            )
+            .fetch_optional(&db)
+            .await?;
+            if let Some(r) = r {
+                let value = r
+                    .flow_status
+                    .as_ref()
+                    .ok_or_else(|| Error::InternalErr(format!("requiring a flow status value")))?
+                    .to_owned();
+                parent_id = r.parent_job;
+                let status_o = serde_json::from_value::<FlowStatus>(value).ok();
+                result_id = status_o.and_then(|status| {
+                    status
+                        .modules
+                        .iter()
+                        .find(|m| m.id() == node_id)
+                        .and_then(|m| m.job_result())
+                });
+            } else {
+                parent_id = None;
+            }
+        } else {
+            let q_parent = sqlx::query_scalar!(
+                "SELECT parent_job FROM completed_job WHERE id = $1 AND workspace_id = $2 UNION ALL SELECT parent_job FROM queue WHERE id = $1 AND workspace_id = $2",
+                parent_id.unwrap(),
+                w_id,
+            )
+            .fetch_optional(&db)
+            .await?
+            .flatten();
+            parent_id = q_parent;
+            skip_direct = false
+        }
+    }
     let result_id = windmill_common::utils::not_found_if_none(
-        job_result,
+        result_id,
         "Flow result by id",
         format!("{}, {}", flow_id, node_id),
     )?;
@@ -254,7 +282,6 @@ pub async fn push<'c>(
     scheduled_for_o: Option<chrono::DateTime<chrono::Utc>>,
     schedule_path: Option<String>,
     parent_job: Option<Uuid>,
-    root_job: Option<Uuid>,
     is_flow_step: bool,
     mut same_worker: bool,
     pre_run_error: Option<&windmill_common::error::Error>,
@@ -265,8 +292,8 @@ pub async fn push<'c>(
     let job_id: Uuid = Ulid::new().into();
 
     if cfg!(feature = "enterprise") {
-        let premium_workspace = *CLOUD_HOSTED
-            && sqlx::query_scalar!("SELECT premium FROM workspace WHERE id = $1", workspace_id)
+        let premium_workspace =
+            sqlx::query_scalar!("SELECT premium FROM workspace WHERE id = $1", workspace_id)
                 .fetch_one(&mut tx)
                 .await
                 .map_err(|e| {
@@ -489,6 +516,7 @@ pub async fn push<'c>(
             modules.push(FlowModule {
                 id: format!("{}-v", flow.modules[flow.modules.len() - 1].id),
                 value: FlowModuleValue::Identity,
+                input_transforms: HashMap::new(),
                 stop_after_if: None,
                 summary: Some(
                     "Virtual module needed for suspend/sleep when last module".to_string(),
@@ -506,13 +534,12 @@ pub async fn push<'c>(
         .unwrap_or_else(|| (None, None));
 
     let flow_status = raw_flow.as_ref().map(FlowStatus::new);
-
     let uuid = sqlx::query_scalar!(
         "INSERT INTO queue
             (workspace_id, id, running, parent_job, created_by, permissioned_as, scheduled_for, 
                 script_hash, script_path, raw_code, raw_lock, args, job_kind, schedule_path, raw_flow, \
-         flow_status, is_flow_step, language, started_at, same_worker, pre_run_error, email, visible_to_owner, root_job)
-            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, CASE WHEN $3 THEN now() END, $19, $20, $21, $22, $23) \
+         flow_status, is_flow_step, language, started_at, same_worker, pre_run_error, email, visible_to_owner)
+            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, CASE WHEN $3 THEN now() END, $19, $20, $21, $22) \
          RETURNING id",
         workspace_id,
         job_id,
@@ -535,8 +562,7 @@ pub async fn push<'c>(
         same_worker,
         pre_run_error.map(|e| e.to_string()),
         email,
-        visible_to_owner,
-        root_job
+        visible_to_owner
     )
     .fetch_one(&mut tx)
     .await
@@ -649,10 +675,6 @@ pub struct QueuedJob {
     pub suspend: Option<i32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub mem_peak: Option<i32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub root_job: Option<Uuid>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub leaf_jobs: Option<serde_json::Value>,
 }
 
 impl QueuedJob {
@@ -660,7 +682,7 @@ impl QueuedJob {
         self.script_path
             .as_ref()
             .map(String::as_str)
-            .unwrap_or("tmp/main")
+            .unwrap_or("NO_FLOW_PATH")
     }
 }
 

backend/windmill-queue/src/schedule.rs

@@ -6,9 +6,10 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-use crate::{push, JobPayload};
-use sqlx::{query_scalar, Postgres, Transaction};
 use std::str::FromStr;
+
+use chrono::Duration;
+use sqlx::{query_scalar, Postgres, Transaction};
 use windmill_common::{
     error::{self, Result},
     schedule::Schedule,
@@ -16,6 +17,8 @@ use windmill_common::{
     utils::{now_from_db, StripPath},
 };
 
+use crate::{push, JobPayload};
+
 pub async fn push_scheduled_job<'c>(
     mut tx: Transaction<'c, Postgres>,
     schedule: Schedule,
@@ -23,21 +26,13 @@ pub async fn push_scheduled_job<'c>(
     let sched = cron::Schedule::from_str(&schedule.schedule)
         .map_err(|e| error::Error::BadRequest(e.to_string()))?;
 
-    let tz = chrono_tz::Tz::from_str(&schedule.timezone)
-        .map_err(|e| error::Error::BadRequest(e.to_string()))?;
-
-    let now = now_from_db(&mut tx).await?.with_timezone(&tz);
-
+    let offset = Duration::minutes(schedule.offset_.into());
+    let now = now_from_db(&mut tx).await?;
     let next = sched
-        .after(&now)
+        .after(&(now - offset + Duration::seconds(1)))
         .next()
-        .expect("a schedule should have a next event");
-
-    // println!("next event ({:?}): {}", tz, next);
-    // println!("next event(UTC): {}", next.with_timezone(&chrono::Utc));
-
-    // Scheduled events must be stored in the database in UTC
-    let next = next.with_timezone(&chrono::Utc);
+        .expect("a schedule should have a next event")
+        + offset;
 
     let already_exists: bool = query_scalar!(
         "SELECT EXISTS (SELECT 1 FROM queue WHERE workspace_id = $1 AND schedule_path = $2 AND scheduled_for = $3)",
@@ -90,7 +85,6 @@ pub async fn push_scheduled_job<'c>(
         Some(next),
         Some(schedule.path.clone()),
         None,
-        None,
         false,
         false,
         None,

backend/windmill-worker/Cargo.toml

@@ -48,4 +48,3 @@ deno_core.workspace = true
 const_format.workspace = true
 git-version.workspace = true
 dyn-iter.workspace = true
-once_cell.workspace = true

backend/windmill-worker/nsjail/run.deno.config.proto

@@ -0,0 +1,135 @@
+name: "deno run script"
+
+mode: ONCE
+hostname: "deno"
+log_level: ERROR
+
+rlimit_as: 16000
+rlimit_cpu: 1000
+rlimit_fsize: 1000
+rlimit_nofile: 10000
+
+cwd: "/tmp"
+
+
+clone_newnet: false
+clone_newuser: {CLONE_NEWUSER}
+
+keep_caps: false
+keep_env: true
+mount_proc: true
+
+mount {
+    src: "/bin"
+    dst: "/bin"
+	is_bind: true
+}
+
+mount {
+    src: "/lib"
+    dst: "/lib"
+	is_bind: true
+}
+
+
+mount {
+    src: "/lib64"
+    dst: "/lib64"
+	is_bind: true
+}
+
+
+mount {
+    src: "/usr"
+    dst: "/usr"
+	is_bind: true
+}
+
+mount {
+	src: "/dev/null"
+	dst: "/dev/null"
+	is_bind: true
+	rw: true
+}
+
+mount {
+	dst: "/tmp"
+	fstype: "tmpfs"
+	rw: true
+    options: "size=500000000"
+}
+
+
+mount {
+    src: "{JOB_DIR}/inner.ts"
+    dst: "/tmp/inner.ts"
+    is_bind: true
+}
+
+mount {
+    src: "{JOB_DIR}/main.ts"
+    dst: "/tmp/main.ts"
+    is_bind: true
+}
+
+mount {
+    src: "{JOB_DIR}/import_map.json"
+    dst: "/tmp/import_map.json"
+    is_bind: true
+}
+
+mount {
+    src: "{JOB_DIR}/lock.json"
+    dst: "/tmp/lock.json"
+    is_bind: true
+}
+
+mount {
+    src: "{JOB_DIR}/args.json"
+    dst: "/tmp/args.json"
+    is_bind: true
+}
+
+mount {
+    src: "{JOB_DIR}/result.json"
+    dst: "/tmp/result.json"
+    is_bind: true
+    rw: true
+}
+
+mount {
+    src: "/etc"
+    dst: "/etc"
+	is_bind: true
+}
+
+mount {
+    src: "/dev/random"
+    dst: "/dev/random"
+    is_bind: true
+}
+
+mount {
+    src: "/dev/urandom"
+    dst: "/dev/urandom"
+    is_bind: true
+}
+
+mount {
+    src: "{CACHE_DIR}"
+    dst: "/tmp/.cache/deno"
+    is_bind: true
+    rw: true
+    mandatory: false
+}
+
+{SHARED_MOUNT}
+
+iface_no_lo: true
+
+envar: "DENO_DIR=/tmp/.cache/deno"
+envar: "NO_COLOR=true"
+envar: "HOME=/tmp"
+
+
+

backend/windmill-worker/nsjail/run.python3.config.proto

@@ -66,8 +66,8 @@ mount {
 }
 
 mount {
-    src: "{JOB_DIR}/{MAIN}.py"
-    dst: "/tmp/{MAIN}.py"
+    src: "{JOB_DIR}/inner.py"
+    dst: "/tmp/inner.py"
     is_bind: true
 }
 
@@ -79,8 +79,8 @@ mount {
 }
 
 mount {
-    src: "{JOB_DIR}/wrapper.py"
-    dst: "/tmp/wrapper.py"
+    src: "{JOB_DIR}/main.py"
+    dst: "/tmp/main.py"
     is_bind: true
 }
 

backend/windmill-worker/src/jobs.rs

@@ -10,7 +10,7 @@ use sqlx::{Pool, Postgres, Transaction};
 use tracing::instrument;
 use uuid::Uuid;
 use windmill_common::{error::Error, flow_status::FlowStatusModule, schedule::Schedule};
-use windmill_queue::{delete_job, schedule::get_schedule_opt, JobKind, QueuedJob, CLOUD_HOSTED};
+use windmill_queue::{delete_job, schedule::get_schedule_opt, JobKind, QueuedJob};
 
 #[instrument(level = "trace", skip_all)]
 pub async fn add_completed_job_error(
@@ -175,8 +175,8 @@ pub async fn add_completed_job(
         let additional_usage = duration.unwrap() as i32 / 1000;
 
         let w_id = &queued_job.workspace_id;
-        let premium_workspace = *CLOUD_HOSTED
-            && sqlx::query_scalar!("SELECT premium FROM workspace WHERE id = $1", w_id)
+        let premium_workspace =
+            sqlx::query_scalar!("SELECT premium FROM workspace WHERE id = $1", w_id)
                 .fetch_one(db)
                 .await
                 .map_err(|e| Error::InternalErr(format!("fetching if {w_id} is premium: {e}")))?;
@@ -232,7 +232,7 @@ pub async fn schedule_again_if_scheduled<'c>(
                 edited_by: schedule.edited_by,
                 edited_at: schedule.edited_at,
                 schedule: schedule.schedule,
-                timezone: schedule.timezone,
+                offset_: schedule.offset_,
                 enabled: schedule.enabled,
                 script_path: schedule.script_path,
                 is_flow: schedule.is_flow,

backend/windmill-worker/src/js_eval.rs

@@ -6,11 +6,9 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-use std::{cell::RefCell, collections::HashMap, rc::Rc};
+use std::collections::HashMap;
 
-use deno_core::{
-    op, serde_v8, v8, v8::IsolateHandle, Extension, JsRuntime, OpState, RuntimeOptions,
-};
+use deno_core::{op, serde_v8, v8, v8::IsolateHandle, Extension, JsRuntime, RuntimeOptions};
 use itertools::Itertools;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -19,7 +17,10 @@ use tokio::{sync::oneshot, time::timeout};
 use uuid::Uuid;
 use windmill_common::{error::Error, flow_status::JobResult};
 
-use crate::AuthedClient;
+pub struct EvalCreds {
+    pub workspace: String,
+    pub token: String,
+}
 
 #[derive(Debug, Clone)]
 pub struct IdContext {
@@ -28,23 +29,22 @@ pub struct IdContext {
     pub previous_id: String,
 }
 
-pub struct OptAuthedClient(Option<AuthedClient>);
 pub async fn eval_timeout(
     expr: String,
     env: Vec<(String, serde_json::Value)>,
-    authed_client: Option<&AuthedClient>,
+    creds: Option<EvalCreds>,
     by_id: Option<IdContext>,
+    base_internal_url: &str,
 ) -> anyhow::Result<serde_json::Value> {
     let expr2 = expr.clone();
     let (sender, mut receiver) = oneshot::channel::<IsolateHandle>();
-    let has_client = authed_client.is_some();
-    let authed_client = authed_client.cloned();
+    let base_internal_url: String = base_internal_url.to_string();
     timeout(
-        std::time::Duration::from_millis(10000),
+        std::time::Duration::from_millis(2000),
         tokio::task::spawn_blocking(move || {
             let mut ops = vec![];
 
-            if authed_client.is_some() {
+            if creds.is_some() {
                 ops.extend([
                     // An op for summing an array of numbers
                     // The op-layer automatically deserializes inputs
@@ -54,12 +54,12 @@ pub async fn eval_timeout(
                 ])
             }
 
-            if by_id.is_some() && authed_client.is_some() {
+            if by_id.is_some() {
                 ops.push(op_get_result::decl());
                 ops.push(op_get_id::decl());
             }
 
-            let ext = Extension::builder("js_eval").ops(ops).build();
+            let ext = Extension::builder().ops(ops).build();
             // Use our snapshot to provision our new runtime
             let options = RuntimeOptions {
                 extensions: vec![ext],
@@ -68,11 +68,6 @@ pub async fn eval_timeout(
             };
 
             let mut js_runtime = JsRuntime::new(options);
-            {
-                let op_state = js_runtime.op_state();
-                let mut op_state = op_state.borrow_mut();
-                op_state.put(OptAuthedClient(authed_client.clone()));
-            }
 
             sender
                 .send(js_runtime.v8_isolate().thread_safe_handle())
@@ -91,7 +86,14 @@ pub async fn eval_timeout(
 
             let expr = replace_with_await_result(expr);
 
-            let r = runtime.block_on(eval(&mut js_runtime, &expr, env, by_id, has_client))?;
+            let r = runtime.block_on(eval(
+                &mut js_runtime,
+                &expr,
+                env,
+                creds,
+                by_id,
+                &base_internal_url,
+            ))?;
 
             Ok(r) as anyhow::Result<Value>
         }),
@@ -102,7 +104,7 @@ pub async fn eval_timeout(
             isolate.terminate_execution();
         };
         Error::ExecutionErr(format!(
-            "The expression of evaluation `{expr2}` took too long to execute (>10000ms)"
+            "The expression of evaluation `{expr2}` took too long to execute (>2000ms)"
         ))
     })??
 }
@@ -143,30 +145,24 @@ fn add_closing_bracket(s: &str) -> String {
     s
 }
 
-const SPLIT_PAT: &str = ";";
+const SPLIT_PAT: &str = ";\n";
 async fn eval(
     context: &mut JsRuntime,
     expr: &str,
     env: Vec<(String, serde_json::Value)>,
+    creds: Option<EvalCreds>,
     by_id: Option<IdContext>,
-    has_client: bool,
+    base_internal_url: &str,
 ) -> anyhow::Result<serde_json::Value> {
-    let exprs = expr
-        .trim()
-        .split(SPLIT_PAT)
-        .map(|x| x.trim())
-        .filter(|x| !x.is_empty())
-        .collect::<Vec<&str>>();
-    let expr = if exprs.is_empty() {
-        "return undefined;".to_string()
-    } else {
-        format!(
-            "{};\n    return {};",
-            exprs.iter().take(exprs.len() - 1).join(";\n"),
-            exprs.last().unwrap()
-        )
-    };
-    let (api_code, by_id_code) = if has_client {
+    let expr = expr.trim();
+    let expr = format!(
+        "{}\nreturn {};",
+        expr.split(SPLIT_PAT)
+            .take(expr.split(SPLIT_PAT).count() - 1)
+            .join("\n"),
+        expr.split(SPLIT_PAT).last().unwrap_or_else(|| "")
+    );
+    let (api_code, by_id_code) = if let Some(EvalCreds { workspace, token }) = creds {
         let by_id_code = if let Some(by_id) = by_id {
             format!(
                 r#"
@@ -183,12 +179,12 @@ async function result_by_id(node_id) {{
         }}
     }} else {{
         let flow_job_id = "{}";
-        return await Deno.core.opAsync("op_get_id", [ flow_job_id, node_id]);
+        return await Deno.core.opAsync("op_get_id", [workspace, flow_job_id, token, base_url, node_id]);
     }}
 }}
 
 async function get_result(id) {{
-    return await Deno.core.opAsync("op_get_result", [id]);
+    return await Deno.core.opAsync("op_get_result", [workspace, id, token, base_url]);
 }}
 const results = new Proxy({{}}, {{
     get: function(target, name, receiver) {{
@@ -202,12 +198,12 @@ const results = new Proxy({{}}, {{
                     .into_iter()
                     .map(|(k, v)| {
                         let v_str = match v {
-                            JobResult::SingleJob(x) => format!("\"{x}\""),
+                            JobResult::SingleJob(x) => x.to_string(),
                             JobResult::ListJob(x) => {
-                                format!("[{}]", x.iter().map(|x| format!("\"{x}\"")).join(","))
+                                format!("[{}]", x.iter().map(|x| x.to_string()).join(","))
                             }
                         };
-                        format!("\"{k}\": {v_str}")
+                        format!("\"{k}\": \"{v_str}\"")
                     })
                     .join(","),
                 by_id.previous_id,
@@ -219,13 +215,17 @@ const results = new Proxy({{}}, {{
 
         let api_code = format!(
             r#"
+let workspace = "{workspace}";
+let base_url = "{}";
+let token = "{token}";
 async function variable(path) {{
-    return await Deno.core.opAsync("op_variable", [path]);
+    return await Deno.core.opAsync("op_variable", [workspace, path, token, base_url]);
 }}
 async function resource(path) {{
-    return await Deno.core.opAsync("op_resource", [path]);
+    return await Deno.core.opAsync("op_resource", [workspace, path, token, base_url]);
 }}
         "#,
+            base_internal_url,
         );
         (api_code, by_id_code)
     } else {
@@ -252,7 +252,7 @@ async function resource(path) {{
             .join(""),
     );
     tracing::debug!("{}", code);
-    let global = context.execute_script("<anon>", code)?;
+    let global = context.execute_script("<anon>", &code)?;
     let global = context.resolve_value(global).await?;
 
     let scope = &mut context.handle_scope();
@@ -274,83 +274,60 @@ async function resource(path) {{
 
 // TODO: Can we a) share the api configuration here somehow or b) just implement this natively in deno, via the deno client?
 #[op]
-async fn op_variable(
-    op_state: Rc<RefCell<OpState>>,
-    args: Vec<String>,
-) -> Result<String, anyhow::Error> {
-    let path = &args[0];
-    let client = op_state.borrow().borrow::<OptAuthedClient>().0.clone();
-    if let Some(client) = client {
-        let result = client
-            .get_client()
-            .get_variable(&client.workspace, path, None)
-            .await?;
-        Ok(result.into_inner().value.unwrap_or_else(|| "".to_owned()))
-    } else {
-        anyhow::bail!("No client found in op state");
-    }
+async fn op_variable(args: Vec<String>) -> Result<String, anyhow::Error> {
+    let workspace = &args[0];
+    let path = &args[1];
+    let token = &args[2];
+    let base_url = &args[3];
+    let client = windmill_api_client::create_client(base_url, token.clone());
+    let result = client.get_variable(workspace, path, None).await?;
+    Ok(result.into_inner().value.unwrap_or_else(|| "".to_owned()))
 }
 
 #[op]
-async fn op_get_result(
-    op_state: Rc<RefCell<OpState>>,
-    args: Vec<String>,
-) -> Result<serde_json::Value, anyhow::Error> {
-    let id = &args[0];
-    let client = op_state.borrow().borrow::<OptAuthedClient>().0.clone();
-    if let Some(client) = client {
-        let result = client
-            .get_client()
-            .get_completed_job_result(&client.workspace, &id.parse()?)
-            .await?
-            .clone();
-        Ok(serde_json::json!(result))
-    } else {
-        anyhow::bail!("No client found in op state");
-    }
+async fn op_get_result(args: Vec<String>) -> Result<serde_json::Value, anyhow::Error> {
+    let workspace = &args[0];
+    let id = &args[1];
+    let token = &args[2];
+    let base_url = &args[3];
+    let client = windmill_api_client::create_client(base_url, token.clone());
+    let result = client
+        .get_completed_job(workspace, &id.parse()?)
+        .await?
+        .result
+        .clone();
+    Ok(serde_json::json!(result))
 }
 
 #[op]
-async fn op_get_id(
-    op_state: Rc<RefCell<OpState>>,
-    args: Vec<String>,
-) -> Result<Option<serde_json::Value>, anyhow::Error> {
-    let flow_job_id = &args[0];
-    let node_id = &args[1];
+async fn op_get_id(args: Vec<String>) -> Result<Option<serde_json::Value>, anyhow::Error> {
+    let workspace = &args[0];
+    let flow_job_id = &args[1];
+    let token = &args[2];
+    let base_url = &args[3];
+    let node_id = &args[4];
 
-    let client = op_state.borrow().borrow::<OptAuthedClient>().0.clone();
-    if let Some(client) = client {
-        let result = client
-            .get_client()
-            .result_by_id(&client.workspace, flow_job_id, node_id)
-            .await
-            .map_or(None, |e| Some(e.into_inner()));
-        Ok(result)
-    } else {
-        anyhow::bail!("No client found in op state");
-    }
+    let client = windmill_api_client::create_client(base_url, token.clone());
+    let result = client
+        .result_by_id(workspace, flow_job_id, node_id, Some(true))
+        .await
+        .map_or(None, |e| Some(e.into_inner()));
+
+    Ok(result)
 }
 
 #[op]
-async fn op_resource(
-    op_state: Rc<RefCell<OpState>>,
-    args: Vec<String>,
-) -> Result<serde_json::Value, anyhow::Error> {
-    let path = &args[0];
-
-    let client = op_state.borrow().borrow::<OptAuthedClient>().0.clone();
-    if let Some(client) = client {
-        let result = client
-            .get_client()
-            .get_resource(&client.workspace, path)
-            .await?;
-        Ok(result
-            .into_inner()
-            .value
-            .unwrap_or_else(|| serde_json::json!({})))
-    } else {
-        anyhow::bail!("No client found in op state");
-    }
+async fn op_resource(args: Vec<String>) -> Result<serde_json::Value, anyhow::Error> {
+    let workspace = &args[0];
+    let path = &args[1];
+    let token = &args[2];
+    let base_url = &args[3];
+    let client = windmill_api_client::create_client(base_url, token.clone());
+    let result = client.get_resource(workspace, path).await?;
+    Ok(result
+        .into_inner()
+        .value
+        .unwrap_or_else(|| serde_json::json!({})))
 }
 
 #[cfg(test)]
@@ -370,7 +347,7 @@ mod tests {
         let code = "value.test + params.test";
 
         let mut runtime = JsRuntime::new(RuntimeOptions::default());
-        let res = eval(&mut runtime, code, env, None, false).await?;
+        let res = eval(&mut runtime, code, env, None, None, String::new().as_str()).await?;
         assert_eq!(res, json!(4));
         Ok(())
     }
@@ -383,7 +360,7 @@ mod tests {
 multiline template`";
 
         let mut runtime = JsRuntime::new(RuntimeOptions::default());
-        let res = eval(&mut runtime, code, env, None, false).await?;
+        let res = eval(&mut runtime, code, env, None, None, String::new().as_str()).await?;
         assert_eq!(res, json!("my 5\nmultiline template"));
         Ok(())
     }
@@ -396,7 +373,7 @@ multiline template`";
         ];
         let code = r#"params.test"#;
 
-        let res = eval_timeout(code.to_string(), env, None, None).await?;
+        let res = eval_timeout(code.to_string(), env, None, None, String::new().as_str()).await?;
         assert_eq!(res, json!(2));
         Ok(())
     }

cli/apps.ts

@@ -1,22 +1,12 @@
-import { requireLogin, resolveWorkspace, validatePath } from "./context.ts";
-import { Any, decoverto, model, property } from "./decoverto.ts";
+import { Any, model, property } from "./decoverto.ts";
 import {
   AppService,
   AppWithLastVersion,
   colors,
-  Command,
-  ListableApp,
   microdiff,
   Policy,
-  Table,
 } from "./deps.ts";
-import {
-  Difference,
-  GlobalOptions,
-  PushDiffs,
-  Resource,
-  setValueByPath,
-} from "./types.ts";
+import { Difference, PushDiffs, Resource, setValueByPath } from "./types.ts";
 
 @model()
 export class AppFile implements Resource, PushDiffs {
@@ -27,6 +17,7 @@ export class AppFile implements Resource, PushDiffs {
   @property(Any)
   policy: Policy;
 
+
   constructor(value: string, summary: string, policy: Policy) {
     this.value = value;
     this.summary = summary;
@@ -35,20 +26,16 @@ export class AppFile implements Resource, PushDiffs {
   async pushDiffs(
     workspace: string,
     remotePath: string,
-    diffs: Difference[]
+    diffs: Difference[],
   ): Promise<void> {
-    let app: AppWithLastVersion | undefined = undefined;
-    try {
-      app = await AppService.getAppByPath({ workspace, path: remotePath });
-    } catch (e) {}
-
-    if (app) {
+    if (await AppService.existsApp({ workspace, path: remotePath })) {
       console.log(
         colors.bold.yellow(
-          `Applying ${diffs.length} diffs to existing app... ${remotePath}`
-        )
+          `Applying ${diffs.length} diffs to existing app...`,
+        ),
       );
       const changeset: {
+        path?: string | undefined;
         summary?: string | undefined;
         value?: any;
         policy?: Policy | undefined;
@@ -56,10 +43,14 @@ export class AppFile implements Resource, PushDiffs {
       for (const diff of diffs) {
         if (
           diff.type !== "REMOVE" &&
-          diff.path[0] !== "value" &&
-          diff.path[0] !== "policy" &&
-          (diff.path.length !== 1 ||
-            !["summary"].includes(diff.path[0] as string))
+          (
+            diff.path[0] !== "value" && diff.path[0] !== "policy" && (
+              diff.path.length !== 1 ||
+              !["path", "summary"].includes(
+                diff.path[0] as string,
+              )
+            )
+          )
         ) {
           throw new Error("Invalid app diff with path " + diff.path);
         }
@@ -70,21 +61,8 @@ export class AppFile implements Resource, PushDiffs {
         }
       }
 
-      if (
-        (!changeset?.policy ||
-          JSON.stringify(changeset?.policy) == JSON.stringify(app.policy)) &&
-        (!changeset?.value ||
-          JSON.stringify(changeset?.value) == JSON.stringify(app.value)) &&
-        (!changeset?.summary || changeset.summary == app.summary)
-      ) {
-        console.log(
-          colors.yellow(`No changes to push for app ${remotePath}, skipping`)
-        );
-        return;
-      }
-
-      const hasChanges = Object.values(changeset).some(
-        (v) => v !== null && typeof v !== "undefined"
+      const hasChanges = Object.values(changeset).some((v) =>
+        v !== null && typeof v !== "undefined"
       );
       if (!hasChanges) {
         return;
@@ -97,7 +75,6 @@ export class AppFile implements Resource, PushDiffs {
       });
     } else {
       console.log(colors.yellow.bold("Creating new app..."));
-
       await AppService.createApp({
         workspace,
         requestBody: {
@@ -110,70 +87,19 @@ export class AppFile implements Resource, PushDiffs {
     }
   }
   async push(workspace: string, remotePath: string): Promise<void> {
+    let existing: AppWithLastVersion | undefined;
+    try {
+      existing = await AppService.getAppByPath({
+        workspace: workspace,
+        path: remotePath,
+      });
+    } catch {
+      existing = undefined;
+    }
     await this.pushDiffs(
       workspace,
       remotePath,
-      microdiff({}, this, { cyclesFix: false })
+      microdiff(existing ?? {}, this, { cyclesFix: false }),
     );
   }
 }
-
-async function list(opts: GlobalOptions) {
-  const workspace = await resolveWorkspace(opts);
-  await requireLogin(opts);
-
-  let page = 0;
-  const perPage = 10;
-  const total: ListableApp[] = [];
-  while (true) {
-    const res = await AppService.listApps({
-      workspace: workspace.workspaceId,
-      page,
-      perPage,
-    });
-    page += 1;
-    total.push(...res);
-    if (res.length < perPage) {
-      break;
-    }
-  }
-
-  new Table()
-    .header(["path", "summary"])
-    .padding(2)
-    .border(true)
-    .body(total.map((x) => [x.path, x.summary]))
-    .render();
-}
-
-async function push(opts: GlobalOptions, filePath: string) {
-  const remotePath = filePath.split(".")[0];
-  if (!validatePath(remotePath)) {
-    return;
-  }
-  const workspace = await resolveWorkspace(opts);
-  await requireLogin(opts);
-
-  await pushApp(filePath, workspace.workspaceId, remotePath);
-  console.log(colors.bold.underline.green("App pushed"));
-}
-
-export async function pushApp(
-  filePath: string,
-  workspace: string,
-  remotePath: string
-) {
-  const data = decoverto
-    .type(AppFile)
-    .rawToInstance(await Deno.readTextFile(filePath));
-  await data.push(workspace, remotePath);
-}
-
-const command = new Command()
-  .description("app related commands")
-  .action(list as any)
-  .command("push", "push a local app ")
-  .arguments("<file_path:file>")
-  .action(push as any);
-
-export default command;

cli/context.ts

@@ -18,12 +18,12 @@ export type Context = {
 };
 
 async function tryResolveWorkspace(
-  opts: GlobalOptions
+  opts: GlobalOptions,
 ): Promise<
   { isError: false; value: Workspace } | { isError: true; error: string }
 > {
   const cache = (opts as any).__secret_workspace;
-  if (cache) return { isError: false, value: cache };
+  if (cache) return cache;
 
   if (opts.workspace) {
     const e = await getWorkspaceByName(opts.workspace);
@@ -49,23 +49,21 @@ async function tryResolveWorkspace(
 }
 
 export async function resolveWorkspace(
-  opts: GlobalOptions
+  opts: GlobalOptions,
 ): Promise<Workspace> {
   const res = await tryResolveWorkspace(opts);
   if (res.isError) {
-    console.log(colors.red.bold(res.error));
+    console.log(res.error);
     return Deno.exit(-1);
   } else {
     return res.value;
   }
 }
 
-export async function requireLogin(
-  opts: GlobalOptions
-): Promise<GlobalUserInfo> {
+export async function requireLogin(opts: GlobalOptions): Promise<GlobalUserInfo> {
   const workspace = await resolveWorkspace(opts);
-  let token = await tryGetLoginInfo(opts);
 
+  let token = await tryGetLoginInfo(opts);
   if (!token) {
     token = workspace.token;
   }
@@ -76,26 +74,26 @@ export async function requireLogin(
     return await UserService.globalWhoami();
   } catch {
     console.log(
-      "! Could not reach API given existing credentials. Attempting to reauth..."
+      "! Could not reach API given existing credentials. Attempting to reauth...",
     );
     const newToken = await loginInteractive(workspace.remote);
     if (!newToken) {
       throw new Error("Could not reauth");
     }
-    removeWorkspace(workspace.name, false, opts);
+    removeWorkspace(workspace.name);
     workspace.token = newToken;
-    addWorkspace(workspace, opts);
+    addWorkspace(workspace);
 
     setClient(
       token,
-      workspace.remote.substring(0, workspace.remote.length - 1)
+      workspace.remote.substring(0, workspace.remote.length - 1),
     );
     return await UserService.globalWhoami();
   }
 }
 
 export async function tryResolveVersion(
-  opts: GlobalOptions
+  opts: GlobalOptions,
 ): Promise<number | undefined> {
   if ((opts as any).__cache_version) {
     return (opts as any).__cache_version;
@@ -105,24 +103,41 @@ export async function tryResolveVersion(
   if (workspaceRes.isError) return undefined;
 
   const response = await fetch(
-    new URL(new URL(workspaceRes.value.remote).origin + "/api/version")
+    new URL(new URL(workspaceRes.value.remote).origin + "/api/version"),
   );
   const version = await response.text();
   try {
     return Number.parseInt(
-      version.split("-", 1)[0].replaceAll(".", "").replace("v", "")
+      version.split("-", 1)[0].replaceAll(".", "").replace("v", ""),
     );
   } catch {
     return undefined;
   }
 }
 
-export function validatePath(path: string): boolean {
-  if (!(path.startsWith("g") || path.startsWith("u") || path.startsWith("f"))) {
+export async function validatePath(
+  opts: GlobalOptions,
+  path: string,
+): Promise<boolean> {
+  const backendVersion = await tryResolveVersion(opts);
+  if (path.startsWith("f")) {
+    if (!backendVersion || backendVersion >= 1550) {
+      return true;
+    }
+    console.log(
+      `Attempting to use folders, but the current remote does not have support. Remote version is ${backendVersion} but folders are supported from 1560.`,
+    );
+    return false;
+  }
+
+  if (
+    !(path.startsWith("g") ||
+      path.startsWith("u"))
+  ) {
     console.log(
       colors.red(
-        "Given remote path looks invalid. Remote paths are typically of the form <u|g|f>/<username|group|folder>/..."
-      )
+        "Given remote path looks invalid. Remote paths are typically of the form <u|g|f>/<username|group|folder>/...",
+      ),
     );
     return false;
   }

cli/deps.ts

@@ -33,7 +33,9 @@ export { passwordGenerator } from "https://deno.land/x/password_generator@latest
 export { nanoid } from "https://deno.land/x/nanoid@v3.0.0/mod.ts";
 export * as cbor from "https://deno.land/x/cbor@v1.4.1/index.js";
 export { default as Murmurhash3 } from "https://deno.land/x/murmurhash@v1.0.0/mod.ts";
-export { default as microdiff } from "https://deno.land/x/microdiff@v1.3.1/index.ts";
+export {
+  default as microdiff,
+} from "https://deno.land/x/microdiff@v1.3.1/index.ts";
 export { default as objectHash } from "https://deno.land/x/object_hash@2.0.3.1/mod.ts";
 export { default as gitignore_parser } from "npm:gitignore-parser";
 export { default as JSZip } from "npm:jszip@3.7.1";

cli/flow.ts

@@ -20,6 +20,7 @@ import { requireLogin, resolveWorkspace, validatePath } from "./context.ts";
 import { resolve, track_job } from "./script.ts";
 import { Any, decoverto, model, property } from "./decoverto.ts";
 
+
 // this is effectively "OpenFlow" but a copy as it is accepted by the CLI
 @model()
 export class FlowFile implements Resource, PushDiffs {
@@ -39,7 +40,7 @@ export class FlowFile implements Resource, PushDiffs {
   async pushDiffs(
     workspace: string,
     remotePath: string,
-    diffs: Difference[]
+    diffs: Difference[],
   ): Promise<void> {
     if (
       await FlowService.existsFlowByPath({
@@ -49,8 +50,8 @@ export class FlowFile implements Resource, PushDiffs {
     ) {
       console.log(
         colors.bold.yellow(
-          `Applying ${diffs.length} diffs to existing flow... ${remotePath}`
-        )
+          `Applying ${diffs.length} diffs to existing flow... ${remotePath}`,
+        ),
       );
 
       // TODO: Make these optional in backend (not path ofc)
@@ -65,11 +66,14 @@ export class FlowFile implements Resource, PushDiffs {
       for (const diff of diffs) {
         if (
           diff.type !== "REMOVE" &&
-          diff.path[0] !== "value" &&
-          (diff.path.length !== 1 ||
-            !["summary", "description", "schema"].includes(
-              diff.path[0] as string
-            ))
+          (
+            diff.path[0] !== "value" && (
+              diff.path.length !== 1 ||
+              !["summary", "description", "schema"].includes(
+                diff.path[0] as string,
+              )
+            )
+          )
         ) {
           throw new Error("Invalid flow diff with path " + diff.path);
         }
@@ -79,8 +83,8 @@ export class FlowFile implements Resource, PushDiffs {
           setValueByPath(changeset, diff.path, null);
         }
       }
-      const hasChanges = Object.values(changeset).some(
-        (v) => v !== null && typeof v !== "undefined"
+      const hasChanges = Object.values(changeset).some((v) =>
+        v !== null && typeof v !== "undefined"
       );
       if (!hasChanges) {
         return;
@@ -89,8 +93,7 @@ export class FlowFile implements Resource, PushDiffs {
       const update = {
         ...changeset,
         ...base_changeset,
-      };
-
+      }
       await FlowService.updateFlow({
         workspace: workspace,
         path: remotePath,
@@ -111,10 +114,20 @@ export class FlowFile implements Resource, PushDiffs {
     }
   }
   async push(workspace: string, remotePath: string): Promise<void> {
+    let remote: Flow | undefined;
+    try {
+      remote = await FlowService.getFlowByPath({
+        workspace,
+        path: remotePath,
+      });
+    } catch {
+
+      remote = undefined;
+    }
     await this.pushDiffs(
       workspace,
       remotePath,
-      microdiff({}, this, { cyclesFix: false })
+      microdiff(remote ?? {}, this, { cyclesFix: false }),
     );
   }
 }
@@ -122,24 +135,24 @@ export class FlowFile implements Resource, PushDiffs {
 type Options = GlobalOptions;
 
 async function push(opts: Options, filePath: string, remotePath: string) {
-  if (!validatePath(remotePath)) {
+  if (!await validatePath(opts, remotePath)) {
     return;
   }
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
 
-  await pushFlow(filePath, workspace.workspaceId, remotePath);
+  await pushFlow(filePath, workspace.remote, remotePath);
   console.log(colors.bold.underline.green("Flow pushed"));
 }
 
 export async function pushFlow(
   filePath: string,
   workspace: string,
-  remotePath: string
+  remotePath: string,
 ) {
-  const data = decoverto
-    .type(FlowFile)
-    .rawToInstance(await Deno.readTextFile(filePath));
+  const data = decoverto.type(FlowFile).rawToInstance(
+    await Deno.readTextFile(filePath),
+  );
   await data.push(workspace, remotePath);
 }
 
@@ -168,20 +181,26 @@ async function list(opts: GlobalOptions & { showArchived?: boolean }) {
     .header(["path", "summary", "edited by"])
     .padding(2)
     .border(true)
-    .body(total.map((x) => [x.path, x.summary, x.edited_by]))
+    .body(
+      total.map((x) => [
+        x.path,
+        x.summary,
+        x.edited_by,
+      ]),
+    )
     .render();
 }
 async function run(
   opts: GlobalOptions & {
-    data?: string;
+    input: string[];
     silent: boolean;
   },
-  path: string
+  path: string,
 ) {
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
 
-  const input = opts.data ? await resolve(opts.data) : {};
+  const input = await resolve(opts.input);
 
   const id = await JobService.runFlowByPath({
     workspace: workspace.workspaceId,
@@ -217,7 +236,6 @@ async function run(
 
   if (!opts.silent) {
     console.log(colors.green.underline.bold("Flow ran to completion"));
-    console.log();
   }
   const jobInfo = await JobService.getCompletedJob({
     workspace: workspace.workspaceId,
@@ -232,19 +250,19 @@ const command = new Command()
   .action(list as any)
   .command(
     "push",
-    "push a local flow spec. This overrides any remote versions."
+    "push a local flow spec. This overrides any remote versions.",
   )
   .arguments("<file_path:string> <remote_path:string>")
   .action(push as any)
   .command("run", "run a flow by path.")
   .arguments("<path:string>")
   .option(
-    "-d --data <data:string>",
-    "Inputs specified as a JSON string or a file using @<filename> or stdin using @-."
+    "-i --input [inputs...:string]",
+    "Inputs specified as JSON objects or simply as <name>=<value>. Supports file inputs using @<filename> and stdin using @- these also need to be formatted as JSON. Later inputs override earlier ones.",
   )
   .option(
     "-s --silent",
-    "Do not ouput anything other then the final output. Useful for scripting."
+    "Do not ouput anything other then the final output. Useful for scripting.",
   )
   .action(run as any);
 

cli/folder.ts

@@ -1,4 +1,4 @@
-import { colors, Command, FolderService, microdiff } from "./deps.ts";
+import { colors, Command, Folder, FolderService, microdiff } from "./deps.ts";
 import { requireLogin, resolveWorkspace, validatePath } from "./context.ts";
 import {
   Difference,
@@ -20,16 +20,8 @@ import {
 export class FolderFile implements Resource, PushDiffs {
   @property(array(() => String))
   owners: Array<string> | undefined;
-  @property(
-    map(
-      () => String,
-      () => Boolean,
-      { shape: MapShape.Object }
-    )
-  )
+  @property(map(() => String, () => Boolean, { shape: MapShape.Object }))
   extra_perms: Map<string, boolean> | undefined;
-  @property(() => String)
-  display_name: string | undefined;
 
   async push(workspace: string, remotePath: string): Promise<void> {
     if (remotePath.startsWith("/")) {
@@ -39,17 +31,23 @@ export class FolderFile implements Resource, PushDiffs {
       remotePath = remotePath.substring(2);
     }
 
+    let existing: Folder | undefined;
+    try {
+      existing = await FolderService.getFolder({ workspace, name: remotePath });
+    } catch {
+      existing = undefined;
+    }
     await this.pushDiffs(
       workspace,
       remotePath,
-      microdiff({}, this, { cyclesFix: false })
+      microdiff(existing ?? {}, this, { cyclesFix: false }),
     );
   }
 
   async pushDiffs(
     workspace: string,
     remotePath: string,
-    diffs: Difference[]
+    diffs: Difference[],
   ): Promise<void> {
     if (remotePath.startsWith("/")) {
       remotePath = remotePath.substring(1);
@@ -61,34 +59,29 @@ export class FolderFile implements Resource, PushDiffs {
     // TODO: Support this in backend
     let exists: boolean;
     try {
-      exists = !!(await FolderService.getFolder({
-        workspace,
-        name: remotePath,
-      }));
+      exists = !!await FolderService.getFolder({ workspace, name: remotePath });
     } catch {
       exists = false;
     }
     if (exists) {
       console.log(
         colors.bold.yellow(
-          `Applying ${diffs.length} diffs to existing folder... ${remotePath}`
-        )
+          `Applying ${diffs.length} diffs to existing folder...`,
+        ),
       );
 
       const changeset: {
         owners?: string[] | undefined;
         extra_perms?: any;
-        display_name?: string | undefined;
       } = {};
       for (const diff of diffs) {
         if (
           diff.type !== "REMOVE" &&
-          (diff.path.length !== 1 ||
-            !["owners", "extra_perms", "display_name"].includes(
-              diff.path[0] as string
-            ))
+          (
+            diff.path.length !== 1 ||
+            !["owners", "extra_perms"].includes(diff.path[0] as string)
+          )
         ) {
-          console.log(diff.path);
           throw new Error("Invalid folder diff with path " + diff.path);
         }
         if (diff.type === "CREATE" || diff.type === "CHANGE") {
@@ -98,27 +91,18 @@ export class FolderFile implements Resource, PushDiffs {
         }
       }
 
-      const hasChanges = Object.values(changeset).some(
-        (v) => v !== null && typeof v !== "undefined"
+      const hasChanges = Object.values(changeset).some((v) =>
+        v !== null && typeof v !== "undefined"
       );
       if (!hasChanges) {
         return;
       }
-      try {
-        await FolderService.updateFolder({
-          workspace: workspace,
-          name: remotePath,
-          requestBody: {
-            ...changeset,
-            extra_perms: changeset.extra_perms
-              ? Object.fromEntries(this.extra_perms?.entries() ?? [])
-              : undefined,
-          },
-        });
-      } catch (e) {
-        console.error(colors.red.bold(e.body));
-        throw e;
-      }
+
+      await FolderService.updateFolder({
+        workspace: workspace,
+        name: remotePath,
+        requestBody: changeset,
+      });
     } else {
       console.log(colors.bold.yellow("Creating new folder: " + remotePath));
       await FolderService.createFolder({
@@ -137,7 +121,7 @@ async function push(opts: GlobalOptions, filePath: string, remotePath: string) {
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
 
-  if (!validatePath(remotePath)) {
+  if (!await validatePath(opts, remotePath)) {
     return;
   }
 
@@ -155,11 +139,11 @@ async function push(opts: GlobalOptions, filePath: string, remotePath: string) {
 export async function pushFolder(
   workspace: string,
   filePath: string,
-  remotePath: string
+  remotePath: string,
 ) {
-  const data = decoverto
-    .type(FolderFile)
-    .rawToInstance(await Deno.readTextFile(filePath));
+  const data = decoverto.type(FolderFile).rawToInstance(
+    await Deno.readTextFile(filePath),
+  );
   data.push(workspace, remotePath);
 }
 
@@ -167,7 +151,7 @@ const command = new Command()
   .description("resource related commands")
   .command(
     "push",
-    "push a local folder spec. This overrides any remote versions."
+    "push a local folder spec. This overrides any remote versions.",
   )
   .arguments("<file_path:string> <remote_path:string>")
   .action(push as any);

cli/main.ts

@@ -1,11 +1,5 @@
-import {
-  Command,
-  CompletionsCommand,
-  DenoLandProvider,
-  UpgradeCommand,
-} from "./deps.ts";
+import { Command, CompletionsCommand, DenoLandProvider, UpgradeCommand } from "./deps.ts";
 import flow from "./flow.ts";
-import app from "./apps.ts";
 import script from "./script.ts";
 import workspace from "./workspace.ts";
 import resource from "./resource.ts";
@@ -19,21 +13,21 @@ import sync from "./sync.ts";
 import { tryResolveVersion } from "./context.ts";
 import { GlobalOptions } from "./types.ts";
 
-export const VERSION = "v1.86.0";
+const VERSION = "v1.70.1";
 
 let command: any = new Command()
   .name("wmill")
   .description("A simple CLI tool for windmill.")
+  .action(() => command.showHelp())
   .globalOption(
     "--workspace <workspace:string>",
-    "Specify the target workspace. This overrides the default workspace."
+    "Specify the target workspace. This overrides the default workspace.",
   )
   .globalOption(
     "--token <token:string>",
-    "Specify an API token. This will override any stored token."
+    "Specify an API token. This will override any stored token.",
   )
   .version(VERSION)
-  .command("app", app)
   .command("flow", flow)
   .command("script", script)
   .command("workspace", workspace)
@@ -65,12 +59,14 @@ let command: any = new Command()
         "--unstable",
       ],
       provider: new DenoLandProvider({ name: "wmill" }),
-    })
+    }),
   )
   .command("completions", new CompletionsCommand());
 
 if (Number.parseInt(VERSION.replace("v", "").replace(".", "")) > 1700) {
-  command = command.command("push", push).command("pull", pull);
+  command = command
+    .command("push", push)
+    .command("pull", pull);
 }
 
 try {

cli/pull.ts

@@ -5,27 +5,25 @@ import { Workspace } from "./workspace.ts";
 
 export async function downloadZip(
   workspace: Workspace,
-  plainSecrets: boolean | undefined
 ): Promise<JSZip | undefined> {
   const requestHeaders: HeadersInit = new Headers();
   requestHeaders.set("Authorization", "Bearer " + workspace.token);
   requestHeaders.set("Content-Type", "application/octet-stream");
 
   const zipResponse = await fetch(
-    workspace.remote +
-      "api/w/" +
-      workspace.workspaceId +
-      "/workspaces/tarball?archive_type=zip&plain_secret=" +
-      (plainSecrets ?? false),
+    workspace.remote + "api/w/" + workspace.workspaceId +
+    "/workspaces/tarball?archive_type=zip",
     {
       headers: requestHeaders,
       method: "GET",
-    }
+    },
   );
 
   if (!zipResponse.ok) {
     console.log(
-      colors.red("Failed to request tarball from API " + zipResponse.statusText)
+      colors.red(
+        "Failed to request tarball from API " + zipResponse.statusText,
+      ),
     );
     throw new Error(await zipResponse.text());
   }
@@ -35,18 +33,18 @@ export async function downloadZip(
 
 async function stub(
   _opts: GlobalOptions & { override: boolean },
-  _dir: string
+  _dir: string,
 ) {
   console.log(
     colors.red.underline(
-      'Pull is deprecated. Use "sync pull --raw" instead. See <TODO_LINK_HERE> for more information.'
-    )
+      'Pull is deprecated. Use "sync pull --raw" instead. See <TODO_LINK_HERE> for more information.',
+    ),
   );
 }
 
 const command = new Command()
   .description(
-    "Pull all definitions in the current workspace from the API and write them to disk."
+    "Pull all definitions in the current workspace from the API and write them to disk.",
   )
   .arguments("<dir:string>")
   .action(stub as any);

cli/resource-type.ts

@@ -13,6 +13,7 @@ import {
   EditResourceType,
   microdiff,
   ResourceService,
+  ResourceType,
   Table,
 } from "./deps.ts";
 import { Any, decoverto, model, property } from "./decoverto.ts";
@@ -25,10 +26,19 @@ export class ResourceTypeFile implements ResourceI, PushDiffs {
   description?: string;
 
   async push(workspace: string, remotePath: string): Promise<void> {
-    await this.pushDiffs(
+    let existing: ResourceType | undefined;
+    try {
+      existing = await ResourceService.getResourceType({
+        workspace,
+        path: remotePath,
+      });
+    } catch {
+      existing = undefined;
+    }
+    this.pushDiffs(
       workspace,
       remotePath,
-      microdiff({}, this, { cyclesFix: false }),
+      microdiff(existing ?? {}, this, { cyclesFix: false }),
     );
   }
 
@@ -55,8 +65,8 @@ export class ResourceTypeFile implements ResourceI, PushDiffs {
         return;
       }
       console.log(
-        colors.yellow.bold(
-          `Applying ${diffs.length} diffs to existing resource type... ${remotePath}`,
+        colors.yellow(
+          `Applying ${diffs.length} diffs to existing resource type...`,
         ),
       );
       const changeset: EditResourceType = {};

cli/resource.ts

@@ -34,7 +34,7 @@ export class ResourceFile implements Resource2, PushDiffs {
   async pushDiffs(
     workspace: string,
     remotePath: string,
-    diffs: Difference[]
+    diffs: Difference[],
   ): Promise<void> {
     if (
       await ResourceService.existsResource({
@@ -43,9 +43,7 @@ export class ResourceFile implements Resource2, PushDiffs {
       })
     ) {
       console.log(
-        colors.yellow.bold(
-          `Applying ${diffs.length} diffs to existing resource... ${remotePath}`
-        )
+        colors.yellow(`Applying ${diffs.length} diffs to existing resource...`),
       );
 
       const changeset: EditResource = {
@@ -53,18 +51,22 @@ export class ResourceFile implements Resource2, PushDiffs {
       };
       for (const diff of diffs) {
         if (diff.path[0] === "is_oauth") {
-          //is_oauth is not updatable
+          console.log(
+            colors.yellow(
+              "! is_oauth has been removed in newer versions. Ignoring.",
+            ),
+          );
           continue;
         }
         if (
           diff.type !== "REMOVE" &&
-          diff.path[0] !== "value" &&
-          (diff.path.length !== 1 || diff.path[0] !== "description") &&
-          diff.path[0] !== "resource_type"
+          (
+            diff.path[0] !== "value" && (
+              diff.path.length !== 1 ||
+              diff.path[0] !== "description"
+            )
+          )
         ) {
-          console.log(
-            colors.red("Invalid variable diff with path " + diff.path)
-          );
           throw new Error("Invalid folder diff with path " + diff.path);
         }
         if (diff.type === "CREATE" || diff.type === "CHANGE") {
@@ -74,8 +76,8 @@ export class ResourceFile implements Resource2, PushDiffs {
         }
       }
 
-      const hasChanges = Object.values(changeset).some(
-        (v) => v !== null && typeof v !== "undefined"
+      const hasChanges = Object.values(changeset).some((v) =>
+        v !== null && typeof v !== "undefined"
       );
       if (!hasChanges) {
         return;
@@ -90,8 +92,8 @@ export class ResourceFile implements Resource2, PushDiffs {
       if (typeof this.is_oauth !== "undefined") {
         console.log(
           colors.yellow(
-            "! is_oauth has been removed in newer versions. Ignoring."
-          )
+            "! is_oauth has been removed in newer versions. Ignoring.",
+          ),
         );
       }
 
@@ -108,10 +110,19 @@ export class ResourceFile implements Resource2, PushDiffs {
     }
   }
   async push(workspace: string, remotePath: string): Promise<void> {
+    let existing: Resource | undefined;
+    try {
+      existing = await ResourceService.getResource({
+        workspace,
+        path: remotePath,
+      });
+    } catch {
+      existing = undefined;
+    }
     await this.pushDiffs(
       workspace,
       remotePath,
-      microdiff({}, this, { cyclesFix: false })
+      microdiff(existing ?? {}, this, { cyclesFix: false }),
     );
   }
 }
@@ -119,11 +130,11 @@ export class ResourceFile implements Resource2, PushDiffs {
 export async function pushResource(
   workspace: string,
   filePath: string,
-  remotePath: string
+  remotePath: string,
 ) {
-  const data = decoverto
-    .type(ResourceFile)
-    .rawToInstance(await Deno.readTextFile(filePath));
+  const data = decoverto.type(ResourceFile).rawToInstance(
+    await Deno.readTextFile(filePath),
+  );
   await data.push(workspace, remotePath);
 }
 
@@ -132,7 +143,7 @@ async function push(opts: PushOptions, filePath: string, remotePath: string) {
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
 
-  if (!validatePath(remotePath)) {
+  if (!await validatePath(opts, remotePath)) {
     return;
   }
 
@@ -179,7 +190,7 @@ const command = new Command()
   .action(list as any)
   .command(
     "push",
-    "push a local resource spec. This overrides any remote versions."
+    "push a local resource spec. This overrides any remote versions.",
   )
   .arguments("<file_path:string> <remote_path:string>")
   .action(push as any);

cli/script.ts

@@ -11,7 +11,6 @@ import {
   Table,
 } from "./deps.ts";
 import { Any, array, decoverto, model, property } from "./decoverto.ts";
-import { writeAllSync } from "https://deno.land/std@0.176.0/streams/mod.ts";
 
 @model()
 export class ScriptFile {
@@ -32,11 +31,8 @@ export class ScriptFile {
       if (data == null) return data;
 
       if (
-        data === "script" ||
-        data === "failure" ||
-        data === "trigger" ||
-        data === "command" ||
-        data === "approvial"
+        data === "script" || data === "failure" || data === "trigger" ||
+        data === "command" || data === "approvial"
       ) {
         return data;
       }
@@ -45,7 +41,6 @@ export class ScriptFile {
     },
     toPlain: (data) => data,
   })
-  @property(() => String)
   kind?: "script" | "failure" | "trigger" | "command" | "approval";
 
   constructor(summary: string, description: string) {
@@ -55,11 +50,14 @@ export class ScriptFile {
 }
 
 type PushOptions = GlobalOptions;
-async function push(opts: PushOptions, filePath: string) {
+async function push(
+  opts: PushOptions,
+  filePath: string,
+  remotePath: string,
+  contentPath?: string,
+) {
   const workspace = await resolveWorkspace(opts);
-  const remotePath = filePath.split(".")[0];
-
-  if (!validatePath(remotePath)) {
+  if (!await validatePath(opts, remotePath)) {
     return;
   }
 
@@ -67,136 +65,89 @@ async function push(opts: PushOptions, filePath: string) {
   if (!fstat.isFile) {
     throw new Error("file path must refer to a file.");
   }
-  let contentPath: string;
-  let metaPath: string | undefined;
-  if (filePath.endsWith(".script.json")) {
-    metaPath = filePath;
+  if (!contentPath) {
     contentPath = await findContentFile(filePath);
   } else {
-    contentPath = filePath;
-    metaPath = undefined;
+    const fstat = await Deno.stat(filePath);
+    if (!fstat.isFile) {
+      throw new Error("content path must refer to a file.");
+    }
   }
 
   await requireLogin(opts);
-  await pushScript(metaPath, contentPath, workspace.workspaceId, remotePath);
+  await pushScript(filePath, contentPath, workspace.workspaceId, remotePath);
   console.log(colors.bold.underline.green(`Script ${remotePath} pushed`));
 }
 
-export async function handleScriptMetadata(
-  path: string,
-  workspace: string,
-  alreadySynced: string[]
-): Promise<boolean> {
+export async function handleScriptMetadata(path: string, workspace: string, alreadySynced: string[]): Promise<boolean> {
   if (path.endsWith(".script.json")) {
-    const contentPath = await findContentFile(path);
-    return handleFile(
-      contentPath,
-      await Deno.readTextFile(contentPath),
-      workspace,
-      alreadySynced
-    );
+    const contentPath = await findContentFile(path)
+    return handleFile(contentPath, await Deno.readTextFile(contentPath), workspace, alreadySynced)
   } else {
-    return false;
+    return false
   }
 }
 
-export async function handleFile(
-  path: string,
-  content: string,
-  workspace: string,
-  alreadySynced: string[]
-): Promise<boolean> {
-  if (
-    path.endsWith(".ts") ||
-    path.endsWith(".py") ||
-    path.endsWith(".go") ||
-    path.endsWith(".sh")
-  ) {
+export async function handleFile(path: string, content: string, workspace: string, alreadySynced: string[]): Promise<boolean> {
+  if (path.endsWith(".ts") || path.endsWith(".py") || path.endsWith(".go") || path.endsWith(".sh")) {
     if (alreadySynced.includes(path)) {
-      return true;
+      return true
     }
-    alreadySynced.push(path);
+    alreadySynced.push(path)
     const remotePath = path.substring(0, path.length - 3);
     const metaPath = remotePath + ".script.json";
-    let typed = undefined;
+    let typed = undefined
     try {
-      await Deno.stat(metaPath);
-      typed = JSON.parse(await Deno.readTextFile(metaPath));
+      await Deno.stat(metaPath)
+      typed = JSON.parse(await Deno.readTextFile(metaPath))
       typed = decoverto.type(ScriptFile).plainToInstance(typed);
-    } catch {}
+    } catch { }
     const language = inferContentTypeFromFilePath(path);
 
-    let remote = undefined;
     try {
-      remote = await ScriptService.getScriptByPath({
+      const remote = await ScriptService.getScriptByPath({
         workspace,
         path: remotePath,
       });
-    } catch {}
-
-    if (remote) {
-      if (content === remote.content) {
-        if (
-          typed == undefined ||
-          (typed.description === remote.description &&
-            typed.summary === remote.summary &&
-            typed.is_template === remote.is_template &&
-            typed.kind == remote.kind &&
-            remote?.lock == typed.lock?.join("\n") &&
-            JSON.stringify(typed.schema) == JSON.stringify(remote.schema))
-        ) {
-          console.log(
-            colors.yellow(
-              `No change to push for script ${remotePath}, skipping`
-            )
-          );
-          return true;
-        }
-      }
-
       await ScriptService.createScript({
         workspace,
         requestBody: {
           content,
-          description: typed?.description ?? "",
+          description: typed.description,
           language,
           path: remotePath,
-          summary: typed?.summary ?? "",
-          is_template: typed?.is_template,
-          kind: typed?.kind,
-          lock: typed?.lock,
+          summary: typed.summary,
+          is_template: typed.is_template,
+          kind: typed.kind,
+          lock: typed.lock,
           parent_hash: remote.hash,
-          schema: typed?.schema,
+          schema: typed.schema,
         },
       });
-
-      console.log(
-        colors.yellow.bold(`Creating script with a parent ${remotePath}`)
-      );
-    } else {
+      console.log(colors.yellow.bold(`Creating script with a parent ${remotePath}`))
+    } catch {
       // no parent hash
       await ScriptService.createScript({
         workspace: workspace,
         requestBody: {
           content,
-          description: typed?.description ?? "",
+          description: typed.description,
           language,
           path: remotePath,
-          summary: typed?.summary ?? "",
-          is_template: typed?.is_template,
-          kind: typed?.kind,
-          lock: typed?.lock,
+          summary: typed.summary,
+          is_template: typed.is_template,
+          kind: typed.kind,
+          lock: typed.lock,
           parent_hash: undefined,
-          schema: typed?.schema,
+          schema: typed.schema,
         },
       });
-      console.log(
-        colors.yellow.bold(`Creating script without parent ${remotePath}`)
-      );
+      console.log(colors.yellow.bold(`Creating script without parent ${remotePath}`))
+
     }
-    return true;
+    return true
   }
-  return false;
+  return false
 }
 
 export async function findContentFile(filePath: string) {
@@ -215,7 +166,7 @@ export async function findContentFile(filePath: string) {
           .then((e) => {
             return { path: x, file: e };
           });
-      })
+      }),
     )
   )
     .filter((x) => x.file)
@@ -223,7 +174,7 @@ export async function findContentFile(filePath: string) {
   if (validCandidates.length > 1) {
     throw new Error(
       "No content path given and more then one candidate found: " +
-        validCandidates.join(", ")
+      validCandidates.join(", "),
     );
   }
   if (validCandidates.length < 1) {
@@ -233,7 +184,7 @@ export async function findContentFile(filePath: string) {
 }
 
 export function inferContentTypeFromFilePath(
-  contentPath: string
+  contentPath: string,
 ): "python3" | "deno" | "go" | "bash" {
   let language = contentPath.substring(contentPath.lastIndexOf("."));
   if (language == ".ts") language = "deno";
@@ -241,9 +192,7 @@ export function inferContentTypeFromFilePath(
   if (language == ".sh") language = "bash";
   if (language == ".go") language = "go";
   if (
-    language != "python3" &&
-    language != "deno" &&
-    language != "go" &&
+    language != "python3" && language != "deno" && language != "go" &&
     language != "bash"
   ) {
     throw new Error("Invalid language: " + language);
@@ -252,20 +201,18 @@ export function inferContentTypeFromFilePath(
 }
 
 export async function pushScript(
-  filePath: string | undefined,
+  filePath: string,
   contentPath: string,
   workspace: string,
-  remotePath: string
+  remotePath: string,
 ) {
-  const data = filePath
-    ? decoverto
-        .type(ScriptFile)
-        .rawToInstance(await Deno.readTextFile(filePath))
-    : undefined;
+  const data = decoverto.type(ScriptFile).rawToInstance(
+    await Deno.readTextFile(filePath),
+  );
   const content = await Deno.readTextFile(contentPath);
 
   const language = inferContentTypeFromFilePath(contentPath);
-  let parent_hash = data?.parent_hash;
+  let parent_hash = data.parent_hash;
   if (!parent_hash) {
     try {
       parent_hash = (
@@ -284,15 +231,15 @@ export async function pushScript(
     workspace: workspace,
     requestBody: {
       path: remotePath,
-      summary: data?.summary ?? "",
+      summary: data.summary,
       content: content,
-      description: data?.description ?? "",
+      description: data.description,
       language: language,
-      is_template: data?.is_template,
-      kind: data?.kind,
-      lock: data?.lock,
+      is_template: data.is_template,
+      kind: data.kind,
+      lock: data.lock,
       parent_hash: parent_hash,
-      schema: data?.schema,
+      schema: data.schema,
     },
   });
 }
@@ -322,40 +269,69 @@ async function list(opts: GlobalOptions & { showArchived?: boolean }) {
     .header(["path", "summary", "language", "created by"])
     .padding(2)
     .border(true)
-    .body(total.map((x) => [x.path, x.summary, x.language, x.created_by]))
+    .body(
+      total.map((x) => [
+        x.path,
+        x.summary,
+        x.language,
+        x.created_by,
+      ]),
+    )
     .render();
 }
 
-export async function resolve(input: string): Promise<Record<string, any>> {
-  if (!input) {
-    throw new Error("No data given");
+export async function resolve(inputs: string[]): Promise<Record<string, any>> {
+  let result = {};
+
+  if (!inputs) {
+    return result;
   }
 
-  if (input == "@-") {
-    input = new TextDecoder().decode(await readAll(Deno.stdin));
-  }
-  if (input[0] == "@") {
-    input = await Deno.readTextFile(input.substring(1));
-  }
-  try {
-    return JSON.parse(input);
-  } catch (e) {
-    console.error("Impossible to parse input as JSON", input);
-    throw e;
+  for (const input of inputs) {
+    let data: string;
+    if (input.startsWith("@")) {
+      if (input == "@-") {
+        data = new TextDecoder().decode(await readAll(Deno.stdin));
+      } else {
+        data = await Deno.readTextFile(input.substring(1));
+      }
+    } else {
+      if (input.startsWith("{")) {
+        data = input;
+      } else {
+        const key = input.split("=", 1)[0];
+        const value = input.substring(key.length + 1);
+        let o;
+        try {
+          o = JSON.parse(value);
+        } catch {
+          o = value;
+        }
+        data = JSON.stringify(Object.fromEntries([[key, o]]));
+      }
+    }
+    let jsonObj;
+    try {
+      jsonObj = JSON.parse(data);
+    } catch {
+      jsonObj = data;
+    }
+    result = { ...result, ...jsonObj };
   }
+  return result;
 }
 
 async function run(
   opts: GlobalOptions & {
-    data?: string;
+    input: string[];
     silent: boolean;
   },
-  path: string
+  path: string,
 ) {
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
 
-  const input = opts.data ? await resolve(opts.data) : {};
+  const input = await resolve(opts.input);
   const id = await JobService.runScriptByPath({
     workspace: workspace.workspaceId,
     path,
@@ -368,13 +344,12 @@ async function run(
 
   while (true) {
     try {
-      const result =
-        (
-          await JobService.getCompletedJob({
-            workspace: workspace.workspaceId,
-            id,
-          })
-        ).result ?? {};
+      const result = (
+        await JobService.getCompletedJob({
+          workspace: workspace.workspaceId,
+          id,
+        })
+      ).result ?? {};
       console.log(result);
 
       break;
@@ -389,9 +364,7 @@ export async function track_job(workspace: string, id: string) {
     const result = await JobService.getCompletedJob({ workspace, id });
 
     console.log(result.logs);
-    console.log();
     console.log(colors.bold.underline.green("Job Completed"));
-    console.log();
     return;
   } catch {
     /* ignore */
@@ -430,7 +403,7 @@ export async function track_job(workspace: string, id: string) {
     }
 
     if (updates.new_logs) {
-      writeAllSync(Deno.stdout, new TextEncoder().encode(updates.new_logs));
+      console.log(updates.new_logs);
       logOffset += updates.new_logs.length;
     }
 
@@ -442,7 +415,7 @@ export async function track_job(workspace: string, id: string) {
     if (running && updates.running === false) {
       running = false;
       console.log(
-        colors.yellow("Job suspended. Waiting for it to continue...")
+        colors.yellow("Job suspended. Waiting for it to continue..."),
       );
     }
   }
@@ -453,13 +426,12 @@ export async function track_job(workspace: string, id: string) {
     if ((final_job.logs?.length ?? -1) > logOffset) {
       console.log(final_job.logs!.substring(logOffset));
     }
-    console.log("\n");
+
     if (final_job.success) {
       console.log(colors.bold.underline.green("Job Completed"));
     } else {
       console.log(colors.bold.underline.red("Job Completed"));
     }
-    console.log();
   } catch {
     console.log("Job appears to have completed, but no data can be retrieved");
   }
@@ -484,22 +456,22 @@ const command = new Command()
   .action(list as any)
   .command(
     "push",
-    "push a local script spec. This overrides any remote versions. Can use a script file (.ts, .js, .py, .sh) or a script spec file (.json). "
+    "push a local script spec. This overrides any remote versions.",
   )
-  .arguments("<file_path:file>")
+  .arguments("<file_path:string> <remote_path:string> [content_path:string]")
   .action(push as any)
   .command("show", "show a scripts content")
-  .arguments("<path:file>")
+  .arguments("<path:string>")
   .action(show as any)
   .command("run", "run a script by path")
-  .arguments("<path:file>")
+  .arguments("<path:string>")
   .option(
-    "-d --data <data:file>",
-    "Inputs specified as a JSON string or a file using @<filename> or stdin using @-."
+    "-i --input [inputs...:string]",
+    "Inputs specified as JSON objects or simply as <name>=<value>. Supports file inputs using @<filename> and stdin using @- these also need to be formatted as JSON. Later inputs override earlier ones.",
   )
   .option(
     "-s --silent",
-    "Do not ouput anything other then the final output. Useful for scripting."
+    "Do not ouput anything other then the final output. Useful for scripting.",
   )
   .action(run as any);
 

cli/sync.ts

@@ -13,7 +13,7 @@ import {
   ResourceService,
   VariableService,
   AppService,
-  FlowService,
+  FlowService
 } from "./deps.ts";
 import {
   Difference,
@@ -25,14 +25,16 @@ import {
 import { downloadZip } from "./pull.ts";
 import { FolderFile } from "./folder.ts";
 import { ResourceTypeFile } from "./resource-type.ts";
-import { handleScriptMetadata, ScriptFile } from "./script.ts";
+import {
+  handleScriptMetadata,
+  ScriptFile,
+} from "./script.ts";
 import { ResourceFile } from "./resource.ts";
 import { FlowFile } from "./flow.ts";
 import { VariableFile } from "./variable.ts";
 import { handleFile } from "./script.ts";
-import { equal } from "https://deno.land/x/equal@v1.5.0/mod.ts";
-import * as Diff from "npm:diff";
-
+import { equal } from "https://deno.land/x/equal/mod.ts";
+import { diffCharacters } from "https://deno.land/x/diff/mod.ts";
 type DynFSElement = {
   isDirectory: boolean;
   path: string;
@@ -42,7 +44,10 @@ type DynFSElement = {
 };
 
 async function FSFSElement(p: string): Promise<DynFSElement> {
-  function _internal_element(localP: string, isDir: boolean): DynFSElement {
+  function _internal_element(
+    localP: string,
+    isDir: boolean,
+  ): DynFSElement {
     return {
       isDirectory: isDir,
       path: localP.substring(p.length + 1),
@@ -108,14 +113,16 @@ function ZipFSElement(zip: JSZip): DynFSElement {
 
 async function* readDirRecursiveWithIgnore(
   ignore: (path: string, isDirectory: boolean) => boolean,
-  root: DynFSElement
-): AsyncGenerator<{
-  path: string;
-  ignored: boolean;
-  isDirectory: boolean;
-  getContentBytes(): Promise<Uint8Array>;
-  getContentText(): Promise<string>;
-}> {
+  root: DynFSElement,
+): AsyncGenerator<
+  {
+    path: string;
+    ignored: boolean;
+    isDirectory: boolean;
+    getContentBytes(): Promise<Uint8Array>;
+    getContentText(): Promise<string>;
+  }
+> {
   const stack: {
     path: string;
     isDirectory: boolean;
@@ -123,20 +130,18 @@ async function* readDirRecursiveWithIgnore(
     c(): AsyncIterable<DynFSElement>;
     getContentBytes(): Promise<Uint8Array>;
     getContentText(): Promise<string>;
-  }[] = [
-    {
-      path: root.path,
-      ignored: ignore(root.path, root.isDirectory),
-      isDirectory: root.isDirectory,
-      c: root.getChildren,
-      getContentBytes(): Promise<Uint8Array> {
-        throw undefined;
-      },
-      getContentText(): Promise<string> {
-        throw undefined;
-      },
+  }[] = [{
+    path: root.path,
+    ignored: ignore(root.path, root.isDirectory),
+    isDirectory: root.isDirectory,
+    c: root.getChildren,
+    getContentBytes(): Promise<Uint8Array> {
+      throw undefined;
     },
-  ];
+    getContentText(): Promise<string> {
+      throw undefined;
+    },
+  }];
 
   while (stack.length > 0) {
     const e = stack.pop()!;
@@ -156,17 +161,17 @@ async function* readDirRecursiveWithIgnore(
 }
 
 type Added = { name: "added"; path: string; content: string };
-type Deleted = { name: "deleted"; path: string };
-type Edit = { name: "edited"; path: string; before: string; after: string };
+type Deleted = { name: "deleted"; path: string; };
+type Edit = { name: "edited"; path: string; before: string; after: string; };
 
 type Change = Added | Deleted | Edit;
 
-async function elementsToMap(
-  els: DynFSElement,
-  ignore: (path: string, isDirectory: boolean) => boolean
-): Promise<{ [key: string]: string }> {
+async function elementsToMap(els: DynFSElement, ignore: (path: string, isDirectory: boolean) => boolean): Promise<{ [key: string]: string }> {
   const map: { [key: string]: string } = {};
-  for await (const entry of readDirRecursiveWithIgnore(ignore, els)) {
+  for await (const entry of readDirRecursiveWithIgnore(
+    ignore,
+    els,
+  )) {
     if (entry.isDirectory || entry.ignored) continue;
     const content = await entry.getContentText();
     map[entry.path] = content;
@@ -174,26 +179,20 @@ async function elementsToMap(
   return map;
 }
 async function compareDynFSElement(
-  els1: DynFSElement,
-  els2: DynFSElement | undefined,
-  ignore: (path: string, isDirectory: boolean) => boolean
+  els1: DynFSElement, els2: DynFSElement,
+  ignore: (path: string, isDirectory: boolean) => boolean,
+  raw: boolean
 ): Promise<Change[]> {
-  const [m1, m2] = els2
-    ? await Promise.all([
-        elementsToMap(els1, ignore),
-        elementsToMap(els2, ignore),
-      ])
-    : [await elementsToMap(els1, ignore), {}];
+
+  const [m1, m2] = raw ? [await elementsToMap(els1, ignore), {}] :
+    await Promise.all([elementsToMap(els1, ignore), elementsToMap(els2, ignore)]);
 
   const changes: Change[] = [];
 
   for (const [k, v] of Object.entries(m1)) {
     if (m2[k] === undefined) {
       changes.push({ name: "added", path: k, content: v });
-    } else if (
-      m2[k] != v &&
-      (!k.endsWith(".json") || !equal(JSON.parse(v), JSON.parse(m2[k])))
-    ) {
+    } else if (m2[k] != v && (!k.endsWith(".json") || !equal(JSON.parse(v), JSON.parse(m2[k])))) {
       // await Deno.writeTextFile("/tmp/k", m2[k])
       // await Deno.writeTextFile("/tmp/v", v)
       // console.log(k)
@@ -209,59 +208,54 @@ async function compareDynFSElement(
     }
   }
 
-  return changes;
+  return changes
 }
 
 const isNotWmillFile = (p: string, isDirectory: boolean) => {
   if (p.endsWith("/")) {
-    return false;
+    return false
   }
   if (isDirectory) {
-    return !p.startsWith("u/") && !p.startsWith("f/") && !p.startsWith("g/");
+    return !p.startsWith("u/") && !p.startsWith("f/") && !p.startsWith("g/")
   }
 
   try {
-    const typ = getTypeStrFromPath(p);
-    if (typ == "resource-type") {
-      return p.includes("/");
+    const typ = getTypeStrFromPath(p)
+    if (typ == 'resource-type') {
+      return p.includes('/')
     } else {
-      return !p.startsWith("u/") && !p.startsWith("f/") && !p.startsWith("g/");
+      return !p.startsWith("u/") && !p.startsWith("f/") && !p.startsWith("g/")
     }
   } catch {
-    return true;
+    return true
   }
-};
+}
 
 const isWhitelisted = (p: string) => {
-  return p == "./" || p == "" || p == "u" || p == "f" || p == "g";
-};
+  return p == "./" || p == "" || p == "u" || p == "f" || p == "g"
+}
 async function ignoreF() {
   try {
     const ignore: {
       accepts(file: string): boolean;
       denies(file: string): boolean;
-    } = gitignore_parser.compile(await Deno.readTextFile(".wmillignore"));
+    } = gitignore_parser.compile(
+      await Deno.readTextFile(".wmillignore"),
+    );
 
     return (p: string, isDirectory: boolean) => {
-      return (
-        !isWhitelisted(p) &&
-        (isNotWmillFile(p, isDirectory) || ignore.denies(p))
-      );
-    };
+      return !isWhitelisted(p) && (isNotWmillFile(p, isDirectory) || ignore.denies(p));
+    }
   } catch (e) {
-    return (p: string, isDirectory: boolean) =>
-      !isWhitelisted(p) && isNotWmillFile(p, isDirectory);
+    return (p: string, isDirectory: boolean) => !isWhitelisted(p) && isNotWmillFile(p, isDirectory)
   }
 }
 
 async function pull(
-  opts: GlobalOptions & {
-    raw: boolean;
-    yes: boolean;
-    failConflicts: boolean;
-    plainSecrets?: boolean;
-  }
+  opts: GlobalOptions & { raw: boolean; yes: boolean, failConflicts: boolean },
 ) {
+
+
   if (!opts.raw) {
     await ensureDir(path.join(Deno.cwd(), ".wmill"));
   }
@@ -269,92 +263,74 @@ async function pull(
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
 
-  console.log(
-    colors.gray(
-      "Computing the files to update locally to match remote (taking .wmillignore into account)"
-    )
-  );
-  const remote = ZipFSElement(
-    (await downloadZip(workspace, opts.plainSecrets))!
-  );
-  const local = opts.raw
-    ? undefined
-    : await FSFSElement(path.join(Deno.cwd(), opts.raw ? "" : ".wmill"));
-  const changes = await compareDynFSElement(remote, local, await ignoreF());
+
+  console.log(colors.gray("Computing the files to update locally to match remote (taking .wmillignore into account)"));
+  const remote = ZipFSElement((await downloadZip(workspace))!)
+  const local = await FSFSElement(path.join(Deno.cwd(), opts.raw ? "" : ".wmill"))
+  const changes = await compareDynFSElement(remote, local, await ignoreF(), opts.raw)
+
 
   console.log(`remote -> local: ${changes.length} changes to apply`);
   if (changes.length > 0) {
-    prettyChanges(changes);
+
+    prettyChanges(changes)
     if (
-      !opts.yes &&
-      !opts.raw &&
-      !(await Confirm.prompt({
-        message: `Do you want to apply these ${changes.length} changes?`,
-        default: true,
-      }))
+      !opts.yes && !opts.raw && !(await Confirm.prompt({ message: `Do you want to apply these ${changes.length} changes?`, default: true }))
     ) {
-      return;
+      return
     }
 
-    const conflicts = [];
+    const conflicts = []
     console.log(colors.gray(`Applying changes to files ...`));
     for await (const change of changes) {
       const target = path.join(Deno.cwd(), change.path);
-      const stateTarget = path.join(Deno.cwd(), ".wmill", change.path);
+      const stateTarget = path.join(Deno.cwd(), ".wmill", change.path)
       if (change.name === "edited") {
+
         try {
-          const currentLocal = await Deno.readTextFile(target);
-          if (currentLocal !== change.before && currentLocal !== change.after) {
-            console.log(
-              colors.red(
-                `Conflict detected on ${change.path}\nBoth local and remote have been modified.`
-              )
-            );
+          const currentLocal = await Deno.readTextFile(target)
+          if (currentLocal !== change.before) {
+            console.log(colors.red(`Conflict detected on ${change.path}\nBoth local and remote have been modified.`))
             if (opts.failConflicts) {
-              conflicts.push({
-                local: currentLocal,
-                change,
-                path: change.path,
-              });
+              conflicts.push({ local: currentLocal, change, path: change.path })
               continue;
             } else if (opts.yes) {
-              console.log(
-                colors.red(
-                  `Override local version with remote since --yes was passed and no --fail-conflicts.`
-                )
-              );
-            } else {
-              showConflict(change.path, currentLocal, change.after);
-              if (
-                await Confirm.prompt(
-                  "Preserve local (push to change remote and avoid seeing this again)?"
-                )
-              ) {
+              console.log(colors.red(`Override local version with remote since --yes was passed and no --fail-conflicts.`))
+            }
+            else {
+              showConflict(change.path, currentLocal, change.after)
+              if (await Confirm.prompt("Preserve local (push to change remote and avoid seeing this again)?")) {
                 continue;
               }
             }
           }
-        } catch {}
-        if (!change.path.endsWith(".json")) {
-          console.log(`Editing script content of ${change.path}`);
-        } else {
-          console.log(
-            `Editing ${getTypeStrFromPath(change.path)} ${change.path}`
-          );
-        }
-        await Deno.writeTextFile(target, change.after);
+        } catch { }
+        if (change.path.endsWith(".json")) {
+          const diffs =
+            microdiff(
+              JSON.parse(change.before),
+              JSON.parse(change.after),
+              { cyclesFix: false },
+            )
 
+          console.log(`Editing ${getTypeStrFromPath(change.path)} json ${change.path}`)
+          await applyDiff(
+            diffs,
+            target,
+          );
+        } else {
+          console.log(`Editing script ${change.path}`)
+          await Deno.writeTextFile(target, change.after);
+        }
         if (!opts.raw) {
-          await ensureDir(path.dirname(stateTarget));
+          await ensureDir(path.dirname(stateTarget))
           await Deno.copyFile(target, stateTarget);
         }
       } else if (change.name === "added") {
-        await ensureDir(path.dirname(target));
+        await ensureDir(path.dirname(target))
         if (!opts.raw) {
-          await ensureDir(path.dirname(stateTarget));
-          console.log(
-            `Adding ${getTypeStrFromPath(change.path)} ${change.path}`
-          );
+          await ensureDir(path.dirname(stateTarget))
+          console.log(`Adding ${getTypeStrFromPath(change.path)} ${change.path}`)
         }
         await Deno.writeTextFile(target, change.content);
         if (!opts.raw) {
@@ -362,10 +338,8 @@ async function pull(
         }
       } else if (change.name === "deleted") {
         try {
-          console.log(
-            `Deleting ${getTypeStrFromPath(change.path)} ${change.path}`
-          );
-          await Deno.remove(target);
+          console.log(`Deleting ${getTypeStrFromPath(change.path)} ${change.path}`)
+          await Deno.remove(target)
           if (!opts.raw) {
             await Deno.remove(stateTarget);
           }
@@ -378,301 +352,238 @@ async function pull(
     }
     if (opts.failConflicts) {
       if (conflicts.length > 0) {
-        console.error(colors.red(`Conflicts were found`));
-        console.log("Conflicts:");
+        console.error(colors.red(`Conflicts were found`))
+        console.log("Conflicts:")
         for (const conflict of conflicts) {
-          showConflict(conflict.path, conflict.local, conflict.change.after);
+          showConflict(conflict.path, conflict.local, conflict.change.after)
         }
-        console.log(
-          colors.red(`Please resolve theses conflicts manually by either:
+        console.log(colors.red(`Please resolve theses conflicts manually by either:
   - reverting the content back to its remote (\`wmill pull\` and refuse to preserve local when prompted)
   - pushing the changes with \`wmill push --skip-pull\` to override wmill with all your local changes
-`)
-        );
-        Deno.exit(1);
+`))
+        Deno.exit(1)
       }
     }
-    console.log(
-      colors.green.underline(
-        `Done! All ${changes.length} changes applied locally.`
-      )
-    );
+    console.log(colors.green.underline(`Done! All ${changes.length} changes applied locally.`));
   }
 
+
   function showConflict(path: string, local: string, remote: string) {
-    console.log(colors.yellow(`- ${path}`));
+    console.log(colors.yellow(`- ${path}`))
 
     let finalString = "";
-    for (const part of Diff.diffLines(local, remote)) {
-      if (part.removed) {
+    for (const character of diffCharacters(local, remote)) {
+      if (character.wasRemoved) {
         // print red if removed without newline
-        finalString += `\x1b[31m${part.value}\x1b[0m`;
-      } else if (part.added) {
+        finalString += `\x1b[31m${character.character}\x1b[0m`;
+      } else if (character.wasAdded) {
         // print green if added
-        finalString += `\x1b[32m${part.value}\x1b[0m`;
+        finalString += `\x1b[32m${character.character}\x1b[0m`;
       } else {
         // print white if unchanged
-        finalString += `\x1b[37m${part.value}\x1b[0m`;
+        finalString += `\x1b[37m${character.character}\x1b[0m`;
       }
     }
     console.log(finalString);
-    console.log("\x1b[31mlocal\x1b[31m - \x1b[32mremote\x1b[32m");
-    console.log();
+    console.log("\x1b[31mlocal\x1b[31m - \x1b[32mremote\x1b[32m")
+    console.log()
+  }
+  async function applyDiff(diffs: Difference[], file: string) {
+    ensureDir(path.dirname(file));
+    let json;
+    try {
+      json = JSON.parse(await Deno.readTextFile(file));
+    } catch {
+      json = {};
+    }
+    // TODO: Delegate the below to the object itself
+    // This would work by infering the type of `JSON` (which includes then statically typing it using decoverto) and then
+    // delegating the applying of the diffs to the object via an interface
+    for (const diff of diffs) {
+      if (diff.type === "CREATE") {
+        setValueByPath(json, diff.path, diff.value);
+      } else if (diff.type === "REMOVE") {
+        setValueByPath(json, diff.path, undefined);
+      } else if (diff.type === "CHANGE") {
+        setValueByPath(json, diff.path, diff.value);
+      }
+    }
+
+    await Deno.writeTextFile(file, JSON.stringify(json, undefined, "  "), {
+      create: true,
+    });
   }
 }
 
+
+
+
 function prettyChanges(changes: Change[]) {
   for (const change of changes) {
     if (change.name === "added") {
-      console.log(
-        colors.green(`+ ${getTypeStrFromPath(change.path)} ` + change.path)
-      );
+      console.log(colors.green(`+ ${getTypeStrFromPath(change.path)} ` + change.path));
     } else if (change.name === "deleted") {
-      console.log(
-        colors.red(`- ${getTypeStrFromPath(change.path)} ` + change.path)
-      );
+      console.log(colors.red(`- ${getTypeStrFromPath(change.path)} ` + change.path));
     } else if (change.name === "edited") {
-      console.log(
-        colors.yellow(`~ ${getTypeStrFromPath(change.path)} ` + change.path)
-      );
+      console.log(colors.yellow(`~ ${getTypeStrFromPath(change.path)} ` + change.path));
+    }
+  }
+}
+
+function prettyDiff(diffs: Difference[]) {
+  for (const diff of diffs) {
+    let pathString = "";
+    for (const pathSegment of diff.path) {
+      if (typeof pathSegment === "string") {
+        pathString += ".";
+        pathString += pathSegment;
+      } else {
+        pathString += "[";
+        pathString += pathSegment;
+        pathString += "]";
+      }
+    }
+    if (diff.type === "REMOVE" || diff.type === "CHANGE") {
+      console.log(colors.red("- " + pathString + " = " + diff.oldValue));
+    }
+    if (diff.type === "CREATE" || diff.type === "CHANGE") {
+      console.log(colors.green("+ " + pathString + " = " + diff.value));
     }
   }
 }
 
-// function prettyDiff(diffs: Difference[]) {
-//   for (const diff of diffs) {
-//     let pathString = "";
-//     for (const pathSegment of diff.path) {
-//       if (typeof pathSegment === "string") {
-//         pathString += ".";
-//         pathString += pathSegment;
-//       } else {
-//         pathString += "[";
-//         pathString += pathSegment;
-//         pathString += "]";
-//       }
-//     }
-//     if (diff.type === "REMOVE" || diff.type === "CHANGE") {
-//       console.log(colors.red("- " + pathString + " = " + diff.oldValue));
-//     }
-//     if (diff.type === "CREATE" || diff.type === "CHANGE") {
-//       console.log(colors.green("+ " + pathString + " = " + diff.value));
-//     }
-//   }
-// }
 
 function removeSuffix(str: string, suffix: string) {
   return str.slice(0, str.length - suffix.length);
 }
 
-async function push(
-  opts: GlobalOptions & {
-    raw: boolean;
-    yes: boolean;
-    skipPull: boolean;
-    failConflicts: boolean;
-    plainSecrets?: boolean;
-  }
-) {
+async function push(opts: GlobalOptions & { raw: boolean, yes: boolean, skipPull: boolean, failConflicts: boolean }) {
+
+
   if (!opts.raw) {
     if (!opts.skipPull) {
-      console.log(
-        colors.gray("You need to be up-to-date before pushing, pulling first.")
-      );
-      await pull(opts);
-      console.log(colors.green("Pull done, now pushing."));
-      console.log();
+      console.log(colors.gray("You need to be up-to-date before pushing, pulling first."))
+      await pull(opts)
+      console.log(colors.green("Pull done, now pushing."))
+      console.log()
     }
   }
 
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
 
-  console.log(
-    colors.gray(
-      "Computing the files to update on the remote to match local (taking .wmillignore into account)"
-    )
-  );
-  const remote = opts.raw
-    ? undefined
-    : ZipFSElement((await downloadZip(workspace, opts.plainSecrets))!);
-  const local = await FSFSElement(path.join(Deno.cwd(), ""));
-  const changes = await compareDynFSElement(local, remote, await ignoreF());
+
+  console.log(colors.gray("Computing the files to update on the remote to match local (taking .wmillignore into account)"));
+  const remote = ZipFSElement((await downloadZip(workspace))!)
+  const local = await FSFSElement(path.join(Deno.cwd(), ""))
+  const changes = await compareDynFSElement(local, remote, await ignoreF(), opts.raw)
 
   console.log(`remote <- local: ${changes.length} changes to apply`);
   if (changes.length > 0) {
-    prettyChanges(changes);
+
+    prettyChanges(changes)
     if (
-      !opts.yes &&
-      !(await Confirm.prompt({
-        message: `Do you want to apply these ${changes.length} changes?`,
-        default: true,
-      }))
+      !opts.yes && !(await Confirm.prompt({ message: `Do you want to apply these ${changes.length} changes?`, default: true }))
     ) {
-      return;
+      return
     }
     console.log(colors.gray(`Applying changes to files ...`));
-    const alreadySynced: string[] = [];
+    const alreadySynced: string[] = []
     for await (const change of changes) {
-      const stateTarget = path.join(Deno.cwd(), ".wmill", change.path);
-      let stateExists = true;
-      try {
-        await Deno.stat(stateTarget);
-      } catch {
-        stateExists = false;
-      }
-
+      const stateTarget = path.join(Deno.cwd(), ".wmill", change.path)
       if (change.name === "edited") {
-        if (
-          await handleScriptMetadata(
-            change.path,
-            workspace.workspaceId,
-            alreadySynced
-          )
-        ) {
-          if (!opts.raw && stateExists) {
+        if (await handleScriptMetadata(change.path, workspace.workspaceId, alreadySynced)) {
+          if (!opts.raw) {
             await Deno.writeTextFile(stateTarget, change.after);
           }
-          continue;
-        } else if (
-          await handleFile(
-            change.path,
-            change.after,
-            workspace.workspaceId,
-            alreadySynced
-          )
-        ) {
-          if (!opts.raw && stateExists) {
+          continue
+        } else if (await handleFile(change.path, change.after, workspace.workspaceId, alreadySynced)) {
+          if (!opts.raw) {
             await Deno.writeTextFile(stateTarget, change.after);
           }
-          continue;
+          continue
         }
         if (!opts.raw) {
-          await ensureDir(path.dirname(stateTarget));
-          console.log(
-            `Editing ${getTypeStrFromPath(change.path)} ${change.path}`
-          );
+          await ensureDir(path.dirname(stateTarget))
+          console.log(`Editing ${getTypeStrFromPath(change.path)} ${change.path}`)
         }
-        const obj = inferTypeFromPath(change.path, JSON.parse(change.after));
+        const obj = inferTypeFromPath(change.path, JSON.parse(change.after))
 
-        const diff = microdiff(
-          inferTypeFromPath(change.path, JSON.parse(change.before)),
-          obj,
-          { cyclesFix: false }
-        );
+        const diff = microdiff(inferTypeFromPath(change.path, JSON.parse(change.before)), obj, { cyclesFix: false });
         await applyDiff(
           workspace.workspaceId,
           change.path.split(".")[0],
           obj,
           diff,
-          opts.plainSecrets
         );
-        if (!opts.raw && stateExists) {
+        if (!opts.raw) {
           await Deno.writeTextFile(stateTarget, change.after);
         }
       } else if (change.name === "added") {
         if (change.path.endsWith(".script.json")) {
-          continue;
-        } else if (
-          await handleFile(
-            change.path,
-            change.content,
-            workspace.workspaceId,
-            alreadySynced
-          )
-        ) {
-          continue;
+          continue
+        } else if (await handleFile(change.path, change.content, workspace.workspaceId, alreadySynced)) {
+          continue
         }
-        if (!opts.raw && stateExists) {
-          await ensureDir(path.dirname(stateTarget));
-          console.log(
-            `Adding ${getTypeStrFromPath(change.path)} ${change.path}`
-          );
+        if (!opts.raw) {
+          await ensureDir(path.dirname(stateTarget))
+          console.log(`Adding ${getTypeStrFromPath(change.path)} ${change.path}`)
         }
-        const obj = inferTypeFromPath(change.path, JSON.parse(change.content));
+        const obj = inferTypeFromPath(change.path, JSON.parse(change.content))
         const diff = microdiff({}, obj, { cyclesFix: false });
         await applyDiff(
           workspace.workspaceId,
           change.path.split(".")[0],
           obj,
           diff,
-          opts.plainSecrets
         );
-        if (!opts.raw && stateExists) {
+        if (!opts.raw) {
           await Deno.writeTextFile(stateTarget, change.content);
         }
       } else if (change.name === "deleted") {
         if (!change.path.includes(".json")) {
-          continue;
+          continue
         }
-        console.log(
-          `Deleting ${getTypeStrFromPath(change.path)} ${change.path}`
-        );
-        const typ = getTypeStrFromPath(change.path);
+        console.log(`Deleting ${getTypeStrFromPath(change.path)} ${change.path}`)
+        const typ = getTypeStrFromPath(change.path)
         const workspaceId = workspace.workspaceId;
         switch (typ) {
           case "script": {
-            const script = await ScriptService.getScriptByPath({
-              workspace: workspaceId,
-              path: removeSuffix(change.path, ".script.json"),
-            });
-            await ScriptService.deleteScriptByHash({
-              workspace: workspaceId,
-              hash: script.hash,
-            });
+            const script = await ScriptService.getScriptByPath({ workspace: workspaceId, path: removeSuffix(change.path, ".script.json") })
+            await ScriptService.deleteScriptByHash({ workspace: workspaceId, hash: script.hash })
             break;
           }
           case "folder":
-            await FolderService.deleteFolder({
-              workspace: workspaceId,
-              name: change.path.split("/")[1],
-            });
+            await FolderService.deleteFolder({ workspace: workspaceId, name: change.path.split('/')[1] })
             break;
           case "resource":
-            await ResourceService.deleteResource({
-              workspace: workspaceId,
-              path: removeSuffix(change.path, ".resource.json"),
-            });
+            await ResourceService.deleteResource({ workspace: workspaceId, path: removeSuffix(change.path, ".resource.json") })
             break;
           case "resource-type":
-            await ResourceService.deleteResourceType({
-              workspace: workspaceId,
-              path: removeSuffix(change.path, ".resource-type.json"),
-            });
-            break;
+            await ResourceService.deleteResourceType({ workspace: workspaceId, path: removeSuffix(change.path, ".resource-type.json") })
+            break
           case "flow":
-            await FlowService.deleteFlowByPath({
-              workspace: workspaceId,
-              path: removeSuffix(change.path, ".flow.json"),
-            });
-            break;
+            await FlowService.deleteFlowByPath({ workspace: workspaceId, path: removeSuffix(change.path, ".flow.json") })
+            break
           case "app":
-            await AppService.deleteApp({
-              workspace: workspaceId,
-              path: removeSuffix(change.path, ".app.json"),
-            });
-            break;
+            await AppService.deleteApp({ workspace: workspaceId, path: removeSuffix(change.path, ".app.json") })
+            break
           case "variable":
-            await VariableService.deleteVariable({
-              workspace: workspaceId,
-              path: removeSuffix(change.path, ".variable.json"),
-            });
-            break;
+            await VariableService.deleteVariable({ workspace: workspaceId, path: removeSuffix(change.path, ".variable.json") })
+            break
           default:
             break;
         }
         try {
-          await Deno.remove(stateTarget);
-        } catch {}
+          Deno.remove(stateTarget)
+        } catch { }
       }
     }
-    console.log(
-      colors.green.underline(
-        `Done! All ${changes.length} changes pushed to the remote workspace.`
-      )
-    );
+    console.log(colors.green.underline(`Done! All ${changes.length} changes pushed to the remote workspace.`));
+
   }
 
+
   async function applyDiff(
     workspace: string,
     remotePath: string,
@@ -684,11 +595,10 @@ async function push(
       | ResourceTypeFile
       | FolderFile,
     diffs: Difference[],
-    plainSecrets?: boolean
   ) {
     if (file instanceof ScriptFile) {
       throw new Error(
-        "This code path should be unreachable - we should never generate diffs for scripts"
+        "This code path should be unreachable - we should never generate diffs for scripts",
       );
     } else if (file instanceof FolderFile) {
       const parts = remotePath.split("/");
@@ -699,14 +609,14 @@ async function push(
       }
     }
     if (diffs.length === 0) {
-      console.log("No diffs to apply to " + remotePath);
+      console.log("No diffs to apply to " + remotePath)
       return;
     }
     try {
-      await file.pushDiffs(workspace, remotePath, diffs, plainSecrets);
+      await file.pushDiffs(workspace, remotePath, diffs);
     } catch (e) {
-      console.error("Failing to apply diffs to " + remotePath);
-      console.error(JSON.stringify(e));
+      console.error("Failing to apply diffs to " + remotePath)
+      console.error(e.body)
     }
   }
 }
@@ -714,28 +624,20 @@ async function push(
 const command = new Command()
   .command("pull")
   .description(
-    "Pull any remote changes and apply them locally. Use --raw for usage without local state tracking."
-  )
-  .option(
-    "--fail-conflicts",
-    "Error on conflicts (both remote and local have changes on the same item)"
+    "Pull any remote changes and apply them locally. Use --raw for usage without local state tracking.",
   )
+  .option("--fail-conflicts", "Error on conflicts (both remote and local have changes on the same item)")
   .option("--yes", "Pull without needing confirmation")
   .option("--raw", "Pull without using state, just overwrite.")
-  .option("--plain-secrets", "Pull secrets as plain text")
   .action(pull as any)
   .command("push")
   .description(
-    "Push any local changes and apply them remotely. Use --raw for usage without local state tracking."
+    "Push any local changes and apply them remotely. Use --raw for usage without local state tracking.",
   )
-  .option(
-    "--fail-conflicts",
-    "Error on conflicts (both remote and local have changes on the same item)"
-  )
-  .option("--skip-pull", "Push without pulling first (you have pulled prior)")
+  .option("--fail-conflicts", "Error on conflicts (both remote and local have changes on the same item)")
+  .option("--skip-pull", "Push without pulling first")
   .option("--yes", "Push without needing confirmation")
   .option("--raw", "Push without using state, just overwrite.")
-  .option("--plain-secrets", "Push secrets as plain text")
   .action(push as any);
 
 export default command;

cli/types.ts

@@ -11,11 +11,7 @@ import { AppFile } from "./apps.ts";
 // TODO: Remove this & replace with a "pull" that lets the object either pull the remote version or return undefined.
 // Then combine those with diffing, which then gives the new push impl
 export interface Resource {
-  push(
-    workspace: string,
-    remotePath: string,
-    plainSecrets?: boolean
-  ): Promise<void>;
+  push(workspace: string, remotePath: string): Promise<void>;
 }
 
 export interface PushDiffs {
@@ -23,7 +19,6 @@ export interface PushDiffs {
     workspace: string,
     remotePath: string,
     diffs: Difference[],
-    plainSecrets?: boolean
   ): Promise<void>;
 }
 
@@ -51,7 +46,7 @@ export type Difference = DifferenceCreate | DifferenceRemove | DifferenceChange;
 export function setValueByPath(
   obj: any,
   path: (string | number)[],
-  value: any
+  value: any,
 ) {
   let i;
   let lastObj = undefined;
@@ -89,7 +84,7 @@ export type GlobalOptions = {
 
 export function inferTypeFromPath(
   p: string,
-  obj: any
+  obj: any,
 ):
   | ScriptFile
   | VariableFile
@@ -120,7 +115,7 @@ export function inferTypeFromPath(
 }
 
 export function getTypeStrFromPath(
-  p: string
+  p: string,
 ):
   | "script"
   | "variable"
@@ -130,13 +125,8 @@ export function getTypeStrFromPath(
   | "folder"
   | "app" {
   const parsed = path.parse(p);
-  if (
-    parsed.ext == ".go" ||
-    parsed.ext == ".ts" ||
-    parsed.ext == ".sh" ||
-    parsed.ext == ".py"
-  ) {
-    return "script";
+  if (parsed.ext == ".go" || parsed.ext == ".ts" || parsed.ext == ".sh" || parsed.ext == ".py") {
+    return 'script'
   }
 
   if (parsed.name === "folder.meta") {
@@ -145,12 +135,9 @@ export function getTypeStrFromPath(
 
   const typeEnding = parsed.name.split(".").at(-1);
   if (
-    typeEnding === "script" ||
-    typeEnding === "variable" ||
-    typeEnding === "flow" ||
-    typeEnding === "resource" ||
-    typeEnding === "resource-type" ||
-    typeEnding === "app"
+    typeEnding === "script" || typeEnding === "variable" ||
+    typeEnding === "flow" || typeEnding === "resource" ||
+    typeEnding === "resource-type" || typeEnding === "app"
   ) {
     return typeEnding;
   } else {

cli/variable.ts

@@ -11,6 +11,7 @@ import {
   colors,
   Command,
   EditVariable,
+  ListableVariable,
   microdiff,
   Table,
   VariableService,
@@ -35,7 +36,7 @@ async function list(opts: GlobalOptions) {
         x.is_secret ? "true" : "false",
         x.account ?? "-",
         x.value ?? "-",
-      ])
+      ]),
     )
     .render();
 }
@@ -62,31 +63,24 @@ export class VariableFile implements Resource, PushDiffs {
     workspace: string,
     remotePath: string,
     diffs: Difference[],
-    plainSecrets?: boolean
   ): Promise<void> {
     if (await VariableService.existsVariable({ workspace, path: remotePath })) {
       console.log(
         colors.bold.yellow(
-          `Applying ${diffs.length} diffs to existing variable... ${remotePath}`
-        )
+          `Applying ${diffs.length} diffs to existing variable...`,
+        ),
       );
       const changeset: EditVariable = {};
       for (const diff of diffs) {
         if (
           diff.type !== "REMOVE" &&
-          (diff.path.length !== 1 ||
-            ![
-              "path",
-              "value",
-              "is_secret",
-              "description",
-              "account",
-              "is_oauth",
-            ].includes(diff.path[0] as string))
+          (
+            diff.path.length !== 1 ||
+            !["path", "value", "is_secret", "description"].includes(
+              diff.path[0] as string,
+            )
+          )
         ) {
-          console.log(
-            colors.red("Invalid variable diff with path " + diff.path)
-          );
           throw new Error("Invalid variable diff with path " + diff.path);
         }
         if (diff.type === "CREATE" || diff.type === "CHANGE") {
@@ -96,24 +90,25 @@ export class VariableFile implements Resource, PushDiffs {
         }
       }
 
-      const hasChanges = Object.values(changeset).some(
-        (v) => v !== null && typeof v !== "undefined"
+      const hasChanges = Object.values(changeset).some((v) =>
+        v !== null && typeof v !== "undefined"
       );
       if (!hasChanges) {
         return;
       }
-
       await VariableService.updateVariable({
         workspace,
         path: remotePath,
-        alreadyEncrypted: !plainSecrets,
+        alreadyEncrypted: true,
         requestBody: changeset,
       });
+
+      console.log(changeset);
     } else {
       console.log(colors.yellow.bold("Creating new variable..."));
       await VariableService.createVariable({
         workspace,
-        alreadyEncrypted: !plainSecrets,
+        alreadyEncrypted: true,
         requestBody: {
           path: remotePath,
           description: this.description,
@@ -125,29 +120,29 @@ export class VariableFile implements Resource, PushDiffs {
       });
     }
   }
-  async push(
-    workspace: string,
-    remotePath: string,
-    plainSecrets?: boolean
-  ): Promise<void> {
+  async push(workspace: string, remotePath: string): Promise<void> {
+    let existing: ListableVariable | undefined;
+    try {
+      existing = await VariableService.getVariable({
+        workspace: workspace,
+        path: remotePath,
+      });
+    } catch {
+      existing = undefined;
+    }
     await this.pushDiffs(
       workspace,
       remotePath,
-      microdiff({}, this, { cyclesFix: false }),
-      plainSecrets
+      microdiff(existing ?? {}, this, { cyclesFix: false }),
     );
   }
 }
 
-async function push(
-  opts: GlobalOptions & { plainSecrets: boolean },
-  filePath: string,
-  remotePath: string
-) {
+async function push(opts: GlobalOptions, filePath: string, remotePath: string) {
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
 
-  if (!validatePath(remotePath)) {
+  if (!await validatePath(opts, remotePath)) {
     return;
   }
 
@@ -158,12 +153,7 @@ async function push(
 
   console.log(colors.bold.yellow("Pushing variable..."));
 
-  await pushVariable(
-    workspace.workspaceId,
-    filePath,
-    remotePath,
-    opts.plainSecrets
-  );
+  await pushVariable(workspace.workspaceId, filePath, remotePath);
   console.log(colors.bold.underline.green(`Variable ${remotePath} pushed`));
 }
 
@@ -171,12 +161,11 @@ export async function pushVariable(
   workspace: string,
   filePath: string,
   remotePath: string,
-  plainSecrets: boolean
 ) {
-  const data = decoverto
-    .type(VariableFile)
-    .rawToInstance(await Deno.readTextFile(filePath));
-  await data.push(workspace, remotePath, plainSecrets);
+  const data = decoverto.type(VariableFile).rawToInstance(
+    await Deno.readTextFile(filePath),
+  );
+  await data.push(workspace, remotePath);
 }
 
 const command = new Command()
@@ -184,10 +173,9 @@ const command = new Command()
   .action(list as any)
   .command(
     "push",
-    "Push a local variable spec. This overrides any remote versions."
+    "Push a local variable spec. This overrides any remote versions.",
   )
   .arguments("<file_path:string> <remote_path:string>")
-  .option("--plain-secrets", "Push secrets as plain text")
   .action(push as any);
 
 export default command;

cli/workspace.ts

@@ -9,11 +9,9 @@ import {
   Input,
   setClient,
   Table,
-  UserService,
   WorkspaceService,
 } from "./deps.ts";
 import { decoverto, model, property } from "./decoverto.ts";
-import { requireLogin } from "./context.ts";
 
 @model()
 export class Workspace {
@@ -30,7 +28,7 @@ export class Workspace {
     remote: string,
     workspaceId: string,
     name: string,
-    token: string
+    token: string,
   ) {
     this.remote = remote;
     this.workspaceId = workspaceId;
@@ -40,7 +38,7 @@ export class Workspace {
 }
 
 function makeWorkspaceStream(
-  readable: ReadableStream<Uint8Array>
+  readable: ReadableStream<Uint8Array>,
 ): ReadableStream<Workspace> {
   return readable
     .pipeThrough(new DelimiterStream(new TextEncoder().encode("\n")))
@@ -59,7 +57,7 @@ function makeWorkspaceStream(
             /* ignore */
           }
         },
-      })
+      }),
     );
 }
 
@@ -86,7 +84,7 @@ export async function allWorkspaces(): Promise<Workspace[]> {
 }
 
 async function getActiveWorkspaceName(
-  opts: GlobalOptions
+  opts: GlobalOptions,
 ): Promise<string | undefined> {
   if (opts.workspace) {
     return opts.workspace;
@@ -99,7 +97,7 @@ async function getActiveWorkspaceName(
 }
 
 export async function getActiveWorkspace(
-  opts: GlobalOptions
+  opts: GlobalOptions,
 ): Promise<Workspace | undefined> {
   const name = await getActiveWorkspaceName(opts);
   if (!name) {
@@ -109,7 +107,7 @@ export async function getActiveWorkspace(
 }
 
 export async function getWorkspaceByName(
-  workspaceName: string
+  workspaceName: string,
 ): Promise<Workspace | undefined> {
   const workspaceStream = await getWorkspaceStream();
   for await (const workspace of workspaceStream) {
@@ -136,40 +134,34 @@ async function list(opts: GlobalOptions) {
         } else {
           return a;
         }
-      })
+      }),
     )
     .render();
-
-  console.log("Active: " + colors.green.bold(activeName || "none"));
 }
 
 async function switchC(opts: GlobalOptions, workspaceName: string) {
   if (opts.workspace) {
     console.log(
       colors.red.bold(
-        "! Workspace needs to be specified as positional argument, not as option."
-      )
+        "! Workspace needs to be specified as positional argument, not as option.",
+      ),
     );
     return;
   }
 
   const all = await allWorkspaces();
   if (all.findIndex((x) => x.name === workspaceName) === -1) {
-    console.log(
-      colors.red.bold(
-        `! This workspace profile ${workspaceName} does not exist locally.`
-      )
-    );
-    console.log("available workspace profiles:");
+    console.log(colors.red.bold(`! This workspace profile ${workspaceName} does not exist locally.`));
+    console.log("available workspace profiles:")
     for (const w of all) {
-      console.log("  - " + w.name);
+      console.log('  - ' + w.name)
     }
     return;
   }
 
   return await Deno.writeTextFile(
     (await getRootStore()) + "/activeWorkspace",
-    workspaceName
+    workspaceName,
   );
 }
 
@@ -181,13 +173,13 @@ export async function add(
   },
   workspaceName: string | undefined,
   workspaceId: string | undefined,
-  remote: string | undefined
+  remote: string | undefined,
 ) {
   if (opts.workspace) {
     console.log(
       colors.red.bold(
-        "! Workspace needs to be specified as positional argument, not as option."
-      )
+        "! Workspace needs to be specified as positional argument, not as option.",
+      ),
     );
     return;
   }
@@ -197,11 +189,7 @@ export async function add(
   }
 
   if (!workspaceId) {
-    workspaceId = await Input.prompt({
-      message: "Enter the ID of this workspace",
-      default: workspaceName,
-      suggestions: [workspaceName],
-    });
+    workspaceId = await Input.prompt({ message: "Enter the ID of this workspace", default: workspaceName, suggestions: [workspaceName] });
   }
 
   if (!remote) {
@@ -217,8 +205,8 @@ export async function add(
         await Input.prompt({
           message: "Enter the Remote URL",
           suggestions: ["https://app.windmill.dev/"],
-          default: "https://app.windmill.dev/",
-        })
+          default: "https://app.windmill.dev/"
+        }),
       ).toString();
     }
   }
@@ -231,26 +219,22 @@ export async function add(
 
   setClient(
     token,
-    remote.endsWith("/") ? remote.substring(0, remote.length - 1) : remote
+    remote.endsWith("/") ? remote.substring(0, remote.length - 1) : remote,
   );
-  let alreadyExists = false;
+  let alreadyExists = false
   try {
     alreadyExists = await WorkspaceService.existsWorkspace({
       requestBody: { id: workspaceId },
-    });
+    })
   } catch (e) {
-    console.log(
-      colors.red.bold("! Credentials or instance is invalid. Aborting.")
-    );
-    throw e;
+    console.log(colors.red.bold("! Credentials or instance is invalid. Aborting."));
+    throw e
   }
   if (opts.create) {
-    if (!alreadyExists) {
-      console.log(
-        colors.yellow(
-          `Workspace at id ${workspaceId} on ${remote} does not exist. Creating...`
-        )
-      );
+    if (
+      !alreadyExists
+    ) {
+      console.log(colors.yellow(`Workspace at id ${workspaceId} on ${remote} does not exist. Creating...`));
       await WorkspaceService.createWorkspace({
         requestBody: {
           id: workspaceId,
@@ -260,87 +244,63 @@ export async function add(
       });
     }
   } else if (!alreadyExists) {
-    console.log(
-      colors.red.bold(
-        `! Workspace at id ${workspaceId} on ${remote} does not exist. Re-run with --create to create it. Aborting.`
-      )
-    );
-    console.log(
-      "On that instance and with those credentials, the workspaces that you can access are:"
-    );
-    const workspaces = await WorkspaceService.listWorkspaces();
+    console.log(colors.red.bold(`! Workspace at id ${workspaceId} on ${remote} does not exist. Re-run with --create to create it. Aborting.`));
+    console.log("On that instance and with those credentials, the workspaces that you can access are:")
+    const workspaces = await WorkspaceService.listWorkspaces()
     for (const workspace of workspaces) {
-      console.log(`- ${workspace.id} (name: ${workspace.name})`);
+      console.log(`- ${workspace.id} (name: ${workspace.name})`)
     }
     Deno.exit(1);
   }
 
-  await addWorkspace(
-    {
-      name: workspaceName,
-      remote: remote,
-      workspaceId: workspaceId,
-      token: token,
-    },
-    opts
-  );
+  await addWorkspace({
+    name: workspaceName,
+    remote: remote,
+    workspaceId: workspaceId,
+    token: token,
+  }, opts);
   await Deno.writeTextFile(
     (await getRootStore()) + "/activeWorkspace",
-    workspaceName
-  );
-  console.log(
-    colors.green.underline(
-      `Added workspace ${workspaceName} for ${workspaceId} on ${remote}!`
-    )
+    workspaceName,
   );
+  console.log(colors.green.underline(`Added workspace ${workspaceName} for ${workspaceId} on ${remote}!`));
 }
 
 export async function addWorkspace(workspace: Workspace, opts: any) {
   workspace.remote = new URL(workspace.remote).toString(); // add trailing slash in all cases!
-  await removeWorkspace(workspace.name, true, opts);
   const file = await Deno.open((await getRootStore()) + "remotes.ndjson", {
     append: true,
     write: true,
     read: true,
     create: true,
   });
+  await removeWorkspace(workspace.name, true, opts);
   await file.write(new TextEncoder().encode(JSON.stringify(workspace) + "\n"));
-
   file.close();
 }
 
-export async function removeWorkspace(
-  name: string,
-  silent: boolean,
-  opts: any
-) {
+export async function removeWorkspace(name: string, silent: boolean, opts: any) {
   const orgWorkspaces = await allWorkspaces();
   if (orgWorkspaces.findIndex((x) => x.name === name) === -1) {
     if (!silent) {
-      console.log(
-        colors.red.bold(`! Workspace profile ${name} does not exist locally`)
-      );
-      console.log("available workspace profiles:");
-      await list(opts);
+      console.log(colors.red.bold(`! Workspace profile ${name} does not exist locally`));
+      console.log("available workspace profiles:")
+      await list(opts)
     }
     return;
   }
   if (silent) {
-    console.log(colors.yellow(`Replacing existing workspace ${name}`));
+    console.log(colors.yellow(`Replacing existing workspace ${name}`))
   }
-
   await Deno.writeTextFile(
     (await getRootStore()) + "remotes.ndjson",
     orgWorkspaces
       .filter((x) => x.name !== name)
       .map((x) => JSON.stringify(x))
-      .join("\n") + "\n"
+      .join("\n"),
   );
-
   if (!silent) {
-    console.log(
-      colors.green.underline(`Succesfully removed workspace ${name}!`)
-    );
+    console.log(colors.green.underline(`Succesfully removed workspace ${name}!`));
   }
 }
 
@@ -348,13 +308,6 @@ async function remove(_opts: GlobalOptions, name: string) {
   await removeWorkspace(name, false, _opts);
 }
 
-async function whoami(_opts: GlobalOptions) {
-  await requireLogin(_opts);
-  console.log(await UserService.globalWhoami());
-  const activeName = await getActiveWorkspaceName(_opts);
-  console.log("Active: " + colors.green.bold(activeName || "none"));
-}
-
 const command = new Command()
   .description("workspace related commands")
   .action(list as any)
@@ -369,22 +322,19 @@ const command = new Command()
   .option("-c --create", "Create the workspace if it does not exist")
   .option(
     "--create-workspace-name <workspace_name:string>",
-    "Specify the workspace name. Ignored if --create is not specified or the workspace already exists. Will default to the workspace id."
+    "Specify the workspace name. Ignored if --create is not specified or the workspace already exists. Will default to the workspace id.",
   )
   .option(
     "--create-username <username:string>",
     "Specify your own username in the newly created workspace. Ignored if --create is not specified or the workspace already exists.",
     {
       default: "admin",
-    }
+    },
   )
   .action(add as any)
   .command("remove")
   .description("Remove a workspace")
   .arguments("<workspace_name:string>")
-  .action(remove as any)
-  .command("whoami")
-  .description("Show the currently active user")
-  .action(whoami as any);
+  .action(remove as any);
 
 export default command;

deno-client/mod.ts

@@ -1,59 +1,41 @@
-import {
-  JobService,
-  ResourceService,
-  VariableService,
-} from "./windmill-api/index.ts";
-import { OpenAPI } from "./windmill-api/index.ts";
+import { JobService, ResourceService, VariableService } from './windmill-api/index.ts'
+import { OpenAPI } from './windmill-api/index.ts'
 
 export {
-  AdminService,
-  AuditService,
-  FlowService,
-  GranularAclService,
-  GroupService,
-  JobService,
-  ResourceService,
-  VariableService,
-  ScriptService,
-  ScheduleService,
-  SettingsService,
-  UserService,
-  WorkspaceService,
-} from "./windmill-api/index.ts";
+    AdminService, AuditService, FlowService, GranularAclService, GroupService,
+    JobService, ResourceService, VariableService, ScriptService, ScheduleService, SettingsService,
+    UserService, WorkspaceService
+} from './windmill-api/index.ts'
+
 
 // @ts-ignore: Otherwise BigInt is not supported for export
 BigInt.prototype.toJSON = function () {
-  return this.toString();
+    return this.toString();
 };
 
-export { pgSql, pgClient } from "./pg.ts";
+export { pgSql, pgClient } from './pg.ts'
 
-export type Sql = string;
-export type Email = string;
-export type Base64 = string;
-export type Resource<S extends string> = any;
+export type Sql = string
+export type Email = string
+export type Base64 = string
+export type Resource<S extends string> = any
 
-export const SHARED_FOLDER = "/shared";
+export const SHARED_FOLDER = '/shared'
 
 export function setClient(token: string, baseUrl: string) {
-  OpenAPI.WITH_CREDENTIALS = true;
-  OpenAPI.TOKEN = token;
-  OpenAPI.BASE = baseUrl + "/api";
+    OpenAPI.WITH_CREDENTIALS = true
+    OpenAPI.TOKEN = token
+    OpenAPI.BASE = baseUrl + '/api'
 }
 
-setClient(
-  Deno.env.get("WM_TOKEN") ?? "no_token",
-  Deno.env.get("BASE_INTERNAL_URL") ??
-    Deno.env.get("BASE_URL") ??
-    "http://localhost:8000"
-);
+setClient(Deno.env.get("WM_TOKEN") ?? 'no_token', Deno.env.get("BASE_INTERNAL_URL") ?? Deno.env.get("BASE_URL") ?? 'http://localhost:8000')
 
 /**
  * Create a client configuration from env variables
  * @returns client configuration
  */
 export function getWorkspace(): string {
-  return Deno.env.get("WM_WORKSPACE") ?? "no_workspace";
+    return Deno.env.get("WM_WORKSPACE") ?? 'no_workspace'
 }
 
 /**
@@ -62,55 +44,27 @@ export function getWorkspace(): string {
  * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
  * @returns resource value
  */
-export async function getResource(
-  path?: string,
-  undefinedIfEmpty?: boolean
-): Promise<any> {
-  const workspace = getWorkspace();
-  path = path ?? getStatePath();
-  try {
-    const resource = await ResourceService.getResource({ workspace, path });
-    return await _transformLeaf(resource.value);
-  } catch (e: any) {
-    if (undefinedIfEmpty && e.status === 404) {
-      return undefined;
-    } else {
-      throw Error(`Resource not found at ${path} or not visible to you`);
+export async function getResource(path?: string, undefinedIfEmpty?: boolean): Promise<any> {
+    const workspace = getWorkspace()
+    path = path ?? getStatePath()
+    try {
+        const resource = await ResourceService.getResource({ workspace, path })
+        return await _transformLeaf(resource.value)
+    } catch (e: any) {
+        if (undefinedIfEmpty && e.status === 404) {
+            return undefined
+        } else {
+            throw Error(`Resource not found at ${path} or not visible to you`)
+        }
     }
-  }
-}
-
-/**
- * Get the full resource value by path
- * @param path path of the resource,  default to internal state path
- * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
- * @returns full resource
- */
-export async function getFullResource(
-  path?: string,
-  undefinedIfEmpty?: boolean
-): Promise<any> {
-  const workspace = getWorkspace();
-  path = path ?? getStatePath();
-  try {
-    const resource = await ResourceService.getResource({ workspace, path });
-    const value = await _transformLeaf(resource.value);
-    return { ...resource, value };
-  } catch (e: any) {
-    if (undefinedIfEmpty && e.status === 404) {
-      return undefined;
-    } else {
-      throw Error(`Resource not found at ${path} or not visible to you`);
-    }
-  }
 }
 
 export function getStatePath(): string {
-  const state_path = Deno.env.get("WM_STATE_PATH");
-  if (state_path === undefined) {
-    throw Error("State path not set");
-  }
-  return state_path;
+    const state_path = Deno.env.get("WM_STATE_PATH")
+    if (state_path === undefined) {
+        throw Error("State path not set")
+    }
+    return state_path
 }
 
 /**
@@ -119,29 +73,16 @@ export function getStatePath(): string {
  * @param value new value of the resource to set
  * @param initializeToTypeIfNotExist if the resource does not exist, initialize it with this type
  */
-export async function setResource(
-  value: any,
-  path?: string,
-  initializeToTypeIfNotExist?: string
-): Promise<void> {
-  path = path ?? getStatePath();
-  const workspace = getWorkspace();
-  if (await ResourceService.existsResource({ workspace, path })) {
-    await ResourceService.updateResourceValue({
-      workspace,
-      path,
-      requestBody: { value },
-    });
-  } else if (initializeToTypeIfNotExist) {
-    await ResourceService.createResource({
-      workspace,
-      requestBody: { path, value, resource_type: initializeToTypeIfNotExist },
-    });
-  } else {
-    throw Error(
-      `Resource at path ${path} does not exist and no type was provided to initialize it`
-    );
-  }
+export async function setResource(value: any, path?: string, initializeToTypeIfNotExist?: string): Promise<void> {
+    path = path ?? getStatePath()
+    const workspace = getWorkspace()
+    if (await ResourceService.existsResource({ workspace, path })) {
+        await ResourceService.updateResourceValue({ workspace, path, requestBody: { value } })
+    } else if (initializeToTypeIfNotExist) {
+        await ResourceService.createResource({ workspace, requestBody: { path, value, resource_type: initializeToTypeIfNotExist } })
+    } else {
+        throw Error(`Resource at path ${path} does not exist and no type was provided to initialize it`)
+    }
 }
 
 /**
@@ -150,7 +91,7 @@ export async function setResource(
  * @deprecated use setState instead
  */
 export async function setInternalState(state: any): Promise<void> {
-  await setResource(state, undefined, "state");
+    await setResource(state, undefined, 'state')
 }
 
 /**
@@ -158,41 +99,39 @@ export async function setInternalState(state: any): Promise<void> {
  * @param state state to set
  */
 export async function setState(state: any): Promise<void> {
-  await setResource(state, undefined, "state");
+    await setResource(state, undefined, 'state')
 }
 
 /**
  * Set the shared state
  * @param state state to set
  */
-export async function setSharedState(
-  state: any,
-  path = "state.json"
-): Promise<void> {
-  await Deno.writeTextFile(SHARED_FOLDER + "/" + path, JSON.stringify(state));
+export async function setSharedState(state: any, path = 'state.json'): Promise<void> {
+    await Deno.writeTextFile(SHARED_FOLDER + '/' + path, JSON.stringify(state))
 }
 
 /**
  * Get the shared state
  * @param state state to set
  */
-export async function getSharedState(path = "state.json"): Promise<any> {
-  return JSON.parse(await Deno.readTextFile(SHARED_FOLDER + "/" + path));
+export async function getSharedState(path = 'state.json'): Promise<any> {
+    return JSON.parse(await Deno.readTextFile(SHARED_FOLDER + '/' + path))
 }
 
+
 /**
  * Get the internal state
  * @deprecated use getState instead
  */
 export async function getInternalState(): Promise<any> {
-  return await getResource(getStatePath(), true);
+    return await getResource(getStatePath(), true)
 }
 
 /**
  * Get the state shared across executions
  */
 export async function getState(): Promise<any> {
-  return await getResource(getStatePath(), true);
+    return await getResource(getStatePath(), true)
 }
 
 /**
@@ -201,43 +140,38 @@ export async function getState(): Promise<any> {
  * @returns variable value
  */
 export async function getVariable(path: string): Promise<string | undefined> {
-  const workspace = getWorkspace();
-  try {
-    const variable = await VariableService.getVariable({ workspace, path });
-    return variable.value;
-  } catch (e: any) {
-    throw Error(`Variable not found at ${path} or not visible to you`);
-  }
+    const workspace = getWorkspace()
+    try {
+        const variable = await VariableService.getVariable({ workspace, path })
+        return variable.value
+    } catch (e: any) {
+        throw Error(`Variable not found at ${path} or not visible to you`)
+    }
 }
 
-async function transformLeaves(d: {
-  [key: string]: any;
-}): Promise<{ [key: string]: any }> {
-  for (const k in d) {
-    d[k] = await _transformLeaf(d[k]);
-  }
-  return d;
+async function transformLeaves(d: { [key: string]: any }): Promise<{ [key: string]: any }> {
+    for (const k in d) {
+        d[k] = await _transformLeaf(d[k])
+    }
+    return d
 }
 
-const VAR_RESOURCE_PREFIX = "$var:";
-const RES_RESOURCE_PREFIX = "$res:";
+const VAR_RESOURCE_PREFIX = "$var:"
 async function _transformLeaf(v: any): Promise<any> {
-  if (typeof v === "object") {
-    return transformLeaves(v);
-  } else if (typeof v === "string" && v.startsWith(VAR_RESOURCE_PREFIX)) {
-    const varName = v.substring(VAR_RESOURCE_PREFIX.length);
-    return await getVariable(varName);
-  } else if (typeof v === "string" && v.startsWith(RES_RESOURCE_PREFIX)) {
-    const resName = v.substring(RES_RESOURCE_PREFIX.length);
-    return await getResource(resName);
-  } else {
-    return v;
-  }
+    if (typeof v === 'object') {
+        return transformLeaves(v)
+    }
+    else if (typeof v === 'string' && v.startsWith(VAR_RESOURCE_PREFIX)) {
+        const varName = v.substring(VAR_RESOURCE_PREFIX.length)
+        return await getVariable(varName)
+    } else {
+        return v
+    }
 }
 
 export async function databaseUrlFromResource(path: string): Promise<string> {
-  const resource = await getResource(path);
-  return `postgresql://${resource.user}:${resource.password}@${resource.host}:${resource.port}/${resource.dbname}?sslmode=${resource.sslmode}`;
+    const resource = await getResource(path)
+    return `postgresql://${resource.user}:${resource.password}@${resource.host}:${resource.port}/${resource.dbname}?sslmode=${resource.sslmode}`
 }
 
 /**
@@ -246,84 +180,78 @@ export async function databaseUrlFromResource(path: string): Promise<string> {
  * @returns approval page UI URL, resume and cancel API URLs for resumeing the flow
  */
 export async function getResumeUrls(approver?: string): Promise<{
-  approvalPage: string;
-  resume: string;
-  cancel: string;
+    approvalPage: string;
+    resume: string;
+    cancel: string;
 }> {
-  const nonce = Math.floor(Math.random() * 4294967295);
-  const workspace = getWorkspace();
-  return await JobService.getResumeUrls({
-    workspace,
-    resumeId: nonce,
-    approver,
-    id: Deno.env.get("WM_JOB_ID") ?? "NO_JOB_ID",
-  });
+    const nonce = Math.floor(Math.random() * 4294967295);
+    const workspace = getWorkspace()
+    return await JobService.getResumeUrls({ workspace, resumeId: nonce, approver, id: Deno.env.get("WM_JOB_ID") ?? 'NO_JOB_ID' })
 }
 
 /**
  * @deprecated use getResumeUrls instead
  */
 export function getResumeEndpoints(approver?: string): Promise<{
-  approvalPage: string;
-  resume: string;
-  cancel: string;
+    approvalPage: string;
+    resume: string;
+    cancel: string;
 }> {
-  return getResumeUrls(approver);
+    return getResumeUrls(approver)
 }
 
 export function base64ToUint8Array(data: string): Uint8Array {
-  return Uint8Array.from(atob(data), (c) => c.charCodeAt(0));
+    return Uint8Array.from(atob(data), c => c.charCodeAt(0))
 }
 
 export function uint8ArrayToBase64(arrayBuffer: Uint8Array): string {
-  let base64 = "";
-  const encodings =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let base64 = ''
+    const encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
 
-  const bytes = new Uint8Array(arrayBuffer);
-  const byteLength = bytes.byteLength;
-  const byteRemainder = byteLength % 3;
-  const mainLength = byteLength - byteRemainder;
+    const bytes = new Uint8Array(arrayBuffer)
+    const byteLength = bytes.byteLength
+    const byteRemainder = byteLength % 3
+    const mainLength = byteLength - byteRemainder
 
-  let a, b, c, d;
-  let chunk;
+    let a, b, c, d
+    let chunk
 
-  // Main loop deals with bytes in chunks of 3
-  for (let i = 0; i < mainLength; i = i + 3) {
-    // Combine the three bytes into a single integer
-    chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+    // Main loop deals with bytes in chunks of 3
+    for (let i = 0; i < mainLength; i = i + 3) {
+        // Combine the three bytes into a single integer
+        chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]
 
-    // Use bitmasks to extract 6-bit segments from the triplet
-    a = (chunk & 16515072) >> 18; // 16515072 = (2^6 - 1) << 18
-    b = (chunk & 258048) >> 12; // 258048   = (2^6 - 1) << 12
-    c = (chunk & 4032) >> 6; // 4032     = (2^6 - 1) << 6
-    d = chunk & 63; // 63       = 2^6 - 1
+        // Use bitmasks to extract 6-bit segments from the triplet
+        a = (chunk & 16515072) >> 18 // 16515072 = (2^6 - 1) << 18
+        b = (chunk & 258048) >> 12 // 258048   = (2^6 - 1) << 12
+        c = (chunk & 4032) >> 6 // 4032     = (2^6 - 1) << 6
+        d = chunk & 63               // 63       = 2^6 - 1
 
-    // Convert the raw binary segments to the appropriate ASCII encoding
-    base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d];
-  }
+        // Convert the raw binary segments to the appropriate ASCII encoding
+        base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d]
+    }
 
-  // Deal with the remaining bytes and padding
-  if (byteRemainder == 1) {
-    chunk = bytes[mainLength];
+    // Deal with the remaining bytes and padding
+    if (byteRemainder == 1) {
+        chunk = bytes[mainLength]
 
-    a = (chunk & 252) >> 2; // 252 = (2^6 - 1) << 2
+        a = (chunk & 252) >> 2 // 252 = (2^6 - 1) << 2
 
-    // Set the 4 least significant bits to zero
-    b = (chunk & 3) << 4; // 3   = 2^2 - 1
+        // Set the 4 least significant bits to zero
+        b = (chunk & 3) << 4 // 3   = 2^2 - 1
 
-    base64 += encodings[a] + encodings[b] + "==";
-  } else if (byteRemainder == 2) {
-    chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1];
+        base64 += encodings[a] + encodings[b] + '=='
+    } else if (byteRemainder == 2) {
+        chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1]
 
-    a = (chunk & 64512) >> 10; // 64512 = (2^6 - 1) << 10
-    b = (chunk & 1008) >> 4; // 1008  = (2^6 - 1) << 4
+        a = (chunk & 64512) >> 10 // 64512 = (2^6 - 1) << 10
+        b = (chunk & 1008) >> 4 // 1008  = (2^6 - 1) << 4
 
-    // Set the 2 least significant bits to zero
-    c = (chunk & 15) << 2; // 15    = 2^4 - 1
+        // Set the 2 least significant bits to zero
+        c = (chunk & 15) << 2 // 15    = 2^4 - 1
 
-    base64 += encodings[a] + encodings[b] + encodings[c] + "=";
-  }
+        base64 += encodings[a] + encodings[b] + encodings[c] + '='
+    }
 
-  return base64;
+    return base64
 }

docker-compose.yml

@@ -1,18 +1,21 @@
-version: "3.7"
+version: '3.7'
 
 services:
+
   db:
     image: postgres:14
     restart: unless-stopped
     volumes:
       - db_data:/var/lib/postgresql/data
-    expose:
-      - 5432
+    ports:
+      - 5432:5432
+      # NOTE: if port 5432 are already in use locally, we'll also bind another port
+      - 5433:5432
     environment:
       POSTGRES_PASSWORD: ${DB_PASSWORD}
       POSTGRES_DB: windmill
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      test: [ "CMD-SHELL", "pg_isready -U postgres" ]
       interval: 10s
       timeout: 5s
       retries: 5
@@ -22,11 +25,11 @@ services:
     deploy:
       replicas: 1
     restart: unless-stopped
-    expose:
-      - 8000
+    ports:
+      - 8000:8000
     environment:
       - DATABASE_URL=postgres://postgres:${DB_PASSWORD}@db/windmill?sslmode=disable
-      - BASE_URL=${WM_BASE_URL}
+      - BASE_URL=http://${WM_BASE_URL}
       - RUST_LOG=info
       ## You can set the number of workers to > 0 and not need any separate worker service
       - NUM_WORKERS=0
@@ -35,8 +38,6 @@ services:
     depends_on:
       db:
         condition: service_healthy
-    # volumes:
-    # - ./oauth.json/:/usr/src/app/oauth.json
 
   windmill_worker:
     image: ghcr.io/windmill-labs/windmill:main
@@ -45,7 +46,7 @@ services:
     restart: unless-stopped
     environment:
       - DATABASE_URL=postgres://postgres:${DB_PASSWORD}@db/windmill?sslmode=disable
-      - BASE_URL=${WM_BASE_URL}
+      - BASE_URL=http://${WM_BASE_URL}
       - BASE_INTERNAL_URL=http://windmill_server:8000
       - RUST_LOG=info
       - NUM_WORKERS=1
@@ -60,12 +61,13 @@ services:
     # to mount the worker folder to debug,, KEEP_JOB_DIR=true and mount /tmp/windmill
     volumes:
       - worker_dependency_cache:/tmp/windmill/cache
+      # - ./oauth.json/:/usr/src/app/oauth.json
 
   lsp:
     image: ghcr.io/windmill-labs/windmill-lsp:latest
     restart: unless-stopped
-    expose:
-      - 3001
+    ports:
+      - 3001:3001
 
   caddy:
     image: caddy:2.5.2-alpine
@@ -76,7 +78,7 @@ services:
       - 80:80
       - 443:443
     environment:
-      - BASE_URL=${CADDY_REVERSE_PROXY}
+      - BASE_URL=${WM_BASE_URL}
 
 volumes:
   db_data: null

frontend/.env

@@ -1 +0,0 @@
-VITE_DEFAULT_WEBHOOK_TYPE=async 

frontend/.gitignore

@@ -7,4 +7,3 @@ node_modules
 CaddyfileRemoteRuben
 tests-out/
 storageState.json
-.env.production

frontend/Caddyfile

@@ -2,11 +2,9 @@ http://localhost {
   bind {$ADDRESS}
   reverse_proxy /api/* http://localhost:8000
   reverse_proxy /* http://localhost:3000
-  reverse_proxy /ws/* http://localhost:3001
 }
 
 https://localhost {  
   bind {$ADDRESS}
-  reverse_proxy /api/* http://localhost:8000
   reverse_proxy /ws/* http://localhost:3001
 }

frontend/README_DEV.md

@@ -1,6 +1,6 @@
 # Developing
 
-## Starting The Development Server
+## Starting the Development Server
 
 Once you've created a project and installed dependencies with `npm install` (or
 `pnpm install` or `yarn`), start a development server:
@@ -17,7 +17,7 @@ In the root folder:
 
 ```bash
 docker build . -t windmill
-docker compose up db windmill_server windmill_worker
+docker-compose up db server
 ```
 
 ### 2. Backend is run by cargo
@@ -25,9 +25,9 @@ docker compose up db windmill_server windmill_worker
 **Prerequisites**
 
 - Install Rust [as explained on the website](https://www.rust-lang.org/tools/install).
-- Install llvm
+- Install llvm 
 
-  **On OSX:**
+  **on OSX:**
   ```bash
   brew install llvm caddy gsed
   
@@ -36,20 +36,7 @@ docker compose up db windmill_server windmill_worker
   
   # now, restart your shell. You should now have the `lld` binary on your PATH.
   ```
-- To test that you have Rust and Cargo installed run `cargo --version`
-
-- In your terminal, go to the backend directory and run `cargo build`
-- Run `cargo run`
-
-**Known issue on M1 Mac while running `cargo build`**
-- You may encounter `linking with cc failed` build time error.
-- To solve this run:
-  ```bash
-  echo 'export RUSTFLAGS="-L/opt/homebrew/opt/libomp/lib"' >> ~/.zshrc
-  source ~/.zshrc
-  ```
-
-
+  
 **Do a Frontend Build**
 
 In order to run the backend, you need to have a frontend build inside `frontend/build/`.
@@ -69,14 +56,6 @@ npm run build
 # now, you'll have a `frontend/build` folder.
 ```
 
-**Known issue while running `npm run build`**
-- You may encounter `FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory` error.
-- To solve this run:
-```bash
-export NODE_OPTIONS=--max_old_space_size=8096
-```
-- run `npm run build` again
-
 In the root folder:
 
 ```bash
@@ -103,7 +82,7 @@ sudo caddy run --config ./Caddyfile
 
 and then go to <http://localhost>
 
-### 3. Backend is run by remote!
+### Backend is run by remote!
 
 ```bash
 sudo caddy run --config ./CaddyfileRemote
@@ -140,30 +119,8 @@ Recommended config for VS Code:
 
 ```json
 "[svelte]": {
-"editor.defaultFormatter": "esbenp.prettier-vscode"
-}
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    }
 ```
 
 - turn _format on save_ on
-
-
-## Building
-
-The project is built with [SvelteKit](https://kit.svelte.dev/) and uses as output static files.
-There are others adapters for sveltekit, but we use the static adapter.
-
-To build the frontend as static assets, use:
-```
-npm run build
-```
-
-The output is in the `build` folder.
-
-The default build assume you serve every non static files as the 200.html file which is catchall. If you prefer a normal layout, you can use:
-```
-NOTCATCHALL=true npm run build
-```
-which will generate an index.html and allow you to serve the frontend with any static server.
-
-Env variables used for build are set in .env file. See [https://vitejs.dev/guide/env-and-mode.html#env-files](https://vitejs.dev/guide/env-and-mode.html#env-files) for more details.
-

frontend/copy_workers.sh

@@ -1 +0,0 @@
-cp -r node_modules/monaco-editor-workers/dist/workers static

frontend/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "windmill",
-	"version": "1.86.0",
+	"version": "1.70.1",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
@@ -16,50 +16,42 @@
 	},
 	"devDependencies": {
 		"@playwright/test": "^1.31.1",
-		"@rgossiaux/svelte-headlessui": "^1.0.2",
-		"@sveltejs/adapter-static": "^2.0.1",
+		"@sveltejs/adapter-static": "^1.0.0",
 		"@sveltejs/kit": "^1.0.0-next.589",
 		"@sveltejs/package": "^1.0.2",
 		"@tailwindcss/forms": "^0.5.3",
 		"@tailwindcss/typography": "^0.5.8",
-		"@types/d3": "^7.4.0",
-		"@types/d3-zoom": "^3.0.2",
-		"@types/lodash": "^4.14.191",
 		"@types/node": "^18.11.18",
-		"@types/vscode": "~1.76.0",
+		"@types/vscode": "~1.74.0",
 		"@typescript-eslint/eslint-plugin": "^5.49.0",
 		"@typescript-eslint/parser": "^5.48.0",
+		"@windmill-labs/svelte-grid": "^5.1.4",
+		"@windmill-labs/svelvet": "^4.0.20",
 		"@zerodevx/svelte-toast": "^0.8.1",
 		"autoprefixer": "^10.4.13",
-		"cssnano": "^6.0.0",
+		"cssnano": "^5.1.14",
 		"d3-dag": "^0.11.5",
 		"eslint": "^8.28.0",
 		"eslint-config-prettier": "^8.6.0",
 		"eslint-plugin-svelte3": "^4.0.0",
-		"monaco-editor-workers": "0.36.0",
-		"ol": "^7.2.2",
 		"openapi-typescript-codegen": "^0.23.0",
 		"path-browserify": "^1.0.1",
-		"pdfjs-dist": "^3.4.120",
 		"postcss": "^8.4.18",
 		"postcss-load-config": "^4.0.1",
 		"prettier": "^2.8.3",
 		"prettier-plugin-svelte": "^2.9.0",
 		"simple-svelte-autocomplete": "^2.5.1",
-		"style-to-object": "^0.4.1",
 		"stylelint-config-recommended": "^9.0.0",
 		"svelte": "^3.55.1",
-		"svelte-awesome": "^3.2.0",
-		"svelte-awesome-color-picker": "^2.4.1",
+		"svelte-awesome": "^3.0.0",
 		"svelte-check": "^3.0.2",
-		"svelte-highlight": "^7.2.1",
-		"svelte-multiselect": "^8.6.0",
+		"svelte-highlight": "^6.2.1",
 		"svelte-overlay": "^1.4.1",
 		"svelte-popperjs": "^1.3.2",
 		"svelte-preprocess": "^5.0.1",
 		"svelte-range-slider-pips": "^2.1.1",
 		"svelte-splitpanes": "^0.7.3",
-		"svelte2tsx": "^0.6.10",
+		"svelte2tsx": "^0.6.1",
 		"tailwindcss": "^3.2.2",
 		"tslib": "^2.4.1",
 		"typescript": "^4.9.3",
@@ -70,30 +62,29 @@
 	"dependencies": {
 		"@fortawesome/free-brands-svg-icons": "^6.2.1",
 		"@fortawesome/free-solid-svg-icons": "^6.2.1",
-		"@leeoniya/ufuzzy": "^1.0.6",
+		"@leeoniya/ufuzzy": "^0.9.1",
 		"@popperjs/core": "^2.11.6",
 		"@redocly/json-to-json-schema": "^0.0.1",
 		"@tanstack/svelte-table": "^8.7.6",
 		"ag-grid-svelte": "^0.1.4",
+		"async-mutex": "^0.4.0",
 		"chart.js": "^3.9.1",
 		"chartjs-adapter-date-fns": "^3.0.0",
 		"chartjs-plugin-zoom": "^2.0.0",
-		"d3-zoom": "^3.0.0",
 		"date-fns": "^2.29.3",
 		"fast-equals": "^4.0.3",
 		"highlight.js": "^11.7.0",
-		"lodash": "^4.17.21",
 		"lucide-svelte": "^0.115.0",
-		"monaco-editor": "0.36.1",
-		"monaco-languageclient": "5.0.1",
+		"monaco-editor": "0.33.0",
+		"monaco-editor-workers": "0.33.0",
+		"monaco-languageclient": "2.1.0",
+		"monaco-yaml": "^4.0.2",
 		"svelte-autosize": "^1.0.1",
 		"svelte-chartjs": "^3.1.0",
 		"svelte-portal": "^2.2.0",
 		"svelte-select": "^5.3.1",
-		"svelte-timezone-picker": "^2.0.3",
 		"tailwind-merge": "^1.9.1",
-		"vscode-languageclient": "^8.1.0",
-		"vscode-ws-jsonrpc": "3.0.0"
+		"vscode-ws-jsonrpc": "^2.0.1"
 	},
 	"peerDependencies": {
 		"svelte": "^3.55.1"

frontend/src/app.html

@@ -1,13 +1,17 @@
 <!DOCTYPE html>
 <html lang="en">
-	<head>
-		<meta charset="utf-8" />
-		<link rel="icon" href="/logo.svg" />
-		<meta name="viewport" content="width=device-width, initial-scale=1" />
-		%sveltekit.head%
-	</head>
 
-	<body data-sveltekit-preload-code="viewport" class="outline-none focus:outline-none">
-		<div style="display: contents"> %sveltekit.body% </div>
-	</body>
+<head>
+	<meta charset="utf-8" />
+	<link rel="icon" href="/logo.svg" />
+	<meta name="viewport" content="width=device-width, initial-scale=1" />
+	%sveltekit.head%
+</head>
+
+<body data-sveltekit-preload-code="viewport" class="outline-none focus:outline-none">
+	<div style="display: contents">
+		%sveltekit.body%
+	</div>
+</body>
+
 </html>

frontend/src/global.d.ts

@@ -1,2 +1,78 @@
 /// <reference types="@sveltejs/kit" />
 
+declare type Item = import('svelte-dnd-action').Item
+declare type DndEvent<ItemType = Item> = import('svelte-dnd-action').DndEvent<ItemType>
+declare namespace svelte.JSX {
+	interface HTMLAttributes<T> {
+		onconsider?: (event: CustomEvent<DndEvent<ItemType>> & { target: EventTarget & T }) => void
+		onfinalize?: (event: CustomEvent<DndEvent<ItemType>> & { target: EventTarget & T }) => void
+	}
+}
+
+declare module '@windmill-labs/svelte-grid' {
+	import type { SvelteComponentTyped } from 'svelte'
+
+	export interface Size {
+		w: number
+		h: number
+	}
+
+	export interface Positon {
+		x: number
+		y: number
+	}
+
+	interface ItemLayout extends Size, Positon {
+		fixed?: boolean
+		resizable?: boolean
+		draggable?: boolean
+		customDragger?: boolean
+		customResizer?: boolean
+		min?: Size
+		max?: Size
+	}
+
+	export type Item<T> = T & { [width: number]: ItemLayout; data: any }
+	export type FilledItem<T> = T & { [width: number]: Required<ItemLayout>; data: any }
+
+	export interface Props<T> {
+		fillSpace?: boolean
+		items: FilledItem<T>[]
+		rowHeight: number
+		cols: [number, number][]
+		gap?: [number, number]
+		fastStart?: boolean
+		throttleUpdate?: number
+		throttleResize?: number
+		onTopId?: string
+		scroller?: undefined
+		sensor?: number
+	}
+
+	export interface Slots<T> {
+		default: { item: ItemLayout; dataItem: Item<T> }
+	}
+
+	export default class Grid<T = {}> extends SvelteComponentTyped<
+		Props<T>,
+		{
+			pointerup: CustomEvent<{ id: string }>
+			mount: CustomEvent<>
+		},
+		Slots<T>
+	> { }
+}
+
+declare module '@windmill-labs/svelte-grid/build/helper/index.mjs' {
+	import { ItemLayout } from '@windmill-labs/svelte-grid'
+
+	const x: {
+		normalize(items: any[], col: any): unknown[]
+		adjust(items: any[], col: any): unknown[]
+		findSpace(item: any, items: any, cols: any): unknown
+
+		item<T>(obj: ItemLayout): Required<ItemLayout>
+	}
+
+	export default x
+}

frontend/src/lib/assets/app.css

@@ -50,23 +50,12 @@
 	.Template-editor span.mtk20 {
 		color: black !important;
 	}
-
-	::-webkit-scrollbar {
-		width: 9px;
-		height: 9px;
-	}
-	::-webkit-scrollbar-track {
-		background: transparent;
-	}
-	::-webkit-scrollbar-thumb {
-		background-color: rgba(155, 155, 155, 0.5);
-		border: transparent;
-	}
 }
 
 @layer components {
 	/* Flow graph viewer -> Svelvet library internal class overwrite */
 	.Node {
 		display: flex !important;
+		cursor: pointer !important;
 	}
 }

frontend/src/lib/common.ts

@@ -1,4 +1,4 @@
-import type { Script } from './gen'
+import type { Script } from "./gen"
 
 export type OwnerKind = 'group' | 'user' | 'folder'
 
@@ -14,7 +14,7 @@ export interface SchemaProperty {
 	enum?: string[]
 	contentEncoding?: 'base64' | 'binary'
 	format?: string
-	items?: { type?: 'string' | 'number' | 'bytes' | 'object'; contentEncoding?: 'base64' }
+	items?: { type?: 'string' | 'number' | 'bytes'; contentEncoding?: 'base64' }
 	properties?: { [name: string]: SchemaProperty }
 }
 
@@ -28,14 +28,11 @@ export type Schema = {
 export type Meta = { ownerKind: OwnerKind; owner: string; name: string }
 
 type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N
-	? Acc[number]
-	: Enumerate<N, [...Acc, Acc['length']]>
+  ? Acc[number]
+  : Enumerate<N, [...Acc, Acc['length']]>
 
 /** An inclusive range of integer numbers */
-export type IntRange<F extends number, T extends number> =
-	| F
-	| Exclude<Enumerate<T>, Enumerate<F>>
-	| T
+export type IntRange<F extends number, T extends number> = F | Exclude<Enumerate<T>, Enumerate<F>> | T
 
 export function pathToMeta(path: string): Meta {
 	const splitted = path.split('/')

frontend/src/lib/components/AppConnect.svelte

@@ -81,7 +81,7 @@
 	$: key =
 		apiTokenApps[resource_type]?.key ??
 		(args != undefined
-			? Object.keys(args).filter((x) => ['token', 'password', 'api_key', 'key'].includes(x))[0]
+			? Object.keys(args).filter((x) => ['token', 'password', 'api_key'].includes(x))[0]
 			: undefined)
 
 	let scopes: string[] = []
@@ -259,7 +259,6 @@
 			args['token'] == '' &&
 			args['password'] == '' &&
 			args['api_key'] == '' &&
-			args['key'] == '' &&
 			key != undefined) ||
 		(step == 3 && pathError != '') ||
 		!isValid
@@ -370,7 +369,7 @@
 			<h2 class="mt-8 mb-4">Non OAuth APIs & Resources</h2>
 			<div class="grid sm:grid-cols-2 md:grid-cols-3 gap-x-2 gap-y-1 items-center mb-2">
 				{#if filteredConnectsManual}
-					{#each filteredConnectsManual as [key, _]}
+					{#each filteredConnectsManual as [key, instructions]}
 						<Button
 							size="sm"
 							variant="border"
@@ -397,7 +396,7 @@
 				bind:error={pathError}
 				bind:path
 				initialPath=""
-				namePlaceholder={resource_type}
+				namePlaceholder="{resource_type}"
 				kind="resource"
 			/>
 
@@ -414,7 +413,7 @@
 				</div>
 				{#if apiTokenApps[resource_type].img}
 					<div class="mt-4 w-full overflow-hidden">
-						<img class="m-auto max-h-60" alt="connect" src={apiTokenApps[resource_type].img} />
+						<img class="m-auto  max-h-60" alt="connect" src={apiTokenApps[resource_type].img} />
 					</div>
 				{/if}
 			{/if}
@@ -434,7 +433,7 @@
 		{:else}
 			<Path
 				initialPath=""
-				namePlaceholder={resource_type}
+				namePlaceholder="{resource_type}"
 				bind:error={pathError}
 				bind:path
 				kind="resource"

frontend/src/lib/components/ArgInfo.svelte

@@ -1,11 +1,13 @@
 <script lang="ts">
+	import { truncate } from '$lib/utils'
+	import Tooltip from './Tooltip.svelte'
+	import json from 'svelte-highlight/languages/json'
+	import { Highlight } from 'svelte-highlight'
 	import { ResourceService } from '$lib/gen'
 	import { workspaceStore } from '$lib/stores'
-	import { truncate } from '$lib/utils'
-	import { DrawerContent } from './common'
 	import Drawer from './common/drawer/Drawer.svelte'
+	import { DrawerContent } from './common'
 	import ObjectViewer from './propertyPicker/ObjectViewer.svelte'
-	import Tooltip from './Tooltip.svelte'
 
 	export let value: any
 	let jsonViewer: Drawer

frontend/src/lib/components/ArgInput.svelte

@@ -3,31 +3,29 @@
 		faChevronDown,
 		faChevronUp,
 		faDollarSign,
+		faMinus,
 		faPlus
 	} from '@fortawesome/free-solid-svg-icons'
 
-	import type { SchemaProperty } from '$lib/common'
-	import { setInputCat as computeInputCat } from '$lib/utils'
-	import { X } from 'lucide-svelte'
-	import { createEventDispatcher } from 'svelte'
-	import autosize from 'svelte-autosize'
-	import Icon from 'svelte-awesome'
-	import { fade } from 'svelte/transition'
-	import JsonEditor from './apps/editor/settingsPanel/inputEditor/JsonEditor.svelte'
+	import { setInputCat as computeInputCat, type InputCat } from '$lib/utils'
 	import { Badge, Button } from './common'
+	import { createEventDispatcher } from 'svelte'
+	import Icon from 'svelte-awesome'
 	import FieldHeader from './FieldHeader.svelte'
-	import type ItemPicker from './ItemPicker.svelte'
-	import NumberTypeNarrowing from './NumberTypeNarrowing.svelte'
 	import ObjectResourceInput from './ObjectResourceInput.svelte'
 	import ObjectTypeNarrowing from './ObjectTypeNarrowing.svelte'
-	import Password from './Password.svelte'
-	import Range from './Range.svelte'
 	import ResourcePicker from './ResourcePicker.svelte'
-	import SchemaForm from './SchemaForm.svelte'
-	import SimpleEditor from './SimpleEditor.svelte'
 	import StringTypeNarrowing from './StringTypeNarrowing.svelte'
+	import SchemaForm from './SchemaForm.svelte'
+	import type { SchemaProperty } from '$lib/common'
+	import SimpleEditor from './SimpleEditor.svelte'
+	import autosize from 'svelte-autosize'
 	import Toggle from './Toggle.svelte'
+	import Password from './Password.svelte'
 	import type VariableEditor from './VariableEditor.svelte'
+	import type ItemPicker from './ItemPicker.svelte'
+	import NumberTypeNarrowing from './NumberTypeNarrowing.svelte'
+	import Range from './Range.svelte'
 
 	export let label: string = ''
 	export let value: any
@@ -41,11 +39,12 @@
 	export let required = false
 	export let pattern: undefined | string = undefined
 	export let valid = required ? false : true
+	export let maxRows = 10
 	export let enum_: string[] | undefined = undefined
 	export let disabled = false
 	export let editableSchema = false
 	export let itemsType:
-		| { type?: 'string' | 'number' | 'bytes' | 'object'; contentEncoding?: 'base64' }
+		| { type?: 'string' | 'number' | 'bytes'; contentEncoding?: 'base64' }
 		| undefined = undefined
 	export let displayHeader = true
 	export let properties: { [name: string]: SchemaProperty } | undefined = undefined
@@ -61,6 +60,8 @@
 	let seeEditable: boolean = enum_ != undefined || pattern != undefined
 	const dispatch = createEventDispatcher()
 
+	$: maxHeight = maxRows ? `${1 + maxRows * 1.2}em` : `auto`
+
 	$: validateInput(pattern, value)
 
 	let error: string = ''
@@ -92,7 +93,7 @@
 
 	export function evalValueToRaw() {
 		if (value) {
-			rawValue = JSON.stringify(value, null, 2)
+			rawValue = JSON.stringify(value, null, 4)
 		}
 	}
 
@@ -151,28 +152,21 @@
 					value = enum_?.[0]
 				} else if (inputCat == 'boolean') {
 					value = false
-				} else if (inputCat == 'list') {
-					value = []
 				}
 			}
 		}
 	}
 
 	$: inputCat = computeInputCat(type, format, itemsType?.type, enum_, contentEncoding)
-	let redraw = 0
-
-	let itemsLimit = 50
 </script>
 
-<!-- svelte-ignore a11y-autofocus -->
 <div class="flex flex-col w-full min-w-[250px]">
 	<div>
 		{#if displayHeader}
-			<FieldHeader {label} {required} {type} {contentEncoding} {format} />
+			<FieldHeader {label} {required} {type} {contentEncoding} {format} {itemsType} />
 		{/if}
 		{#if editableSchema}
 			<div class="p-2 my-1 text-xs border-solid border border-gray-400">
-				<!-- svelte-ignore a11y-click-events-have-key-events -->
 				<span
 					class="underline"
 					on:click={() => {
@@ -192,7 +186,6 @@
 								use:autosize
 								rows="1"
 								bind:value={description}
-								on:keydown|stopPropagation
 								placeholder="Field description"
 							/>
 							{#if type == 'string' && format != 'date-time'}
@@ -205,7 +198,6 @@
 								<select bind:value={itemsType}>
 									<option value={undefined}>No specific item type</option>
 									<option value={{ type: 'string' }}> Items are strings</option>
-									<option value={{ type: 'object' }}> Items are objects (JSON)</option>
 									<option value={{ type: 'number' }}>Items are numbers</option>
 									<option value={{ type: 'string', contentEncoding: 'base64' }}
 										>Items are bytes</option
@@ -240,6 +232,7 @@
 					<input
 						{autofocus}
 						on:focus={(e) => {
+							window.dispatchEvent(new Event('pointerup'))
 							dispatch('focus')
 						}}
 						{disabled}
@@ -251,12 +244,14 @@
 						bind:value
 						min={extra['min']}
 						max={extra['max']}
+						on:input={() => dispatch('input', { value, isRaw: true })}
 					/>
 				{/if}
 			{:else if inputCat == 'boolean'}
 				<Toggle
 					on:pointerdown={(e) => {
 						e?.stopPropagation()
+						window.dispatchEvent(new Event('pointerup'))
 					}}
 					{disabled}
 					class={valid
@@ -268,53 +263,44 @@
 					<span>&nbsp; Not set</span>
 				{/if}
 			{:else if inputCat == 'list'}
-				<div class="w-full">
-					<div class="w-full">
-						{#key redraw}
-							{#if Array.isArray(value)}
-								{#each value ?? [] as v, i}
-									{#if i < itemsLimit}
-										<div class="flex max-w-md mt-1 w-full items-center">
-											{#if itemsType?.type == 'number'}
-												<input type="number" bind:value={v} />
-											{:else if itemsType?.type == 'string' && itemsType?.contentEncoding == 'base64'}
-												<input
-													type="file"
-													class="my-6"
-													on:change={(x) => fileChanged(x, (val) => (value[i] = val))}
-													multiple={false}
-												/>
-											{:else if itemsType?.type == 'object'}
-												<JsonEditor code={JSON.stringify(v, null, 2)} bind:value={v} />
-											{:else}
-												<input type="text" bind:value={v} />
-											{/if}
-											<button
-												transition:fade|local={{ duration: 100 }}
-												class="rounded-full p-1 bg-white/60 duration-200 hover:bg-gray-200"
-												aria-label="Clear"
-												on:click={() => {
-													value.splice(i, 1)
-													redraw += 1
-												}}
-											>
-												<X size={14} />
-											</button>
-										</div>
-									{/if}
-								{/each}
-								{#if value.length > itemsLimit}
-									<button on:click={() => (itemsLimit += 50)} class="text-xs py-2 text-blue-600"
-										>{itemsLimit}/{value.length}: Load 50 more...</button
-									>
+				<div>
+					<div>
+						{#each value ?? [] as v, i}
+							<div class="flex flex-row max-w-md mt-1">
+								{#if itemsType?.type == 'number'}
+									<input autofocus={autofocus && i == 0} type="number" bind:value={v} />
+								{:else if itemsType?.type == 'string' && itemsType?.contentEncoding == 'base64'}
+									<input
+										autofocus={autofocus && i == 0}
+										type="file"
+										class="my-6"
+										on:change={(x) => fileChanged(x, (val) => (value[i] = val))}
+										multiple={false}
+									/>
+								{:else}
+									<input autofocus={autofocus && i == 0} type="text" bind:value={v} />
 								{/if}
-							{/if}
-						{/key}
+								<Button
+									variant="border"
+									color="red"
+									size="sm"
+									btnClasses="mx-6"
+									on:click={() => {
+										value = value.filter((el) => el != v)
+										if (value.length == 0) {
+											value = undefined
+										}
+									}}
+								>
+									<Icon data={faMinus} />
+								</Button>
+							</div>
+						{/each}
 					</div>
 					<Button
 						variant="border"
-						color="dark"
-						size="xs"
+						color="blue"
+						size="sm"
 						btnClasses="mt-1"
 						on:click={() => {
 							if (value == undefined || !Array.isArray(value)) {
@@ -326,6 +312,9 @@
 						<Icon data={faPlus} class="mr-2" />
 						Add item
 					</Button>
+					<span class="ml-2">
+						{(value ?? []).length} item{(value ?? []).length > 1 ? 's' : ''}
+					</span>
 				</div>
 			{:else if inputCat == 'resource-object'}
 				<ObjectResourceInput {format} bind:value />
@@ -338,21 +327,31 @@
 							bind:args={value}
 						/>
 					</div>
-				{:else if disabled}
-					<textarea disabled />
 				{:else}
-					<JsonEditor
-						bind:editor
+					<textarea
+						bind:this={el}
 						on:focus={(e) => {
+							window.dispatchEvent(new Event('pointerup'))
 							dispatch('focus')
 						}}
-						code={rawValue}
-						bind:value
+						{autofocus}
+						{disabled}
+						use:autosize
+						style="max-height: {maxHeight}"
+						on:input={() => {
+							dispatch('input', { rawValue: value, isRaw: false })
+						}}
+						class="col-span-10 {valid
+							? ''
+							: 'border border-red-700 border-opacity-30 focus:border-red-700 focus:border-opacity-30 bg-red-100'}"
+						placeholder={defaultValue ? JSON.stringify(defaultValue, null, 4) : ''}
+						bind:value={rawValue}
 					/>
 				{/if}
 			{:else if inputCat == 'enum'}
 				<select
 					on:focus={(e) => {
+						window.dispatchEvent(new Event('pointerup'))
 						dispatch('focus')
 					}}
 					{disabled}
@@ -369,11 +368,16 @@
 				<div class="border my-1 mb-4 w-full border-gray-400">
 					<SimpleEditor
 						on:focus={(e) => {
+							window.dispatchEvent(new Event('pointerup'))
 							dispatch('focus')
 						}}
+						on:blur={() => dispatch('blur')}
 						bind:this={editor}
 						lang={inputCat}
 						bind:code={value}
+						on:change={async () => {
+							dispatch('input', { rawValue: value, isRaw: false })
+						}}
 						autoHeight
 					/>
 				</div>
@@ -403,10 +407,11 @@
 								rows="1"
 								bind:this={el}
 								on:focus={(e) => {
+									window.dispatchEvent(new Event('pointerup'))
 									dispatch('focus')
 								}}
+								on:blur={() => dispatch('blur')}
 								use:autosize
-								on:keydown|stopPropagation
 								type="text"
 								{disabled}
 								class="col-span-10 {valid
@@ -414,6 +419,9 @@
 									: 'border border-red-700 border-opacity-30 focus:border-red-700 focus:border-opacity-30 bg-red-100'}"
 								placeholder={defaultValue ?? ''}
 								bind:value
+								on:input={() => {
+									dispatch('input', { rawValue: value, isRaw: false })
+								}}
 							/>
 							{#if itemPicker}
 								<div class="ml-1 relative">
@@ -442,6 +450,19 @@
 					{/if}
 				</div>
 			{/if}
+			{#if !required && inputCat != 'resource-object'}
+				<!-- <Tooltip placement="bottom" content="Reset to default value">
+					<Button
+						on:click={() => (value = undefined)}
+						{disabled}
+						color="alternative"
+						size="sm"
+						class="h-8"
+					>
+						<Icon data={faArrowRotateLeft} />
+					</Button>
+				</Tooltip> -->
+			{/if}
 			<slot name="actions" />
 		</div>
 		{#if !compact || (error && error != '')}