@push.rocks/smartregistry 1.1.1

package/dist_ts/oci/classes.ociregistry.js

@@ -0,0 +1,565 @@
+import { BaseRegistry } from '../core/classes.baseregistry.js';
+import { RegistryStorage } from '../core/classes.registrystorage.js';
+import { AuthManager } from '../core/classes.authmanager.js';
+/**
+ * OCI Distribution Specification v1.1 compliant registry
+ */
+export class OciRegistry extends BaseRegistry {
+    storage;
+    authManager;
+    uploadSessions = new Map();
+    basePath = '/oci';
+    cleanupInterval;
+    constructor(storage, authManager, basePath = '/oci') {
+        super();
+        this.storage = storage;
+        this.authManager = authManager;
+        this.basePath = basePath;
+    }
+    async init() {
+        // Start cleanup of stale upload sessions
+        this.startUploadSessionCleanup();
+    }
+    getBasePath() {
+        return this.basePath;
+    }
+    async handleRequest(context) {
+        // Remove base path from URL
+        const path = context.path.replace(this.basePath, '');
+        // Extract token from Authorization header
+        const authHeader = context.headers['authorization'] || context.headers['Authorization'];
+        const tokenString = authHeader?.replace(/^Bearer\s+/i, '');
+        const token = tokenString ? await this.authManager.validateToken(tokenString, 'oci') : null;
+        // Route to appropriate handler
+        if (path === '/v2/' || path === '/v2') {
+            return this.handleVersionCheck();
+        }
+        // Manifest operations: /v2/{name}/manifests/{reference}
+        const manifestMatch = path.match(/^\/v2\/([^\/]+(?:\/[^\/]+)*)\/manifests\/([^\/]+)$/);
+        if (manifestMatch) {
+            const [, name, reference] = manifestMatch;
+            return this.handleManifestRequest(context.method, name, reference, token, context.body, context.headers);
+        }
+        // Blob operations: /v2/{name}/blobs/{digest}
+        const blobMatch = path.match(/^\/v2\/([^\/]+(?:\/[^\/]+)*)\/blobs\/(sha256:[a-f0-9]{64})$/);
+        if (blobMatch) {
+            const [, name, digest] = blobMatch;
+            return this.handleBlobRequest(context.method, name, digest, token, context.headers);
+        }
+        // Blob upload operations: /v2/{name}/blobs/uploads/
+        const uploadInitMatch = path.match(/^\/v2\/([^\/]+(?:\/[^\/]+)*)\/blobs\/uploads\/?$/);
+        if (uploadInitMatch && context.method === 'POST') {
+            const [, name] = uploadInitMatch;
+            return this.handleUploadInit(name, token, context.query, context.body);
+        }
+        // Blob upload operations: /v2/{name}/blobs/uploads/{uuid}
+        const uploadMatch = path.match(/^\/v2\/([^\/]+(?:\/[^\/]+)*)\/blobs\/uploads\/([^\/]+)$/);
+        if (uploadMatch) {
+            const [, name, uploadId] = uploadMatch;
+            return this.handleUploadSession(context.method, uploadId, token, context);
+        }
+        // Tags list: /v2/{name}/tags/list
+        const tagsMatch = path.match(/^\/v2\/([^\/]+(?:\/[^\/]+)*)\/tags\/list$/);
+        if (tagsMatch) {
+            const [, name] = tagsMatch;
+            return this.handleTagsList(name, token, context.query);
+        }
+        // Referrers: /v2/{name}/referrers/{digest}
+        const referrersMatch = path.match(/^\/v2\/([^\/]+(?:\/[^\/]+)*)\/referrers\/(sha256:[a-f0-9]{64})$/);
+        if (referrersMatch) {
+            const [, name, digest] = referrersMatch;
+            return this.handleReferrers(name, digest, token, context.query);
+        }
+        return {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' },
+            body: this.createError('NOT_FOUND', 'Endpoint not found'),
+        };
+    }
+    async checkPermission(token, resource, action) {
+        if (!token)
+            return false;
+        return this.authManager.authorize(token, `oci:repository:${resource}`, action);
+    }
+    // ========================================================================
+    // REQUEST HANDLERS
+    // ========================================================================
+    handleVersionCheck() {
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json',
+                'Docker-Distribution-API-Version': 'registry/2.0',
+            },
+            body: {},
+        };
+    }
+    async handleManifestRequest(method, repository, reference, token, body, headers) {
+        switch (method) {
+            case 'GET':
+                return this.getManifest(repository, reference, token, headers);
+            case 'HEAD':
+                return this.headManifest(repository, reference, token);
+            case 'PUT':
+                return this.putManifest(repository, reference, token, body, headers);
+            case 'DELETE':
+                return this.deleteManifest(repository, reference, token);
+            default:
+                return {
+                    status: 405,
+                    headers: {},
+                    body: this.createError('UNSUPPORTED', 'Method not allowed'),
+                };
+        }
+    }
+    async handleBlobRequest(method, repository, digest, token, headers) {
+        switch (method) {
+            case 'GET':
+                return this.getBlob(repository, digest, token, headers['range'] || headers['Range']);
+            case 'HEAD':
+                return this.headBlob(repository, digest, token);
+            case 'DELETE':
+                return this.deleteBlob(repository, digest, token);
+            default:
+                return {
+                    status: 405,
+                    headers: {},
+                    body: this.createError('UNSUPPORTED', 'Method not allowed'),
+                };
+        }
+    }
+    async handleUploadInit(repository, token, query, body) {
+        if (!await this.checkPermission(token, repository, 'push')) {
+            return {
+                status: 401,
+                headers: {},
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        // Check for monolithic upload (digest + body provided)
+        const digest = query.digest;
+        if (digest && body) {
+            // Monolithic upload: complete upload in single POST
+            const blobData = Buffer.isBuffer(body) ? body : Buffer.from(JSON.stringify(body));
+            // Verify digest
+            const calculatedDigest = await this.calculateDigest(blobData);
+            if (calculatedDigest !== digest) {
+                return {
+                    status: 400,
+                    headers: {},
+                    body: this.createError('DIGEST_INVALID', 'Provided digest does not match uploaded content'),
+                };
+            }
+            // Store the blob
+            await this.storage.putOciBlob(digest, blobData);
+            return {
+                status: 201,
+                headers: {
+                    'Location': `${this.basePath}/v2/${repository}/blobs/${digest}`,
+                    'Docker-Content-Digest': digest,
+                },
+                body: null,
+            };
+        }
+        // Standard chunked upload: create session
+        const uploadId = this.generateUploadId();
+        const session = {
+            uploadId,
+            repository,
+            chunks: [],
+            totalSize: 0,
+            createdAt: new Date(),
+            lastActivity: new Date(),
+        };
+        this.uploadSessions.set(uploadId, session);
+        return {
+            status: 202,
+            headers: {
+                'Location': `${this.basePath}/v2/${repository}/blobs/uploads/${uploadId}`,
+                'Docker-Upload-UUID': uploadId,
+            },
+            body: null,
+        };
+    }
+    async handleUploadSession(method, uploadId, token, context) {
+        const session = this.uploadSessions.get(uploadId);
+        if (!session) {
+            return {
+                status: 404,
+                headers: {},
+                body: this.createError('BLOB_UPLOAD_INVALID', 'Upload session not found'),
+            };
+        }
+        if (!await this.checkPermission(token, session.repository, 'push')) {
+            return {
+                status: 401,
+                headers: {},
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        switch (method) {
+            case 'PATCH':
+                return this.uploadChunk(uploadId, context.body, context.headers['content-range']);
+            case 'PUT':
+                return this.completeUpload(uploadId, context.query['digest'], context.body);
+            case 'GET':
+                return this.getUploadStatus(uploadId);
+            default:
+                return {
+                    status: 405,
+                    headers: {},
+                    body: this.createError('UNSUPPORTED', 'Method not allowed'),
+                };
+        }
+    }
+    // Continuing with the actual OCI operations implementation...
+    // (The rest follows the same pattern as before, adapted to return IResponse objects)
+    async getManifest(repository, reference, token, headers) {
+        if (!await this.checkPermission(token, repository, 'pull')) {
+            return {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': `Bearer realm="${this.basePath}/v2/token",service="registry",scope="repository:${repository}:pull"`,
+                },
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        // Resolve tag to digest if needed
+        let digest = reference;
+        if (!reference.startsWith('sha256:')) {
+            const tags = await this.getTagsData(repository);
+            digest = tags[reference];
+            if (!digest) {
+                return {
+                    status: 404,
+                    headers: {},
+                    body: this.createError('MANIFEST_UNKNOWN', 'Manifest not found'),
+                };
+            }
+        }
+        const manifestData = await this.storage.getOciManifest(repository, digest);
+        if (!manifestData) {
+            return {
+                status: 404,
+                headers: {},
+                body: this.createError('MANIFEST_UNKNOWN', 'Manifest not found'),
+            };
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/vnd.oci.image.manifest.v1+json',
+                'Docker-Content-Digest': digest,
+            },
+            body: manifestData,
+        };
+    }
+    async headManifest(repository, reference, token) {
+        if (!await this.checkPermission(token, repository, 'pull')) {
+            return {
+                status: 401,
+                headers: {},
+                body: null,
+            };
+        }
+        // Similar logic as getManifest but return headers only
+        let digest = reference;
+        if (!reference.startsWith('sha256:')) {
+            const tags = await this.getTagsData(repository);
+            digest = tags[reference];
+            if (!digest) {
+                return { status: 404, headers: {}, body: null };
+            }
+        }
+        const exists = await this.storage.ociManifestExists(repository, digest);
+        if (!exists) {
+            return { status: 404, headers: {}, body: null };
+        }
+        const manifestData = await this.storage.getOciManifest(repository, digest);
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/vnd.oci.image.manifest.v1+json',
+                'Docker-Content-Digest': digest,
+                'Content-Length': manifestData ? manifestData.length.toString() : '0',
+            },
+            body: null,
+        };
+    }
+    async putManifest(repository, reference, token, body, headers) {
+        if (!await this.checkPermission(token, repository, 'push')) {
+            return {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': `Bearer realm="${this.basePath}/v2/token",service="registry",scope="repository:${repository}:push"`,
+                },
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        if (!body) {
+            return {
+                status: 400,
+                headers: {},
+                body: this.createError('MANIFEST_INVALID', 'Manifest body is required'),
+            };
+        }
+        const manifestData = Buffer.isBuffer(body) ? body : Buffer.from(JSON.stringify(body));
+        const contentType = headers?.['content-type'] || headers?.['Content-Type'] || 'application/vnd.oci.image.manifest.v1+json';
+        // Calculate manifest digest
+        const digest = await this.calculateDigest(manifestData);
+        // Store manifest by digest
+        await this.storage.putOciManifest(repository, digest, manifestData, contentType);
+        // If reference is a tag (not a digest), update tags mapping
+        if (!reference.startsWith('sha256:')) {
+            const tags = await this.getTagsData(repository);
+            tags[reference] = digest;
+            const tagsPath = `oci/tags/${repository}/tags.json`;
+            await this.storage.putObject(tagsPath, Buffer.from(JSON.stringify(tags), 'utf-8'));
+        }
+        return {
+            status: 201,
+            headers: {
+                'Location': `${this.basePath}/v2/${repository}/manifests/${digest}`,
+                'Docker-Content-Digest': digest,
+            },
+            body: null,
+        };
+    }
+    async deleteManifest(repository, digest, token) {
+        if (!digest.startsWith('sha256:')) {
+            return {
+                status: 400,
+                headers: {},
+                body: this.createError('UNSUPPORTED', 'Must use digest for deletion'),
+            };
+        }
+        if (!await this.checkPermission(token, repository, 'delete')) {
+            return {
+                status: 401,
+                headers: {},
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        await this.storage.deleteOciManifest(repository, digest);
+        return {
+            status: 202,
+            headers: {},
+            body: null,
+        };
+    }
+    async getBlob(repository, digest, token, range) {
+        if (!await this.checkPermission(token, repository, 'pull')) {
+            return {
+                status: 401,
+                headers: {},
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        const data = await this.storage.getOciBlob(digest);
+        if (!data) {
+            return {
+                status: 404,
+                headers: {},
+                body: this.createError('BLOB_UNKNOWN', 'Blob not found'),
+            };
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'Docker-Content-Digest': digest,
+            },
+            body: data,
+        };
+    }
+    async headBlob(repository, digest, token) {
+        if (!await this.checkPermission(token, repository, 'pull')) {
+            return { status: 401, headers: {}, body: null };
+        }
+        const exists = await this.storage.ociBlobExists(digest);
+        if (!exists) {
+            return { status: 404, headers: {}, body: null };
+        }
+        const blob = await this.storage.getOciBlob(digest);
+        return {
+            status: 200,
+            headers: {
+                'Content-Length': blob ? blob.length.toString() : '0',
+                'Docker-Content-Digest': digest,
+            },
+            body: null,
+        };
+    }
+    async deleteBlob(repository, digest, token) {
+        if (!await this.checkPermission(token, repository, 'delete')) {
+            return {
+                status: 401,
+                headers: {},
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        await this.storage.deleteOciBlob(digest);
+        return {
+            status: 202,
+            headers: {},
+            body: null,
+        };
+    }
+    async uploadChunk(uploadId, data, contentRange) {
+        const session = this.uploadSessions.get(uploadId);
+        if (!session) {
+            return {
+                status: 404,
+                headers: {},
+                body: this.createError('BLOB_UPLOAD_INVALID', 'Upload session not found'),
+            };
+        }
+        session.chunks.push(data);
+        session.totalSize += data.length;
+        session.lastActivity = new Date();
+        return {
+            status: 202,
+            headers: {
+                'Location': `${this.basePath}/v2/${session.repository}/blobs/uploads/${uploadId}`,
+                'Range': `0-${session.totalSize - 1}`,
+                'Docker-Upload-UUID': uploadId,
+            },
+            body: null,
+        };
+    }
+    async completeUpload(uploadId, digest, finalData) {
+        const session = this.uploadSessions.get(uploadId);
+        if (!session) {
+            return {
+                status: 404,
+                headers: {},
+                body: this.createError('BLOB_UPLOAD_INVALID', 'Upload session not found'),
+            };
+        }
+        const chunks = [...session.chunks];
+        if (finalData)
+            chunks.push(finalData);
+        const blobData = Buffer.concat(chunks);
+        // Verify digest
+        const calculatedDigest = await this.calculateDigest(blobData);
+        if (calculatedDigest !== digest) {
+            return {
+                status: 400,
+                headers: {},
+                body: this.createError('DIGEST_INVALID', 'Digest mismatch'),
+            };
+        }
+        await this.storage.putOciBlob(digest, blobData);
+        this.uploadSessions.delete(uploadId);
+        return {
+            status: 201,
+            headers: {
+                'Location': `${this.basePath}/v2/${session.repository}/blobs/${digest}`,
+                'Docker-Content-Digest': digest,
+            },
+            body: null,
+        };
+    }
+    async getUploadStatus(uploadId) {
+        const session = this.uploadSessions.get(uploadId);
+        if (!session) {
+            return {
+                status: 404,
+                headers: {},
+                body: this.createError('BLOB_UPLOAD_INVALID', 'Upload session not found'),
+            };
+        }
+        return {
+            status: 204,
+            headers: {
+                'Location': `${this.basePath}/v2/${session.repository}/blobs/uploads/${uploadId}`,
+                'Range': session.totalSize > 0 ? `0-${session.totalSize - 1}` : '0-0',
+                'Docker-Upload-UUID': uploadId,
+            },
+            body: null,
+        };
+    }
+    async handleTagsList(repository, token, query) {
+        if (!await this.checkPermission(token, repository, 'pull')) {
+            return {
+                status: 401,
+                headers: {},
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        const tags = await this.getTagsData(repository);
+        const tagNames = Object.keys(tags);
+        const response = {
+            name: repository,
+            tags: tagNames,
+        };
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: response,
+        };
+    }
+    async handleReferrers(repository, digest, token, query) {
+        if (!await this.checkPermission(token, repository, 'pull')) {
+            return {
+                status: 401,
+                headers: {},
+                body: this.createError('DENIED', 'Insufficient permissions'),
+            };
+        }
+        const response = {
+            schemaVersion: 2,
+            mediaType: 'application/vnd.oci.image.index.v1+json',
+            manifests: [],
+        };
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: response,
+        };
+    }
+    // ========================================================================
+    // HELPER METHODS
+    // ========================================================================
+    async getTagsData(repository) {
+        const path = `oci/tags/${repository}/tags.json`;
+        const data = await this.storage.getObject(path);
+        return data ? JSON.parse(data.toString('utf-8')) : {};
+    }
+    async putTagsData(repository, tags) {
+        const path = `oci/tags/${repository}/tags.json`;
+        const data = Buffer.from(JSON.stringify(tags, null, 2), 'utf-8');
+        await this.storage.putObject(path, data);
+    }
+    generateUploadId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    async calculateDigest(data) {
+        const crypto = await import('crypto');
+        const hash = crypto.createHash('sha256').update(data).digest('hex');
+        return `sha256:${hash}`;
+    }
+    createError(code, message, detail) {
+        return {
+            errors: [{ code, message, detail }],
+        };
+    }
+    startUploadSessionCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            const now = new Date();
+            const maxAge = 60 * 60 * 1000; // 1 hour
+            for (const [uploadId, session] of this.uploadSessions.entries()) {
+                if (now.getTime() - session.lastActivity.getTime() > maxAge) {
+                    this.uploadSessions.delete(uploadId);
+                }
+            }
+        }, 10 * 60 * 1000);
+    }
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.ociregistry.js","sourceRoot":"","sources":["../../ts/oci/classes.ociregistry.ts"],"names":[],"mappings":"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"}

package/dist_ts/oci/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * OCI Registry module exports
+ */
+export { OciRegistry } from './classes.ociregistry.js';
+export * from './interfaces.oci.js';

package/dist_ts/oci/index.js

@@ -0,0 +1,6 @@
+/**
+ * OCI Registry module exports
+ */
+export { OciRegistry } from './classes.ociregistry.js';
+export * from './interfaces.oci.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9vY2kvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDdkQsY0FBYyxxQkFBcUIsQ0FBQyJ9