@phpsandbox/sdk 0.1.2 → 0.1.6

package/dist/browser/phpsandbox-sdk.iife.js

@@ -33,12 +33,17 @@ var PHPSandbox = (() => {
     CommandError: () => CommandError,
     ComposerCredentials: () => ComposerCredentials,
     ErrorEvent: () => ErrorEvent,
+    Feedback: () => Feedback,
     FileChangeFilter: () => FileChangeFilter,
     FileChangeType: () => FileChangeType,
     FileType: () => FileType,
     Filesystem: () => Filesystem,
     FilesystemError: () => FilesystemError,
     FilesystemErrorType: () => FilesystemErrorType,
+    GitTarget: () => GitTarget,
+    GitTargetApi: () => GitTargetApi,
+    Integration: () => Integration,
+    IntegrationApi: () => IntegrationApi,
     LspConnection: () => LspConnection,
     NotebookApi: () => NotebookApi,
     NotebookComposerCredentialApi: () => NotebookComposerCredentialApi,
@@ -91,18 +96,48 @@ var PHPSandbox = (() => {
     PublishStreamSseResultEventSchema: () => PublishStreamSseResultEventSchema,
     RateLimitError: () => RateLimitError,
     RuntimeTelemetry: () => RuntimeTelemetry,
+    SandboxIntegration: () => SandboxIntegration,
+    SandboxIntegrationApi: () => SandboxIntegrationApi,
     SendTimeoutError: () => SendTimeoutError,
     ServerApi: () => ServerApi,
     ServerInstance: () => ServerInstance,
     ShellProcess: () => ShellProcess,
     UnsupportedRuntimeTransportError: () => UnsupportedRuntimeTransportError,
+    integrationId: () => integrationId,
     notebookBuiltinServices: () => notebookBuiltinServices,
     notebookKnownServices: () => notebookKnownServices,
     once: () => once,
+    sandboxIntegrationId: () => sandboxIntegrationId,
     timeout: () => timeout,
     watchRuntimeTelemetry: () => watchRuntimeTelemetry
   });
 
+  // src/errors/index.ts
+  var PromiseTimeoutError = class extends Error {
+    constructor(message, time3) {
+      super(message);
+      this.time = time3;
+    }
+  };
+  var SendTimeoutError = class _SendTimeoutError extends PromiseTimeoutError {
+    static fromPromiseTimeoutError(error51) {
+      return new _SendTimeoutError(error51.message, error51.time);
+    }
+  };
+  var NotebookUnavailableError = class extends Error {
+    constructor(message = "Notebook is no longer available", raw = {}) {
+      super(message);
+      this.raw = raw;
+      this.name = "NotebookUnavailableError";
+    }
+  };
+  var UnsupportedRuntimeTransportError = class extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "UnsupportedRuntimeTransportError";
+    }
+  };
+
   // src/types.ts
   var ErrorEvent = class extends Error {
     constructor(code, message, raw = {}) {
@@ -317,6 +352,77 @@ var PHPSandbox = (() => {
         }
       });
     }
