Merge branch 'next' into add-opnform-template

.cursor/rules/frontend-patterns.mdc

@@ -267,18 +267,365 @@ For complete documentation, see **[form-components.mdc](mdc:.cursor/rules/form-c
 
 ## Form Handling Patterns
 
+### Livewire Component Data Synchronization Pattern
+
+**IMPORTANT**: All Livewire components must use the **manual `syncData()` pattern** for synchronizing component properties with Eloquent models.
+
+#### Property Naming Convention
+- **Component properties**: Use camelCase (e.g., `$gitRepository`, `$isStatic`)
+- **Database columns**: Use snake_case (e.g., `git_repository`, `is_static`)
+- **View bindings**: Use camelCase matching component properties (e.g., `id="gitRepository"`)
+
+#### The syncData() Method Pattern
+
+```php
+use Livewire\Attributes\Validate;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+
+class MyComponent extends Component
+{
+    use AuthorizesRequests;
+
+    public Application $application;
+
+    // Properties with validation attributes
+    #[Validate(['required'])]
+    public string $name;
+
+    #[Validate(['string', 'nullable'])]
+    public ?string $description = null;
+
+    #[Validate(['boolean', 'required'])]
+    public bool $isStatic = false;
+
+    public function mount()
+    {
+        $this->authorize('view', $this->application);
+        $this->syncData(); // Load from model
+    }
+
+    public function syncData(bool $toModel = false): void
+    {
+        if ($toModel) {
+            $this->validate();
+
+            // Sync TO model (camelCase → snake_case)
+            $this->application->name = $this->name;
+            $this->application->description = $this->description;
+            $this->application->is_static = $this->isStatic;
+
+            $this->application->save();
+        } else {
+            // Sync FROM model (snake_case → camelCase)
+            $this->name = $this->application->name;
+            $this->description = $this->application->description;
+            $this->isStatic = $this->application->is_static;
+        }
+    }
+
+    public function submit()
+    {
+        $this->authorize('update', $this->application);
+        $this->syncData(toModel: true); // Save to model
+        $this->dispatch('success', 'Saved successfully.');
+    }
+}
+```
+
+#### Validation with #[Validate] Attributes
+
+All component properties should have `#[Validate]` attributes:
+
+```php
+// Boolean properties
+#[Validate(['boolean'])]
+public bool $isEnabled = false;
+
+// Required strings
+#[Validate(['string', 'required'])]
+public string $name;
+
+// Nullable strings
+#[Validate(['string', 'nullable'])]
+public ?string $description = null;
+
+// With constraints
+#[Validate(['integer', 'min:1'])]
+public int $timeout;
+```
+
+#### Benefits of syncData() Pattern
+
+- **Explicit Control**: Clear visibility of what's being synchronized
+- **Type Safety**: #[Validate] attributes provide compile-time validation info
+- **Easy Debugging**: Single method to check for data flow issues
+- **Maintainability**: All sync logic in one place
+- **Flexibility**: Can add custom logic (encoding, transformations, etc.)
+
+#### Creating New Form Components with syncData()
+
+#### Step-by-Step Component Creation Guide
+
+**Step 1: Define properties in camelCase with #[Validate] attributes**
+```php
+use Livewire\Attributes\Validate;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Livewire\Component;
+
+class MyFormComponent extends Component
+{
+    use AuthorizesRequests;
+
+    // The model we're syncing with
+    public Application $application;
+
+    // Component properties in camelCase with validation
+    #[Validate(['string', 'required'])]
+    public string $name;
+
+    #[Validate(['string', 'nullable'])]
+    public ?string $gitRepository = null;
+
+    #[Validate(['string', 'nullable'])]
+    public ?string $installCommand = null;
+
+    #[Validate(['boolean'])]
+    public bool $isStatic = false;
+}
+```
+
+**Step 2: Implement syncData() method**
+```php
+public function syncData(bool $toModel = false): void
+{
+    if ($toModel) {
+        $this->validate();
+
+        // Sync TO model (component camelCase → database snake_case)
+        $this->application->name = $this->name;
+        $this->application->git_repository = $this->gitRepository;
+        $this->application->install_command = $this->installCommand;
+        $this->application->is_static = $this->isStatic;
+
+        $this->application->save();
+    } else {
+        // Sync FROM model (database snake_case → component camelCase)
+        $this->name = $this->application->name;
+        $this->gitRepository = $this->application->git_repository;
+        $this->installCommand = $this->application->install_command;
+        $this->isStatic = $this->application->is_static;
+    }
+}
+```
+
+**Step 3: Implement mount() to load initial data**
+```php
+public function mount()
+{
+    $this->authorize('view', $this->application);
+    $this->syncData(); // Load data from model to component properties
+}
+```
+
+**Step 4: Implement action methods with authorization**
+```php
+public function instantSave()
+{
+    try {
+        $this->authorize('update', $this->application);
+        $this->syncData(toModel: true); // Save component properties to model
+        $this->dispatch('success', 'Settings saved.');
+    } catch (\Throwable $e) {
+        return handleError($e, $this);
+    }
+}
+
+public function submit()
+{
+    try {
+        $this->authorize('update', $this->application);
+        $this->syncData(toModel: true); // Save component properties to model
+        $this->dispatch('success', 'Changes saved successfully.');
+    } catch (\Throwable $e) {
+        return handleError($e, $this);
+    }
+}
+```
+
+**Step 5: Create Blade view with camelCase bindings**
+```blade
+<div>
+    <form wire:submit="submit">
+        <x-forms.input
+            canGate="update"
+            :canResource="$application"
+            id="name"
+            label="Name"
+            required />
+
+        <x-forms.input
+            canGate="update"
+            :canResource="$application"
+            id="gitRepository"
+            label="Git Repository" />
+
+        <x-forms.input
+            canGate="update"
+            :canResource="$application"
+            id="installCommand"
+            label="Install Command" />
+
+        <x-forms.checkbox
+            instantSave
+            canGate="update"
+            :canResource="$application"
+            id="isStatic"
+            label="Static Site" />
+
+        <x-forms.button
+            canGate="update"
+            :canResource="$application"
+            type="submit">
+            Save Changes
+        </x-forms.button>
+    </form>
+</div>
+```
+
+**Key Points**:
+- Use `wire:model="camelCase"` and `id="camelCase"` in Blade views
+- Component properties are camelCase, database columns are snake_case
+- Always include authorization checks (`authorize()`, `canGate`, `canResource`)
+- Use `instantSave` for checkboxes that save immediately without form submission
+
+#### Special Patterns
+
+**Pattern 1: Related Models (e.g., Application → Settings)**
+```php
+public function syncData(bool $toModel = false): void
+{
+    if ($toModel) {
+        $this->validate();
+
+        // Sync main model
+        $this->application->name = $this->name;
+        $this->application->save();
+
+        // Sync related model
+        $this->application->settings->is_static = $this->isStatic;
+        $this->application->settings->save();
+    } else {
+        // From main model
+        $this->name = $this->application->name;
+
+        // From related model
+        $this->isStatic = $this->application->settings->is_static;
+    }
+}
+```
+
+**Pattern 2: Custom Encoding/Decoding**
+```php
+public function syncData(bool $toModel = false): void
+{
+    if ($toModel) {
+        $this->validate();
+
+        // Encode before saving
+        $this->application->custom_labels = base64_encode($this->customLabels);
+        $this->application->save();
+    } else {
+        // Decode when loading
+        $this->customLabels = $this->application->parseContainerLabels();
+    }
+}
+```
+
+**Pattern 3: Error Rollback**
+```php
+public function submit()
+{
+    $this->authorize('update', $this->resource);
+    $original = $this->model->getOriginal();
+
+    try {
+        $this->syncData(toModel: true);
+        $this->dispatch('success', 'Saved successfully.');
+    } catch (\Throwable $e) {
+        // Rollback on error
+        $this->model->setRawAttributes($original);
+        $this->model->save();
+        $this->syncData(); // Reload from model
+        return handleError($e, $this);
+    }
+}
+```
+
+#### Property Type Patterns
+
+**Required Strings**
+```php
+#[Validate(['string', 'required'])]
+public string $name;  // No ?, no default, always has value
+```
+
+**Nullable Strings**
+```php
+#[Validate(['string', 'nullable'])]
+public ?string $description = null;  // ?, = null, can be empty
+```
+
+**Booleans**
+```php
+#[Validate(['boolean'])]
+public bool $isEnabled = false;  // Always has default value
+```
+
+**Integers with Constraints**
+```php
+#[Validate(['integer', 'min:1'])]
+public int $timeout;  // Required
+
+#[Validate(['integer', 'min:1', 'nullable'])]
+public ?int $port = null;  // Nullable
+```
+
+#### Testing Checklist
+
+After creating a new component with syncData(), verify:
+
+- [ ] All checkboxes save correctly (especially `instantSave` ones)
+- [ ] All form inputs persist to database
+- [ ] Custom encoded fields (like labels) display correctly if applicable
+- [ ] Form validation works for all fields
+- [ ] No console errors in browser
+- [ ] Authorization checks work (`@can` directives and `authorize()` calls)
+- [ ] Error rollback works if exceptions occur
+- [ ] Related models save correctly if applicable (e.g., Application + ApplicationSetting)
+
+#### Common Pitfalls to Avoid
+
+1. **snake_case in component properties**: Always use camelCase for component properties (e.g., `$gitRepository` not `$git_repository`)
+2. **Missing #[Validate] attributes**: Every property should have validation attributes for type safety
+3. **Forgetting to call syncData()**: Must call `syncData()` in `mount()` to load initial data
+4. **Missing authorization**: Always use `authorize()` in methods and `canGate`/`canResource` in views
+5. **View binding mismatch**: Use camelCase in Blade (e.g., `id="gitRepository"` not `id="git_repository"`)
+6. **wire:model vs wire:model.live**: Use `.live` for `instantSave` checkboxes to avoid timing issues
+7. **Validation sync**: If using `rules()` method, keep it in sync with `#[Validate]` attributes
+8. **Related models**: Don't forget to save both main and related models in syncData() method
+
 ### Livewire Forms
 ```php
 class ServerCreateForm extends Component
 {
     public $name;
     public $ip;
-    
+
     protected $rules = [
         'name' => 'required|min:3',
         'ip' => 'required|ip',
     ];
-    
+
     public function save()
     {
         $this->validate();

.github/workflows/chore-lock-closed-issues-discussions-and-prs.yml

@@ -4,6 +4,11 @@ on:
   schedule:
     - cron: '0 1 * * *'
 
+permissions:
+  issues: write
+  discussions: write
+  pull-requests: write
+
 jobs:
   lock-threads:
     runs-on: ubuntu-latest
@@ -13,5 +18,5 @@ jobs:
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           issue-inactive-days: '30'
-          pr-inactive-days: '30'
           discussion-inactive-days: '30'
+          pr-inactive-days: '30'

.github/workflows/chore-manage-stale-issues-and-prs.yml

@@ -4,6 +4,10 @@ on:
   schedule:
     - cron: '0 2 * * *'
 
+permissions:
+  issues: write
+  pull-requests: write
+
 jobs:
   manage-stale:
     runs-on: ubuntu-latest

.github/workflows/chore-pr-comments.yml

@@ -3,20 +3,13 @@ on:
   pull_request_target:
     types:
       - labeled
+
+permissions:
+  pull-requests: write
+
 jobs:
   add-comment:
     runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-      contents: read
-      actions: none
-      checks: none
-      deployments: none
-      issues: none
-      packages: none
-      repository-projects: none
-      security-events: none
-      statuses: none
     strategy:
       matrix:
         include:

.github/workflows/chore-remove-labels-and-assignees-on-close.yml

@@ -8,6 +8,10 @@ on:
   pull_request_target:
     types: [closed]
 
+permissions:
+  issues: write
+  pull-requests: write
+
 jobs:
   remove-labels-and-assignees:
     runs-on: ubuntu-latest

.github/workflows/claude-code-review.yml

@@ -1,79 +0,0 @@
-name: Claude Code Review
-
-on:
-  pull_request:
-    types: [opened, synchronize]
-    # Optional: Only run on specific file changes
-    # paths:
-    #   - "src/**/*.ts"
-    #   - "src/**/*.tsx"
-    #   - "src/**/*.js"
-    #   - "src/**/*.jsx"
-
-jobs:
-  claude-review:
-    if: false
-    # Optional: Filter by PR author
-    # if: |
-    #   github.event.pull_request.user.login == 'external-contributor' ||
-    #   github.event.pull_request.user.login == 'new-developer' ||
-    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
-    
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: read
-      issues: read
-      id-token: write
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
-
-      - name: Run Claude Code Review
-        id: claude-review
-        uses: anthropics/claude-code-action@beta
-        with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-
-          # Optional: Specify model (defaults to Claude Sonnet 4, uncomment for Claude Opus 4.1)
-          # model: "claude-opus-4-1-20250805"
-
-          # Direct prompt for automated review (no @claude mention needed)
-          direct_prompt: |
-            Please review this pull request and provide feedback on:
-            - Code quality and best practices
-            - Potential bugs or issues
-            - Performance considerations
-            - Security concerns
-            - Test coverage
-            
-            Be constructive and helpful in your feedback.
-
-          # Optional: Use sticky comments to make Claude reuse the same comment on subsequent pushes to the same PR
-          # use_sticky_comment: true
-          
-          # Optional: Customize review based on file types
-          # direct_prompt: |
-          #   Review this PR focusing on:
-          #   - For TypeScript files: Type safety and proper interface usage
-          #   - For API endpoints: Security, input validation, and error handling
-          #   - For React components: Performance, accessibility, and best practices
-          #   - For tests: Coverage, edge cases, and test quality
-          
-          # Optional: Different prompts for different authors
-          # direct_prompt: |
-          #   ${{ github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR' && 
-          #   'Welcome! Please review this PR from a first-time contributor. Be encouraging and provide detailed explanations for any suggestions.' ||
-          #   'Please provide a thorough code review focusing on our coding standards and best practices.' }}
-          
-          # Optional: Add specific tools for running tests or linting
-          # allowed_tools: "Bash(npm run test),Bash(npm run lint),Bash(npm run typecheck)"
-          
-          # Optional: Skip review for certain conditions
-          # if: |
-          #   !contains(github.event.pull_request.title, '[skip-review]') &&
-          #   !contains(github.event.pull_request.title, '[WIP]')
-

.github/workflows/claude.yml

@@ -1,65 +0,0 @@
-name: Claude Code
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_review_comment:
-    types: [created]
-  issues:
-    types: [opened, assigned]
-  pull_request_review:
-    types: [submitted]
-
-jobs:
-  claude:
-    if: |
-      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
-      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
-      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
-      (github.event_name == 'issues' && github.event.action == 'labeled' && github.event.label.name == 'Claude') ||
-      (github.event_name == 'pull_request' && github.event.action == 'labeled' && github.event.label.name == 'Claude') ||
-      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: read
-      issues: read
-      id-token: write
-      actions: read # Required for Claude to read CI results on PRs
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
-
-      - name: Run Claude Code
-        id: claude
-        uses: anthropics/claude-code-action@v1
-        with:
-          anthropic_api_key: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-
-          # This is an optional setting that allows Claude to read CI results on PRs
-          additional_permissions: |
-            actions: read
-          
-          # Optional: Specify model (defaults to Claude Sonnet 4, uncomment for Claude Opus 4.1)
-          # model: "claude-opus-4-1-20250805"
-          
-          # Optional: Customize the trigger phrase (default: @claude)
-          # trigger_phrase: "/claude"
-          
-          # Optional: Trigger when specific user is assigned to an issue
-          # assignee_trigger: "claude-bot"
-          
-          # Optional: Allow Claude to run specific commands
-          # allowed_tools: "Bash(npm install),Bash(npm run build),Bash(npm run test:*),Bash(npm run lint:*)"
-          
-          # Optional: Add custom instructions for Claude to customize its behavior for your project
-          # custom_instructions: |
-          #   Follow our coding standards
-          #   Ensure all new code has tests
-          #   Use TypeScript for new files
-          
-          # Optional: Custom environment variables for Claude
-          # claude_env: |
-          #   NODE_ENV: test

.github/workflows/cleanup-ghcr-untagged.yml

@@ -1,17 +1,14 @@
 name: Cleanup Untagged GHCR Images
 
 on:
-  workflow_dispatch: # Manual trigger only
+  workflow_dispatch:
 
-env:
-  GITHUB_REGISTRY: ghcr.io
+permissions:
+  packages: write
 
 jobs:
   cleanup-all-packages:
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
     strategy:
       matrix:
         package: ['coolify', 'coolify-helper', 'coolify-realtime', 'coolify-testing-host']

.github/workflows/coolify-helper-next.yml

@@ -7,19 +7,31 @@ on:
       - .github/workflows/coolify-helper-next.yml
       - docker/coolify-helper/Dockerfile
 
+permissions:
+  contents: read
+  packages: write
+
 env:
   GITHUB_REGISTRY: ghcr.io
   DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-helper"
 
 jobs:
-  amd64:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
+  build-push:
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            platform: linux/amd64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            platform: linux/aarch64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
@@ -40,66 +52,27 @@ jobs:
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getHelperVersion.php)"|xargs >> $GITHUB_OUTPUT
 
-      - name: Build and Push Image
+      - name: Build and Push Image (${{ matrix.arch }})
         uses: docker/build-push-action@v6
         with:
           context: .
           file: docker/coolify-helper/Dockerfile
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
-          labels: |
-            coolify.managed=true
-  aarch64:
-    runs-on: [ self-hosted, arm64 ]
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Login to ${{ env.GITHUB_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GITHUB_REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-
-      - name: Login to ${{ env.DOCKER_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.DOCKER_REGISTRY }}
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_TOKEN }}
-
-      - name: Get Version
-        id: version
-        run: |
-          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getHelperVersion.php)"|xargs >> $GITHUB_OUTPUT
-
-      - name: Build and Push Image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: docker/coolify-helper/Dockerfile
-          platforms: linux/aarch64
-          push: true
-          tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-${{ matrix.arch }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-${{ matrix.arch }}
           labels: |
             coolify.managed=true
 
   merge-manifest:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    needs: [ amd64, aarch64 ]
+    runs-on: ubuntu-24.04
+    needs: build-push
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+
       - uses: docker/setup-buildx-action@v3
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
@@ -124,14 +97,16 @@ jobs:
       - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-amd64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:next
 
       - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-amd64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:next
 

.github/workflows/coolify-helper.yml

@@ -7,19 +7,31 @@ on:
       - .github/workflows/coolify-helper.yml
       - docker/coolify-helper/Dockerfile
 
+permissions:
+  contents: read
+  packages: write
+
 env:
   GITHUB_REGISTRY: ghcr.io
   DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-helper"
 
 jobs:
-  amd64:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
+  build-push:
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            platform: linux/amd64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            platform: linux/aarch64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
@@ -40,65 +52,25 @@ jobs:
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getHelperVersion.php)"|xargs >> $GITHUB_OUTPUT
 
-      - name: Build and Push Image
+      - name: Build and Push Image (${{ matrix.arch }})
         uses: docker/build-push-action@v6
         with:
           context: .
           file: docker/coolify-helper/Dockerfile
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
-          labels: |
-            coolify.managed=true
-  aarch64:
-    runs-on: [ self-hosted, arm64 ]
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Login to ${{ env.GITHUB_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GITHUB_REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-
-      - name: Login to ${{ env.DOCKER_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.DOCKER_REGISTRY }}
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_TOKEN }}
-
-      - name: Get Version
-        id: version
-        run: |
-          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getHelperVersion.php)"|xargs >> $GITHUB_OUTPUT
-
-      - name: Build and Push Image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: docker/coolify-helper/Dockerfile
-          platforms: linux/aarch64
-          push: true
-          tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-${{ matrix.arch }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-${{ matrix.arch }}
           labels: |
             coolify.managed=true
   merge-manifest:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    needs: [ amd64, aarch64 ]
+    runs-on: ubuntu-24.04
+    needs: build-push
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - uses: docker/setup-buildx-action@v3
 
@@ -124,14 +96,16 @@ jobs:
       - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-amd64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
 
       - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-amd64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
 

.github/workflows/coolify-production-build.yml

@@ -14,16 +14,31 @@ on:
       - templates/**
       - CHANGELOG.md
 
+permissions:
+  contents: read
+  packages: write
+
 env:
   GITHUB_REGISTRY: ghcr.io
   DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify"
 
 jobs:
-  amd64:
-    runs-on: ubuntu-latest
+  build-push:
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            platform: linux/amd64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            platform: linux/aarch64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
@@ -44,60 +59,24 @@ jobs:
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getVersion.php)"|xargs >> $GITHUB_OUTPUT
 
-      - name: Build and Push Image
+      - name: Build and Push Image (${{ matrix.arch }})
         uses: docker/build-push-action@v6
         with:
           context: .
           file: docker/production/Dockerfile
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
-
-  aarch64:
-    runs-on: [self-hosted, arm64]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Login to ${{ env.GITHUB_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GITHUB_REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-
-      - name: Login to ${{ env.DOCKER_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.DOCKER_REGISTRY }}
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_TOKEN }}
-
-      - name: Get Version
-        id: version
-        run: |
-          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getVersion.php)"|xargs >> $GITHUB_OUTPUT
-
-      - name: Build and Push Image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: docker/production/Dockerfile
-          platforms: linux/aarch64
-          push: true
-          tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-${{ matrix.arch }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-${{ matrix.arch }}
 
   merge-manifest:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    needs: [amd64, aarch64]
+    runs-on: ubuntu-24.04
+    needs: build-push
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - uses: docker/setup-buildx-action@v3
 
@@ -123,14 +102,16 @@ jobs:
       - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-amd64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
 
       - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-amd64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
 

.github/workflows/coolify-realtime-next.yml

@@ -11,19 +11,31 @@ on:
       - docker/coolify-realtime/package-lock.json
       - docker/coolify-realtime/soketi-entrypoint.sh
 
+permissions:
+  contents: read
+  packages: write
+
 env:
   GITHUB_REGISTRY: ghcr.io
   DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-realtime"
 
 jobs:
-  amd64:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
+  build-push:
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            platform: linux/amd64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            platform: linux/aarch64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
@@ -44,67 +56,26 @@ jobs:
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getRealtimeVersion.php)"|xargs >> $GITHUB_OUTPUT
 
-      - name: Build and Push Image
+      - name: Build and Push Image (${{ matrix.arch }})
         uses: docker/build-push-action@v6
         with:
           context: .
           file: docker/coolify-realtime/Dockerfile
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next
-          labels: |
-            coolify.managed=true
-
-  aarch64:
-    runs-on: [ self-hosted, arm64 ]
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Login to ${{ env.GITHUB_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GITHUB_REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-
-      - name: Login to ${{ env.DOCKER_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.DOCKER_REGISTRY }}
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_TOKEN }}
-
-      - name: Get Version
-        id: version
-        run: |
-          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getRealtimeVersion.php)"|xargs >> $GITHUB_OUTPUT
-
-      - name: Build and Push Image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: docker/coolify-realtime/Dockerfile
-          platforms: linux/aarch64
-          push: true
-          tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-${{ matrix.arch }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-${{ matrix.arch }}
           labels: |
             coolify.managed=true
 
   merge-manifest:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    needs: [ amd64, aarch64 ]
+    runs-on: ubuntu-24.04
+    needs: build-push
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - uses: docker/setup-buildx-action@v3
 
@@ -130,14 +101,16 @@ jobs:
       - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-amd64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:next
 
       - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-amd64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next-aarch64 \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-next \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:next
 

.github/workflows/coolify-realtime.yml

@@ -11,19 +11,31 @@ on:
       - docker/coolify-realtime/package-lock.json
       - docker/coolify-realtime/soketi-entrypoint.sh
 
+permissions:
+  contents: read
+  packages: write
+
 env:
   GITHUB_REGISTRY: ghcr.io
   DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-realtime"
 
 jobs:
-  amd64:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
+  build-push:
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            platform: linux/amd64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            platform: linux/aarch64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
@@ -44,67 +56,26 @@ jobs:
         run: |
           echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getRealtimeVersion.php)"|xargs >> $GITHUB_OUTPUT
 
-      - name: Build and Push Image
+      - name: Build and Push Image (${{ matrix.arch }})
         uses: docker/build-push-action@v6
         with:
           context: .
           file: docker/coolify-realtime/Dockerfile
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
-          labels: |
-            coolify.managed=true
-
-  aarch64:
-    runs-on: [ self-hosted, arm64 ]
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Login to ${{ env.GITHUB_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GITHUB_REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-
-      - name: Login to ${{ env.DOCKER_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.DOCKER_REGISTRY }}
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_TOKEN }}
-
-      - name: Get Version
-        id: version
-        run: |
-          echo "VERSION=$(docker run --rm -v "$(pwd):/app" -w /app php:8.2-alpine3.16 php bootstrap/getRealtimeVersion.php)"|xargs >> $GITHUB_OUTPUT
-
-      - name: Build and Push Image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: docker/coolify-realtime/Dockerfile
-          platforms: linux/aarch64
-          push: true
-          tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-${{ matrix.arch }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-${{ matrix.arch }}
           labels: |
             coolify.managed=true
 
   merge-manifest:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    needs: [ amd64, aarch64 ]
+    runs-on: ubuntu-24.04
+    needs: build-push
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - uses: docker/setup-buildx-action@v3
 
@@ -130,14 +101,16 @@ jobs:
       - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-amd64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
 
       - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-amd64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}-aarch64 \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }} \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
 

.github/workflows/coolify-staging-build.yml

@@ -17,6 +17,10 @@ on:
         - templates/**
         - CHANGELOG.md
 
+permissions:
+  contents: read
+  packages: write
+
 env:
   GITHUB_REGISTRY: ghcr.io
   DOCKER_REGISTRY: docker.io
@@ -34,11 +38,10 @@ jobs:
             platform: linux/aarch64
             runner: ubuntu-24.04-arm
     runs-on: ${{ matrix.runner }}
-    permissions:
-      contents: read
-      packages: write
     steps:
       - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - name: Sanitize branch name for Docker tag
         id: sanitize
@@ -82,11 +85,10 @@ jobs:
   merge-manifest:
     runs-on: ubuntu-24.04
     needs: build-push
-    permissions:
-      contents: read
-      packages: write
     steps:
       - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - name: Sanitize branch name for Docker tag
         id: sanitize

.github/workflows/coolify-testing-host.yml

@@ -7,19 +7,31 @@ on:
       - .github/workflows/coolify-testing-host.yml
       - docker/testing-host/Dockerfile
 
+permissions:
+  contents: read
+  packages: write
+
 env:
   GITHUB_REGISTRY: ghcr.io
   DOCKER_REGISTRY: docker.io
   IMAGE_NAME: "coollabsio/coolify-testing-host"
 
 jobs:
-  amd64:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
+  build-push:
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            platform: linux/amd64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            platform: linux/aarch64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - name: Login to ${{ env.GITHUB_REGISTRY }}
         uses: docker/login-action@v3
@@ -35,62 +47,26 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_TOKEN }}
 
-      - name: Build and Push Image
+      - name: Build and Push Image (${{ matrix.arch }})
         uses: docker/build-push-action@v6
         with:
           context: .
           file: docker/testing-host/Dockerfile
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           push: true
           tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
-          labels: |
-            coolify.managed=true
-
-  aarch64:
-    runs-on: [ self-hosted, arm64 ]
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Login to ${{ env.GITHUB_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GITHUB_REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN  }}
-
-      - name: Login to ${{ env.DOCKER_REGISTRY }}
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.DOCKER_REGISTRY }}
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_TOKEN }}
-
-      - name: Build and Push Image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: docker/testing-host/Dockerfile
-          platforms: linux/aarch64
-          push: true
-          tags: |
-            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64
-            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64
+            ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-${{ matrix.arch }}
+            ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-${{ matrix.arch }}
           labels: |
             coolify.managed=true
 
   merge-manifest:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    needs: [ amd64, aarch64 ]
+    runs-on: ubuntu-24.04
+    needs: build-push
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
 
       - uses: docker/setup-buildx-action@v3
 
@@ -111,13 +87,15 @@ jobs:
       - name: Create & publish manifest on ${{ env.GITHUB_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-amd64 \
+          ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64 \
           --tag ${{ env.GITHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
 
       - name: Create & publish manifest on ${{ env.DOCKER_REGISTRY }}
         run: |
           docker buildx imagetools create \
-          --append ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-amd64 \
+          ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest-aarch64 \
           --tag ${{ env.DOCKER_REGISTRY }}/${{ env.IMAGE_NAME }}:latest
 
       - uses: sarisia/actions-status-discord@v1

.gitignore

@@ -37,3 +37,4 @@ scripts/load-test/*
 docker/coolify-realtime/node_modules
 .DS_Store
 CHANGELOG.md
+/.workspaces

README.md

@@ -69,7 +69,6 @@ ## Big Sponsors
 * [Dade2](https://dade2.net/?ref=coolify.io) - IT Consulting, Cloud Solutions & System Integration
 * [Formbricks](https://formbricks.com?ref=coolify.io) - The open source feedback platform
 * [GoldenVM](https://billing.goldenvm.com?ref=coolify.io) - Premium virtual machine hosting solutions
-* [Gozunga](https://gozunga.com?ref=coolify.io) - Seriously Simple Cloud Infrastructure
 * [Hetzner](http://htznr.li/CoolifyXHetzner) - Server, cloud, hosting, and data center solutions
 * [Hostinger](https://www.hostinger.com/vps/coolify-hosting?ref=coolify.io) - Web hosting and VPS solutions
 * [JobsCollider](https://jobscollider.com/remote-jobs?ref=coolify.io) - 30,000+ remote jobs for developers

app/Actions/Database/StartClickhouse.php

@@ -105,7 +105,7 @@ public function handle(StandaloneClickhouse $database)
         $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
         $this->commands[] = "echo 'Pulling {$database->image} image.'";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
-        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker stop --time=10 $container_name 2>/dev/null || true";
         $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";

app/Actions/Database/StartDragonfly.php

@@ -192,7 +192,7 @@ public function handle(StandaloneDragonfly $database)
         if ($this->database->enable_ssl) {
             $this->commands[] = "chown -R 999:999 $this->configuration_dir/ssl/server.key $this->configuration_dir/ssl/server.crt";
         }
-        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker stop --time=10 $container_name 2>/dev/null || true";
         $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";

app/Actions/Database/StartKeydb.php

@@ -208,7 +208,7 @@ public function handle(StandaloneKeydb $database)
         if ($this->database->enable_ssl) {
             $this->commands[] = "chown -R 999:999 $this->configuration_dir/ssl/server.key $this->configuration_dir/ssl/server.crt";
         }
-        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker stop --time=10 $container_name 2>/dev/null || true";
         $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";

app/Actions/Database/StartMariadb.php

@@ -209,7 +209,7 @@ public function handle(StandaloneMariadb $database)
         $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
         $this->commands[] = "echo 'Pulling {$database->image} image.'";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
-        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker stop --time=10 $container_name 2>/dev/null || true";
         $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";

app/Actions/Database/StartMongodb.php

@@ -260,7 +260,7 @@ public function handle(StandaloneMongodb $database)
         $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
         $this->commands[] = "echo 'Pulling {$database->image} image.'";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
-        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker stop --time=10 $container_name 2>/dev/null || true";
         $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         if ($this->database->enable_ssl) {

app/Actions/Database/StartMysql.php

@@ -210,7 +210,7 @@ public function handle(StandaloneMysql $database)
         $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
         $this->commands[] = "echo 'Pulling {$database->image} image.'";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
-        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker stop --time=10 $container_name 2>/dev/null || true";
         $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
 

app/Actions/Database/StartPostgresql.php

@@ -223,7 +223,7 @@ public function handle(StandalonePostgresql $database)
         $this->commands[] = "echo '{$readme}' > $this->configuration_dir/README.md";
         $this->commands[] = "echo 'Pulling {$database->image} image.'";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml pull";
-        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker stop --time=10 $container_name 2>/dev/null || true";
         $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         if ($this->database->enable_ssl) {
@@ -231,8 +231,6 @@ public function handle(StandalonePostgresql $database)
         }
         $this->commands[] = "echo 'Database started.'";
 
-        ray($this->commands);
-
         return remote_process($this->commands, $database->destination->server, callEventOnFinish: 'DatabaseStatusChanged');
     }
 

app/Actions/Database/StartRedis.php

@@ -205,7 +205,7 @@ public function handle(StandaloneRedis $database)
         if ($this->database->enable_ssl) {
             $this->commands[] = "chown -R 999:999 $this->configuration_dir/ssl/server.key $this->configuration_dir/ssl/server.crt";
         }
-        $this->commands[] = "docker stop --timeout=10 $container_name 2>/dev/null || true";
+        $this->commands[] = "docker stop --time=10 $container_name 2>/dev/null || true";
         $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
         $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
         $this->commands[] = "echo 'Database started.'";

app/Actions/Database/StopDatabase.php

@@ -49,7 +49,7 @@ private function stopContainer($database, string $containerName, int $timeout =
     {
         $server = $database->destination->server;
         instant_remote_process(command: [
-            "docker stop --timeout=$timeout $containerName",
+            "docker stop --time=$timeout $containerName",
             "docker rm -f $containerName",
         ], server: $server, throwError: false);
     }

app/Actions/Docker/GetContainersStatus.php

@@ -10,6 +10,7 @@
 use App\Models\ServiceDatabase;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
 use Lorisleiva\Actions\Concerns\AsAction;
 
 class GetContainersStatus
@@ -28,6 +29,8 @@ class GetContainersStatus
 
     protected ?Collection $applicationContainerStatuses;
 
+    protected ?Collection $applicationContainerRestartCounts;
+
     public function handle(Server $server, ?Collection $containers = null, ?Collection $containerReplicates = null)
     {
         $this->containers = $containers;
@@ -136,6 +139,18 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
                         if ($containerName) {
                             $this->applicationContainerStatuses->get($applicationId)->put($containerName, $containerStatus);
                         }
+
+                        // Track restart counts for applications
+                        $restartCount = data_get($container, 'RestartCount', 0);
+                        if (! isset($this->applicationContainerRestartCounts)) {
+                            $this->applicationContainerRestartCounts = collect();
+                        }
+                        if (! $this->applicationContainerRestartCounts->has($applicationId)) {
+                            $this->applicationContainerRestartCounts->put($applicationId, collect());
+                        }
+                        if ($containerName) {
+                            $this->applicationContainerRestartCounts->get($applicationId)->put($containerName, $restartCount);
+                        }
                     } else {
                         // Notify user that this container should not be there.
                     }
@@ -291,7 +306,24 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
                 continue;
             }
 
-            $application->update(['status' => 'exited']);
+            // If container was recently restarting (crash loop), keep it as degraded for a grace period
+            // This prevents false "exited" status during the brief moment between container removal and recreation
+            $recentlyRestarted = $application->restart_count > 0 &&
+                                 $application->last_restart_at &&
+                                 $application->last_restart_at->greaterThan(now()->subSeconds(30));
+
+            if ($recentlyRestarted) {
+                // Keep it as degraded if it was recently in a crash loop
+                $application->update(['status' => 'degraded (unhealthy)']);
+            } else {
+                // Reset restart count when application exits completely
+                $application->update([
+                    'status' => 'exited',
+                    'restart_count' => 0,
+                    'last_restart_at' => null,
+                    'last_restart_type' => null,
+                ]);
+            }
         }
         $notRunningApplicationPreviews = $previews->pluck('id')->diff($foundApplicationPreviews);
         foreach ($notRunningApplicationPreviews as $previewId) {
@@ -340,22 +372,56 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
                     continue;
                 }
 
-                $aggregatedStatus = $this->aggregateApplicationStatus($application, $containerStatuses);
-                if ($aggregatedStatus) {
-                    $statusFromDb = $application->status;
-                    if ($statusFromDb !== $aggregatedStatus) {
-                        $application->update(['status' => $aggregatedStatus]);
-                    } else {
-                        $application->update(['last_online_at' => now()]);
-                    }
+                // Track restart counts first
+                $maxRestartCount = 0;
+                if (isset($this->applicationContainerRestartCounts) && $this->applicationContainerRestartCounts->has($applicationId)) {
+                    $containerRestartCounts = $this->applicationContainerRestartCounts->get($applicationId);
+                    $maxRestartCount = $containerRestartCounts->max() ?? 0;
                 }
+
+                // Wrap all database updates in a transaction to ensure consistency
+                DB::transaction(function () use ($application, $maxRestartCount, $containerStatuses) {
+                    $previousRestartCount = $application->restart_count ?? 0;
+
+                    if ($maxRestartCount > $previousRestartCount) {
+                        // Restart count increased - this is a crash restart
+                        $application->update([
+                            'restart_count' => $maxRestartCount,
+                            'last_restart_at' => now(),
+                            'last_restart_type' => 'crash',
+                        ]);
+
+                        // Send notification
+                        $containerName = $application->name;
+                        $projectUuid = data_get($application, 'environment.project.uuid');
+                        $environmentName = data_get($application, 'environment.name');
+                        $applicationUuid = data_get($application, 'uuid');
+
+                        if ($projectUuid && $applicationUuid && $environmentName) {
+                            $url = base_url().'/project/'.$projectUuid.'/'.$environmentName.'/application/'.$applicationUuid;
+                        } else {
+                            $url = null;
+                        }
+                    }
+
+                    // Aggregate status after tracking restart counts
+                    $aggregatedStatus = $this->aggregateApplicationStatus($application, $containerStatuses, $maxRestartCount);
+                    if ($aggregatedStatus) {
+                        $statusFromDb = $application->status;
+                        if ($statusFromDb !== $aggregatedStatus) {
+                            $application->update(['status' => $aggregatedStatus]);
+                        } else {
+                            $application->update(['last_online_at' => now()]);
+                        }
+                    }
+                });
             }
         }
 
         ServiceChecked::dispatch($this->server->team->id);
     }
 
-    private function aggregateApplicationStatus($application, Collection $containerStatuses): ?string
+    private function aggregateApplicationStatus($application, Collection $containerStatuses, int $maxRestartCount = 0): ?string
     {
         // Parse docker compose to check for excluded containers
         $dockerComposeRaw = data_get($application, 'docker_compose_raw');
@@ -413,6 +479,11 @@ private function aggregateApplicationStatus($application, Collection $containerS
             return 'degraded (unhealthy)';
         }
 
+        // If container is exited but has restart count > 0, it's in a crash loop
+        if ($hasExited && $maxRestartCount > 0) {
+            return 'degraded (unhealthy)';
+        }
+
         if ($hasRunning && $hasExited) {
             return 'degraded (unhealthy)';
         }
@@ -421,7 +492,7 @@ private function aggregateApplicationStatus($application, Collection $containerS
             return $hasUnhealthy ? 'running (unhealthy)' : 'running (healthy)';
         }
 
-        // All containers are exited
+        // All containers are exited with no restart count - truly stopped
         return 'exited (unhealthy)';
     }
 }

app/Actions/Server/CleanupDocker.php

@@ -20,7 +20,7 @@ public function handle(Server $server, bool $deleteUnusedVolumes = false, bool $
         $realtimeImageWithoutPrefix = 'coollabsio/coolify-realtime';
         $realtimeImageWithoutPrefixVersion = "coollabsio/coolify-realtime:$realtimeImageVersion";
 
-        $helperImageVersion = data_get($settings, 'helper_version');
+        $helperImageVersion = getHelperVersion();
         $helperImage = config('constants.coolify.helper_image');
         $helperImageWithVersion = "$helperImage:$helperImageVersion";
         $helperImageWithoutPrefix = 'coollabsio/coolify-helper';

app/Actions/Service/StartService.php

@@ -20,18 +20,23 @@ public function handle(Service $service, bool $pullLatestImages = false, bool $s
         }
         $service->saveComposeConfigs();
         $service->isConfigurationChanged(save: true);
-        $commands[] = 'cd '.$service->workdir();
-        $commands[] = "echo 'Saved configuration files to {$service->workdir()}.'";
+        $workdir = $service->workdir();
+        // $commands[] = "cd {$workdir}";
+        $commands[] = "echo 'Saved configuration files to {$workdir}.'";
+        // Ensure .env exists in the correct directory before docker compose tries to load it
+        // This is defensive programming - saveComposeConfigs() already creates it,
+        // but we guarantee it here in case of any edge cases or manual deployments
+        $commands[] = "touch {$workdir}/.env";
         if ($pullLatestImages) {
             $commands[] = "echo 'Pulling images.'";
-            $commands[] = 'docker compose pull';
+            $commands[] = "docker compose --project-directory {$workdir} pull";
         }
         if ($service->networks()->count() > 0) {
             $commands[] = "echo 'Creating Docker network.'";
             $commands[] = "docker network inspect $service->uuid >/dev/null 2>&1 || docker network create --attachable $service->uuid";
         }
         $commands[] = 'echo Starting service.';
-        $commands[] = 'docker compose up -d --remove-orphans --force-recreate --build';
+        $commands[] = "docker compose --project-directory {$workdir} -f {$workdir}/docker-compose.yml --project-name {$service->uuid} up -d --remove-orphans --force-recreate --build";
         $commands[] = "docker network connect $service->uuid coolify-proxy >/dev/null 2>&1 || true";
         if (data_get($service, 'connect_to_docker_network')) {
             $compose = data_get($service, 'docker_compose', []);

app/Console/Commands/CleanupRedis.php

@@ -7,7 +7,7 @@
 
 class CleanupRedis extends Command
 {
-    protected $signature = 'cleanup:redis {--dry-run : Show what would be deleted without actually deleting} {--skip-overlapping : Skip overlapping queue cleanup} {--clear-locks : Clear stale WithoutOverlapping locks}';
+    protected $signature = 'cleanup:redis {--dry-run : Show what would be deleted without actually deleting} {--skip-overlapping : Skip overlapping queue cleanup} {--clear-locks : Clear stale WithoutOverlapping locks} {--restart : Aggressive cleanup mode for system restart (marks all processing jobs as failed)}';
 
     protected $description = 'Cleanup Redis (Horizon jobs, metrics, overlapping queues, cache locks, and related data)';
 
@@ -63,6 +63,14 @@ public function handle()
             $deletedCount += $locksCleaned;
         }
 
+        // Clean up stuck jobs (restart mode = aggressive, runtime mode = conservative)
+        $isRestart = $this->option('restart');
+        if ($isRestart || $this->option('clear-locks')) {
+            $this->info($isRestart ? 'Cleaning up stuck jobs (RESTART MODE - aggressive)...' : 'Checking for stuck jobs (runtime mode - conservative)...');
+            $jobsCleaned = $this->cleanupStuckJobs($redis, $prefix, $dryRun, $isRestart);
+            $deletedCount += $jobsCleaned;
+        }
+
         if ($dryRun) {
             $this->info("DRY RUN: Would delete {$deletedCount} out of {$totalKeys} keys");
         } else {
@@ -332,4 +340,130 @@ private function cleanupCacheLocks(bool $dryRun): int
 
         return $cleanedCount;
     }
+
+    /**
+     * Clean up stuck jobs based on mode (restart vs runtime).
+     *
+     * @param  mixed  $redis  Redis connection
+     * @param  string  $prefix  Horizon prefix
+     * @param  bool  $dryRun  Dry run mode
+     * @param  bool  $isRestart  Restart mode (aggressive) vs runtime mode (conservative)
+     * @return int Number of jobs cleaned
+     */
+    private function cleanupStuckJobs($redis, string $prefix, bool $dryRun, bool $isRestart): int
+    {
+        $cleanedCount = 0;
+        $now = time();
+
+        // Get all keys with the horizon prefix
+        $cursor = 0;
+        $keys = [];
+        do {
+            $result = $redis->scan($cursor, ['match' => '*', 'count' => 100]);
+
+            // Guard against scan() returning false
+            if ($result === false) {
+                $this->error('Redis scan failed, stopping key retrieval');
+                break;
+            }
+
+            $cursor = $result[0];
+            $keys = array_merge($keys, $result[1]);
+        } while ($cursor !== 0);
+
+        foreach ($keys as $key) {
+            $keyWithoutPrefix = str_replace($prefix, '', $key);
+            $type = $redis->command('type', [$keyWithoutPrefix]);
+
+            // Only process hash-type keys (individual jobs)
+            if ($type !== 5) {
+                continue;
+            }
+
+            $data = $redis->command('hgetall', [$keyWithoutPrefix]);
+            $status = data_get($data, 'status');
+            $payload = data_get($data, 'payload');
+
+            // Only process jobs in "processing" or "reserved" state
+            if (! in_array($status, ['processing', 'reserved'])) {
+                continue;
+            }
+
+            // Parse job payload to get job class and started time
+            $payloadData = json_decode($payload, true);
+
+            // Check for JSON decode errors
+            if ($payloadData === null || json_last_error() !== JSON_ERROR_NONE) {
+                $errorMsg = json_last_error_msg();
+                $truncatedPayload = is_string($payload) ? substr($payload, 0, 200) : 'non-string payload';
+                $this->error("Failed to decode job payload for {$keyWithoutPrefix}: {$errorMsg}. Payload: {$truncatedPayload}");
+
+                continue;
+            }
+
+            $jobClass = data_get($payloadData, 'displayName', 'Unknown');
+
+            // Prefer reserved_at (when job started processing), fallback to created_at
+            $reservedAt = (int) data_get($data, 'reserved_at', 0);
+            $createdAt = (int) data_get($data, 'created_at', 0);
+            $startTime = $reservedAt ?: $createdAt;
+
+            // If we can't determine when the job started, skip it
+            if (! $startTime) {
+                continue;
+            }
+
+            // Calculate how long the job has been processing
+            $processingTime = $now - $startTime;
+
+            $shouldFail = false;
+            $reason = '';
+
+            if ($isRestart) {
+                // RESTART MODE: Mark ALL processing/reserved jobs as failed
+                // Safe because all workers are dead on restart
+                $shouldFail = true;
+                $reason = 'System restart - all workers terminated';
+            } else {
+                // RUNTIME MODE: Only mark truly stuck jobs as failed
+                // Be conservative to avoid killing legitimate long-running jobs
+
+                // Skip ApplicationDeploymentJob entirely (has dynamic_timeout, can run 2+ hours)
+                if (str_contains($jobClass, 'ApplicationDeploymentJob')) {
+                    continue;
+                }
+
+                // Skip DatabaseBackupJob (large backups can take hours)
+                if (str_contains($jobClass, 'DatabaseBackupJob')) {
+                    continue;
+                }
+
+                // For other jobs, only fail if processing > 12 hours
+                if ($processingTime > 43200) { // 12 hours
+                    $shouldFail = true;
+                    $reason = 'Processing for more than 12 hours';
+                }
+            }
+
+            if ($shouldFail) {
+                if ($dryRun) {
+                    $this->warn("  Would mark as FAILED: {$jobClass} (processing for ".round($processingTime / 60, 1)." min) - {$reason}");
+                } else {
+                    // Mark job as failed
+                    $redis->command('hset', [$keyWithoutPrefix, 'status', 'failed']);
+                    $redis->command('hset', [$keyWithoutPrefix, 'failed_at', $now]);
+                    $redis->command('hset', [$keyWithoutPrefix, 'exception', "Job cleaned up by cleanup:redis - {$reason}"]);
+
+                    $this->info("  ✓ Marked as FAILED: {$jobClass} (processing for ".round($processingTime / 60, 1).' min) - '.$reason);
+                }
+                $cleanedCount++;
+            }
+        }
+
+        if ($cleanedCount === 0) {
+            $this->info($isRestart ? '  No jobs to clean up' : '  No stuck jobs found (all jobs running normally)');
+        }
+
+        return $cleanedCount;
+    }
 }

app/Console/Commands/CleanupStuckedResources.php

@@ -222,9 +222,14 @@ private function cleanup_stucked_resources()
         try {
             $scheduled_backups = ScheduledDatabaseBackup::all();
             foreach ($scheduled_backups as $scheduled_backup) {
-                if (! $scheduled_backup->server()) {
-                    echo "Deleting stuck scheduledbackup: {$scheduled_backup->name}\n";
-                    $scheduled_backup->delete();
+                try {
+                    $server = $scheduled_backup->server();
+                    if (! $server) {
+                        echo "Deleting stuck scheduledbackup: {$scheduled_backup->name}\n";
+                        $scheduled_backup->delete();
+                    }
+                } catch (\Throwable $e) {
+                    echo "Error checking server for scheduledbackup {$scheduled_backup->id}: {$e->getMessage()}\n";
                 }
             }
         } catch (\Throwable $e) {
@@ -416,7 +421,7 @@ private function cleanup_stucked_resources()
             foreach ($serviceApplications as $service) {
                 if (! data_get($service, 'service')) {
                     echo 'ServiceApplication without service: '.$service->name.'\n';
-                    DeleteResourceJob::dispatch($service);
+                    $service->forceDelete();
 
                     continue;
                 }
@@ -429,7 +434,7 @@ private function cleanup_stucked_resources()
             foreach ($serviceDatabases as $service) {
                 if (! data_get($service, 'service')) {
                     echo 'ServiceDatabase without service: '.$service->name.'\n';
-                    DeleteResourceJob::dispatch($service);
+                    $service->forceDelete();
 
                     continue;
                 }

app/Console/Commands/Cloud/RestoreDatabase.php

@@ -0,0 +1,219 @@
+<?php
+
+namespace App\Console\Commands\Cloud;
+
+use Illuminate\Console\Command;
+
+class RestoreDatabase extends Command
+{
+    protected $signature = 'cloud:restore-database {file : Path to the database dump file} {--debug : Show detailed debug output}';
+
+    protected $description = 'Restore a PostgreSQL database from a dump file (development mode only)';
+
+    private bool $debug = false;
+
+    public function handle(): int
+    {
+        $this->debug = $this->option('debug');
+
+        if (! $this->isDevelopment()) {
+            $this->error('This command can only be run in development mode.');
+
+            return 1;
+        }
+
+        $filePath = $this->argument('file');
+
+        if (! file_exists($filePath)) {
+            $this->error("File not found: {$filePath}");
+
+            return 1;
+        }
+
+        if (! is_readable($filePath)) {
+            $this->error("File is not readable: {$filePath}");
+
+            return 1;
+        }
+
+        try {
+            $this->info('Starting database restoration...');
+
+            $database = config('database.connections.pgsql.database');
+            $host = config('database.connections.pgsql.host');
+            $port = config('database.connections.pgsql.port');
+            $username = config('database.connections.pgsql.username');
+            $password = config('database.connections.pgsql.password');
+
+            if (! $database || ! $username) {
+                $this->error('Database configuration is incomplete.');
+
+                return 1;
+            }
+
+            $this->info("Restoring to database: {$database}");
+
+            // Drop all tables
+            if (! $this->dropAllTables($database, $host, $port, $username, $password)) {
+                return 1;
+            }
+
+            // Restore the database dump
+            if (! $this->restoreDatabaseDump($filePath, $database, $host, $port, $username, $password)) {
+                return 1;
+            }
+
+            $this->info('Database restoration completed successfully!');
+
+            return 0;
+        } catch (\Exception $e) {
+            $this->error("An error occurred: {$e->getMessage()}");
+
+            return 1;
+        }
+    }
+
+    private function dropAllTables(string $database, string $host, string $port, string $username, string $password): bool
+    {
+        $this->info('Dropping all tables...');
+
+        // SQL to drop all tables
+        $dropTablesSQL = <<<'SQL'
+            DO $$ DECLARE
+                r RECORD;
+            BEGIN
+                FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public') LOOP
+                    EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.tablename) || ' CASCADE';
+                END LOOP;
+            END $$;
+            SQL;
+
+        // Build the psql command to drop all tables
+        $command = sprintf(
+            'PGPASSWORD=%s psql -h %s -p %s -U %s -d %s -c %s',
+            escapeshellarg($password),
+            escapeshellarg($host),
+            escapeshellarg($port),
+            escapeshellarg($username),
+            escapeshellarg($database),
+            escapeshellarg($dropTablesSQL)
+        );
+
+        if ($this->debug) {
+            $this->line('<comment>Executing drop command:</comment>');
+            $this->line($command);
+        }
+
+        $output = shell_exec($command.' 2>&1');
+
+        if ($this->debug) {
+            $this->line("<comment>Output:</comment> {$output}");
+        }
+
+        $this->info('All tables dropped successfully.');
+
+        return true;
+    }
+
+    private function restoreDatabaseDump(string $filePath, string $database, string $host, string $port, string $username, string $password): bool
+    {
+        $this->info('Restoring database from dump file...');
+
+        // Handle gzipped files by decompressing first
+        $actualFile = $filePath;
+        if (str_ends_with($filePath, '.gz')) {
+            $actualFile = rtrim($filePath, '.gz');
+            $this->info('Decompressing gzipped dump file...');
+
+            $decompressCommand = sprintf(
+                'gunzip -c %s > %s',
+                escapeshellarg($filePath),
+                escapeshellarg($actualFile)
+            );
+
+            if ($this->debug) {
+                $this->line('<comment>Executing decompress command:</comment>');
+                $this->line($decompressCommand);
+            }
+
+            $decompressOutput = shell_exec($decompressCommand.' 2>&1');
+            if ($this->debug && $decompressOutput) {
+                $this->line("<comment>Decompress output:</comment> {$decompressOutput}");
+            }
+        }
+
+        // Use pg_restore for custom format dumps
+        $command = sprintf(
+            'PGPASSWORD=%s pg_restore -h %s -p %s -U %s -d %s -v %s',
+            escapeshellarg($password),
+            escapeshellarg($host),
+            escapeshellarg($port),
+            escapeshellarg($username),
+            escapeshellarg($database),
+            escapeshellarg($actualFile)
+        );
+
+        if ($this->debug) {
+            $this->line('<comment>Executing restore command:</comment>');
+            $this->line($command);
+        }
+
+        // Execute the restore command
+        $process = proc_open(
+            $command,
+            [
+                1 => ['pipe', 'w'],
+                2 => ['pipe', 'w'],
+            ],
+            $pipes
+        );
+
+        if (! is_resource($process)) {
+            $this->error('Failed to start restoration process.');
+
+            return false;
+        }
+
+        $output = stream_get_contents($pipes[1]);
+        $error = stream_get_contents($pipes[2]);
+        $exitCode = proc_close($process);
+
+        // Clean up decompressed file if we created one
+        if ($actualFile !== $filePath && file_exists($actualFile)) {
+            unlink($actualFile);
+        }
+
+        if ($this->debug) {
+            if ($output) {
+                $this->line('<comment>Output:</comment>');
+                $this->line($output);
+            }
+            if ($error) {
+                $this->line('<comment>Error output:</comment>');
+                $this->line($error);
+            }
+            $this->line("<comment>Exit code:</comment> {$exitCode}");
+        }
+
+        if ($exitCode !== 0) {
+            $this->error("Restoration failed with exit code: {$exitCode}");
+            if ($error) {
+                $this->error('Error details:');
+                $this->error($error);
+            }
+
+            return false;
+        }
+
+        if ($output && ! $this->debug) {
+            $this->line($output);
+        }
+
+        return true;
+    }
+
+    private function isDevelopment(): bool
+    {
+        return app()->environment(['local', 'development', 'dev']);
+    }
+}

app/Console/Commands/Dev.php

@@ -4,6 +4,9 @@
 
 use App\Jobs\CheckHelperImageJob;
 use App\Models\InstanceSettings;
+use App\Models\ScheduledDatabaseBackupExecution;
+use App\Models\ScheduledTaskExecution;
+use Carbon\Carbon;
 use Illuminate\Console\Command;
 use Illuminate\Support\Facades\Artisan;
 
@@ -45,6 +48,44 @@ public function init()
         } else {
             echo "Instance already initialized.\n";
         }
+
+        // Clean up stuck jobs and stale locks on development startup
+        try {
+            echo "Cleaning up Redis (stuck jobs and stale locks)...\n";
+            Artisan::call('cleanup:redis', ['--restart' => true, '--clear-locks' => true]);
+            echo "Redis cleanup completed.\n";
+        } catch (\Throwable $e) {
+            echo "Error in cleanup:redis: {$e->getMessage()}\n";
+        }
+
+        try {
+            $updatedTaskCount = ScheduledTaskExecution::where('status', 'running')->update([
+                'status' => 'failed',
+                'message' => 'Marked as failed during Coolify startup - job was interrupted',
+                'finished_at' => Carbon::now(),
+            ]);
+
+            if ($updatedTaskCount > 0) {
+                echo "Marked {$updatedTaskCount} stuck scheduled task executions as failed\n";
+            }
+        } catch (\Throwable $e) {
+            echo "Could not cleanup stuck scheduled task executions: {$e->getMessage()}\n";
+        }
+
+        try {
+            $updatedBackupCount = ScheduledDatabaseBackupExecution::where('status', 'running')->update([
+                'status' => 'failed',
+                'message' => 'Marked as failed during Coolify startup - job was interrupted',
+                'finished_at' => Carbon::now(),
+            ]);
+
+            if ($updatedBackupCount > 0) {
+                echo "Marked {$updatedBackupCount} stuck database backup executions as failed\n";
+            }
+        } catch (\Throwable $e) {
+            echo "Could not cleanup stuck database backup executions: {$e->getMessage()}\n";
+        }
+
         CheckHelperImageJob::dispatch();
     }
 }

app/Console/Commands/Emails.php

@@ -167,7 +167,7 @@ public function handle()
                     ]);
                 }
                 $output = 'Because of an error, the backup of the database '.$db->name.' failed.';
-                $this->mail = (new BackupFailed($backup, $db, $output))->toMail();
+                $this->mail = (new BackupFailed($backup, $db, $output, $backup->database_name ?? 'unknown'))->toMail();
                 $this->sendEmail();
                 break;
             case 'backup-success':

app/Console/Commands/Init.php

@@ -10,9 +10,12 @@
 use App\Models\Environment;
 use App\Models\InstanceSettings;
 use App\Models\ScheduledDatabaseBackup;
+use App\Models\ScheduledDatabaseBackupExecution;
+use App\Models\ScheduledTaskExecution;
 use App\Models\Server;
 use App\Models\StandalonePostgresql;
 use App\Models\User;
+use Carbon\Carbon;
 use Illuminate\Console\Command;
 use Illuminate\Support\Facades\Artisan;
 use Illuminate\Support\Facades\File;
@@ -73,7 +76,7 @@ public function handle()
         $this->cleanupUnusedNetworkFromCoolifyProxy();
 
         try {
-            $this->call('cleanup:redis', ['--clear-locks' => true]);
+            $this->call('cleanup:redis', ['--restart' => true, '--clear-locks' => true]);
         } catch (\Throwable $e) {
             echo "Error in cleanup:redis command: {$e->getMessage()}\n";
         }
@@ -86,6 +89,7 @@ public function handle()
             $this->call('cleanup:stucked-resources');
         } catch (\Throwable $e) {
             echo "Error in cleanup:stucked-resources command: {$e->getMessage()}\n";
+            echo "Continuing with initialization - cleanup errors will not prevent Coolify from starting\n";
         }
         try {
             $updatedCount = ApplicationDeploymentQueue::whereIn('status', [
@@ -102,6 +106,34 @@ public function handle()
             echo "Could not cleanup inprogress deployments: {$e->getMessage()}\n";
         }
 
+        try {
+            $updatedTaskCount = ScheduledTaskExecution::where('status', 'running')->update([
+                'status' => 'failed',
+                'message' => 'Marked as failed during Coolify startup - job was interrupted',
+                'finished_at' => Carbon::now(),
+            ]);
+
+            if ($updatedTaskCount > 0) {
+                echo "Marked {$updatedTaskCount} stuck scheduled task executions as failed\n";
+            }
+        } catch (\Throwable $e) {
+            echo "Could not cleanup stuck scheduled task executions: {$e->getMessage()}\n";
+        }
+
+        try {
+            $updatedBackupCount = ScheduledDatabaseBackupExecution::where('status', 'running')->update([
+                'status' => 'failed',
+                'message' => 'Marked as failed during Coolify startup - job was interrupted',
+                'finished_at' => Carbon::now(),
+            ]);
+
+            if ($updatedBackupCount > 0) {
+                echo "Marked {$updatedBackupCount} stuck database backup executions as failed\n";
+            }
+        } catch (\Throwable $e) {
+            echo "Could not cleanup stuck database backup executions: {$e->getMessage()}\n";
+        }
+
         try {
             $localhost = $this->servers->where('id', 0)->first();
             if ($localhost) {

app/Console/Commands/SyncBunny.php

@@ -26,9 +26,9 @@ class SyncBunny extends Command
     protected $description = 'Sync files to BunnyCDN';
 
     /**
-     * Fetch GitHub releases and sync to CDN
+     * Fetch GitHub releases and sync to GitHub repository
      */
-    private function syncGitHubReleases($parent_dir, $bunny_cdn_storage_name, $bunny_cdn_path, $bunny_cdn)
+    private function syncReleasesToGitHubRepo(): bool
     {
         $this->info('Fetching releases from GitHub...');
         try {
@@ -37,33 +37,122 @@ private function syncGitHubReleases($parent_dir, $bunny_cdn_storage_name, $bunny
                     'per_page' => 30,  // Fetch more releases for better changelog
                 ]);
 
-            if ($response->successful()) {
-                $releases = $response->json();
-
-                // Save releases to a temporary file
-                $releases_file = "$parent_dir/releases.json";
-                file_put_contents($releases_file, json_encode($releases, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
-
-                // Upload to CDN
-                Http::pool(fn (Pool $pool) => [
-                    $pool->storage(fileName: $releases_file)->put("/$bunny_cdn_storage_name/$bunny_cdn_path/releases.json"),
-                    $pool->purge("$bunny_cdn/coolify/releases.json"),
-                ]);
-
-                // Clean up temporary file
-                unlink($releases_file);
-
-                $this->info('releases.json uploaded & purged...');
-                $this->info('Total releases synced: '.count($releases));
-
-                return true;
-            } else {
+            if (! $response->successful()) {
                 $this->error('Failed to fetch releases from GitHub: '.$response->status());
 
                 return false;
             }
+
+            $releases = $response->json();
+            $timestamp = time();
+            $tmpDir = sys_get_temp_dir().'/coolify-cdn-'.$timestamp;
+            $branchName = 'update-releases-'.$timestamp;
+
+            // Clone the repository
+            $this->info('Cloning coolify-cdn repository...');
+            exec('gh repo clone coollabsio/coolify-cdn '.escapeshellarg($tmpDir).' 2>&1', $output, $returnCode);
+            if ($returnCode !== 0) {
+                $this->error('Failed to clone repository: '.implode("\n", $output));
+
+                return false;
+            }
+
+            // Create feature branch
+            $this->info('Creating feature branch...');
+            exec('cd '.escapeshellarg($tmpDir).' && git checkout -b '.escapeshellarg($branchName).' 2>&1', $output, $returnCode);
+            if ($returnCode !== 0) {
+                $this->error('Failed to create branch: '.implode("\n", $output));
+                exec('rm -rf '.escapeshellarg($tmpDir));
+
+                return false;
+            }
+
+            // Write releases.json
+            $this->info('Writing releases.json...');
+            $releasesPath = "$tmpDir/json/releases.json";
+            $jsonContent = json_encode($releases, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
+            $bytesWritten = file_put_contents($releasesPath, $jsonContent);
+
+            if ($bytesWritten === false) {
+                $this->error("Failed to write releases.json to: $releasesPath");
+                $this->error('Possible reasons: directory does not exist, permission denied, or disk full.');
+                exec('rm -rf '.escapeshellarg($tmpDir));
+
+                return false;
+            }
+
+            // Stage and commit
+            $this->info('Committing changes...');
+            exec('cd '.escapeshellarg($tmpDir).' && git add json/releases.json 2>&1', $output, $returnCode);
+            if ($returnCode !== 0) {
+                $this->error('Failed to stage changes: '.implode("\n", $output));
+                exec('rm -rf '.escapeshellarg($tmpDir));
+
+                return false;
+            }
+
+            $this->info('Checking for changes...');
+            $statusOutput = [];
+            exec('cd '.escapeshellarg($tmpDir).' && git status --porcelain json/releases.json 2>&1', $statusOutput, $returnCode);
+            if ($returnCode !== 0) {
+                $this->error('Failed to check repository status: '.implode("\n", $statusOutput));
+                exec('rm -rf '.escapeshellarg($tmpDir));
+
+                return false;
+            }
+
+            if (empty(array_filter($statusOutput))) {
+                $this->info('Releases are already up to date. No changes to commit.');
+                exec('rm -rf '.escapeshellarg($tmpDir));
+
+                return true;
+            }
+
+            $commitMessage = 'Update releases.json with latest releases - '.date('Y-m-d H:i:s');
+            $output = [];
+            exec('cd '.escapeshellarg($tmpDir).' && git commit -m '.escapeshellarg($commitMessage).' 2>&1', $output, $returnCode);
+            if ($returnCode !== 0) {
+                $this->error('Failed to commit changes: '.implode("\n", $output));
+                exec('rm -rf '.escapeshellarg($tmpDir));
+
+                return false;
+            }
+
+            // Push to remote
+            $this->info('Pushing branch to remote...');
+            exec('cd '.escapeshellarg($tmpDir).' && git push origin '.escapeshellarg($branchName).' 2>&1', $output, $returnCode);
+            if ($returnCode !== 0) {
+                $this->error('Failed to push branch: '.implode("\n", $output));
+                exec('rm -rf '.escapeshellarg($tmpDir));
+
+                return false;
+            }
+
+            // Create pull request
+            $this->info('Creating pull request...');
+            $prTitle = 'Update releases.json - '.date('Y-m-d H:i:s');
+            $prBody = 'Automated update of releases.json with latest '.count($releases).' releases from GitHub API';
+            $prCommand = 'gh pr create --repo coollabsio/coolify-cdn --title '.escapeshellarg($prTitle).' --body '.escapeshellarg($prBody).' --base main --head '.escapeshellarg($branchName).' 2>&1';
+            exec($prCommand, $output, $returnCode);
+
+            // Clean up
+            exec('rm -rf '.escapeshellarg($tmpDir));
+
+            if ($returnCode !== 0) {
+                $this->error('Failed to create PR: '.implode("\n", $output));
+
+                return false;
+            }
+
+            $this->info('Pull request created successfully!');
+            if (! empty($output)) {
+                $this->info('PR Output: '.implode("\n", $output));
+            }
+            $this->info('Total releases synced: '.count($releases));
+
+            return true;
         } catch (\Throwable $e) {
-            $this->error('Error fetching releases: '.$e->getMessage());
+            $this->error('Error syncing releases: '.$e->getMessage());
 
             return false;
         }
@@ -174,11 +263,7 @@ public function handle()
                     return;
                 }
 
-                // First sync GitHub releases
-                $this->info('Syncing GitHub releases first...');
-                $this->syncGitHubReleases($parent_dir, $bunny_cdn_storage_name, $bunny_cdn_path, $bunny_cdn);
-
-                // Then sync versions.json
+                // Sync versions.json to BunnyCDN
                 Http::pool(fn (Pool $pool) => [
                     $pool->storage(fileName: $versions_location)->put("/$bunny_cdn_storage_name/$bunny_cdn_path/$versions"),
                     $pool->purge("$bunny_cdn/$bunny_cdn_path/$versions"),
@@ -187,14 +272,14 @@ public function handle()
 
                 return;
             } elseif ($only_github_releases) {
-                $this->info('About to sync GitHub releases to BunnyCDN.');
+                $this->info('About to sync GitHub releases to GitHub repository.');
                 $confirmed = confirm('Are you sure you want to sync GitHub releases?');
                 if (! $confirmed) {
                     return;
                 }
 
-                // Use the reusable function
-                $this->syncGitHubReleases($parent_dir, $bunny_cdn_storage_name, $bunny_cdn_path, $bunny_cdn);
+                // Sync releases to GitHub repository
+                $this->syncReleasesToGitHubRepo();
 
                 return;
             }

app/Exceptions/DeploymentException.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Exceptions;
+
+use Exception;
+
+/**
+ * Exception for expected deployment failures caused by user/application errors.
+ * These are not Coolify bugs and should not be logged to laravel.log.
+ * Examples: Nixpacks detection failures, missing Dockerfiles, invalid configs, etc.
+ */
+class DeploymentException extends Exception
+{
+    /**
+     * Create a new deployment exception instance.
+     *
+     * @param  string  $message
+     * @param  int  $code
+     */
+    public function __construct($message = '', $code = 0, ?\Throwable $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+    }
+
+    /**
+     * Create from another exception, preserving its message and stack trace.
+     */
+    public static function fromException(\Throwable $exception): static
+    {
+        return new static($exception->getMessage(), $exception->getCode(), $exception);
+    }
+}

app/Exceptions/Handler.php

@@ -30,6 +30,7 @@ class Handler extends ExceptionHandler
     protected $dontReport = [
         ProcessException::class,
         NonReportableException::class,
+        DeploymentException::class,
     ];
 
     /**

app/Http/Controllers/Api/DatabasesController.php

@@ -1619,6 +1619,18 @@ public function create_database(Request $request, NewDatabaseTypes $type)
             return response()->json(['message' => 'Server has multiple destinations and you do not set destination_uuid.'], 400);
         }
         $destination = $destinations->first();
+        if ($destinations->count() > 1 && $request->has('destination_uuid')) {
+            $destination = $destinations->where('uuid', $request->destination_uuid)->first();
+            if (! $destination) {
+                return response()->json([
+                    'message' => 'Validation failed.',
+                    'errors' => [
+                        'destination_uuid' => 'Provided destination_uuid does not belong to the specified server.',
+                    ],
+                ], 422);
+            }
+        }
+
         if ($request->has('public_port') && $request->is_public) {
             if (isPublicPortAlreadyUsed($server, $request->public_port)) {
                 return response()->json(['message' => 'Public port already used by another database.'], 400);

app/Http/Controllers/Webhook/Github.php

@@ -246,6 +246,40 @@ public function manual(Request $request)
                         if ($action === 'closed') {
                             $found = ApplicationPreview::where('application_id', $application->id)->where('pull_request_id', $pull_request_id)->first();
                             if ($found) {
+                                // Cancel any active deployments for this PR immediately
+                                $activeDeployment = \App\Models\ApplicationDeploymentQueue::where('application_id', $application->id)
+                                    ->where('pull_request_id', $pull_request_id)
+                                    ->whereIn('status', [
+                                        \App\Enums\ApplicationDeploymentStatus::QUEUED->value,
+                                        \App\Enums\ApplicationDeploymentStatus::IN_PROGRESS->value,
+                                    ])
+                                    ->first();
+
+                                if ($activeDeployment) {
+                                    try {
+                                        // Mark deployment as cancelled
+                                        $activeDeployment->update([
+                                            'status' => \App\Enums\ApplicationDeploymentStatus::CANCELLED_BY_USER->value,
+                                        ]);
+
+                                        // Add cancellation log entry
+                                        $activeDeployment->addLogEntry('Deployment cancelled: Pull request closed.', 'stderr');
+
+                                        // Check if helper container exists and kill it
+                                        $deployment_uuid = $activeDeployment->deployment_uuid;
+                                        $server = $application->destination->server;
+                                        $checkCommand = "docker ps -a --filter name={$deployment_uuid} --format '{{.Names}}'";
+                                        $containerExists = instant_remote_process([$checkCommand], $server);
+
+                                        if ($containerExists && str($containerExists)->trim()->isNotEmpty()) {
+                                            instant_remote_process(["docker rm -f {$deployment_uuid}"], $server);
+                                            $activeDeployment->addLogEntry('Deployment container stopped.');
+                                        }
+                                    } catch (\Throwable $e) {
+                                        // Silently handle errors during deployment cancellation
+                                    }
+                                }
+
                                 DeleteResourceJob::dispatch($found);
                                 $return_payloads->push([
                                     'application' => $application->name,
@@ -481,6 +515,42 @@ public function normal(Request $request)
                         if ($action === 'closed' || $action === 'close') {
                             $found = ApplicationPreview::where('application_id', $application->id)->where('pull_request_id', $pull_request_id)->first();
                             if ($found) {
+                                // Cancel any active deployments for this PR immediately
+                                $activeDeployment = \App\Models\ApplicationDeploymentQueue::where('application_id', $application->id)
+                                    ->where('pull_request_id', $pull_request_id)
+                                    ->whereIn('status', [
+                                        \App\Enums\ApplicationDeploymentStatus::QUEUED->value,
+                                        \App\Enums\ApplicationDeploymentStatus::IN_PROGRESS->value,
+                                    ])
+                                    ->first();
+
+                                if ($activeDeployment) {
+                                    try {
+                                        // Mark deployment as cancelled
+                                        $activeDeployment->update([
+                                            'status' => \App\Enums\ApplicationDeploymentStatus::CANCELLED_BY_USER->value,
+                                        ]);
+
+                                        // Add cancellation log entry
+                                        $activeDeployment->addLogEntry('Deployment cancelled: Pull request closed.', 'stderr');
+
+                                        // Check if helper container exists and kill it
+                                        $deployment_uuid = $activeDeployment->deployment_uuid;
+                                        $server = $application->destination->server;
+                                        $checkCommand = "docker ps -a --filter name={$deployment_uuid} --format '{{.Names}}'";
+                                        $containerExists = instant_remote_process([$checkCommand], $server);
+
+                                        if ($containerExists && str($containerExists)->trim()->isNotEmpty()) {
+                                            instant_remote_process(["docker rm -f {$deployment_uuid}"], $server);
+                                            $activeDeployment->addLogEntry('Deployment container stopped.');
+                                        }
+
+                                    } catch (\Throwable $e) {
+                                        // Silently handle errors during deployment cancellation
+                                    }
+                                }
+
+                                // Clean up any deployed containers
                                 $containers = getCurrentApplicationContainerStatus($application->destination->server, $application->id, $pull_request_id);
                                 if ($containers->isNotEmpty()) {
                                     $containers->each(function ($container) use ($application) {

app/Jobs/ApplicationDeploymentJob.php

@@ -7,6 +7,7 @@
 use App\Enums\ProcessStatus;
 use App\Events\ApplicationConfigurationChanged;
 use App\Events\ServiceStatusChanged;
+use App\Exceptions\DeploymentException;
 use App\Models\Application;
 use App\Models\ApplicationDeploymentQueue;
 use App\Models\ApplicationPreview;
@@ -31,7 +32,6 @@
 use Illuminate\Support\Collection;
 use Illuminate\Support\Sleep;
 use Illuminate\Support\Str;
-use RuntimeException;
 use Spatie\Url\Url;
 use Symfony\Component\Yaml\Yaml;
 use Throwable;
@@ -341,20 +341,42 @@ public function handle(): void
             $this->fail($e);
             throw $e;
         } finally {
-            $this->application_deployment_queue->update([
-                'finished_at' => Carbon::now()->toImmutable(),
-            ]);
-
-            if ($this->use_build_server) {
-                $this->server = $this->build_server;
-            } else {
-                $this->write_deployment_configurations();
+            // Wrap cleanup operations in try-catch to prevent exceptions from interfering
+            // with Laravel's job failure handling and status updates
+            try {
+                $this->application_deployment_queue->update([
+                    'finished_at' => Carbon::now()->toImmutable(),
+                ]);
+            } catch (Exception $e) {
+                // Log but don't fail - finished_at is not critical
+                \Log::warning('Failed to update finished_at for deployment '.$this->deployment_uuid.': '.$e->getMessage());
             }
 
-            $this->application_deployment_queue->addLogEntry("Gracefully shutting down build container: {$this->deployment_uuid}");
-            $this->graceful_shutdown_container($this->deployment_uuid);
+            try {
+                if ($this->use_build_server) {
+                    $this->server = $this->build_server;
+                } else {
+                    $this->write_deployment_configurations();
+                }
+            } catch (Exception $e) {
+                // Log but don't fail - configuration writing errors shouldn't prevent status updates
+                $this->application_deployment_queue->addLogEntry('Warning: Failed to write deployment configurations: '.$e->getMessage(), 'stderr');
+            }
 
-            ServiceStatusChanged::dispatch(data_get($this->application, 'environment.project.team.id'));
+            try {
+                $this->application_deployment_queue->addLogEntry("Gracefully shutting down build container: {$this->deployment_uuid}");
+                $this->graceful_shutdown_container($this->deployment_uuid);
+            } catch (Exception $e) {
+                // Log but don't fail - container cleanup errors are expected when container is already gone
+                \Log::warning('Failed to shutdown container '.$this->deployment_uuid.': '.$e->getMessage());
+            }
+
+            try {
+                ServiceStatusChanged::dispatch(data_get($this->application, 'environment.project.team.id'));
+            } catch (Exception $e) {
+                // Log but don't fail - event dispatch errors shouldn't prevent status updates
+                \Log::warning('Failed to dispatch ServiceStatusChanged for deployment '.$this->deployment_uuid.': '.$e->getMessage());
+            }
         }
     }
 
@@ -954,7 +976,7 @@ private function push_to_docker_registry()
         } catch (Exception $e) {
             $this->application_deployment_queue->addLogEntry('Failed to push image to docker registry. Please check debug logs for more information.');
             if ($forceFail) {
-                throw new RuntimeException($e->getMessage(), 69420);
+                throw new DeploymentException($e->getMessage(), 69420);
             }
         }
     }
@@ -1146,6 +1168,18 @@ private function generate_runtime_environment_variables()
             foreach ($runtime_environment_variables as $env) {
                 $envs->push($env->key.'='.$env->real_value);
             }
+
+            // Check for PORT environment variable mismatch with ports_exposes
+            if ($this->build_pack !== 'dockercompose') {
+                $detectedPort = $this->application->detectPortFromEnvironment(false);
+                if ($detectedPort && ! empty($ports) && ! in_array($detectedPort, $ports)) {
+                    $this->application_deployment_queue->addLogEntry(
+                        "Warning: PORT environment variable ({$detectedPort}) does not match configured ports_exposes: ".implode(',', $ports).'. It could case "bad gateway" or "no server" errors. Check the "General" page to fix it.',
+                        'stderr'
+                    );
+                }
+            }
+
             // Add PORT if not exists, use the first port as default
             if ($this->build_pack !== 'dockercompose') {
                 if ($this->application->environment_variables->where('key', 'PORT')->isEmpty()) {
@@ -1780,9 +1814,8 @@ private function create_workdir()
     private function prepare_builder_image(bool $firstTry = true)
     {
         $this->checkForCancellation();
-        $settings = instanceSettings();
         $helperImage = config('constants.coolify.helper_image');
-        $helperImage = "{$helperImage}:{$settings->helper_version}";
+        $helperImage = "{$helperImage}:".getHelperVersion();
         // Get user home directory
         $this->serverUserHomeDir = instant_remote_process(['echo $HOME'], $this->server);
         $this->dockerConfigFileExists = instant_remote_process(["test -f {$this->serverUserHomeDir}/.docker/config.json && echo 'OK' || echo 'NOK'"], $this->server);
@@ -1790,7 +1823,7 @@ private function prepare_builder_image(bool $firstTry = true)
         $env_flags = $this->generate_docker_env_flags_for_secrets();
         if ($this->use_build_server) {
             if ($this->dockerConfigFileExists === 'NOK') {
-                throw new RuntimeException('Docker config file (~/.docker/config.json) not found on the build server. Please run "docker login" to login to the docker registry on the server.');
+                throw new DeploymentException('Docker config file (~/.docker/config.json) not found on the build server. Please run "docker login" to login to the docker registry on the server.');
             }
             $runCommand = "docker run -d --name {$this->deployment_uuid} {$env_flags} --rm -v {$this->serverUserHomeDir}/.docker/config.json:/root/.docker/config.json:ro -v /var/run/docker.sock:/var/run/docker.sock {$helperImage}";
         } else {
@@ -2056,7 +2089,7 @@ private function generate_nixpacks_confs()
         if ($this->saved_outputs->get('nixpacks_type')) {
             $this->nixpacks_type = $this->saved_outputs->get('nixpacks_type');
             if (str($this->nixpacks_type)->isEmpty()) {
-                throw new RuntimeException('Nixpacks failed to detect the application type. Please check the documentation of Nixpacks: https://nixpacks.com/docs/providers');
+                throw new DeploymentException('Nixpacks failed to detect the application type. Please check the documentation of Nixpacks: https://nixpacks.com/docs/providers');
             }
         }
 
@@ -2322,8 +2355,8 @@ private function generate_compose_file()
             $this->application->parseHealthcheckFromDockerfile($this->saved_outputs->get('dockerfile_from_repo'));
         }
         $custom_network_aliases = [];
-        if (is_array($this->application->custom_network_aliases) && count($this->application->custom_network_aliases) > 0) {
-            $custom_network_aliases = $this->application->custom_network_aliases;
+        if (! empty($this->application->custom_network_aliases_array)) {
+            $custom_network_aliases = $this->application->custom_network_aliases_array;
         }
         $docker_compose = [
             'services' => [
@@ -3030,6 +3063,11 @@ private function stop_running_container(bool $force = false)
 
     private function start_by_compose_file()
     {
+        // Ensure .env file exists before docker compose tries to load it (defensive programming)
+        $this->execute_remote_command(
+            ["touch {$this->configuration_dir}/.env", 'hidden' => true],
+        );
+
         if ($this->application->build_pack === 'dockerimage') {
             $this->application_deployment_queue->addLogEntry('Pulling latest images from the registry.');
             $this->execute_remote_command(
@@ -3227,6 +3265,20 @@ private function generate_secrets_hash($variables)
         return hash_hmac('sha256', $secrets_string, $this->secrets_hash_key);
     }
 
+    protected function findFromInstructionLines($dockerfile): array
+    {
+        $fromLines = [];
+        foreach ($dockerfile as $index => $line) {
+            $trimmedLine = trim($line);
+            // Check if line starts with FROM (case-insensitive)
+            if (preg_match('/^FROM\s+/i', $trimmedLine)) {
+                $fromLines[] = $index;
+            }
+        }
+
+        return $fromLines;
+    }
+
     private function add_build_env_variables_to_dockerfile()
     {
         if ($this->dockerBuildkitSupported) {
@@ -3239,6 +3291,18 @@ private function add_build_env_variables_to_dockerfile()
                 'ignore_errors' => true,
             ]);
             $dockerfile = collect(str($this->saved_outputs->get('dockerfile'))->trim()->explode("\n"));
+
+            // Find all FROM instruction positions
+            $fromLines = $this->findFromInstructionLines($dockerfile);
+
+            // If no FROM instructions found, skip ARG insertion
+            if (empty($fromLines)) {
+                return;
+            }
+
+            // Collect all ARG statements to insert
+            $argsToInsert = collect();
+
             if ($this->pull_request_id === 0) {
                 // Only add environment variables that are available during build
                 $envs = $this->application->environment_variables()
@@ -3247,9 +3311,9 @@ private function add_build_env_variables_to_dockerfile()
                     ->get();
                 foreach ($envs as $env) {
                     if (data_get($env, 'is_multiline') === true) {
-                        $dockerfile->splice(1, 0, ["ARG {$env->key}"]);
+                        $argsToInsert->push("ARG {$env->key}");
                     } else {
-                        $dockerfile->splice(1, 0, ["ARG {$env->key}={$env->real_value}"]);
+                        $argsToInsert->push("ARG {$env->key}={$env->real_value}");
                     }
                 }
                 // Add Coolify variables as ARGs
@@ -3259,9 +3323,7 @@ private function add_build_env_variables_to_dockerfile()
                         ->map(function ($var) {
                             return "ARG {$var}";
                         });
-                    foreach ($coolify_vars as $arg) {
-                        $dockerfile->splice(1, 0, [$arg]);
-                    }
+                    $argsToInsert = $argsToInsert->merge($coolify_vars);
                 }
             } else {
                 // Only add preview environment variables that are available during build
@@ -3271,9 +3333,9 @@ private function add_build_env_variables_to_dockerfile()
                     ->get();
                 foreach ($envs as $env) {
                     if (data_get($env, 'is_multiline') === true) {
-                        $dockerfile->splice(1, 0, ["ARG {$env->key}"]);
+                        $argsToInsert->push("ARG {$env->key}");
                     } else {
-                        $dockerfile->splice(1, 0, ["ARG {$env->key}={$env->real_value}"]);
+                        $argsToInsert->push("ARG {$env->key}={$env->real_value}");
                     }
                 }
                 // Add Coolify variables as ARGs
@@ -3283,15 +3345,23 @@ private function add_build_env_variables_to_dockerfile()
                         ->map(function ($var) {
                             return "ARG {$var}";
                         });
-                    foreach ($coolify_vars as $arg) {
-                        $dockerfile->splice(1, 0, [$arg]);
-                    }
+                    $argsToInsert = $argsToInsert->merge($coolify_vars);
                 }
             }
 
-            if ($envs->isNotEmpty()) {
-                $secrets_hash = $this->generate_secrets_hash($envs);
-                $dockerfile->splice(1, 0, ["ARG COOLIFY_BUILD_SECRETS_HASH={$secrets_hash}"]);
+            // Insert ARGs after each FROM instruction (in reverse order to maintain correct line numbers)
+            if ($argsToInsert->isNotEmpty()) {
+                foreach (array_reverse($fromLines) as $fromLineIndex) {
+                    // Insert all ARGs after this FROM instruction
+                    foreach ($argsToInsert->reverse() as $arg) {
+                        $dockerfile->splice($fromLineIndex + 1, 0, [$arg]);
+                    }
+                }
+                $envs_mapped = $envs->mapWithKeys(function ($env) {
+                    return [$env->key => $env->real_value];
+                });
+                $secrets_hash = $this->generate_secrets_hash($envs_mapped);
+                $argsToInsert->push("ARG COOLIFY_BUILD_SECRETS_HASH={$secrets_hash}");
             }
 
             $dockerfile_base64 = base64_encode($dockerfile->implode("\n"));
@@ -3606,7 +3676,7 @@ private function run_pre_deployment_command()
                 return;
             }
         }
-        throw new RuntimeException('Pre-deployment command: Could not find a valid container. Is the container name correct?');
+        throw new DeploymentException('Pre-deployment command: Could not find a valid container. Is the container name correct?');
     }
 
     private function run_post_deployment_command()
@@ -3642,7 +3712,7 @@ private function run_post_deployment_command()
                 return;
             }
         }
-        throw new RuntimeException('Post-deployment command: Could not find a valid container. Is the container name correct?');
+        throw new DeploymentException('Post-deployment command: Could not find a valid container. Is the container name correct?');
     }
 
     /**
@@ -3653,7 +3723,7 @@ private function checkForCancellation(): void
         $this->application_deployment_queue->refresh();
         if ($this->application_deployment_queue->status === ApplicationDeploymentStatus::CANCELLED_BY_USER->value) {
             $this->application_deployment_queue->addLogEntry('Deployment cancelled by user, stopping execution.');
-            throw new \RuntimeException('Deployment cancelled by user', 69420);
+            throw new DeploymentException('Deployment cancelled by user', 69420);
         }
     }
 
@@ -3686,7 +3756,7 @@ private function isInTerminalState(): bool
 
         if ($this->application_deployment_queue->status === ApplicationDeploymentStatus::CANCELLED_BY_USER->value) {
             $this->application_deployment_queue->addLogEntry('Deployment cancelled by user, stopping execution.');
-            throw new \RuntimeException('Deployment cancelled by user', 69420);
+            throw new DeploymentException('Deployment cancelled by user', 69420);
         }
 
         return false;
@@ -3767,10 +3837,8 @@ private function failDeployment(): void
     public function failed(Throwable $exception): void
     {
         $this->failDeployment();
-        $this->application_deployment_queue->addLogEntry('Oops something is not okay, are you okay? 😢', 'stderr');
-        if (str($exception->getMessage())->isNotEmpty()) {
-            $this->application_deployment_queue->addLogEntry($exception->getMessage(), 'stderr');
-        }
+        $errorMessage = $exception->getMessage() ?: 'Unknown error occurred';
+        $this->application_deployment_queue->addLogEntry("Deployment failed: {$errorMessage}", 'stderr');
 
         if ($this->application->build_pack !== 'dockercompose') {
             $code = $exception->getCode();

app/Jobs/CleanupHelperContainersJob.php

@@ -2,6 +2,8 @@
 
 namespace App\Jobs;
 
+use App\Enums\ApplicationDeploymentStatus;
+use App\Models\ApplicationDeploymentQueue;
 use App\Models\Server;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldBeEncrypted;
@@ -20,10 +22,51 @@ public function __construct(public Server $server) {}
     public function handle(): void
     {
         try {
+            // Get all active deployments on this server
+            $activeDeployments = ApplicationDeploymentQueue::where('server_id', $this->server->id)
+                ->whereIn('status', [
+                    ApplicationDeploymentStatus::IN_PROGRESS->value,
+                    ApplicationDeploymentStatus::QUEUED->value,
+                ])
+                ->pluck('deployment_uuid')
+                ->toArray();
+
+            \Log::info('CleanupHelperContainersJob - Active deployments', [
+                'server' => $this->server->name,
+                'active_deployment_uuids' => $activeDeployments,
+            ]);
+
             $containers = instant_remote_process_with_timeout(['docker container ps --format \'{{json .}}\' | jq -s \'map(select(.Image | contains("'.config('constants.coolify.registry_url').'/coollabsio/coolify-helper")))\''], $this->server, false);
-            $containerIds = collect(json_decode($containers))->pluck('ID');
-            if ($containerIds->count() > 0) {
-                foreach ($containerIds as $containerId) {
+            $helperContainers = collect(json_decode($containers));
+
+            if ($helperContainers->count() > 0) {
+                foreach ($helperContainers as $container) {
+                    $containerId = data_get($container, 'ID');
+                    $containerName = data_get($container, 'Names');
+
+                    // Check if this container belongs to an active deployment
+                    $isActiveDeployment = false;
+                    foreach ($activeDeployments as $deploymentUuid) {
+                        if (str_contains($containerName, $deploymentUuid)) {
+                            $isActiveDeployment = true;
+                            break;
+                        }
+                    }
+
+                    if ($isActiveDeployment) {
+                        \Log::info('CleanupHelperContainersJob - Skipping active deployment container', [
+                            'container' => $containerName,
+                            'id' => $containerId,
+                        ]);
+
+                        continue;
+                    }
+
+                    \Log::info('CleanupHelperContainersJob - Removing orphaned helper container', [
+                        'container' => $containerName,
+                        'id' => $containerId,
+                    ]);
+
                     instant_remote_process_with_timeout(['docker container rm -f '.$containerId], $this->server, false);
                 }
             }

app/Jobs/CoolifyTask.php

@@ -3,18 +3,35 @@
 namespace App\Jobs;
 
 use App\Actions\CoolifyTask\RunRemoteProcess;
+use App\Enums\ProcessStatus;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldBeEncrypted;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Bus\Dispatchable;
 use Illuminate\Queue\InteractsWithQueue;
 use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Log;
 use Spatie\Activitylog\Models\Activity;
 
 class CoolifyTask implements ShouldBeEncrypted, ShouldQueue
 {
     use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
+    /**
+     * The number of times the job may be attempted.
+     */
+    public $tries = 3;
+
+    /**
+     * The maximum number of unhandled exceptions to allow before failing.
+     */
+    public $maxExceptions = 1;
+
+    /**
+     * The number of seconds the job can run before timing out.
+     */
+    public $timeout = 600;
+
     /**
      * Create a new job instance.
      */
@@ -42,4 +59,36 @@ public function handle(): void
 
         $remote_process();
     }
+
+    /**
+     * Calculate the number of seconds to wait before retrying the job.
+     */
+    public function backoff(): array
+    {
+        return [30, 90, 180]; // 30s, 90s, 180s between retries
+    }
+
+    /**
+     * Handle a job failure.
+     */
+    public function failed(?\Throwable $exception): void
+    {
+        Log::channel('scheduled-errors')->error('CoolifyTask permanently failed', [
+            'job' => 'CoolifyTask',
+            'activity_id' => $this->activity->id,
+            'server_uuid' => $this->activity->getExtraProperty('server_uuid'),
+            'command_preview' => substr($this->activity->getExtraProperty('command') ?? '', 0, 200),
+            'error' => $exception?->getMessage(),
+            'total_attempts' => $this->attempts(),
+            'trace' => $exception?->getTraceAsString(),
+        ]);
+
+        // Update activity status to reflect permanent failure
+        $this->activity->properties = $this->activity->properties->merge([
+            'status' => ProcessStatus::ERROR->value,
+            'error' => $exception?->getMessage() ?? 'Job permanently failed',
+            'failed_at' => now()->toIso8601String(),
+        ]);
+        $this->activity->save();
+    }
 }

app/Jobs/DatabaseBackupJob.php

@@ -23,6 +23,7 @@
 use Illuminate\Foundation\Bus\Dispatchable;
 use Illuminate\Queue\InteractsWithQueue;
 use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Str;
 use Throwable;
 use Visus\Cuid2\Cuid2;
@@ -31,6 +32,8 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
 {
     use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
+    public $maxExceptions = 1;
+
     public ?Team $team = null;
 
     public Server $server;
@@ -74,7 +77,7 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
     public function __construct(public ScheduledDatabaseBackup $backup)
     {
         $this->onQueue('high');
-        $this->timeout = $backup->timeout;
+        $this->timeout = $backup->timeout ?? 3600;
     }
 
     public function handle(): void
@@ -653,24 +656,42 @@ private function upload_to_s3(): void
 
     private function getFullImageName(): string
     {
-        $settings = instanceSettings();
         $helperImage = config('constants.coolify.helper_image');
-        $latestVersion = $settings->helper_version;
+        $latestVersion = getHelperVersion();
 
         return "{$helperImage}:{$latestVersion}";
     }
 
     public function failed(?Throwable $exception): void
     {
+        Log::channel('scheduled-errors')->error('DatabaseBackup permanently failed', [
+            'job' => 'DatabaseBackupJob',
+            'backup_id' => $this->backup->uuid,
+            'database' => $this->database?->name ?? 'unknown',
+            'database_type' => get_class($this->database ?? new \stdClass),
+            'server' => $this->server?->name ?? 'unknown',
+            'total_attempts' => $this->attempts(),
+            'error' => $exception?->getMessage(),
+            'trace' => $exception?->getTraceAsString(),
+        ]);
+
         $log = ScheduledDatabaseBackupExecution::where('uuid', $this->backup_log_uuid)->first();
 
         if ($log) {
             $log->update([
                 'status' => 'failed',
-                'message' => 'Job failed: '.($exception?->getMessage() ?? 'Unknown error'),
+                'message' => 'Job permanently failed after '.$this->attempts().' attempts: '.($exception?->getMessage() ?? 'Unknown error'),
                 'size' => 0,
                 'filename' => null,
+                'finished_at' => Carbon::now(),
             ]);
         }
+
+        // Notify team about permanent failure
+        if ($this->team) {
+            $databaseName = $log?->database_name ?? 'unknown';
+            $output = $this->backup_output ?? $exception?->getMessage() ?? 'Unknown error';
+            $this->team->notify(new BackupFailed($this->backup, $this->database, $output, $databaseName));
+        }
     }
 }

app/Jobs/DeleteResourceJob.php

@@ -124,16 +124,54 @@ private function deleteApplicationPreview()
             $this->resource->delete();
         }
 
+        // Cancel any active deployments for this PR (same logic as API cancel_deployment)
+        $activeDeployments = \App\Models\ApplicationDeploymentQueue::where('application_id', $application->id)
+            ->where('pull_request_id', $pull_request_id)
+            ->whereIn('status', [
+                \App\Enums\ApplicationDeploymentStatus::QUEUED->value,
+                \App\Enums\ApplicationDeploymentStatus::IN_PROGRESS->value,
+            ])
+            ->get();
+
+        foreach ($activeDeployments as $activeDeployment) {
+            try {
+                // Mark deployment as cancelled
+                $activeDeployment->update([
+                    'status' => \App\Enums\ApplicationDeploymentStatus::CANCELLED_BY_USER->value,
+                ]);
+
+                // Add cancellation log entry
+                $activeDeployment->addLogEntry('Deployment cancelled: Pull request closed.', 'stderr');
+
+                // Check if helper container exists and kill it
+                $deployment_uuid = $activeDeployment->deployment_uuid;
+                $escapedDeploymentUuid = escapeshellarg($deployment_uuid);
+                $checkCommand = "docker ps -a --filter name={$escapedDeploymentUuid} --format '{{.Names}}'";
+                $containerExists = instant_remote_process([$checkCommand], $server);
+
+                if ($containerExists && str($containerExists)->trim()->isNotEmpty()) {
+                    instant_remote_process(["docker rm -f {$escapedDeploymentUuid}"], $server);
+                    $activeDeployment->addLogEntry('Deployment container stopped.');
+                } else {
+                    $activeDeployment->addLogEntry('Helper container not yet started. Deployment will be cancelled when job checks status.');
+                }
+
+            } catch (\Throwable $e) {
+                // Silently handle errors during deployment cancellation
+            }
+        }
+
         try {
             if ($server->isSwarm()) {
-                instant_remote_process(["docker stack rm {$application->uuid}-{$pull_request_id}"], $server);
+                $escapedStackName = escapeshellarg("{$application->uuid}-{$pull_request_id}");
+                instant_remote_process(["docker stack rm {$escapedStackName}"], $server);
             } else {
                 $containers = getCurrentApplicationContainerStatus($server, $application->id, $pull_request_id)->toArray();
                 $this->stopPreviewContainers($containers, $server);
             }
         } catch (\Throwable $e) {
             // Log the error but don't fail the job
-            ray('Error stopping preview containers: '.$e->getMessage());
+            \Log::warning('Error stopping preview containers for application '.$application->uuid.', PR #'.$pull_request_id.': '.$e->getMessage());
         }
 
         // Finally, force delete to trigger resource cleanup
@@ -156,7 +194,6 @@ private function stopPreviewContainers(array $containers, $server, int $timeout
             "docker stop --time=$timeout $containerList",
             "docker rm -f $containerList",
         ];
-
         instant_remote_process(
             command: $commands,
             server: $server,

app/Jobs/PullHelperImageJob.php

@@ -24,7 +24,7 @@ public function __construct(public Server $server)
     public function handle(): void
     {
         $helperImage = config('constants.coolify.helper_image');
-        $latest_version = instanceSettings()->helper_version;
+        $latest_version = getHelperVersion();
         instant_remote_process(["docker pull -q {$helperImage}:{$latest_version}"], $this->server, false);
     }
 }

app/Jobs/ScheduledJobManager.php

@@ -52,7 +52,7 @@ public function middleware(): array
     {
         return [
             (new WithoutOverlapping('scheduled-job-manager'))
-                ->expireAfter(60)   // Lock expires after 1 minute to prevent stale locks
+                ->expireAfter(90)   // Lock expires after 90s to handle high-load environments with many tasks
                 ->dontRelease(),    // Don't re-queue on lock conflict
         ];
     }

app/Jobs/ScheduledTaskJob.php

@@ -18,14 +18,30 @@
 use Illuminate\Foundation\Bus\Dispatchable;
 use Illuminate\Queue\InteractsWithQueue;
 use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Log;
 
 class ScheduledTaskJob implements ShouldQueue
 {
     use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
+    /**
+     * The number of times the job may be attempted.
+     */
+    public $tries = 3;
+
+    /**
+     * The maximum number of unhandled exceptions to allow before failing.
+     */
+    public $maxExceptions = 1;
+
+    /**
+     * The number of seconds the job can run before timing out.
+     */
+    public $timeout = 300;
+
     public Team $team;
 
-    public Server $server;
+    public ?Server $server = null;
 
     public ScheduledTask $task;
 
@@ -33,6 +49,11 @@ class ScheduledTaskJob implements ShouldQueue
 
     public ?ScheduledTaskExecution $task_log = null;
 
+    /**
+     * Store execution ID to survive job serialization for timeout handling.
+     */
+    protected ?int $executionId = null;
+
     public string $task_status = 'failed';
 
     public ?string $task_output = null;
@@ -55,6 +76,9 @@ public function __construct($task)
         }
         $this->team = Team::findOrFail($task->team_id);
         $this->server_timezone = $this->getServerTimezone();
+
+        // Set timeout from task configuration
+        $this->timeout = $this->task->timeout ?? 300;
     }
 
     private function getServerTimezone(): string
@@ -70,11 +94,18 @@ private function getServerTimezone(): string
 
     public function handle(): void
     {
+        $startTime = Carbon::now();
+
         try {
             $this->task_log = ScheduledTaskExecution::create([
                 'scheduled_task_id' => $this->task->id,
+                'started_at' => $startTime,
+                'retry_count' => $this->attempts() - 1,
             ]);
 
+            // Store execution ID for timeout handling
+            $this->executionId = $this->task_log->id;
+
             $this->server = $this->resource->destination->server;
 
             if ($this->resource->type() === 'application') {
@@ -129,15 +160,101 @@ public function handle(): void
                     'message' => $this->task_output ?? $e->getMessage(),
                 ]);
             }
-            $this->team?->notify(new TaskFailed($this->task, $e->getMessage()));
+
+            // Log the error to the scheduled-errors channel
+            Log::channel('scheduled-errors')->error('ScheduledTask execution failed', [
+                'job' => 'ScheduledTaskJob',
+                'task_id' => $this->task->uuid,
+                'task_name' => $this->task->name,
+                'server' => $this->server?->name ?? 'unknown',
+                'attempt' => $this->attempts(),
+                'error' => $e->getMessage(),
+            ]);
+
+            // Only notify and throw on final failure
+
+            // Re-throw to trigger Laravel's retry mechanism with backoff
             throw $e;
         } finally {
             ScheduledTaskDone::dispatch($this->team->id);
             if ($this->task_log) {
+                $finishedAt = Carbon::now();
+                $duration = round($startTime->floatDiffInSeconds($finishedAt), 2);
+
                 $this->task_log->update([
-                    'finished_at' => Carbon::now()->toImmutable(),
+                    'finished_at' => $finishedAt->toImmutable(),
+                    'duration' => $duration,
                 ]);
             }
         }
     }
+
+    /**
+     * Calculate the number of seconds to wait before retrying the job.
+     */
+    public function backoff(): array
+    {
+        return [30, 60, 120]; // 30s, 60s, 120s between retries
+    }
+
+    /**
+     * Handle a job failure.
+     */
+    public function failed(?\Throwable $exception): void
+    {
+        Log::channel('scheduled-errors')->error('ScheduledTask permanently failed', [
+            'job' => 'ScheduledTaskJob',
+            'task_id' => $this->task->uuid,
+            'task_name' => $this->task->name,
+            'server' => $this->server?->name ?? 'unknown',
+            'total_attempts' => $this->attempts(),
+            'error' => $exception?->getMessage(),
+            'trace' => $exception?->getTraceAsString(),
+        ]);
+
+        // Reload execution log from database
+        // When a job times out, failed() is called in a fresh process with the original
+        // queue payload, so $executionId will be null. We need to query for the latest execution.
+        $execution = null;
+
+        // Try to find execution using stored ID first (works for non-timeout failures)
+        if ($this->executionId) {
+            $execution = ScheduledTaskExecution::find($this->executionId);
+        }
+
+        // If no stored ID or not found, query for the most recent execution log for this task
+        if (! $execution) {
+            $execution = ScheduledTaskExecution::query()
+                ->where('scheduled_task_id', $this->task->id)
+                ->orderBy('created_at', 'desc')
+                ->first();
+        }
+
+        // Last resort: check task_log property
+        if (! $execution && $this->task_log) {
+            $execution = $this->task_log;
+        }
+
+        if ($execution) {
+            $errorMessage = 'Job permanently failed after '.$this->attempts().' attempts';
+            if ($exception) {
+                $errorMessage .= ': '.$exception->getMessage();
+            }
+
+            $execution->update([
+                'status' => 'failed',
+                'message' => $errorMessage,
+                'error_details' => $exception?->getTraceAsString(),
+                'finished_at' => Carbon::now()->toImmutable(),
+            ]);
+        } else {
+            Log::channel('scheduled-errors')->warning('Could not find execution log to update', [
+                'execution_id' => $this->executionId,
+                'task_id' => $this->task->uuid,
+            ]);
+        }
+
+        // Notify team about permanent failure
+        $this->team?->notify(new TaskFailed($this->task, $exception?->getMessage() ?? 'Unknown error'));
+    }
 }

app/Livewire/Concerns/SynchronizesModelData.php

@@ -1,35 +0,0 @@
-<?php
-
-namespace App\Livewire\Concerns;
-
-trait SynchronizesModelData
-{
-    /**
-     * Define the mapping between component properties and model keys.
-     *
-     * @return array<string, string> Array mapping property names to model keys (e.g., ['content' => 'fileStorage.content'])
-     */
-    abstract protected function getModelBindings(): array;
-
-    /**
-     * Synchronize component properties TO the model.
-     * Copies values from component properties to the model.
-     */
-    protected function syncToModel(): void
-    {
-        foreach ($this->getModelBindings() as $property => $modelKey) {
-            data_set($this, $modelKey, $this->{$property});
-        }
-    }
-
-    /**
-     * Synchronize component properties FROM the model.
-     * Copies values from the model to component properties.
-     */
-    protected function syncFromModel(): void
-    {
-        foreach ($this->getModelBindings() as $property => $modelKey) {
-            $this->{$property} = data_get($this, $modelKey);
-        }
-    }
-}

app/Livewire/Project/Application/General.php

@@ -3,11 +3,11 @@
 namespace App\Livewire\Project\Application;
 
 use App\Actions\Application\GenerateConfig;
-use App\Livewire\Concerns\SynchronizesModelData;
 use App\Models\Application;
 use App\Support\ValidationPatterns;
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 use Illuminate\Support\Collection;
+use Livewire\Attributes\Validate;
 use Livewire\Component;
 use Spatie\Url\Url;
 use Visus\Cuid2\Cuid2;
@@ -15,7 +15,6 @@
 class General extends Component
 {
     use AuthorizesRequests;
-    use SynchronizesModelData;
 
     public string $applicationId;
 
@@ -23,94 +22,136 @@ class General extends Component
 
     public Collection $services;
 
+    #[Validate('required|regex:/^[a-zA-Z0-9\s\-_.\/:()]+$/')]
     public string $name;
 
+    #[Validate(['string', 'nullable'])]
     public ?string $description = null;
 
+    #[Validate(['nullable'])]
     public ?string $fqdn = null;
 
-    public string $git_repository;
+    #[Validate(['required'])]
+    public string $gitRepository;
 
-    public string $git_branch;
+    #[Validate(['required'])]
+    public string $gitBranch;
 
-    public ?string $git_commit_sha = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $gitCommitSha = null;
 
-    public ?string $install_command = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $installCommand = null;
 
-    public ?string $build_command = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $buildCommand = null;
 
-    public ?string $start_command = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $startCommand = null;
 
-    public string $build_pack;
+    #[Validate(['required'])]
+    public string $buildPack;
 
-    public string $static_image;
+    #[Validate(['required'])]
+    public string $staticImage;
 
-    public string $base_directory;
+    #[Validate(['required'])]
+    public string $baseDirectory;
 
-    public ?string $publish_directory = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $publishDirectory = null;
 
-    public ?string $ports_exposes = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $portsExposes = null;
 
-    public ?string $ports_mappings = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $portsMappings = null;
 
-    public ?string $custom_network_aliases = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $customNetworkAliases = null;
 
+    #[Validate(['string', 'nullable'])]
     public ?string $dockerfile = null;
 
-    public ?string $dockerfile_location = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerfileLocation = null;
 
-    public ?string $dockerfile_target_build = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerfileTargetBuild = null;
 
-    public ?string $docker_registry_image_name = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerRegistryImageName = null;
 
-    public ?string $docker_registry_image_tag = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerRegistryImageTag = null;
 
-    public ?string $docker_compose_location = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerComposeLocation = null;
 
-    public ?string $docker_compose = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerCompose = null;
 
-    public ?string $docker_compose_raw = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerComposeRaw = null;
 
-    public ?string $docker_compose_custom_start_command = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerComposeCustomStartCommand = null;
 
-    public ?string $docker_compose_custom_build_command = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $dockerComposeCustomBuildCommand = null;
 
-    public ?string $custom_labels = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $customDockerRunOptions = null;
 
-    public ?string $custom_docker_run_options = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $preDeploymentCommand = null;
 
-    public ?string $pre_deployment_command = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $preDeploymentCommandContainer = null;
 
-    public ?string $pre_deployment_command_container = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $postDeploymentCommand = null;
 
-    public ?string $post_deployment_command = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $postDeploymentCommandContainer = null;
 
-    public ?string $post_deployment_command_container = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $customNginxConfiguration = null;
 
-    public ?string $custom_nginx_configuration = null;
+    #[Validate(['boolean', 'required'])]
+    public bool $isStatic = false;
 
-    public bool $is_static = false;
+    #[Validate(['boolean', 'required'])]
+    public bool $isSpa = false;
 
-    public bool $is_spa = false;
+    #[Validate(['boolean', 'required'])]
+    public bool $isBuildServerEnabled = false;
 
-    public bool $is_build_server_enabled = false;
+    #[Validate(['boolean', 'required'])]
+    public bool $isPreserveRepositoryEnabled = false;
 
-    public bool $is_preserve_repository_enabled = false;
+    #[Validate(['boolean', 'required'])]
+    public bool $isContainerLabelEscapeEnabled = true;
 
-    public bool $is_container_label_escape_enabled = true;
+    #[Validate(['boolean', 'required'])]
+    public bool $isContainerLabelReadonlyEnabled = false;
 
-    public bool $is_container_label_readonly_enabled = false;
+    #[Validate(['boolean', 'required'])]
+    public bool $isHttpBasicAuthEnabled = false;
 
-    public bool $is_http_basic_auth_enabled = false;
+    #[Validate(['string', 'nullable'])]
+    public ?string $httpBasicAuthUsername = null;
 
-    public ?string $http_basic_auth_username = null;
+    #[Validate(['string', 'nullable'])]
+    public ?string $httpBasicAuthPassword = null;
 
-    public ?string $http_basic_auth_password = null;
-
-    public ?string $watch_paths = null;
+    #[Validate(['nullable'])]
+    public ?string $watchPaths = null;
 
+    #[Validate(['string', 'required'])]
     public string $redirect;
 
+    #[Validate(['nullable'])]
     public $customLabels;
 
     public bool $labelsChanged = false;
@@ -141,46 +182,46 @@ protected function rules(): array
             'name' => ValidationPatterns::nameRules(),
             'description' => ValidationPatterns::descriptionRules(),
             'fqdn' => 'nullable',
-            'git_repository' => 'required',
-            'git_branch' => 'required',
-            'git_commit_sha' => 'nullable',
-            'install_command' => 'nullable',
-            'build_command' => 'nullable',
-            'start_command' => 'nullable',
-            'build_pack' => 'required',
-            'static_image' => 'required',
-            'base_directory' => 'required',
-            'publish_directory' => 'nullable',
-            'ports_exposes' => 'required',
-            'ports_mappings' => 'nullable',
-            'custom_network_aliases' => 'nullable',
+            'gitRepository' => 'required',
+            'gitBranch' => 'required',
+            'gitCommitSha' => 'nullable',
+            'installCommand' => 'nullable',
+            'buildCommand' => 'nullable',
+            'startCommand' => 'nullable',
+            'buildPack' => 'required',
+            'staticImage' => 'required',
+            'baseDirectory' => 'required',
+            'publishDirectory' => 'nullable',
+            'portsExposes' => 'required',
+            'portsMappings' => 'nullable',
+            'customNetworkAliases' => 'nullable',
             'dockerfile' => 'nullable',
-            'docker_registry_image_name' => 'nullable',
-            'docker_registry_image_tag' => 'nullable',
-            'dockerfile_location' => 'nullable',
-            'docker_compose_location' => 'nullable',
-            'docker_compose' => 'nullable',
-            'docker_compose_raw' => 'nullable',
-            'dockerfile_target_build' => 'nullable',
-            'docker_compose_custom_start_command' => 'nullable',
-            'docker_compose_custom_build_command' => 'nullable',
-            'custom_labels' => 'nullable',
-            'custom_docker_run_options' => 'nullable',
-            'pre_deployment_command' => 'nullable',
-            'pre_deployment_command_container' => 'nullable',
-            'post_deployment_command' => 'nullable',
-            'post_deployment_command_container' => 'nullable',
-            'custom_nginx_configuration' => 'nullable',
-            'is_static' => 'boolean|required',
-            'is_spa' => 'boolean|required',
-            'is_build_server_enabled' => 'boolean|required',
-            'is_container_label_escape_enabled' => 'boolean|required',
-            'is_container_label_readonly_enabled' => 'boolean|required',
-            'is_preserve_repository_enabled' => 'boolean|required',
-            'is_http_basic_auth_enabled' => 'boolean|required',
-            'http_basic_auth_username' => 'string|nullable',
-            'http_basic_auth_password' => 'string|nullable',
-            'watch_paths' => 'nullable',
+            'dockerRegistryImageName' => 'nullable',
+            'dockerRegistryImageTag' => 'nullable',
+            'dockerfileLocation' => 'nullable',
+            'dockerComposeLocation' => 'nullable',
+            'dockerCompose' => 'nullable',
+            'dockerComposeRaw' => 'nullable',
+            'dockerfileTargetBuild' => 'nullable',
+            'dockerComposeCustomStartCommand' => 'nullable',
+            'dockerComposeCustomBuildCommand' => 'nullable',
+            'customLabels' => 'nullable',
+            'customDockerRunOptions' => 'nullable',
+            'preDeploymentCommand' => 'nullable',
+            'preDeploymentCommandContainer' => 'nullable',
+            'postDeploymentCommand' => 'nullable',
+            'postDeploymentCommandContainer' => 'nullable',
+            'customNginxConfiguration' => 'nullable',
+            'isStatic' => 'boolean|required',
+            'isSpa' => 'boolean|required',
+            'isBuildServerEnabled' => 'boolean|required',
+            'isContainerLabelEscapeEnabled' => 'boolean|required',
+            'isContainerLabelReadonlyEnabled' => 'boolean|required',
+            'isPreserveRepositoryEnabled' => 'boolean|required',
+            'isHttpBasicAuthEnabled' => 'boolean|required',
+            'httpBasicAuthUsername' => 'string|nullable',
+            'httpBasicAuthPassword' => 'string|nullable',
+            'watchPaths' => 'nullable',
             'redirect' => 'string|required',
         ];
     }
@@ -193,26 +234,26 @@ protected function messages(): array
                 'name.required' => 'The Name field is required.',
                 'name.regex' => 'The Name may only contain letters, numbers, spaces, dashes (-), underscores (_), dots (.), slashes (/), colons (:), and parentheses ().',
                 'description.regex' => 'The Description contains invalid characters. Only letters, numbers, spaces, and common punctuation (- _ . : / () \' " , ! ? @ # % & + = [] {} | ~ ` *) are allowed.',
