@phpsandbox/sdk 0.0.68 → 0.1.1

package/dist/filesystem.d.ts

@@ -454,7 +454,8 @@ export declare class Filesystem {
     constructor(okra: NotebookInstance, registerReconnect?: ((handler: () => void) => Disposable) | null);
     private registerReconnectHandler;
     info(path: string): Promise<FileInfo>;
-    write(path: string, contents: string): Promise<boolean>;
+    write(path: string, contents: string | Uint8Array | ReadableStream<Uint8Array>, options?: FileWriteOptions): Promise<boolean>;
+    read(path: string): ReadableStream<Uint8Array>;
     find(query: string, options?: Partial<FileSearchOptions>): Promise<FileResult[]>;
     search(query: TextSearchQuery, options?: Partial<TextSearchOptions>, onMatch?: (result: TextSearchResult | false) => boolean | Promise<boolean> | void | Promise<void>): Promise<[boolean, TextSearchMatch[]]>;
     mkdir(path: string): Promise<boolean>;

package/dist/filesystem.js

@@ -87,8 +87,26 @@ export class Filesystem {
     info(path) {
         return this.okra.invoke('fs.info', { path });
     }
-    write(path, contents) {
-        return this.okra.invoke('fs.write', { path, contents: contents });
+    async write(path, contents, options = { overwrite: true, create: true, unlock: false, atomic: false }) {
+        if (typeof contents === 'string') {
+            return this.okra.invoke('fs.write', { path, contents });
+        }
+        const bytes = contents instanceof Uint8Array ? contents : await collectBytes(contents);
+        await this.writeFile(path, bytes, options);
+        return true;
+    }
+    read(path) {
+        return new ReadableStream({
+            start: async (controller) => {
+                try {
+                    controller.enqueue(await this.readFile(path));
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
     }
     find(query, options = {
         useIgnoreFiles: false,
@@ -275,3 +293,18 @@ export class Filesystem {
         throw e;
     }
 }
+async function collectBytes(stream) {
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+        length += chunk.byteLength;
+    }
+    const output = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        output.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return output;
+}

package/dist/index.d.ts

@@ -1,24 +1,21 @@
 import { Filesystem, FilesystemActions, FilesystemEvents } from './filesystem.js';
-import Terminal, { TerminalEvents, TerminalActions } from './terminal.js';
+import Terminal, { TerminalEvents, TerminalActions, type SpawnOptions } from './terminal.js';
 import Container, { ContainerActions, ContainerEvents, PortInfo, TelemetryFeature } from './container.js';
 import Auth, { AuthActions } from './auth.js';
 import Lsp, { LspActions, LspEvents } from './lsp.js';
 import Composer, { ComposerActions, ComposerEvents } from './composer.js';
 import Log, { LogActions, LogEvents } from './log.js';
-import Laravel, { LaravelActions, LaravelEvents } from './laravel.js';
 import Repl, { ReplActions, ReplEvents } from './repl.js';
-import Shell, { ShellEvents, ShellActions } from './shell.js';
+import Shell, { ShellEvents, ShellActions, type ShellProcess } from './shell.js';
 import Services, { ServiceActions, ServiceEvents } from './services.js';
 import Config, { ConfigActions } from './config.js';
 import { EventDispatcher } from './events/index.js';
 import Git, { GitActions, GitCredentials, GitEvents } from './git.js';
 import { Disposable } from './types.js';
-import { Beacon, BeaconOptions } from './beacon/index.js';
 import { NotebookUnavailableError } from './errors/index.js';
-import { DeploymentApi, NotebookDeploymentApi, type DeploymentInstance, type DeploymentRun, type PublishInput } from './deployments.js';
+import { PublicationApi, NotebookPublicationApi, type PublicationInstance, type PublicationRun, type PublishInput } from './publications.js';
 import { ServerApi } from './servers.js';
 export * from './types.js';
-export { Transport } from './socket/index.js';
 export * from './lsp.js';
 export * from './filesystem.js';
 export * from './container.js';
@@ -28,9 +25,8 @@ export * from './git.js';
 export * from './services.js';
 export * from './config.js';
 export * from './utils/promise.js';
-export * from './beacon/index.js';
 export * from './errors/index.js';
-export * from './deployments.js';
+export * from './publications.js';
 export * from './servers.js';
 interface Result<TType extends 'success' | 'error' | 'running', TData extends object> {
     type: TType;
@@ -100,11 +96,11 @@ export interface Action<Args = object, Response = void> {
     args: Args;
     response: Response;
 }
-export type Events = TerminalEvents & ContainerEvents & LspEvents & ComposerEvents & LogEvents & ServiceEvents & LaravelEvents & NotebookEvents & ReplEvents & ShellEvents & FilesystemEvents & GitEvents;
+export type Events = TerminalEvents & ContainerEvents & LspEvents & ComposerEvents & LogEvents & ServiceEvents & NotebookEvents & ReplEvents & ShellEvents & FilesystemEvents & GitEvents;
 interface SystemActions {
     ping: Action<object, 'pong'>;
 }
-export type Invokable = SystemActions & TerminalActions & ContainerActions & FilesystemActions & AuthActions & LspActions & LaravelActions & ComposerActions & LogActions & ServiceActions & ConfigActions & NotebookActions & ReplActions & ShellActions & GitActions;
+export type Invokable = SystemActions & TerminalActions & ContainerActions & FilesystemActions & AuthActions & LspActions & ComposerActions & LogActions & ServiceActions & ConfigActions & NotebookActions & ReplActions & ShellActions & GitActions;
 export interface CreateNotebookImportAuthInput {
     access_token: string;
 }
@@ -289,15 +285,14 @@ export declare class NotebookApi {
     readonly composerCredentials: NotebookComposerCredentialApi;
     readonly preview: NotebookPreviewApi;
     readonly mail: NotebookMailApi;
-    readonly deployment: NotebookDeploymentApi;
+    readonly publication: NotebookPublicationApi;
     constructor(client: Client);
     create(template: string, input?: Partial<CreateNotebookInput>, init?: boolean): Promise<NotebookInstance>;
     get(id: string): Promise<NotebookInstance>;
     update(id: string, input?: Partial<UpdateNotebookInput>): Promise<NotebookInstance>;
-    delete(id: string): Promise<void>;
+    destroy(id: string): Promise<void>;
     fork(id: string, input?: Partial<ForkNotebookInput>): Promise<NotebookInstance>;
     gitCredentials(id: string): Promise<GitCredentials>;
-    open(id: string): Promise<NotebookInstance>;
     openFromData(data: NotebookData): Promise<NotebookInstance>;
     private init;
 }
@@ -312,7 +307,7 @@ export interface PHPSandboxClientOptions {
 export type RuntimeTransport = 'realtime' | 'rest';
 export declare class Client {
     readonly notebook: NotebookApi;
-    readonly deployments: DeploymentApi;
+    readonly publications: PublicationApi;
     readonly servers: ServerApi;
     readonly options: PHPSandboxClientOptions;
     protected runtimeTransportValue: RuntimeTransport;
@@ -397,7 +392,6 @@ export declare class NotebookInstance {
     readonly log: Log;
     readonly repl: Repl;
     readonly container: Container;
-    readonly laravel: Laravel;
     readonly shell: Shell;
     readonly git: Git;
     readonly services: Services;
@@ -414,10 +408,12 @@ export declare class NotebookInstance {
     constructor(data: NotebookData, client: Client);
     ready(): Promise<NotebookInitSuccessResult>;
     fork(input?: Partial<ForkNotebookInput>): Promise<NotebookInstance>;
-    deployment(): Promise<DeploymentInstance | null>;
-    publish(input?: PublishInput): Promise<DeploymentRun>;
+    publication(): Promise<PublicationInstance | null>;
+    publish(input: PublishInput): Promise<PublicationRun>;
+    run(command: string | string[], opts?: SpawnOptions): ShellProcess;
+    run(command: string, args: string[], opts?: SpawnOptions): ShellProcess;
     gitCredentials(): Promise<GitCredentials>;
-    delete(): Promise<void>;
+    destroy(): Promise<void>;
     stop(): Promise<void>;
     restart(): Promise<void>;
     invoke<T extends keyof Invokable>(action: T, data?: Invokable[T]['args'], options?: CallOption): Promise<Invokable[T]['response']>;
@@ -437,7 +433,6 @@ export declare class NotebookInstance {
     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 {

package/dist/index.js

@@ -17,7 +17,6 @@ import Auth from './auth.js';
 import Lsp from './lsp.js';
 import Composer from './composer.js';
 import Log from './log.js';
-import Laravel from './laravel.js';
 import Repl from './repl.js';
 import Shell from './shell.js';
 import Services from './services.js';
@@ -25,13 +24,11 @@ import Config from './config.js';
 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, UnsupportedRuntimeTransportError } from './errors/index.js';
-import { DeploymentApi, NotebookDeploymentApi } from './deployments.js';
+import { PublicationApi, NotebookPublicationApi } from './publications.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';
 export * from './filesystem.js';
 export * from './container.js';
@@ -41,9 +38,8 @@ export * from './git.js';
 export * from './services.js';
 export * from './config.js';
 export * from './utils/promise.js';
-export * from './beacon/index.js';
 export * from './errors/index.js';
-export * from './deployments.js';
+export * from './publications.js';
 export * from './servers.js';
 function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
@@ -101,7 +97,7 @@ export class NotebookApi {
         this.composerCredentials = new NotebookComposerCredentialApi(client);
         this.preview = new NotebookPreviewApi(client);
         this.mail = new NotebookMailApi(client);
-        this.deployment = new NotebookDeploymentApi(client);
+        this.publication = new NotebookPublicationApi(client);
     }
     async create(template, input = {}, init = true) {
         const response = await this.client.post('/notebook', { template, ...input });
@@ -119,7 +115,7 @@ export class NotebookApi {
         const response = await this.client.put(`/notebook/${id}`, input);
         return new NotebookInstance(response.data, this.client);
     }
-    async delete(id) {
+    async destroy(id) {
         await this.client.delete(`/notebook/${id}`);
     }
     async fork(id, input = {}) {
@@ -130,10 +126,6 @@ export class NotebookApi {
         const response = await this.client.post(`/notebook/${id}/git/credentials`);
         return response.data;
     }
-    async open(id) {
-        const response = await this.client.get(`/notebook/${id}`);
-        return new NotebookInstance(response.data, this.client);
-    }
     openFromData(data) {
         return this.init(new NotebookInstance(data, this.client));
     }
@@ -157,7 +149,7 @@ export class Client {
     constructor(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
         this.runtimeTransportValue = 'realtime';
         this.fetch = globalThis.fetch;
-        this.deployments = new DeploymentApi(this);
+        this.publications = new PublicationApi(this);
         this.notebook = new NotebookApi(this);
         this.servers = new ServerApi(this);
         this.options = Object.assign({ startClosed: true }, options);
@@ -383,7 +375,6 @@ export class NotebookInstance {
         this.log = new Log(this);
         this.repl = new Repl(this);
         this.container = new Container(this);
-        this.laravel = new Laravel(this);
         this.shell = new Shell(this);
         this.git = new Git(this, client);
         this.services = new Services(this);
@@ -418,17 +409,23 @@ export class NotebookInstance {
     fork(input = {}) {
         return this.client.notebook.fork(this.data.id, input);
     }
-    deployment() {
-        return this.client.notebook.deployment.current(this.data.id);
+    publication() {
+        return this.client.notebook.publication.current(this.data.id);
     }
     publish(input) {
-        return this.client.notebook.deployment.publish(this.data.id, input);
+        return this.client.notebook.publication.publish(this.data.id, input);
+    }
+    run(command, argsOrOpts = [], opts) {
+        if (Array.isArray(argsOrOpts)) {
+            return this.shell.run(command, argsOrOpts, opts);
+        }
+        return this.shell.run(command, argsOrOpts);
     }
     gitCredentials() {
         return this.client.notebook.gitCredentials(this.data.id);
     }
-    delete() {
-        return this.client.notebook.delete(this.data.id).then(() => {
+    destroy() {
+        return this.client.notebook.destroy(this.data.id).then(() => {
             this.socket?.terminate(new NotebookUnavailableError('Notebook has been deleted.', { id: this.data.id }));
         });
     }
@@ -581,11 +578,6 @@ export class NotebookInstance {
         // Wait for initialization to complete
         return this.ready().then(() => this);
     }
-    async beacon(iframe, options) {
-        const result = await this.ready();
-        iframe.src = result.data.previewUrl;
-        return createBeacon(iframe, options);
-    }
     realtimeSocket() {
         if (this.socket === null) {
             throw new UnsupportedRuntimeTransportError('This operation requires the realtime transport.');

package/dist/publications.d.ts

@@ -0,0 +1,222 @@
+import { type Client, type SecretRef } from './index.js';
+import type { PublicationBuildStatus, PublicationDomainDnsRecordType, PublicationEventData, PublicationJurisdiction, PublicationLogChunkData, PublicationProtectionMode, PublicationRegion, PublicationReleaseStatus, PublicationSize, PublicationStatus, PublishStreamEvent, PublishStreamResult } from './schemas/publications.js';
+export * from './schemas/publications.js';
+export interface PublicationPlacement {
+    regions?: PublicationRegion[];
+    jurisdiction?: PublicationJurisdiction;
+}
+export type LaravelCloudRegion = 'us-east-2' | 'us-east-1' | 'ca-central-1' | 'eu-central-1' | 'eu-west-1' | 'eu-west-2' | 'me-central-1' | 'ap-southeast-1' | 'ap-southeast-2' | 'ap-northeast-1';
+export interface PublicationProtectionData {
+    mode: PublicationProtectionMode;
+    enabled: boolean;
+    token?: string;
+    expiresAt?: string;
+    url?: string;
+}
+export interface PublicationFeedbackData {
+    enabled: boolean;
+    config: Record<string, unknown>;
+}
+export type PublicationProtectionInput = {
+    mode: 'none';
+    password?: never;
+} | {
+    mode: 'password';
+    password: string;
+};
+export interface PublicationFeedbackInput {
+    enabled: boolean;
+    config?: Record<string, unknown>;
+}
+export interface CloudflareContainersProviderOptions {
+    size?: PublicationSize;
+    sleepAfter?: string;
+    placement?: PublicationPlacement;
+    instances?: number;
+}
+export interface SshServerProviderOptions {
+    serverId: string;
+}
+export interface LaravelCloudProviderData {
+    region?: LaravelCloudRegion;
+    repository?: string;
+    branch?: string;
+    sourceControlProviderType?: 'github' | 'gitlab' | 'bitbucket';
+    apiKeyConfigured?: boolean;
+}
+export interface LaravelCloudProviderInput {
+    apiKey: SecretRef;
+    region?: LaravelCloudRegion;
+}
+export interface PublicationProviderInputs {
+    'cloudflare-containers': CloudflareContainersProviderOptions;
+    'ssh-server': SshServerProviderOptions;
+    'laravel-cloud': LaravelCloudProviderInput;
+}
+export interface PublicationProviderData {
+    'cloudflare-containers': CloudflareContainersProviderOptions;
+    'ssh-server': SshServerProviderOptions;
+    'laravel-cloud': LaravelCloudProviderData;
+}
+export type PublicationProviderName = Extract<keyof PublicationProviderInputs, string>;
+export type PublicationProviderInput<TName extends PublicationProviderName = PublicationProviderName> = {
+    [Name in TName]: {
+        name: Name;
+    } & PublicationProviderInputs[Name];
+}[TName];
+export type PublicationProvider<TName extends PublicationProviderName = PublicationProviderName> = {
+    [Name in TName]: {
+        name: Name;
+    } & PublicationProviderData[Name];
+}[TName];
+export interface PublishInput<TName extends PublicationProviderName = PublicationProviderName> {
+    slug: string;
+    provider: PublicationProviderInput<TName>;
+    protection?: PublicationProtectionInput;
+    feedback?: PublicationFeedbackInput;
+    metadata?: Record<string, unknown>;
+}
+export interface PublicationBuildData<TProvider extends PublicationProviderName = PublicationProviderName> {
+    id: string;
+    status: PublicationBuildStatus;
+    strategy: string;
+    provider: PublicationProvider<TProvider>;
+    errorMessage: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+}
+export interface PublicationReleaseData {
+    id: string;
+    status: PublicationReleaseStatus;
+    manifest: Record<string, unknown>;
+}
+export interface PublicationDomainDnsData {
+    type: PublicationDomainDnsRecordType;
+    name: string;
+    value: string;
+}
+export interface PublicationDomainData {
+    id: string;
+    publicationId: string | null;
+    hostname: string;
+    status: string;
+    provider: string;
+    providerHostnameId: string | null;
+    dns: PublicationDomainDnsData;
+    ssl: {
+        status: string | null;
+    };
+    validationErrors: unknown[];
+    validationRecords: unknown[];
+    metadata: Record<string, unknown>;
+    verifiedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+export interface CreatePublicationDomainInput {
+    hostname: string;
+}
+export interface PublicationData<TProvider extends PublicationProviderName = PublicationProviderName> {
+    id: string;
+    slug: string;
+    url: string;
+    status: PublicationStatus;
+    strategy: string;
+    provider: PublicationProvider<TProvider>;
+    protection: PublicationProtectionData;
+    feedback: PublicationFeedbackData;
+    eventStreamUrl: string | null;
+    originUrl: string | null;
+    currentRelease?: PublicationReleaseData | null;
+    domains?: PublicationDomainData[];
+    latestBuild?: PublicationBuildData<TProvider> | null;
+    deployedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+export interface UpdatePublicationProtectionInput {
+    mode: PublicationProtectionMode;
+    password?: string;
+}
+export interface PublicationProtectionSessionData {
+    previewSessionId: string;
+    token: string;
+    expiresAt: string;
+    url: string;
+}
+export interface UpdatePublicationFeedbackInput {
+    enabled: boolean;
+    config?: Record<string, unknown>;
+}
+export declare class NotebookPublicationApi {
+    private readonly client;
+    constructor(client: Client);
+    current<TProvider extends PublicationProviderName = PublicationProviderName>(notebookId: string): Promise<PublicationInstance<TProvider> | null>;
+    publish<TProvider extends PublicationProviderName = PublicationProviderName>(notebookId: string, input?: PublishInput): Promise<PublicationRun<TProvider>>;
+}
+export declare class PublicationApi {
+    private readonly client;
+    constructor(client: Client);
+    get<TProvider extends PublicationProviderName = PublicationProviderName>(id: string): Promise<PublicationInstance<TProvider>>;
+    destroy(id: string): Promise<void>;
+    setProtection<TProvider extends PublicationProviderName = PublicationProviderName>(id: string, input: UpdatePublicationProtectionInput): Promise<PublicationInstance<TProvider>>;
+    protection(id: string): Promise<PublicationProtectionData>;
+    createProtectionSession(id: string): Promise<PublicationProtectionSessionData>;
+    disableProtection<TProvider extends PublicationProviderName = PublicationProviderName>(id: string): Promise<PublicationInstance<TProvider>>;
+    setFeedback<TProvider extends PublicationProviderName = PublicationProviderName>(id: string, input: UpdatePublicationFeedbackInput): Promise<PublicationInstance<TProvider>>;
+    listDomains(id: string): Promise<PublicationDomainData[]>;
+    createDomain(id: string, input: CreatePublicationDomainInput): Promise<PublicationDomainData>;
+    refreshDomain(id: string, domainId: string): Promise<PublicationDomainData>;
+    deleteDomain(id: string, domainId: string): Promise<void>;
+    events(id: string): Promise<ReadableStream<PublicationEventData>>;
+    buildLogs(id: string, buildId: string): Promise<ReadableStream<PublicationLogChunkData>>;
+    logs(id: string): Promise<ReadableStream<PublicationLogChunkData>>;
+}
+export declare class PublicationRun<TProvider extends PublicationProviderName = PublicationProviderName> {
+    readonly initial: PublicationInstance<TProvider>;
+    private readonly client;
+    private started;
+    private completed;
+    private finalError;
+    private finalResult;
+    private resultPromise;
+    private resolveResult;
+    private rejectResult;
+    private readonly bufferedEvents;
+    private readonly subscribers;
+    constructor(initial: PublicationInstance<TProvider>, client: Client);
+    events(): AsyncIterable<PublishStreamEvent>;
+    result(): Promise<PublishStreamResult>;
+    publication(): Promise<PublicationInstance<TProvider>>;
+    start(): this;
+    private subscribe;
+    private consumeStream;
+    private publish;
+    private closeSubscribers;
+    private fail;
+}
+export declare class PublicationInstance<TProvider extends PublicationProviderName = PublicationProviderName> {
+    readonly data: PublicationData<TProvider>;
+    private readonly client;
+    private readonly notebookId?;
+    constructor(data: PublicationData<TProvider>, client: Client, notebookId?: string);
+    refresh(): Promise<PublicationInstance<TProvider>>;
+    publish(): Promise<PublicationRun<TProvider>>;
+    destroy(): Promise<void>;
+    wait(options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<PublicationInstance<TProvider>>;
+    events(): Promise<ReadableStream<PublicationEventData>>;
+    buildLogs(buildId?: string): Promise<ReadableStream<PublicationLogChunkData>>;
+    logs(): Promise<ReadableStream<PublicationLogChunkData>>;
+    setProtection(input: UpdatePublicationProtectionInput): Promise<PublicationInstance<TProvider>>;
+    protection(): Promise<PublicationProtectionData>;
+    createProtectionSession(): Promise<PublicationProtectionSessionData>;
+    disableProtection(): Promise<PublicationInstance<TProvider>>;
+    setFeedback(input: UpdatePublicationFeedbackInput): Promise<PublicationInstance<TProvider>>;
+    domains(): Promise<PublicationDomainData[]>;
+    addDomain(input: CreatePublicationDomainInput): Promise<PublicationDomainData>;
+    refreshDomain(domainId: string): Promise<PublicationDomainData>;
+    deleteDomain(domainId: string): Promise<void>;
+}