@phpsandbox/sdk 0.1.1 → 0.1.4

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

@@ -12,6 +12,32 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
+// 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 = {}) {
@@ -109,29 +135,194 @@ var Filesystem = class {
       }
     });
   }
-  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,
@@ -209,53 +400,38 @@ var Filesystem = class {
     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));
@@ -284,17 +460,17 @@ var Filesystem = class {
   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 });
@@ -306,6 +482,13 @@ var Filesystem = class {
     throw e;
   }
 };
+async function* toAsyncIterable(contents) {
+  if (contents instanceof Uint8Array) {
+    yield contents;
+    return;
+  }
+  yield* contents;
+}
 async function collectBytes(stream) {
   const chunks = [];
   let length = 0;
@@ -322,32 +505,6 @@ async function collectBytes(stream) {
   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;
@@ -366,30 +523,35 @@ var once = (fn) => {
 // 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);
@@ -415,31 +577,6 @@ var Terminal = class {
       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;
@@ -465,7 +602,7 @@ var Terminal = class {
       }
       const input2 = pendingInput;
       pendingInput = "";
-      void this.input(id, input2);
+      void this.okra.send("terminal.input", { id, input: input2 });
     };
     const scheduleInputFlush = () => {
       if (inputFlushTimer) {
@@ -473,7 +610,8 @@ var Terminal = class {
       }
       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();
@@ -495,7 +633,7 @@ var Terminal = class {
       start: (_controller) => {
         controller = _controller;
         disposables.add(
-          this.listen(`terminal.output.${id}`, (data) => {
+          this.okra.listen(`terminal.output.${id}`, (data) => {
             controller?.enqueue(data.output);
           })
         );
@@ -507,7 +645,7 @@ var Terminal = class {
     });
     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();
@@ -572,37 +710,9 @@ var Container = class {
   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
@@ -689,76 +799,6 @@ var LspConnection = class _LspConnection {
   }
 };
 
-// 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 : [];
@@ -788,7 +828,7 @@ var ProcessResult = class {
     return this;
   }
 };
-var OutputStream = class {
+var ProcessReadable = class {
   constructor() {
     this.controller = null;
     this.closed = false;
@@ -828,9 +868,9 @@ var ShellProcess = class {
   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;
@@ -899,6 +939,264 @@ var Shell = class {
   }
 };
 
+// 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];
@@ -918,12 +1216,6 @@ var Services = class {
   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);
@@ -976,11 +1268,11 @@ var Services = class {
       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);
           })
         );
@@ -994,10 +1286,9 @@ var Services = class {
         });
       },
       cancel: () => {
-        void stop();
+        return stop().then(() => void 0);
       }
     });
-    return { id, output, stop };
   }
 };
 
@@ -19125,6 +19416,7 @@ var restActionRoutes = {
   "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" },
@@ -19150,10 +19442,6 @@ var restActionRoutes = {
   "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" },
@@ -19397,7 +19685,7 @@ var NotebookApi = class {
   }
   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;
     }
@@ -19405,25 +19693,25 @@ var NotebookApi = class {
   }
   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();
@@ -19438,7 +19726,7 @@ function normalizeApiBaseUrl(url2) {
   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;
@@ -19522,7 +19810,7 @@ var Client2 = class {
     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);
   }
@@ -19630,7 +19918,7 @@ var NotebookMailApi = class {
   }
 };
 var _initPromise, _NotebookInstance_instances, init_fn;
-var NotebookInstance2 = class {
+var NotebookInstance = class {
   constructor(data, client) {
     this.data = data;
     this.client = client;
@@ -19665,15 +19953,18 @@ var NotebookInstance2 = class {
       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);
@@ -19719,6 +20010,12 @@ var NotebookInstance2 = class {
     }
     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);
   }
@@ -19809,9 +20106,6 @@ var NotebookInstance2 = class {
     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");
@@ -19988,7 +20282,7 @@ function formatQueryString(params) {
 }
 export {
   ApiError,
-  Client2 as Client,
+  Client,
   CommandError,
   ComposerCredentials,
   ErrorEvent,
@@ -20002,7 +20296,7 @@ export {
   NotebookApi,
   NotebookComposerCredentialApi,
   NotebookInitError,
-  NotebookInstance2 as NotebookInstance,
+  NotebookInstance,
   NotebookMail,
   NotebookMailApi,
   NotebookPreview,
@@ -20014,6 +20308,7 @@ export {
   NotebookUnavailableError,
   PHPSandbox,
   PHPSandboxError,
+  ProcessReadable,
   ProcessResult,
   PromiseTimeoutError,
   PublicationApi,
@@ -20048,6 +20343,7 @@ export {
   PublishStreamSsePhaseEventSchema,
   PublishStreamSseResultEventSchema,
   RateLimitError,
+  RuntimeTelemetry,
   SendTimeoutError,
   ServerApi,
   ServerInstance,
@@ -20056,7 +20352,8 @@ export {
   notebookBuiltinServices,
   notebookKnownServices,
   once,
-  timeout
+  timeout,
+  watchRuntimeTelemetry
 };
 /*! Bundled license information: