mozempk/insta-recipe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix

Browse Source
This commit is contained in:
Giancarmine Salucci
2025-12-21 02:03:05 +01:00
parent 167cd1f4bb
commit 9357bd483a
36 changed files with 6251 additions and 1547 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
.github/copilot-instructions.md vendored Normal file
View File

@@ -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

4
.gitignore vendored
View File

@@ -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

0
.system/abstract_architecture.md Normal file
View File

35
.system/agents/analyst.md Normal file
View File

@@ -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}

106
.system/agents/developer.md Normal file
View File

@@ -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

6
.system/constants.md Normal file
View File

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

165
.system/skills/finalize_branch.md Normal file
View File

@@ -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.

11
.system/skills/sveltekit_documentation.md Normal file
View File

@@ -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.

20
README.md
View File

@@ -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"

1
dev-dist/registerSW.js Normal file
View File

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

0
dev-dist/suppress-warnings.js Normal file
View File

95
dev-dist/sw.js Normal file
View File

@@ -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: [/^\/$/]
}));
}));

3377
dev-dist/workbox-7a5e81cd.js Normal file
View File

File diff suppressed because it is too large Load Diff

19
docs/outcomes/GenerateSSLFromExternalCaddy.md Normal file
View File

@@ -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.

50
docs/plans/FixAuthSchedulerEnvVars.md Normal file
View File

@@ -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`.

82
docs/plans/GenerateSSLFromExternalCaddy.md Normal file
View File

@@ -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
}
```

515
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

818
patch.js
View File

