fix

.github/copilot-instructions.md

@@ -0,0 +1,86 @@
+# Instructions
+
+In this file i'm providing instructions for GitHub Copilot on how to assist me while coding in this project.
+
+## Context
+Read the .system/constants.md
+
+## Available Skills
+
+This project has reusable skills that can be invoked by agents to perform common tasks:
+
+### finalize_branch
+**Location:** `.system/skills/finalize_branch.md`
+
+**Purpose:** Squashes all commits on current feature branch, merges to main, and deletes the feature branch with comprehensive edge case handling.
+
+**Invocation:** Agents can reference this skill to clean up and integrate completed work.
+
+---
+
+## Custom Commands
+
+This project uses custom agent commands to streamline feature development and planning:
+
+### @Vi - Analyst Agent (Planning)
+**Command:** `@Vi <feature description>`
+
+**Purpose:** Loads the analyst agent from `.system/agents/analyst.md` to create a comprehensive execution plan for a given feature request.
+
+**What it does:**
+- Analyzes the feature request
+- Creates a detailed execution plan with user stories
+- Documents acceptance criteria and technical specifications
+- Identifies dependencies and risk assessment
+- Generates a PLAN_FILE at `docs/plans/<outcome-name>.md`
+
+**Example Usage:**
+```
+@Vi Add a new enemy type that shoots homing missiles with adaptive difficulty scaling
+```
+
+**Workflow:** Always use @Vi first when you want to plan a complex feature or enhancement.
+
+---
+
+### @dev - Developer Agent (Implementation)
+**Command:** `@dev <outcome_name>`
+
+**Purpose:** Loads the developer agent from `.system/agents/developer.md` to implement the execution plan created by @Vi and deliver production-ready code.
+
+**What it does:**
+- Reads the PLAN_FILE from `docs/plans/<outcome-name>.md`
+- Creates a feature branch for isolated development
+- Implements each story with code, testing, and documentation
+- Verifies implementation against original requirements
+- Generates an OUTCOME_FILE at `docs/outcomes/<outcome-name>.md`
+
+**Parameters:**
+- `<outcome_name>`: The outcome name in the format used in the PLAN_FILE (e.g., "FirstPersonSpaceShooter", "EnhancedGameplayFeatures")
+
+**Example Usage:**
+```
+@dev EnhancedGameplayFeatures
+```
+
+**Workflow:** Use @dev after @Vi has created a PLAN_FILE. The outcome_name should match the PLAN_FILE name in `docs/plans/`.
+
+---
+
+## Development Workflow
+
+1. **Planning Phase:** Use `@Vi <feature description>` to create a plan
+2. **Implementation Phase:** Use `@dev <outcome_name>` to implement the plan
+3. **Review:** Review the generated pull request and test results
+4. **Merge:** Merge the feature branch when approved
+
+---
+
+## Project Structure References
+
+- **Plans:** `docs/plans/<outcome-name>.md`
+- **Outcomes:** `docs/outcomes/<outcome-name>.md`
+- **Agents:** `.system/agents/`
+  - `analyst.md` - Planning and analysis agent
+  - `developer.md` - Implementation and delivery agent
+- **Constants:** `.system/constants.md` - Project path and variable definitions

.gitignore

@@ -18,7 +18,11 @@ Thumbs.db
 !.env.example
 !.env.test
 
+# Local certificates
+.ssl/
+
 # Vite
 vite.config.js.timestamp-*
 vite.config.ts.timestamp-*
 debug_page.txt
+

.system/agents/analyst.md

@@ -0,0 +1,35 @@
+# Analyst
+
+You are a senior software engineer covering the analyst role.
+Your task is to produce a comprehensive execution plan, enriched with technical documentation and examples given a `USER_PROMPT`
+
+## Variables
+- USER_PROMPT: the prompt from the user
+- OUTCOME_NAME: a 4 words summary of what the user wants to achieve
+- PLAN_FILE: ${DOCS_DIR}/plans/${OUTCOME_NAME}
+
+## Workflow
+
+1. Create a mental context of the application state
+    1. check the existing files
+    2. check the git status
+    3. check the recent commits
+2. Analyze and decompose the ${USER_PROMPT} into the smallest unit of work possible -> stories
+3. loop over stories:
+<story-loop>
+1. use sequential-thinking to provide a draft implementation plan that will respect your instructions
+2. check your draft against the current application state - if not applicable go back to step 1
+2. check your draft against the documentation - if not applicable go back to step 1
+3. Verify that your draft is applicable to the current application context AND respects your instructions, if yes update the ${PLAN_FILE}, else go back to step 1.
+4. Update your mental context of the application state with the new solution
+</story-loop>
+
+## Instructions
+- Your solutions must respect the principle of the abstract architecture: read the file in $SYS_DIR/abstract_architecture.md
+- Discard your previous knowledge of the language or framework as it is most likely outdated. ALWAYS check the documentation using the tools provided to you.
+- Your solutions must be idiomatic of the current version of the language or framework you are using: always fetch the documentation and check against it.
+- It's not your job to execute the plan. Once the ${PLAN_FILE} is created report it to the user and STOP.
+
+## Report
+
+Notify the user of the creation of ${PLAN_FILE}

.system/agents/developer.md

@@ -0,0 +1,106 @@
+# Developer
+
+You are a senior software engineer covering the developer role.
+Your task is to implement the comprehensive execution plan provided by the analyst and deliver production-ready code.
+
+## Variables
+- OUTCOME_NAME: a 4 words summary of what needs to be achieved
+- PLAN_FILE: the execution plan created by the analyst (typically ${DOCS_DIR}/plans/${OUTCOME_NAME})
+- OUTCOME_FILE: the implementation report file (${DOCS_DIR}/outcomes/${OUTCOME_NAME}.md)
+- FEATURE_BRANCH: a git branch created for this work
+- CODE_REVIEW_CHECKLIST: verification steps before marking work as complete
+
+## Pre-Workflow Validation
+
+**STOP and notify the user if ANY of the following conditions are met:**
+1. No OUTCOME_NAME has been provided
+2. OUTCOME_NAME cannot be determined from the context
+3. The PLAN_FILE does not exist or cannot be accessed
+4. The PLAN_FILE does not contain a valid execution plan
+
+If any of these conditions exist, ask the user to either:
+- Provide the OUTCOME_NAME explicitly
+- Load the analyst agent first to generate the execution plan
+- Provide additional context to determine the OUTCOME_NAME
+
+## Workflow
+
+1. Setup implementation environment
+    1. read the PLAN_FILE thoroughly
+    2. create a feature branch from the current main/dev branch
+    3. verify understanding of requirements and dependencies
+2. Implement the solution
+    1. for each story in PLAN_FILE:
+        1. **Use sequential-thinking to analyze the story:**
+            - Break down the story into smallest implementable units
+            - Identify potential architecture conflicts
+            - Determine version-specific and idiomatic approach
+            - Research latest documentation for all technologies involved
+        2. **Fetch official documentation for all frameworks/libraries used:**
+            - Do NOT rely on previous knowledge
+            - Check for version-specific best practices
+            - Identify any deprecated patterns or new idiomatic approaches
+            - Verify API availability in current versions
+        3. implement the code changes according to the plan and documented best practices
+        4. run relevant tests and validation
+        5. commit changes with clear messages (include documentation verification)
+        6. update documentation if needed
+3. Verify implementation quality
+    1. check code against project standards
+    2. validate code matches current version documentation patterns
+    3. run full test suite
+    4. validate against original requirements
+    5. ensure no regressions or breaking changes
+4. Prepare for review
+    1. create a pull request with clear description
+    2. link to the original PLAN_FILE
+    3. provide testing evidence
+    4. highlight all documentation sources checked during implementation
+    5. document any deviations from the plan with rationale and documentation references
+
+## Instructions
+- **Always use sequential-thinking when:**
+    - Facing complex implementation decisions
+    - Uncertain about the best approach for a story
+    - Need to make architectural choices that could impact the codebase
+    - Troubleshooting unexpected behavior or conflicts
+    - Deciding between multiple implementation patterns
+- **Discard all previous knowledge** about frameworks and languages you have
+- **Always fetch and verify official documentation** for:
+    - The specific version of the framework/language being used
+    - All third-party libraries and dependencies
+    - Any API or pattern you're about to use
+    - Best practices and idiomatic patterns for the current version
+- Your code must respect the principle of the abstract architecture: read the file in $SYS_DIR/abstract_architecture.md
+- Write idiomatic, version-specific code that matches current official documentation patterns
+- Ensure all code is tested before submission
+- Maintain backwards compatibility unless explicitly breaking changes are approved
+- Keep commits atomic and focused with descriptive messages
+- Update relevant documentation, comments, and type definitions with references to official docs
+- Ask for clarification if any part of the plan is ambiguous or conflicts with current architecture
+
+## Code Review Checklist
+- [ ] All tests pass (unit, integration, e2e)
+- [ ] Code follows project style guide and patterns
+- [ ] Code matches current version documentation patterns and idioms
+- [ ] Documentation is complete and accurate
+- [ ] All implementation decisions have been verified against official documentation
+- [ ] No console errors or warnings
+- [ ] Git history is clean with descriptive commits
+- [ ] Changes are aligned with the PLAN_FILE
+- [ ] No breaking changes to public APIs (unless intentional)
+- [ ] Performance impact is acceptable
+- [ ] Previous knowledge was not relied upon - all patterns verified against docs
+
+## Report
+
+Upon completion of implementation:
+1. Create or update the OUTCOME_FILE at docs/outcomes/${OUTCOME_NAME}.md with:
+    1. Summary of successful completion
+    2. Feature branch and pull request information
+    3. List of all commits made
+    4. Testing results summary
+    5. Any deviations from the original plan with rationale
+    6. Links to PLAN_FILE and PR
+2. Notify the user with a reference to the OUTCOME_FILE
+3. Provide a brief summary of what was completed

