@seedvault/server 0.1.5 → 0.2.1

package/dist/server.js

@@ -6,7 +6,7 @@ import { mkdir } from "fs/promises";
 
 // src/db.ts
 import { Database } from "bun:sqlite";
-import { randomUUID } from "crypto";
+import { randomBytes, randomUUID } from "crypto";
 var db;
 function getDb() {
   if (!db)
@@ -50,6 +50,17 @@ function initDb(dbPath) {
       PRIMARY KEY (contributor, path),
       FOREIGN KEY (contributor) REFERENCES contributors(username)
     );
+
+    CREATE TABLE IF NOT EXISTS activity (
+      id TEXT PRIMARY KEY,
+      contributor TEXT NOT NULL REFERENCES contributors(username),
+      action TEXT NOT NULL,
+      detail TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_activity_contributor ON activity(contributor);
+    CREATE INDEX IF NOT EXISTS idx_activity_created_at ON activity(created_at);
+    CREATE INDEX IF NOT EXISTS idx_activity_action ON activity(action);
   `);
   const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='items_fts'").get();
   if (!hasFts) {
@@ -137,8 +148,11 @@ function deleteContributor(username) {
   const exists = d.prepare("SELECT 1 FROM contributors WHERE username = ?").get(username);
   if (!exists)
     return false;
+  d.prepare("DELETE FROM activity WHERE contributor = ?").run(username);
   d.prepare("DELETE FROM items WHERE contributor = ?").run(username);
   d.prepare("DELETE FROM api_keys WHERE contributor = ?").run(username);
+  d.prepare("UPDATE invites SET used_by = NULL WHERE used_by = ?").run(username);
+  d.prepare("DELETE FROM invites WHERE created_by = ?").run(username);
   d.prepare("DELETE FROM contributors WHERE username = ?").run(username);
   return true;
 }
@@ -208,7 +222,12 @@ function upsertItem(contributor, path, content, originCtime, originMtime) {
        VALUES (?, ?, ?, ?, ?)
        ON CONFLICT (contributor, path) DO UPDATE SET
          content = excluded.content,
-         modified_at = excluded.modified_at`).run(contributor, path, content, createdAt, modifiedAt);
+         modified_at = excluded.modified_at,
+         created_at = CASE
+           WHEN excluded.created_at < items.created_at
+           THEN excluded.created_at
+           ELSE items.created_at
+         END`).run(contributor, path, content, createdAt, modifiedAt);
   return getItem(contributor, path);
 }
 function getItem(contributor, path) {
@@ -252,6 +271,33 @@ function searchItems(query, contributor, limit = 10) {
        ORDER BY rank
        LIMIT ?`).all(query, limit);
 }