-                'git_repository.required' => 'The Git Repository field is required.',
-                'git_branch.required' => 'The Git Branch field is required.',
-                'build_pack.required' => 'The Build Pack field is required.',
-                'static_image.required' => 'The Static Image field is required.',
-                'base_directory.required' => 'The Base Directory field is required.',
-                'ports_exposes.required' => 'The Exposed Ports field is required.',
-                'is_static.required' => 'The Static setting is required.',
-                'is_static.boolean' => 'The Static setting must be true or false.',
-                'is_spa.required' => 'The SPA setting is required.',
-                'is_spa.boolean' => 'The SPA setting must be true or false.',
-                'is_build_server_enabled.required' => 'The Build Server setting is required.',
-                'is_build_server_enabled.boolean' => 'The Build Server setting must be true or false.',
-                'is_container_label_escape_enabled.required' => 'The Container Label Escape setting is required.',
-                'is_container_label_escape_enabled.boolean' => 'The Container Label Escape setting must be true or false.',
-                'is_container_label_readonly_enabled.required' => 'The Container Label Readonly setting is required.',
-                'is_container_label_readonly_enabled.boolean' => 'The Container Label Readonly setting must be true or false.',
-                'is_preserve_repository_enabled.required' => 'The Preserve Repository setting is required.',
-                'is_preserve_repository_enabled.boolean' => 'The Preserve Repository setting must be true or false.',
-                'is_http_basic_auth_enabled.required' => 'The HTTP Basic Auth setting is required.',
-                'is_http_basic_auth_enabled.boolean' => 'The HTTP Basic Auth setting must be true or false.',
+                'gitRepository.required' => 'The Git Repository field is required.',
+                'gitBranch.required' => 'The Git Branch field is required.',
+                'buildPack.required' => 'The Build Pack field is required.',
+                'staticImage.required' => 'The Static Image field is required.',
+                'baseDirectory.required' => 'The Base Directory field is required.',
+                'portsExposes.required' => 'The Exposed Ports field is required.',
+                'isStatic.required' => 'The Static setting is required.',
+                'isStatic.boolean' => 'The Static setting must be true or false.',
+                'isSpa.required' => 'The SPA setting is required.',
+                'isSpa.boolean' => 'The SPA setting must be true or false.',
+                'isBuildServerEnabled.required' => 'The Build Server setting is required.',
+                'isBuildServerEnabled.boolean' => 'The Build Server setting must be true or false.',
+                'isContainerLabelEscapeEnabled.required' => 'The Container Label Escape setting is required.',
+                'isContainerLabelEscapeEnabled.boolean' => 'The Container Label Escape setting must be true or false.',
+                'isContainerLabelReadonlyEnabled.required' => 'The Container Label Readonly setting is required.',
+                'isContainerLabelReadonlyEnabled.boolean' => 'The Container Label Readonly setting must be true or false.',
+                'isPreserveRepositoryEnabled.required' => 'The Preserve Repository setting is required.',
+                'isPreserveRepositoryEnabled.boolean' => 'The Preserve Repository setting must be true or false.',
+                'isHttpBasicAuthEnabled.required' => 'The HTTP Basic Auth setting is required.',
+                'isHttpBasicAuthEnabled.boolean' => 'The HTTP Basic Auth setting must be true or false.',
                 'redirect.required' => 'The Redirect setting is required.',
                 'redirect.string' => 'The Redirect setting must be a string.',
             ]
