@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/acp/draftInterceptor.js

@@ -1,163 +0,0 @@
-/**
- * Peels off the `session/update` notifications the pinned ACP SDK would destroy, before it sees them.
- *
- * ## Why this exists at all
- *
- * Two classes of notification never reach a handler we are allowed to register, and both were found
- * by running the thing rather than reading the types:
- *
- * 1. **Draft variants throw.** `ClientApp`'s constructor installs `client-session-update-router` as
- *    the *first* static handler (`sdk/dist/acp.js:869-872`), and that router parses every
- *    notification through `zSessionNotification` (`:680`), whose `update` is a closed 15-member
- *    union. A `subagent_spawned` fails that parse. The dispatch loop's catch treats a failed
- *    notification as `console.error` + return (`sdk/dist/jsonrpc.js:777-790`) — connection alive,
- *    event gone.
- * 2. **A child session's ordinary frames are dropped.** The same router routes by
- *    `notification.sessionId` into a map of sessions *this client opened*. A subagent's session id
- *    was never opened here, so nothing is enqueued, the router answers `Handled.no`, and no later
- *    handler exists to catch it.
- *
- * `builder.withHandler` only ever appends, so there is no handler position ahead of the router. The
- * stream is the only place left — and it is the right place anyway, because "which consumer do
- * these bytes belong to" is a transport question.
- *
- * ## What it must not become
- *
- * Pure carriage. It answers two predicates and either diverts or forwards; it never reads a payload
- * for meaning, and it never rewrites one. Every message it does not divert must reach the SDK
- * byte-for-byte — a re-encode that changed key order or dropped an unknown field would make this
- * layer a silent second normaliser, which is precisely what ruling L1 (normalise in one place,
- * server ingest) exists to prevent.
- *
- * ## Lifetime
- *
- * Predicate 1 dies with the draft: when RFD #1992 ships in the SDK, delete it along with
- * `draftSubagents.ts`. Predicate 2 outlives it — it can only go once the SDK has a concept of a
- * session it did not open.
- */
-import { DRAFT_SESSION_UPDATE_NAMES } from './draftSubagents.js';
-/** ACP's client-bound notification for session updates. */
-const SESSION_UPDATE_METHOD = 'session/update';
-const DRAFT_NAMES = new Set(DRAFT_SESSION_UPDATE_NAMES);
-/**
- * Whether this raw JSON-RPC message is a `session/update` that the SDK cannot deliver.
- *
- * Returns the diversion reason, or `null` to forward. Exported for its own tests: the two
- * predicates are the whole contract, and testing them through a stream would only obscure them.
- *
- * Deliberately total — any shape it does not recognise is forwarded. Being wrong in that direction
- * costs nothing (the SDK handles what it always handled); being wrong the other way silently
- * removes a message from the protocol.
- */
-export function diversionReasonFor(message, isOwnSession) {
-    if (typeof message !== 'object' || message === null)
-        return null;
-    const record = message;
-    if (record.method !== SESSION_UPDATE_METHOD)
-        return null;
-    // A request carries an `id` and is owed a response; this notification does not. Anything with an
-    // id is left alone rather than answered by a layer that has no business answering.
-    if ('id' in record)
-        return null;
-    const params = record.params;
-    if (typeof params !== 'object' || params === null)
-        return null;
-    const { sessionId, update } = params;
-    if (typeof sessionId !== 'string' || sessionId.length === 0)
-        return null;
-    if (typeof update !== 'object' || update === null)
-        return null;
-    const updateRecord = update;
-    const variant = updateRecord.sessionUpdate;
-    if (typeof variant === 'string' && DRAFT_NAMES.has(variant)) {
-        return { sessionId, update: updateRecord, reason: 'draft-variant' };
-    }
-    if (!isOwnSession(sessionId)) {
-        return { sessionId, update: updateRecord, reason: 'foreign-session' };
-    }
-    return null;
-}
-/**
- * Wraps the child's stdout so diverted notifications never reach the SDK, and everything else
- * arrives unchanged.
- *
- * Works on whole lines because that is the framing ACP uses over stdio and because it lets the
- * forwarded half stay **the original bytes**: a line that is not diverted is enqueued exactly as it
- * arrived, so no re-encoding can perturb it. Only a diverted line is ever parsed.
- *
- * A line that is not valid JSON is forwarded untouched — reporting a protocol error is the SDK's
- * job, and a transport shim that swallowed malformed input would hide the failure from the layer
- * equipped to describe it.
- */
-export function interceptDraftUpdates(source, options) {
-    const decoder = new TextDecoder();
-    const encoder = new TextEncoder();
-    let buffered = '';
-    const handleLine = (line, enqueue) => {
-        if (line.trim().length === 0)
-            return;
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            enqueue(encoder.encode(`${line}\n`));
-            return;
-        }
-        if (options.captureUpdate && typeof parsed === 'object' && parsed !== null) {
-            const message = parsed;
-            const params = message.params;
-            if (message.method === SESSION_UPDATE_METHOD && !('id' in message) &&
-                params && typeof params.sessionId === 'string' && params.sessionId.length > 0 &&
-                typeof params.update === 'object' && params.update !== null &&
-                options.captureUpdate(params))
-                return;
-        }
-        const diverted = diversionReasonFor(parsed, options.isOwnSession);
-        if (!diverted) {
-            // The original text, not a re-serialisation of the parse — see the doc comment.
-            enqueue(encoder.encode(`${line}\n`));
-            return;
-        }
-        try {
-            options.onDiverted(diverted);
-        }
-        catch (err) {
-            // The sink is ours and is documented as non-throwing; if it throws anyway, losing one update
-            // is strictly better than wedging the stream that carries every other one.
-            console.error(`[acp] draft update sink threw for session ${diverted.sessionId}: ${String(err)}`);
-        }
-    };
-    return new ReadableStream({
-        async start(controller) {
-            const reader = source.getReader();
-            try {
-                for (;;) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buffered += decoder.decode(value, { stream: true });
-                    let newline = buffered.indexOf('\n');
-                    while (newline >= 0) {
-                        const line = buffered.slice(0, newline);
-                        buffered = buffered.slice(newline + 1);
-                        handleLine(line, (chunk) => controller.enqueue(chunk));
-                        newline = buffered.indexOf('\n');
-                    }
-                }
-                // A final line with no trailing newline is still a message: an agent that exits right after
-                // writing one would otherwise have its last word dropped.
-                buffered += decoder.decode();
-                if (buffered.length > 0)
-                    handleLine(buffered, (chunk) => controller.enqueue(chunk));
-                controller.close();
-            }
-            catch (err) {
-                controller.error(err);
-            }
-            finally {
-                reader.releaseLock();
-            }
-        },
-    });
-}

