@push.rocks/smartregistry 1.1.1

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartregistry',
+    version: '1.1.1',
+    description: 'a registry for npm modules and oci images'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDJDQUEyQztDQUN6RCxDQUFBIn0=

package/dist_ts/classes.smartregistry.d.ts

@@ -0,0 +1,45 @@
+import { RegistryStorage } from './core/classes.registrystorage.js';
+import { AuthManager } from './core/classes.authmanager.js';
+import { BaseRegistry } from './core/classes.baseregistry.js';
+import type { IRegistryConfig, IRequestContext, IResponse } from './core/interfaces.core.js';
+/**
+ * Main registry orchestrator
+ * Routes requests to appropriate protocol handlers (OCI or NPM)
+ */
+export declare class SmartRegistry {
+    private storage;
+    private authManager;
+    private registries;
+    private config;
+    private initialized;
+    constructor(config: IRegistryConfig);
+    /**
+     * Initialize the registry system
+     */
+    init(): Promise<void>;
+    /**
+     * Handle an incoming HTTP request
+     * Routes to the appropriate protocol handler based on path
+     */
+    handleRequest(context: IRequestContext): Promise<IResponse>;
+    /**
+     * Get the storage instance (for testing/advanced use)
+     */
+    getStorage(): RegistryStorage;
+    /**
+     * Get the auth manager instance (for testing/advanced use)
+     */
+    getAuthManager(): AuthManager;
+    /**
+     * Get a specific registry handler
+     */
+    getRegistry(protocol: 'oci' | 'npm'): BaseRegistry | undefined;
+    /**
+     * Check if the registry is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Clean up resources (timers, connections, etc.)
+     */
+    destroy(): void;
+}

package/dist_ts/classes.smartregistry.js