@@ -220,43 +261,43 @@ protected function messages(): array
     }
 
     protected $validationAttributes = [
-        'application.name' => 'name',
-        'application.description' => 'description',
-        'application.fqdn' => 'FQDN',
-        'application.git_repository' => 'Git repository',
-        'application.git_branch' => 'Git branch',
-        'application.git_commit_sha' => 'Git commit SHA',
-        'application.install_command' => 'Install command',
-        'application.build_command' => 'Build command',
-        'application.start_command' => 'Start command',
-        'application.build_pack' => 'Build pack',
-        'application.static_image' => 'Static image',
-        'application.base_directory' => 'Base directory',
-        'application.publish_directory' => 'Publish directory',
-        'application.ports_exposes' => 'Ports exposes',
-        'application.ports_mappings' => 'Ports mappings',
-        'application.dockerfile' => 'Dockerfile',
-        'application.docker_registry_image_name' => 'Docker registry image name',
-        'application.docker_registry_image_tag' => 'Docker registry image tag',
-        'application.dockerfile_location' => 'Dockerfile location',
-        'application.docker_compose_location' => 'Docker compose location',
-        'application.docker_compose' => 'Docker compose',
-        'application.docker_compose_raw' => 'Docker compose raw',
-        'application.custom_labels' => 'Custom labels',
-        'application.dockerfile_target_build' => 'Dockerfile target build',
-        'application.custom_docker_run_options' => 'Custom docker run commands',
-        'application.custom_network_aliases' => 'Custom docker network aliases',
-        'application.docker_compose_custom_start_command' => 'Docker compose custom start command',
-        'application.docker_compose_custom_build_command' => 'Docker compose custom build command',
-        'application.custom_nginx_configuration' => 'Custom Nginx configuration',
-        'application.settings.is_static' => 'Is static',
-        'application.settings.is_spa' => 'Is SPA',
-        'application.settings.is_build_server_enabled' => 'Is build server enabled',
-        'application.settings.is_container_label_escape_enabled' => 'Is container label escape enabled',
-        'application.settings.is_container_label_readonly_enabled' => 'Is container label readonly',
-        'application.settings.is_preserve_repository_enabled' => 'Is preserve repository enabled',
-        'application.watch_paths' => 'Watch paths',
-        'application.redirect' => 'Redirect',
+        'name' => 'name',
+        'description' => 'description',
+        'fqdn' => 'FQDN',
+        'gitRepository' => 'Git repository',
+        'gitBranch' => 'Git branch',
+        'gitCommitSha' => 'Git commit SHA',
+        'installCommand' => 'Install command',
+        'buildCommand' => 'Build command',
+        'startCommand' => 'Start command',
+        'buildPack' => 'Build pack',
+        'staticImage' => 'Static image',
+        'baseDirectory' => 'Base directory',
+        'publishDirectory' => 'Publish directory',
+        'portsExposes' => 'Ports exposes',
+        'portsMappings' => 'Ports mappings',
+        'dockerfile' => 'Dockerfile',
+        'dockerRegistryImageName' => 'Docker registry image name',
+        'dockerRegistryImageTag' => 'Docker registry image tag',
+        'dockerfileLocation' => 'Dockerfile location',
+        'dockerComposeLocation' => 'Docker compose location',
+        'dockerCompose' => 'Docker compose',
+        'dockerComposeRaw' => 'Docker compose raw',
+        'customLabels' => 'Custom labels',
+        'dockerfileTargetBuild' => 'Dockerfile target build',
+        'customDockerRunOptions' => 'Custom docker run commands',
+        'customNetworkAliases' => 'Custom docker network aliases',
+        'dockerComposeCustomStartCommand' => 'Docker compose custom start command',
+        'dockerComposeCustomBuildCommand' => 'Docker compose custom build command',
+        'customNginxConfiguration' => 'Custom Nginx configuration',
+        'isStatic' => 'Is static',
+        'isSpa' => 'Is SPA',
+        'isBuildServerEnabled' => 'Is build server enabled',
+        'isContainerLabelEscapeEnabled' => 'Is container label escape enabled',
+        'isContainerLabelReadonlyEnabled' => 'Is container label readonly',
+        'isPreserveRepositoryEnabled' => 'Is preserve repository enabled',
+        'watchPaths' => 'Watch paths',
+        'redirect' => 'Redirect',
     ];
 
     public function mount()