package/dist/workstation/acp/qoderStartup.js

@@ -1,45 +0,0 @@
-import { execFile } from 'node:child_process';
-import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { buildSessionMcpServers } from './delegationMcp.js';
-export const QODER_MANAGED_VERSION = '1.1.61';
-/** Owned by one process; the bearer is never an argument or environment variable. */
-export async function prepareQoderStartup(launch, lease, cwd, env, agentEnv) {
-    buildSessionMcpServers([], lease);
-    if (launch.args.some((arg) => arg === '--' || /^(--mcp-config|--strict-mcp-config|--settings|--setting-sources)(=|$)/.test(arg))) {
-        throw new Error('Managed Qoder startup has conflicting configuration arguments');
-    }
-    const version = await new Promise((resolve, reject) => {
-        execFile(launch.command, [...launch.args, '--version'], {
-            cwd, env: { ...process.env, ...launch.env, ...env, ...agentEnv },
-            encoding: 'utf8', timeout: 10_000, maxBuffer: 64 * 1024, windowsHide: true,
-        }, (error, stdout) => error ? reject(new Error('Managed Qoder version could not be verified')) : resolve(stdout.trim()));
-    });
-    if (version !== QODER_MANAGED_VERSION)
-        throw new Error('Managed Qoder version is not certified');
-    const dir = await mkdtemp(join(tmpdir(), 'axom-qoder-mcp-'));
-    let disposal;
-    const dispose = () => disposal ??= rm(dir, { recursive: true, force: true });
-    try {
-        await chmod(dir, 0o700);
-        const config = join(dir, 'mcp.json');
-        const authorization = Object.values(lease.headers)[0];
-        await writeFile(config, JSON.stringify({ mcpServers: {
-                'axom-delegation': { type: 'http', url: lease.url, headers: { Authorization: authorization } },
-            } }), { mode: 0o600, flag: 'wx' });
-        // Validate again after the asynchronous version probe; an expired lease cannot start a process.
-        buildSessionMcpServers([], lease);
-        return {
-            launch: { ...launch, args: [...launch.args, '--strict-mcp-config', '--mcp-config', config,
-                    '--setting-sources', '', '--settings', '{"autoMemoryEnabled":false}',
-                    '--disallowed-tools', 'Agent', '--cwd', cwd,
-                    '--append-system-prompt', 'Use the axom-delegation MCP tools for delegation. Native Agent execution is disabled in this session.'] },
-            secrets: [authorization, authorization.slice('Bearer '.length)], dispose,
-        };
-    }
-    catch (error) {
-        await dispose();
-        throw error;
-    }
-}

