@phpsandbox/sdk 0.1.1 → 0.1.4

package/dist/browser/phpsandbox-sdk.iife.js

@@ -29,7 +29,7 @@ var PHPSandbox = (() => {
   var index_exports = {};
   __export(index_exports, {
     ApiError: () => ApiError,
-    Client: () => Client2,
+    Client: () => Client,
     CommandError: () => CommandError,
     ComposerCredentials: () => ComposerCredentials,
     ErrorEvent: () => ErrorEvent,
@@ -43,7 +43,7 @@ var PHPSandbox = (() => {
     NotebookApi: () => NotebookApi,
     NotebookComposerCredentialApi: () => NotebookComposerCredentialApi,
     NotebookInitError: () => NotebookInitError,
-    NotebookInstance: () => NotebookInstance2,
+    NotebookInstance: () => NotebookInstance,
     NotebookMail: () => NotebookMail,
     NotebookMailApi: () => NotebookMailApi,
     NotebookPreview: () => NotebookPreview,
@@ -55,6 +55,7 @@ var PHPSandbox = (() => {
     NotebookUnavailableError: () => NotebookUnavailableError,
     PHPSandbox: () => PHPSandbox,
     PHPSandboxError: () => PHPSandboxError,
+    ProcessReadable: () => ProcessReadable,
     ProcessResult: () => ProcessResult,
     PromiseTimeoutError: () => PromiseTimeoutError,
     PublicationApi: () => PublicationApi,
@@ -89,6 +90,7 @@ var PHPSandbox = (() => {
     PublishStreamSsePhaseEventSchema: () => PublishStreamSsePhaseEventSchema,
     PublishStreamSseResultEventSchema: () => PublishStreamSseResultEventSchema,
     RateLimitError: () => RateLimitError,
+    RuntimeTelemetry: () => RuntimeTelemetry,
     SendTimeoutError: () => SendTimeoutError,
     ServerApi: () => ServerApi,
     ServerInstance: () => ServerInstance,
@@ -97,9 +99,36 @@ var PHPSandbox = (() => {
     notebookBuiltinServices: () => notebookBuiltinServices,
     notebookKnownServices: () => notebookKnownServices,
     once: () => once,
-    timeout: () => timeout
+    timeout: () => timeout,
+    watchRuntimeTelemetry: () => watchRuntimeTelemetry
   });
 
+  // src/errors/index.ts
+  var PromiseTimeoutError = class extends Error {
+    constructor(message, time3) {
+      super(message);
+      this.time = time3;
+    }
+  };
+  var SendTimeoutError = class _SendTimeoutError extends PromiseTimeoutError {
+    static fromPromiseTimeoutError(error51) {
+      return new _SendTimeoutError(error51.message, error51.time);
+    }
+  };
+  var NotebookUnavailableError = class extends Error {
+    constructor(message = "Notebook is no longer available", raw = {}) {
+      super(message);
+      this.raw = raw;
+      this.name = "NotebookUnavailableError";
+    }
+  };
+  var UnsupportedRuntimeTransportError = class extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "UnsupportedRuntimeTransportError";
+    }
+  };
+
   // src/types.ts
   var ErrorEvent = class extends Error {
     constructor(code, message, raw = {}) {
@@ -197,29 +226,194 @@ var PHPSandbox = (() => {
         }
       });
     }
-    info(path) {
-      return this.okra.invoke("fs.info", { path });
+    async write(path, contents, options = {}) {
+      const resolvedOptions = {
+        overwrite: true,
+        create: true,
+        unlock: false,
+        atomic: false,
+        ...options
+      };
+      const source = typeof contents === "string" ? new TextEncoder().encode(contents) : contents;
+      if (this.okra.runtimeTransport === "rest") {
+        const bytes = source instanceof Uint8Array ? source : await collectBytes(source);
+        await this.okra.invoke("fs.writeFile", {
+          path,
+          contents: bytes,
+          options: resolvedOptions
+        }).catch((error51) => this.handleError(error51));
+        return;
+      }
+      const id = nanoid();
+      const completion = this.okra.invoke("fs.writeStream", { id, path, options: resolvedOptions });
+      void completion.catch(() => {
+      });
+      try {
+        for await (const chunk of toAsyncIterable(source)) {
+          const written = await this.okra.invoke("fs.writeChunk", { id, contents: chunk });
+          if (!written) {
+            throw new Error(`File write stream ${id} is not available`);
+          }
+        }
+        const ended = await this.okra.invoke("fs.endWrite", { id });
+        if (!ended) {
+          throw new Error(`File write stream ${id} could not be completed`);
+        }
+        await completion;
+      } catch (error51) {
+        await this.okra.invoke("fs.abortWrite", { id }).catch(() => false);
+        await completion.catch(() => false);
+        throw error51;
+      }
     }
-    async write(path, contents, options = { overwrite: true, create: true, unlock: false, atomic: false }) {
-      if (typeof contents === "string") {
-        return this.okra.invoke("fs.write", { path, contents });
+    async read(path) {
+      try {
+        const content = await this.okra.invoke("fs.readFile", { path });
+        return content instanceof Uint8Array ? content : new TextEncoder().encode(content);
+      } catch (error51) {
+        this.handleError(error51);
+      }
+    }
+    async readText(path) {
+      return new TextDecoder().decode(await this.read(path));
+    }
+    async readLines(path, range) {
+      try {
+        const result = await this.okra.invoke("fs.readFile", {
+          path,
+          lineRange: {
+            lineStart: range.start,
+            lineEnd: range.end
+          }
+        });
+        if (typeof result === "string" || result instanceof Uint8Array) {
+          throw new Error(`Unexpected ranged file response for ${path}`);
+        }
+        return {
+          start: result.lineStart,
+          end: result.lineEnd,
+          content: result.content,
+          ...result.error === null ? {} : { warning: result.error }
+        };
+      } catch (error51) {
+        this.handleError(error51);
       }
-      const bytes = contents instanceof Uint8Array ? contents : await collectBytes(contents);
-      await this.writeFile(path, bytes, options);
-      return true;
     }
-    read(path) {
+    readStream(path) {
+      if (this.okra.runtimeTransport === "rest") {
+        return new ReadableStream({
+          start: async (controller) => {
+            try {
+              controller.enqueue(await this.read(path));
+              controller.close();
+            } catch (error51) {
+              controller.error(error51);
+            }
+          }
+        });
+      }
+      const id = nanoid();
+      let disposable = null;
+      let closed = false;
       return new ReadableStream({
-        start: async (controller) => {
-          try {
-            controller.enqueue(await this.readFile(path));
-            controller.close();
-          } catch (error51) {
-            controller.error(error51);
+        start: (controller) => {
+          disposable = this.okra.listen(`fs.read.${id}`, (event) => {
+            controller.enqueue(event.data);
+          });
+          void this.okra.invoke("fs.readStream", { id, path }).then(() => {
+            if (!closed) {
+              closed = true;
+              disposable?.dispose();
+              controller.close();
+            }
+          }).catch((error51) => {
+            if (!closed) {
+              closed = true;
+              disposable?.dispose();
+              controller.error(error51);
+            }
+          });
+        },
+        cancel: async () => {
+          if (!closed) {
+            closed = true;
+            disposable?.dispose();
+            await this.okra.invoke("fs.cancelRead", { id }).catch(() => false);
           }
         }
       });
     }
+    follow(path, options = {}) {
+      if (this.okra.runtimeTransport === "rest") {
+        return new ReadableStream({
+          start(controller) {
+            controller.error(new UnsupportedRuntimeTransportError("Following files requires the realtime transport."));
+          }
+        });
+      }
+      const id = nanoid();
+      let disposable = null;
+      let abort = null;
+      let started = false;
+      let closed = false;
+      const stop = async () => {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        disposable?.dispose();
+        disposable = null;
+        if (abort && options.signal) {
+          options.signal.removeEventListener("abort", abort);
+        }
+        abort = null;
+        if (started) {
+          await this.okra.invoke("fs.cancelFollow", { id }).catch(() => false);
+        }
+      };
+      return new ReadableStream({
+        start: (controller) => {
+          disposable = this.okra.listen(`fs.follow.${id}`, (event) => {
+            if (!closed) {
+              controller.enqueue(event.data);
+            }
+          });
+          if (options.signal) {
+            abort = () => {
+              void stop().finally(() => controller.error(options.signal?.reason ?? new Error("Aborted")));
+            };
+            if (options.signal.aborted) {
+              abort();
+              return;
+            }
+            options.signal.addEventListener("abort", abort, { once: true });
+          }
+          started = true;
+          void this.okra.invoke("fs.follow", { id, path, lines: options.lines ?? 10 }).then(() => {
+            if (!closed) {
+              closed = true;
+              disposable?.dispose();
+              if (abort && options.signal) {
+                options.signal.removeEventListener("abort", abort);
+              }
+              abort = null;
+              controller.close();
+            }
+          }).catch((error51) => {
+            if (!closed) {
+              closed = true;
+              disposable?.dispose();
+              if (abort && options.signal) {
+                options.signal.removeEventListener("abort", abort);
+              }
+              abort = null;
+              controller.error(error51);
+            }
+          });
+        },
+        cancel: stop
+      });
+    }
     find(query, options = {
       useIgnoreFiles: false,
       followSymlinks: false,
@@ -297,53 +491,38 @@ var PHPSandbox = (() => {
       const disposable = this.okra.listen(`fs.text.search.${sid}`, localOnMatch);
       return this.okra.invoke("fs.textSearch", { query, options: { ...defaultOptions, ...options } }).finally(() => disposable.dispose());
     }
-    mkdir(path) {
-      return this.okra.invoke("fs.mkdir", { path });
-    }
-    move(from, to) {
-      return this.okra.invoke("fs.move", { from, to });
-    }
-    remove(path, type) {
-      return this.okra.invoke("fs.remove", { path, type });
-    }
-    async readFile(path, lineRange) {
-      try {
-        const content = await this.okra.invoke("fs.readFile", { path, lineRange });
-        if (content instanceof Uint8Array) {
-          return content;
-        }
-        if (typeof content === "string") {
-          return new TextEncoder().encode(content);
-        }
-        return content;
-      } catch (e) {
-        this.handleError(e);
-      }
-    }
-    tail(path, lines = 10) {
-      return this.okra.invoke("fs.tail", { path, lines }).catch((e) => this.handleError(e));
-    }
-    writeFile(path, contents, options) {
-      return this.okra.invoke("fs.writeFile", {
-        path,
-        contents,
-        options
-      }).catch((e) => this.handleError(e));
+    tail(path, options = {}) {
+      return this.okra.invoke("fs.tail", { path, lines: options.lines ?? 10 }).catch((e) => this.handleError(e));
     }
     stat(path) {
       return this.okra.invoke("fs.stat", { path }).catch((e) => this.handleError(e));
     }
-    rename(from, to, options) {
-      return this.okra.invoke("fs.rename", { from, to, options }).catch((e) => this.handleError(e));
+    move(from, to, options = {}) {
+      return this.okra.invoke("fs.rename", {
+        from,
+        to,
+        options: { overwrite: false, ...options }
+      }).catch((e) => this.handleError(e));
     }
-    delete(path, options) {
-      return this.okra.invoke("fs.delete", { path, options }).catch((e) => this.handleError(e));
+    remove(path, options = {}) {
+      return this.okra.invoke("fs.delete", {
+        path,
+        options: { recursive: false, useTrash: false, atomic: false, ...options }
+      }).catch((e) => this.handleError(e));
     }
-    copy(source, destination, options) {
-      return this.okra.invoke("fs.copy", { source, destination, options }).catch((e) => this.handleError(e));
+    copy(source, destination, options = {}) {
+      return this.okra.invoke("fs.copy", {
+        source,
+        destination,
+        options: { overwrite: false, ...options }
+      }).catch((e) => this.handleError(e));
     }
-    readDirectory(path, include = [], exclude = []) {
-      return this.okra.invoke("fs.readDirectory", { path, include, exclude }).catch((e) => this.handleError(e));
+    list(path, options = {}) {
+      return this.okra.invoke("fs.readDirectory", {
+        path,
+        include: options.include ?? [],
+        exclude: options.exclude ?? []
+      }).catch((e) => this.handleError(e));
     }
     createDirectory(path) {
       return this.okra.invoke("fs.createDirectory", { path }).catch((e) => this.handleError(e));
@@ -372,17 +551,17 @@ var PHPSandbox = (() => {
     exists(path) {
       return this.stat(path).then(() => true).catch(() => false);
     }
-    async download(chunk, exclude, include) {
+    async download(options = {}) {
       const id = nanoid();
-      const stream = !!chunk;
+      const stream = !!options.onChunk;
       const chunks = [];
       const disposable = this.okra.listen(
         `fs.download.${id}`,
-        stream ? chunk : (data) => {
+        stream ? options.onChunk : (data) => {
           chunks.push(data);
         }
       );
-      return this.okra.invoke("fs.download", { id, exclude, include }).then(() => new Blob(chunks, { type: "application/octet-stream" })).finally(() => disposable.dispose());
+      return this.okra.invoke("fs.download", { id, exclude: options.exclude, include: options.include }).then(() => new Blob(chunks, { type: "application/octet-stream" })).finally(() => disposable.dispose());
     }
     tree(path = "/") {
       return this.okra.invoke("fs.tree", { path });
@@ -394,6 +573,13 @@ var PHPSandbox = (() => {
       throw e;
     }
   };
+  async function* toAsyncIterable(contents) {
+    if (contents instanceof Uint8Array) {
+      yield contents;
+      return;
+    }
+    yield* contents;
+  }
   async function collectBytes(stream) {
     const chunks = [];
     let length = 0;
@@ -410,32 +596,6 @@ var PHPSandbox = (() => {
     return output;
   }
 
-  // src/errors/index.ts
-  var PromiseTimeoutError = class extends Error {
-    constructor(message, time3) {
-      super(message);
-      this.time = time3;
-    }
-  };
-  var SendTimeoutError = class _SendTimeoutError extends PromiseTimeoutError {
-    static fromPromiseTimeoutError(error51) {
-      return new _SendTimeoutError(error51.message, error51.time);
-    }
-  };
-  var NotebookUnavailableError = class extends Error {
-    constructor(message = "Notebook is no longer available", raw = {}) {
-      super(message);
-      this.raw = raw;
-      this.name = "NotebookUnavailableError";
-    }
-  };
-  var UnsupportedRuntimeTransportError = class extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "UnsupportedRuntimeTransportError";
-    }
-  };
-
   // src/utils/promise.ts
   var timeout = (prom, time3) => {
     let timer;
@@ -454,30 +614,35 @@ var PHPSandbox = (() => {
   // src/terminal.ts
   var TERMINAL_INPUT_FLUSH_DELAY_MS = 8;
   var terminalInputFlushPattern = /[\x00-\x1f\x7f]/;
-  var Terminal = class {
+  var Terminals = class {
     constructor(okra) {
       this.okra = okra;
     }
     list() {
       return this.okra.invoke("terminal.list");
     }
-    create(input) {
-      return this.okra.invoke("terminal.create", input);
-    }
-    onStarted(handler) {
-      return this.okra.listen("terminal.started", handler);
-    }
-    resize(id, size) {
-      return this.okra.invoke("terminal.resize", { id, width: size[0], height: size[1] });
-    }
-    onOutput(id, handler) {
-      return this.okra.listen(`terminal.output.${id}`, handler);
-    }
-    input(id, input) {
-      return Promise.resolve(this.okra.send("terminal.input", { id, input }));
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
+    async create(options = {}) {
+      const id = options.id ?? nanoid();
+      const handle = this.processHandle(id, options.abortSignal);
+      const command = typeof options.command === "string" && options.args?.length ? [options.command, ...options.args] : options.command;
+      const { abortSignal, args: _args, ...input } = options;
+      try {
+        const task = await this.okra.invoke(
+          "terminal.create",
+          {
+            ...input,
+            id,
+            kind: options.kind ?? "bash",
+            size: options.size ?? [80, 24],
+            command
+          },
+          { abortSignal }
+        );
+        return { ...handle.process, ...task };
+      } catch (error51) {
+        handle.dispose();
+        throw error51;
+      }
     }
     async attach(id, opts) {
       const handle = this.processHandle(id, opts?.abortSignal);
@@ -503,31 +668,6 @@ var PHPSandbox = (() => {
         throw error51;
       }
     }
-    async spawn(command, args, opts) {
-      const id = opts?.id || nanoid();
-      const handle = this.processHandle(id, opts?.abortSignal);
-      const { abortSignal, ...otherOpts } = opts ?? {};
-      try {
-        const result = await this.okra.invoke(
-          "terminal.spawn",
-          {
-            command: [command, ...args],
-            opts: {
-              id,
-              ...otherOpts
-            }
-          },
-          { abortSignal }
-        );
-        return {
-          ...handle.process,
-          ...result
-        };
-      } catch (error51) {
-        handle.dispose();
-        throw error51;
-      }
-    }
     processHandle(id, abortSignal) {
       const disposables = /* @__PURE__ */ new Set();
       let abortHandler;
@@ -553,7 +693,7 @@ var PHPSandbox = (() => {
         }
         const input2 = pendingInput;
         pendingInput = "";
-        void this.input(id, input2);
+        void this.okra.send("terminal.input", { id, input: input2 });
       };
       const scheduleInputFlush = () => {
         if (inputFlushTimer) {
@@ -561,7 +701,8 @@ var PHPSandbox = (() => {
         }
         inputFlushTimer = setTimeout(flushInput, TERMINAL_INPUT_FLUSH_DELAY_MS);
       };
-      const queueInput = (chunk) => {
+      const queueInput = (value) => {
+        const chunk = typeof value === "string" ? value : new TextDecoder().decode(value);
         pendingInput += chunk;
         if (terminalInputFlushPattern.test(chunk)) {
           flushInput();
@@ -583,7 +724,7 @@ var PHPSandbox = (() => {
         start: (_controller) => {
           controller = _controller;
           disposables.add(
-            this.listen(`terminal.output.${id}`, (data) => {
+            this.okra.listen(`terminal.output.${id}`, (data) => {
               controller?.enqueue(data.output);
             })
           );
@@ -595,7 +736,7 @@ var PHPSandbox = (() => {
       });
       const completion = new Promise((resolve) => {
         disposables.add(
-          this.listen(`terminal.close.${id}`, (data) => {
+          this.okra.listen(`terminal.close.${id}`, (data) => {
             if (controller) {
               try {
                 controller.close();
@@ -660,37 +801,9 @@ var PHPSandbox = (() => {
     state() {
       return this.okra.invoke("container.state");
     }
-    openedPorts() {
-      return this.okra.invoke("container.opened-ports");
-    }
     setPhp(version2) {
       return this.okra.invoke("container.set-php", { version: version2 });
     }
-    enableTelemetry(features) {
-      return this.okra.invoke("container.stream-telemetry", { features: Array.from(features) });
-    }
-    stopTelemetry() {
-      return this.okra.invoke("container.stop-telemetry");
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
-    }
-    onPort(handler) {
-      let ports = [];
-      return this.listen("container.ports", (newPorts) => {
-        for (const port of newPorts) {
-          if (!ports.some((p) => p.port === port.port)) {
-            handler(port, "open");
-          }
-        }
-        for (const port of ports) {
-          if (!newPorts.some((p) => p.port === port.port)) {
-            handler(port, "close");
-          }
-        }
-        ports = newPorts;
-      });
-    }
   };
 
   // src/auth.ts
@@ -777,76 +890,6 @@ var PHPSandbox = (() => {
     }
   };
 
-  // src/composer.ts
-  var Composer = class {
-    constructor(okra, client) {
-      this.okra = okra;
-      this.credentials = new ComposerCredentials(client, okra.data.id);
-    }
-    invoke(command, args = {}, options = {}) {
-      return this.okra.invoke("composer.invoke", { command, args, options });
-    }
-    dumpAutoload() {
-      return this.okra.invoke("composer.dump-autoload");
-    }
-    install(options = {}) {
-      return this.invoke("install", {}, options);
-    }
-    update(args, options = {}) {
-      return this.invoke("update", args, options);
-    }
-    require(packages, options = {}) {
-      return this.invoke("require", packages, options);
-    }
-    remove(args, options = {}) {
-      return this.invoke("remove", args, options);
-    }
-    stream(fn) {
-      return this.okra.listen("composer.log", fn);
-    }
-    packages() {
-      return this.okra.invoke("composer.packages");
-    }
-  };
-
-  // src/log.ts
-  var Log = class {
-    constructor(okra) {
-      this.okra = okra;
-    }
-    stream(fn) {
-      return this.okra.listen("notebook.log", fn);
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
-    }
-  };
-
-  // src/repl.ts
-  var Repl = class {
-    constructor(okra) {
-      this.okra = okra;
-    }
-    eval(code, args = "", repl = { prependWith: "", appendWith: "" }) {
-      return this.okra.invoke("repl.eval", { code, args, repl });
-    }
-    write(input) {
-      return this.okra.invoke("repl.write", { input });
-    }
-    stop() {
-      return this.okra.invoke("repl.stop");
-    }
-    resize(cols, rows) {
-      return this.okra.invoke("repl.resize", { cols, rows });
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
-    }
-    onOutput(handler) {
-      return this.okra.listen("repl.output", handler);
-    }
-  };
-
   // src/shell.ts
   function resolveRunInput(command, argsOrOpts = [], opts) {
     const args = Array.isArray(argsOrOpts) ? argsOrOpts : [];
@@ -876,7 +919,7 @@ var PHPSandbox = (() => {
       return this;
     }
   };
-  var OutputStream = class {
+  var ProcessReadable = class {
     constructor() {
       this.controller = null;
       this.closed = false;
@@ -916,9 +959,9 @@ var PHPSandbox = (() => {
     constructor(id, okra, command, opts) {
       this.id = id;
       this.okra = okra;
-      const output = new OutputStream();
-      const stdout = new OutputStream();
-      const stderr = new OutputStream();
+      const output = new ProcessReadable();
+      const stdout = new ProcessReadable();
+      const stderr = new ProcessReadable();
       this.output = output.stream;
       this.stdout = stdout.stream;
       this.stderr = stderr.stream;
@@ -987,6 +1030,264 @@ var PHPSandbox = (() => {
     }
   };
 
+  // src/composer.ts
+  var ComposerProcess = class {
+    constructor(id, okra, command, args, options) {
+      this.id = id;
+      this.okra = okra;
+      const output = new ProcessReadable();
+      const stdout = new ProcessReadable();
+      const stderr = new ProcessReadable();
+      this.output = output.stream;
+      this.stdout = stdout.stream;
+      this.stderr = stderr.stream;
+      const encoder = new TextEncoder();
+      let subscription = this.okra.listen(`composer.output.${this.id}`, (event) => {
+        const data = encoder.encode(event.output);
+        const source = event.source ?? "output";
+        output.enqueue({ source, data });
+        if (source === "stderr") {
+          stderr.enqueue(data);
+        } else {
+          stdout.enqueue(data);
+        }
+      });
+      const finish = () => {
+        subscription?.dispose();
+        subscription = null;
+        output.close();
+        stdout.close();
+        stderr.close();
+      };
+      const fail = (error51) => {
+        subscription?.dispose();
+        subscription = null;
+        output.fail(error51);
+        stdout.fail(error51);
+        stderr.fail(error51);
+      };
+      this.completion = this.okra.invoke("composer.invoke", { id, command, args, options }).then((result) => {
+        finish();
+        return new ProcessResult(result.output, result.stdout, result.stderr, result.exitCode);
+      }).catch((error51) => {
+        fail(error51);
+        throw error51;
+      });
+    }
+    wait() {
+      return this.completion;
+    }
+    async kill() {
+      await this.okra.invoke("composer.kill", { id: this.id });
+    }
+  };
+  var Composer = class {
+    constructor(okra, client) {
+      this.okra = okra;
+      this.credentials = new ComposerCredentials(client, okra.data.id);
+    }
+    run(command, args = {}, options = {}) {
+      return new ComposerProcess(nanoid(), this.okra, command, args, options);
+    }
+    dumpAutoload(options = {}) {
+      return this.run("dump-autoload", {}, options);
+    }
+    install(options = {}) {
+      return this.run("install", {}, options);
+    }
+    update(args, options = {}) {
+      return this.run("update", args, options);
+    }
+    require(packages, options = {}) {
+      return this.run("require", packages, options);
+    }
+    remove(args, options = {}) {
+      return this.run("remove", args, options);
+    }
+    packages() {
+      return this.okra.invoke("composer.packages");
+    }
+  };
+
+  // src/runtime-telemetry.ts
+  var RuntimeTelemetry = class {
+    constructor(okra) {
+      this.okra = okra;
+      this.references = /* @__PURE__ */ new Map();
+      this.synchronization = Promise.resolve();
+      if (okra.runtimeTransport === "realtime") {
+        okra.onDidConnect(() => {
+          if (this.references.size > 0) {
+            void this.synchronize();
+          }
+        });
+      }
+    }
+    async acquire(feature) {
+      this.references.set(feature, (this.references.get(feature) ?? 0) + 1);
+      try {
+        await this.synchronize();
+      } catch (error51) {
+        this.removeReference(feature);
+        throw error51;
+      }
+      let released = false;
+      return async () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        this.removeReference(feature);
+        await this.synchronize();
+      };
+    }
+    removeReference(feature) {
+      const references = this.references.get(feature) ?? 0;
+      if (references <= 1) {
+        this.references.delete(feature);
+      } else {
+        this.references.set(feature, references - 1);
+      }
+    }
+    synchronize() {
+      this.synchronization = this.synchronization.catch(() => {
+      }).then(async () => {
+        const features = Array.from(this.references.keys());
+        if (features.length === 0) {
+          await this.okra.invoke("container.stop-telemetry");
+        } else {
+          await this.okra.invoke("container.stream-telemetry", { features });
+        }
+      });
+      return this.synchronization;
+    }
+  };
+  function watchRuntimeTelemetry(okra, telemetry, feature, event, transform2, options = {}) {
+    let subscription = null;
+    let release = null;
+    let closed = false;
+    let abort = null;
+    const stop = async () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      subscription?.dispose();
+      subscription = null;
+      if (abort && options.signal) {
+        options.signal.removeEventListener("abort", abort);
+      }
+      abort = null;
+      await release?.();
+      release = null;
+    };
+    return new ReadableStream({
+      start(controller) {
+        subscription = okra.listen(event, (data) => {
+          if (!closed) {
+            controller.enqueue(transform2(data));
+          }
+        });
+        if (options.signal) {
+          abort = () => {
+            void stop().finally(() => controller.error(options.signal?.reason ?? new Error("Aborted")));
+          };
+          if (options.signal.aborted) {
+            abort();
+            return;
+          }
+          options.signal.addEventListener("abort", abort, { once: true });
+        }
+        void telemetry.acquire(feature).then(async (releaseTelemetry) => {
+          if (closed) {
+            await releaseTelemetry();
+            return;
+          }
+          release = releaseTelemetry;
+        }).catch((error51) => {
+          if (!closed) {
+            closed = true;
+            subscription?.dispose();
+            if (abort && options.signal) {
+              options.signal.removeEventListener("abort", abort);
+            }
+            abort = null;
+            controller.error(error51);
+          }
+        });
+      },
+      cancel: stop
+    });
+  }
+
+  // src/log.ts
+  var Logs = class {
+    constructor(okra, telemetry) {
+      this.okra = okra;
+      this.telemetry = telemetry;
+    }
+    follow(options = {}) {
+      return watchRuntimeTelemetry(this.okra, this.telemetry, "logs", "notebook.log", (message) => ({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "runtime",
+        message
+      }), options);
+    }
+  };
+
+  // src/metrics.ts
+  var Metrics = class {
+    constructor(okra, telemetry) {
+      this.okra = okra;
+      this.telemetry = telemetry;
+    }
+    current() {
+      return this.okra.invoke("container.stats");
+    }
+    watch(options = {}) {
+      return watchRuntimeTelemetry(this.okra, this.telemetry, "stats", "container.stats", (stats) => stats, options);
+    }
+  };
+
+  // src/ports.ts
+  var Ports = class {
+    constructor(okra, telemetry) {
+      this.okra = okra;
+      this.telemetry = telemetry;
+    }
+    list() {
+      return this.okra.invoke("container.opened-ports");
+    }
+    watch(options = {}) {
+      return watchRuntimeTelemetry(this.okra, this.telemetry, "ports", "container.ports", (ports) => ports, options);
+    }
+  };
+
+  // src/repl.ts
+  var Repl = class {
+    constructor(okra) {
+      this.okra = okra;
+    }
+    eval(code, args = "", repl = { prependWith: "", appendWith: "" }) {
+      return this.okra.invoke("repl.eval", { code, args, repl });
+    }
+    write(input) {
+      return this.okra.invoke("repl.write", { input });
+    }
+    stop() {
+      return this.okra.invoke("repl.stop");
+    }
+    resize(cols, rows) {
+      return this.okra.invoke("repl.resize", { cols, rows });
+    }
+    listen(event, handler) {
+      return this.okra.listen(event, handler);
+    }
+    onOutput(handler) {
+      return this.okra.listen("repl.output", handler);
+    }
+  };
+
   // src/services.ts
   var notebookBuiltinServices = ["redis"];
   var notebookKnownServices = ["start", "nginx", ...notebookBuiltinServices];
@@ -1006,12 +1307,6 @@ var PHPSandbox = (() => {
     stop(name) {
       return this.okra.invoke("service.stop", { name });
     }
-    onLog(id, handler) {
-      return this.okra.listen(`service.log.${id}`, handler);
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
-    }
     logs(name, options = {}) {
       if (options.follow) {
         return this.followLogs(name, options);
@@ -1064,11 +1359,11 @@ var PHPSandbox = (() => {
         close();
         return this.okra.invoke("service.stop-logs", { id });
       });
-      const output = new ReadableStream({
+      return new ReadableStream({
         start: (_controller) => {
           controller = _controller;
           disposables.add(
-            this.onLog(id, (data) => {
+            this.okra.listen(`service.log.${id}`, (data) => {
               controller?.enqueue(data.output);
             })
           );
@@ -1082,10 +1377,9 @@ var PHPSandbox = (() => {
           });
         },
         cancel: () => {
-          void stop();
+          return stop().then(() => void 0);
         }
       });
-      return { id, output, stop };
     }
   };
 
@@ -19213,6 +19507,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "container.stop": { method: "POST", path: "/runtime/container/stop" },
     "container.set-php": { method: "PUT", path: "/runtime/container/php" },
     "container.opened-ports": { method: "GET", path: "/runtime/container/ports" },
+    "container.stats": { method: "GET", path: "/runtime/container/stats" },
     "terminal.list": { method: "GET", path: "/runtime/terminals" },
     "shell.exec": { method: "POST", path: "/runtime/executions" },
     "fs.info": { method: "POST", path: "/runtime/files/info" },
@@ -19238,10 +19533,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "service.logs": { method: "POST", path: "/runtime/services/logs" },
     "composer.invoke": { method: "POST", path: "/runtime/composer/executions" },
     "composer.packages": { method: "GET", path: "/runtime/composer/packages" },
-    "composer.dump-autoload": {
-      method: "POST",
-      path: "/runtime/composer/autoload"
-    },
     "git.checkpoint": { method: "POST", path: "/runtime/git/checkpoints" },
     "git.checkout": { method: "POST", path: "/runtime/git/checkouts" },
     "git.log": { method: "POST", path: "/runtime/git/log" },
@@ -19485,7 +19776,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     async create(template, input = {}, init = true) {
       const response = await this.client.post("/notebook", { template, ...input });
-      const instance = new NotebookInstance2(response.data, this.client);
+      const instance = new NotebookInstance(response.data, this.client);
       if (!init) {
         return instance;
       }
@@ -19493,25 +19784,25 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     async get(id) {
       const response = await this.client.get(`/notebook/${id}`);
-      return new NotebookInstance2(response.data, this.client);
+      return new NotebookInstance(response.data, this.client);
     }
     async update(id, input = {}) {
       const response = await this.client.put(`/notebook/${id}`, input);
-      return new NotebookInstance2(response.data, this.client);
+      return new NotebookInstance(response.data, this.client);
     }
     async destroy(id) {
       await this.client.delete(`/notebook/${id}`);
     }
     async fork(id, input = {}) {
       const response = await this.client.post(`/notebook/${id}/fork`, input);
-      return new NotebookInstance2(response.data, this.client);
+      return new NotebookInstance(response.data, this.client);
     }
     async gitCredentials(id) {
       const response = await this.client.post(`/notebook/${id}/git/credentials`);
       return response.data;
     }
     openFromData(data) {
-      return this.init(new NotebookInstance2(data, this.client));
+      return this.init(new NotebookInstance(data, this.client));
     }
     async init(instance) {
       await instance.ready();
@@ -19526,7 +19817,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     baseUrl.hash = "";
     return baseUrl.toString();
   }
-  var Client2 = class {
+  var Client = class {
     constructor(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
       this.runtimeTransportValue = "realtime";
       this.fetch = globalThis.fetch;
@@ -19610,7 +19901,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return { data: body === "" ? void 0 : JSON.parse(body) };
     }
   };
-  var PHPSandbox = class _PHPSandbox extends Client2 {
+  var PHPSandbox = class _PHPSandbox extends Client {
     static realtime(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
       return new _PHPSandbox(token, url2, options);
     }
@@ -19718,7 +20009,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   };
   var _initPromise, _NotebookInstance_instances, init_fn;
-  var NotebookInstance2 = class {
+  var NotebookInstance = class {
     constructor(data, client) {
       this.data = data;
       this.client = client;
@@ -19753,15 +20044,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         this.watchConnection();
         __privateSet(this, _initPromise, __privateMethod(this, _NotebookInstance_instances, init_fn).call(this));
       }
-      this.file = new Filesystem(
+      this.files = new Filesystem(
         this,
         this.socket === null ? null : (handler) => this.onDidConnect(handler)
       );
-      this.terminal = new Terminal(this);
+      this.terminals = new Terminals(this);
       this.auth = new Auth(this);
       this.lsp = new Lsp(this);
       this.composer = new Composer(this, client);
-      this.log = new Log(this);
+      const telemetry = new RuntimeTelemetry(this);
+      this.logs = new Logs(this, telemetry);
+      this.metrics = new Metrics(this, telemetry);
+      this.ports = new Ports(this, telemetry);
       this.repl = new Repl(this);
       this.container = new Container(this);
       this.shell = new Shell(this);
@@ -19807,6 +20101,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return this.shell.run(command, argsOrOpts);
     }
+    exec(command, argsOrOpts = [], opts) {
+      if (Array.isArray(argsOrOpts)) {
+        return this.run(command, argsOrOpts, opts).wait();
+      }
+      return this.run(command, argsOrOpts).wait();
+    }
     gitCredentials() {
       return this.client.notebook.gitCredentials(this.data.id);
     }
@@ -19897,9 +20197,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const socket = this.realtimeSocket();
       socket.onDidConnect(() => {
         socket.emit("okra.connected");
-        if (this.client.options.telemetry) {
-          this.container.enableTelemetry(this.client.options.telemetry);
-        }
       });
       socket.onDidClose(() => {
         socket.emit("okra.disconnected");