@agentproto/secrets 0.2.6 → 1.0.0

package/dist/identity/index.d.ts

@@ -1,3 +1,7 @@
+import { C as CryptoProvider } from '../types-B2ZfEhsU.js';
+import { D as DaemonIdentity } from '../core-D8zVNPDb.js';
+export { I as IDENTITY_VERSION, a as IdentityError, b as IdentityKeyPair } from '../core-D8zVNPDb.js';
+
 /**
  * @agentproto/secrets/identity — the daemon's persistent cryptographic
  * identity for E2E pairing (design: PAIRING / DESIGN §1).
@@ -14,52 +18,27 @@
  * shape `@agentproto/secrets/seal` already uses, so the identity file travels
  * as plain JSON and the seal box can consume the X25519 public half verbatim.
  *
- * Everything here is `node:crypto` — X25519, Ed25519, SHA-256 — so the package
- * keeps its zero-native-dependency footprint. The private halves never leave
+ * The crypto (X25519, Ed25519, SHA-256) lives once in ./core.ts against a
+ * `CryptoProvider`; this Node entry defaults to `node:crypto` and adds the
+ * file-backed store. Everything is async (WebCrypto is) and takes an optional
+ * trailing `crypto` to override the provider. The private halves never leave
  * the identity file (mode 0600) and are never logged.
  */
-/** Current identity-file schema version. */
-declare const IDENTITY_VERSION: 1;
-/** Raised for every identity load/generate/sign/verify failure. The message
- *  is safe to surface — it never contains private key material. */
-declare class IdentityError extends Error {
-    constructor(message: string);
-}
-/** One keypair, both halves base64-DER. Public = SPKI, private = PKCS8. */
-interface IdentityKeyPair {
-    /** base64 DER (SPKI) public key — publishable. */
-    pub: string;
-    /** base64 DER (PKCS8) private key — secret. */
-    priv: string;
-}
-/**
- * A daemon's persistent identity. Serialized verbatim to
- * `~/.agentproto/identity.json` (0600). The `x25519` public half is the key a
- * client seals its hello to; the `ed25519` public half is the key a client
- * verifies the daemon's transcript signature against. Both public halves are
- * carried in the offer URL.
- */
-interface DaemonIdentity {
-    v: typeof IDENTITY_VERSION;
-    /** Encryption / key-agreement keypair. */
-    x25519: IdentityKeyPair;
-    /** Signing / authenticity keypair. */
-    ed25519: IdentityKeyPair;
-    /** ISO-8601 creation timestamp. */
-    createdAt: string;
-}
+
 /**
  * Mint a fresh daemon identity: one X25519 keypair (encryption) and one
  * Ed25519 keypair (signing). Called lazily on first `pair offer`.
  */
-declare function generateIdentity(): DaemonIdentity;
+declare function generateIdentity(crypto?: CryptoProvider): Promise<DaemonIdentity>;
 /**
- * Stable short identifier for a daemon, derived from its X25519 public key —
- * the same construction as `sealKeyId` in `@agentproto/secrets/seal` (first 16
- * hex of `sha256(pub DER)`). Displayed everywhere a human confirms identity
- * (offer QR, `pair accept`, `pair ls`). Not a secret.
+ * Stable identifier for a daemon, derived from its X25519 public key: the
+ * first 32 hex (128 bits) of `sha256(pub DER)`. It names the daemon's browser
+ * origin (`<fingerprint>.agentproto.cloud`), so it is long enough to resist a
+ * grind for a colliding key. `sealKeyId` in `@agentproto/secrets/seal` is its
+ * 16-hex prefix. Displayed everywhere a human confirms identity (offer QR,
+ * `pair accept`, `pair ls`). Not a secret.
  */
-declare function identityFingerprint(x25519Pub: string): string;
+declare function identityFingerprint(x25519Pub: string, crypto?: CryptoProvider): Promise<string>;
 /**
  * Load the daemon identity from `filePath`, creating it on first use. The
  * caller supplies the path (typically `~/.agentproto/identity.json`) so this
@@ -73,17 +52,17 @@ declare function identityFingerprint(x25519Pub: string): string;
  */
 declare function loadOrCreateIdentity(filePath: string): Promise<DaemonIdentity>;
 /**
- * Sign a handshake transcript with the daemon's Ed25519 private key. Returns a
- * base64 signature. `transcript` is the exact bytes both sides agree on
+ * Sign a handshake transcript with the daemon's Ed25519 private key. Resolves
+ * to a base64 signature. `transcript` is the exact bytes both sides agree on
  * (`sha256(e_pub ‖ ct₀ ‖ d_e_pub)`); signing it — not the raw messages — is
  * what binds the daemon's authenticity to the whole exchange.
  */