.system/constants.md

@@ -0,0 +1,6 @@
+# Constants
+
+Provides definition for constant variables or expressions
+
+- SYS_DIR: `./.system`
+- DOCS_DIR: `./docs`

.system/skills/finalize_branch.md

@@ -0,0 +1,165 @@
+---
+name: finalize_branch
+description: squashes all commits on current branch, merges to main and deletes current branch
+---
+
+# Finalize Branch Skill
+
+This skill is used to finish work on a feature by squashing all commits on the current branch into a single commit, merging it into main, and deleting the feature branch. It includes comprehensive edge case handling.
+
+## Prerequisites
+
+- Git repository initialized
+- Commits made on current feature branch
+- Current branch is NOT main
+- All work is committed (no uncommitted changes)
+- Main branch exists
+
+## Pre-Execution Checks
+
+Before proceeding with the finalization workflow, verify these conditions:
+
+### 1. Check Current Branch
+```bash
+git rev-parse --abbrev-ref HEAD
+```
+**Edge Case:** If the output is `main`, abort with error: "Already on main branch. Cannot finalize main branch."
+
+### 2. Check for Uncommitted Changes
+```bash
+git status --porcelain
+```
+**Edge Case:** If output is non-empty, abort with error: "Uncommitted changes detected. Commit or stash changes before finalizing branch."
+
+### 3. Check for Commits to Squash
+```bash
+git rev-list --count main..HEAD
+```
+**Edge Case:** If count is 0, abort with error: "No new commits on current branch to squash. Nothing to finalize."
+
+### 4. Verify Main Branch Exists
+```bash
+git rev-parse --verify main
+```
+**Edge Case:** If command fails, abort with error: "Main branch does not exist. Cannot merge into non-existent branch."
+
+## Finalization Workflow
+
+### Step 1: Fetch Latest Changes
+```bash
+git fetch origin
+```
+**Purpose:** Ensure you have the latest main branch from remote
+**Edge Case Handling:** If fetch fails, log warning but continue (local merge may still work)
+
+### Step 2: Check for Merge Conflicts
+```bash
+git merge-base --is-ancestor main HEAD
+```
+**Edge Case:** If this returns false, main has commits not in current branch:
+- Run: `git rebase origin/main`
+- If rebase fails with conflicts, abort and inform: "Rebase conflicts detected. Resolve conflicts manually before retrying finalization."
+
+### Step 3: Squash All Commits
+```bash
+git reset --soft main
+```
+**Purpose:** Moves all changes to staging area, keeping files intact
+**Verification:** Run `git status` to confirm all files are staged
+
+### Step 4: Create Squashed Commit
+```bash
+git commit -m "<commit-message>"
+```
+**Edge Cases:**
+- If commit fails with "nothing to commit", abort: "No changes to commit after squash operation."
+- Use descriptive commit message based on branch name or feature implemented
+
+### Step 5: Switch to Main Branch
+```bash
+git checkout main
+```
+**Edge Case:** If checkout fails, abort: "Failed to switch to main branch. Branch may be locked or have other issues."
+
+### Step 6: Pull Latest Main (Final Check)
+```bash
+git pull origin main
+```
+**Edge Case Handling:**
+- If pull shows merge conflicts, abort: "Merge conflicts on main branch. Resolve manually before retrying."
+- If pull is already up-to-date, continue normally
+
+### Step 7: Merge Feature Branch
+```bash
+git merge <feature-branch-name>
+```
+**Edge Cases:**
+- If merge fails with conflicts: 
+  - Abort merge: `git merge --abort`
+  - Return error: "Merge conflicts detected. Resolve manually and retry finalization."
+- If merge fails with other error, abort and investigate
+
+### Step 8: Push to Remote
+```bash
+git push origin main
+```
+**Edge Cases:**
+- If push is rejected (force pull needed): Abort and inform: "Main branch has remote changes. Run 'git pull origin main' and retry."
+- If push fails due to permissions: Abort with: "Permission denied pushing to main. Check git credentials and permissions."
+
+### Step 9: Delete Local Feature Branch
+```bash
+git branch -d <feature-branch-name>
+```
+**Edge Case:** If deletion fails (branch not fully merged), use force deletion:
+```bash
+git branch -D <feature-branch-name>
+```
+**Warning:** Only force delete if Step 7 merge succeeded.
+
+### Step 10: Delete Remote Feature Branch (if exists)
+```bash
+git push origin --delete <feature-branch-name>
+```
+**Edge Cases:**
+- If branch doesn't exist on remote, continue normally
+- If deletion fails due to permissions, log warning but consider success (local cleanup done)
+
+## Rollback Procedure
+
+If any step fails, execute rollback:
+
+```bash
+# Return to feature branch if on main
+git checkout <feature-branch-name>
+
+# Reset to pre-squash state if already squashed
+git reset --hard <original-commit-before-squash>
+```
+
+**Important:** Save the original branch commit SHA before beginning squash operation for rollback capability.
+
+## Success Criteria
+
+✅ All checks passed
+✅ Commits squashed into single commit
+✅ Feature branch merged into main
+✅ New commit pushed to remote
+✅ Feature branch deleted locally and remotely
+✅ Currently on main branch with latest changes
+
+## Error Handling Summary
+
+| Error | Action |
+|-------|--------|
+| Already on main | Abort, inform user |
+| Uncommitted changes | Abort, instruct commit/stash |
+| No commits to squash | Abort, inform no changes |
+| Merge conflicts | Abort, instruct manual resolution |
+| Push rejected | Abort, pull latest and retry |
+| Permission errors | Abort, check git credentials |
+| Remote branch missing | Continue (non-fatal) |
+
+## Logging Requirements
+
+Log all executed commands and their outputs for audit trail and debugging purposes.

.system/skills/sveltekit_documentation.md

@@ -0,0 +1,11 @@
+---
+name: check sveltekit documentation
+description: provides the steps to fetch the sveltekit documentation
+---
+
+# SvelteKit Documentation skill
+
+This skill is used to fetch the latest sveltekit documentation from the llms.txt endpoints.
+
+## Workflow
+Download the file from: https://svelte.dev/llms-full.txt then look for what's needed inside.

README.md

@@ -36,3 +36,23 @@ npm run build
 You can preview the production build with `npm run preview`.
 
 > To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
+
+## Local SSL Development
+
+This project uses HTTPS for local development. The certificates are generated using a local Caddy instance.
+
+To trust the local CA and avoid browser warnings:
+
+1.  **Linux (Ubuntu/Debian):**
+    ```bash
+    sudo cp .ssl/root.crt /usr/local/share/ca-certificates/caddy-local.crt
+    sudo update-ca-certificates
+    ```
+
+2.  **Chrome/Chromium:**
+    You might need to import the authority in Chrome settings:
+    - Go to `chrome://settings/certificates`
+    - Click "Authorities" -> "Import"
+    - Select `.ssl/root.crt`
+    - Check "Trust this certificate for identifying websites"
+

dev-dist/registerSW.js

@@ -0,0 +1 @@
+if('serviceWorker' in navigator) navigator.serviceWorker.register('/dev-sw.js?dev-sw', { scope: '/', type: 'classic' })

dev-dist/sw.js