+    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((error51) => {
+            if (!closed) {
+              closed = true;
+              disposable?.dispose();
+              if (abort && options.signal) {
+                options.signal.removeEventListener("abort", abort);
+              }
+              abort = null;
+              controller.error(error51);
+            }
+          });
+        },
+        cancel: stop
+      });
+    }
     find(query, options = {
       useIgnoreFiles: false,
       followSymlinks: false,
@@ -395,7 +501,7 @@ var PHPSandbox = (() => {
       return this.okra.invoke("fs.textSearch", { query, options: { ...defaultOptions, ...options } }).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));
@@ -499,32 +605,6 @@ var PHPSandbox = (() => {
     return output;
   }
 
-  // src/errors/index.ts
-  var PromiseTimeoutError = class extends Error {
-    constructor(message, time3) {
-      super(message);
-      this.time = time3;
-    }
-  };
-  var SendTimeoutError = class _SendTimeoutError extends PromiseTimeoutError {
-    static fromPromiseTimeoutError(error51) {
-      return new _SendTimeoutError(error51.message, error51.time);
-    }
-  };
-  var NotebookUnavailableError = class extends Error {
-    constructor(message = "Notebook is no longer available", raw = {}) {
-      super(message);
-      this.raw = raw;
-      this.name = "NotebookUnavailableError";
-    }
-  };
-  var UnsupportedRuntimeTransportError = class extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "UnsupportedRuntimeTransportError";
-    }
-  };
-
   // src/utils/promise.ts
   var timeout = (prom, time3) => {
     let timer;
@@ -4186,6 +4266,7 @@ var PHPSandbox = (() => {
     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 });
@@ -4193,17 +4274,6 @@ var PHPSandbox = (() => {
     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 });
     }
@@ -4272,10 +4342,56 @@ var PHPSandbox = (() => {
       url2.hash = "";
       return url2.toString();
     }
-    omitUndefined(input) {
-      return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+  };
+  var GitTargetApi = class {
+    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);
+    }
+  };
+  var GitTarget = class {
+    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 !== void 0));
+  }
 
   // node_modules/zod/v4/classic/external.js
   var external_exports = {};
@@ -18844,11 +18960,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var PublicationProtectionModeSchema = external_exports.enum(["none", "password"]);
   var PublicationLogStreamSchema = external_exports.enum(["build", "runtime"]);
   var PublishStreamLogStreamSchema = external_exports.enum(["build", "publish", "runtime"]);
