@phpsandbox/sdk 0.3.1 → 0.3.3

package/README.md

@@ -418,3 +418,41 @@ Preparing or viewing a proposal does not start publishing. Confirmation sends th
 Inspect deployment, runtime and routing outcomes for each selected app; a partial outcome is not full success. `retryApplication(id)` retries failed apps after revalidation. If an outcome is uncertain, inspect status and logs before retrying. `destroyApplication(id)` unpublishes; deleting managed resources additionally requires `deleteResources: true`.
 
 Shared managed-resource creation currently starts with one app. After creation, update the resource definition to `reuse` with the catalog resource ID before attaching other apps. Simultaneous first-time shared-resource creation is unsupported.
+
+#### Browser publishing streams through your backend
+
+Keep service-account credentials on your server. After authorizing project access and checking the requested publishing attempt, open the original SSE bytes with `publication.stream()`. Return the SDK's standard `Response` directly from your framework:
+
+```ts
+import { createPublicationStreamResponse } from '@phpsandbox/sdk/stream';
+
+// Server: `publication` belongs to the authenticated user's project.
+// `requestSignal` is aborted when the downstream client disconnects.
+const bytes = await publication.stream(requestSignal);
+return createPublicationStreamResponse(bytes, {
+  signal: requestSignal,
+  onDispose: () => notebook.dispose(),
+});
+```
+
+The helper forwards bytes unchanged and supplies SSE headers. It releases resources on completion, upstream failure, or downstream cancellation. Dispose resources yourself if opening the upstream stream fails. Opening this endpoint can start an already queued release; it is not a purely passive log subscription.
+
+In the browser, use the lightweight `stream` entry point without constructing a client or exposing a PHPSandbox token. For example, if your backend exposes the proxy at `/api/publishing/stream`:
+
+```ts
+import { readPublicationStream } from '@phpsandbox/sdk/stream';
+
+const controller = new AbortController();
+const response = await fetch('/api/publishing/stream', {
+  credentials: 'same-origin',
+  headers: { Accept: 'text/event-stream' },
+  signal: controller.signal,
+});
+for await (const event of readPublicationStream(response)) {
+  // Discriminated union: phase, log, or result. `done` is normalized to result.
+  if (event.type === 'log') console.log(event.content);
+}
+// Call controller.abort() when the view closes, including while waiting for an event.
+```
+
+`readPublicationStream` also accepts a `ReadableStream<Uint8Array>`. By default, it rejects EOF without a final result (including empty streams). Use `{ requireResult: false }` only when deliberately consuming a stream fragment. It validates recognized event payloads, throws for server error events, and ignores unknown event names and heartbeat comments. Ending iteration early cancels the stream; aborting the fetch interrupts a pending read. Disconnecting observation does not cancel the server-side deployment. `PublicationRun.events()` uses this same parser.

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

@@ -14795,6 +14795,140 @@ var PublishStreamSseEventSchema = external_exports.discriminatedUnion("event", [
   return PublishStreamEventSchema.parse({ type, ...event.data });
 });
 