package/dist/workstation/acp/sessionScope.js

@@ -1,19 +0,0 @@
-import { SessionMapperState } from './sessionUpdateMapper.js';
-export function scopeKey(scope) {
-    return JSON.stringify([scope.rootRuntimeId, scope.nativeSessionId]);
-}
-export class SessionMapperScopes {
-    create;
-    states = new Map();
-    constructor(create = () => new SessionMapperState()) {
-        this.create = create;
-    }
-    get(scope) {
-        const key = scopeKey(scope);
-        let state = this.states.get(key);
-        if (!state)
-            this.states.set(key, state = this.create(scope));
-        return state;
-    }
-    clear() { this.states.clear(); }
-}

package/dist/workstation/filePaths.js

@@ -1,174 +0,0 @@
-import { lstat, realpath } from 'node:fs/promises';
-import { isAbsolute, join } from 'node:path';
-export class ComputerFileError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'ComputerFileError';
-    }
-}
-export function computerFileError(error) {
-    if (error instanceof ComputerFileError)
-        return error;
-    const code = error?.code;
-    if (code === 'ENOENT')
-        return new ComputerFileError('not_found', 'File or parent directory not found');
-    if (code === 'EACCES' || code === 'EPERM')
-        return new ComputerFileError('permission_denied', 'File access denied');
-    if (code === 'EEXIST')
-        return new ComputerFileError('conflict', 'Target already exists');
-    if (code === 'ELOOP')
-        return new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-    return new ComputerFileError('io_error', 'File operation failed');
-}
-/** Validate portable slash components before touching the filesystem. */
-export function validateComputerFilePath(path) {
-    if (!path || path.includes('\\') || path.includes(':') || path.includes('\0') || isAbsolute(path)) {
-        throw new ComputerFileError('invalid_path', 'Path must be relative to the selected workspace');
-    }
-    const components = path.split('/');
-    if (components.some(component => !component || component === '.' || component === '..')) {
-        throw new ComputerFileError('invalid_path', 'Path contains an unsafe component');
-    }
-    return components;
-}
-/** The configured root may itself be a symlink; none of its descendants may be. */
-export async function resolveComputerFilePath(root, path, allowMissingLeaf) {
-    const components = validateComputerFilePath(path);
-    let cursor;
-    try {
-        cursor = await realpath(root);
-    }
-    catch (error) {
-        throw computerFileError(error);
-    }
-    for (let index = 0; index < components.length; index++) {
-        cursor = join(cursor, components[index]);
-        let stat;
-        try {
-            stat = await lstat(cursor);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT' && allowMissingLeaf && index === components.length - 1)
-                return cursor;
-            throw computerFileError(error);
-        }
-        if (stat.isSymbolicLink())
-            throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-        if (index === components.length - 1) {
-            if (!stat.isFile())
-                throw new ComputerFileError('not_regular_file', 'Target is not a regular file');
-        }
-        else if (!stat.isDirectory()) {
-            throw new ComputerFileError('not_regular_file', 'Parent is not a directory');
-        }
-    }
-    return cursor;
-}
-/** Resolve only a leaf relative to an already pinned process cwd; never turn it back into an absolute pathname. */
-export async function resolvePinnedLeafPath(_root, path, allowMissingLeaf) {
-    const components = validateComputerFilePath(path);
-    if (components.length !== 1)
-        throw new ComputerFileError('invalid_path', 'Pinned file operation requires one path component');
-    try {
-        const entry = await lstat(path);
-        if (entry.isSymbolicLink())
-            throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-        if (!entry.isFile())
-            throw new ComputerFileError('not_regular_file', 'Target is not a regular file');
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT' || !allowMissingLeaf)
-            throw computerFileError(error);
-    }
-    return path;
-}
-/** Every component of a directory listing target must exist, be a directory, and not be a symlink; '' is the root. */
-export async function resolveComputerDirPath(root, path) {
-    const components = path === '' ? [] : validateComputerFilePath(path);
-    let cursor;
-    try {
-        cursor = await realpath(root);
-    }
-    catch (error) {
-        throw computerFileError(error);
-    }
-    for (const component of components) {
-        cursor = join(cursor, component);
-        let entry;
-        try {
-            entry = await lstat(cursor);
-        }
-        catch (error) {
-            throw computerFileError(error);
-        }
-        if (entry.isSymbolicLink())
-            throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-        if (!entry.isDirectory())
-            throw new ComputerFileError('not_regular_file', 'Target is not a directory');
-    }
-    return cursor;
-}
-/** Pinned variant for the file worker: '' lists the pinned cwd itself, otherwise exactly one component. */
-export async function resolvePinnedDirPath(_root, path) {
-    const components = path === '' ? [] : validateComputerFilePath(path);
-    if (components.length > 1)
-        throw new ComputerFileError('invalid_path', 'Pinned directory operation requires at most one path component');
-    const target = path === '' ? '.' : join('.', path);
-    let entry;
-    try {
-        entry = await lstat(target);
-    }
-    catch (error) {
-        throw computerFileError(error);
-    }
-    if (entry.isSymbolicLink())
-        throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-    if (!entry.isDirectory())
-        throw new ComputerFileError('not_regular_file', 'Target is not a directory');
-    return target;
-}
-/**
- * Locate the deepest existing ancestor for a directory creation. Without parents the anchor must be the
- * target's own parent (only the leaf may be missing); with parents any prefix may be missing. Existing
- * components must be directories and never symlinks; an existing leaf counts as "already created".
- */
-export async function resolveComputerDirCreatePath(root, path, parents) {
-    const components = validateComputerFilePath(path);
-    let cursor;
-    try {
-        cursor = await realpath(root);
-    }
-    catch (error) {
-        throw computerFileError(error);
-    }
-    let anchorIndex = 0;
-    for (; anchorIndex < components.length; anchorIndex++) {
-        const candidate = join(cursor, components[anchorIndex]);
-        let entry;
-        try {
-            entry = await lstat(candidate);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw computerFileError(error);
-            break;
-        }
-        if (entry.isSymbolicLink())
-            throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-        if (!entry.isDirectory())
-            throw new ComputerFileError('not_found', 'Path is not a directory');
-        cursor = candidate;
-    }
-    const missing = components.slice(anchorIndex);
-    if (!parents && missing.length > 1) {
-        throw new ComputerFileError('not_found', 'Parent directory not found');
-    }
-    return { anchor: cursor, missing };
-}
-/** Pinned variant for the file worker: create the missing components below the pinned cwd, one leaf at a time. */
-export async function resolvePinnedDirCreatePath(_root, path, _parents) {
-    const components = path === '' ? [] : validateComputerFilePath(path);
-    return { anchor: '.', missing: components };
-}