@@ -1,410 +1,410 @@
import fs from 'node:fs';
import path from 'node:path';
const log = (msg) => console.log(`\x1b[36m[Patch]\x1b[0m ${msg}`);
// --- 1. Fix package.json ---
log('Patching package.json...');
const pkgPath = path.resolve('package.json');
if (fs.existsSync(pkgPath)) {
const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
// FIX: Downgrade Vite to v6 to satisfy PWA/Tailwind peer deps
if (pkg.devDependencies?.vite) {
log(`Create-svelte installed Vite ${pkg.devDependencies.vite}. Downgrading to ^6.0.0 for compatibility.`);
pkg.devDependencies.vite = "^6.0.0";
}
// Add Backend Dependencies
pkg.dependencies = {
...pkg.dependencies,
"zod": "^3.23.0",
"openai": "^4.20.0"
// playwright is already in your devDependencies, which is fine for the service approach
};
// Add PWA Dev Dependency
pkg.devDependencies = {
...pkg.devDependencies,
"@vite-pwa/sveltekit": "^0.3.0"
};
fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 4));
log('✅ package.json updated.');
} else {
console.error('❌ package.json not found! Are you in the project root?');
process.exit(1);
}
// --- 2. Inject PWA into vite.config.ts ---
log('Updating vite.config.ts...');
const viteConfigPath = path.resolve('vite.config.ts');
let viteConfig = fs.readFileSync(viteConfigPath, 'utf-8');
// Check if already patched to avoid duplicates
if (!viteConfig.includes('SvelteKitPWA')) {
// Add Import
if (viteConfig.includes('import { sveltekit }')) {
viteConfig = viteConfig.replace(
"import { sveltekit } from '@sveltejs/kit/vite';",
"import { sveltekit } from '@sveltejs/kit/vite';\nimport { SvelteKitPWA } from '@vite-pwa/sveltekit';"
);
}
// Add Plugin (Insert before sveltekit to be safe, or commonly after)
// We look for 'plugins: [' and append the PWA config
const pwaConfig = `
SvelteKitPWA({
srcDir: './src',
mode: 'development',
strategies: 'generateSW',
scope: '/',
base: '/',
selfDestroying: process.env.SELF_DESTROYING_SW === 'true',
manifest: {
short_name: 'InstaChef',
name: 'InstaChef Recipe Saver',
start_url: '/',
scope: '/',
display: 'standalone',
theme_color: "#ffffff",
background_color: "#ffffff",
icons: [
{ src: '/favicon.png', sizes: '192x192', type: 'image/png' },
{ src: '/favicon.png', sizes: '512x512', type: 'image/png' }
],
share_target: {
action: '/share',
method: 'GET',
enctype: 'application/x-www-form-urlencoded',
params: { title: 'title', text: 'text', url: 'url' }
}
},
workbox: {
globPatterns: ['client/**/*.{js,css,ico,png,svg,webp,woff,woff2}']
},
devOptions: {
enabled: true,
suppressWarnings: true,
navigateFallback: '/',
},
}),`;
// Insert inside plugins array
viteConfig = viteConfig.replace('plugins: [', `plugins: [${pwaConfig}`);
fs.writeFileSync(viteConfigPath, viteConfig);
log('✅ vite.config.ts updated with PWA settings.');
} else {
log('ℹ️ vite.config.ts already contains PWA settings. Skipping.');
}
// --- 3. Create Backend & Docker Files ---
// We write these strictly to avoid overwriting your existing src/ files
// (except for the new API routes)
const newFiles = {
// Docker Composition
'docker-compose.yml': `
services:
app:
build: .
ports:
- "5173:5173"
environment:
- PLAYWRIGHT_WS_ENDPOINT=ws://playwright-service:3000
- OPENAI_BASE_URL=http://ollama:11434/v1
- OPENAI_API_KEY=ollama
- LLM_MODEL=llama3.2
volumes:
- ./src:/app/src
- ./secrets:/app/secrets:ro
depends_on:
- playwright-service
- ollama
playwright-service:
build: ./playwright-service
ipc: host
ports: ["3000:3000"]
environment:
- DISPLAY=:99
security_opt:
- seccomp=unconfined
ollama:
image: ollama/ollama:latest
ports: ["11434:11434"]
volumes:
- ollama_data:/root/.ollama
volumes:
ollama_data:
`,
// Dockerfile for SvelteKit
'Dockerfile': `
FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
EXPOSE 5173
CMD ["npm", "run", "dev", "--", "--host"]
`,
// Playwright Service
'playwright-service/Dockerfile': `
FROM mcr.microsoft.com/playwright:v1.49.0-jammy
WORKDIR /app
RUN npm init -y && npm install playwright
COPY server.js .
EXPOSE 3000
CMD ["node", "server.js"]
`,
'playwright-service/server.js': `
const { chromium } = require('playwright');
(async () => {
const server = await chromium.launchServer({
port: 3000,
headless: true,
args: ['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
});
console.log('Browser Server running on port 3000...');
await new Promise(() => {});
})();
`,
// Auth Generator Script (Updated to use imports since project is type: module)
'scripts/gen-auth.js': `
import { chromium } from 'playwright';
import fs from 'fs';
import path from 'path';
(async () => {
const browser = await chromium.launch({ headless: false });
const context = await browser.newContext();
const page = await context.newPage();
console.log('🔹 Navigating to Instagram...');
await page.goto('https://www.instagram.com/');
console.log('⏳ Please log in manually. Waiting for "Home" icon...');
try {
await page.waitForSelector('svg[aria-label="Home"]', { timeout: 120000 });
const secretsDir = path.resolve('secrets');
if (!fs.existsSync(secretsDir)) fs.mkdirSync(secretsDir);
await context.storageState({ path: path.join(secretsDir, 'auth.json') });
console.log('🎉 Session saved to secrets/auth.json');
} catch (e) {
console.error('❌ Timeout or error:', e);
}
await browser.close();
})();
`,
// Logic: LLM Client
'src/lib/server/llm.ts': `
import OpenAI from 'openai';
import { env } from '$env/dynamic/private';
export const createLLM = () => {
// Detect if we are using Ollama or OpenAI based on URL
const baseURL = env.OPENAI_BASE_URL;
const client = new OpenAI({
apiKey: env.OPENAI_API_KEY,
baseURL: baseURL
});
return { client, model: env.LLM_MODEL || 'gpt-4o' };
};
`,
// Logic: API Endpoint
'src/routes/api/extract/+server.ts': `
import { json } from '@sveltejs/kit';
import { createLLM } from '$lib/server/llm';
import { z } from 'zod';
import { zodResponseFormat } from 'openai/helpers/zod';
import { chromium } from 'playwright';
import fs from 'fs';
import { env } from '$env/dynamic/private';
const RecipeSchema = z.object({
name: z.string(),
description: z.string(),
steps: z.array(z.string()),
ingredients: z.array(z.object({
item: z.string(),
amount: z.string(),
unit: z.string()
}))
});
export async function POST({ request }) {
const { url } = await request.json();
// 1. Browser Connection
// Fallback to localhost if env var not set (e.g. running outside docker)
const wsEndpoint = env.PLAYWRIGHT_WS_ENDPOINT || 'ws://127.0.0.1:3000';
console.log('Connecting to browser at:', wsEndpoint);
const browser = await chromium.connect(wsEndpoint);
// 2. Load Auth if available
const authPath = '/app/secrets/auth.json';
let context;
// We check absolute path (Docker) or relative (Local)
if (fs.existsSync(authPath)) {
context = await browser.newContext({ storageState: authPath });
} else if (fs.existsSync('./secrets/auth.json')) {
context = await browser.newContext({ storageState: './secrets/auth.json' });
} else {
console.warn('No auth.json found. Running as guest.');
context = await browser.newContext();
}
const page = await context.newPage();
let bodyText = '';
try {
await page.goto(url, { waitUntil: 'domcontentloaded' });
// Naive scraper attempt
bodyText = await page.evaluate(() => document.body.innerText);
} catch (e) {
console.error('Scraping error:', e);
return json({ error: 'Failed to scrape URL' }, { status: 500 });
} finally {
await page.close();
await context.close();
await browser.close();
}
// 3. LLM Processing
try {
const { client, model } = createLLM();
const completion = await client.beta.chat.completions.parse({
model,
messages: [
{ role: "system", content: "Extract a recipe structure from this text. If it is not a recipe, return empty arrays." },
{ role: "user", content: bodyText.substring(0, 8000) } // Limit context window
],
response_format: zodResponseFormat(RecipeSchema, "recipe")
});
return json({ recipe: completion.choices[0].message.parsed });
} catch (e) {
console.error('LLM error:', e);
return json({ error: 'Failed to parse recipe' }, { status: 500 });
}
}
`,
// UI: Share Target Page
'src/routes/share/+page.svelte': `
<script lang="ts">
import { page } from '$app/stores';
let status = $state('idle');
let logs = $state<string[]>([]);
let recipe = $state<any>(null);
// URL param parsing for Share Target
// Instagram typically shares text that contains the URL, so we might need to parse it out
let sharedText = $derived($page.url.searchParams.get('text') || '');
let sharedUrl = $derived($page.url.searchParams.get('url') || '');
function extractUrl(text: string) {
const match = text.match(/(https?:\\/\\/[^\\s]+)/);
return match ? match[0] : null;
}
let targetUrl = $derived(sharedUrl || extractUrl(sharedText));
async function process() {
if(!targetUrl) return;
status = 'extracting';
logs = [...logs, 'Sending to server... ' + targetUrl];
try {
const res = await fetch('/api/extract', {
method: 'POST',
body: JSON.stringify({ url: targetUrl }),
headers: { 'Content-Type': 'application/json' }
});
const data = await res.json();
if (data.recipe) {
recipe = data.recipe;
status = 'done';
} else {
logs = [...logs, 'Error: ' + JSON.stringify(data)];
status = 'error';
}
} catch(e) {
logs = [...logs, 'Network Error'];
status = 'error';
}
}
</script>
<div class="p-8 max-w-lg mx-auto space-y-4">
<h1 class="text-2xl font-bold">InstaChef PWA</h1>
{#if targetUrl}
<div class="bg-gray-100 p-2 rounded break-all text-sm border">{targetUrl}</div>
{#if status === 'idle'}
<button onclick={process} class="bg-blue-600 text-white px-4 py-2 rounded shadow hover:bg-blue-700 w-full">
Extract Recipe
</button>
{/if}
{:else}
<p class="text-gray-500">No URL detected. Open this app via Instagram Share Menu.</p>
<div class="text-xs text-gray-400">Debug: Text={sharedText} URL={sharedUrl}</div>
{/if}
{#if status === 'extracting'}
<div class="animate-pulse text-blue-600">Extracting data...</div>
{/if}
{#if recipe}
<div class="border rounded p-4 bg-green-50 space-y-2">
<h2 class="font-bold text-xl">{recipe.name}</h2>
<p class="text-sm">{recipe.description}</p>
<h3 class="font-bold mt-2">Ingredients</h3>
<ul class="list-disc pl-5 text-sm">
{#each recipe.ingredients as ing}
<li>{ing.amount} {ing.unit} {ing.item}</li>
{/each}
</ul>
</div>
{/if}
<div class="font-mono text-xs bg-slate-900 text-green-400 p-4 rounded min-h-[100px] mt-8">
<div class="opacity-50 border-b border-slate-700 mb-2">System Logs</div>
{#each logs as l}<div>> {l}</div>{/each}
</div>
</div>
`
};
log('Writing service files...');
// Ensure dirs
['playwright-service', 'scripts', 'src/lib/server', 'src/routes/api/extract', 'src/routes/share', 'secrets'].forEach(dir => {
if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
});
for (const [filepath, content] of Object.entries(newFiles)) {
// Only write if file doesn't exist to avoid destroying user work
// EXCEPT for the new API routes which we know are new
if (!fs.existsSync(filepath) || filepath.includes('src/routes/api') || filepath.includes('src/lib/server')) {
fs.writeFileSync(path.resolve(filepath), content.trim());
log(`Created: ${filepath}`);
} else {
log(`Skipped (Exists): ${filepath}`);
}
}
import fs from 'node:fs';
import path from 'node:path';
const log = (msg) => console.log(`\x1b[36m[Patch]\x1b[0m ${msg}`);
// --- 1. Fix package.json ---
log('Patching package.json...');
const pkgPath = path.resolve('package.json');
if (fs.existsSync(pkgPath)) {
const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
// FIX: Downgrade Vite to v6 to satisfy PWA/Tailwind peer deps
if (pkg.devDependencies?.vite) {
log(`Create-svelte installed Vite ${pkg.devDependencies.vite}. Downgrading to ^6.0.0 for compatibility.`);
pkg.devDependencies.vite = "^6.0.0";
}
// Add Backend Dependencies
pkg.dependencies = {
...pkg.dependencies,
"zod": "^3.23.0",
"openai": "^4.20.0"
// playwright is already in your devDependencies, which is fine for the service approach
};
// Add PWA Dev Dependency
pkg.devDependencies = {
...pkg.devDependencies,
"@vite-pwa/sveltekit": "^0.3.0"
};
fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 4));
log('✅ package.json updated.');
} else {
console.error('❌ package.json not found! Are you in the project root?');
process.exit(1);
}
// --- 2. Inject PWA into vite.config.ts ---
log('Updating vite.config.ts...');
const viteConfigPath = path.resolve('vite.config.ts');
let viteConfig = fs.readFileSync(viteConfigPath, 'utf-8');
// Check if already patched to avoid duplicates
if (!viteConfig.includes('SvelteKitPWA')) {
// Add Import
if (viteConfig.includes('import { sveltekit }')) {
viteConfig = viteConfig.replace(
"import { sveltekit } from '@sveltejs/kit/vite';",
"import { sveltekit } from '@sveltejs/kit/vite';\nimport { SvelteKitPWA } from '@vite-pwa/sveltekit';"
);
}
// Add Plugin (Insert before sveltekit to be safe, or commonly after)
// We look for 'plugins: [' and append the PWA config
const pwaConfig = `
SvelteKitPWA({
srcDir: './src',
mode: 'development',
strategies: 'generateSW',
scope: '/',
base: '/',
selfDestroying: process.env.SELF_DESTROYING_SW === 'true',
manifest: {
short_name: 'InstaChef',
name: 'InstaChef Recipe Saver',
start_url: '/',
scope: '/',
display: 'standalone',
theme_color: "#ffffff",
background_color: "#ffffff",
icons: [
{ src: '/favicon.png', sizes: '192x192', type: 'image/png' },
{ src: '/favicon.png', sizes: '512x512', type: 'image/png' }
],
share_target: {
action: '/share',
method: 'GET',
enctype: 'application/x-www-form-urlencoded',
params: { title: 'title', text: 'text', url: 'url' }
}
},
workbox: {
globPatterns: ['client/**/*.{js,css,ico,png,svg,webp,woff,woff2}']
},
devOptions: {
enabled: true,
suppressWarnings: true,
navigateFallback: '/',
},
}),`;
// Insert inside plugins array
viteConfig = viteConfig.replace('plugins: [', `plugins: [${pwaConfig}`);
fs.writeFileSync(viteConfigPath, viteConfig);
log('✅ vite.config.ts updated with PWA settings.');
} else {
log('ℹ️ vite.config.ts already contains PWA settings. Skipping.');
}
// --- 3. Create Backend & Docker Files ---
// We write these strictly to avoid overwriting your existing src/ files
// (except for the new API routes)
const newFiles = {
// Docker Composition
'docker-compose.yml': `
services:
app:
build: .
ports:
- "5173:5173"
environment:
- PLAYWRIGHT_WS_ENDPOINT=ws://playwright-service:3000
- OPENAI_BASE_URL=http://ollama:11434/v1
- OPENAI_API_KEY=ollama
- LLM_MODEL=llama3.2
volumes:
- ./src:/app/src
- ./secrets:/app/secrets:ro
depends_on:
- playwright-service
- ollama
playwright-service:
build: ./playwright-service
ipc: host
ports: ["3000:3000"]
environment:
- DISPLAY=:99
security_opt:
- seccomp=unconfined
ollama:
image: ollama/ollama:latest
ports: ["11434:11434"]
volumes:
- ollama_data:/root/.ollama
volumes:
ollama_data:
`,
// Dockerfile for SvelteKit
'Dockerfile': `
FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
EXPOSE 5173
CMD ["npm", "run", "dev", "--", "--host"]
`,
// Playwright Service
'playwright-service/Dockerfile': `
FROM mcr.microsoft.com/playwright:v1.49.0-jammy
WORKDIR /app
RUN npm init -y && npm install playwright
COPY server.js .
EXPOSE 3000
CMD ["node", "server.js"]
`,
'playwright-service/server.js': `
const { chromium } = require('playwright');
(async () => {
const server = await chromium.launchServer({
port: 3000,
headless: true,
args: ['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
});
console.log('Browser Server running on port 3000...');
await new Promise(() => {});
})();
`,
// Auth Generator Script (Updated to use imports since project is type: module)
'scripts/gen-auth.js': `
import { chromium } from 'playwright';
import fs from 'fs';
import path from 'path';
(async () => {
const browser = await chromium.launch({ headless: false });
const context = await browser.newContext();
const page = await context.newPage();
console.log('🔹 Navigating to Instagram...');
await page.goto('https://www.instagram.com/');
console.log('⏳ Please log in manually. Waiting for "Home" icon...');
try {
await page.waitForSelector('svg[aria-label="Home"]', { timeout: 120000 });
const secretsDir = path.resolve('secrets');
if (!fs.existsSync(secretsDir)) fs.mkdirSync(secretsDir);
await context.storageState({ path: path.join(secretsDir, 'auth.json') });
console.log('🎉 Session saved to secrets/auth.json');
} catch (e) {
console.error('❌ Timeout or error:', e);
}
await browser.close();
})();
`,
// Logic: LLM Client
'src/lib/server/llm.ts': `
import OpenAI from 'openai';
import { env } from '$env/dynamic/private';
export const createLLM = () => {
// Detect if we are using Ollama or OpenAI based on URL
const baseURL = env.OPENAI_BASE_URL;
const client = new OpenAI({
apiKey: env.OPENAI_API_KEY,
baseURL: baseURL
});
return { client, model: env.LLM_MODEL || 'gpt-4o' };
};
`,
// Logic: API Endpoint
'src/routes/api/extract/+server.ts': `
import { json } from '@sveltejs/kit';
import { createLLM } from '$lib/server/llm';
import { z } from 'zod';
import { zodResponseFormat } from 'openai/helpers/zod';
import { chromium } from 'playwright';
import fs from 'fs';
import { env } from '$env/dynamic/private';
const RecipeSchema = z.object({
name: z.string(),
description: z.string(),
steps: z.array(z.string()),
ingredients: z.array(z.object({
item: z.string(),
amount: z.string(),
unit: z.string()
}))
});
export async function POST({ request }) {
const { url } = await request.json();
// 1. Browser Connection
// Fallback to localhost if env var not set (e.g. running outside docker)
const wsEndpoint = env.PLAYWRIGHT_WS_ENDPOINT || 'ws://127.0.0.1:3000';
console.log('Connecting to browser at:', wsEndpoint);
const browser = await chromium.connect(wsEndpoint);
// 2. Load Auth if available
const authPath = '/app/secrets/auth.json';
let context;
// We check absolute path (Docker) or relative (Local)
if (fs.existsSync(authPath)) {
context = await browser.newContext({ storageState: authPath });
} else if (fs.existsSync('./secrets/auth.json')) {
context = await browser.newContext({ storageState: './secrets/auth.json' });
} else {
console.warn('No auth.json found. Running as guest.');
context = await browser.newContext();
}
const page = await context.newPage();
let bodyText = '';
try {
await page.goto(url, { waitUntil: 'domcontentloaded' });
// Naive scraper attempt
bodyText = await page.evaluate(() => document.body.innerText);
} catch (e) {
console.error('Scraping error:', e);
return json({ error: 'Failed to scrape URL' }, { status: 500 });
} finally {
await page.close();
await context.close();
await browser.close();
}
// 3. LLM Processing
try {
const { client, model } = createLLM();
const completion = await client.beta.chat.completions.parse({
model,
messages: [
{ role: "system", content: "Extract a recipe structure from this text. If it is not a recipe, return empty arrays." },
{ role: "user", content: bodyText.substring(0, 8000) } // Limit context window
],
response_format: zodResponseFormat(RecipeSchema, "recipe")
});
return json({ recipe: completion.choices[0].message.parsed });
} catch (e) {
console.error('LLM error:', e);
return json({ error: 'Failed to parse recipe' }, { status: 500 });
}
}
`,
// UI: Share Target Page
'src/routes/share/+page.svelte': `
<script lang="ts">
import { page } from '$app/stores';
let status = $state('idle');
let logs = $state<string[]>([]);
let recipe = $state<any>(null);
// URL param parsing for Share Target
// Instagram typically shares text that contains the URL, so we might need to parse it out
let sharedText = $derived($page.url.searchParams.get('text') || '');
let sharedUrl = $derived($page.url.searchParams.get('url') || '');
function extractUrl(text: string) {
const match = text.match(/(https?:\\/\\/[^\\s]+)/);
return match ? match[0] : null;
}
let targetUrl = $derived(sharedUrl || extractUrl(sharedText));
async function process() {
if(!targetUrl) return;
status = 'extracting';
logs = [...logs, 'Sending to server... ' + targetUrl];
try {
const res = await fetch('/api/extract', {
method: 'POST',
body: JSON.stringify({ url: targetUrl }),
headers: { 'Content-Type': 'application/json' }
});
const data = await res.json();
if (data.recipe) {
recipe = data.recipe;
status = 'done';
} else {
logs = [...logs, 'Error: ' + JSON.stringify(data)];
status = 'error';
}
} catch(e) {
logs = [...logs, 'Network Error'];
status = 'error';
}
}
</script>
<div class="p-8 max-w-lg mx-auto space-y-4">
<h1 class="text-2xl font-bold">InstaChef PWA</h1>
{#if targetUrl}
<div class="bg-gray-100 p-2 rounded break-all text-sm border">{targetUrl}</div>
{#if status === 'idle'}
<button onclick={process} class="bg-blue-600 text-white px-4 py-2 rounded shadow hover:bg-blue-700 w-full">
Extract Recipe
</button>
{/if}
{:else}
<p class="text-gray-500">No URL detected. Open this app via Instagram Share Menu.</p>
<div class="text-xs text-gray-400">Debug: Text={sharedText} URL={sharedUrl}</div>
{/if}
{#if status === 'extracting'}
<div class="animate-pulse text-blue-600">Extracting data...</div>
{/if}
{#if recipe}
<div class="border rounded p-4 bg-green-50 space-y-2">
<h2 class="font-bold text-xl">{recipe.name}</h2>
<p class="text-sm">{recipe.description}</p>
<h3 class="font-bold mt-2">Ingredients</h3>
<ul class="list-disc pl-5 text-sm">
{#each recipe.ingredients as ing}
<li>{ing.amount} {ing.unit} {ing.item}</li>
{/each}
</ul>
</div>
{/if}
<div class="font-mono text-xs bg-slate-900 text-green-400 p-4 rounded min-h-[100px] mt-8">
<div class="opacity-50 border-b border-slate-700 mb-2">System Logs</div>
{#each logs as l}<div>> {l}</div>{/each}
</div>
</div>
`
};
log('Writing service files...');
// Ensure dirs
['playwright-service', 'scripts', 'src/lib/server', 'src/routes/api/extract', 'src/routes/share', 'secrets'].forEach(dir => {
if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
});
for (const [filepath, content] of Object.entries(newFiles)) {
// Only write if file doesn't exist to avoid destroying user work
// EXCEPT for the new API routes which we know are new
if (!fs.existsSync(filepath) || filepath.includes('src/routes/api') || filepath.includes('src/lib/server')) {
fs.writeFileSync(path.resolve(filepath), content.trim());
log(`Created: ${filepath}`);
} else {
log(`Skipped (Exists): ${filepath}`);
}
}
log('✅ Patch complete. Run "npm install" now.');

52
secrets/auth.json
View File

@@ -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"
}
]
}

1
src/app.html
View File

@@ -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">

54
src/app.server.ts
View File

@@ -1,27 +1,27 @@
import { initializeBrowser, closeBrowser } from '$lib/server/browser';
// Initialize browser when server starts
export async function init() {
try {
await initializeBrowser();
} catch (error) {
console.error('Failed to initialize browser:', error);
process.exit(1);
}
// Graceful shutdown
process.on('SIGTERM', async () => {
console.log('SIGTERM received, shutting down gracefully...');
await closeBrowser();
process.exit(0);
});
process.on('SIGINT', async () => {
console.log('SIGINT received, shutting down gracefully...');
await closeBrowser();
process.exit(0);
});
}
// Run initialization immediately
init().catch(console.error);
import { initializeBrowser, closeBrowser } from '$lib/server/browser';
// Initialize browser when server starts
export async function init() {
try {
await initializeBrowser();
} catch (error) {
console.error('Failed to initialize browser:', error);
process.exit(1);
}
// Graceful shutdown
process.on('SIGTERM', async () => {
console.log('SIGTERM received, shutting down gracefully...');
await closeBrowser();
process.exit(0);
});
process.on('SIGINT', async () => {
console.log('SIGINT received, shutting down gracefully...');
await closeBrowser();
process.exit(0);
});
}
// Run initialization immediately
init().catch(console.error);

