prime8dev

shell-fs.js (7212B)

---

 // Writable filesystem for the web shell. The server's read-only tree
 // (/api/fs, generated from site content) is the base layer; whatever the
 // visitor creates, edits or deletes is kept as an overlay in localStorage and
 // replayed on top of it, so their files survive reloads and new site content
 // still shows up underneath.
 //
 // Overlay entries are keyed by absolute path:
 //   null              deleted (whiteout over a base node)
 //   {d:1, m, f?:1}    directory; f = fresh, replaces whatever the base had
 //   {c, m}            file with content c
 // m is the mtime in ms.
 
 const STORE_KEY = "prime8.fs.v1";
 const QUOTA = 1 << 20; // chars of serialized overlay, well under localStorage limits
 
 export const enc = new TextEncoder();
 
 // --- paths (same rules as internal/vfs) ---
 
 export function cleanPath(p) {
   const out = [];
   for (const part of p.split("/")) {
     if (part === "" || part === ".") continue;
     if (part === "..") out.pop();
     else out.push(part);
   }
   return "/" + out.join("/");
 }
 
 export function resolvePath(home, cwd, p) {
   if (p === "" || p === "~") return home;
   if (p.startsWith("~/")) p = home + p.slice(1);
   else if (!p.startsWith("/")) p = cwd + "/" + p;
   return cleanPath(p);
 }
 
 export function displayPath(home, abs) {
   if (abs === home) return "~";
   if (abs.startsWith(home + "/")) return "~" + abs.slice(home.length);
   return abs;
 }
 
 export function dirname(abs) {
   const i = abs.lastIndexOf("/");
   return i <= 0 ? "/" : abs.slice(0, i);
 }
 
 export function basename(abs) {
   return abs.slice(abs.lastIndexOf("/") + 1);
 }
 
 export function inside(abs, base) {
   return abs === base || abs.startsWith(base === "/" ? "/" : base + "/");
 }
 
 export function lookup(root, abs) {
   let n = root;
   for (const part of abs.split("/")) {
     if (part === "") continue;
     if (!n.dir) return null;
     const c = n.children[part];
     if (!c) return null;
     n = c;
   }
   return n;
 }
 
 export function sortedChildren(n) {
   return Object.values(n.children || {}).sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
 }
 
 export function nodeSize(n) {
   return n.dir ? 4096 : enc.encode(n.content).length;
 }
 
 function mkDir(name, mtime) {
   return { name, dir: true, children: {}, mtime };
 }
 
 function mkFile(name, content, mtime) {
   return { name, dir: false, content, mtime };
 }
 
 function cloneBase(n, mtime) {
   if (!n.dir) return mkFile(n.name, n.content || "", mtime);
   const d = mkDir(n.name, mtime);
   for (const [k, c] of Object.entries(n.children || {})) d.children[k] = cloneBase(c, mtime);
   return d;
 }
 
 function depth(p) {
   return p.split("/").length;
 }
 
 function applyOverlay(root, entries) {
   const keys = Object.keys(entries).sort((a, b) => depth(a) - depth(b) || (a < b ? -1 : 1));
   for (const k of keys) {
     const parent = lookup(root, dirname(k));
     if (!parent || !parent.dir) continue;
     const name = basename(k);
     const v = entries[k];
     if (v === null) delete parent.children[name];
     else if (v.d) {
       const cur = parent.children[name];
       if (v.f || !cur || !cur.dir) parent.children[name] = mkDir(name, v.m);
       else cur.mtime = v.m;
     } else parent.children[name] = mkFile(name, v.c, v.m);
   }
 }
 
 export class VFS {
   constructor(data) {
     this.base = data.root;
     this.user = data.user;
     this.home = data.home;
     const t = new Date();
     t.setHours(0, 0, 0, 0);
     this.baseTime = t.getTime();
     this.load();
   }
 
   load() {
     let saved = "";
     try {
       saved = window.localStorage.getItem(STORE_KEY) || "";
     } catch {
       saved = "";
     }
     this.saved = saved;
     this.entries = {};
     try {
       const parsed = saved ? JSON.parse(saved) : null;
       if (parsed && typeof parsed.e === "object" && parsed.e) this.entries = parsed.e;
     } catch {
       this.entries = {};
     }
     this.dirty = false;
     this.rebuild();
   }
 
   rebuild() {
     this.root = cloneBase(this.base, this.baseTime);
     applyOverlay(this.root, this.entries);
   }
 
   changes() {
     return Object.keys(this.entries).length;
   }
 
   // commit persists the overlay. On quota failure it rolls back to the last
   // saved state and returns false.
   commit() {
     if (!this.dirty) return true;
     this.dirty = false;
     const s = JSON.stringify({ v: 1, e: this.entries });
     let ok = s.length <= QUOTA;
     if (ok) {
       try {
         window.localStorage.setItem(STORE_KEY, s);
       } catch {
         ok = false;
       }
     }
     if (ok) {
       this.saved = s;
       return true;
     }
     this.load();
     return false;
   }
 
   reset() {
     this.entries = {};
     try {
       window.localStorage.removeItem(STORE_KEY);
     } catch {
       /* ignore */
     }
     this.saved = "";
     this.dirty = false;
     this.rebuild();
   }
 
   // writable: the visitor owns their home and /tmp; everything else is root's.
   writable(abs) {
     return inside(abs, this.home) || inside(abs, "/tmp");
   }
 
   owner(abs) {
     return inside(abs, this.home) ? this.user : "root";
   }
 
   inBase(abs) {
     return lookup(this.base, abs) !== null;
   }
 
   get(abs) {
     return lookup(this.root, abs);
   }
 
   // checkCreate reports why abs cannot be created/replaced/removed, or "".
   checkCreate(abs) {
     if (abs === "/") return "Permission denied";
     const parent = this.get(dirname(abs));
     if (!parent) return "No such file or directory";
     if (!parent.dir) return "Not a directory";
     if (!this.writable(dirname(abs)) || !this.writable(abs)) return "Permission denied";
     return "";
   }
 
   mkdir(abs) {
     const parent = this.get(dirname(abs));
     const name = basename(abs);
     const t = Date.now();
     parent.children[name] = mkDir(name, t);
     parent.mtime = t;
     this.entries[abs] = this.inBase(abs) ? { d: 1, m: t, f: 1 } : { d: 1, m: t };
     this.dirty = true;
   }
 
   write(abs, content) {
     const parent = this.get(dirname(abs));
     const name = basename(abs);
     const t = Date.now();
     if (!parent.children[name]) parent.mtime = t;
     parent.children[name] = mkFile(name, content, t);
     this.entries[abs] = { c: content, m: t };
     this.dirty = true;
   }
 
   touch(abs) {
     const n = this.get(abs);
     const t = Date.now();
     n.mtime = t;
     if (!n.dir) this.entries[abs] = { c: n.content, m: t };
     else if (this.entries[abs]) this.entries[abs].m = t;
     this.dirty = true;
   }
 
   remove(abs) {
     const parent = this.get(dirname(abs));
     delete parent.children[basename(abs)];
     parent.mtime = Date.now();
     const prefix = abs + "/";
     for (const k of Object.keys(this.entries)) if (k.startsWith(prefix)) delete this.entries[k];
     if (this.inBase(abs)) this.entries[abs] = null;
     else delete this.entries[abs];
     this.dirty = true;
   }
 
   // copy materializes node (a whole subtree for a directory) at abs.
   copy(node, abs) {
     if (this.get(abs)) this.remove(abs);
     if (!node.dir) {
       this.write(abs, node.content);
       return;
     }
     this.mkdir(abs);
     for (const c of sortedChildren(node)) this.copy(c, abs + "/" + c.name);
   }
 
   count(n = this.root) {
     if (!n.dir) return 1;
     let total = 1;
     for (const c of Object.values(n.children)) total += this.count(c);
     return total;
   }
 }
 
 export { STORE_KEY };