From e33568e6f93068a94e0daeaf1a0415326cd6d35c Mon Sep 17 00:00:00 2001
From: Alexander Piskun <bigcat88@icloud.com>
Date: Tue, 15 Oct 2024 19:02:23 +0300
Subject: [PATCH] implemented simpler "manual" installation

Signed-off-by: Alexander Piskun <bigcat88@icloud.com>
---
 .run/NC 30.run.xml |   6 +-
 Dockerfile         |   2 +
 Makefile           |  23 +++++--
 README.md          | 154 +++++++++++++++++++++++++++++++++------------
 ex_app/lib/main.py |  88 +++++++++++++++-----------
 pyproject.toml     |   2 +-
 6 files changed, 193 insertions(+), 82 deletions(-)

diff --git a/.run/NC 30.run.xml b/.run/NC 30.run.xml
index bc36797..bf13f7d 100644
--- a/.run/NC 30.run.xml	
+++ b/.run/NC 30.run.xml	
@@ -5,13 +5,13 @@
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="PARENT_ENVS" value="true" />
     <envs>
-      <env name="PYTHONUNBUFFERED" value="1" />
+      <env name="APP_HOST" value="0.0.0.0" />
       <env name="APP_ID" value="windmill_app" />
-      <env name="APP_PORT" value="23000" />
+      <env name="APP_PORT" value="24000" />
       <env name="APP_SECRET" value="12345" />
       <env name="APP_VERSION" value="1.0.0" />
       <env name="NEXTCLOUD_URL" value="http://nextcloud.local/index.php" />
-      <env name="APP_HOST" value="0.0.0.0" />
+      <env name="PYTHONUNBUFFERED" value="1" />
     </envs>
     <option name="SDK_HOME" value="" />
     <option name="SDK_NAME" value="Python 3.10 (windmill_app)" />
diff --git a/Dockerfile b/Dockerfile
index d4f4b21..c072d0d 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -45,6 +45,8 @@ ENV NODE_OPTIONS "--max-old-space-size=8192"
 ARG VITE_BASE_URL ""
 RUN npm run build
 
+FROM scratch AS export_frontend
+COPY --from=frontend /frontend/build/ /
 
 FROM rust_base AS planner
 
diff --git a/Makefile b/Makefile
index e2d937c..b7d1227 100644
--- a/Makefile
+++ b/Makefile
@@ -10,17 +10,32 @@ help:
 	@echo "  init        	   clone Windmill repository to the 'windmill_src' folder and copy ExApp files inside it"
 	@echo "  build-push        build image and upload to ghcr.io"
 	@echo "  "
-	@echo "  run30             install Flow for Nextcloud 30"
-	@echo "  run               install Flow for Nextcloud Last"
+	@echo "  run30             install Flow App for Nextcloud 30"
+	@echo "  run               install Flow App for Nextcloud Last"
+	@echo "  "
+	@echo "  static_frontend   build Windmill static frontend for Manual Installation"
+	@echo "  register30        register manually running Flow App into Nextcloud"
 
 .PHONY: init
 init:
+	rm -rf windmill_src
 	git -c advice.detachedHead=False clone -b v1.394.4 https://github.com/windmill-labs/windmill.git windmill_src
 	cp Dockerfile requirements.txt windmill_src/
 
 	cp -r ex_app windmill_src/
 	cp -r ex_app_scripts windmill_src/
 
+.PHONY: static_frontend
+static_frontend:
+	rm -rf static_frontend
+	pushd windmill_src && \
+	DOCKER_BUILDKIT=1 docker buildx build \
+		--build-arg VITE_BASE_URL=/index.php/apps/app_api/proxy/flow \
+		--platform linux/amd64 \
+		--target export_frontend \
+		--output type=local,dest=../static_frontend . && \
+	popd
+
 .PHONY: build-push
 build-push:
 	docker login ghcr.io
@@ -45,12 +60,12 @@ run:
 register30:
 	docker exec master-stable30-1 sudo -u www-data php occ app_api:app:unregister flow --silent --force || true
 	docker exec master-stable30-1 sudo -u www-data php occ app_api:app:register flow manual_install --json-info \
