@phpsandbox/sdk 0.0.29 → 0.0.30

package/README.md

@@ -101,6 +101,7 @@ Each `NotebookInstance` exposes service clients:
 - `notebook.laravel` (`Laravel`)
 - `notebook.auth` (`Auth`)
 - `notebook.log` (`Log`)
+- `notebook.services` (`Services`)
 
 ## Common Operations
 
@@ -144,6 +145,23 @@ result.throw();
 console.log(result.output);
 ```
 
+### Services
+
+```ts
+const services = await notebook.services.list();
+
+await notebook.services.run('redis');
+
+const snapshot = await notebook.services.logs('redis', { tail: 50 });
+console.log(snapshot);
+
+const stream = notebook.services.logs('redis', { follow: true, tail: 25 });
+const reader = stream.output.getReader();
+const chunk = await reader.read();
+console.log(chunk.value);
+await stream.stop();
+```
+
 ### Composer
 
 ```ts

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

@@ -572,6 +572,13 @@ var SendTimeoutError = class _SendTimeoutError extends PromiseTimeoutError {
     return new _SendTimeoutError(error.message, error.time);
   }
 };
+var NotebookUnavailableError = class extends Error {
+  constructor(message = "Notebook is no longer available", raw = {}) {
+    super(message);
+    this.raw = raw;
+    this.name = "NotebookUnavailableError";
+  }
+};
 
 // src/utils/promise.ts
 var timeout = (prom, time) => {
@@ -1019,6 +1026,103 @@ var Shell = class {
   }
 };
 
+// src/services.ts
+var Services = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  list() {
+    return this.okra.invoke("service.list");
+  }
+  run(name) {
+    return this.okra.invoke("service.run", { name });
+  }
+  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);
+    }
+    return this.okra.invoke("service.logs", {
+      name,
+      tail: options.tail
+    }).then((response) => {
+      if (!("output" in response)) {
+        throw new Error(`Unexpected service.logs response for ${name}`);
+      }
+      return response.output;
+    });
+  }
+  followLogs(name, options) {
+    const id = options.id || nanoid();
+    const disposables = /* @__PURE__ */ new Set();
+    let controller = null;
+    let closed = false;
+    const dispose = () => {
+      for (const disposable of disposables) {
+        disposable.dispose();
+      }
+      disposables.clear();
+    };
+    const close = () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      dispose();
+      if (controller) {
+        try {
+          controller.close();
+        } catch {
+        }
+      }
+    };
+    const fail = (error) => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      dispose();
+      if (controller) {
+        controller.error(error);
+      }
+    };
+    const stop = once(() => {
+      close();
+      return this.okra.invoke("service.stop-logs", { id });
+    });
+    const output = new ReadableStream({
+      start: (_controller) => {
+        controller = _controller;
+        disposables.add(
+          this.onLog(id, (data) => {
+            controller?.enqueue(data.output);
+          })
+        );
+        void this.okra.invoke("service.logs", {
+          name,
+          tail: options.tail,
+          follow: true,
+          id
+        }).catch((error) => {
+          fail(error);
+        });
+      },
+      cancel: () => {
+        void stop();
+      }
+    });
+    return { id, output, stop };
+  }
+};
+
 // node_modules/@msgpack/msgpack/dist.esm/utils/utf8.mjs
 function utf8Count(str) {
   const strLength = str.length;
@@ -3042,6 +3146,7 @@ var Transport = class {
     this.closed = false;
     this.disposables = new NamedDisposable();
     this.connectPromise = null;
+    this.terminalError = null;
     this.pingIntervalStarted = false;
     // Connection health monitoring
     this.connectionStats = {
@@ -3073,7 +3178,7 @@ var Transport = class {
     const startClosed = options.startClosed !== false;
     this.rws = new reconnecting_websocket_mjs_default(this.url.toString(), [], {
       WebSocket: globalThis.WebSocket ?? browser_default,
-      connectionTimeout: options.connectionTimeout ?? 1e3,
+      connectionTimeout: options.connectionTimeout,
       maxReconnectionDelay: 2e3,
       minReconnectionDelay: 200,
       maxEnqueuedMessages: 0,
@@ -3116,6 +3221,9 @@ var Transport = class {
    * Ensure the websocket is open without requiring an application-level roundtrip.
    */
   connect() {
+    if (this.terminalError) {
+      return Promise.reject(this.terminalError);
+    }
     return __privateMethod(this, _Transport_instances, connect_fn).call(this);
   }
   id() {
@@ -3172,7 +3280,12 @@ var Transport = class {
         return;
       }
       if (event === "Events.BootError" /* BootError */) {
+        const error = new NotebookUnavailableError(
+          data?.message || "Notebook is no longer available",
+          data || {}
+        );
         this.log("error", "Boot error received", { data });
+        this.terminate(error, 4e3, error.message);
         return;
       }
       if (event === "response" /* Response */) {
@@ -3231,6 +3344,11 @@ var Transport = class {
   listen(event, listener, _context) {
     return this.eventEmitter.listen(event, listener);
   }
+  onDidBootError(listener) {
+    this.eventEmitter.listen("transport.boot_error", (event) => {
+      listener(event.error);
+    });
+  }
   removeListener(event, listener) {
     this.eventEmitter.removeListener(event, listener);
   }
@@ -3257,6 +3375,9 @@ var Transport = class {
   get isClosed() {
     return this.closed;
   }
+  getTerminalError() {
+    return this.terminalError;
+  }
   get status() {
     return {
       0: "CONNECTING",
@@ -3266,6 +3387,9 @@ var Transport = class {
     }[this.rws.readyState];
   }
   async call(action, data = {}, options = {}) {
+    if (this.terminalError) {
+      throw this.terminalError;
+    }
     if (this.isRateLimited()) {
       throw new RateLimitError("Rate limit exceeded - too many requests");
     }
@@ -3282,6 +3406,10 @@ var Transport = class {
       this.eventEmitter.removeListener(errorEvent);
     };
     const handler = async (resolve, reject) => {
+      if (this.terminalError) {
+        reject(this.terminalError);
+        return;
+      }
       const abortError = new DOMException("Request aborted", "AbortError");
       if (options.abortSignal?.aborted) {
         reject(abortError);
@@ -3333,7 +3461,7 @@ var Transport = class {
           reject(new RateLimitError(_ev.reason || "Rate limit exceeded", _ev));
           return;
         }
-        reject(new Error(`Connection lost to the notebook during request: ${_ev.reason || "Unknown reason"}`));
+        reject(this.terminalError || new Error(`Connection lost to the notebook during request: ${_ev.reason || "Unknown reason"}`));
       };
       this.rws.addEventListener("close", closeHandler);
       this.rws.addEventListener("error", closeHandler);
@@ -3369,7 +3497,7 @@ var Transport = class {
         try {
           return await sender();
         } catch (e) {
-          if (e instanceof ErrorEvent || e instanceof RateLimitError || e instanceof InvalidConfigurationError || e instanceof InvalidMessageError || e instanceof DOMException) {
+          if (e instanceof ErrorEvent || e instanceof RateLimitError || e instanceof InvalidConfigurationError || e instanceof InvalidMessageError || e instanceof NotebookUnavailableError || e instanceof DOMException) {
             this.log("debug", "Non-retryable error, bailing", {
               error: e.message,
               attempt
@@ -3421,6 +3549,9 @@ var Transport = class {
    * This preserves all event listeners and state.
    */
   reconnect() {
+    if (this.terminalError) {
+      throw this.terminalError;
+    }
     if (this.closed) {
       throw new Error("Cannot reconnect a closed transport. The transport has been permanently closed.");
     }
@@ -3435,6 +3566,16 @@ var Transport = class {
     }
     this.close();
   }
+  terminate(error, code = 4e3, reason = error.message) {
+    this.terminalError = error;
+    if (error instanceof NotebookUnavailableError) {
+      this.eventEmitter.emit("transport.boot_error", {
+        error,
+        timestamp: Date.now()
+      });
+    }
+    this.close(code, reason);
+  }
   close(code, reason) {
     if (this.closed) {
       return;
@@ -3442,9 +3583,9 @@ var Transport = class {
     this.log("info", "Closing transport connection", { code, reason });
     this.connectPromise = null;
     const queuedCount = this.messageQueue.length;
+    const closeError = this.terminalError || new Error("Connection closed while message was queued");
     this.messageQueue.forEach((msg) => {
-      console.log("Rejecting queued message due to connection close");
-      msg.reject(new Error("Connection closed while message was queued"));
+      msg.reject(closeError);
     });
     this.messageQueue = [];
     if (queuedCount > 0) {
@@ -3532,6 +3673,9 @@ var Transport = class {
         this.log("error", "Connection closed due to policy violation");
         this.clearOldQueuedMessages();
         return "stop";
+      case 4e3:
+        this.log("info", "Connection closed due to terminal notebook error");
+        return "stop";
       default:
         this.log("warn", `Unknown close code: ${code}, will reconnect`);
         return "reconnect";
@@ -3747,6 +3891,9 @@ _Transport_instances = new WeakSet();
  * by caching the connection promise.
  */
 connect_fn = function() {
+  if (this.terminalError) {
+    return Promise.reject(this.terminalError);
+  }
   if (this.isConnected) {
     return Promise.resolve();
   }
@@ -4793,9 +4940,14 @@ var NotebookInstance = class {
     this.laravel = new Lravel(this);
     this.shell = new Shell(this);
     this.git = new Git(this);
+    this.services = new Services(this);
     this.secrets = new NotebookSecrets(client, this.data.id);
   }
   async ready() {
+    const terminalError = this.socket.getTerminalError();
+    if (terminalError) {
+      throw terminalError;
+    }
     const ready = async () => {
       if (this.client.options.startClosed && !this.socket.isConnected) {
         await this.socket.connect();
@@ -4808,7 +4960,9 @@ var NotebookInstance = class {
     return this.client.notebook.fork(this.data.id);
   }
   delete() {
-    return this.client.notebook.delete(this.data.id);
+    return this.client.notebook.delete(this.data.id).then(() => {
+      this.socket.terminate(new NotebookUnavailableError("Notebook has been deleted.", { id: this.data.id }));
+    });
   }
   stop() {
     return this.container.stop();
@@ -4832,6 +4986,10 @@ var NotebookInstance = class {
     !this.socket.isClosed && this.socket.disconnect();
   }
   connected() {
+    const terminalError = this.socket.getTerminalError();
+    if (terminalError) {
+      return Promise.reject(terminalError);
+    }
     if (this.socket.isConnected) {
       return Promise.resolve(this);
     }
@@ -4839,18 +4997,24 @@ var NotebookInstance = class {
       try {
         this.socket.onDidConnect(() => resolve(this));
         this.socket.onDidClose(() => reject(new Error("Connection closed")));
+        this.socket.onDidBootError((error) => reject(error));
       } catch (e) {
         reject(e);
       }
     });
   }
   whenConnected() {
+    const terminalError = this.socket.getTerminalError();
+    if (terminalError) {
+      return Promise.reject(terminalError);
+    }
     if (this.socket.isConnected) {
       return Promise.resolve(this);
     }
     return new Promise((resolve, reject) => {
       try {
         this.socket.onDidConnect(() => resolve(this));
+        this.socket.onDidBootError((error) => reject(error));
       } catch (e) {
         reject(e);
       }
@@ -4867,6 +5031,11 @@ var NotebookInstance = class {
       this.socket.emit("okra.disconnected");
       this.initialized = false;
     });
+    this.socket.onDidBootError((error) => {
+      this.socket.emit("okra.boot_error", error);
+      this.socket.emit("okra.disconnected");
+      this.initialized = false;
+    });
   }
   onDidConnect(handler) {
     this.socket.removeListener("okra.connected", handler);
@@ -4879,6 +5048,11 @@ var NotebookInstance = class {
     this.disposables.push(disposable);
     return disposable;
   }
+  onDidBootError(handler) {
+    const disposable = this.socket.listen("okra.boot_error", handler);
+    this.disposables.push(disposable);
+    return disposable;
+  }
   update() {
     return this.invoke("notebook.update");
   }
@@ -4904,6 +5078,7 @@ _NotebookInstance_instances = new WeakSet();
 init_fn = function() {
   __privateSet(this, _initPromise, new Promise((resolve, reject) => {
     const initializationListener = this.onDidInitialize((result) => {
+      bootErrorListener.dispose();
       initializationListener.dispose();
       this.initialized = result;
       if (result.type === "error") {
@@ -4912,6 +5087,11 @@ init_fn = function() {
       }
       resolve(result);
     });
+    const bootErrorListener = this.onDidBootError((error) => {
+      initializationListener.dispose();
+      bootErrorListener.dispose();
+      reject(error);
+    });
   }));
   return __privateGet(this, _initPromise);
 };
@@ -4955,6 +5135,7 @@ export {
   NotebookSecretApi,
   NotebookSecrets,
   NotebookState,
+  NotebookUnavailableError,
   PHPSandbox,
   PHPSandboxError,
   PromiseTimeoutError,