-declare function signTranscript(ed25519Priv: string, transcript: Uint8Array): string;
+declare function signTranscript(ed25519Priv: string, transcript: Uint8Array, crypto?: CryptoProvider): Promise<string>;
 /**
- * Verify a transcript signature against a daemon's Ed25519 public key. Returns
- * a boolean — never throws on a bad signature (only on a structurally invalid
- * key), so callers branch on the result rather than a control-flow exception.
+ * Verify a transcript signature against a daemon's Ed25519 public key. Resolves
+ * to a boolean — never rejects on a bad signature (only on a structurally
+ * invalid key), so callers branch on the result rather than an exception.
  */
-declare function verifyTranscript(ed25519Pub: string, transcript: Uint8Array, signature: string): boolean;
+declare function verifyTranscript(ed25519Pub: string, transcript: Uint8Array, signature: string, crypto?: CryptoProvider): Promise<boolean>;
 
-export { type DaemonIdentity, IDENTITY_VERSION, IdentityError, type IdentityKeyPair, generateIdentity, identityFingerprint, loadOrCreateIdentity, signTranscript, verifyTranscript };
+export { CryptoProvider, DaemonIdentity, generateIdentity, identityFingerprint, loadOrCreateIdentity, signTranscript, verifyTranscript };

package/dist/identity/index.mjs

