@phpsandbox/sdk 0.0.56 → 0.0.58

package/dist/deployments.js

@@ -1,18 +1,31 @@
+import { ApiError } from './index.js';
+import { DeploymentEventDataSchema, DeploymentLogChunkDataSchema, DeployStreamSseEventNameSchema, DeployStreamSseEventSchema, } from './schemas/deployments.js';
+export * from './schemas/deployments.js';
 export class NotebookDeploymentApi {
     constructor(client) {
         this.client = client;
     }
-    async create(id, input = {}) {
-        const response = await this.client.post(`/notebook/${id}/deployments`, input);
-        return new DeploymentInstance(response.data, this.client);
+    async current(notebookId) {
+        try {
+            const response = await this.client.get(`/notebook/${notebookId}/deployment`);
+            return new DeploymentInstance(response.data, this.client, notebookId);
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
     }
-    async list(id) {
-        const response = await this.client.get(`/notebook/${id}/deployments`);
-        return response.data;
+    async publish(notebookId, input) {
+        const response = await this.client.post(`/notebook/${notebookId}/deployment/publish`, input);
+        const run = new DeploymentRun(new DeploymentInstance(response.data, this.client, notebookId), this.client);
+        run.start();
+        return run;
     }
     async slugAvailability(id, slug) {
         const query = new URLSearchParams({ slug }).toString();
-        const response = await this.client.get(`/notebook/${id}/deployments/slug-availability?${query}`);
+        const response = await this.client.get(`/notebook/${id}/deployment/slug-availability?${query}`);
         return response.data;
     }
 }
@@ -24,10 +37,6 @@ export class DeploymentApi {
         const response = await this.client.get(`/deployments/${id}`);
         return new DeploymentInstance(response.data, this.client);
     }
-    async redeploy(id, input = {}) {
-        const response = await this.client.post(`/deployments/${id}/redeploy`, input);
-        return new DeploymentInstance(response.data, this.client);
-    }
     async delete(id) {
         await this.client.delete(`/deployments/${id}`);
     }
@@ -67,25 +76,140 @@ export class DeploymentApi {
         await this.client.delete(`/deployments/${id}/domains/${domainId}`);
     }
     async events(id) {
-        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/events/stream`));
+        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/events/stream`), DeploymentEventDataSchema);
     }
     async buildLogs(id, buildId) {
-        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/builds/${buildId}/logs/stream`));
+        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/builds/${buildId}/logs/stream`), DeploymentLogChunkDataSchema);
     }
     async logs(id) {
-        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/logs/stream`));
+        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/logs/stream`), DeploymentLogChunkDataSchema);
+    }
+}
+export class DeploymentRun {
+    constructor(initial, client) {
+        this.initial = initial;
+        this.client = client;
+        this.started = false;
+        this.completed = false;
+        this.finalError = null;
+        this.finalResult = null;
+        this.resultPromise = null;
+        this.resolveResult = null;
+        this.rejectResult = null;
+        this.bufferedEvents = [];
+        this.subscribers = new Set();
+    }
+    async *events() {
+        this.start();
+        const queue = this.subscribe();
+        try {
+            for await (const event of queue) {
+                yield event;
+            }
+        }
+        finally {
+            this.subscribers.delete(queue);
+            queue.close();
+        }
+    }
+    result() {
+        this.start();
+        return this.resultPromise;
+    }
+    async deployment() {
+        await this.result();
+        return this.initial.refresh();
+    }
+    start() {
+        if (this.started) {
+            return this;
+        }
+        if (!this.initial.data.okraUrl) {
+            throw new Error(`Deployment ${this.initial.data.id} has no okraUrl for SSE streaming`);
+        }
+        this.started = true;
+        this.resultPromise = new Promise((resolve, reject) => {
+            this.resolveResult = resolve;
+            this.rejectResult = reject;
+        });
+        this.resultPromise.catch(() => undefined);
+        void this.consumeStream(this.initial.data.okraUrl);
+        return this;
+    }
+    subscribe() {
+        const queue = new AsyncDeployEventQueue();
+        for (const event of this.bufferedEvents) {
+            queue.push(event);
+        }
+        if (this.finalError) {
+            queue.fail(this.finalError);
+        }
+        else if (this.completed) {
+            queue.close();
+        }
+        else {
+            this.subscribers.add(queue);
+        }
+        return queue;
+    }
+    async consumeStream(okraUrl) {
+        try {
+            const stream = await this.client.sse(okraUrl);
+            for await (const event of readDeployStreamEvents(stream)) {
+                this.publish(event);
+                if (event.type === 'result') {
+                    const { type: _, ...result } = event;
+                    this.finalResult = result;
+                    this.resolveResult?.(result);
+                }
+            }
+            if (!this.finalResult) {
+                throw new Error('Deploy stream ended without result');
+            }
+            this.closeSubscribers();
+        }
+        catch (err) {
+            this.fail(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    publish(event) {
+        this.bufferedEvents.push(event);
+        for (const subscriber of this.subscribers) {
+            subscriber.push(event);
+        }
+    }
+    closeSubscribers() {
+        this.completed = true;
+        for (const subscriber of this.subscribers) {
+            subscriber.close();
+        }
+        this.subscribers.clear();
+    }
+    fail(error) {
+        this.finalError = error;
+        this.completed = true;
+        this.rejectResult?.(error);
+        for (const subscriber of this.subscribers) {
+            subscriber.fail(error);
+        }
+        this.subscribers.clear();
     }
 }
 export class DeploymentInstance {
-    constructor(data, client) {
+    constructor(data, client, notebookId) {
         this.data = data;
         this.client = client;
+        this.notebookId = notebookId;
     }
-    refresh() {
-        return this.client.deployments.get(this.data.id);
+    async refresh() {
+        const response = await this.client.get(`/deployments/${this.data.id}`);
+        return new DeploymentInstance(response.data, this.client, this.notebookId);
     }
-    redeploy(input = {}) {
-        return this.client.deployments.redeploy(this.data.id, input);
+    publish() {
+        if (!this.notebookId) {
+            return Promise.reject(new Error('Deployment publish requires a notebook-scoped deployment instance.'));
+        }
+        return this.client.notebook.deployment.publish(this.notebookId);
     }
     delete() {
         return this.client.deployments.delete(this.data.id);
@@ -107,7 +231,7 @@ export class DeploymentInstance {
     events() {
         return this.client.deployments.events(this.data.id);
     }
-    buildLogs(buildId = this.data.latest_build?.id ?? '') {
+    buildLogs(buildId = this.data.latestBuild?.id ?? '') {
         if (buildId === '') {
             return Promise.reject(new Error('Deployment has no latest build id'));
         }
@@ -156,7 +280,143 @@ function unwrapDeploymentDomainCollection(input) {
     }
     return Array.isArray(input.data) ? input.data : [];
 }
-function parseNdjsonStream(input) {
+class AsyncDeployEventQueue {
+    constructor() {
+        this.values = [];
+        this.pending = [];
+        this.closed = false;
+        this.error = null;
+    }
+    push(value) {
+        if (this.closed) {
+            return;
+        }
+        const next = this.pending.shift();
+        if (next) {
+            next.resolve({ done: false, value });
+            return;
+        }
+        this.values.push(value);
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        for (const next of this.pending.splice(0)) {
+            next.resolve({ done: true, value: undefined });
+        }
+    }
+    fail(error) {
+        if (this.closed) {
+            return;
+        }
+        this.error = error;
+        this.closed = true;
+        for (const next of this.pending.splice(0)) {
+            next.reject(error);
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const next = await this.next();
+            if (next.done) {
+                return;
+            }
+            yield next.value;
+        }
+    }
+    next() {
+        const value = this.values.shift();
+        if (value) {
+            return Promise.resolve({ done: false, value });
+        }
+        if (this.error) {
+            return Promise.reject(this.error);
+        }
+        if (this.closed) {
+            return Promise.resolve({ done: true, value: undefined });
+        }
+        return new Promise((resolve, reject) => {
+            this.pending.push({ resolve, reject });
+        });
+    }
+}
+async function* readDeployStreamEvents(stream) {
+    const reader = parseSSEStream(stream).getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return;
+            }
+            const event = parseDeployStreamEvent(value);
+            if (event) {
+                yield event;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function parseDeployStreamEvent(event) {
+    if (!DeployStreamSseEventNameSchema.safeParse(event.event).success) {
+        return null;
+    }
+    return DeployStreamSseEventSchema.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 };
+    }
+}
+function parseNdjsonStream(input, schema) {
     const decoder = new TextDecoder();
     let buffer = '';
     return input.pipeThrough(new TransformStream({
@@ -167,7 +427,7 @@ function parseNdjsonStream(input) {
             for (const line of lines) {
                 const trimmed = line.trim();
                 if (trimmed !== '') {
-                    controller.enqueue(JSON.parse(trimmed));
+                    controller.enqueue(schema.parse(JSON.parse(trimmed)));
                 }
             }
         },
@@ -175,7 +435,7 @@ function parseNdjsonStream(input) {
             buffer += decoder.decode();
             const trimmed = buffer.trim();
             if (trimmed !== '') {
-                controller.enqueue(JSON.parse(trimmed));
+                controller.enqueue(schema.parse(JSON.parse(trimmed)));
             }
         },
     }));

package/dist/git.d.ts

@@ -1,3 +1,4 @@
+import type { Client, SecretRef } from './index.js';
 import { Action, NotebookInstance } from './index.js';
 export interface GitLog {
     hash: string;
@@ -48,6 +49,32 @@ export interface GitCredentials {
     abilities: string[];
     expiresAt: string;
 }
+export type GitProvider = 'github' | (string & {});
+export type GitRepositoryVisibility = 'private' | 'public';
+export type GitSyncDirection = 'pull' | 'push' | 'both';
+export interface GitSyncTargetInput {
+    provider: GitProvider;
+    repository: string;
+    author: string;
+    branch?: string;
+    credential: SecretRef;
+    direction?: GitSyncDirection;
+    visibility?: GitRepositoryVisibility;
+    setDefault?: boolean;
+}
+export interface GitSyncTargetData {
+    id: string;
+    provider: GitProvider;
+    repository: string;
+    url: string | null;
+    branch: string;
+    credentialConfigured: boolean;
+    default: boolean;
+    lastCommitSha: string | null;
+    lastSyncedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
 export interface GitCheckoutResult extends GitRef {
     branch: string;
     created: boolean;
@@ -180,10 +207,12 @@ export interface GitActions {
 }
 export default class Git {
     protected okra: NotebookInstance;
-    constructor(okra: NotebookInstance);
+    private readonly client;
+    constructor(okra: NotebookInstance, client: Client);
     checkpoint(author: string, message: string, branch?: string, allowEmpty?: boolean): Promise<GitRef>;
     checkout(branch: string, create?: boolean): Promise<GitCheckoutResult>;
-    sync(url: string, author: string, ref?: string, token?: string, direction?: 'pull' | 'push' | 'both', force?: boolean): Promise<GitRef>;
+    sync(input: GitSyncTargetInput): Promise<GitSyncTargetData>;
+    syncTargets(): Promise<GitSyncTargetData[]>;
     log(ref?: string): Promise<GitLog[]>;
     diff(input: GitDiffInput): Promise<GitDiffPreview>;
     merge(input: GitMergeInput): Promise<GitMergeResult>;
@@ -199,5 +228,6 @@ export default class Git {
     status(): Promise<GitStatus>;
     private normalizeRemoteInput;
     private gitUrlForNotebook;
+    private omitUndefined;
 }
 export {};

package/dist/git.js

@@ -1,6 +1,7 @@
 export default class Git {
-    constructor(okra) {
+    constructor(okra, client) {
         this.okra = okra;
+        this.client = client;
     }
     checkpoint(author, message, branch = 'main', allowEmpty = false) {
         return this.okra.invoke('git.checkpoint', { author, message, branch, allowEmpty });
@@ -8,8 +9,13 @@ export default class Git {
     checkout(branch, create = true) {
         return this.okra.invoke('git.checkout', { branch, create });
     }
-    sync(url, author, ref = 'main', token, direction = 'both', force = false) {
-        return this.okra.invoke('git.sync', { url, author, ref, token, direction, force });
+    async sync(input) {
+        const response = await this.client.post(`/notebook/${this.okra.data.id}/git/sync-targets`, this.omitUndefined({ ...input }));
+        return response.data;
+    }
+    async syncTargets() {
+        const response = await this.client.get(`/notebook/${this.okra.data.id}/git/sync-targets`);
+        return response.data;
     }
     log(ref = 'main') {
         return this.okra.invoke('git.log', { ref });
@@ -79,4 +85,7 @@ export default class Git {
         url.hash = '';
         return url.toString();
     }
+    omitUndefined(input) {
+        return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+    }
 }

package/dist/index.d.ts

@@ -15,7 +15,8 @@ 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 DeployInput, type DeploymentInstance } from './deployments.js';
+import { DeploymentApi, NotebookDeploymentApi, type DeploymentInstance, type DeploymentRun, type PublishInput } from './deployments.js';
+import { ServerApi } from './servers.js';
 export * from './types.js';
 export { Transport } from './socket/index.js';
 export * from './lsp.js';
@@ -30,6 +31,7 @@ export * from './utils/promise.js';
 export * from './beacon/index.js';
 export * from './errors/index.js';
 export * from './deployments.js';
+export * from './servers.js';
 interface Result<TType extends 'success' | 'error' | 'running', TData extends object> {
     type: TType;
     message: string;
@@ -124,21 +126,35 @@ export interface NotebookPolicyData {
     stale_after_minutes: number | null;
     prune_after_at: string | null;
 }
+export type SecretEnvironment = 'development' | 'production';
+export type SecretType = 'environment_variable' | 'credential';
+export interface SecretRef {
+    secret: string;
+    environment?: SecretEnvironment;
+}
 export interface NotebookSecretData {
     uuid: string;
     name: string;
-    type: 'environment_variable';
+    type: SecretType;
+    environment: SecretEnvironment;
     createdAt: string | null;
     updatedAt: string | null;
 }
+export interface NotebookSecretListOptions {
+    environment?: SecretEnvironment;
+}
 export interface UpsertNotebookSecretInput {
     value: string;
-    type?: 'environment_variable';
+    type?: SecretType;
+    environment?: SecretEnvironment;
 }
 export interface UpsertNotebookSecretItemInput extends UpsertNotebookSecretInput {
     name: string;
 }
 export type UpsertNotebookSecretsInput = UpsertNotebookSecretItemInput[] | Record<string, string | UpsertNotebookSecretInput>;
+export interface NotebookSecretDeleteOptions {
+    environment?: SecretEnvironment;
+}
 export interface NotebookPreviewDataDisabled {
     enabled: false;
 }
@@ -214,7 +230,7 @@ export declare class NotebookApi {
     readonly secrets: NotebookSecretApi;
     readonly preview: NotebookPreviewApi;
     readonly mail: NotebookMailApi;
-    readonly deployments: NotebookDeploymentApi;
+    readonly deployment: NotebookDeploymentApi;
     constructor(client: Client);
     create(template: string, input?: Partial<CreateNotebookInput>, init?: boolean): Promise<NotebookInstance>;
     get(id: string): Promise<NotebookInstance>;
@@ -236,6 +252,7 @@ export interface PHPSandboxClientOptions {
 export declare class Client {
     readonly notebook: NotebookApi;
     readonly deployments: DeploymentApi;
+    readonly servers: ServerApi;
     readonly options: PHPSandboxClientOptions;
     private readonly fetch;
     private readonly baseUrl;
@@ -254,6 +271,7 @@ export declare class Client {
         data: T;
     }>;
     stream(path: string): Promise<ReadableStream<Uint8Array>>;
+    sse(url: string): Promise<ReadableStream<Uint8Array>>;
     private makeRequest;
 }
 export declare class PHPSandbox extends Client {
@@ -261,10 +279,10 @@ export declare class PHPSandbox extends Client {
 export declare class NotebookSecretApi {
     private readonly client;
     constructor(client: Client);
-    list(id: string): Promise<NotebookSecretData[]>;
+    list(id: string, options?: NotebookSecretListOptions): Promise<NotebookSecretData[]>;
     set(id: string, name: string, input: string | UpsertNotebookSecretInput): Promise<NotebookSecretData>;
     setMany(id: string, input: UpsertNotebookSecretsInput): Promise<NotebookSecretData[]>;
-    delete(id: string, name: string): Promise<void>;
+    delete(id: string, name: string, options?: NotebookSecretDeleteOptions): Promise<void>;
 }
 export declare class NotebookPreviewApi {
     private readonly client;
@@ -322,7 +340,8 @@ export declare class NotebookInstance {
     constructor(data: NotebookData, client: Client);
     ready(): Promise<NotebookInitSuccessResult>;
     fork(input?: Partial<ForkNotebookInput>): Promise<NotebookInstance>;
-    deploy(input?: DeployInput): Promise<DeploymentInstance>;
+    deployment(): Promise<DeploymentInstance | null>;
+    publish(input?: PublishInput): Promise<DeploymentRun>;
     gitCredentials(): Promise<GitCredentials>;
     delete(): Promise<void>;
     stop(): Promise<void>;
@@ -349,10 +368,10 @@ export declare class NotebookSecrets {
     private readonly client;
     private readonly notebookId;
     constructor(client: Client, notebookId: string);
-    list(): Promise<NotebookSecretData[]>;
+    list(options?: NotebookSecretListOptions): Promise<NotebookSecretData[]>;
     set(name: string, input: string | UpsertNotebookSecretInput): Promise<NotebookSecretData>;
     setMany(input: UpsertNotebookSecretsInput): Promise<NotebookSecretData[]>;
-    delete(name: string): Promise<void>;
+    delete(name: string, options?: NotebookSecretDeleteOptions): Promise<void>;
 }
 export declare class NotebookPreview {
     private readonly client;