package/dist/workstation/fileWorker.js

@@ -1,81 +0,0 @@
-import { realpath } from 'node:fs/promises';
-import { isAbsolute, relative, sep } from 'node:path';
-import { computerFileError, ComputerFileError, resolvePinnedDirCreatePath, resolvePinnedDirPath, resolvePinnedLeafPath, } from './filePaths.js';
-import { createComputerDir, listComputerDir, readComputerFile, writeComputerFile, } from './fileOps.js';
-const controller = new AbortController();
-let started = false;
-let pending;
-/**
- * This worker is a separate process so its cwd is a kernel-pinned directory reference, not a
- * pathname re-resolved after validation. A swapped ancestor symlink may affect process launch,
- * but the post-launch realpath check then rejects it before touching the leaf. Directory
- * operations accept at most one pinned component: multi-component `parents` creation walks
- * one leaf at a time from the pinned anchor instead of re-resolving full pathnames.
- */
-process.on('message', (message) => {
-    if (message.kind === 'cancel') {
-        controller.abort();
-        if (pending) {
-            pending = undefined;
-            process.disconnect();
-        }
-        return;
-    }
-    if (message.kind === 'continue') {
-        const work = pending;
-        if (!work)
-            return;
-        pending = undefined;
-        void (async () => {
-            try {
-                if (work.kind === 'read') {
-                    const request = { ...work.request, root: '.' };
-                    const data = await readComputerFile(request, controller.signal, resolvePinnedLeafPath);
-                    process.send?.({ ok: true, data }, () => process.disconnect());
-                }
-                else if (work.kind === 'write') {
-                    const request = { ...work.request, root: '.' };
-                    const data = await writeComputerFile(request, controller.signal, resolvePinnedLeafPath);
-                    process.send?.({ ok: true, data }, () => process.disconnect());
-                }
-                else if (work.kind === 'ls') {
-                    const request = { ...work.request, root: '.' };
-                    const data = await listComputerDir(request, controller.signal, resolvePinnedDirPath);
-                    process.send?.({ ok: true, data }, () => process.disconnect());
-                }
-                else {
-                    const request = { ...work.request, root: '.' };
-                    const data = await createComputerDir(request, controller.signal, resolvePinnedDirCreatePath);
-                    process.send?.({ ok: true, data }, () => process.disconnect());
-                }
-            }
-            catch (error) {
-                const mapped = computerFileError(error);
-                process.send?.({ ok: false, error: { code: mapped.code, message: mapped.message } }, () => process.disconnect());
-            }
-        })();
-        return;
-    }
-    if (started)
-        return;
-    started = true;
-    void (async () => {
-        try {
-            const parent = await realpath('.');
-            const rel = relative(message.root, parent);
-            if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-                throw new ComputerFileError('invalid_path', 'File parent escaped the configured workspace');
-            }
-            if (controller.signal.aborted) {
-                process.disconnect();
-                return;
-            }
-            pending = message;
-            process.send?.({ kind: 'ready' });
-        }
-        catch (error) {
-            const mapped = computerFileError(error);
-            process.send?.({ ok: false, error: { code: mapped.code, message: mapped.message } }, () => process.disconnect());
-        }
-    })();
-});

