@agimon-ai/doompi-web-security 0.0.1-alpha.40 → 0.0.1-alpha.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agimon-ai/doompi-web-security",
-  "version": "0.0.1-alpha.40",
+  "version": "0.0.1-alpha.42",
   "description": "Shared security primitives for the DoomPi web cockpit: sealed channels and signed bundle manifests for independently trusted verifiers.",
   "keywords": [
     "ai",

package/dist/browser.d.cts

@@ -1,5 +0,0 @@
-import { BUNDLE_MANIFEST_ROUTE, BUNDLE_MANIFEST_VERSION, BundleAsset, BundleManifest, SignedBundleManifest, assetFor, canonicalManifest, digestFor, isBundleManifest, isSignedBundleManifest } from "./types/bundleManifest.cjs";
-import { BundleAssetVerificationFailure, BundleAssetVerificationResult, BundleVerificationFailure, BundleVerificationResult, verifyBundleAsset, verifySignedBundleManifest } from "./services/browserBundleVerifier/index.cjs";
-import { OpenResult, SealResult, SealedChannel, channelFromSecret, connectSealedChannel } from "./services/browserSealedChannel/index.cjs";
-import { SealedTransport, createSealedTransport, sealedTransport } from "./services/sealedTransport/index.cjs";
-export { BUNDLE_MANIFEST_ROUTE, BUNDLE_MANIFEST_VERSION, type BundleAsset, type BundleAssetVerificationFailure, type BundleAssetVerificationResult, type BundleManifest, type BundleVerificationFailure, type BundleVerificationResult, type OpenResult, type SealResult, type SealedChannel, type SealedTransport, type SignedBundleManifest, assetFor, canonicalManifest, channelFromSecret, connectSealedChannel, createSealedTransport, digestFor, isBundleManifest, isSignedBundleManifest, sealedTransport, verifyBundleAsset, verifySignedBundleManifest };

package/dist/index.d.cts

@@ -1,4 +0,0 @@
-import { BUNDLE_MANIFEST_ROUTE, BUNDLE_MANIFEST_VERSION, BundleAsset, BundleManifest, SignedBundleManifest, assetFor, canonicalManifest, digestFor, isBundleManifest, isSignedBundleManifest } from "./types/bundleManifest.cjs";
-import { CLIENT_TO_SERVER_INFO, MAX_MESSAGES_PER_KEY, NONCE_BYTES, NONCE_COUNTER_BYTES, NONCE_PREFIX_BYTES, SEALED_BODY_HEADER, SEALED_CLIENT_KEY_HEADER, SEALED_KEY_PARAM, SEALED_VERSION, SERVER_TO_CLIENT_INFO, SealedDirection, SealedEnvelope, SealedFailure, describeSealedFailure, infoFor, isSealedEnvelope } from "./types/sealedChannel.cjs";
-import { SerialQueue, createSerialQueue } from "./services/serialQueue/index.cjs";
-export { BUNDLE_MANIFEST_ROUTE, BUNDLE_MANIFEST_VERSION, type BundleAsset, type BundleManifest, CLIENT_TO_SERVER_INFO, MAX_MESSAGES_PER_KEY, NONCE_BYTES, NONCE_COUNTER_BYTES, NONCE_PREFIX_BYTES, SEALED_BODY_HEADER, SEALED_CLIENT_KEY_HEADER, SEALED_KEY_PARAM, SEALED_VERSION, SERVER_TO_CLIENT_INFO, type SealedDirection, type SealedEnvelope, type SealedFailure, type SerialQueue, type SignedBundleManifest, assetFor, canonicalManifest, createSerialQueue, describeSealedFailure, digestFor, infoFor, isBundleManifest, isSealedEnvelope, isSignedBundleManifest };

package/dist/node.d.cts

@@ -1,3 +0,0 @@
-import { ClientHandshake, HostHandshake, OpenResult, SealResult, SealedChannel, createClientHandshake, createHostHandshake } from "./services/nodeSealedChannel/index.cjs";
-import { BundleSigner, createBundleSigner, publicKeyOf } from "./services/bundleSigner/index.cjs";
-export { type BundleSigner, type ClientHandshake, type HostHandshake, type OpenResult, type SealResult, type SealedChannel, createBundleSigner, createClientHandshake, createHostHandshake, publicKeyOf };

package/dist/services/browserBundleVerifier/index.d.cts

@@ -1,44 +0,0 @@
-import { BundleManifest } from "../../types/bundleManifest.cjs";
-//#region src/services/browserBundleVerifier/index.d.ts
-export type BundleVerificationFailure = {
-  code: 'invalid-envelope';
-} | {
-  code: 'untrusted-public-key';
-} | {
-  code: 'stale-revision';
-  minimumRevision: number;
-  actualRevision: number;
-} | {
-  code: 'invalid-public-key';
-} | {
-  code: 'invalid-signature';
-};
-export type BundleVerificationResult = {
-  ok: true;
-  manifest: BundleManifest;
-} | {
-  ok: false;
-  failure: BundleVerificationFailure;
-};
-export type BundleAssetVerificationFailure = {
-  code: 'asset-not-listed';
-  path: string;
-} | {
-  code: 'byte-length-mismatch';
-  expected: number;
-  actual: number;
-} | {
-  code: 'digest-mismatch';
-};
-export type BundleAssetVerificationResult = {
-  ok: true;
-} | {
-  ok: false;
-  failure: BundleAssetVerificationFailure;
-};
-/** Verifies a strict envelope against a separately trusted key and revision floor. */
-export declare function verifySignedBundleManifest(value: unknown, trustedPublicKey: string, minimumRevision?: number): Promise<BundleVerificationResult>;
-/** Verifies fetched raw response bytes against an authenticated manifest. */
-export declare function verifyBundleAsset(manifest: BundleManifest, assetPath: string, bytes: ArrayBuffer): Promise<BundleAssetVerificationResult>;
-//#endregion
-//# sourceMappingURL=index.d.cts.map

package/dist/services/browserBundleVerifier/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/browserBundleVerifier/index.ts"],"mappings":";;YAQY;EACN;;EACA;;EACA;EAAwB;EAAyB;;EACjD;;EACA;;YAEM;EACN;EAAU,UAAU;;EACpB;EAAW,SAAS;;YAEd;EACN;EAA0B;;EAC1B;EAA8B;EAAkB;;EAChD;;YAEM;EAAkC;;EAAe;EAAW,SAAS;;;wBAgB3D,2BACpB,gBACA,0BACA,2BACC,QAAQ;;wBAsCW,kBACpB,UAAU,gBACV,mBACA,OAAO,cACN,QAAQ"}

package/dist/services/browserSealedChannel/index.d.cts

@@ -1,35 +0,0 @@
-import { SealedDirection, SealedEnvelope, SealedFailure } from "../../types/sealedChannel.cjs";
-//#region src/services/browserSealedChannel/index.d.ts
-export type SealResult = {
-  ok: true;
-  envelope: SealedEnvelope;
-} | {
-  ok: false;
-  failure: SealedFailure;
-};
-export type OpenResult = {
-  ok: true;
-  plaintext: Uint8Array;
-} | {
-  ok: false;
-  failure: SealedFailure;
-};
-export interface SealedChannel {
-  seal(plaintext: Uint8Array): Promise<SealResult>;
-  open(envelope: unknown): Promise<OpenResult>;
-}
-/**
- * Completes the handshake against the host key read out of the QR fragment.
- *
- * That key never travelled through the tunnel, which is what makes this
- * authenticated: a relay can watch the client's public key go past and learn
- * nothing, and it cannot substitute the host's because it never carried it.
- */
-export declare function connectSealedChannel(hostPublicKey: string): Promise<{
-  channel: SealedChannel;
-  clientPublicKey: string;
-} | undefined>;
-/** Exposed so a test can build the browser side against a known secret. */
-export declare function channelFromSecret(secret: ArrayBuffer, sendDirection: SealedDirection, noncePrefix: Uint8Array): Promise<SealedChannel>;
-//#endregion
-//# sourceMappingURL=index.d.cts.map

package/dist/services/browserSealedChannel/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/browserSealedChannel/index.ts"],"mappings":";;YA8BY;EAAe;EAAU,UAAU;;EAAqB;EAAW,SAAS;;YAC5E;EAAe;EAAU,WAAW;;EAAiB;EAAW,SAAS;;iBAEpE;EACf,KAAK,WAAW,aAAa,QAAQ;EACrC,KAAK,oBAAoB,QAAQ;;;;;;;;;wBA+Gb,qBACpB,wBACC;EAAU,SAAS;EAAe;;;wBAyBf,kBACpB,QAAQ,aACR,eAAe,iBACf,aAAa,aACZ,QAAQ"}

package/dist/services/bundleSigner/index.d.cts

@@ -1,17 +0,0 @@
-import { SignedBundleManifest } from "../../types/bundleManifest.cjs";
-//#region src/services/bundleSigner/index.d.ts
-export interface BundleSigner {
-  /** Base64url SPKI for an independently trusted verifier to pin. */
-  publicKey(): string;
-  /** Hashes and signs once per asset directory. Undefined when the bundle is empty. */
-  sign(assetsDir: string): SignedBundleManifest | undefined;
-  /** Invalidates and immediately rebuilds one cached manifest. */
-  refresh(assetsDir: string): SignedBundleManifest | undefined;
-  /** Invalidates one cached directory, or every cached directory when omitted. */
-  invalidate(assetsDir?: string): void;
-}
-export declare function createBundleSigner(stateDir: string, _onNotice?: (message: string) => void): BundleSigner;
-/** Re-derives the public key from a stored private key. */
-export declare function publicKeyOf(privateKeyPem: string): string;
-//#endregion
-//# sourceMappingURL=index.d.cts.map

package/dist/services/bundleSigner/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/bundleSigner/index.ts"],"mappings":";;iBA8CiB;;EAEf;;EAEA,KAAK,oBAAoB;;EAEzB,QAAQ,oBAAoB;;EAE5B,WAAW;;wBAsJG,mBAAmB,kBAAkB,aAAY,2BAAsC;;wBAoDvF,YAAY"}

package/dist/services/nodeSealedChannel/index.d.cts

@@ -1,47 +0,0 @@
-import { SealedEnvelope, SealedFailure } from "../../types/sealedChannel.cjs";
-//#region src/services/nodeSealedChannel/index.d.ts
-export type SealResult = {
-  ok: true;
-  envelope: SealedEnvelope;
-} | {
-  ok: false;
-  failure: SealedFailure;
-};
-export type OpenResult = {
-  ok: true;
-  plaintext: Uint8Array;
-} | {
-  ok: false;
-  failure: SealedFailure;
-};
-export interface SealedChannel {
-  /** Seals one message. Counters advance only on success. */
-  seal(plaintext: Uint8Array): SealResult;
-  open(envelope: unknown): OpenResult;
-}
-export interface HostHandshake {
-  /** Base64url uncompressed P-256 point, printed in the QR. */
-  publicKey: string;
-  /** Completes the exchange against the peer's key and yields the channel. */
-  accept(peerPublicKey: string): SealedChannel | undefined;
-}
-export interface ClientHandshake {
-  /** Base64url uncompressed P-256 point sent to the host. */
-  publicKey: string;
-  /** Completes the exchange against the host's fresh key and yields the channel. */
-  accept(hostPublicKey: string): SealedChannel | undefined;
-}
-/**
- * The host half of the handshake.
- *
- * The ephemeral key pair is generated per tunnel and its public half goes in the
- * QR, which is the out-of-band channel that makes this authenticated. A relay
- * that swaps the client's key gets a channel with itself and nothing from the
- * host, because the host only ever derives against the key the client presents
- * and the client only ever derives against the key it read off the screen.
- */
-export declare function createHostHandshake(): HostHandshake;
-/** Creates the client half for a single fresh peer handshake. */
-export declare function createClientHandshake(): ClientHandshake;
-//#endregion
-//# sourceMappingURL=index.d.cts.map

package/dist/services/nodeSealedChannel/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/nodeSealedChannel/index.ts"],"mappings":";;YAsBY;EAAe;EAAU,UAAU;;EAAqB;EAAW,SAAS;;YAC5E;EAAe;EAAU,WAAW;;EAAiB;EAAW,SAAS;;iBAEpE;;EAEf,KAAK,WAAW,aAAa;EAC7B,KAAK,oBAAoB;;iBAGV;;EAEf;;EAEA,OAAO,wBAAwB;;iBAGhB;;EAEf;;EAEA,OAAO,wBAAwB;;;;;;;;;;;wBA6GjB,uBAAuB;;wBAwBvB,yBAAyB"}

package/dist/services/sealedTransport/index.d.cts

@@ -1,42 +0,0 @@
-//#region src/services/sealedTransport/index.d.ts
-export interface SealedTransport {
-  /** False on loopback and before the handshake completes, where everything passes through. */
-  active(): boolean;
-  sealText(text: string): Promise<string>;
-  /** Undefined when the message could not be opened; `lastFailure` says why. */
-  openText(text: string): Promise<string | undefined>;
-  sealBinary(bytes: Uint8Array): Promise<Uint8Array>;
-  openBinary(bytes: Uint8Array): Promise<Uint8Array | undefined>;
-  /** Drop-in for `fetch`, relaying the complete request through the sealed channel when configured. */
-  fetch(input: string, init?: RequestInit): Promise<Response>;
-  lastFailure(): string | undefined;
-}
-export declare function createSealedTransport(): SealedTransport & {
-  /** Completes the handshake against the host key from the QR. */
-  connect: (hostPublicKey: string) => Promise<string | undefined>;
-  /** Drops the channel, so everything falls back to pass-through. */
-  reset: () => void;
-  /** Selects the same-origin endpoint that carries sealed HTTP exchanges. */
-  relayRequestsThrough: (path: string) => void;
-};
-/**
- * The page's one sealed channel.
- *
- * A module singleton rather than an instance per caller, because the cockpit
- * and every plugin are bundled into the same page and all of them must share
- * one pair of nonce counters. Two transports over one handshake would each
- * start counting at zero and the receiver would reject the second as a replay.
- *
- * Inactive until a handshake completes, and inactive forever on the loopback
- * listener, so `sealedTransport.fetch` is a plain `fetch` there.
- */
-export declare const sealedTransport: SealedTransport & {
-  /** Completes the handshake against the host key from the QR. */
-  connect: (hostPublicKey: string) => Promise<string | undefined>;
-  /** Drops the channel, so everything falls back to pass-through. */
-  reset: () => void;
-  /** Selects the same-origin endpoint that carries sealed HTTP exchanges. */
-  relayRequestsThrough: (path: string) => void;
-};
-//#endregion
-//# sourceMappingURL=index.d.cts.map

package/dist/services/sealedTransport/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/sealedTransport/index.ts"],"mappings":";iBAqBiB;;EAEf;EACA,SAAS,eAAe;;EAExB,SAAS,eAAe;EACxB,WAAW,OAAO,aAAa,QAAQ;EACvC,WAAW,OAAO,aAAa,QAAQ;;EAEvC,MAAM,eAAe,OAAO,cAAc,QAAQ;EAClD;;wBA4Dc,yBAAyB;;EAEvC,UAAU,0BAA0B;;EAEpC;;EAEA,uBAAuB;;;;;;;;;;;;;qBAmJZ,iBAAe;;EAvJjB,UAAC,0BAA0B;;EAE7B;;EAEe,uBAAC"}

package/dist/services/serialQueue/index.d.cts

@@ -1,22 +0,0 @@
-//#region src/services/serialQueue/index.d.ts
-/**
- * Runs async work strictly one at a time, in the order it was handed over.
- *
- * The sealed channel needs this on both directions and it is not an
- * optimisation. Sealing increments a nonce counter and opening enforces that
- * the counter strictly increases, so two overlapping operations are a
- * correctness bug rather than a race worth tolerating: two concurrent seals can
- * resolve out of order and reach the wire with descending counters, and two
- * concurrent opens can advance the high-water mark past a message that has not
- * been read yet, which the receiver then rejects as a replay.
- *
- * Deliberately not a general work pool. A pool with any concurrency above one
- * reintroduces exactly the reordering this exists to prevent.
- */
-export interface SerialQueue {
-  /** Resolves with the task's result once every task queued before it has settled. */
-  run<T>(task: () => Promise<T>): Promise<T>;
-}
-export declare function createSerialQueue(): SerialQueue;
-//#endregion
-//# sourceMappingURL=index.d.cts.map

package/dist/services/serialQueue/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/serialQueue/index.ts"],"mappings":";;;;;;;;;;;;;;;iBAciB;;EAEf,IAAI,GAAG,YAAY,QAAQ,KAAK,QAAQ;;wBAG1B,qBAAqB"}

package/dist/types/bundleManifest.d.cts

@@ -1,44 +0,0 @@
-//#region src/types/bundleManifest.d.ts
-/**
- * A signed description of cockpit assets for an independently trusted verifier.
- *
- * A manifest does not let a browser SPA defend itself against the server or TLS
- * edge that supplied its executable code. Consumers need a separately trusted
- * bootstrap and key before these signatures become a delivery guarantee.
- */
-export declare const BUNDLE_MANIFEST_ROUTE = "/bundle-manifest.json";
-export declare const BUNDLE_MANIFEST_VERSION = 2;
-export interface BundleAsset {
-  /** Normalized absolute URL path, without a query or fragment. */
-  path: string;
-  /** Lowercase hex SHA-256 of the served bytes. */
-  sha256: string;
-  byteLength: number;
-  /** MIME type of the response, without parameters. */
-  contentType: string;
-}
-export interface BundleManifest {
-  version: typeof BUNDLE_MANIFEST_VERSION;
-  /** Monotonically increasing persistent signer revision. */
-  revision: number;
-  /** Unix time in milliseconds. */
-  builtAt: number;
-  assets: BundleAsset[];
-}
-export interface SignedBundleManifest {
-  manifest: BundleManifest;
-  /** Base64url IEEE P1363 ECDSA P-256 signature over the canonical serialization. */
-  signature: string;
-  /** Base64url SPKI of the signing key. Trust must be established out of band. */
-  publicKey: string;
-}
-/** The exact bytes signed by Node and verified by WebCrypto. */
-export declare function canonicalManifest(manifest: BundleManifest): string;
-export declare function isBundleManifest(value: unknown): value is BundleManifest;
-export declare function isSignedBundleManifest(value: unknown): value is SignedBundleManifest;
-/** The recorded asset for one path, or undefined if the manifest does not cover it. */
-export declare function assetFor(manifest: BundleManifest, path: string): BundleAsset | undefined;
-/** The recorded digest for one asset, or undefined if the manifest does not cover it. */
-export declare function digestFor(manifest: BundleManifest, path: string): string | undefined;
-//#endregion
-//# sourceMappingURL=bundleManifest.d.cts.map

package/dist/types/bundleManifest.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundleManifest.d.cts","names":[],"sources":["../../src/types/bundleManifest.ts"],"mappings":";;;;;;;;qBAQa;qBACA;iBAMI;;EAEf;;EAEA;EACA;;EAEA;;iBAGe;EACf,gBAAgB;;EAEhB;;EAEA;EACA,QAAQ;;iBAGO;EACf,UAAU;;EAEV;;EAEA;;;wBAwBc,kBAAkB,UAAU;wBAU5B,iBAAiB,iBAAiB,SAAS;wBAsB3C,uBAAuB,iBAAiB,SAAS;;wBAgBjD,SAAS,UAAU,gBAAgB,eAAe;;wBAKlD,UAAU,UAAU,gBAAgB"}

package/dist/types/sealedChannel.d.cts

@@ -1,76 +0,0 @@
-//#region src/types/sealedChannel.d.ts
-/**
- * The envelope that keeps the tunnel provider out of the payload.
- *
- * Cloudflare terminates TLS at its edge, so everything the cockpit carries
- * (prompts, file previews, model output) is plaintext to them. Sealing the
- * payload underneath their TLS leaves them a relay that can see timing and
- * sizes but not content.
- *
- * The key exchange is anchored on the QR rather than negotiated in band: the
- * host's ephemeral public key is printed on a screen the user is holding, so
- * there is no moment at which a relay could substitute its own. That is the
- * same job Telegram's emoji comparison does for a secret chat, except it
- * happens automatically instead of depending on two people comparing pictures.
- *
- * Declared here because the server seals with `node:crypto` and the browser
- * unseals with WebCrypto, and an envelope is only an envelope if both sides
- * read it identically.
- */
-/** Bumped when the envelope layout changes; a mismatch is refused, never guessed at. */
-export declare const SEALED_VERSION = 1;
-/** Fragment key in the pairing URL carrying the host's ephemeral public key. */
-export declare const SEALED_KEY_PARAM = "k";
-/** AES-GCM standard nonce length. Longer is non-standard, shorter is unsafe. */
-export declare const NONCE_BYTES = 12;
-/** Random per-channel prefix, so two channels never share a nonce space. */
-export declare const NONCE_PREFIX_BYTES = 4;
-/** Monotonic per-direction counter filling the rest of the nonce. */
-export declare const NONCE_COUNTER_BYTES: number;
-/**
- * Rekey well before the counter could wrap.
- *
- * A repeated nonce under one AES-GCM key is catastrophic, not merely weak: it
- * leaks the XOR of two plaintexts and the authentication subkey. The counter is
- * 64 bits, so this bound is nowhere near it; the point is that the bound exists
- * and is enforced rather than assumed.
- */
-export declare const MAX_MESSAGES_PER_KEY: number;
-/**
- * HKDF info strings, one per direction.
- *
- * Separate keys per direction, not one shared key, so a message the server sent
- * can never be replayed back at it as though the client had sent it.
- */
-export declare const CLIENT_TO_SERVER_INFO = "doompi/sealed/c2s/v1";
-export declare const SERVER_TO_CLIENT_INFO = "doompi/sealed/s2c/v1";
-export type SealedDirection = 'c2s' | 's2c';
-export declare function infoFor(direction: SealedDirection): string;
-/**
- * One sealed message, as it travels.
- *
- * Base64url rather than binary so the same envelope works on a JSON body and a
- * text WebSocket frame without a second encoding path to get wrong.
- */
-export interface SealedEnvelope {
-  v: number;
-  /** Base64url, 4-byte prefix plus 8-byte counter. */
-  n: string;
-  /** Base64url ciphertext with the GCM tag appended. */
-  c: string;
-}
-export declare function isSealedEnvelope(value: unknown): value is SealedEnvelope;
-/** Header naming the client's ephemeral public key during the handshake. */
-export declare const SEALED_CLIENT_KEY_HEADER = "x-doompi-channel-key";
-/** Header carrying a sealed request body's envelope on a non-JSON request. */
-export declare const SEALED_BODY_HEADER = "x-doompi-sealed";
-export type SealedFailure = 'version' | 'malformed' | 'replay' | 'auth' | 'exhausted';
-/**
- * Why an unseal failed, in words a diagnostic can show.
- *
- * A decryption failure means a blank cockpit, so every one of these has to name
- * its cause rather than leaving a dead page and no explanation.
- */
-export declare function describeSealedFailure(failure: SealedFailure): string;
-//#endregion
-//# sourceMappingURL=sealedChannel.d.cts.map

package/dist/types/sealedChannel.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sealedChannel.d.cts","names":[],"sources":["../../src/types/sealedChannel.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAoBa;;qBAGA;;qBAGA;;qBAEA;;qBAEA;;;;;;;;;qBAUA;;;;;;;qBAQA;qBACA;YAED;wBAEI,QAAQ,WAAW;;;;;;;iBAUlB;EACf;;EAEA;;EAEA;;wBAGc,iBAAiB,iBAAiB,SAAS;;qBAO9C;;qBAEA;YAED;;;;;;;wBAQI,sBAAsB,SAAS"}