@datalayer/core 0.0.12 → 0.0.14

package/lib/client/base.js

@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Base SDK class providing core configuration and token management.
+ * @module client/base
+ */
+import { DEFAULT_SERVICE_URLS } from '../api/constants';
+/** Base Client class providing core configuration and token management. */
+export class DatalayerClientBase {
+    /** URL for IAM service */
+    iamRunUrl;
+    /** URL for Runtimes service */
+    runtimesRunUrl;
+    /** URL for Spacer service */
+    spacerRunUrl;
+    /** Authentication token */
+    token;
+    /** Environments */
+    environments = [];
+    /** Method lifecycle handlers */
+    handlers;
+    /**
+     * Create a DatalayerClient base instance.
+     * @param config - Client configuration options
+     */
+    constructor(config) {
+        this.iamRunUrl = config.iamRunUrl || DEFAULT_SERVICE_URLS.IAM;
+        this.runtimesRunUrl =
+            config.runtimesRunUrl || DEFAULT_SERVICE_URLS.RUNTIMES;
+        this.spacerRunUrl = config.spacerRunUrl || DEFAULT_SERVICE_URLS.SPACER;
+        this.token = config.token;
+        this.handlers = config.handlers;
+    }
+    /**
+     * Get the current configuration including service URLs and token.
+     * @returns Current configuration
+     */
+    getConfig() {
+        return {
+            iamRunUrl: this.iamRunUrl,
+            runtimesRunUrl: this.runtimesRunUrl,
+            spacerRunUrl: this.spacerRunUrl,
+            token: this.token,
+        };
+    }
+    /** Get the IAM service URL. */
+    getIamRunUrl() {
+        return this.iamRunUrl;
+    }
+    /** Get the Runtimes service URL. */
+    getRuntimesRunUrl() {
+        return this.runtimesRunUrl;
+    }
+    /** Get the Spacer service URL. */
+    getSpacerRunUrl() {
+        return this.spacerRunUrl;
+    }
+    /** Get the current authentication token. */
+    getToken() {
+        return this.token;
+    }
+    /**
+     * set the authentication token for all API requests.
+     * @param token - New authentication token
+     */
+    async setToken(token) {
+        this.token = token;
+    }
+    /**
+     * Wrap all SDK methods with handlers for cross-cutting concerns.
+     * Called automatically by the DatalayerClient constructor.
+     *
+     * @internal
+     */
+    wrapAllMethods() {
+        if (!this.handlers) {
+            return; // No handlers configured, nothing to wrap
+        }
+        // Get all method names from the prototype chain
+        const methodNames = this.getAllMethodNames();
+        // Wrap each method with handlers
+        methodNames.forEach(methodName => {
+            const original = this[methodName];
+            if (typeof original !== 'function') {
+                return;
+            }
+            // Detect if the original method is async by checking if it's an AsyncFunction
+            const isAsync = original.constructor.name === 'AsyncFunction';
+            if (isAsync) {
+                // Create async wrapped version for originally async methods
+                this[methodName] = async (...args) => {
+                    // Call beforeCall handler if defined
+                    if (this.handlers?.beforeCall) {
+                        await Promise.resolve(this.handlers.beforeCall(methodName, args));
+                    }
+                    try {
+                        // Call the original async method
+                        const result = await original.apply(this, args);
+                        // Call afterCall handler if defined
+                        if (this.handlers?.afterCall) {
+                            await Promise.resolve(this.handlers.afterCall(methodName, result));
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        // Call onError handler if defined
+                        if (this.handlers?.onError) {
+                            await Promise.resolve(this.handlers.onError(methodName, error));
+                        }
+                        throw error;
+                    }
+                };
+            }
+            else {
+                // Create sync wrapped version for originally sync methods
+                this[methodName] = (...args) => {
+                    // Call beforeCall handler if defined (sync version)
+                    if (this.handlers?.beforeCall) {
+                        const beforeResult = this.handlers.beforeCall(methodName, args);
+                        // If beforeCall returns a Promise, we can't await it in sync context
+                        if (beforeResult instanceof Promise) {
+                            // Promise ignored in sync context
+                        }
+                    }
+                    try {
+                        // Call the original sync method
+                        const result = original.apply(this, args);
+                        // Call afterCall handler if defined (sync version)
+                        if (this.handlers?.afterCall) {
+                            const afterResult = this.handlers.afterCall(methodName, result);
+                            if (afterResult instanceof Promise) {
+                                // Promise ignored in sync context
+                            }
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        // Call onError handler if defined (sync version)
+                        if (this.handlers?.onError) {
+                            const errorResult = this.handlers.onError(methodName, error);
+                            if (errorResult instanceof Promise) {
+                                // Promise ignored in sync context
+                            }
+                        }
+                        throw error;
+                    }
+                };
+            }
+        });
+    }
+    /**
+     * Get all method names from mixins only.
+     * @returns Array of mixin method names to wrap
+     * @internal
+     */
+    getAllMethodNames() {
+        const methodNames = new Set();
+        // First, collect all base class methods to exclude
+        const baseClassMethods = new Set();
+        const basePrototype = DatalayerClientBase.prototype;
+        Object.getOwnPropertyNames(basePrototype).forEach(name => {
+            baseClassMethods.add(name);
+        });
+        // Also exclude methods from the concrete SDK class itself
+        const sdkPrototype = Object.getPrototypeOf(this).constructor.prototype;
+        Object.getOwnPropertyNames(sdkPrototype).forEach(name => {
+            baseClassMethods.add(name);
+        });
+        // Now walk the prototype chain and only include mixin methods
+        let obj = Object.getPrototypeOf(this);
+        while (obj && obj !== Object.prototype) {
+            const names = Object.getOwnPropertyNames(obj);
+            names.forEach(name => {
+                // Only include if:
+                // 1. Not a constructor
+                // 2. Not a private method (starts with _)
+                // 3. Not a base class method
+                // 4. Is actually a function
+                if (name !== 'constructor' &&
+                    !name.startsWith('_') &&
+                    !baseClassMethods.has(name)) {
+                    const descriptor = Object.getOwnPropertyDescriptor(obj, name);
+                    if (descriptor && typeof descriptor.value === 'function') {
+                        methodNames.add(name);
+                    }
+                }
+            });
+            obj = Object.getPrototypeOf(obj);
+        }
+        return Array.from(methodNames);
+    }
+    // Utility Methods
+    calculateCreditsFromMinutes(minutes, burningRate) {
+        const burningRatePerMinute = burningRate * 60;
+        return Math.ceil(minutes * burningRatePerMinute);
+    }
+}

package/lib/client/constants.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Constants for the Datalayer SDK.
+ *
+ * @module client/constants
+ */
+/**
+ * Item types used throughout the SDK and consuming applications.
+ * These constants define the type identifiers for different Datalayer items.
+ * Values match what the Datalayer API returns.
+ */
+export declare const ItemTypes: {
+    readonly NOTEBOOK: "notebook";
+    readonly LEXICAL: "document";
+    readonly EXERCISE: "exercise";
+    readonly CELL: "cell";
+    readonly SPACE: "space";
+    readonly UNKNOWN: "unknown";
+};
+/**
+ * Type representing valid item types.
+ */
+export type ItemType = (typeof ItemTypes)[keyof typeof ItemTypes];

package/lib/client/constants.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Constants for the Datalayer SDK.
+ *
+ * @module client/constants
+ */
+/**
+ * Item types used throughout the SDK and consuming applications.
+ * These constants define the type identifiers for different Datalayer items.
+ * Values match what the Datalayer API returns.
+ */
+export const ItemTypes = {
+    NOTEBOOK: 'notebook',
+    LEXICAL: 'document',
+    EXERCISE: 'exercise',
+    CELL: 'cell',
+    SPACE: 'space',
+    UNKNOWN: 'unknown',
+};

package/lib/client/index.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Main Datalayer Client with intuitive mixin-based API.
+ * Provides unified, flat API for all Datalayer platform services through TypeScript mixins.
+ *
+ * @module client
+ *
+ * @example
+ * ```typescript
+ * const client = new DatalayerClient({
+ *   token: 'your-api-token'
+ * });
+ *
+ * const user = await client.whoami();
+ * const runtime = await client.createRuntime(config);
+ * ```
+ */
+import { DatalayerClientBase, type DatalayerClientConfig, type SDKHandlers } from './base';
+import type { UserDTO } from './../models/UserDTO';
+import type { CreditsDTO } from '../models/CreditsDTO';
+import type { EnvironmentDTO } from '../models/EnvironmentDTO';
+import type { RuntimeDTO } from '../models/RuntimeDTO';
+import type { RuntimeSnapshotDTO } from '../models/RuntimeSnapshotDTO';
+import type { SpaceDTO } from '../models/SpaceDTO';
+import type { NotebookDTO } from '../models/NotebookDTO';
+import type { LexicalDTO } from '../models/LexicalDTO';
+import type { HealthCheck } from '../models/HealthCheck';
+declare const DatalayerClientWithMixins: typeof DatalayerClientBase;
+/**
+ * Main Datalayer Client providing unified access to all platform services.
+ * Uses TypeScript mixins to provide a flat, discoverable API.
+ *
+ * @example
+ * ```typescript
+ * const client = new DatalayerClient({
+ *   token: 'your-token'
+ * });
+ *
+ * const user = await client.whoami();
+ * const runtime = await client.createRuntime({
+ *   environment_name: 'python-cpu-env',
+ *   credits_limit: 100
+ * });
+ * ```
+ */
+export declare class DatalayerClient extends DatalayerClientWithMixins {
+    /**
+     * Create a DatalayerClient instance.
+     *
+     * @param config - Client configuration options
+     */
+    constructor(config: DatalayerClientConfig);
+}
+export type { DatalayerClientConfig, SDKHandlers };
+export { DatalayerClientBase };
+export { UserDTO as User } from './../models/UserDTO';
+export type { UserJSON } from './../models/UserDTO';
+export { RuntimeDTO as Runtime } from '../models/RuntimeDTO';
+export type { RuntimeJSON } from '../models/RuntimeDTO';
+export { EnvironmentDTO as Environment } from '../models/EnvironmentDTO';
+export type { EnvironmentJSON } from '../models/EnvironmentDTO';
+export { RuntimeSnapshotDTO as Snapshot } from '../models/RuntimeSnapshotDTO';
+export { SpaceDTO as Space } from '../models/SpaceDTO';
+export { NotebookDTO as Notebook } from '../models/NotebookDTO';
+export { LexicalDTO } from '../models/LexicalDTO';
+export { CreditsDTO as Credits } from '../models/CreditsDTO';
+export { ItemDTO as Item } from '../models/ItemDTO';
+export { HealthCheck } from '../models/HealthCheck';
+export type { HealthCheckJSON } from '../models/HealthCheck';
+export { ItemTypes } from './constants';
+export type { ItemType } from './constants';
+export interface DatalayerClient {
+    getToken(): string | undefined;
+    setToken(token: string): Promise<void>;
+    whoami(): Promise<UserDTO>;
+    login(token: string): Promise<UserDTO>;
+    logout(): Promise<void>;
+    getCredits(): Promise<CreditsDTO>;
+    calculateMaxRuntimeMinutes(availableCredits: number, burningRate: number): number;
+    calculateCreditsRequired(minutes: number, burningRate: number): number;
+    checkIAMHealth(): Promise<HealthCheck>;
+    listEnvironments(): Promise<EnvironmentDTO[]>;
+    ensureRuntime(environmentName?: string, creditsLimit?: number, waitForReady?: boolean, maxWaitTime?: number, reuseExisting?: boolean, snapshotId?: string): Promise<RuntimeDTO>;
+    createRuntime(environmentName: string, type: 'notebook' | 'terminal' | 'job', givenName: string, minutesLimit: number, fromSnapshotId?: string): Promise<RuntimeDTO>;
+    listRuntimes(): Promise<RuntimeDTO[]>;
+    getRuntime(podName: string): Promise<RuntimeDTO>;
+    deleteRuntime(podName: string): Promise<void>;
+    terminateAllRuntimes(): Promise<PromiseSettledResult<void>[]>;
+    createSnapshot(podName: string, name: string, description: string, stop?: boolean): Promise<RuntimeSnapshotDTO>;
+    listSnapshots(): Promise<RuntimeSnapshotDTO[]>;
+    getSnapshot(id: string): Promise<RuntimeSnapshotDTO>;
+    deleteSnapshot(id: string): Promise<void>;
+    checkRuntimesHealth(): Promise<HealthCheck>;
+    getMySpaces(): Promise<SpaceDTO[]>;
+    createSpace(name: string, description: string, variant: string, spaceHandle: string, organizationId: string, seedSpaceId: string, isPublic: boolean): Promise<SpaceDTO>;
+    createNotebook(spaceId: string, name: string, description: string, file?: File | Blob): Promise<NotebookDTO>;
+    getNotebook(id: string): Promise<NotebookDTO>;
+    updateNotebook(id: string, name?: string, description?: string): Promise<NotebookDTO>;
+    createLexical(spaceId: string, name: string, description: string, file?: File | Blob): Promise<LexicalDTO>;
+    getLexical(id: string): Promise<LexicalDTO>;
+    updateLexical(id: string, name?: string, description?: string): Promise<LexicalDTO>;
+    getSpaceItems(spaceId: string): Promise<(NotebookDTO | LexicalDTO)[]>;
+    getSpaceItem(itemId: string): Promise<NotebookDTO | LexicalDTO>;
+    deleteSpaceItem(itemId: string): Promise<void>;
+    getCollaborationSessionId(documentId: string): Promise<string>;
+    getContent(itemId: string): Promise<any>;
+    checkSpacerHealth(): Promise<HealthCheck>;
+    calculateCreditsFromMinutes(minutes: number, burningRate: number): number;
+}

package/lib/client/index.js

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Main Datalayer Client with intuitive mixin-based API.
+ * Provides unified, flat API for all Datalayer platform services through TypeScript mixins.
+ *
+ * @module client
+ *
+ * @example
+ * ```typescript
+ * const client = new DatalayerClient({
+ *   token: 'your-api-token'
+ * });
+ *
+ * const user = await client.whoami();
+ * const runtime = await client.createRuntime(config);
+ * ```
+ */
+import { DatalayerClientBase, } from './base';
+import { IAMMixin } from './mixins/IAMMixin';
+import { RuntimesMixin } from './mixins/RuntimesMixin';
+import { SpacerMixin } from './mixins/SpacerMixin';
+/**
+ * Helper function to compose mixins in a more readable way.
+ * Applies mixins in the order provided.
+ *
+ * @param mixins - Array of mixin functions to apply
+ * @returns The composed class with all mixins applied
+ */
+function composeMixins(...mixins) {
+    return mixins.reduce((base, mixin) => mixin(base), DatalayerClientBase);
+}
+// Apply mixins to the base class using the helper
+const DatalayerClientWithMixins = composeMixins(IAMMixin, RuntimesMixin, SpacerMixin);
+/**
+ * Main Datalayer Client providing unified access to all platform services.
+ * Uses TypeScript mixins to provide a flat, discoverable API.
+ *
+ * @example
+ * ```typescript
+ * const client = new DatalayerClient({
+ *   token: 'your-token'
+ * });
+ *
+ * const user = await client.whoami();
+ * const runtime = await client.createRuntime({
+ *   environment_name: 'python-cpu-env',
+ *   credits_limit: 100
+ * });
+ * ```
+ */
+export class DatalayerClient extends DatalayerClientWithMixins {
+    /**
+     * Create a DatalayerClient instance.
+     *
+     * @param config - Client configuration options
+     */
+    constructor(config) {
+        super(config);
+        // Wrap all methods with handlers if configured
+        this.wrapAllMethods();
+    }
+}
+export { DatalayerClientBase };
+// Export models for use by consumers
+export { UserDTO as User } from './../models/UserDTO';
+export { RuntimeDTO as Runtime } from '../models/RuntimeDTO';
+export { EnvironmentDTO as Environment } from '../models/EnvironmentDTO';
+export { RuntimeSnapshotDTO as Snapshot } from '../models/RuntimeSnapshotDTO';
+export { SpaceDTO as Space } from '../models/SpaceDTO';
+export { NotebookDTO as Notebook } from '../models/NotebookDTO';
+export { LexicalDTO } from '../models/LexicalDTO';
+export { CreditsDTO as Credits } from '../models/CreditsDTO';
+export { ItemDTO as Item } from '../models/ItemDTO';
+export { HealthCheck } from '../models/HealthCheck';
+// Export constants
+export { ItemTypes } from './constants';

package/lib/client/mixins/IAMMixin.d.ts

@@ -0,0 +1,54 @@
+import type { Constructor } from '../utils/mixins';
+import { UserDTO } from '../../models/UserDTO';
+import { CreditsDTO } from '../../models/CreditsDTO';
+import { HealthCheck } from '../../models/HealthCheck';
+/** IAM mixin providing authentication and user management. */
+export declare function IAMMixin<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {
+        currentUserCache?: UserDTO;
+        /**
+         * Get the current user's profile information.
+         * @returns User model instance
+         */
+        whoami(): Promise<UserDTO>;
+        /**
+         * Authenticate the user with a token.
+         * @param token - Authentication token
+         * @returns User object on successful login
+         * @throws Error if token is invalid
+         */
+        login(token: string): Promise<UserDTO>;
+        /** Log out the current user. */
+        logout(): Promise<void>;
+        /**
+         * Get the current user's available credits and usage information.
+         * @returns Credits model instance
+         */
+        getCredits(): Promise<CreditsDTO>;
+        /**
+         * Calculate the maximum runtime duration in minutes based on available credits and burning rate.
+         * @param availableCredits - The amount of credits available
+         * @param burningRate - The burning rate per second for the environment
+         * @returns Maximum runtime duration in minutes
+         */
+        calculateMaxRuntimeMinutes(availableCredits: number, burningRate: number): number;
+        /**
+         * Calculate the credits required for a given runtime duration.
+         * @param minutes - Runtime duration in minutes
+         * @param burningRate - The burning rate per second for the environment
+         * @returns Credits required (rounded up to nearest integer)
+         */
+        calculateCreditsRequired(minutes: number, burningRate: number): number;
+        /**
+         * Calculate the burning rate per minute from the per-second rate.
+         * @param burningRatePerSecond - The burning rate per second
+         * @returns Burning rate per minute
+         */
+        calculateBurningRatePerMinute(burningRatePerSecond: number): number;
+        /**
+         * Check the health status of the IAM service.
+         * @returns Health check model instance
+         */
+        checkIAMHealth(): Promise<HealthCheck>;
+    };
+} & TBase;

package/lib/client/mixins/IAMMixin.js

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * IAM mixin providing authentication and user management functionality.
+ * @module client/mixins/IAMMixin
+ */
+import * as authentication from '../../api/iam/authentication';
+import * as profile from '../../api/iam/profile';
+import * as usage from '../../api/iam/usage';
+import { UserDTO } from '../../models/UserDTO';
+import { CreditsDTO } from '../../models/CreditsDTO';
+import { HealthCheck } from '../../models/HealthCheck';
+/** IAM mixin providing authentication and user management. */
+export function IAMMixin(Base) {
+    return class extends Base {
+        // Cache for current user
+        currentUserCache;
+        /**
+         * Get the current user's profile information.
+         * @returns User model instance
+         */
+        async whoami() {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const token = this.getToken();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await profile.whoami(token, iamRunUrl);
+            // Handle the whoami response format
+            let userData;
+            if (!response) {
+                throw new Error(`No response from profile.whoami API`);
+            }
+            // Check if response has the expected wrapper structure with profile
+            if (response.profile) {
+                // Transform the API response to match the User model's expected data structure
+                // Note: whoami returns fields with suffixes like _s, _t
+                userData = {
+                    id: response.profile.id,
+                    uid: response.profile.uid,
+                    // User model expects fields with suffixes from API types
+                    handle_s: response.profile.handle_s || response.profile.handle,
+                    email_s: response.profile.email_s || response.profile.email,
+                    first_name_t: response.profile.first_name_t || response.profile.first_name || '',
+                    last_name_t: response.profile.last_name_t || response.profile.last_name || '',
+                    // Use avatar_url_s if available, otherwise leave undefined for fallback
+                    avatar_url_s: response.profile.avatar_url_s || response.profile.avatar_url,
+                };
+            }
+            // Fallback for unexpected format
+            else {
+                throw new Error(`Unexpected response format from profile.whoami API: ${JSON.stringify(response)}`);
+            }
+            // Create new User instance (User model is immutable, no update method)
+            this.currentUserCache = new UserDTO(userData, this);
+            return this.currentUserCache;
+        }
+        /**
+         * Authenticate the user with a token.
+         * @param token - Authentication token
+         * @returns User object on successful login
+         * @throws Error if token is invalid
+         */
+        async login(token) {
+            // For token-based login, we simply set the token and verify it works
+            await this.setToken(token);
+            // Verify the token by calling whoami
+            try {
+                const user = await this.whoami();
+                return user;
+            }
+            catch (error) {
+                // Clear the invalid token
+                await this.setToken('');
+                throw new Error(`Invalid token: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        /** Log out the current user. */
+        async logout() {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            await authentication.logout(token, iamRunUrl);
+            // Clear the token from the SDK and cached user
+            this.setToken('');
+            this.currentUserCache = undefined;
+        }
+        /**
+         * Get the current user's available credits and usage information.
+         * @returns Credits model instance
+         */
+        async getCredits() {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await usage.getCredits(token, iamRunUrl);
+            if (!response || !response.credits) {
+                throw new Error('Invalid response from credits API');
+            }
+            return new CreditsDTO(response.credits, response.reservations || []);
+        }
+        // ========================================================================
+        // Credits Calculation Utilities
+        // ========================================================================
+        /**
+         * Calculate the maximum runtime duration in minutes based on available credits and burning rate.
+         * @param availableCredits - The amount of credits available
+         * @param burningRate - The burning rate per second for the environment
+         * @returns Maximum runtime duration in minutes
+         */
+        calculateMaxRuntimeMinutes(availableCredits, burningRate) {
+            if (!burningRate || burningRate <= 0)
+                return 0;
+            const burningRatePerMinute = burningRate * 60;
+            return Math.floor(availableCredits / burningRatePerMinute);
+        }
+        /**
+         * Calculate the credits required for a given runtime duration.
+         * @param minutes - Runtime duration in minutes
+         * @param burningRate - The burning rate per second for the environment
+         * @returns Credits required (rounded up to nearest integer)
+         */
+        calculateCreditsRequired(minutes, burningRate) {
+            if (!burningRate || burningRate <= 0 || !minutes || minutes <= 0)
+                return 0;
+            return Math.ceil(minutes * this.calculateBurningRatePerMinute(burningRate));
+        }
+        /**
+         * Calculate the burning rate per minute from the per-second rate.
+         * @param burningRatePerSecond - The burning rate per second
+         * @returns Burning rate per minute
+         */
+        calculateBurningRatePerMinute(burningRatePerSecond) {
+            return burningRatePerSecond * 60;
+        }
+        // ========================================================================
+        // Service Health Checks
+        // ========================================================================
+        /**
+         * Check the health status of the IAM service.
+         * @returns Health check model instance
+         */
+        async checkIAMHealth() {
+            const startTime = Date.now();
+            const errors = [];
+            let status = 'unknown';
+            let healthy = false;
+            try {
+                // Test basic connectivity and authentication by getting user profile
+                const user = await this.whoami();
+                const responseTime = Date.now() - startTime;
+                if (user && user.uid) {
+                    healthy = true;
+                    status = 'operational';
+                }
+                else {
+                    status = 'degraded';
+                    errors.push('Unexpected response format from profile endpoint');
+                }
+                return new HealthCheck({
+                    healthy,
+                    status,
+                    responseTime,
+                    errors,
+                    timestamp: new Date(),
+                }, this);
+            }
+            catch (error) {
+                const responseTime = Date.now() - startTime;
+                status = 'down';
+                errors.push(`Service unreachable: ${error}`);
+                return new HealthCheck({
+                    healthy: false,
+                    status,
+                    responseTime,
+                    errors,
+                    timestamp: new Date(),
+                }, this);
+            }
+        }
+    };
+}