@lotagate/cli 0.1.22 → 0.1.23

package/dist/infrastructure/filesystem/workspace-media-artifact-store.js

@@ -1,152 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { atomicWriteFile } from './atomic-file-store.js';
-import { assertExternalWriteTarget, assertWorkspaceWriteTarget, resolveExternalOutputPath, resolveExternalPath, resolveWorkspacePath, } from './path-resolver.js';
-const MAX_OUTPUT_NAME_ATTEMPTS = 10_000;
-const DEFAULT_MEDIA_OUTPUT_DIRECTORIES = {
-    image: path.join('tmp', 'images'),
-    speech: path.join('tmp', 'speechs'),
-    transcription: path.join('tmp', 'transcribes'),
-    translation: path.join('tmp', 'translates'),
-    video: path.join('tmp', 'videos'),
-};
-/** Persists generated media below the workspace by default or in an explicitly supplied local directory. */
-export class WorkspaceMediaArtifactStore {
-    cwd;
-    logger;
-    constructor(cwd, logger) {
-        this.cwd = cwd;
-        this.logger = logger;
-    }
-    async writeMany(request, artifacts) {
-        if (artifacts.length === 0)
-            throw invalidOutput('The provider returned no media artifacts.');
-        if (request.out !== undefined && artifacts.length !== 1)
-            throw invalidOutput('--out can only be used when exactly one artifact is returned. Use --out-dir instead.');
-        const targetDirectory = await this.resolveDirectory(request);
-        const externalOutput = request.outDir !== undefined;
-        const results = [];
-        for (const [index, artifact] of artifacts.entries()) {
-            const initialTarget = await this.resolveTarget(request, targetDirectory, index, artifacts.length);
-            const defaultTarget = request.out === undefined;
-            const target = defaultTarget ? await reserveAvailableTarget(initialTarget, this.context(), externalOutput) : initialTarget;
-            let reserved = defaultTarget;
-            try {
-                await fs.mkdir(path.dirname(target), { recursive: true });
-                await assertWriteTarget(target, this.context(), externalOutput);
-                if (!reserved)
-                    reserved = await reserveTarget(target, request.force, this.context(), externalOutput);
-                await atomicWriteFile(target, artifact);
-                await assertWriteTarget(target, this.context(), externalOutput);
-            }
-            catch (error) {
-                if (reserved)
-                    await releaseReservedTarget(target, this.context(), externalOutput);
-                throw error;
-            }
-            results.push({ path: target, bytes: artifact.byteLength });
-        }
-        this.logger?.info('Media artifacts stored.', {
-            kind: request.kind,
-            artifactCount: results.length,
-            artifactBytes: results.reduce((total, artifact) => total + artifact.bytes, 0),
-        });
-        return results;
-    }
-    async resolveDirectory(request) {
-        const supplied = request.outDir ?? DEFAULT_MEDIA_OUTPUT_DIRECTORIES[request.kind];
-        return request.outDir === undefined
-            ? resolveWorkspacePath(supplied, this.context(), true)
-            : resolveExternalPath(supplied, { cwd: this.cwd }, true);
-    }
-    async resolveTarget(request, directory, index, total) {
-        if (request.out !== undefined) {
-            validateOutputName(request.out);
-            const suffix = total > 1 ? `-${index + 1}` : '';
-            return this.resolveOutputPath(path.join(directory, `${request.out}${suffix}.${request.extension}`), request.outDir !== undefined);
-        }
-        const suffix = total > 1 ? `-${index + 1}` : '';
-        const candidate = path.join(directory, `${toSafeStem(request.source)}${suffix}.${request.extension}`);
-        return this.resolveOutputPath(candidate, request.outDir !== undefined);
-    }
-    resolveOutputPath(candidate, externalOutput) {
-        return externalOutput
-            ? resolveExternalOutputPath(candidate, { cwd: this.cwd })
-            : resolveWorkspacePath(candidate, this.context(), true);
-    }
-    context() { return { cwd: this.cwd, workspaceRoot: this.cwd }; }
-}
-async function assertWriteTarget(target, context, externalOutput) {
-    if (externalOutput)
-        await assertExternalWriteTarget(target);
-    else
-        await assertWorkspaceWriteTarget(target, context);
-}
-async function reserveTarget(target, overwrite, context, externalOutput) {
-    if (overwrite)
-        return false;
-    try {
-        await fs.mkdir(path.dirname(target), { recursive: true });
-        await assertWriteTarget(target, context, externalOutput);
-        const handle = await fs.open(target, 'wx', 0o600);
-        await handle.close();
-        await assertWriteTarget(target, context, externalOutput);
-        return true;
-    }
-    catch (error) {
-        if (isAlreadyExists(error))
-            throw invalidOutput(`Refusing to overwrite an existing file: ${target}. Use --force with --out to replace it.`);
-        throw error;
-    }
-}
-async function reserveAvailableTarget(initialTarget, context, externalOutput) {
-    const parsed = path.parse(initialTarget);
-    for (let attempt = 0; attempt < MAX_OUTPUT_NAME_ATTEMPTS; attempt += 1) {
-        const target = attempt === 0 ? initialTarget : path.join(parsed.dir, `${parsed.name}-${attempt + 1}${parsed.ext}`);
-        try {
-            await fs.mkdir(parsed.dir, { recursive: true });
-            await assertWriteTarget(target, context, externalOutput);
-            const handle = await fs.open(target, 'wx', 0o600);
-            await handle.close();
-            await assertWriteTarget(target, context, externalOutput);
-            return target;
-        }
-        catch (error) {
-            if (!isAlreadyExists(error))
-                throw error;
-        }
-    }
-    throw invalidOutput(`Unable to allocate a unique output path near: ${initialTarget}.`);
-}
-async function releaseReservedTarget(target, context, externalOutput) {
-    try {
-        await assertWriteTarget(target, context, externalOutput);
-        await fs.rm(target, { force: true });
-    }
-    catch {
-        // Do not delete a path that no longer resolves inside the trusted workspace.
-    }
-}
-function toSafeStem(source) {
-    const stem = source
-        .normalize('NFKD').replace(/[^a-zA-Z0-9]+/gu, '-').replace(/^-+|-+$/gu, '')
-        .toLowerCase().slice(0, 72);
-    return stem.length === 0 ? 'media' : stem;
-}
-function validateOutputName(value) {
-    const hasControlCharacter = [...value].some(character => {
-        const codePoint = character.codePointAt(0) ?? 0;
-        return codePoint < 32 || codePoint === 127;
-    });
-    if (value.length === 0 || value === '.' || value === '..' || value.includes('/') || value.includes('\\') || hasControlCharacter) {
-        throw invalidOutput('--out must be a filename without path separators or control characters.');
-    }
-}
-function isAlreadyExists(error) {
-    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'EEXIST';
-}
-function invalidOutput(userMessage) {
-    return new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, userMessage, { category: 'media', userMessage });
-}

