@lotagate/cli 0.1.22 → 0.1.23

package/dist/infrastructure/filesystem/atomic-file-store.js

@@ -1,106 +0,0 @@
-import crypto from 'node:crypto';
-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 { isAlreadyExists, isFileNotFound } from './fs-errors.js';
-const DEFAULT_LOCK_TIMEOUT_MS = 5_000;
-const DEFAULT_LOCK_STALE_MS = 15 * 60 * 1_000;
-const LOCK_RETRY_MS = 25;
-/** Writes a file through a same-directory temporary file and rename. */
-export async function atomicWriteFile(filePath, data, mode = 0o600) {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    const temporary = `${filePath}.tmp-${process.pid}-${crypto.randomUUID()}`;
-    try {
-        await fs.writeFile(temporary, data, { mode });
-        await fs.rename(temporary, filePath);
-    }
-    finally {
-        await fs.rm(temporary, { force: true });
-    }
-}
-/** Creates an advisory lock and removes it again when lock metadata cannot be persisted. */
-export async function acquireAdvisoryFileLock(lockPath) {
-    const handle = await fs.open(lockPath, 'wx', 0o600);
-    try {
-        await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
-        return handle;
-    }
-    catch (error) {
-        await releaseAdvisoryFileLock(handle, lockPath);
-        throw error;
-    }
-}
-/** Closes an advisory lock handle and removes its lock file even when close fails. */
-export async function releaseAdvisoryFileLock(handle, lockPath) {
-    try {
-        await handle.close();
-    }
-    finally {
-        await fs.rm(lockPath, { force: true });
-    }
-}
-/** Serializes mutations across CLI processes using an advisory lock file. */
-export async function withFileLock(filePath, operation, options = {}) {
-    const lockPath = `${filePath}.lock`;
-    const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
-    const staleMs = options.staleMs ?? DEFAULT_LOCK_STALE_MS;
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    const deadline = Date.now() + timeoutMs;
-    let handle;
-    while (handle === undefined) {
-        try {
-            handle = await acquireAdvisoryFileLock(lockPath);
-        }
-        catch (error) {
-            if (!isAlreadyExists(error))
-                throw error;
-            if (await recoverStaleLock(lockPath, staleMs))
-                continue;
-            if (Date.now() >= deadline) {
-                throw new CliError(CLI_ERROR_CODES.CONFIG_LOCKED, `Configuration file is locked: ${filePath}`, {
-                    category: 'config', userMessage: 'A configuration update is already in progress. Try again shortly.', retryable: true,
-                });
-            }
-            await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
-        }
-    }
-    try {
-        return await operation();
-    }
-    finally {
-        await releaseAdvisoryFileLock(handle, lockPath);
-    }
-}
-async function recoverStaleLock(lockPath, staleMs) {
-    let stat;
-    try {
-        stat = await fs.stat(lockPath);
-    }
-    catch (error) {
-        return isFileNotFound(error);
-    }
-    if (Date.now() - stat.mtimeMs < staleMs)
-        return false;
-    let pid;
-    try {
-        const value = JSON.parse(await fs.readFile(lockPath, 'utf8'));
-        pid = typeof value.pid === 'number' ? value.pid : undefined;
-    }
-    catch { /* An old malformed lock is recoverable. */ }
-    if (pid !== undefined && isProcessAlive(pid))
-        return false;
-    await fs.rm(lockPath, { force: true });
-    return true;
-}
-function isProcessAlive(pid) {
-    if (pid === process.pid)
-        return true;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/infrastructure/filesystem/bounded-file-reader.d.ts

@@ -1,6 +0,0 @@
-export interface BoundedFileRead {
-    bytes: Buffer;
-    truncated: boolean;
-}
-/** Reads at most maxBytes and never loads an entire untrusted file into memory. */
-export declare function readFileBounded(filePath: string, maxBytes: number): Promise<BoundedFileRead>;

package/dist/infrastructure/filesystem/bounded-file-reader.js

@@ -1,24 +0,0 @@
-import fs from 'node:fs/promises';
-/** Reads at most maxBytes and never loads an entire untrusted file into memory. */
-export async function readFileBounded(filePath, maxBytes) {
-    const limit = Math.max(0, Math.floor(maxBytes));
-    const handle = await fs.open(filePath, 'r');
-    try {
-        const chunks = [];
-        let total = 0;
-        const target = limit + 1;
-        while (total < target) {
-            const buffer = Buffer.alloc(Math.min(64 * 1024, target - total));
-            const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, null);
-            if (bytesRead === 0)
-                break;
-            chunks.push(buffer.subarray(0, bytesRead));
-            total += bytesRead;
-        }
-        const bytes = Buffer.concat(chunks);
-        return { bytes: bytes.subarray(0, limit), truncated: bytes.byteLength > limit };
-    }
-    finally {
-        await handle.close();
-    }
-}