+// src/publication/stream.ts
+async function* readPublicationStream(input, options = {}) {
+  if (input instanceof Response && (!input.ok || !input.body)) {
+    await input.body?.cancel().catch(() => void 0);
+    throw new PHPSandboxError(`Publishing stream is unavailable (HTTP ${input.status}).`);
+  }
+  const stream = input instanceof Response ? input.body : input;
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let eventName = "message";
+  let data = [];
+  let ended = false;
+  let receivedResult = false;
+  function dispatch() {
+    const name = eventName;
+    const lines = data;
+    eventName = "message";
+    data = [];
+    if (!lines.length || !PublishStreamSseEventNameSchema.safeParse(name).success) return null;
+    const raw = lines.join("\n");
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+    } catch {
+      payload = raw;
+    }
+    const event = PublishStreamSseEventSchema.parse({ event: name, data: payload });
+    if (event.type === "result") receivedResult = true;
+    return event;
+  }
+  function line(value) {
+    if (value === "") return dispatch();
+    if (value.startsWith(":")) return null;
+    const colon = value.indexOf(":");
+    const field = colon < 0 ? value : value.slice(0, colon);
+    let content = colon < 0 ? "" : value.slice(colon + 1);
+    if (content.startsWith(" ")) content = content.slice(1);
+    if (field === "event") eventName = content;
+    if (field === "data") data.push(content);
+    return null;
+  }
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+      let match;
+      while (match = /\r\n|\r|\n/.exec(buffer)) {
+        if (!done && match[0] === "\r" && match.index === buffer.length - 1) break;
+        const event = line(buffer.slice(0, match.index));
+        buffer = buffer.slice(match.index + match[0].length);
+        if (event) yield event;
+      }
+      if (done) {
+        ended = true;
+        if (buffer) {
+          const event2 = line(buffer);
+          if (event2) yield event2;
+        }
+        const event = dispatch();
+        if (event) yield event;
+        if (options.requireResult !== false && !receivedResult) {
+          throw new PHPSandboxError("Publish stream ended without result");
+        }
+        return;
+      }
+    }
+  } finally {
+    if (!ended) await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function createPublicationStreamResponse(stream, options = {}) {
+  const reader = stream.getReader();
+  let disposed = false;
+  let finished = false;
+  let cancellation;
+  let abort;
+  async function dispose() {
+    if (disposed) return;
+    disposed = true;
+    options.signal?.removeEventListener("abort", abort);
+    reader.releaseLock();
+    await options.onDispose?.();
+  }
+  function cancel(reason) {
+    return cancellation ?? (cancellation = (async () => {
+      finished = true;
+      try {
+        await reader.cancel(reason);
+      } finally {
+        await dispose();
+      }
+    })());
+  }
+  return new Response(new ReadableStream({
+    start(controller) {
+      abort = () => {
+        controller.error(options.signal.reason);
+        void cancel(options.signal.reason).catch(() => void 0);
+      };
+      if (options.signal?.aborted) abort();
+      else options.signal?.addEventListener("abort", abort, { once: true });
+    },
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (finished) return;
+        if (done) {
+          finished = true;
+          await dispose();
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error51) {
+        if (finished && cancellation) return;
+        try {
+          await cancel(error51);
+        } finally {
+          controller.error(error51);
+        }
+      }
+    },
+    cancel
+  }, { highWaterMark: 0 }), {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      "X-Accel-Buffering": "no"
+    }
+  });
+}
+
 // src/publication/run.ts
 var PublicationRun = class {
   constructor(initial, client) {
@@ -14882,7 +15016,7 @@ var PublicationRun = class {
   async consumeStream(eventStreamUrl) {
     try {
       const stream = await this.client.sse(eventStreamUrl, this.streamAbort.signal);
-      for await (const event of readPublishStreamEvents(stream)) {
+      for await (const event of readPublicationStream(stream)) {
         this.publish(event);
         if (event.type === "result") {
           const { type: _, ...result } = event;
@@ -14983,78 +15117,6 @@ var AsyncPublishEventQueue = class {
     });
   }
 };
-async function* readPublishStreamEvents(stream) {
-  const reader = parseSSEStream(stream).getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        return;
-      }
-      const event = parsePublishStreamEvent(value);
-      if (event) {
-        yield event;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-function parsePublishStreamEvent(event) {
-  if (!PublishStreamSseEventNameSchema.safeParse(event.event).success) {
-    return null;
-  }
-  return PublishStreamSseEventSchema.parse(event);
-}
-function parseSSEStream(input) {
-  const decoder = new TextDecoder();
-  let buffer = "";
-  return input.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        buffer += decoder.decode(chunk, { stream: true });
-        const blocks = buffer.split("\n\n");
-        buffer = blocks.pop() ?? "";
-        for (const block of blocks) {
-          const event = parseSSEBlock(block);
-          if (event) {
-            controller.enqueue(event);
-          }
-        }
-      },
-      flush(controller) {
-        buffer += decoder.decode();
-        if (buffer.trim() !== "") {
-          const event = parseSSEBlock(buffer);
-          if (event) {
-            controller.enqueue(event);
-          }
-        }
-      }
-    })
-  );
-}
-function parseSSEBlock(block) {
-  let eventType = "message";
-  let data = "";
-  for (const line of block.split("\n")) {
-    if (line.startsWith("event: ")) {
-      eventType = line.slice(7).trim();
-    } else if (line.startsWith("data: ")) {
-      data += line.slice(6);
-    } else if (line.startsWith("data:")) {
-      data += line.slice(5);
-    }
-  }
-  if (data === "") {
-    return null;
-  }
-  try {
-    return { event: eventType, data: JSON.parse(data) };
-  } catch {
-    return { event: eventType, data };
-  }
-}
 
 // src/publication/resources.ts
 var PublicationResources = class {
@@ -15146,6 +15208,13 @@ var PublicationInstance = class _PublicationInstance {
   follow() {
     return new PublicationRun(this, this.client).start();
   }
+  /** Open the original publishing SSE bytes for an authenticated, transparent proxy. */
+  async stream(signal) {
+    if (!this.data.eventStreamUrl) {
+      throw new PHPSandboxError(`Publication ${this.data.id} has no eventStreamUrl for SSE streaming`);
+    }
+    return this.client.sse(this.data.eventStreamUrl, signal);
+  }
   async destroy(options = {}) {
     const query = options.deleteResources ? "?deleteResources=1" : "";
     await this.client.delete(`/publications/${encodeURIComponent(this.data.id)}${query}`);
@@ -19613,6 +19682,16 @@ var ServerInstance = class {
   async installation() {
     return (await this.client.get(`/servers/${encodeURIComponent(this.data.id)}/installation`)).data;
   }
+  async members(options = {}) {
+    const query = options.page === void 0 ? "" : `?${new URLSearchParams({ page: String(options.page) }).toString()}`;
+    return this.client.get(`/servers/${encodeURIComponent(this.data.id)}/members${query}`);
+  }
+  async share(email3) {
+    return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, { email: email3 })).data;
+  }
+  async revokeAccess(memberId) {
+    await this.client.delete(`/servers/${encodeURIComponent(this.data.id)}/members/${encodeURIComponent(String(memberId))}`);
+  }
   refresh() {
     return this.client.servers.get(this.data.id);
   }
@@ -20618,9 +20697,11 @@ export {
   PublicationRun,
   RemoteError,
   TransportError,
+  createPublicationStreamResponse,
   laravelCloudSetupForRepublish,
   notebookBuiltinServices,
-  notebookKnownServices
+  notebookKnownServices,
+  readPublicationStream
 };
 /*! Bundled license information: