@poe-platform/safe-bash 0.1.803 → 0.1.804

package/dist/remote-execution/materializations.js

@@ -1,284 +0,0 @@
-import { parseWireJson } from './wire-json.js';
-import { validateNativeResult } from './native-result.js';
-import { assertJobInvocation } from './job-binding.js';
-import { validateDependencyManifest, validateDependencyMaterialization, validateDependencyMaterializeRequest, validateManifestInvocation } from './protocol.js';
-import { UploadError } from './upload-protocol.js';
-function validateJob(value, max) {
-    const invalid = () => { throw new TypeError('Invalid native job status'); };
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        invalid();
-    const job = value;
-    const invocation = job.invocation;
-    if (!invocation || typeof invocation !== 'object' || Array.isArray(invocation))
-        invalid();
-    for (const id of [job.jobId, job.materializationId, job.directoryRevision, invocation.sessionId,
-        invocation.epoch, invocation.buildId, invocation.sourceAuthorityId, invocation.bindingId, invocation.materializationId])
-        if (typeof id !== 'string' || !id.length || id.length > 256)
-            invalid();
-    validateManifestInvocation({ manifestId: invocation.manifestId, manifestRevision: invocation.manifestRevision,
-        directoryRevision: invocation.directoryRevision, cwd: invocation.cwd, originalArgv: invocation.originalArgv }, { maxArguments: max, maxArgvBytes: max, maxPathBytes: max });
-    if (job.materializationId !== invocation.materializationId || job.directoryRevision !== invocation.directoryRevision
-        || !['accepted', 'running', 'exited', 'failed'].includes(job.state))
-        invalid();
-    if (job.state === 'exited') {
-        validateNativeResult(job.result);
-        if (job.error !== undefined || job.failure !== undefined)
-            invalid();
-    }
-    else if (job.result !== undefined)
-        invalid();
-    if (job.state === 'failed') {
-        if (!['readiness', 'integrity', 'native'].includes(job.error) || !job.failure
-            || typeof job.failure.message !== 'string' || (job.failure.code !== undefined && typeof job.failure.code !== 'string'))
-            invalid();
-    }
-    else if (job.error !== undefined || job.failure !== undefined)
-        invalid();
-}
-function invocationIdentity(invocation) {
-    return JSON.stringify([invocation.sessionId, invocation.epoch, invocation.buildId, invocation.sourceAuthorityId,
-        invocation.bindingId, invocation.materializationId, invocation.manifestId, invocation.manifestRevision,
-        invocation.directoryRevision, invocation.cwd, invocation.originalArgv]);
-}
-function validateStatus(value) {
-    const invalid = () => { throw new TypeError('Invalid materialization status'); };
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        invalid();
-    const s = value;
-    // The HTTP profile adds logical paths and failure/cleanup observations to the
-    // shared progress record. Validate that record with the same contract used by
-    // protocol consumers, including its preparation-only error vocabulary.
-    const { logicalRoot, cwd, failureCategory, cleanup, readiness, ...progress } = s;
-    try {
-        validateDependencyMaterialization(progress);
-    }
-    catch {
-        invalid();
-    }
-    for (const path of [logicalRoot, cwd]) {
-        if (!Array.isArray(path) || path[0] !== 47)
-            invalid();
-        for (const n of path)
-            if (!Number.isInteger(n) || n < 1 || n > 255)
-                invalid();
-    }
-    // Check the byte component boundary even on a first recovered observation,
-    // before there is a stored manifest identity to compare. This is only the
-    // logical binding check: leave symlink-sensitive dotdot resolution to the
-    // server rather than normalizing or rewriting the reported cwd.
-    if (!(logicalRoot.length === 1 && logicalRoot[0] === 47)
-        && (cwd.length < logicalRoot.length
-            || logicalRoot.some((octet, index) => cwd[index] !== octet)
-            || cwd.length > logicalRoot.length && cwd[logicalRoot.length] !== 47))
-        invalid();
-    if (s.state === 'ready' && failureCategory !== undefined)
-        invalid();
-    if (failureCategory !== undefined && !['readiness', 'integrity'].includes(failureCategory))
-        invalid();
-    if (cleanup !== undefined && !['complete', 'failed'].includes(cleanup))
-        invalid();
-    if (readiness !== undefined) {
-        if (!Array.isArray(readiness))
-            invalid();
-        const identities = new Set();
-        for (const work of readiness) {
-            if (!work || typeof work.identity !== 'string' || !work.identity.length
-                || identities.has(work.identity)
-                || !['metadata-only', 'speculative', 'required'].includes(work.kind)
-                || !['pending', 'complete', 'failed'].includes(work.state))
-                invalid();
-            identities.add(work.identity);
-        }
-    }
-}
-/** Portable control client. Mutations are never automatically retried. An operation
- * key recovers materialization after a lost acknowledgement. */
-export function createExecutionClient(options) {
-    // Credentials may arrive asynchronously; the control authority cannot drift
-    // away from the session used to construct its endpoints during that await.
-    options = Object.freeze({ ...options });
-    const base = new URL(options.baseUrl);
-    if (base.protocol !== 'https:' || base.username || base.password || base.search || base.hash)
-        throw new TypeError('An authenticated HTTPS origin is required');
-    const root = new URL(`/v1/sessions/${encodeURIComponent(options.sessionId)}/`, base);
-    const max = options.maxResponseBytes ?? 1048576;
-    const manifestIdentities = new Map();
-    const operationIdentities = new Map();
-    const jobIdentities = new Map();
-    const manifestDigests = new Map();
-    async function digest(bytes) {
-        const hash = new Uint8Array(await crypto.subtle.digest('SHA-256', Uint8Array.from(bytes)));
-        return Array.from(hash, n => n.toString(16).padStart(2, '0')).join('');
-    }
-    if (!Number.isSafeInteger(max) || max < 1)
-        throw new TypeError('Invalid response limit');
-    async function request(path, method = 'GET', body, signal, key) {
-        signal?.throwIfAborted();
-        // Admission and response checks must use the same caller-owned snapshot,
-        // even when credentials or the operation acknowledgement arrive later.
-        body = structuredClone(body);
-        if (path === 'materializations' && method === 'POST') {
-            validateDependencyMaterializeRequest(body);
-            if (body.sessionId !== options.sessionId || body.epoch !== options.epoch)
-                throw new TypeError('Materialization scope mismatch');
-        }
-        if (path === 'jobs' && method === 'POST') {
-            const invocation = body;
-            assertJobInvocation(invocation);
-            if (invocation.sessionId !== options.sessionId || invocation.epoch !== options.epoch)
-                throw new TypeError('Job scope mismatch');
-            const operation = operationIdentities.get(invocation.materializationId);
-            if (operation !== undefined) {
-                const [manifestId, manifestRevision] = JSON.parse(operation.identity);
-                if (invocation.manifestId !== manifestId || invocation.manifestRevision !== manifestRevision
-                    || operation.readyRevision !== undefined && invocation.directoryRevision !== operation.readyRevision)
-                    throw new UploadError(409, 'Native job identity mismatch');
-            }
-        }
-        const headers = new Headers({ Authorization: `Bearer ${await options.token()}`, 'Execution-Epoch': options.epoch, 'Execution-Profile': 'dependency-manifest-v1' });
-        if (method !== 'GET') {
-            headers.set('Idempotency-Key', key ?? crypto.randomUUID());
-            headers.set('Content-Type', 'application/json');
-        }
-        const response = await (options.fetch ?? globalThis.fetch)(new URL(path, root), { method, headers, body: body === undefined ? undefined : JSON.stringify(body), signal, redirect: 'error' });
-        if (!response.ok || response.headers.get('Execution-Epoch') !== options.epoch) {
-            await response.body?.cancel();
-            throw new UploadError(response.ok ? 410 : response.status, 'Execution control request failed; inspect before retrying');
-        }
-        const reader = response.body?.getReader();
-        const abort = () => { void reader?.cancel(signal?.reason).catch(() => { }); };
-        signal?.addEventListener('abort', abort, { once: true });
-        try {
-            if (!reader)
-                throw new TypeError('Missing response');
-            const chunks = [];
-            let size = 0;
-            for (;;) {
-                signal?.throwIfAborted();
-                const part = await reader.read();
-                signal?.throwIfAborted();
-                if (part.done)
-                    break;
-                size += part.value.length;
-                if (size > max)
-                    throw new TypeError('Response limit');
-                chunks.push(part.value);
-            }
-            const bytes = new Uint8Array(size);
-            let offset = 0;
-            for (const chunk of chunks) {
-                bytes.set(chunk, offset);
-                offset += chunk.length;
-            }
-            const value = parseWireJson(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
-            if (!value || typeof value !== 'object')
-                throw new TypeError('Invalid control response');
-            if (path === 'manifests' && method === 'POST') {
-                const receipt = value;
-                if (typeof receipt.manifestId !== 'string' || !receipt.manifestId.length || receipt.manifestId.length > 256
-                    || receipt.revision !== body.revision
-                    || receipt.sha256 !== await digest(new TextEncoder().encode(JSON.stringify(body)))
-                    || manifestDigests.has(receipt.manifestId) && manifestDigests.get(receipt.manifestId) !== receipt.sha256)
-                    throw new TypeError('Manifest receipt identity mismatch');
-                manifestDigests.set(receipt.manifestId, receipt.sha256);
-            }
-            if (path.startsWith('manifests/')) {
-                validateDependencyManifest(value, { maxEntries: max, maxPathBytes: max });
-                const id = decodeURIComponent(path.slice('manifests/'.length));
-                const hash = await digest(bytes);
-                if (value.sessionId !== options.sessionId || value.epoch !== options.epoch
-                    || manifestDigests.has(id) && manifestDigests.get(id) !== hash)
-                    throw new TypeError('Manifest inspection identity mismatch');
-                manifestDigests.set(id, hash);
-            }
-            if (path === 'jobs' || path.startsWith('jobs/')) {
-                validateJob(value, max);
-                const identity = invocationIdentity(value.invocation);
-                const previous = jobIdentities.get(value.jobId);
-                if (value.invocation.sessionId !== options.sessionId || value.invocation.epoch !== options.epoch
-                    || previous !== undefined && previous !== identity
-                    || method === 'POST' && identity !== invocationIdentity(body)
-                    || path.startsWith('jobs/') && value.jobId !== decodeURIComponent(path.slice('jobs/'.length)))
-                    throw new TypeError('Native job identity mismatch');
-                const operation = operationIdentities.get(value.materializationId);
-                if (operation !== undefined) {
-                    const [manifestId, manifestRevision] = JSON.parse(operation.identity);
-                    if (manifestId !== value.invocation.manifestId || manifestRevision !== value.invocation.manifestRevision
-                        || operation.readyRevision !== undefined && operation.readyRevision !== value.directoryRevision)
-                        throw new TypeError('Native job identity mismatch');
-                }
-                jobIdentities.set(value.jobId, identity);
-            }
-            if (path === 'materializations' || path.startsWith('materializations/')) {
-                const listing = path === 'materializations' && method === 'GET';
-                if (listing && !Array.isArray(value))
-                    throw new TypeError('Invalid materialization listing');
-                const observed = new Map();
-                for (const status of listing ? value : [value]) {
-                    validateStatus(status);
-                    const identity = JSON.stringify([status.manifestId, status.manifestRevision, status.logicalRoot, status.cwd, status.entries.length]);
-                    const previous = operationIdentities.get(status.operationId);
-                    if ((previous !== undefined && (previous.identity !== identity
-                        || previous.readyRevision !== undefined && previous.readyRevision !== status.directoryRevision))
-                        || observed.has(status.operationId))
-                        throw new TypeError('Materialization identity mismatch');
-                    observed.set(status.operationId, { identity, readyRevision: previous?.readyRevision ?? (status.state === 'ready' ? status.directoryRevision : undefined) });
-                    const manifest = manifestIdentities.get(status.manifestId);
-                    if (manifest !== undefined) {
-                        if (status.entries.length !== manifest.entryCount)
-                            throw new TypeError('Incomplete materialization status');
-                        if (status.manifestRevision !== manifest.revision
-                            || JSON.stringify(status.logicalRoot) !== manifest.logicalRoot
-                            || JSON.stringify(status.cwd) !== manifest.cwd)
-                            throw new TypeError('Manifest identity mismatch');
-                    }
-                    if (path.startsWith('materializations/') && status.operationId !== decodeURIComponent(path.slice('materializations/'.length)))
-                        throw new TypeError('Materialization identity mismatch');
-                    if (method === 'POST') {
-                        const input = body;
-                        if (status.manifestId !== input.manifestId || status.manifestRevision !== input.manifestRevision)
-                            throw new TypeError('Manifest identity mismatch');
-                        // Initial readiness requires a complete starting tree. Inspection
-                        // may later report live readiness loss without discarding the
-                        // admitted revision; execution revalidates that work independently.
-                        if (status.state === 'ready' && status.readiness !== undefined
-                            && (!status.readiness.some(work => work.kind === 'required')
-                                || status.readiness.some(work => work.kind === 'required' && work.state !== 'complete')))
-                            throw new TypeError('Incomplete required readiness');
-                    }
-                }
-                // Retain only fully validated observations; progress and readiness may
-                // evolve, but an operation cannot acquire another admitted tree.
-                for (const [id, identity] of observed)
-                    operationIdentities.set(id, identity);
-            }
-            return value;
-        }
-        finally {
-            signal?.removeEventListener('abort', abort);
-            await reader?.cancel().catch(() => { });
-            reader?.releaseLock();
-        }
-    }
-    return {
-        async putManifest(manifest, signal) {
-            const document = structuredClone(manifest);
-            validateDependencyManifest(document, { maxEntries: max, maxPathBytes: max });
-            if (document.sessionId !== options.sessionId || document.epoch !== options.epoch)
-                throw new TypeError('Manifest scope mismatch');
-            const receipt = await request('manifests', 'POST', document, signal);
-            manifestIdentities.set(receipt.manifestId, { revision: document.revision, logicalRoot: JSON.stringify(document.logicalRoot), cwd: JSON.stringify(document.cwd), entryCount: document.entries.length });
-            return receipt;
-        },
-        async inspectManifest(id, signal) {
-            const manifest = await request(`manifests/${encodeURIComponent(id)}`, 'GET', undefined, signal);
-            manifestIdentities.set(id, { revision: manifest.revision, logicalRoot: JSON.stringify(manifest.logicalRoot), cwd: JSON.stringify(manifest.cwd), entryCount: manifest.entries.length });
-            return manifest;
-        },
-        materialize(input, signal) { return request('materializations', 'POST', input, signal, input.operationKey); },
-        inspectMaterialization(id, signal) { return request(`materializations/${encodeURIComponent(id)}`, 'GET', undefined, signal); },
-        listMaterializations(signal) { return request('materializations', 'GET', undefined, signal); },
-        execute(input, signal, key) { return request('jobs', 'POST', input, signal, key); },
-        inspectJob(id, signal) { return request(`jobs/${encodeURIComponent(id)}`, 'GET', undefined, signal); },
-    };
-}

package/dist/remote-execution/modal-driver.js

@@ -1,90 +0,0 @@
-import { createRestExecutionDriver } from './rest-driver.js';
-export function createModalExecutionDriver(config, resolve, fetch = globalThis.fetch, now = Date.now) {
-    // Retain the validated selection across asynchronous attachments and requests.
-    config = { ...config };
-    if (!['standard-sandbox', 'vm-sandbox'].includes(config.executionClass))
-        throw new TypeError('Explicit supported Sandbox execution class required');
-    if (!Number.isSafeInteger(config.port) || config.port < 1 || config.port > 65535 || !Number.isSafeInteger(config.readinessTimeoutMs) || config.readinessTimeoutMs <= 0)
-        throw new TypeError('Explicit port and readiness deadline required');
-    async function service(namespaceId, options) {
-        const sandbox = await resolve(namespaceId, options);
-        if (sandbox.executionClass !== config.executionClass) {
-            sandbox.detach?.();
-            throw new Error('Sandbox execution class mismatch');
-        }
-        return sandbox;
-    }
-    return createRestExecutionDriver(config, async (namespaceId, signal) => {
-        let sandbox;
-        let expiresAt;
-        let retired = false;
-        try {
-            const deadline = now() + config.readinessTimeoutMs;
-            function remaining() {
-                signal.throwIfAborted();
-                const time = now();
-                if (sandbox && (!Number.isFinite(expiresAt) || expiresAt <= time))
-                    throw new Error('Sandbox lease expired');
-                if (deadline <= time)
-                    throw new Error('Sandbox readiness deadline exceeded');
-                return Math.min(deadline, expiresAt ?? deadline) - time;
-            }
-            // SDK calls cannot be interrupted by detach(). Reject the caller promptly,
-            // handle late completion, and release listeners/timers on every outcome.
-            async function wait(operation) {
-                const timeoutMs = remaining();
-                let timer;
-                let abort = () => { };
-                const cancelled = new Promise((_, reject) => {
-                    abort = () => reject(signal.reason);
-                    signal.addEventListener('abort', abort, { once: true });
-                    timer = setTimeout(() => reject(new Error('Sandbox readiness deadline or lease expired')), timeoutMs);
-                });
-                try {
-                    const result = await Promise.race([operation(timeoutMs), cancelled]);
-                    remaining();
-                    return result;
-                }
-                finally {
-                    clearTimeout(timer);
-                    signal.removeEventListener('abort', abort);
-                }
-            }
-            const attached = await wait(async () => {
-                const value = await service(namespaceId);
-                if (retired) {
-                    value.detach?.();
-                    throw new Error('Sandbox preparation already cancelled');
-                }
-                sandbox = value;
-                // Keep this request's lifetime tied to the selected binding even if the
-                // borrowed SDK handle is reused or its metadata rotates during readiness.
-                expiresAt = value.expiresAt;
-                return value;
-            });
-            if (await wait(() => attached.poll()) !== null)
-                throw new Error('Sandbox finished; explicit restart required');
-            await wait(timeoutMs => attached.waitUntilReady(timeoutMs));
-            if (await wait(() => attached.poll()) !== null)
-                throw new Error('Sandbox finished; explicit restart required');
-            const tunnel = (await wait(timeoutMs => attached.tunnels(timeoutMs)))[config.port];
-            if (!tunnel)
-                throw new Error('Service tunnel unavailable');
-            if (await wait(() => attached.poll()) !== null)
-                throw new Error('Sandbox finished; explicit restart required');
-            return { origin: tunnel.url, expiresAt: expiresAt };
-        }
-        finally {
-            retired = true;
-            sandbox?.detach?.();
-        }
-    }, fetch, now, async (namespaceId) => {
-        const sandbox = await service(namespaceId, { purpose: 'terminate' });
-        try {
-            await sandbox.terminate({ wait: true });
-        }
-        finally {
-            sandbox.detach?.();
-        }
-    });
-}

package/dist/remote-execution/native-result.d.ts

@@ -1,3 +0,0 @@
-import type { NativeResult } from './materializations.js';
-/** Shared admission for adapter results and portable status observations. */
-export declare function validateNativeResult(value: unknown): asserts value is NativeResult;

package/dist/remote-execution/native-result.js

@@ -1,16 +0,0 @@
-/** Shared admission for adapter results and portable status observations. */
-export function validateNativeResult(value) {
-    const invalid = () => { throw new TypeError('Invalid native job status'); };
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        invalid();
-    const result = value;
-    if (!Number.isSafeInteger(result.exitCode) || result.exitCode < 0)
-        invalid();
-    for (const octets of [result.stdout, result.stderr]) {
-        if (!Array.isArray(octets))
-            invalid();
-        for (const octet of octets)
-            if (!Number.isInteger(octet) || octet < 0 || octet > 255)
-                invalid();
-    }
-}

package/dist/remote-execution/output-freshness.d.ts

@@ -1,4 +0,0 @@
-import type { OutputFreshness } from './output-retrieval.js';
-/** Keep the validator's native receiver while preventing it from silently
- * validating a different identity/version under an acknowledged resume token. */
-export declare function admitOutputFreshness(guard: OutputFreshness): OutputFreshness;

package/dist/remote-execution/output-freshness.js

@@ -1,19 +0,0 @@
-/** Keep the validator's native receiver while preventing it from silently
- * validating a different identity/version under an acknowledged resume token. */
-export function admitOutputFreshness(guard) {
-    const { identity, version, assertCurrent } = guard;
-    if (identity === null || !['object', 'symbol'].includes(typeof identity)
-        || typeof version !== 'string' || !version.length || version.length > 256
-        || typeof assertCurrent !== 'function')
-        throw new TypeError('Invalid output freshness binding');
-    const validate = assertCurrent.bind(guard);
-    return Object.freeze({ identity, version, async assertCurrent(signal) {
-            signal?.throwIfAborted();
-            if (guard.identity !== identity || guard.version !== version)
-                throw new TypeError('Canonical output freshness binding changed');
-            await validate(signal);
-            signal?.throwIfAborted();
-            if (guard.identity !== identity || guard.version !== version)
-                throw new TypeError('Canonical output freshness binding changed');
-        } });
-}