+  var PublicationEventPayloadSchema = external_exports.preprocess(
+    (payload) => Array.isArray(payload) && payload.length === 0 ? {} : payload,
+    external_exports.record(external_exports.string(), external_exports.unknown())
+  );
   var PublicationEventDataSchema = external_exports.object({
     id: external_exports.union([external_exports.number(), external_exports.string()]).optional(),
     sequence: external_exports.number(),
     type: external_exports.string(),
-    payload: external_exports.record(external_exports.string(), external_exports.unknown()),
+    payload: PublicationEventPayloadSchema,
     createdAt: external_exports.string().nullable()
   }).passthrough();
   var PublicationLogChunkDataSchema = external_exports.object({
@@ -18869,6 +18989,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var PublishStreamResultSchema = external_exports.object({
     success: external_exports.boolean(),
     publicationId: external_exports.string(),
+    url: external_exports.string().url(),
     buildId: external_exports.string(),
     releaseId: external_exports.string(),
     status: PublicationStatusSchema
@@ -18980,10 +19101,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const response = await this.client.delete(`/publications/${id}/protection`);
       return new PublicationInstance(response.data, this.client);
     }
-    async setFeedback(id, input) {
-      const response = await this.client.put(`/publications/${id}/feedback`, input);
-      return new PublicationInstance(response.data, this.client);
-    }
     async listDomains(id) {
       const response = await this.client.get(
         `/publications/${id}/domains`
@@ -19093,7 +19210,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           if (event.type === "result") {
             const { type: _, ...result } = event;
             this.finalResult = result;
-            this.resolveResult?.(result);
+            this.resolveResult?.(this.finalResult);
           }
         }
         if (!this.finalResult) {
@@ -19184,9 +19301,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     disableProtection() {
       return this.client.publications.disableProtection(this.data.id);
     }
-    setFeedback(input) {
-      return this.client.publications.setFeedback(this.data.id, input);
-    }
     domains() {
       return this.client.publications.listDomains(this.data.id);
     }
@@ -19439,18 +19553,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "container.stats": { method: "GET", path: "/runtime/container/stats" },
     "terminal.list": { method: "GET", path: "/runtime/terminals" },
     "shell.exec": { method: "POST", path: "/runtime/executions" },
-    "fs.info": { method: "POST", path: "/runtime/files/info" },
     "fs.readFile": { method: "GET", path: "/runtime/files/content" },
     "fs.writeFile": { method: "PUT", path: "/runtime/files/content" },
-    "fs.write": { method: "PUT", path: "/runtime/files/text" },
-    "fs.mkdir": { method: "POST", path: "/runtime/directories" },
     "fs.createDirectory": { method: "PUT", path: "/runtime/directories" },
     "fs.readDirectory": { method: "POST", path: "/runtime/directories/read" },
     "fs.stat": { method: "POST", path: "/runtime/files/stat" },
-    "fs.move": { method: "POST", path: "/runtime/files/move" },
     "fs.rename": { method: "POST", path: "/runtime/files/rename" },
     "fs.copy": { method: "POST", path: "/runtime/files/copy" },
-    "fs.remove": { method: "POST", path: "/runtime/files/remove" },
     "fs.delete": { method: "DELETE", path: "/runtime/files" },
     "fs.tail": { method: "POST", path: "/runtime/files/tail" },
     "fs.find": { method: "POST", path: "/runtime/files/find" },
@@ -19645,6 +19754,164 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     };
   }
 
+  // src/feedback.ts
+  var Feedback = class {
+    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 !== void 0) 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}`;
+    }
+  };
+
+  // src/integrations.ts
+  var IntegrationApi = class {
+    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))}`);
+    }
+  };
+  var Integration = class {
+    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);
+    }
+  };
+  function integrationId(integration) {
+    return typeof integration === "string" ? integration : integration.id;
+  }
+
+  // src/sandbox-integrations.ts
+  var SandboxIntegrationApi = class {
+    constructor(notebookId, client) {
+      this.notebookId = notebookId;
+      this.client = client;
+    }
+    async attach(input) {
+      const response = await this.client.post(this.path(), {
+        ...input,
+        integration: integrationId(input.integration)
+      });
+      return new SandboxIntegration(response.data, this.notebookId, this.client);
+    }
+    async list() {
+      const response = await this.client.get(this.path());
+      return response.data.map((integration) => new SandboxIntegration(integration, this.notebookId, this.client));
+    }
+    async get(integration) {
+      const response = await this.client.get(this.bindingPath(integration));
+      return new SandboxIntegration(response.data, this.notebookId, this.client);
+    }
+    async update(integration, input) {
+      const response = await this.client.patch(this.bindingPath(integration), {
+        ...input,
+        integration: input.integration === void 0 ? void 0 : integrationId(input.integration)
+      });
+      return new SandboxIntegration(response.data, this.notebookId, this.client);
+    }
+    async detach(integration) {
+      await this.client.delete(this.bindingPath(integration));
+    }
+    path() {
+      return `/notebook/${this.notebookId}/integrations`;
+    }
+    bindingPath(integration) {
+      return `${this.path()}/${encodeURIComponent(sandboxIntegrationId(integration))}`;
+    }
+  };
+  var SandboxIntegration = class {
+    constructor(data, notebookId, client) {
+      this.data = data;
+      this.notebookId = notebookId;
+      this.client = client;
+    }
+    get id() {
+      return this.data.id;
+    }
+    get integration() {
+      return new Integration(this.data.integration, this.client);
+    }
+    get effects() {
+      return this.data.effects;
+    }
+    update(input) {
+      return new SandboxIntegrationApi(this.notebookId, this.client).update(this, input);
+    }
+    detach() {
+      return new SandboxIntegrationApi(this.notebookId, this.client).detach(this);
+    }
+  };
+  function sandboxIntegrationId(integration) {
+    return typeof integration === "string" ? integration : integration.id;
+  }
+
   // src/index.ts
   function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
@@ -19753,6 +20020,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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(url2);
       if (options.fetch) {
@@ -19779,6 +20047,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     put(path, body) {
       return this.makeRequest("PUT", path, { body: body === void 0 ? void 0 : JSON.stringify(body) });
     }
+    patch(path, body) {
+      return this.makeRequest("PATCH", path, { body: body === void 0 ? void 0 : JSON.stringify(body) });
+    }
     async stream(path) {
       const response = await this.fetch(
         new Request(new URL(path.replace(/^\//, ""), this.baseUrl), {
@@ -19992,8 +20263,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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);
     }
     get runtimeTransport() {
       return this.client.runtimeTransport;