-  "{\"id\":\"flow\",\"name\":\"Flow\",\"daemon_config_name\":\"manual_install\",\"version\":\"1.0.0\",\"secret\":\"12345\",\"port\":23000}" \
+  "{\"id\":\"flow\",\"name\":\"Flow\",\"daemon_config_name\":\"manual_install\",\"version\":\"1.0.0\",\"secret\":\"12345\",\"port\":24000, \"routes\": [{\"url\":\"^api\\\/w\\\/nextcloud\\\/jobs\\\/.*\", \"verb\":\"GET, POST, PUT, DELETE\", \"access_level\":0, \"headers_to_exclude\":[], \"bruteforce_protection\":[401]}, {\"url\":\"^api\\\/w\\\/nextcloud\\\/jobs_u\\\/.*\", \"verb\":\"GET, POST, PUT, DELETE\", \"access_level\":0, \"headers_to_exclude\":[], \"bruteforce_protection\":[401]}, {\"url\":\".*\", \"verb\":\"GET, POST, PUT, DELETE\", \"access_level\":2, \"headers_to_exclude\":[]}]}" \
   --wait-finish
 
 .PHONY: register
 register:
 	docker exec master-nextcloud-1 sudo -u www-data php occ app_api:app:unregister flow --silent --force || true
 	docker exec master-nextcloud-1 sudo -u www-data php occ app_api:app:register flow manual_install --json-info \
-  "{\"id\":\"flow\",\"name\":\"Flow\",\"daemon_config_name\":\"manual_install\",\"version\":\"1.0.0\",\"secret\":\"12345\",\"port\":23000}" \
+  "{\"id\":\"flow\",\"name\":\"Flow\",\"daemon_config_name\":\"manual_install\",\"version\":\"1.0.0\",\"secret\":\"12345\",\"port\":24000, \"routes\": [{\"url\":\"^api\\\/w\\\/nextcloud\\\/jobs\\\/.*\", \"verb\":\"GET, POST, PUT, DELETE\", \"access_level\":0, \"headers_to_exclude\":[], \"bruteforce_protection\":[401]}, {\"url\":\"^api\\\/w\\\/nextcloud\\\/jobs_u\\\/.*\", \"verb\":\"GET, POST, PUT, DELETE\", \"access_level\":0, \"headers_to_exclude\":[], \"bruteforce_protection\":[401]}, {\"url\":\".*\", \"verb\":\"GET, POST, PUT, DELETE\", \"access_level\":2, \"headers_to_exclude\":[]}]}" \
   --wait-finish
diff --git a/README.md b/README.md
index f848914..3fe7ec2 100644
--- a/README.md
+++ b/README.md
@@ -1,60 +1,43 @@
 # Flow: Seamless Automation for Nextcloud
 
-Flow is a dynamic workflow automation application, carefully integrated into your Nextcloud environment. Built upon the powerful Windmill engine, Flow takes the robust capabilities of Windmill and adapts them for a smooth experience within Nextcloud, providing teams and individuals with the ability to automate, streamline, and enhance their workflows like never before.
+Flow is a dynamic workflow automation application, carefully integrated into your Nextcloud environment. Built upon the powerful Windmill engine, Flow adapts the robust capabilities of Windmill for a smooth experience within Nextcloud, providing teams and individuals with the ability to automate, streamline, and enhance their workflows like never before.
 
