@moxt-ai/mobius 0.0.167 → 0.0.168

package/dist/cli.js

@@ -3381,7 +3381,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.167",
+  version: "0.0.168",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -30745,7 +30745,7 @@ function createDaemonConfig(connection, agents = [], installableAgents = [], loc
 // src/daemon-manager.ts
 import { spawn as spawn6 } from "node:child_process";
 import { createHash as createHash9, randomBytes } from "node:crypto";
-import { readFile as readFile4, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
+import { readFile as readFile3, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
 import { tmpdir } from "node:os";
 import { join as join20 } from "node:path";
@@ -40507,13 +40507,13 @@ var AgentSession = class _AgentSession {
   };
   #processUpdate = async (notification) => {
     this.assertNativeSession(notification.sessionId);
-    const update = notification.update;
     const externalized = await this.#contentExternalizer.update(
       this.#mobiusSessionId,
-      update,
+      notification.update,
       AbortSignal.timeout(3e4)
     );
-    const rawUpdate = decodeAcpSessionUpdateV2(JSON.stringify(externalized));
+    const update = externalized.agent;
+    const rawUpdate = decodeAcpSessionUpdateV2(JSON.stringify(externalized.event));
     if (this.#sessionLoad.kind === "capturing") {
       await this.#sessionLoad.history.record(update, rawUpdate);
     } else {
@@ -40939,7 +40939,19 @@ function decodeBase64(data) {
   if (data.length > MAXIMUM_ENCODED_CONTENT_CHARACTERS || data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(data)) {
     throw new Error("The ACP embedded content is not valid bounded base64");
   }
-  return Buffer.from(data, "base64");
+  const bytes = Buffer.from(data, "base64");
+  if (bytes.toString("base64") !== data) {
+    throw new Error("The ACP embedded content is not canonical base64");
+  }
+  return bytes;
+}
+var embeddedImageSchema = external_exports.looseObject({
+  type: external_exports.literal("image"),
+  data: external_exports.string(),
+  mimeType: external_exports.string()
+});
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var AcpContentExternalizer = class {
   #store;
@@ -40950,32 +40962,45 @@ var AcpContentExternalizer = class {
     switch (content.type) {
       case "text":
       case "resource_link":
-        return content;
+        return { agent: content, event: content };
       case "image": {
         if (content.data.length === 0) {
-          return content;
+          return { agent: content, event: content };
+        }
+        try {
+          const bytes = decodeBase64(content.data);
+          if (sniffRasterMime(bytes) !== content.mimeType) {
+            throw new Error("Embedded image bytes do not match a supported image MIME type");
+          }
+          const stored = await this.#store.put({
+            bytes,
+            kind: "image",
+            mediaType: content.mimeType,
+            name: "image",
+            sessionId,
+            signal
+          });
+          return {
+            agent: { ...content, data: "", uri: `mobius-content:image:${stored.key}` },
+            event: {
+              _meta: content._meta,
+              annotations: content.annotations,
+              byteLength: stored.byteLength,
+              imageKey: stored.key,
+              mimeType: content.mimeType,
+              type: "external_image",
+              uri: content.uri
+            }
+          };
+        } catch {
+          signal.throwIfAborted();
+          const unavailable = { type: "text", text: "[Image unavailable]" };
+          return { agent: unavailable, event: unavailable };
         }
-        const stored = await this.#store.put({
-          bytes: decodeBase64(content.data),
-          kind: "image",
-          mediaType: content.mimeType,
-          name: "image",
-          sessionId,
-          signal
-        });
-        return {
-          _meta: content._meta,
-          annotations: content.annotations,
-          byteLength: stored.byteLength,
-          imageKey: stored.key,
-          mimeType: content.mimeType,
-          type: "external_image",
-          uri: content.uri
-        };
       }
       case "audio": {
         if (content.data.length === 0) {
-          return content;
+          return { agent: content, event: content };
         }
         const stored = await this.#store.put({
           bytes: decodeBase64(content.data),
@@ -40986,12 +41011,15 @@ var AcpContentExternalizer = class {
           signal
         });
         return {
-          _meta: content._meta,
-          annotations: content.annotations,
-          audioKey: stored.key,
-          byteLength: stored.byteLength,
-          mimeType: content.mimeType,
-          type: "external_audio"
+          agent: content,
+          event: {
+            _meta: content._meta,
+            annotations: content.annotations,
+            audioKey: stored.key,
+            byteLength: stored.byteLength,
+            mimeType: content.mimeType,
+            type: "external_audio"
+          }
         };
       }
       case "resource": {
@@ -40999,7 +41027,7 @@ var AcpContentExternalizer = class {
         const encoding = "text" in embedded ? "text" : "binary";
         const bytes = "text" in embedded ? Buffer.from(embedded.text, "utf8") : decodeBase64(embedded.blob);
         if (bytes.byteLength === 0) {
-          return content;
+          return { agent: content, event: content };
         }
         const mediaType = embedded.mimeType ?? "application/octet-stream";
         const stored = await this.#store.put({
@@ -41011,43 +41039,111 @@ var AcpContentExternalizer = class {
           signal
         });
         return {
-          _meta: content._meta,
-          annotations: content.annotations,
-          byteLength: stored.byteLength,
-          encoding,
-          mimeType: embedded.mimeType,
-          resourceKey: stored.key,
-          type: "external_resource",
-          uri: embedded.uri
+          agent: content,
+          event: {
+            _meta: content._meta,
+            annotations: content.annotations,
+            byteLength: stored.byteLength,
+            encoding,
+            mimeType: embedded.mimeType,
+            resourceKey: stored.key,
+            type: "external_resource",
+            uri: embedded.uri
+          }
         };
       }
     }
   }
