Compare commits
4
Commits
0b51bb6142
..
main
| Author | SHA1 | Date | |
|---|---|---|---|
 nico
|
b740ce1316 | ||
|
nico
|
12f01b86d6 | ||
|
nico
|
ab4f8e8570 | ||
|
nico
|
8a2bf46b09 |
No files matched your search
+5
-9
@@ -2,10 +2,6 @@
|
||||
# DeepSeek API Key (https://platform.deepseek.com/api_keys)
|
||||
DEEPSEEK_API_KEY=sk-xxxx
|
||||
|
||||
# OpenRouter API Key für zusätzliche Modelle (https://openrouter.ai/keys),
|
||||
# z.B. GLM 5.3 Flash (z-ai/glm-5.3-flash, Vision/Bilderkennung)
|
||||
OPENROUTER_API_KEY=sk-or-xxxx
|
||||
|
||||
# Gemeinsames Login-Passwort für die App (hinter NGINX mit IP-Prüfung)
|
||||
APP_PASSWORD=ein-sicheres-passwort
|
||||
|
||||
@@ -14,14 +10,14 @@ APP_PASSWORD=ein-sicheres-passwort
|
||||
SESSION_SECRET=
|
||||
# Port der App (NGINX proxied auf diesen; in Docker per EXPOSE/PORTS)
|
||||
PORT=3000
|
||||
# DeepSeek Modell
|
||||
MODEL=deepseek-v4-flash
|
||||
# DeepSeek Modell (V4.1 Flash, inkl. Vision/Bilderkennung)
|
||||
MODEL=deepseek-flash
|
||||
# Thinking-Mode des Modells: enabled | disabled (gilt für DeepSeek)
|
||||
THINKING=enabled
|
||||
# Reasoning-Tiefe je Modell: low | high | max (GLM: Pflicht, max Default)
|
||||
# Reasoning-Tiefe: low | high | max
|
||||
DEEPSEEK_REASONING_EFFORT=max
|
||||
GLM_REASONING_EFFORT=max
|
||||
# Maximale Antwort-Tokens pro API-Aufruf (Dashboards sind große HTML-Dateien)
|
||||
# Maximale Antwort-Tokens: nur relevant für eigene Modelle aus der Env (MODEL).
|
||||
# Das eingebaute Modell (DeepSeek V4.1 Flash) nutzt fest 300000 aus der Registry.
|
||||
MAX_TOKENS=64000
|
||||
# VAPID-Schlüsselpaar für Web Push (wird automatisch generiert)
|
||||
VAPID_PUBLIC_KEY=
|
||||
|
||||
@@ -3,4 +3,9 @@ data/
|
||||
dashboards/*.html
|
||||
dashboards/*.gpx
|
||||
dashboards/*.tour.json
|
||||
dashboards/*.jpg
|
||||
dashboards/*.jpeg
|
||||
dashboards/*.png
|
||||
dashboards/*.webp
|
||||
dashboards/*.gif
|
||||
.env
|
||||
@@ -1,12 +1,13 @@
|
||||
# Research Agent – Web-Chat-Oberfläche
|
||||
|
||||
Browser-Chatoberfläche für den Research-Agent: DeepSeek v4 Flash recherchiert per Playwright im
|
||||
Browser-Chatoberfläche für den Research-Agent: DeepSeek V4.1 Flash recherchiert per Playwright im
|
||||
Internet, verifiziert alle Links und generiert HTML-Dashboards – ohne dass Opencode lokal laufen muss.
|
||||
|
||||
## Funktionen
|
||||
|
||||
- 💬 Chat-Oberfläche mit Live-Fortschritt (SSE): Suchen, Seitenbesuche, Link-Verifizierung in Echtzeit
|
||||
- 🔎 Volle Research-Funktion: DuckDuckGo-Suche, Seiten lesen, Links verifizieren, HTML-Dashboard generieren
|
||||
- 📷 Bild-Upload & Vision: Fotos analysieren, ähnliche Produkte finden und mit lokal gespeicherten Bildern ins Dashboard einbetten
|
||||
- 🔔 Web-Push-Benachrichtigung, wenn die Recherche fertig ist (auch wenn der Browser zu ist)
|
||||
- 📱 PWA: installierbar auf Desktop & Handy (Chrome/Android; iOS 16.4+ für Push)
|
||||
- 👤 Eine gemeinsame Anmeldung (Name + Passwort), Sessions sind dem Namen zugeordnet
|
||||
@@ -34,7 +35,7 @@ erzeugt und in die `.env` geschrieben.
|
||||
| `DEEPSEEK_API_KEY` | ja | Key von https://platform.deepseek.com/api_keys |
|
||||
| `APP_PASSWORD` | ja | Gemeinsames Login-Passwort |
|
||||
| `PORT` | nein | Standard 3000 |
|
||||
| `MODEL` | nein | Standard `deepseek-v4-flash` |
|
||||
| `MODEL` | nein | Standard `deepseek-flash` |
|
||||
| `THINKING` | nein | `enabled` (Standard) oder `disabled` |
|
||||
| `DEEPSEEK_BASE_URL` | nein | Für Tests/Proxies überschreibbar |
|
||||
| `LOGIN_MAX_ATTEMPTS` | nein | Fehlversuche pro IP vor Sperre (Standard 5) |
|
||||
@@ -191,5 +192,5 @@ researchChat/
|
||||
- Nur **eine** Recherche läuft gleichzeitig; weitere Anfragen zeigen „Recherche läuft…“
|
||||
- DuckDuckGo blockiert nach ~4-5 Suchen: Der Agent wechselt automatisch auf Fallback-Suchmaschinen
|
||||
- Der Browser-Context bleibt pro Server-Lauf erhalten (weniger CAPTCHAs durch stabile Session-Cookies)
|
||||
- API-Kosten: DeepSeek v4 Flash kostet ~$0,44/M Input- und ~$0,66/M Output-Token – eine Recherche kostet Cent-Beträge
|
||||
- API-Kosten: DeepSeek V4.1 Flash kostet ~$0,30/M Input- (Cache-Miss) und ~$1,20/M Output-Token (Peak; Off-Peak halb so teuer) – eine Recherche kostet Cent-Beträge
|
||||
- Auf SELinux-Systemen (Bazzite/Fedora Atomic) sind die Volume-Mounts mit `:Z` markiert – Docker ignoriert das Flag, dort reicht die Compose-Datei unverändert
|
||||
+12
-19
@@ -51,9 +51,8 @@ const vapid = ensureVapidPair();
|
||||
const config = {
|
||||
port: Number(process.env.PORT || env.PORT || 3000),
|
||||
apiKey: process.env.DEEPSEEK_API_KEY || env.DEEPSEEK_API_KEY || '',
|
||||
openrouterApiKey: process.env.OPENROUTER_API_KEY || env.OPENROUTER_API_KEY || '',
|
||||
appPassword: process.env.APP_PASSWORD || env.APP_PASSWORD || '',
|
||||
model: process.env.MODEL || env.MODEL || 'deepseek-v4-flash',
|
||||
model: process.env.MODEL || env.MODEL || 'deepseek-flash',
|
||||
thinking: process.env.THINKING || env.THINKING || 'enabled',
|
||||
maxTokens: Number(process.env.MAX_TOKENS || env.MAX_TOKENS || 64000),
|
||||
baseUrl: process.env.DEEPSEEK_BASE_URL || env.DEEPSEEK_BASE_URL || 'https://api.deepseek.com',
|
||||
@@ -69,28 +68,22 @@ const config = {
|
||||
const envOr = (key, def) => process.env[key] || env[key] || def;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Modell-Registry: DeepSeek direkt + OpenRouter-Modelle (z.B. GLM 5.3 Flash)
|
||||
// Modell-Registry: DeepSeek V4.1 Flash (Text + Vision/Bilderkennung)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const MODELS = [
|
||||
{
|
||||
id: 'deepseek-v4-flash',
|
||||
label: 'DeepSeek V4 Flash',
|
||||
id: 'deepseek-flash',
|
||||
label: 'DeepSeek V4.1 Flash',
|
||||
provider: 'deepseek',
|
||||
vision: false,
|
||||
maxTokens: 64000,
|
||||
reasoningEffort: () => envOr('DEEPSEEK_REASONING_EFFORT', 'max'),
|
||||
prices: { inputCacheHit: 0.014, inputCacheMiss: 0.44, output: 1.32 },
|
||||
},
|
||||
{
|
||||
id: 'z-ai/glm-5.3-flash',
|
||||
label: 'GLM 5.3 Flash (OpenRouter)',
|
||||
provider: 'openrouter',
|
||||
vision: true,
|
||||
maxTokens: 64000,
|
||||
reasoningEffort: () => envOr('GLM_REASONING_EFFORT', 'max'),
|
||||
prices: { inputCacheHit: 0.015, inputCacheMiss: 0.075, output: 0.25 },
|
||||
costNote: 'Schätzung (OpenRouter, Rabatt bis Sep 2026)',
|
||||
// Max. Output laut Doku: 384K
|
||||
maxTokens: 300000,
|
||||
reasoningEffort: () => envOr('DEEPSEEK_REASONING_EFFORT', 'max'),
|
||||
// Liefer-Runde des Dashboards: Denken komplett aus, Budget gehört dem HTML
|
||||
deliveryEffort: 'none',
|
||||
// Peak-Preise laut Docs (USD pro 1M Tokens; Off-Peak ist halb so teuer)
|
||||
prices: { inputCacheHit: 0.006, inputCacheMiss: 0.3, output: 1.2 },
|
||||
},
|
||||
];
|
||||
|
||||
@@ -106,7 +99,7 @@ function getModels() {
|
||||
vision: false,
|
||||
maxTokens: config.maxTokens,
|
||||
reasoningEffort: () => envOr('DEEPSEEK_REASONING_EFFORT', 'max'),
|
||||
prices: { inputCacheHit: 0.014, inputCacheMiss: 0.44, output: 1.32 },
|
||||
prices: { inputCacheHit: 0.006, inputCacheMiss: 0.3, output: 1.2 },
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
@@ -49,9 +49,8 @@ const now = () => new Date().toISOString();
|
||||
const uid = () => crypto.randomBytes(12).toString('hex');
|
||||
const shareToken = () => crypto.randomBytes(16).toString('hex');
|
||||
|
||||
// DeepSeek v4 Flash Preise (USD pro 1M Tokens, Peak) – obere Schätzung.
|
||||
// Andere Modelle (z.B. OpenRouter) legen eigene Preise in der Registry an.
|
||||
const PRICES = { inputCacheHit: 0.014, inputCacheMiss: 0.44, output: 1.32 };
|
||||
// DeepSeek V4.1 Flash Preise (USD pro 1M Tokens, Peak) – obere Schätzung.
|
||||
const PRICES = { inputCacheHit: 0.006, inputCacheMiss: 0.3, output: 1.2 };
|
||||
|
||||
function computeCost(u, prices = PRICES) {
|
||||
return (
|
||||
@@ -86,6 +85,12 @@ function computeCost(u, prices = PRICES) {
|
||||
add('image', 'TEXT');
|
||||
}
|
||||
|
||||
// Migration: Legacy-/OpenRouter-Modell-IDs auf den aktuellen Namen umstellen
|
||||
db.prepare(
|
||||
`UPDATE sessions SET model = 'deepseek-flash'
|
||||
WHERE model IN ('deepseek-v4-flash', 'deepseek-v4-flash-vision-exp', 'z-ai/glm-5.3-flash')`
|
||||
).run();
|
||||
|
||||
const stmts = {
|
||||
createSession: db.prepare(
|
||||
`INSERT INTO sessions (id, title, owner_name, share_token, status, model, created_at, updated_at)
|
||||
@@ -115,6 +120,7 @@ const stmts = {
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
|
||||
),
|
||||
listMessages: db.prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY id ASC`),
|
||||
listStaleSessions: db.prepare(`SELECT id FROM sessions WHERE status IN ('running', 'queued')`),
|
||||
lastMessage: db.prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY id DESC LIMIT 1`),
|
||||
updateMessageContent: db.prepare(`UPDATE messages SET content = ? WHERE id = ?`),
|
||||
deleteMessages: db.prepare(`DELETE FROM messages WHERE session_id = ?`),
|
||||
@@ -254,7 +260,33 @@ module.exports = {
|
||||
id
|
||||
),
|
||||
computeCost,
|
||||
deleteSession: (id) => stmts.deleteSession.run(id),
|
||||
deleteSession: (id) => {
|
||||
stmts.deleteMessages.run(id);
|
||||
stmts.deleteSession.run(id);
|
||||
},
|
||||
/**
|
||||
* Setzt nach einem Server-Neustart alle Sessions zurück, die im alten
|
||||
* Prozess noch als 'running'/'queued' festhingen (Jobs existieren im
|
||||
* Speicher nicht mehr). Gibt die Anzahl zurück.
|
||||
*/
|
||||
markStaleJobs() {
|
||||
const stale = stmts.listStaleSessions.all();
|
||||
for (const s of stale) {
|
||||
stmts.setSessionStatus.run('done', now(), s.id);
|
||||
stmts.insertMessage.run(
|
||||
s.id,
|
||||
'assistant',
|
||||
'⛔ Recherche wurde durch einen Server-Neustart abgebrochen.',
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
now()
|
||||
);
|
||||
}
|
||||
return stale.length;
|
||||
},
|
||||
getSessionMessages,
|
||||
toApiMessages,
|
||||
upsertPushSub(userName, endpoint, keys) {
|
||||
|
||||
+28
-1
@@ -6,6 +6,33 @@ events.setMaxListeners(100);
|
||||
let queue = [];
|
||||
let running = false;
|
||||
|
||||
// Abort-Controller für laufende Jobs (für manuellen Abbruch)
|
||||
const controllers = new Map();
|
||||
|
||||
/** Abort-Controller für eine Session registrieren (einmal pro Job). */
|
||||
function registerController(sessionId) {
|
||||
const controller = new AbortController();
|
||||
controllers.set(sessionId, controller);
|
||||
return controller;
|
||||
}
|
||||
|
||||
/** Laufenden Job einer Session abbrechen. */
|
||||
function abortRunning(sessionId) {
|
||||
const controller = controllers.get(sessionId);
|
||||
if (controller) controller.abort();
|
||||
controllers.delete(sessionId);
|
||||
}
|
||||
|
||||
/** Läuft für diese Session gerade ein Job im Speicher? */
|
||||
function hasController(sessionId) {
|
||||
return controllers.has(sessionId);
|
||||
}
|
||||
|
||||
/** Controller nach Job-Ende entfernen. */
|
||||
function clearController(sessionId) {
|
||||
controllers.delete(sessionId);
|
||||
}
|
||||
|
||||
/** Einen Job anmelden. Läuft sofort, wenn nichts anderes läuft, sonst wartet er. */
|
||||
function enqueue(job) {
|
||||
queue.push(job);
|
||||
@@ -45,4 +72,4 @@ function state() {
|
||||
return { running, queued: queue.map((j) => j.sessionId) };
|
||||
}
|
||||
|
||||
module.exports = { events, enqueue, queuedBefore, isRunning, cancelQueued, state };
|
||||
module.exports = { events, enqueue, queuedBefore, isRunning, cancelQueued, state, registerController, abortRunning, hasController, clearController };
|
||||
+187
-41
@@ -17,7 +17,7 @@ const SYSTEM_PROMPT = `Du bist ein professioneller Web-Researcher und Wissensber
|
||||
4. VERIFIZIERE JEDEN Link, der ins Dashboard kommt, mit dem verify-Tool (Seite lädt UND Inhalt passt zum Kontext). Nur verifizierte Links kommen ins Dashboard! Wenn ein Link nicht passt, suche den richtigen nach.
|
||||
5. STRUKTURIERE die Ergebnisse in logische Kategorien (nach Plattform, Typ, Reife oder Einfachheit).
|
||||
6. ANALYSIERE: Schreibe eine ausführliche Einleitung mit 6 Absätzen: (1) Überblick, (2) Horizonterweiterung - was du außerdem herausgefunden hast, (3) Einschätzung der Optionen mit Vor-/Nachteilen, (4) konkrete Empfehlung, (5) Fahrplan / erste Schritte, (6) Fallstricke und Hinweise.
|
||||
7. GENERIERE das Dashboard mit dem save_dashboard-Tool (Detailstruktur unten) und fasse dann in deiner finalen Antwort das Wichtigste zusammen.
|
||||
7. GENERIERE das Dashboard: Rufe das save_dashboard-Tool mit Titel und Dateinamen auf – OHNE HTML (das Tool bestätigt nur und setzt den Dateinamen). Danach ist deine FINALE Antwort das KOMPLETTE Dashboard-HTML in einem Markdown-Codeblock \`\`\`html ... \`\`\` (Detailstruktur unten). Ein kurzer Einleitungssatz vor dem Codeblock ist erlaubt, danach endet deine Antwort. Kein weiterer Tool-Aufruf nötig.
|
||||
|
||||
## Tour-Planung (PFLICHT bei Tour-Anfragen!)
|
||||
Erkennst du den Wunsch nach einer Route/Tour/Städtebesichtigung (z.B. "plane eine Tour", "Route durch", "Städtebummel", "was sollte ich in X sehen"), gilt:
|
||||
@@ -55,8 +55,8 @@ Erkennst du den Wunsch nach einer Route/Tour/Städtebesichtigung (z.B. "plane ei
|
||||
- Erfinde NIEMALS Koordinaten, Distanzen oder Gehzeiten – bei Touren kommen die ausschließlich aus geocode() und save_tour()
|
||||
- Ziele auf 8-15 verifizierte Ressourcen pro Thema
|
||||
- Bei Login-Walls: old.reddit.com statt reddit.com, nitter.net statt twitter.com; wenn eine Seite blockiert, notiere das und nimm einen anderen Link
|
||||
- Die finale Antwort ist eine deutsche Zusammenfassung (max. 300 Wörter): wichtigste Erkenntnisse + Link zum Dashboard. Details gehören ins Dashboard, nicht in die Antwort.
|
||||
- Bei Folge-Nachrichten in einer bestehenden Session: Recherchiere die neue Anforderung und überschreibe das bestehende Dashboard mit dem save_dashboard-Tool, indem du DENSELBEN Dateinamen wie zuvor verwendest.
|
||||
- Deine finale Antwort nach dem save_dashboard-Tool-Aufruf ist das komplette Dashboard-HTML in einem \`\`\`html\`\`\`-Codeblock (eine Text-Zusammenfassung ist dann NICHT nötig – Details gehören ins Dashboard).
|
||||
- Bei Folge-Nachrichten in einer bestehenden Session: Recherchiere die neue Anforderung und überschreibe das bestehende Dashboard, indem du save_dashboard mit DENSELBEN Dateinamen wie zuvor aufrufst (OHNE HTML) und das komplette aktualisierte HTML in deiner finalen Antwort im \`\`\`html\`\`\`-Codeblock sendest.
|
||||
- Du darfst KEINE anderen URLs erfinden. Nutze ausschließlich Ergebnisse aus search/browse/verify.`;
|
||||
|
||||
const TOOL_DEFINITIONS = [
|
||||
@@ -80,7 +80,7 @@ const TOOL_DEFINITIONS = [
|
||||
function: {
|
||||
name: 'browse',
|
||||
description:
|
||||
'Besucht eine URL und liest den sichtbaren Text der Seite (Titel + Inhalt). Nutze das zum Lesen von Artikeln, Projektseiten und Fallback-Suchmaschinen (Startpage: https://www.startpage.com/do/dsearch?query=..., Google: https://www.google.com/search?q=...).',
|
||||
'Besucht eine URL, liest den sichtbaren Text und lädt Produktbilder der Seite lokal herunter. Das Feld `images` enthält die fertigen Bild-URLs (z.B. /dashboards/...) fürs Dashboard. Nutze das zum Lesen von Artikeln, Projektseiten und Fallback-Suchmaschinen (Startpage: https://www.startpage.com/do/dsearch?query=..., Google: https://www.google.com/search?q=...).',
|
||||
parameters: {
|
||||
type: 'object',
|
||||
properties: {
|
||||
@@ -110,15 +110,15 @@ const TOOL_DEFINITIONS = [
|
||||
function: {
|
||||
name: 'save_dashboard',
|
||||
description:
|
||||
'Speichert das fertige HTML-Dashboard als Datei auf dem Server und liefert die URL zurück. Übergib die KOMPLETTE standalone HTML-Datei (mit Tailwind CDN, deutsch, verifizierte Links mit Badges, Einleitung mit Analyse). Nutze bei Folge-Nachrichten den bisherigen Dateinamen, um das Dashboard zu aktualisieren.',
|
||||
'Bereitet das Speichern des HTML-Dashboards vor. Übergib NUR Titel und Dateinamen (OHNE HTML). Danach sendest du das KOMPLETTE HTML in deiner finalen Antwort in einem ```html```-Codeblock. Bei Folge-Nachrichten denselben Dateinamen wie zuvor verwenden, um das Dashboard zu aktualisieren.',
|
||||
parameters: {
|
||||
type: 'object',
|
||||
properties: {
|
||||
title: { type: 'string', description: 'Titel des Dashboards, z.B. "Fediverse-Alternativen zu Instagram"' },
|
||||
filename: { type: 'string', description: 'Dateiname ohne Endung, z.B. "fediverse-alternativen". Für Updates denselben Namen wie vorher verwenden.' },
|
||||
html: { type: 'string', description: 'Die komplette standalone HTML-Datei des Dashboards' },
|
||||
html: { type: 'string', description: 'Optional: komplettes HTML direkt übergeben – nur für kleine Dashboards; bevorzugt ist der Weg über die finale Antwort (```html```-Codeblock).' },
|
||||
},
|
||||
required: ['title', 'filename', 'html'],
|
||||
required: ['title', 'filename'],
|
||||
},
|
||||
},
|
||||
},
|
||||
@@ -175,7 +175,7 @@ const SCREENSHOT_TOOL = {
|
||||
function: {
|
||||
name: 'screenshot',
|
||||
description:
|
||||
'Macht einen Screenshot einer Seite (JPEG) und liefert das Bild in den Kontext. Nutze das bei bildlastigen Seiten, wenn der Text nicht ausreicht (z.B. Anzeigen-Listen, Produktfotos, Infografiken). Maximal 2-3 Screenshots pro Session.',
|
||||
'Macht einen Screenshot einer Seite (JPEG) und liefert das Bild in den Kontext. Nutze das bei bildlastigen Seiten, wenn der Text nicht ausreicht (z.B. Anzeigen-Listen, Produktfotos, Infografiken) oder um Produkte visuell zu vergleichen (Farbe, Form). Maximal ~5 Screenshots pro Session.',
|
||||
parameters: {
|
||||
type: 'object',
|
||||
properties: {
|
||||
@@ -204,11 +204,13 @@ function summarizeTool(toolName, output) {
|
||||
(data.results || []).slice(0, 5).map((r) => `${r.title} (${r.url})`).join(', ') || (data.note || '')
|
||||
}`;
|
||||
case 'browse':
|
||||
return `Seite: ${data.title || data.url || ''} – ${String(data.text || '').slice(0, 500)}`;
|
||||
return `Seite: ${data.title || data.url || ''} – ${String(data.text || '').slice(0, 500)}${
|
||||
data.images?.length ? ` [${data.images.length} Bilder extrahiert]` : ''
|
||||
}`;
|
||||
case 'verify':
|
||||
return `Link ${data.ok ? 'VERIFIZIERT ✓' : 'FEHLGESCHLAGEN ✗'}: ${data.url}${data.reason ? ' – ' + data.reason : ''}`;
|
||||
case 'save_dashboard':
|
||||
return `Dashboard gespeichert: ${data.url || ''}`;
|
||||
return data.note ? `Dashboard vorbereitet – HTML folgt in der finalen Antwort` : `Dashboard gespeichert: ${data.url || ''}`;
|
||||
case 'geocode':
|
||||
return data.error
|
||||
? `Geocoding FEHLGESCHLAGEN: ${data.error}`
|
||||
@@ -228,6 +230,15 @@ function summarizeTool(toolName, output) {
|
||||
|
||||
const MAX_ITERATIONS = 40;
|
||||
|
||||
// Abbruch, wenn der API-Stream länger hängt (z.B. Upstream ohne Keep-Alive)
|
||||
const REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
|
||||
|
||||
// Leere Modell-Antworten (kein Inhalt, keine Tool-Calls) einmal wiederholen
|
||||
const MAX_EMPTY_RETRIES = 1;
|
||||
|
||||
/** Wird geworfen, wenn der Nutzer die Recherche manuell abbricht. */
|
||||
class JobAbortedError extends Error {}
|
||||
|
||||
/** Baut den System-Prompt inkl. aktuellem Dashboard-Stand und Vision-Hinweisen. */
|
||||
function buildSystemPrompt(session, model) {
|
||||
let prompt = SYSTEM_PROMPT;
|
||||
@@ -237,16 +248,19 @@ function buildSystemPrompt(session, model) {
|
||||
|
||||
## Aktueller Stand dieser Session
|
||||
Für diese Session existiert bereits ein Dashboard: ${session.dashboard}
|
||||
Wenn der Nutzer Änderungen, Ergänzungen oder Erweiterungen wünscht, MUSST du das save_dashboard-Tool aufrufen und das KOMPLETTE aktualisierte HTML mit EXAKT diesem Dateinamen übergeben: "${file}" (ohne .html).
|
||||
Eine bloße Erklärung oder Beschreibung der Änderungen im Chat ist KEINE Umsetzung – erst wenn save_dashboard erfolgreich gelaufen ist, fasst du die Änderungen im Chat zusammen.`;
|
||||
Wenn der Nutzer Änderungen, Ergänzungen oder Erweiterungen wünscht, MUSST du das save_dashboard-Tool mit EXAKT diesem Dateinamen aufrufen: "${file}" (ohne .html) – OHNE HTML im Aufruf. Das KOMPLETTE aktualisierte HTML sendest du danach in deiner finalen Antwort in einem \`\`\`html\`\`\`-Codeblock.
|
||||
Eine bloße Erklärung oder Beschreibung der Änderungen im Chat ist KEINE Umsetzung – erst wenn der Codeblock gespeichert wurde, ist die Aufgabe erfüllt.`;
|
||||
}
|
||||
if (model.vision) {
|
||||
prompt += `
|
||||
|
||||
## Bilderkennung (Vision)
|
||||
- Wenn der Nutzer ein Bild hochgeladen hat (z.B. ein Foto eines Schuhs): Analysiere es SORGFÄLTIG (Marke, Farbe, Material, Form, Zustand, erkennbare Details) und suche gezielt nach ähnlichen Produkten und Angeboten. Beschreibe im Dashboard, worauf du beim Vergleich geachtet hast.
|
||||
- Das hochgeladene Bild liegt dir als Data-URL im Verlauf vor – du kannst es bei Bedarf direkt ins Dashboard einbetten.
|
||||
- Nutze das screenshot-Tool, um bildlastige Seiten (z.B. Anzeigen-Listen, Produktfotos) visuell zu beurteilen, wenn die Text-Extraktion nicht ausreicht. Maximal 2-3 Screenshots pro Session.`;
|
||||
## Bilderkennung & visuelle Produktsuche (Vision)
|
||||
- Hat der Nutzer ein Bild hochgeladen (z.B. einen Schuh): Analysiere es SORGFÄLTIG – Gattung/Modelltyp (z.B. Sneaker, Loafer, Stiefelette), Farben (Haupt-, Neben- und Sohlenfarbe), Material (Leder, Mesh, Wildleder), Form/Details (Sohle, Schnürung, Logo, Muster), Marke und Zustand.
|
||||
- Leite daraus 4-8 Suchbegriffe ab, Deutsch UND Englisch (z.B. "weißer minimalistischer leder-sneaker" / "white minimalist leather sneaker"), und suche gezielt nach ähnlichen Produkten und Angeboten. Priorität: Farbe, Form und Modelltyp.
|
||||
- Das browse-Tool lädt Produktbilder der Seite automatisch lokal herunter und liefert im Feld \`images\` fertige Dashboard-URLs (z.B. /dashboards/session-img-abc123.jpg). Bette sie direkt ein: <img src="..." alt="..." loading="lazy">. Nur diese URLs verwenden – niemals erfinden.
|
||||
- Baue eine Sektion "Visuelle Treffer" ins Dashboard: pro Treffer Produktbild, Name, ggf. Preis, verifizierter Link und eine kurze Begründung, warum er passt (Farbe/Form/Material).
|
||||
- Nutze das screenshot-Tool, um bildlastige Seiten (Anzeigen-Listen, Produktseiten) visuell zu vergleichen, wenn der Text nicht ausreicht – achte auf Farbton, Silhouette und Sohlenform. Maximal ~5 Screenshots pro Session; priorisiere die aussichtsreichsten Treffer.
|
||||
- Das hochgeladene Bild liegt dir als Data-URL im Verlauf vor – du kannst es als Referenz oben im Dashboard einbetten und beschreiben, worauf du beim Vergleich geachtet hast.`;
|
||||
}
|
||||
return prompt;
|
||||
}
|
||||
@@ -258,7 +272,22 @@ function isChangeRequest(text) {
|
||||
);
|
||||
}
|
||||
|
||||
async function chatCompletion(config, messages, systemPrompt, model, tools) {
|
||||
/** HTML aus der finalen Antwort extrahieren (```html```-Codeblock oder direktes HTML). */
|
||||
function extractHtmlBlock(content) {
|
||||
const s = String(content || '');
|
||||
const m = s.match(/```html\s*([\s\S]*?)```/i);
|
||||
if (m && m[1].trim()) return m[1].trim();
|
||||
const t = s.trim();
|
||||
if (/^<!DOCTYPE html/i.test(t) || /^<html[\s>]/i.test(t)) return t;
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Codeblöcke aus der finalen Antwort entfernen (für die Chat-Anzeige). */
|
||||
function stripHtmlBlock(content) {
|
||||
return String(content || '').replace(/```html\s*[\s\S]*?```/gi, '');
|
||||
}
|
||||
|
||||
async function chatCompletion(config, messages, systemPrompt, model, tools, signal, effortOverride) {
|
||||
const body = {
|
||||
model: model.id,
|
||||
messages: [{ role: 'system', content: systemPrompt }, ...messages],
|
||||
@@ -268,36 +297,38 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
|
||||
stream_options: { include_usage: true },
|
||||
};
|
||||
|
||||
const isOpenRouter = model.provider === 'openrouter';
|
||||
const baseUrl = isOpenRouter
|
||||
? 'https://openrouter.ai/api/v1'
|
||||
: config.baseUrl || 'https://api.deepseek.com';
|
||||
const baseUrl = config.baseUrl || 'https://api.deepseek.com';
|
||||
|
||||
if (isOpenRouter) {
|
||||
// GLM: Reasoning ist Pflicht; Effort über OpenRouter-Param "reasoning"
|
||||
body.reasoning = { effort: model.reasoningEffort?.() || 'max' };
|
||||
} else if (config.thinking !== 'disabled') {
|
||||
if (effortOverride === 'none' || config.thinking === 'disabled') {
|
||||
// DeepSeek: Denken pro Request abschaltbar (Liefer-Runde des Dashboards)
|
||||
body.thinking = { type: 'disabled' };
|
||||
} else {
|
||||
body.thinking = { type: 'enabled' };
|
||||
body.reasoning_effort = model.reasoningEffort?.() || 'high';
|
||||
body.reasoning_effort = effortOverride || model.reasoningEffort?.() || 'max';
|
||||
}
|
||||
|
||||
const headers = isOpenRouter
|
||||
? {
|
||||
'Content-Type': 'application/json',
|
||||
Authorization: `Bearer ${config.openrouterApiKey}`,
|
||||
'X-Title': 'Research Chat',
|
||||
'HTTP-Referer': 'https://github.com/nico/researchchat',
|
||||
}
|
||||
: {
|
||||
const headers = {
|
||||
'Content-Type': 'application/json',
|
||||
Authorization: `Bearer ${config.apiKey}`,
|
||||
};
|
||||
|
||||
const resp = await fetch(`${baseUrl}/chat/completions`, {
|
||||
const controller = new AbortController();
|
||||
const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
|
||||
const fetchSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
|
||||
let resp;
|
||||
try {
|
||||
resp = await fetch(`${baseUrl}/chat/completions`, {
|
||||
method: 'POST',
|
||||
headers,
|
||||
body: JSON.stringify(body),
|
||||
signal: fetchSignal,
|
||||
});
|
||||
} catch (e) {
|
||||
clearTimeout(timer);
|
||||
if (signal?.aborted) throw new JobAbortedError();
|
||||
throw new Error(`Modell-API nicht erreichbar (${model.id}): ${e.message.slice(0, 200)}`);
|
||||
}
|
||||
clearTimeout(timer);
|
||||
|
||||
if (!resp.ok) {
|
||||
const err = await resp.text().catch(() => '');
|
||||
@@ -324,9 +355,8 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
|
||||
const choice = json.choices?.[0];
|
||||
if (!choice) return;
|
||||
const d = choice.delta || {};
|
||||
// DeepSeek liefert reasoning_content, OpenRouter/GLM reasoning
|
||||
// DeepSeek liefert den Denk-Text als reasoning_content
|
||||
if (d.reasoning_content) delta.reasoning += d.reasoning_content;
|
||||
else if (d.reasoning) delta.reasoning += d.reasoning;
|
||||
if (d.content) delta.content += d.content;
|
||||
if (d.tool_calls) {
|
||||
for (const tc of d.tool_calls) {
|
||||
@@ -344,6 +374,7 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
|
||||
}
|
||||
}
|
||||
if (choice.finish_reason) delta.finishReason = choice.finish_reason;
|
||||
else if (d.finish_reason) delta.finishReason = d.finish_reason;
|
||||
};
|
||||
|
||||
for (;;) {
|
||||
@@ -358,6 +389,36 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
|
||||
}
|
||||
if (buffer.trim()) feed(buffer);
|
||||
|
||||
// Stream ohne Abschlussstatus: unvollständig beendet (Upstream-Fehler)
|
||||
if (!delta.finishReason && !delta.content && !delta.toolCalls) {
|
||||
throw new Error(`Modell ${model.id}: Stream unvollständig beendet (keine Antwort erhalten). Bitte erneut versuchen.`);
|
||||
}
|
||||
|
||||
// Antwort abgeschnitten (max_tokens erreicht): Wenn weder Inhalt noch
|
||||
// vollständige Tool-Calls vorhanden sind, endet die Recherche sonst
|
||||
// stillschweigend ohne Ergebnis. Dann lieber sichtbar abbrechen.
|
||||
if (delta.finishReason === 'length') {
|
||||
const hasCalls = Array.isArray(delta.toolCalls) && delta.toolCalls.length > 0;
|
||||
const callsComplete = !hasCalls || delta.toolCalls.every((tc) => {
|
||||
try {
|
||||
JSON.parse(tc.function.arguments || '{}');
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
if (!hasCalls && !delta.content) {
|
||||
throw new Error(
|
||||
`Modell-Antwort abgeschnitten (Token-Limit bei ${model.id} erreicht) – Ergebnis unvollständig. Bitte erneut versuchen oder ein anderes Modell wählen.`
|
||||
);
|
||||
}
|
||||
if (hasCalls && !callsComplete) {
|
||||
throw new Error(
|
||||
`Tool-Aufruf abgeschnitten (Token-Limit bei ${model.id} erreicht) – Recherche wird abgebrochen. Bitte erneut versuchen.`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
content: delta.content,
|
||||
reasoning: delta.reasoning,
|
||||
@@ -375,13 +436,18 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
|
||||
* @param {object} emit Event-Helfer: { token(t), thinking(t), progress(icon, text), step(msg), done(obj), error(msg) }
|
||||
* @param {object} db Datenbankmodul
|
||||
*/
|
||||
async function runResearchJob(config, session, userMessageText, emit, db) {
|
||||
async function runResearchJob(config, session, userMessageText, emit, db, signal) {
|
||||
let dashboardUrl = session.dashboard || null;
|
||||
let dashboardSaved = false;
|
||||
let pendingDashboard = null;
|
||||
// Sobald das Dashboard vorbereitet ist, läuft die nächste Runde mit minimalem
|
||||
// Denken – das Budget gehört dann dem kompletten HTML (siehe deliveryEffort).
|
||||
let deliveryEffort = null;
|
||||
|
||||
const model = getModel(session.model || config.model);
|
||||
const toolDefs = model.vision ? [...TOOL_DEFINITIONS, SCREENSHOT_TOOL] : TOOL_DEFINITIONS;
|
||||
const prices = model.prices;
|
||||
const isAborted = () => signal?.aborted === true;
|
||||
|
||||
const handlers = {
|
||||
async search({ query }) {
|
||||
@@ -392,7 +458,7 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
|
||||
},
|
||||
async browse({ url }) {
|
||||
emit.progress('🌐', `Besuche: ${url}`);
|
||||
const result = await tools.browse(url, (m) => emit.step(m));
|
||||
const result = await tools.browse(url, (m) => emit.step(m), { sessionId: session.id });
|
||||
return JSON.stringify(result);
|
||||
},
|
||||
async screenshot({ url, full_page }) {
|
||||
@@ -405,6 +471,8 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
|
||||
return JSON.stringify(result);
|
||||
},
|
||||
async save_dashboard({ title, filename, html }) {
|
||||
if (html && String(html).trim()) {
|
||||
// Alter Weg: HTML direkt im Tool-Aufruf (nur kleine Dashboards)
|
||||
emit.progress('📊', 'Dashboard wird gespeichert…');
|
||||
const saved = tools.saveDashboard(session.id, filename || title, html, (m) => emit.step(m));
|
||||
dashboardUrl = saved.url;
|
||||
@@ -412,6 +480,18 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
|
||||
db.setSessionDashboard(session.id, saved.url);
|
||||
emit.progress('📊', `Dashboard gespeichert: ${saved.file}`);
|
||||
return JSON.stringify(saved);
|
||||
}
|
||||
// Neuer Weg: nur vorbereiten, HTML kommt in der finalen Antwort
|
||||
pendingDashboard = { title: title || 'Dashboard', filename: filename || null };
|
||||
deliveryEffort = model.deliveryEffort || 'none';
|
||||
emit.progress(
|
||||
'📊',
|
||||
`Dashboard vorbereitet (${(filename || title || 'dashboard').toLowerCase().replace(/[^a-z0-9äöü-]+/g, '-')}.html) – sende jetzt das komplette HTML in deiner finalen Antwort als \`\`\`html\`\`\`-Codeblock…`
|
||||
);
|
||||
return JSON.stringify({
|
||||
ok: true,
|
||||
note: 'Dashboard vorbereitet. Sende jetzt das komplette HTML in deiner finalen Antwort in einem ```html```-Codeblock. Kein weiterer Tool-Aufruf nötig.',
|
||||
});
|
||||
},
|
||||
async geocode({ query }) {
|
||||
emit.progress('📍', `Geocode: ${query}`);
|
||||
@@ -428,6 +508,7 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
|
||||
const apiMessages = db.toApiMessages(session.id, { provider: model.provider, vision: model.vision });
|
||||
const text = userMessageText;
|
||||
const usage = { promptTokens: 0, completionTokens: 0, cacheHitTokens: 0, cacheMissTokens: 0 };
|
||||
let emptyRetries = 0;
|
||||
emit.progress('🤖', `Research startet mit ${model.label}…`);
|
||||
|
||||
const trackUsage = (u) => {
|
||||
@@ -450,9 +531,25 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
|
||||
return { text: finalText, dashboardUrl, usage, costEstimate, model: model.id };
|
||||
};
|
||||
|
||||
const finishAborted = () => {
|
||||
db.createMessage(session.id, { role: 'assistant', content: '⛔ Recherche abgebrochen.' });
|
||||
db.setSessionUsage(session.id, usage, prices);
|
||||
db.setSessionStatus(session.id, 'done');
|
||||
const costEstimate = db.computeCost(usage, prices);
|
||||
emit.aborted?.();
|
||||
return { text: '⛔ Recherche abgebrochen.', dashboardUrl, usage, costEstimate, model: model.id, aborted: true };
|
||||
};
|
||||
|
||||
for (let iter = 0; iter < MAX_ITERATIONS; iter++) {
|
||||
if (isAborted()) return finishAborted();
|
||||
emit.progress('🤖', iter === 0 ? 'Analysiere Anfrage und plane Suche…' : 'Weitere Analyse…');
|
||||
const result = await chatCompletion(config, apiMessages, buildSystemPrompt(session, model), model, toolDefs);
|
||||
let result;
|
||||
try {
|
||||
result = await chatCompletion(config, apiMessages, buildSystemPrompt(session, model), model, toolDefs, signal, deliveryEffort);
|
||||
} catch (e) {
|
||||
if (isAborted() || e instanceof JobAbortedError) return finishAborted();
|
||||
throw e;
|
||||
}
|
||||
trackUsage(result.usage);
|
||||
|
||||
if (result.reasoning) emit.thinking(result.reasoning);
|
||||
@@ -511,10 +608,59 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
|
||||
apiMessages.push({ role: 'tool', tool_call_id: tc.id, content: outStr.slice(0, 8000) });
|
||||
}
|
||||
}
|
||||
if (isAborted()) return finishAborted();
|
||||
continue;
|
||||
}
|
||||
|
||||
const finalText = result.content || (dashboardUrl ? 'Recherche abgeschlossen – siehe Dashboard.' : '');
|
||||
// Leere Antwort: Modell-Glitch oder abgebrochener Stream
|
||||
if (!result.content) {
|
||||
if (!pendingDashboard && !dashboardUrl && emptyRetries < MAX_EMPTY_RETRIES) {
|
||||
emptyRetries++;
|
||||
emit.progress('🔄', 'Leere Antwort erhalten – versuche es erneut…');
|
||||
continue;
|
||||
}
|
||||
if (pendingDashboard) {
|
||||
throw new Error(
|
||||
`Modell ${model.id} hat das Dashboard-HTML nicht geliefert (leere Antwort). Bitte erneut versuchen.`
|
||||
);
|
||||
}
|
||||
if (!dashboardUrl) {
|
||||
const hint = result.reasoning
|
||||
? ` Letzter Gedanke: „${String(result.reasoning).slice(-200)}“`
|
||||
: '';
|
||||
throw new Error(
|
||||
`Modell ${model.id} hat keine Antwort geliefert.${hint} Bitte erneut versuchen oder ein anderes Modell wählen.`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Dashboard vorbereitet → HTML aus der finalen Antwort extrahieren und speichern
|
||||
if (pendingDashboard && result.content) {
|
||||
const html = extractHtmlBlock(result.content);
|
||||
if (!html) {
|
||||
if (/```html/i.test(result.content)) {
|
||||
throw new Error(
|
||||
`Modell ${model.id}: Dashboard-HTML unvollständig (Codeblock nicht geschlossen) – möglicherweise wurde das Token-Limit erreicht. Bitte erneut versuchen oder ein kleineres Dashboard anfragen.`
|
||||
);
|
||||
}
|
||||
throw new Error(
|
||||
`Modell ${model.id} hat das Dashboard-HTML nicht geliefert (kein \`\`\`html\`\`\`-Codeblock in der Antwort). Bitte erneut versuchen.`
|
||||
);
|
||||
}
|
||||
const saved = tools.saveDashboard(
|
||||
session.id,
|
||||
pendingDashboard.filename || pendingDashboard.title,
|
||||
html,
|
||||
(m) => emit.step(m)
|
||||
);
|
||||
dashboardUrl = saved.url;
|
||||
dashboardSaved = true;
|
||||
db.setSessionDashboard(session.id, saved.url);
|
||||
emit.progress('📊', `Dashboard gespeichert: ${saved.file}`);
|
||||
result.content = stripHtmlBlock(result.content).trim() || `Fertig! Dein Dashboard ist online: ${saved.url}`;
|
||||
}
|
||||
|
||||
const finalText = result.content || (dashboardUrl ? 'Recherche abgeschlossen – siehe Dashboard.' : 'Recherche abgeschlossen.');
|
||||
if (!dashboardSaved && dashboardUrl && isChangeRequest(userMessageText)) {
|
||||
emit.progress(
|
||||
'⚠️',
|
||||
|
||||
+94
-6
@@ -1,5 +1,6 @@
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
const crypto = require('crypto');
|
||||
const { chromium } = require('playwright');
|
||||
|
||||
const DASHBOARD_DIR = path.join(__dirname, '..', 'dashboards');
|
||||
@@ -92,8 +93,76 @@ async function search(query, log) {
|
||||
return results;
|
||||
}
|
||||
|
||||
/** Seite besuchen und lesbaren Text extrahieren. */
|
||||
async function browse(url, log) {
|
||||
const IMAGE_TYPES = { 'image/jpeg': 'jpg', 'image/png': 'png', 'image/webp': 'webp', 'image/gif': 'gif' };
|
||||
const MAX_IMAGE_BYTES = 4 * 1024 * 1024;
|
||||
const MAX_TOTAL_IMAGE_BYTES = 12 * 1024 * 1024;
|
||||
const MAX_IMAGES = 8;
|
||||
|
||||
/**
|
||||
* Extrahiert Produktbild-URLs (nur absolute http(s), ausreichend groß, dedupliziert).
|
||||
* Läuft im Browser-Kontext der besuchten Seite.
|
||||
*/
|
||||
function collectImages() {
|
||||
const images = [];
|
||||
const seen = new Set();
|
||||
for (const img of document.querySelectorAll('img')) {
|
||||
const src = (img.currentSrc || img.src || '').split('#')[0];
|
||||
if (!/^https?:/i.test(src) || seen.has(src)) continue;
|
||||
const nw = img.naturalWidth || 0;
|
||||
const nh = img.naturalHeight || 0;
|
||||
const rect = img.getBoundingClientRect();
|
||||
const w = nw || rect.width || img.width || 0;
|
||||
const h = nh || rect.height || img.height || 0;
|
||||
if (w < 120 || h < 120) continue;
|
||||
seen.add(src);
|
||||
images.push({ url: src, alt: (img.alt || '').trim().slice(0, 120) });
|
||||
if (images.length >= 12) break;
|
||||
}
|
||||
return images;
|
||||
}
|
||||
|
||||
/**
|
||||
* Lädt extrahierte Bilder lokal in den Dashboards-Ordner, damit das Dashboard
|
||||
* sie unabhängig von Hotlink-Schutz und ablaufenden CDN-URLs einbetten kann.
|
||||
* Dateiname: <sessionId>-img-<hash>.<ext> – wird beim Session-Löschen mit entfernt.
|
||||
*/
|
||||
async function cacheImages(page, images, sessionId, log) {
|
||||
if (!sessionId) return images;
|
||||
fs.mkdirSync(DASHBOARD_DIR, { recursive: true });
|
||||
const existingFiles = new Set(fs.readdirSync(DASHBOARD_DIR));
|
||||
const out = [];
|
||||
let total = 0;
|
||||
for (const img of images) {
|
||||
if (out.length >= MAX_IMAGES || total >= MAX_TOTAL_IMAGE_BYTES) break;
|
||||
try {
|
||||
const hash = crypto.createHash('sha1').update(img.url).digest('hex').slice(0, 12);
|
||||
const known = [...existingFiles].find((f) => f.startsWith(`${sessionId}-img-${hash}.`));
|
||||
if (known) {
|
||||
out.push({ url: `/dashboards/${known}`, alt: img.alt });
|
||||
continue;
|
||||
}
|
||||
const resp = await page.request.get(img.url, {
|
||||
timeout: 15000,
|
||||
headers: { Referer: page.url() },
|
||||
});
|
||||
const type = String(resp.headers()['content-type'] || '').split(';')[0].trim().toLowerCase();
|
||||
const ext = IMAGE_TYPES[type];
|
||||
if (!ext || !resp.ok()) continue;
|
||||
const buf = await resp.body();
|
||||
if (buf.length < 512 || buf.length > MAX_IMAGE_BYTES || total + buf.length > MAX_TOTAL_IMAGE_BYTES) continue;
|
||||
const file = `${sessionId}-img-${hash}.${ext}`;
|
||||
fs.writeFileSync(path.join(DASHBOARD_DIR, file), buf);
|
||||
existingFiles.add(file);
|
||||
total += buf.length;
|
||||
out.push({ url: `/dashboards/${file}`, alt: img.alt });
|
||||
} catch {}
|
||||
}
|
||||
log?.(`Produktbilder lokal gespeichert: ${out.length}`);
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Seite besuchen und lesbaren Text + Produktbilder (lokal gespeichert) extrahieren. */
|
||||
async function browse(url, log, opts = {}) {
|
||||
return withPage(url, async (page) => {
|
||||
const nav = await goto(page, url);
|
||||
if (!nav.ok) return { nav, error: 'Seite konnte nicht geladen werden' };
|
||||
@@ -101,10 +170,12 @@ async function browse(url, log) {
|
||||
const data = await page.evaluate(() => {
|
||||
const title = document.title || '';
|
||||
const text = (document.body ? document.body.innerText : '').replace(/\s+\n/g, '\n');
|
||||
return { title, text: text.slice(0, 15000) };
|
||||
return { title, text: text.slice(0, 6000) };
|
||||
});
|
||||
log?.(`Besuche ${url} -> ${data.title}`);
|
||||
return { nav, title: data.title, text: data.text };
|
||||
const extracted = await page.evaluate(collectImages);
|
||||
const images = await cacheImages(page, extracted, opts.sessionId, log);
|
||||
log?.(`Besuche ${url} -> ${data.title} (${images.length} Bilder lokal)`);
|
||||
return { nav, title: data.title, images, text: data.text };
|
||||
});
|
||||
}
|
||||
|
||||
@@ -144,6 +215,23 @@ function saveDashboard(sessionId, filename, html, log) {
|
||||
return { file, url: `/dashboards/${file}` };
|
||||
}
|
||||
|
||||
/** Alle Dashboard-Dateien einer Session (HTML/GPX/tour.json) löschen. */
|
||||
function deleteSessionFiles(sessionId) {
|
||||
let entries;
|
||||
try {
|
||||
entries = fs.readdirSync(DASHBOARD_DIR);
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
for (const f of entries) {
|
||||
if (f.startsWith(`${sessionId}-`)) {
|
||||
try {
|
||||
fs.unlinkSync(path.join(DASHBOARD_DIR, f));
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Screenshot einer Seite (JPEG, als Data-URL) – für Vision-Modelle. */
|
||||
async function screenshot(url, fullPage = false, log) {
|
||||
return withPage(url, async (page) => {
|
||||
@@ -374,4 +462,4 @@ async function closeBrowser() {
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { search, browse, verify, saveDashboard, screenshot, geocode, saveTour, closeBrowser };
|
||||
module.exports = { search, browse, verify, saveDashboard, screenshot, geocode, saveTour, deleteSessionFiles, closeBrowser };
|
||||
+59
-2
@@ -62,18 +62,52 @@ function renderSessions() {
|
||||
: s.status === 'done'
|
||||
? '<span class="w-2 h-2 rounded-full bg-emerald-400 inline-block mr-2"></span>'
|
||||
: '<span class="w-2 h-2 rounded-full bg-slate-500 inline-block mr-2"></span>';
|
||||
const row = document.createElement('div');
|
||||
row.className = 'group relative';
|
||||
const btn = document.createElement('button');
|
||||
btn.className = `w-full text-left px-3 py-2 rounded-lg text-sm flex items-start gap-1 ${
|
||||
active ? 'bg-blue-600/20 text-blue-300' : 'hover:bg-slate-800'
|
||||
}`;
|
||||
btn.innerHTML = `${dot}<span class="truncate">${escapeHtml(s.title)}</span>`;
|
||||
btn.innerHTML = `${dot}<span class="truncate flex-1">${escapeHtml(s.title)}</span>`;
|
||||
btn.onclick = () => openSession(s.id);
|
||||
list.appendChild(btn);
|
||||
const del = document.createElement('button');
|
||||
del.className =
|
||||
'absolute right-1 top-1/2 -translate-y-1/2 w-6 h-6 rounded text-xs text-slate-500 hover:text-red-400 hover:bg-slate-700 opacity-0 group-hover:opacity-100';
|
||||
del.textContent = '🗑';
|
||||
del.title = 'Chat löschen';
|
||||
del.onclick = (e) => {
|
||||
e.stopPropagation();
|
||||
deleteSession(s.id);
|
||||
};
|
||||
row.append(btn, del);
|
||||
list.appendChild(row);
|
||||
}
|
||||
const qs = state.sessions.find((s) => s.job === 'running' || s.job === 'queued');
|
||||
$('queueStatus').classList.toggle('hidden', !qs);
|
||||
}
|
||||
|
||||
async function deleteSession(id) {
|
||||
const s = state.sessions.find((x) => x.id === id);
|
||||
if (!confirm(`Chat „${s?.title || '…'}“ wirklich löschen? Das zugehörige Dashboard wird mit gelöscht.`)) return;
|
||||
const res = await fetch(`/api/sessions/${id}`, { method: 'DELETE' });
|
||||
if (!res.ok) {
|
||||
addToolLine('⚠️', 'Löschen fehlgeschlagen');
|
||||
return;
|
||||
}
|
||||
if (state.current?.id === id) {
|
||||
state.stream?.close();
|
||||
state.stream = null;
|
||||
state.streamingEl = null;
|
||||
state.current = null;
|
||||
hideActivity();
|
||||
const next = state.sessions.find((x) => x.id !== id);
|
||||
if (next) await openSession(next.id);
|
||||
else await newSession();
|
||||
} else {
|
||||
await loadSessions();
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Chat-Rendering
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -187,6 +221,8 @@ function showActivity() {
|
||||
$('activityLog').classList.add('hidden');
|
||||
$('toggleLog').textContent = 'Details zeigen';
|
||||
state.activityShown = true;
|
||||
$('abortBtn').classList.remove('hidden');
|
||||
$('abortBtn').disabled = false;
|
||||
}
|
||||
|
||||
function setActivity(text, icon = '') {
|
||||
@@ -202,15 +238,29 @@ function logActivity(text) {
|
||||
|
||||
function hideActivity() {
|
||||
$('activityBar').classList.add('hidden');
|
||||
$('abortBtn').classList.add('hidden');
|
||||
state.activityShown = false;
|
||||
}
|
||||
|
||||
async function abortResearch() {
|
||||
if (!state.current) return;
|
||||
$('abortBtn').disabled = true;
|
||||
setActivity('Breche Recherche ab…', '⛔');
|
||||
try {
|
||||
await fetch(`/api/sessions/${state.current.id}/abort`, { method: 'POST' });
|
||||
} catch {
|
||||
$('abortBtn').disabled = false;
|
||||
}
|
||||
}
|
||||
|
||||
$('toggleLog').onclick = () => {
|
||||
const log = $('activityLog');
|
||||
const hidden = log.classList.toggle('hidden');
|
||||
$('toggleLog').textContent = hidden ? 'Details zeigen' : 'Details verbergen';
|
||||
};
|
||||
|
||||
$('abortBtn').onclick = abortResearch;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// SSE-Stream
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -286,6 +336,13 @@ function connectStream(sessionId) {
|
||||
$('sendBtn').disabled = false;
|
||||
});
|
||||
|
||||
es.addEventListener('aborted', () => {
|
||||
addToolLine('⛔', 'Recherche abgebrochen.');
|
||||
hideActivity();
|
||||
loadSessions();
|
||||
$('sendBtn').disabled = false;
|
||||
});
|
||||
|
||||
es.addEventListener('error', (e) => {
|
||||
if (!e.data) return;
|
||||
const d = JSON.parse(e.data);
|
||||
|
||||
@@ -57,6 +57,8 @@
|
||||
<div id="activityLine" class="flex items-center gap-2">
|
||||
<span class="inline-block w-3 h-3 border-2 border-blue-500 border-t-transparent rounded-full animate-spin"></span>
|
||||
<span id="activityText">Starte…</span>
|
||||
<button id="abortBtn" type="button" title="Recherche abbrechen"
|
||||
class="ml-auto hidden text-xs px-2 py-1 rounded-lg bg-red-600/15 text-red-400 hover:bg-red-600/30">⛔ Abbrechen</button>
|
||||
</div>
|
||||
<div id="activityLog" class="hidden mt-1 max-h-32 overflow-y-auto text-xs text-slate-400 space-y-0.5"></div>
|
||||
<button id="toggleLog" class="text-xs text-blue-400 mt-1">Details zeigen</button>
|
||||
|
||||
+1
-1
@@ -28,7 +28,7 @@
|
||||
<div id="content" class="hidden space-y-4"></div>
|
||||
|
||||
<footer class="mt-8 text-center text-xs text-slate-500">
|
||||
<p>Generiert mit dem Research Agent · DeepSeek V4 Flash / GLM 5.3 Flash</p>
|
||||
<p>Generiert mit dem Research Agent · DeepSeek V4.1 Flash</p>
|
||||
</footer>
|
||||
</div>
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
const path = require('path');
|
||||
const http = require('http');
|
||||
const crypto = require('crypto');
|
||||
const fs = require('fs');
|
||||
const express = require('express');
|
||||
const webpush = require('web-push');
|
||||
|
||||
@@ -8,7 +9,7 @@ const { config, getModel, getModels } = require('./lib/config');
|
||||
const db = require('./lib/db');
|
||||
const queue = require('./lib/queue');
|
||||
const { runResearchJob } = require('./lib/research');
|
||||
const { closeBrowser } = require('./lib/tools');
|
||||
const { closeBrowser, deleteSessionFiles } = require('./lib/tools');
|
||||
|
||||
const app = express();
|
||||
app.disable('x-powered-by');
|
||||
@@ -165,7 +166,7 @@ app.post('/api/sessions', requireAuth, (req, res) => {
|
||||
|
||||
app.patch('/api/sessions/:id', requireAuth, (req, res) => {
|
||||
const session = db.getSession(req.params.id);
|
||||
if (!session || session.owner_name !== req.user.n) {
|
||||
if (!session) {
|
||||
return res.status(404).json({ error: 'Session nicht gefunden' });
|
||||
}
|
||||
const modelId = String(req.body?.model || '');
|
||||
@@ -206,9 +207,35 @@ app.get('/api/sessions/:id/share', requireAuth, (req, res) => {
|
||||
|
||||
app.delete('/api/sessions/:id', requireAuth, (req, res) => {
|
||||
const session = db.getSession(req.params.id);
|
||||
if (!session) return res.status(404).json({ error: 'Session nicht gefunden' });
|
||||
if (!session) {
|
||||
return res.status(404).json({ error: 'Session nicht gefunden' });
|
||||
}
|
||||
queue.cancelQueued(session.id);
|
||||
queue.abortRunning(session.id);
|
||||
db.deleteSession(session.id);
|
||||
deleteSessionFiles(session.id);
|
||||
res.json({ ok: true });
|
||||
});
|
||||
|
||||
app.post('/api/sessions/:id/abort', requireAuth, (req, res) => {
|
||||
const session = db.getSession(req.params.id);
|
||||
if (!session) {
|
||||
return res.status(404).json({ error: 'Session nicht gefunden' });
|
||||
}
|
||||
if (queue.queuedBefore(session.id) >= 0) {
|
||||
// Job wartet noch in der Queue → direkt entfernen und aufräumen
|
||||
queue.cancelQueued(session.id);
|
||||
} else if (queue.hasController(session.id)) {
|
||||
// Laufender Job → Controller auslösen, der Job räumt selbst auf
|
||||
queue.abortRunning(session.id);
|
||||
return res.json({ ok: true });
|
||||
}
|
||||
// Wartender Job oder veralteter Job (z.B. nach Server-Neustart, ohne
|
||||
// laufenden Prozess): Zustand und UI direkt zurücksetzen
|
||||
db.createMessage(session.id, { role: 'assistant', content: '⛔ Recherche abgebrochen.' });
|
||||
db.setSessionStatus(session.id, 'done');
|
||||
emitToSession(session.id, 'aborted', {});
|
||||
emitToSession(session.id, 'status', { sessionStatus: 'done', jobStatus: 'aborted' });
|
||||
res.json({ ok: true });
|
||||
});
|
||||
|
||||
@@ -242,7 +269,7 @@ app.post('/api/sessions/:id/messages', requireAuth, (req, res) => {
|
||||
const model = getModel(session.model);
|
||||
if (!model.vision) {
|
||||
return res.status(400).json({
|
||||
error: `Das Modell "${model.label}" kann keine Bilder verarbeiten – bitte auf ein Modell mit Bilderkennung wechseln (z.B. GLM 5.3 Flash).`,
|
||||
error: `Das Modell "${model.label}" kann keine Bilder verarbeiten.`,
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -259,9 +286,12 @@ app.post('/api/sessions/:id/messages', requireAuth, (req, res) => {
|
||||
}
|
||||
db.setSessionStatus(session.id, 'queued');
|
||||
|
||||
const controller = queue.registerController(session.id);
|
||||
|
||||
const job = {
|
||||
sessionId: session.id,
|
||||
async run() {
|
||||
try {
|
||||
db.setSessionStatus(session.id, 'running');
|
||||
emitToSession(session.id, 'status', { sessionStatus: 'running', jobStatus: 'running' });
|
||||
|
||||
@@ -275,6 +305,10 @@ app.post('/api/sessions/:id/messages', requireAuth, (req, res) => {
|
||||
emitToSession(session.id, 'status', { sessionStatus: 'done', jobStatus: 'done' });
|
||||
sendPush(session, result);
|
||||
},
|
||||
aborted: () => {
|
||||
emitToSession(session.id, 'aborted', {});
|
||||
emitToSession(session.id, 'status', { sessionStatus: 'done', jobStatus: 'aborted' });
|
||||
},
|
||||
error: (msg) => emitToSession(session.id, 'error', { text: msg }),
|
||||
};
|
||||
|
||||
@@ -283,8 +317,12 @@ app.post('/api/sessions/:id/messages', requireAuth, (req, res) => {
|
||||
db.getSession(session.id),
|
||||
text,
|
||||
emit,
|
||||
db
|
||||
db,
|
||||
controller.signal
|
||||
);
|
||||
} finally {
|
||||
queue.clearController(session.id);
|
||||
}
|
||||
},
|
||||
async onError(e) {
|
||||
console.error('Job-Fehler:', e);
|
||||
@@ -379,6 +417,75 @@ function sendPush(session, result) {
|
||||
// Statische Dateien & Dashboard-Dateien
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// Wird in jedes ausgelieferte Dashboard-HTML injiziert: speichert den Zustand
|
||||
// der Checklisten-Häkchen im localStorage und stellt ihn beim Laden wieder her
|
||||
// (inkl. „Liste zurücksetzen"-Button). Key = Label-Text der Checkbox, damit
|
||||
// der Stand auch bei Layout-Änderungen stabil bleibt.
|
||||
const CHECKLIST_SCRIPT = `<script>
|
||||
(function () {
|
||||
var KEY = 'rc-checks:' + location.pathname;
|
||||
var boxes = document.querySelectorAll('input[type=checkbox]');
|
||||
if (!boxes.length) return;
|
||||
var saved = {};
|
||||
try { saved = JSON.parse(localStorage.getItem(KEY) || '{}'); } catch (e) {}
|
||||
|
||||
function labelFor(box, i) {
|
||||
var li = box.closest('li');
|
||||
var t = li ? li.querySelector('.check-text') : null;
|
||||
var text = (t || li || {}).textContent || '';
|
||||
return text.trim() || 'item-' + i;
|
||||
}
|
||||
|
||||
boxes.forEach(function (box, i) {
|
||||
var k = labelFor(box, i);
|
||||
if (saved[k] !== undefined) box.checked = !!saved[k];
|
||||
box.addEventListener('change', function () {
|
||||
saved[k] = box.checked;
|
||||
try { localStorage.setItem(KEY, JSON.stringify(saved)); } catch (e) {}
|
||||
});
|
||||
});
|
||||
|
||||
function refresh() {
|
||||
if (typeof update === 'function') update();
|
||||
}
|
||||
|
||||
// „Liste zurücksetzen"-Button am Anfang der ersten Checklisten-Section
|
||||
var firstBox = boxes[0];
|
||||
var section = firstBox.closest('section') || firstBox.closest('div') || document.body;
|
||||
var btn = document.createElement('button');
|
||||
btn.type = 'button';
|
||||
btn.textContent = '↺ Liste zurücksetzen';
|
||||
btn.style.cssText =
|
||||
'margin:0 0 12px;padding:6px 14px;font-size:12px;font-weight:600;border-radius:8px;' +
|
||||
'border:1px solid rgba(100,116,139,.4);background:transparent;color:inherit;cursor:pointer;';
|
||||
btn.addEventListener('click', function () {
|
||||
if (!confirm('Alle Häkchen dieser Liste zurücksetzen?')) return;
|
||||
try { localStorage.removeItem(KEY); } catch (e) {}
|
||||
saved = {};
|
||||
boxes.forEach(function (b) { b.checked = false; });
|
||||
refresh();
|
||||
});
|
||||
section.insertBefore(btn, section.firstChild);
|
||||
|
||||
refresh();
|
||||
})();
|
||||
</script>`;
|
||||
|
||||
const CHECKLIST_MARKER = 'rc-checks';
|
||||
|
||||
app.get('/dashboards/:name.html', (req, res, next) => {
|
||||
const name = path.basename(req.params.name);
|
||||
const file = path.join(__dirname, 'dashboards', `${name}.html`);
|
||||
fs.readFile(file, 'utf8', (err, html) => {
|
||||
if (err) return next();
|
||||
if (!html.includes(CHECKLIST_MARKER)) {
|
||||
html = html.replace(/<\/body>/i, `${CHECKLIST_SCRIPT}\n</body>`);
|
||||
}
|
||||
res.setHeader('Cache-Control', 'no-cache');
|
||||
res.type('html').send(html);
|
||||
});
|
||||
});
|
||||
|
||||
app.use(
|
||||
'/dashboards',
|
||||
express.static(path.join(__dirname, 'dashboards'), {
|
||||
@@ -412,12 +519,16 @@ app.get('/', (req, res) => {
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// Nach einem Server-Neustart hängengebliebene Jobs (running/queued in der DB)
|
||||
// zurücksetzen – die Jobs existieren im Speicher nicht mehr.
|
||||
const staleCount = db.markStaleJobs();
|
||||
if (staleCount > 0) {
|
||||
console.log(`INFO: ${staleCount} verwaiste Recherche(n) nach Neustart zurückgesetzt.`);
|
||||
}
|
||||
|
||||
if (!config.apiKey) {
|
||||
console.error('WARNUNG: DEEPSEEK_API_KEY fehlt in .env – DeepSeek-Modelle werden nicht funktionieren.');
|
||||
}
|
||||
if (!config.openrouterApiKey) {
|
||||
console.error('WARNUNG: OPENROUTER_API_KEY fehlt in .env – OpenRouter-Modelle (z.B. GLM 5.3 Flash) werden nicht funktionieren.');
|
||||
}
|
||||
if (!config.appPassword) {
|
||||
console.error('WARNUNG: APP_PASSWORD fehlt in .env – Login ohne Passwort-Check.');
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user