@phpsandbox/sdk 0.6.0-canary.2 → 0.6.0-canary.4

package/README.md

@@ -209,6 +209,32 @@ const [hasMore, matches] = await notebook.files.search(
 );
 ```
 
+`files.download()` returns a `ReadableStream<Uint8Array>` containing the notebook ZIP.
+Read it incrementally or pipe it to a writable stream:
+
+```ts
+const controller = new AbortController();
+const archive = notebook.files.download({
+  include: ['src/**'],
+  exclude: ['vendor/**'],
+  signal: controller.signal,
+});
+
+for await (const chunk of archive) {
+  await consume(chunk);
+}
+```
+
+Downloads use HTTP for both realtime and REST clients and require the runtime's
+`POST /api/v1/notebooks/{notebook}/runtime/files/download` endpoint. Reading starts
+the request; cancelling the stream, aborting its signal, or disposing the notebook
+stops the transfer. Failures reject stream reads and are not retried after bytes
+have started arriving.
+
+**Breaking change in 0.6.0-canary.4:** downloads no longer return a `Blob` or accept
+`onChunk`. If you need a Blob, explicitly collect the archive with
+`await new Response(notebook.files.download()).blob()`; this buffers the ZIP in memory.
+
 ### Terminal
 
 ```ts
@@ -378,6 +404,9 @@ await notebook.mail.disable();
 ### Feedback
 
 ```ts
+// Feedback uses the same API token as the rest of the SDK.
+// You can also address it directly with client.feedback.forProject(projectId)
+// or client.feedback.forNotebook(notebookId), without fetching a notebook.
 await notebook.feedback.configure({
   widget: {
     targets: ['preview', 'publication'],

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

@@ -16372,17 +16372,14 @@ var Filesystem = class {
   exists(path) {
     return this.stat(path).then(() => true).catch(() => false);
   }
-  async download(options = {}) {
-    const id = nanoid3();
-    const stream = !!options.onChunk;
-    const chunks = [];
-    const disposable = this.okra.listen(
-      `fs.download.${id}`,
-      stream ? options.onChunk : (data) => {
-        chunks.push(data);
+  download(options = {}) {
+    return this.okra.stream(
+      "fs.download",
+      { include: options.include, exclude: options.exclude },
+      {
+        abortSignal: options.signal
       }
     );
-    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 });
@@ -20343,6 +20340,7 @@ var restActionRoutes = {
   "shell.exec": { method: "POST", path: "/runtime/executions" },
   "fs.readFile": { method: "GET", path: "/runtime/files/content" },
   "fs.writeFile": { method: "PUT", path: "/runtime/files/content" },
+  "fs.download": { method: "POST", path: "/runtime/files/download" },
   "fs.createDirectory": { method: "PUT", path: "/runtime/directories" },
   "fs.readDirectory": { method: "POST", path: "/runtime/directories/read" },
   "fs.stat": { method: "POST", path: "/runtime/files/stat" },
@@ -20379,6 +20377,7 @@ var RestRuntimeInvoker = class {
     this.fetch = fetch;
     this.refresh = refresh;
     this.refreshPromise = null;
+    this.streams = /* @__PURE__ */ new Set();
     this.notebookId = data.id;
     this.configure(data.runtimeUrl);
   }
@@ -20411,6 +20410,127 @@ var RestRuntimeInvoker = class {
   send() {
     throw new PHPSandboxError("Fire-and-forget actions require the realtime transport.");
   }
+  dispose() {
+    for (const stream of this.streams) {
+      stream.abort(new DOMException("Notebook disposed", "AbortError"));
+    }
+  }
+  stream(action, data, options = {}) {
+    const cancellation = new AbortController();
+    this.streams.add(cancellation);
+    const abort = runtimeAbort({ ...options, abortSignal: cancellation.signal });
+    const abortFromCaller = () => cancellation.abort(options.abortSignal?.reason);
+    let reader;
+    let closed = false;
+    let onAbort = () => {
+    };
+    const dispose = () => {
+      this.streams.delete(cancellation);
+      options.abortSignal?.removeEventListener("abort", abortFromCaller);
+      abort.signal.removeEventListener("abort", onAbort);
+      abort.dispose();
+    };
+    const cancelReader = async (reason) => {
+      const activeReader = reader;
+      reader = void 0;
+      if (activeReader !== void 0) {
+        await activeReader.cancel(reason).catch(() => void 0);
+        activeReader.releaseLock();
+      }
+    };
+    return new ReadableStream(
+      {
+        start: (controller) => {
+          onAbort = () => {
+            if (closed) {
+              return;
+            }
+            closed = true;
+            dispose();
+            controller.error(abort.signal.reason);
+            void cancelReader(abort.signal.reason);
+          };
+          abort.signal.addEventListener("abort", onAbort, { once: true });
+          options.abortSignal?.addEventListener("abort", abortFromCaller, { once: true });
+          if (options.abortSignal?.aborted) {
+            abortFromCaller();
+          }
+        },
+        pull: async (controller) => {
+          try {
+            if (reader === void 0) {
+              const response = await this.streamResponse(action, data, abort.signal);
+              if (closed) {
+                await response.body?.cancel();
+                return;
+              }
+              if (response.body === null) {
+                throw new TransportError("PHPSandbox runtime returned an empty download.", "InvalidResponse", response);
+              }
+              reader = response.body.getReader();
+            }
+            const result = await reader.read();
+            if (closed) {
+              return;
+            }
+            if (result.done) {
+              closed = true;
+              dispose();
+              reader.releaseLock();
+              reader = void 0;
+              controller.close();
+            } else {
+              controller.enqueue(result.value);
+            }
+          } catch (error51) {
+            if (!closed) {
+              closed = true;
+              cancellation.abort(error51);
+              dispose();
+              await cancelReader(error51);
+              controller.error(error51);
+            }
+          }
+        },
+        cancel: async (reason) => {
+          closed = true;
+          cancellation.abort(reason);
+          dispose();
+          await cancelReader(reason);
+        }
+      },
+      { highWaterMark: 0 }
+    );
+  }
+  async streamResponse(action, data, signal) {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      signal.throwIfAborted();
+      const response = await runtimeFetch(this.fetch, this.request(action, data, signal));
+      if (signal.aborted) {
+        await response.body?.cancel();
+        signal.throwIfAborted();
+      }
+      if (response.status === 401 && attempt === 0 && this.refresh !== void 0) {
+        await response.body?.cancel();
+        await this.refreshAuthorization();
+        continue;
+      }
+      if (!response.ok) {
+        const payload = await runtimeActionResponse(response);
+        throw remoteError("runtime", payload.error, response);
+      }
+      if (!response.headers.get("content-type")?.toLowerCase().startsWith("application/zip")) {
+        await response.body?.cancel();
+        throw new TransportError("PHPSandbox runtime returned an invalid download.", "InvalidResponse", response);
+      }
+      return response;
+    }
+    throw new RemoteError("Notebook download could not be authorized.", {
+      source: "runtime",
+      status: 401,
+      code: "AuthenticationRequired"
+    });
+  }
   async invokeRaw(action, data, options) {
     const abort = runtimeAbort(options);
     try {
@@ -20443,7 +20563,7 @@ var RestRuntimeInvoker = class {
     const url2 = new URL(this.actionUrl);
     url2.pathname += route.path;
     const headers = {
-      Accept: "application/json, application/octet-stream",
+      Accept: action === "fs.download" ? "application/zip" : "application/json, application/octet-stream",
       Authorization: `Bearer ${this.ticket}`
     };
     const body = runtimeActionRequestBody(action, data, url2, headers);
@@ -20560,9 +20680,9 @@ function runtimeAbort(options) {
 
 // src/feedback.ts
 var Feedback = class {
-  constructor(client, notebookId) {
+  constructor(client, identifier) {
     this.client = client;
-    this.notebookId = notebookId;
+    this.identifier = identifier;
   }
   async configure(input) {
     const response = await this.client.put(this.path("/configuration"), input);
@@ -20572,8 +20692,8 @@ var Feedback = class {
     const response = await this.client.get(this.path("/configuration"));
     return response.data;
   }
-  async submit(input) {
-    const response = await this.client.post(this.path(), input);
+  async submit(input, options = {}) {
+    const response = await this.client.post(this.path(), input, options);
     return response.data;
   }
   async list(options = {}) {
@@ -20594,7 +20714,18 @@ var Feedback = class {
     return response.data;
   }
   path(suffix = "") {
-    return `/notebook/${this.notebookId}/feedback${suffix}`;
+    return `/platform/projects/${encodeURIComponent(this.identifier)}/feedback${suffix}`;
+  }
+};
+var FeedbackApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  forProject(projectId) {
+    return new Feedback(this.client, projectId);
+  }
+  forNotebook(notebookId) {
+    return new Feedback(this.client, notebookId);
   }
 };
 
@@ -20755,6 +20886,7 @@ var ClientImplementation = class {
     this.integrations = new IntegrationApi(this);
     this.payments = new PaymentsApi(this);
     this.customers = new CustomersApi(this);
+    this.feedback = new FeedbackApi(this);
     this.options = { ...options };
     this.runtimeTransportValue = runtimeTransport;
     this.baseUrl = normalizeApiBaseUrl(url2);
@@ -20773,8 +20905,13 @@ var ClientImplementation = class {
   get(path) {
     return this.requireData(this.makeRequest("GET", path));
   }
-  post(path, body) {
-    return this.requireData(this.makeRequest("POST", path, { body: body === void 0 ? void 0 : JSON.stringify(body) }));
+  post(path, body, options = {}) {
+    return this.requireData(
+      this.makeRequest("POST", path, {
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        headers: options.idempotencyKey === void 0 ? void 0 : { "Idempotency-Key": options.idempotencyKey }
+      })
+    );
   }
   delete(path) {
     return this.makeRequest("DELETE", path);
@@ -20827,11 +20964,15 @@ var ClientImplementation = class {
     return { ...response, data: response.data };
   }
   async makeRequest(method, path, init) {
+    const headers = new Headers(init?.headers);
+    for (const [name, value] of Object.entries(this.headers)) {
+      headers.set(name, value);
+    }
     const response = await this.fetchResponse(
       authenticatedRequest(new URL(path.replace(/^\//, ""), this.baseUrl), {
         method,
         ...init,
-        headers: this.headers
+        headers
       })
     );
     if (!response.ok) {
@@ -20897,6 +21038,7 @@ var PHPSandbox = class _PHPSandbox {
     this.integrations = client.integrations;
     this.payments = client.payments;
     this.customers = client.customers;
+    this.feedback = client.feedback;
   }
   async whoami() {
     const { data } = await this.client.get("/auth/whoami");
@@ -20926,6 +21068,7 @@ var _NotebookInstance = class _NotebookInstance {
     this.data = data;
     this.client = client;
     __privateAdd(this, _NotebookInstance_instances);
+    this.downloadInvoker = null;
     this.initialized = false;
     __privateAdd(this, _initPromise, null);
     this.disposables = [];
@@ -21047,12 +21190,23 @@ var _NotebookInstance = class _NotebookInstance {
     }
     return this.realtimeSocket().send(action, data || {});
   }
+  /** Binary downloads use HTTP independently of the selected runtime transport. */
+  stream(action, data = {}, options = {}) {
+    const runtimeUrlProvider = this.client.options.runtimeUrlProvider;
+    this.downloadInvoker ?? (this.downloadInvoker = this.restInvoker ?? new RestRuntimeInvoker(
+      this.data,
+      this.client.options.fetch ?? globalThis.fetch,
+      runtimeUrlProvider === void 0 ? void 0 : () => runtimeUrlProvider(this.data.id)
+    ));
+    return this.downloadInvoker.stream(action, data, options);
+  }
   listen(event, handler) {
     const disposable = this.emitter.listen(event, handler);
     this.disposables.push(disposable);
     return disposable;
   }
   dispose() {
+    this.downloadInvoker?.dispose();
     this.disposables.forEach((d) => d.dispose());
     if (this.socket !== null && !this.socket.isClosed) {
       this.socket.disconnect();
@@ -21309,6 +21463,8 @@ export {
   CustomerRuntime,
   CustomersApi,
   DEFAULT_PAYMENT_CALLBACK_PATH,
+  Feedback,
+  FeedbackApi,
   FileChangeFilter,
   FileChangeType,
   FileType,