@ai-ecoverse/slicc-kernel 1.125.11 → 1.126.0

package/dist/kernel-worker.js

@@ -1096,6 +1096,7 @@ var ABSENT_NAMES = 4096;
 var FILE_HANDLES = 4096;
 var STALE = /* @__PURE__ */ new Set(["NotFoundError", "TypeMismatchError"]);
 var REPLACED_ATTEMPTS = 4;
+var RECONCILE_LISTINGS = 8;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
 var ERRNO_BY_DOM_ERROR = {
   NotFoundError: "ENOENT",
@@ -2455,15 +2456,57 @@ var OpfsFs = class {
       timesBy: this.id
     }));
   }
+  async present(paths) {
+    const listed = /* @__PURE__ */ new Map();
+    const done4 = /* @__PURE__ */ new Map();
+    const list = (dir) => {
+      const known = listed.get(dir);
+      if (known !== void 0) return known;
+      const listing = (async () => {
+        const above = dir === "/" ? void 0 : await list(parentOf3(dir));
+        if (above === null) return null;
+        const handle = dir === "/" ? this.root : above?.get(baseOf(dir));
+        if (handle?.kind !== "directory") return void 0;
+        this.calls++;
+        const children3 = /* @__PURE__ */ new Map();
+        try {
+          for await (const child of handle.values())
+            children3.set(child.name, child);
+        } catch {
+          return null;
+        }
+        return children3;
+      })().then((children3) => {
+        done4.set(dir, children3);
+        return children3;
+      });
+      listed.set(dir, listing);
+      return listing;
+    };
+    const dirs = [...new Set(paths.filter((p) => split(p).length > 0).map(parentOf3))];
+    let next3 = 0;
+    const lister = async () => {
+      while (next3 < dirs.length) await list(dirs[next3++]);
+    };
+    await Promise.all(Array.from({ length: Math.min(RECONCILE_LISTINGS, dirs.length) }, lister));
+    return async (path) => {
+      if (split(path).length === 0) return true;
+      const listing = done4.get(parentOf3(path));
+      if (listing === null) return this.real(path);
+      return listing?.has(baseOf(path)) === true;
+    };
+  }
   async reconcile() {
     if (this.remote && await this.remote.peered()) return 0;
     let removed = 0;
     const entries = await this.meta.all();
     const carried = new Set(entries.filter((e) => !e.vacated).map((e) => e.ino));
-    for (const entry of entries) {
-      if (entry.vacated && carried.has(inodeOf(entry.path))) continue;
-      const real = await this.real(entry.path);
-      const stale = entry.link === void 0 ? !real : real || !await this.real(parentOf3(entry.path));
+    const checked = entries.filter((e) => !(e.vacated && carried.has(inodeOf(e.path))));
+    const real = await this.present(
+      checked.flatMap((e) => e.link === void 0 ? [e.path] : [e.path, parentOf3(e.path)])
+    );
+    for (const entry of checked) {
+      const stale = entry.link === void 0 ? !await real(entry.path) : await real(entry.path) || !await real(parentOf3(entry.path));
       if (!stale) continue;
       const seen = JSON.stringify(entry);
       await this.meta.update(
@@ -6656,7 +6699,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.125.11" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.126.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -8288,10 +8331,10 @@ function tunnelRequestUrl(req, origin) {
     throw new HttpError(400, "malformed request target");
   }
   const hosts = fieldValues(req.headers, "host");
-  const hostOk = hosts.every(
+  const hostOk2 = hosts.every(
     (h) => URL.canParse(`https://${h}`) && new URL(`https://${h}`).host === base.host
   );
-  if (url.origin !== base.origin || !hostOk) {
+  if (url.origin !== base.origin || !hostOk2) {
     throw new HttpError(421, `this tunnel is for ${base.host}`);
   }
   return url.href;
@@ -17619,6 +17662,10 @@ function controlsOf(o, session, protocol, chain2, shape) {
     ...o.insecure ? insecureOf(session, chain2, shape) : { hostnameMatches: checked || !session.nameMismatch }
   };
 }
+function verdictOf(o, session) {
+  if (o.bundled !== true || isIP(o.servername) || session.verifyResult !== 0) return false;
+  return o.checkHostname !== false || !session.nameMismatch;
+}
 async function infoOf(o, session) {
   const flags2 = session.verifyResult;
   const code = verifyCode(flags2);
@@ -17631,7 +17678,9 @@ async function infoOf(o, session) {
     authorized: code === void 0,
     ...code ? { authorizationError: code, authorizationText: o.engine.verifyInfo(flags2).trim() } : {},
     peerCertificates: chain2,
-    ...controlsOf(o, session, protocol, chain2, shape)
+    ...controlsOf(o, session, protocol, chain2, shape),
+    verified: verdictOf(o, session),
+    handshakeAt: Date.now()
   };
 }
 var FATAL_ALERT = -30592;
@@ -17749,6 +17798,7 @@ function sessionOf(info, servername) {
   return {
     path: "kernel",
     substitutes: false,
+    verified: info.verified,
     protocol: info.protocol,
     alpnProtocol: info.alpnProtocol,
     authorized: info.authorized,
@@ -17862,7 +17912,8 @@ async function prepareWith(support, req, servername, cert) {
     insecure: req.insecure === true,
     ...req.sni === false ? { sni: false } : {},
     ...req.checkHostname === false ? { checkHostname: false } : {},
-    clientCertificate: cert !== void 0
+    clientCertificate: cert !== void 0,
+    bundled: own === void 0
   };
   let session;
   try {
@@ -18449,9 +18500,21 @@ var VfsNode = class {
   }
   async keep() {
     const ranged2 = await this.prepare();
-    await ranged2?.pin();
+    if (ranged2) await this.followed(() => ranged2.pin());
   }
   moving = /* @__PURE__ */ new Set();
+  async followed(op) {
+    for (; ; ) {
+      const at = this.path;
+      try {
+        return await op();
+      } catch (err) {
+        if (!isMissing(err)) throw err;
+        while (this.moving.size > 0) await Promise.all(this.moving);
+        if (this.path === at) throw err;
+      }
+    }
+  }
   async load() {
     if (this.revoked) throw new KernelError("EIO");
     while (!this.data) {
@@ -18497,7 +18560,7 @@ var VfsNode = class {
   }
   async pread(max, at) {
     const ranged2 = await this.prepare();
-    if (ranged2) return ranged2.read(at, max);
+    if (ranged2) return this.followed(() => ranged2.read(at, max));
     const bytes = await this.load();
     const n = Math.max(0, Math.min(max, this.length - at));
     return bytes.slice(at, at + n);
@@ -18540,7 +18603,7 @@ var VfsNode = class {
     await this.fits(at + bytes.length);
     const ranged2 = await this.prepare();
     if (ranged2) {
-      await ranged2.write(at, bytes);
+      await this.followed(() => ranged2.write(at, bytes));
       this.markDirty();
       return bytes.length;
     }
@@ -18609,8 +18672,9 @@ var VfsNode = class {
     this.dirty = false;
     const started = performance.now();
     try {
-      if (this.ranged) await this.ranged.flush();
-      else await this.fs.writeFile(this.path, this.data.slice(0, this.length));
+      await this.followed(
+        () => this.ranged ? this.ranged.flush() : this.fs.writeFile(this.path, this.data.slice(0, this.length))
+      );
     } catch (err) {
       this.dirty = true;
       throw err;
@@ -22589,6 +22653,79 @@ function scrubStdio(fds, scrubber) {
   }
 }
 
+// src/kernel/sealed-session.ts
+var SESSION_WINDOW_MS = 6e4;
+var SESSION_PLACEHOLDERS = 16;
+var SESSION_PLACEHOLDER = /^fnox_proxy_[0-9a-f]{24}$/;
+var SESSION_ID = /^[A-Za-z0-9_-]{16,128}$/;
+var TOKEN5 = "[!#$%&'*+.^_`|~0-9a-z-]+";
+var HEADER = new RegExp(`^header:${TOKEN5}$`);
+var METHOD = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var TARGET = /^[\x21-\x7e]+$/;
+var EXIT = /^(page|proxy|tailscale|device:[\x21-\x7e]+)$/;
+var HOST = /^[a-z0-9.:-]+$/;
+var UNSAFE = /[\r\n\0]/;
+var POSITIONS = {
+  http1: (position) => HEADER.test(position),
+  smtp: (position) => position === "auth-plain" || position === "auth-login",
+  pg: (position) => position === "password-cleartext"
+};
+function boundHost(servername) {
+  const lower = servername.toLowerCase();
+  return lower.endsWith(".") ? lower.slice(0, -1) : lower;
+}
+function headOk(f) {
+  if (f.protocol !== "http1") return f.head === void 0;
+  const head = f.head;
+  return head !== void 0 && typeof head.method === "string" && METHOD.test(head.method) && typeof head.path === "string" && TARGET.test(head.path);
+}
+function placeholdersOk(list) {
+  if (!Array.isArray(list) || list.length === 0 || list.length > SESSION_PLACEHOLDERS) return false;
+  return new Set(list).size === list.length && list.every((p) => typeof p === "string" && SESSION_PLACEHOLDER.test(p));
+}
+function hostOk(host) {
+  return typeof host === "string" && HOST.test(host) && boundHost(host) === host;
+}
+function sessionAskable(f, now) {
+  if (!Object.hasOwn(POSITIONS, f.protocol) || typeof f.position !== "string") return false;
+  if (!POSITIONS[f.protocol](f.position)) return false;
+  if (typeof f.session !== "string" || !SESSION_ID.test(f.session)) return false;
+  if (f.verified !== true || !hostOk(f.host) || typeof f.handshakeAt !== "number") return false;
+  if (!Number.isInteger(f.port) || f.port < 1 || f.port > 65535) return false;
+  const age = now - f.handshakeAt;
+  if (!Number.isFinite(age) || age < 0 || age > SESSION_WINDOW_MS) return false;
+  return typeof f.exit === "string" && EXIT.test(f.exit) && placeholdersOk(f.placeholders) && headOk(f);
+}
+function sessionRequest(f) {
+  return {
+    v: 1,
+    op: "sessionMaterialize",
+    caller: f.stamp,
+    stamp: f.stamp,
+    session: f.session,
+    host: f.host,
+    port: f.port,
+    protocol: f.protocol,
+    position: f.position,
+    verified: true,
+    handshakeAt: f.handshakeAt,
+    exit: f.exit,
+    placeholders: [...f.placeholders],
+    ...f.head ? { head: { method: f.head.method, path: f.head.path } } : {}
+  };
+}
+function sessionValues(reply, asked) {
+  if (typeof reply !== "object" || reply === null || Array.isArray(reply)) return void 0;
+  const { error, values } = reply;
+  if (error !== void 0 || typeof values !== "object" || values === null) return void 0;
+  const out = {};
+  for (const ph of asked) {
+    const value2 = values[ph];
+    if (typeof value2 === "string" && value2.length > 0 && !UNSAFE.test(value2)) out[ph] = value2;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+
 // src/kernel/sealed.ts
 var SEALED_MAX_BYTES = 64 * 1024;
 var SEALED_TIMEOUT_MS = 1e4;
@@ -22783,6 +22920,15 @@ var SealedBroker = class {
     };
   }
   async consume(fields) {
+    const req = { ...fields, v: 1, op: "materializeConsume", caller: fields.stamp };
+    return this.ask(req, swapOf);
+  }
+  async sessionMaterialize(fields, now = Date.now()) {
+    if (!sessionAskable(fields, now)) return void 0;
+    const req = sessionRequest(fields);
+    return this.ask(req, (reply) => sessionValues(reply, req.placeholders));
+  }
+  async ask(req, parse) {
     const { hook } = this;
     if (!hook) return void 0;
     const control = new AbortController();
@@ -22790,14 +22936,8 @@ var SealedBroker = class {
     const stopped = new Promise((resolve2) => {
       control.signal.addEventListener("abort", () => resolve2(void 0), { once: true });
     });
-    const req = {
-      ...fields,
-      v: 1,
-      op: "materializeConsume",
-      caller: fields.stamp
-    };
     try {
-      const asked = Promise.resolve().then(() => hook(req, { signal: control.signal })).then(swapOf, () => void 0);
+      const asked = Promise.resolve().then(() => hook(req, { signal: control.signal })).then(parse, () => void 0);
       return await Promise.race([asked, stopped]);
     } finally {
       clearTimeout(timer);