-  async #toolContent(sessionId, item, signal) {
-    return item.type === "content" ? { ...item, content: await this.#content(sessionId, item.content, signal) } : item;
+  async #rawOutput(sessionId, value, images, signal, depth = 0) {
+    signal.throwIfAborted();
+    if (depth > 16) {
+      throw new Error("ACP tool output exceeds the maximum nesting depth");
+    }
+    if (Array.isArray(value)) {
+      const result2 = [];
+      for (const item of value) {
+        result2.push(await this.#rawOutput(sessionId, item, images, signal, depth + 1));
+      }
+      return result2;
+    }
+    if (!isRecord10(value)) {
+      return value;
+    }
+    const image = embeddedImageSchema.safeParse(value);
+    if (image.success && image.data.data.length > 0) {
+      const prepared = await this.#content(sessionId, image.data, signal);
+      if (isRecord10(prepared.event) && typeof prepared.event["imageKey"] === "string") {
+        images.set(prepared.event["imageKey"], prepared);
+      } else {
+        images.set(`unavailable:${images.size}`, prepared);
+      }
+      return prepared.event;
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = await this.#rawOutput(sessionId, item, images, signal, depth + 1);
+    }
+    return result;
+  }
+  async #toolUpdate(sessionId, update, signal) {
+    const images = /* @__PURE__ */ new Map();
+    const rawOutput = update.rawOutput === void 0 ? void 0 : await this.#rawOutput(sessionId, update.rawOutput, images, signal);
+    const originalJson = images.size === 0 ? void 0 : JSON.stringify(update.rawOutput);
+    const rewrittenJson = images.size === 0 ? void 0 : JSON.stringify(rawOutput);
+    const agentContent = [];
+    const eventContent = [];
+    for (const item of update.content ?? []) {
+      if (item.type !== "content") {
+        agentContent.push(item);
+        eventContent.push(item);
+        continue;
+      }
+      const content = item.content.type === "text" && item.content.text === originalJson && rewrittenJson !== void 0 ? { ...item.content, text: rewrittenJson } : item.content;
+      const prepared = await this.#content(sessionId, content, signal);
+      agentContent.push({ ...item, content: prepared.agent });
+      eventContent.push({ ...item, content: prepared.event });
+      if (isRecord10(prepared.event) && typeof prepared.event["imageKey"] === "string") {
+        images.delete(prepared.event["imageKey"]);
+      }
+    }
+    for (const prepared of images.values()) {
+      agentContent.push({ type: "content", content: prepared.agent });
+      eventContent.push({ type: "content", content: prepared.event });
+    }
+    const output2 = update.rawOutput === void 0 ? {} : { rawOutput };
+    const hasContent = update.content !== void 0 && update.content !== null || agentContent.length > 0;
+    return {
+      agent: { ...update, ...output2, ...hasContent ? { content: agentContent } : {} },
+      event: { ...update, ...output2, ...hasContent ? { content: eventContent } : {} }
+    };
   }
   update = async (sessionId, update, signal) => {
     switch (update.sessionUpdate) {
       case "user_message_chunk":
       case "agent_message_chunk":
       case "agent_thought_chunk":
-      case "compaction_summary_chunk":
-        return { ...update, content: await this.#content(sessionId, update.content, signal) };
+      case "compaction_summary_chunk": {
+        const content = await this.#content(sessionId, update.content, signal);
+        return {
+          agent: { ...update, content: content.agent },
+          event: { ...update, content: content.event }
+        };
+      }
       case "tool_call":
       case "tool_call_update":
-        return update.content === void 0 || update.content === null ? update : {
-          ...update,
-          content: await Promise.all(
-            update.content.map(async (item) => await this.#toolContent(sessionId, item, signal))
-          )
-        };
-      case "compaction_update":
-        return update.summary === void 0 || update.summary === null ? update : {
-          ...update,
-          summary: await Promise.all(
-            update.summary.map(async (content) => await this.#content(sessionId, content, signal))
-          )
+        return await this.#toolUpdate(sessionId, update, signal);
+      case "compaction_update": {
+        if (update.summary === void 0 || update.summary === null) {
+          return { agent: update, event: update };
+        }
+        const content = await Promise.all(
+          update.summary.map(async (item) => await this.#content(sessionId, item, signal))
+        );
+        return {
+          agent: { ...update, summary: content.map((item) => item.agent) },
+          event: { ...update, summary: content.map((item) => item.event) }
         };
+      }
       case "plan":
       case "plan_update":
       case "plan_removed":
@@ -41056,16 +41152,17 @@ var AcpContentExternalizer = class {
       case "config_option_update":
       case "session_info_update":
       case "usage_update":
-        return update;
+        return { agent: update, event: update };
     }
   };
 };
 
 // src/external-content/local-external-content-store.ts
 import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
-import { lstat, mkdir as mkdir6, readFile as readFile3, realpath as realpath8, rename as rename4, rm as rm3, stat as stat7, writeFile as writeFile4 } from "node:fs/promises";
+import { lstat, mkdir as mkdir6, readdir as readdir3, realpath as realpath8, rename as rename4, rm as rm3, stat as stat7, utimes, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname5, join as join16 } from "node:path";
 var contentRequest = /^mobius-content:(image|audio|resource):([a-f0-9]{64})$/u;
+var CONTENT_LIFETIME_MILLISECONDS = 24 * 60 * 60 * 1e3;
 var metadataSchema2 = external_exports.strictObject({
   kind: external_exports.enum(["image", "audio", "resource"]),
   mediaType: external_exports.string().min(1).max(2048).regex(/^[\u0020-\u007e]+$/u),
@@ -41081,9 +41178,6 @@ var UnretainedExternalContentStore = class {
     return Promise.resolve(null);
   };
 };
-function sessionScope(sessionId) {
-  return createHash3("sha256").update(sessionId).digest("hex");
-}
 async function atomicWrite(path3, bytes, signal) {
   const temporary = `${path3}.${randomUUID2()}.tmp`;
   try {
@@ -41096,55 +41190,134 @@ async function atomicWrite(path3, bytes, signal) {
 }
 var LocalExternalContentStore = class {
   #root;
+  #entries = /* @__PURE__ */ new Map();
+  #operations = /* @__PURE__ */ new Set();
+  #lifetime = new AbortController();
+  #expirationTimer;
+  #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join16(stateDirectory, "tmp", "session-content");
-  }
-  put = async ({ bytes, kind, mediaType, name, sessionId, signal }) => {
-    signal.throwIfAborted();
+    this.#root = join16(stateDirectory, "tmp", "session-content", randomUUID2());
+    this.#expirationTimer = setInterval(() => {
+      void this.#expire().catch(() => void 0);
+    }, 6e4);
+    this.#expirationTimer.unref();
+  }
+  #expire = () => {
+    this.#cleanup = this.#cleanup.catch(() => void 0).then(async () => {
+      await mkdir6(this.#root, { mode: 448, recursive: true });
+      const now = /* @__PURE__ */ new Date();
+      await utimes(this.#root, now, now);
+      for (const directory of await readdir3(dirname5(this.#root), { withFileTypes: true })) {
+        if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
+          continue;
+        }
+        const path3 = join16(dirname5(this.#root), directory.name);
+        if (path3 === this.#root) {
+          continue;
+        }
+        const modified = await stat7(path3).then(
+          (entry) => entry.mtimeMs,
+          () => Date.now()
+        );
+        if (modified + CONTENT_LIFETIME_MILLISECONDS <= Date.now()) {
+          await rm3(path3, { force: true, recursive: true });
+        }
+      }
+      for (const [request, entry] of this.#entries) {
+        if (entry.expiresAt > Date.now()) {
+          continue;
+        }
+        await rm3(entry.path, { force: true });
+        this.#entries.delete(request);
+      }
+    });
+    return this.#cleanup;
+  };
+  #track = async (operation) => {
+    this.#lifetime.signal.throwIfAborted();
+    const pending = operation();
+    this.#operations.add(pending);
+    try {
+      return await pending;
+    } finally {
+      this.#operations.delete(pending);
+    }
+  };
+  put = (input2) => this.#track(() => this.#put(input2));
+  #put = async ({ bytes, kind, mediaType, name, sessionId, signal }) => {
+    const active = AbortSignal.any([signal, this.#lifetime.signal]);
+    active.throwIfAborted();
+    const metadata = metadataSchema2.parse({ kind, mediaType, name });
     const key = createHash3("sha256").update(bytes).digest("hex");
-    const directory = join16(this.#root, sessionScope(sessionId), kind);
+    const request = `mobius-content:${kind}:${key}`;
+    const existing = this.#entries.get(request);
+    if (existing !== void 0 && existing.expiresAt > Date.now()) {
+      this.#entries.set(request, {
+        ...existing,
+        expiresAt: Date.now() + CONTENT_LIFETIME_MILLISECONDS,
+        sessions: /* @__PURE__ */ new Set([...existing.sessions, sessionId])
+      });
+      return { byteLength: existing.byteLength, key };
+    }
+    await this.#expire();
+    active.throwIfAborted();
+    const directory = join16(this.#root, kind);
     await mkdir6(directory, { mode: 448, recursive: true });
-    signal.throwIfAborted();
+    active.throwIfAborted();
     const path3 = join16(directory, key);
-    await atomicWrite(path3, bytes, signal);
-    await atomicWrite(
-      `${path3}.json`,
-      Buffer.from(JSON.stringify(metadataSchema2.parse({ kind, mediaType, name })), "utf8"),
-      signal
-    );
+    const write = atomicWrite(path3, bytes, active);
+    await write;
+    active.throwIfAborted();
+    const retained = this.#entries.get(request);
+    this.#entries.set(request, {
+      byteLength: bytes.byteLength,
+      expiresAt: Date.now() + CONTENT_LIFETIME_MILLISECONDS,
+      mediaType: metadata.mediaType,
+      name: metadata.name,
+      path: path3,
+      sessions: /* @__PURE__ */ new Set([...retained?.sessions ?? [], sessionId])
+    });
     return { byteLength: bytes.byteLength, key };
   };
-  resolve = async (sessionId, request, signal) => {
-    const matched = contentRequest.exec(request);
-    if (matched === null) {
+  resolve = (sessionId, request, signal) => this.#track(() => this.#resolve(sessionId, request, AbortSignal.any([signal, this.#lifetime.signal])));
+  #resolve = async (sessionId, request, signal) => {
+    signal.throwIfAborted();
+    this.#lifetime.signal.throwIfAborted();
+    if (!contentRequest.test(request)) {
       return null;
     }
-    const kind = matched[1];
-    const key = matched[2];
-    if (kind !== "image" && kind !== "audio" && kind !== "resource" || key === void 0) {
+    const entry = this.#entries.get(request);
+    if (entry === void 0 || !entry.sessions.has(sessionId)) {
+      return null;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      await this.#expire();
+      signal.throwIfAborted();
       return null;
     }
-    const directory = join16(this.#root, sessionScope(sessionId), kind);
-    const path3 = join16(directory, key);
     try {
-      const [resolvedDirectory, resolvedPath, file2, metadata] = await Promise.all([
-        realpath8(directory),
-        realpath8(path3),
-        lstat(path3),
-        readFile3(`${path3}.json`, "utf8").then((value) => metadataSchema2.parse(JSON.parse(value)))
+      const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
+        realpath8(dirname5(entry.path)),
+        realpath8(entry.path),
+        lstat(entry.path)
       ]);
       signal.throwIfAborted();
-      if (!file2.isFile() || dirname5(resolvedPath) !== resolvedDirectory || metadata.kind !== kind) {
+      if (!file2.isFile() || file2.isSymbolicLink() || dirname5(resolvedPath) !== resolvedDirectory) {
         return null;
       }
-      await stat7(resolvedPath);
-      signal.throwIfAborted();
-      return { mediaType: metadata.mediaType, name: metadata.name, path: resolvedPath };
+      return { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
     } catch {
       signal.throwIfAborted();
       return null;
     }
   };
+  [Symbol.asyncDispose] = async () => {
+    clearInterval(this.#expirationTimer);
+    this.#lifetime.abort();
+    await Promise.allSettled([...this.#operations, this.#cleanup]);
+    this.#entries.clear();
+    await rm3(this.#root, { force: true, recursive: true });
+  };
 };
 
 // src/native-sessions/chat-agent.ts
@@ -42066,7 +42239,7 @@ var AgentCatalogPublishError = class extends Error {
     this.name = "AgentCatalogPublishError";
   }
 };
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isSafeRelayErrorMessage(value) {
@@ -42079,7 +42252,7 @@ async function rejectedCatalogError(response) {
   } catch {
     return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
   }
-  if (!isRecord10(value) || !isRecord10(value["error"])) {
+  if (!isRecord11(value) || !isRecord11(value["error"])) {
     return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
   }
   const code = value["error"]["code"];
@@ -42610,7 +42783,7 @@ var FixedInstallationExecutor = class {
 };
 
 // src/authorization/workspace-directory.ts
-import { readdir as readdir3, realpath as realpath9, stat as stat8 } from "node:fs/promises";
+import { readdir as readdir4, realpath as realpath9, stat as stat8 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { basename as basename4, dirname as dirname6, isAbsolute as isAbsolute9, join as join17, normalize as normalize3, relative as relative4 } from "node:path";
 
@@ -42730,7 +42903,7 @@ var WorkspaceDirectoryService = class {
   list = async (bindingId, id, signal) => {
     const target = await this.resolve(bindingId, id, signal);
     try {
-      const children = await readdir3(target, { withFileTypes: true });
+      const children = await readdir4(target, { withFileTypes: true });
       signal.throwIfAborted();
       const entries = [];
       for (const child2 of children) {
@@ -48429,7 +48602,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
   const sessionStore = new SqliteAcpSessionStore(
     join19(stateDirectory, "sessions", `${createHash8("sha256").update(config2.channelId).digest("hex")}.sqlite`)
   );
-  const externalContent = new LocalExternalContentStore(stateDirectory);
+  await using externalContent = new LocalExternalContentStore(stateDirectory);
   const operations = new DaemonOperationState();
   const publisher = new DaemonSessionEventPublisher(sessionStore);
   const eventLogV2 = new DaemonSessionEventLogV2(publisher, sessionStore);
@@ -48697,7 +48870,7 @@ async function acquireManagerLock(stateDirectory) {
       if (!isNodeError2(cause, "EEXIST")) {
         throw cause;
       }
-      const encoded = await readFile4(path3, "utf8").catch(() => "");
+      const encoded = await readFile3(path3, "utf8").catch(() => "");
       const pid = Number(encoded.trim());
       if (Number.isSafeInteger(pid) && pid > 1) {
         try {
@@ -48714,7 +48887,7 @@ async function acquireManagerLock(stateDirectory) {
   }
   return null;
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function controlSocketPath(stateDirectory) {
@@ -48727,7 +48900,7 @@ function controlTokenPath(stateDirectory) {
 async function readOrCreateControlToken(stateDirectory) {
   const path3 = controlTokenPath(stateDirectory);
   try {
-    return (await readFile4(path3, "utf8")).trim();
+    return (await readFile3(path3, "utf8")).trim();
   } catch (cause) {
     if (!isNodeError2(cause, "ENOENT")) {
       throw cause;
@@ -48742,14 +48915,14 @@ async function readOrCreateControlToken(stateDirectory) {
     if (!isNodeError2(cause, "EEXIST")) {
       throw cause;
     }
-    return (await readFile4(path3, "utf8")).trim();
+    return (await readFile3(path3, "utf8")).trim();
   }
 }
 function isNodeError2(error62, code) {
   return typeof error62 === "object" && error62 !== null && "code" in error62 && error62.code === code;
 }
 function decodeCommand(value, expectedToken) {
-  if (!isRecord11(value) || value["token"] !== expectedToken || typeof value["kind"] !== "string") {
+  if (!isRecord12(value) || value["token"] !== expectedToken || typeof value["kind"] !== "string") {
     throw new Error("The manager request is invalid");
   }
   if (value["kind"] === "list" || value["kind"] === "stop") {
@@ -48768,7 +48941,7 @@ function decodeCommand(value, expectedToken) {
   throw new Error("The manager command is unsupported");
 }
 function decodeResponse(value) {
-  if (!isRecord11(value) || typeof value["kind"] !== "string") {
+  if (!isRecord12(value) || typeof value["kind"] !== "string") {
     throw new Error("The Mobius manager returned an invalid response");
   }
   if (value["kind"] === "error" && typeof value["code"] === "string" && typeof value["message"] === "string") {
@@ -48795,7 +48968,7 @@ function decodeResponse(value) {
   throw new Error("The Mobius manager returned an invalid response");
 }
 function isManagedRuntimeSummary(value) {
-  return isRecord11(value) && typeof value["appId"] === "string" && typeof value["connectionId"] === "string" && typeof value["runtimeId"] === "string" && typeof value["workspace"] === "string" && ["starting", "online", "reconnecting", "failed", "stopped"].includes(String(value["status"]));
+  return isRecord12(value) && typeof value["appId"] === "string" && typeof value["connectionId"] === "string" && typeof value["runtimeId"] === "string" && typeof value["workspace"] === "string" && ["starting", "online", "reconnecting", "failed", "stopped"].includes(String(value["status"]));
 }
 function summary(connection, status) {
   return {
@@ -49054,7 +49227,7 @@ async function waitForManagerExit(stateDirectory, signal) {
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(1e4)]);
   while (!deadline.aborted) {
     try {
-      await readFile4(join20(stateDirectory, "manager.lock"), "utf8");
+      await readFile3(join20(stateDirectory, "manager.lock"), "utf8");
     } catch (cause) {
       if (isNodeError2(cause, "ENOENT")) {
         return;