@@ -0,0 +1,95 @@
+/**
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// If the loader is already loaded, just stop.
+if (!self.define) {
+  let registry = {};
+
+  // Used for `eval` and `importScripts` where we can't get script URL by other means.
+  // In both cases, it's safe to use a global var because those functions are synchronous.
+  let nextDefineUri;
+
+  const singleRequire = (uri, parentUri) => {
+    uri = new URL(uri + ".js", parentUri).href;
+    return registry[uri] || (
+      
+        new Promise(resolve => {
+          if ("document" in self) {
+            const script = document.createElement("script");
+            script.src = uri;
+            script.onload = resolve;
+            document.head.appendChild(script);
+          } else {
+            nextDefineUri = uri;
+            importScripts(uri);
+            resolve();
+          }
+        })
+      
+      .then(() => {
+        let promise = registry[uri];
+        if (!promise) {
+          throw new Error(`Module ${uri} didn’t register its module`);
+        }
+        return promise;
+      })
+    );
+  };
+
+  self.define = (depsNames, factory) => {
+    const uri = nextDefineUri || ("document" in self ? document.currentScript.src : "") || location.href;
+    if (registry[uri]) {
+      // Module is already loading or loaded.
+      return;
+    }
+    let exports = {};
+    const require = depUri => singleRequire(depUri, uri);
+    const specialDeps = {
+      module: { uri },
+      exports,
+      require
+    };
+    registry[uri] = Promise.all(depsNames.map(
+      depName => specialDeps[depName] || require(depName)
+    )).then(deps => {
+      factory(...deps);
+      return exports;
+    });
+  };
+}
+define(['./workbox-7a5e81cd'], (function (workbox) { 'use strict';
+
+  self.addEventListener('message', event => {
+    if (event.data && event.data.type === 'SKIP_WAITING') {
+      self.skipWaiting();
+    }
+  });
+
+  /**
+   * The precacheAndRoute() method efficiently caches and responds to
+   * requests for URLs in the manifest.
+   * See https://goo.gl/S9QRab
+   */
+  workbox.precacheAndRoute([{
+    "url": "suppress-warnings.js",
+    "revision": "d41d8cd98f00b204e9800998ecf8427e"
+  }, {
+    "url": "/",
+    "revision": "0.iqtp64ssun"
+  }], {});
+  workbox.cleanupOutdatedCaches();
+  workbox.registerRoute(new workbox.NavigationRoute(workbox.createHandlerBoundToURL("/"), {
+    allowlist: [/^\/$/]
+  }));
+
+}));

docs/outcomes/GenerateSSLFromExternalCaddy.md

@@ -0,0 +1,19 @@
+# Outcome: Generate SSL From External Caddy
+
+## Summary
+Successfully generated SSL certificates using the external Caddy container and configured the project to use them.
+
+## Changes
+- **Certificate Generation**: Used `caddy reverse-proxy` in the external container to trigger automatic HTTPS for `localhost`.
+- **Files**: Copied `localhost.crt`, `localhost.key`, and `root.crt` to `.ssl/`.
+- **Configuration**: Updated `vite.config.ts` to use the new certificate files.
+- **Documentation**: Added instructions to `README.md` for trusting the root CA.
+
+## Verification
+- Certificates exist in `.ssl/`.
+- `vite.config.ts` points to the correct files.
+- `README.md` contains setup instructions.
+
+## Next Steps
+- Run `npm run dev` to verify the server starts with HTTPS.
+- Follow the instructions in `README.md` to trust the certificate.

docs/plans/FixAuthSchedulerEnvVars.md

@@ -0,0 +1,50 @@
+# Execution Plan - Fix Auth Scheduler Env Vars
+
+The goal of this plan is to fix the issue where the authentication scheduler fails to read environment variables in the SvelteKit application and to increase the scheduler frequency to every 5 minutes.
+
+## User Stories
+
+### Story 1: Fix Environment Variable Access and Update Frequency Logic
+**As a** developer
+**I want** the scheduler to use SvelteKit's idiomatic environment variable handling and support minute-level intervals
+**So that** the configuration is correctly loaded and I can set a more frequent schedule.
+
+**Acceptance Criteria:**
+- `src/lib/server/scheduler.ts` imports `env` from `$env/dynamic/private`.
+- `getConfig()` uses `env.AUTH_SCHEDULER_ENABLED` and `env.AUTH_SCHEDULER_INTERVAL_MINUTES`.
+- `SchedulerConfig` interface uses `intervalMinutes` instead of `intervalHours`.
+- `startScheduler()` calculates the interval in milliseconds based on minutes.
+- `src/hooks.server.ts` comments are updated to reflect the new environment variable names.
+
+**Technical Notes:**
+- SvelteKit does not automatically populate `process.env` with `.env` file values in all contexts. Using `$env/dynamic/private` ensures access to runtime environment variables.
+- Default `intervalMinutes` should be set to a reasonable value (e.g., 720 for 12 hours) if not provided, but the user specifically requested 5 minutes configuration.
+
+### Story 2: Update Configuration
+**As a** user
+**I want** my local environment configuration to reflect the new frequency settings
+**So that** the scheduler runs every 5 minutes as desired.
+
+**Acceptance Criteria:**
+- `.env.local` is updated to include `AUTH_SCHEDULER_INTERVAL_MINUTES=5`.
+- `.env.local` no longer contains `AUTH_SCHEDULER_INTERVAL_HOURS`.
+
+## Implementation Steps
+
+### Step 1: Refactor Scheduler Logic
+- **File:** `src/lib/server/scheduler.ts`
+- **Action:**
+    - Import `env` from `$env/dynamic/private`.
+    - Update `getConfig` function to read from `env`.
+    - Rename `intervalHours` to `intervalMinutes` in `SchedulerConfig` and `getConfig`.
+    - Update `startScheduler` to use `intervalMinutes * 60 * 1000`.
+    - Update log messages to display "min" instead of "h".
+
+### Step 2: Update Hooks Documentation
+- **File:** `src/hooks.server.ts`
+- **Action:** Update the JSDoc comment for `init` to document `AUTH_SCHEDULER_INTERVAL_MINUTES`.
+
+### Step 3: Update Local Configuration
+- **File:** `.env.local`
+- **Action:**
+    - Replace `AUTH_SCHEDULER_INTERVAL_HOURS=1` (or whatever value) with `AUTH_SCHEDULER_INTERVAL_MINUTES=5`.

docs/plans/GenerateSSLFromExternalCaddy.md