package/dist/infrastructure/logging/daily-rotating-file-writer.d.ts

@@ -1,20 +0,0 @@
-export interface DailyRotatingFileWriterOptions {
-    retentionDays: number;
-    now?: () => number;
-}
-export declare class DailyRotatingFileWriter {
-    private readonly directory;
-    private readonly options;
-    private readonly now;
-    private queue;
-    private queueBytes;
-    private dropped;
-    private drainPromise;
-    private closed;
-    constructor(directory: string, options: DailyRotatingFileWriterOptions);
-    write(line: string): void;
-    flush(): Promise<void>;
-    close(): Promise<void>;
-    private drain;
-    private prune;
-}

package/dist/infrastructure/logging/daily-rotating-file-writer.js

@@ -1,75 +0,0 @@
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-export class DailyRotatingFileWriter {
-    directory;
-    options;
-    now;
-    queue = [];
-    queueBytes = 0;
-    dropped = 0;
-    drainPromise = Promise.resolve();
-    closed = false;
-    constructor(directory, options) {
-        this.directory = directory;
-        this.options = options;
-        this.now = options.now ?? Date.now;
-        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-        this.prune();
-    }
-    write(line) {
-        if (this.closed)
-            return;
-        const lineBytes = Buffer.byteLength(line, 'utf8');
-        if (this.queue.length >= RESOURCE_LIMITS.logQueueEntries || this.queueBytes + lineBytes > RESOURCE_LIMITS.logQueueBytes) {
-            this.dropped += 1;
-            return;
-        }
-        this.queue.push({ filePath: path.join(this.directory, `lotagate-${utcDate(this.now())}.jsonl`), line });
-        this.queueBytes += lineBytes;
-        this.drainPromise = this.drainPromise.then(() => this.drain()).catch(() => undefined);
-    }
-    async flush() {
-        await this.drainPromise;
-        if (this.queue.length > 0) {
-            this.drainPromise = this.drainPromise.then(() => this.drain()).catch(() => undefined);
-            await this.drainPromise;
-        }
-    }
-    async close() {
-        this.closed = true;
-        await this.flush();
-    }
-    async drain() {
-        if (this.queue.length === 0)
-            return;
-        const entries = this.queue.splice(0, this.queue.length);
-        this.queueBytes = 0;
-        if (this.dropped > 0) {
-            entries.push({ filePath: path.join(this.directory, `lotagate-${utcDate(this.now())}.jsonl`), line: `${JSON.stringify({ timestamp: new Date(this.now()).toISOString(), level: 'warn', message: 'Log entries dropped because the file writer queue was full.', dropped: this.dropped })}\n` });
-            this.dropped = 0;
-        }
-        const grouped = new Map();
-        for (const entry of entries)
-            grouped.set(entry.filePath, [...(grouped.get(entry.filePath) ?? []), entry.line]);
-        for (const [filePath, lines] of grouped)
-            await fsp.appendFile(filePath, lines.join(''), { encoding: 'utf8', mode: 0o600 });
-    }
-    prune() {
-        const cutoff = this.now() - this.options.retentionDays * 24 * 60 * 60 * 1_000;
-        for (const entry of fs.readdirSync(this.directory, { withFileTypes: true })) {
-            if (!entry.isFile())
-                continue;
-            const match = /^lotagate-(\d{4}-\d{2}-\d{2})\.jsonl$/u.exec(entry.name);
-            if (match === null || match[1] === undefined)
-                continue;
-            const timestamp = Date.parse(`${match[1]}T00:00:00.000Z`);
-            if (Number.isFinite(timestamp) && timestamp < cutoff)
-                fs.rmSync(path.join(this.directory, entry.name), { force: true });
-        }
-    }
-}
-function utcDate(timestamp) {
-    return new Date(timestamp).toISOString().slice(0, 10);
-}

