@dcasegr/skein 0.1.1 → 0.1.2

package/README.md

@@ -82,7 +82,10 @@ every user skein: the front door, the messagebox, the wallet, and one row
 to the kernel, `claim`, from anyone: the first claim's sender owns it
 (#127), so claim it first thing. The host signs no user's claim; `skein
 claim --messagebox <url>` names where the instance reaches its owner. A
-second claim is refused. It has no apps (#152). After the claim, install
+second claim is refused. `GET <its origin>/.well-known/skein` answers
+`{handle, identity, origin, claimed}` (the host's read: whether anyone
+holds root yet); `GET /skeins?key=<key>` lists the instances a key is root
+on. It has no apps (#152). After the claim, install
 the chain, git and site apps by message, and root's route `/` to the site:
 
 ```

package/dist/host/router.d.ts

@@ -732,6 +732,15 @@ export declare class Router {
      * in a wallet tracks them). Unsigned, anyone; mailbox instances are not listed.
      */
     private skeinsHeldBy;
+    /**
+     * GET /.well-known/skein at an instance's origin (its hostname, `/@<handle>/`, or the root instance's
+     * hostname): `{handle, identity, origin, claimed}` — `claimed` whether its head `grants` names a root
+     * holder (an image instance nobody has claimed: false). Read from its store read-only, no kernel, as
+     * /skeins does. Unsigned, anyone; 404 for no instance. "Am I root" is /skeins?key=<identity>.
+     */
+    private instanceCard;
+    /** The keys an instance's head `grants` names root (#143), its store read read-only; none when it has no store yet. */
+    private rootsOf;
     /** A forwarded request, held among the in-flight ones (shutdown answers them 503). */
     private held;
     /**

package/dist/host/router.js

@@ -27,6 +27,8 @@
 //   With no host skein: 404 (tests may answer them with a fixture: `discovery`).
 //   GET  /skeins?key=<hex>                at the host's own origin: the skeins here whose head `grants` names the key
 //                                         among root's holders, [{handle, identity, url}] (no wallet token tracks them)
+//   GET  /.well-known/skein               at an instance's origin (its hostname, /@<handle>/, the root instance's): {handle,
+//                                         identity, origin, claimed} — claimed: its head `grants` names a root holder
 //   GET  /.well-known/skein-host          at every host name, an instance's too (#103): {origin, domain} — this
 //                                         router's origin and the handle domain (the onboarding app's
 //                                         config.onboard.domain), for a page an instance serves (the management
@@ -2060,6 +2062,9 @@ export class Router {
                 return await this.held(this.forward(o.handle, url.pathname, url, req));
         }
         const serve = async (x) => {
+            // The instance's own card, the host's read (no program): whether anyone holds root yet.
+            if (req.method === "GET" && x.route === "/.well-known/skein")
+                return await this.instanceCard(x.handle);
             // #138: the liveness tool's read, the host's own (no program).
             const live = req.method === "GET" ? /^\/([^/]+)\/\.live\/([^/]+)$/.exec(x.route) : null;
             if (live)
@@ -2183,24 +2188,41 @@ export class Router {
             return json(400, { status: "error", code: "ERR_BAD_REQUEST", description: "key: an identity key (33 bytes, hex)" });
         const out = [];
         for (const row of this.o.db.list("enabled")) {
-            if (row.kind === "mailbox" || !row.identity || !storeExists(storeSpec(row)))
+            if (row.kind === "mailbox" || !row.identity)
                 continue;
-            let roots;
-            const s = openStoreFile(storeSpec(row), { readOnly: true });
-            try {
-                roots = await rootOf(s);
-            }
-            catch {
-                roots = [];
-            }
-            finally {
-                s.close();
-            }
-            if (roots.includes(key))
+            if ((await this.rootsOf(row)).includes(key))
                 out.push({ handle: row.handle, identity: row.identity, url: this.originOf(row.handle) });
         }
         return json(200, out);
     }
+    /**
+     * GET /.well-known/skein at an instance's origin (its hostname, `/@<handle>/`, or the root instance's
+     * hostname): `{handle, identity, origin, claimed}` — `claimed` whether its head `grants` names a root
+     * holder (an image instance nobody has claimed: false). Read from its store read-only, no kernel, as
+     * /skeins does. Unsigned, anyone; 404 for no instance. "Am I root" is /skeins?key=<identity>.
+     */
+    async instanceCard(handle) {
+        const row = this.o.db.get(handle);
+        if (!row?.identity)
+            return json(404, { status: "error", code: "ERR_NOT_FOUND", description: `no instance ${handle} here` });
+        return json(200, { handle, identity: row.identity, origin: this.originOf(handle), claimed: (await this.rootsOf(row)).length > 0 });
+    }
+    /** The keys an instance's head `grants` names root (#143), its store read read-only; none when it has no store yet. */
+    async rootsOf(row) {
+        const spec = storeSpec(row);
+        if (!storeExists(spec))
+            return [];
+        const s = openStoreFile(spec, { readOnly: true });
+        try {
+            return await rootOf(s);
+        }
+        catch {
+            return [];
+        }
+        finally {
+            s.close();
+        }
+    }
     /** A forwarded request, held among the in-flight ones (shutdown answers them 503). */
     async held(p) {
         this.inflight.add(p);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcasegr/skein",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A deterministic WASI machine over a content-addressed graph: the node host (it loads the wasm kernel, kernel-zig built for the web target), the client, its peers, and dev tools.",
   "type": "module",
   "bin": {