@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/sandbox/engines/authority.js

@@ -1,289 +0,0 @@
-import { createHash } from 'node:crypto';
-import { runProbe } from '../shell.js';
-import { getAdapter } from './index.js';
-function digest(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-function canonical(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonical).join(',')}]`;
-    if (!value || typeof value !== 'object')
-        return JSON.stringify(value) ?? 'null';
-    return `{${Object.entries(value)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`)
-        .join(',')}}`;
-}
-function text(value) {
-    return typeof value === 'string' ? value : value?.toString('utf8') ?? '';
-}
-function safeEndpoint(value) {
-    if (!value)
-        return 'docker-default';
-    try {
-        const parsed = new URL(value);
-        const hasUnreplayableParts = Boolean(parsed.username || parsed.password || parsed.search || parsed.hash);
-        parsed.username = '';
-        parsed.password = '';
-        parsed.search = '';
-        parsed.hash = '';
-        const normalized = parsed.toString().replace(/\/$/u, '');
-        return hasUnreplayableParts
-            ? `${normalized}#<redacted>`
-            : normalized;
-    }
-    catch {
-        const normalized = value
-            .replace(/\/\/[^/@]+@/u, '//<redacted>@')
-            .replace(/[?&](?:token|password|secret|key)=[^&]*/giu, '');
-        return /[@?#]/u.test(value) ? `${normalized.replace(/[?#].*$/u, '')}#<redacted>` : normalized;
-    }
-}
-function lockDomainFor(engine, endpoint) {
-    return digest(`${process.platform}\0${process.arch}\0${engine}\0${endpoint}`);
-}
-function contextRoute(context) {
-    return {
-        kind: 'context',
-        selector: { context },
-        endpoint: `docker-context://${context}`,
-        command: (args) => ({ cmd: 'docker', args: ['--context', context, ...args] })
-    };
-}
-function endpointRoute(endpoint, rawEndpoint, unreplayable) {
-    return {
-        kind: 'endpoint',
-        selector: {
-            source: 'DOCKER_HOST',
-            endpoint,
-            ...(unreplayable ? { unreplayable } : {})
-        },
-        endpoint,
-        command: (args) => ({ cmd: 'docker', args: ['--host', rawEndpoint, ...args] })
-    };
-}
-function tlsEnvironmentReason(env) {
-    return env.DOCKER_TLS_VERIFY || env.DOCKER_CERT_PATH || env.DOCKER_TLS
-        ? 'tls-environment'
-        : undefined;
-}
-function routeFor(engine, env) {
-    const context = getAdapter(engine).dockerContext;
-    if (context) {
-        return contextRoute(context);
-    }
-    if (env.DOCKER_CONTEXT) {
-        return contextRoute(env.DOCKER_CONTEXT);
-    }
-    if (env.DOCKER_HOST) {
-        return endpointRoute(safeEndpoint(env.DOCKER_HOST), env.DOCKER_HOST, tlsEnvironmentReason(env));
-    }
-    return contextRoute('default');
-}
-function validRouteName(value) {
-    return /^[A-Za-z0-9][A-Za-z0-9_.@/-]*$/u.test(value);
-}
-function resolveWslDistro(probe, timeoutMs, explicit) {
-    if (explicit) {
-        if (!validRouteName(explicit))
-            throw new Error('SANDBOX_AUTHORITY_ROUTE_CAPTURE_FAILED');
-        return explicit;
-    }
-    const result = probe('wsl.exe', ['--list', '--verbose'], timeoutMs === undefined ? {} : { timeout: timeoutMs });
-    if (result.status !== 0)
-        throw new Error('SANDBOX_AUTHORITY_ROUTE_CAPTURE_FAILED');
-    const output = text(result.stdout).replace(/\0/gu, '').replace(/\r/gu, '');
-    const defaultLine = output.split('\n').find((line) => /^\s*\*\s+/u.test(line));
-    const distro = defaultLine?.replace(/^\s*\*\s+/u, '').replace(/\s+(?:Running|Stopped)\s+\d+\s*$/iu, '').trim();
-    if (!distro || !validRouteName(distro))
-        throw new Error('SANDBOX_AUTHORITY_ROUTE_CAPTURE_FAILED');
-    return distro;
-}
-function wslRoute(distro, context, env) {
-    const endpoint = env.DOCKER_HOST
-        ? safeEndpoint(env.DOCKER_HOST)
-        : `wsl://${distro}/${context ?? 'default'}`;
-    const unreplayable = tlsEnvironmentReason(env)
-        ?? (endpoint.includes('<redacted>') ? 'ambient-endpoint-secret' : undefined);
-    return {
-        kind: 'wsl2',
-        selector: {
-            distro,
-            ...(context ? { context } : {}),
-            ...(unreplayable ? { unreplayable } : {}),
-            ...(env.DOCKER_HOST ? { endpoint } : {})
-        },
-        endpoint,
-        command: (args) => ({
-            cmd: 'wsl.exe',
-            args: [
-                '--distribution', distro,
-                '--exec', 'docker',
-                ...(context ? ['--context', context] : []),
-                ...(env.DOCKER_HOST ? ['--host', env.DOCKER_HOST] : []),
-                ...args
-            ]
-        })
-    };
-}
-function currentWslRoute(env, probe, timeoutMs) {
-    const distro = resolveWslDistro(probe, timeoutMs, env.WSL_DISTRO_NAME);
-    let context = env.DOCKER_CONTEXT;
-    if (!context && !env.DOCKER_HOST) {
-        const result = probe('wsl.exe', ['--distribution', distro, '--exec', 'docker', 'context', 'show'], timeoutMs === undefined ? {} : { timeout: timeoutMs });
-        context = text(result.stdout).trim();
-        if (result.status !== 0 || !validRouteName(context)) {
-            throw new Error('SANDBOX_AUTHORITY_ROUTE_CAPTURE_FAILED');
-        }
-    }
-    return wslRoute(distro, context, env);
-}
-function routeFromEvidence(evidence) {
-    return {
-        kind: evidence.routeKind,
-        selector: evidence.routeSelector,
-        endpoint: evidence.normalizedEndpoint,
-        command: (args) => commandForSandboxAuthority(evidence, 'docker', args)
-    };
-}
-function currentContextRoute(engine, env, probe, timeoutMs) {
-    const configured = routeFor(engine, env);
-    if (configured.kind !== 'context' || configured.selector.context !== 'default')
-        return configured;
-    if (env.DOCKER_CONTEXT || env.DOCKER_HOST || getAdapter(engine).dockerContext)
-        return configured;
-    const result = probe('docker', ['context', 'show'], timeoutMs === undefined ? {} : { timeout: timeoutMs });
-    const context = text(result.stdout).trim();
-    if (result.status !== 0 || !/^[A-Za-z0-9][A-Za-z0-9_.@/-]*$/u.test(context)) {
-        throw new Error('SANDBOX_AUTHORITY_ROUTE_CAPTURE_FAILED');
-    }
-    return contextRoute(context);
-}
-/** Build a command using only the route persisted with the sandbox authority. */
-export function commandForSandboxAuthority(evidence, cmd, args = []) {
-    if (cmd !== 'docker') {
-        throw new Error('SANDBOX_AUTHORITY_ROUTE_UNSUPPORTED');
-    }
-    if (evidence.routeKind === 'context') {
-        const context = evidence.routeSelector.context;
-        if (!context)
-            throw new Error('SANDBOX_AUTHORITY_ROUTE_INVALID');
-        return { cmd, args: ['--context', context, ...args] };
-    }
-    if (evidence.routeKind === 'endpoint') {
-        const endpoint = evidence.routeSelector.endpoint;
-        if (!endpoint || endpoint.includes('<redacted>') || evidence.routeSelector.unreplayable) {
-            throw new Error('SANDBOX_AUTHORITY_ROUTE_UNREPLAYABLE');
-        }
-        return { cmd, args: ['--host', endpoint, ...args] };
-    }
-    if (evidence.routeKind === 'wsl2') {
-        const distro = evidence.routeSelector.distro;
-        const context = evidence.routeSelector.context;
-        const endpoint = evidence.routeSelector.endpoint;
-        if (!distro || evidence.routeSelector.unreplayable || endpoint?.includes('<redacted>')) {
-            throw new Error('SANDBOX_AUTHORITY_ROUTE_UNREPLAYABLE');
-        }
-        return {
-            cmd: 'wsl.exe',
-            args: [
-                '--distribution', distro,
-                '--exec', cmd,
-                ...(context ? ['--context', context] : []),
-                ...(endpoint && !endpoint.startsWith('wsl://') ? ['--host', endpoint] : []),
-                ...args
-            ]
-        };
-    }
-    return { cmd, args: ['--context', 'default', ...args] };
-}
-export function authorityVersionArgs() {
-    return ['version', '--format', '{{json .Server}}'];
-}
-export function captureSandboxAuthority(engine, options = {}) {
-    const env = options.env ?? process.env;
-    const probe = options.probe ?? runProbe;
-    const route = options.route
-        ? routeFromEvidence(options.route)
-        : engine === 'wsl2'
-            ? currentWslRoute(env, probe, options.timeoutMs)
-            : currentContextRoute(engine, env, probe, options.timeoutMs);
-    function probeJson(args) {
-        const command = options.route
-            ? commandForSandboxAuthority(options.route, 'docker', args)
-            : route.command(args);
-        try {
-            const response = probe(command.cmd, command.args, options.timeoutMs === undefined ? {} : { timeout: options.timeoutMs });
-            if (response.status !== 0)
-                throw new Error('SANDBOX_AUTHORITY_CAPTURE_FAILED');
-            return JSON.parse(text(response.stdout).trim());
-        }
-        catch {
-            throw new Error('SANDBOX_AUTHORITY_CAPTURE_FAILED');
-        }
-    }
-    const server = probeJson(authorityVersionArgs());
-    if (!server || typeof server !== 'object' || Array.isArray(server)) {
-        throw new Error('SANDBOX_AUTHORITY_CAPTURE_FAILED');
-    }
-    const record = server;
-    const api = typeof record.ApiVersion === 'string' ? /^(\d+)\.(\d+)$/u.exec(record.ApiVersion) : null;
-    if (!api)
-        throw new Error('SANDBOX_AUTHORITY_CAPTURE_FAILED');
-    // Docker version exposes API metadata; the daemon ID belongs to Docker info.
-    const serverId = probeJson(['info', '--format', '{{json .ID}}']);
-    if (typeof serverId !== 'string' || !serverId.trim())
-        throw new Error('SANDBOX_AUTHORITY_CAPTURE_FAILED');
-    const normalizedEndpoint = route.endpoint;
-    const evidenceWithoutFingerprint = {
-        version: 1,
-        provider: engine,
-        lockDomain: options.lockDomain ?? options.route?.lockDomain ?? lockDomainFor(engine, normalizedEndpoint),
-        routeKind: route.kind,
-        routeSelector: route.selector,
-        normalizedEndpoint,
-        endpointFingerprint: digest(normalizedEndpoint),
-        daemonIdentity: { kind: 'docker-server-id', fingerprint: digest(serverId) },
-        apiVersion: { major: Number(api[1]), minor: Number(api[2]) }
-    };
-    return {
-        ...evidenceWithoutFingerprint,
-        authorityFingerprint: digest(canonical(evidenceWithoutFingerprint))
-    };
-}
-export function verifySandboxAuthority(expected, actual) {
-    if (!expected)
-        return { state: 'unknown', reason: 'SANDBOX_AUTHORITY_EVIDENCE_MISSING' };
-    if (!actual)
-        return { state: 'unknown', reason: 'SANDBOX_AUTHORITY_UNAVAILABLE' };
-    if (expected.authorityFingerprint !== actual.authorityFingerprint
-        || expected.lockDomain !== actual.lockDomain
-        || expected.routeKind !== actual.routeKind
-        || expected.endpointFingerprint !== actual.endpointFingerprint
-        || expected.daemonIdentity.fingerprint !== actual.daemonIdentity.fingerprint) {
-        return { state: 'conflict', reason: 'SANDBOX_AUTHORITY_DRIFT' };
-    }
-    return { state: 'verified' };
-}
-export function isSandboxAuthorityEvidence(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const evidence = value;
-    const selector = evidence.routeSelector;
-    const daemon = evidence.daemonIdentity;
-    const api = evidence.apiVersion;
-    return evidence.version === 1
-        && typeof evidence.provider === 'string'
-        && /^[a-f0-9]{64}$/u.test(evidence.lockDomain)
-        && ['default', 'context', 'endpoint', 'wsl2'].includes(evidence.routeKind)
-        && !!selector && typeof selector === 'object' && !Array.isArray(selector)
-        && Object.values(selector).every((entry) => typeof entry === 'string')
-        && typeof evidence.normalizedEndpoint === 'string'
-        && /^[a-f0-9]{64}$/u.test(evidence.endpointFingerprint)
-        && !!daemon && daemon.kind === 'docker-server-id'
-        && /^[a-f0-9]{64}$/u.test(daemon.fingerprint)
-        && !!api && Number.isSafeInteger(api.major) && api.major >= 0
-        && Number.isSafeInteger(api.minor) && api.minor >= 0
-        && /^[a-f0-9]{64}$/u.test(evidence.authorityFingerprint);
-}
-//# sourceMappingURL=authority.js.map