32
src/hooks.server.ts Normal file
View File

@@ -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');
});

104
src/lib/server/browser.ts
View File

@@ -1,52 +1,52 @@
import { chromium, type Browser, type BrowserContext } from 'playwright';
import fs from 'fs';
let browser: Browser | null = null;
export async function initializeBrowser(): Promise<Browser> {
if (browser) {
return browser;
}
console.log('Initializing Playwright browser...');
browser = await chromium.launch({
headless: true,
args: ['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
});
console.log('Browser initialized successfully');
return browser;
}
export async function getBrowser(): Promise<Browser> {
if (!browser) {
return initializeBrowser();
}
return browser;
}
export async function createBrowserContext(
authStoragePath?: string
): Promise<BrowserContext> {
const browserInstance = await getBrowser();
// Load auth if available
let context: BrowserContext;
if (authStoragePath && fs.existsSync(authStoragePath)) {
console.log('Loading authentication from:', authStoragePath);
context = await browserInstance.newContext({ storageState: authStoragePath });
} else {
console.warn('No auth storage found. Running as guest.');
context = await browserInstance.newContext();
}
return context;
}
export async function closeBrowser(): Promise<void> {
if (browser) {
console.log('Closing Playwright browser...');
await browser.close();
browser = null;
}
}
import { chromium, type Browser, type BrowserContext } from 'playwright';
import fs from 'fs';
let browser: Browser | null = null;
export async function initializeBrowser(): Promise<Browser> {
if (browser) {
return browser;
}
console.log('Initializing Playwright browser...');
browser = await chromium.launch({
headless: true,
args: ['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
});
console.log('Browser initialized successfully');
return browser;
}
export async function getBrowser(): Promise<Browser> {
if (!browser) {
return initializeBrowser();
}
return browser;
}
export async function createBrowserContext(
authStoragePath?: string
): Promise<BrowserContext> {
const browserInstance = await getBrowser();
// Load auth if available
let context: BrowserContext;
if (authStoragePath && fs.existsSync(authStoragePath)) {
console.log('Loading authentication from:', authStoragePath);
context = await browserInstance.newContext({ storageState: authStoragePath });
} else {
console.warn('No auth storage found. Running as guest.');
context = await browserInstance.newContext();
}
return context;
}
export async function closeBrowser(): Promise<void> {
if (browser) {
console.log('Closing Playwright browser...');
await browser.close();
browser = null;
}
}

115
src/lib/server/extraction.ts Normal file
View File

@@ -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')}`;
}

130
src/lib/server/parser.ts Normal file
View File

@@ -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);
}

182
src/lib/server/scheduler.ts Normal file
View File

@@ -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()
};
}

22
src/lib/server/tandoor-config.ts
View File

@@ -1,12 +1,12 @@
import { env } from '$env/dynamic/private';
/**
* Server-side environment configuration for Tandoor integration
* These variables should be set in your .env file or as environment variables
*/
export const tandoorConfig = {
enabled: env.TANDOOR_ENABLED === 'true',
serverUrl: (env.TANDOOR_SERVER_URL || '').replace(/\/$/, ''),
space: env.TANDOOR_SPACE ? parseInt(env.TANDOOR_SPACE, 10) : 1,
token: env.TANDOOR_TOKEN || null
import { env } from '$env/dynamic/private';
/**
* Server-side environment configuration for Tandoor integration
* These variables should be set in your .env file or as environment variables
*/
export const tandoorConfig = {
enabled: env.TANDOOR_ENABLED === 'true',
serverUrl: (env.TANDOOR_SERVER_URL || '').replace(/\/$/, ''),
space: env.TANDOOR_SPACE ? parseInt(env.TANDOOR_SPACE, 10) : 1,
token: env.TANDOOR_TOKEN || null
};

760
src/lib/server/tandoor.ts
View File

@@ -1,380 +1,380 @@
import { tandoorConfig } from '$lib/server/tandoor-config';
import { z } from 'zod';
/**
* Tandoor Recipe Export Format
* Based on the Default/JSON-LD Tandoor export format
*/
export const TandoorRecipeSchema = z.object({
name: z.string(),
author: z.string().optional().nullable(),
description: z.string().optional().nullable(),
servings: z.number().optional().nullable(),
servings_text: z.string().optional().nullable(),
keywords: z.array(z.string()).optional(),
prep_time: z.string().optional(),
cook_time: z.string().optional(),
waiting_time: z.string().optional(),
steps: z.array(
z.object({
step: z.number(),
instruction: z.string(),
ingredients: z.array(
z.object({
food: z.object({
id: z.number(),
name: z.string()
}),
unit: z.object({
id: z.number(),
name: z.string()
}).nullable(),
amount: z.number(),
note: z.string().optional()
})
).optional()
})
).optional(),
ingredients: z.array(
z.object({
food: z.object({
name: z.string()
}),
unit: z.object({
name: z.string()
}).nullable(),
amount: z.number(),
note: z.string().optional()
})
).optional()
});
export type TandoorRecipe = z.infer<typeof TandoorRecipeSchema>;
interface ExtractedRecipe {
name: string;
servings: number | null;
description: string | null;
ingredients: Array<{
item: string;
amount: string;
unit: string;
}> | null;
steps: string[] | null;
image?: string | null;
}
/**
* DTO for Tandoor Recipe API (POST /api/recipe/)
* Matches the Tandoor endpoint schema for recipe creation
*/
interface TandoorRecipeDTO {
name: string;
description?: string;
keywords: Array<{
name: string;
description?: string;
}>;
steps: Array<{
name?: string;
instruction: string;
ingredients: Array<{
food: {
name: string;
};
unit: {
name: string;
} | null;
amount: string;
note?: string;
}>;
order?: number;
show_as_header?: boolean;
}>;
working_time?: number;
waiting_time?: number;
servings?: number;
servings_text?: string;
private?: boolean;
show_ingredient_overview?: boolean;
}
/**
* Helper function to make authenticated API calls
*/
async function fetchFromTandoor<T>(
url: string,
options: Partial<RequestInit> = { method: 'GET' },
): Promise<{ ok: boolean; data?: T; error?: string }> {
const headers = new Headers({
'Content-Type': 'application/json',
'Accept': 'application/json',
Authorization: `Bearer ${tandoorConfig.token}`
});
// Merge any additional headers from options
if (options.headers) {
const optHeaders = new Headers(options.headers);
optHeaders.forEach((value, key) => {
headers.set(key, value);
});
}
console.debug(`Fetching from Tandoor: ${url}`, {
method: options.method,
headers: Object.fromEntries(headers),
body: options.body
});
try {
const response = await fetch(`${tandoorConfig.serverUrl}${url}`, {
...options,
headers
});
if (!response.ok) {
const errorBody = await response.json().catch(() => ({}));
console.error(`API Error ${response.status}: ${response.statusText}`, errorBody);
return {
ok: false,
error: `API Error: ${response.statusText} - ${JSON.stringify(errorBody)}`
};
}
const data = (await response.json()) as T;
console.debug(`Tandoor response OK:`, data);
return { ok: true, data };
} catch (error) {
const errorMsg = error instanceof Error ? error.message : 'Unknown error';
console.error(`Fetch error: ${errorMsg}`);
return {
ok: false,
error: `Fetch error: ${errorMsg}`
};
}
}
/**
* Partitions ingredients across steps by distributing them evenly
* When step association is unknown, this spreads ingredients proportionally
*/
function partitionIngredientsAcrossSteps(
ingredients: Array<{
item: string;
amount: string;
unit: string;
}>,
stepCount: number
): Array<Array<{ item: string; amount: string; unit: string }>> {
if (stepCount === 0 || !ingredients || ingredients.length === 0) {
return [];
}
const partitions: Array<Array<{ item: string; amount: string; unit: string }>> = Array.from(
{ length: stepCount },
() => []
);
// Distribute ingredients round-robin across steps
ingredients.forEach((ingredient, index) => {
partitions[index % stepCount].push(ingredient);
});
console.debug(`Partitioned ${ingredients.length} ingredients across ${stepCount} steps:`, partitions);
return partitions;
}
/**
* Parses amount string to a number, handling special cases
* Returns null if amount cannot be parsed to a valid number
*/
function parseAmount(amountStr: string): number | null {
if (!amountStr || typeof amountStr !== 'string') {
return null;
}
const trimmed = amountStr.trim().toLowerCase();
// Skip special cases that can't be converted to numbers
if (!trimmed || trimmed === 'q.b.' || trimmed === 'qb' || trimmed === 'to taste') {
return null;
}
// Try to extract the first number from the string
const numberMatch = trimmed.match(/^[\d.,]+/);
if (!numberMatch) {
return null;
}
const numStr = numberMatch[0].replace(',', '.');
const parsed = parseFloat(numStr);
// Return null for zero or invalid numbers
if (isNaN(parsed) || parsed === 0) {
return null;
}
return parsed;
}
/**
* Builds a complete Tandoor Recipe DTO from extracted recipe data
* Includes ingredients partitioned across steps
*/
function buildTandoorRecipeDTO(recipe: ExtractedRecipe): TandoorRecipeDTO {
const stepCount = recipe.steps?.length || 1;
const ingredientPartitions = partitionIngredientsAcrossSteps(
recipe.ingredients || [],
stepCount
);
const steps: TandoorRecipeDTO['steps'] = (recipe.steps || []).map((instruction, index) => {
// Map ingredients, converting unparseable amounts to 1 q.b.
const mappedIngredients = (ingredientPartitions[index] || []).map((ing) => {
const amount = parseAmount(ing.amount);
if (amount === null) {
console.debug(`Converting ingredient with unparseable amount to 1 q.b.: ${ing.item} (${ing.amount})`);
return {
food: {
name: ing.item
},
unit: { name: 'q.b.' },
amount: '1',
note: ''
};
}
return {
food: {
name: ing.item
},
unit: ing.unit && ing.unit.trim() ? { name: ing.unit } : null,
amount: amount.toString(),
note: ''
};
});
return {
instruction,
order: index,
ingredients: mappedIngredients
};
});
return {
name: recipe.name,
description: recipe.description || undefined,
keywords: [],
steps,
servings: recipe.servings || undefined,
servings_text: recipe.servings ? `${recipe.servings} servings` : undefined,
private: false,
show_ingredient_overview: true
};
}
/**
* Uploads a recipe to Tandoor server using the DTO-based approach
* Creates recipe with ingredients partitioned across steps in a single request
*/
export async function uploadRecipeWithIngredientsDTO(
recipe: ExtractedRecipe
): Promise<{ success: boolean; recipeId?: number; imageUrl?: string; error?: string }> {
try {
// Validate token
const token = tandoorConfig.token;
if (!token) {
return {
success: false,
error: 'TANDOOR_TOKEN environment variable not set'
};
}
// Build the complete DTO
const recipeDTO = buildTandoorRecipeDTO(recipe);
console.debug('Uploading recipe with ingredients DTO:', recipeDTO);
// Call the API with the DTO
const recipeResult = await fetchFromTandoor<{ id: number }>(
`/api/recipe/`,
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(recipeDTO)
}
);
if (!recipeResult.ok || !recipeResult.data) {
console.error('Recipe creation failed:', recipeResult.error);
return {
success: false,
error: `Failed to create recipe: ${recipeResult.error}`
};
}
const createdRecipe = recipeResult.data;
console.debug('Successfully created recipe with ID:', createdRecipe.id);
return {
success: true,
recipeId: createdRecipe.id,
imageUrl: recipe.image || undefined
};
} catch (error) {
const errorMsg = error instanceof Error ? error.message : 'Unknown error';
console.error(`Error uploading recipe to Tandoor: ${errorMsg}`);
return {
success: false,
error: `Error uploading to Tandoor: ${errorMsg}`
};
}
}
/**
* Uploads an image to a Tandoor recipe
*/
export async function uploadRecipeImage(
recipeId: number,
imageUrl: string
): Promise<{ success: boolean; error?: string }> {
try {
const token = tandoorConfig.token;
if (!token) {
return { success: false, error: 'TANDOOR_TOKEN not set' };
}
console.log('Uploading image for recipe ID:', recipeId, 'URL:', imageUrl.substring(0, 50));
// Convert base64 data URL to Blob for multipart upload
const response = await fetch(imageUrl);
const imageBlob = await response.blob();
// Use image field with multipart form data (Tandoor's binary upload support)
const formData = new FormData();
formData.append('image', imageBlob, 'recipe-image.jpg');
// Upload to Tandoor
const uploadResponse = await fetch(
`${tandoorConfig.serverUrl}/api/recipe/${recipeId}/image/`,
{
method: 'PUT',
headers: { 'Authorization': `Bearer ${token}` },
body: formData
}
);
if (!uploadResponse.ok) {
console.warn(`Image upload returned ${uploadResponse.status}`);
return { success: false, error: `Upload failed: ${uploadResponse.statusText}` };
}
console.log('Image uploaded successfully');
return { success: true };
} catch (error) {
const errorMsg = error instanceof Error ? error.message : 'Unknown error';
console.warn(`Image upload failed: ${errorMsg}`);
// Don't fail recipe creation if image fails
return { success: false, error: errorMsg };
}
}
import { tandoorConfig } from '$lib/server/tandoor-config';
import { z } from 'zod';
/**
* Tandoor Recipe Export Format
* Based on the Default/JSON-LD Tandoor export format
*/
export const TandoorRecipeSchema = z.object({
name: z.string(),
author: z.string().optional().nullable(),
description: z.string().optional().nullable(),
servings: z.number().optional().nullable(),
servings_text: z.string().optional().nullable(),
keywords: z.array(z.string()).optional(),
prep_time: z.string().optional(),
cook_time: z.string().optional(),
waiting_time: z.string().optional(),
steps: z.array(
z.object({
step: z.number(),
instruction: z.string(),
ingredients: z.array(
z.object({
food: z.object({
id: z.number(),
name: z.string()
}),
unit: z.object({
id: z.number(),
name: z.string()
}).nullable(),
amount: z.number(),
note: z.string().optional()
})
).optional()
})
).optional(),
ingredients: z.array(
z.object({
food: z.object({
name: z.string()
}),
unit: z.object({
name: z.string()
}).nullable(),
amount: z.number(),
note: z.string().optional()
})
).optional()
});
export type TandoorRecipe = z.infer<typeof TandoorRecipeSchema>;
interface ExtractedRecipe {
name: string;
servings: number | null;
description: string | null;
ingredients: Array<{
item: string;
amount: string;
unit: string;
}> | null;
steps: string[] | null;
image?: string | null;
}
/**
* DTO for Tandoor Recipe API (POST /api/recipe/)
* Matches the Tandoor endpoint schema for recipe creation
*/
interface TandoorRecipeDTO {
name: string;
description?: string;
keywords: Array<{
name: string;
description?: string;
}>;
steps: Array<{
name?: string;
instruction: string;
ingredients: Array<{
food: {
name: string;
};
unit: {
name: string;
} | null;
amount: string;
note?: string;
}>;
order?: number;
show_as_header?: boolean;
}>;
working_time?: number;
waiting_time?: number;
servings?: number;
servings_text?: string;
private?: boolean;
show_ingredient_overview?: boolean;
}
/**
* Helper function to make authenticated API calls
*/
async function fetchFromTandoor<T>(
url: string,
options: Partial<RequestInit> = { method: 'GET' },
): Promise<{ ok: boolean; data?: T; error?: string }> {
const headers = new Headers({
'Content-Type': 'application/json',
'Accept': 'application/json',
Authorization: `Bearer ${tandoorConfig.token}`
});
// Merge any additional headers from options
if (options.headers) {
const optHeaders = new Headers(options.headers);
optHeaders.forEach((value, key) => {
headers.set(key, value);
});
}
console.debug(`Fetching from Tandoor: ${url}`, {
method: options.method,
headers: Object.fromEntries(headers),
body: options.body
});
try {
const response = await fetch(`${tandoorConfig.serverUrl}${url}`, {
...options,
headers
});
if (!response.ok) {
const errorBody = await response.json().catch(() => ({}));
console.error(`API Error ${response.status}: ${response.statusText}`, errorBody);
return {
ok: false,
error: `API Error: ${response.statusText} - ${JSON.stringify(errorBody)}`
};
}
const data = (await response.json()) as T;
console.debug(`Tandoor response OK:`, data);
return { ok: true, data };
} catch (error) {
const errorMsg = error instanceof Error ? error.message : 'Unknown error';
console.error(`Fetch error: ${errorMsg}`);
return {
ok: false,
error: `Fetch error: ${errorMsg}`
};
}
}
/**
* Partitions ingredients across steps by distributing them evenly
* When step association is unknown, this spreads ingredients proportionally
*/
function partitionIngredientsAcrossSteps(
ingredients: Array<{
item: string;
amount: string;
unit: string;
}>,
stepCount: number
): Array<Array<{ item: string; amount: string; unit: string }>> {
if (stepCount === 0 || !ingredients || ingredients.length === 0) {
return [];
}
const partitions: Array<Array<{ item: string; amount: string; unit: string }>> = Array.from(
{ length: stepCount },
() => []
);
// Distribute ingredients round-robin across steps
ingredients.forEach((ingredient, index) => {
partitions[index % stepCount].push(ingredient);
});
console.debug(`Partitioned ${ingredients.length} ingredients across ${stepCount} steps:`, partitions);
return partitions;
}
/**
* Parses amount string to a number, handling special cases
* Returns null if amount cannot be parsed to a valid number
*/
function parseAmount(amountStr: string): number | null {
if (!amountStr || typeof amountStr !== 'string') {
return null;
}
const trimmed = amountStr.trim().toLowerCase();
// Skip special cases that can't be converted to numbers
if (!trimmed || trimmed === 'q.b.' || trimmed === 'qb' || trimmed === 'to taste') {
return null;
}
// Try to extract the first number from the string
const numberMatch = trimmed.match(/^[\d.,]+/);
if (!numberMatch) {
return null;
}
const numStr = numberMatch[0].replace(',', '.');
const parsed = parseFloat(numStr);
// Return null for zero or invalid numbers
if (isNaN(parsed) || parsed === 0) {
return null;
}
return parsed;
}
/**
* Builds a complete Tandoor Recipe DTO from extracted recipe data
* Includes ingredients partitioned across steps
*/
function buildTandoorRecipeDTO(recipe: ExtractedRecipe): TandoorRecipeDTO {
const stepCount = recipe.steps?.length || 1;
const ingredientPartitions = partitionIngredientsAcrossSteps(
recipe.ingredients || [],
stepCount
);
const steps: TandoorRecipeDTO['steps'] = (recipe.steps || []).map((instruction, index) => {
// Map ingredients, converting unparseable amounts to 1 q.b.
const mappedIngredients = (ingredientPartitions[index] || []).map((ing) => {
const amount = parseAmount(ing.amount);
if (amount === null) {
console.debug(`Converting ingredient with unparseable amount to 1 q.b.: ${ing.item} (${ing.amount})`);
return {
food: {
name: ing.item
},
unit: { name: 'q.b.' },
amount: '1',
note: ''
};
}
return {
food: {
name: ing.item
},
unit: ing.unit && ing.unit.trim() ? { name: ing.unit } : null,
amount: amount.toString(),
note: ''
};
});
return {
instruction,
order: index,
ingredients: mappedIngredients
};
});
return {
name: recipe.name,
description: recipe.description || undefined,
keywords: [],
steps,
servings: recipe.servings || undefined,
servings_text: recipe.servings ? `${recipe.servings} servings` : undefined,
private: false,
show_ingredient_overview: true
};
}
/**
* Uploads a recipe to Tandoor server using the DTO-based approach
* Creates recipe with ingredients partitioned across steps in a single request
*/
export async function uploadRecipeWithIngredientsDTO(
recipe: ExtractedRecipe
): Promise<{ success: boolean; recipeId?: number; imageUrl?: string; error?: string }> {
try {
// Validate token
const token = tandoorConfig.token;
if (!token) {
return {
success: false,
error: 'TANDOOR_TOKEN environment variable not set'
};
}
// Build the complete DTO
const recipeDTO = buildTandoorRecipeDTO(recipe);
console.debug('Uploading recipe with ingredients DTO:', recipeDTO);
// Call the API with the DTO
const recipeResult = await fetchFromTandoor<{ id: number }>(
`/api/recipe/`,
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(recipeDTO)
}
);
if (!recipeResult.ok || !recipeResult.data) {
console.error('Recipe creation failed:', recipeResult.error);
return {
success: false,
error: `Failed to create recipe: ${recipeResult.error}`
};
}
const createdRecipe = recipeResult.data;
console.debug('Successfully created recipe with ID:', createdRecipe.id);
return {
success: true,
recipeId: createdRecipe.id,
imageUrl: recipe.image || undefined
};
} catch (error) {
const errorMsg = error instanceof Error ? error.message : 'Unknown error';
console.error(`Error uploading recipe to Tandoor: ${errorMsg}`);
return {
success: false,
error: `Error uploading to Tandoor: ${errorMsg}`
};
}
}
/**
* Uploads an image to a Tandoor recipe
*/
export async function uploadRecipeImage(
recipeId: number,
imageUrl: string
): Promise<{ success: boolean; error?: string }> {
try {
const token = tandoorConfig.token;
if (!token) {
return { success: false, error: 'TANDOOR_TOKEN not set' };
}
console.log('Uploading image for recipe ID:', recipeId, 'URL:', imageUrl.substring(0, 50));
// Convert base64 data URL to Blob for multipart upload
const response = await fetch(imageUrl);
const imageBlob = await response.blob();
// Use image field with multipart form data (Tandoor's binary upload support)
const formData = new FormData();
formData.append('image', imageBlob, 'recipe-image.jpg');
// Upload to Tandoor
const uploadResponse = await fetch(
`${tandoorConfig.serverUrl}/api/recipe/${recipeId}/image/`,
{
method: 'PUT',
headers: { 'Authorization': `Bearer ${token}` },
body: formData
}
);
if (!uploadResponse.ok) {
console.warn(`Image upload returned ${uploadResponse.status}`);
return { success: false, error: `Upload failed: ${uploadResponse.statusText}` };
}
console.log('Image uploaded successfully');
return { success: true };
} catch (error) {
const errorMsg = error instanceof Error ? error.message : 'Unknown error';
console.warn(`Image upload failed: ${errorMsg}`);
// Don't fail recipe creation if image fails
return { success: false, error: errorMsg };
}
}

180
src/routes/api/extract/+server.ts
View File

@@ -1,162 +1,42 @@
import { createBrowserContext } from '$lib/server/browser';
import { createLLM } from '$lib/server/llm';
import { extractTextAndThumbnail } from '$lib/server/extraction';
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('Creating browser context for URL:', url);
const { url } = await request.json();
// 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;
console.log('Processing URL:', url);
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 {
// Step 1: Extract text and thumbnail from page
const { bodyText, thumbnail } = await extractTextAndThumbnail(url);
try {
await page.goto(url, { waitUntil: 'domcontentloaded' });
bodyText = (await page.evaluate(() => document.body.innerText)).replace(/^(?:.*\n){6}/, '').split('More posts from')[0].trim();
bodyText = bodyText.replace(/@\w+/g, '').replace(/#\w+/g, '');
// Step 2: Parse recipe from extracted text
const recipe = await extractRecipe(bodyText);
writeFileSync(path.resolve('debug_page.txt'), bodyText); // Save for debugging, overwriting if exists
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)
};
});
if (!recipe) {
return json({ error: 'No recipe found in provided text' }, { status: 400 });
}
if (videoBounds && videoBounds.width > 0 && videoBounds.height > 0) {
const screenshotBuffer = await page.screenshot({
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();
}
// Step 3: Enrich recipe with metadata
if (recipe.description) {
recipe.description += `\n\nLink: ${url}`;
} else {
recipe.description = `Link: ${url}`;
}
// 2. LLM Processing - Two-step validation
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,
});
if (thumbnail) {
recipe.image = thumbnail;
}
const detectionResult = detectionResponse.choices[0].message.content?.toLowerCase() ?? '';
const hasRecipe = detectionResult.includes("yes");
return json({ recipe, bodyText });
} catch (error) {
const errorMessage = error instanceof Error ? error.message : 'Unknown error';
console.error('Recipe extraction pipeline error:', errorMessage);
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) {
console.error('LLM error:', e);
return json({ error: 'Failed to parse recipe', bodyText }, { status: 500 });
}
return json(
{ error: errorMessage || 'Failed to process URL' },
{ status: error instanceof Error && error.message.includes('scrape') ? 500 : 400 }
);
}
}