package/dist/workstation/fileWorkerClient.js

@@ -1,121 +0,0 @@
-import { fork } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { realpath } from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ComputerFileError, computerFileError, resolveComputerDirCreatePath, resolveComputerDirPath, resolveComputerFilePath } from './filePaths.js';
-const workerUrl = existsSync(new URL('./fileWorker.js', import.meta.url))
-    ? new URL('./fileWorker.js', import.meta.url)
-    : new URL('../../dist/workstation/fileWorker.js', import.meta.url);
-const writeLocks = new Map();
-async function serialWrite(target, action) {
-    const previous = writeLocks.get(target) ?? Promise.resolve();
-    let release;
-    const gate = new Promise(resolve => { release = resolve; });
-    const queued = previous.then(() => gate);
-    writeLocks.set(target, queued);
-    await previous;
-    try {
-        return await action();
-    }
-    finally {
-        release();
-        if (writeLocks.get(target) === queued)
-            writeLocks.delete(target);
-    }
-}
-async function execute(kind, request, anchor, leaf, signal, hooks) {
-    if (signal?.aborted)
-        throw new ComputerFileError('workstation_offline', 'File operation was cancelled');
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    await hooks?.afterValidation?.();
-    return new Promise((resolve, reject) => {
-        const child = fork(fileURLToPath(workerUrl), [], {
-            cwd: anchor, stdio: ['ignore', 'ignore', 'ignore', 'ipc'], execArgv: [],
-        });
-        let settled = false;
-        let killTimer;
-        const finish = (error, data) => {
-            if (settled)
-                return;
-            settled = true;
-            signal?.removeEventListener('abort', abort);
-            if (error)
-                reject(error);
-            else
-                resolve(data);
-        };
-        const abort = () => {
-            if (settled)
-                return;
-            child.send({ kind: 'cancel' }, () => { });
-            killTimer = setTimeout(() => child.kill(), 2_000);
-            killTimer.unref();
-            finish(new ComputerFileError(kind === 'write' || kind === 'mkdir' ? 'outcome_unknown' : 'workstation_offline', 'File operation was cancelled'));
-        };
-        child.on('message', (message) => {
-            if (typeof message !== 'object' || message === null)
-                return;
-            const reply = message;
-            if (reply.kind === 'ready') {
-                void (async () => {
-                    try {
-                        await hooks?.afterWorkerReady?.();
-                        if (!settled)
-                            child.send({ kind: 'continue' }, error => { if (error)
-                                finish(computerFileError(error)); });
-                    }
-                    catch (error) {
-                        child.kill();
-                        finish(computerFileError(error));
-                    }
-                })();
-                return;
-            }
-            if (reply.ok === true)
-                finish(undefined, reply.data);
-            else if (reply.ok === false && reply.error)
-                finish(new ComputerFileError(reply.error.code, reply.error.message));
-        });
-        child.once('error', error => finish(computerFileError(error)));
-        child.once('exit', () => {
-            if (killTimer)
-                clearTimeout(killTimer);
-            finish(new ComputerFileError(kind === 'write' || kind === 'mkdir' ? 'outcome_unknown' : 'workstation_offline', 'File worker exited without a result'));
-        });
-        signal?.addEventListener('abort', abort, { once: true });
-        if (signal?.aborted) {
-            abort();
-            return;
-        }
-        child.send({ kind, root, request: { ...request, root: '.', path: leaf } }, error => {
-            if (error)
-                finish(computerFileError(error));
-        });
-    });
-}
-export async function readComputerFileSafely(request, signal, hooks) {
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    const target = await resolveComputerFilePath(root, request.path, false);
-    return execute('read', request, dirname(target), basename(target), signal, hooks);
-}
-export async function writeComputerFileSafely(request, signal, hooks) {
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    const target = await resolveComputerFilePath(root, request.path, request.mode === 'create');
-    return serialWrite(target, () => execute('write', request, dirname(target), basename(target), signal, hooks));
-}
-export async function listComputerDirSafely(request, signal, hooks) {
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    const target = await resolveComputerDirPath(root, request.path);
-    // Listing the workspace root pins the worker at the root itself; '' is the zero-component leaf.
-    const anchor = target === root ? root : dirname(target);
-    const leaf = target === root ? '' : basename(target);
-    const data = await execute('ls', request, anchor, leaf, signal, hooks);
-    return { ...data, path: request.path };
-}
-export async function createComputerDirSafely(request, signal, hooks) {
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    const plan = await resolveComputerDirCreatePath(root, request.path, request.parents);
-    const data = await execute('mkdir', request, plan.anchor, plan.missing.join('/'), signal, hooks);
-    return { ...data, path: request.path };
-}