+function createActivityEvent(contributor, action, detail) {
+  const id = `act_${randomBytes(6).toString("hex")}`;
+  const now = new Date().toISOString();
+  const detailJson = detail ? JSON.stringify(detail) : null;
+  getDb().prepare("INSERT INTO activity (id, contributor, action, detail, created_at) VALUES (?, ?, ?, ?, ?)").run(id, contributor, action, detailJson, now);
+  return { id, contributor, action, detail: detailJson, created_at: now };
+}
+function listActivityEvents(opts) {
+  const conditions = [];
+  const params = [];
+  if (opts?.contributor) {
+    conditions.push("contributor = ?");
+    params.push(opts.contributor);
+  }
+  if (opts?.action) {
+    conditions.push("action = ?");
+    params.push(opts.action);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = opts?.limit ?? 50;
+  const offset = opts?.offset ?? 0;
+  params.push(limit, offset);
+  return getDb().prepare(`SELECT id, contributor, action, detail, created_at
+       FROM activity ${where}
+       ORDER BY created_at DESC
+       LIMIT ? OFFSET ?`).all(...params);
+}
 
 class ItemTooLargeError extends Error {
   size;
@@ -1786,9 +1832,9 @@ import { readFileSync } from "fs";
 import { resolve } from "path";
 
 // src/auth.ts
-import { createHash, randomBytes } from "crypto";
+import { createHash, randomBytes as randomBytes2 } from "crypto";
 function generateToken() {
-  return `sv_${randomBytes(16).toString("hex")}`;
+  return `sv_${randomBytes2(16).toString("hex")}`;
 }
 function hashToken(raw2) {
   return createHash("sha256").update(raw2).digest("hex");
@@ -1847,9 +1893,161 @@ data: ${JSON.stringify(data)}
   }
 }
 
+// src/diff.ts
+var DIFF_MAX_BYTES = 5000;
+function computeDiff(oldText, newText) {
+  if (oldText === newText)
+    return null;
+  if (oldText === "")
+    return null;
+  const oldLines = oldText.split(`
+`);
+  const newLines = newText.split(`
+`);
+  const editScript = myersDiff(oldLines, newLines);
+  const hunks = buildHunks(editScript, oldLines, newLines, 3);
+  let diff = "";
+  let truncated = false;
+  for (const hunk of hunks) {
+    const header = `@@ -${hunk.oldStart},${hunk.oldCount}` + ` +${hunk.newStart},${hunk.newCount} @@
+`;
+    diff += header;
+    for (const line of hunk.lines) {
+      diff += line + `
+`;
+    }
+    if (diff.length > DIFF_MAX_BYTES) {
+      diff = diff.slice(0, DIFF_MAX_BYTES);
+      truncated = true;
+      break;
+    }
+  }
+  return { diff, truncated };
+}
+function myersDiff(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const max = n + m;
+  const vSize = 2 * max + 1;
+  const v = new Int32Array(vSize);
+  v.fill(-1);
+  const offset = max;
+  v[offset + 1] = 0;
+  const trace = [];
+  outer:
+    for (let d = 0;d <= max; d++) {
+      trace.push(v.slice());
+      for (let k = -d;k <= d; k += 2) {
+        let x2;
+        if (k === -d || k !== d && v[offset + k - 1] < v[offset + k + 1]) {
+          x2 = v[offset + k + 1];
+        } else {
+          x2 = v[offset + k - 1] + 1;
+        }
+        let y2 = x2 - k;
+        while (x2 < n && y2 < m && a[x2] === b[y2]) {
+          x2++;
+          y2++;
+        }
+        v[offset + k] = x2;
+        if (x2 >= n && y2 >= m)
+          break outer;
+      }
+    }
+  const edits = [];
+  let x = n;
+  let y = m;
+  for (let d = trace.length - 1;d >= 0; d--) {
+    const tv = trace[d];
+    const k = x - y;
+    let prevK;
+    if (k === -d || k !== d && tv[offset + k - 1] < tv[offset + k + 1]) {
+      prevK = k + 1;
+    } else {
+      prevK = k - 1;
+    }
+    const prevX = tv[offset + prevK];
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      x--;
+      y--;
+      edits.push({ op: 0 /* Equal */, oldIdx: x, newIdx: y });
+    }
+    if (d > 0) {
+      if (x === prevX) {
+        edits.push({ op: 1 /* Insert */, oldIdx: x, newIdx: prevY });
+        y--;
+      } else {
+        edits.push({ op: 2 /* Delete */, oldIdx: prevX, newIdx: y });
+        x--;
+      }
+    }
+  }
+  edits.reverse();
+  return edits;
+}
+function buildHunks(edits, oldLines, newLines, context) {
+  const hunks = [];
+  let i = 0;
+  while (i < edits.length) {
+    while (i < edits.length && edits[i].op === 0 /* Equal */)
+      i++;
+    if (i >= edits.length)
+      break;
+    let start = i;
+    for (let c = 0;c < context && start > 0; c++)
+      start--;
+    let end = i;
+    while (end < edits.length) {
+      if (edits[end].op !== 0 /* Equal */) {
+        end++;
+        continue;
+      }
+      let run = 0;
+      let j = end;
+      while (j < edits.length && edits[j].op === 0 /* Equal */) {
+        run++;
+        j++;
+      }
+      if (j >= edits.length || run > context * 2) {
+        end = Math.min(end + context, edits.length);
+        break;
+      }
+      end = j;
+    }
+    const hunkEdits = edits.slice(start, end);
+    const firstEdit = hunkEdits[0];
+    let oldStart = firstEdit.oldIdx + 1;
+    let newStart = firstEdit.newIdx + 1;
+    let oldCount = 0;
+    let newCount = 0;
+    const lines = [];
+    for (const e of hunkEdits) {
+      if (e.op === 0 /* Equal */) {
+        lines.push(" " + oldLines[e.oldIdx]);
+        oldCount++;
+        newCount++;
+      } else if (e.op === 2 /* Delete */) {
+        lines.push("-" + oldLines[e.oldIdx]);
+        oldCount++;
+      } else {
+        lines.push("+" + newLines[e.newIdx]);
+        newCount++;
+      }
+    }
+    hunks.push({ oldStart, oldCount, newStart, newCount, lines });
+    i = end;
+  }
+  return hunks;
+}
+
 // src/routes.ts
 var uiPath = resolve(import.meta.dirname, "index.html");
 var isDev = true;
