@fungi.computer/computer 0.0.0-stage → 0.0.1

package/Dockerfile

@@ -0,0 +1,85 @@
+# node-pty ships no Linux prebuild; compile it against the runtime's Node ABI.
+FROM node:24.20.0-trixie-slim@sha256:a747ad80c8a161b650d79a6da9c422005b91148b18b8d2c669eb5a0b7c07e600 AS terminal
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends python3 make g++ pkg-config libfuse-dev \
+  && rm -rf /var/lib/apt/lists/*
+RUN npm install --global --no-fund --no-audit pnpm@11.24.0
+WORKDIR /opt/fungi
+COPY container/package.json container/pnpm-lock.yaml container/pnpm-workspace.yaml ./
+RUN pnpm install --frozen-lockfile --prod --config.node-linker=hoisted \
+  && cd node_modules/node-pty \
+  && mv build/Release/pty.node /tmp/pty.node \
+  && rm -rf build deps third_party src scripts typings prebuilds node-addon-api \
+  && mkdir -p build/Release \
+  && mv /tmp/pty.node build/Release/pty.node
+
+COPY container/runtime-privileges.cc ./
+RUN g++ -shared -fPIC -I/usr/local/include/node runtime-privileges.cc -o runtime-privileges.node
+
+# Compile Cordyceps' native apply-patch engine (source copied into
+# dist/apply-patch by this package's build) for this image's own platform.
+FROM node:24.20.0-trixie-slim@sha256:a747ad80c8a161b650d79a6da9c422005b91148b18b8d2c669eb5a0b7c07e600 AS apply-patch
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends \
+    build-essential ca-certificates curl pkg-config libssl-dev \
+  && rm -rf /var/lib/apt/lists/*
+ENV RUSTUP_HOME=/opt/rustup CARGO_HOME=/opt/cargo
+ENV PATH=/opt/cargo/bin:$PATH
+COPY dist/apply-patch/pin.mjs /source/
+RUN toolchain="$(node --input-type=module --eval "import { codexPatchPin } from '/source/pin.mjs'; console.log(codexPatchPin.rustToolchain)")" \
+  && curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o /tmp/rustup.sh \
+  && sh /tmp/rustup.sh -y --profile minimal --default-toolchain "$toolchain" \
+  && rm /tmp/rustup.sh
+COPY dist/apply-patch/ /source/
+RUN node /source/compile.mjs --out /out --scratch /scratch
+
+# Match the repository toolchain on the same Linux x64 target as computerd.
+FROM node:24.20.0-trixie-slim@sha256:a747ad80c8a161b650d79a6da9c422005b91148b18b8d2c669eb5a0b7c07e600
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends \
+    fuse3 libfuse2t64 ca-certificates curl git tini \
+  && rm -rf /var/lib/apt/lists/*
+
+RUN npm install --global --no-fund --no-audit pnpm@11.24.0 \
+  && test "$(node --version)" = "v24.20.0" \
+  && test "$(pnpm --version)" = "11.24.0"
+
+# Build contexts may come from private gate checkouts (umask 077). Runtime
+# modules must remain readable after init drops to the Computer's own UID.
+# dist/computerd.cjs comes from this package's own build, which copies it from
+# @fungi.computer/cordyceps; the apply-patch engine and its crate notices come
+# from the builder stage above. The image assembly step
+# (scripts/assemble-image.mjs, also run by prepack) copies Oyster's App
+# candidate builder into dist/ before this Dockerfile is built.
+COPY dist/computerd.cjs dist/team-candidate-builder.mjs /opt/fungi/
+COPY --from=apply-patch --chmod=755 /out/fungi-apply-patch /opt/fungi/fungi-apply-patch
+COPY --from=apply-patch /out/build.json /opt/fungi/fungi-apply-patch.notices.json
+COPY dist/apply-patch/LICENSE.codex /opt/fungi/fungi-apply-patch.LICENSE
+COPY --from=terminal /opt/fungi/node_modules /opt/fungi/node_modules
+COPY container/runtime-privileges.mjs /opt/fungi/
+COPY --from=terminal /opt/fungi/runtime-privileges.node /opt/fungi/
+COPY container/package.json container/computer-init.mjs container/computer-start.sh container/resource-bounds.mjs container/terminal-server.mjs container/terminal-runtime.mjs container/terminal-protocol.mjs /opt/fungi/
+COPY container/terminal-assets/bashrc container/terminal-assets/git-prompt.sh /opt/fungi/terminal-assets/
+RUN chmod -R a+rX /opt/fungi \
+  && printf '\n. /opt/fungi/terminal-assets/bashrc\n' >> /etc/bash.bashrc \
+  && printf '. /opt/fungi/terminal-assets/bashrc\n' > /etc/profile.d/fungi-terminal.sh
+
+# No customer process can invoke a setuid/setgid helper, including fusermount.
+# FUSE is mounted while init is root, before either runtime listener opens.
+RUN find / -xdev -perm /6000 -exec chmod a-s {} +
+
+ENV PORT=8080
+ENV MOUNT_POINT=/workspace
+ENV FUSE_MOUNT=auto
+ENV COMPUTER_TERMINAL_PORT=7681
+ENV NODE_EXTRA_CA_CERTS=/etc/cloudflare/certs/cloudflare-containers-ca.crt
+ENV SSL_CERT_FILE=/tmp/fungi-ca-bundle.crt
+ENV GIT_SSL_CAINFO=/tmp/fungi-ca-bundle.crt
+EXPOSE 8080 7681
+
+# tini is PID 1 and only reaps orphans and forwards signals. computer-init is
+# the one supervisor: it owns computerd and the terminal server, and exits
+# with them so the Containers runtime replaces the whole Computer runtime.
+ENTRYPOINT ["/usr/bin/tini", "-g", "--"]
+CMD ["/usr/bin/bash", "/opt/fungi/computer-start.sh"]

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jamstack Consulting LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,229 @@
-# Temporary Holding Version
+# Computer runtime
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This private runtime hosts one logical Fungi Computer: a SQLite-backed workspace
+of files, admitted operations, and optional execution backends. The Hub composes
+it with Team authorization, capacity and billing. The runtime is not an
+independently installed npm VM service and does not own Team roles.
+
+## Fleet contracts
+
+Node tooling and browser consumers can import the grant/fact schemas and types
+from `@fungi.computer/computer/fleet/wire`, and backing descriptions from
+`@fungi.computer/computer/backing`. These entries do not load Worker runtime
+declarations. The `./fleet` lifecycle and main Computer entry require the host
+runtime's Cloudflare Workers types.
+
+`@fungi.computer/computer/fleet` owns the host-neutral grant check, backing
+records and fact contracts. A host authenticates its caller and supplies a
+`ComputerGrant`: one Computer, explicit actions, an expiry, optional host-owned
+egress data, plus opaque actor/invocation provenance. `checkComputerGrant`
+returns `admitted` or `Refused`; grants impose no paid-usage budget. A caller's
+per-command timeout remains a command parameter enforced by the operation
+executor. Hub credit enforcement remains on its existing funded/unfunded
+admission and `creditChanged` → credit-publication restate/stop path.
+
+`createFleetBacking` accepts the maintained SQLite owner. Creation records a
+plain backing decision once. Explicit fleet-default and Computer overrides
+remain possible; local attachment keeps replay identity, actor ownership and
+detach cancellation. Mutations return complete backend projections rather than
+calling a host or delivering messages. The composing host can include the call
+and durable outbox staging in its SQLite transaction. Its deployment chooses the
+offered backing kinds; the fleet never rereads deployment configuration.
+
+`ComputerFact` describes process exit, file writes, egress, lifecycle and
+runtime interval observations with provenance. CPU time is nullable when
+unmeasured. The host reads these records and owns settlement and delivery.
+Host-specific egress data is decoded by its host; the fleet contract carries
+JSON data without importing the host's policy.
+
+The fleet also owns inventory/replay receipts, running-slot storage, runtime
+intervals, and native lifecycle activity/recycling. Inventory admission stays at
+the host: an existing create receipt is checked before funding a new create.
+Slot capacity is explicit infrastructure input; grants carry no usage cap.
+`FleetLifecycle.run` checks a host-issued start grant before native execution.
+The host consumes returned reservation/diagnostic facts and
+`ComputerRuntimeUsage.pendingFacts` interval facts; it owns credit changes,
+usage delivery, logging, and Team Git. Acknowledgment retains the existing
+runtime checkpoint identity and occurs only after delivery. Transport activity,
+idle sleep, and VM recycle sequencing retain the existing runtime behavior. The
+Hub records creation backing facts for its declared known Computers at
+initialization; the fleet never derives missing records on reads.
+
+The Hub projects each current resource decision into a grant for the requested
+Files or execution permission. It carries the stored decision's expiry and
+actor/attachment identity. Native acceptance still rechecks the current Hub
+decision before fleet admission; a grant is never cached across that check. The
+Hub projects interval facts into its existing usage Post payload without
+changing billing or credit-stop behavior.
+
+The repository architecture test rejects upward imports from this runtime into
+Apps, Billing, Broker or Team/plan modules, including type and dynamic imports.
+
+## Source setup
+
+Use a configured repository checkout with the pinned Node and pnpm tools. Run
+from the repository root:
+
+```sh
+pnpm turbo:run run build --filter=@fungi.computer/computer
+pnpm --filter @fungi.computer/computer typecheck
+pnpm --filter @fungi.computer/computer lint
+pnpm --filter @fungi.computer/computer test
+```
+
+The build emits the runtime and copies its daemon/build assets. The test suite
+uses disposable Workers and proof containers, so container proofs require a
+working local Docker/Workers environment. These commands do not deploy a Hub,
+publish an App or replace a production Computer image.
+
+## Files and operation results
+
+[ComputerDO](src/index.ts) composes the maintained Cloudflare Workspace and
+SQLite provider. Files belong to that workspace, not to a running shell process.
+A file read can work with no available execution backend.
+
+[Operation contracts](src/operation-contract.ts) declare discovery, bounded file
+reads/writes, directories, command execution, processes and port exposure. The
+[Files adapter](src/files.ts) implements the same read and compare/replace
+contract for Agent tools. Failed containment, conflicting contents and reserved
+ports remain explicit errors.
+
+An execution request carries a replay key. The
+[operation record](src/operation-record.ts) admits the immutable input and
+retains its result. Repeating that key reads the same operation rather than
+silently starting it again with different content. Accepted, running, settled
+and uncertain outcomes are distinct. An uncertain result is not a successful
+command or proof that no side effect happened.
+
+The Workspace is authoritative. A Files save pushes to a hosted runtime that is
+already running, and a Files read pulls from it first. While a terminal is
+attached, the Computer pushes and then pulls every 3 s, so the open terminal and
+Files stay close to each other without either side waiting on the other. A
+stopped runtime is never woken to sync; it catches up through its own push/pull
+bracket on its next command or terminal attach. A failed sync stays pending in
+the library's own cursors and is resent on the next sync, so it never fails the
+Files operation that triggered it. There is no merge: each path takes the last
+version applied. Edits to the same path on both sides between two syncs resolve
+to the Workspace's version, because the loop pushes before it pulls. A
+compare-and-replace save pulls first, so a newer terminal edit surfaces as an
+honest conflict instead of a silent overwrite, while a blind write still
+overwrites the container's copy.
+
+## Choose an execution backend
+
+[Backend routing](src/computer-backends.ts) owns these choices:
+
+| Operation                             | Routing                                                                                                            |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `exec` without a backend ID           | Built-in Worker shell.                                                                                             |
+| `bash`, or execution naming a backend | The named backend, or online local folders before on-box VMs before platform containers. Attach order breaks ties. |
+| Terminal, processes and ports         | Hosted backends only. A local folder cannot serve these operations.                                                |
+
+An explicit unavailable backend never silently falls back. With no usable
+backend, execution returns `no_backend` or `backend_unavailable`; workspace
+Files remain separate. The backend list is bounded and IDs are unique.
+
+[Local backends](src/local-backend.ts) connect through the member's device-key
+admission and dial-out socket. Files sync with the attached folder. Commands run
+with that member's OS access. [On-box VM support](src/on-box-vm.ts) adapts a
+registered host to the Workspace backend interface. Platform containers use the
+maintained Cloudflare container backend. Neither backend label nor a green
+container fixture certifies an installed VM host or production routing.
+
+## Processes, ports and lifetime
+
+Start requires a host-owned opaque `requestId` and `requestScope`, plus a
+command, optional working directory and optional declared port. Within this
+Computer, the same scope/key and immutable input return the retained process;
+changed input conflicts. Replay protection lasts while its process record is
+retained (at most 64 records, with 16 running **per host scope**). Another scope
+cannot consume these slots or evict its replay protection. Once this scope's own
+history evicts an exited record, its key can start a new process; callers must
+not retry a retired command as new work. Inventory presentation lists the newest
+64 records across the Computer; retained records can outlive that read window. A
+retained replay never starts another command or boots a backend. A running
+receipt replays as `uncertain`; liveness reads verify execution. Failed dispatch
+retains an exited receipt.
+
+App hosts derive scope from Installation, method and member/actor, separately
+from the unchanged opaque invocation key. The helper uses an unambiguous JSON
+tuple and labels the caller `member:<id>`, `agent:<id>` or `team-key:<id>`. One
+method invocation permits one declared start: identical input is a retry,
+different input conflicts. The trusted App HTTP route takes only the sealed host
+method label and derives Installation and member from its admitted principal;
+arbitrary requestScope is invalid. Native model capability input has only
+command/cwd/port; public call mints its own native-tool scope/key. Scope strings
+are replay identities, not grants.
+
+Admission records the process and any newly created port exposure in one SQLite
+transaction. Process rows carry `port` (`null` when none was declared). An
+observed exit or refused dispatch removes only that process's exposure; manual
+exposures remain, including an explicit manual re-expose. Request/frame
+cancellation after host dispatch does not cancel Computer-owned work.
+
+[Process inventory](src/process-inventory.ts) retains owner-issued identities
+and reports running, exited or uncertain state. Worker reconstruction and
+backend termination are different events. A reachable backend can preserve a
+process across Worker reconstruction; a sleeping or stopped backend does not
+keep that process alive.
+
+Ordinary command execution is bounded to two minutes. Long-running work uses
+process operations. Port exposure is explicit and bounded. Ports 8080 and 7681
+belong to Computer control/terminal daemons and cannot be application previews.
+The Hub owns preview admission and URLs; this runtime does not expose arbitrary
+Computer control endpoints to the browser.
+
+[Container policy](src/container-policy.ts) configures idle sleep and respects
+`HOSTED_COMPUTERS`. Invalid pause settings fail closed. Network access follows
+the host's admitted egress composition; a native container binding and the
+on-box host adapter are separate configuration paths.
+
+## Image and build inputs
+
+The [Dockerfile](Dockerfile) builds the Linux environment with pinned Node,
+pnpm, Git, FUSE support and the bundled computerd. Its
+[container manifest](container/package.json) owns the PTY and runtime
+dependencies. [computer-init](container/computer-init.mjs) supervises computerd
+and the terminal server. Initialization mounts before dropping privileges; the
+image removes setuid/setgid helpers. Terminal shell assets live under
+[container/terminal-assets](container/terminal-assets).
+
+The [Forage dependency fixture](test/forage-dependencies/README.md) describes an
+offline dependency layer and its exact source manifest. It is a reproducible
+build fixture, not another runtime package or evidence that generated outputs
+were saved in a hosted Computer. Do not copy its temporary output into source.
+
+## Proof and reference
+
+[package.json](package.json) declares the private entrypoints `.` and `./files`,
+`./backing`, `./host-config`, `./operations`.
+[Runtime proof](test/runtime-proof.mjs) checks native workspace operations and
+reconstruction. [Process proof](test/process-proof.mjs) checks retained process
+identity against the real container.
+[Terminal proof](test/terminal-container-proof.mjs),
+[resource proof](test/container-resource-proof.mjs) and
+[backend tests](test/computer-backends.test.mjs) cover their separate
+boundaries. The declared nightly egress proof is separate from the ordinary
+package test. No local proof alone qualifies a production or celld/on-box
+deployment.
+
+### Post-command Workspace transport
+
+The Computer's remote-backend adapter observes the backend's closed-connection
+signal and classifies failed RPC calls and streams as transport failures
+understood by `@cloudflare/computer`. It does not inspect exception text. The
+library retains its existing one-reconnect bound and finishes the post-command
+pull against the same runtime. The adapter adds no retry loop, never replays an
+uncertain command, and leaves failed synchronization pending. Public consumers
+use the unpatched dependency. `node --test test/workspace-sync.test.mjs`
+exercises that installed Workspace runtime and SQLite filesystem, including
+persisted file bytes, persistent failure, domain failure, runtime replacement
+and uncertain dispatch.
+
+### Port previews
+
+`@fungi.computer/computer/preview` owns bounded, signed preview tickets and
+service-relative routing. The host supplies its selector decoder, hostname
+policy and live admission callback. Admission runs at the exposed-port listing
+and forwarding acceptance points; a ticket is never a grant. Hub retains its
+local App projection and signed-ticket hostname configuration.

package/container/computer-init.mjs

@@ -0,0 +1,119 @@
+// The Computer image's only supervisor. tini is PID 1 and reaps orphans;
+// this process owns computerd and the terminal server. It restarts neither:
+// if either dies the container exits, the Containers monitor records the
+// exit, and the Computer's container backend launches a fresh runtime.
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { setTimeout, clearTimeout } from "node:timers";
+import { fileURLToPath, URL } from "node:url";
+import { enterRuntimePhase } from "./runtime-privileges.mjs";
+import { boundedRuntimeMs } from "./resource-bounds.mjs";
+
+const computerd = "/opt/fungi/computerd.cjs";
+const terminalPort = Number(process.env.COMPUTER_TERMINAL_PORT ?? "7681");
+// computerd (cordyceps) drops its own privileges in-process, so it needs this
+// module by path, not by name: it never names a sibling package. This
+// supervisor is its only supplier, since it is the one process that knows
+// where the container placed the privilege boundary.
+const runtimePrivilegeModule = fileURLToPath(
+  new URL("./runtime-privileges.mjs", import.meta.url),
+);
+
+function log(message, fields) {
+  process.stderr.write(
+    `${JSON.stringify({ component: "computer-init", message, ...fields })}\n`,
+  );
+}
+
+let terminal;
+const daemon = spawn(process.execPath, [computerd], {
+  stdio: ["ignore", "inherit", "inherit", "ipc"],
+  env: {
+    ...process.env,
+    COMPUTER_RUNTIME_PRIVILEGE_MODULE: runtimePrivilegeModule,
+  },
+});
+let stopping = false;
+const maximumRuntimeMs = boundedRuntimeMs(process.env.COMPUTER_MAX_RUNTIME_MS);
+setTimeout(() => {
+  log("runtime deadline reached", { maximumRuntimeMs });
+  stopping = true;
+  terminal?.kill("SIGTERM");
+  daemon.kill("SIGTERM");
+  setTimeout(() => process.exit(0), 5_000).unref();
+}, maximumRuntimeMs).unref();
+
+daemon.once("exit", (code, signal) => {
+  log("computerd exited", { code, signal, stopping });
+  terminal?.kill("SIGTERM");
+  // An unrequested exit is a failure even when computerd reports 0.
+  process.exit(stopping ? (code ?? 0) : 1);
+});
+daemon.once("error", (error) => {
+  log("computerd failed to start", { error: error.message });
+  terminal?.kill("SIGTERM");
+  process.exit(1);
+});
+
+try {
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error("Computer mount phase timed out")),
+      15_000,
+    );
+    const failed = () => {
+      clearTimeout(timer);
+      reject(new Error("Computer exited during its mount phase"));
+    };
+    daemon.once("exit", failed);
+    daemon.once("error", failed);
+    daemon.once("message", (message) => {
+      clearTimeout(timer);
+      daemon.off("exit", failed);
+      daemon.off("error", failed);
+      if (message?.type !== "runtime-unprivileged") {
+        reject(new Error("Unexpected Computer mount result"));
+        return;
+      }
+      daemon.disconnect();
+      resolve();
+    });
+  });
+  enterRuntimePhase();
+  // exec the terminal runtime with the permanent UID/GID and no-new-privs
+  // inherited. The mount daemon retains its live FUSE descriptor and VFS state.
+  terminal = spawn(process.execPath, ["/opt/fungi/terminal-runtime.mjs"], {
+    stdio: ["ignore", "inherit", "inherit", "ipc"],
+    env: process.env,
+  });
+  terminal.once("exit", () => {
+    daemon.kill("SIGTERM");
+    process.exit(stopping ? 0 : 1);
+  });
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error("Terminal startup timed out")),
+      15_000,
+    );
+    terminal.once("error", reject);
+    terminal.once("message", (message) => {
+      clearTimeout(timer);
+      if (message?.type !== "terminal-ready")
+        return reject(new Error("Unexpected Terminal startup result"));
+      terminal.disconnect();
+      resolve();
+    });
+  });
+  log("terminal listening", { port: terminalPort });
+} catch (error) {
+  daemon.kill("SIGTERM");
+  throw new Error("Computer terminal failed to listen", { cause: error });
+}
+
+for (const signal of ["SIGTERM", "SIGINT"]) {
+  process.on(signal, () => {
+    stopping = true;
+    terminal?.kill("SIGTERM");
+    daemon.kill(signal);
+  });
+}

package/container/computer-start.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# A distinct real UID makes RLIMIT_NPROC independent even when local Docker
+# containers share one kernel. The hard limit survives into shells and their
+# children; an unprivileged Computer cannot raise it again.
+uid_file=/opt/fungi/.computer-uid
+if [[ -f "$uid_file" ]]; then
+  uid=$(<"$uid_file")
+else
+  uid=$((100000 + $(od -An -N4 -tu4 /dev/urandom) % 2000000000))
+  printf '%s\n' "$uid" >"$uid_file"
+fi
+if ! getent passwd "$uid" >/dev/null; then
+  useradd --no-log-init --uid "$uid" --user-group --no-create-home --home-dir /workspace --shell /bin/bash fungi
+fi
+export COMPUTER_RUNTIME_UID="$uid"
+pids_max=$(node --input-type=module -e 'import { computerResourceBounds } from "/opt/fungi/resource-bounds.mjs"; process.stdout.write(String(computerResourceBounds.pidsMax))')
+mkdir -p /workspace
+chown "$uid:$uid" /workspace
+ulimit -Su "$pids_max"
+ulimit -Hu "$pids_max"
+export HOME=/workspace
+exec node /opt/fungi/computer-init.mjs

package/container/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@fungi.computer/computer-container",
+  "version": "0.0.0",
+  "private": true,
+  "description": "In-container supervisor and terminal server for one Fungi Computer image",
+  "type": "module",
+  "dependencies": {
+    "node-pty": "1.1.0",
+    "ws": "8.21.3",
+    "fuse-native": "2.2.6",
+    "esbuild": "0.28.2"
+  },
+  "license": "MIT"
+}