@datalayer/core 0.0.16 → 0.0.18

package/lib/client/auth/storage.js

@@ -0,0 +1,447 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+/**
+ * Token storage backend implementations
+ */
+import { DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '../../state/storage/IAMStorage';
+/**
+ * Browser localStorage-based token storage
+ */
+export class BrowserStorage {
+    /**
+     * Get token from browser localStorage
+     */
+    get(key) {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        return window.localStorage.getItem(key);
+    }
+    /**
+     * Set token in browser localStorage
+     */
+    set(key, value) {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        window.localStorage.setItem(key, value);
+    }
+    /**
+     * Delete token from browser localStorage
+     */
+    delete(key) {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        window.localStorage.removeItem(key);
+    }
+    /**
+     * Check if browser localStorage is available
+     */
+    isAvailable() {
+        return typeof window !== 'undefined' && !!window.localStorage;
+    }
+    /**
+     * Get stored authentication token
+     */
+    getToken() {
+        return this.get(DATALAYER_IAM_TOKEN_KEY);
+    }
+    /**
+     * Store authentication token
+     */
+    setToken(token) {
+        this.set(DATALAYER_IAM_TOKEN_KEY, token);
+    }
+    /**
+     * Delete authentication token
+     */
+    deleteToken() {
+        this.delete(DATALAYER_IAM_TOKEN_KEY);
+    }
+    /**
+     * Get stored user data
+     */
+    getUser() {
+        const userData = this.get(DATALAYER_IAM_USER_KEY);
+        if (!userData) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(userData);
+            return parsed;
+        }
+        catch (error) {
+            console.error('Failed to parse stored user data:', error);
+            return null;
+        }
+    }
+    /**
+     * Store user data
+     */
+    setUser(user) {
+        this.set(DATALAYER_IAM_USER_KEY, JSON.stringify(user));
+    }
+    /**
+     * Delete user data
+     */
+    deleteUser() {
+        this.delete(DATALAYER_IAM_USER_KEY);
+    }
+    /**
+     * Clear all authentication data
+     */
+    clear() {
+        this.deleteToken();
+        this.deleteUser();
+    }
+}
+/**
+ * Node.js storage with keyring support using keytar
+ */
+export class NodeStorage {
+    memoryStorage = new Map();
+    keytar = null;
+    serviceUrl;
+    constructor(serviceUrl = 'https://prod1.datalayer.run') {
+        this.serviceUrl = serviceUrl;
+        try {
+            // Load keytar for system keyring access
+            // VS Code extensions get this from VS Code's bundled keytar
+            // CLI gets this from installed keytar package
+            this.keytar = require('keytar');
+        }
+        catch (e) {
+            // Keyring not available, use memory only
+            console.warn('keytar not available, tokens will not persist');
+        }
+    }
+    /**
+     * Get token from keyring, environment variable, or memory
+     * Supports both sync (getPasswordSync) and async (getPassword) keytar APIs
+     */
+    get(key) {
+        console.log('[NodeStorage.get] key:', key, 'keytar available:', !!this.keytar);
+        // 1. Try keyring first (if available)
+        if (this.keytar) {
+            try {
+                // Try sync API first (CLI keytar)
+                if (this.keytar.getPasswordSync) {
+                    console.log('[NodeStorage.get] using keytar.getPasswordSync');
+                    const value = this.keytar.getPasswordSync(this.serviceUrl, key);
+                    console.log('[NodeStorage.get] keytar returned:', value ? 'token found' : 'null');
+                    if (value)
+                        return value;
+                }
+                else {
+                    console.log('[NodeStorage.get] getPasswordSync not available, skipping sync keytar');
+                }
+            }
+            catch (e) {
+                console.warn('[NodeStorage.get] keytar.getPasswordSync failed:', e);
+                // Fall through to other methods
+            }
+        }
+        // 2. Try environment variables
+        const envValue = process.env[key];
+        console.log('[NodeStorage.get] env var', key, ':', envValue ? 'found' : 'not found');
+        if (envValue)
+            return envValue;
+        // 3. Fall back to memory storage
+        const memValue = this.memoryStorage.get(key) || null;
+        console.log('[NodeStorage.get] memory storage:', memValue ? 'found' : 'not found');
+        return memValue;
+    }
+    /**
+     * Set token in keyring or memory storage (sync version)
+     */
+    set(key, value) {
+        console.log('[NodeStorage.set] key:', key, 'keytar available:', !!this.keytar);
+        // Store in keyring if available and has sync API
+        if (this.keytar && this.keytar.setPasswordSync) {
+            try {
+                console.log('[NodeStorage.set] calling keytar.setPasswordSync');
+                this.keytar.setPasswordSync(this.serviceUrl, key, value);
+                console.log('[NodeStorage.set] keytar.setPasswordSync succeeded');
+                return;
+            }
+            catch (e) {
+                console.warn('[NodeStorage.set] Failed to store in keyring, using memory:', e);
+            }
+        }
+        else if (this.keytar) {
+            console.log('[NodeStorage.set] setPasswordSync not available, use setAsync() instead');
+        }
+        // Fall back to memory
+        console.log('[NodeStorage.set] falling back to memory storage');
+        this.memoryStorage.set(key, value);
+    }
+    /**
+     * Async version of set - supports VS Code's async keytar API
+     */
+    async setAsync(key, value) {
+        console.log('[NodeStorage.setAsync] key:', key, 'keytar available:', !!this.keytar);
+        // Store in keyring if available
+        if (this.keytar) {
+            try {
+                // Try async API (VS Code keytar)
+                if (this.keytar.setPassword) {
+                    console.log('[NodeStorage.setAsync] calling keytar.setPassword (async)');
+                    await this.keytar.setPassword(this.serviceUrl, key, value);
+                    console.log('[NodeStorage.setAsync] keytar.setPassword succeeded');
+                    // IMPORTANT: Also store in memory so synchronous get() can access it
+                    this.memoryStorage.set(key, value);
+                    return;
+                }
+                // Try sync API (CLI keytar)
+                else if (this.keytar.setPasswordSync) {
+                    console.log('[NodeStorage.setAsync] calling keytar.setPasswordSync');
+                    this.keytar.setPasswordSync(this.serviceUrl, key, value);
+                    console.log('[NodeStorage.setAsync] keytar.setPasswordSync succeeded');
+                    // Also store in memory for consistency
+                    this.memoryStorage.set(key, value);
+                    return;
+                }
+            }
+            catch (e) {
+                console.warn('[NodeStorage.setAsync] Failed to store in keyring, using memory:', e);
+            }
+        }
+        // Fall back to memory
+        console.log('[NodeStorage.setAsync] falling back to memory storage');
+        this.memoryStorage.set(key, value);
+    }
+    /**
+     * Async version of get - supports VS Code's async keytar API
+     */
+    async getAsync(key) {
+        console.log('[NodeStorage.getAsync] key:', key, 'keytar available:', !!this.keytar);
+        // Try keyring first (if available)
+        if (this.keytar) {
+            try {
+                // Try async API (VS Code keytar)
+                if (this.keytar.getPassword) {
+                    console.log('[NodeStorage.getAsync] calling keytar.getPassword (async)');
+                    const value = await this.keytar.getPassword(this.serviceUrl, key);
+                    console.log('[NodeStorage.getAsync] keytar returned:', value ? 'token found' : 'null');
+                    if (value)
+                        return value;
+                }
+                // Try sync API (CLI keytar)
+                else if (this.keytar.getPasswordSync) {
+                    console.log('[NodeStorage.getAsync] calling keytar.getPasswordSync');
+                    const value = this.keytar.getPasswordSync(this.serviceUrl, key);
+                    console.log('[NodeStorage.getAsync] keytar returned:', value ? 'token found' : 'null');
+                    if (value)
+                        return value;
+                }
+            }
+            catch (e) {
+                console.warn('[NodeStorage.getAsync] keytar failed:', e);
+            }
+        }
+        // Try environment variables
+        const envValue = process.env[key];
+        console.log('[NodeStorage.getAsync] env var', key, ':', envValue ? 'found' : 'not found');
+        if (envValue)
+            return envValue;
+        // Fall back to memory storage
+        const memValue = this.memoryStorage.get(key) || null;
+        console.log('[NodeStorage.getAsync] memory storage:', memValue ? 'found' : 'not found');
+        return memValue;
+    }
+    /**
+     * Delete token from keyring or memory storage (sync version)
+     */
+    delete(key) {
+        console.log('[NodeStorage.delete] key:', key, 'keytar available:', !!this.keytar);
+        if (this.keytar && this.keytar.deletePasswordSync) {
+            try {
+                console.log('[NodeStorage.delete] calling keytar.deletePasswordSync');
+                this.keytar.deletePasswordSync(this.serviceUrl, key);
+                console.log('[NodeStorage.delete] keytar.deletePasswordSync succeeded');
+            }
+            catch (e) {
+                console.warn('[NodeStorage.delete] Failed to delete from keyring:', e);
+            }
+        }
+        else if (this.keytar) {
+            console.log('[NodeStorage.delete] deletePasswordSync not available, use deleteAsync() instead');
+        }
+        console.log('[NodeStorage.delete] deleting from memory storage');
+        this.memoryStorage.delete(key);
+    }
+    /**
+     * Async version of delete - supports VS Code's async keytar API
+     */
+    async deleteAsync(key) {
+        console.log('[NodeStorage.deleteAsync] key:', key, 'keytar available:', !!this.keytar);
+        if (this.keytar) {
+            try {
+                // Try async API (VS Code keytar)
+                if (this.keytar.deletePassword) {
+                    console.log('[NodeStorage.deleteAsync] calling keytar.deletePassword (async)');
+                    await this.keytar.deletePassword(this.serviceUrl, key);
+                    console.log('[NodeStorage.deleteAsync] keytar.deletePassword succeeded');
+                }
+                // Try sync API (CLI keytar)
+                else if (this.keytar.deletePasswordSync) {
+                    console.log('[NodeStorage.deleteAsync] calling keytar.deletePasswordSync');
+                    this.keytar.deletePasswordSync(this.serviceUrl, key);
+                    console.log('[NodeStorage.deleteAsync] keytar.deletePasswordSync succeeded');
+                }
+            }
+            catch (e) {
+                console.warn('[NodeStorage.deleteAsync] Failed to delete from keyring:', e);
+            }
+        }
+        console.log('[NodeStorage.deleteAsync] deleting from memory storage');
+        this.memoryStorage.delete(key);
+    }
+    /**
+     * Check if Node.js environment
+     */
+    isAvailable() {
+        return typeof process !== 'undefined' && !!process.env;
+    }
+    /**
+     * Get stored authentication token (sync version)
+     * Checks environment variables and memory, but not async keytar
+     */
+    getToken() {
+        // Check DATALAYER_API_KEY first
+        const apiKey = process.env['DATALAYER_API_KEY'];
+        if (apiKey)
+            return apiKey;
+        // Use "access_token" key (sync only - won't find tokens stored via async keytar)
+        return this.get('access_token');
+    }
+    /**
+     * Get stored authentication token (async version)
+     * Properly checks async keytar API (VS Code), then env vars, then memory
+     */
+    async getTokenAsync() {
+        // Check DATALAYER_API_KEY first
+        const apiKey = process.env['DATALAYER_API_KEY'];
+        if (apiKey)
+            return apiKey;
+        // Use async method to check keyring (supports VS Code's async keytar)
+        return await this.getAsync('access_token');
+    }
+    /**
+     * Store authentication token (async version - use this in auth strategies)
+     */
+    async setToken(token) {
+        console.log('[NodeStorage] setToken called, keytar available:', !!this.keytar);
+        console.log('[NodeStorage] storing token with key: access_token, service:', this.serviceUrl);
+        // Use async method to support VS Code's keytar
+        await this.setAsync('access_token', token);
+        console.log('[NodeStorage] token stored successfully');
+    }
+    /**
+     * Delete authentication token (async version - use this in auth manager)
+     */
+    async deleteToken() {
+        console.log('[NodeStorage] deleteToken called');
+        // Use async method to support VS Code's keytar
+        await this.deleteAsync('access_token');
+        console.log('[NodeStorage] token deleted successfully');
+    }
+    /**
+     * Clear all authentication data (async version - use this in auth manager)
+     */
+    async clear() {
+        console.log('[NodeStorage] clear called');
+        await this.deleteToken();
+        this.memoryStorage.clear();
+        console.log('[NodeStorage] all data cleared');
+    }
+}
+/**
+ * Electron safeStorage-based token storage
+ * Falls back to BrowserStorage if Electron safeStorage is not available
+ */
+export class ElectronStorage {
+    browserStorage = new BrowserStorage();
+    /**
+     * Get token from Electron safeStorage or fall back to localStorage
+     */
+    get(key) {
+        // TODO: Implement Electron safeStorage when running in Electron
+        // For now, fall back to browser storage
+        return this.browserStorage.get(key);
+    }
+    /**
+     * Set token in Electron safeStorage or fall back to localStorage
+     */
+    set(key, value) {
+        // TODO: Implement Electron safeStorage when running in Electron
+        // For now, fall back to browser storage
+        this.browserStorage.set(key, value);
+    }
+    /**
+     * Delete token from Electron safeStorage or localStorage
+     */
+    delete(key) {
+        // TODO: Implement Electron safeStorage when running in Electron
+        // For now, fall back to browser storage
+        this.browserStorage.delete(key);
+    }
+    /**
+     * Check if Electron safeStorage or browser storage is available
+     */
+    isAvailable() {
+        // TODO: Check for Electron safeStorage API
+        // For now, check browser storage
+        return this.browserStorage.isAvailable();
+    }
+    /**
+     * Get stored authentication token
+     */
+    getToken() {
+        return this.get(DATALAYER_IAM_TOKEN_KEY);
+    }
+    /**
+     * Store authentication token
+     */
+    setToken(token) {
+        this.set(DATALAYER_IAM_TOKEN_KEY, token);
+    }
+    /**
+     * Delete authentication token
+     */
+    deleteToken() {
+        this.delete(DATALAYER_IAM_TOKEN_KEY);
+    }
+    /**
+     * Clear all authentication data
+     */
+    clear() {
+        this.browserStorage.clear();
+    }
+}
+/**
+ * Get the appropriate storage backend for the current environment
+ */
+export function getDefaultStorage() {
+    if (typeof window !== 'undefined') {
+        // Browser environment
+        return new BrowserStorage();
+    }
+    else if (typeof process !== 'undefined') {
+        // Node.js environment
+        return new NodeStorage();
+    }
+    else {
+        // Unknown environment, use in-memory storage
+        console.warn('Unknown environment, using in-memory storage (data will not persist)');
+        return new NodeStorage(); // NodeStorage has in-memory fallback
+    }
+}