package/dist/infrastructure/filesystem/bounded-json-reader.d.ts

@@ -1 +0,0 @@
-export declare function readJsonFileBounded(filePath: string, maxBytes: number): Promise<unknown>;

package/dist/infrastructure/filesystem/bounded-json-reader.js

@@ -1,7 +0,0 @@
-import { readFileBounded } from './bounded-file-reader.js';
-export async function readJsonFileBounded(filePath, maxBytes) {
-    const result = await readFileBounded(filePath, maxBytes);
-    if (result.truncated)
-        throw new Error(`File exceeds the maximum supported size: ${filePath}`);
-    return JSON.parse(result.bytes.toString('utf8'));
-}

package/dist/infrastructure/filesystem/fs-errors.d.ts

@@ -1,2 +0,0 @@
-export declare function isFileNotFound(error: unknown): boolean;
-export declare function isAlreadyExists(error: unknown): boolean;

package/dist/infrastructure/filesystem/fs-errors.js

@@ -1,6 +0,0 @@
-export function isFileNotFound(error) {
-    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
-}
-export function isAlreadyExists(error) {
-    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'EEXIST';
-}

package/dist/infrastructure/filesystem/gateway-media-input-reader.d.ts

@@ -1,12 +0,0 @@
-export interface GatewayImageEditInput {
-    readonly images: readonly Uint8Array[];
-    readonly mask: Uint8Array | undefined;
-}
-export interface GatewayAudioInput {
-    readonly bytes: Uint8Array;
-    readonly filename: string;
-    readonly sourceName: string;
-}
-/** Reads local upload inputs sequentially and enforces the gateway's published limits. */
-export declare function readGatewayImageEditInput(imageValue: string, maskValue: string | undefined, cwd: string): Promise<GatewayImageEditInput>;
-export declare function readGatewayAudioInput(source: string, cwd: string): Promise<GatewayAudioInput>;

package/dist/infrastructure/filesystem/gateway-media-input-reader.js

@@ -1,49 +0,0 @@
-import path from 'node:path';
-import { GATEWAY_MEDIA_LIMITS, validateImageEditInputCount, validateImageEditTotalSize, validateUploadSize, } from '../../domain/media/gateway-media-contract.js';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { normalizeImage } from '../clipboard/image-normalizer.js';
-import { readFileBounded } from './bounded-file-reader.js';
-import { resolveExternalPath } from './path-resolver.js';
-/** Reads local upload inputs sequentially and enforces the gateway's published limits. */
-export async function readGatewayImageEditInput(imageValue, maskValue, cwd) {
-    const paths = imageValue.split(',').map((item) => item.trim()).filter(Boolean);
-    validateImageEditInputCount(paths);
-    const images = [];
-    let totalBytes = 0;
-    for (const source of paths) {
-        const image = await readLocalImage(source, cwd, GATEWAY_MEDIA_LIMITS.imageEditFileBytes, 'Image', ['image/png', 'image/jpeg', 'image/webp']);
-        totalBytes += image.byteLength;
-        validateImageEditTotalSize(totalBytes);
-        images.push(image);
-    }
-    const mask = maskValue === undefined
-        ? undefined
-        : await readLocalImage(maskValue, cwd, GATEWAY_MEDIA_LIMITS.imageEditMaskBytes, 'Mask', ['image/png']);
-    if (mask !== undefined)
-        validateImageEditTotalSize(totalBytes + mask.byteLength);
-    return { images, mask };
-}
-export async function readGatewayAudioInput(source, cwd) {
-    const resolved = await resolveExternalPath(source, { cwd });
-    const read = await readFileBounded(resolved, GATEWAY_MEDIA_LIMITS.audioUploadBytes);
-    if (read.truncated)
-        validateUploadSize(GATEWAY_MEDIA_LIMITS.audioUploadBytes + 1, GATEWAY_MEDIA_LIMITS.audioUploadBytes, 'Audio file');
-    validateUploadSize(read.bytes.byteLength, GATEWAY_MEDIA_LIMITS.audioUploadBytes, 'Audio file');
-    return { bytes: read.bytes, filename: path.basename(resolved), sourceName: path.parse(path.basename(resolved)).name };
-}
-async function readLocalImage(source, cwd, maximum, label, allowedMimeTypes) {
-    const resolved = await resolveExternalPath(source, { cwd });
-    const read = await readFileBounded(resolved, maximum);
-    if (read.truncated)
-        validateUploadSize(maximum + 1, maximum, label);
-    const image = normalizeImage(read.bytes, undefined, maximum);
-    if (!allowedMimeTypes.includes(image.mimeType)) {
-        throw new CliError(CLI_ERROR_CODES.ATTACHMENT_FORMAT_UNSUPPORTED, `${label} format is not accepted by the gateway.`, {
-            category: 'media',
-            userMessage: `${label} must use one of: ${allowedMimeTypes.join(', ')}.`,
-        });
-    }
-    validateUploadSize(image.bytes.byteLength, maximum, label);
-    return image.bytes;
-}

