npm - @microtoll/mcp - Versions diffs - 0.1.0 - Mend

@microtoll/mcp 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/CHANGELOG.md +15 -0
package/LICENSE +202 -0
package/README.md +42 -0
package/bin/microtoll-mcp.mjs +7 -0
package/generated/docs.json +957 -0
package/generated/scaffold/notes/README.md +39 -0
package/generated/scaffold/notes/docker-compose.yml +65 -0
package/generated/scaffold/notes/index.html +73 -0
package/generated/scaffold/notes/nginx.conf +58 -0
package/generated/scaffold/notes/notes.js +214 -0
package/generated/scaffold/notes/package.json +15 -0
package/generated/scaffold/notes/page.js +130 -0
package/package.json +30 -0
package/src/docs.js +78 -0
package/src/index.js +61 -0
package/src/protocol.js +93 -0
package/src/scaffold.js +60 -0
package/types/index.d.ts +35 -0

package/generated/scaffold/notes/README.md ADDED Viewed

@@ -0,0 +1,39 @@
+# __NAME__
+An end-to-end-encrypted notes app on [Microtoll Engine](https://microtoll.dev),
+scaffolded by `@microtoll/mcp`. It is the engine's notes example with your
+namespace and origin filled in: read `notes.js` (the whole model, about two
+hundred lines) before changing anything.
+## Run it
+```sh
+npm install          # fetches the @microtoll packages this Compose file mounts
+docker compose up
+```
+Then open __ORIGIN__. Sign up with a recovery code, write a note, share it
+by link, open the link in a private window as a second person.
+## What is where
+- `notes.js` — the model: list (the shelf query), create, update, share,
+  open, join, members, remove (rotation), heal, delete, live watch.
+- `page.js`, `index.html` — the page. The packages load from `node_modules`
+  through an import map: no build step.
+- `docker-compose.yml`, `nginx.conf` — Postgres with the engine schema, the
+  blind-store reference server (namespace `__NAMESPACE__`, collection
+  `notes` with a two-character selector), nginx serving this directory and
+  forwarding `/ws`.
+## Before you change it
+- **The namespace is one string used twice**: `__NAMESPACE__` in `page.js`
+  (`createCryptoCore`) and in `docker-compose.yml`
+  (`BLIND_STORE_NAMESPACE`). Sign-in is bound to it and to the page's origin.
+- **Do not add cryptography.** Everything needed is in the packages, with
+  its threat model. If something seems to need a new primitive, ask a person.
+- **Say what is not protected.** Copy the engine's honest limits
+  (<https://microtoll.dev/honest-limits.html>) into your own about page.
+- **For a deployment**, use the engine's `deploy/` kit: secret files, TLS at
+  the proxy, the server as its own database role, no access log.

package/generated/scaffold/notes/docker-compose.yml ADDED Viewed

@@ -0,0 +1,65 @@
+# Scaffolded by @microtoll/mcp: Postgres with the engine schema, the
+# blind-store reference server from the published package, and nginx serving
+# this directory and forwarding /ws. Run `npm install` first (it fetches the
+# packages this Compose file mounts), then `docker compose up` and open
+# __ORIGIN__.
+#
+# LOCAL ONLY as written: fixed database passwords, the database reachable
+# only inside this network. For a deployment, see the engine's deploy/ kit.
+name: __NAME__
+services:
+  db:
+    image: postgres:17
+    environment:
+      - TZ=Etc/UTC
+      - PGTZ=UTC
+      - POSTGRES_USER=app_owner
+      - POSTGRES_DB=app
+      - POSTGRES_PASSWORD=${DB_OWNER_PASSWORD:-local-only-owner}
+      - BLIND_STORE_APP_PASSWORD=${DB_APP_PASSWORD:-local-only-app}
+    volumes:
+      - ./node_modules/@microtoll/blind-store/schema:/docker-entrypoint-initdb.d:ro
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U app_owner -d app"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+  blind-store:
+    image: node:24-alpine
+    working_dir: /app
+    command: ["node", "node_modules/@microtoll/blind-store/bin/blind-store.mjs"]
+    user: node
+    read_only: true
+    tmpfs:
+      - /tmp
+    cap_drop:
+      - ALL
+    security_opt:
+      - no-new-privileges:true
+    volumes:
+      - ./:/app:ro
+    environment:
+      - BLIND_STORE_NAMESPACE=__NAMESPACE__
+      - BLIND_STORE_ALLOWED_ORIGINS=__ORIGIN__
+      - BLIND_STORE_COLLECTIONS={"notes":{"selectorLength":2}}
+      - BLIND_STORE_PORT=8020
+      - DB_HOST=db
+      - DB_PORT=5432
+      - DB_USER=blind_store_app
+      - DB_NAME=app
+      - DB_PASSWORD=${DB_APP_PASSWORD:-local-only-app}
+    depends_on:
+      db:
+        condition: service_healthy
+  web:
+    image: nginx:1.30-alpine
+    ports:
+      - "__PORT__:80"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./:/usr/share/nginx/html:ro
+    depends_on:
+      - blind-store

package/generated/scaffold/notes/index.html ADDED Viewed

@@ -0,0 +1,73 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>__NAME__</title>
+<style>
+  :root { color-scheme: light dark; font-family: system-ui, sans-serif; }
+  body { max-width: 46rem; margin: 2rem auto; padding: 0 1rem; line-height: 1.45; }
+  h1 { font-size: 1.4rem; }
+  fieldset { border: 1px solid #8884; border-radius: 6px; margin: 1rem 0; padding: 0.75rem 1rem; }
+  legend { font-weight: 600; }
+  button { margin: 0.2rem 0.3rem 0.2rem 0; padding: 0.35rem 0.6rem; }
+  input, textarea { padding: 0.35rem; width: 100%; box-sizing: border-box; font-family: ui-monospace, monospace; }
+  textarea { min-height: 8rem; }
+  pre { background: #8881; padding: 0.6rem; border-radius: 6px; white-space: pre-wrap; word-break: break-all; font-size: 0.85rem; }
+  li { margin: 0.3rem 0; }
+  .note { color: #888; font-size: 0.85rem; }
+</style>
+<script type="importmap">
+{ "imports": {
+  "@microtoll/crypto-core": "/node_modules/@microtoll/crypto-core/src/index.js",
+  "@microtoll/identity": "/node_modules/@microtoll/identity/src/index.js",
+  "@microtoll/access": "/node_modules/@microtoll/access/src/index.js"
+} }
+</script>
+</head>
+<body>
+<h1>__NAME__</h1>
+<p>End-to-end-encrypted notes on Microtoll Engine. The server holds sealed
+blobs, hashed capabilities and the shelf each note is filed on; it cannot
+read a note or say who owns one. Read <code>notes.js</code> for the model,
+and put the engine's honest limits in your own about page.</p>
+<fieldset><legend>1. Start</legend>
+  <button id="boot">Boot</button>
+  <div id="signed-out">
+    <button id="signup">Sign up with a recovery code</button>
+    <button id="signup-passkey">Sign up with a passkey + recovery code</button>
+    <p class="note">Or unlock an account you made before:</p>
+    <input id="code" placeholder="recovery code">
+    <button id="unlock">Unlock</button>
+  </div>
+  <p id="recovery"></p>
+  <div id="signed-in" hidden><button id="lock">Lock</button> <button id="delete-account">Delete account</button></div>
+</fieldset>
+<fieldset><legend>2. Your notes</legend>
+  <input id="new-title" placeholder="a title"> <button id="new">New note</button>
+  <ul id="notes"></ul>
+  <div id="editor" hidden>
+    <input id="note-id" type="hidden">
+    <input id="title" placeholder="title">
+    <textarea id="body" placeholder="body"></textarea>
+    <button id="save">Save</button>
+  </div>
+</fieldset>
+<fieldset><legend>3. Share and open</legend>
+  <input id="share-url" placeholder="the share link appears here" readonly>
+  <input id="link" placeholder="paste a share link (or its token) here">
+  <button id="open-link">Open link</button>
+  <div id="members-panel" hidden>
+    <p><b>Members</b> (the owner can remove one: every key rotates)</p>
+    <ul id="members"></ul>
+  </div>
+</fieldset>
+<fieldset><legend>Log</legend><pre id="log"></pre></fieldset>
+<script type="module" src="./page.js"></script>
+</body>
+</html>

package/generated/scaffold/notes/nginx.conf ADDED Viewed

@@ -0,0 +1,58 @@
+# Scaffolded by @microtoll/mcp: the page and the packages (from
+# node_modules) as static files, /ws forwarded to blind-store, the client's
+# address blanked, no access log. Plain HTTP for localhost; a deployment
+# terminates TLS in front (see the engine's deploy/nginx.sample.conf).
+worker_processes 1;
+events { worker_connections 256; }
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+    types { text/javascript js mjs; }
+    server_tokens off;
+    access_log    off;
+    error_log     /dev/stderr warn;
+    map $http_upgrade $connection_upgrade {
+        default upgrade;
+        ''      close;
+    }
+    server {
+        listen 80;
+        root /usr/share/nginx/html;
+        add_header X-Content-Type-Options "nosniff" always;
+        add_header Referrer-Policy "no-referrer" always;
+        add_header Cache-Control "no-store" always;
+        add_header Content-Security-Policy "default-src 'self'; base-uri 'none'; object-src 'none'; frame-ancestors 'none'; form-action 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' __WS_ORIGIN__; img-src 'self' data:" always;
+        location /ws {
+            proxy_pass http://blind-store:8020;
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+            proxy_set_header X-Forwarded-For "";
+            proxy_set_header X-Real-IP "";
+            proxy_set_header Forwarded "";
+            proxy_read_timeout 300s;
+        }
+        location = /healthz {
+            proxy_pass http://blind-store:8020/healthz;
+            proxy_http_version 1.1;
+        }
+        # Only the app's files and the packages' sources are served; nothing else in node_modules.
+        location ~ ^/node_modules/@microtoll/[a-z-]+/src/ { try_files $uri =404; }
+        location /node_modules/ { return 404; }
+        location / {
+            try_files $uri $uri/ =404;
+            add_header X-Content-Type-Options "nosniff" always;
+            add_header Referrer-Policy "no-referrer" always;
+            add_header Cache-Control "no-store" always;
+            add_header Content-Security-Policy "default-src 'self'; base-uri 'none'; object-src 'none'; frame-ancestors 'none'; form-action 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' __WS_ORIGIN__; img-src 'self' data:" always;
+        }
+    }
+}

package/generated/scaffold/notes/notes.js ADDED Viewed

@@ -0,0 +1,214 @@
+// The notes app, without a page: everything it does with the packages, so
+// the same code runs in the browser (page.js) and in Node (test/). Read
+// this file first; it is the whole model.
+//
+// A note is an object in the `notes` collection. Its content {title, body}
+// is sealed under K_object; its owner holds the admin capability; a reader
+// who opens a share link gets K_object and a read-only pointer, and becomes
+// a member by "joining" (the protocol calls it a first reaction). The owner
+// can remove a member: every key rotates and the removed key opens nothing
+// written afterwards.
+//
+// THE SHELF is the coarse public selector. When a note is created the app
+// picks one of 256 shelves at random and keeps it in the note's pointer
+// (the access package's pointer extension). To list its notes the app asks
+// the server for every note on the shelves it uses and decrypts only its
+// own. What the server learns: which shelves this routing key reads. What
+// it cannot learn: which notes on a shelf are this account's. Cover is only
+// as deep as the crowd on a shelf -- the same honesty any coarse selector
+// owes its users.
+import { createAccess, asIs } from '@microtoll/access';
+import * as ac from '@microtoll/access';
+export const COLLECTION = 'notes';
+export const SHELVES = 256;
+/** One of 256 shelves, at random: two hex characters. */
+export function pickShelf(cc) {
+  return cc.randomBytes(1)[0].toString(16).padStart(2, '0');
+}
+/**
+ * createNotes({ cryptoCore, session })
+ *   session  an identity session (createIdentitySession) that is unlocked:
+ *            its `state()` gives the identity and the open socket, and
+ *            `ensureConnected()` reconnects.
+ */
+export function createNotes({ cryptoCore: cc, session }) {
+  const access = createAccess({ cryptoCore: cc, pointerFields: { shelf: { wire: 'shelf', ...asIs } } });
+  const me = () => { const s = session.state(); if (s.locked || !s.identity) throw new Error('unlock first'); return s.identity; };
+  const ws = () => session.ensureConnected();
+  const selectorOf = (shelf) => ({ collection: COLLECTION, selector: shelf });
+  /** Every pointer this account holds, opened: objectId -> { pointerId, p }. */
+  async function myPointers() {
+    const identity = me();
+    const out = new Map();
+    for (const { pointerId, sealed } of await access.fetchPointers(await ws())) {
+      try {
+        const p = await access.pointerCodec.open(identity, sealed);
+        out.set(p.objectId, { pointerId, p });
+      } catch { /* not this app's pointer, or not this account's: skipped */ }
+    }
+    return out;
+  }
+  /** The content a note's holder can read, or null when the held key no longer opens it (removed after a rotation). */
+  async function openNote(objectId, kObjectRaw, fetched) {
+    try {
+      const key = await cc.importSymmetricKey(kObjectRaw);
+      const content = await ac.openContent(cc, key, objectId, fetched.keyEpoch, fetched.encryptedContent);
+      return content;
+    } catch { return null; }
+  }
+  /**
+   * The notes this account can read: the shelves from its pointers, one
+   * query for all of them, and only the rows it holds keys for opened. A
+   * row that will not open with the held key is reported `stale` (the note
+   * was re-keyed; heal() fetches the member's own row for the new key).
+   */
+  async function list() {
+    const pointers = await myPointers();
+    const shelves = [...new Set([...pointers.values()].map(({ p }) => p.shelf).filter(Boolean))];
+    if (shelves.length === 0) return [];
+    const { objects } = await access.queryObjects(await ws(), { collection: COLLECTION, selectors: shelves });
+    const notes = [];
+    for (const o of objects) {
+      const held = pointers.get(o.objectId);
+      if (!held) continue; // cover traffic: someone else's note on a shared shelf
+      const content = await openNote(o.objectId, held.p.kObject, o);
+      notes.push({
+        id: o.objectId, shelf: o.fields.selector, keyEpoch: o.keyEpoch,
+        title: content ? content.title : null, body: content ? content.body : null,
+        mine: Boolean(held.p.adminCapabilitySecret), member: Boolean(held.p.rowCapabilitySecret),
+        stale: !content || held.p.keyEpoch !== o.keyEpoch,
+      });
+    }
+    // Pointers whose note no longer exists are dropped here, on the next use.
+    const seen = new Set(objects.map((o) => o.objectId));
+    for (const [objectId, { pointerId }] of pointers) if (!seen.has(objectId)) await access.deletePointer(await ws(), pointerId).catch(() => {});
+    return notes;
+  }
+  async function create({ title, body }) {
+    const identity = me();
+    const shelf = pickShelf(cc);
+    const c = await access.createObject({ identity, content: { title, body }, ownerRowContent: { role: 'owner' } });
+    // The pointer carries the shelf so the app knows where to ask for this note.
+    c.pointer = await access.pointerCodec.build(identity, {
+      objectId: c.objectId, kObject: c.kObjectRaw, keyEpoch: 1, rowCapabilitySecret: c.ownerRow.rowCapabilitySecret, adminCapabilitySecret: c.adminCapabilitySecret, shelf,
+    });
+    await access.createObjectMessage(await ws(), c, selectorOf(shelf));
+    return { id: c.objectId, shelf };
+  }
+  /** The owner edits: the content is re-sealed under the current key at the current epoch. */
+  async function update(id, { title, body }) {
+    const held = (await myPointers()).get(id);
+    if (!held || !held.p.adminCapabilitySecret) throw new Error('not your note');
+    const fetched = await access.fetchObject(await ws(), id);
+    const key = await cc.importSymmetricKey(held.p.kObject);
+    const current = await ac.openContent(cc, key, id, fetched.keyEpoch, fetched.encryptedContent);
+    const sealed = await ac.sealContent(cc, key, id, fetched.keyEpoch, { ...current, title, body });
+    await access.updateObject(await ws(), { objectId: id, adminCapabilitySecret: held.p.adminCapabilitySecret, keyEpoch: fetched.keyEpoch, encryptedContent: sealed, selector: selectorOf(held.p.shelf) });
+  }
+  /** A share link: the token stays in the URL fragment and never reaches the server. Returns the fragment to append to the page's address. */
+  async function share(id, { maxUses = 10, days = 7 } = {}) {
+    const held = (await myPointers()).get(id);
+    if (!held || !held.p.adminCapabilitySecret) throw new Error('not your note');
+    const link = await access.createShareLink({ objectId: id, kObjectRaw: held.p.kObject, maxUses, expiresAt: new Date(Date.now() + days * 86400000).toISOString(), creator: me(), keyEpoch: held.p.keyEpoch });
+    await access.publishShareLink(await ws(), link);
+    return { fragment: `#note=${link.token}`, token: link.token };
+  }
+  /** Opening a link: redeem it, fetch the note, keep a read-only pointer with the shelf, read it. */
+  async function open(token) {
+    const identity = me();
+    const socket = await ws();
+    const payload = await access.redeemShareLinkMessage(socket, await access.hashToken(token));
+    const redeemed = await access.redeemShareLink(token, payload);
+    const fetched = await access.fetchObject(socket, redeemed.objectId);
+    const pointer = await access.buildReadOnlyPointer({ identity, objectId: redeemed.objectId, kObjectRaw: redeemed.kObjectRaw, keyEpoch: fetched.keyEpoch, extra: { shelf: fetched.fields.selector } });
+    await access.joinObject(socket, { objectId: redeemed.objectId, pointer });
+    const content = await openNote(redeemed.objectId, redeemed.kObjectRaw, fetched);
+    return { id: redeemed.objectId, title: content && content.title, body: content && content.body, verifiedCreator: redeemed.verified === true };
+  }
+  /** Becoming a member of a note held read-only: the first reaction, which gives this account a signed row the owner can see and remove. */
+  async function join(id, { name }) {
+    const identity = me();
+    const held = (await myPointers()).get(id);
+    if (!held) throw new Error('no pointer for this note');
+    const first = await access.buildFirstReaction({ identity, objectId: id, kObjectRaw: held.p.kObject, keyEpoch: held.p.keyEpoch, content: { name }, existingPointer: held.p });
+    await access.createMemberRow(await ws(), { objectId: id, row: first.row, pointerId: held.pointerId, pointer: first.pointer, readCapabilitySecret: first.readCapabilitySecret });
+  }
+  /** Who holds a row on this note, with the display rule applied (verified rows show their name; forged ones show nothing). */
+  async function members(id) {
+    const held = (await myPointers()).get(id);
+    if (!held) throw new Error('no pointer for this note');
+    const auth = held.p.adminCapabilitySecret ? { adminCapabilitySecret: held.p.adminCapabilitySecret } : { readCapabilitySecret: await access.readCapability(held.p.kObject) };
+    const rows = await access.fetchMembers(await ws(), id, auth);
+    const roster = access.roster(await access.openRows({ kObjectRaw: held.p.kObject, objectId: id, rows }));
+    return roster.map((e) => ({ rowId: e.id, name: e.content ? (e.content.name || e.content.role || null) : null, verified: e.verified, quiet: e.quiet }));
+  }
+  /** The owner removes a member: a new key for everyone else in one checked transaction; the owner's own pointer moves to the new key. */
+  async function remove(id, rowId) {
+    const identity = me();
+    const held = (await myPointers()).get(id);
+    if (!held || !held.p.adminCapabilitySecret) throw new Error('not your note');
+    const socket = await ws();
+    const fetched = await access.fetchObject(socket, id);
+    const key = await cc.importSymmetricKey(held.p.kObject);
+    const content = await ac.openContent(cc, key, id, fetched.keyEpoch, fetched.encryptedContent);
+    const rows = await access.fetchMembers(socket, id, { adminCapabilitySecret: held.p.adminCapabilitySecret });
+    const plan = await access.buildRotationPlan({ objectId: id, identity, oldKObjectRaw: held.p.kObject, oldEpoch: fetched.keyEpoch, content, rows, remove: [rowId], selfRowId: null });
+    const newEpoch = await access.rotateObjectKey(socket, id, held.p.adminCapabilitySecret, plan);
+    const pointer = await access.pointerCodec.build(identity, { ...held.p, kObject: plan.newKObjectRaw, keyEpoch: newEpoch, adminCapabilitySecret: plan.adminCapabilitySecret });
+    await access.updatePointer(socket, held.pointerId, pointer);
+    return newEpoch;
+  }
+  /** A member whose note was re-keyed (and who was kept) picks up the new key from their own row. */
+  async function heal(id) {
+    const identity = me();
+    const held = (await myPointers()).get(id);
+    if (!held || !held.p.rowCapabilitySecret) throw new Error('no member row to heal from');
+    const socket = await ws();
+    const myRow = await access.fetchMyRow(socket, id, held.p.rowCapabilitySecret);
+    const refreshed = await access.refreshPointerAfterRotation({ identity, objectId: id, myRow, existingPointer: held.p });
+    await access.updatePointer(socket, held.pointerId, refreshed.pointer);
+    return refreshed.kObjectRaw !== null;
+  }
+  async function destroy(id) {
+    const held = (await myPointers()).get(id);
+    if (!held || !held.p.adminCapabilitySecret) throw new Error('not your note');
+    const socket = await ws();
+    await access.deleteObject(socket, id, held.p.adminCapabilitySecret);
+    await access.deletePointer(socket, held.pointerId);
+  }
+  /** Live: re-run `onChange` when any note on this account's shelves changes. Returns a stop function. */
+  async function watch(onChange) {
+    const pointers = await myPointers();
+    const shelves = [...new Set([...pointers.values()].map(({ p }) => p.shelf).filter(Boolean))];
+    const socket = await ws();
+    if (shelves.length) await access.watchObjects(socket, { collection: COLLECTION, selectors: shelves });
+    return access.onLiveObject(socket, () => onChange());
+  }
+  /** The pointer this account holds for a note, opened: { pointerId, p } or null. (The invite example builds on it.) */
+  async function held(id) { return (await myPointers()).get(id) || null; }
+  return { access, list, create, update, share, open, join, members, remove, heal, destroy, watch, held, pickShelf: () => pickShelf(cc) };
+}
+/** The token from a page address such as https://host/#note=<token>, or null. */
+export function tokenFromLocation(hash) {
+  const m = /(?:^#|[#&])note=([A-Za-z0-9_-]+)/.exec(hash || '');
+  return m ? m[1] : null;
+}

package/generated/scaffold/notes/package.json ADDED Viewed

@@ -0,0 +1,15 @@
+{
+  "name": "__NAME__",
+  "private": true,
+  "type": "module",
+  "description": "An end-to-end-encrypted notes app on Microtoll Engine, scaffolded by @microtoll/mcp.",
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@microtoll/access": "^0.1.0",
+    "@microtoll/blind-store": "^0.1.0",
+    "@microtoll/crypto-core": "^0.1.0",
+    "@microtoll/identity": "^0.1.0"
+  }
+}

package/generated/scaffold/notes/page.js ADDED Viewed

@@ -0,0 +1,130 @@
+// The page: the identity session wired to buttons, and notes.js wired to a
+// list. Nothing here touches a key; the packages do, in this browser only.
+import { createCryptoCore } from '@microtoll/crypto-core';
+import { createIdentitySession, createSessionStore, createKnownAccountStore, createWebAuthn } from '@microtoll/identity';
+import { createNotes, tokenFromLocation } from './notes.js';
+const cc = createCryptoCore({ namespace: 'notes-example' });
+const $ = (id) => document.getElementById(id);
+const log = (line) => { $('log').textContent = `${new Date().toISOString().slice(11, 19)}  ${line}\n` + $('log').textContent; };
+// The socket: the same host as the page, at /ws (nginx forwards it).
+function connect() {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`${location.protocol === 'https:' ? 'wss' : 'ws'}://${location.host}/ws`);
+    ws.addEventListener('open', () => resolve(ws), { once: true });
+    ws.addEventListener('error', () => reject(new Error('could not reach the server')), { once: true });
+  });
+}
+const session = createIdentitySession({
+  cryptoCore: cc,
+  origin: location.origin,
+  transport: { connect },
+  sessionStore: createSessionStore({ cryptoCore: cc }),
+  knownAccounts: createKnownAccountStore({ cryptoCore: cc }),
+  webauthn: createWebAuthn({ rpName: 'Microtoll notes' }),
+  ui: {
+    askRecoveryCode: async (reason) => prompt(`Recovery code needed to ${reason}`),
+    confirmDeletion: async () => confirm('Delete the account and every note it owns?'),
+    passkeyName: () => 'Microtoll notes',
+  },
+  hooks: {
+    afterUnlock: () => { log('unlocked'); refresh(); },
+    onLocked: () => { log('locked'); render([]); },
+  },
+});
+const notes = createNotes({ cryptoCore: cc, session });
+let stopWatch = null;
+function setSignedIn(on) {
+  $('signed-out').hidden = on;
+  $('signed-in').hidden = !on;
+}
+async function run(name, fn) {
+  try { const r = await fn(); log(`${name}: ok`); return r; }
+  catch (e) { log(`${name}: ${e.code || e.reason || 'error'} — ${e.message}`); }
+}
+function render(list) {
+  const ul = $('notes');
+  ul.innerHTML = '';
+  for (const n of list) {
+    const li = document.createElement('li');
+    const title = document.createElement('b');
+    title.textContent = n.stale ? '(re-keyed — press heal, or you were removed)' : (n.title || '(untitled)');
+    li.append(title, ' ', n.mine ? '· yours' : n.member ? '· member' : '· reader', ' ');
+    const b = (label, fn) => { const x = document.createElement('button'); x.textContent = label; x.onclick = fn; li.append(x); };
+    if (!n.stale) b('open', () => { $('editor').hidden = false; $('note-id').value = n.id; $('title').value = n.title || ''; $('body').value = n.body || ''; $('save').hidden = !n.mine; });
+    if (n.mine) {
+      b('share', () => run('share', async () => { const { fragment } = await notes.share(n.id); $('share-url').value = `${location.origin}${location.pathname}${fragment}`; }));
+      b('members', () => run('members', async () => showMembers(n.id)));
+      b('delete', () => run('delete', async () => { await notes.destroy(n.id); await refresh(); }));
+    } else if (!n.member && !n.stale) {
+      b('join as member', () => run('join', async () => { await notes.join(n.id, { name: prompt('Your name, as the owner will see it') || 'someone' }); await refresh(); }));
+    } else if (n.member && n.stale) {
+      b('heal', () => run('heal', async () => { const ok = await notes.heal(n.id); log(ok ? 'new key picked up' : 'no new key for you: you were removed'); await refresh(); }));
+    }
+    ul.append(li);
+  }
+}
+async function showMembers(id) {
+  const list = await notes.members(id);
+  const ul = $('members');
+  ul.innerHTML = '';
+  for (const m of list) {
+    const li = document.createElement('li');
+    li.textContent = `${m.name || '(unverified row: nothing shown)'} ${m.verified ? '✓' : ''} `;
+    if (m.name !== 'owner') {
+      const x = document.createElement('button'); x.textContent = 'remove';
+      x.onclick = () => run('remove', async () => { await notes.remove(id, m.rowId); await showMembers(id); await refresh(); });
+      li.append(x);
+    }
+    ul.append(li);
+  }
+  $('members-panel').hidden = false;
+}
+async function refresh() {
+  const s = session.state();
+  setSignedIn(!s.locked && s.hasAccount);
+  if (s.locked || !s.hasAccount) return;
+  const list = await run('list', () => notes.list());
+  render(list || []);
+  if (!stopWatch) stopWatch = await notes.watch(() => refresh()).catch(() => null);
+}
+$('boot').onclick = () => run('boot', async () => {
+  const r = await session.bootFromTrustedSession();
+  if (!r.restored) { await session.bootGuest(); log(`no trusted session (${r.reason}); started as a guest — sign up or unlock`); }
+  await refresh();
+});
+$('signup').onclick = () => run('sign up', async () => {
+  const { recoveryCode } = await session.registerCurrentIdentity({ label: 'this browser', passkey: 'none' });
+  $('recovery').textContent = `Your recovery code (shown once, keep it): ${recoveryCode}`;
+  await refresh();
+});
+$('signup-passkey').onclick = () => run('sign up with a passkey', async () => {
+  const { recoveryCode } = await session.registerCurrentIdentity({ label: 'this browser', passkey: 'platform' });
+  $('recovery').textContent = `Your recovery code (shown once, keep it): ${recoveryCode}`;
+  await refresh();
+});
+$('unlock').onclick = () => run('unlock', async () => { await session.unlockWithRecoveryCode($('code').value); await refresh(); });
+$('lock').onclick = () => run('lock', () => session.lock());
+$('new').onclick = () => run('create', async () => { await notes.create({ title: $('new-title').value || 'Untitled', body: '' }); $('new-title').value = ''; await refresh(); });
+$('save').onclick = () => run('save', async () => { await notes.update($('note-id').value, { title: $('title').value, body: $('body').value }); await refresh(); });
+$('open-link').onclick = () => run('open link', async () => {
+  const token = tokenFromLocation($('link').value.includes('#') ? $('link').value.slice($('link').value.indexOf('#')) : `#note=${$('link').value}`);
+  if (!token) throw new Error('no token in that address');
+  const note = await notes.open(token);
+  log(`opened "${note.title}" (creator ${note.verifiedCreator ? 'verified' : 'not verified'})`);
+  await refresh();
+});
+$('delete-account').onclick = () => run('delete account', async () => { await session.deleteAccount(); await refresh(); });
+const token = tokenFromLocation(location.hash);
+if (token) { $('link').value = location.href; log('a shared note is in this address: boot, sign up or unlock, then press "open link"'); }
+setSignedIn(false);
+log('ready — press Boot');

package/package.json ADDED Viewed

@@ -0,0 +1,30 @@
+{
+  "name": "@microtoll/mcp",
+  "version": "0.1.0",
+  "description": "Microtoll Engine inside your coding tool: docs search, page reading and a project scaffold over the Model Context Protocol (stdio). Zero dependencies, no network, nothing runs but what is in src/.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "bin": {
+    "microtoll-mcp": "bin/microtoll-mcp.mjs"
+  },
+  "files": [
+    "src",
+    "bin",
+    "generated",
+    "types",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=24"
+  }
+}