@@ -266,14 +307,14 @@ public function mount()
             if (is_null($this->parsedServices) || empty($this->parsedServices)) {
                 $this->dispatch('error', 'Failed to parse your docker-compose file. Please check the syntax and try again.');
                 // Still sync data even if parse fails, so form fields are populated
-                $this->syncFromModel();
+                $this->syncData();
 
                 return;
             }
         } catch (\Throwable $e) {
             $this->dispatch('error', $e->getMessage());
             // Still sync data even on error, so form fields are populated
-            $this->syncFromModel();
+            $this->syncData();
         }
         if ($this->application->build_pack === 'dockercompose') {
             // Only update if user has permission
@@ -325,57 +366,114 @@ public function mount()
 
         // Sync data from model to properties at the END, after all business logic
         // This ensures any modifications to $this->application during mount() are reflected in properties
-        $this->syncFromModel();
+        $this->syncData();
     }
 
-    protected function getModelBindings(): array
+    public function syncData(bool $toModel = false): void
     {
-        return [
-            'name' => 'application.name',
-            'description' => 'application.description',
-            'fqdn' => 'application.fqdn',
-            'git_repository' => 'application.git_repository',
-            'git_branch' => 'application.git_branch',
-            'git_commit_sha' => 'application.git_commit_sha',
-            'install_command' => 'application.install_command',
-            'build_command' => 'application.build_command',
-            'start_command' => 'application.start_command',
-            'build_pack' => 'application.build_pack',
-            'static_image' => 'application.static_image',
-            'base_directory' => 'application.base_directory',
-            'publish_directory' => 'application.publish_directory',
-            'ports_exposes' => 'application.ports_exposes',
-            'ports_mappings' => 'application.ports_mappings',
-            'custom_network_aliases' => 'application.custom_network_aliases',
-            'dockerfile' => 'application.dockerfile',
-            'dockerfile_location' => 'application.dockerfile_location',
-            'dockerfile_target_build' => 'application.dockerfile_target_build',
-            'docker_registry_image_name' => 'application.docker_registry_image_name',
-            'docker_registry_image_tag' => 'application.docker_registry_image_tag',
-            'docker_compose_location' => 'application.docker_compose_location',
-            'docker_compose' => 'application.docker_compose',
-            'docker_compose_raw' => 'application.docker_compose_raw',
-            'docker_compose_custom_start_command' => 'application.docker_compose_custom_start_command',
-            'docker_compose_custom_build_command' => 'application.docker_compose_custom_build_command',
-            'custom_labels' => 'application.custom_labels',
-            'custom_docker_run_options' => 'application.custom_docker_run_options',
-            'pre_deployment_command' => 'application.pre_deployment_command',
-            'pre_deployment_command_container' => 'application.pre_deployment_command_container',
-            'post_deployment_command' => 'application.post_deployment_command',
-            'post_deployment_command_container' => 'application.post_deployment_command_container',
-            'custom_nginx_configuration' => 'application.custom_nginx_configuration',
-            'is_static' => 'application.settings.is_static',
-            'is_spa' => 'application.settings.is_spa',
-            'is_build_server_enabled' => 'application.settings.is_build_server_enabled',
-            'is_preserve_repository_enabled' => 'application.settings.is_preserve_repository_enabled',
-            'is_container_label_escape_enabled' => 'application.settings.is_container_label_escape_enabled',
-            'is_container_label_readonly_enabled' => 'application.settings.is_container_label_readonly_enabled',
-            'is_http_basic_auth_enabled' => 'application.is_http_basic_auth_enabled',
-            'http_basic_auth_username' => 'application.http_basic_auth_username',
-            'http_basic_auth_password' => 'application.http_basic_auth_password',
-            'watch_paths' => 'application.watch_paths',
-            'redirect' => 'application.redirect',
-        ];
+        if ($toModel) {
+            $this->validate();
+
+            // Application properties
+            $this->application->name = $this->name;
+            $this->application->description = $this->description;
+            $this->application->fqdn = $this->fqdn;
+            $this->application->git_repository = $this->gitRepository;
+            $this->application->git_branch = $this->gitBranch;
+            $this->application->git_commit_sha = $this->gitCommitSha;
+            $this->application->install_command = $this->installCommand;
+            $this->application->build_command = $this->buildCommand;
+            $this->application->start_command = $this->startCommand;
+            $this->application->build_pack = $this->buildPack;
+            $this->application->static_image = $this->staticImage;
+            $this->application->base_directory = $this->baseDirectory;
+            $this->application->publish_directory = $this->publishDirectory;
+            $this->application->ports_exposes = $this->portsExposes;
+            $this->application->ports_mappings = $this->portsMappings;
+            $this->application->custom_network_aliases = $this->customNetworkAliases;
+            $this->application->dockerfile = $this->dockerfile;
+            $this->application->dockerfile_location = $this->dockerfileLocation;
+            $this->application->dockerfile_target_build = $this->dockerfileTargetBuild;
+            $this->application->docker_registry_image_name = $this->dockerRegistryImageName;
+            $this->application->docker_registry_image_tag = $this->dockerRegistryImageTag;
+            $this->application->docker_compose_location = $this->dockerComposeLocation;
+            $this->application->docker_compose = $this->dockerCompose;
+            $this->application->docker_compose_raw = $this->dockerComposeRaw;
+            $this->application->docker_compose_custom_start_command = $this->dockerComposeCustomStartCommand;
+            $this->application->docker_compose_custom_build_command = $this->dockerComposeCustomBuildCommand;
+            $this->application->custom_labels = is_null($this->customLabels)
+                ? null
+                : base64_encode($this->customLabels);
+            $this->application->custom_docker_run_options = $this->customDockerRunOptions;
+            $this->application->pre_deployment_command = $this->preDeploymentCommand;
+            $this->application->pre_deployment_command_container = $this->preDeploymentCommandContainer;
+            $this->application->post_deployment_command = $this->postDeploymentCommand;
+            $this->application->post_deployment_command_container = $this->postDeploymentCommandContainer;
+            $this->application->custom_nginx_configuration = $this->customNginxConfiguration;
+            $this->application->is_http_basic_auth_enabled = $this->isHttpBasicAuthEnabled;
+            $this->application->http_basic_auth_username = $this->httpBasicAuthUsername;
+            $this->application->http_basic_auth_password = $this->httpBasicAuthPassword;
+            $this->application->watch_paths = $this->watchPaths;
+            $this->application->redirect = $this->redirect;
+
+            // Application settings properties
+            $this->application->settings->is_static = $this->isStatic;
+            $this->application->settings->is_spa = $this->isSpa;
+            $this->application->settings->is_build_server_enabled = $this->isBuildServerEnabled;
+            $this->application->settings->is_preserve_repository_enabled = $this->isPreserveRepositoryEnabled;
+            $this->application->settings->is_container_label_escape_enabled = $this->isContainerLabelEscapeEnabled;
+            $this->application->settings->is_container_label_readonly_enabled = $this->isContainerLabelReadonlyEnabled;
+
+            $this->application->settings->save();
+        } else {
+            // From model to properties
+            $this->name = $this->application->name;
+            $this->description = $this->application->description;
+            $this->fqdn = $this->application->fqdn;
+            $this->gitRepository = $this->application->git_repository;
+            $this->gitBranch = $this->application->git_branch;
+            $this->gitCommitSha = $this->application->git_commit_sha;
+            $this->installCommand = $this->application->install_command;
+            $this->buildCommand = $this->application->build_command;
+            $this->startCommand = $this->application->start_command;
+            $this->buildPack = $this->application->build_pack;
+            $this->staticImage = $this->application->static_image;
+            $this->baseDirectory = $this->application->base_directory;
+            $this->publishDirectory = $this->application->publish_directory;
+            $this->portsExposes = $this->application->ports_exposes;
+            $this->portsMappings = $this->application->ports_mappings;
+            $this->customNetworkAliases = $this->application->custom_network_aliases;
+            $this->dockerfile = $this->application->dockerfile;
+            $this->dockerfileLocation = $this->application->dockerfile_location;
+            $this->dockerfileTargetBuild = $this->application->dockerfile_target_build;
+            $this->dockerRegistryImageName = $this->application->docker_registry_image_name;
+            $this->dockerRegistryImageTag = $this->application->docker_registry_image_tag;
+            $this->dockerComposeLocation = $this->application->docker_compose_location;
+            $this->dockerCompose = $this->application->docker_compose;
+            $this->dockerComposeRaw = $this->application->docker_compose_raw;
+            $this->dockerComposeCustomStartCommand = $this->application->docker_compose_custom_start_command;
+            $this->dockerComposeCustomBuildCommand = $this->application->docker_compose_custom_build_command;
+            $this->customLabels = $this->application->parseContainerLabels();
+            $this->customDockerRunOptions = $this->application->custom_docker_run_options;
+            $this->preDeploymentCommand = $this->application->pre_deployment_command;
+            $this->preDeploymentCommandContainer = $this->application->pre_deployment_command_container;
+            $this->postDeploymentCommand = $this->application->post_deployment_command;
+            $this->postDeploymentCommandContainer = $this->application->post_deployment_command_container;
+            $this->customNginxConfiguration = $this->application->custom_nginx_configuration;
+            $this->isHttpBasicAuthEnabled = $this->application->is_http_basic_auth_enabled;
+            $this->httpBasicAuthUsername = $this->application->http_basic_auth_username;
+            $this->httpBasicAuthPassword = $this->application->http_basic_auth_password;
+            $this->watchPaths = $this->application->watch_paths;
+            $this->redirect = $this->application->redirect;
+
+            // Application settings properties
+            $this->isStatic = $this->application->settings->is_static;
+            $this->isSpa = $this->application->settings->is_spa;
+            $this->isBuildServerEnabled = $this->application->settings->is_build_server_enabled;
+            $this->isPreserveRepositoryEnabled = $this->application->settings->is_preserve_repository_enabled;
+            $this->isContainerLabelEscapeEnabled = $this->application->settings->is_container_label_escape_enabled;
+            $this->isContainerLabelReadonlyEnabled = $this->application->settings->is_container_label_readonly_enabled;
+        }
     }
 
     public function instantSave()
