@phpsandbox/sdk 0.1.2 → 0.1.6

package/dist/feedback.d.ts

@@ -0,0 +1,73 @@
+import type { Client, PaginatedApiResponse } from './index.js';
+export type FeedbackType = 'bug' | 'suggestion' | 'question' | 'other';
+export type FeedbackStatus = 'open' | 'resolved' | 'archived';
+export type FeedbackSource = 'sdk' | 'widget';
+export type FeedbackWidgetTarget = 'preview' | 'publication';
+export interface FeedbackWidgetConfig {
+    targets: FeedbackWidgetTarget[];
+    label?: string;
+    types?: FeedbackType[];
+}
+export interface ConfigureFeedbackInput {
+    widget: FeedbackWidgetConfig | null;
+}
+export interface SubmitFeedbackInput {
+    type: FeedbackType;
+    message: string;
+    author?: {
+        externalId?: string;
+        name?: string;
+        email?: string;
+    };
+    context?: {
+        url?: string;
+        path?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface FeedbackData {
+    id: string;
+    type: FeedbackType;
+    message: string;
+    status: FeedbackStatus;
+    source: FeedbackSource;
+    author: {
+        source: 'external' | 'phpsandbox';
+        externalId: string | null;
+        phpsandboxUserId: number | null;
+        name: string | null;
+        email: string | null;
+    };
+    context: {
+        url: string | null;
+        path: string | null;
+        publication: {
+            id: string;
+            releaseId: string | null;
+        } | null;
+    };
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface FeedbackListOptions {
+    type?: FeedbackType;
+    status?: FeedbackStatus;
+    source?: FeedbackSource;
+    page?: number;
+}
+export interface UpdateFeedbackInput {
+    status: FeedbackStatus;
+}
+export declare class Feedback {
+    private readonly client;
+    private readonly notebookId;
+    constructor(client: Client, notebookId: string);
+    configure(input: ConfigureFeedbackInput): Promise<ConfigureFeedbackInput>;
+    configuration(): Promise<ConfigureFeedbackInput>;
+    submit(input: SubmitFeedbackInput): Promise<FeedbackData>;
+    list(options?: FeedbackListOptions): Promise<PaginatedApiResponse<FeedbackData>>;
+    get(id: string): Promise<FeedbackData>;
+    update(id: string, input: UpdateFeedbackInput): Promise<FeedbackData>;
+    private path;
+}

package/dist/feedback.js

@@ -0,0 +1,38 @@
+export class Feedback {
+    constructor(client, notebookId) {
+        this.client = client;
+        this.notebookId = notebookId;
+    }
+    async configure(input) {
+        const response = await this.client.put(this.path('/configuration'), input);
+        return response.data;
+    }
+    async configuration() {
+        const response = await this.client.get(this.path('/configuration'));
+        return response.data;
+    }
+    async submit(input) {
+        const response = await this.client.post(this.path(), input);
+        return response.data;
+    }
+    async list(options = {}) {
+        const query = new URLSearchParams();
+        for (const [name, value] of Object.entries(options)) {
+            if (value !== undefined)
+                query.set(name, String(value));
+        }
+        const response = await this.client.get(`${this.path()}${query.size === 0 ? '' : `?${query.toString()}`}`);
+        return response.data;
+    }
+    async get(id) {
+        const response = await this.client.get(this.path(`/${encodeURIComponent(id)}`));
+        return response.data;
+    }
+    async update(id, input) {
+        const response = await this.client.patch(this.path(`/${encodeURIComponent(id)}`), input);
+        return response.data;
+    }
+    path(suffix = '') {
+        return `/notebook/${this.notebookId}/feedback${suffix}`;
+    }
+}

package/dist/filesystem.d.ts

@@ -1,10 +1,5 @@
 import type { Action, Disposable, NotebookInstance } from './index.js';
 import { ErrorEvent } from './types.js';
-export interface FileInfo {
-    binary: boolean;
-    contents: string | null;
-    language: string;
-}
 export interface FileResult {
     name: string;
     directory: string;
@@ -68,6 +63,9 @@ export interface FileListOptions {
 export interface FileTailOptions {
     lines?: number;
 }
+export interface FileFollowOptions extends FileTailOptions {
+    signal?: AbortSignal;
+}
 export interface FileLineRange {
     start: number;
     end: number;
@@ -358,24 +356,6 @@ export interface ReadFileRangeResult {
     error: string | null;
 }
 export interface FilesystemActions {
-    'fs.info': Action<{
-        path: string;
-    }, FileInfo>;
-    'fs.write': Action<{
-        path: string;
-        contents: string;
-    }, boolean>;
-    'fs.mkdir': Action<{
-        path: string;
-    }, boolean>;
-    'fs.remove': Action<{
-        path: string;
-        type: 'file' | 'directory';
-    }, boolean>;
-    'fs.move': Action<{
-        from: string;
-        to: string;
-    }, boolean>;
     'fs.find': Action<{
         query: string;
         options: FileSearchOptions;
@@ -403,6 +383,14 @@ export interface FilesystemActions {
     'fs.cancelRead': Action<{
         id: string;
     }, boolean>;
+    'fs.follow': Action<{
+        id: string;
+        path: string;
+        lines: number;
+    }, boolean>;
+    'fs.cancelFollow': Action<{
+        id: string;
+    }, boolean>;
     'fs.writeStream': Action<{
         id: string;
         path: string;
@@ -461,7 +449,9 @@ export interface FilesystemActions {
     'fs.tail': Action<{
         path: string;
         lines: number;
-    }, string>;
+    }, {
+        content: string;
+    }>;
 }
 interface FilesystemEventData {
     'fs.watch': FileChange;
@@ -471,6 +461,10 @@ interface FilesystemEventData {
         id: string;
         data: Uint8Array;
     };
+    'fs.follow': {
+        id: string;
+        data: Uint8Array;
+    };
 }
 type PrefixKey<K extends keyof FilesystemEventData> = `${K}.${string}`;
 export type FilesystemEvents = FilesystemEventData & {
@@ -505,6 +499,7 @@ export declare class Filesystem {
     readText(path: string): Promise<string>;
     readLines(path: string, range: FileLineRange): Promise<FileLineRangeResult>;
     readStream(path: string): ReadableStream<Uint8Array>;
+    follow(path: string, options?: FileFollowOptions): 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[]]>;
     tail(path: string, options?: FileTailOptions): Promise<string>;

package/dist/filesystem.js

@@ -1,3 +1,4 @@
+import { UnsupportedRuntimeTransportError } from './errors/index.js';
 import { ErrorEvent } from './types.js';
 import { nanoid } from 'nanoid';
 export var FileType;
@@ -204,6 +205,77 @@ export class Filesystem {
             },
         });
     }
+    follow(path, options = {}) {
+        if (this.okra.runtimeTransport === 'rest') {
+            return new ReadableStream({
+                start(controller) {
+                    controller.error(new UnsupportedRuntimeTransportError('Following files requires the realtime transport.'));
+                },
+            });
+        }
+        const id = nanoid();
+        let disposable = null;
+        let abort = null;
+        let started = false;
+        let closed = false;
+        const stop = async () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            disposable?.dispose();
+            disposable = null;
+            if (abort && options.signal) {
+                options.signal.removeEventListener('abort', abort);
+            }
+            abort = null;
+            if (started) {
+                await this.okra.invoke('fs.cancelFollow', { id }).catch(() => false);
+            }
+        };
+        return new ReadableStream({
+            start: (controller) => {
+                disposable = this.okra.listen(`fs.follow.${id}`, (event) => {
+                    if (!closed) {
+                        controller.enqueue(event.data);
+                    }
+                });
+                if (options.signal) {
+                    abort = () => {
+                        void stop().finally(() => controller.error(options.signal?.reason ?? new Error('Aborted')));
+                    };
+                    if (options.signal.aborted) {
+                        abort();
+                        return;
+                    }
+                    options.signal.addEventListener('abort', abort, { once: true });
+                }
+                started = true;
+                void this.okra.invoke('fs.follow', { id, path, lines: options.lines ?? 10 }).then(() => {
+                    if (!closed) {
+                        closed = true;
+                        disposable?.dispose();
+                        if (abort && options.signal) {
+                            options.signal.removeEventListener('abort', abort);
+                        }
+                        abort = null;
+                        controller.close();
+                    }
+                }).catch((error) => {
+                    if (!closed) {
+                        closed = true;
+                        disposable?.dispose();
+                        if (abort && options.signal) {
+                            options.signal.removeEventListener('abort', abort);
+                        }
+                        abort = null;
+                        controller.error(error);
+                    }
+                });
+            },
+            cancel: stop,
+        });
+    }
     find(query, options = {
         useIgnoreFiles: false,
         followSymlinks: false,
@@ -284,7 +356,9 @@ export class Filesystem {
             .finally(() => disposable.dispose());
     }
     tail(path, options = {}) {
-        return this.okra.invoke('fs.tail', { path, lines: options.lines ?? 10 }).catch((e) => this.handleError(e));
+        return this.okra.invoke('fs.tail', { path, lines: options.lines ?? 10 })
+            .then(({ content }) => content)
+            .catch((e) => this.handleError(e));
     }
     stat(path) {
         return this.okra.invoke('fs.stat', { path }).catch((e) => this.handleError(e));

package/dist/git.d.ts

@@ -1,4 +1,4 @@
-import type { Client, SecretRef } from './index.js';
+import type { Client } from './index.js';
 import { Action, NotebookInstance } from './index.js';
 export interface GitLog {
     hash: string;
@@ -50,35 +50,37 @@ export interface GitCredentials {
     expiresAt: string;
 }
 export type GitProvider = 'github' | (string & {});
-export type GitRepositoryVisibility = 'private' | 'public';
 export type GitSyncDirection = 'pull' | 'push' | 'both';
 export interface GitSyncAuthor {
     name: string;
     email: string;
 }
-export interface GitSyncTargetInput {
+export interface GitTargetConfiguration {
     provider: GitProvider;
     repository: string;
     author: GitSyncAuthor;
     branch?: string;
-    credential: SecretRef;
-    direction?: GitSyncDirection;
-    visibility?: GitRepositoryVisibility;
     setDefault?: boolean;
 }
-export interface GitSyncTargetData {
+export type CreateGitTargetInput = GitTargetConfiguration;
+export interface GitSyncExistingTargetInput {
+    direction?: GitSyncDirection;
+    author?: GitSyncAuthor;
+    force?: boolean;
+}
+export interface GitTargetData {
     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 type GitTargetReference = string | GitTarget;
 export interface GitCheckoutResult extends GitRef {
     branch: string;
     created: boolean;
@@ -213,11 +215,10 @@ export interface GitActions {
 export default class Git {
     protected okra: NotebookInstance;
     private readonly client;
+    readonly targets: GitTargetApi;
     constructor(okra: NotebookInstance, client: Client);
     checkpoint(author: string, message: string, branch?: string, allowEmpty?: boolean): Promise<GitRef>;
     checkout(branch: string, create?: boolean): Promise<GitCheckoutResult>;
-    sync(input: GitSyncTargetInput): Promise<GitSyncTargetData>;
-    syncTargets(): Promise<GitSyncTargetData[]>;
     log(ref?: string): Promise<GitLog[]>;
     diff(input: GitDiffInput): Promise<GitDiffPreview>;
     merge(input: GitMergeInput): Promise<GitMergeResult>;
@@ -233,6 +234,22 @@ export default class Git {
     status(): Promise<GitStatus>;
     private normalizeRemoteInput;
     private gitUrlForNotebook;
-    private omitUndefined;
+}
+export declare class GitTargetApi {
+    private readonly notebookId;
+    private readonly client;
+    constructor(notebookId: string, client: Client);
+    create(input: CreateGitTargetInput): Promise<GitTarget>;
+    list(): Promise<GitTarget[]>;
+    get(target: GitTargetReference): Promise<GitTarget>;
+    sync(target: GitTargetReference, input?: GitSyncExistingTargetInput): Promise<GitTarget>;
+}
+export declare class GitTarget {
+    readonly data: GitTargetData;
+    private readonly notebookId;
+    private readonly client;
+    constructor(data: GitTargetData, notebookId: string, client: Client);
+    get id(): string;
+    sync(input?: GitSyncExistingTargetInput): Promise<GitTarget>;
 }
 export {};

package/dist/git.js

@@ -2,6 +2,7 @@ export default class Git {
     constructor(okra, client) {
         this.okra = okra;
         this.client = client;
+        this.targets = new GitTargetApi(okra.data.id, client);
     }
     checkpoint(author, message, branch = 'main', allowEmpty = false) {
         return this.okra.invoke('git.checkpoint', { author, message, branch, allowEmpty });
@@ -9,14 +10,6 @@ export default class Git {
     checkout(branch, create = true) {
         return this.okra.invoke('git.checkout', { branch, create });
     }
-    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 });
     }
@@ -85,7 +78,45 @@ export default class Git {
         url.hash = '';
         return url.toString();
     }
-    omitUndefined(input) {
-        return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+export class GitTargetApi {
+    constructor(notebookId, client) {
+        this.notebookId = notebookId;
+        this.client = client;
+    }
+    async create(input) {
+        const response = await this.client.post(`/notebook/${this.notebookId}/git/targets`, omitUndefined({ ...input }));
+        return new GitTarget(response.data, this.notebookId, this.client);
+    }
+    async list() {
+        const response = await this.client.get(`/notebook/${this.notebookId}/git/targets`);
+        return response.data.map((target) => new GitTarget(target, this.notebookId, this.client));
+    }
+    async get(target) {
+        const response = await this.client.get(`/notebook/${this.notebookId}/git/targets/${encodeURIComponent(gitTargetId(target))}`);
+        return new GitTarget(response.data, this.notebookId, this.client);
+    }
+    async sync(target, input = {}) {
+        const response = await this.client.post(`/notebook/${this.notebookId}/git/targets/${encodeURIComponent(gitTargetId(target))}/sync`, omitUndefined({ ...input }));
+        return new GitTarget(response.data, this.notebookId, this.client);
     }
 }
+export class GitTarget {
+    constructor(data, notebookId, client) {
+        this.data = data;
+        this.notebookId = notebookId;
+        this.client = client;
+    }
+    get id() {
+        return this.data.id;
+    }
+    sync(input = {}) {
+        return new GitTargetApi(this.notebookId, this.client).sync(this, input);
+    }
+}
+function gitTargetId(target) {
+    return typeof target === 'string' ? target : target.id;
+}
+function omitUndefined(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}

package/dist/index.d.ts

@@ -17,6 +17,9 @@ import { Disposable } from './types.js';
 import { NotebookUnavailableError } from './errors/index.js';
 import { PublicationApi, NotebookPublicationApi, type PublicationInstance, type PublicationRun, type PublishInput } from './publications.js';
 import { ServerApi } from './servers.js';
+import { Feedback } from './feedback.js';
+import { IntegrationApi } from './integrations.js';
+import { SandboxIntegrationApi } from './sandbox-integrations.js';
 export * from './types.js';
 export * from './lsp.js';
 export * from './filesystem.js';
@@ -34,6 +37,9 @@ export * from './utils/promise.js';
 export * from './errors/index.js';
 export * from './publications.js';
 export * from './servers.js';
+export * from './feedback.js';
+export * from './integrations.js';
+export * from './sandbox-integrations.js';
 interface Result<TType extends 'success' | 'error' | 'running', TData extends object> {
     type: TType;
     message: string;
@@ -314,6 +320,7 @@ export declare class Client {
     readonly notebook: NotebookApi;
     readonly publications: PublicationApi;
     readonly servers: ServerApi;
+    readonly integrations: IntegrationApi;
     readonly options: PHPSandboxClientOptions;
     protected runtimeTransportValue: RuntimeTransport;
     get runtimeTransport(): RuntimeTransport;
@@ -333,6 +340,9 @@ export declare class Client {
     put<T extends unknown>(path: string, body?: unknown): Promise<{
         data: T;
     }>;
+    patch<T extends unknown>(path: string, body?: unknown): Promise<{
+        data: T;
+    }>;
     stream(path: string): Promise<ReadableStream<Uint8Array>>;
     sse(url: string): Promise<ReadableStream<Uint8Array>>;
     private makeRequest;
@@ -404,8 +414,10 @@ export declare class NotebookInstance {
     readonly services: Services;
     readonly config: Config;
     readonly secrets: NotebookSecrets;
+    readonly integrations: SandboxIntegrationApi;
     readonly preview: NotebookPreview;
     readonly mail: NotebookMail;
+    readonly feedback: Feedback;
     private readonly socket;
     private readonly restInvoker;
     readonly emitter: EventDispatcher;

package/dist/index.js

@@ -31,6 +31,9 @@ import { NotebookUnavailableError, UnsupportedRuntimeTransportError } from './er
 import { PublicationApi, NotebookPublicationApi } from './publications.js';
 import { ServerApi } from './servers.js';
 import { RestRuntimeInvoker } from './runtime/rest.js';
+import { Feedback } from './feedback.js';
+import { IntegrationApi } from './integrations.js';
+import { SandboxIntegrationApi } from './sandbox-integrations.js';
 export * from './types.js';
 export * from './lsp.js';
 export * from './filesystem.js';
@@ -48,6 +51,9 @@ export * from './utils/promise.js';
 export * from './errors/index.js';
 export * from './publications.js';
 export * from './servers.js';
+export * from './feedback.js';
+export * from './integrations.js';
+export * from './sandbox-integrations.js';
 function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
         return input;
@@ -159,6 +165,7 @@ export class Client {
         this.publications = new PublicationApi(this);
         this.notebook = new NotebookApi(this);
         this.servers = new ServerApi(this);
+        this.integrations = new IntegrationApi(this);
         this.options = Object.assign({ startClosed: true }, options);
         this.baseUrl = normalizeApiBaseUrl(url);
         if (options.fetch) {
@@ -182,6 +189,9 @@ export class Client {
     put(path, body) {
         return this.makeRequest('PUT', path, { body: body === undefined ? undefined : JSON.stringify(body) });
     }
+    patch(path, body) {
+        return this.makeRequest('PATCH', path, { body: body === undefined ? undefined : JSON.stringify(body) });
+    }
     async stream(path) {
         const response = await this.fetch(new Request(new URL(path.replace(/^\//, ''), this.baseUrl), {
             method: 'GET',
@@ -390,8 +400,10 @@ export class NotebookInstance {
         this.services = new Services(this);
         this.config = new Config(this);
         this.secrets = new NotebookSecrets(client, this.data.id);
+        this.integrations = new SandboxIntegrationApi(this.data.id, client);
         this.preview = new NotebookPreview(client, this.data.id);
         this.mail = new NotebookMail(client, this.data.id);
+        this.feedback = new Feedback(client, this.data.id);
     }
     async ready() {
         if (this.restInvoker !== null) {

package/dist/integrations.d.ts

@@ -0,0 +1,43 @@
+import type { Client } from './index.js';
+export type IntegrationProvider = 'cloudflare' | 'github' | 'laravel-cloud';
+export type IntegrationAuthorizationType = 'token';
+export interface IntegrationAuthorization {
+    type: IntegrationAuthorizationType;
+    token: string;
+}
+export interface LinkIntegrationInput {
+    provider: IntegrationProvider;
+    label?: string | null;
+    authorization: IntegrationAuthorization;
+}
+export interface UpdateIntegrationInput {
+    label?: string | null;
+    authorization?: IntegrationAuthorization;
+}
+export interface IntegrationData {
+    id: string;
+    provider: IntegrationProvider;
+    label: string | null;
+    createdAt: string | null;
+}
+export type IntegrationReference = string | Integration;
+export declare class IntegrationApi {
+    private readonly client;
+    constructor(client: Client);
+    link(input: LinkIntegrationInput): Promise<Integration>;
+    list(): Promise<Integration[]>;
+    get(integration: IntegrationReference): Promise<Integration>;
+    update(integration: IntegrationReference, input: UpdateIntegrationInput): Promise<Integration>;
+    unlink(integration: IntegrationReference): Promise<void>;
+}
+export declare class Integration {
+    readonly data: IntegrationData;
+    private readonly client;
+    constructor(data: IntegrationData, client: Client);
+    get id(): string;
+    get provider(): IntegrationProvider;
+    get label(): string | null;
+    update(input: UpdateIntegrationInput): Promise<Integration>;
+    unlink(): Promise<void>;
+}
+export declare function integrationId(integration: IntegrationReference): string;

package/dist/integrations.js

@@ -0,0 +1,48 @@
+export class IntegrationApi {
+    constructor(client) {
+        this.client = client;
+    }
+    async link(input) {
+        const response = await this.client.post('/integrations', input);
+        return new Integration(response.data, this.client);
+    }
+    async list() {
+        const response = await this.client.get('/integrations');
+        return response.data.map((integration) => new Integration(integration, this.client));
+    }
+    async get(integration) {
+        const response = await this.client.get(`/integrations/${encodeURIComponent(integrationId(integration))}`);
+        return new Integration(response.data, this.client);
+    }
+    async update(integration, input) {
+        const response = await this.client.patch(`/integrations/${encodeURIComponent(integrationId(integration))}`, input);
+        return new Integration(response.data, this.client);
+    }
+    async unlink(integration) {
+        await this.client.delete(`/integrations/${encodeURIComponent(integrationId(integration))}`);
+    }
+}
+export class Integration {
+    constructor(data, client) {
+        this.data = data;
+        this.client = client;
+    }
+    get id() {
+        return this.data.id;
+    }
+    get provider() {
+        return this.data.provider;
+    }
+    get label() {
+        return this.data.label;
+    }
+    update(input) {
+        return new IntegrationApi(this.client).update(this, input);
+    }
+    unlink() {
+        return new IntegrationApi(this.client).unlink(this);
+    }
+}
+export function integrationId(integration) {
+    return typeof integration === 'string' ? integration : integration.id;
+}