@mdbase-dev/connect 0.1.0-beta.23 → 0.1.0-beta.25

package/README.md

@@ -33,7 +33,14 @@ if (!started.ok) {
   return;
 }
 if (session.getSnapshot().status === "unselected") {
-  const authorized = await session.authorize("choose");
+  const authorized = await session.authorize("choose", {
+    onFirstContact: ({ authenticationString }) => {
+      showPersistentSecurityPrompt({
+        title: "Compare with mdbase connect",
+        code: authenticationString
+      });
+    }
+  });
   if (!authorized.ok) {
     renderProblem(authorized.problem);
     return;
@@ -72,15 +79,15 @@ problem model, setup failures, mutation uncertainty, and UI guidance.
 
 `MdbaseConnect` is the application-level authorization registry.
 `MdbaseSession` is the normal application boundary: it owns active collection
-selection, authorization callback completion, access capabilities, and one
+selection, authorization completion, access capabilities, and one
 reactive snapshot. Use `getSnapshot()` and `subscribe()` directly or through
 your framework's external-store integration. A snapshot is `unselected`,
 `ready`, or `unavailable`; an unavailable bookmark includes the explicit
 collection ID and reason instead of collapsing every recovery state to `null`.
 
 `MdbaseBrowserSelection` keeps the stable collection ID in
-`?collection=<id>`, preserves unrelated path/query/hash and router state,
-restores authorization callbacks safely, and reports browser back/forward
+`?collection=<id>`, preserves unrelated path/query/hash and router state, and
+reports browser back/forward
 changes to the session. The session auto-selects only when exactly one saved
 connection exists. Switching is state-driven and must not reload the page:
 
@@ -104,6 +111,16 @@ Collection IDs are opaque non-secret locators that may appear in browser
 history and logs. Grants remain the authorization boundary, and names are
 display text that may change.
 
+When the chosen collection is owned by a computer that has not seen this
+application installation before, `onFirstContact` is required. The SDK derives
+the eight-character value locally from the application's non-extractable
+installation key and the connector key; it never accepts a value supplied by
+the control plane. Keep the value visible while the user compares and accepts
+the exact same value in mdbase connect. Headless operators use
+`mdbase connect trust list`, `trust show <id>`, and
+`trust accept <id> --code XXXX-XXXX`. Hosted-only authorization does not invoke
+this callback.
+
 Bundled v1 application manifests can declare runtime notification criteria.
 Register a service worker from a user gesture to receive standards-based Web
 Push while the app is closed:
@@ -378,12 +395,13 @@ Authorization is retained in `localStorage` by default. Access tokens are
 renewed with rotating refresh tokens; passing a custom `Storage` implementation
 allows a host to choose another persistence boundary.
 
-Native shells can pass `navigate` to open the authorization URL in the system
+Native shells can pass `navigate` to open the approval URL in the system
 browser and list a reverse-domain callback such as
 `dev.mdbase.worklog://auth/mdbase/callback` in the bundled declaration. Its
-scheme must match the declaration ID. PKCE remains mandatory. Call
-`completeAuthorization(callbackUrl)` when the application receives the deep
-link.
+scheme must match the declaration ID. The application remains alive, polls the
+PKCE-bound status endpoint, displays first contact when required, and receives
+the completed connection directly from `authorize()`; the browser does not
+carry credentials back through a deep link.
 
 New authorizations require encrypted relay protocol 1 by default. The SDK keeps
 independent non-extractable P-256 ECDH agreement and ECDSA signing keys plus an

package/dist/application-identity.d.ts

@@ -0,0 +1,5 @@
+import { authorizationSigningMessage, type ApplicationAuthorizationBinding, type ApplicationAuthorizationProof } from "@mdbase-dev/connect-protocol";
+import type { GrantKeyRecord } from "./crypto.js";
+export { authorizationSigningMessage };
+export declare function applicationInstallationId(identity: Pick<GrantKeyRecord, "agreementPublicKey" | "signingPublicKey">): Promise<string>;
+export declare function signApplicationAuthorization(binding: ApplicationAuthorizationBinding, identity: Pick<GrantKeyRecord, "signingPrivateKey" | "agreementPublicKey" | "signingPublicKey">): Promise<ApplicationAuthorizationProof>;

package/dist/application-identity.js

@@ -0,0 +1,56 @@
+import { applicationInstallationIdFromPublicKeys, authorizationSigningMessage } from "@mdbase-dev/connect-protocol";
+const P256_ORDER = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
+const P256_HALF_ORDER = P256_ORDER / 2n;
+export { authorizationSigningMessage };
+export async function applicationInstallationId(identity) {
+    return applicationInstallationIdFromPublicKeys(identity.agreementPublicKey, identity.signingPublicKey);
+}
+export async function signApplicationAuthorization(binding, identity) {
+    if (binding.installation_agreement_public_key !== identity.agreementPublicKey
+        || binding.installation_signing_public_key !== identity.signingPublicKey
+        || binding.application_installation_id !== await applicationInstallationId(identity)) {
+        throw new Error("Application authorization identity does not match its binding.");
+    }
+    const signature = canonicalSignature(new Uint8Array(await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, identity.signingPrivateKey, authorizationSigningMessage(binding))));
+    return {
+        binding,
+        signature: base64Url(signature)
+    };
+}
+function concat(values) {
+    const output = new Uint8Array(values.reduce((length, value) => length + value.byteLength, 0));
+    let offset = 0;
+    for (const value of values) {
+        output.set(value, offset);
+        offset += value.byteLength;
+    }
+    return output;
+}
+function base64Url(value) {
+    return btoa(String.fromCharCode(...value))
+        .replaceAll("+", "-")
+        .replaceAll("/", "_")
+        .replace(/=+$/u, "");
+}
+function canonicalSignature(signature) {
+    if (signature.byteLength !== 64) {
+        throw new Error("Application authorization signature is invalid.");
+    }
+    const s = bytesBigInt(signature.slice(32));
+    if (s === 0n || s >= P256_ORDER) {
+        throw new Error("Application authorization signature is invalid.");
+    }
+    if (s <= P256_HALF_ORDER)
+        return signature;
+    return concat([signature.slice(0, 32), bigIntBytes(P256_ORDER - s, 32)]);
+}
+function bytesBigInt(value) {
+    return BigInt(`0x${hex(value)}`);
+}
+function bigIntBytes(value, length) {
+    const encoded = value.toString(16).padStart(length * 2, "0");
+    return Uint8Array.from({ length }, (_, index) => Number.parseInt(encoded.slice(index * 2, index * 2 + 2), 16));
+}
+function hex(value) {
+    return [...value].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}

package/dist/browser/integrity.json

@@ -1,4 +1,4 @@
 {
   "file": "mdbase-connect.min.js",
-  "integrity": "sha384-5i/BVtYUAqTluHzqWtHkb2tI4mKjuOsQMdAKhtXjddN95BAkTPOpub7++MQX+fU0"
+  "integrity": "sha384-Rejwyx0zN9iv54K0UaKMWs09sQLXcxnOBtKT574KVKlC7aR4FZ7CqpPRMd7mKlNl"
 }