@@ -386,33 +484,36 @@ public function instantSave()
             $oldPortsExposes = $this->application->ports_exposes;
             $oldIsContainerLabelEscapeEnabled = $this->application->settings->is_container_label_escape_enabled;
             $oldIsPreserveRepositoryEnabled = $this->application->settings->is_preserve_repository_enabled;
+            $oldIsSpa = $this->application->settings->is_spa;
+            $oldIsHttpBasicAuthEnabled = $this->application->is_http_basic_auth_enabled;
 
-            $this->syncToModel();
+            $this->syncData(toModel: true);
 
-            if ($this->application->settings->isDirty('is_spa')) {
-                $this->generateNginxConfiguration($this->application->settings->is_spa ? 'spa' : 'static');
+            if ($oldIsSpa !== $this->isSpa) {
+                $this->generateNginxConfiguration($this->isSpa ? 'spa' : 'static');
             }
-            if ($this->application->isDirty('is_http_basic_auth_enabled')) {
+            if ($oldIsHttpBasicAuthEnabled !== $this->isHttpBasicAuthEnabled) {
                 $this->application->save();
             }
-            $this->application->settings->save();
+
             $this->dispatch('success', 'Settings saved.');
             $this->application->refresh();
-            $this->syncFromModel();
+
+            $this->syncData();
 
             // If port_exposes changed, reset default labels
-            if ($oldPortsExposes !== $this->ports_exposes || $oldIsContainerLabelEscapeEnabled !== $this->is_container_label_escape_enabled) {
+            if ($oldPortsExposes !== $this->portsExposes || $oldIsContainerLabelEscapeEnabled !== $this->isContainerLabelEscapeEnabled) {
                 $this->resetDefaultLabels(false);
             }
-            if ($oldIsPreserveRepositoryEnabled !== $this->is_preserve_repository_enabled) {
-                if ($this->is_preserve_repository_enabled === false) {
+            if ($oldIsPreserveRepositoryEnabled !== $this->isPreserveRepositoryEnabled) {
+                if ($this->isPreserveRepositoryEnabled === false) {
                     $this->application->fileStorages->each(function ($storage) {
-                        $storage->is_based_on_git = $this->is_preserve_repository_enabled;
+                        $storage->is_based_on_git = $this->isPreserveRepositoryEnabled;
                         $storage->save();
                     });
                 }
             }
-            if ($this->is_container_label_readonly_enabled) {
+            if ($this->isContainerLabelReadonlyEnabled) {
                 $this->resetDefaultLabels(false);
             }
         } catch (\Throwable $e) {
@@ -441,7 +542,7 @@ public function loadComposeFile($isInit = false, $showToast = true)
 
             // Sync the docker_compose_raw from the model to the component property
             // This ensures the Monaco editor displays the loaded compose file
-            $this->syncFromModel();
+            $this->syncData();
 
             $this->parsedServiceDomains = $this->application->docker_compose_domains ? json_decode($this->application->docker_compose_domains, true) : [];
             // Convert service names with dots and dashes to use underscores for HTML form binding
@@ -507,7 +608,7 @@ public function generateDomain(string $serviceName)
 
     public function updatedBaseDirectory()
     {
-        if ($this->build_pack === 'dockercompose') {
+        if ($this->buildPack === 'dockercompose') {
             $this->loadComposeFile();
         }
     }
@@ -527,24 +628,24 @@ public function updatedBuildPack()
         } catch (\Illuminate\Auth\Access\AuthorizationException $e) {
             // User doesn't have permission, revert the change and return
             $this->application->refresh();
-            $this->syncFromModel();
+            $this->syncData();
 
             return;
         }
 
         // Sync property to model before checking/modifying
-        $this->syncToModel();
+        $this->syncData(toModel: true);
 
-        if ($this->build_pack !== 'nixpacks') {
-            $this->is_static = false;
+        if ($this->buildPack !== 'nixpacks') {
+            $this->isStatic = false;
             $this->application->settings->is_static = false;
             $this->application->settings->save();
         } else {
-            $this->ports_exposes = 3000;
-            $this->application->ports_exposes = 3000;
+            $this->portsExposes = '3000';
+            $this->application->ports_exposes = '3000';
             $this->resetDefaultLabels(false);
         }
-        if ($this->build_pack === 'dockercompose') {
+        if ($this->buildPack === 'dockercompose') {
             // Only update if user has permission
             try {
                 $this->authorize('update', $this->application);
@@ -567,9 +668,9 @@ public function updatedBuildPack()
                 $this->application->environment_variables_preview()->where('key', 'LIKE', 'SERVICE_URL_%')->delete();
             }
         }
-        if ($this->build_pack === 'static') {
-            $this->ports_exposes = 80;
-            $this->application->ports_exposes = 80;
+        if ($this->buildPack === 'static') {
+            $this->portsExposes = '80';
+            $this->application->ports_exposes = '80';
             $this->resetDefaultLabels(false);
             $this->generateNginxConfiguration();
         }
@@ -586,10 +687,10 @@ public function getWildcardDomain()
             if ($server) {
                 $fqdn = generateUrl(server: $server, random: $this->application->uuid);
                 $this->fqdn = $fqdn;
-                $this->syncToModel();
+                $this->syncData(toModel: true);
                 $this->application->save();
                 $this->application->refresh();
-                $this->syncFromModel();
+                $this->syncData();
                 $this->resetDefaultLabels();
                 $this->dispatch('success', 'Wildcard domain generated.');
             }
@@ -603,11 +704,11 @@ public function generateNginxConfiguration($type = 'static')
         try {
             $this->authorize('update', $this->application);
 
-            $this->custom_nginx_configuration = defaultNginxConfiguration($type);
-            $this->syncToModel();
+            $this->customNginxConfiguration = defaultNginxConfiguration($type);
+            $this->syncData(toModel: true);
             $this->application->save();
             $this->application->refresh();
-            $this->syncFromModel();
+            $this->syncData();
             $this->dispatch('success', 'Nginx configuration generated.');
         } catch (\Throwable $e) {
             return handleError($e, $this);
@@ -617,16 +718,15 @@ public function generateNginxConfiguration($type = 'static')
     public function resetDefaultLabels($manualReset = false)
     {
         try {
-            if (! $this->is_container_label_readonly_enabled && ! $manualReset) {
+            if (! $this->isContainerLabelReadonlyEnabled && ! $manualReset) {
                 return;
             }
             $this->customLabels = str(implode('|coolify|', generateLabelsApplication($this->application)))->replace('|coolify|', "\n");
-            $this->custom_labels = base64_encode($this->customLabels);
-            $this->syncToModel();
+            $this->application->custom_labels = base64_encode($this->customLabels);
             $this->application->save();
             $this->application->refresh();
-            $this->syncFromModel();
-            if ($this->build_pack === 'dockercompose') {
+            $this->syncData();
+            if ($this->buildPack === 'dockercompose') {
                 $this->loadComposeFile(showToast: false);
             }
             $this->dispatch('configurationChanged');
@@ -722,7 +822,7 @@ public function submit($showToaster = true)
                 $this->dispatch('warning', __('warning.sslipdomain'));
             }
 
-            $this->syncToModel();
+            $this->syncData(toModel: true);
 
             if ($this->application->isDirty('redirect')) {
                 $this->setRedirect();
@@ -742,42 +842,42 @@ public function submit($showToaster = true)
                 $this->application->save();
             }
 
-            if ($this->build_pack === 'dockercompose' && $oldDockerComposeLocation !== $this->docker_compose_location) {
+            if ($this->buildPack === 'dockercompose' && $oldDockerComposeLocation !== $this->dockerComposeLocation) {
                 $compose_return = $this->loadComposeFile(showToast: false);
                 if ($compose_return instanceof \Livewire\Features\SupportEvents\Event) {
                     return;
                 }
             }
 
-            if ($oldPortsExposes !== $this->ports_exposes || $oldIsContainerLabelEscapeEnabled !== $this->is_container_label_escape_enabled) {
+            if ($oldPortsExposes !== $this->portsExposes || $oldIsContainerLabelEscapeEnabled !== $this->isContainerLabelEscapeEnabled) {
                 $this->resetDefaultLabels();
             }
-            if ($this->build_pack === 'dockerimage') {
+            if ($this->buildPack === 'dockerimage') {
                 $this->validate([
-                    'docker_registry_image_name' => 'required',
+                    'dockerRegistryImageName' => 'required',
                 ]);
             }
 
-            if ($this->custom_docker_run_options) {
-                $this->custom_docker_run_options = str($this->custom_docker_run_options)->trim()->toString();
-                $this->application->custom_docker_run_options = $this->custom_docker_run_options;
+            if ($this->customDockerRunOptions) {
+                $this->customDockerRunOptions = str($this->customDockerRunOptions)->trim()->toString();
+                $this->application->custom_docker_run_options = $this->customDockerRunOptions;
             }
             if ($this->dockerfile) {
                 $port = get_port_from_dockerfile($this->dockerfile);
-                if ($port && ! $this->ports_exposes) {
-                    $this->ports_exposes = $port;
+                if ($port && ! $this->portsExposes) {
+                    $this->portsExposes = $port;
                     $this->application->ports_exposes = $port;
                 }
             }
-            if ($this->base_directory && $this->base_directory !== '/') {
-                $this->base_directory = rtrim($this->base_directory, '/');
-                $this->application->base_directory = $this->base_directory;
+            if ($this->baseDirectory && $this->baseDirectory !== '/') {
+                $this->baseDirectory = rtrim($this->baseDirectory, '/');
+                $this->application->base_directory = $this->baseDirectory;
             }
-            if ($this->publish_directory && $this->publish_directory !== '/') {
-                $this->publish_directory = rtrim($this->publish_directory, '/');
-                $this->application->publish_directory = $this->publish_directory;
+            if ($this->publishDirectory && $this->publishDirectory !== '/') {
+                $this->publishDirectory = rtrim($this->publishDirectory, '/');
+                $this->application->publish_directory = $this->publishDirectory;
             }
-            if ($this->build_pack === 'dockercompose') {
+            if ($this->buildPack === 'dockercompose') {
                 $this->application->docker_compose_domains = json_encode($this->parsedServiceDomains);
                 if ($this->application->isDirty('docker_compose_domains')) {
                     foreach ($this->parsedServiceDomains as $service) {
@@ -809,11 +909,11 @@ public function submit($showToaster = true)
             $this->application->custom_labels = base64_encode($this->customLabels);
             $this->application->save();
             $this->application->refresh();
-            $this->syncFromModel();
+            $this->syncData();
             $showToaster && ! $warning && $this->dispatch('success', 'Application settings updated!');
         } catch (\Throwable $e) {
             $this->application->refresh();
-            $this->syncFromModel();
+            $this->syncData();
 
             return handleError($e, $this);
         } finally {
@@ -900,4 +1000,23 @@ private function updateServiceEnvironmentVariables()
             }
         }
     }
+
+    public function getDetectedPortInfoProperty(): ?array
+    {
+        $detectedPort = $this->application->detectPortFromEnvironment();
+
+        if (! $detectedPort) {
+            return null;
+        }
+
+        $portsExposesArray = $this->application->ports_exposes_array;
+        $isMatch = in_array($detectedPort, $portsExposesArray);
+        $isEmpty = empty($portsExposesArray);
+
+        return [
+            'port' => $detectedPort,
+            'matches' => $isMatch,
+            'isEmpty' => $isEmpty,
+        ];
+    }
 }

app/Livewire/Project/Application/Heading.php

@@ -101,11 +101,18 @@ public function deploy(bool $force_rebuild = false)
             force_rebuild: $force_rebuild,
         );
         if ($result['status'] === 'skipped') {
-            $this->dispatch('success', 'Deployment skipped', $result['message']);
+            $this->dispatch('error', 'Deployment skipped', $result['message']);
 
             return;
         }
 
+        // Reset restart count on successful deployment
+        $this->application->update([
+            'restart_count' => 0,
+            'last_restart_at' => null,
+            'last_restart_type' => null,
+        ]);
+
         return $this->redirectRoute('project.application.deployment.show', [
             'project_uuid' => $this->parameters['project_uuid'],
             'application_uuid' => $this->parameters['application_uuid'],
@@ -137,6 +144,7 @@ public function restart()
 
             return;
         }
+
         $this->setDeploymentUuid();
         $result = queue_application_deployment(
             application: $this->application,
@@ -149,6 +157,13 @@ public function restart()
             return;
         }
 
+        // Reset restart count on manual restart
+        $this->application->update([
+            'restart_count' => 0,
+            'last_restart_at' => now(),
+            'last_restart_type' => 'manual',
+        ]);
+
         return $this->redirectRoute('project.application.deployment.show', [
             'project_uuid' => $this->parameters['project_uuid'],
             'application_uuid' => $this->parameters['application_uuid'],

app/Livewire/Project/Database/BackupEdit.php

@@ -79,7 +79,7 @@ class BackupEdit extends Component
     #[Validate(['required', 'boolean'])]
     public bool $dumpAll = false;
 
-    #[Validate(['required', 'int', 'min:1', 'max:36000'])]
+    #[Validate(['required', 'int', 'min:60', 'max:36000'])]
     public int $timeout = 3600;
 
     public function mount()

app/Livewire/Project/Service/EditDomain.php

@@ -2,14 +2,16 @@
 
 namespace App\Livewire\Project\Service;
 
-use App\Livewire\Concerns\SynchronizesModelData;
 use App\Models\ServiceApplication;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Livewire\Attributes\Validate;
 use Livewire\Component;
 use Spatie\Url\Url;
 
 class EditDomain extends Component
 {
-    use SynchronizesModelData;
+    use AuthorizesRequests;
+
     public $applicationId;
 
     public ServiceApplication $application;
@@ -20,6 +22,13 @@ class EditDomain extends Component
 
     public $forceSaveDomains = false;
 
+    public $showPortWarningModal = false;
+
+    public $forceRemovePort = false;
+
+    public $requiredPort = null;
+
+    #[Validate(['nullable'])]
     public ?string $fqdn = null;
 
     protected $rules = [
@@ -28,16 +37,25 @@ class EditDomain extends Component
 
     public function mount()
     {
-        $this->application = ServiceApplication::query()->findOrFail($this->applicationId);
+        $this->application = ServiceApplication::ownedByCurrentTeam()->findOrFail($this->applicationId);
         $this->authorize('view', $this->application);
-        $this->syncFromModel();
+        $this->requiredPort = $this->application->getRequiredPort();
+        $this->syncData();
     }
 
-    protected function getModelBindings(): array
+    public function syncData(bool $toModel = false): void
     {
-        return [
-            'fqdn' => 'application.fqdn',
-        ];
+        if ($toModel) {
+            $this->validate();
+
+            // Sync to model
+            $this->application->fqdn = $this->fqdn;
+
+            $this->application->save();
+        } else {
+            // Sync from model
+            $this->fqdn = $this->application->fqdn;
+        }
     }
 
     public function confirmDomainUsage()
@@ -47,6 +65,19 @@ public function confirmDomainUsage()
         $this->submit();
     }
 
+    public function confirmRemovePort()
+    {
+        $this->forceRemovePort = true;
+        $this->showPortWarningModal = false;
+        $this->submit();
+    }
+
+    public function cancelRemovePort()
+    {
+        $this->showPortWarningModal = false;
+        $this->syncData(); // Reset to original FQDN
+    }
+
     public function submit()
     {
         try {
@@ -64,8 +95,8 @@ public function submit()
             if ($warning) {
                 $this->dispatch('warning', __('warning.sslipdomain'));
             }
-            // Sync to model for domain conflict check
-            $this->syncToModel();
+            // Sync to model for domain conflict check (without validation)
+            $this->application->fqdn = $this->fqdn;
             // Check for domain conflicts if not forcing save
             if (! $this->forceSaveDomains) {
                 $result = checkDomainUsage(resource: $this->application);
@@ -80,10 +111,44 @@ public function submit()
                 $this->forceSaveDomains = false;
             }
 
+            // Check for required port
+            if (! $this->forceRemovePort) {
+                $requiredPort = $this->application->getRequiredPort();
+
+                if ($requiredPort !== null) {
+                    // Check if all FQDNs have a port
+                    $fqdns = str($this->fqdn)->trim()->explode(',');
+                    $missingPort = false;
+
+                    foreach ($fqdns as $fqdn) {
+                        $fqdn = trim($fqdn);
+                        if (empty($fqdn)) {
+                            continue;
+                        }
+
+                        $port = ServiceApplication::extractPortFromUrl($fqdn);
+                        if ($port === null) {
+                            $missingPort = true;
+                            break;
+                        }
+                    }
+
+                    if ($missingPort) {
+                        $this->requiredPort = $requiredPort;
+                        $this->showPortWarningModal = true;
+
+                        return;
+                    }
+                }
+            } else {
+                // Reset the force flag after using it
+                $this->forceRemovePort = false;
+            }
+
             $this->validate();
             $this->application->save();
             $this->application->refresh();
-            $this->syncFromModel();
+            $this->syncData();
             updateCompose($this->application);
             if (str($this->application->fqdn)->contains(',')) {
                 $this->dispatch('warning', 'Some services do not support multiple domains, which can lead to problems and is NOT RECOMMENDED.<br><br>Only use multiple domains if you know what you are doing.');
@@ -96,7 +161,7 @@ public function submit()
             $originalFqdn = $this->application->getOriginal('fqdn');
             if ($originalFqdn !== $this->application->fqdn) {
                 $this->application->fqdn = $originalFqdn;
-                $this->syncFromModel();
+                $this->syncData();
             }
 
             return handleError($e, $this);

app/Livewire/Project/Service/FileStorage.php

@@ -2,7 +2,6 @@
 
 namespace App\Livewire\Project\Service;
 
-use App\Livewire\Concerns\SynchronizesModelData;
 use App\Models\Application;
 use App\Models\InstanceSettings;
 use App\Models\LocalFileVolume;
@@ -19,11 +18,12 @@
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Hash;
+use Livewire\Attributes\Validate;
 use Livewire\Component;
 
 class FileStorage extends Component
 {
-    use AuthorizesRequests, SynchronizesModelData;
+    use AuthorizesRequests;
 
     public LocalFileVolume $fileStorage;
 
@@ -37,8 +37,10 @@ class FileStorage extends Component
 
     public bool $isReadOnly = false;
 
+    #[Validate(['nullable'])]
     public ?string $content = null;
 
+    #[Validate(['required', 'boolean'])]
     public bool $isBasedOnGit = false;
 
     protected $rules = [
@@ -61,15 +63,24 @@ public function mount()
         }
 
         $this->isReadOnly = $this->fileStorage->isReadOnlyVolume();
-        $this->syncFromModel();
+        $this->syncData();
     }
 
-    protected function getModelBindings(): array
+    public function syncData(bool $toModel = false): void
     {
-        return [
-            'content' => 'fileStorage.content',
-            'isBasedOnGit' => 'fileStorage.is_based_on_git',
-        ];
+        if ($toModel) {
+            $this->validate();
+
+            // Sync to model
+            $this->fileStorage->content = $this->content;
+            $this->fileStorage->is_based_on_git = $this->isBasedOnGit;
+
+            $this->fileStorage->save();
+        } else {
+            // Sync from model
+            $this->content = $this->fileStorage->content;
+            $this->isBasedOnGit = $this->fileStorage->is_based_on_git;
+        }
     }
 
     public function convertToDirectory()
@@ -96,7 +107,7 @@ public function loadStorageOnServer()
             $this->authorize('update', $this->resource);
 
             $this->fileStorage->loadStorageOnServer();
-            $this->syncFromModel();
+            $this->syncData();
             $this->dispatch('success', 'File storage loaded from server.');
         } catch (\Throwable $e) {
             return handleError($e, $this);
@@ -165,14 +176,16 @@ public function submit()
             if ($this->fileStorage->is_directory) {
                 $this->content = null;
             }
-            $this->syncToModel();
+            // Sync component properties to model
+            $this->fileStorage->content = $this->content;
+            $this->fileStorage->is_based_on_git = $this->isBasedOnGit;
             $this->fileStorage->save();
             $this->fileStorage->saveStorageOnServer();
             $this->dispatch('success', 'File updated.');
         } catch (\Throwable $e) {
             $this->fileStorage->setRawAttributes($original);
             $this->fileStorage->save();
-            $this->syncFromModel();
+            $this->syncData();
 
             return handleError($e, $this);
         }

app/Livewire/Project/Service/ServiceApplicationView.php

@@ -2,20 +2,19 @@
 
 namespace App\Livewire\Project\Service;
 
-use App\Livewire\Concerns\SynchronizesModelData;
 use App\Models\InstanceSettings;
 use App\Models\ServiceApplication;
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Hash;
+use Livewire\Attributes\Validate;
 use Livewire\Component;
 use Spatie\Url\Url;
 
 class ServiceApplicationView extends Component
 {
     use AuthorizesRequests;
-    use SynchronizesModelData;
 
     public ServiceApplication $application;
 
@@ -31,20 +30,34 @@ class ServiceApplicationView extends Component
 
     public $forceSaveDomains = false;
 
+    public $showPortWarningModal = false;
+
+    public $forceRemovePort = false;
+
+    public $requiredPort = null;
+
+    #[Validate(['nullable'])]
     public ?string $humanName = null;
 
+    #[Validate(['nullable'])]
     public ?string $description = null;
 
+    #[Validate(['nullable'])]
     public ?string $fqdn = null;
 
+    #[Validate(['string', 'nullable'])]
     public ?string $image = null;
 
+    #[Validate(['required', 'boolean'])]
     public bool $excludeFromStatus = false;
 
+    #[Validate(['nullable', 'boolean'])]
     public bool $isLogDrainEnabled = false;
 
+    #[Validate(['nullable', 'boolean'])]
     public bool $isGzipEnabled = false;
 
+    #[Validate(['nullable', 'boolean'])]
     public bool $isStripprefixEnabled = false;
 
     protected $rules = [
@@ -79,7 +92,15 @@ public function instantSaveAdvanced()
 
                 return;
             }
-            $this->syncToModel();
+            // Sync component properties to model
+            $this->application->human_name = $this->humanName;
+            $this->application->description = $this->description;
+            $this->application->fqdn = $this->fqdn;
+            $this->application->image = $this->image;
+            $this->application->exclude_from_status = $this->excludeFromStatus;
+            $this->application->is_log_drain_enabled = $this->isLogDrainEnabled;
+            $this->application->is_gzip_enabled = $this->isGzipEnabled;
+            $this->application->is_stripprefix_enabled = $this->isStripprefixEnabled;
             $this->application->save();
             $this->dispatch('success', 'You need to restart the service for the changes to take effect.');
         } catch (\Throwable $e) {
@@ -114,24 +135,53 @@ public function mount()
         try {
             $this->parameters = get_route_parameters();
             $this->authorize('view', $this->application);
-            $this->syncFromModel();
+            $this->requiredPort = $this->application->getRequiredPort();
+            $this->syncData();
         } catch (\Throwable $e) {
             return handleError($e, $this);
         }
     }
 
-    protected function getModelBindings(): array
+    public function confirmRemovePort()
     {
-        return [
-            'humanName' => 'application.human_name',
-            'description' => 'application.description',
-            'fqdn' => 'application.fqdn',
-            'image' => 'application.image',
-            'excludeFromStatus' => 'application.exclude_from_status',
-            'isLogDrainEnabled' => 'application.is_log_drain_enabled',
-            'isGzipEnabled' => 'application.is_gzip_enabled',
-            'isStripprefixEnabled' => 'application.is_stripprefix_enabled',
-        ];
+        $this->forceRemovePort = true;
+        $this->showPortWarningModal = false;
+        $this->submit();
+    }
+
+    public function cancelRemovePort()
+    {
+        $this->showPortWarningModal = false;
+        $this->syncData(); // Reset to original FQDN
+    }
+
+    public function syncData(bool $toModel = false): void
+    {
+        if ($toModel) {
+            $this->validate();
+
+            // Sync to model
+            $this->application->human_name = $this->humanName;
+            $this->application->description = $this->description;
+            $this->application->fqdn = $this->fqdn;
+            $this->application->image = $this->image;
+            $this->application->exclude_from_status = $this->excludeFromStatus;
+            $this->application->is_log_drain_enabled = $this->isLogDrainEnabled;
+            $this->application->is_gzip_enabled = $this->isGzipEnabled;
+            $this->application->is_stripprefix_enabled = $this->isStripprefixEnabled;
+
+            $this->application->save();
+        } else {
+            // Sync from model
+            $this->humanName = $this->application->human_name;
+            $this->description = $this->application->description;
+            $this->fqdn = $this->application->fqdn;
+            $this->image = $this->application->image;
+            $this->excludeFromStatus = data_get($this->application, 'exclude_from_status', false);
+            $this->isLogDrainEnabled = data_get($this->application, 'is_log_drain_enabled', false);
+            $this->isGzipEnabled = data_get($this->application, 'is_gzip_enabled', true);
+            $this->isStripprefixEnabled = data_get($this->application, 'is_stripprefix_enabled', true);
+        }
     }
 
     public function convertToDatabase()
@@ -193,8 +243,15 @@ public function submit()
             if ($warning) {
                 $this->dispatch('warning', __('warning.sslipdomain'));
             }
-            // Sync to model for domain conflict check
-            $this->syncToModel();
+            // Sync to model for domain conflict check (without validation)
+            $this->application->human_name = $this->humanName;
+            $this->application->description = $this->description;
+            $this->application->fqdn = $this->fqdn;
+            $this->application->image = $this->image;
+            $this->application->exclude_from_status = $this->excludeFromStatus;
+            $this->application->is_log_drain_enabled = $this->isLogDrainEnabled;
+            $this->application->is_gzip_enabled = $this->isGzipEnabled;
+            $this->application->is_stripprefix_enabled = $this->isStripprefixEnabled;
             // Check for domain conflicts if not forcing save
             if (! $this->forceSaveDomains) {
                 $result = checkDomainUsage(resource: $this->application);
@@ -209,10 +266,44 @@ public function submit()
                 $this->forceSaveDomains = false;
             }
 
+            // Check for required port
+            if (! $this->forceRemovePort) {
+                $requiredPort = $this->application->getRequiredPort();
+
+                if ($requiredPort !== null) {
+                    // Check if all FQDNs have a port
+                    $fqdns = str($this->fqdn)->trim()->explode(',');
+                    $missingPort = false;
+
+                    foreach ($fqdns as $fqdn) {
+                        $fqdn = trim($fqdn);
+                        if (empty($fqdn)) {
+                            continue;
+                        }
+
+                        $port = ServiceApplication::extractPortFromUrl($fqdn);
+                        if ($port === null) {
+                            $missingPort = true;
+                            break;
+                        }
+                    }
+
+                    if ($missingPort) {
+                        $this->requiredPort = $requiredPort;
+                        $this->showPortWarningModal = true;
+
+                        return;
+                    }
+                }
+            } else {
+                // Reset the force flag after using it
+                $this->forceRemovePort = false;
+            }
+
             $this->validate();
             $this->application->save();
             $this->application->refresh();
-            $this->syncFromModel();
+            $this->syncData();
             updateCompose($this->application);
             if (str($this->application->fqdn)->contains(',')) {
                 $this->dispatch('warning', 'Some services do not support multiple domains, which can lead to problems and is NOT RECOMMENDED.<br><br>Only use multiple domains if you know what you are doing.');
@@ -224,7 +315,7 @@ public function submit()
             $originalFqdn = $this->application->getOriginal('fqdn');
             if ($originalFqdn !== $this->application->fqdn) {
                 $this->application->fqdn = $originalFqdn;
-                $this->syncFromModel();
+                $this->syncData();
             }
 
             return handleError($e, $this);

app/Livewire/Project/Service/StackForm.php

@@ -5,6 +5,7 @@
 use App\Models\Service;
 use App\Support\ValidationPatterns;
 use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
 use Livewire\Component;
 
 class StackForm extends Component
@@ -22,7 +23,7 @@ class StackForm extends Component
 
     public string $dockerComposeRaw;
 
-    public string $dockerCompose;
+    public ?string $dockerCompose = null;
 
     public ?bool $connectToDockerNetwork = null;
 
@@ -30,7 +31,7 @@ protected function rules(): array
     {
         $baseRules = [
             'dockerComposeRaw' => 'required',
-            'dockerCompose' => 'required',
+            'dockerCompose' => 'nullable',
             'name' => ValidationPatterns::nameRules(),
             'description' => ValidationPatterns::descriptionRules(),
             'connectToDockerNetwork' => 'nullable',
@@ -140,18 +141,27 @@ public function submit($notify = true)
             $this->validate();
             $this->syncData(true);
 
-            // Validate for command injection BEFORE saving to database
+            // Validate for command injection BEFORE any database operations
             validateDockerComposeForInjection($this->service->docker_compose_raw);
 
-            $this->service->save();
-            $this->service->saveExtraFields($this->fields);
-            $this->service->parse();
+            // Use transaction to ensure atomicity - if parse fails, save is rolled back
+            DB::transaction(function () {
+                $this->service->save();
+                $this->service->saveExtraFields($this->fields);
+                $this->service->parse();
+            });
+            // Refresh and write files after a successful commit
             $this->service->refresh();
             $this->service->saveComposeConfigs();
+
             $this->dispatch('refreshEnvs');
             $this->dispatch('refreshServices');
             $notify && $this->dispatch('success', 'Service saved.');
         } catch (\Throwable $e) {
+            // On error, refresh from database to restore clean state
+            $this->service->refresh();
+            $this->syncData(false);
+
             return handleError($e, $this);
         } finally {
             if (is_null($this->service->config_hash)) {

app/Livewire/Project/Shared/HealthChecks.php

@@ -2,42 +2,54 @@
 
 namespace App\Livewire\Project\Shared;
 
-use App\Livewire\Concerns\SynchronizesModelData;
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Livewire\Attributes\Validate;
 use Livewire\Component;
 
 class HealthChecks extends Component
 {
     use AuthorizesRequests;
-    use SynchronizesModelData;
 
     public $resource;
 
     // Explicit properties
+    #[Validate(['boolean'])]
     public bool $healthCheckEnabled = false;
 
+    #[Validate(['string'])]
     public string $healthCheckMethod;
 
+    #[Validate(['string'])]
     public string $healthCheckScheme;
 
+    #[Validate(['string'])]
     public string $healthCheckHost;
 
+    #[Validate(['nullable', 'string'])]
     public ?string $healthCheckPort = null;
 
+    #[Validate(['string'])]
     public string $healthCheckPath;
 
+    #[Validate(['integer'])]
     public int $healthCheckReturnCode;
 
+    #[Validate(['nullable', 'string'])]
     public ?string $healthCheckResponseText = null;
 
+    #[Validate(['integer', 'min:1'])]
     public int $healthCheckInterval;
 
+    #[Validate(['integer', 'min:1'])]
     public int $healthCheckTimeout;
 
+    #[Validate(['integer', 'min:1'])]
     public int $healthCheckRetries;
 
+    #[Validate(['integer'])]
     public int $healthCheckStartPeriod;
 
+    #[Validate(['boolean'])]
     public bool $customHealthcheckFound = false;
 
     protected $rules = [
@@ -56,36 +68,69 @@ class HealthChecks extends Component
         'customHealthcheckFound' => 'boolean',
     ];
 
-    protected function getModelBindings(): array
-    {
-        return [
-            'healthCheckEnabled' => 'resource.health_check_enabled',
-            'healthCheckMethod' => 'resource.health_check_method',
-            'healthCheckScheme' => 'resource.health_check_scheme',
-            'healthCheckHost' => 'resource.health_check_host',
-            'healthCheckPort' => 'resource.health_check_port',
-            'healthCheckPath' => 'resource.health_check_path',
-            'healthCheckReturnCode' => 'resource.health_check_return_code',
-            'healthCheckResponseText' => 'resource.health_check_response_text',
-            'healthCheckInterval' => 'resource.health_check_interval',
-            'healthCheckTimeout' => 'resource.health_check_timeout',
-            'healthCheckRetries' => 'resource.health_check_retries',
-            'healthCheckStartPeriod' => 'resource.health_check_start_period',
-            'customHealthcheckFound' => 'resource.custom_healthcheck_found',
-        ];
-    }
-
     public function mount()
     {
         $this->authorize('view', $this->resource);
-        $this->syncFromModel();
+        $this->syncData();
+    }
+
+    public function syncData(bool $toModel = false): void
+    {
+        if ($toModel) {
+            $this->validate();
+
+            // Sync to model
+            $this->resource->health_check_enabled = $this->healthCheckEnabled;
+            $this->resource->health_check_method = $this->healthCheckMethod;
+            $this->resource->health_check_scheme = $this->healthCheckScheme;
+            $this->resource->health_check_host = $this->healthCheckHost;
+            $this->resource->health_check_port = $this->healthCheckPort;
+            $this->resource->health_check_path = $this->healthCheckPath;
+            $this->resource->health_check_return_code = $this->healthCheckReturnCode;
+            $this->resource->health_check_response_text = $this->healthCheckResponseText;
+            $this->resource->health_check_interval = $this->healthCheckInterval;
+            $this->resource->health_check_timeout = $this->healthCheckTimeout;
+            $this->resource->health_check_retries = $this->healthCheckRetries;
+            $this->resource->health_check_start_period = $this->healthCheckStartPeriod;
+            $this->resource->custom_healthcheck_found = $this->customHealthcheckFound;
+
+            $this->resource->save();
+        } else {
+            // Sync from model
+            $this->healthCheckEnabled = $this->resource->health_check_enabled;
+            $this->healthCheckMethod = $this->resource->health_check_method;
+            $this->healthCheckScheme = $this->resource->health_check_scheme;
+            $this->healthCheckHost = $this->resource->health_check_host;
+            $this->healthCheckPort = $this->resource->health_check_port;
+            $this->healthCheckPath = $this->resource->health_check_path;
+            $this->healthCheckReturnCode = $this->resource->health_check_return_code;
+            $this->healthCheckResponseText = $this->resource->health_check_response_text;
+            $this->healthCheckInterval = $this->resource->health_check_interval;
+            $this->healthCheckTimeout = $this->resource->health_check_timeout;
+            $this->healthCheckRetries = $this->resource->health_check_retries;
+            $this->healthCheckStartPeriod = $this->resource->health_check_start_period;
+            $this->customHealthcheckFound = $this->resource->custom_healthcheck_found;
+        }
     }
 
     public function instantSave()
     {
         $this->authorize('update', $this->resource);
 
-        $this->syncToModel();
+        // Sync component properties to model
+        $this->resource->health_check_enabled = $this->healthCheckEnabled;
+        $this->resource->health_check_method = $this->healthCheckMethod;
+        $this->resource->health_check_scheme = $this->healthCheckScheme;
+        $this->resource->health_check_host = $this->healthCheckHost;
+        $this->resource->health_check_port = $this->healthCheckPort;
+        $this->resource->health_check_path = $this->healthCheckPath;
+        $this->resource->health_check_return_code = $this->healthCheckReturnCode;
+        $this->resource->health_check_response_text = $this->healthCheckResponseText;
+        $this->resource->health_check_interval = $this->healthCheckInterval;
+        $this->resource->health_check_timeout = $this->healthCheckTimeout;
+        $this->resource->health_check_retries = $this->healthCheckRetries;
+        $this->resource->health_check_start_period = $this->healthCheckStartPeriod;
+        $this->resource->custom_healthcheck_found = $this->customHealthcheckFound;
         $this->resource->save();
         $this->dispatch('success', 'Health check updated.');
     }
@@ -96,7 +141,20 @@ public function submit()
             $this->authorize('update', $this->resource);
             $this->validate();
 
-            $this->syncToModel();
+            // Sync component properties to model
+            $this->resource->health_check_enabled = $this->healthCheckEnabled;
+            $this->resource->health_check_method = $this->healthCheckMethod;
+            $this->resource->health_check_scheme = $this->healthCheckScheme;
+            $this->resource->health_check_host = $this->healthCheckHost;
+            $this->resource->health_check_port = $this->healthCheckPort;
+            $this->resource->health_check_path = $this->healthCheckPath;
+            $this->resource->health_check_return_code = $this->healthCheckReturnCode;
+            $this->resource->health_check_response_text = $this->healthCheckResponseText;
+            $this->resource->health_check_interval = $this->healthCheckInterval;
+            $this->resource->health_check_timeout = $this->healthCheckTimeout;
+            $this->resource->health_check_retries = $this->healthCheckRetries;
+            $this->resource->health_check_start_period = $this->healthCheckStartPeriod;
+            $this->resource->custom_healthcheck_found = $this->customHealthcheckFound;
             $this->resource->save();
             $this->dispatch('success', 'Health check updated.');
         } catch (\Throwable $e) {
@@ -111,7 +169,20 @@ public function toggleHealthcheck()
             $wasEnabled = $this->healthCheckEnabled;
             $this->healthCheckEnabled = ! $this->healthCheckEnabled;
 
-            $this->syncToModel();
+            // Sync component properties to model
+            $this->resource->health_check_enabled = $this->healthCheckEnabled;
+            $this->resource->health_check_method = $this->healthCheckMethod;
+            $this->resource->health_check_scheme = $this->healthCheckScheme;
+            $this->resource->health_check_host = $this->healthCheckHost;
+            $this->resource->health_check_port = $this->healthCheckPort;
+            $this->resource->health_check_path = $this->healthCheckPath;
+            $this->resource->health_check_return_code = $this->healthCheckReturnCode;
+            $this->resource->health_check_response_text = $this->healthCheckResponseText;
+            $this->resource->health_check_interval = $this->healthCheckInterval;
+            $this->resource->health_check_timeout = $this->healthCheckTimeout;
+            $this->resource->health_check_retries = $this->healthCheckRetries;
+            $this->resource->health_check_start_period = $this->healthCheckStartPeriod;
+            $this->resource->custom_healthcheck_found = $this->customHealthcheckFound;
             $this->resource->save();
 
             if ($this->healthCheckEnabled && ! $wasEnabled && $this->resource->isRunning()) {

app/Livewire/Project/Shared/ScheduledTask/Add.php

@@ -34,11 +34,14 @@ class Add extends Component
 
     public ?string $container = '';
 
+    public int $timeout = 300;
+
     protected $rules = [
         'name' => 'required|string',
         'command' => 'required|string',
         'frequency' => 'required|string',
         'container' => 'nullable|string',
+        'timeout' => 'required|integer|min:60|max:3600',
     ];
 
     protected $validationAttributes = [
@@ -46,6 +49,7 @@ class Add extends Component
         'command' => 'command',
         'frequency' => 'frequency',
         'container' => 'container',
+        'timeout' => 'timeout',
     ];
 
     public function mount()
@@ -103,6 +107,7 @@ public function saveScheduledTask()
             $task->command = $this->command;
             $task->frequency = $this->frequency;
             $task->container = $this->container;
+            $task->timeout = $this->timeout;
             $task->team_id = currentTeam()->id;
 
             switch ($this->type) {
@@ -130,5 +135,6 @@ public function clear()
         $this->command = '';
         $this->frequency = '';
         $this->container = '';
+        $this->timeout = 300;
     }
 }

app/Livewire/Project/Shared/ScheduledTask/Show.php

@@ -40,6 +40,9 @@ class Show extends Component
     #[Validate(['string', 'nullable'])]
     public ?string $container = null;
 
+    #[Validate(['integer', 'required', 'min:60', 'max:3600'])]
+    public $timeout = 300;
+
     #[Locked]
     public ?string $application_uuid;
 
@@ -99,6 +102,7 @@ public function syncData(bool $toModel = false)
             $this->task->command = str($this->command)->trim()->value();
             $this->task->frequency = str($this->frequency)->trim()->value();
             $this->task->container = str($this->container)->trim()->value();
+            $this->task->timeout = (int) $this->timeout;
             $this->task->save();
         } else {
             $this->isEnabled = $this->task->enabled;
@@ -106,6 +110,7 @@ public function syncData(bool $toModel = false)
             $this->command = $this->task->command;
             $this->frequency = $this->task->frequency;
             $this->container = $this->task->container;
+            $this->timeout = $this->task->timeout ?? 300;
         }
     }
 

app/Livewire/Settings/Index.php

@@ -35,6 +35,9 @@ class Index extends Component
     #[Validate('required|string|timezone')]
     public string $instance_timezone;
 
+    #[Validate('nullable|string|max:50')]
+    public ?string $dev_helper_version = null;
+
     public array $domainConflicts = [];
 
     public bool $showDomainConflictModal = false;
@@ -60,6 +63,7 @@ public function mount()
         $this->public_ipv4 = $this->settings->public_ipv4;
         $this->public_ipv6 = $this->settings->public_ipv6;
         $this->instance_timezone = $this->settings->instance_timezone;
+        $this->dev_helper_version = $this->settings->dev_helper_version;
     }
 
     #[Computed]
@@ -81,6 +85,7 @@ public function instantSave($isSave = true)
         $this->settings->public_ipv4 = $this->public_ipv4;
         $this->settings->public_ipv6 = $this->public_ipv6;
         $this->settings->instance_timezone = $this->instance_timezone;
+        $this->settings->dev_helper_version = $this->dev_helper_version;
         if ($isSave) {
             $this->settings->save();
             $this->dispatch('success', 'Settings updated!');

app/Models/Application.php

@@ -120,8 +120,9 @@ class Application extends BaseModel
     protected $appends = ['server_status'];
 
     protected $casts = [
-        'custom_network_aliases' => 'array',
         'http_basic_auth_password' => 'encrypted',
+        'restart_count' => 'integer',
+        'last_restart_at' => 'datetime',
     ];
 
     protected static function booted()
@@ -253,6 +254,30 @@ public function customNetworkAliases(): Attribute
                     return null;
                 }
 
+                if (is_string($value) && $this->isJson($value)) {
+                    $decoded = json_decode($value, true);
+
+                    // Return as comma-separated string, not array
+                    return is_array($decoded) ? implode(',', $decoded) : $value;
+                }
+
+                return $value;
+            }
+        );
+    }
+
+    /**
+     * Get custom_network_aliases as an array
+     */
+    public function customNetworkAliasesArray(): Attribute
+    {
+        return Attribute::make(
+            get: function () {
+                $value = $this->getRawOriginal('custom_network_aliases');
+                if (is_null($value)) {
+                    return null;
+                }
+
                 if (is_string($value) && $this->isJson($value)) {
                     return json_decode($value, true);
                 }
@@ -749,6 +774,24 @@ public function main_port()
         return $this->settings->is_static ? [80] : $this->ports_exposes_array;
     }
 
+    public function detectPortFromEnvironment(?bool $isPreview = false): ?int
+    {
+        $envVars = $isPreview
+            ? $this->environment_variables_preview
+            : $this->environment_variables;
+
+        $portVar = $envVars->firstWhere('key', 'PORT');
+
+        if ($portVar && $portVar->real_value) {
+            $portValue = trim($portVar->real_value);
+            if (is_numeric($portValue)) {
+                return (int) $portValue;
+            }
+        }
+
+        return null;
+    }
+
     public function environment_variables()
     {
         return $this->morphMany(EnvironmentVariable::class, 'resourceable')
@@ -957,7 +1000,7 @@ public function isLogDrainEnabled()
 
     public function isConfigurationChanged(bool $save = false)
     {
-        $newConfigHash = base64_encode($this->fqdn.$this->git_repository.$this->git_branch.$this->git_commit_sha.$this->build_pack.$this->static_image.$this->install_command.$this->build_command.$this->start_command.$this->ports_exposes.$this->ports_mappings.$this->base_directory.$this->publish_directory.$this->dockerfile.$this->dockerfile_location.$this->custom_labels.$this->custom_docker_run_options.$this->dockerfile_target_build.$this->redirect.$this->custom_nginx_configuration.$this->custom_labels.$this->settings->use_build_secrets);
+        $newConfigHash = base64_encode($this->fqdn.$this->git_repository.$this->git_branch.$this->git_commit_sha.$this->build_pack.$this->static_image.$this->install_command.$this->build_command.$this->start_command.$this->ports_exposes.$this->ports_mappings.$this->custom_network_aliases.$this->base_directory.$this->publish_directory.$this->dockerfile.$this->dockerfile_location.$this->custom_labels.$this->custom_docker_run_options.$this->dockerfile_target_build.$this->redirect.$this->custom_nginx_configuration.$this->settings->use_build_secrets);
         if ($this->pull_request_id === 0 || $this->pull_request_id === null) {
             $newConfigHash .= json_encode($this->environment_variables()->get(['value',  'is_multiline', 'is_literal', 'is_buildtime', 'is_runtime'])->sort());
         } else {

app/Models/ApplicationSetting.php

@@ -7,8 +7,14 @@
 
 class ApplicationSetting extends Model
 {
-    protected $cast = [
+    protected $casts = [
         'is_static' => 'boolean',
+        'is_spa' => 'boolean',
+        'is_build_server_enabled' => 'boolean',
+        'is_preserve_repository_enabled' => 'boolean',
+        'is_container_label_escape_enabled' => 'boolean',
+        'is_container_label_readonly_enabled' => 'boolean',
+        'use_build_secrets' => 'boolean',
         'is_auto_deploy_enabled' => 'boolean',
         'is_force_https_enabled' => 'boolean',
         'is_debug_enabled' => 'boolean',

app/Models/ScheduledTask.php

@@ -12,6 +12,14 @@ class ScheduledTask extends BaseModel
 
     protected $guarded = [];
 
+    protected function casts(): array
+    {
+        return [
+            'enabled' => 'boolean',
+            'timeout' => 'integer',
+        ];
+    }
+
     public function service()
     {
         return $this->belongsTo(Service::class);

app/Models/ScheduledTaskExecution.php

@@ -8,6 +8,16 @@ class ScheduledTaskExecution extends BaseModel
 {
     protected $guarded = [];
 
+    protected function casts(): array
+    {
+        return [
+            'started_at' => 'datetime',
+            'finished_at' => 'datetime',
+            'retry_count' => 'integer',
+            'duration' => 'decimal:2',
+        ];
+    }
+
     public function scheduledTask(): BelongsTo
     {
         return $this->belongsTo(ScheduledTask::class);

app/Models/Service.php

@@ -1184,6 +1184,31 @@ public function documentation()
         return data_get($service, 'documentation', config('constants.urls.docs'));
     }
 
+    /**
+     * Get the required port for this service from the template definition.
+     */
+    public function getRequiredPort(): ?int
+    {
+        try {
+            $services = get_service_templates();
+            $serviceName = str($this->name)->beforeLast('-')->value();
+            $service = data_get($services, $serviceName, []);
+            $port = data_get($service, 'port');
+
+            return $port ? (int) $port : null;
+        } catch (\Throwable) {
+            return null;
+        }
+    }
+
+    /**
+     * Check if this service requires a port to function correctly.
+     */
+    public function requiresPort(): bool
+    {
+        return $this->getRequiredPort() !== null;
+    }
+
     public function applications()
     {
         return $this->hasMany(ServiceApplication::class);
@@ -1262,6 +1287,11 @@ public function workdir()
 
     public function saveComposeConfigs()
     {
+        // Guard against null or empty docker_compose
+        if (! $this->docker_compose) {
+            return;
+        }
+
         $workdir = $this->workdir();
 
         instant_remote_process([

app/Models/ServiceApplication.php

@@ -109,6 +109,11 @@ public function fileStorages()
         return $this->morphMany(LocalFileVolume::class, 'resource');
     }
 
+    public function environment_variables()
+    {
+        return $this->morphMany(EnvironmentVariable::class, 'resourceable');
+    }
+
     public function fqdns(): Attribute
     {
         return Attribute::make(
@@ -118,6 +123,53 @@ public function fqdns(): Attribute
         );
     }
 
+    /**
+     * Extract port number from a given FQDN URL.
+     * Returns null if no port is specified.
+     */
+    public static function extractPortFromUrl(string $url): ?int
+    {
+        try {
+            // Ensure URL has a scheme for proper parsing
+            if (! str_starts_with($url, 'http://') && ! str_starts_with($url, 'https://')) {
+                $url = 'http://'.$url;
+            }
+
+            $parsed = parse_url($url);
+            $port = $parsed['port'] ?? null;
+
+            return $port ? (int) $port : null;
+        } catch (\Throwable) {
+            return null;
+        }
+    }
+
+    /**
+     * Check if all FQDNs have a port specified.
+     */
+    public function allFqdnsHavePort(): bool
+    {
+        if (is_null($this->fqdn) || $this->fqdn === '') {
+            return false;
+        }
+
+        $fqdns = explode(',', $this->fqdn);
+
+        foreach ($fqdns as $fqdn) {
+            $fqdn = trim($fqdn);
+            if (empty($fqdn)) {
+                continue;
+            }
+
+            $port = self::extractPortFromUrl($fqdn);
+            if ($port === null) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     public function getFilesFromServer(bool $isInit = false)
     {
         getFilesystemVolumesFromServer($this, $isInit);
@@ -127,4 +179,77 @@ public function isBackupSolutionAvailable()
     {
         return false;
     }
+
+    /**
+     * Get the required port for this service application.
+     * Extracts port from SERVICE_URL_* or SERVICE_FQDN_* environment variables
+     * stored at the Service level, filtering by normalized container name.
+     * Falls back to service-level port if no port-specific variable is found.
+     */
+    public function getRequiredPort(): ?int
+    {
+        try {
+            // Normalize container name same way as variable creation
+            // (uppercase, replace - and . with _)
+            $normalizedName = str($this->name)
+                ->upper()
+                ->replace('-', '_')
+                ->replace('.', '_')
+                ->value();
+            // Get all environment variables from the service
+            $serviceEnvVars = $this->service->environment_variables()->get();
+
+            // Look for SERVICE_FQDN_* or SERVICE_URL_* variables that match this container
+            foreach ($serviceEnvVars as $envVar) {
+                $key = str($envVar->key);
+
+                // Check if this is a SERVICE_FQDN_* or SERVICE_URL_* variable
+                if (! $key->startsWith('SERVICE_FQDN_') && ! $key->startsWith('SERVICE_URL_')) {
+                    continue;
+                }
+                // Extract the part after SERVICE_FQDN_ or SERVICE_URL_
+                if ($key->startsWith('SERVICE_FQDN_')) {
+                    $suffix = $key->after('SERVICE_FQDN_');
+                } else {
+                    $suffix = $key->after('SERVICE_URL_');
+                }
+
+                // Check if this variable starts with our normalized container name
+                // Format: {NORMALIZED_NAME}_{PORT} or just {NORMALIZED_NAME}
+                if (! $suffix->startsWith($normalizedName)) {
+                    \Log::debug('[ServiceApplication::getRequiredPort] Suffix does not match container', [
+                        'expected_start' => $normalizedName,
+                        'actual_suffix' => $suffix->value(),
+                    ]);
+
+                    continue;
+                }
+
+                // Check if there's a port suffix after the container name
+                // The suffix should be exactly NORMALIZED_NAME or NORMALIZED_NAME_PORT
+                $afterName = $suffix->after($normalizedName)->value();
+
+                // If there's content after the name, it should start with underscore
+                if ($afterName !== '' && str($afterName)->startsWith('_')) {
+                    // Extract port: _3210 -> 3210
+                    $port = str($afterName)->after('_')->value();
+                    // Validate that the extracted port is numeric
+                    if (is_numeric($port)) {
+                        \Log::debug('[ServiceApplication::getRequiredPort] MATCH FOUND - Returning port', [
+                            'port' => (int) $port,
+                        ]);
+
+                        return (int) $port;
+                    }
+                }
+            }
+
+            // Fall back to service-level port if no port-specific variable is found
+            $fallbackPort = $this->service->getRequiredPort();
+
+            return $fallbackPort;
+        } catch (\Throwable $e) {
+            return null;
+        }
+    }
 }

app/Models/ServiceDatabase.php

@@ -84,6 +84,10 @@ public function databaseType()
         $image = str($this->image)->before(':');
         if ($image->contains('supabase/postgres')) {
             $finalImage = 'supabase/postgres';
+        } elseif ($image->contains('timescale')) {
+            $finalImage = 'postgresql';
+        } elseif ($image->contains('pgvector')) {
+            $finalImage = 'postgresql';
         } elseif ($image->contains('postgres') || $image->contains('postgis')) {
             $finalImage = 'postgresql';
         } else {

app/Notifications/Channels/EmailChannel.php

@@ -101,6 +101,38 @@ public function send(SendsEmail $notifiable, Notification $notification): void
 
                 $mailer->send($email);
             }
+        } catch (\Resend\Exceptions\ErrorException $e) {
+            // Map HTTP status codes to user-friendly messages
+            $userMessage = match ($e->getErrorCode()) {
+                403 => 'Invalid Resend API key. Please verify your API key in the Resend dashboard and update it in settings.',
+                401 => 'Your Resend API key has restricted permissions. Please use an API key with Full Access permissions.',
+                429 => 'Resend rate limit exceeded. Please try again in a few minutes.',
+                400 => 'Email validation failed: '.$e->getErrorMessage(),
+                default => 'Failed to send email via Resend: '.$e->getErrorMessage(),
+            };
+
+            // Log detailed error for admin debugging (redact sensitive data)
+            $emailSettings = $notifiable->emailNotificationSettings ?? instanceSettings();
+            data_set($emailSettings, 'smtp_password', '********');
+            data_set($emailSettings, 'resend_api_key', '********');
+
+            send_internal_notification(sprintf(
+                "Resend Error\nStatus Code: %s\nMessage: %s\nNotification: %s\nEmail Settings:\n%s",
+                $e->getErrorCode(),
+                $e->getErrorMessage(),
+                get_class($notification),
+                json_encode($emailSettings, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)
+            ));
+
+            // Don't report expected errors (invalid keys, validation) to Sentry
+            if (in_array($e->getErrorCode(), [403, 401, 400])) {
+                throw NonReportableException::fromException(new \Exception($userMessage, $e->getCode(), $e));
+            }
+
+            throw new \Exception($userMessage, $e->getCode(), $e);
+        } catch (\Resend\Exceptions\TransporterException $e) {
+            send_internal_notification("Resend Transport Error: {$e->getMessage()}");
+            throw new \Exception('Unable to connect to Resend API. Please check your internet connection and try again.');
         } catch (\Throwable $e) {
             // Check if this is a Resend domain verification error on cloud instances
             if (isCloud() && str_contains($e->getMessage(), 'domain is not verified')) {

app/Traits/ExecuteRemoteCommand.php

@@ -219,9 +219,22 @@ private function executeCommandWithProcess($command, $hidden, $customType, $appe
         $process_result = $process->wait();
         if ($process_result->exitCode() !== 0) {
             if (! $ignore_errors) {
+                // Check if deployment was cancelled while command was running
+                if (isset($this->application_deployment_queue)) {
+                    $this->application_deployment_queue->refresh();
+                    if ($this->application_deployment_queue->status === \App\Enums\ApplicationDeploymentStatus::CANCELLED_BY_USER->value) {
+                        throw new \RuntimeException('Deployment cancelled by user', 69420);
+                    }
+                }
+
                 // Don't immediately set to FAILED - let the retry logic handle it
                 // This prevents premature status changes during retryable SSH errors
-                throw new \RuntimeException($process_result->errorOutput());
+                $error = $process_result->errorOutput();
+                if (empty($error)) {
+                    $error = $process_result->output() ?: 'Command failed with no error output';
+                }
+                $redactedCommand = $this->redact_sensitive_info($command);
+                throw new \RuntimeException("Command execution failed (exit code {$process_result->exitCode()}): {$redactedCommand}\nError: {$error}");
             }
         }
     }

bootstrap/helpers/api.php

@@ -97,6 +97,7 @@ function sharedDataApplications()
         'start_command' => 'string|nullable',
         'ports_exposes' => 'string|regex:/^(\d+)(,\d+)*$/',
         'ports_mappings' => 'string|regex:/^(\d+:\d+)(,\d+:\d+)*$/|nullable',
+        'custom_network_aliases' => 'string|nullable',
         'base_directory' => 'string|nullable',
         'publish_directory' => 'string|nullable',
         'health_check_enabled' => 'boolean',

bootstrap/helpers/constants.php

@@ -47,6 +47,8 @@
     'neo4j',
     'influxdb',
     'clickhouse/clickhouse-server',
+    'timescaledb/timescaledb',
+    'pgvector/pgvector',
 ];
 const SPECIFIC_SERVICES = [
     'quay.io/minio/minio',

bootstrap/helpers/docker.php

@@ -17,24 +17,44 @@ function getCurrentApplicationContainerStatus(Server $server, int $id, ?int $pul
     if (! $server->isSwarm()) {
         $containers = instant_remote_process(["docker ps -a --filter='label=coolify.applicationId={$id}' --format '{{json .}}' "], $server);
         $containers = format_docker_command_output_to_json($containers);
+
         $containers = $containers->map(function ($container) use ($pullRequestId, $includePullrequests) {
             $labels = data_get($container, 'Labels');
-            if (! str($labels)->contains('coolify.pullRequestId=')) {
-                data_set($container, 'Labels', $labels.",coolify.pullRequestId={$pullRequestId}");
+            $containerName = data_get($container, 'Names');
+            $hasPrLabel = str($labels)->contains('coolify.pullRequestId=');
+            $prLabelValue = null;
 
+            if ($hasPrLabel) {
+                preg_match('/coolify\.pullRequestId=(\d+)/', $labels, $matches);
+                $prLabelValue = $matches[1] ?? null;
+            }
+
+            // Treat pullRequestId=0 or missing label as base deployment (convention: 0 = no PR)
+            $isBaseDeploy = ! $hasPrLabel || (int) $prLabelValue === 0;
+
+            // If we're looking for a specific PR and this is a base deployment, exclude it
+            if ($pullRequestId !== null && $pullRequestId !== 0 && $isBaseDeploy) {
+                return null;
+            }
+
+            // If this is a base deployment, include it when not filtering for PRs
+            if ($isBaseDeploy) {
                 return $container;
             }
+
             if ($includePullrequests) {
                 return $container;
             }
-            if (str($labels)->contains("coolify.pullRequestId=$pullRequestId")) {
+            if ($pullRequestId !== null && $pullRequestId !== 0 && str($labels)->contains("coolify.pullRequestId={$pullRequestId}")) {
                 return $container;
             }
 
             return null;
         });
 
-        return $containers->filter();
+        $filtered = $containers->filter();
+
+        return $filtered;
     }
 
     return $containers;
@@ -1073,6 +1093,9 @@ function validateComposeFile(string $compose, int $server_id): string|Throwable
         }
         $yaml_compose = Yaml::parse($compose);
         foreach ($yaml_compose['services'] as $service_name => $service) {
+            if (! isset($service['volumes'])) {
+                continue;
+            }
             foreach ($service['volumes'] as $volume_name => $volume) {
                 if (data_get($volume, 'type') === 'bind' && data_get($volume, 'content')) {
                     unset($yaml_compose['services'][$service_name]['volumes'][$volume_name]['content']);

bootstrap/helpers/parsers.php

@@ -59,11 +59,13 @@ function validateDockerComposeForInjection(string $composeYaml): void
                     if (isset($volume['source'])) {
                         $source = $volume['source'];
                         if (is_string($source)) {
-                            // Allow simple env vars and env vars with defaults (validated in parseDockerVolumeString)
+                            // Allow env vars and env vars with defaults (validated in parseDockerVolumeString)
+                            // Also allow env vars followed by safe path concatenation (e.g., ${VAR}/path)
                             $isSimpleEnvVar = preg_match('/^\$\{[a-zA-Z_][a-zA-Z0-9_]*\}$/', $source);
                             $isEnvVarWithDefault = preg_match('/^\$\{[^}]+:-[^}]*\}$/', $source);
+                            $isEnvVarWithPath = preg_match('/^\$\{[a-zA-Z_][a-zA-Z0-9_]*\}[\/\w\.\-]*$/', $source);
 
-                            if (! $isSimpleEnvVar && ! $isEnvVarWithDefault) {
+                            if (! $isSimpleEnvVar && ! $isEnvVarWithDefault && ! $isEnvVarWithPath) {
                                 try {
                                     validateShellSafePath($source, 'volume source');
                                 } catch (\Exception $e) {
@@ -310,15 +312,17 @@ function parseDockerVolumeString(string $volumeString): array
     // Validate source path for command injection attempts
     // We validate the final source value after environment variable processing
     if ($source !== null) {
-        // Allow simple environment variables like ${VAR_NAME} or ${VAR}
-        // but validate everything else for shell metacharacters
+        // Allow environment variables like ${VAR_NAME} or ${VAR}
+        // Also allow env vars followed by safe path concatenation (e.g., ${VAR}/path)
         $sourceStr = is_string($source) ? $source : $source;
 
         // Skip validation for simple environment variable references
-        // Pattern: ${WORD_CHARS} with no special characters inside
+        // Pattern 1: ${WORD_CHARS} with no special characters inside
+        // Pattern 2: ${WORD_CHARS}/path/to/file (env var with path concatenation)
         $isSimpleEnvVar = preg_match('/^\$\{[a-zA-Z_][a-zA-Z0-9_]*\}$/', $sourceStr);
+        $isEnvVarWithPath = preg_match('/^\$\{[a-zA-Z_][a-zA-Z0-9_]*\}[\/\w\.\-]*$/', $sourceStr);
 
-        if (! $isSimpleEnvVar) {
+        if (! $isSimpleEnvVar && ! $isEnvVarWithPath) {
             try {
                 validateShellSafePath($sourceStr, 'volume source');
             } catch (\Exception $e) {
@@ -453,13 +457,9 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
             // for example SERVICE_FQDN_APP_3000 (without a value)
             if ($key->startsWith('SERVICE_FQDN_')) {
                 // SERVICE_FQDN_APP or SERVICE_FQDN_APP_3000
-                if (substr_count(str($key)->value(), '_') === 3) {
-                    $fqdnFor = $key->after('SERVICE_FQDN_')->beforeLast('_')->lower()->value();
-                    $port = $key->afterLast('_')->value();
-                } else {
-                    $fqdnFor = $key->after('SERVICE_FQDN_')->lower()->value();
-                    $port = null;
-                }
+                $parsed = parseServiceEnvironmentVariable($key->value());
+                $fqdnFor = $parsed['service_name'];
+                $port = $parsed['port'];
                 $fqdn = $resource->fqdn;
                 if (blank($resource->fqdn)) {
                     $fqdn = generateFqdn(server: $server, random: "$uuid", parserVersion: $resource->compose_parsing_version);
@@ -482,7 +482,7 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
                     $resource->save();
                 }
 
-                if (substr_count(str($key)->value(), '_') === 2) {
+                if (! $parsed['has_port']) {
                     $resource->environment_variables()->updateOrCreate([
                         'key' => $key->value(),
                         'resourceable_type' => get_class($resource),
@@ -492,7 +492,7 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
                         'is_preview' => false,
                     ]);
                 }
-                if (substr_count(str($key)->value(), '_') === 3) {
+                if ($parsed['has_port']) {
 
                     $newKey = str($key)->beforeLast('_');
                     $resource->environment_variables()->updateOrCreate([
@@ -563,12 +563,21 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
                         }
                     }
                 } elseif ($command->value() === 'URL') {
-                    $urlFor = $key->after('SERVICE_URL_')->lower()->value();
+                    // SERVICE_URL_APP or SERVICE_URL_APP_3000
+                    // Detect if there's a port suffix
+                    $parsed = parseServiceEnvironmentVariable($key->value());
+                    $urlFor = $parsed['service_name'];
+                    $port = $parsed['port'];
                     $originalUrlFor = str($urlFor)->replace('_', '-');
                     if (str($urlFor)->contains('-')) {
                         $urlFor = str($urlFor)->replace('-', '_')->replace('.', '_');
                     }
                     $url = generateUrl(server: $server, random: "$originalUrlFor-$uuid");
+                    // Append port if specified
+                    $urlWithPort = $url;
+                    if ($port && is_numeric($port)) {
+                        $urlWithPort = "$url:$port";
+                    }
                     $resource->environment_variables()->firstOrCreate([
                         'key' => $key->value(),
                         'resourceable_type' => get_class($resource),
@@ -595,12 +604,12 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
                             $envExists = $resource->environment_variables()->where('key', $key->value())->first();
                             if ($domainExists !== $envExists->value) {
                                 $envExists->update([
-                                    'value' => $url,
+                                    'value' => $urlWithPort,
                                 ]);
                             }
                             if (is_null($domainExists)) {
                                 $domains->put((string) $urlFor, [
-                                    'domain' => $url,
+                                    'domain' => $urlWithPort,
                                 ]);
                                 $resource->docker_compose_domains = $domains->toJson();
                                 $resource->save();
@@ -711,9 +720,12 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
                     // Validate source and target for command injection (array/long syntax)
                     if ($source !== null && ! empty($source->value())) {
                         $sourceValue = $source->value();
-                        // Allow simple environment variable references
+                        // Allow environment variable references and env vars with path concatenation
                         $isSimpleEnvVar = preg_match('/^\$\{[a-zA-Z_][a-zA-Z0-9_]*\}$/', $sourceValue);
-                        if (! $isSimpleEnvVar) {
+                        $isEnvVarWithDefault = preg_match('/^\$\{[^}]+:-[^}]*\}$/', $sourceValue);
+                        $isEnvVarWithPath = preg_match('/^\$\{[a-zA-Z_][a-zA-Z0-9_]*\}[\/\w\.\-]*$/', $sourceValue);
+
+                        if (! $isSimpleEnvVar && ! $isEnvVarWithDefault && ! $isEnvVarWithPath) {
                             try {
                                 validateShellSafePath($sourceValue, 'volume source');
                             } catch (\Exception $e) {
@@ -1164,13 +1176,21 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
             $environment = $environment->filter(function ($value, $key) {
                 return ! str($key)->startsWith('SERVICE_FQDN_');
             })->map(function ($value, $key) use ($resource) {
-                // if value is empty, set it to null so if you set the environment variable in the .env file (Coolify's UI), it will used
-                if (str($value)->isEmpty()) {
-                    if ($resource->environment_variables()->where('key', $key)->exists()) {
-                        $value = $resource->environment_variables()->where('key', $key)->first()->value;
-                    } else {
-                        $value = null;
+                // Preserve empty strings and null values with correct Docker Compose semantics:
+                // - Empty string: Variable is set to "" (e.g., HTTP_PROXY="" means "no proxy")
+                // - Null: Variable is unset/removed from container environment (may inherit from host)
+                if ($value === null) {
+                    // User explicitly wants variable unset - respect that
+                    // NEVER override from database - null means "inherit from environment"
+                    // Keep as null (will be excluded from container environment)
+                } elseif ($value === '') {
+                    // Empty string - allow database override for backward compatibility
+                    $dbEnv = $resource->environment_variables()->where('key', $key)->first();
+                    // Only use database override if it exists AND has a non-empty value
+                    if ($dbEnv && str($dbEnv->value)->isNotEmpty()) {
+                        $value = $dbEnv->value;
                     }
+                    // Otherwise keep empty string as-is
                 }
 
                 return $value;
@@ -1285,6 +1305,15 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
         if ($depends_on->count() > 0) {
             $payload['depends_on'] = $depends_on;
         }
+        // Auto-inject .env file so Coolify environment variables are available inside containers
+        // This makes Applications behave consistently with manual .env file usage
+        $existingEnvFiles = data_get($service, 'env_file');
+        $envFiles = collect(is_null($existingEnvFiles) ? [] : (is_array($existingEnvFiles) ? $existingEnvFiles : [$existingEnvFiles]))
+            ->push('.env')
+            ->unique()
+            ->values();
+
+        $payload['env_file'] = $envFiles;
         if ($isPullRequest) {
             $serviceName = addPreviewDeploymentSuffix($serviceName, $pullRequestId);
         }
@@ -1299,6 +1328,18 @@ function applicationParser(Application $resource, int $pull_request_id = 0, ?int
         return array_search($key, $customOrder);
     });
 
+    // Remove empty top-level sections (volumes, networks, configs, secrets)
+    // Keep only non-empty sections to match Docker Compose best practices
+    $topLevel = $topLevel->filter(function ($value, $key) {
+        // Always keep 'services' section
+        if ($key === 'services') {
+            return true;
+        }
+
+        // Keep section only if it has content
+        return $value instanceof Collection ? $value->isNotEmpty() : ! empty($value);
+    });
+
     $cleanedCompose = Yaml::dump(convertToArray($topLevel), 10, 2);
     $resource->docker_compose = $cleanedCompose;
 
@@ -1392,22 +1433,40 @@ function serviceParser(Service $resource): Collection
         }
 
         $image = data_get_str($service, 'image');
-        $isDatabase = isDatabaseImage($image, $service);
-        if ($isDatabase) {
-            $applicationFound = ServiceApplication::where('name', $serviceName)->where('service_id', $resource->id)->first();
-            if ($applicationFound) {
-                $savedService = $applicationFound;
+
+        // Check for manually migrated services first (respects user's conversion choice)
+        $migratedApp = ServiceApplication::where('name', $serviceName)
+            ->where('service_id', $resource->id)
+            ->where('is_migrated', true)
+            ->first();
+        $migratedDb = ServiceDatabase::where('name', $serviceName)
+            ->where('service_id', $resource->id)
+            ->where('is_migrated', true)
+            ->first();
+
+        if ($migratedApp || $migratedDb) {
+            // Use the migrated service type, ignoring image detection
+            $isDatabase = (bool) $migratedDb;
+            $savedService = $migratedApp ?: $migratedDb;
+        } else {
+            // Use image detection for non-migrated services
+            $isDatabase = isDatabaseImage($image, $service);
+            if ($isDatabase) {
+                $applicationFound = ServiceApplication::where('name', $serviceName)->where('service_id', $resource->id)->first();
+                if ($applicationFound) {
+                    $savedService = $applicationFound;
+                } else {
+                    $savedService = ServiceDatabase::firstOrCreate([
+                        'name' => $serviceName,
+                        'service_id' => $resource->id,
+                    ]);
+                }
             } else {
-                $savedService = ServiceDatabase::firstOrCreate([
+                $savedService = ServiceApplication::firstOrCreate([
                     'name' => $serviceName,
                     'service_id' => $resource->id,
                 ]);
             }
-        } else {
-            $savedService = ServiceApplication::firstOrCreate([
-                'name' => $serviceName,
-                'service_id' => $resource->id,
-            ]);
         }
         // Update image if it changed
         if ($savedService->image !== $image) {
@@ -1422,7 +1481,24 @@ function serviceParser(Service $resource): Collection
         $environment = collect(data_get($service, 'environment', []));
         $buildArgs = collect(data_get($service, 'build.args', []));
         $environment = $environment->merge($buildArgs);
-        $isDatabase = isDatabaseImage($image, $service);
+
+        // Check for manually migrated services first (respects user's conversion choice)
+        $migratedApp = ServiceApplication::where('name', $serviceName)
+            ->where('service_id', $resource->id)
+            ->where('is_migrated', true)
+            ->first();
+        $migratedDb = ServiceDatabase::where('name', $serviceName)
+            ->where('service_id', $resource->id)
+            ->where('is_migrated', true)
+            ->first();
+
+        if ($migratedApp || $migratedDb) {
+            // Use the migrated service type, ignoring image detection
+            $isDatabase = (bool) $migratedDb;
+        } else {
+            // Use image detection for non-migrated services
+            $isDatabase = isDatabaseImage($image, $service);
+        }
 
         $containerName = "$serviceName-{$resource->uuid}";
 
@@ -1442,7 +1518,11 @@ function serviceParser(Service $resource): Collection
         if ($serviceName === 'plausible') {
             $predefinedPort = '8000';
         }
-        if ($isDatabase) {
+
+        if ($migratedApp || $migratedDb) {
+            // Use the already determined migrated service
+            $savedService = $migratedApp ?: $migratedDb;
+        } elseif ($isDatabase) {
             $applicationFound = ServiceApplication::where('name', $serviceName)->where('service_id', $resource->id)->first();
             if ($applicationFound) {
                 $savedService = $applicationFound;
@@ -1505,27 +1585,16 @@ function serviceParser(Service $resource): Collection
             // Get magic environments where we need to preset the FQDN / URL
             if ($key->startsWith('SERVICE_FQDN_') || $key->startsWith('SERVICE_URL_')) {
                 // SERVICE_FQDN_APP or SERVICE_FQDN_APP_3000
-                if (substr_count(str($key)->value(), '_') === 3) {
-                    if ($key->startsWith('SERVICE_FQDN_')) {
-                        $urlFor = null;
-                        $fqdnFor = $key->after('SERVICE_FQDN_')->beforeLast('_')->lower()->value();
-                    }
-                    if ($key->startsWith('SERVICE_URL_')) {
-                        $fqdnFor = null;
-                        $urlFor = $key->after('SERVICE_URL_')->beforeLast('_')->lower()->value();
-                    }
-                    $port = $key->afterLast('_')->value();
-                } else {
-                    if ($key->startsWith('SERVICE_FQDN_')) {
-                        $urlFor = null;
-                        $fqdnFor = $key->after('SERVICE_FQDN_')->lower()->value();
-                    }
-                    if ($key->startsWith('SERVICE_URL_')) {
-                        $fqdnFor = null;
-                        $urlFor = $key->after('SERVICE_URL_')->lower()->value();
-                    }
-                    $port = null;
+                $parsed = parseServiceEnvironmentVariable($key->value());
+                if ($key->startsWith('SERVICE_FQDN_')) {
+                    $urlFor = null;
+                    $fqdnFor = $parsed['service_name'];
                 }
+                if ($key->startsWith('SERVICE_URL_')) {
+                    $fqdnFor = null;
+                    $urlFor = $parsed['service_name'];
+                }
+                $port = $parsed['port'];
                 if (blank($savedService->fqdn)) {
                     if ($fqdnFor) {
                         $fqdn = generateFqdn(server: $server, random: "$fqdnFor-$uuid", parserVersion: $resource->compose_parsing_version);
@@ -1570,7 +1639,7 @@ function serviceParser(Service $resource): Collection
                     }
                     $savedService->save();
                 }
-                if (substr_count(str($key)->value(), '_') === 2) {
+                if (! $parsed['has_port']) {
                     $resource->environment_variables()->updateOrCreate([
                         'key' => $key->value(),
                         'resourceable_type' => get_class($resource),
@@ -1588,22 +1657,23 @@ function serviceParser(Service $resource): Collection
                         'is_preview' => false,
                     ]);
                 }
-                if (substr_count(str($key)->value(), '_') === 3) {
-                    $newKey = str($key)->beforeLast('_');
+                if ($parsed['has_port']) {
+                    // For port-specific variables (e.g., SERVICE_FQDN_UMAMI_3000),
+                    // keep the port suffix in the key and use the URL with port
                     $resource->environment_variables()->updateOrCreate([
-                        'key' => $newKey->value(),
+                        'key' => $key->value(),
                         'resourceable_type' => get_class($resource),
                         'resourceable_id' => $resource->id,
                     ], [
-                        'value' => $fqdn,
+                        'value' => $fqdnWithPort,
                         'is_preview' => false,
                     ]);
                     $resource->environment_variables()->updateOrCreate([
-                        'key' => $newKey->value(),
+                        'key' => $key->value(),
                         'resourceable_type' => get_class($resource),
                         'resourceable_id' => $resource->id,
                     ], [
-                        'value' => $url,
+                        'value' => $urlWithPort,
                         'is_preview' => false,
                     ]);
                 }
@@ -1621,8 +1691,17 @@ function serviceParser(Service $resource): Collection
                     $url = generateUrl(server: $server, random: str($fqdnFor)->replace('_', '-')->value()."-$uuid");
 
                     $envExists = $resource->environment_variables()->where('key', $key->value())->first();
+                    // Also check if a port-suffixed version exists (e.g., SERVICE_FQDN_UMAMI_3000)
+                    $portSuffixedExists = $resource->environment_variables()
+                        ->where('key', 'LIKE', $key->value().'_%')
+                        ->whereRaw('key ~ ?', ['^'.$key->value().'_[0-9]+$'])
+                        ->exists();
                     $serviceExists = ServiceApplication::where('name', str($fqdnFor)->replace('_', '-')->value())->where('service_id', $resource->id)->first();
-                    if (! $envExists && (data_get($serviceExists, 'name') === str($fqdnFor)->replace('_', '-')->value())) {
+                    // Check if FQDN already has a port set (contains ':' after the domain)
+                    $fqdnHasPort = $serviceExists && str($serviceExists->fqdn)->contains(':') && str($serviceExists->fqdn)->afterLast(':')->isMatch('/^\d+$/');
+                    // Only set FQDN if it's for the current service being processed (prevent race conditions)
+                    $isCurrentService = $serviceExists && $serviceExists->id === $savedService->id;
+                    if (! $envExists && ! $portSuffixedExists && ! $fqdnHasPort && $isCurrentService && (data_get($serviceExists, 'name') === str($fqdnFor)->replace('_', '-')->value())) {
                         // Save URL otherwise it won't work.
                         $serviceExists->fqdn = $url;
                         $serviceExists->save();
@@ -1641,8 +1720,17 @@ function serviceParser(Service $resource): Collection
                     $url = generateUrl(server: $server, random: str($urlFor)->replace('_', '-')->value()."-$uuid");
 
                     $envExists = $resource->environment_variables()->where('key', $key->value())->first();
+                    // Also check if a port-suffixed version exists (e.g., SERVICE_URL_DASHBOARD_6791)
+                    $portSuffixedExists = $resource->environment_variables()
+                        ->where('key', 'LIKE', $key->value().'_%')
+                        ->whereRaw('key ~ ?', ['^'.$key->value().'_[0-9]+$'])
+                        ->exists();
                     $serviceExists = ServiceApplication::where('name', str($urlFor)->replace('_', '-')->value())->where('service_id', $resource->id)->first();
-                    if (! $envExists && (data_get($serviceExists, 'name') === str($urlFor)->replace('_', '-')->value())) {
+                    // Check if FQDN already has a port set (contains ':' after the domain)
+                    $fqdnHasPort = $serviceExists && str($serviceExists->fqdn)->contains(':') && str($serviceExists->fqdn)->afterLast(':')->isMatch('/^\d+$/');
+                    // Only set FQDN if it's for the current service being processed (prevent race conditions)
+                    $isCurrentService = $serviceExists && $serviceExists->id === $savedService->id;
+                    if (! $envExists && ! $portSuffixedExists && ! $fqdnHasPort && $isCurrentService && (data_get($serviceExists, 'name') === str($urlFor)->replace('_', '-')->value())) {
                         $serviceExists->fqdn = $url;
                         $serviceExists->save();
                     }
@@ -1707,7 +1795,25 @@ function serviceParser(Service $resource): Collection
         $environment = convertToKeyValueCollection($environment);
         $coolifyEnvironments = collect([]);
 
-        $isDatabase = isDatabaseImage($image, $service);
+        // Check for manually migrated services first (respects user's conversion choice)
+        $migratedApp = ServiceApplication::where('name', $serviceName)
+            ->where('service_id', $resource->id)
+            ->where('is_migrated', true)
+            ->first();
+        $migratedDb = ServiceDatabase::where('name', $serviceName)
+            ->where('service_id', $resource->id)
+            ->where('is_migrated', true)
+            ->first();
+
+        if ($migratedApp || $migratedDb) {
+            // Use the migrated service type, ignoring image detection
+            $isDatabase = (bool) $migratedDb;
+            $savedService = $migratedApp ?: $migratedDb;
+        } else {
+            // Use image detection for non-migrated services
+            $isDatabase = isDatabaseImage($image, $service);
+        }
+
         $volumesParsed = collect([]);
 
         $containerName = "$serviceName-{$resource->uuid}";
@@ -1729,7 +1835,10 @@ function serviceParser(Service $resource): Collection
             $predefinedPort = '8000';
         }
 
-        if ($isDatabase) {
+        if ($migratedApp || $migratedDb) {
+            // Use the already determined migrated service
+            $savedService = $migratedApp ?: $migratedDb;
+        } elseif ($isDatabase) {
             $applicationFound = ServiceApplication::where('name', $serviceName)->where('service_id', $resource->id)->first();
             if ($applicationFound) {
                 $savedService = $applicationFound;
@@ -1791,9 +1900,12 @@ function serviceParser(Service $resource): Collection
                     // Validate source and target for command injection (array/long syntax)
                     if ($source !== null && ! empty($source->value())) {
                         $sourceValue = $source->value();
-                        // Allow simple environment variable references
+                        // Allow environment variable references and env vars with path concatenation
                         $isSimpleEnvVar = preg_match('/^\$\{[a-zA-Z_][a-zA-Z0-9_]*\}$/', $sourceValue);
-                        if (! $isSimpleEnvVar) {
+                        $isEnvVarWithDefault = preg_match('/^\$\{[^}]+:-[^}]*\}$/', $sourceValue);
+                        $isEnvVarWithPath = preg_match('/^\$\{[a-zA-Z_][a-zA-Z0-9_]*\}[\/\w\.\-]*$/', $sourceValue);
+
+                        if (! $isSimpleEnvVar && ! $isEnvVarWithDefault && ! $isEnvVarWithPath) {
                             try {
                                 validateShellSafePath($sourceValue, 'volume source');
                             } catch (\Exception $e) {
@@ -2122,13 +2234,21 @@ function serviceParser(Service $resource): Collection
             $environment = $environment->filter(function ($value, $key) {
                 return ! str($key)->startsWith('SERVICE_FQDN_');
             })->map(function ($value, $key) use ($resource) {
-                // if value is empty, set it to null so if you set the environment variable in the .env file (Coolify's UI), it will used
-                if (str($value)->isEmpty()) {
-                    if ($resource->environment_variables()->where('key', $key)->exists()) {
-                        $value = $resource->environment_variables()->where('key', $key)->first()->value;
-                    } else {
-                        $value = null;
+                // Preserve empty strings and null values with correct Docker Compose semantics:
+                // - Empty string: Variable is set to "" (e.g., HTTP_PROXY="" means "no proxy")
+                // - Null: Variable is unset/removed from container environment (may inherit from host)
+                if ($value === null) {
+                    // User explicitly wants variable unset - respect that
+                    // NEVER override from database - null means "inherit from environment"
+                    // Keep as null (will be excluded from container environment)
+                } elseif ($value === '') {
+                    // Empty string - allow database override for backward compatibility
+                    $dbEnv = $resource->environment_variables()->where('key', $key)->first();
+                    // Only use database override if it exists AND has a non-empty value
+                    if ($dbEnv && str($dbEnv->value)->isNotEmpty()) {
+                        $value = $dbEnv->value;
                     }
+                    // Otherwise keep empty string as-is
                 }
 
                 return $value;
@@ -2240,6 +2360,15 @@ function serviceParser(Service $resource): Collection
         if ($depends_on->count() > 0) {
             $payload['depends_on'] = $depends_on;
         }
+        // Auto-inject .env file so Coolify environment variables are available inside containers
+        // This makes Services behave consistently with Applications
+        $existingEnvFiles = data_get($service, 'env_file');
+        $envFiles = collect(is_null($existingEnvFiles) ? [] : (is_array($existingEnvFiles) ? $existingEnvFiles : [$existingEnvFiles]))
+            ->push('.env')
+            ->unique()
+            ->values();
+
+        $payload['env_file'] = $envFiles;
 
         $parsedServices->put($serviceName, $payload);
     }
@@ -2251,6 +2380,18 @@ function serviceParser(Service $resource): Collection
         return array_search($key, $customOrder);
     });
 
+    // Remove empty top-level sections (volumes, networks, configs, secrets)
+    // Keep only non-empty sections to match Docker Compose best practices
+    $topLevel = $topLevel->filter(function ($value, $key) {
+        // Always keep 'services' section
+        if ($key === 'services') {
+            return true;
+        }
+
+        // Keep section only if it has content
+        return $value instanceof Collection ? $value->isNotEmpty() : ! empty($value);
+    });
+
     $cleanedCompose = Yaml::dump(convertToArray($topLevel), 10, 2);
     $resource->docker_compose = $cleanedCompose;
 

bootstrap/helpers/proxy.php

@@ -212,7 +212,7 @@ function generateDefaultProxyConfiguration(Server $server, array $custom_command
             'services' => [
                 'traefik' => [
                     'container_name' => 'coolify-proxy',
-                    'image' => 'traefik:v3.1',
+                    'image' => 'traefik:v3.6',
                     'restart' => RESTART_MODE,
                     'extra_hosts' => [
                         'host.docker.internal:host-gateway',

bootstrap/helpers/services.php

@@ -184,3 +184,53 @@ function serviceKeys()
 {
     return get_service_templates()->keys();
 }
+
+/**
+ * Parse a SERVICE_URL_* or SERVICE_FQDN_* variable to extract the service name and port.
+ *
+ * This function detects if a service environment variable has a port suffix by checking
+ * if the last segment after the underscore is numeric.
+ *
+ * Examples:
+ *   - SERVICE_URL_APP_3000 → ['service_name' => 'app', 'port' => '3000', 'has_port' => true]
+ *   - SERVICE_URL_MY_API_8080 → ['service_name' => 'my_api', 'port' => '8080', 'has_port' => true]
+ *   - SERVICE_URL_MY_APP → ['service_name' => 'my_app', 'port' => null, 'has_port' => false]
+ *   - SERVICE_FQDN_REDIS_CACHE_6379 → ['service_name' => 'redis_cache', 'port' => '6379', 'has_port' => true]
+ *
+ * @param  string  $key  The environment variable key (e.g., SERVICE_URL_APP_3000)
+ * @return array{service_name: string, port: string|null, has_port: bool} Parsed service information
+ */
+function parseServiceEnvironmentVariable(string $key): array
+{
+    $strKey = str($key);
+    $lastSegment = $strKey->afterLast('_')->value();
+    $hasPort = is_numeric($lastSegment) && ctype_digit($lastSegment);
+
+    if ($hasPort) {
+        // Port-specific variable (e.g., SERVICE_URL_APP_3000)
+        if ($strKey->startsWith('SERVICE_URL_')) {
+            $serviceName = $strKey->after('SERVICE_URL_')->beforeLast('_')->lower()->value();
+        } elseif ($strKey->startsWith('SERVICE_FQDN_')) {
+            $serviceName = $strKey->after('SERVICE_FQDN_')->beforeLast('_')->lower()->value();
+        } else {
+            $serviceName = '';
+        }
+        $port = $lastSegment;
+    } else {
+        // Base variable without port (e.g., SERVICE_URL_APP)
+        if ($strKey->startsWith('SERVICE_URL_')) {
+            $serviceName = $strKey->after('SERVICE_URL_')->lower()->value();
+        } elseif ($strKey->startsWith('SERVICE_FQDN_')) {
+            $serviceName = $strKey->after('SERVICE_FQDN_')->lower()->value();
+        } else {
+            $serviceName = '';
+        }
+        $port = null;
+    }
+
+    return [
+        'service_name' => $serviceName,
+        'port' => $port,
+        'has_port' => $hasPort,
+    ];
+}

bootstrap/helpers/shared.php

@@ -1353,52 +1353,71 @@ function parseDockerComposeFile(Service|Application $resource, bool $isNew = fal
 
                 // Decide if the service is a database
                 $image = data_get_str($service, 'image');
-                $isDatabase = isDatabaseImage($image, $service);
-                data_set($service, 'is_database', $isDatabase);
 
-                // Create new serviceApplication or serviceDatabase
-                if ($isDatabase) {
-                    if ($isNew) {
-                        $savedService = ServiceDatabase::create([
-                            'name' => $serviceName,
-                            'image' => $image,
-                            'service_id' => $resource->id,
-                        ]);
-                    } else {
-                        $savedService = ServiceDatabase::where([
-                            'name' => $serviceName,
-                            'service_id' => $resource->id,
-                        ])->first();
-                        if (is_null($savedService)) {
+                // Check for manually migrated services first (respects user's conversion choice)
+                $migratedApp = ServiceApplication::where('name', $serviceName)
+                    ->where('service_id', $resource->id)
+                    ->where('is_migrated', true)
+                    ->first();
+                $migratedDb = ServiceDatabase::where('name', $serviceName)
+                    ->where('service_id', $resource->id)
+                    ->where('is_migrated', true)
+                    ->first();
+
+                if ($migratedApp || $migratedDb) {
+                    // Use the migrated service type, ignoring image detection
+                    $isDatabase = (bool) $migratedDb;
+                    $savedService = $migratedApp ?: $migratedDb;
+                } else {
+                    // Use image detection for non-migrated services
+                    $isDatabase = isDatabaseImage($image, $service);
+
+                    // Create new serviceApplication or serviceDatabase
+                    if ($isDatabase) {
+                        if ($isNew) {
                             $savedService = ServiceDatabase::create([
                                 'name' => $serviceName,
                                 'image' => $image,
                                 'service_id' => $resource->id,
                             ]);
+                        } else {
+                            $savedService = ServiceDatabase::where([
+                                'name' => $serviceName,
+                                'service_id' => $resource->id,
+                            ])->first();
+                            if (is_null($savedService)) {
+                                $savedService = ServiceDatabase::create([
+                                    'name' => $serviceName,
+                                    'image' => $image,
+                                    'service_id' => $resource->id,
+                                ]);
+                            }
                         }
-                    }
-                } else {
-                    if ($isNew) {
-                        $savedService = ServiceApplication::create([
-                            'name' => $serviceName,
-                            'image' => $image,
-                            'service_id' => $resource->id,
-                        ]);
                     } else {
-                        $savedService = ServiceApplication::where([
-                            'name' => $serviceName,
-                            'service_id' => $resource->id,
-                        ])->first();
-                        if (is_null($savedService)) {
+                        if ($isNew) {
                             $savedService = ServiceApplication::create([
                                 'name' => $serviceName,
                                 'image' => $image,
                                 'service_id' => $resource->id,
                             ]);
+                        } else {
+                            $savedService = ServiceApplication::where([
+                                'name' => $serviceName,
+                                'service_id' => $resource->id,
+                            ])->first();
+                            if (is_null($savedService)) {
+                                $savedService = ServiceApplication::create([
+                                    'name' => $serviceName,
+                                    'image' => $image,
+                                    'service_id' => $resource->id,
+                                ]);
+                            }
                         }
                     }
                 }
 
+                data_set($service, 'is_database', $isDatabase);
+
                 // Check if image changed
                 if ($savedService->image !== $image) {
                     $savedService->image = $image;
@@ -2879,6 +2898,18 @@ function instanceSettings()
     return InstanceSettings::get();
 }
 
+function getHelperVersion(): string
+{
+    $settings = instanceSettings();
+
+    // In development mode, use the dev_helper_version if set, otherwise fallback to config
+    if (isDev() && ! empty($settings->dev_helper_version)) {
+        return $settings->dev_helper_version;
+    }
+
+    return config('constants.coolify.helper_version');
+}
+
 function loadConfigFromGit(string $repository, string $branch, string $base_directory, int $server_id, int $team_id)
 {
     $server = Server::find($server_id)->where('team_id', $team_id)->first();

composer.json

@@ -36,7 +36,7 @@
         "poliander/cron": "^3.2.1",
         "purplepixie/phpdns": "^2.2",
         "pusher/pusher-php-server": "^7.2.7",
-        "resend/resend-laravel": "^0.19.0",
+        "resend/resend-laravel": "^0.20.0",
         "sentry/sentry-laravel": "^4.15.1",
         "socialiteproviders/authentik": "^5.2",
         "socialiteproviders/clerk": "^5.0",

composer.lock

@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "a993799242581bd06b5939005ee458d9",
+    "content-hash": "423b7d10901b9f31c926d536ff163a22",
     "packages": [
         {
             "name": "amphp/amp",
@@ -7048,16 +7048,16 @@
         },
         {
             "name": "resend/resend-laravel",
-            "version": "v0.19.0",
+            "version": "v0.20.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/resend/resend-laravel.git",
-                "reference": "ce11e363c42c1d6b93983dfebbaba3f906863c3a"
+                "reference": "f32c2f484df2bc65fba8ea9ab9b210cd42d9f3ed"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/resend/resend-laravel/zipball/ce11e363c42c1d6b93983dfebbaba3f906863c3a",
-                "reference": "ce11e363c42c1d6b93983dfebbaba3f906863c3a",
+                "url": "https://api.github.com/repos/resend/resend-laravel/zipball/f32c2f484df2bc65fba8ea9ab9b210cd42d9f3ed",
+                "reference": "f32c2f484df2bc65fba8ea9ab9b210cd42d9f3ed",
                 "shasum": ""
             },
             "require": {
@@ -7111,9 +7111,9 @@
             ],
             "support": {
                 "issues": "https://github.com/resend/resend-laravel/issues",
-                "source": "https://github.com/resend/resend-laravel/tree/v0.19.0"
+                "source": "https://github.com/resend/resend-laravel/tree/v0.20.0"
             },
-            "time": "2025-05-06T21:36:51+00:00"
+            "time": "2025-08-04T19:26:47+00:00"
         },
         {
             "name": "resend/resend-php",

config/constants.php

@@ -2,8 +2,8 @@
 
 return [
     'coolify' => [
-        'version' => '4.0.0-beta.439',
-        'helper_version' => '1.0.11',
+        'version' => '4.0.0-beta.443',
+        'helper_version' => '1.0.12',
         'realtime_version' => '1.0.10',
         'self_hosted' => env('SELF_HOSTED', true),
         'autoupdate' => env('AUTOUPDATE'),
@@ -12,7 +12,7 @@
         'helper_image' => env('HELPER_IMAGE', env('REGISTRY_URL', 'ghcr.io').'/coollabsio/coolify-helper'),
         'realtime_image' => env('REALTIME_IMAGE', env('REGISTRY_URL', 'ghcr.io').'/coollabsio/coolify-realtime'),
         'is_windows_docker_desktop' => env('IS_WINDOWS_DOCKER_DESKTOP', false),
-        'releases_url' => 'https://cdn.coollabs.io/coolify/releases.json',
+        'releases_url' => 'https://cdn.coolify.io/releases.json',
     ],
 
     'urls' => [

config/logging.php

@@ -129,8 +129,8 @@
         'scheduled-errors' => [
             'driver' => 'daily',
             'path' => storage_path('logs/scheduled-errors.log'),
-            'level' => 'debug',
-            'days' => 7,
+            'level' => 'warning',
+            'days' => 14,
         ],
     ],
 

database/migrations/2025_11_02_161923_add_dev_helper_version_to_instance_settings.php

@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('instance_settings', function (Blueprint $table) {
+            $table->string('dev_helper_version')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('instance_settings', function (Blueprint $table) {
+            $table->dropColumn('dev_helper_version');
+        });
+    }
+};

database/migrations/2025_11_09_000001_add_timeout_to_scheduled_tasks_table.php

@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('scheduled_tasks', function (Blueprint $table) {
+            $table->integer('timeout')->default(300)->after('frequency');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('scheduled_tasks', function (Blueprint $table) {
+            $table->dropColumn('timeout');
+        });
+    }
+};

database/migrations/2025_11_09_000002_improve_scheduled_task_executions_tracking.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('scheduled_task_executions', function (Blueprint $table) {
+            $table->timestamp('started_at')->nullable()->after('scheduled_task_id');
+            $table->integer('retry_count')->default(0)->after('status');
+            $table->decimal('duration', 10, 2)->nullable()->after('retry_count')->comment('Duration in seconds');
+            $table->text('error_details')->nullable()->after('message');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('scheduled_task_executions', function (Blueprint $table) {
+            $table->dropColumn(['started_at', 'retry_count', 'duration', 'error_details']);
+        });
+    }
+};

database/migrations/2025_11_10_112500_add_restart_tracking_to_applications_table.php

@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('applications', function (Blueprint $table) {
+            $table->integer('restart_count')->default(0)->after('status');
+            $table->timestamp('last_restart_at')->nullable()->after('restart_count');
+            $table->string('last_restart_type', 10)->nullable()->after('last_restart_at');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('applications', function (Blueprint $table) {
+            $table->dropColumn(['restart_count', 'last_restart_at', 'last_restart_type']);
+        });
+    }
+};

docker/coolify-helper/Dockerfile

@@ -10,7 +10,7 @@ ARG DOCKER_BUILDX_VERSION=0.25.0
 # https://github.com/buildpacks/pack/releases
 ARG PACK_VERSION=0.38.2
 # https://github.com/railwayapp/nixpacks/releases
-ARG NIXPACKS_VERSION=1.40.0
+ARG NIXPACKS_VERSION=1.41.0
 # https://github.com/minio/mc/releases
 ARG MINIO_VERSION=RELEASE.2025-08-13T08-35-41Z
 

docker/development/etc/nginx/site-opts.d/http.conf

@@ -13,6 +13,9 @@ charset utf-8;
 # Set max upload to 2048M
 client_max_body_size 2048M;
 
+# Set client body buffer to handle Sentinel payloads in memory
+client_body_buffer_size 256k;
+
 # Healthchecks: Set /healthcheck to be the healthcheck URL
 location /healthcheck {
     access_log off;

docker/production/etc/nginx/site-opts.d/http.conf

@@ -13,6 +13,9 @@ charset utf-8;
 # Set max upload to 2048M
 client_max_body_size 2048M;
 
+# Set client body buffer to handle Sentinel payloads in memory
+client_body_buffer_size 256k;
+
 # Healthchecks: Set /healthcheck to be the healthcheck URL
 location /healthcheck {
     access_log off;

jean.json

@@ -0,0 +1,5 @@
+{
+  "scripts": {
+    "setup": "cp $JEAN_ROOT_PATH/.env . && mkdir -p .claude && cp $JEAN_ROOT_PATH/.claude/settings.local.json .claude/settings.local.json"
+  }
+}

other/nightly/versions.json

@@ -1,10 +1,10 @@
 {
     "coolify": {
         "v4": {
-            "version": "4.0.0-beta.435"
+            "version": "4.0.0-beta.443"
         },
         "nightly": {
-            "version": "4.0.0-beta.436"
+            "version": "4.0.0-beta.444"
         },
         "helper": {
             "version": "1.0.11"

package-lock.json

@@ -2664,11 +2664,11 @@
             }
         },
         "node_modules/tar": {
-            "version": "7.5.1",
-            "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.1.tgz",
-            "integrity": "sha512-nlGpxf+hv0v7GkWBK2V9spgactGOp0qvfWRxUMjqHyzrt3SgwE48DIv/FhqPHJYLHpgW1opq3nERbz5Anq7n1g==",
+            "version": "7.5.2",
+            "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.2.tgz",
+            "integrity": "sha512-7NyxrTE4Anh8km8iEy7o0QYPs+0JKBTj5ZaqHg6B39erLg0qYXN3BijtShwbsNSvQ+LN75+KV+C4QR/f6Gwnpg==",
             "dev": true,
-            "license": "ISC",
+            "license": "BlueOak-1.0.0",
             "dependencies": {
                 "@isaacs/fs-minipass": "^4.0.0",
                 "chownr": "^3.0.0",

public/svgs/postgresus.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?> <svg xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="none"><path d="M18.1899 24.7431C17.4603 24.7737 16.6261 24.3423 16.1453 23.6749C15.9745 23.438 15.6161 23.4548 15.4621 23.7026C15.1857 24.1478 14.9389 24.5259 14.8066 24.751C14.4739 25.3197 14.5242 25.4223 14.7918 25.8636C15.2923 26.689 16.8374 27.9675 19.0113 27.999C22.3807 28.0474 25.2269 26.2506 26.303 21.9058C29.0811 22.0322 29.5767 20.9018 29.5866 19.8415C29.5965 18.795 29.1542 18.2796 27.8866 17.9232C27.4739 17.8067 26.9902 17.7061 26.4689 17.4948C26.3198 16.2281 25.9496 15.0257 25.376 13.8933C28.1433 2.78289 16.4839 -0.631985 12.0048 4.22426C11.3818 3.42756 9.81016 2.00395 7.14065 2C4.12857 1.99606 1 4.47798 1 8.23346C1 9.79626 1.93492 12.1331 2.56083 14.1332C3.86103 18.2875 4.6992 19.4683 6.52362 19.801C7.98376 20.0675 9.1645 19.3972 10.0471 18.2796C11.3233 18.4028 10.4726 19.5371 16.4099 19.2234C17.6765 19.1168 18.7694 19.564 19.5937 20.498C20.8071 21.8732 20.4566 24.6474 18.1899 24.7421V24.7431ZM17.8483 13.0423C17.2174 12.9801 16.707 12.4697 16.6448 11.8389C16.5599 10.9859 17.2708 10.2761 18.1237 10.36C18.7546 10.4222 19.265 10.9326 19.3272 11.5634C19.4111 12.4154 18.7013 13.1262 17.8483 13.0423ZM20.578 18.178C19.9403 17.5392 19.8524 16.7149 20.3519 16.1788C20.9186 15.5706 21.7242 15.85 22.1428 16.3061C23.4331 17.712 24.9209 18.6193 27.854 19.337C28.4651 19.487 28.4157 20.3716 27.7908 20.4476C26.4798 20.6076 24.3355 20.3065 22.8882 19.6934C22.0115 19.3222 21.1763 18.7762 20.578 18.177V18.178Z" fill="#1677FF"></path><path d="M17.0439 19.2156C17.0439 19.2156 17.037 19.2156 17.0321 19.2156C18.0648 19.2738 18.9029 19.7161 19.594 20.498C20.8073 21.8732 20.4568 24.6474 18.1901 24.7421C17.4606 24.7727 16.6263 24.3413 16.1456 23.6739C17.7202 26.6505 21.8281 26.0818 22.2694 23.3432C22.6288 21.114 20.0304 18.5699 17.0439 19.2136V19.2156ZM10 18C7.24751 15.8875 7.91886 10.4824 10.7779 6.4742C10.3317 5.85322 9.00779 4.787 7.32553 4.74751C4.61357 4.68433 2.68055 6.99842 3.66286 10.206C3.9768 6.91846 7.20805 6.33105 8.7363 8.17324C6.76477 12.1479 7.27817 16.1766 10 18C15 19.2194 12.2436 19.21 10 18Z" fill="#1E56E2"></path><path d="M10 18H12L13 19H12L11 18.5L10 18Z" fill="#1677FF"></path></svg> 

resources/css/app.css

@@ -82,7 +82,7 @@ @keyframes lds-heart {
 */
 html,
 body {
-    @apply w-full min-h-full bg-neutral-50 dark:bg-base dark:text-neutral-400;
+    @apply w-full min-h-full bg-gray-50 dark:bg-base dark:text-neutral-400;
 }
 
 body {

resources/css/utilities.css

@@ -152,7 +152,7 @@ @utility custom-modal {
 }
 
 @utility navbar-main {
-    @apply flex flex-col gap-4 justify-items-start pb-2 border-b-2 border-solid h-fit md:flex-row sm:justify-between dark:border-coolgray-200 border-neutral-200 md:items-center;
+    @apply flex flex-col gap-4 justify-items-start pb-2 border-b-2 border-solid h-fit md:flex-row sm:justify-between dark:border-coolgray-200 border-neutral-200 md:items-center text-neutral-700 dark:text-neutral-400;
 }
 
 @utility loading {

resources/views/auth/login.blade.php

@@ -61,7 +61,7 @@ class="text-sm dark:text-neutral-400 hover:text-coollabs dark:hover:text-warning
                                 <div class="w-full border-t border-neutral-300 dark:border-coolgray-400"></div>
                             </div>
                             <div class="relative flex justify-center text-sm">
-                                <span class="px-2 dark:bg-base text-neutral-500 dark:text-neutral-400">
+                                <span class="px-2 bg-gray-50 dark:bg-base text-neutral-500 dark:text-neutral-400 ">
                                     Don't have an account?
                                 </span>
                             </div>
@@ -82,7 +82,7 @@ class="block w-full text-center py-3 px-4 rounded-lg border border-neutral-300 d
                                 <div class="w-full border-t border-neutral-300 dark:border-coolgray-400"></div>
                             </div>
                             <div class="relative flex justify-center text-sm">
-                                <span class="px-2 dark:bg-base text-neutral-500 dark:text-neutral-400">or
+                                <span class="px-2 bg-gray-50 dark:bg-base text-neutral-500 dark:text-neutral-400">or
                                     continue with</span>
                             </div>
                         </div>

resources/views/auth/register.blade.php

@@ -33,7 +33,8 @@ function getOldOrLocal($key, $localValue)
                                 </svg>
                                 <div>
                                     <p class="font-bold text-warning">Root User Setup</p>
-                                    <p class="text-sm dark:text-white text-black">This user will be the root user with full admin access.</p>
+                                    <p class="text-sm dark:text-white text-black">This user will be the root user with full
+                                        admin access.</p>
                                 </div>
                             </div>
                         </div>
@@ -58,13 +59,16 @@ function getOldOrLocal($key, $localValue)
                         <x-forms.input id="password_confirmation" required type="password" name="password_confirmation"
                             label="{{ __('input.password.again') }}" />
 
-                        <div class="p-4 bg-neutral-50 dark:bg-coolgray-200 rounded-lg border border-neutral-200 dark:border-coolgray-400">
+                        <div
+                            class="p-4 bg-neutral-50 dark:bg-coolgray-200 rounded-lg border border-neutral-200 dark:border-coolgray-400">
                             <p class="text-xs dark:text-neutral-400">
-                                Your password should be min 8 characters long and contain at least one uppercase letter, one lowercase letter, one number, and one symbol.
+                                Your password should be min 8 characters long and contain at least one uppercase letter,
+                                one lowercase letter, one number, and one symbol.
                             </p>
                         </div>
 
-                        <x-forms.button class="w-full justify-center py-3 box-boarding mt-2" type="submit" isHighlighted>
+                        <x-forms.button class="w-full justify-center py-3 box-boarding mt-2" type="submit"
+                            isHighlighted>
                             Create Account
                         </x-forms.button>
                     </form>
@@ -74,17 +78,18 @@ function getOldOrLocal($key, $localValue)
                             <div class="w-full border-t border-neutral-300 dark:border-coolgray-400"></div>
                         </div>
                         <div class="relative flex justify-center text-sm">
-                            <span class="px-2 dark:bg-base text-neutral-500 dark:text-neutral-400">
+                            <span class="px-2 bg-gray-50 dark:bg-base text-neutral-500 dark:text-neutral-400">
                                 Already have an account?
                             </span>
                         </div>
                     </div>
 
-                    <a href="/login" class="block w-full text-center py-3 px-4 rounded-lg border border-neutral-300 dark:border-coolgray-400 font-medium hover:border-coollabs dark:hover:border-warning transition-colors">
+                    <a href="/login"
+                        class="block w-full text-center py-3 px-4 rounded-lg border border-neutral-300 dark:border-coolgray-400 font-medium hover:border-coollabs dark:hover:border-warning transition-colors">
                         {{ __('auth.already_registered') }}
                     </a>
                 </div>
             </div>
         </div>
     </section>
-</x-layout-simple>
+</x-layout-simple>

resources/views/auth/reset-password.blade.php

@@ -47,16 +47,19 @@
                             label="{{ __('input.email') }}" />
                         <x-forms.input required type="password" id="password" name="password"
                             label="{{ __('input.password') }}" />
-                        <x-forms.input required type="password" id="password_confirmation"
-                            name="password_confirmation" label="{{ __('input.password.again') }}" />
+                        <x-forms.input required type="password" id="password_confirmation" name="password_confirmation"
+                            label="{{ __('input.password.again') }}" />
 
-                        <div class="p-4 bg-neutral-50 dark:bg-coolgray-200 rounded-lg border border-neutral-200 dark:border-coolgray-400">
+                        <div
+                            class="p-4 bg-neutral-50 dark:bg-coolgray-200 rounded-lg border border-neutral-200 dark:border-coolgray-400">
                             <p class="text-xs dark:text-neutral-400">
-                                Your password should be min 8 characters long and contain at least one uppercase letter, one lowercase letter, one number, and one symbol.
+                                Your password should be min 8 characters long and contain at least one uppercase letter,
+                                one lowercase letter, one number, and one symbol.
                             </p>
                         </div>
 
-                        <x-forms.button class="w-full justify-center py-3 box-boarding mt-2" type="submit" isHighlighted>
+                        <x-forms.button class="w-full justify-center py-3 box-boarding mt-2" type="submit"
+                            isHighlighted>
                             {{ __('auth.reset_password') }}
                         </x-forms.button>
                     </form>
@@ -66,17 +69,18 @@
                             <div class="w-full border-t border-neutral-300 dark:border-coolgray-400"></div>
                         </div>
                         <div class="relative flex justify-center text-sm">
-                            <span class="px-2 dark:bg-base text-neutral-500 dark:text-neutral-400">
+                            <span class="px-2 bg-gray-50 dark:bg-base text-neutral-500 dark:text-neutral-400">
                                 Remember your password?
                             </span>
                         </div>
                     </div>
 
-                    <a href="/login" class="block w-full text-center py-3 px-4 rounded-lg border border-neutral-300 dark:border-coolgray-400 font-medium hover:border-coollabs dark:hover:border-warning transition-colors">
+                    <a href="/login"
+                        class="block w-full text-center py-3 px-4 rounded-lg border border-neutral-300 dark:border-coolgray-400 font-medium hover:border-coollabs dark:hover:border-warning transition-colors">
                         Back to Login
                     </a>
                 </div>
             </div>
         </div>
     </section>
-</x-layout-simple>
+</x-layout-simple>

resources/views/auth/two-factor-challenge.blade.php

@@ -120,7 +120,7 @@ class="mt-2 text-sm dark:text-neutral-400 hover:text-black dark:hover:text-white
                             <div class="w-full border-t border-neutral-300 dark:border-coolgray-400"></div>
                         </div>
                         <div class="relative flex justify-center text-sm">
-                            <span class="px-2 dark:bg-base text-neutral-500 dark:text-neutral-400">
+                            <span class="px-2 bg-gray-50 dark:bg-base text-neutral-500 dark:text-neutral-400">
                                 Need help?
                             </span>
                         </div>

resources/views/components/status/index.blade.php

@@ -12,6 +12,13 @@
 @else
     <x-status.stopped :status="$resource->status" />
 @endif
+@if (isset($resource->restart_count) && $resource->restart_count > 0 && !str($resource->status)->startsWith('exited'))
+    <div class="flex items-center pl-2">
+        <span class="text-xs dark:text-warning" title="Container has restarted {{ $resource->restart_count }} time{{ $resource->restart_count > 1 ? 's' : '' }}. Last restart: {{ $resource->last_restart_at?->diffForHumans() }}">
+            ({{ $resource->restart_count }}x restarts)
+        </span>
+    </div>
+@endif
 @if (!str($resource->status)->contains('exited') && $showRefreshButton)
     <button wire:loading.remove.delay.shortest wire:target="manualCheckStatus" title="Refresh Status" wire:click='manualCheckStatus'
         class="mx-1 dark:hover:fill-white fill-black dark:fill-warning">

resources/views/layouts/app.blade.php

@@ -17,7 +17,8 @@
                     localStorage.setItem('pageWidth', 'full');
                 }
             }
-        }" x-cloak class="mx-auto" :class="pageWidth === 'full' ? '' : 'max-w-7xl'">
+        }" x-cloak class="mx-auto dark:text-inherit text-black"
+            :class="pageWidth === 'full' ? '' : 'max-w-7xl'">
             <div class="relative z-50 lg:hidden" :class="open ? 'block' : 'hidden'" role="dialog" aria-modal="true">
                 <div class="fixed inset-0 bg-black/80" x-on:click="open = false"></div>
                 <div class="fixed inset-y-0 right-0 h-full flex">
@@ -45,9 +46,11 @@
                 </div>
             </div>
 
-            <div class="sticky top-0 z-40 flex items-center justify-between px-4 py-4 gap-x-6 sm:px-6 lg:hidden bg-white/95 dark:bg-base/95 backdrop-blur-sm border-b border-neutral-300/50 dark:border-coolgray-200/50">
+            <div
+                class="sticky top-0 z-40 flex items-center justify-between px-4 py-4 gap-x-6 sm:px-6 lg:hidden bg-white/95 dark:bg-base/95 backdrop-blur-sm border-b border-neutral-300/50 dark:border-coolgray-200/50">
                 <div class="flex items-center gap-3 flex-shrink-0">
-                    <a href="/" class="text-xl font-bold tracking-wide dark:text-white hover:opacity-80 transition-opacity">Coolify</a>
+                    <a href="/"
+                        class="text-xl font-bold tracking-wide dark:text-white hover:opacity-80 transition-opacity">Coolify</a>
                     <livewire:switch-team />
                 </div>
                 <button type="button" class="-m-2.5 p-2.5 dark:text-warning" x-on:click="open = !open">