lynkr 9.0.1 → 9.1.2

package/src/routing/risk-analyzer.js

@@ -0,0 +1,194 @@
+/**
+ * Risk Analyzer
+ *
+ * Scores a request along a risk axis that is orthogonal to complexity.
+ * A trivially short edit to `auth/middleware.ts` is still high risk and
+ * should not be served by a cheap local model.
+ *
+ * @module routing/risk-analyzer
+ */
+
+const { extractContent } = require('./complexity-analyzer');
+
+// Substring keywords found in file paths or instruction text.
+// Matched case-insensitively as raw substrings, so "auth" hits
+// "src/auth/login.ts" and "authentication".
+const PROTECTED_PATH_KEYWORDS = [
+  'auth', 'oauth', 'jwt', 'session', 'security', 'permission', 'rbac',
+  'payment', 'payments', 'billing', 'invoice', 'subscription',
+  'migration', 'migrations', 'schema',
+  'infra', 'terraform', 'kustomize', 'helm', 'kubernetes',
+  '.github/workflows', '.env', 'secret', 'credential',
+  'api-key', 'api_key', 'apikey', 'token',
+  'webhook', 'admin',
+];
+
+// Whole-word instruction keywords that signal sensitive intent regardless
+// of which files are involved. Higher signal than path keywords because
+// they reflect what the user is *asking for*.
+const HIGH_RISK_INSTRUCTION_KEYWORDS = [
+  'authentication', 'authorization', 'permission', 'security',
+  'payment', 'billing', 'migration', 'database schema',
+  'encrypt', 'decrypt', 'secret', 'credential', 'api key',
+  'production', 'deploy', 'rollout', 'rollback',
+];
+
+// Path-extracting patterns. We look at:
+//   1. Anything that looks like a file path inside the instruction text.
+//   2. Explicit path-like fields in tool inputs (e.g. tool_use blocks).
+const PATH_LIKE_RE = /(?:^|[\s`'"([])([./a-zA-Z0-9_-]+\.[a-zA-Z0-9]{1,8})(?=[\s`'")\]:,;]|$)/g;
+const SLASHED_PATH_RE = /(?:^|[\s`'"([])((?:[a-zA-Z0-9_.-]+\/)+[a-zA-Z0-9_.-]+)(?=[\s`'")\]:,;]|$)/g;
+
+/**
+ * Pull every path-shaped substring out of free-form text.
+ * @param {string} text
+ * @returns {string[]}
+ */
+function extractPathsFromText(text) {
+  if (!text) return [];
+  const out = new Set();
+  let m;
+  while ((m = PATH_LIKE_RE.exec(text)) !== null) {
+    out.add(m[1]);
+  }
+  while ((m = SLASHED_PATH_RE.exec(text)) !== null) {
+    out.add(m[1]);
+  }
+  return Array.from(out);
+}
+
+/**
+ * Walk every tool_use block in the conversation and collect any string
+ * inputs that look like paths. Catches cases where the model already
+ * called an Edit/Read tool on a sensitive file.
+ * @param {object} payload
+ * @returns {string[]}
+ */
+function extractPathsFromToolUses(payload) {
+  const out = new Set();
+  const messages = payload?.messages;
+  if (!Array.isArray(messages)) return [];
+
+  for (const msg of messages) {
+    if (!Array.isArray(msg?.content)) continue;
+    for (const block of msg.content) {
+      if (block?.type !== 'tool_use' || !block.input) continue;
+      const stack = [block.input];
+      while (stack.length) {
+        const node = stack.pop();
+        if (typeof node === 'string') {
+          if (node.includes('/') || node.includes('.')) {
+            // Treat short tool-input strings that look path-y as paths.
+            if (node.length <= 200) out.add(node);
+          }
+        } else if (Array.isArray(node)) {
+          for (const v of node) stack.push(v);
+        } else if (node && typeof node === 'object') {
+          for (const v of Object.values(node)) stack.push(v);
+        }
+      }
+    }
+  }
+  return Array.from(out);
+}
+
+/**
+ * Find which keywords from `keywords` appear (case-insensitively) inside
+ * any of `haystack`. Substring match — by design — so "auth" matches
+ * both "src/auth/login.ts" and the word "authorization".
+ * @param {string[]} keywords
+ * @param {string[]} haystack
+ * @returns {string[]} hit keywords, sorted
+ */
+function findHits(keywords, haystack) {
+  const hits = new Set();
+  const joined = haystack.join('\n').toLowerCase();
+  for (const kw of keywords) {
+    if (joined.includes(kw.toLowerCase())) hits.add(kw);
+  }
+  return Array.from(hits).sort();
+}
+
+/**
+ * Analyze the risk level of a request.
+ *
+ * Risk is orthogonal to complexity:
+ *   - low    → no protected paths or sensitive keywords detected
+ *   - medium → protected paths *or* a read-only task on a protected area
+ *   - high   → instruction explicitly names sensitive domain logic,
+ *              or protected paths combined with a write-intent task
+ *
+ * @param {object} payload - Anthropic-format request payload
+ * @returns {{ level: 'low'|'medium'|'high',
+ *             reason: string,
+ *             pathHits: string[],
+ *             instructionHits: string[],
+ *             paths: string[] }}
+ */
+function analyzeRisk(payload) {
+  const instructionText = extractContent(payload) || '';
+  const lowText = instructionText.toLowerCase();
+
+  const textPaths = extractPathsFromText(instructionText);
+  const toolPaths = extractPathsFromToolUses(payload);
+  const allPaths = Array.from(new Set([...textPaths, ...toolPaths]));
+
+  // Instruction-level hits scan the raw text. Path-level hits scan only
+  // the extracted path strings so phrases like "authentication is hard"
+  // don't double-fire as a path hit.
+  const instructionHits = findHits(HIGH_RISK_INSTRUCTION_KEYWORDS, [instructionText]);
+  const pathHits = findHits(PROTECTED_PATH_KEYWORDS, allPaths.length ? allPaths : []);
+  // Also let path keywords match against the instruction text — covers
+  // "update the auth flow" with no path mentioned.
+  const textPathHits = findHits(PROTECTED_PATH_KEYWORDS, [instructionText]);
+  const mergedPathHits = Array.from(new Set([...pathHits, ...textPathHits])).sort();
+
+  if (instructionHits.length > 0) {
+    return {
+      level: 'high',
+      reason: 'High-risk instruction keyword detected.',
+      pathHits: mergedPathHits,
+      instructionHits,
+      paths: allPaths,
+    };
+  }
+
+  if (mergedPathHits.length > 0) {
+    // Read-only intent on a protected area is medium, not high.
+    // Heuristic: presence of explain/summarize/read verbs.
+    const readOnly = /\b(explain|summarize|describe|what does|walk me through|read|show|list|search|find|grep|locate)\b/i.test(lowText);
+    if (readOnly) {
+      return {
+        level: 'medium',
+        reason: 'Protected paths involved but task appears read-only.',
+        pathHits: mergedPathHits,
+        instructionHits: [],
+        paths: allPaths,
+      };
+    }
+    return {
+      level: 'high',
+      reason: 'Protected path referenced with write-capable intent.',
+      pathHits: mergedPathHits,
+      instructionHits: [],
+      paths: allPaths,
+    };
+  }
+
+  return {
+    level: 'low',
+    reason: 'No risk signals detected.',
+    pathHits: [],
+    instructionHits: [],
+    paths: allPaths,
+  };
+}
+
+module.exports = {
+  analyzeRisk,
+  PROTECTED_PATH_KEYWORDS,
+  HIGH_RISK_INSTRUCTION_KEYWORDS,
+  // Exposed for tests
+  extractPathsFromText,
+  extractPathsFromToolUses,
+};

package/src/routing/telemetry.js

@@ -105,6 +105,9 @@ function init() {
 
       CREATE INDEX IF NOT EXISTS idx_telemetry_timestamp
         ON routing_telemetry(timestamp);
+
+      CREATE INDEX IF NOT EXISTS idx_telemetry_session_id
+        ON routing_telemetry(session_id, timestamp);
     `);
 
     logger.info({ dbPath }, "Routing telemetry database initialised");
@@ -233,6 +236,10 @@ function query(filters = {}) {
     clauses.push("timestamp >= @since");
     params.since = filters.since;
   }
+  if (filters.session_id) {
+    clauses.push("session_id = @session_id");
+    params.session_id = filters.session_id;
+  }
 
   const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
   const limit = filters.limit ?? 100;
@@ -454,11 +461,49 @@ function cleanup(olderThanMs) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// In-memory stats cache (avoids SQLite queries on every /v1/routing/stats hit)
+// ---------------------------------------------------------------------------
+
+const STATS_CACHE_TTL = 5000; // 5 seconds
+let statsCache = null;
+let statsCacheTs = 0;
+
+function getStatsCached(timeRange = {}) {
+  const now = Date.now();
+  // Use cache for default time range (last 24h) — custom ranges bypass cache
+  if (!timeRange.since && !timeRange.until && statsCache && now - statsCacheTs < STATS_CACHE_TTL) {
+    return statsCache;
+  }
+  const result = getStats(timeRange);
+  if (!timeRange.since && !timeRange.until) {
+    statsCache = result;
+    statsCacheTs = now;
+  }
+  return result;
+}
+
+let providerStatsCache = new Map();
+let providerStatsCacheTs = 0;
+
+function getProviderStatsCached(provider, timeRange = {}) {
+  const now = Date.now();
+  if (!timeRange.since && !timeRange.until && providerStatsCache.has(provider) && now - providerStatsCacheTs < STATS_CACHE_TTL) {
+    return providerStatsCache.get(provider);
+  }
+  const result = getProviderStats(provider, timeRange);
+  if (!timeRange.since && !timeRange.until) {
+    providerStatsCache.set(provider, result);
+    providerStatsCacheTs = now;
+  }
+  return result;
+}
+
 module.exports = {
   record,
   query,
-  getStats,
-  getProviderStats,
+  getStats: getStatsCached,
+  getProviderStats: getProviderStatsCached,
   getRoutingAccuracy,
   cleanup,
 };

package/src/server.js

@@ -147,6 +147,13 @@ function createApp() {
 
   app.use(router);
 
+  // Dashboard UI
+  app.use('/dashboard', require('./dashboard/router'));
+
+  // Files API
+  const filesRouter = require("./api/files-router");
+  app.use("/v1", filesRouter);
+
   // 404 handler (must be after all routes)
   app.use(notFoundHandler);
 
@@ -195,6 +202,14 @@ async function start() {
   const provider = config.modelProvider?.type?.toLowerCase();
   if (provider === "ollama" || config.tiersReferenceOllama()) {
     await waitForOllama();
+
+    // Pre-probe Ollama's Anthropic API at startup (avoids 1-3s cold-start on first request)
+    try {
+      const { hasAnthropicEndpoint } = require("./clients/ollama-utils");
+      await hasAnthropicEndpoint(config.ollama.endpoint);
+    } catch (err) {
+      logger.debug({ err: err.message }, "Ollama Anthropic endpoint probe failed at startup");
+    }
   }
 
   const server = app.listen(config.port, () => {

package/src/stores/file-store.js

@@ -0,0 +1,104 @@
+const fs = require("fs");
+const fsp = require("fs").promises;
+const path = require("path");
+const crypto = require("crypto");
+const logger = require("../logger");
+
+const STORAGE_DIR = path.resolve(process.env.FILES_STORAGE_PATH || "./data/files");
+const METADATA_FILE = path.join(STORAGE_DIR, "_metadata.json");
+const MAX_FILES = parseInt(process.env.FILES_MAX_COUNT || "1000", 10);
+
+const metadata = new Map();
+
+function ensureStorageDir() {
+  if (!fs.existsSync(STORAGE_DIR)) {
+    fs.mkdirSync(STORAGE_DIR, { recursive: true });
+  }
+}
+
+function persistMetadata() {
+  try {
+    const entries = Array.from(metadata.values());
+    fs.writeFileSync(METADATA_FILE, JSON.stringify(entries), "utf8");
+  } catch (err) {
+    logger.warn({ err: err.message }, "Failed to persist file metadata");
+  }
+}
+
+function loadMetadata() {
+  ensureStorageDir();
+  try {
+    if (!fs.existsSync(METADATA_FILE)) return;
+    const entries = JSON.parse(fs.readFileSync(METADATA_FILE, "utf8"));
+    for (const entry of entries) {
+      // Only restore entries whose backing file still exists on disk
+      if (fs.existsSync(entry.storage_path)) {
+        metadata.set(entry.id, entry);
+      } else {
+        logger.debug({ fileId: entry.id }, "Dropping orphaned metadata entry (file missing)");
+      }
+    }
+    logger.info({ count: metadata.size }, "File metadata restored from disk");
+  } catch (err) {
+    logger.warn({ err: err.message }, "Could not load file metadata; starting fresh");
+  }
+}
+
+// Restore metadata at module load so restarts don't orphan files
+loadMetadata();
+
+async function storeFile(buffer, { filename, purpose, mimeType }) {
+  ensureStorageDir();
+  if (metadata.size >= MAX_FILES) {
+    const oldest = metadata.keys().next().value;
+    await deleteFile(oldest);
+  }
+  const id = `file-${crypto.randomUUID()}`;
+  const storagePath = path.join(STORAGE_DIR, id);
+  await fsp.writeFile(storagePath, buffer);
+  const entry = {
+    id,
+    object: "file",
+    filename: filename || "upload",
+    purpose: purpose || "assistants",
+    bytes: buffer.length,
+    mime_type: mimeType || "application/octet-stream",
+    created_at: Math.floor(Date.now() / 1000),
+    storage_path: storagePath,
+  };
+  metadata.set(id, entry);
+  persistMetadata();
+  logger.info({ fileId: id, bytes: buffer.length, filename }, "File stored");
+  return entry;
+}
+
+function getFile(id) {
+  return metadata.get(id) || null;
+}
+
+async function getFileContent(id) {
+  const entry = metadata.get(id);
+  if (!entry) return null;
+  try {
+    return await fsp.readFile(entry.storage_path);
+  } catch {
+    return null;
+  }
+}
+
+async function deleteFile(id) {
+  const entry = metadata.get(id);
+  if (!entry) return false;
+  try { await fsp.unlink(entry.storage_path); } catch {}
+  metadata.delete(id);
+  persistMetadata();
+  return true;
+}
+
+function listFiles({ purpose } = {}) {
+  const files = Array.from(metadata.values());
+  if (purpose) return files.filter((f) => f.purpose === purpose);
+  return files;
+}
+
+module.exports = { storeFile, getFile, getFileContent, deleteFile, listFiles };

package/src/stores/response-store.js

@@ -0,0 +1,25 @@
+const MAX_ENTRIES = 1000;
+
+const store = new Map();
+
+function storeResponse(id, data) {
+  if (store.size >= MAX_ENTRIES) {
+    const oldest = store.keys().next().value;
+    store.delete(oldest);
+  }
+  store.set(id, { ...data, createdAt: Date.now() });
+}
+
+function getResponse(id) {
+  return store.get(id) || null;
+}
+
+function deleteResponse(id) {
+  return store.delete(id);
+}
+
+function size() {
+  return store.size;
+}
+
+module.exports = { storeResponse, getResponse, deleteResponse, size };

package/src/tools/index.js

@@ -34,7 +34,7 @@ const TOOL_ALIASES = {
   webagent: "web_agent",
   WebAgent: "web_agent",
   tinyfish: "web_agent",
-  task: "fs_write",
+  task: "Task",
   write: "fs_write",
   filewrite: "fs_write",
   read: "fs_read",

package/src/tools/smart-selection.js

@@ -280,9 +280,18 @@ function selectToolsSmartly(tools, classification, options = {}) {
 
   // Get relevant tool names for this request type
   const relevantToolNames = TOOL_SELECTION_MAP[requestType] || TOOL_SELECTION_MAP.coding;
+  const relevantLower = new Set(relevantToolNames.map(n => n.toLowerCase()));
 
-  // Filter to relevant tools only
-  let selectedTools = tools.filter(tool => relevantToolNames.includes(tool.name));
+  // Filter to relevant tools only (case-insensitive match so external clients
+  // using lowercase names like Pi's `bash`/`read` aren't filtered out)
+  let selectedTools = tools.filter(tool => relevantLower.has(String(tool.name || '').toLowerCase()));
+
+  // If nothing matched, the caller is using a tool ecosystem we don't recognize
+  // (e.g. Pi's read/write/edit/bash). Pass tools through untouched rather than
+  // deleting them — otherwise the LLM gets no schema and hallucinates defaults.
+  if (selectedTools.length === 0) {
+    return tools;
+  }
 
   // Mode-specific adjustments
   if (config.mode === 'aggressive') {

package/src/tools/web.js

@@ -152,7 +152,7 @@ function summariseResult(item) {
   return {
     title: item.title ?? item.name ?? null,
     url: item.url ?? item.link ?? null,
-    snippet: item.snippet ?? item.summary ?? item.excerpt ?? null,
+    snippet: item.snippet ?? item.content ?? item.summary ?? item.excerpt ?? null,
     score: item.score ?? item.rank ?? null,
     source: item.source ?? null,
     metadata: item.metadata ?? null,