@phpsandbox/sdk 0.1.1 → 0.1.4

package/dist/composer.d.ts

@@ -1,11 +1,16 @@
-import { Action, Client, ComposerCredentials, Disposable, NotebookInstance } from './index.js';
-export interface ComposerEvents {
-    'composer.log': string;
-}
-export interface Result {
-    exitCode: number;
-    output: string;
+import { ComposerCredentials, type Action, type Client, type NotebookInstance } from './index.js';
+import { ProcessResult, type ProcessOutputChunk, type ProcessOutputSource, type ProcessResultData } from './shell.js';
+export interface ComposerEventData {
+    'composer.output': {
+        id: string;
+        output: string;
+        source: ProcessOutputSource;
+    };
 }
+type ComposerEventPattern = `${keyof ComposerEventData}.${string}`;
+export type ComposerEvents = ComposerEventData & {
+    [K in ComposerEventPattern]: ComposerEventData['composer.output'];
+};
 export interface ComposerPackage {
     name: string;
     _installedVersion: string;
@@ -14,32 +19,40 @@ export interface ComposerPackage {
 }
 export interface ComposerActions {
     'composer.invoke': Action<{
+        id: string;
         command: ComposerCommand;
         args: Argument;
         options: Options;
-    }, Result>;
-    'composer.dump-autoload': Action<undefined, {
-        message: string;
-        success: boolean;
-    }>;
+    }, ProcessResultData>;
+    'composer.kill': Action<{
+        id: string;
+    }, boolean>;
     'composer.packages': Action<undefined, ComposerPackage[]>;
 }
-export type ComposerCommand = 'install' | 'update' | 'require' | 'remove' | 'search' | 'show';
+export type ComposerCommand = 'install' | 'update' | 'require' | 'remove' | 'search' | 'show' | 'dump-autoload';
 export type Argument<Name extends string = string, Type extends string | string[] = string | string[]> = Record<Name, Type>;
 export type Options<Name extends string = string, Type extends string | string[] | boolean = string | string[] | boolean> = Record<Name, Type>;
+export declare class ComposerProcess {
+    readonly id: string;
+    private readonly okra;
+    readonly output: ReadableStream<ProcessOutputChunk>;
+    readonly stdout: ReadableStream<Uint8Array>;
+    readonly stderr: ReadableStream<Uint8Array>;
+    private readonly completion;
+    constructor(id: string, okra: NotebookInstance, command: ComposerCommand, args: Argument, options: Options);
+    wait(): Promise<ProcessResult>;
+    kill(): Promise<void>;
+}
 export default class Composer {
     protected okra: NotebookInstance;
     readonly credentials: ComposerCredentials;
     constructor(okra: NotebookInstance, client: Client);
-    invoke(command: ComposerCommand, args?: Argument, options?: Options): Promise<Result>;
-    dumpAutoload(): Promise<{
-        message: string;
-        success: boolean;
-    }>;
-    install(options?: Options): Promise<Result>;
-    update(args: Argument<'packages'>, options?: Options): Promise<Result>;
-    require(packages: Argument<'packages'>, options?: Options): Promise<Result>;
-    remove(args: Argument<'packages'>, options?: Options): Promise<Result>;
-    stream(fn: (data: string) => void): Disposable;
+    run(command: ComposerCommand, args?: Argument, options?: Options): ComposerProcess;
+    dumpAutoload(options?: Options): ComposerProcess;
+    install(options?: Options): ComposerProcess;
+    update(args: Argument<'packages'>, options?: Options): ComposerProcess;
+    require(packages: Argument<'packages'>, options?: Options): ComposerProcess;
+    remove(args: Argument<'packages'>, options?: Options): ComposerProcess;
     packages(): Promise<ComposerPackage[]>;
 }
+export {};

package/dist/composer.js

@@ -1,29 +1,79 @@
 import { ComposerCredentials } from './index.js';
+import { ProcessReadable, ProcessResult, } from './shell.js';
+import { nanoid } from 'nanoid';
+export class ComposerProcess {
+    constructor(id, okra, command, args, options) {
+        this.id = id;
+        this.okra = okra;
+        const output = new ProcessReadable();
+        const stdout = new ProcessReadable();
+        const stderr = new ProcessReadable();
+        this.output = output.stream;
+        this.stdout = stdout.stream;
+        this.stderr = stderr.stream;
+        const encoder = new TextEncoder();
+        let subscription = this.okra.listen(`composer.output.${this.id}`, (event) => {
+            const data = encoder.encode(event.output);
+            const source = event.source ?? 'output';
+            output.enqueue({ source, data });
+            if (source === 'stderr') {
+                stderr.enqueue(data);
+            }
+            else {
+                stdout.enqueue(data);
+            }
+        });
+        const finish = () => {
+            subscription?.dispose();
+            subscription = null;
+            output.close();
+            stdout.close();
+            stderr.close();
+        };
+        const fail = (error) => {
+            subscription?.dispose();
+            subscription = null;
+            output.fail(error);
+            stdout.fail(error);
+            stderr.fail(error);
+        };
+        this.completion = this.okra.invoke('composer.invoke', { id, command, args, options }).then((result) => {
+            finish();
+            return new ProcessResult(result.output, result.stdout, result.stderr, result.exitCode);
+        }).catch((error) => {
+            fail(error);
+            throw error;
+        });
+    }
+    wait() {
+        return this.completion;
+    }
+    async kill() {
+        await this.okra.invoke('composer.kill', { id: this.id });
+    }
+}
 export default class Composer {
     constructor(okra, client) {
         this.okra = okra;
         this.credentials = new ComposerCredentials(client, okra.data.id);
     }
-    invoke(command, args = {}, options = {}) {
-        return this.okra.invoke('composer.invoke', { command, args, options });
+    run(command, args = {}, options = {}) {
+        return new ComposerProcess(nanoid(), this.okra, command, args, options);
     }
-    dumpAutoload() {
-        return this.okra.invoke('composer.dump-autoload');
+    dumpAutoload(options = {}) {
+        return this.run('dump-autoload', {}, options);
     }
     install(options = {}) {
-        return this.invoke('install', {}, options);
+        return this.run('install', {}, options);
     }
     update(args, options = {}) {
-        return this.invoke('update', args, options);
+        return this.run('update', args, options);
     }
     require(packages, options = {}) {
-        return this.invoke('require', packages, options);
+        return this.run('require', packages, options);
     }
     remove(args, options = {}) {
-        return this.invoke('remove', args, options);
-    }
-    stream(fn) {
-        return this.okra.listen('composer.log', fn);
+        return this.run('remove', args, options);
     }
     packages() {
         return this.okra.invoke('composer.packages');

package/dist/container.d.ts

@@ -1,4 +1,4 @@
-import { Action, Disposable, NotebookInstance } from './index.js';
+import { Action, NotebookInstance } from './index.js';
 interface Stat {
     usage: number;
     limit: number;
@@ -38,6 +38,7 @@ export interface ContainerActions {
         state: NotebookState;
     }>;
     'container.opened-ports': Action<{}, PortInfo[]>;
+    'container.stats': Action<{}, ContainerStats | null>;
     'container.set-php': Action<{
         version: string;
     }, {
@@ -57,13 +58,8 @@ export default class Container {
     state(): Promise<{
         state: NotebookState;
     }>;
-    openedPorts(): Promise<PortInfo[]>;
     setPhp(version: string): Promise<{
         version: string;
     }>;
-    enableTelemetry(features: Set<TelemetryFeature>): Promise<void>;
-    stopTelemetry(): Promise<void>;
-    listen<T extends keyof ContainerEvents>(event: T, handler: (data: ContainerEvents[T]) => void): Disposable;
-    onPort(handler: (port: PortInfo, type: 'open' | 'close') => void): Disposable;
 }
 export {};

package/dist/container.js

@@ -24,35 +24,7 @@ export default class Container {
     state() {
         return this.okra.invoke('container.state');
     }
-    openedPorts() {
-        return this.okra.invoke('container.opened-ports');
-    }
     setPhp(version) {
         return this.okra.invoke('container.set-php', { version });
     }
-    enableTelemetry(features) {
-        return this.okra.invoke('container.stream-telemetry', { features: Array.from(features) });
-    }
-    stopTelemetry() {
-        return this.okra.invoke('container.stop-telemetry');
-    }
-    listen(event, handler) {
-        return this.okra.listen(event, handler);
-    }
-    onPort(handler) {
-        let ports = [];
-        return this.listen('container.ports', (newPorts) => {
-            for (const port of newPorts) {
-                if (!ports.some((p) => p.port === port.port)) {
-                    handler(port, 'open');
-                }
-            }
-            for (const port of ports) {
-                if (!newPorts.some((p) => p.port === port.port)) {
-                    handler(port, 'close');
-                }
-            }
-            ports = newPorts;
-        });
-    }
 }

package/dist/filesystem.d.ts

@@ -60,6 +60,30 @@ export interface FileDeleteOptions {
         postfix: string;
     };
 }
+export type FileContents = string | Uint8Array | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+export interface FileListOptions {
+    include?: string[];
+    exclude?: string[];
+}
+export interface FileTailOptions {
+    lines?: number;
+}
+export interface FileFollowOptions extends FileTailOptions {
+    signal?: AbortSignal;
+}
+export interface FileLineRange {
+    start: number;
+    end: number;
+}
+export interface FileLineRangeResult extends FileLineRange {
+    content: string;
+    warning?: string;
+}
+export interface FileDownloadOptions {
+    onChunk?: (data: Uint8Array) => void;
+    exclude?: string[];
+    include?: string[];
+}
 export interface SearchOptions {
     /**
      * The maximum number of results to be returned.
@@ -375,6 +399,36 @@ export interface FilesystemActions {
         contents: Uint8Array;
         options: FileWriteOptions;
     }, void>;
+    'fs.readStream': Action<{
+        id: string;
+        path: string;
+    }, boolean>;
+    '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;
+        options: FileWriteOptions;
+    }, boolean>;
+    'fs.writeChunk': Action<{
+        id: string;
+        contents: Uint8Array;
+    }, boolean>;
+    'fs.endWrite': Action<{
+        id: string;
+    }, boolean>;
+    'fs.abortWrite': Action<{
+        id: string;
+    }, boolean>;
     'fs.stat': Action<{
         path: string;
     }, Stats>;
@@ -424,6 +478,14 @@ interface FilesystemEventData {
     'fs.watch': FileChange;
     'fs.download': Uint8Array;
     'fs.text.search': TextSearchResult | false;
+    'fs.read': {
+        id: string;
+        data: Uint8Array;
+    };
+    'fs.follow': {
+        id: string;
+        data: Uint8Array;
+    };
 }
 type PrefixKey<K extends keyof FilesystemEventData> = `${K}.${string}`;
 export type FilesystemEvents = FilesystemEventData & {
@@ -453,30 +515,24 @@ export declare class Filesystem {
     private watches;
     constructor(okra: NotebookInstance, registerReconnect?: ((handler: () => void) => Disposable) | null);
     private registerReconnectHandler;
-    info(path: string): Promise<FileInfo>;
-    write(path: string, contents: string | Uint8Array | ReadableStream<Uint8Array>, options?: FileWriteOptions): Promise<boolean>;
-    read(path: string): ReadableStream<Uint8Array>;
+    write(path: string, contents: FileContents, options?: Partial<FileWriteOptions>): Promise<void>;
+    read(path: string): Promise<Uint8Array>;
+    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[]]>;
-    mkdir(path: string): Promise<boolean>;
-    move(from: string, to: string): Promise<boolean>;
-    remove(path: string, type: 'file' | 'directory'): Promise<boolean>;
-    readFile(path: string): Promise<Uint8Array>;
-    readFile(path: string, lineRange: {
-        lineStart: number;
-        lineEnd: number;
-    }): Promise<ReadFileRangeResult>;
-    tail(path: string, lines?: number): Promise<string>;
-    writeFile(path: string, contents: Uint8Array, options: FileWriteOptions): Promise<void>;
+    tail(path: string, options?: FileTailOptions): Promise<string>;
     stat(path: string): Promise<Stats>;
-    rename(from: string, to: string, options: FileOverwriteOptions): Promise<void>;
-    delete(path: string, options: FileDeleteOptions): Promise<void>;
-    copy(source: string, destination: string, options: FileOverwriteOptions): Promise<void>;
-    readDirectory(path: string, include?: string[], exclude?: string[]): Promise<[string, FileType, number | null][]>;
+    move(from: string, to: string, options?: Partial<FileOverwriteOptions>): Promise<void>;
+    remove(path: string, options?: Partial<FileDeleteOptions>): Promise<void>;
+    copy(source: string, destination: string, options?: Partial<FileOverwriteOptions>): Promise<void>;
+    list(path: string, options?: FileListOptions): Promise<[string, FileType, number | null][]>;
     createDirectory(path: string): Promise<void>;
     watch(path: string, options: WatchOptions, onDidChange: (e: FileChange) => void): Promise<FilesystemSubscription>;
     exists(path: string): Promise<boolean>;
-    download(chunk?: (data: Uint8Array) => void, exclude?: string[], include?: string[]): Promise<Blob>;
+    download(options?: FileDownloadOptions): Promise<Blob>;
     tree(path?: string): Promise<string>;
     protected handleError(e: unknown): never;
 }