@phpsandbox/sdk 0.0.65 → 0.0.67

package/dist/deployments.d.ts

@@ -153,6 +153,8 @@ export interface DeploymentData<TProvider extends DeploymentTargetProvider = Dep
     strategy: string;
     targetProvider: TProvider;
     options: DeploymentOptionsForProvider<TProvider>;
+    eventStreamUrl?: string | null;
+    /** @deprecated Use eventStreamUrl instead. */
     okraUrl: string | null;
     originUrl: string | null;
     currentRelease?: DeploymentReleaseData | null;

package/dist/deployments.js

@@ -124,8 +124,9 @@ export class DeploymentRun {
         if (this.started) {
             return this;
         }
-        if (!this.initial.data.okraUrl) {
-            throw new Error(`Deployment ${this.initial.data.id} has no okraUrl for SSE streaming`);
+        const eventStreamUrl = this.initial.data.eventStreamUrl ?? this.initial.data.okraUrl;
+        if (!eventStreamUrl) {
+            throw new Error(`Deployment ${this.initial.data.id} has no eventStreamUrl for SSE streaming`);
         }
         this.started = true;
         this.resultPromise = new Promise((resolve, reject) => {
@@ -133,7 +134,7 @@ export class DeploymentRun {
             this.rejectResult = reject;
         });
         this.resultPromise.catch(() => undefined);
-        void this.consumeStream(this.initial.data.okraUrl);
+        void this.consumeStream(eventStreamUrl);
         return this;
     }
     subscribe() {
@@ -152,9 +153,9 @@ export class DeploymentRun {
         }
         return queue;
     }
-    async consumeStream(okraUrl) {
+    async consumeStream(eventStreamUrl) {
         try {
-            const stream = await this.client.sse(okraUrl);
+            const stream = await this.client.sse(eventStreamUrl);
             for await (const event of readDeployStreamEvents(stream)) {
                 this.publish(event);
                 if (event.type === 'result') {

package/dist/errors/index.d.ts

@@ -9,3 +9,6 @@ export declare class NotebookUnavailableError extends Error {
     readonly raw: object;
     constructor(message?: string, raw?: object);
 }
+export declare class UnsupportedRuntimeTransportError extends Error {
+    constructor(message: string);
+}

package/dist/errors/index.js

@@ -16,3 +16,9 @@ export class NotebookUnavailableError extends Error {
         this.name = 'NotebookUnavailableError';
     }
 }
+export class UnsupportedRuntimeTransportError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnsupportedRuntimeTransportError';
+    }
+}

package/dist/filesystem.d.ts

@@ -451,8 +451,8 @@ declare class FilesystemSubscription {
 export declare class Filesystem {
     protected okra: NotebookInstance;
     private watches;
-    constructor(okra: NotebookInstance);
-    private watchOkraConnection;
+    constructor(okra: NotebookInstance, registerReconnect?: ((handler: () => void) => Disposable) | null);
+    private registerReconnectHandler;
     info(path: string): Promise<FileInfo>;
     write(path: string, contents: string): Promise<boolean>;
     find(query: string, options?: Partial<FileSearchOptions>): Promise<FileResult[]>;

package/dist/filesystem.js

@@ -69,13 +69,16 @@ class FilesystemSubscription {
     }
 }
 export class Filesystem {
-    constructor(okra) {
+    constructor(okra, registerReconnect = (handler) => okra.onDidConnect(handler)) {
         this.okra = okra;
         this.watches = new Map();
-        this.watchOkraConnection();
+        this.registerReconnectHandler(registerReconnect);
     }
-    watchOkraConnection() {
-        this.okra.onDidConnect(() => {
+    registerReconnectHandler(registerReconnect) {
+        if (registerReconnect === null) {
+            return;
+        }
+        registerReconnect(() => {
             for (const { path, options } of this.watches.values()) {
                 void this.okra.invoke('fs.watch', { path, options }).catch(() => { });
             }

package/dist/index.d.ts

@@ -307,12 +307,18 @@ export interface PHPSandboxClientOptions {
     telemetry?: Set<TelemetryFeature>;
     fetch?: typeof globalThis.fetch;
     webSocket?: unknown;
+    runtimeUrlProvider?: (notebookId: string) => Promise<string>;
+    /** @deprecated Use runtimeUrlProvider instead. */
+    okraUrlProvider?: (notebookId: string) => Promise<string>;
 }
+export type RuntimeTransport = 'realtime' | 'rest';
 export declare class Client {
     readonly notebook: NotebookApi;
     readonly deployments: DeploymentApi;
     readonly servers: ServerApi;
     readonly options: PHPSandboxClientOptions;
+    protected runtimeTransportValue: RuntimeTransport;
+    get runtimeTransport(): RuntimeTransport;
     private readonly fetch;
     private readonly baseUrl;
     private readonly headers;
@@ -334,6 +340,8 @@ export declare class Client {
     private makeRequest;
 }
 export declare class PHPSandbox extends Client {
+    static realtime(token: string, url?: string, options?: PHPSandboxClientOptions): PHPSandbox;
+    static rest(token: string, url?: string, options?: PHPSandboxClientOptions): PHPSandbox;
 }
 export declare class NotebookSecretApi {
     private readonly client;
@@ -371,6 +379,8 @@ export declare class NotebookMailApi {
 }
 export interface NotebookData {
     id: string;
+    runtimeUrl?: string;
+    /** @deprecated Use runtimeUrl instead. */
     okraUrl: string;
     gitUrl: string;
     type?: string;
@@ -400,8 +410,10 @@ export declare class NotebookInstance {
     readonly preview: NotebookPreview;
     readonly mail: NotebookMail;
     private readonly socket;
+    private readonly restInvoker;
     readonly emitter: EventDispatcher;
     initialized: NotebookInitResult | false;
+    get runtimeTransport(): RuntimeTransport;
     private readonly disposables;
     constructor(data: NotebookData, client: Client);
     ready(): Promise<NotebookInitSuccessResult>;
@@ -425,10 +437,12 @@ export declare class NotebookInstance {
     onDidConnect(handler: () => void): Disposable;
     onDidDisconnect(handler: () => void): Disposable;
     onDidBootError(handler: (error: NotebookUnavailableError) => void): Disposable;
+    private restInitialization;
     update(input: Partial<UpdateNotebookInput>): Promise<NotebookInstance>;
     onDidInitialize(handler: (result: NotebookInitResult) => void): Disposable;
     reconnect(): Promise<NotebookInstance>;
     beacon(iframe: HTMLIFrameElement, options?: BeaconOptions): Promise<Beacon>;
+    private realtimeSocket;
 }
 export declare class NotebookSecrets {
     private readonly client;

package/dist/index.js

@@ -26,9 +26,10 @@ import { Transport } from './socket/index.js';
 import EventManager from './events/index.js';
 import Git from './git.js';
 import { createBeacon } from './beacon/index.js';
-import { NotebookUnavailableError } from './errors/index.js';
+import { NotebookUnavailableError, UnsupportedRuntimeTransportError } from './errors/index.js';
 import { DeploymentApi, NotebookDeploymentApi } from './deployments.js';
 import { ServerApi } from './servers.js';
+import { RestRuntimeInvoker } from './runtime/rest.js';
 export * from './types.js';
 export { Transport } from './socket/index.js';
 export * from './lsp.js';
@@ -150,7 +151,11 @@ function normalizeApiBaseUrl(url) {
     return baseUrl.toString();
 }
 export class Client {
+    get runtimeTransport() {
+        return this.runtimeTransportValue;
+    }
     constructor(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
+        this.runtimeTransportValue = 'realtime';
         this.fetch = globalThis.fetch;
         this.deployments = new DeploymentApi(this);
         this.notebook = new NotebookApi(this);
@@ -224,6 +229,14 @@ export class Client {
     }
 }
 export class PHPSandbox extends Client {
+    static realtime(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
+        return new PHPSandbox(token, url, options);
+    }
+    static rest(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
+        const client = new PHPSandbox(token, url, options);
+        client.runtimeTransportValue = 'rest';
+        return client;
+    }
 }
 export class NotebookSecretApi {
     constructor(client) {
@@ -324,22 +337,46 @@ export class NotebookMailApi {
     }
 }
 export class NotebookInstance {
+    get runtimeTransport() {
+        return this.client.runtimeTransport;
+    }
     constructor(data, client) {
         _NotebookInstance_instances.add(this);
         this.data = data;
         this.client = client;
         this.initialized = false;
-        _NotebookInstance_initPromise.set(this, void 0);
+        _NotebookInstance_initPromise.set(this, null);
         this.disposables = [];
+        const runtimeUrl = data.runtimeUrl ?? data.okraUrl;
+        const runtimeUrlProvider = client.options.runtimeUrlProvider ?? client.options.okraUrlProvider;
         this.emitter = EventManager.createInstance();
-        this.socket = new Transport(data.okraUrl, this.emitter, {
-            debug: client.options.debug,
-            startClosed: client.options.startClosed,
-            webSocket: client.options.webSocket,
-        });
-        this.watchConnection();
-        __classPrivateFieldSet(this, _NotebookInstance_initPromise, __classPrivateFieldGet(this, _NotebookInstance_instances, "m", _NotebookInstance_init).call(this), "f");
-        this.file = new Filesystem(this);
+        if (client.runtimeTransport === 'rest') {
+            this.socket = null;
+            this.restInvoker = new RestRuntimeInvoker(data, client.options.fetch ?? globalThis.fetch, runtimeUrlProvider === undefined
+                ? undefined
+                : () => runtimeUrlProvider(data.id));
+        }
+        else {
+            this.restInvoker = null;
+            let initialConnection = true;
+            const connectionUrl = runtimeUrlProvider === undefined
+                ? runtimeUrl
+                : async () => {
+                    if (initialConnection) {
+                        initialConnection = false;
+                        return runtimeUrl;
+                    }
+                    return runtimeUrlProvider(data.id);
+                };
+            this.socket = new Transport(connectionUrl, this.emitter, {
+                debug: client.options.debug,
+                startClosed: client.options.startClosed,
+                webSocket: client.options.webSocket,
+            });
+            this.watchConnection();
+            __classPrivateFieldSet(this, _NotebookInstance_initPromise, __classPrivateFieldGet(this, _NotebookInstance_instances, "m", _NotebookInstance_init).call(this), "f");
+        }
+        this.file = new Filesystem(this, this.socket === null ? null : (handler) => this.onDidConnect(handler));
         this.terminal = new Terminal(this);
         this.auth = new Auth(this);
         this.lsp = new Lsp(this);
@@ -357,7 +394,11 @@ export class NotebookInstance {
         this.mail = new NotebookMail(client, this.data.id);
     }
     async ready() {
-        const terminalError = this.socket.getTerminalError();
+        if (this.restInvoker !== null) {
+            return this.restInitialization();
+        }
+        const socket = this.realtimeSocket();
+        const terminalError = socket.getTerminalError();
         if (terminalError) {
             throw terminalError;
         }
@@ -366,8 +407,8 @@ export class NotebookInstance {
              * If ready is called, ensure the websocket is open so server-driven
              * initialization can begin, but do not block on an extra ping roundtrip.
              */
-            if (this.client.options.startClosed && !this.socket.isConnected) {
-                await this.socket.connect();
+            if (this.client.options.startClosed && !socket.isConnected) {
+                await socket.connect();
             }
             return __classPrivateFieldGet(this, _NotebookInstance_initPromise, "f");
         };
@@ -389,7 +430,7 @@ export class NotebookInstance {
     }
     delete() {
         return this.client.notebook.delete(this.data.id).then(() => {
-            this.socket.terminate(new NotebookUnavailableError('Notebook has been deleted.', { id: this.data.id }));
+            this.socket?.terminate(new NotebookUnavailableError('Notebook has been deleted.', { id: this.data.id }));
         });
     }
     stop() {
@@ -399,10 +440,19 @@ export class NotebookInstance {
         return this.container.restart();
     }
     invoke(action, data = {}, options = {}) {
-        return this.socket.invoke(action, data || {}, options);
+        if (this.restInvoker !== null) {
+            if (this.restInvoker.supports(String(action))) {
+                void this.restInitialization();
+            }
+            return this.restInvoker.invoke(action, data || {}, options);
+        }
+        return this.realtimeSocket().invoke(action, data || {}, options);
     }
     send(action, data = {}) {
-        return this.socket.send(action, data || {});
+        if (this.restInvoker !== null) {
+            return this.restInvoker.send();
+        }
+        return this.realtimeSocket().send(action, data || {});
     }
     ping() {
         return this.invoke('ping');
@@ -414,7 +464,9 @@ export class NotebookInstance {
     }
     dispose() {
         this.disposables.forEach((d) => d.dispose());
-        !this.socket.isClosed && this.socket.disconnect();
+        if (this.socket !== null && !this.socket.isClosed) {
+            this.socket.disconnect();
+        }
     }
     connected() {
         return this.waitForSocketConnection({ rejectOnClose: true });
@@ -423,11 +475,12 @@ export class NotebookInstance {
         return this.waitForSocketConnection({ rejectOnClose: false });
     }
     waitForSocketConnection(options) {
-        const terminalError = this.socket.getTerminalError();
+        const socket = this.realtimeSocket();
+        const terminalError = socket.getTerminalError();
         if (terminalError) {
             return Promise.reject(terminalError);
         }
-        if (this.socket.isConnected) {
+        if (socket.isConnected) {
             return Promise.resolve(this);
         }
         return new Promise((resolve, reject) => {
@@ -448,11 +501,11 @@ export class NotebookInstance {
                 callback();
             };
             try {
-                disposables.push(this.socket.onDidConnect(() => settle(() => resolve(this))));
+                disposables.push(socket.onDidConnect(() => settle(() => resolve(this))));
                 if (options.rejectOnClose) {
-                    disposables.push(this.socket.onDidClose(() => settle(() => reject(new Error('Connection closed')))));
+                    disposables.push(socket.onDidClose(() => settle(() => reject(new Error('Connection closed')))));
                 }
-                disposables.push(this.socket.onDidBootError((error) => settle(() => reject(error))));
+                disposables.push(socket.onDidBootError((error) => settle(() => reject(error))));
             }
             catch (e) {
                 settle(() => reject(e));
@@ -460,38 +513,54 @@ export class NotebookInstance {
         });
     }
     watchConnection() {
-        this.socket.onDidConnect(() => {
-            this.socket.emit('okra.connected');
+        const socket = this.realtimeSocket();
+        socket.onDidConnect(() => {
+            socket.emit('okra.connected');
             if (this.client.options.telemetry) {
                 this.container.enableTelemetry(this.client.options.telemetry);
             }
         });
-        this.socket.onDidClose(() => {
-            this.socket.emit('okra.disconnected');
+        socket.onDidClose(() => {
+            socket.emit('okra.disconnected');
             this.initialized = false;
         });
-        this.socket.onDidBootError((error) => {
-            this.socket.emit('okra.boot_error', error);
-            this.socket.emit('okra.disconnected');
+        socket.onDidBootError((error) => {
+            socket.emit('okra.boot_error', error);
+            socket.emit('okra.disconnected');
             this.initialized = false;
         });
     }
     onDidConnect(handler) {
-        this.socket.removeListener('okra.connected', handler);
-        const disposable = this.socket.listen('okra.connected', handler);
+        const socket = this.realtimeSocket();
+        socket.removeListener('okra.connected', handler);
+        const disposable = socket.listen('okra.connected', handler);
         this.disposables.push(disposable);
         return disposable;
     }
     onDidDisconnect(handler) {
-        const disposable = this.socket.listen('okra.disconnected', handler);
+        const disposable = this.realtimeSocket().listen('okra.disconnected', handler);
         this.disposables.push(disposable);
         return disposable;
     }
     onDidBootError(handler) {
-        const disposable = this.socket.listen('okra.boot_error', handler);
+        const disposable = this.realtimeSocket().listen('okra.boot_error', handler);
         this.disposables.push(disposable);
         return disposable;
     }
+    restInitialization() {
+        if (this.restInvoker === null) {
+            throw new UnsupportedRuntimeTransportError('This operation requires the REST transport.');
+        }
+        if (__classPrivateFieldGet(this, _NotebookInstance_initPromise, "f") === null) {
+            __classPrivateFieldSet(this, _NotebookInstance_initPromise, this.restInvoker.ready().then((result) => {
+                this.initialized = result;
+                this.emitter.emit('notebook.initialized', result);
+                return result;
+            }), "f");
+            void __classPrivateFieldGet(this, _NotebookInstance_initPromise, "f").catch(() => { });
+        }
+        return __classPrivateFieldGet(this, _NotebookInstance_initPromise, "f");
+    }
     update(input) {
         return this.client.notebook.update(this.data.id, input);
     }
@@ -499,10 +568,11 @@ export class NotebookInstance {
         return this.listen('notebook.initialized', handler);
     }
     async reconnect() {
+        const socket = this.realtimeSocket();
         const whenConnected = this.whenConnected();
         // Use the socket's reconnect method which preserves listeners
         // and uses the underlying ReconnectingWebSocket mechanism
-        this.socket.reconnect();
+        socket.reconnect();
         // Reset initialization state
         this.initialized = false;
         // Wait for the socket to reconnect
@@ -517,6 +587,12 @@ export class NotebookInstance {
         iframe.src = result.data.previewUrl;
         return createBeacon(iframe, options);
     }
+    realtimeSocket() {
+        if (this.socket === null) {
+            throw new UnsupportedRuntimeTransportError('This operation requires the realtime transport.');
+        }
+        return this.socket;
+    }
 }
 _NotebookInstance_initPromise = new WeakMap(), _NotebookInstance_instances = new WeakSet(), _NotebookInstance_init = function _NotebookInstance_init() {
     __classPrivateFieldSet(this, _NotebookInstance_initPromise, new Promise((resolve, reject) => {

package/dist/runtime/rest.d.ts

@@ -0,0 +1,20 @@
+import type { CallOption, Invokable, NotebookData, NotebookInitSuccessResult } from '../index.js';
+type RestRuntimeAction = keyof Invokable | 'runtime.ready';
+export declare class RestRuntimeInvoker {
+    private readonly fetch;
+    private readonly refresh?;
+    private actionUrl;
+    private ticket;
+    private refreshPromise;
+    private readonly notebookId;
+    constructor(data: NotebookData, fetch: typeof globalThis.fetch, refresh?: () => Promise<string>);
+    private configure;
+    ready(): Promise<NotebookInitSuccessResult>;
+    supports(action: string): action is RestRuntimeAction;
+    invoke<T extends keyof Invokable>(action: T, data?: Invokable[T]['args'], options?: CallOption): Promise<Invokable[T]['response']>;
+    send(): never;
+    private invokeRaw;
+    private request;
+    private refreshAuthorization;
+}
+export {};