@phpsandbox/sdk 0.0.52 → 0.0.54

package/README.md

@@ -220,16 +220,15 @@ await notebook.git.revert({ path: 'README.md' });
 await notebook.git.revert({ path: 'staged-file.php', staged: true });
 
 const fork = await notebook.fork();
-const forkCredentials = await fork.git.credentials();
 const preview = await notebook.git.diff({
-  url: forkCredentials.url,
-  token: forkCredentials.token,
+  notebookId: fork.data.id,
+  token: process.env.PHPSANDBOX_TOKEN,
 });
 
 if (preview.status === 'ready') {
   const result = await notebook.git.merge({
-    url: forkCredentials.url,
-    token: forkCredentials.token,
+    notebookId: fork.data.id,
+    token: process.env.PHPSANDBOX_TOKEN,
     expectedBaseRef: preview.baseRef,
     author: 'PHPSandbox <hi@phpsandbox.io>',
     message: 'Merge fork into base',
@@ -241,6 +240,8 @@ if (preview.status === 'ready') {
 }
 ```
 
+Use `notebookId` when diffing or merging from another PHPSandbox notebook. Use `url` for external Git remotes. `notebookId`, `url`, and `target` are mutually exclusive.
+
 Fork diff requires the base and fork to share Git history. If they do not, `diff()` returns `status: 'unrelated'`.
 
 ### Mail

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

@@ -2848,15 +2848,15 @@ var ReconnectingWebSocket = (
     };
     ReconnectingWebSocket3.prototype._getNextDelay = function() {
       var _a = this._options, _b = _a.reconnectionDelayGrowFactor, reconnectionDelayGrowFactor = _b === void 0 ? DEFAULT.reconnectionDelayGrowFactor : _b, _c = _a.minReconnectionDelay, minReconnectionDelay = _c === void 0 ? DEFAULT.minReconnectionDelay : _c, _d = _a.maxReconnectionDelay, maxReconnectionDelay = _d === void 0 ? DEFAULT.maxReconnectionDelay : _d;
-      var delay = 0;
+      var delay2 = 0;
       if (this._retryCount > 0) {
-        delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
-        if (delay > maxReconnectionDelay) {
-          delay = maxReconnectionDelay;
+        delay2 = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
+        if (delay2 > maxReconnectionDelay) {
+          delay2 = maxReconnectionDelay;
         }
       }
-      this._debug("next delay", delay);
-      return delay;
+      this._debug("next delay", delay2);
+      return delay2;
     };
     ReconnectingWebSocket3.prototype._wait = function() {
       var _this = this;
@@ -3825,10 +3825,10 @@ var Git = class {
     return this.okra.invoke("git.log", { ref });
   }
   diff(input) {
-    return this.okra.invoke("git.diff", input);
+    return this.okra.invoke("git.diff", this.normalizeRemoteInput(input));
   }
   merge(input) {
-    return this.okra.invoke("git.merge", input);
+    return this.okra.invoke("git.merge", this.normalizeRemoteInput(input));
   }
   conflicts() {
     return this.okra.invoke("git.conflicts", {});
@@ -3860,6 +3860,35 @@ var Git = class {
   status() {
     return this.okra.invoke("git.status", {});
   }
+  normalizeRemoteInput(input) {
+    if (input.notebookId === void 0) {
+      return input;
+    }
+    const notebookId = input.notebookId.trim();
+    if (!notebookId) {
+      throw new Error("'notebookId' cannot be empty.");
+    }
+    if (input.url?.trim()) {
+      throw new Error("Pass either 'url' or 'notebookId', not both.");
+    }
+    if (input.target?.trim()) {
+      throw new Error("Pass either 'target' or 'notebookId', not both.");
+    }
+    const { notebookId: _notebookId, ...payload } = input;
+    return {
+      ...payload,
+      url: this.gitUrlForNotebook(notebookId)
+    };
+  }
+  gitUrlForNotebook(notebookId) {
+    const url = new URL(this.okra.data.gitUrl);
+    url.username = "";
+    url.password = "";
+    url.pathname = `/${encodeURIComponent(notebookId)}.git`;
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  }
 };
 
 // src/beacon/navigator.ts
@@ -4588,6 +4617,198 @@ function isBeaconSupported() {
   }
 }
 
+// src/deployments.ts
+var NotebookDeploymentApi = class {
+  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 list(id) {
+    const response = await this.client.get(`/notebook/${id}/deployments`);
+    return response.data;
+  }
+  async slugAvailability(id, slug) {
+    const query = new URLSearchParams({ slug }).toString();
+    const response = await this.client.get(
+      `/notebook/${id}/deployments/slug-availability?${query}`
+    );
+    return response.data;
+  }
+};
+var DeploymentApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(id) {
+    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}`);
+  }
+  async setProtection(id, input) {
+    const response = await this.client.put(`/deployments/${id}/protection`, input);
+    return new DeploymentInstance(response.data, this.client);
+  }
+  async protection(id) {
+    const response = await this.client.get(`/deployments/${id}/protection`);
+    return response.data;
+  }
+  async createProtectionSession(id) {
+    const response = await this.client.post(`/deployments/${id}/protection/session`);
+    return response.data;
+  }
+  async disableProtection(id) {
+    const response = await this.client.delete(`/deployments/${id}/protection`);
+    return new DeploymentInstance(response.data, this.client);
+  }
+  async setFeedback(id, input) {
+    const response = await this.client.put(`/deployments/${id}/feedback`, input);
+    return new DeploymentInstance(response.data, this.client);
+  }
+  async listDomains(id) {
+    const response = await this.client.get(
+      `/deployments/${id}/domains`
+    );
+    return unwrapDeploymentDomainCollection(response.data);
+  }
+  async createDomain(id, input) {
+    const response = await this.client.post(`/deployments/${id}/domains`, input);
+    return response.data;
+  }
+  async refreshDomain(id, domainId) {
+    const response = await this.client.post(`/deployments/${id}/domains/${domainId}/refresh`);
+    return response.data;
+  }
+  async deleteDomain(id, domainId) {
+    await this.client.delete(`/deployments/${id}/domains/${domainId}`);
+  }
+  async events(id) {
+    return parseNdjsonStream(await this.client.stream(`/deployments/${id}/events/stream`));
+  }
+  async buildLogs(id, buildId) {
+    return parseNdjsonStream(
+      await this.client.stream(`/deployments/${id}/builds/${buildId}/logs/stream`)
+    );
+  }
+  async logs(id) {
+    return parseNdjsonStream(await this.client.stream(`/deployments/${id}/logs/stream`));
+  }
+};
+var DeploymentInstance = class {
+  constructor(data, client) {
+    this.data = data;
+    this.client = client;
+  }
+  refresh() {
+    return this.client.deployments.get(this.data.id);
+  }
+  redeploy(input = {}) {
+    return this.client.deployments.redeploy(this.data.id, input);
+  }
+  delete() {
+    return this.client.deployments.delete(this.data.id);
+  }
+  async wait(options = {}) {
+    const intervalMs = options.intervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 3e5;
+    const startedAt = Date.now();
+    let current = this;
+    while (!deploymentStatusIsTerminal(current.data.status)) {
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new Error(`Timed out waiting for deployment ${this.data.id}`);
+      }
+      await delay(intervalMs);
+      current = await current.refresh();
+    }
+    return current;
+  }
+  events() {
+    return this.client.deployments.events(this.data.id);
+  }
+  buildLogs(buildId = this.data.latest_build?.id ?? "") {
+    if (buildId === "") {
+      return Promise.reject(new Error("Deployment has no latest build id"));
+    }
+    return this.client.deployments.buildLogs(this.data.id, buildId);
+  }
+  logs() {
+    return this.client.deployments.logs(this.data.id);
+  }
+  setProtection(input) {
+    return this.client.deployments.setProtection(this.data.id, input);
+  }
+  protection() {
+    return this.client.deployments.protection(this.data.id);
+  }
+  createProtectionSession() {
+    return this.client.deployments.createProtectionSession(this.data.id);
+  }
+  disableProtection() {
+    return this.client.deployments.disableProtection(this.data.id);
+  }
+  setFeedback(input) {
+    return this.client.deployments.setFeedback(this.data.id, input);
+  }
+  domains() {
+    return this.client.deployments.listDomains(this.data.id);
+  }
+  addDomain(input) {
+    return this.client.deployments.createDomain(this.data.id, input);
+  }
+  refreshDomain(domainId) {
+    return this.client.deployments.refreshDomain(this.data.id, domainId);
+  }
+  deleteDomain(domainId) {
+    return this.client.deployments.deleteDomain(this.data.id, domainId);
+  }
+};
+function deploymentStatusIsTerminal(status) {
+  return ["healthy", "failed", "stopped", "deleted", "delete_failed"].includes(status);
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function unwrapDeploymentDomainCollection(input) {
+  if (Array.isArray(input)) {
+    return input;
+  }
+  return Array.isArray(input.data) ? input.data : [];
+}
+function parseNdjsonStream(input) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  return input.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed !== "") {
+            controller.enqueue(JSON.parse(trimmed));
+          }
+        }
+      },
+      flush(controller) {
+        buffer += decoder.decode();
+        const trimmed = buffer.trim();
+        if (trimmed !== "") {
+          controller.enqueue(JSON.parse(trimmed));
+        }
+      }
+    })
+  );
+}
+
 // src/index.ts
 function normalizeNotebookSecretInputs(input) {
   if (Array.isArray(input)) {
@@ -4608,18 +4829,42 @@ var NotebookInitError = class extends Error {
 };
 var ApiError = class extends Error {
   constructor(response, body) {
-    super(`PHPSandbox API Error: ${response.status} ${response.statusText} - ${body}`);
+    const data = parseApiErrorBody(body);
+    const apiMessage = apiErrorMessage(data, body);
+    super(`PHPSandbox API Error: ${response.status} ${response.statusText}${apiMessage === "" ? "" : ` - ${apiMessage}`}`);
     this.response = response;
     this.body = body;
     this.status = response.status;
+    this.data = data;
+    this.apiMessage = apiMessage === "" ? void 0 : apiMessage;
   }
 };
+function parseApiErrorBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+function apiErrorMessage(data, fallback) {
+  if (data !== null && typeof data === "object") {
+    const record = data;
+    if (typeof record.message === "string" && record.message.trim() !== "") {
+      return record.message.trim();
+    }
+    if (record.error !== void 0) {
+      return typeof record.error === "string" ? record.error.trim() : JSON.stringify(record.error);
+    }
+  }
+  return fallback.trim();
+}
 var NotebookApi = class {
   constructor(client) {
     this.client = client;
     this.secrets = new NotebookSecretApi(client);
     this.preview = new NotebookPreviewApi(client);
     this.mail = new NotebookMailApi(client);
+    this.deployments = new NotebookDeploymentApi(client);
   }
   async create(template, input = {}, init = true) {
     const response = await this.client.post("/notebook", { template, ...input });
@@ -4671,6 +4916,7 @@ function normalizeApiBaseUrl(url) {
 var Client = class {
   constructor(token, url = "https://api.phpsandbox.io/v1", options = {}) {
     this.fetch = globalThis.fetch;
+    this.deployments = new DeploymentApi(this);
     this.notebook = new NotebookApi(this);
     this.options = Object.assign({ startClosed: true }, options);
     this.baseUrl = normalizeApiBaseUrl(url);
@@ -4695,6 +4941,21 @@ var Client = class {
   put(path, body) {
     return this.makeRequest("PUT", 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), {
+        method: "GET",
+        headers: this.headers
+      })
+    );
+    if (!response.ok) {
+      throw new ApiError(response, await response.text());
+    }
+    if (!response.body) {
+      throw new Error("PHPSandbox API Error: response body is not readable");
+    }
+    return response.body;
+  }
   async makeRequest(method, path, init) {
     const response = await this.fetch(
       new Request(new URL(path.replace(/^\//, ""), this.baseUrl), {
@@ -4841,6 +5102,9 @@ var NotebookInstance = class {
   fork(input = {}) {
     return this.client.notebook.fork(this.data.id, input);
   }
+  deploy(input = {}) {
+    return this.client.notebook.deployments.create(this.data.id, input);
+  }
   gitCredentials() {
     return this.client.notebook.gitCredentials(this.data.id);
   }
@@ -5073,6 +5337,8 @@ export {
   BeaconTimeoutError,
   Client,
   CommandError,
+  DeploymentApi,
+  DeploymentInstance,
   ErrorEvent,
   FileChangeFilter,
   FileChangeType,
@@ -5083,6 +5349,7 @@ export {
   LspConnection,
   Navigator,
   NotebookApi,
+  NotebookDeploymentApi,
   NotebookInitError,
   NotebookInstance,
   NotebookMail,