@datalayer/core 0.0.17 → 0.0.19

package/README.md

@@ -1,7 +1,3 @@
-**Datalayer Core**
-
----
-
 [![Datalayer](https://assets.datalayer.tech/datalayer-25.svg)](https://datalayer.io)
 
 [![Become a Sponsor](https://img.shields.io/static/v1?label=Become%20a%20Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=1ABC9C)](https://github.com/sponsors/datalayer)
@@ -9,11 +5,7 @@
 # Ξ Datalayer Core
 
 <p align="center">
-  <img src="https://assets.datalayer.tech/datalayer-25.svg" alt="Datalayer Logo" width="200"></img>
-</p>
-
-<p align="center">
-  <strong>The foundational Python SDK for the Datalayer AI Platform</strong>
+  <strong>Python and Typescript libraries for Datalayer</strong>
 </p>
 
 <p align="center">
@@ -21,12 +13,12 @@
   <a href="https://pypi.org/project/datalayer-core/"><img src="https://img.shields.io/pypi/pyversions/datalayer-core.svg" alt="Python versions"></img></a>
   <a href="https://github.com/datalayer/core/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-BSD%203--Clause-blue.svg" alt="License"></img></a>
   <a href="https://docs.datalayer.app/"><img src="https://img.shields.io/badge/docs-datalayer.app-blue" alt="Documentation"></img></a>
-  <a href="https://github.com/datalayer/core/actions/workflows/tests.yml"><img src="https://github.com/datalayer/core/actions/workflows/tests.yml/badge.svg" alt="Units Tests"></img></a>
+  <a href="https://github.com/datalayer/core/actions/workflows/py-tests.yml"><img src="https://github.com/datalayer/core/actions/workflows/py-tests.yml/badge.svg" alt="Units Tests"></img></a><a href="https://github.com/datalayer/core/actions/workflows/ts-tests.yml"><img src="https://github.com/datalayer/core/actions/workflows/ts-tests.yml/badge.svg" alt="Units Tests"></img></a>
 </p>
 
 ## Overview
 
-Datalayer Core is the foundational package that powers the [Datalayer AI Platform](https://datalayer.app/). It provides both a Python SDK and Command Line Interface (CLI) for AI engineers, data scientists, and researchers to seamlessly integrate scalable compute runtimes into their workflows.
+Datalayer Core is the foundational package that powers the [Datalayer AI Platform](https://datalayer.app/). It provides a TypesScript and Python packages as a Command Line Interface (CLI) for AI engineers, data scientists, and researchers to seamlessly integrate scalable compute runtimes into their workflows.
 
 This package serves as the base foundation used by many other Datalayer packages, containing core application classes, configuration, and unified APIs for authentication, runtime management, and code execution in cloud-based environments.
 
@@ -156,7 +148,7 @@ npm install
 echo "VITE_DATALAYER_API_KEY=your-token-here" > .env
 
 # Start the examples server
-npm run example
+npm run examples
 ```
 
 Available at http://localhost:3000/:
@@ -305,6 +297,10 @@ This project is licensed under the [BSD 3-Clause License](https://github.com/dat
 ---
 
 <p align="center">
-  <strong>🚀 AI Platform for Data Analysis</strong><br></br>
+  <img src="https://assets.datalayer.tech/datalayer-25.svg" alt="Datalayer Logo" width="200"></img>
+</p>
+
+<p align="center">
+  <strong>🚀 AI Agents for Data Analysis</strong><br></br>
   <a href="https://datalayer.app/">Get started with Datalayer today!</a>
 </p>

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

@@ -0,0 +1,95 @@
+/**
+ * Core authentication manager for the Datalayer SDK
+ */
+import type { AuthOptions, AuthResult, TokenStorage, TokenValidationResult } from './types';
+import { UserDTO } from '../../models/UserDTO';
+/**
+ * Authentication Manager for Datalayer SDK
+ * Provides a unified interface for all authentication methods
+ */
+export declare class AuthenticationManager {
+    private strategies;
+    private storage;
+    private iamRunUrl;
+    private currentUser?;
+    private currentToken?;
+    /**
+     * Create an AuthenticationManager instance
+     * @param iamRunUrl - IAM service URL (e.g., "https://prod1.datalayer.run")
+     * @param storage - Token storage backend (optional, defaults to auto-detected)
+     */
+    constructor(iamRunUrl: string, storage?: TokenStorage);
+    /**
+     * Login using various authentication methods
+     * Automatically selects the appropriate strategy based on options
+     *
+     * @param options - Authentication options
+     * @returns Authentication result with user and token
+     * @throws Error if authentication fails or no suitable strategy found
+     *
+     * @example
+     * // Token-based auth
+     * const result = await auth.login({ token: 'abc123' });
+     *
+     * @example
+     * // Credentials-based auth
+     * const result = await auth.login({
+     *   handle: 'user@example.com',
+     *   password: 'secret'
+     * });
+     *
+     * @example
+     * // Storage-based auth (uses stored token)
+     * const result = await auth.login({});
+     */
+    login(options?: AuthOptions): Promise<AuthResult>;
+    /**
+     * Logout the current user
+     * Calls the logout API and clears stored tokens
+     */
+    logout(): Promise<void>;
+    /**
+     * Get the current user profile
+     * Uses cached user if available, otherwise fetches from API
+     *
+     * @returns Current user or null if not authenticated
+     */
+    whoami(): Promise<UserDTO | null>;
+    /**
+     * Validate a token
+     * Checks if a token is valid by attempting to get the user profile
+     *
+     * @param token - Token to validate
+     * @returns Validation result with user if valid
+     */
+    validateToken(token: string): Promise<TokenValidationResult>;
+    /**
+     * Get the stored token from storage
+     * @returns Stored token or null
+     */
+    getStoredToken(): string | null;
+    /**
+     * Store a token in storage
+     * @param token - Token to store
+     */
+    storeToken(token: string): void;
+    /**
+     * Clear the stored token
+     */
+    clearStoredToken(): void;
+    /**
+     * Get the current cached user
+     * @returns Current user or undefined
+     */
+    getCurrentUser(): UserDTO | undefined;
+    /**
+     * Get the current token
+     * @returns Current token or undefined
+     */
+    getCurrentToken(): string | undefined;
+    /**
+     * Check if user is currently authenticated
+     * @returns True if user is authenticated
+     */
+    isAuthenticated(): boolean;
+}

package/lib/client/auth/AuthenticationManager.js

@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Core authentication manager for the Datalayer SDK
+ */
+import * as authentication from '../../api/iam/authentication';
+import { TokenAuthStrategy, CredentialsAuthStrategy, StorageAuthStrategy, BrowserOAuthStrategy, } from './strategies';
+import { NodeStorage, BrowserStorage } from './storage';
+/**
+ * Authentication Manager for Datalayer SDK
+ * Provides a unified interface for all authentication methods
+ */
+export class AuthenticationManager {
+    strategies;
+    storage;
+    iamRunUrl;
+    currentUser;
+    currentToken;
+    /**
+     * Create an AuthenticationManager instance
+     * @param iamRunUrl - IAM service URL (e.g., "https://prod1.datalayer.run")
+     * @param storage - Token storage backend (optional, defaults to auto-detected)
+     */
+    constructor(iamRunUrl, storage) {
+        this.iamRunUrl = iamRunUrl;
+        // Extract run_url (remove /api/iam/v1 if present)
+        const runUrl = iamRunUrl.replace('/api/iam/v1', '');
+        // CRITICAL: Pass runUrl to storage for keyring compatibility
+        if (!storage) {
+            if (typeof window !== 'undefined') {
+                this.storage = new BrowserStorage();
+            }
+            else {
+                this.storage = new NodeStorage(runUrl); // Pass runUrl as serviceUrl
+            }
+        }
+        else {
+            this.storage = storage;
+        }
+        // Initialize strategies
+        this.strategies = [
+            new TokenAuthStrategy(this.iamRunUrl, this.storage),
+            new CredentialsAuthStrategy(this.iamRunUrl, this.storage),
+            new StorageAuthStrategy(this.iamRunUrl, this.storage),
+            new BrowserOAuthStrategy(this.iamRunUrl, this.storage),
+        ];
+    }
+    /**
+     * Login using various authentication methods
+     * Automatically selects the appropriate strategy based on options
+     *
+     * @param options - Authentication options
+     * @returns Authentication result with user and token
+     * @throws Error if authentication fails or no suitable strategy found
+     *
+     * @example
+     * // Token-based auth
+     * const result = await auth.login({ token: 'abc123' });
+     *
+     * @example
+     * // Credentials-based auth
+     * const result = await auth.login({
+     *   handle: 'user@example.com',
+     *   password: 'secret'
+     * });
+     *
+     * @example
+     * // Storage-based auth (uses stored token)
+     * const result = await auth.login({});
+     */
+    async login(options = {}) {
+        // Find the first strategy that can handle these options
+        const strategy = this.strategies.find(s => s.canHandle(options));
+        if (!strategy) {
+            throw new Error('No authentication strategy found for the provided options. ' +
+                'Please provide a token, credentials (handle + password), or use browser OAuth.');
+        }
+        try {
+            const result = await strategy.authenticate(options);
+            // Cache the user and token
+            this.currentUser = result.user;
+            this.currentToken = result.token;
+            return result;
+        }
+        catch (error) {
+            // Clear any cached data on failure
+            this.currentUser = undefined;
+            this.currentToken = undefined;
+            throw error;
+        }
+    }
+    /**
+     * Logout the current user
+     * Calls the logout API and clears stored tokens
+     */
+    async logout() {
+        if (this.currentToken) {
+            try {
+                await authentication.logout(this.currentToken, this.iamRunUrl);
+            }
+            catch (error) {
+                console.error('Error during logout API call:', error);
+                // Continue with local cleanup even if API call fails
+            }
+        }
+        // Clear stored data
+        if (this.storage.clear) {
+            await this.storage.clear();
+        }
+        // Clear cached data
+        this.currentUser = undefined;
+        this.currentToken = undefined;
+    }
+    /**
+     * Get the current user profile
+     * Uses cached user if available, otherwise fetches from API
+     *
+     * @returns Current user or null if not authenticated
+     */
+    async whoami() {
+        if (this.currentUser) {
+            return this.currentUser;
+        }
+        if (this.currentToken) {
+            try {
+                // Re-authenticate using the current token
+                const result = await this.login({
+                    token: this.currentToken,
+                    noStore: true,
+                });
+                return result.user;
+            }
+            catch (error) {
+                console.error('Failed to get user profile:', error);
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Validate a token
+     * Checks if a token is valid by attempting to get the user profile
+     *
+     * @param token - Token to validate
+     * @returns Validation result with user if valid
+     */
+    async validateToken(token) {
+        try {
+            const result = await this.login({ token, noStore: true });
+            return {
+                valid: true,
+                user: result.user,
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Get the stored token from storage
+     * @returns Stored token or null
+     */
+    getStoredToken() {
+        if (!this.storage.getToken) {
+            return null;
+        }
+        return this.storage.getToken();
+    }
+    /**
+     * Store a token in storage
+     * @param token - Token to store
+     */
+    storeToken(token) {
+        if (this.storage.setToken) {
+            this.storage.setToken(token);
+        }
+        this.currentToken = token;
+    }
+    /**
+     * Clear the stored token
+     */
+    clearStoredToken() {
+        if (this.storage.deleteToken) {
+            this.storage.deleteToken();
+        }
+        this.currentToken = undefined;
+    }
+    /**
+     * Get the current cached user
+     * @returns Current user or undefined
+     */
+    getCurrentUser() {
+        return this.currentUser;
+    }
+    /**
+     * Get the current token
+     * @returns Current token or undefined
+     */
+    getCurrentToken() {
+        return this.currentToken;
+    }
+    /**
+     * Check if user is currently authenticated
+     * @returns True if user is authenticated
+     */
+    isAuthenticated() {
+        return !!this.currentToken && !!this.currentUser;
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Authentication module for Datalayer SDK
+ * Provides unified authentication interface with multiple strategies
+ */
+export * from './types';
+export * from './storage';
+export * from './strategies';
+export * from './AuthenticationManager';

package/lib/client/auth/index.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+/**
+ * Authentication module for Datalayer SDK
+ * Provides unified authentication interface with multiple strategies
+ */
+export * from './types';
+export * from './storage';
+export * from './strategies';
+export * from './AuthenticationManager';

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

@@ -0,0 +1,154 @@
+import type { TokenStorage } from './types';
+import { UserDTO } from '../../models/UserDTO';
+/**
+ * Browser localStorage-based token storage
+ */
+export declare class BrowserStorage implements TokenStorage {
+    /**
+     * Get token from browser localStorage
+     */
+    get(key: string): string | null;
+    /**
+     * Set token in browser localStorage
+     */
+    set(key: string, value: string): void;
+    /**
+     * Delete token from browser localStorage
+     */
+    delete(key: string): void;
+    /**
+     * Check if browser localStorage is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Get stored authentication token
+     */
+    getToken(): string | null;
+    /**
+     * Store authentication token
+     */
+    setToken(token: string): void;
+    /**
+     * Delete authentication token
+     */
+    deleteToken(): void;
+    /**
+     * Get stored user data
+     */
+    getUser(): UserDTO | null;
+    /**
+     * Store user data
+     */
+    setUser(user: UserDTO): void;
+    /**
+     * Delete user data
+     */
+    deleteUser(): void;
+    /**
+     * Clear all authentication data
+     */
+    clear(): void;
+}
+/**
+ * Node.js storage with keyring support using keytar
+ */
+export declare class NodeStorage implements TokenStorage {
+    private memoryStorage;
+    private keytar;
+    private serviceUrl;
+    constructor(serviceUrl?: string);
+    /**
+     * Get token from keyring, environment variable, or memory
+     * Supports both sync (getPasswordSync) and async (getPassword) keytar APIs
+     */
+    get(key: string): string | null;
+    /**
+     * Set token in keyring or memory storage (sync version)
+     */
+    set(key: string, value: string): void;
+    /**
+     * Async version of set - supports VS Code's async keytar API
+     */
+    setAsync(key: string, value: string): Promise<void>;
+    /**
+     * Async version of get - supports VS Code's async keytar API
+     */
+    getAsync(key: string): Promise<string | null>;
+    /**
+     * Delete token from keyring or memory storage (sync version)
+     */
+    delete(key: string): void;
+    /**
+     * Async version of delete - supports VS Code's async keytar API
+     */
+    deleteAsync(key: string): Promise<void>;
+    /**
+     * Check if Node.js environment
+     */
+    isAvailable(): boolean;
+    /**
+     * Get stored authentication token (sync version)
+     * Checks environment variables and memory, but not async keytar
+     */
+    getToken(): string | null;
+    /**
+     * Get stored authentication token (async version)
+     * Properly checks async keytar API (VS Code), then env vars, then memory
+     */
+    getTokenAsync(): Promise<string | null>;
+    /**
+     * Store authentication token (async version - use this in auth strategies)
+     */
+    setToken(token: string): Promise<void>;
+    /**
+     * Delete authentication token (async version - use this in auth manager)
+     */
+    deleteToken(): Promise<void>;
+    /**
+     * Clear all authentication data (async version - use this in auth manager)
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Electron safeStorage-based token storage
+ * Falls back to BrowserStorage if Electron safeStorage is not available
+ */
+export declare class ElectronStorage implements TokenStorage {
+    private browserStorage;
+    /**
+     * Get token from Electron safeStorage or fall back to localStorage
+     */
+    get(key: string): string | null;
+    /**
+     * Set token in Electron safeStorage or fall back to localStorage
+     */
+    set(key: string, value: string): void;
+    /**
+     * Delete token from Electron safeStorage or localStorage
+     */
+    delete(key: string): void;
+    /**
+     * Check if Electron safeStorage or browser storage is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Get stored authentication token
+     */
+    getToken(): string | null;
+    /**
+     * Store authentication token
+     */
+    setToken(token: string): void;
+    /**
+     * Delete authentication token
+     */
+    deleteToken(): void;
+    /**
+     * Clear all authentication data
+     */
+    clear(): void;
+}
+/**
+ * Get the appropriate storage backend for the current environment
+ */
+export declare function getDefaultStorage(): TokenStorage;