package/dist/infrastructure/filesystem/local-filesystem-tool-executor.d.ts

@@ -1,21 +0,0 @@
-import type { ToolDefinition } from '@lotagate/sdk';
-import type { ToolExecutionContext, ToolExecutor, ToolInfo, ToolResult } from '@lotagate/agent-sdk';
-import { type FileChangeDiff } from '../../domain/filesystem/file-change-diff.js';
-import type { ToolActivityObserver } from '../../ports/tool-activity.js';
-/** Exposes the same filesystem capability definitions to runtime and context accounting. */
-export declare function filesystemToolDefinitions(): readonly ToolDefinition[];
-export declare class LocalFilesystemToolExecutor implements ToolExecutor {
-    private readonly options;
-    constructor(options?: {
-        onWrite?: (change: FileChangeDiff) => void | Promise<void>;
-        onActivity?: ToolActivityObserver;
-        writeScope?: readonly string[];
-    });
-    listTools(): readonly ToolDefinition[];
-    getToolInfo(toolName: string): ToolInfo | undefined;
-    execute(toolName: string, input: Record<string, unknown>, context: ToolExecutionContext): Promise<ToolResult>;
-    private read;
-    private list;
-    private write;
-    private exists;
-}

package/dist/infrastructure/filesystem/local-filesystem-tool-executor.js

