@phpsandbox/sdk 0.1.2 → 0.1.6

package/README.md

@@ -111,6 +111,7 @@ Each `NotebookInstance` exposes service clients:
 - `notebook.container` (`Container`)
 - `notebook.composer` (`Composer`)
 - `notebook.git` (`Git`)
+- `notebook.integrations` (`SandboxIntegrationApi`)
 - `notebook.lsp` (`Lsp`)
 - `notebook.repl` (`Repl`)
 - `notebook.auth` (`Auth`)
@@ -119,6 +120,7 @@ Each `NotebookInstance` exposes service clients:
 - `notebook.metrics` (`Metrics`)
 - `notebook.services` (`Services`)
 - `notebook.mail` (`NotebookMail`)
+- `notebook.feedback` (`Feedback`)
 
 Notes:
 
@@ -242,18 +244,19 @@ console.log(installed.map((pkg) => pkg.name));
 ```ts
 await notebook.git.checkpoint('Jane Doe <jane@example.com>', 'Initial checkpoint');
 
-await notebook.secrets.set('GITHUB_TOKEN', {
-  value: process.env.GITHUB_TOKEN!,
-  type: 'credential',
+const github = await client.integrations.link({
+  provider: 'github',
+  authorization: { type: 'token', token: process.env.GITHUB_TOKEN! },
 });
+await notebook.integrations.attach({ integration: github });
 
-await notebook.git.sync({
+const target = await notebook.git.targets.create({
   provider: 'github',
   repository: 'acme/my-repo',
-  author: 'Jane Doe <jane@example.com>',
+  author: { name: 'Jane Doe', email: 'jane@example.com' },
   branch: 'main',
-  credential: { secret: 'GITHUB_TOKEN' },
 });
+await target.sync();
 
 const history = await notebook.git.log('main');
 console.log(history[0]);
@@ -306,6 +309,28 @@ await notebook.mail.delete(mail.hash);
 await notebook.mail.disable();
 ```
 
+### Feedback
+
+```ts
+await sandbox.feedback.configure({
+  widget: {
+    targets: ['preview', 'publication'],
+    types: ['bug', 'suggestion', 'question'],
+  },
+});
+
+const feedback = await sandbox.feedback.submit({
+  type: 'bug',
+  message: 'Saving the profile failed.',
+  author: { externalId: 'customer-42', email: 'ada@example.com' },
+  context: { url: 'https://app.example.com/profile', path: '/profile' },
+});
+
+await sandbox.feedback.update(feedback.id, { status: 'resolved' });
+```
+
+The server-side SDK uses the same PHPSandbox API token as the rest of the sandbox. Set `widget: null` to remove the optional popout without disabling API ingestion.
+
 ### Events
 
 ```ts

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

@@ -12,6 +12,32 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
+// 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 = {}) {
@@ -226,6 +252,77 @@ var Filesystem = class {
       }
     });
   }
+  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,
@@ -304,7 +401,7 @@ var Filesystem = class {
     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));
@@ -408,32 +505,6 @@ async function collectBytes(stream) {
   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;
@@ -4095,6 +4166,7 @@ var Git = class {
   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 });
@@ -4102,17 +4174,6 @@ var Git = class {
   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 });
   }
@@ -4181,10 +4242,56 @@ var Git = class {
     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 = {};
@@ -18753,11 +18860,15 @@ var PublicationDomainDnsRecordTypeSchema = external_exports.enum(["CNAME", "ALIA
 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({
@@ -18778,6 +18889,7 @@ var PublishStreamLogSchema = external_exports.object({
 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
@@ -18889,10 +19001,6 @@ var PublicationApi = class {
     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`
@@ -19002,7 +19110,7 @@ var PublicationRun = class {
         if (event.type === "result") {
           const { type: _, ...result } = event;
           this.finalResult = result;
-          this.resolveResult?.(result);
+          this.resolveResult?.(this.finalResult);
         }
       }
       if (!this.finalResult) {
@@ -19093,9 +19201,6 @@ var PublicationInstance = class _PublicationInstance {
   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);
   }
@@ -19348,18 +19453,13 @@ var restActionRoutes = {
   "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" },
@@ -19554,6 +19654,164 @@ function runtimeAbort(options) {
   };
 }
 
+// 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)) {
@@ -19662,6 +19920,7 @@ var Client = class {
     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) {
@@ -19688,6 +19947,9 @@ var Client = class {
   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), {
@@ -19901,8 +20163,10 @@ var NotebookInstance = class {
     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;
@@ -20215,12 +20479,17 @@ export {
   CommandError,
   ComposerCredentials,
   ErrorEvent,
+  Feedback,
   FileChangeFilter,
   FileChangeType,
   FileType,
   Filesystem,
   FilesystemError,
   FilesystemErrorType,
+  GitTarget,
+  GitTargetApi,
+  Integration,
+  IntegrationApi,
   LspConnection,
   NotebookApi,
   NotebookComposerCredentialApi,
@@ -20273,14 +20542,18 @@ export {
   PublishStreamSseResultEventSchema,
   RateLimitError,
   RuntimeTelemetry,
+  SandboxIntegration,
+  SandboxIntegrationApi,
   SendTimeoutError,
   ServerApi,
   ServerInstance,
   ShellProcess,
   UnsupportedRuntimeTransportError,
+  integrationId,
   notebookBuiltinServices,
   notebookKnownServices,
   once,
+  sandboxIntegrationId,
   timeout,
   watchRuntimeTelemetry
 };