+function logActivity(contributor, action, detail) {
+  const event = createActivityEvent(contributor, action, detail);
+  broadcast("activity", event);
+}
 var uiHtmlCached = readFileSync(uiPath, "utf-8");
 function extractFileInfo(reqPath) {
   const raw2 = reqPath.replace("/v1/files/", "");
@@ -1907,6 +2105,9 @@ function createApp() {
     if (!isFirstUser && body.invite) {
       markInviteUsed(body.invite, contributor.username);
     }
+    logActivity(contributor.username, "contributor_created", {
+      username: contributor.username
+    });
     return c.json({
       contributor: {
         username: contributor.username,
@@ -1930,6 +2131,9 @@ function createApp() {
       return c.json({ error: "Only the admin can generate invite codes" }, 403);
     }
     const invite = createInvite(contributor.username);
+    logActivity(contributor.username, "invite_created", {
+      invite: invite.id
+    });
     return c.json({
       invite: invite.id,
       createdAt: invite.created_at
@@ -1957,6 +2161,9 @@ function createApp() {
     if (!found) {
       return c.json({ error: "Contributor not found" }, 404);
     }
+    logActivity(contributor.username, "contributor_deleted", {
+      username: target
+    });
     return c.body(null, 204);
   });
   authed.put("/v1/files/*", async (c) => {
@@ -1976,11 +2183,22 @@ function createApp() {
       return c.json({ error: pathError }, 400);
     }
     const content = await c.req.text();
-    const now = new Date().toISOString();
-    const originCtime = c.req.header("X-Origin-Ctime") || now;
-    const originMtime = c.req.header("X-Origin-Mtime") || now;
+    const originCtime = c.req.header("X-Origin-Ctime") || undefined;
+    const originMtime = c.req.header("X-Origin-Mtime") || undefined;
+    const existing = getItem(parsed.username, parsed.filePath);
     try {
       const item = upsertItem(parsed.username, parsed.filePath, content, originCtime, originMtime);
+      const detail = {
+        path: item.path,
+        size: Buffer.byteLength(item.content)
+      };
+      const diffResult = computeDiff(existing?.content ?? "", content);
+      if (diffResult) {
+        detail.diff = diffResult.diff;
+        if (diffResult.truncated)
+          detail.diff_truncated = true;
+      }
+      logActivity(contributor.username, "file_upserted", detail);
       broadcast("file_updated", {
         contributor: parsed.username,
         path: item.path,
@@ -2017,6 +2235,9 @@ function createApp() {
     if (!found) {
       return c.json({ error: "File not found" }, 404);
     }
+    logActivity(contributor.username, "file_deleted", {
+      path: parsed.filePath
+    });
     broadcast("file_deleted", {
       contributor: parsed.username,
       path: parsed.filePath
@@ -2111,6 +2332,19 @@ data: {}
     const results = searchItems(q, contributorParam, limit);
     return c.json({ results });
   });
+  authed.get("/v1/activity", (c) => {
+    const contributor = c.req.query("contributor") || undefined;
+    const action = c.req.query("action") || undefined;
+    const limit = c.req.query("limit") ? parseInt(c.req.query("limit"), 10) : undefined;
+    const offset = c.req.query("offset") ? parseInt(c.req.query("offset"), 10) : undefined;
+    const events = listActivityEvents({
+      contributor,
+      action,
+      limit,
+      offset
+    });
+    return c.json({ events });
+  });
   app.route("/", authed);
   return app;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seedvault/server",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "type": "module",
   "bin": {
     "seedvault-server": "bin/seedvault-server.mjs"