@tinycloud/node-sdk 3.10.0-beta.3 → 3.11.0-beta.0

package/dist/encryption-keys.d.cts

@@ -1,6 +1,6 @@
 import { NamedKeyClient } from '@tinycloud/sdk-services/encryption/named-keys';
 export { DecryptManyResult, KeyCallOptions, KeyDescriptor, KeyEncryptOptions, NamedKeyClient, NamedKeyEnvelope, NamedKeyError, NamedKeyErrorCode, PublicKeyDescriptor, buildKeyAdminFacts, buildKeyDescribeFacts } from '@tinycloud/sdk-services/encryption/named-keys';
-import { T as TinyCloudNode } from './TinyCloudNode-BhWBbCay.cjs';
+import { T as TinyCloudNode } from './TinyCloudNode-wAQN1Ndh.cjs';
 import '@tinycloud/sdk-core';
 import '@tinycloud/sdk-services/kv/replication';
 import '@tinycloud/sdk-services';

package/dist/encryption-keys.d.ts

@@ -1,6 +1,6 @@
 import { NamedKeyClient } from '@tinycloud/sdk-services/encryption/named-keys';
 export { DecryptManyResult, KeyCallOptions, KeyDescriptor, KeyEncryptOptions, NamedKeyClient, NamedKeyEnvelope, NamedKeyError, NamedKeyErrorCode, PublicKeyDescriptor, buildKeyAdminFacts, buildKeyDescribeFacts } from '@tinycloud/sdk-services/encryption/named-keys';
-import { T as TinyCloudNode } from './TinyCloudNode-BjJJIifr.js';
+import { T as TinyCloudNode } from './TinyCloudNode-BpolXzu5.js';
 import '@tinycloud/sdk-core';
 import '@tinycloud/sdk-services/kv/replication';
 import '@tinycloud/sdk-services';

package/dist/index.cjs

@@ -18969,6 +18969,16 @@ var MemorySessionStorage = class {
 };
 
 // src/authorization/NodeUserAuthorization.ts
