maka-agent 0.2.0-dev.76.20261009 → 0.2.0-dev.78.20261010

package/node_modules/@maka/runtime/dist/file-stable-write.js

@@ -134,13 +134,25 @@ async function openExistingNoTruncate(path) {
  * only after the identity was validated on the fd. Write-step failures
  * (ENOSPC/EIO/EDQUOT/EFBIG) can leave the file truncated or half-written, so
  * they surface as `outcome_unknown` — the file's state is genuinely unknown.
+ * Short writes complete the remaining bytes; zero progress also reports outcome_unknown.
  */
 export async function writeThroughHandle(handle, content) {
+    const bytes = Buffer.from(content, 'utf8');
     try {
         await handle.truncate(0);
-        // Position 0 explicitly: a prior readFile leaves the fd position at EOF,
-        // and a positionless write would create a NUL-prefixed sparse file.
-        await handle.write(content, 0, 'utf8');
+        // Use an explicit offset from zero: a previous readFile may leave the fd at
+        // EOF, where an implicit write would create a sparse prefix.
+        // A successful write may consume only part of the buffer. Keep byte
+        // offsets (not string indices) so a short write inside UTF-8 is lossless.
+        let offset = 0;
+        while (offset < bytes.length) {
+            const { bytesWritten } = await handle.write(bytes, offset, bytes.length - offset, offset);
+            if (bytesWritten <= 0) {
+                throw new StableWriteFailure('outcome_unknown', 'The write stopped making progress; the file may be truncated. ' +
+                    'Re-read the file before writing to it again.');
+            }
+            offset += bytesWritten;
+        }
     }
     catch (error) {
         const code = error.code;

package/node_modules/@maka/runtime/dist/filesystem-worker/resource-resolver.js

@@ -19,7 +19,9 @@
 import { realpath, stat } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-export const FILESYSTEM_WORKER_BUNDLE_NAME = 'filesystem-worker.js';
+// `.mjs` so Node never looks for a package.json to decide the module type:
+// the Windows AppContainer sandbox denies that read and the worker crashes.
+export const FILESYSTEM_WORKER_BUNDLE_NAME = 'filesystem-worker.mjs';
 export function filesystemWorkerBundleCandidate(location) {
     if (location.kind === 'desktop-packaged') {
         return join(location.resourcesPath, 'workers', FILESYSTEM_WORKER_BUNDLE_NAME);

package/node_modules/@maka/runtime/dist/model-adapter.js

@@ -181,7 +181,8 @@ export class ModelAdapter {
             sdkTools[TOOL_SEARCH_PROVIDER_NAME] = sdkTools[TOOL_SEARCH_NAME];
             delete sdkTools[TOOL_SEARCH_NAME];
         }
-        const fullMessages = this.runtime.wire === 'openai-chat' ? lowerChatToolImages(input.messages) : input.messages;
+        const messages = withAnthropicHistoryCacheBreakpoint(input.messages, input.historyMessageCount, this.input.providerOptions);
+        const fullMessages = this.runtime.wire === 'openai-chat' ? lowerChatToolImages(messages) : messages;
         const responsesLane = input.continuationKey && usesNativeOpenAiResponses(this.input.connection, this.runtime)
             ? input.continuationKey
             : undefined;
@@ -895,6 +896,24 @@ function translateChunk(chunk, openAiChatReasoningTransportState, runtime, runti
             return [];
     }
 }
+function withAnthropicHistoryCacheBreakpoint(messages, historyMessageCount, providerOptions) {
+    const cacheControl = providerOptions?.anthropic
+        ?.cacheControl;
+    if (cacheControl === undefined ||
+        historyMessageCount === undefined ||
+        historyMessageCount >= messages.length) {
+        return messages;
+    }
+    return messages.map((message, index) => index === historyMessageCount - 1
+        ? {
+            ...message,
+            providerOptions: {
+                ...message.providerOptions,
+                anthropic: { ...message.providerOptions?.anthropic, cacheControl },
+            },
+        }
+        : message);
+}
 function lowerChatToolImages(messages) {
     const result = [];
     let images = [];

package/node_modules/@maka/runtime/dist/network/proxy-test.js

@@ -21,6 +21,10 @@ import { buildProxyDispatcher } from './proxy-dispatcher.js';
 import { fetch } from 'undici';
 const DEFAULT_PROBE_URL = 'https://icanhazip.com';
 const DEFAULT_TIMEOUT_MS = 8_000;
+// Bounded wait for dispatcher teardown: a graceful close that never settles
+// (observed behind real proxies after an abort) must not keep this call —
+// and the serialized settings lane it runs on — pending forever.
+const DISPATCHER_CLOSE_GRACE_MS = 1_000;
 export async function testProxyConnection(input = {}, storedProxy) {
     const proxy = parseProxyConfig(input.proxy ?? storedProxy);
     const probeUrl = input.url ?? DEFAULT_PROBE_URL;
@@ -81,8 +85,31 @@ export async function testProxyConnection(input = {}, storedProxy) {
         };
     }
     finally {
+        // Mirror the shared transport teardown ordering: begin dispatcher
+        // teardown before aborting, so the graceful close can retire live
+        // CONNECT tunnels before the signal kills their sockets; abort still
+        // cancels any pending connect or handshake. Keep the wait bounded so a
+        // stalled close cannot hold this call past its result.
+        const teardown = disposeDispatcher(timedOut);
         controller.abort();
-        await disposeDispatcher(timedOut);
+        let graceTimer;
+        const graceExpired = await Promise.race([
+            teardown.then(() => false),
+            new Promise((resolve) => {
+                graceTimer = setTimeout(() => resolve(true), DISPATCHER_CLOSE_GRACE_MS);
+            }),
+        ]);
+        if (graceTimer)
+            clearTimeout(graceTimer);
+        if (graceExpired) {
+            // The graceful close never settled within the grace, so destroy the
+            // dispatcher instead of leaking it. Fire-and-forget with the error
+            // swallowed: teardown must never replace the result this call owes.
+            const disposable = dispatcher;
+            if (typeof disposable.destroy === 'function') {
+                void Promise.resolve(disposable.destroy.call(dispatcher, new Error('Dispatcher close grace expired'))).catch(() => { });
+            }
+        }
     }
 }
 async function lookupCountry(ip, dispatcher, signal) {

package/node_modules/@maka/runtime/dist/network/scoped-fetch-transport.js

@@ -21,6 +21,7 @@ import { matchesBypassList } from './bypass-matcher.js';
 import { buildProxyDispatcher } from './proxy-dispatcher.js';
 import { buildAbortableConnector } from './abortable-connector.js';
 export const FETCH_PROXY_SNAPSHOT = Symbol.for('maka.fetch.proxy-snapshot');
+const TRANSPORT_CLOSE_GRACE_MS = 1_000;
 export function inheritFetchProxySnapshot(fetch, source) {
     const descriptor = Object.getOwnPropertyDescriptor(source, FETCH_PROXY_SNAPSHOT);
     if (descriptor)
@@ -62,8 +63,7 @@ export function createProxiedFetchTransport(proxy) {
         if (closePromise)
             return closePromise;
         closed = true;
-        connections.abort(new Error('Connection effect fetch transport closed'));
-        closePromise = Promise.all([
+        const destroyed = Promise.all([
             directDispatcher
                 .destroy(new Error('Connection effect fetch transport closed'))
                 .catch(() => { }),
@@ -71,6 +71,17 @@ export function createProxiedFetchTransport(proxy) {
                 ?.destroy(new Error('Connection effect fetch transport closed'))
                 .catch(() => { }),
         ]).then(() => undefined);
+        // Let dispatchers begin teardown before aborting CONNECT tunnels, so Undici
+        // can retire HTTP/2 sessions before their sockets disappear. Abort still
+        // cancels pending connects and handshakes; retain a bound for stalled teardown.
+        connections.abort(new Error('Connection effect fetch transport closed'));
+        let deadline;
+        closePromise = Promise.race([
+            destroyed,
+            new Promise((resolve) => {
+                deadline = setTimeout(resolve, TRANSPORT_CLOSE_GRACE_MS);
+            }),
+        ]).finally(() => clearTimeout(deadline));
         return closePromise;
     };
     return { fetch, close };

package/node_modules/@maka/runtime/dist/owned-child-process.js

@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { buildSpawnStdio } from './child-fd-input.js';
+import { terminateProcessTree } from './process-tree-terminator.js';
+/** The returned PID owns the command group. Its private IPC channel is a
+ * lifetime lease: only the supervisor can spawn the command, and losing the
+ * owner tears down the group even when no Host cleanup callback can run.
+ * Output and descriptor payloads flow directly through inherited OS handles.
+ * `ready` resolves with the command's own PID once the supervisor admits it.
+ */
+export function spawnOwnedProcess(input) {
+    const stdio = buildSpawnStdio(input.fdInputs, input.stdin);
+    const child = spawn(process.execPath, [fileURLToPath(new URL('./owned-process-main.js', import.meta.url))], {
+        cwd: input.cwd,
+        // Caller-supplied environment belongs to the command, not this trusted supervisor.
+        env: {
+            ...process.env,
+            NODE_OPTIONS: '',
+            ...(process.versions.electron ? { ELECTRON_RUN_AS_NODE: '1' } : {}),
+        },
+        stdio: [...stdio, 'ipc'],
+        // POSIX: the supervisor leads a new process group that the command joins.
+        // Termination signals the group and removes descendants visible outside
+        // it at each process-table snapshot. Windows has no process groups;
+        // taskkill /T owns the equivalent cleanup. There, detaching also keeps
+        // the supervisor out of the Host's libuv job, which would kill it with
+        // the Host before it could stop the command's descendants; the command
+        // itself stays in the supervisor's job.
+        detached: true,
+        windowsHide: true,
+    });
+    let started = false;
+    let completed = false;
+    let failureReported = false;
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    // Some callers observe ChildProcess errors instead of awaiting admission.
+    void ready.catch(() => { });
+    const timer = setTimeout(() => fail(new Error('Command supervisor startup timed out')), 10_000);
+    timer.unref();
+    const terminate = () => {
+        if (child.pid)
+            void terminateProcessTree({ pid: child.pid, signal: 'SIGKILL' }).catch(() => { });
+    };
+    // Once the supervisor is reaped its PID can be reused, so a tree walk from it
+    // could reach unrelated processes. Its POSIX process group cannot be
+    // reallocated while members remain, so it alone still names the command.
+    // Windows has no such handle; taskkill /T on a reaped PID is skipped.
+    const terminateOrphanedGroup = () => {
+        if (process.platform === 'win32' || !child.pid)
+            return;
+        try {
+            process.kill(-child.pid, 'SIGKILL');
+        }
+        catch {
+            // The group is already empty.
+        }
+    };
+    // Command output reaches these pipes directly, racing the IPC admission
+    // message. Hold it until callers have observed `ready`, so output never
+    // precedes admission, as with a direct spawn. Callers attach 'data'
+    // listeners synchronously; an explicit pause keeps those from resuming.
+    const outputs = [child.stdout, child.stderr].filter((stream) => stream !== null);
+    for (const stream of outputs)
+        stream.pause();
+    let outputReleased = false;
+    const releaseOutput = () => {
+        if (outputReleased)
+            return;
+        outputReleased = true;
+        for (const stream of outputs)
+            stream.resume();
+    };
+    /**
+     * `stop` says who stops the tree: `tree` walks it from the live supervisor;
+     * `group` signals only its process group, because the supervisor is exiting
+     * on its own and its PID may be reaped before a walk could start; `none`
+     * leaves the stop to the supervisor, which walks its own tree.
+     */
+    function fail(error, stop = 'tree') {
+        if (failureReported)
+            return;
+        failureReported = true;
+        clearTimeout(timer);
+        rejectReady(error);
+        releaseOutput();
+        if (stop === 'tree')
+            terminate();
+        else if (stop === 'group')
+            terminateOrphanedGroup();
+        child.emit('error', error);
+    }
+    child.once('error', (error) => {
+        clearTimeout(timer);
+        rejectReady(error);
+        releaseOutput();
+    });
+    child.once('spawn', () => {
+        const request = {
+            kind: 'launch',
+            program: input.program,
+            args: input.args,
+            cwd: input.cwd,
+            env: input.env ?? process.env,
+            shell: input.shell,
+            inheritedFds: (input.fdInputs ?? []).map(({ fd }) => fd),
+        };
+        child.send(request, (error) => {
+            if (error && child.exitCode === null && child.signalCode === null)
+                fail(error);
+        });
+    });
+    child.on('message', (value) => {
+        const message = value;
+        if (message.kind === 'started') {
+            started = true;
+            clearTimeout(timer);
+            resolveReady(message.pid);
+            // Promise continuations of `ready` run before the check phase; a
+            // nextTick resume would deliver output ahead of them.
+            setImmediate(releaseOutput);
+        }
+        else if (message.kind === 'completed') {
+            completed = true;
+        }
+        else if (message.kind === 'failed') {
+            // A result already arrived; a later report cannot replace it.
+            if (completed)
+                return;
+            const error = Object.assign(new Error(message.message), { code: message.code });
+            if (!started) {
+                // The command never spawned; the supervisor is exiting on its own.
+                completed = true;
+                fail(error, 'group');
+            }
+            else {
+                // A supervisor fault after admission: it stops its own tree, including
+                // descendants that left its group, before exiting. Signalling the group
+                // now would kill it mid-walk. The group kill on its exit stays the
+                // backstop, so `completed` remains unset.
+                fail(error, 'none');
+            }
+        }
+    });
+    child.once('exit', (code) => {
+        clearTimeout(timer);
+        releaseOutput();
+        // `exit` is not ordered after IPC messages still being read; the channel's
+        // close is. Decide a missing result only once the channel has drained.
+        if (completed || !child.connected)
+            settleExit(code);
+        else
+            child.once('disconnect', () => settleExit(code));
+    });
+    function settleExit(code) {
+        if (!started)
+            rejectReady(new Error('Command supervisor exited before admission'));
+        if (completed)
+            return;
+        // The group can outlive its leader. An unexpected supervisor exit must
+        // not leave an admitted command running while the Host is still alive.
+        terminateOrphanedGroup();
+        // A clean exit without `completed` lost the command's result. On POSIX the
+        // Host's own stops end the supervisor by signal, so any exit code there is
+        // a supervisor fault too. On Windows taskkill, the Host's forced stop, also
+        // ends with an ordinary code.
+        const lost = code === 0 || (code !== null && process.platform !== 'win32');
+        if (lost && !failureReported) {
+            child.emit('error', new Error('Command supervisor lost its result'));
+        }
+    }
+    return { child, ready };
+}
+/** A supervisor PID denotes the whole command group, including during startup. */
+export function signalOwnedProcess(child, signal) {
+    if (process.platform === 'win32' || !child.pid)
+        return child.kill(signal);
+    try {
+        process.kill(-child.pid, signal);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ESRCH')
+            return false;
+        throw error;
+    }
+}

package/node_modules/@maka/runtime/dist/owned-process-main.js

@@ -0,0 +1,183 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+import { terminateProcessTree } from './process-tree-terminator.js';
+let command;
+let stopping = false;
+let completed = false;
+let ownerLost = false;
+let finishing = false;
+function loseOwner() {
+    if (completed || ownerLost)
+        return;
+    ownerLost = true;
+    stopping = true;
+    // This process is the POSIX group leader; the command joins its group. The
+    // Windows implementation uses taskkill /T. Discovery also includes descendants
+    // that have moved into another process group while still attached to this tree.
+    void terminateProcessTree({
+        pid: process.pid,
+        signal: 'SIGKILL',
+        fallback: () => process.exit(1),
+    }).then(() => process.exit(1), () => process.exit(1));
+}
+/** An unexpected supervisor error. Stopping the tree ends this process with
+ * its own group's SIGKILL, which the Host cannot tell from a forced stop, so
+ * report the fault first while the lease is still up. */
+function fault(error) {
+    if (completed || ownerLost)
+        return;
+    // The command has exited and its result is already on the way; a fault
+    // now must not turn it into a failure. Only make sure this process ends.
+    if (finishing) {
+        setTimeout(() => process.exit(1), 1_000);
+        return;
+    }
+    if (!process.connected) {
+        loseOwner();
+        return;
+    }
+    // The tree stops whether or not the report goes through.
+    setTimeout(loseOwner, 1_000);
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+        process.send({ kind: 'failed', message: `Command supervisor failed: ${message}` }, () => loseOwner());
+    }
+    catch {
+        loseOwner();
+    }
+}
+process.on('disconnect', loseOwner);
+process.on('uncaughtException', fault);
+process.on('unhandledRejection', fault);
+// The command shares this process group, so a group-wide signal its own script
+// sends (`kill -HUP 0`) reaches the supervisor too. Ignore the ones whose
+// default action would end it, or for SIGUSR1 start the inspector, so the
+// command alone decides how to handle them. Windows cannot listen for these.
+if (process.platform !== 'win32') {
+    for (const signal of ['SIGHUP', 'SIGUSR1', 'SIGUSR2', 'SIGQUIT', 'SIGALRM']) {
+        process.on(signal, () => { });
+    }
+}
+for (const signal of ['SIGTERM', 'SIGINT']) {
+    process.on(signal, () => {
+        stopping = true;
+        // On POSIX the Host signals our entire group, including the command. Do not
+        // forward the signal a second time. Before admission, stop without spawning.
+        if (!command)
+            finish(null, signal);
+    });
+}
+function send(message, then) {
+    if (!process.connected) {
+        loseOwner();
+        return;
+    }
+    process.send(message, (error) => {
+        if (error)
+            loseOwner();
+        else
+            then?.();
+    });
+}
+function finish(code, signal) {
+    finishing = true;
+    send({ kind: 'completed' }, () => {
+        completed = true;
+        if (signal)
+            exitWithSignal(signal);
+        else
+            process.exit(code ?? 1);
+    });
+}
+/** Mirror the command's terminating signal. Node ignores SIGPIPE and reserves
+ * SIGUSR1 for its inspector even without listeners; removing a listener resets
+ * the handler to the default action, so the re-raised signal ends this process.
+ */
+function exitWithSignal(signal) {
+    process.removeAllListeners(signal);
+    try {
+        process.on(signal, () => { });
+        process.removeAllListeners(signal);
+    }
+    catch {
+        // SIGKILL and SIGSTOP accept no listener; their default action already applies.
+    }
+    process.kill(process.pid, signal);
+    // Never outlive the command if the signal did not end this process.
+    setTimeout(() => process.exit(1), 1_000);
+}
+if (!process.connected)
+    process.exit(1);
+process.once('message', (message) => {
+    if (!process.connected) {
+        loseOwner();
+        return;
+    }
+    // A stop that arrived before the launch is already finishing.
+    if (stopping)
+        return;
+    const input = message;
+    if (input.kind !== 'launch') {
+        loseOwner();
+        return;
+    }
+    // A group signal can be pending in this loop turn alongside the launch.
+    // Spawn in the check phase, after its handler has run, so a stop that
+    // arrived first ends the supervisor without starting the command.
+    setImmediate(() => {
+        if (stopping)
+            return;
+        if (!process.connected) {
+            loseOwner();
+            return;
+        }
+        launch(input);
+    });
+});
+function launch(input) {
+    const stdio = [0, 1, 2];
+    for (const fd of input.inheritedFds) {
+        while (stdio.length <= fd)
+            stdio.push('ignore');
+        stdio[fd] = fd;
+    }
+    try {
+        command = spawn(input.program, [...input.args], {
+            cwd: input.cwd,
+            env: input.env,
+            shell: input.shell,
+            stdio,
+            detached: false,
+            windowsHide: true,
+        });
+        command.once('spawn', () => send({ kind: 'started', pid: command?.pid }));
+        command.once('error', failed);
+        command.once('exit', finish);
+    }
+    catch (error) {
+        failed(error);
+    }
+}
+function failed(error) {
+    send({ kind: 'failed', message: error.message, code: error.code }, () => {
+        completed = true;
+        process.exit(1);
+    });
+}

package/node_modules/@maka/runtime/dist/pipe-process-driver.js

@@ -16,11 +16,12 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { spawn } from 'node:child_process';
-import { buildSpawnStdio, closeChildFdSources, writeChildFdInputs, } from './child-fd-input.js';
+import { signalOwnedProcess, spawnOwnedProcess } from './owned-child-process.js';
+import { closeChildFdSources, writeChildFdInputs } from './child-fd-input.js';
 import { trackCapturedOutputDrain, } from './child-process-lifecycle.js';
 export class PipeProcessDriver {
     options;
+    /** Supervisor PID; it leads the command's process group, so signals target it. */
     pid;
     ready;
     child;
@@ -34,16 +35,24 @@ export class PipeProcessDriver {
     rootExit;
     stdinSettled;
     stdinError;
+    admittedPid;
     constructor(options) {
         this.options = options;
         try {
-            this.child = spawn(options.plan.file, options.plan.args, {
+            const spawned = spawnOwnedProcess({
+                program: options.plan.file,
+                args: options.plan.args,
                 cwd: options.cwd,
                 env: options.env,
                 shell: options.plan.useShellOption,
-                stdio: buildSpawnStdio(options.fdInputs, options.plan.stdin === undefined ? 'ignore' : 'pipe'),
-                detached: process.platform !== 'win32',
+                stdin: options.plan.stdin === undefined ? 'ignore' : 'pipe',
+                fdInputs: options.fdInputs,
             });
+            this.child = spawned.child;
+            this.ready = spawned.ready.then((pid) => {
+                this.admittedPid = pid;
+            });
+            void this.ready.catch(() => { });
         }
         finally {
             closeChildFdSources(options.fdInputs);
@@ -78,7 +87,10 @@ export class PipeProcessDriver {
         this.child.on('exit', this.onRootExit);
         this.child.on('close', this.onCloseFallback);
         this.child.on('error', this.onError);
-        this.ready = waitForSpawn(this.child);
+    }
+    /** The command's own PID, known once `ready` resolves; this is what users see. */
+    get commandPid() {
+        return this.admittedPid;
     }
     writeInputs() {
         writeChildFdInputs(this.child, this.options.fdInputs);
@@ -88,7 +100,7 @@ export class PipeProcessDriver {
         this.stdin.end(this.options.plan.stdin, this.onStdinEnd);
     }
     kill(signal) {
-        return this.child.kill(signal);
+        return signalOwnedProcess(this.child, signal);
     }
     dispose() {
         if (this.disposed)
@@ -157,21 +169,3 @@ export class PipeProcessDriver {
         this.settleAfterDrain();
     };
 }
-function waitForSpawn(child) {
-    return new Promise((resolve, reject) => {
-        const onSpawn = () => {
-            cleanup();
-            resolve();
-        };
-        const onError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const cleanup = () => {
-            child.off('spawn', onSpawn);
-            child.off('error', onError);
-        };
-        child.once('spawn', onSpawn);
-        child.once('error', onError);
-    });
-}