package/lib/client/auth/strategies.d.ts

@@ -0,0 +1,54 @@
+import type { AuthStrategy, AuthOptions, AuthResult, TokenStorage } from './types';
+import { UserDTO } from '../../models/UserDTO';
+/**
+ * Base authentication strategy with common functionality
+ */
+declare abstract class BaseAuthStrategy implements AuthStrategy {
+    protected iamRunUrl: string;
+    protected storage?: TokenStorage | undefined;
+    constructor(iamRunUrl: string, storage?: TokenStorage | undefined);
+    abstract authenticate(options: AuthOptions): Promise<AuthResult>;
+    abstract canHandle(options: AuthOptions): boolean;
+    /**
+     * Validate a token by calling whoami
+     */
+    protected validateToken(token: string): Promise<UserDTO>;
+}
+/**
+ * Token-based authentication strategy
+ * Authenticates using an existing token
+ */
+export declare class TokenAuthStrategy extends BaseAuthStrategy {
+    canHandle(options: AuthOptions): boolean;
+    authenticate(options: AuthOptions): Promise<AuthResult>;
+}
+/**
+ * Credentials-based authentication strategy
+ * Authenticates using handle and password
+ */
+export declare class CredentialsAuthStrategy extends BaseAuthStrategy {
+    canHandle(options: AuthOptions): boolean;
+    authenticate(options: AuthOptions): Promise<AuthResult>;
+}
+/**
+ * Storage-based authentication strategy
+ * Authenticates using a token from storage
+ */
+export declare class StorageAuthStrategy extends BaseAuthStrategy {
+    canHandle(options: AuthOptions): boolean;
+    authenticate(options: AuthOptions): Promise<AuthResult>;
+}
+/**
+ * Browser OAuth strategy
+ * Authenticates using browser-based OAuth flow with GitHub or LinkedIn
+ */
+export declare class BrowserOAuthStrategy extends BaseAuthStrategy {
+    canHandle(options: AuthOptions): boolean;
+    authenticate(options: AuthOptions): Promise<AuthResult>;
+    /**
+     * Wait for OAuth callback in popup window
+     * Expects: { user, token, error } from the Datalayer OAuth callback
+     */
+    private waitForOAuthCallback;
+}
+export {};