@@ -1,3 +1,78 @@
-export { IDENTITY_VERSION, IdentityError, generateIdentity, identityFingerprint, loadOrCreateIdentity, signTranscript, verifyTranscript } from '../chunk-2DL6W33G.mjs';
+import { generateIdentity, identityFingerprint, IdentityError, signTranscript, verifyTranscript, IDENTITY_VERSION } from '../chunk-NQX3KBPW.mjs';
+export { IDENTITY_VERSION, IdentityError } from '../chunk-NQX3KBPW.mjs';
+import { nodeCryptoProvider } from '../chunk-5HUHYBPR.mjs';
+import '../chunk-3YRYO6LK.mjs';
+import { readFile, mkdir, writeFile, chmod, rename } from 'fs/promises';
+import { dirname, join, basename } from 'path';
+
+/**
+ * @agentproto/secrets v0.1.0-alpha
+ * AIP-19 SECRETS.md `defineSecrets` reference implementation.
+ */
+function generateIdentity2(crypto = nodeCryptoProvider) {
+  return generateIdentity(crypto);
+}
+function identityFingerprint2(x25519Pub, crypto = nodeCryptoProvider) {
+  return identityFingerprint(x25519Pub, crypto);
+}
+function isEnoent(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+function isKeyPair(kp) {
+  return isRecord(kp) && typeof kp["pub"] === "string" && typeof kp["priv"] === "string";
+}
+function isDaemonIdentity(value) {
+  if (!isRecord(value)) return false;
+  if (value["v"] !== IDENTITY_VERSION) return false;
+  if (typeof value["createdAt"] !== "string") return false;
+  return isKeyPair(value["x25519"]) && isKeyPair(value["ed25519"]);
+}
+async function loadOrCreateIdentity(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new IdentityError(
+        `identity file ${filePath} is not valid JSON \u2014 refusing to overwrite; move it aside to regenerate`
+      );
+    }
+    if (!isDaemonIdentity(parsed)) {
+      throw new IdentityError(
+        `identity file ${filePath} is malformed or an unsupported version \u2014 refusing to overwrite; move it aside to regenerate`
+      );
+    }
+    return parsed;
+  } catch (err) {
+    if (!isEnoent(err)) throw err;
+  }
+  const identity = await generateIdentity2();
+  await persistIdentity(filePath, identity);
+  return identity;
+}
+async function persistIdentity(filePath, identity) {
+  const dir = dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  const tmp = join(dir, `.${basename(filePath)}.tmp-${process.pid}`);
+  await writeFile(tmp, JSON.stringify(identity, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  await chmod(tmp, 384).catch(() => {
+  });
+  await rename(tmp, filePath);
+}
+function signTranscript2(ed25519Priv, transcript, crypto = nodeCryptoProvider) {
+  return signTranscript(ed25519Priv, transcript, crypto);
+}
+function verifyTranscript2(ed25519Pub, transcript, signature, crypto = nodeCryptoProvider) {
+  return verifyTranscript(ed25519Pub, transcript, signature, crypto);
+}
+
+export { generateIdentity2 as generateIdentity, identityFingerprint2 as identityFingerprint, loadOrCreateIdentity, signTranscript2 as signTranscript, verifyTranscript2 as verifyTranscript };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/identity/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}
+{"version":3,"sources":["../../src/identity/index.ts"],"names":["generateIdentity","identityFingerprint","signTranscript","verifyTranscript"],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * @agentproto/secrets/identity — the daemon's persistent cryptographic\n * identity for E2E pairing (design: PAIRING / DESIGN §1).\n *\n * A daemon that accepts pairings needs a stable identity a client can pin:\n *   - an **X25519** keypair for key agreement (the client seals its hello to\n *     this key, and it is one of the two ECDH inputs to the session key), and\n *   - an **Ed25519** keypair for authenticity (the daemon signs the handshake\n *     transcript so the client — who learned the public halves out-of-band via\n *     the offer URL — can prove it is really talking to the daemon it scanned,\n *     not an evil rendezvous in the middle).\n *\n * Both keypairs are stored base64-DER (SPKI public / PKCS8 private), the exact\n * shape `@agentproto/secrets/seal` already uses, so the identity file travels\n * as plain JSON and the seal box can consume the X25519 public half verbatim.\n *\n * The crypto (X25519, Ed25519, SHA-256) lives once in ./core.ts against a\n * `CryptoProvider`; this Node entry defaults to `node:crypto` and adds the\n * file-backed store. Everything is async (WebCrypto is) and takes an optional\n * trailing `crypto` to override the provider. The private halves never leave\n * the identity file (mode 0600) and are never logged.\n */\n\nimport { mkdir, readFile, writeFile, chmod, rename } from \"node:fs/promises\"\nimport { dirname, join, basename } from \"node:path\"\nimport { nodeCryptoProvider } from \"../crypto/node.js\"\nimport type { CryptoProvider } from \"../crypto/types.js\"\nimport * as core from \"./core.js\"\nimport { IDENTITY_VERSION, IdentityError, type DaemonIdentity } from \"./core.js\"\n\nexport {\n  IDENTITY_VERSION,\n  IdentityError,\n  type IdentityKeyPair,\n  type DaemonIdentity,\n} from \"./core.js\"\nexport type { CryptoProvider } from \"../crypto/types.js\"\n\n/**\n * Mint a fresh daemon identity: one X25519 keypair (encryption) and one\n * Ed25519 keypair (signing). Called lazily on first `pair offer`.\n */\nexport function generateIdentity(crypto: CryptoProvider = nodeCryptoProvider): Promise<DaemonIdentity> {\n  return core.generateIdentity(crypto)\n}\n\n/**\n * Stable identifier for a daemon, derived from its X25519 public key: the\n * first 32 hex (128 bits) of `sha256(pub DER)`. It names the daemon's browser\n * origin (`<fingerprint>.agentproto.cloud`), so it is long enough to resist a\n * grind for a colliding key. `sealKeyId` in `@agentproto/secrets/seal` is its\n * 16-hex prefix. Displayed everywhere a human confirms identity (offer QR,\n * `pair accept`, `pair ls`). Not a secret.\n */\nexport function identityFingerprint(x25519Pub: string, crypto: CryptoProvider = nodeCryptoProvider): Promise<string> {\n  return core.identityFingerprint(x25519Pub, crypto)\n}\n\n/** True for a filesystem \"no such file\" error, without an unchecked cast. */\nfunction isEnoent(err: unknown): boolean {\n  return (\n    typeof err === \"object\" &&\n    err !== null &&\n    \"code\" in err &&\n    err.code === \"ENOENT\"\n  )\n}\n\nfunction isRecord(v: unknown): v is Record<string, unknown> {\n  return typeof v === \"object\" && v !== null\n}\n\nfunction isKeyPair(kp: unknown): boolean {\n  return isRecord(kp) && typeof kp[\"pub\"] === \"string\" && typeof kp[\"priv\"] === \"string\"\n}\n\nfunction isDaemonIdentity(value: unknown): value is DaemonIdentity {\n  if (!isRecord(value)) return false\n  if (value[\"v\"] !== IDENTITY_VERSION) return false\n  if (typeof value[\"createdAt\"] !== \"string\") return false\n  return isKeyPair(value[\"x25519\"]) && isKeyPair(value[\"ed25519\"])\n}\n\n/**\n * Load the daemon identity from `filePath`, creating it on first use. The\n * caller supplies the path (typically `~/.agentproto/identity.json`) so this\n * module stays free of any home-dir policy.\n *\n * The private halves are secret, so a freshly created file is written 0600 and\n * atomically (temp file in the same directory + `rename`, so a crash mid-write\n * can never leave a half-written identity or a world-readable window). A\n * malformed existing file is a hard error — never silently overwritten, since\n * that would rotate the daemon's identity and orphan every existing pairing.\n */\nexport async function loadOrCreateIdentity(\n  filePath: string\n): Promise<DaemonIdentity> {\n  try {\n    const raw = await readFile(filePath, \"utf8\")\n    let parsed: unknown\n    try {\n      parsed = JSON.parse(raw)\n    } catch {\n      throw new IdentityError(\n        `identity file ${filePath} is not valid JSON — refusing to overwrite; ` +\n          `move it aside to regenerate`\n      )\n    }\n    if (!isDaemonIdentity(parsed)) {\n      throw new IdentityError(\n        `identity file ${filePath} is malformed or an unsupported version — ` +\n          `refusing to overwrite; move it aside to regenerate`\n      )\n    }\n    return parsed\n  } catch (err) {\n    if (!isEnoent(err)) throw err\n    // ENOENT → first run; fall through to lazy creation below.\n  }\n\n  const identity = await generateIdentity()\n  await persistIdentity(filePath, identity)\n  return identity\n}\n\n/** Atomic 0600 write: serialize to a sibling temp file, chmod it before it\n *  holds any secret bytes, then rename over the target. */\nasync function persistIdentity(\n  filePath: string,\n  identity: DaemonIdentity\n): Promise<void> {\n  const dir = dirname(filePath)\n  await mkdir(dir, { recursive: true })\n  const tmp = join(dir, `.${basename(filePath)}.tmp-${process.pid}`)\n  await writeFile(tmp, JSON.stringify(identity, null, 2) + \"\\n\", {\n    encoding: \"utf8\",\n    mode: 0o600,\n  })\n  // Belt-and-suspenders: writeFile's mode is subject to umask on some\n  // platforms, so tighten explicitly before the file is visible at its\n  // final name. Windows / mounts that ignore chmod fall back to the\n  // already-private user profile dir.\n  await chmod(tmp, 0o600).catch(() => {})\n  await rename(tmp, filePath)\n}\n\n/**\n * Sign a handshake transcript with the daemon's Ed25519 private key. Resolves\n * to a base64 signature. `transcript` is the exact bytes both sides agree on\n * (`sha256(e_pub ‖ ct₀ ‖ d_e_pub)`); signing it — not the raw messages — is\n * what binds the daemon's authenticity to the whole exchange.\n */\nexport function signTranscript(\n  ed25519Priv: string,\n  transcript: Uint8Array,\n  crypto: CryptoProvider = nodeCryptoProvider,\n): Promise<string> {\n  return core.signTranscript(ed25519Priv, transcript, crypto)\n}\n\n/**\n * Verify a transcript signature against a daemon's Ed25519 public key. Resolves\n * to a boolean — never rejects on a bad signature (only on a structurally\n * invalid key), so callers branch on the result rather than an exception.\n */\nexport function verifyTranscript(\n  ed25519Pub: string,\n  transcript: Uint8Array,\n  signature: string,\n  crypto: CryptoProvider = nodeCryptoProvider,\n): Promise<boolean> {\n  return core.verifyTranscript(ed25519Pub, transcript, signature, crypto)\n}\n"]}

package/dist/pairing/browser.d.ts

@@ -0,0 +1,18 @@
+export { C as ClientHandshakeParams, D as DEFAULT_PAIR_PAGE, a as DaemonHandshakeParams, b as DaemonHandshakeResult, H as HOSTED_RENDEZVOUS_URL, L as LEGACY_PAIR_VERSION, O as OFFER_URL_HOST, c as OFFER_URL_SCHEME, d as OFFER_VERSION, P as PAIRING_PROTOCOL_OUTDATED_MESSAGE, e as PAIR_PAGE_FP_PLACEHOLDER, f as PAIR_VERSION, g as PAIR_WEB_URL, h as PAIR_WEB_URL_TEMPLATE_CLOUD, i as PairingError, j as PairingErrorCode, k as PairingHello, l as PairingOffer, m as PairingReply, n as PairingSession, o as ParseOfferOptions, R as RouteAuthTokens, S as StartedClientHandshake, p as StartedTunnelHandshake, T as TUNNEL_E2E_VERSION, q as TunnelAccept, r as TunnelE2ESession, s as TunnelHandshakeError, t as TunnelHandshakeErrorCode, u as TunnelHandshakeResult, v as TunnelOffer, w as currentEpoch, x as decodePairingHello, y as decodePairingReply, z as decodeTunnelAccept, A as decodeTunnelOffer, B as deriveEpochAuthToken, E as deriveEpochRoutingToken, F as deriveEpochTokens, G as deriveOfferTokens, I as derivePairRoot, J as encodeOfferUrl, K as encodeOfferWebUrl, M as encodePairingMessage, N as encodeTunnelMessage, Q as epochRoutingTokens, U as expectedPairHost, V as importPairRootKey, W as parseOfferUrl, X as resolvePairPageUrl, Y as respondToHandshake, Z as respondToLegacyHandshake, _ as respondToTunnelHandshake, $ as startClientHandshake, a0 as startTunnelHandshake, a1 as webCryptoProvider } from '../webcrypto-BU57p0_g.js';
+export { S as SEAL_ALG, a as SEAL_VERSION, b as SealError, c as SealKeyPair, g as generateSealKeyPair, s as seal, d as sealKeyId, e as sealingPublicKey, u as unseal } from '../core-CIn0-z-Y.js';
+export { D as DaemonIdentity, I as IDENTITY_VERSION, a as IdentityError, b as IdentityKeyPair, g as generateIdentity, i as identityFingerprint, s as signTranscript, v as verifyTranscript } from '../core-D8zVNPDb.js';
+export { C as CryptoProvider, K as KeyPairDer } from '../types-B2ZfEhsU.js';
+
+/** Standard base64 (padded) — identical to `Buffer#toString("base64")`. */
+declare function base64Encode(bytes: Uint8Array): string;
+/** Lenient base64 decode — identical to `Buffer.from(s, "base64")`. Returns a
+ *  plain `Uint8Array` view (a `Buffer` under Node). Never throws. */
+declare function base64Decode(s: string): Uint8Array;
+/** base64url without padding. */
+declare function base64UrlEncode(bytes: Uint8Array): string;
+declare function utf8Encode(s: string): Uint8Array;
+/** UTF-8 decode, replacing invalid sequences with U+FFFD (like Buffer). */
+declare function utf8Decode(bytes: Uint8Array): string;
+declare function concatBytes(...parts: Uint8Array[]): Uint8Array;
+
+export { base64Decode, base64Encode, base64UrlEncode, concatBytes, utf8Decode, utf8Encode };

package/dist/pairing/browser.mjs

@@ -0,0 +1,6 @@
+export { DEFAULT_PAIR_PAGE, HOSTED_RENDEZVOUS_URL, LEGACY_PAIR_VERSION, OFFER_URL_HOST, OFFER_URL_SCHEME, OFFER_VERSION, PAIRING_PROTOCOL_OUTDATED_MESSAGE, PAIR_PAGE_FP_PLACEHOLDER, PAIR_VERSION, PAIR_WEB_URL, PAIR_WEB_URL_TEMPLATE_CLOUD, PairingError, TUNNEL_E2E_VERSION, TunnelHandshakeError, currentEpoch, decodePairingHello, decodePairingReply, decodeTunnelAccept, decodeTunnelOffer, deriveEpochAuthToken, deriveEpochRoutingToken, deriveEpochTokens, deriveOfferTokens, derivePairRoot, encodeOfferUrl, encodeOfferWebUrl, encodePairingMessage, encodeTunnelMessage, epochRoutingTokens, expectedPairHost, importPairRootKey, parseOfferUrl, resolvePairPageUrl, respondToHandshake, respondToLegacyHandshake, respondToTunnelHandshake, startClientHandshake, startTunnelHandshake } from '../chunk-JNTDSOZQ.mjs';
+export { IDENTITY_VERSION, IdentityError, generateIdentity, identityFingerprint, signTranscript, verifyTranscript } from '../chunk-NQX3KBPW.mjs';
+export { SEAL_ALG, SEAL_VERSION, SealError, generateSealKeyPair, seal, sealKeyId, sealingPublicKey, unseal } from '../chunk-432SC3XS.mjs';
+export { base64Decode, base64Encode, base64UrlEncode, concatBytes, utf8Decode, utf8Encode, webCryptoProvider } from '../chunk-3YRYO6LK.mjs';
+//# sourceMappingURL=browser.mjs.map
+//# sourceMappingURL=browser.mjs.map

package/dist/pairing/browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"browser.mjs"}