@phpsandbox/sdk 0.3.2 → 0.3.4

package/dist/publication/stream.js

@@ -0,0 +1,185 @@
+import { PublishStreamSseEventNameSchema, PublishStreamSseEventSchema } from '../schemas/publications.js';
+import { PHPSandboxError } from '../errors/index.js';
+/** Consume publishing SSE in browsers or servers, including through an authenticated proxy.
+ * Cancels the source when iteration ends early or parsing fails. Fetch cancellation belongs
+ * to the caller's AbortSignal. Unknown event names and heartbeat comments are ignored.
+ * A complete stream must include a result; set requireResult to false only for fragments.
+ */
+export async function* readPublicationStream(input, options = {}) {
+    if (input instanceof Response && (!input.ok || !input.body)) {
+        await input.body?.cancel().catch(() => undefined);
+        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 });
+            // A CR at the end of a chunk may be the first half of CRLF.
+            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 event = line(buffer);
+                    if (event) {
+                        yield event;
+                    }
+                }
+                // Preserve the SDK's support for a final event without a trailing blank line.
+                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(() => undefined);
+        }
+        reader.releaseLock();
+    }
+}
+/** Forward the original bytes with SSE headers and exactly-once resource cleanup.
+ * Works with Fetch-based servers and frameworks that accept a standard Response.
+ * Does not parse, buffer a replay, or re-encode events. Upstream errors fail the body.
+ */
+export 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(() => undefined);
+            };
+            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 (error) {
+                if (finished && cancellation) {
+                    return;
+                }
+                try {
+                    await cancel(error);
+                }
+                finally {
+                    controller.error(error);
+                }
+            }
+        },
+        cancel,
+    }, { highWaterMark: 0 }), {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            'X-Accel-Buffering': 'no',
+        },
+    });
+}

package/dist/runtime/rest.js

@@ -194,7 +194,8 @@ function runtimeActionRequestBody(action, data, url, headers) {
             throw new TypeError('Runtime file contents must be binary data.');
         }
         headers['Content-Type'] = 'application/octet-stream';
-        return Uint8Array.from(new Uint8Array(payload.contents.buffer, payload.contents.byteOffset, payload.contents.byteLength)).buffer;
+        return Uint8Array.from(new Uint8Array(payload.contents.buffer, payload.contents.byteOffset, payload.contents.byteLength))
+            .buffer;
     }
     headers['Content-Type'] = 'application/json';
     return JSON.stringify(data);

package/dist/runtime.js

@@ -1,7 +1,7 @@
 import Logs from './log.js';
 import Metrics from './metrics.js';
 import Ports from './ports.js';
