@naylence/runtime 0.3.12 → 0.3.13

package/dist/esm/naylence/fame/node/upstream-session-manager.js

@@ -100,6 +100,7 @@ export class UpstreamSessionManager extends TaskSpawner {
         super();
         this.readyEvent = new AsyncEvent();
         this.stopEvent = new AsyncEvent();
+        this.wakeEvent = new AsyncEvent();
         this.queueEvent = new AsyncEvent();
         this.currentStopSubtasks = null;
         this.messageQueue = [];
@@ -111,6 +112,7 @@ export class UpstreamSessionManager extends TaskSpawner {
         this.hadSuccessfulAttach = false;
         this.lastConnectorState = null;
         this.connectEpoch = 0;
+        this._visibilityHandler = null;
         const options = normalizeOptions(optionsInput);
         this.node = options.node;
         this.attachClient = options.attachClient;
@@ -130,6 +132,34 @@ export class UpstreamSessionManager extends TaskSpawner {
     get systemId() {
         return this.targetSystemId;
     }
+    setupVisibilityListener() {
+        logger.debug('setup_visibility_listener_called', {
+            has_document: typeof document !== 'undefined',
+        });
+        if (typeof document !== 'undefined' && document.addEventListener) {
+            this._visibilityHandler = () => {
+                logger.debug('visibility_change_event_fired', {
+                    state: document.visibilityState,
+                });
+                if (document.visibilityState === 'visible') {
+                    logger.debug('visibility_change_detected_waking_up');
+                    this.wakeEvent.set();
+                }
+            };
+            document.addEventListener('visibilitychange', this._visibilityHandler);
+        }
+        else {
+            logger.debug('setup_visibility_listener_skipped_no_document');
+        }
+    }
+    teardownVisibilityListener() {
+        if (this._visibilityHandler &&
+            typeof document !== 'undefined' &&
+            document.removeEventListener) {
+            document.removeEventListener('visibilitychange', this._visibilityHandler);
+            this._visibilityHandler = null;
+        }
+    }
     async start(options = {}) {
         const { waitUntilReady = true } = options;
         if (this.fsmTask) {
@@ -137,6 +167,8 @@ export class UpstreamSessionManager extends TaskSpawner {
         }
         this.stopEvent.clear();
         this.readyEvent.clear();
+        this.wakeEvent.clear();
+        this.setupVisibilityListener();
         const taskName = `upstream-fsm-${this.connectEpoch}`;
         this.fsmTask = this.spawn(() => this.fsmLoop(), { name: taskName });
         if (!waitUntilReady) {
@@ -157,6 +189,7 @@ export class UpstreamSessionManager extends TaskSpawner {
     }
     async stop() {
         logger.debug('upstream_session_manager_stopping');
+        this.teardownVisibilityListener();
         this.stopEvent.set();
         this.currentStopSubtasks?.set();
         if (this.fsmTask) {
@@ -210,11 +243,16 @@ export class UpstreamSessionManager extends TaskSpawner {
     async fsmLoop() {
         let delay = UpstreamSessionManager.BACKOFF_INITIAL;
         while (!this.stopEvent.isSet()) {
+            const startTime = Date.now();
             try {
                 await this.connectCycle();
                 delay = UpstreamSessionManager.BACKOFF_INITIAL;
             }
             catch (error) {
+                // Reset backoff if the connection was alive for more than 10 seconds
+                if (Date.now() - startTime > 10000) {
+                    delay = UpstreamSessionManager.BACKOFF_INITIAL;
+                }
                 if (error instanceof TaskCancelledError) {
                     throw error;
                 }
@@ -229,11 +267,20 @@ export class UpstreamSessionManager extends TaskSpawner {
                     }
                 }
                 else {
-                    logger.warning('upstream_link_closed', {
-                        error: error.message,
-                        will_retry: true,
-                        exc_info: true,
-                    });
+                    const err = error;
+                    if (err.name === 'OAuth2PkceRedirectInitiatedError') {
+                        logger.info('upstream_link_redirecting', {
+                            error: err.message,
+                            will_retry: true,
+                        });
+                    }
+                    else {
+                        logger.warning('upstream_link_closed', {
+                            error: err.message,
+                            will_retry: true,
+                            exc_info: true,
+                        });
+                    }
                     if (!this.hadSuccessfulAttach) {
                         throw error;
                     }
@@ -251,14 +298,40 @@ export class UpstreamSessionManager extends TaskSpawner {
         if (delaySeconds <= 0) {
             return;
         }
+        // If the document is visible, cap the backoff delay to improve UX
+        // This ensures that if the user is watching, we retry quickly (e.g. 1s)
+        // instead of waiting for the full exponential backoff (up to 30s).
+        let effectiveDelay = delaySeconds;
+        if (typeof document !== 'undefined' &&
+            document.visibilityState === 'visible') {
+            effectiveDelay = Math.min(delaySeconds, 1.0);
+            if (effectiveDelay < delaySeconds) {
+                logger.debug('sleep_reduced_document_visible', {
+                    original: delaySeconds,
+                    new: effectiveDelay,
+                });
+            }
+        }
+        if (this.wakeEvent.isSet()) {
+            this.wakeEvent.clear();
+            return;
+        }
         let timeout;
         const sleepPromise = new Promise((resolve) => {
             timeout = setTimeout(() => {
                 timeout = undefined;
                 resolve();
-            }, delaySeconds * 1000);
+            }, effectiveDelay * 1000);
         });
-        await Promise.race([sleepPromise, this.stopEvent.wait()]);
+        await Promise.race([
+            sleepPromise,
+            this.stopEvent.wait(),
+            this.wakeEvent.wait(),
+        ]);
+        if (this.wakeEvent.isSet()) {
+            logger.debug('sleep_interrupted_by_wake_event');
+            this.wakeEvent.clear();
+        }
         if (timeout !== undefined) {
             clearTimeout(timeout);
         }
@@ -278,7 +351,7 @@ export class UpstreamSessionManager extends TaskSpawner {
         return signal ? event.wait({ signal }) : event.wait();
     }
     _getLocalNodeId() {
-        const normalized = this._normalizeNodeId(this.node.id);
+        const normalized = this._normalizeNodeId(this.node.provisionalId);
         if (!normalized) {
             throw new Error('UpstreamSessionManager requires node with a stable identifier');
         }
@@ -296,7 +369,7 @@ export class UpstreamSessionManager extends TaskSpawner {
             throw new FameConnectError('Admission client is required to attach upstream');
         }
         this.connectEpoch += 1;
-        const welcome = await this.admissionClient.hello(this.node.id, generateId(), this.requestedLogicals);
+        const welcome = await this.admissionClient.hello(this.node.provisionalId, generateId(), this.requestedLogicals);
         const connectionGrants = welcome.frame.connectionGrants;
         if (!connectionGrants?.length) {
             throw new Error('Welcome frame missing connection grants');
@@ -338,6 +411,11 @@ export class UpstreamSessionManager extends TaskSpawner {
             Array.isArray(welcome.frame.connectionGrants)) {
             for (const grant of welcome.frame.connectionGrants) {
                 if (grant && typeof grant === 'object') {
+                    const grantType = grant.type;
+                    if (grantType === 'WebSocketConnectionGrant' ||
+                        grantType === 'HttpConnectionGrant') {
+                        continue;
+                    }
                     // Avoid duplicates by checking if grant already exists
                     const isDuplicate = callbackGrants.some((existing) => JSON.stringify(existing) === JSON.stringify(grant));
                     if (!isDuplicate) {

package/dist/esm/naylence/fame/security/auth/auth-identity.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/naylence/fame/security/auth/materializable-token-provider.js

@@ -0,0 +1,6 @@
+export function isMaterializableTokenProvider(candidate) {
+    return (typeof candidate === 'object' &&
+        candidate !== null &&
+        typeof candidate.materialize ===
+            'function');
+}

package/dist/esm/naylence/fame/security/auth/oauth2-pkce-token-provider.js

@@ -271,6 +271,15 @@ export class OAuth2PkceTokenProvider {
     constructor(rawOptions) {
         this.options = normalizeOptions(rawOptions);
     }
+    async materialize() {
+        const token = await this.getToken();
+        return {
+            type: 'StaticTokenProvider',
+            token: token.value,
+            expiresAt: token.expiresAt,
+            expires_at: token.expiresAt,
+        };
+    }
     async getToken() {
         if (!isBrowserEnvironment()) {
             throw new Error('OAuth2PkceTokenProvider requires a browser environment with sessionStorage support');

package/dist/esm/naylence/fame/security/auth/static-token-provider.js

@@ -41,6 +41,50 @@ export class StaticTokenProvider {
     async getToken() {
         return { ...this.token };
     }
+    async getIdentity() {
+        const tokenValue = this.token.value;
+        const parts = tokenValue.split('.');
+        if (parts.length !== 3) {
+            return undefined;
+        }
+        try {
+            const payloadSegment = parts[1];
+            // Fix padding for base64url
+            const padding = '='.repeat((4 - (payloadSegment.length % 4)) % 4);
+            const base64 = (payloadSegment + padding)
+                .replace(/-/g, '+')
+                .replace(/_/g, '/');
+            let jsonString;
+            if (typeof Buffer !== 'undefined') {
+                jsonString = Buffer.from(base64, 'base64').toString('utf-8');
+            }
+            else if (typeof atob === 'function') {
+                jsonString = atob(base64);
+                try {
+                    jsonString = decodeURIComponent(jsonString
+                        .split('')
+                        .map(function (c) {
+                        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+                    })
+                        .join(''));
+                }
+                catch {
+                    // ignore
+                }
+            }
+            else {
+                return undefined;
+            }
+            const payload = JSON.parse(jsonString);
+            if (payload && typeof payload.sub === 'string') {
+                return { subject: payload.sub, claims: payload };
+            }
+        }
+        catch {
+            // ignore decoding errors
+        }
+        return undefined;
+    }
 }
 function normalizeOptions(input) {
     if (input === null || input === undefined) {

package/dist/esm/naylence/fame/security/auth/token-provider.js

@@ -3,3 +3,8 @@ export function isTokenProvider(candidate) {
         candidate !== null &&
         typeof candidate.getToken === 'function');
 }
+export function isIdentityExposingTokenProvider(candidate) {
+    return (isTokenProvider(candidate) &&
+        typeof candidate.getIdentity ===
+            'function');
+}

package/dist/esm/naylence/fame/security/default-security-manager.js

@@ -377,7 +377,7 @@ export class DefaultSecurityManager {
     async onNodeInitialized(node) {
         this._node = node;
         logger.debug('security_manager_node_initialized', {
-            node_id: node.id,
+            node_id: node.provisionalId,
             has_node_crypto_provider: Boolean(node.cryptoProvider),
             provider_type: node.cryptoProvider
                 ? (node.cryptoProvider.constructor?.name ?? 'unknown')
@@ -401,7 +401,9 @@ export class DefaultSecurityManager {
         if (encryption && hasNodeListenerMethod(encryption, 'onNodeInitialized')) {
             await encryption.onNodeInitialized(node);
         }
-        logger.debug('node_security_initialization_complete', { node_id: node.id });
+        logger.debug('node_security_initialization_complete', {
+            node_id: node.provisionalId,
+        });
     }
     async onNodeAttachToPeer(node, attachInfo, connector) {
         const attachRecord = attachInfo;

package/dist/esm/naylence/fame/security/index.js

@@ -1,4 +1,5 @@
 export * from './auth/authorizer.js';
+export * from './auth/auth-identity.js';
 export { AUTHORIZER_FACTORY_BASE_TYPE, AuthorizerFactory, } from './auth/authorizer-factory.js';
 export * from './auth/auth-injection-strategy.js';
 export { AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE, AuthInjectionStrategyFactory, } from './auth/auth-injection-strategy-factory.js';

package/dist/esm/naylence/fame/security/keys/default-key-manager.js

@@ -92,7 +92,7 @@ export class DefaultKeyManager {
         this.node = node;
         this.routingNode = isRoutingNode(node) ? node : null;
         logger.debug('key_manager_started', {
-            node_id: this.nodeId,
+            node_id: node.provisionalId,
             physical_path: this.physicalPath,
             has_upstream: this.hasUpstream,
         });

package/dist/esm/naylence/fame/util/task-spawner.js

@@ -275,6 +275,14 @@ export class TaskSpawner {
             });
             return;
         }
+        // Handle PKCE redirect "errors" as info
+        if (error.name === 'OAuth2PkceRedirectInitiatedError') {
+            logger.debug('background_task_redirecting', {
+                task_name: taskName,
+                note: 'Task interrupted for PKCE redirect',
+            });
+            return;
+        }
         // Check if this is a retriable connection error (will be logged and retried by FSM)
         const isRetriableError = error.name === 'FameConnectError' ||
             error.message.includes('missed heartbeat') ||

package/dist/esm/version.js

@@ -1,7 +1,7 @@
 // This file is auto-generated during build - do not edit manually
-// Generated from package.json version: 0.3.12
+// Generated from package.json version: 0.3.13
 /**
  * The package version, injected at build time.
  * @internal
  */
-export const VERSION = '0.3.12';
+export const VERSION = '0.3.13';