@@ -0,0 +1,113 @@
+import { RegistryStorage } from './core/classes.registrystorage.js';
+import { AuthManager } from './core/classes.authmanager.js';
+import { BaseRegistry } from './core/classes.baseregistry.js';
+import { OciRegistry } from './oci/classes.ociregistry.js';
+import { NpmRegistry } from './npm/classes.npmregistry.js';
+/**
+ * Main registry orchestrator
+ * Routes requests to appropriate protocol handlers (OCI or NPM)
+ */
+export class SmartRegistry {
+    storage;
+    authManager;
+    registries = new Map();
+    config;
+    initialized = false;
+    constructor(config) {
+        this.config = config;
+        this.storage = new RegistryStorage(config.storage);
+        this.authManager = new AuthManager(config.auth);
+    }
+    /**
+     * Initialize the registry system
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        // Initialize storage
+        await this.storage.init();
+        // Initialize auth manager
+        await this.authManager.init();
+        // Initialize OCI registry if enabled
+        if (this.config.oci?.enabled) {
+            const ociBasePath = this.config.oci.basePath || '/oci';
+            const ociRegistry = new OciRegistry(this.storage, this.authManager, ociBasePath);
+            await ociRegistry.init();
+            this.registries.set('oci', ociRegistry);
+        }
+        // Initialize NPM registry if enabled
+        if (this.config.npm?.enabled) {
+            const npmBasePath = this.config.npm.basePath || '/npm';
+            const registryUrl = `http://localhost:5000${npmBasePath}`; // TODO: Make configurable
+            const npmRegistry = new NpmRegistry(this.storage, this.authManager, npmBasePath, registryUrl);
+            await npmRegistry.init();
+            this.registries.set('npm', npmRegistry);
+        }
+        this.initialized = true;
+    }
+    /**
+     * Handle an incoming HTTP request
+     * Routes to the appropriate protocol handler based on path
+     */
+    async handleRequest(context) {
+        const path = context.path;
+        // Route to OCI registry
+        if (this.config.oci?.enabled && path.startsWith(this.config.oci.basePath)) {
+            const ociRegistry = this.registries.get('oci');
+            if (ociRegistry) {
+                return ociRegistry.handleRequest(context);
+            }
+        }
+        // Route to NPM registry
+        if (this.config.npm?.enabled && path.startsWith(this.config.npm.basePath)) {
+            const npmRegistry = this.registries.get('npm');
+            if (npmRegistry) {
+                return npmRegistry.handleRequest(context);
+            }
+        }
+        // No matching registry
+        return {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' },
+            body: {
+                error: 'NOT_FOUND',
+                message: 'No registry handler for this path',
+            },
+        };
+    }
+    /**
+     * Get the storage instance (for testing/advanced use)
+     */
+    getStorage() {
+        return this.storage;
+    }
+    /**
+     * Get the auth manager instance (for testing/advanced use)
+     */
+    getAuthManager() {
+        return this.authManager;
+    }
+    /**
+     * Get a specific registry handler
+     */
+    getRegistry(protocol) {
+        return this.registries.get(protocol);
+    }
+    /**
+     * Check if the registry is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Clean up resources (timers, connections, etc.)
+     */
+    destroy() {
+        for (const registry of this.registries.values()) {
+            if (typeof registry.destroy === 'function') {
+                registry.destroy();
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zbWFydHJlZ2lzdHJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5zbWFydHJlZ2lzdHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNwRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDNUQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRTlELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFM0Q7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLGFBQWE7SUFDaEIsT0FBTyxDQUFrQjtJQUN6QixXQUFXLENBQWM7SUFDekIsVUFBVSxHQUE4QixJQUFJLEdBQUcsRUFBRSxDQUFDO0lBQ2xELE1BQU0sQ0FBa0I7SUFDeEIsV0FBVyxHQUFZLEtBQUssQ0FBQztJQUVyQyxZQUFZLE1BQXVCO1FBQ2pDLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxlQUFlLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ25ELElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxXQUFXLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxJQUFJO1FBQ2YsSUFBSSxJQUFJLENBQUMsV0FBVztZQUFFLE9BQU87UUFFN0IscUJBQXFCO1FBQ3JCLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUUxQiwwQkFBMEI7UUFDMUIsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksRUFBRSxDQUFDO1FBRTlCLHFDQUFxQztRQUNyQyxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLE9BQU8sRUFBRSxDQUFDO1lBQzdCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLFFBQVEsSUFBSSxNQUFNLENBQUM7WUFDdkQsTUFBTSxXQUFXLEdBQUcsSUFBSSxXQUFXLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLFdBQVcsQ0FBQyxDQUFDO1lBQ2pGLE1BQU0sV0FBVyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3pCLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxXQUFXLENBQUMsQ0FBQztRQUMxQyxDQUFDO1FBRUQscUNBQXFDO1FBQ3JDLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsT0FBTyxFQUFFLENBQUM7WUFDN0IsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxJQUFJLE1BQU0sQ0FBQztZQUN2RCxNQUFNLFdBQVcsR0FBRyx3QkFBd0IsV0FBVyxFQUFFLENBQUMsQ0FBQywwQkFBMEI7WUFDckYsTUFBTSxXQUFXLEdBQUcsSUFBSSxXQUFXLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLFdBQVcsRUFBRSxXQUFXLENBQUMsQ0FBQztZQUM5RixNQUFNLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUN6QixJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsV0FBVyxDQUFDLENBQUM7UUFDMUMsQ0FBQztRQUVELElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDO0lBQzFCLENBQUM7SUFFRDs7O09BR0c7SUFDSSxLQUFLLENBQUMsYUFBYSxDQUFDLE9BQXdCO1FBQ2pELE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUM7UUFFMUIsd0JBQXdCO1FBQ3hCLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsT0FBTyxJQUFJLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztZQUMxRSxNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUMvQyxJQUFJLFdBQVcsRUFBRSxDQUFDO2dCQUNoQixPQUFPLFdBQVcsQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDNUMsQ0FBQztRQUNILENBQUM7UUFFRCx3QkFBd0I7UUFDeEIsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxPQUFPLElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQzFFLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQy9DLElBQUksV0FBVyxFQUFFLENBQUM7Z0JBQ2hCLE9BQU8sV0FBVyxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUM1QyxDQUFDO1FBQ0gsQ0FBQztRQUVELHVCQUF1QjtRQUN2QixPQUFPO1lBQ0wsTUFBTSxFQUFFLEdBQUc7WUFDWCxPQUFPLEVBQUUsRUFBRSxjQUFjLEVBQUUsa0JBQWtCLEVBQUU7WUFDL0MsSUFBSSxFQUFFO2dCQUNKLEtBQUssRUFBRSxXQUFXO2dCQUNsQixPQUFPLEVBQUUsbUNBQW1DO2FBQzdDO1NBQ0YsQ0FBQztJQUNKLENBQUM7SUFFRDs7T0FFRztJQUNJLFVBQVU7UUFDZixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDdEIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksY0FBYztRQUNuQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDMUIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksV0FBVyxDQUFDLFFBQXVCO1FBQ3hDLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDdkMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksYUFBYTtRQUNsQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDMUIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksT0FBTztRQUNaLEtBQUssTUFBTSxRQUFRLElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDO1lBQ2hELElBQUksT0FBUSxRQUFnQixDQUFDLE9BQU8sS0FBSyxVQUFVLEVBQUUsQ0FBQztnQkFDbkQsUUFBZ0IsQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUM5QixDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

package/dist_ts/core/classes.authmanager.d.ts

@@ -0,0 +1,108 @@
+import type { IAuthConfig, IAuthToken, ICredentials, TRegistryProtocol } from './interfaces.core.js';
+/**
+ * Unified authentication manager for all registry protocols
+ * Handles both NPM UUID tokens and OCI JWT tokens
+ */
+export declare class AuthManager {
+    private config;
+    private tokenStore;
+    private userCredentials;
+    constructor(config: IAuthConfig);
+    /**
+     * Initialize the auth manager
+     */
+    init(): Promise<void>;
+    /**
+     * Create an NPM token
+     * @param userId - User ID
+     * @param readonly - Whether the token is readonly
+     * @returns NPM UUID token
+     */
+    createNpmToken(userId: string, readonly?: boolean): Promise<string>;
+    /**
+     * Validate an NPM token
+     * @param token - NPM UUID token
+     * @returns Auth token object or null
+     */
+    validateNpmToken(token: string): Promise<IAuthToken | null>;
+    /**
+     * Revoke an NPM token
+     * @param token - NPM UUID token
+     */
+    revokeNpmToken(token: string): Promise<void>;
+    /**
+     * List all tokens for a user
+     * @param userId - User ID
+     * @returns List of token info (without actual token values)
+     */
+    listUserTokens(userId: string): Promise<Array<{
+        key: string;
+        readonly: boolean;
+        created: string;
+    }>>;
+    /**
+     * Create an OCI JWT token
+     * @param userId - User ID
+     * @param scopes - Permission scopes
+     * @param expiresIn - Expiration time in seconds
+     * @returns JWT token string
+     */
+    createOciToken(userId: string, scopes: string[], expiresIn?: number): Promise<string>;
+    /**
+     * Validate an OCI JWT token
+     * @param jwt - JWT token string
+     * @returns Auth token object or null
+     */
+    validateOciToken(jwt: string): Promise<IAuthToken | null>;
+    /**
+     * Authenticate user credentials
+     * @param credentials - Username and password
+     * @returns User ID or null
+     */
+    authenticate(credentials: ICredentials): Promise<string | null>;
+    /**
+     * Validate any token (NPM or OCI)
+     * @param tokenString - Token string (UUID or JWT)
+     * @param protocol - Expected protocol type
+     * @returns Auth token object or null
+     */
+    validateToken(tokenString: string, protocol?: TRegistryProtocol): Promise<IAuthToken | null>;
+    /**
+     * Check if token has permission for an action
+     * @param token - Auth token
+     * @param resource - Resource being accessed (e.g., "package:foo" or "repository:bar")
+     * @param action - Action being performed (read, write, push, pull, delete)
+     * @returns true if authorized
+     */
+    authorize(token: IAuthToken | null, resource: string, action: string): Promise<boolean>;
+    /**
+     * Check if a scope matches a resource and action
+     * Scope format: "{protocol}:{type}:{name}:{action}"
+     * Examples:
+     * - "npm:*:*" - All NPM access
+     * - "npm:package:foo:*" - All actions on package foo
+     * - "npm:package:foo:read" - Read-only on package foo
+     * - "oci:repository:*:pull" - Pull from any OCI repo
+     */
+    private matchesScope;
+    /**
+     * Convert unified scopes to OCI access array
+     */
+    private scopesToOciAccess;
+    /**
+     * Convert OCI access array to unified scopes
+     */
+    private ociAccessToScopes;
+    /**
+     * Generate UUID for NPM tokens
+     */
+    private generateUuid;
+    /**
+     * Check if string is a valid UUID
+     */
+    private isValidUuid;
+    /**
+     * Hash a token for identification (SHA-512 mock)
+     */
+    private hashToken;
+}

package/dist_ts/core/classes.authmanager.js

@@ -0,0 +1,315 @@
+/**
+ * Unified authentication manager for all registry protocols
+ * Handles both NPM UUID tokens and OCI JWT tokens
+ */
+export class AuthManager {
+    config;
+    tokenStore = new Map();
+    userCredentials = new Map(); // username -> password hash (mock)
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Initialize the auth manager
+     */
+    async init() {
+        // Initialize token store (in-memory for now)
+        // In production, this could be Redis or a database
+    }
+    // ========================================================================
+    // NPM AUTHENTICATION
+    // ========================================================================
+    /**
+     * Create an NPM token
+     * @param userId - User ID
+     * @param readonly - Whether the token is readonly
+     * @returns NPM UUID token
+     */
+    async createNpmToken(userId, readonly = false) {
+        if (!this.config.npmTokens.enabled) {
+            throw new Error('NPM tokens are not enabled');
+        }
+        const token = this.generateUuid();
+        const authToken = {
+            type: 'npm',
+            userId,
+            scopes: readonly ? ['npm:*:*:read'] : ['npm:*:*:*'],
+            readonly,
+            metadata: {
+                created: new Date().toISOString(),
+            },
+        };
+        this.tokenStore.set(token, authToken);
+        return token;
+    }
+    /**
+     * Validate an NPM token
+     * @param token - NPM UUID token
+     * @returns Auth token object or null
+     */
+    async validateNpmToken(token) {
+        if (!this.isValidUuid(token)) {
+            return null;
+        }
+        const authToken = this.tokenStore.get(token);
+        if (!authToken || authToken.type !== 'npm') {
+            return null;
+        }
+        // Check expiration if set
+        if (authToken.expiresAt && authToken.expiresAt < new Date()) {
+            this.tokenStore.delete(token);
+            return null;
+        }
+        return authToken;
+    }
+    /**
+     * Revoke an NPM token
+     * @param token - NPM UUID token
+     */
+    async revokeNpmToken(token) {
+        this.tokenStore.delete(token);
+    }
+    /**
+     * List all tokens for a user
+     * @param userId - User ID
+     * @returns List of token info (without actual token values)
+     */
+    async listUserTokens(userId) {
+        const tokens = [];
+        for (const [token, authToken] of this.tokenStore.entries()) {
+            if (authToken.userId === userId) {
+                tokens.push({
+                    key: this.hashToken(token),
+                    readonly: authToken.readonly || false,
+                    created: authToken.metadata?.created || 'unknown',
+                });
+            }
+        }
+        return tokens;
+    }
+    // ========================================================================
+    // OCI AUTHENTICATION (JWT)
+    // ========================================================================
+    /**
+     * Create an OCI JWT token
+     * @param userId - User ID
+     * @param scopes - Permission scopes
+     * @param expiresIn - Expiration time in seconds
+     * @returns JWT token string
+     */
+    async createOciToken(userId, scopes, expiresIn = 3600) {
+        if (!this.config.ociTokens.enabled) {
+            throw new Error('OCI tokens are not enabled');
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const payload = {
+            iss: this.config.ociTokens.realm,
+            sub: userId,
+            aud: this.config.ociTokens.service,
+            exp: now + expiresIn,
+            nbf: now,
+            iat: now,
+            access: this.scopesToOciAccess(scopes),
+        };
+        // In production, use proper JWT library with signing
+        // For now, return JSON string (mock JWT)
+        return JSON.stringify(payload);
+    }
+    /**
+     * Validate an OCI JWT token
+     * @param jwt - JWT token string
+     * @returns Auth token object or null
+     */
+    async validateOciToken(jwt) {
+        try {
+            // In production, verify JWT signature
+            const payload = JSON.parse(jwt);
+            // Check expiration
+            const now = Math.floor(Date.now() / 1000);
+            if (payload.exp && payload.exp < now) {
+                return null;
+            }
+            // Convert to unified token format
+            const scopes = this.ociAccessToScopes(payload.access || []);
+            return {
+                type: 'oci',
+                userId: payload.sub,
+                scopes,
+                expiresAt: payload.exp ? new Date(payload.exp * 1000) : undefined,
+                metadata: {
+                    iss: payload.iss,
+                    aud: payload.aud,
+                },
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    // ========================================================================
+    // UNIFIED AUTHENTICATION
+    // ========================================================================
+    /**
+     * Authenticate user credentials
+     * @param credentials - Username and password
+     * @returns User ID or null
+     */
+    async authenticate(credentials) {
+        // Mock authentication - in production, verify against database
+        const storedPassword = this.userCredentials.get(credentials.username);
+        if (!storedPassword) {
+            // Auto-register for testing (remove in production)
+            this.userCredentials.set(credentials.username, credentials.password);
+            return credentials.username;
+        }
+        if (storedPassword === credentials.password) {
+            return credentials.username;
+        }
+        return null;
+    }
+    /**
+     * Validate any token (NPM or OCI)
+     * @param tokenString - Token string (UUID or JWT)
+     * @param protocol - Expected protocol type
+     * @returns Auth token object or null
+     */
+    async validateToken(tokenString, protocol) {
+        // Try NPM token first (UUID format)
+        if (this.isValidUuid(tokenString)) {
+            const npmToken = await this.validateNpmToken(tokenString);
+            if (npmToken && (!protocol || protocol === 'npm')) {
+                return npmToken;
+            }
+        }
+        // Try OCI JWT
+        const ociToken = await this.validateOciToken(tokenString);
+        if (ociToken && (!protocol || protocol === 'oci')) {
+            return ociToken;
+        }
+        return null;
+    }
+    /**
+     * Check if token has permission for an action
+     * @param token - Auth token
+     * @param resource - Resource being accessed (e.g., "package:foo" or "repository:bar")
+     * @param action - Action being performed (read, write, push, pull, delete)
+     * @returns true if authorized
+     */
+    async authorize(token, resource, action) {
+        if (!token) {
+            return false;
+        }
+        // Check readonly flag
+        if (token.readonly && ['write', 'push', 'delete'].includes(action)) {
+            return false;
+        }
+        // Check scopes
+        for (const scope of token.scopes) {
+            if (this.matchesScope(scope, resource, action)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // ========================================================================
+    // HELPER METHODS
+    // ========================================================================
+    /**
+     * Check if a scope matches a resource and action
+     * Scope format: "{protocol}:{type}:{name}:{action}"
+     * Examples:
+     * - "npm:*:*" - All NPM access
+     * - "npm:package:foo:*" - All actions on package foo
+     * - "npm:package:foo:read" - Read-only on package foo
+     * - "oci:repository:*:pull" - Pull from any OCI repo
+     */
+    matchesScope(scope, resource, action) {
+        const scopeParts = scope.split(':');
+        const resourceParts = resource.split(':');
+        // Scope must have at least protocol:type:name:action
+        if (scopeParts.length < 4) {
+            return false;
+        }
+        const [scopeProtocol, scopeType, scopeName, scopeAction] = scopeParts;
+        const [resourceProtocol, resourceType, resourceName] = resourceParts;
+        // Check protocol
+        if (scopeProtocol !== '*' && scopeProtocol !== resourceProtocol) {
+            return false;
+        }
+        // Check type
+        if (scopeType !== '*' && scopeType !== resourceType) {
+            return false;
+        }
+        // Check name
+        if (scopeName !== '*' && scopeName !== resourceName) {
+            return false;
+        }
+        // Check action
+        if (scopeAction !== '*' && scopeAction !== action) {
+            // Map action aliases
+            const actionAliases = {
+                read: ['pull', 'get'],
+                write: ['push', 'put', 'post'],
+            };
+            const aliases = actionAliases[scopeAction] || [];
+            if (!aliases.includes(action)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Convert unified scopes to OCI access array
+     */
+    scopesToOciAccess(scopes) {
+        const access = [];
+        for (const scope of scopes) {
+            const parts = scope.split(':');
+            if (parts.length >= 4 && parts[0] === 'oci') {
+                access.push({
+                    type: parts[1],
+                    name: parts[2],
+                    actions: [parts[3]],
+                });
+            }
+        }
+        return access;
+    }
+    /**
+     * Convert OCI access array to unified scopes
+     */
+    ociAccessToScopes(access) {
+        const scopes = [];
+        for (const item of access) {
+            for (const action of item.actions) {
+                scopes.push(`oci:${item.type}:${item.name}:${action}`);
+            }
+        }
+        return scopes;
+    }
+    /**
+     * Generate UUID for NPM tokens
+     */
+    generateUuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    /**
+     * Check if string is a valid UUID
+     */
+    isValidUuid(str) {
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(str);
+    }
+    /**
+     * Hash a token for identification (SHA-512 mock)
+     */
+    hashToken(token) {
+        // In production, use actual SHA-512
+        return `sha512-${token.substring(0, 16)}...`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authmanager.js","sourceRoot":"","sources":["../../ts/core/classes.authmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/core/classes.baseregistry.d.ts

@@ -0,0 +1,28 @@
+import type { IRequestContext, IResponse, IAuthToken } from './interfaces.core.js';
+/**
+ * Abstract base class for all registry protocol implementations
+ */
+export declare abstract class BaseRegistry {
+    /**
+     * Initialize the registry
+     */
+    abstract init(): Promise<void>;
+    /**
+     * Handle an incoming HTTP request
+     * @param context - Request context
+     * @returns Response object
+     */
+    abstract handleRequest(context: IRequestContext): Promise<IResponse>;
+    /**
+     * Get the base path for this registry protocol
+     */
+    abstract getBasePath(): string;
+    /**
+     * Validate that a token has the required permissions
+     * @param token - Authentication token
+     * @param resource - Resource being accessed
+     * @param action - Action being performed
+     * @returns true if authorized
+     */
+    protected abstract checkPermission(token: IAuthToken | null, resource: string, action: string): Promise<boolean>;
+}

package/dist_ts/core/classes.baseregistry.js

@@ -0,0 +1,6 @@
+/**
+ * Abstract base class for all registry protocol implementations
+ */
+export class BaseRegistry {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5iYXNlcmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb3JlL2NsYXNzZXMuYmFzZXJlZ2lzdHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxPQUFnQixZQUFZO0NBOEJqQyJ9