meta-sovereign 0.53.2 → 0.53.3

package/README.md

@@ -370,3 +370,5 @@ The CI/CD pipeline inherited from `js-ai-driven-development-pipeline-template` c
 ## License
 
 [Unlicense](LICENSE) - Public Domain
+
+Reloads and browser history preserve your section and conversation context; see [navigation](docs/NAVIGATION.md). [Mini App recovery](docs/MINI-APPS.md) documents SDK compatibility and external-site limitations.

package/js/src/server/local-certificate-check.js

@@ -0,0 +1,82 @@
+// Verify our ECDSA certificate using portable crypto primitives. Deno exposes
+// X509Certificate but omits verify(), checkPrivateKey() and subjectAltName.
+import crypto from 'node:crypto';
+
+const der = (data, start = 0) => {
+  const tag = data[start];
+  let length = data[start + 1];
+  let offset = start + 2;
+  if (length & 0x80) {
+    const count = length & 0x7f;
+    if (!count || count > 4) {
+      throw new Error('invalid DER length');
+    }
+    length = 0;
+    for (let n = 0; n < count; n++) {
+      length = length * 256 + data[offset++];
+    }
+  }
+  const end = offset + length;
+  if (!Number.isInteger(end) || end > data.length) {
+    throw new Error('truncated DER');
+  }
+  return {
+    tag,
+    end,
+    raw: data.subarray(start, end),
+    body: data.subarray(offset, end),
+  };
+};
+const children = (data) => {
+  const parts = [];
+  for (let offset = 0; offset < data.length;) {
+    const part = der(data, offset);
+    parts.push(part);
+    offset = part.end;
+  }
+  return parts;
+};
+const SAN_OID = Buffer.from('0603551d11', 'hex');
+const ECDSA_SHA256 = Buffer.from('300a06082a8648ce3d040302', 'hex');
+
+export const matchesLocalCertificate = (cert, key, { now, renewMs, san }) => {
+  try {
+    const x509 = new crypto.X509Certificate(cert);
+    if (
+      x509.ca ||
+      Date.parse(x509.validFrom) > now ||
+      Date.parse(x509.validTo) - now <= renewMs
+    ) {
+      return false;
+    }
+    const encoded = String(cert).replace(/-----[^-]+-----|\s/g, '');
+    const root = der(Buffer.from(encoded, 'base64'));
+    const [tbs, algorithm, signature] = children(root.body);
+    if (!algorithm.raw.equals(ECDSA_SHA256) || signature.body[0] !== 0) {
+      return false;
+    }
+    const fields = children(tbs.body);
+    const extensions = children(
+      children(fields.find((field) => field.tag === 0xa3).body)[0].body
+    );
+    const names = extensions.filter((ext) =>
+      children(ext.body)[0].raw.equals(SAN_OID)
+    );
+    if (names.length !== 1 || !names[0].raw.equals(san)) {
+      return false;
+    }
+    const publicKey = crypto.createPublicKey(crypto.createPrivateKey(key));
+    const exportKey = (value) => value.export({ type: 'spki', format: 'der' });
+    return (
+      exportKey(publicKey).equals(exportKey(x509.publicKey)) &&
+      crypto.verify(
+        'sha256',
+        tbs.raw,
+        x509.publicKey,
+        signature.body.subarray(1)
+      )
+    );
+  } catch {
+    return false;
+  }
+};

package/js/src/server/local-tls.js

@@ -17,6 +17,7 @@
  */
 
 import crypto from 'node:crypto';
+import { matchesLocalCertificate } from './local-certificate-check.js';
 import { promises as fs } from 'node:fs';
 import net from 'node:net';
 import path from 'node:path';
@@ -155,25 +156,19 @@ export const makeLocalCertificate = ({
   };
 };
 