+function assertMaxExpiresAt(value) {
+  if (value === void 0 || typeof value === "function") return;
+  const ms = value instanceof Date ? value.getTime() : value;
+  if (typeof ms !== "number" || !Number.isFinite(new Date(ms).getTime())) {
+    throw new Error("maxExpiresAt must be a finite number of epoch milliseconds, a valid Date, or a function returning one");
+  }
+}
+function lastAnchoredLine(siwe, pattern) {
+  return [...siwe.matchAll(pattern)].at(-1)?.[1];
+}
 function pkhSpaceIdentity(spaceId) {
   const match = /^(tinycloud:pkh:eip155:\d+:)(0x[0-9a-fA-F]{40})(:.+)$/.exec(spaceId);
   return match === null ? spaceId : `${match[1]}${match[2].toLowerCase()}${match[3]}`;
@@ -20261,10 +20271,8 @@ var NodeUserAuthorization = class {
       siwe: prepared.siwe,
       signature: signature2
     };
-    const expirationMatch = prepared.siwe?.match(/Expiration Time: (.+)/);
-    const issuedAtMatch = prepared.siwe?.match(/Issued At: (.+)/);
-    const expiresAt = expirationMatch?.[1] ?? new Date(Date.now() + this.sessionExpirationMs).toISOString();
-    const createdAt = issuedAtMatch?.[1] ?? (/* @__PURE__ */ new Date()).toISOString();
+    const expiresAt = lastAnchoredLine(prepared.siwe ?? "", /^Expiration Time: (.+)$/gm) ?? new Date(Date.now() + this.sessionExpirationMs).toISOString();
+    const createdAt = lastAnchoredLine(prepared.siwe ?? "", /^Issued At: (.+)$/gm) ?? (/* @__PURE__ */ new Date()).toISOString();
     const replicaStamp = await this.establishReplicaStamp?.(tinyCloudSession);
     const persistedData = this.persistedData(tinyCloudSession, expiresAt, createdAt, replicaStamp);
     await this.sessionStorage.save(address, persistedData);
@@ -20323,6 +20331,7 @@ var NodeUserAuthorization = class {
   /** Finish address, host and SIWE preparation before an approval click. */
   async prepareOpenKeySignIn(options) {
     refuseCaveated(this.getCapabilityRequest()?.manifests);
+    assertMaxExpiresAt(options?.maxExpiresAt);
     if (options?.host !== void 0) {
       const overrideHost = options.host.trim();
       if (!overrideHost) {
@@ -20343,7 +20352,9 @@ var NodeUserAuthorization = class {
       verificationMethod: prepared.verificationMethod,
       host: hostHint,
       keyId: options?.openkeyKeyId,
-      presentation
+      presentation,
+      // Present only when set, so the default request shape is unchanged.
+      ...options?.expiryChangeable === true ? { expiryChangeable: true } : {}
     };
     return {
       request: originalRequest,
@@ -20353,7 +20364,10 @@ var NodeUserAuthorization = class {
       address,
       chainId,
       generation: this.sessionGeneration,
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      // Kept in memory with the pending request. It is not part of `request`, so it is never sent to OpenKey, and
+      // nothing here is persisted.
+      ...options?.maxExpiresAt === void 0 ? {} : { maxExpiresAt: options.maxExpiresAt }
     };
   }
   /** Complete a prepared approval. The caller starts authorization before awaiting this method. */
@@ -20371,7 +20385,11 @@ var NodeUserAuthorization = class {
     for (let attempt = 0; ; ) {
       try {
         result ?? (result = await authorization);
-        signed2 = await this.verifyOpenKeyResult(result, prepared);
+        signed2 = await this.verifyOpenKeyResult(result, prepared, {
+          // Relax only for a request that actually carried the opt-in.
+          allowExpirationChange: originalRequest.expiryChangeable === true,
+          maxExpiresAt: pending.maxExpiresAt
+        });
         signature2 = result.signature;
         break;
       } catch (error) {
@@ -20463,13 +20481,23 @@ var NodeUserAuthorization = class {
    *    in the original prepared SIWE — narrowing OK, broadening rejected.
    * 5. Every `result.selectedActionKeys` entry corresponds to a
    *    (resource, action) pair in the returned SIWE.
+   *
+   * `options.expiryChangeable` is true only when the request sent to OpenKey
+   * carried `expiryChangeable: true`. Then (and only then) the signed
+   * `Expiration Time` may differ from the prepared one and is the expiry the
+   * session is built with; the changed expiry must pass
+   * `checkChangedExpiration` and every other field in (3) must still match.
+   * Without it, any expiry difference is refused as in (3).
    */
-  async signInWithOpenKeyResult(result, prepared, keyId, jwk) {
-    const signed2 = await this.verifyOpenKeyResult(result, prepared);
+  async signInWithOpenKeyResult(result, prepared, keyId, jwk, options) {
+    const signed2 = await this.verifyOpenKeyResult(result, prepared, {
+      allowExpirationChange: options?.expiryChangeable === true,
+      maxExpiresAt: options?.maxExpiresAt
+    });
     return this.signInWithPreparedSession(signed2, result.signature, keyId, jwk);
   }
   /** Validate a candidate without activating a network session, so paste retries reuse one preparation. */
-  async verifyOpenKeyResult(result, prepared) {
+  async verifyOpenKeyResult(result, prepared, options) {
     if (result.protocolVersion !== 1) {
       throw new Error(`Unsupported OpenKey protocol version ${result.protocolVersion}`);
     }
@@ -20512,16 +20540,39 @@ var NodeUserAuthorization = class {
         `OpenKey signedMessage.address (${parsedSignedSiwe.address}) does not match local signer address (${expectedAddress})`
       );
     }
+    const parsedExpiry = parsedSignedSiwe.expirationTime;
+    const lineExpiry = lastAnchoredLine(result.signedMessage, /^Expiration Time: (.+)$/gm);
+    if (parsedExpiry === void 0 || parsedExpiry === null || lineExpiry === void 0) {
+      throw new Error("OpenKey signedMessage has no Expiration Time line of its own");
+    }
+    const parsedExpiryMs = Date.parse(parsedExpiry);
+    if (!Number.isFinite(parsedExpiryMs) || parsedExpiryMs !== Date.parse(lineExpiry)) {
+      throw new Error("OpenKey signedMessage Expiration Time line does not match the message's own expiry");
+    }
     const originalHasRecap = /(?:^|\n)-\s+urn:recap:/i.test(prepared.siwe);
     const originalFields = (0, import_sdk_core5.extractImmutableSiweFields)(prepared.siwe);
     const signedFields = (0, import_sdk_core5.extractImmutableSiweFields)(result.signedMessage);
-    const changedFields = (0, import_sdk_core5.diffImmutableSiweFields)(originalFields, signedFields, {
-      originalHasRecap
-    });
-    if (changedFields.length > 0) {
-      throw new Error(
-        `OpenKey signedMessage altered immutable SIWE fields: ${changedFields.join(", ")}`
-      );
+    if (options?.allowExpirationChange === true) {
+      const maxExpiresAt = typeof options.maxExpiresAt === "function" ? options.maxExpiresAt() : options.maxExpiresAt;
+      const refusal = (0, import_sdk_core5.checkChangedExpiration)({
+        preparedSiwe: prepared.siwe,
+        signedSiwe: result.signedMessage,
+        now: Date.now(),
+        originalHasRecap,
+        ...maxExpiresAt === void 0 ? {} : { maxExpiresAt }
+      });
+      if (refusal !== null) {
+        throw new Error(`OpenKey signedMessage ${refusal}`);
+      }
+    } else {
+      const changedFields = (0, import_sdk_core5.diffImmutableSiweFields)(originalFields, signedFields, {
+        originalHasRecap
+      });
+      if (changedFields.length > 0) {
+        throw new Error(
+          `OpenKey signedMessage altered immutable SIWE fields: ${changedFields.join(", ")}`
+        );
+      }
     }
     let originalCaps;
     let signedCaps;
@@ -22706,14 +22757,14 @@ var _TinyCloudNode = class _TinyCloudNode {
     await this.signInWith(() => this.auth.signInWithOpenKey(authorizeFn, options));
   }
   /** Prepare the OpenKey request before the approval click. */
-  async prepareOpenKeySignIn() {
+  async prepareOpenKeySignIn(options) {
     if (!this.signer || !this.tc || !this.auth) {
       throw new Error("Cannot prepare OpenKey sign-in in session-only mode. Provide a signer in config.");
     }
     await this.signOutInFlight;
     await this.accountRegistryTail;
     await this.wasmBindings.ensureInitialized?.();
-    return this.auth.prepareOpenKeySignIn();
+    return this.auth.prepareOpenKeySignIn(options);
   }
   /** Start OpenKey authorization synchronously, then complete normal session setup. */
   signInWithPreparedOpenKey(pending, authorizeFn) {
@@ -25297,7 +25348,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         path: "",
         // Root access
         actions: [...ROOT_DELEGATION_ACTIONS],
-        expiry: this.getSessionExpiry(),
+        expiry: this.getSignedSessionExpiry(),
         isRevoked: false,
         allowSubDelegation: true
       };
@@ -25310,7 +25361,7 @@ var _TinyCloudNode = class _TinyCloudNode {
             spaceId,
             path: "",
             actions: [...ROOT_DELEGATION_ACTIONS],
-            expiry: this.getSessionExpiry(),
+            expiry: this.getSignedSessionExpiry(),
             isRevoked: false,
             allowSubDelegation: true
           });
@@ -25402,7 +25453,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       assertActive: () => graph.assertActive(),
       keyProvider: this._keyProvider,
       registry: this._capabilityRegistry,
-      sessionExpiry: this.getSessionExpiry(),
+      sessionExpiry: this.getSignedSessionExpiry(),
       createDelegationWasm: (params) => {
         graph.assertActive();
         return this.createDelegationWrapper(params);
@@ -25449,6 +25500,29 @@ var _TinyCloudNode = class _TinyCloudNode {
     const expirationMs = this.config.sessionExpirationMs ?? DEFAULT_SESSION_EXPIRATION_MS;
     return new Date(Date.now() + expirationMs);
   }
+  /**
+   * The expiry of the session that was actually signed, so the registry root
+   * and the sharing service never outlive or undercut what the SIWE grants
+   * (a user may change the expiry in the OpenKey approval).
+   *
+   * Any expiry the SIWE parses to is used exactly as signed, however near or
+   * far. The configured lifetime is used only when the SIWE cannot be parsed
+   * (the session is already established, so failing sign-in here would be
+   * worse; real sign-ins verify the SIWE first) or when a valid SIWE carries
+   * no `Expiration Time` line, as the other `extractSiweExpiration` callers do.
+   * @internal
+   */
+  getSignedSessionExpiry() {
+    const siwe = this.auth?.tinyCloudSession?.siwe;
+    if (!siwe) return this.getSessionExpiry();
+    let signed2;
+    try {
+      signed2 = extractSiweExpiration(siwe);
+    } catch {
+      return this.getSessionExpiry();
+    }
+    return signed2 ?? this.getSessionExpiry();
+  }
   /**
    * Wrapper for the WASM createDelegation function.
    *
@@ -28335,7 +28409,9 @@ function wireOpenKeyAuthorize(openkey, opts) {
       host: input.host,
       // Forward the presentation envelope verbatim — the OpenKey SDK
       // validates and size-bounds it before use.
-      presentation: input.presentation
+      presentation: input.presentation,
+      // Sent only when true, so a request without it keeps its prior shape.
+      ...input.expiryChangeable === true ? { expiryChangeable: true } : {}
     }, opts);
     if (result.protocolVersion !== 1) {
       throw new Error(