@ai-ecoverse/slicc-kernel 1.160.0 → 1.160.1

package/README.md

@@ -1156,6 +1156,7 @@ printf '{"kind":"open.url","url":"%s"}\n' "$url" | cat > /dev/embedder
 
 - **The request:** the first line is a JSON object with a `kind` (`a.b-c`: lower-case words with dots, at most 64 bytes) and options (every other key), at most 64 KiB. Everything written after it is the body, streamed to the page as it is written: a write waits while 1 MiB of it is unread by the page. A bad header fails that `write()` with `EINVAL`, and the description stays failed. A page that answers with bytes, a string or nothing, or cancels the body, before it has read all of it gets no more: the rest the program writes is dropped ([#1536](https://github.com/ai-ecoverse/slicc-kernel/issues/1536)), so a writer never waits on a body nobody reads. A page that answers with a stream keeps the body until that stream ends, so it must read or cancel the body: until it does, a writer past the 1 MiB window waits. The request goes to the page when its header line ends.
 - **The reply:** reads return the page's reply in order, pulled as the program reads, and its end is end-of-file. Opened `O_RDWR`, the first `read()` ends the body. Opened `O_WRONLY` (nobody reads), the last close ends the body and waits for the page to finish, so `close()` returns its error (an Emscripten program's standard output follows `/dev/clipboard`'s exit rule, so `printf … | cat > /dev/embedder` fails with `cat: write error: …`). There is no timeout: a reply may wait for a prompt or a model download; run `timeout` for one.
+- **Who waits:** the process that does the last close waits for the reply, and only a signal to that process interrupts it. So put the open inside the command that `timeout` bounds: `timeout 12 sh -c 'cat request > /dev/embedder'`. In `timeout 12 cat request > /dev/embedder` the redirection is `timeout`'s own. `cat` writes the header and exits at once, so the timer never fires, and then `timeout` waits in its own last close, on its way out (coreutils closes its standard output), until the page answers.
 - **Cancel:** a signal during a blocked read, write or `O_WRONLY` close fails it with `EINTR`, and the page's `signal` aborts with reason `interrupted`. Closing the description before the end of the reply aborts it with reason `closed`, and that is no error: it is how `hear` stops recording. A process that ends during a request aborts it too.
 - **Errors:** the hook's error gives the errno: `NotAllowedError` or `AbortError` (a dismissed prompt, a refused permission) `EACCES`; `NotSupportedError` `ENOTSUP`; `NotFoundError` `ENOENT`; anything else `EIO`. An Emscripten or WASI program first gets `<argv0>: /dev/embedder: <first line of the message>` on standard error, as for `/dev/clipboard`; a JS program has it in the error. `request.progress(line)` from the page writes `<argv0>: <line>` to standard error the same way, at most 4 lines a second.
 - **Who answers:** the hook of the client the process's session was started through, inherited by its children, forks and `exec`s: `createKernel({ requests })` (and `createNodeKernel`) for the page's own `run` and `openTerminal`, the hook a port was made with (`connect({ requests })`), or the hook its attached client brought (`connect({ requests: 'attach' })`, then `attachKernel(port, { requests })`). Nothing falls back to another client's hook, so a request from another tab's terminal never opens in this one. With no hook, or a kind the hook doesn't list, the request is `ENOTSUP` before the page sees it. A program has no way to register, replace or see a hook.

package/dist/kernel-worker.js

@@ -8236,7 +8236,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.160.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.160.1" : "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
@@ -14932,7 +14932,8 @@ async function dispatchSyncFs(req) {
   const entry = resolveSyncFsToken(req.token);
   if (!entry) return { ok: false, errno: "EACCES", message: "sync-fs: unknown or revoked token" };
   if (req.identity && req.op === "create") return created2(entry, req);
-  if (!req.identity || !IDENTITY_OPS.has(req.op)) return dispatchOne(entry, req);
+  if (!req.identity || !IDENTITY_OPS.has(req.op))
+    return devsOf(entry, req, await dispatchOne(entry, req));
   const { fs, cwd } = entry;
   const path = fs.resolvePath(cwd, req.path);
   const identified = async (held) => {
@@ -14950,6 +14951,30 @@ async function dispatchSyncFs(req) {
     return toErrno(err);
   }
 }
+var DEV_PROBES = /* @__PURE__ */ new Set(["stat", "lstat", "read", "exists"]);
+async function devsOf(entry, req, result) {
+  if (req.devs !== true || !DEV_PROBES.has(req.op)) return result;
+  const absent2 = result.ok ? result.kind === "json" && result.json === false : result.errno === "ENOENT";
+  if (!absent2) return result;
+  const dev = await devTarget(entry, req, entry.fs.resolvePath(entry.cwd, req.path));
+  if (dev === void 0) return result;
+  return result.ok ? json2({ dev }) : { ...result, dev };
+}
+async function devTarget(entry, req, path) {
+  const look = async (op, at) => {
+    const r = await dispatchPath(entry, { token: req.token, op, path: at });
+    if (!r.ok) throw new Error(r.errno);
+    return r.json;
+  };
+  const resolved2 = await physicalPathAsync(
+    {
+      lstat: async (p) => await look("lstat", p),
+      readlink: async (p) => String(await look("readlink", p))
+    },
+    path
+  );
+  return resolved2 !== path && (resolved2 === "/dev" || resolved2.startsWith("/dev/")) ? resolved2 : void 0;
+}
 async function created2(entry, req) {
   const result = await dispatchOne(entry, req);
   if (!result.ok) return result;
@@ -15136,7 +15161,8 @@ function encodeSabResult(result) {
         JSON.stringify({
           errno: result.errno,
           message: result.message,
-          ...result.direct ? { direct: true } : {}
+          ...result.direct ? { direct: true } : {},
+          ...result.dev !== void 0 ? { dev: result.dev } : {}
         })
       )
     };