-const usable = (cert, key, now) => {
-  try {
-    const x509 = new crypto.X509Certificate(cert);
-    return (
-      !x509.ca &&
-      x509.verify(x509.publicKey) &&
-      x509.checkPrivateKey(crypto.createPrivateKey(key)) &&
-      Date.parse(x509.validFrom) <= now &&
-      Date.parse(x509.validTo) - now > RENEW_DAYS * DAY_MS &&
-      x509.subjectAltName?.split(', ').length === 3 &&
-      x509.subjectAltName.includes('DNS:localhost') &&
-      x509.subjectAltName.includes('IP Address:127.0.0.1') &&
-      (x509.subjectAltName.includes('IP Address:0:0:0:0:0:0:0:1') ||
-        x509.subjectAltName.includes('IP Address:::1'))
-    );
-  } catch {
-    return false;
-  }
-};
+const usable = (cert, key, now) =>
+  matchesLocalCertificate(cert, key, {
+    now,
+    renewMs: RENEW_DAYS * DAY_MS,
+    san: extension(
+      '2.5.29.17',
+      seq(
+        tlv(0x82, Buffer.from('localhost')),
+        tlv(0x87, Buffer.from([127, 0, 0, 1])),
+        tlv(0x87, LOOPBACK_V6)
+      )
+    ),
+  });
 
 /** Where the certificate of a store lives. */
 export const localTlsPaths = (storeDir) => {

package/js/src/sources/telegram-chat-url.js

@@ -2,6 +2,17 @@
 // Use documented username/phone/message links; numeric-only peers use Web A's
 // signed-in chat route instead of launching a native app without a destination.
 // References: core.telegram.org/api/links; Ajaxy/telegram-tt src/util/routing.ts.
+const resolvedLink = (handle, number, native) =>
+  /^[a-zA-Z][a-zA-Z0-9_]{3,31}$/.test(handle)
+    ? native
+      ? `tg://resolve?domain=${handle}`
+      : `https://t.me/${handle}`
+    : /^[1-9]\d{6,14}$/.test(number)
+      ? native
+        ? `tg://resolve?phone=${number}`
+        : `https://t.me/+${number}`
+      : null;
+
 export const telegramChatUrl = ({
   source,
   chat,
@@ -9,23 +20,24 @@ export const telegramChatUrl = ({
   phone,
   lastId,
   text,
+  native = false,
 } = {}) => {
   if (source !== 'telegram' || !/^-?[1-9]\d*$/.test(String(chat))) {
     return null;
   }
   const handle = String(username ?? '').replace(/^@/, '');
   const number = String(phone ?? '').replace(/[\s()+-]/g, '');
-  const native = /^[a-zA-Z][a-zA-Z0-9_]{3,31}$/.test(handle)
-    ? `https://t.me/${handle}`
-    : /^[1-9]\d{6,14}$/.test(number)
-      ? `https://t.me/+${number}`
-      : null;
-  if (native) {
-    return text ? `${native}?text=${encodeURIComponent(text)}` : native;
+  const resolved = resolvedLink(handle, number, native);
+  if (resolved) {
+    return text
+      ? `${resolved}${native ? '&' : '?'}text=${encodeURIComponent(text)}`
+      : resolved;
   }
   const id = String(chat);
   if (/^-100\d+$/.test(id) && /^[1-9]\d*$/.test(String(lastId))) {
-    return `https://t.me/c/${id.slice(4)}/${lastId}`;
+    return native
+      ? `tg://privatepost?channel=${id.slice(4)}&post=${lastId}`
+      : `https://t.me/c/${id.slice(4)}/${lastId}`;
   }
   return `https://web.telegram.org/a/#${id}`;
 };

package/js/src/storage/doublets-mirror.js

@@ -42,6 +42,10 @@ export const snapshotInWorker = (from, to) =>
     let result = null;
     worker.once('message', (message) => {
       result = message;
+      // The message follows the durable rename. Deno's worker compatibility
+      // layer can keep its port alive without emitting an exit event.
+      resolve(message);
+      Promise.resolve(worker.terminate()).catch(() => {});
     });
     worker.once('error', reject);
     worker.once('exit', (code) => {
@@ -92,6 +96,7 @@ const createSnapshots = ({
   let lastAt = 0;
   let lastCost = 0;
   let failures = 0;
+  let closed = false;
   const once = async () => {
     const started = clock.now();
     try {
@@ -115,6 +120,9 @@ const createSnapshots = ({
   };
   let later = null;
   const now = () => {
+    if (closed) {
+      return Promise.resolve(null);
+    }
     clock.clearTimeout(timer);
     timer = null;
     if (queued) {
@@ -123,7 +131,7 @@ const createSnapshots = ({
     if (!inFlight) {
       inFlight = once().finally(() => {
         inFlight = null;
-        if (wanted && !queued) {
+        if (wanted && !queued && !closed) {
           wanted = false;
           later();
         }
@@ -139,7 +147,7 @@ const createSnapshots = ({
     return queued;
   };
   later = () => {
-    if (timer) {
+    if (closed || timer) {
       return;
     }
     if (inFlight || queued) {
@@ -157,7 +165,14 @@ const createSnapshots = ({
     }, wait);
     timer.unref?.();
   };
-  return { now, later };
+  const close = async () => {
+    closed = true;
+    wanted = false;
+    clock.clearTimeout(timer);
+    timer = null;
+    await (queued ?? inFlight);
+  };
+  return { now, later, close };
 };
 
 /**
@@ -230,6 +245,7 @@ export const createDoubletsMirror = async (
     },
     /** Write the snapshot now (after the log) and wait for it. */
     flush: () => snapshots.now(),
+    close: () => snapshots.close(),
     /** A snapshot older than the log is written again, in the background. */
     async refresh() {
       const behind = await stale();

package/js/src/storage/dual-store.js

@@ -245,7 +245,17 @@ export const openDualStore = async (
       // What a backup streams, and the flush of just the log (R-Z16).
       logFile: text.filePath,
       flushLog: () => text.flush(),
-      close: lock.release,
+      async close() {
+        try {
+          await binary.close();
+        } finally {
+          try {
+            await text.flush();
+          } finally {
+            lock.release();
+          }
+        }
+      },
     };
   } catch (error) {
     lock.release();

package/js/src/web/app-navigation.js

@@ -0,0 +1,61 @@
+import { useEffect, useLayoutEffect, useSyncExternalStore } from 'react';
+import { appNavigation } from './app-route.js';
+
+// Wait for async section content to be tall enough before restoring its scroll.
+// User input cancels restoration so it cannot pull the page away afterwards.
+const restoreScroll = (scroll, done) => {
+  const [x, y] = scroll ?? [0, 0];
+  let frame;
+  let stopped = false;
+  const end = () => {
+    stopped = true;
+    globalThis.cancelAnimationFrame(frame);
+    done();
+  };
+  const until = Date.now() + 5000;
+  const apply = () => {
+    const height = globalThis.document.scrollingElement?.scrollHeight ?? 0;
+    if (height - globalThis.innerHeight >= y || Date.now() >= until) {
+      globalThis.scrollTo?.(x, y);
+      end();
+    } else if (!stopped) {
+      frame = globalThis.requestAnimationFrame(apply);
+    }
+  };
+  const events = ['wheel', 'pointerdown', 'touchstart', 'keydown'];
+  events.forEach((event) =>
+    globalThis.addEventListener(event, end, { passive: true, once: true })
+  );
+  apply();
+  return () => {
+    end();
+    events.forEach((event) => globalThis.removeEventListener(event, end));
+  };
+};
+
+export const useAppNavigation = () => {
+  const navigation = appNavigation();
+  const route = useSyncExternalStore(
+    navigation.subscribe,
+    navigation.snapshot,
+    navigation.snapshot
+  );
+  useLayoutEffect(() => navigation.start(), [navigation]);
+  useEffect(() => {
+    const onNavigate = (event) => navigation.go(event.detail ?? {});
+    globalThis.addEventListener('meta-sovereign:navigate', onNavigate);
+    return () =>
+      globalThis.removeEventListener('meta-sovereign:navigate', onNavigate);
+  }, [navigation]);
+  useLayoutEffect(() => {
+    const previous = globalThis.history.scrollRestoration;
+    globalThis.history.scrollRestoration = 'manual';
+    navigation.restoring(true);
+    const stop = restoreScroll(route.scroll, () => navigation.restoring(false));
+    return () => {
+      stop();
+      globalThis.history.scrollRestoration = previous;
+    };
+  }, [route, navigation]);
+  return [route, navigation.go];
+};

package/js/src/web/app-route.js

@@ -0,0 +1,205 @@
+// Section routes coexist with the original chat and provider deep links.
+import { navItems } from './nav-items.js';
+
+export const APP_ROUTE_KEY = 'metaSovereignNavigation';
+const VIEWS = new Set(navItems.map(([view]) => view));
+
+export const splitChatAddress = (key) => {
+  const match = /^([a-z0-9_-]+):(.+)$/i.exec(String(key ?? ''));
+  return match ? { source: match[1], chat: match[2] } : null;
+};
+
+export const parseAppRoute = (hash = '') => {
+  const anchor = String(hash);
+  if (/^#conn-[a-z0-9-]+(?:\/manual)?$/i.test(anchor)) {
+    return { view: 'connections', anchor };
+  }
+  if (anchor.startsWith('#chat=')) {
+    try {
+      const chat = splitChatAddress(decodeURIComponent(anchor.slice(6)));
+      return chat ? { view: 'chat', anchor, chat } : null;
+    } catch {
+      return null;
+    }
+  }
+  const match = /^#\/?([a-z][a-z0-9-]*)(?:\?(.*))?$/.exec(anchor);
+  if (!match || !VIEWS.has(match[1])) {
+    return null;
+  }
+  const view = match[1];
+  const chat = splitChatAddress(new URLSearchParams(match[2]).get('chat'));
+  return { view, anchor, ...(chat ? { chat } : {}) };
+};
+
+export const sectionHash = (view) => `#/${view}`;
+export const operatorHash = (key) =>
+  key ? `#/operator?chat=${encodeURIComponent(key)}` : sectionHash('operator');
+export const chatHash = ({ source, chat }) =>
+  `#chat=${source}:${encodeURIComponent(chat)}`;
+
+const remembered = (env) => {
+  try {
+    const value = JSON.parse(
+      env.sessionStorage?.getItem(APP_ROUTE_KEY) ?? 'null'
+    );
+    return value && typeof value === 'object' ? value : {};
+  } catch {
+    return {};
+  }
+};
+
+const targetFor = (view, anchor, hashes) => {
+  const wanted = anchor === undefined ? hashes[view] : anchor;
+  const next = parseAppRoute(wanted);
+  return next?.view === view ? next : { view, anchor: sectionHash(view) };
+};
+
+const visit = (target, before, replace) => ({
+  ...target,
+  previous: replace ? before.previous : before.anchor,
+  scroll: replace && before.view === target.view ? before.scroll : [0, 0],
+});
+
+/** Browser history is the authority; session storage only remembers sections. */
+export const createAppNavigation = (env = globalThis) => {
+  const memory = remembered(env);
+  const hashes = { ...memory.hashes };
+  const initial = parseAppRoute(env.location?.hash) ??
+    parseAppRoute(hashes[memory.view]) ?? { view: 'chat', anchor: '#/chat' };
+  let route = {
+    ...initial,
+    previous: env.history?.state?.[APP_ROUTE_KEY]?.previous,
+    scroll: env.history?.state?.[APP_ROUTE_KEY]?.scroll ?? [0, 0],
+  };
+  let url = env.location?.hash;
+  let restoring = false;
+  const listeners = new Set();
+  const notify = () => listeners.forEach((listener) => listener());
+  const remember = () => {
+    hashes[route.view] = route.anchor;
+    try {
+      env.sessionStorage?.setItem(
+        APP_ROUTE_KEY,
+        JSON.stringify({ view: route.view, hashes })
+      );
+    } catch {
+      // The URL and history still work with browser storage disabled.
+    }
+  };
+  const write = (next, replace) => {
+    const state = {
+      ...env.history?.state,
+      [APP_ROUTE_KEY]: { ...next, scroll: next.scroll },
+    };
+    env.history?.[replace ? 'replaceState' : 'pushState']?.(
+      state,
+      '',
+      `${env.location?.pathname ?? ''}${env.location?.search ?? ''}${next.anchor}`
+    );
+    url = env.location?.hash;
+  };
+  const saveScroll = () => {
+    if (restoring) {
+      return;
+    }
+    env.history?.replaceState?.(
+      {
+        ...env.history.state,
+        [APP_ROUTE_KEY]: {
+          ...route,
+          scroll: [env.scrollX ?? 0, env.scrollY ?? 0],
+        },
+      },
+      '',
+      env.location?.href
+    );
+  };
+  const accept = () => {
+    if (env.location?.hash === url) {
+      return;
+    }
+    const next = parseAppRoute(env.location?.hash);
+    url = env.location?.hash;
+    if (!next) {
+      return; // In-page anchors such as #root do not switch sections.
+    }
+    const kept = env.history?.state?.[APP_ROUTE_KEY];
+    route = {
+      ...next,
+      previous: kept?.anchor === next.anchor ? kept.previous : route.anchor,
+      scroll: kept?.anchor === next.anchor ? kept.scroll : [0, 0],
+    };
+    write(route, true);
+    remember();
+    notify();
+  };
+  const go = ({ view, anchor } = {}, { replace = false } = {}) => {
+    if (!VIEWS.has(view)) {
+      return;
+    }
+    if (anchor === undefined && route.view === view) {
+      return;
+    }
+    const target = targetFor(view, anchor, hashes);
+    if (
+      route.anchor === target.anchor &&
+      env.location?.hash === target.anchor
+    ) {
+      return;
+    }
+    saveScroll();
+    const oldURL = env.location?.href;
+    route = visit(target, route, replace);
+    write(route, replace);
+    remember();
+    notify();
+    // pushState does not emit hashchange; existing chat/provider listeners need it.
+    if (env.HashChangeEvent) {
+      env.dispatchEvent(
+        new env.HashChangeEvent('hashchange', {
+          oldURL,
+          newURL: env.location?.href,
+        })
+      );
+    }
+  };
+  return {
+    snapshot: () => route,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    go,
+    restoring: (active) => {
+      restoring = active;
+    },
+    back: (detail) => {
+      const target = targetFor(detail.view, detail.anchor, hashes);
+      if (route.previous === target.anchor) {
+        env.history.back();
+      } else {
+        go(detail, { replace: true });
+      }
+    },
+    start: () => {
+      accept();
+      write(route, true);
+      remember();
+      env.addEventListener?.('popstate', accept);
+      env.addEventListener?.('hashchange', accept);
+      env.addEventListener?.('scroll', saveScroll, { passive: true });
+      return () => {
+        env.removeEventListener?.('popstate', accept);
+        env.removeEventListener?.('hashchange', accept);
+        env.removeEventListener?.('scroll', saveScroll);
+      };
+    },
+  };
+};
+
+let browserNavigation;
+export const appNavigation = () =>
+  (browserNavigation ??= createAppNavigation());
+export const navigateApp = (detail, options) =>
+  appNavigation().go(detail, options);
+export const backInApp = (detail) => appNavigation().back(detail);