package/dist/infrastructure/logging/log-redactor.d.ts

@@ -1,2 +0,0 @@
-export declare function redactLogDetails(details: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
-export declare function redactLogText(value: string): string;

package/dist/infrastructure/logging/log-redactor.js

@@ -1,26 +0,0 @@
-const SENSITIVE_KEY = /(api.?key|authorization|credential|password|private.?key|secret|token)/iu;
-export function redactLogDetails(details) {
-    if (details === undefined)
-        return undefined;
-    return redactRecord(details);
-}
-function redactRecord(value) {
-    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, SENSITIVE_KEY.test(key) ? '[REDACTED]' : redactValue(entry)]));
-}
-function redactValue(value) {
-    if (typeof value === 'string')
-        return redactString(value);
-    if (Array.isArray(value))
-        return value.map((item) => item !== null && typeof item === 'object' ? redactRecord(item) : typeof item === 'string' ? redactString(item) : item);
-    if (value !== null && typeof value === 'object')
-        return redactRecord(value);
-    return value;
-}
-export function redactLogText(value) { return redactString(value); }
-function redactString(value) {
-    return value
-        .replace(/Bearer\s+[^\s]+/giu, 'Bearer [REDACTED]')
-        .replace(/sk-[A-Za-z0-9_-]{8,}/gu, '[REDACTED]')
-        .replace(/((?:api[_-]?key|password|secret|token|authorization)\s*[:=]\s*)[^\s,]+/giu, '$1[REDACTED]')
-        .replace(/([?&](?:key|token|secret|password|auth|api[_-]?key)=)[^&#\s]+/giu, '$1[REDACTED]');
-}

package/dist/infrastructure/logging/logging-policy.d.ts

@@ -1,6 +0,0 @@
-import type { LogLevel } from '../../ports/logger.js';
-export interface LoggingPolicy {
-    level: LogLevel;
-    retentionDays: number;
-}
-export declare function resolveLoggingPolicy(env?: Readonly<Record<string, string | undefined>>): LoggingPolicy;

package/dist/infrastructure/logging/logging-policy.js

@@ -1,6 +0,0 @@
-import { readBoundedEnvironmentInteger } from '../config/environment-values.js';
-export function resolveLoggingPolicy(env = process.env) {
-    const rawLevel = env['LOTAGATE_LOG_LEVEL']?.trim().toLowerCase();
-    const level = rawLevel === 'error' || rawLevel === 'warn' || rawLevel === 'debug' || rawLevel === 'trace' ? rawLevel : 'info';
-    return { level, retentionDays: readBoundedEnvironmentInteger(env['LOTAGATE_LOG_RETENTION_DAYS'], 14, 1, 365) };
-}

package/dist/infrastructure/logging/structured-logger.d.ts

@@ -1,24 +0,0 @@
-import type { Logger, LogLevel } from '../../ports/logger.js';
-import type { Writable } from 'node:stream';
-import type { DailyRotatingFileWriter } from './daily-rotating-file-writer.js';
-export interface StructuredLoggerOptions {
-    level?: LogLevel;
-    consoleLevel?: LogLevel;
-    json?: boolean;
-    output?: Writable;
-    file?: DailyRotatingFileWriter;
-}
-export declare class StructuredLogger implements Logger {
-    private readonly minimumPriority;
-    private readonly consoleMinimumPriority;
-    private readonly output;
-    private readonly json;
-    private readonly file;
-    constructor(options?: StructuredLoggerOptions);
-    error(message: string, details?: Record<string, unknown>): void;
-    warn(message: string, details?: Record<string, unknown>): void;
-    info(message: string, details?: Record<string, unknown>): void;
-    debug(message: string, details?: Record<string, unknown>): void;
-    trace(message: string, details?: Record<string, unknown>): void;
-    private write;
-}

package/dist/infrastructure/logging/structured-logger.js

@@ -1,40 +0,0 @@
-import { redactLogDetails, redactLogText } from './log-redactor.js';
-const LEVEL_PRIORITY = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    debug: 3,
-    trace: 4,
-};
-export class StructuredLogger {
-    minimumPriority;
-    consoleMinimumPriority;
-    output;
-    json;
-    file;
-    constructor(options = {}) {
-        this.minimumPriority = LEVEL_PRIORITY[options.level ?? 'info'];
-        this.consoleMinimumPriority = LEVEL_PRIORITY[options.consoleLevel ?? options.level ?? 'info'];
-        this.output = options.output ?? process.stderr;
-        this.json = options.json ?? false;
-        this.file = options.file;
-    }
-    error(message, details) { this.write('error', message, details); }
-    warn(message, details) { this.write('warn', message, details); }
-    info(message, details) { this.write('info', message, details); }
-    debug(message, details) { this.write('debug', message, details); }
-    trace(message, details) { this.write('trace', message, details); }
-    write(level, message, details) {
-        if (LEVEL_PRIORITY[level] > this.minimumPriority)
-            return;
-        const safeDetails = redactLogDetails(details);
-        const safeMessage = redactLogText(message);
-        const entry = { timestamp: new Date().toISOString(), level, message: safeMessage, ...(safeDetails ?? {}) };
-        if (LEVEL_PRIORITY[level] <= this.consoleMinimumPriority)
-            this.output.write(this.json ? `${JSON.stringify(entry)}\n` : `[${level}] ${safeMessage}\n`);
-        try {
-            this.file?.write(`${JSON.stringify(entry)}\n`);
-        }
-        catch { /* File logging must not hide the original CLI result. */ }
-    }
-}

package/dist/infrastructure/network/safe-media-downloader.d.ts

@@ -1,23 +0,0 @@
-import https from 'node:https';
-export interface DownloadedMedia {
-    readonly bytes: Uint8Array;
-    readonly contentType: string | undefined;
-}
-export interface PublicMediaAddress {
-    readonly address: string;
-    readonly family: 4 | 6;
-}
-export interface PublicMediaDownloaderDependencies {
-    resolveAddresses?: (hostname: string) => Promise<readonly PublicMediaAddress[]>;
-    request?: typeof https.request;
-}
-interface DownloadOptions {
-    readonly maxBytes: number;
-    readonly timeoutMs: number;
-    readonly signal?: AbortSignal | undefined;
-}
-/** Downloads a generated artifact only through a verified public HTTPS address. */
-export declare function downloadPublicMedia(rawUrl: string | undefined, options: DownloadOptions): Promise<DownloadedMedia>;
-/** Creates an isolated downloader for CLI infrastructure tests and alternate Node transports. */
-export declare function createPublicMediaDownloader(dependencies?: PublicMediaDownloaderDependencies): (rawUrl: string | undefined, options: DownloadOptions) => Promise<DownloadedMedia>;
-export {};

package/dist/infrastructure/network/safe-media-downloader.js

@@ -1,239 +0,0 @@
-import { lookup } from 'node:dns/promises';
-import https from 'node:https';
-import { isIP } from 'node:net';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-/** Downloads a generated artifact only through a verified public HTTPS address. */
-export async function downloadPublicMedia(rawUrl, options) {
-    return createPublicMediaDownloader()(rawUrl, options);
-}
-/** Creates an isolated downloader for CLI infrastructure tests and alternate Node transports. */
-export function createPublicMediaDownloader(dependencies = {}) {
-    const resolveAddresses = dependencies.resolveAddresses ?? resolveAddressesFromDns;
-    const request = dependencies.request ?? https.request;
-    return async (rawUrl, options) => {
-        const url = parsePublicHttpsUrl(rawUrl);
-        return withDownloadSignal(options, async (signal) => {
-            const addresses = await resolvePublicDestination(url.hostname, resolveAddresses, signal, options.signal);
-            const response = await requestPublicResponse(url, addresses, request, signal, options.signal);
-            if (response.statusCode === undefined || response.statusCode < 200 || response.statusCode >= 300) {
-                response.destroy();
-                throw mediaError(`Image download failed with HTTP ${response.statusCode ?? 'unknown'}.`);
-            }
-            const contentLength = response.headers['content-length'];
-            const length = Array.isArray(contentLength) ? contentLength[0] : contentLength;
-            if (length !== undefined && (!/^\d+$/u.test(length) || Number(length) > options.maxBytes)) {
-                response.destroy();
-                throw mediaError('Downloaded image exceeds the supported output limit.');
-            }
-            return {
-                bytes: await readResponseBounded(response, options.maxBytes, signal, options.signal),
-                contentType: contentType(response.headers['content-type']),
-            };
-        });
-    };
-}
-function parsePublicHttpsUrl(rawUrl) {
-    if (rawUrl === undefined)
-        throw mediaError('The provider returned an image without Base64 data or a download URL.');
-    let url;
-    try {
-        url = new URL(rawUrl);
-    }
-    catch {
-        throw mediaError('The provider returned an invalid image download URL.');
-    }
-    if (url.protocol !== 'https:' || url.username || url.password || (url.port !== '' && url.port !== '443')) {
-        throw mediaError('Image download URLs must use public HTTPS on port 443.');
-    }
-    return url;
-}
-async function resolvePublicDestination(hostname, resolveAddresses, signal, parentSignal) {
-    if (hostname.toLowerCase() === 'localhost')
-        throw mediaError('Image download URL must not target localhost.');
-    const addresses = await awaitWithAbort(resolveAddresses(hostname), signal, parentSignal);
-    if (addresses.length === 0 || addresses.some((entry) => !isPublicIpAddress(entry.address))) {
-        throw mediaError('Image download URL must resolve only to public network addresses.');
-    }
-    return addresses;
-}
-async function resolveAddressesFromDns(hostname) {
-    const addresses = await lookup(hostname, { all: true, verbatim: true });
-    return addresses.map((entry) => ({ address: entry.address, family: entry.family === 6 ? 6 : 4 }));
-}
-async function requestPublicResponse(url, addresses, request, signal, parentSignal) {
-    let lastError;
-    for (const address of addresses) {
-        try {
-            return await requestPinnedResponse(url, address, request, signal, parentSignal);
-        }
-        catch (error) {
-            if (signal.aborted)
-                throw abortedDownloadError(signal, parentSignal);
-            lastError = error;
-        }
-    }
-    const detail = lastError instanceof Error && lastError.message.length > 0 ? `: ${lastError.message}` : '';
-    throw mediaError(`Image download failed${detail}`);
-}
-function requestPinnedResponse(url, address, request, signal, parentSignal) {
-    return new Promise((resolve, reject) => {
-        let completed = false;
-        let clientRequest;
-        const finish = (callback) => {
-            if (completed)
-                return;
-            completed = true;
-            signal.removeEventListener('abort', abort);
-            callback();
-        };
-        const abort = () => {
-            const error = abortedDownloadError(signal, parentSignal);
-            clientRequest?.destroy(error);
-            finish(() => reject(error));
-        };
-        try {
-            clientRequest = request({
-                protocol: 'https:',
-                hostname: url.hostname,
-                port: 443,
-                path: `${url.pathname}${url.search}`,
-                method: 'GET',
-                servername: url.hostname,
-                lookup: (_hostname, options, callback) => {
-                    if (options.all === true)
-                        callback(null, [{ address: address.address, family: address.family }]);
-                    else
-                        callback(null, address.address, address.family);
-                },
-            }, (response) => finish(() => resolve(response)));
-            clientRequest.once('error', (error) => finish(() => reject(error)));
-            if (signal.aborted)
-                abort();
-            else
-                signal.addEventListener('abort', abort, { once: true });
-            clientRequest.end();
-        }
-        catch (error) {
-            finish(() => reject(error));
-        }
-    });
-}
-async function readResponseBounded(response, maxBytes, signal, parentSignal) {
-    const chunks = [];
-    let size = 0;
-    const abort = () => { response.destroy(); };
-    if (signal.aborted)
-        abort();
-    else
-        signal.addEventListener('abort', abort, { once: true });
-    try {
-        for await (const chunk of response) {
-            if (signal.aborted)
-                throw abortedDownloadError(signal, parentSignal);
-            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            size += bytes.byteLength;
-            if (size > maxBytes) {
-                response.destroy();
-                throw mediaError('Downloaded image exceeds the supported output limit.');
-            }
-            chunks.push(bytes);
-        }
-    }
-    catch (error) {
-        if (signal.aborted)
-            throw abortedDownloadError(signal, parentSignal);
-        if (error instanceof CliError)
-            throw error;
-        throw mediaError(error instanceof Error ? `Image download failed: ${error.message}` : 'Image download failed.');
-    }
-    finally {
-        signal.removeEventListener('abort', abort);
-    }
-    if (signal.aborted)
-        throw abortedDownloadError(signal, parentSignal);
-    const result = new Uint8Array(size);
-    let offset = 0;
-    for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return result;
-}
-async function withDownloadSignal(options, operation) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(new Error('Image download timed out.')), options.timeoutMs);
-    const forwardAbort = () => controller.abort(options.signal?.reason);
-    if (options.signal?.aborted)
-        forwardAbort();
-    else
-        options.signal?.addEventListener('abort', forwardAbort, { once: true });
-    try {
-        return await operation(controller.signal);
-    }
-    finally {
-        clearTimeout(timeout);
-        options.signal?.removeEventListener('abort', forwardAbort);
-    }
-}
-async function awaitWithAbort(operation, signal, parentSignal) {
-    if (signal.aborted)
-        throw abortedDownloadError(signal, parentSignal);
-    return new Promise((resolve, reject) => {
-        const abort = () => {
-            signal.removeEventListener('abort', abort);
-            reject(abortedDownloadError(signal, parentSignal));
-        };
-        signal.addEventListener('abort', abort, { once: true });
-        operation.then((value) => { signal.removeEventListener('abort', abort); resolve(value); }, (error) => { signal.removeEventListener('abort', abort); reject(error); });
-    });
-}
-function contentType(value) {
-    const raw = Array.isArray(value) ? value[0] : value;
-    return raw?.split(';', 1)[0]?.trim() || undefined;
-}
-function isPublicIpAddress(address) {
-    const version = isIP(address);
-    if (version === 4)
-        return isPublicIpv4(address);
-    if (version === 6)
-        return isPublicIpv6(address);
-    return false;
-}
-function isPublicIpv4(address) {
-    const parts = address.split('.').map(Number);
-    const [first, second] = parts;
-    if (first === undefined || second === undefined)
-        return false;
-    if (first === 0 || first === 10 || first === 127 || first >= 224)
-        return false;
-    if (first === 100 && second >= 64 && second <= 127)
-        return false;
-    if (first === 169 && second === 254)
-        return false;
-    if (first === 172 && second >= 16 && second <= 31)
-        return false;
-    if (first === 192 && second === 168)
-        return false;
-    if (first === 198 && (second === 18 || second === 19))
-        return false;
-    return true;
-}
-function isPublicIpv6(address) {
-    const normalized = address.toLowerCase();
-    if (normalized === '::' || normalized === '::1' || normalized.startsWith('fe80:') || normalized.startsWith('fc') || normalized.startsWith('fd'))
-        return false;
-    const mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/u);
-    return mapped === null || isPublicIpv4(mapped[1]);
-}
-function abortedDownloadError(signal, parentSignal) {
-    if (parentSignal?.aborted)
-        return interrupted(parentSignal.reason);
-    return mediaError('Image download timed out.');
-}
-function interrupted(cause) {
-    return new CliError(CLI_ERROR_CODES.INTERRUPTED, 'Media command interrupted.', { category: 'media', userMessage: 'Media command interrupted.', retryable: true, cause });
-}
-function mediaError(userMessage) {
-    return new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, userMessage, { category: 'media', userMessage });
-}

package/dist/infrastructure/platform/host-platform.d.ts

@@ -1,14 +0,0 @@
-export type HostPlatformId = 'windows' | 'linux' | 'macos' | 'bsd' | 'unsupported';
-export type HostNodePlatform = typeof process.platform;
-export interface HostPlatformContext {
-    readonly id: HostPlatformId;
-    readonly nodePlatform: HostNodePlatform;
-    readonly isWindows: boolean;
-    readonly supportsProcessGroups: boolean;
-    readonly env: Readonly<Record<string, string | undefined>>;
-}
-export interface HostPlatformInput {
-    nodePlatform?: HostNodePlatform;
-    env?: Readonly<Record<string, string | undefined>>;
-}
-export declare function detectHostPlatform(input?: HostPlatformInput): HostPlatformContext;

package/dist/infrastructure/platform/host-platform.js

@@ -1,23 +0,0 @@
-export function detectHostPlatform(input = {}) {
-    const nodePlatform = input.nodePlatform ?? process.platform;
-    const id = identifyPlatform(nodePlatform);
-    const isWindows = id === 'windows';
-    return {
-        id,
-        nodePlatform,
-        isWindows,
-        supportsProcessGroups: !isWindows,
-        env: input.env ?? process.env,
-    };
-}
-function identifyPlatform(platform) {
-    if (platform === 'win32' || platform === 'cygwin')
-        return 'windows';
-    if (platform === 'linux' || platform === 'android')
-        return 'linux';
-    if (platform === 'darwin')
-        return 'macos';
-    if (platform === 'freebsd' || platform === 'openbsd' || platform === 'netbsd')
-        return 'bsd';
-    return 'unsupported';
-}