10
src/routes/api/tandoor-config/+server.ts
View File

@@ -1,5 +1,5 @@
import { json } from '@sveltejs/kit';
import {tandoorConfig} from '$lib/server/tandoor-config';
export async function GET() {
return json({...tandoorConfig, token: ''});
}
import { json } from '@sveltejs/kit';
import {tandoorConfig} from '$lib/server/tandoor-config';
export async function GET() {
return json({...tandoorConfig, token: ''});
}

84
src/routes/api/tandoor/+server.ts
View File

@@ -1,42 +1,42 @@
import { json } from '@sveltejs/kit';
import { uploadRecipeWithIngredientsDTO, uploadRecipeImage } from '$lib/server/tandoor';
export async function POST({ request }) {
const { recipe } = await request.json();
if (!recipe) {
return json({ error: 'No recipe provided' }, { status: 400 });
}
try {
const result = await uploadRecipeWithIngredientsDTO(recipe);
if (!result.success) {
return json({ error: result.error || 'Failed to upload recipe' }, { status: 500 });
}
// Upload image if available
let imageStatus = null;
if (result.recipeId && result.imageUrl) {
imageStatus = await uploadRecipeImage(result.recipeId, result.imageUrl);
if (!imageStatus.success) {
console.warn('Image upload failed, but recipe created:', imageStatus.error);
}
}
return json({
success: true,
message: 'Recipe successfully imported to Tandoor',
recipeId: result.recipeId,
imageUpload: imageStatus?.success ? 'successful' : 'failed'
});
} catch (error) {
console.error('Tandoor upload error:', error);
return json(
{
error: error instanceof Error ? error.message : 'Unknown error occurred'
},
{ status: 500 }
);
}
}
import { json } from '@sveltejs/kit';
import { uploadRecipeWithIngredientsDTO, uploadRecipeImage } from '$lib/server/tandoor';
export async function POST({ request }) {
const { recipe } = await request.json();
if (!recipe) {
return json({ error: 'No recipe provided' }, { status: 400 });
}
try {
const result = await uploadRecipeWithIngredientsDTO(recipe);
if (!result.success) {
return json({ error: result.error || 'Failed to upload recipe' }, { status: 500 });
}
// Upload image if available
let imageStatus = null;
if (result.recipeId && result.imageUrl) {
imageStatus = await uploadRecipeImage(result.recipeId, result.imageUrl);
if (!imageStatus.success) {
console.warn('Image upload failed, but recipe created:', imageStatus.error);
}
}
return json({
success: true,
message: 'Recipe successfully imported to Tandoor',
recipeId: result.recipeId,
imageUpload: imageStatus?.success ? 'successful' : 'failed'
});
} catch (error) {
console.error('Tandoor upload error:', error);
return json(
{
error: error instanceof Error ? error.message : 'Unknown error occurred'
},
{ status: 500 }
);
}
}

177
src/tests/README.md Normal file
View File

@@ -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.

164
src/tests/fixtures.ts Normal file
View File

@@ -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 = [];
}
};
};

134
src/tests/scheduler.integration.spec.ts Normal file
View File

@@ -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/);
});
});
});

200
src/tests/scheduler.spec.ts Normal file
View File

@@ -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();
});
});
});

7
vite.config.ts
View File

@@ -3,12 +3,17 @@ 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: [
SvelteKitPWA({