-import { RuntimeTelemetry, } from './telemetry.js';
+import { RuntimeTelemetry } from './telemetry.js';
 export class RuntimeMetrics {
     constructor(metrics) {
         this.metrics = metrics;

package/dist/schemas/publications.js

@@ -1,9 +1,5 @@
 import { z } from 'zod';
-export const PublicationProviderNameSchema = z.enum([
-    'cloudflare-containers',
-    'ssh-server',
-    'laravel-cloud',
-]);
+export const PublicationProviderNameSchema = z.enum(['cloudflare-containers', 'ssh-server', 'laravel-cloud']);
 export const PublicationStatusSchema = z.enum([
     'pending',
     'queued',
@@ -16,71 +12,55 @@ export const PublicationStatusSchema = z.enum([
     'deleted',
     'delete_failed',
 ]);
-export const PublicationBuildStatusSchema = z.enum([
-    'pending',
-    'queued',
-    'running',
-    'succeeded',
-    'failed',
-    'cancelled',
-]);
+export const PublicationBuildStatusSchema = z.enum(['pending', 'queued', 'running', 'succeeded', 'failed', 'cancelled']);
 export const PublicationReleaseStatusSchema = z.enum(['created', 'ready', 'deleted']);
-export const PublicationSizeSchema = z.enum([
-    'nano',
-    'small',
-    'medium',
-    'large',
-    'lite',
-    'basic',
-    'standard-1',
-    'standard-2',
-]);
-export const PublicationRegionSchema = z.enum([
-    'ENAM',
-    'WNAM',
-    'EEUR',
-    'WEUR',
-    'APAC',
-    'SAM',
-    'ME',
-    'OC',
-    'AFR',
-]);
+export const PublicationSizeSchema = z.enum(['nano', 'small', 'medium', 'large', 'lite', 'basic', 'standard-1', 'standard-2']);
+export const PublicationRegionSchema = z.enum(['ENAM', 'WNAM', 'EEUR', 'WEUR', 'APAC', 'SAM', 'ME', 'OC', 'AFR']);
 export const PublicationJurisdictionSchema = z.enum(['eu', 'fedramp']);
 export const PublicationProtectionModeSchema = z.enum(['none', 'password']);
 export const PublicationLogStreamSchema = z.enum(['build', 'runtime']);
 export const PublishStreamLogStreamSchema = z.enum(['build', 'publish', 'runtime']);
-const PublicationEventPayloadSchema = z.preprocess((payload) => Array.isArray(payload) && payload.length === 0 ? {} : payload, z.record(z.string(), z.unknown()));
-export const PublicationEventDataSchema = z.object({
+const PublicationEventPayloadSchema = z.preprocess((payload) => (Array.isArray(payload) && payload.length === 0 ? {} : payload), z.record(z.string(), z.unknown()));
+export const PublicationEventDataSchema = z
+    .object({
     id: z.union([z.number(), z.string()]).optional(),
     sequence: z.number(),
     type: z.string(),
     payload: PublicationEventPayloadSchema,
     createdAt: z.string().nullable(),
-}).passthrough();
-export const PublicationLogChunkDataSchema = z.object({
+})
+    .passthrough();
+export const PublicationLogChunkDataSchema = z
+    .object({
     sequence: z.number(),
     stream: PublicationLogStreamSchema,
     content: z.string(),
     createdAt: z.string().nullable(),
-}).passthrough();
-export const PublishStreamPhaseSchema = z.object({
+})
+    .passthrough();
+export const PublishStreamPhaseSchema = z
+    .object({
     name: z.string(),
     status: z.enum(['running', 'completed', 'failed']).optional(),
     data: z.record(z.string(), z.unknown()).optional(),
-}).strict();
-export const PublishStreamLogSchema = z.object({
+})
+    .strict();
+export const PublishStreamLogSchema = z
+    .object({
     stream: PublishStreamLogStreamSchema,
     content: z.string(),
-}).strict();
-export const PublishStreamResultSchema = z.object({
+})
+    .strict();
+export const PublishStreamResultSchema = z
+    .object({
     success: z.boolean(),
     publicationId: z.string(),
     url: z.string().url(),
     buildId: z.string(),
     releaseId: z.string(),
     status: PublicationStatusSchema,
-}).strict();
+})
+    .strict();
 export const PublishStreamPhaseEventSchema = PublishStreamPhaseSchema.extend({
     type: z.literal('phase'),
 }).strict();
@@ -95,37 +75,51 @@ export const PublishStreamEventSchema = z.discriminatedUnion('type', [
     PublishStreamLogEventSchema,
     PublishStreamResultEventSchema,
 ]);
-export const PublishStreamErrorSchema = z.object({
+export const PublishStreamErrorSchema = z
+    .object({
     message: z.string().optional(),
-}).passthrough();
+})
+    .passthrough();
 export const PublishStreamSseEventNameSchema = z.enum(['phase', 'log', 'done', 'result', 'error']);
-export const PublishStreamSsePhaseEventSchema = z.object({
+export const PublishStreamSsePhaseEventSchema = z
+    .object({
     event: z.literal('phase'),
     data: PublishStreamPhaseSchema,
-}).strict();
-export const PublishStreamSseLogEventSchema = z.object({
+})
+    .strict();
+export const PublishStreamSseLogEventSchema = z
+    .object({
     event: z.literal('log'),
     data: PublishStreamLogSchema,
-}).strict();
-export const PublishStreamSseDoneEventSchema = z.object({
+})
+    .strict();
+export const PublishStreamSseDoneEventSchema = z
+    .object({
     event: z.literal('done'),
     data: PublishStreamResultSchema,
-}).strict();
-export const PublishStreamSseResultEventSchema = z.object({
+})
+    .strict();
+export const PublishStreamSseResultEventSchema = z
+    .object({
     event: z.literal('result'),
     data: PublishStreamResultSchema,
-}).strict();
-export const PublishStreamSseErrorEventSchema = z.object({
+})
+    .strict();
+export const PublishStreamSseErrorEventSchema = z
+    .object({
     event: z.literal('error'),
     data: PublishStreamErrorSchema,
-}).strict();
-export const PublishStreamSseEventSchema = z.discriminatedUnion('event', [
+})
+    .strict();
+export const PublishStreamSseEventSchema = z
+    .discriminatedUnion('event', [
     PublishStreamSsePhaseEventSchema,
     PublishStreamSseLogEventSchema,
     PublishStreamSseDoneEventSchema,
     PublishStreamSseResultEventSchema,
     PublishStreamSseErrorEventSchema,
-]).transform((event) => {
+])
+    .transform((event) => {
     if (event.event === 'error') {
         throw new Error(event.data.message ?? 'Publish failed');
     }

package/dist/servers.d.ts

@@ -14,6 +14,7 @@ export interface ServerData {
     updatedAt: string | null;
 }
 export interface ServerMemberData {
+    organizationId?: string | null;
     id: number;
     name: string;
     email: string;
@@ -47,6 +48,7 @@ export declare class ServerInstance {
     }>;
     members(options?: ServerListOptions): Promise<PaginatedApiResponse<ServerMemberData>>;
     share(email: string): Promise<ServerMemberData>;
+    shareWithOrganization(organizationId: string): Promise<ServerMemberData>;
     revokeAccess(memberId: number): Promise<void>;
     refresh(): Promise<ServerInstance>;
     delete(): Promise<void>;

package/dist/servers.js

@@ -30,6 +30,10 @@ export class ServerInstance {
     async share(email) {
         return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, { email })).data;
     }
+    async shareWithOrganization(organizationId) {
+        return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, { organizationId }))
+            .data;
+    }
     async revokeAccess(memberId) {
         await this.client.delete(`/servers/${encodeURIComponent(this.data.id)}/members/${encodeURIComponent(String(memberId))}`);
     }
@@ -51,7 +55,7 @@ export class ServerInstance {
             if (server.data.status === 'failed') {
                 throw new Error(`Server provisioning failed: ${server.data.id}`);
             }
-            await new Promise(resolve => setTimeout(resolve, interval));
+            await new Promise((resolve) => setTimeout(resolve, interval));
         }
         throw new Error(`Server did not become ready within ${timeout}ms`);
     }

package/dist/shell.js

@@ -89,10 +89,13 @@ export class ShellProcess {
             stderr.fail(error);
         };
         const { abortSignal, ...payloadOpts } = opts;
-        this.completion = this.okra.invoke('shell.exec', { command, opts: { ...payloadOpts, id: this.id } }, { abortSignal }).then((result) => {
+        this.completion = this.okra
+            .invoke('shell.exec', { command, opts: { ...payloadOpts, id: this.id } }, { abortSignal })
+            .then((result) => {
             finish();
             return result;
-        }).catch((error) => {
+        })
+            .catch((error) => {
             fail(error);
             throw error;
         });

package/dist/socket/index.js

@@ -6,7 +6,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Transport_instances, _Transport_connect, _Transport_startPeriodicPing;
 import { nanoid } from 'nanoid';
 import { encode, decode } from '@msgpack/msgpack';
-import { PromiseTimeoutError, RemoteError, SendTimeoutError, TransportError, remoteError, } from '../errors/index.js';
+import { PromiseTimeoutError, RemoteError, SendTimeoutError, TransportError, remoteError } from '../errors/index.js';
 import { retry } from '../utils/retry.js';
 import * as ReconnectingWebSocketModule from 'reconnecting-websocket';
 import { timeout } from '../utils/promise.js';
@@ -14,11 +14,21 @@ import { describeWebSocketEvent } from '../utils/websocket.js';
 import WebSocket from 'isomorphic-ws';
 import { NamedDisposable } from '../utils/disposable.js';
 const SAFE_DEBUG_METADATA_KEYS = new Set([
-    'url', 'action', 'event', 'responseEvent', 'errorEvent', 'hasData',
-    'code', 'attempt', 'maxRetries', 'timeout', 'errorCount', 'byteLength',
+    'url',
+    'action',
+    'event',
+    'responseEvent',
+    'errorEvent',
+    'hasData',
+    'code',
+    'attempt',
+    'maxRetries',
+    'timeout',
+    'errorCount',
+    'byteLength',
 ]);
-const ReconnectingWebSocket = (ReconnectingWebSocketModule.default
-    ?? ReconnectingWebSocketModule);
+const ReconnectingWebSocket = (ReconnectingWebSocketModule
+    .default ?? ReconnectingWebSocketModule);
 export var SocketEvent;
 (function (SocketEvent) {
     SocketEvent["BootError"] = "Events.BootError";
@@ -66,9 +76,7 @@ export class Transport {
         // Validate configuration
         this.validateConfiguration(options);
         this.url = typeof url === 'string' ? new URL(url) : null;
-        const urlProvider = typeof url === 'string'
-            ? new URL(url).toString()
-            : async () => new URL(await url()).toString();
+        const urlProvider = typeof url === 'string' ? new URL(url).toString() : async () => new URL(await url()).toString();
         // Use configurable ping interval
         this.PING_INTERVAL = options.pingInterval ?? 30000;
         this.CONNECT_WAIT_TIMEOUT = options.connectWaitTimeout ?? 30000;
@@ -127,7 +135,7 @@ export class Transport {
     id() {
         return this.clientId;
     }
-    async registerWatchers() {
+    registerWatchers() {
         const onMessage = (ev) => {
             this.incomingMessageChain = this.incomingMessageChain
                 .catch(() => undefined)
@@ -306,7 +314,9 @@ export class Transport {
             this.eventEmitter.emit(event, this.clientId);
             return;
         }
-        event && this.eventEmitter.emit(as || event, data);
+        if (event) {
+            this.eventEmitter.emit(as || event, data);
+        }
     }
     listen(event, listener, _context) {
         return this.eventEmitter.listen(event, listener);
@@ -437,14 +447,16 @@ export class Transport {
             if (!options.timeout) {
                 return promise;
             }
-            return timeout(promise, options.timeout).catch((error) => {
+            return timeout(promise, options.timeout)
+                .catch((error) => {
                 if (error instanceof PromiseTimeoutError) {
                     throw SendTimeoutError.fromPromiseTimeoutError(error);
                 }
                 throw error;
-            }).finally(removeListeners);
+            })
+                .finally(removeListeners);
         };
-        const retries = options.retries === false ? 0 : options.retries ?? 0;
+        const retries = options.retries === false ? 0 : (options.retries ?? 0);
         return this.sendWithRetry(async () => await send(), retries);
     }
     send(action, data = {}) {

package/dist/telemetry.js

@@ -40,7 +40,9 @@ export class RuntimeTelemetry {
         }
     }
     synchronize() {
-        this.synchronization = this.synchronization.catch(() => { }).then(async () => {
+        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');
@@ -88,13 +90,16 @@ export function watchRuntimeTelemetry(okra, telemetry, feature, event, transform
                 }
                 options.signal.addEventListener('abort', abort, { once: true });
             }
-            void telemetry.acquire(feature).then(async (releaseTelemetry) => {
+            void telemetry
+                .acquire(feature)
+                .then(async (releaseTelemetry) => {
                 if (closed) {
                     await releaseTelemetry();
                     return;
                 }
                 release = releaseTelemetry;
-            }).catch((error) => {
+            })
+                .catch((error) => {
                 if (!closed) {
                     closed = true;
                     subscription?.dispose();

package/dist/terminal.js

@@ -1,6 +1,7 @@
 import { nanoid } from 'nanoid';
 import { once } from './utils/promise.js';
 const TERMINAL_INPUT_FLUSH_DELAY_MS = 8;
+// eslint-disable-next-line no-control-regex -- Terminal control bytes intentionally trigger an immediate flush.
 const terminalInputFlushPattern = /[\x00-\x1f\x7f]/;
 export default class Terminals {
     constructor(okra) {
@@ -12,9 +13,7 @@ export default class Terminals {
     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 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', {
@@ -135,7 +134,7 @@ export default class Terminals {
             return this.okra.invoke('terminal.close', { id });
         });
         const resize = (dimensions) => {
-            this.okra.invoke('terminal.resize', { id, width: dimensions.cols, height: dimensions.rows });
+            return this.okra.invoke('terminal.resize', { id, width: dimensions.cols, height: dimensions.rows });
         };
         if (abortSignal && !abortSignal.aborted) {
             abortHandler = () => {

package/dist/utils/promise.js

@@ -5,7 +5,7 @@
  * @param time
  * @param exception
  */
-import { PromiseTimeoutError } from "../errors/index.js";
+import { PromiseTimeoutError } from '../errors/index.js';
 export const timeout = (prom, time) => {
     let timer;
     return Promise.race([

package/dist/utils/websocket.js

@@ -2,12 +2,12 @@ const getReadyStateLabel = (state) => {
     if (typeof state !== 'number') {
         return undefined;
     }
-    return {
+    return ({
         0: 'CONNECTING',
         1: 'OPEN',
         2: 'CLOSING',
         3: 'CLOSED',
-    }[state] ?? `STATE_${state}`;
+    }[state] ?? `STATE_${state}`);
 };
 const sanitizeWebSocketUrl = (value) => {
     try {