@@ -1,176 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { createFileChangeDiff } from '../../domain/filesystem/file-change-diff.js';
-import { assertWorkspaceWriteTarget, resolveWorkspacePath } from './path-resolver.js';
-import { readFileBounded } from './bounded-file-reader.js';
-import { isFileNotFound } from './fs-errors.js';
-import { atomicWriteFile } from './atomic-file-store.js';
-const FILESYSTEM_TOOLS = [
-    functionTool('filesystem.read', 'Read a UTF-8 text file inside the trusted workspace.', {
-        path: { type: 'string', description: 'Workspace-relative file path.' },
-    }, ['path']),
-    functionTool('filesystem.list', 'List entries inside a trusted workspace directory.', {
-        path: { type: 'string', description: 'Optional workspace-relative directory path. Defaults to the workspace root.' },
-    }, []),
-    functionTool('filesystem.write', 'Write UTF-8 text to a file inside the trusted workspace.', {
-        path: { type: 'string', description: 'Workspace-relative file path.' },
-        content: { type: 'string', description: 'UTF-8 file content.' },
-    }, ['path', 'content']),
-    functionTool('filesystem.exists', 'Check whether a workspace-relative path exists.', {
-        path: { type: 'string', description: 'Workspace-relative path.' },
-    }, ['path']),
-];
-const FILE_DIFF_MAX_BYTES = 64 * 1024;
-const FILE_DIFF_MAX_INPUT_LINES = 400;
-const FILE_DIFF_MAX_LINES = 240;
-/** Exposes the same filesystem capability definitions to runtime and context accounting. */
-export function filesystemToolDefinitions() { return FILESYSTEM_TOOLS; }
-export class LocalFilesystemToolExecutor {
-    options;
-    constructor(options = {}) {
-        this.options = options;
-    }
-    listTools() {
-        return filesystemToolDefinitions();
-    }
-    getToolInfo(toolName) {
-        return FILESYSTEM_TOOLS.some((definition) => getToolName(definition) === toolName)
-            ? { toolName, source: 'filesystem', executorId: 'local-filesystem', metadata: { risk: toolName === 'filesystem.write' ? 'write' : 'read' } }
-            : undefined;
-    }
-    async execute(toolName, input, context) {
-        const activity = this.options.onActivity?.start({ key: `${context.runId}:${toolName}`, toolName, source: 'filesystem', label: formatFilesystemActivity(toolName, input['path']) });
-        let result;
-        try {
-            switch (toolName) {
-                case 'filesystem.read':
-                    result = await this.read(input, context);
-                    break;
-                case 'filesystem.list':
-                    result = await this.list(input, context);
-                    break;
-                case 'filesystem.write':
-                    result = await this.write(input, context);
-                    break;
-                case 'filesystem.exists':
-                    result = await this.exists(input, context);
-                    break;
-                default:
-                    result = errorResult(`Unknown filesystem tool: ${toolName}`);
-                    break;
-            }
-        }
-        catch (error) {
-            result = errorResult(error instanceof Error ? error.message : String(error));
-        }
-        activity?.complete(result.isError === true);
-        return result;
-    }
-    async read(input, context) {
-        const filePath = await resolveWorkspacePath(input['path'], context);
-        const result = await readFileBounded(filePath, context.maxResultBytes);
-        return okResult(`${result.bytes.toString('utf8')}${result.truncated ? '\n[truncated]' : ''}`);
-    }
-    async list(input, context) {
-        const directory = await resolveWorkspacePath(input['path'] === undefined || (typeof input['path'] === 'string' && input['path'].trim().length === 0) ? '.' : input['path'], context);
-        const result = [];
-        const maxEntries = Math.max(1, Math.floor(context.maxResultBytes / 64));
-        const handle = await fs.opendir(directory);
-        try {
-            for (let entry = await handle.read(); entry !== null; entry = await handle.read()) {
-                result.push({ name: entry.name, kind: entry.isDirectory() ? 'directory' : 'file' });
-                if (result.length >= maxEntries)
-                    break;
-            }
-        }
-        finally {
-            await handle.close();
-        }
-        return okResult(boundText(Buffer.from(JSON.stringify(result)), context.maxResultBytes));
-    }
-    async write(input, context) {
-        if (typeof input['content'] !== 'string')
-            return errorResult('filesystem.write requires string content.');
-        const filePath = await resolveWorkspacePath(input['path'], context, true);
-        if (this.options.writeScope !== undefined && !(await isWithinWriteScope(filePath, context, this.options.writeScope)))
-            return errorResult('filesystem.write path is outside the delegated worker write scope.');
-        const content = Buffer.from(input['content'], 'utf8');
-        if (content.byteLength > context.maxResultBytes)
-            return errorResult('filesystem.write content exceeds the configured limit.');
-        const previous = await readExistingText(filePath);
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await assertWorkspaceWriteTarget(filePath, context);
-        await atomicWriteFile(filePath, content);
-        await assertWorkspaceWriteTarget(filePath, context);
-        const change = createFileChangeDiff(String(input['path']), previous.content, input['content'], {
-            maxInputLines: FILE_DIFF_MAX_INPUT_LINES,
-            maxLines: FILE_DIFF_MAX_LINES,
-            truncated: previous.truncated,
-        });
-        try {
-            await this.options.onWrite?.(change);
-        }
-        catch { /* UI observers must not turn a successful write into a failed tool call. */ }
-        return okResult(`Wrote ${content.byteLength} bytes.`);
-    }
-    async exists(input, context) {
-        try {
-            await resolveWorkspacePath(input['path'], context);
-            return okResult('true');
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return okResult('false');
-            throw error;
-        }
-    }
-}
-async function isWithinWriteScope(filePath, context, scopes) {
-    const workspaceRoot = await fs.realpath(path.resolve(context.workspaceRoot ?? context.cwd ?? process.cwd()));
-    const relativeFile = path.relative(workspaceRoot, path.resolve(filePath));
-    if (relativeFile.startsWith('..') || path.isAbsolute(relativeFile))
-        return false;
-    return scopes.some((scope) => {
-        const normalizedScope = path.normalize(scope).replace(/[\\/]$/u, '');
-        if (normalizedScope === '.')
-            return true;
-        return relativeFile === normalizedScope || relativeFile.startsWith(`${normalizedScope}${path.sep}`);
-    });
-}
-async function readExistingText(filePath) {
-    try {
-        const result = await readFileBounded(filePath, FILE_DIFF_MAX_BYTES);
-        return { content: result.bytes.toString('utf8'), truncated: result.truncated };
-    }
-    catch (error) {
-        if (isFileNotFound(error))
-            return { content: '', truncated: false };
-        return { content: '', truncated: true };
-    }
-}
-function functionTool(name, description, properties, required) {
-    return { type: 'function', function: { name, description, parameters: { type: 'object', properties, required, additionalProperties: false } } };
-}
-function getToolName(definition) {
-    return 'function' in definition ? definition.function.name : undefined;
-}
-function okResult(content) { return { content, isError: false }; }
-function errorResult(content) { return { content, isError: true }; }
-function boundText(content, maxBytes) {
-    return content.byteLength <= maxBytes ? content.toString('utf8') : `${content.subarray(0, maxBytes).toString('utf8')}\n[truncated]`;
-}
-function formatFilesystemActivity(toolName, value) {
-    const pathValue = typeof value === 'string' && value.trim().length > 0 ? value.trim() : '.';
-    const displayPath = pathValue === '.' ? 'workspace' : pathValue;
-    const action = toolName === 'filesystem.read'
-        ? 'Read'
-        : toolName === 'filesystem.list'
-            ? 'List'
-            : toolName === 'filesystem.exists'
-                ? 'Check'
-                : toolName === 'filesystem.write'
-                    ? 'Write'
-                    : toolName;
-    const label = `${action} ${displayPath}${toolName === 'filesystem.list' && displayPath !== 'workspace' && !displayPath.endsWith('/') ? '/' : ''}`;
-    return label.length <= 180 ? label : `${label.slice(0, 177)}...`;
-}

