lynkr 9.0.1 → 9.1.2

package/src/api/files-multipart.js

@@ -0,0 +1,30 @@
+function parseMultipart(buffer, boundary) {
+  const boundaryStr = `--${boundary}`;
+  const str = buffer.toString("latin1");
+  const parts = str.split(boundaryStr).filter((p) => p.trim() && p.trim() !== "--");
+  let file = null;
+  let filename = null;
+  let mimeType = null;
+  let purpose = null;
+
+  for (const part of parts) {
+    const headerEnd = part.indexOf("\r\n\r\n");
+    if (headerEnd === -1) continue;
+    const headers = part.substring(0, headerEnd);
+    const body = part.substring(headerEnd + 4).replace(/\r\n$/, "");
+
+    if (headers.includes('name="purpose"')) {
+      purpose = body.trim();
+    } else if (headers.includes('name="file"') || headers.includes("filename=")) {
+      const fnMatch = headers.match(/filename="([^"]+)"/);
+      if (fnMatch) filename = fnMatch[1];
+      const ctMatch = headers.match(/Content-Type:\s*(.+)/i);
+      if (ctMatch) mimeType = ctMatch[1].trim();
+      file = Buffer.from(body, "latin1");
+    }
+  }
+
+  return { file, filename, mimeType, purpose };
+}
+
+module.exports = { parseMultipart };

package/src/api/files-router.js

@@ -0,0 +1,81 @@
+const express = require("express");
+const logger = require("../logger");
+const fileStore = require("../stores/file-store");
+
+const router = express.Router();
+
+const MAX_FILE_SIZE = parseInt(process.env.FILES_MAX_SIZE_MB || "100", 10) * 1024 * 1024;
+
+router.post("/files", async (req, res) => {
+  try {
+    const chunks = [];
+    let totalSize = 0;
+    for await (const chunk of req) {
+      totalSize += chunk.length;
+      if (totalSize > MAX_FILE_SIZE) {
+        return res.status(413).json({ error: { message: `File exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit` } });
+      }
+      chunks.push(chunk);
+    }
+    const buffer = Buffer.concat(chunks);
+
+    const contentType = req.headers["content-type"] || "";
+    let filename = "upload";
+    let purpose = "assistants";
+    let mimeType = "application/octet-stream";
+
+    if (contentType.includes("multipart/form-data")) {
+      const boundary = contentType.split("boundary=")[1];
+      if (boundary) {
+        const { parseMultipart } = require("./files-multipart");
+        const parsed = parseMultipart(buffer, boundary);
+        if (parsed.file) {
+          filename = parsed.filename || filename;
+          mimeType = parsed.mimeType || mimeType;
+          purpose = parsed.purpose || purpose;
+          const entry = await fileStore.storeFile(parsed.file, { filename, purpose, mimeType });
+          return res.json(entry);
+        }
+      }
+    }
+
+    // Raw body upload
+    mimeType = contentType.split(";")[0].trim() || mimeType;
+    filename = req.headers["x-filename"] || filename;
+    purpose = req.query.purpose || purpose;
+    const entry = await fileStore.storeFile(buffer, { filename, purpose, mimeType });
+    res.json(entry);
+  } catch (err) {
+    logger.error({ err }, "File upload failed");
+    res.status(500).json({ error: { message: err.message } });
+  }
+});
+
+router.get("/files", (req, res) => {
+  const files = fileStore.listFiles({ purpose: req.query.purpose });
+  res.json({ object: "list", data: files });
+});
+
+router.get("/files/:id", (req, res) => {
+  const file = fileStore.getFile(req.params.id);
+  if (!file) return res.status(404).json({ error: { message: "File not found" } });
+  res.json(file);
+});
+
+router.get("/files/:id/content", async (req, res) => {
+  const file = fileStore.getFile(req.params.id);
+  if (!file) return res.status(404).json({ error: { message: "File not found" } });
+  const content = await fileStore.getFileContent(req.params.id);
+  if (!content) return res.status(404).json({ error: { message: "File content not found" } });
+  res.setHeader("Content-Type", file.mime_type);
+  res.setHeader("Content-Disposition", `attachment; filename="${file.filename}"`);
+  res.send(content);
+});
+
+router.delete("/files/:id", async (req, res) => {
+  const deleted = await fileStore.deleteFile(req.params.id);
+  if (!deleted) return res.status(404).json({ error: { message: "File not found" } });
+  res.json({ id: req.params.id, object: "file", deleted: true });
+});
+
+module.exports = router;

package/src/api/middleware/budget.js

@@ -57,12 +57,30 @@ function budgetMiddleware(req, res, next) {
     }, 'Budget warning: approaching limits');
   }
 
-  // Attach budget info to request for usage recording later
   req.budgetInfo = {
     userId,
     budgetCheck,
+    startTime: Date.now(),
   };
 
+  // Record usage after response completes
+  res.on('finish', () => {
+    try {
+      const usage = res.locals.usage;
+      if (!usage) return;
+      budgetManager.recordUsage(userId, req.session?.id || null, {
+        tokensInput: usage.prompt_tokens || usage.input_tokens || 0,
+        tokensOutput: usage.completion_tokens || usage.output_tokens || 0,
+        costUsd: usage.cost_usd || 0,
+        model: usage.model || null,
+        endpoint: req.path,
+        latencyMs: Date.now() - req.budgetInfo.startTime,
+      });
+    } catch (err) {
+      logger.warn({ err: err.message }, 'Failed to record usage after response');
+    }
+  });
+
   next();
 }
 

package/src/api/middleware/load-shedding.js

@@ -1,3 +1,4 @@
+const os = require("os");
 const logger = require("../../logger");
 const { ServiceUnavailableError } = require("./error-handling");
 
@@ -55,6 +56,20 @@ class LoadShedder {
       return true;
     }
 
+    // Check RSS / system memory
+    const rssPercent = memUsage.rss / os.totalmem();
+    if (rssPercent > this.memoryThreshold) {
+      logger.warn(
+        {
+          rssPercent: (rssPercent * 100).toFixed(2),
+          threshold: (this.memoryThreshold * 100).toFixed(2),
+        },
+        "Load shedding: RSS memory usage exceeded threshold"
+      );
+      this.cachedOverloadState = true;
+      return true;
+    }
+
     // Check active requests
     if (this.activeRequests > this.activeRequestsThreshold) {
       logger.warn(
@@ -81,8 +96,10 @@ class LoadShedder {
       activeRequests: this.activeRequests,
       totalShed: this.totalShed,
       heapUsedPercent: ((memUsage.heapUsed / memUsage.heapTotal) * 100).toFixed(2),
+      rssPercent: ((memUsage.rss / os.totalmem()) * 100).toFixed(2),
       thresholds: {
         heapThreshold: (this.heapThreshold * 100).toFixed(2),
+        memoryThreshold: (this.memoryThreshold * 100).toFixed(2),
         activeRequestsThreshold: this.activeRequestsThreshold,
       },
     };