-> [!NOTE]
-> **Requires [`AppAPI`](https://github.com/nextcloud/app_api) and `webhook_listeners` to be enabled to work.**
+> **Note:**
+> **Requires the `AppAPI` and `webhooks_listener` apps to be enabled to work properly.**
 
 ## Key Features of Flow
 
 Flow brings a wealth of features designed to improve productivity and collaboration, with a particular focus on user-friendliness and scalability:
 
 ### 1. **Drag-and-Drop Workflow Builder**
-   - Create complex workflows with ease using a highly intuitive drag-and-drop interface. Whether you're automating document management, team notifications, or custom processes, Flow's visual workflow designer ensures anyone can build and modify workflows with minimal effort.
 
-### 2. **Automate Repetitive Tasks**
-   - Save time and resources by automating common repetitive tasks. With Flow, you can schedule tasks to run on specific conditions or set up trigger-based actions to run automatically, reducing manual interventions and enhancing efficiency.
+- Create complex workflows with ease using a highly intuitive drag-and-drop interface. Whether you're automating document management, team notifications, or custom processes, Flow's visual workflow designer ensures anyone can build and modify workflows with minimal effort.
 
-### 3. **Seamless Integration with Nextcloud**
-   - As a fully integrated part of Nextcloud, Flow works effortlessly alongside other applications in your Nextcloud environment. Automate tasks related to file management, collaboration, communication, and more, all within the same familiar platform.
+### 2. **Automate Repetitive Tasks**
 
-### 4. **Built on the Windmill Engine**
-   - Flow leverages the robust backend of Windmill, an established workflow automation platform, which powers its capabilities for scalability, efficiency, and reliability. Windmill’s foundation ensures that Flow inherits an array of advanced features while being customized for seamless use within Nextcloud.
+- Save time and resources by automating common repetitive tasks. With Flow, you can schedule tasks to run on specific conditions or set up trigger-based actions to run automatically, reducing manual interventions and enhancing efficiency.
 
-### 5. **Real-Time Workflow Monitoring**
-   - Keep track of the progress of your workflows in real-time with detailed analytics and dashboards. Monitor performance, track errors, and ensure that every task is executed smoothly without delays.
+### 3. **Seamless Integration with Nextcloud**
 
-### 6. **Flexible Scheduling and Triggers**
-   - Flow allows you to set up flexible schedules for tasks, trigger workflows based on specific events, and monitor their execution in real time. With Flow’s built-in scheduler, you can execute workflows on demand, at predefined intervals, or when specific criteria are met.
+- As a fully integrated part of Nextcloud, Flow works effortlessly alongside other applications in your Nextcloud environment. Automate tasks related to file management, collaboration, communication, and more—all within the same familiar platform.
 
-## Benefits of Using Flow
+### 4. **Built on the Windmill Engine**
 
-Flow is more than just a workflow tool. It's a productivity powerhouse designed to work seamlessly in the Nextcloud environment, enhancing everything from document management to team collaboration.
+- Flow leverages the robust backend of Windmill, an established workflow automation platform, powering its capabilities for scalability, efficiency, and reliability. Windmill’s foundation ensures that Flow inherits an array of advanced features while being customized for seamless use within Nextcloud.
 
-### 1. **Centralized Workflow Automation**
-   - Flow helps you centralize all your workflow automation needs within Nextcloud, reducing the need for external tools and ensuring a smoother, more integrated experience for users.
+### 5. **Real-Time Workflow Monitoring**
 
-### 2. **Boosted Team Collaboration**
-   - By automating notifications, approvals, and task assignments, Flow ensures that your team stays in sync and focused on the tasks that matter most, reducing the time spent on administrative overhead.
+- Keep track of the progress of your workflows in real-time with detailed analytics and dashboards. Monitor performance, track errors, and ensure that every task is executed smoothly without delays.
 
-### 3. **Scalable for Any Team Size**
-   - Whether you’re working with a small team or an entire organization, Flow is built to scale. Thanks to Windmill’s proven engine, Flow can handle workflows of any complexity, ensuring that your automation can grow alongside your team.
+### 6. **Flexible Scheduling and Triggers**
 
-### 4. **Security and Privacy First**
-   - Built within the secure framework of Nextcloud, Flow ensures that all your workflows and automation are handled with the highest level of security and data protection. Your data stays within your Nextcloud environment, respecting your organization’s privacy policies.
+- Flow allows you to set up flexible schedules for tasks, trigger workflows based on specific events, and monitor their execution in real-time. With Flow’s built-in scheduler, you can execute workflows on demand, at predefined intervals, or when specific criteria are met.
 
 ## Getting Started
 
 Flow is designed to be easy to set up and use. Follow these steps to get started:
 
-### Step 1: Install Flow in Nextcloud
-To install Flow, navigate to the Nextcloud AppStore and search for **Flow**. Install the app and [`follow the instructions`](https://docs.nextcloud.com/server/latest/admin_manual/windmill_workflows/index.html) to complete the setup.
-
-### Step 2: Configure Workflows
-Once Flow is installed, you can start creating workflows by accessing the Flow tab within Nextcloud. Use the drag-and-drop builder to configure your desired workflows, add conditions, and set triggers.
-
-### Step 3: Automate and Optimize
-After creating your workflows, sit back and let Flow do the heavy lifting. You can monitor all automated tasks in real time and optimize them as needed.
+To install Flow, navigate to the Nextcloud App Store and search for **Flow**. Install the app and [follow the instructions](https://docs.nextcloud.com/server/latest/admin_manual/windmill_workflows/index.html) to complete the setup.
 
 ## Advanced Features
 
@@ -66,18 +49,111 @@ For users familiar with Windmill, Flow offers additional advanced features that
 
 ## FAQ
 
-### Specific environment options to control ExApp behavior
+### Specific Environment Options to Control ExApp Behavior
 
-> [!NOTE]
+> **Note:**
 >
-> This is only supported starting from Nextcloud version `30.0.2` and `Flow 1.1.0` version 
+> This is only supported starting from Nextcloud version `30.0.2` and Flow version `1.1.0`
 
-**Q: How can I control the number of Windmill workers?**  
+**Q: How can I control the number of Windmill workers?**
 **A:** You can set the `NUM_WORKERS` environment variable. The default value is `number_of_cpu_cores * 2`.
 
-**Q: I want to use an external PGSQL database instead of the bundled one in the container. Can I?**  
-**A:** You can configure it by setting the `DATABASE_URI` environment variable in the following format:  
-`postgres://DB_USER:DB_PASS@localhost:5432/DB_NAME`.
+**Q: I want to use an external PostgreSQL database instead of the bundled one in the container. Can I?**
+**A:** Yes, you can configure it by setting the `DATABASE_URI` environment variable in the following format:
+`postgres://DB_USER:DB_PASS@localhost:5432/DB_NAME`
+
+### Manual Deployment
+
+> **Note:**
+> 
+> This method can also be used for enterprise or custom scaled Windmill setups.
+
+**Prerequisites:**
+
+- Nextcloud instance with `AppAPI` and `webhooks_listener` apps enabled.
+- Python 3.10 or higher installed on the server.
+- Git installed on the server.
+
+Follow these steps to manually deploy Flow without Docker:
+
+1. **Register the Deploy Daemon in AppAPI**
+
+   First, register the Deploy Daemon in AppAPI with the `manual-install` type. Refer to the Nextcloud documentation for detailed instructions: [AppAPI Manual Install](todo)
+
+2. **Clone the Repository and Install Dependencies**
+
+   Clone the Flow repository:
+
+   ```bash
+   git clone https://github.com/cloud-py-api/flow.git
+   ```
+
+   Navigate into the cloned directory, create a Python virtual environment, and install the required dependencies:
+
+   ```bash
+   cd flow
+   python3 -m venv venv
+   source venv/bin/activate
+   pip install -r requirements.txt
+   ```
+
+3. **Install Windmill**
+
+   Install Windmill by following the official instructions: [Setup Windmill on Localhost](https://www.windmill.dev/docs/advanced/self_host#setup-windmill-on-localhost)
+
+   **Note:** Windmill should be in its default state, with the default user `admin@windmill.dev` and password `changeme`. If you have changed the administrator username/password, adjust the `DEFAULT_USER_EMAIL` and `DEFAULT_USER_PASSWORD` variables in the `ex_app/lib/main.py` file accordingly.
+
+4. **Configure ExApp Environment Variables**
+
+   Set the required ExApp environment variables (`NEXTCLOUD_URL`, `APP_HOST`, `APP_PORT`, `APP_SECRET`) or modify them directly in the script at the top of `ex_app/lib/main.py`. Refer to the Nextcloud documentation for more details: [ExApp Configuration](todo)
+
+5. **Set the `WINDMILL_URL` Environment Variable**
+
+   Define the `WINDMILL_URL` environment variable or set it in the script. This variable specifies the location of the Windmill instance you deployed in step 3.
+
+6. **Adjust Windmill Version (Optional)**
+
+   **Note:** If you are using a non-standard version of Windmill from the ExApp, please adjust its version in the `Makefile` by editing the line under the `init` target:
+
+   ```makefile
+   git -c advice.detachedHead=False clone -b v1.394.4 https://github.com/windmill-labs/windmill.git windmill_src
+   ```
+
+   Replace `v1.394.4` with your desired Windmill version.
+
+7. **Initialize Windmill Source and Build Frontend**
+
+   Run the following commands from the cloned `flow` repository to clone Windmill into the `windmill_src` folder and build the frontend:
+
+   ```bash
+   make init
+   make static_frontend
+   ```
+
+   These commands will:
+
+   - Clone the Windmill source code into `windmill_src`.
+   - Build the frontend assets and create the `static_frontend` folder, which will be served by ExApp as the Windmill frontend.
+
+8. **Run the ExApp and Register with Nextcloud**
+
+   Start the ExApp main script:
+
+   ```bash
+   python ex_app/lib/main.py
+   ```
+
+   In a new terminal window (while keeping the ExApp running), execute the registration command to register the ExApp with Nextcloud:
+
+   ```bash
+   make register
+   ```
+
+   This registers the ExApp in Nextcloud for operation without Docker.
+
+9. **Access Windmill in Nextcloud**
+
+   Windmill should now appear within your Nextcloud instance, accessible via the Flow app.
 
 ## Contributing
 
diff --git a/ex_app/lib/main.py b/ex_app/lib/main.py
index a12b99d..a48d430 100644
--- a/ex_app/lib/main.py
+++ b/ex_app/lib/main.py
@@ -25,11 +25,20 @@
 from nc_py_api.ex_app.integration_fastapi import AppAPIAuthMiddleware, fetch_models_task
 from starlette.responses import FileResponse, Response
 
+# ---------Start of configuration values for manual deploy---------
+
+# Uncommenting the following lines may be useful when installing manually.
+
 # os.environ["NEXTCLOUD_URL"] = "http://nextcloud.local/index.php"
 # os.environ["APP_HOST"] = "0.0.0.0"
+# os.environ["APP_PORT"] = "24000"
 # os.environ["APP_ID"] = "flow"
 # os.environ["APP_SECRET"] = "12345"  # noqa
-# os.environ["APP_PORT"] = "23001"
+
+WINDMILL_URL = os.environ.get("WINDMILL_URL", "http://127.0.0.1:8000")
+# WINDMILL_URL = "http://localhost:85"  # uncomment this for dev(Windmill should be avalaible at port 85)
+
+# ---------Enf of configuration values for manual deploy---------
 
 logging.basicConfig(
     level=logging.WARNING,
@@ -40,6 +49,7 @@
 LOGGER.setLevel(logging.DEBUG)
 
 DEFAULT_USER_EMAIL = "admin@windmill.dev"
+DEFAULT_USER_PASSWORD = "changeme"
 USERS_STORAGE_PATH = Path(persistent_storage()).joinpath("windmill_users_config.json")
 USERS_STORAGE = {}
 print("[DEBUG]: USERS_STORAGE_PATH=", str(USERS_STORAGE_PATH), flush=True)
@@ -47,6 +57,12 @@
     with open(USERS_STORAGE_PATH, encoding="utf-8") as __f:
         USERS_STORAGE.update(json.load(__f))
 
+PROJECT_ROOT_FOLDER = Path(__file__).parent.parent.parent
+STATIC_FRONTEND_FOLDER = PROJECT_ROOT_FOLDER.joinpath("static_frontend")
+STATIC_FRONTEND_PRESENT = STATIC_FRONTEND_FOLDER.is_dir()
+print("[DEBUG]: PROJECT_ROOT_FOLDER=", PROJECT_ROOT_FOLDER, flush=True)
+print("[DEBUG]: STATIC_FRONTEND_PRESENT=", STATIC_FRONTEND_PRESENT, flush=True)
+
 
 def get_user_email(user_name: str) -> str:
     user_name = user_name.replace(" ", "__UNIQUE_SPACE__")
@@ -66,17 +82,17 @@ async def create_user(user_name: str) -> str:
     async with httpx.AsyncClient() as client:
         await client.request(
             method="POST",
-            url="http://127.0.0.1:8000/api/users/create",
+            url=f"{WINDMILL_URL}/api/users/create",
             json={
                 "email": user_email,
                 "password": password,
                 "super_admin": True,
                 "name": user_name,
             },
-            cookies={"token": USERS_STORAGE["admin@windmill.dev"]["token"]},
+            cookies={"token": USERS_STORAGE[DEFAULT_USER_EMAIL]["token"]},
         )
         r = await client.post(
-            url="http://127.0.0.1:8000/api/auth/login",
+            url=f"{WINDMILL_URL}/api/auth/login",
             json={"email": user_email, "password": password},
         )
         add_user_to_storage(user_email, password, r.text)
@@ -87,7 +103,7 @@ async def login_user(user_email: str, password: str) -> str:
     LOGGER.debug(user_email)
     async with httpx.AsyncClient() as client:
         r = await client.post(
-            url="http://127.0.0.1:8000/api/auth/login",
+            url=f"{WINDMILL_URL}/api/auth/login",
             json={"email": user_email, "password": password},
         )
         if r.status_code >= 400:
@@ -100,7 +116,7 @@ def login_user_sync(user_email: str, password: str) -> str:
     LOGGER.debug(user_email)
     with httpx.Client() as client:
         r = client.post(
-            url="http://127.0.0.1:8000/api/auth/login",
+            url=f"{WINDMILL_URL}/api/auth/login",
             json={"email": user_email, "password": password},
         )
         if r.status_code >= 400:
@@ -111,13 +127,13 @@ def login_user_sync(user_email: str, password: str) -> str:
 
 async def check_token(token: str) -> bool:
     async with httpx.AsyncClient() as client:
-        r = await client.get("http://127.0.0.1:8000/api/users/whoami", cookies={"token": token})
+        r = await client.get(f"{WINDMILL_URL}/api/users/whoami", cookies={"token": token})
         return bool(r.status_code < 400)
 
 
 def check_token_sync(token: str) -> bool:
     with httpx.Client() as client:
-        r = client.get("http://127.0.0.1:8000/api/users/whoami", cookies={"token": token})
+        r = client.get(f"{WINDMILL_URL}/api/users/whoami", cookies={"token": token})
         return bool(r.status_code < 400)
 
 
@@ -210,7 +226,7 @@ def enabled_callback(enabled: bool, nc: typing.Annotated[NextcloudApp, Depends(n
 
 async def proxy_request_to_windmill(request: Request, path: str, path_prefix: str = ""):
     async with httpx.AsyncClient() as client:
-        url = f"http://127.0.0.1:8000{path_prefix}/{path}"
+        url = f"{WINDMILL_URL}{path_prefix}/{path}"
         headers = {key: value for key, value in request.headers.items() if key.lower() not in ("host", "cookie")}
         if request.method == "GET":
             response = await client.get(
@@ -247,17 +263,19 @@ async def proxy_frontend_requests(request: Request, path: str):
     await provision_user(request, True)
     file_server_path = ""
     if path.startswith("ex_app"):
-        file_server_path = Path("../../" + path)
-    elif not path:
-        file_server_path = Path("/static_frontend/200.html").joinpath(path)
-    elif Path("/static_frontend/").joinpath(path).is_file():
-        file_server_path = Path("/static_frontend/").joinpath(path)
+        file_server_path = PROJECT_ROOT_FOLDER.joinpath(path)
+    elif STATIC_FRONTEND_PRESENT:
+        if not path:
+            file_server_path = STATIC_FRONTEND_FOLDER.joinpath("200.html")
+        elif STATIC_FRONTEND_FOLDER.joinpath(path).is_file():
+            file_server_path = STATIC_FRONTEND_FOLDER.joinpath(path)
 
     if file_server_path:
         LOGGER.debug("proxy_FRONTEND_requests: <OK> Returning: %s", file_server_path)
         response = FileResponse(str(file_server_path))
     else:
-        LOGGER.debug("proxy_FRONTEND_requests: <LOCAL FILE MISSING> Routing(%s) to the backend", path)
+        if STATIC_FRONTEND_PRESENT:
+            LOGGER.debug("proxy_FRONTEND_requests: <LOCAL FILE MISSING> Routing(%s) to the backend", path)
         response = await proxy_request_to_windmill(request, path)
     response.headers["content-security-policy"] = "default-src * 'unsafe-inline' 'unsafe-eval' data: blob:;"
     return response
@@ -266,12 +284,12 @@ async def proxy_frontend_requests(request: Request, path: str):
 def initialize_windmill() -> None:
     while True:  # Let's wait until Windmill opens the port.
         with contextlib.suppress(httpx.ReadError, httpx.ConnectError, httpx.RemoteProtocolError):
-            r = httpx.get("http://127.0.0.1:8000/api/users/whoami")
+            r = httpx.get(f"{WINDMILL_URL}/api/users/whoami")
             if r.status_code in (401, 403):
                 break
     if not USERS_STORAGE_PATH.exists():
         r = httpx.post(
-            url="http://127.0.0.1:8000/api/auth/login", json={"email": "admin@windmill.dev", "password": "changeme"}
+            url=f"{WINDMILL_URL}/api/auth/login", json={"email": DEFAULT_USER_EMAIL, "password": DEFAULT_USER_PASSWORD}
         )
         if r.status_code >= 400:
             LOGGER.error("initialize_windmill: can not login with default credentials: %s", r.text)
@@ -279,7 +297,7 @@ def initialize_windmill() -> None:
         default_token = r.text
         new_default_password = generate_random_string()
         r = httpx.post(
-            url="http://127.0.0.1:8000/api/users/setpassword",
+            url=f"{WINDMILL_URL}/api/users/setpassword",
             json={"password": new_default_password},
             cookies={"token": default_token},
         )
@@ -288,7 +306,7 @@ def initialize_windmill() -> None:
             raise RuntimeError(f"initialize_windmill: can not change default credentials password, {r.text}")
         add_user_to_storage(DEFAULT_USER_EMAIL, new_default_password, default_token)
         r = httpx.post(
-            url="http://127.0.0.1:8000/api/users/tokens/create",
+            url=f"{WINDMILL_URL}/api/users/tokens/create",
             json={"label": "NC_PERSISTENT"},
             cookies={"token": default_token},
         )
@@ -298,7 +316,7 @@ def initialize_windmill() -> None:
         default_token = r.text
         add_user_to_storage(DEFAULT_USER_EMAIL, new_default_password, default_token)
         r = httpx.post(
-            url="http://127.0.0.1:8000/api/workspaces/create",
+            url=f"{WINDMILL_URL}/api/workspaces/create",
             json={"id": "nextcloud", "name": "nextcloud"},
             cookies={"token": default_token},
         )
@@ -306,7 +324,7 @@ def initialize_windmill() -> None:
             LOGGER.error("initialize_windmill: can not create default workspace: %s", r.text)
             raise RuntimeError(f"initialize_windmill: can not create default workspace, {r.text}")
         r = httpx.post(
-            url="http://127.0.0.1:8000/api/w/nextcloud/workspaces/edit_auto_invite",
+            url=f"{WINDMILL_URL}/api/w/nextcloud/workspaces/edit_auto_invite",
             json={"operator": False, "invite_all": True, "auto_add": True},
             cookies={"token": default_token},
         )
@@ -392,7 +410,7 @@ def get_flow_paths(workspace: str, token: str) -> list[str]:
     path = f"w/{workspace}/flows/list"
     flow_paths = []
     with httpx.Client() as client:
-        url = f"http://127.0.0.1:8000/api/{path}"
+        url = f"{WINDMILL_URL}/api/{path}"
         headers = {"Authorization": f"Bearer {token}"}
         response = client.request(
             method=method,
@@ -416,7 +434,7 @@ def get_expected_listeners(workspace: str, token: str, flow_paths: list[str]) ->
         with httpx.Client() as client:
             method = "GET"
             path = f"w/{workspace}/flows/get/{flow_path}"
-            url = f"http://127.0.0.1:8000/api/{path}"
+            url = f"{WINDMILL_URL}/api/{path}"
             headers = {"Authorization": f"Bearer {token}"}
             response = client.request(
                 method=method,
@@ -516,8 +534,8 @@ def delete_listener(registered_listener: dict) -> bool:
 
 def create_nextcloud_auth_variable() -> bool:
     r = httpx.post(
-        url="http://127.0.0.1:8000/api/w/nextcloud/variables/create",
-        cookies={"token": USERS_STORAGE["admin@windmill.dev"]["token"]},
+        url=f"{WINDMILL_URL}/api/w/nextcloud/variables/create",
+        cookies={"token": USERS_STORAGE[DEFAULT_USER_EMAIL]["token"]},
         json={
             "path": "u/admin/exapp_token",
             "value": os.environ["APP_SECRET"],
@@ -534,8 +552,8 @@ def create_nextcloud_auth_variable() -> bool:
 
 def update_nextcloud_auth_variable() -> bool:
     r = httpx.post(
-        url="http://127.0.0.1:8000/api/w/nextcloud/variables/update/u/admin/exapp_token",
-        cookies={"token": USERS_STORAGE["admin@windmill.dev"]["token"]},
+        url=f"{WINDMILL_URL}/api/w/nextcloud/variables/update/u/admin/exapp_token",
+        cookies={"token": USERS_STORAGE[DEFAULT_USER_EMAIL]["token"]},
         json={"value": os.environ["APP_SECRET"]},
     )
     if r.status_code >= 400:
@@ -546,8 +564,8 @@ def update_nextcloud_auth_variable() -> bool:
 
 def create_nextcloud_auth_resource() -> bool:
     r = httpx.post(
-        url="http://127.0.0.1:8000/api/w/nextcloud/resources/create",
-        cookies={"token": USERS_STORAGE["admin@windmill.dev"]["token"]},
+        url=f"{WINDMILL_URL}/api/w/nextcloud/resources/create",
+        cookies={"token": USERS_STORAGE[DEFAULT_USER_EMAIL]["token"]},
         json={
             "path": "u/admin/exapp_resource",
             "resource_type": "nextcloud",
@@ -564,8 +582,8 @@ def create_nextcloud_auth_resource() -> bool:
 
 def create_nextcloud_resource():
     r = httpx.get(
-        url="http://127.0.0.1:8000/api/w/nextcloud/variables/exists/u/admin/exapp_token",
-        cookies={"token": USERS_STORAGE["admin@windmill.dev"]["token"]},
+        url=f"{WINDMILL_URL}/api/w/nextcloud/variables/exists/u/admin/exapp_token",
+        cookies={"token": USERS_STORAGE[DEFAULT_USER_EMAIL]["token"]},
     )
     if r.status_code >= 400:
         LOGGER.critical("Can not check for Nextcloud Auth Variable: %s %s", r.status_code, r.text)
@@ -576,8 +594,8 @@ def create_nextcloud_resource():
             return
     else:
         r = httpx.get(
-            url="http://127.0.0.1:8000/api/w/nextcloud/variables/get_value/u/admin/exapp_token",
-            cookies={"token": USERS_STORAGE["admin@windmill.dev"]["token"]},
+            url=f"{WINDMILL_URL}/api/w/nextcloud/variables/get_value/u/admin/exapp_token",
+            cookies={"token": USERS_STORAGE[DEFAULT_USER_EMAIL]["token"]},
         )
         if r.status_code >= 400:
             LOGGER.critical("Can not get Nextcloud Auth Variable value: %s %s", r.status_code, r.text)
@@ -588,8 +606,8 @@ def create_nextcloud_resource():
                 return
 
     r = httpx.get(
-        url="http://127.0.0.1:8000/api/w/nextcloud/resources/exists/u/admin/exapp_resource",
-        cookies={"token": USERS_STORAGE["admin@windmill.dev"]["token"]},
+        url=f"{WINDMILL_URL}/api/w/nextcloud/resources/exists/u/admin/exapp_resource",
+        cookies={"token": USERS_STORAGE[DEFAULT_USER_EMAIL]["token"]},
     )
     if r.status_code >= 400:
         LOGGER.critical("Can not check for Nextcloud Auth Resource: %s %s", r.status_code, r.text)
diff --git a/pyproject.toml b/pyproject.toml
index 2aaaef7..69a6e40 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,7 +7,7 @@ preview = true
 line-length = 120
 target-version = "py310"
 lint.select = ["A", "B", "C", "D", "E", "F", "G", "I", "S", "SIM", "PIE", "Q", "RET", "RUF", "UP" , "W"]
-lint.extend-ignore = ["D101", "D102", "D103", "D105", "D107", "D203", "D213", "D401", "I001", "RUF100", "D400", "D415"]
+lint.extend-ignore = ["D101", "D102", "D103", "D105", "D107", "D203", "D213", "D401", "I001", "RUF100", "D400", "D415", "S105"]
 
 [tool.isort]
 profile = "black"