@modelprofile.com/browser-runtime 1.0.0

package/dist_ts/classes.artifactstore.js

@@ -0,0 +1,344 @@
+import * as plugins from './plugins.js';
+import { BrowserRuntimeError } from './errors.js';
+import { TransitionMutex, randomId, validateBoundedString, validateOptionalInteger, } from './utils.js';
+export class BrowserArtifactStore {
+    rootDirectory;
+    maxFileBytes;
+    maxArtifactsPerProject;
+    maxProjectBytes;
+    maxProjects;
+    maxTotalArtifacts;
+    maxTotalBytes;
+    artifactTtlMs;
+    now;
+    directoryKey = plugins.crypto.randomBytes(32);
+    projects = new Map();
+    mutex = new TransitionMutex();
+    totalArtifacts = 0;
+    totalBytes = 0;
+    started = false;
+    startPromise;
+    stopPromise;
+    sweepTimer;
+    sweepRunning = false;
+    constructor(options) {
+        if (!options || typeof options !== 'object' || !plugins.path.isAbsolute(options.rootDirectory)) {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'rootDirectory must be absolute');
+        }
+        this.rootDirectory = options.rootDirectory;
+        this.maxFileBytes = validateOptionalInteger(options.maxFileBytes, 'maxFileBytes', 1024, 64 * 1024 * 1024, 8 * 1024 * 1024);
+        this.maxArtifactsPerProject = validateOptionalInteger(options.maxArtifactsPerProject, 'maxArtifactsPerProject', 1, 4096, 256);
+        this.maxProjectBytes = validateOptionalInteger(options.maxProjectBytes, 'maxProjectBytes', this.maxFileBytes, 1024 * 1024 * 1024, 64 * 1024 * 1024);
+        this.maxProjects = validateOptionalInteger(options.maxProjects, 'maxProjects', 1, 256, 32);
+        this.maxTotalArtifacts = validateOptionalInteger(options.maxTotalArtifacts, 'maxTotalArtifacts', this.maxArtifactsPerProject, 65_536, Math.max(4096, this.maxArtifactsPerProject));
+        this.maxTotalBytes = validateOptionalInteger(options.maxTotalBytes, 'maxTotalBytes', this.maxProjectBytes, 8 * 1024 * 1024 * 1024, Math.max(512 * 1024 * 1024, this.maxProjectBytes));
+        this.artifactTtlMs = validateOptionalInteger(options.artifactTtlMs, 'artifactTtlMs', 1000, 24 * 60 * 60 * 1000, 60 * 60 * 1000);
+        this.now = options.now ?? Date.now;
+        if (typeof this.now !== 'function')
+            throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    start() {
+        if (this.started)
+            return Promise.resolve();
+        if (this.startPromise)
+            return this.startPromise;
+        this.startPromise = this.startInternal().finally(() => {
+            this.startPromise = undefined;
+        });
+        return this.startPromise;
+    }
+    stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        if (!this.started && !this.startPromise)
+            return Promise.resolve();
+        this.stopPromise = (async () => {
+            await this.startPromise?.catch(() => undefined);
+            if (this.sweepTimer)
+                clearInterval(this.sweepTimer);
+            this.sweepTimer = undefined;
+            const release = await this.mutex.acquire();
+            try {
+                await plugins.fsPromises.rm(this.rootDirectory, { recursive: true, force: true });
+                this.projects.clear();
+                this.totalArtifacts = 0;
+                this.totalBytes = 0;
+                this.started = false;
+            }
+            finally {
+                release();
+            }
+        })().finally(() => {
+            this.stopPromise = undefined;
+        });
+        return this.stopPromise;
+    }
+    async store(projectIdArg, mimeTypeArg, data) {
+        this.requireStarted();
+        const projectId = validateBoundedString(projectIdArg, 'projectId', 1, 128);
+        const mimeType = validateBoundedString(mimeTypeArg, 'mimeType', 1, 128);
+        if (!(data instanceof Uint8Array)) {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'data must be Uint8Array');
+        }
+        if (data.byteLength > this.maxFileBytes)
+            throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+        const bytes = plugins.Buffer.from(data);
+        const release = await this.mutex.acquire();
+        try {
+            this.requireStarted();
+            await this.purgeExpiredInternal(projectId);
+            const existingProject = this.projects.get(projectId);
+            if (!existingProject && this.projects.size >= this.maxProjects) {
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            }
+            if (this.totalArtifacts >= this.maxTotalArtifacts
+                || this.totalBytes + bytes.byteLength > this.maxTotalBytes)
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            const project = existingProject ?? await this.createProject(projectId);
+            if (project.artifacts.size >= this.maxArtifactsPerProject
+                || project.totalBytes + bytes.byteLength > this.maxProjectBytes)
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            const artifactId = randomId();
+            const createdAt = this.now();
+            const metadata = {
+                artifactId,
+                projectId,
+                mimeType,
+                size: bytes.byteLength,
+                createdAt,
+                expiresAt: createdAt + this.artifactTtlMs,
+            };
+            const stored = {
+                metadata,
+                digest: plugins.crypto.createHash('sha256').update(bytes).digest('hex'),
+            };
+            const projectDirectory = plugins.path.join(this.rootDirectory, project.directoryName);
+            const finalPath = plugins.path.join(projectDirectory, artifactId);
+            const temporaryPath = plugins.path.join(projectDirectory, `.${randomId(12)}.tmp`);
+            let handle;
+            let renamed = false;
+            try {
+                handle = await plugins.fsPromises.open(temporaryPath, 'wx', 0o600);
+                await handle.writeFile(bytes);
+                await handle.sync();
+                await handle.close();
+                handle = undefined;
+                await plugins.fsPromises.rename(temporaryPath, finalPath);
+                renamed = true;
+                await plugins.fsPromises.chmod(finalPath, 0o600);
+                project.artifacts.set(artifactId, stored);
+                project.totalBytes += bytes.byteLength;
+                this.totalArtifacts += 1;
+                this.totalBytes += bytes.byteLength;
+                return { ...metadata };
+            }
+            catch (error) {
+                await handle?.close().catch(() => undefined);
+                await plugins.fsPromises.rm(temporaryPath, { force: true }).catch(() => undefined);
+                if (renamed)
+                    await plugins.fsPromises.rm(finalPath, { force: true }).catch(() => undefined);
+                if (project.artifacts.size === 0)
+                    await this.removeEmptyProject(projectId, project);
+                throw error;
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    async read(projectIdArg, artifactIdArg) {
+        this.requireStarted();
+        const projectId = validateBoundedString(projectIdArg, 'projectId', 1, 128);
+        const artifactId = validateBoundedString(artifactIdArg, 'artifactId', 1, 128);
+        const release = await this.mutex.acquire();
+        let handle;
+        try {
+            const { project, stored, filePath } = this.resolveArtifact(projectId, artifactId);
+            if (stored.metadata.expiresAt <= this.now()) {
+                await this.deleteArtifact(projectId, project, stored, filePath);
+                throw new BrowserRuntimeError('INVALID_INPUT', 'artifact is unavailable');
+            }
+            handle = await plugins.fsPromises.open(filePath, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_NOFOLLOW);
+            const stat = await handle.stat();
+            if (!stat.isFile() || stat.size !== stored.metadata.size || stat.size > this.maxFileBytes) {
+                await handle.close();
+                handle = undefined;
+                await this.deleteArtifact(projectId, project, stored, filePath);
+                throw new BrowserRuntimeError('FENCED', 'artifact integrity check failed');
+            }
+            const data = plugins.Buffer.allocUnsafe(stat.size);
+            const { bytesRead } = await handle.read(data, 0, stat.size, 0);
+            await handle.close();
+            handle = undefined;
+            const digest = plugins.crypto.createHash('sha256').update(data).digest('hex');
+            if (bytesRead !== stat.size || digest !== stored.digest) {
+                await this.deleteArtifact(projectId, project, stored, filePath);
+                throw new BrowserRuntimeError('FENCED', 'artifact integrity check failed');
+            }
+            return new Uint8Array(data);
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+            release();
+        }
+    }
+    async delete(projectIdArg, artifactIdArg) {
+        this.requireStarted();
+        const projectId = validateBoundedString(projectIdArg, 'projectId', 1, 128);
+        const artifactId = validateBoundedString(artifactIdArg, 'artifactId', 1, 128);
+        const release = await this.mutex.acquire();
+        try {
+            const { project, stored, filePath } = this.resolveArtifact(projectId, artifactId);
+            await this.deleteArtifact(projectId, project, stored, filePath);
+        }
+        finally {
+            release();
+        }
+    }
+    async purgeExpired(projectIdArg) {
+        this.requireStarted();
+        const projectId = projectIdArg === undefined
+            ? undefined
+            : validateBoundedString(projectIdArg, 'projectId', 1, 128);
+        const release = await this.mutex.acquire();
+        try {
+            return await this.purgeExpiredInternal(projectId);
+        }
+        finally {
+            release();
+        }
+    }
+    async purgeProject(projectIdArg) {
+        this.requireStarted();
+        const projectId = validateBoundedString(projectIdArg, 'projectId', 1, 128);
+        const release = await this.mutex.acquire();
+        try {
+            const project = this.projects.get(projectId);
+            if (!project)
+                return;
+            await plugins.fsPromises.rm(plugins.path.join(this.rootDirectory, project.directoryName), { recursive: true, force: true });
+            this.totalArtifacts -= project.artifacts.size;
+            this.totalBytes -= project.totalBytes;
+            this.projects.delete(projectId);
+        }
+        finally {
+            release();
+        }
+    }
+    getMetadata(projectIdArg, artifactIdArg) {
+        this.requireStarted();
+        const projectId = validateBoundedString(projectIdArg, 'projectId', 1, 128);
+        const artifactId = validateBoundedString(artifactIdArg, 'artifactId', 1, 128);
+        const project = this.projects.get(projectId);
+        const stored = project?.artifacts.get(artifactId);
+        if (!stored || stored.metadata.expiresAt <= this.now()) {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'artifact is unavailable');
+        }
+        try {
+            const stat = plugins.fs.lstatSync(plugins.path.join(this.rootDirectory, project.directoryName, artifactId));
+            if (stat.isSymbolicLink() || !stat.isFile() || stat.size !== stored.metadata.size) {
+                throw new BrowserRuntimeError('FENCED', 'artifact integrity check failed');
+            }
+        }
+        catch (error) {
+            if (error instanceof BrowserRuntimeError)
+                throw error;
+            throw new BrowserRuntimeError('FENCED', 'artifact integrity check failed');
+        }
+        return { ...stored.metadata };
+    }
+    async startInternal() {
+        try {
+            await plugins.fsPromises.mkdir(this.rootDirectory, { recursive: false, mode: 0o700 });
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                const entries = await plugins.fsPromises.readdir(this.rootDirectory).catch(() => []);
+                throw new BrowserRuntimeError('FENCED', entries.length > 0 ? 'artifact root is not empty' : 'artifact root must not exist');
+            }
+            throw error;
+        }
+        const stat = await plugins.fsPromises.lstat(this.rootDirectory);
+        const uid = process.getuid?.();
+        if (!stat.isDirectory()
+            || stat.isSymbolicLink()
+            || (uid !== undefined && stat.uid !== uid)
+            || (stat.mode & 0o777) !== 0o700)
+            throw new BrowserRuntimeError('FENCED', 'artifact root is not private');
+        const entries = await plugins.fsPromises.readdir(this.rootDirectory);
+        if (entries.length > 0)
+            throw new BrowserRuntimeError('FENCED', 'artifact root is not empty');
+        await plugins.fsPromises.chmod(this.rootDirectory, 0o700);
+        this.started = true;
+        const sweepIntervalMs = Math.min(60_000, Math.max(1000, Math.floor(this.artifactTtlMs / 2)));
+        this.sweepTimer = setInterval(() => {
+            if (this.sweepRunning)
+                return;
+            this.sweepRunning = true;
+            void this.purgeExpired().catch(() => undefined).finally(() => {
+                this.sweepRunning = false;
+            });
+        }, sweepIntervalMs);
+        this.sweepTimer.unref();
+    }
+    requireStarted() {
+        if (!this.started)
+            throw new BrowserRuntimeError('NOT_RUNNING');
+    }
+    async createProject(projectId) {
+        const directoryName = plugins.crypto
+            .createHmac('sha256', this.directoryKey)
+            .update(projectId, 'utf8')
+            .digest('hex');
+        const projectDirectory = plugins.path.join(this.rootDirectory, directoryName);
+        await plugins.fsPromises.mkdir(projectDirectory, { recursive: false, mode: 0o700 });
+        const project = { directoryName, totalBytes: 0, artifacts: new Map() };
+        this.projects.set(projectId, project);
+        return project;
+    }
+    async purgeExpiredInternal(projectId) {
+        const projectIds = projectId === undefined ? [...this.projects.keys()] : [projectId];
+        let purged = 0;
+        for (const currentProjectId of projectIds) {
+            const project = this.projects.get(currentProjectId);
+            if (!project)
+                continue;
+            for (const stored of [...project.artifacts.values()]) {
+                if (stored.metadata.expiresAt <= this.now()) {
+                    const filePath = plugins.path.join(this.rootDirectory, project.directoryName, stored.metadata.artifactId);
+                    await this.deleteArtifact(currentProjectId, project, stored, filePath);
+                    purged += 1;
+                }
+            }
+        }
+        return purged;
+    }
+    async deleteArtifact(projectId, project, stored, filePath) {
+        await plugins.fsPromises.rm(filePath, { force: true });
+        if (project.artifacts.delete(stored.metadata.artifactId)) {
+            project.totalBytes = Math.max(0, project.totalBytes - stored.metadata.size);
+            this.totalArtifacts = Math.max(0, this.totalArtifacts - 1);
+            this.totalBytes = Math.max(0, this.totalBytes - stored.metadata.size);
+        }
+        await this.removeEmptyProject(projectId, project);
+    }
+    async removeEmptyProject(projectId, project) {
+        if (project.artifacts.size > 0 || this.projects.get(projectId) !== project)
+            return;
+        await plugins.fsPromises.rm(plugins.path.join(this.rootDirectory, project.directoryName), { recursive: true, force: true });
+        this.projects.delete(projectId);
+    }
+    resolveArtifact(projectId, artifactId) {
+        const project = this.projects.get(projectId);
+        const stored = project?.artifacts.get(artifactId);
+        if (!project || !stored) {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'artifact is unavailable');
+        }
+        return {
+            project,
+            stored,
+            filePath: plugins.path.join(this.rootDirectory, project.directoryName, artifactId),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.artifactstore.js","sourceRoot":"","sources":["../ts/classes.artifactstore.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.egressproxy.d.ts

@@ -0,0 +1,67 @@
+import type { IBrowserEgressProxyOptions, IBrowserEgressProxyStats } from './interfaces.js';
+export declare class BrowserEgressProxy {
+    private readonly projectId;
+    private readonly allowedPorts;
+    private readonly maxConnections;
+    private readonly maxActiveRequests;
+    private readonly maxHeaderBytes;
+    private readonly connectTimeoutMs;
+    private readonly idleTimeoutMs;
+    private readonly tunnelLifetimeMs;
+    private readonly requestTimeoutMs;
+    private readonly maxRequestBytes;
+    private readonly maxResponseBytes;
+    private readonly maxTunnelBytes;
+    private readonly resolver;
+    private readonly connector;
+    private readonly username;
+    private readonly password;
+    private readonly expectedAuthorization;
+    private readonly clientSockets;
+    private readonly upstreamSockets;
+    private readonly activeOperations;
+    private server?;
+    private listenPort?;
+    private startPromise?;
+    private stopPromise?;
+    private lifecycleState;
+    private lifecycleController;
+    private ordinaryRequests;
+    private upgradeRequests;
+    private connectRequests;
+    private rejectedRequests;
+    constructor(options: IBrowserEgressProxyOptions);
+    get credentials(): {
+        username: string;
+        password: string;
+    };
+    get port(): number;
+    get project(): string;
+    get allowedTargetPorts(): number[];
+    getStats(): IBrowserEgressProxyStats;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private startInternal;
+    private stopInternal;
+    private track;
+    private admit;
+    private handleHttpRequest;
+    private handleConnect;
+    private handleUpgrade;
+    private authorize;
+    private sendProxyAuthenticationRequired;
+    private sendSafeFailure;
+    private rejectRawSocket;
+    private sanitizeHeaders;
+    private resolveAbsoluteTarget;
+    private resolveAuthority;
+    private canonicalizeHostname;
+    private resolveHost;
+    private openUpstream;
+    private waitForConnect;
+    private pipeTunnel;
+    private readWebSocketHandshake;
+    private createOperationSignal;
+    private raceAbort;
+    private waitForResponseCompletion;
+}