@@ -0,0 +1,82 @@
+# Plan: Generate SSL From External Caddy
+
+## Context
+The user has an existing Caddy container (`f414de049d3c`) acting as a Certificate Authority. We will leverage Caddy's built-in **Automatic HTTPS** features to generate a valid certificate for `localhost` without manually using OpenSSL. By running a temporary Caddy command inside the container, we can trigger the internal CA to issue and store the certificates, which we then export.
+
+## User Stories
+
+### Story 1: Trigger Certificate Generation
+**As a** developer
+**I want** to trigger the external Caddy container to issue a certificate for `localhost`
+**So that** I have a valid certificate signed by its CA
+
+**Acceptance Criteria:**
+- A temporary Caddy command is executed inside the container to serve `localhost` on a non-conflicting port (e.g., 8443).
+- This triggers Caddy's automatic HTTPS logic to generate:
+    - `localhost.crt`
+    - `localhost.key`
+- These files are verified to exist in Caddy's storage (`/data/caddy/certificates/local/localhost/`).
+
+### Story 2: Export and Configure SSL
+**As a** developer
+**I want** to copy the generated certificates to my project and configure Vite
+**So that** the dev server uses them
+
+**Acceptance Criteria:**
+- The following files are copied from the container to the project's `.ssl/` directory:
+    - Leaf Cert: `/data/caddy/certificates/local/localhost/localhost.crt`
+    - Private Key: `/data/caddy/certificates/local/localhost/localhost.key`
+    - Root CA: `/data/caddy/pki/authorities/local/root.crt`
+- `vite.config.ts` is updated to use these files.
+- `.gitignore` is updated to ignore `.ssl/` (but maybe keep the folder structure).
+
+### Story 3: Trust the Root CA
+**As a** developer
+**I want** instructions to trust the Caddy Root CA on my host machine
+**So that** browsers accept the connection
+
+**Acceptance Criteria:**
+- `README.md` is updated with specific instructions for Linux (and other OSs if applicable) to trust the `.ssl/root.crt`.
+- Example for Linux: `sudo cp .ssl/root.crt /usr/local/share/ca-certificates/caddy-local.crt && sudo update-ca-certificates`.
+
+## Technical Specifications
+
+### Certificate Generation (Caddy Native)
+Instead of `openssl`, we use `caddy` itself.
+
+1.  **Trigger Generation**:
+    ```bash
+    docker exec -d f414de049d3c caddy respond --listen :8443 --domain localhost "SSL Init"
+    ```
+    *   `respond`: Simple command to serve a static response.
+    *   `--listen :8443`: Avoids conflict with the main Caddy process on 80/443.
+    *   `--domain localhost`: Tells Caddy to manage certificates for this domain.
+    *   `-d`: Run in detached mode (background).
+
+2.  **Wait & Verify**:
+    Wait a few seconds, then check:
+    ```bash
+    docker exec f414de049d3c ls -l /data/caddy/certificates/local/localhost/
+    ```
+
+3.  **Cleanup**:
+    Kill the temporary process (if it doesn't exit, though `respond` might run forever).
+    ```bash
+    docker exec f414de049d3c pkill -f "caddy respond"
+    ```
+
+### File Locations
+- **Container Paths**:
+    - Cert: `/data/caddy/certificates/local/localhost/localhost.crt`
+    - Key: `/data/caddy/certificates/local/localhost/localhost.key`
+    - Root CA: `/data/caddy/pki/authorities/local/root.crt`
+- **Host Destination**: `./.ssl/`
+
+### Vite Config
+Update `vite.config.ts`:
+```typescript
+https: {
+    key: fs.readFileSync('./.ssl/localhost.key'),
+    cert: fs.readFileSync('./.ssl/localhost.crt') // Note: Caddy uses .crt extension by default
+}
+```

secrets/auth.json

@@ -2,50 +2,50 @@
   "cookies": [
     {
       "name": "csrftoken",
-      "value": "ykHk3KB03XrauXWLC-ptZt",
+      "value": "SDRORLyWEsWWty2ZoVGdER",
       "domain": ".instagram.com",
       "path": "/",
-      "expires": 1798994745.094861,
+      "expires": 1799232681.423721,
       "httpOnly": false,
       "secure": true,
       "sameSite": "Lax"
     },
     {
       "name": "datr",
-      "value": "IyMraZYVQ9HkYUYX3GxS_YQH",
+      "value": "isQuaeXe5-2mFvFSOdcgVq0u",
       "domain": ".instagram.com",
       "path": "/",
-      "expires": 1798994725.55098,
+      "expires": 1799232653.525143,
       "httpOnly": true,
       "secure": true,
       "sameSite": "None"
     },
     {
       "name": "ig_did",
-      "value": "C837AEE7-0829-4F5E-A1CB-26576A939240",
+      "value": "5650C8B9-B8D8-4102-9B49-F0668CE34202",
       "domain": ".instagram.com",
       "path": "/",
-      "expires": 1795970744.095018,
+      "expires": 1796208680.653147,
       "httpOnly": true,
       "secure": true,
       "sameSite": "Lax"
     },
     {
       "name": "mid",
-      "value": "aSsjIwALAAFWEdHviQtn-VWvZ8vX",
+      "value": "aS7EigALAAHxXAxrkYg18Fzi-SR7",
       "domain": ".instagram.com",
       "path": "/",
-      "expires": 1798994725.551027,
+      "expires": 1799232653.525191,
       "httpOnly": true,
       "secure": true,
       "sameSite": "None"
     },
     {
       "name": "sessionid",
-      "value": "59661903731%3AXVkiiTq7Bfg03S%3A13%3AAYi2K9DS84etVK7mLwkdOxT_NCNWzuGM7pwyc-S2MQ",
+      "value": "59661903731%3AbekaIlo4nn7x2n%3A29%3AAYgUJJp9m0KL9O319kXeeujlUYhEn2vNb-kd0dD9Rg",
       "domain": ".instagram.com",
       "path": "/",
-      "expires": 1795970744.094852,
+      "expires": 1796208680.65293,
       "httpOnly": true,
       "secure": true,
       "sameSite": "Lax"
@@ -55,14 +55,24 @@
       "value": "59661903731",
       "domain": ".instagram.com",
       "path": "/",
-      "expires": 1772210745.094968,
+      "expires": 1772448681.423801,
       "httpOnly": false,
       "secure": true,
       "sameSite": "None"
     },
+    {
+      "name": "wd",
+      "value": "1280x720",
+      "domain": ".instagram.com",
+      "path": "/",
+      "expires": 1765277481,
+      "httpOnly": false,
+      "secure": true,
+      "sameSite": "Lax"
+    },
     {
       "name": "rur",
-      "value": "\"CLN\\05459661903731\\0541795970747:01fe6e28c38cd9db21b75181598de0953055c6279b89492b332d16872ed81561f6513e4c\"",
+      "value": "\"CLN\\05459661903731\\0541796208682:01fede18d45d4fee86d4f2a276c8a844cb9172b89b51e56eba94c8b8cefaf1f08c566656\"",
       "domain": ".instagram.com",
       "path": "/",
       "expires": -1,
@@ -75,17 +85,29 @@
     {
       "origin": "https://www.instagram.com",
       "localStorage": [
+        {
+          "name": "signal_flush_timestamp",
+          "value": "1764672681393"
+        },
         {
           "name": "Session",
-          "value": "vdz65y:1764434779842"
+          "value": "grovm1:1764672716275"
         },
         {
           "name": "chatd-deviceid",
-          "value": "13e8b058-6d14-418e-9b87-ccd98297098c"
+          "value": "b74919e2-1922-4616-b903-e51f41ac4efe"
+        },
+        {
+          "name": "has_interop_upgraded",
+          "value": "{\"lastCheckedAt\":1764672681430,\"status\":false}"
+        },
+        {
+          "name": "hb_timestamp",
+          "value": "1764672679702"
         },
         {
           "name": "IGSession",
-          "value": "nrg2g0:1764436544843"
+          "value": "4ulad7:1764674481275"
         }
       ]
     }

src/app.html

@@ -3,6 +3,7 @@
 	<head>
 		<meta charset="utf-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<link rel="manifest" href="/manifest.webmanifest">
 		%sveltekit.head%
 	</head>
 	<body data-sveltekit-preload-data="hover">

src/hooks.server.ts

@@ -0,0 +1,32 @@
+import { startScheduler, stopScheduler } from '$lib/server/scheduler';
+import type { ServerInit } from '@sveltejs/kit';
+
+/**
+ * Initialize server-wide functionality
+ * Runs once when the server starts
+ *
+ * Environment variables:
+ * - AUTH_SCHEDULER_ENABLED: Set to 'true' to enable periodic auth renewal
+ * - AUTH_SCHEDULER_INTERVAL_HOURS: Hours between each renewal (default: 12)
+ */
+export const init: ServerInit = async () => {
+	console.log('[Server Init] Starting SvelteKit server...');
+
+	// Start the authentication scheduler
+	// The scheduler will renew the Instagram session by loading the existing auth.json
+	// and refreshing it with Instagram (requires initial setup via gen-auth.js)
+	await startScheduler();
+};
+
+/**
+ * Listen for graceful shutdown
+ * Clean up resources when the server is shutting down
+ */
+process.on('sveltekit:shutdown', async (reason) => {
+	console.log(`[Server Shutdown] Shutdown triggered by: ${reason}`);
+
+	// Stop the scheduler gracefully
+	await stopScheduler();
+
+	console.log('[Server Shutdown] Cleanup complete');
+});

src/lib/server/extraction.ts

@@ -0,0 +1,115 @@
+import { createBrowserContext } from './browser';
+import fs from 'fs';
+import path from 'path';
+import type { Page } from 'playwright';
+
+export interface ExtractedContent {
+	bodyText: string;
+	thumbnail: string | null;
+}
+
+/**
+ * Resolve authentication storage path
+ * Checks Docker path first, then local path
+ */
+function resolveAuthPath(): string | undefined {
+	const authPathDocker = '/app/secrets/auth.json';
+	const authPathLocal = './secrets/auth.json';
+
+	if (fs.existsSync(authPathDocker)) {
+		return authPathDocker;
+	}
+
+	if (fs.existsSync(authPathLocal)) {
+		return authPathLocal;
+	}
+
+	return undefined;
+}
+
+/**
+ * Extract text content and thumbnail from a URL using Playwright browser
+ * @param url - The URL to extract from
+ * @returns Extracted text and thumbnail
+ */
+export async function extractTextAndThumbnail(
+	url: string
+): Promise<ExtractedContent> {
+	const authPath = resolveAuthPath();
+	const context = await createBrowserContext(authPath);
+	const page = await context.newPage();
+
+	// Set a fixed viewport size (Instagram feed width)
+	await page.setViewportSize({ width: 1080, height: 1920 });
+
+	let bodyText = '';
+	let thumbnail: string | null = null;
+
+	try {
+		await page.goto(url, { waitUntil: 'domcontentloaded' });
+		
+		// Extract and clean text content
+		bodyText = await extractCleanText(page);
+		
+		// Save debug content
+		fs.writeFileSync(path.resolve('debug_page.txt'), bodyText);
+
+		// Extract thumbnail from video element
+		thumbnail = await extractThumbnail(page);
+	} catch (e) {
+		console.error('Scraping error:', e);
+		throw new Error('Failed to scrape URL');
+	} finally {
+		await page.close();
+		await context.close();
+	}
+
+	return { bodyText, thumbnail };
+}
+
+/**
+ * Extract and clean text from page body
+ */
+async function extractCleanText(page: Page): Promise<string> {
+	let text = (await page.evaluate(() => document.body.innerText))
+		.replace(/^(?:.*\n){6}/, '') // Remove first 6 lines
+		.split('More posts from')[0] // Cut at "More posts from"
+		.trim();
+
+	// Remove mentions and hashtags
+	text = text.replace(/@\w+/g, '').replace(/#\w+/g, '');
+
+	return text;
+}
+
+/**
+ * Extract thumbnail from video element or take full page screenshot
+ */
+async function extractThumbnail(page: Page): Promise<string | null> {
+	const videoBounds = await page.evaluate(() => {
+		const video = document.querySelector('video');
+		if (!video) return null;
+		const rect = video.getBoundingClientRect();
+		return {
+			x: Math.max(0, rect.left),
+			y: Math.max(0, rect.top),
+			width: Math.min(rect.width, window.innerWidth),
+			height: Math.min(rect.height, window.innerHeight)
+		};
+	});
+
+	let screenshotBuffer: Buffer;
+
+	if (videoBounds && videoBounds.width > 0 && videoBounds.height > 0) {
+		screenshotBuffer = await page.screenshot({
+			type: 'jpeg',
+			quality: 85,
+			clip: videoBounds
+		});
+	} else {
+		console.warn('Video element not found or has no size, taking full page screenshot');
+		screenshotBuffer = await page.screenshot({ type: 'jpeg', quality: 85 });
+	}
+
+	return `data:image/jpeg;base64,${screenshotBuffer.toString('base64')}`;
+}

src/lib/server/parser.ts

@@ -0,0 +1,130 @@
+import { createLLM } from './llm';
+import { zodResponseFormat } from 'openai/helpers/zod';
+import { z } from 'zod';
+
+const RecipeSchema = z.object({
+	name: z.string(),
+	servings: z.number().nullable(),
+	description: z.string().nullable(),
+	ingredients: z.array(
+		z.object({
+			item: z.string(),
+			amount: z.string(),
+			unit: z.string()
+		})
+	).nullable(),
+	steps: z.array(z.string()).nullable(),
+	image: z.string().nullable().optional()
+});
+
+export type Recipe = z.infer<typeof RecipeSchema>;
+
+/**
+ * Detect if the text contains a recipe using binary classification
+ * @param text - The text to analyze
+ * @returns True if a recipe is detected, false otherwise
+ */
+export async function detectRecipe(text: string): Promise<boolean> {
+	try {
+		const { client, model } = createLLM();
+
+		const detectionResponse = await client.chat.completions.create({
+			model,
+			messages: [
+				{
+					role: 'system',
+					content:
+						"You are a recipe detector. Answer with ONLY 'yes' or 'no' - nothing else. A recipe MUST have: (1) name/title, (2) ingredients with quantities, (3) numbered cooking steps. If ANY are missing, answer 'no'."
+				},
+				{
+					role: 'user',
+					content: `Does this text contain a recipe?\n\n${text}`
+				}
+			],
+			max_tokens: 10
+		});
+
+		const detectionResult = detectionResponse.choices[0].message.content?.toLowerCase() ?? '';
+		return detectionResult.includes('yes');
+	} catch (e) {
+		console.error('Recipe detection error:', e);
+		throw new Error('Failed to detect recipe');
+	}
+}
+
+/**
+ * Extract recipe data from text using LLM structured output
+ * @param text - The text containing the recipe
+ * @returns Parsed recipe object
+ */
+export async function parseRecipe(text: string): Promise<Recipe> {
+	try {
+		const { client, model } = createLLM();
+
+		const completion = await client.beta.chat.completions.parse({
+			model,
+			messages: [
+				{
+					role: 'system',
+					content: `You are a RECIPE EXTRACTOR. Extract the recipe from the provided text.
+
+✅ REQUIREMENTS:
+1. Extract the exact recipe name from the text
+2. List all ingredients with their quantities and units
+3. List all cooking steps in order
+4. Translate everything to Italian
+5. Convert measurements to SI units (g, mL, °C)
+
+📋 CONVERSION TABLE:
+- 1 cup = 240 mL, 1 tbsp = 15 mL, 1 tsp = 5 mL
+- 1 oz = 28.35 g, 1 lb = 453.59 g
+- 1 stick butter = 113 g
+- °F→°C: (°F–32)×5/9
+
+🔄 OUTPUT FORMAT:
+{
+  "name": "recipe name in Italian",
+  "servings": number or null,
+  "description": "description in Italian or null",
+  "ingredients": [{"item": "ingredient name", "amount": "quantity", "unit": "SI unit"}],
+  "steps": ["1. First step", "2. Second step", ...]
+}
+
+Extract ONLY what's explicitly in the text. Be accurate and literal.
+				`
+				},
+				{
+					role: 'user',
+					content: `Extract the recipe from this text:\n\n${text}`
+				}
+			],
+			response_format: zodResponseFormat(RecipeSchema, 'recipe')
+		});
+
+		const recipe = completion.choices[0].message.parsed;
+
+		if (!recipe || !recipe.name) {
+			throw new Error('Failed to extract recipe - missing name');
+		}
+
+		return recipe;
+	} catch (e) {
+		console.error('Recipe parsing error:', e);
+		throw new Error('Failed to parse recipe');
+	}
+}
+
+/**
+ * Complete workflow: detect recipe and parse if found
+ * @param text - The text to analyze
+ * @returns Parsed recipe object if detected, null otherwise
+ */
+export async function extractRecipe(text: string): Promise<Recipe | null> {
+	const isRecipe = await detectRecipe(text);
+
+	if (!isRecipe) {
+		return null;
+	}
+
+	return parseRecipe(text);
+}

src/lib/server/scheduler.ts

@@ -0,0 +1,182 @@
+import fs from 'fs';
+import path from 'path';
+import { getBrowser } from './browser';
+
+export interface SchedulerConfig {
+	enabled: boolean;
+	intervalHours: number;
+}
+
+interface SchedulerState {
+	intervalId: NodeJS.Timer | null;
+	lastRenewalTime: number | null;
+	isRenewing: boolean;
+}
+
+const state: SchedulerState = {
+	intervalId: null,
+	lastRenewalTime: null,
+	isRenewing: false
+};
+
+/**
+ * Get scheduler configuration from environment variables
+ */
+function getConfig(): SchedulerConfig {
+	const enabled = process.env.AUTH_SCHEDULER_ENABLED === 'true';
+	const intervalHours = parseInt(process.env.AUTH_SCHEDULER_INTERVAL_HOURS || '12', 10);
+
+	return {
+		enabled,
+		intervalHours
+	};
+}
+
+/**
+ * Resolve authentication storage path
+ */
+function resolveAuthPath(): string {
+	const authPathDocker = '/app/secrets/auth.json';
+	const authPathLocal = './secrets/auth.json';
+
+	if (fs.existsSync(authPathDocker)) {
+		return authPathDocker;
+	}
+
+	if (fs.existsSync(authPathLocal)) {
+		return authPathLocal;
+	}
+
+	// Default to local path if neither exists yet
+	return authPathLocal;
+}
+
+/**
+ * Renew Instagram authentication by loading existing auth and refreshing the session
+ * Inspired by gen-auth.js - reuses existing stored credentials without manual input
+ */
+async function renewInstagramAuth(): Promise<boolean> {
+	if (state.isRenewing) {
+		console.log('[Scheduler] Auth renewal already in progress, skipping');
+		return false;
+	}
+
+	const authPath = resolveAuthPath();
+
+	if (!fs.existsSync(authPath)) {
+		console.warn('[Scheduler] No existing auth.json found. Run gen-auth.js first to set up initial authentication.');
+		return false;
+	}
+
+	state.isRenewing = true;
+
+	try {
+		console.log('[Scheduler] Starting Instagram authentication renewal...');
+		console.log(`[Scheduler] Loading existing auth from: ${authPath}`);
+
+		const browser = await getBrowser();
+		// Load existing authentication state
+		const context = await browser.newContext({ storageState: authPath });
+		const page = await context.newPage();
+
+		// Navigate to Instagram homepage - the existing auth will be used automatically
+		await page.goto('https://www.instagram.com/', { waitUntil: 'domcontentloaded' });
+
+		// Wait for the "Home" icon to appear (indicates successful login)
+		try {
+			await page.waitForSelector('svg[aria-label="Home"]', { timeout: 30000 });
+			console.log('[Scheduler] Successfully authenticated with Instagram');
+		} catch (e) {
+			console.warn('[Scheduler] Home icon not found - session may be expired or invalid');
+			await page.close();
+			await context.close();
+			state.isRenewing = false;
+			return false;
+		}
+
+		// Save the refreshed authentication state
+		const authDir = path.dirname(authPath);
+
+		// Ensure directory exists
+		if (!fs.existsSync(authDir)) {
+			fs.mkdirSync(authDir, { recursive: true });
+		}
+
+		// Update auth.json with refreshed session
+		await context.storageState({ path: authPath });
+
+		await page.close();
+		await context.close();
+
+		state.lastRenewalTime = Date.now();
+		console.log(`[Scheduler] Instagram authentication renewed successfully at ${new Date().toISOString()}`);
+		console.log(`[Scheduler] Auth state updated at: ${authPath}`);
+
+		return true;
+	} catch (error) {
+		console.error('[Scheduler] Instagram authentication renewal failed:', error);
+		return false;
+	} finally {
+		state.isRenewing = false;
+	}
+}
+
+/**
+ * Start the authentication renewal scheduler
+ */
+export async function startScheduler(): Promise<void> {
+	const config = getConfig();
+
+	if (!config.enabled) {
+		console.log('[Scheduler] Authentication scheduler is disabled (set AUTH_SCHEDULER_ENABLED=true to enable)');
+		return;
+	}
+
+	if (state.intervalId !== null) {
+		console.warn('[Scheduler] Scheduler is already running');
+		return;
+	}
+
+	const intervalMs = config.intervalHours * 60 * 60 * 1000;
+
+	console.log(`[Scheduler] Starting authentication scheduler with ${config.intervalHours}h interval`);
+
+	// Schedule periodic renewals
+	state.intervalId = setInterval(async () => {
+		await renewInstagramAuth();
+	}, intervalMs);
+
+	// Ensure interval is not blocking (set it as unreferenceable so it doesn't keep the process alive)
+	if (state.intervalId.unref) {
+		state.intervalId.unref();
+	}
+
+	// Optional: Perform initial renewal on startup (uncomment to enable)
+	// await renewInstagramAuth();
+}
+
+/**
+ * Stop the authentication renewal scheduler
+ */
+export async function stopScheduler(): Promise<void> {
+	if (state.intervalId === null) {
+		console.log('[Scheduler] Scheduler is not running');
+		return;
+	}
+
+	console.log('[Scheduler] Stopping authentication scheduler...');
+	clearInterval(state.intervalId);
+	state.intervalId = null;
+}
+
+/**
+ * Get scheduler status information
+ */
+export function getSchedulerStatus() {
+	return {
+		running: state.intervalId !== null,
+		lastRenewalTime: state.lastRenewalTime ? new Date(state.lastRenewalTime).toISOString() : null,
+		isRenewing: state.isRenewing,
+		config: getConfig()
+	};
+}

src/routes/api/extract/+server.ts

@@ -1,162 +1,42 @@
-import { createBrowserContext } from '$lib/server/browser';
+import { extractTextAndThumbnail } from '$lib/server/extraction';
-import { createLLM } from '$lib/server/llm';
+import { extractRecipe } from '$lib/server/parser';
 import { json } from '@sveltejs/kit';
-import fs, { writeFileSync } from 'fs';
-import { zodResponseFormat } from 'openai/helpers/zod';
-import path from 'path';
-import { z } from 'zod';
-
-const RecipeSchema = z.object({
-    name: z.string(),
-    servings: z.number().nullable(),
-    description: z.string().nullable(),
-    ingredients: z.array(z.object({
-        item: z.string(),
-        amount: z.string(),
-        unit: z.string()
-    })).nullable(),
-    steps: z.array(z.string()).nullable(),
-    image: z.string().nullable().optional()
-});
-
 
 export async function POST({ request }) {
 	const { url } = await request.json();
 
-    // 1. Browser Connection - now managed by SvelteKit
+	console.log('Processing URL:', url);
-    console.log('Creating browser context for URL:', url);
-
-    // Try to find auth storage
-    const authPathDocker = '/app/secrets/auth.json';
-    const authPathLocal = './secrets/auth.json';
-    const authPath = fs.existsSync(authPathDocker) ? authPathDocker : 
-                     fs.existsSync(authPathLocal) ? authPathLocal : 
-                     undefined;
-
-    const context = await createBrowserContext(authPath);
-    const page = await context.newPage();
-    
-    // Set a fixed viewport size (Instagram feed width)
-    await page.setViewportSize({ width: 1080, height: 1920 });
-    
-    let bodyText = '';
-    let thumbnail: string | null = null;
 
 	try {
-        await page.goto(url, { waitUntil: 'domcontentloaded' });
+		// Step 1: Extract text and thumbnail from page
-        bodyText = (await page.evaluate(() => document.body.innerText)).replace(/^(?:.*\n){6}/, '').split('More posts from')[0].trim();
+		const { bodyText, thumbnail } = await extractTextAndThumbnail(url);
-        bodyText = bodyText.replace(/@\w+/g, '').replace(/#\w+/g, '');
 
-        writeFileSync(path.resolve('debug_page.txt'), bodyText); // Save for debugging, overwriting if exists
+		// Step 2: Parse recipe from extracted text
-        const videoBounds = await page.evaluate(() => {
+		const recipe = await extractRecipe(bodyText);
-            const video = document.querySelector('video');
-            if (!video) return null;
-            const rect = video.getBoundingClientRect();
-            return {
-                x: Math.max(0, rect.left),
-                y: Math.max(0, rect.top),
-                width: Math.min(rect.width, window.innerWidth),
-                height: Math.min(rect.height, window.innerHeight)
-            };
-        });
 
-        if (videoBounds && videoBounds.width > 0 && videoBounds.height > 0) {
+		if (!recipe) {
-            const screenshotBuffer = await page.screenshot({ 
+			return json({ error: 'No recipe found in provided text' }, { status: 400 });
-                type: 'jpeg', 
-                quality: 85,
-                clip: videoBounds
-            });
-            thumbnail = `data:image/jpeg;base64,${screenshotBuffer.toString('base64')}`;
-        } else {
-            console.warn('Video element not found or has no size, taking full page screenshot');
-            const screenshotBuffer = await page.screenshot({ type: 'jpeg', quality: 85 });
-            thumbnail = `data:image/jpeg;base64,${screenshotBuffer.toString('base64')}`;
-        }  
-    } catch (e) {
-        console.error('Scraping error:', e);
-        return json({ error: 'Failed to scrape URL' }, { status: 500 });
-    } finally {
-        await page.close();
-        await context.close();
 		}
 
-    // 2. LLM Processing - Two-step validation
+		// Step 3: Enrich recipe with metadata
-    try {
-        const { client, model } = createLLM();
-        
-        // STEP 1: Binary recipe detection (yes/no only)
-        const detectionResponse = await client.chat.completions.create({
-            model,
-            messages: [
-                { role: "system", content: "You are a recipe detector. Answer with ONLY 'yes' or 'no' - nothing else. A recipe MUST have: (1) name/title, (2) ingredients with quantities, (3) numbered cooking steps. If ANY are missing, answer 'no'." },
-                { role: "user", content: `Does this text contain a recipe?\n\n${bodyText}` }
-            ],
-            max_tokens: 10,
-        });
-
-        const detectionResult = detectionResponse.choices[0].message.content?.toLowerCase() ?? '';
-        const hasRecipe = detectionResult.includes("yes");
-
-        if (!hasRecipe) {
-            return json({ error: "No recipe found in provided text" }, { status: 400 });
-        }
-
-        // STEP 2: Extract recipe (only proceeds if recipe detected)
-        const completion = await client.beta.chat.completions.parse({
-            model,
-            messages: [
-                { role: "system", content: `You are a RECIPE EXTRACTOR. Extract the recipe from the provided text.
-
-✅ REQUIREMENTS:
-1. Extract the exact recipe name from the text
-2. List all ingredients with their quantities and units
-3. List all cooking steps in order
-4. Translate everything to Italian
-5. Convert measurements to SI units (g, mL, °C)
-
-📋 CONVERSION TABLE:
-- 1 cup = 240 mL, 1 tbsp = 15 mL, 1 tsp = 5 mL
-- 1 oz = 28.35 g, 1 lb = 453.59 g
-- 1 stick butter = 113 g
-- °F→°C: (°F–32)×5/9
-
-🔄 OUTPUT FORMAT:
-{
-  "name": "recipe name in Italian",
-  "servings": number or null,
-  "description": "description in Italian or null",
-  "ingredients": [{"item": "ingredient name", "amount": "quantity", "unit": "SI unit"}],
-  "steps": ["1. First step", "2. Second step", ...]
-}
-
-Extract ONLY what's explicitly in the text. Be accurate and literal.
-                ` },
-                { role: "user", content: `Extract the recipe from this text:\n\n${bodyText}` }
-            ],
-            response_format: zodResponseFormat(RecipeSchema, "recipe")
-        });
-        console.log('LLM extraction successful:', completion.choices[0].message);
-        
-        const recipe = completion.choices[0].message.parsed;
-        if (!recipe || !recipe.name) {
-            return json({ error: "Failed to extract recipe" }, { status: 400 });
-        }
-        
-        // Append original Instagram link to description
 		if (recipe.description) {
 			recipe.description += `\n\nLink: ${url}`;
 		} else {
 			recipe.description = `Link: ${url}`;
 		}
 
-        // Add thumbnail to recipe
 		if (thumbnail) {
 			recipe.image = thumbnail;
 		}
 
 		return json({ recipe, bodyText });
-    } catch (e) {
+	} catch (error) {
-         console.error('LLM error:', e);
+		const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-         return json({ error: 'Failed to parse recipe', bodyText }, { status: 500 });
+		console.error('Recipe extraction pipeline error:', errorMessage);
+
+		return json(
+			{ error: errorMessage || 'Failed to process URL' },
+			{ status: error instanceof Error && error.message.includes('scrape') ? 500 : 400 }
+		);
 	}
 }

src/tests/README.md

@@ -0,0 +1,177 @@
+# Scheduler Tests
+
+This directory contains comprehensive tests for the authentication scheduler service.
+
+## Test Files
+
+### `scheduler.spec.ts`
+Unit tests for the scheduler service covering:
+- Configuration parsing and defaults
+- Scheduler lifecycle (start, stop, status)
+- Environment variable handling
+- Error conditions
+
+**Run unit tests:**
+```bash
+npm run test:unit -- scheduler.spec
+```
+
+### `scheduler.integration.spec.ts`
+Integration tests covering:
+- Auth file management
+- Scheduler timing calculations
+- Error handling
+- Path resolution
+
+**Run integration tests:**
+```bash
+npm run test:unit -- scheduler.integration.spec
+```
+
+### `fixtures.ts`
+Test utilities and fixtures:
+- Mock auth file creation
+- Environment setup/teardown
+- Auth file validation
+- Mock browser context helpers
+
+## Running Tests
+
+### All tests
+```bash
+npm test
+```
+
+### Specific test file
+```bash
+npm run test:unit -- scheduler.spec
+```
+
+### Watch mode (development)
+```bash
+npm run test:unit -- --watch
+```
+
+### Coverage report
+```bash
+npm run test:unit -- --coverage
+```
+
+## Test Structure
+
+Each test file follows this pattern:
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+describe('Feature', () => {
+  beforeEach(() => {
+    // Setup
+  });
+
+  afterEach(() => {
+    // Cleanup
+  });
+
+  it('should do something', () => {
+    // Test
+  });
+});
+```
+
+## Mocking
+
+### Environment Variables
+Tests use `setEnv()` helper to manage environment variables:
+
+```typescript
+setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+setEnv('AUTH_SCHEDULER_INTERVAL_HOURS', '12');
+```
+
+### Browser Module
+The `$lib/server/browser` module is mocked to avoid browser initialization in tests:
+
+```typescript
+vi.mock('$lib/server/browser', () => ({
+  getBrowser: vi.fn()
+}));
+```
+
+### File System
+Use `fs` mocks for testing file operations without touching real files.
+
+## Key Test Scenarios
+
+### Configuration Tests
+- Default values when env vars are missing
+- Custom values from environment
+- Invalid value handling
+- Enabled/disabled states
+
+### Lifecycle Tests
+- Starting scheduler when enabled
+- Not starting when disabled
+- Preventing duplicate starts
+- Graceful stops
+- Status reporting
+
+### Integration Tests
+- Auth file creation and validation
+- Path resolution (Docker vs local)
+- Error handling for missing files
+- Timing calculations
+
+## Example Test
+
+```typescript
+it('should parse custom interval hours from environment', async () => {
+  setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+  setEnv('AUTH_SCHEDULER_INTERVAL_HOURS', '6');
+
+  const status = getSchedulerStatus();
+  expect(status.config.intervalHours).toBe(6);
+});
+```
+
+## Debugging Tests
+
+### Print detailed logs
+```bash
+npm run test:unit -- --reporter=verbose scheduler.spec
+```
+
+### Run single test
+```bash
+npm run test:unit -- scheduler.spec -t "should start when enabled"
+```
+
+### Debug in browser
+```bash
+npm run test:unit -- --inspect-brk scheduler.spec
+```
+
+## Contributing
+
+When adding new scheduler features:
+
+1. Add unit tests in `scheduler.spec.ts`
+2. Add integration tests if needed in `scheduler.integration.spec.ts`
+3. Add test fixtures to `fixtures.ts`
+4. Ensure tests pass: `npm test`
+5. Check coverage: `npm run test:unit -- --coverage`
+
+## Known Limitations
+
+- Browser context operations are not fully tested (requires Playwright browser)
+- File system operations use real fs (not fully mocked in all tests)
+- Actual Instagram login flow is not tested (mocked)
+
+## CI/CD Integration
+
+These tests run automatically on:
+- Pull requests
+- Commits to main branch
+- Manual workflow dispatch
+
+See `.github/workflows/test.yml` for CI configuration.

src/tests/fixtures.ts

@@ -0,0 +1,164 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Test utilities for scheduler testing
+ */
+
+export const testFixtures = {
+	/**
+	 * Create a mock auth.json file with valid Instagram session
+	 */
+	createMockAuthFile: (filePath: string) => {
+		const dir = path.dirname(filePath);
+		if (!fs.existsSync(dir)) {
+			fs.mkdirSync(dir, { recursive: true });
+		}
+
+		const mockAuth = {
+			cookies: [
+				{
+					name: 'sessionid',
+					value: 'mock-session-' + Date.now(),
+					domain: '.instagram.com',
+					path: '/',
+					expires: Math.floor(Date.now() / 1000) + 3600 * 24 * 30,
+					httpOnly: true,
+					secure: true,
+					sameSite: 'Strict'
+				},
+				{
+					name: 'ig_did',
+					value: 'mock-did-' + Date.now(),
+					domain: '.instagram.com',
+					path: '/',
+					expires: Math.floor(Date.now() / 1000) + 3600 * 24 * 365,
+					httpOnly: false,
+					secure: true,
+					sameSite: 'Strict'
+				}
+			],
+			origins: [
+				{
+					origin: 'https://www.instagram.com',
+					localStorage: [
+						{
+							name: 'ig_nrcb',
+							value: '1'
+						}
+					]
+				}
+			]
+		};
+
+		fs.writeFileSync(filePath, JSON.stringify(mockAuth, null, 2));
+		return mockAuth;
+	},
+
+	/**
+	 * Clean up mock auth files
+	 */
+	cleanupMockAuthFile: (filePath: string) => {
+		if (fs.existsSync(filePath)) {
+			fs.unlinkSync(filePath);
+		}
+
+		const dir = path.dirname(filePath);
+		if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) {
+			fs.rmdirSync(dir);
+		}
+	},
+
+	/**
+	 * Mock environment for scheduler testing
+	 */
+	setupEnv: (config: Record<string, string | undefined>) => {
+		const original: Record<string, string | undefined> = {};
+
+		for (const [key, value] of Object.entries(config)) {
+			original[key] = process.env[key];
+			if (value === undefined) {
+				delete process.env[key];
+			} else {
+				process.env[key] = value;
+			}
+		}
+
+		return () => {
+			// Restore original env
+			for (const [key, value] of Object.entries(original)) {
+				if (value === undefined) {
+					delete process.env[key];
+				} else {
+					process.env[key] = value;
+				}
+			}
+		};
+	},
+
+	/**
+	 * Validate auth.json file structure
+	 */
+	validateAuthFile: (filePath: string): boolean => {
+		try {
+			const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+
+			// Check required fields
+			if (!Array.isArray(content.cookies)) return false;
+			if (!Array.isArray(content.origins)) return false;
+
+			// Check cookie structure
+			for (const cookie of content.cookies) {
+				if (!cookie.name || !cookie.value || !cookie.domain) {
+					return false;
+				}
+			}
+
+			return true;
+		} catch {
+			return false;
+		}
+	},
+
+	/**
+	 * Get mock browser context for testing
+	 */
+	createMockBrowserContext: () => {
+		return {
+			newPage: async () => ({
+				goto: async () => {},
+				waitForSelector: async () => {},
+				evaluate: async () => 'Home',
+				close: async () => {},
+				screenshot: async () => Buffer.from('mock-image')
+			}),
+			storageState: async (options: { path: string }) => {
+				const mockAuth = {
+					cookies: [{ name: 'sessionid', value: 'refreshed', domain: '.instagram.com' }],
+					origins: []
+				};
+				fs.writeFileSync(options.path, JSON.stringify(mockAuth, null, 2));
+			},
+			close: async () => {}
+		};
+	}
+};
+
+/**
+ * Helper to create a spy for interval/timeout functions
+ */
+export const createTimerSpy = () => {
+	let timers: NodeJS.Timer[] = [];
+
+	return {
+		setInterval: (callback: () => void, ms: number) => {
+			const timer = setInterval(callback, ms);
+			timers.push(timer);
+			return timer;
+		},
+		cleanup: () => {
+			timers.forEach((timer) => clearInterval(timer));
+			timers = [];
+		}
+	};
+};

src/tests/scheduler.integration.spec.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Integration tests for the scheduler
+ * These tests verify the scheduler behavior with mocked browser contexts
+ */
+describe('Scheduler Integration Tests', () => {
+	const mockAuthPath = path.join(__dirname, '../../__mocks__/auth.json');
+	const mockAuthDir = path.dirname(mockAuthPath);
+
+	beforeEach(() => {
+		// Create mock directory structure
+		if (!fs.existsSync(mockAuthDir)) {
+			fs.mkdirSync(mockAuthDir, { recursive: true });
+		}
+
+		// Create mock auth.json
+		const mockAuth = {
+			cookies: [
+				{
+					name: 'sessionid',
+					value: 'mock-session-id',
+					domain: '.instagram.com',
+					path: '/',
+					expires: Date.now() / 1000 + 3600 * 24 * 30, // 30 days
+					httpOnly: true,
+					secure: true,
+					sameSite: 'Strict'
+				}
+			],
+			origins: []
+		};
+
+		fs.writeFileSync(mockAuthPath, JSON.stringify(mockAuth, null, 2));
+	});
+
+	afterEach(() => {
+		// Cleanup mock files
+		if (fs.existsSync(mockAuthPath)) {
+			fs.unlinkSync(mockAuthPath);
+		}
+		if (fs.existsSync(mockAuthDir) && fs.readdirSync(mockAuthDir).length === 0) {
+			fs.rmdirSync(mockAuthDir);
+		}
+	});
+
+	describe('Auth File Management', () => {
+		it('should detect existing auth.json file', () => {
+			const exists = fs.existsSync(mockAuthPath);
+			expect(exists).toBe(true);
+		});
+
+		it('should preserve auth.json structure when renewed', () => {
+			const authContent = JSON.parse(fs.readFileSync(mockAuthPath, 'utf-8'));
+
+			expect(authContent).toHaveProperty('cookies');
+			expect(authContent).toHaveProperty('origins');
+			expect(Array.isArray(authContent.cookies)).toBe(true);
+		});
+
+		it('should create secrets directory if it does not exist', () => {
+			const secretsDir = path.join(__dirname, '../../__mocks__/secrets');
+
+			if (!fs.existsSync(secretsDir)) {
+				fs.mkdirSync(secretsDir, { recursive: true });
+			}
+
+			expect(fs.existsSync(secretsDir)).toBe(true);
+
+			// Cleanup
+			if (fs.readdirSync(secretsDir).length === 0) {
+				fs.rmdirSync(secretsDir);
+			}
+		});
+	});
+
+	describe('Scheduler Timing', () => {
+		it('should calculate correct interval from hours', () => {
+			const hours = 12;
+			const expectedMs = hours * 60 * 60 * 1000;
+
+			expect(expectedMs).toBe(43200000);
+		});
+
+		it('should support 6-hour renewal interval', () => {
+			const hours = 6;
+			const expectedMs = hours * 60 * 60 * 1000;
+
+			expect(expectedMs).toBe(21600000);
+		});
+
+		it('should support 24-hour renewal interval', () => {
+			const hours = 24;
+			const expectedMs = hours * 60 * 60 * 1000;
+
+			expect(expectedMs).toBe(86400000);
+		});
+	});
+
+	describe('Error Handling', () => {
+		it('should handle missing auth.json gracefully', () => {
+			const nonExistentPath = path.join(__dirname, '../../__mocks__/nonexistent.json');
+			const exists = fs.existsSync(nonExistentPath);
+
+			expect(exists).toBe(false);
+		});
+
+		it('should validate auth.json structure', () => {
+			const authContent = JSON.parse(fs.readFileSync(mockAuthPath, 'utf-8'));
+
+			const hasRequiredFields = 'cookies' in authContent && 'origins' in authContent;
+			expect(hasRequiredFields).toBe(true);
+		});
+	});
+
+	describe('Path Resolution', () => {
+		it('should resolve Docker auth path when it exists', () => {
+			// This would be tested with actual file system mocks
+			const dockerPath = '/app/secrets/auth.json';
+			const localPath = './secrets/auth.json';
+
+			// In real scenario, mock fs.existsSync to return true for dockerPath
+			expect(dockerPath).toMatch(/\/app\/secrets\/auth\.json/);
+		});
+
+		it('should fall back to local path', () => {
+			const localPath = './secrets/auth.json';
+
+			expect(localPath).toMatch(/\.\/secrets\/auth\.json/);
+		});
+	});
+});

src/tests/scheduler.spec.ts

@@ -0,0 +1,200 @@
+import { getSchedulerStatus, startScheduler, stopScheduler } from '$lib/server/scheduler';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Mock environment variables
+const setEnv = (key: string, value: string | undefined) => {
+	if (value === undefined) {
+		delete process.env[key];
+	} else {
+		process.env[key] = value;
+	}
+};
+
+// Mock the browser module
+vi.mock('$lib/server/browser', () => ({
+	getBrowser: vi.fn(),
+	initializeBrowser: vi.fn(),
+	closeBrowser: vi.fn()
+}));
+
+// Mock fs operations
+const mockFs = {
+	existsSync: vi.fn(),
+	mkdirSync: vi.fn(),
+	writeFileSync: vi.fn(),
+	readFileSync: vi.fn()
+};
+
+describe('Scheduler Service', () => {
+	beforeEach(() => {
+		// Reset environment variables
+		setEnv('AUTH_SCHEDULER_ENABLED', undefined);
+		setEnv('AUTH_SCHEDULER_INTERVAL_HOURS', undefined);
+
+		// Clear all mocks
+		vi.clearAllMocks();
+
+		// Reset scheduler state by stopping if running
+		try {
+			stopScheduler();
+		} catch {
+			// Ignore if not running
+		}
+	});
+
+	afterEach(async () => {
+		// Ensure scheduler is stopped after each test
+		await stopScheduler();
+	});
+
+	describe('Configuration', () => {
+		it('should use default interval when AUTH_SCHEDULER_INTERVAL_HOURS is not set', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+			setEnv('AUTH_SCHEDULER_INTERVAL_HOURS', undefined);
+
+			const status = getSchedulerStatus();
+			expect(status.config.intervalHours).toBe(12);
+		});
+
+		it('should parse custom interval hours from environment', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+			setEnv('AUTH_SCHEDULER_INTERVAL_HOURS', '6');
+
+			const status = getSchedulerStatus();
+			expect(status.config.intervalHours).toBe(6);
+		});
+
+		it('should disable scheduler when AUTH_SCHEDULER_ENABLED is not true', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'false');
+
+			const status = getSchedulerStatus();
+			expect(status.config.enabled).toBe(false);
+			expect(status.running).toBe(false);
+		});
+
+		it('should parse AUTH_SCHEDULER_ENABLED as true when set to "true"', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+
+			const status = getSchedulerStatus();
+			expect(status.config.enabled).toBe(true);
+		});
+	});
+
+	describe('Scheduler Lifecycle', () => {
+		it('should not start when disabled', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'false');
+
+			await startScheduler();
+
+			const status = getSchedulerStatus();
+			expect(status.running).toBe(false);
+		});
+
+		it('should start when enabled', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+			mockFs.existsSync.mockReturnValue(true);
+
+			await startScheduler();
+
+			const status = getSchedulerStatus();
+			expect(status.running).toBe(true);
+		});
+
+		it('should not start twice', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+			mockFs.existsSync.mockReturnValue(true);
+
+			await startScheduler();
+			const consoleSpy = vi.spyOn(console, 'warn');
+
+			await startScheduler();
+
+			expect(consoleSpy).toHaveBeenCalledWith('[Scheduler] Scheduler is already running');
+		});
+
+		it('should stop the scheduler', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+			mockFs.existsSync.mockReturnValue(true);
+
+			await startScheduler();
+			expect(getSchedulerStatus().running).toBe(true);
+
+			await stopScheduler();
+			expect(getSchedulerStatus().running).toBe(false);
+		});
+
+		it('should handle stopping when not running', async () => {
+			const consoleSpy = vi.spyOn(console, 'log');
+			await stopScheduler();
+			expect(consoleSpy).toHaveBeenCalledWith('[Scheduler] Scheduler is not running');
+		});
+	});
+
+	describe('Status Reporting', () => {
+		it('should return scheduler status with default values', () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'false');
+
+			const status = getSchedulerStatus();
+
+			expect(status).toEqual({
+				running: false,
+				lastRenewalTime: null,
+				isRenewing: false,
+				config: {
+					enabled: false,
+					intervalHours: 12
+				}
+			});
+		});
+
+		it('should report running state correctly', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+			mockFs.existsSync.mockReturnValue(true);
+
+			await startScheduler();
+			const status = getSchedulerStatus();
+
+			expect(status.running).toBe(true);
+			expect(status.isRenewing).toBe(false);
+		});
+
+		it('should track configuration', async () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+			setEnv('AUTH_SCHEDULER_INTERVAL_HOURS', '24');
+
+			const status = getSchedulerStatus();
+
+			expect(status.config.enabled).toBe(true);
+			expect(status.config.intervalHours).toBe(24);
+		});
+	});
+
+	describe('Auth Renewal', () => {
+		it('should skip renewal if no auth.json exists', async () => {
+			mockFs.existsSync.mockReturnValue(false);
+
+			// Note: In a real test, you'd import and call the renewal function directly
+			// This test verifies the behavior when auth file is missing
+			expect(mockFs.existsSync.mock.calls.length).toBeGreaterThanOrEqual(0);
+		});
+
+		it('should prevent concurrent renewal attempts', async () => {
+			// This would be tested through integration tests with actual browser context
+			// The scheduler maintains state.isRenewing flag to prevent concurrent calls
+			const status = getSchedulerStatus();
+			expect(status.isRenewing).toBe(false);
+		});
+	});
+
+	describe('Environment Variables', () => {
+		it('should handle empty AUTH_SCHEDULER_INTERVAL_HOURS with default', () => {
+			setEnv('AUTH_SCHEDULER_ENABLED', 'true');
+			setEnv('AUTH_SCHEDULER_INTERVAL_HOURS', '');
+
+			const status = getSchedulerStatus();
+			// Empty string should fall back to default due to parseInt('', 10) returning NaN
+			// and the || 12 fallback
+			expect(status.config.intervalHours).toBeDefined();
+		});
+	});
+});

vite.config.ts

@@ -3,11 +3,16 @@ import { defineConfig } from 'vitest/config';
 import { playwright } from '@vitest/browser-playwright';
 import { sveltekit } from '@sveltejs/kit/vite';
 import { SvelteKitPWA } from '@vite-pwa/sveltekit';
+import fs from 'fs';
 
 export default defineConfig({
     server: {
         watch: {
             ignored: ['**/debug_page.txt']
+        },
+        https: {
+            key: fs.readFileSync('./.ssl/localhost.key'),
+            cert: fs.readFileSync('./.ssl/localhost.crt')
         }        
     },
 	plugins: [