Hermes
14160f9317
Judge r1 (C) blockers B1-B3 + polish both applied — see body of rev1 commit for feature scope. urn:ump:l2tg66wmchkmd6fde4k3ojwc56zpxqh657spe37bu6dpvduswalq
723 lines
31 KiB
JavaScript
723 lines
31 KiB
JavaScript
/**
|
|
* DashCaddy AI Intent Router
|
|
*
|
|
* Takes natural language input and returns structured, actionable intents
|
|
* that can be executed against the DashCaddy API.
|
|
*
|
|
* POST /api/v1/ai/intent
|
|
* Body: { message: "I want to stream movies", history?: [{role,content}] }
|
|
* Returns: { intent, confidence, action, engine, response, appId?, … }
|
|
*
|
|
* Two engines, one contract:
|
|
* 1. LLM engine (default when configured): a small OpenAI-compatible model
|
|
* classifies the message into the DashCaddy intent vocabulary with the
|
|
* LIVE app catalog + wizard categories as the candidate list — so any
|
|
* of the 78 templates (and follow-ups like "name it vault") work,
|
|
* including ones the old regex list never knew about.
|
|
* Configured at PUT /api/v1/ai/settings (encrypted credential store,
|
|
* key 'ai:llm') with env fallbacks AI_LLM_* / LLM_PROXY_URL. NEVER
|
|
* config.json: GET /config returns the raw file to the browser.
|
|
* The upstream call uses the GLOBAL fetch with an AbortController —
|
|
* deliberately NOT ctx.fetchT, whose https path sets
|
|
* rejectUnauthorized:false for self-signed .sami certs; an EXTERNAL
|
|
* LLM API must get full TLS verification.
|
|
* 2. Pattern engine (instant, offline, zero-config): the original regex
|
|
* library. Used when no LLM is configured, and as the failover when the
|
|
* LLM call fails, times out, or returns an unrepairable shape.
|
|
* The response carries `engine` so callers can show what actually served.
|
|
*
|
|
* Injection-safety model (DC-163): the LLM is given data-finding tasks only.
|
|
* Output is schema-validated against closed vocabularies; free text is
|
|
* bounded and stripped of control chars. The model can NEVER produce an
|
|
* action string outside the known action set or a template id outside the
|
|
* catalog. The reply text is displayed client-side via textContent only.
|
|
* No LLM output is ever executed.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
const express = require('express');
|
|
const { ok, errorResponse } = require('../src/utils/responses');
|
|
const { APP_TEMPLATES } = require('../src/docker/app-templates');
|
|
|
|
// ─── Vocabularies (closed sets — the LLM may only choose from these) ───────
|
|
|
|
const INTENTS = ['deploy', 'recommend', 'diagnose', 'health', 'list', 'backup', 'unknown'];
|
|
|
|
const ACTIONS_BY_INTENT = {
|
|
deploy: 'dashcaddy_deploy_app',
|
|
recommend: 'dashcaddy_wizard_recommend',
|
|
diagnose: 'dashcaddy_diagnose',
|
|
health: 'dashcaddy_system_health',
|
|
list: 'dashcaddy_list_services',
|
|
backup: 'dashcaddy_create_backup',
|
|
unknown: null,
|
|
};
|
|
|
|
const RECOMMEND_CATEGORIES = ['media-streaming', 'file-sync', 'home-network', 'smart-home', 'development', 'monitoring'];
|
|
const TEMPLATE_IDS = Object.keys(APP_TEMPLATES);
|
|
|
|
const MAX_INPUT = 1000; // user message cap (chars)
|
|
const MAX_REPLY = 600; // LLM reply cap (chars)
|
|
const MAX_HISTORY = 6; // prior turns sent to the LLM
|
|
const LLM_TIMEOUT_MS = 8000; // per-call deadline
|
|
|
|
// ─── Text sanitizer: strip control chars; no HTML filtering needed because
|
|
// the chat panel renders replies with textContent only. ─────────────────
|
|
function sanitizeText(s, max = MAX_REPLY) {
|
|
if (typeof s !== 'string') return '';
|
|
// eslint-disable-next-line no-control-regex
|
|
return s.replace(/[\u0000-\u001F\u007F]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
|
|
}
|
|
|
|
function normId(v) {
|
|
return typeof v === 'string' ? v.toLowerCase().replace(/[\s_]+/g, '-') : null;
|
|
}
|
|
|
|
// ─── Candidate catalog for the LLM prompt ──────────────────────────────────
|
|
function catalogBlock(limit = 80) {
|
|
const tpl = TEMPLATE_IDS.slice(0, limit).map((id) => {
|
|
const t = APP_TEMPLATES[id];
|
|
return `- ${id}: ${t.name || id} (${(t.description || '').split(/[.!]/)[0].slice(0, 90)})`;
|
|
}).join('\n');
|
|
const cats = RECOMMEND_CATEGORIES.map((c) => `- ${c}`).join('\n');
|
|
return { tpl, cats };
|
|
}
|
|
|
|
function buildSystemPrompt() {
|
|
const { tpl, cats } = catalogBlock();
|
|
return 'You are the intent classifier for DashCaddy, a self-hosting dashboard. ' +
|
|
'Read the user message (and conversation history) and output ONLY a minified JSON object, no markdown:\n' +
|
|
'{"intent":"deploy|recommend|diagnose|health|list|backup|unknown",' +
|
|
'"appId":"<template id or null>","serviceId":"<service name or null>",' +
|
|
'"categories":["<wizard categories>"],"reply":"<short friendly sentence>"}\n' +
|
|
'Rules:\n' +
|
|
'- intent=deploy when the user wants to install/host/launch/run a specific app (including "set it up", "yes go"). Use history to resolve pronouns.\n' +
|
|
'- appId MUST be one of the template ids below (exact id), else null. Never invent ids.\n' +
|
|
'- intent=recommend when the user states a goal without naming an app; categories from the wizard list.\n' +
|
|
'- diagnose for problems ("why is X down"), health for status questions, list for inventory questions, backup for backup requests, unknown otherwise.\n' +
|
|
'- reply: at most 160 characters, plain text, no markdown, no links.\n' +
|
|
'Template ids:\n' + tpl + '\nWizard categories:\n' + cats;
|
|
}
|
|
|
|
// ─── OpenAI-compatible chat call ───────────────────────────────────────────
|
|
async function callLlm(deps, cfg, messages) {
|
|
const doFetch = deps.fetchImpl || fetch;
|
|
const controller = new AbortController();
|
|
const timer = setTimeout(() => controller.abort(), deps.timeoutMs || LLM_TIMEOUT_MS);
|
|
try {
|
|
const res = await doFetch(`${cfg.baseUrl.replace(/\/+$/, '')}/chat/completions`, {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': `Bearer ${cfg.apiKey}`,
|
|
},
|
|
body: JSON.stringify({
|
|
model: cfg.model,
|
|
messages,
|
|
temperature: 0,
|
|
max_tokens: 300,
|
|
}),
|
|
signal: controller.signal,
|
|
});
|
|
if (!res.ok) {
|
|
throw new Error(`LLM HTTP ${res.status}`);
|
|
}
|
|
const data = await res.json();
|
|
const content = data && data.choices && data.choices[0] &&
|
|
data.choices[0].message && data.choices[0].message.content;
|
|
if (typeof content !== 'string' || !content.trim()) {
|
|
throw new Error('LLM empty completion');
|
|
}
|
|
return content;
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
|
|
// ─── Parse + repair + schema-validate the LLM output ───────────────────────
|
|
function repairParsed(raw) {
|
|
// Deterministic corrections for common small-model drift BEFORE schema.
|
|
let out = raw.replace(/```(json)?/gi, '').trim();
|
|
const first = out.indexOf('{');
|
|
const last = out.lastIndexOf('}');
|
|
if (first !== -1 && last > first) out = out.slice(first, last + 1);
|
|
return out;
|
|
}
|
|
|
|
function validateParsed(parsed) {
|
|
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
|
|
let intent = typeof parsed.intent === 'string' ? parsed.intent.toLowerCase() : null;
|
|
if (!INTENTS.includes(intent)) {
|
|
// drift repair: unknown-ish values → 'unknown'
|
|
intent = 'unknown';
|
|
}
|
|
const appId = normId(parsed.appId);
|
|
const serviceId = normId(parsed.serviceId);
|
|
const categories = Array.isArray(parsed.categories)
|
|
? parsed.categories.map((c) => (typeof c === 'string' ? c.toLowerCase() : null)).filter((c) => c && RECOMMEND_CATEGORIES.includes(c))
|
|
: [];
|
|
return {
|
|
intent,
|
|
appId: appId && TEMPLATE_IDS.includes(appId) ? appId : null,
|
|
serviceId: serviceId || null,
|
|
categories,
|
|
reply: sanitizeText(parsed.reply, MAX_REPLY),
|
|
};
|
|
}
|
|
|
|
// ─── Merge validated LLM fields onto the pattern result ────────────────────
|
|
// Same-intent: pattern stays the structural base (known-good shapes) and
|
|
// the LLM adds semantic corrections (a valid catalog appId wins even when
|
|
// regex missed it). Different-intent: the pattern's intent-SPECIFIC fields
|
|
// (appId/serviceId/categories/response/action) belong to the OLD intent and
|
|
// are dropped — merged fields come exclusively from the validated LLM
|
|
// output, with `action` strictly ACTIONS_BY_INTENT[llm.intent] (null for
|
|
// 'unknown'). Stale pattern data can never ride along under a new intent.
|
|
function mergeIntent(patternResult, llm) {
|
|
const intentChanged = llm.intent !== patternResult.intent;
|
|
if (intentChanged) {
|
|
// Fields only ride along when they are meaningful for the NEW intent
|
|
// (a 'plex' appId under intent 'unknown' is meaningless — drop it).
|
|
return {
|
|
intent: llm.intent,
|
|
confidence: 0.85,
|
|
message: patternResult.message,
|
|
action: ACTIONS_BY_INTENT[llm.intent] ?? null,
|
|
response: null,
|
|
appId: (llm.intent === 'deploy' && llm.appId) ? llm.appId : undefined,
|
|
serviceId: (llm.intent === 'diagnose' && llm.serviceId) ? llm.serviceId : undefined,
|
|
categories: llm.intent === 'recommend'
|
|
? ((llm.categories && llm.categories.length) ? llm.categories : ['media-streaming'])
|
|
: undefined,
|
|
llmReply: llm.reply || undefined,
|
|
};
|
|
}
|
|
const merged = { ...patternResult };
|
|
merged.action = ACTIONS_BY_INTENT[llm.intent] ?? null;
|
|
if (llm.appId) merged.appId = llm.appId;
|
|
if (llm.serviceId && !merged.serviceId) merged.serviceId = llm.serviceId;
|
|
if (llm.intent === 'recommend') {
|
|
merged.categories = (llm.categories && llm.categories.length) ? llm.categories : (patternResult.categories || ['media-streaming']);
|
|
}
|
|
if (llm.reply) merged.llmReply = llm.reply;
|
|
return merged;
|
|
}
|
|
|
|
const DEFAULT_INTENT_MESSAGES = {
|
|
deploy: 'Ready to deploy.',
|
|
recommend: 'Here are some suggestions:',
|
|
diagnose: 'Let me check what\'s going on...',
|
|
health: 'Checking system health...',
|
|
list: 'Here are your services:',
|
|
backup: 'Creating a full system backup now...',
|
|
unknown: 'I\'m not sure what you\'d like to do — try the app catalog, or rephrase.',
|
|
};
|
|
|
|
// ─── Runtime config resolution ─────────────────────────────────────────────
|
|
// Priority: encrypted credential store (self-service Settings UI, key
|
|
// 'ai:llm') → env (AI_LLM_* / LLM_PROXY_URL). NEVER config.json: its GET
|
|
// endpoint returns the raw file to the browser, so secrets must not live
|
|
// there. Env fallback keeps headless installs working without the UI.
|
|
async function getLlmConfig(deps) {
|
|
const env = deps.env || {};
|
|
let stored = null;
|
|
if (deps.credentialManager) {
|
|
try {
|
|
const raw = await deps.credentialManager.retrieve('ai:llm');
|
|
if (raw) stored = typeof raw === 'string' ? JSON.parse(raw) : raw;
|
|
} catch (_) { /* not stored yet — env fallback */ }
|
|
}
|
|
const baseUrl = ((stored && stored.baseUrl) || env.AI_LLM_BASE_URL || env.LLM_PROXY_URL || '').trim();
|
|
const apiKey = ((stored && stored.apiKey) || env.AI_LLM_API_KEY || env.LLM_PROXY_API_KEY || '').trim();
|
|
const model = ((stored && stored.model) || env.AI_LLM_MODEL || 'gpt-4o-mini').trim();
|
|
if (!baseUrl || !apiKey) return null;
|
|
if (!/^https?:\/\//i.test(baseUrl)) return null;
|
|
const source = (stored && stored.baseUrl && stored.apiKey) ? 'credential-store' : 'env';
|
|
return { baseUrl, apiKey, model, source };
|
|
}
|
|
// sync alias retained for pure-callers/tests that never touch the store
|
|
function resolveLlmConfig({ env = {}, site = null } = {}) {
|
|
const ai = (site && site.ai) || {};
|
|
const llm = ai.llm || {};
|
|
const baseUrl = (llm.baseUrl || env.AI_LLM_BASE_URL || env.LLM_PROXY_URL || '').trim();
|
|
const apiKey = (llm.apiKey || env.AI_LLM_API_KEY || env.LLM_PROXY_API_KEY || '').trim();
|
|
const model = (llm.model || env.AI_LLM_MODEL || 'gpt-4o-mini').trim();
|
|
if (!baseUrl || !apiKey) return null;
|
|
if (!/^https?:\/\//i.test(baseUrl)) return null;
|
|
return { baseUrl, apiKey, model };
|
|
}
|
|
|
|
// ─── Intent Pattern Library (engine 2 — offline fallback; unchanged shapes) ─
|
|
|
|
const INTENT_PATTERNS = [
|
|
// ── Deploy intents ──
|
|
{
|
|
intent: 'deploy',
|
|
patterns: [
|
|
/\b(?:deploy|install|set up|setup|host|run|start|spin up|launch)\b.*\b(?:plex|jellyfin|emby|sonarr|radarr|nextcloud|gitea|vaultwarden|adguard|wireguard|home.assistant|grafana|prometheus|qbittorrent|transmission|portainer|redis|postgres|mariadb|mongodb|nginx)\b/i,
|
|
/\b(?:i want|i need|can you|help me|let'?s)\b.*\b(?:deploy|install|set up|host|run)\b/i,
|
|
],
|
|
action: 'dashcaddy_deploy_app',
|
|
extractApp: (msg) => {
|
|
const apps = ['plex', 'jellyfin', 'emby', 'sonarr', 'radarr', 'prowlarr',
|
|
'lidarr', 'readarr', 'qbittorrent', 'transmission', 'nextcloud',
|
|
'vaultwarden', 'gitea', 'adguard', 'pihole', 'wireguard',
|
|
'home assistant', 'homeassistant', 'grafana', 'prometheus',
|
|
'portainer', 'redis', 'postgres', 'postgresql', 'mariadb',
|
|
'mongodb', 'nginx', 'caddy', 'uptime kuma', 'code-server'];
|
|
for (const app of apps) {
|
|
if (msg.toLowerCase().includes(app)) return app.replace(/\s+/g, '-');
|
|
}
|
|
return null;
|
|
},
|
|
},
|
|
|
|
// ── Streaming/Media intents ──
|
|
{
|
|
intent: 'recommend',
|
|
patterns: [
|
|
/\b(?:stream|streaming|movie|movies|tv show|tv shows|film|films|watch|media)\b/i,
|
|
],
|
|
action: 'dashcaddy_wizard_recommend',
|
|
suggestCategories: ['media-streaming'],
|
|
response: (msg) => ({
|
|
message: 'For media streaming, I recommend:',
|
|
recommendations: [
|
|
{ app: 'plex', reason: 'Stream movies and TV shows to any device' },
|
|
{ app: 'jellyfin', reason: 'Free open-source alternative to Plex, no premium features locked' },
|
|
{ app: 'emby', reason: 'Media server with live TV and parental controls' },
|
|
{ app: 'sonarr', reason: 'Automatically download TV shows' },
|
|
{ app: 'radarr', reason: 'Automatically download movies' },
|
|
{ app: 'qbittorrent', reason: 'Download client for media files' },
|
|
],
|
|
question: 'Would you like me to deploy any of these?',
|
|
disclaimer: 'DashCaddy provides deployment tools only. Users are responsible for complying with all applicable copyright and intellectual property laws. Always stream content you own or have rights to access.',
|
|
}),
|
|
},
|
|
|
|
// ── Password manager ──
|
|
{
|
|
intent: 'recommend',
|
|
patterns: [
|
|
/\b(?:password|passwords|password manager|vaultwarden|bitwarden|1password|lastpass|secure password)\b/i,
|
|
],
|
|
action: 'dashcaddy_wizard_recommend',
|
|
suggestCategories: ['file-sync'],
|
|
response: (msg) => ({
|
|
message: 'For password management, I recommend:',
|
|
recommendations: [
|
|
{ app: 'vaultwarden', reason: 'Self-hosted Bitwarden-compatible password manager' },
|
|
],
|
|
question: 'Would you like me to deploy Vaultwarden?',
|
|
}),
|
|
},
|
|
|
|
// ── Ad blocking ──
|
|
{
|
|
intent: 'recommend',
|
|
patterns: [
|
|
/\b(?:ad block|adblock|block ads|ad blocking|pihole|adguard|dns blocking)\b/i,
|
|
],
|
|
action: 'dashcaddy_wizard_recommend',
|
|
suggestCategories: ['home-network'],
|
|
response: (msg) => ({
|
|
message: 'For network-wide ad blocking, I recommend:',
|
|
recommendations: [
|
|
{ app: 'adguard', reason: 'DNS-level ad blocking for your entire network' },
|
|
{ app: 'pihole', reason: 'Alternative DNS ad blocker with detailed statistics' },
|
|
],
|
|
question: 'Would you like me to set up ad blocking?',
|
|
}),
|
|
},
|
|
|
|
// ── File storage ──
|
|
{
|
|
intent: 'recommend',
|
|
patterns: [
|
|
/\b(?:file storage|cloud storage|google drive|dropbox|file sync|nextcloud|owncloud)\b/i,
|
|
],
|
|
action: 'dashcaddy_wizard_recommend',
|
|
suggestCategories: ['file-sync'],
|
|
response: (msg) => ({
|
|
message: 'For file storage and sync, I recommend:',
|
|
recommendations: [
|
|
{ app: 'nextcloud', reason: 'Self-hosted Google Drive replacement' },
|
|
],
|
|
question: 'Would you like me to deploy Nextcloud?',
|
|
}),
|
|
},
|
|
|
|
// ── Development ──
|
|
{
|
|
intent: 'recommend',
|
|
patterns: [
|
|
/\b(?:git|code|develop|programming|ide|vs code|github|self-hosted git)\b/i,
|
|
],
|
|
action: 'dashcaddy_wizard_recommend',
|
|
suggestCategories: ['development'],
|
|
response: (msg) => ({
|
|
message: 'For development tools, I recommend:',
|
|
recommendations: [
|
|
{ app: 'gitea', reason: 'Self-hosted Git with CI/CD pipelines' },
|
|
{ app: 'code-server', reason: 'VS Code in your browser' },
|
|
],
|
|
question: 'Would you like me to deploy any of these?',
|
|
}),
|
|
},
|
|
|
|
// ── Diagnostics ──
|
|
{
|
|
intent: 'diagnose',
|
|
patterns: [
|
|
/\b(?:why|what'?s wrong|broken|down|not working|slow|error|failing|crashed|unhealthy|diagnose|troubleshoot|debug)\b/i,
|
|
],
|
|
action: 'dashcaddy_diagnose',
|
|
extractService: (msg) => {
|
|
const match = msg.match(/(?:why is |is |)(\w+)\s+(?:down|slow|broken|not working|failing|crashed)/i);
|
|
if (match) return match[1].toLowerCase();
|
|
return null;
|
|
},
|
|
response: (msg) => ({
|
|
message: 'Let me check what\'s going on...',
|
|
action: 'diagnose',
|
|
}),
|
|
},
|
|
|
|
// ── Backup ──
|
|
{
|
|
intent: 'backup',
|
|
patterns: [
|
|
/\b(?:backup|back up|save|snapshot|export)\b/i,
|
|
],
|
|
action: 'dashcaddy_create_backup',
|
|
response: (msg) => ({
|
|
message: 'Creating a full system backup now...',
|
|
action: 'backup',
|
|
}),
|
|
},
|
|
|
|
// ── Health check ──
|
|
{
|
|
intent: 'health',
|
|
patterns: [
|
|
/\b(?:health|healthy|status|everything ok|all good|system check|how are things)\b/i,
|
|
],
|
|
action: 'dashcaddy_system_health',
|
|
response: (msg) => ({
|
|
message: 'Checking system health...',
|
|
action: 'health_check',
|
|
}),
|
|
},
|
|
|
|
// ── List/show ──
|
|
{
|
|
intent: 'list',
|
|
patterns: [
|
|
/\b(?:list|show|what.*running|what.*deployed|what.*have|what.*services)\b/i,
|
|
],
|
|
action: 'dashcaddy_list_services',
|
|
response: (msg) => ({
|
|
message: 'Here are your services:',
|
|
action: 'list_services',
|
|
}),
|
|
},
|
|
];
|
|
|
|
// ─── Pattern engine (pure, sync — the public routeIntent contract) ─────────
|
|
|
|
function routeIntent(message) {
|
|
for (const intent of INTENT_PATTERNS) {
|
|
for (const pattern of intent.patterns) {
|
|
if (pattern.test(message)) {
|
|
const result = {
|
|
intent: intent.intent,
|
|
confidence: 0.85,
|
|
action: intent.action,
|
|
message: message,
|
|
response: typeof intent.response === 'function' ? intent.response(message) : null,
|
|
};
|
|
|
|
if (intent.extractApp) {
|
|
const app = intent.extractApp(message);
|
|
if (app) result.appId = app;
|
|
}
|
|
if (intent.extractService) {
|
|
const service = intent.extractService(message);
|
|
if (service) result.serviceId = service;
|
|
}
|
|
if (intent.suggestCategories) {
|
|
result.categories = intent.suggestCategories;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
intent: 'unknown',
|
|
confidence: 0.3,
|
|
message,
|
|
response: {
|
|
message: 'I\'m not sure what you\'d like to do. Here are some things I can help with:',
|
|
suggestions: [
|
|
'Deploy an app: "Deploy Plex" or "Set up Nextcloud"',
|
|
'Get recommendations: "I want to stream movies" or "Block ads on my network"',
|
|
'Check status: "Is everything OK?" or "Why is Plex down?"',
|
|
'Browse catalog: "What can I self-host?"',
|
|
'Create backup: "Back up everything"',
|
|
],
|
|
action: 'suggest',
|
|
},
|
|
};
|
|
}
|
|
|
|
// ─── Enrichment shared by both engines (plans, wizard calls, reply merge) ──
|
|
function enrich(result) {
|
|
if (result.intent === 'deploy' && result.appId) {
|
|
const tpl = APP_TEMPLATES[result.appId];
|
|
result.appName = (tpl && tpl.name) || result.appId;
|
|
result.deployPlan = {
|
|
templateId: result.appId,
|
|
endpoint: 'POST /api/v1/discover/adopt',
|
|
body: {
|
|
containerId: null, // set after container creation
|
|
serviceId: result.appId,
|
|
name: result.appName,
|
|
port: (tpl && tpl.defaultPort) || null, // from template when known
|
|
generateDns: true,
|
|
generateRoute: true,
|
|
},
|
|
nextSteps: [
|
|
`Search catalog: GET /api/v1/catalog/search?q=${encodeURIComponent(result.appId)}`,
|
|
`Get template: GET /api/v1/catalog/${encodeURIComponent(result.appId)}`,
|
|
'Deploy: POST /api/v1/discover/adopt',
|
|
],
|
|
};
|
|
const baseMsg = result.response && result.response.message
|
|
? result.response.message
|
|
: (result.llmReply || DEFAULT_INTENT_MESSAGES.deploy);
|
|
result.response = { ...(result.response || {}), message: baseMsg, appId: result.appId, appName: result.appName };
|
|
} else if (result.intent === 'recommend' && result.categories) {
|
|
result.wizardCall = {
|
|
endpoint: 'POST /api/v1/wizard/recommend',
|
|
body: { categories: result.categories, hardwareProfile: 'medium' },
|
|
};
|
|
// pattern canned recs stay (they're curated); LLM reply rides along as
|
|
// llmReply for the UI's secondary line, and a message exists either way.
|
|
result.response = { ...(result.response || {}), message: (result.response && result.response.message) || result.llmReply || DEFAULT_INTENT_MESSAGES.recommend };
|
|
if (result.llmReply) result.response.llmReply = result.llmReply;
|
|
} else if (result.intent !== 'deploy') {
|
|
const baseMsg = (result.response && result.response.message)
|
|
? result.response.message
|
|
: (result.llmReply || DEFAULT_INTENT_MESSAGES[result.intent] || DEFAULT_INTENT_MESSAGES.unknown);
|
|
result.response = { ...(result.response || {}), message: baseMsg, suggestions: (result.response && result.response.suggestions) || undefined };
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// ─── Classification orchestration ──────────────────────────────────────────
|
|
async function classify({ message, history, deps }) {
|
|
const pattern = routeIntent(message);
|
|
const cfg = await getLlmConfig(deps);
|
|
if (!cfg) {
|
|
return { ...pattern, engine: 'pattern' };
|
|
}
|
|
|
|
const safeHistory = (Array.isArray(history) ? history : [])
|
|
.filter((h) => h && (h.role === 'user' || h.role === 'assistant') && typeof h.content === 'string')
|
|
.slice(-MAX_HISTORY);
|
|
const messages = [
|
|
{ role: 'system', content: buildSystemPrompt() },
|
|
...safeHistory,
|
|
{ role: 'user', content: message },
|
|
];
|
|
|
|
try {
|
|
const content = await callLlm(deps, cfg, messages);
|
|
const parsed = JSON.parse(repairParsed(content));
|
|
const validated = validateParsed(parsed);
|
|
if (!validated) throw new Error('LLM output failed schema validation');
|
|
deps.log.info('ai-intent', 'llm classified', { intent: validated.intent, appId: validated.appId });
|
|
const merged = mergeIntent(pattern, validated);
|
|
return { ...merged, engine: 'llm', model: cfg.model };
|
|
} catch (e) {
|
|
const reason = (e && e.name === 'AbortError') ? 'timeout' : (e && e.message) || 'unknown';
|
|
deps.log.warn('ai-intent', 'llm unavailable — pattern fallback', { reason: String(reason).slice(0, 200) });
|
|
return { ...pattern, engine: 'pattern', llmError: String(reason).slice(0, 200) };
|
|
}
|
|
}
|
|
|
|
// ─── Express Route ──────────────────────────────────────────────────────────
|
|
|
|
module.exports = function ({ asyncHandler, siteConfig = null, log = console, fetchImpl = null, env = process.env, credentialManager = null }) {
|
|
const wrap = asyncHandler || ((fn) => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next));
|
|
const router = express.Router();
|
|
const deps = {
|
|
siteConfig,
|
|
credentialManager,
|
|
log: (log && log.info && log.warn) ? log : { info: () => {}, warn: () => {}, error: () => {} },
|
|
fetchImpl,
|
|
env,
|
|
timeoutMs: Number(env.AI_LLM_TIMEOUT_MS) || LLM_TIMEOUT_MS,
|
|
};
|
|
|
|
/**
|
|
* POST /api/v1/ai/intent — natural language → structured action plan
|
|
*/
|
|
router.post('/ai/intent', wrap(async (req, res) => {
|
|
const { message, context = {} } = req.body || {};
|
|
let history = Array.isArray(req.body && req.body.history) ? req.body.history : [];
|
|
|
|
if (!message || typeof message !== 'string' || !message.trim()) {
|
|
return errorResponse(res, 400, 'message (string) is required');
|
|
}
|
|
const cleanMessage = message.trim().slice(0, MAX_INPUT);
|
|
|
|
// History: keep only role/content string pairs from the client (the
|
|
// panel's own transcript), bounded and sanitized. Prompt-injection is
|
|
// contained by the closed-vocabulary schema, not by trusting this data.
|
|
history = history
|
|
.filter((h) => h && (h.role === 'user' || h.role === 'assistant') && typeof h.content === 'string')
|
|
.slice(-MAX_HISTORY)
|
|
.map((h) => ({ role: h.role, content: sanitizeText(h.content, 400) }));
|
|
|
|
const result = await classify({ message: cleanMessage, history, deps });
|
|
result.context = context;
|
|
result.timestamp = new Date().toISOString();
|
|
enrich(result);
|
|
|
|
ok(res, result);
|
|
}));
|
|
|
|
/**
|
|
* GET /api/v1/ai/settings — LLM assistant configuration (key never echoed)
|
|
*/
|
|
router.get('/ai/settings', wrap(async (req, res) => {
|
|
const cfg = await getLlmConfig(deps);
|
|
ok(res, {
|
|
configured: Boolean(cfg),
|
|
source: cfg ? cfg.source : null,
|
|
baseUrl: cfg ? cfg.baseUrl : null,
|
|
model: cfg ? cfg.model : null,
|
|
hasApiKey: Boolean(cfg && cfg.apiKey),
|
|
});
|
|
}));
|
|
|
|
/**
|
|
* PUT /api/v1/ai/settings — store LLM assistant config in the ENCRYPTED
|
|
* credential store (key 'ai:llm'). Never config.json — GET /config returns
|
|
* the raw file to the browser. body: { baseUrl?, model?, apiKey? }; an
|
|
* empty apiKey string means "keep the stored one".
|
|
*/
|
|
router.put('/ai/settings', wrap(async (req, res) => {
|
|
if (!deps.credentialManager) {
|
|
return errorResponse(res, 503, 'Credential store unavailable — set AI_LLM_BASE_URL/AI_LLM_API_KEY env vars instead');
|
|
}
|
|
const { baseUrl = '', model = '', apiKey = '' } = req.body || {};
|
|
if (baseUrl && !/^https?:\/\//i.test(String(baseUrl).trim())) {
|
|
return errorResponse(res, 400, 'baseUrl must be an http(s) URL of an OpenAI-compatible endpoint');
|
|
}
|
|
let stored = null;
|
|
try {
|
|
const raw = await deps.credentialManager.retrieve('ai:llm');
|
|
if (raw) stored = typeof raw === 'string' ? JSON.parse(raw) : raw;
|
|
} catch (_) { /* fresh config */ }
|
|
stored = stored || {};
|
|
if (baseUrl) stored.baseUrl = String(baseUrl).trim();
|
|
if (model) stored.model = String(model).trim();
|
|
if (String(apiKey).trim()) stored.apiKey = String(apiKey).trim();
|
|
if (!stored.baseUrl || !stored.apiKey) {
|
|
return errorResponse(res, 400, 'baseUrl and apiKey are both required to enable the LLM engine (or clear with DELETE)');
|
|
}
|
|
await deps.credentialManager.store('ai:llm', JSON.stringify(stored), { label: 'AI assistant LLM config' });
|
|
log.info('ai-intent', 'LLM config saved', { model: stored.model });
|
|
ok(res, { saved: true, baseUrl: stored.baseUrl, model: stored.model, hasApiKey: true });
|
|
}));
|
|
|
|
/**
|
|
* DELETE /api/v1/ai/settings — remove stored config (falls back to env/pattern)
|
|
*/
|
|
router.delete('/ai/settings', wrap(async (req, res) => {
|
|
if (!deps.credentialManager) return errorResponse(res, 503, 'Credential store unavailable');
|
|
try { await deps.credentialManager.delete('ai:llm'); } catch (_) { /* already gone */ }
|
|
ok(res, { cleared: true });
|
|
}));
|
|
|
|
/**
|
|
* POST /api/v1/ai/settings/test — one-shot classify probe proving the LLM
|
|
* works end-to-end (returns engine + sample intent, never the key).
|
|
*/
|
|
router.post('/ai/settings/test', wrap(async (req, res) => {
|
|
const cfg = await getLlmConfig(deps);
|
|
if (!cfg) return ok(res, { ok: false, engine: 'pattern', reason: 'No LLM configured (store or env)' });
|
|
try {
|
|
const content = await callLlm(deps, cfg, [
|
|
{ role: 'system', content: buildSystemPrompt() },
|
|
{ role: 'user', content: 'Back up everything please' },
|
|
]);
|
|
const parsed = JSON.parse(repairParsed(content));
|
|
const validated = validateParsed(parsed);
|
|
if (!validated || !validated.intent) throw new Error('invalid classifier output');
|
|
// Contract proof: the fixed sample MUST classify as 'backup'. An
|
|
// 'unknown' here means the endpoint answers but the model/prompt is
|
|
// not actually doing DashCaddy classification — report it as a
|
|
// failure, not a pass.
|
|
if (validated.intent !== 'backup') {
|
|
return ok(res, { ok: false, engine: 'llm-error', reason: `sample misclassified: expected 'backup', got '${validated.intent}'` });
|
|
}
|
|
return ok(res, { ok: true, engine: 'llm', model: cfg.model, sample: { intent: validated.intent, reply: validated.reply } });
|
|
} catch (e) {
|
|
const reason = String((e && (e.name === 'AbortError' ? 'timeout' : e.message)) || 'error').slice(0, 200);
|
|
log.warn('ai-intent', 'LLM config test failed', { reason });
|
|
return ok(res, { ok: false, engine: 'llm-error', reason });
|
|
}
|
|
}));
|
|
|
|
/**
|
|
* GET /api/v1/ai/capabilities — what the AI can do + which engine is live
|
|
*/
|
|
router.get('/ai/capabilities', wrap(async (req, res) => {
|
|
const cfg = await getLlmConfig(deps);
|
|
ok(res, {
|
|
intents: INTENTS.filter((i) => i !== 'unknown'),
|
|
capabilities: [
|
|
{ name: 'deploy', description: 'Deploy self-hosted applications from the catalog (all 78 templates)' },
|
|
{ name: 'recommend', description: 'Get service recommendations based on goals' },
|
|
{ name: 'diagnose', description: 'Troubleshoot service issues' },
|
|
{ name: 'backup', description: 'Create full system backups' },
|
|
{ name: 'health', description: 'Check system and service health' },
|
|
{ name: 'list', description: 'List services and containers' },
|
|
],
|
|
tools: '17 MCP tools available via MCP protocol at /api/v1/mcp',
|
|
engine: cfg ? 'llm' : 'pattern',
|
|
llm: cfg ? { model: cfg.model, configured: true, source: cfg.source } : { configured: false, howToEnable: 'Dashboard → AI Assistant panel → ⚙ Settings (stored in the encrypted credential store), or env AI_LLM_BASE_URL + AI_LLM_API_KEY + AI_LLM_MODEL' },
|
|
exampleQueries: [
|
|
'Deploy Plex',
|
|
'I want a private YouTube for my TV',
|
|
'Block ads on my network',
|
|
'Why is Plex down?',
|
|
'Back up everything',
|
|
'What services am I running?',
|
|
],
|
|
});
|
|
}));
|
|
|
|
return router;
|
|
};
|
|
|
|
// ─── Pure exports (unit-test surface) ───────────────────────────────────────
|
|
module.exports.routeIntent = routeIntent;
|
|
module.exports.classify = classify;
|
|
module.exports.enrich = enrich;
|
|
module.exports.mergeIntent = mergeIntent;
|
|
module.exports.validateParsed = validateParsed;
|
|
module.exports.repairParsed = repairParsed;
|
|
module.exports.buildSystemPrompt = buildSystemPrompt;
|
|
module.exports.sanitizeText = sanitizeText;
|
|
module.exports.resolveLlmConfig = resolveLlmConfig;
|
|
module.exports.INTENTS = INTENTS;
|
|
module.exports.TEMPLATE_IDS = TEMPLATE_IDS;
|
|
module.exports.MAX_INPUT = MAX_INPUT;
|