package/dist/infrastructure/filesystem/path-resolver.d.ts

@@ -1,20 +0,0 @@
-export declare function resolveWorkspacePath(input: unknown, context: {
-    cwd?: string;
-    workspaceRoot?: string;
-}, allowMissing?: boolean): Promise<string>;
-/** Resolves an explicitly supplied local path without applying workspace containment. */
-export declare function resolveExternalPath(input: unknown, context: {
-    cwd?: string;
-}, allowMissing?: boolean): Promise<string>;
-/** Resolves an output path while refusing a final symlink target. */
-export declare function resolveExternalOutputPath(input: unknown, context: {
-    cwd?: string;
-}): Promise<string>;
-/** Revalidates a write target immediately at the filesystem mutation boundary. */
-export declare function assertWorkspaceWriteTarget(filePath: string, context: {
-    cwd?: string;
-    workspaceRoot?: string;
-}): Promise<void>;
-/** Revalidates an explicitly selected external output without following the final path component. */
-export declare function assertExternalWriteTarget(filePath: string): Promise<void>;
-export declare function assertInside(root: string, candidate: string): void;

package/dist/infrastructure/filesystem/path-resolver.js

@@ -1,119 +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 { isFileNotFound } from './fs-errors.js';
-export async function resolveWorkspacePath(input, context, allowMissing = false) {
-    if (typeof input !== 'string' || input.trim().length === 0) {
-        throw new CliError(CLI_ERROR_CODES.TOOL_ARGUMENT_INVALID, 'A relative workspace path is required.', {
-            category: 'tool', userMessage: 'The filesystem tool requires a non-empty path.',
-        });
-    }
-    const root = await fs.realpath(path.resolve(context.workspaceRoot ?? context.cwd ?? process.cwd()));
-    const base = await fs.realpath(path.resolve(context.cwd ?? root));
-    assertInside(root, base);
-    const candidate = path.resolve(base, input);
-    try {
-        const canonical = await fs.realpath(candidate);
-        assertInside(root, canonical);
-        return canonical;
-    }
-    catch (error) {
-        if (!allowMissing || !isFileNotFound(error))
-            throw error;
-        return resolveMissingWorkspacePath(candidate, root);
-    }
-}
-/** Resolves an explicitly supplied local path without applying workspace containment. */
-export async function resolveExternalPath(input, context, allowMissing = false) {
-    const candidate = resolveLocalCandidate(input, context.cwd);
-    try {
-        return await fs.realpath(candidate);
-    }
-    catch (error) {
-        if (!allowMissing || !isFileNotFound(error))
-            throw error;
-        return resolveMissingPath(candidate);
-    }
-}
-/** Resolves an output path while refusing a final symlink target. */
-export async function resolveExternalOutputPath(input, context) {
-    const candidate = resolveLocalCandidate(input, context.cwd);
-    const parent = await resolveExternalPath(path.dirname(candidate), context, true);
-    const target = path.join(parent, path.basename(candidate));
-    await assertNotSymbolicLink(target);
-    return target;
-}
-async function resolveMissingWorkspacePath(candidate, root) {
-    return resolveMissingPath(candidate, root);
-}
-async function resolveMissingPath(candidate, root) {
-    const missingSegments = [];
-    let current = candidate;
-    while (true) {
-        try {
-            const canonical = await fs.realpath(current);
-            if (root !== undefined)
-                assertInside(root, canonical);
-            return path.join(canonical, ...missingSegments);
-        }
-        catch (error) {
-            if (!isFileNotFound(error))
-                throw error;
-            const parent = path.dirname(current);
-            if (parent === current)
-                throw error;
-            missingSegments.unshift(path.basename(current));
-            current = parent;
-        }
-    }
-}
-function resolveLocalCandidate(input, cwd = process.cwd()) {
-    if (typeof input !== 'string' || input.trim().length === 0) {
-        throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'A non-empty local path is required.', {
-            category: 'path', userMessage: 'A non-empty local path is required.',
-        });
-    }
-    return path.resolve(cwd, input);
-}
-async function assertNotSymbolicLink(filePath) {
-    try {
-        const target = await fs.lstat(filePath);
-        if (target.isSymbolicLink()) {
-            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Output paths cannot be symbolic links.', {
-                category: 'path', userMessage: 'The output path cannot be a symbolic link.',
-            });
-        }
-    }
-    catch (error) {
-        if (!isFileNotFound(error))
-            throw error;
-    }
-}
-/** Revalidates a write target immediately at the filesystem mutation boundary. */
-export async function assertWorkspaceWriteTarget(filePath, context) {
-    const root = await fs.realpath(path.resolve(context.workspaceRoot ?? context.cwd ?? process.cwd()));
-    const parent = await fs.realpath(path.dirname(filePath));
-    assertInside(root, parent);
-    try {
-        const target = await fs.realpath(filePath);
-        assertInside(root, target);
-    }
-    catch (error) {
-        if (!isFileNotFound(error))
-            throw error;
-    }
-}
-/** Revalidates an explicitly selected external output without following the final path component. */
-export async function assertExternalWriteTarget(filePath) {
-    await fs.realpath(path.dirname(filePath));
-    await assertNotSymbolicLink(filePath);
-}
-export function assertInside(root, candidate) {
-    const relative = path.relative(root, candidate);
-    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        throw new CliError(CLI_ERROR_CODES.PROJECT_SYMLINK_ESCAPE, 'Path escapes the trusted workspace.', {
-            category: 'project', userMessage: 'Tool access was denied because the path is outside the trusted workspace.',
-        });
-    }
-}

package/dist/infrastructure/filesystem/workspace-media-artifact-store.d.ts

@@ -1,13 +0,0 @@
-import type { MediaArtifactRequest, StoredMediaArtifact } from '../../domain/media/media-contract.js';
-import type { Logger } from '../../ports/logger.js';
-/** Persists generated media below the workspace by default or in an explicitly supplied local directory. */
-export declare class WorkspaceMediaArtifactStore {
-    private readonly cwd;
-    private readonly logger?;
-    constructor(cwd: string, logger?: Logger | undefined);
-    writeMany(request: MediaArtifactRequest, artifacts: readonly Uint8Array[]): Promise<readonly StoredMediaArtifact[]>;
-    private resolveDirectory;
-    private resolveTarget;
-    private resolveOutputPath;
-    private context;
-}