@eyepop.ai/eyepop 0.9.2 → 0.10.0

package/dist/index.mjs

@@ -1,9 +1,4 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -14,22 +9,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 
 // node_modules/mime-db/db.json
 var require_db = __commonJS({
@@ -8655,6 +8634,17 @@ var require_mime_types = __commonJS({
   }
 });
 
+// src/types.ts
+var EndpointState = /* @__PURE__ */ ((EndpointState2) => {
+  EndpointState2["Idle"] = "Idle";
+  EndpointState2["Busy"] = "Busy";
+  EndpointState2["Authenticating"] = "Authenticating";
+  EndpointState2["FetchConfig"] = "FetchConfig";
+  EndpointState2["StartingPop"] = "StartingPop";
+  EndpointState2["Error"] = "Error";
+  return EndpointState2;
+})(EndpointState || {});
+
 // src/streaming.ts
 var Stream = class _Stream {
   constructor(iterator, controller) {
@@ -8907,16 +8897,13 @@ function readableStreamAsyncIterable(stream) {
 }
 
 // src/jobs.ts
-var _AbstractJob = class _AbstractJob {
-  constructor(baseUrl, pipelineId, authorizationHeader, client, requestLogger) {
+var AbstractJob = class {
+  constructor(getSession, client, requestLogger) {
     this._responseStream = null;
     this._controller = new AbortController();
-    this._baseUrl = baseUrl.replace(/\/+$/, "");
-    this._pipelineId = pipelineId;
-    this._authorizationHeader = authorizationHeader;
+    this._getSession = getSession;
     this._client = client;
     this._requestLogger = requestLogger;
-    this.i = _AbstractJob.n++;
   }
   [Symbol.asyncIterator]() {
     if (!this._responseStream) {
@@ -8927,22 +8914,55 @@ var _AbstractJob = class _AbstractJob {
   async startJob() {
     return Promise.reject("abstract class");
   }
-  start(done) {
-    this._responseStream = new Promise((resolve2, reject) => {
-      const request = this.startJob();
-      request.then((response) => {
-        if (response.status != 200) {
-          reject(`upload error ${response.status}: ${response.text()}`);
-        } else if (!response.body) {
-          reject(`response body is empty`);
-        } else {
-          resolve2(response.body);
+  start(done, status) {
+    this._responseStream = new Promise(async (resolve2, reject) => {
+      try {
+        let retries = 1;
+        while (true) {
+          try {
+            const response = await this.startJob();
+            if (response.status == 401) {
+              status(response.status);
+              if (retries--) {
+                this._requestLogger.info("received 401 response, attempt to reauthorize once");
+              } else {
+                reject(`response ${response.status}: ${response.statusText}`);
+                break;
+              }
+            } else if (response.status == 404) {
+              status(response.status);
+              if (retries--) {
+                this._requestLogger.info("received 404 response, attempt to restart pop");
+              } else {
+                reject(`response ${response.status}: ${response.statusText}`);
+                break;
+              }
+            } else if (response.status != 200) {
+              reject(`upload error ${response.status}: ${await response.text()}`);
+              break;
+            } else if (!response.body) {
+              reject(`response body is empty`);
+              break;
+            } else {
+              resolve2(response.body);
+              break;
+            }
+          } catch (error) {
+            if (retries--) {
+              this._requestLogger.info("unknown, attempt to restart pop (as if we received 404)", error);
+              status(404);
+            } else {
+              status(500);
+              reject(error);
+              break;
+            }
+          }
         }
-      }).catch((reason) => {
+      } catch (reason) {
         reject(reason);
-      }).finally(() => {
+      } finally {
         done();
-      });
+      }
     });
     return this;
   }
@@ -8950,24 +8970,24 @@ var _AbstractJob = class _AbstractJob {
     this._controller.abort("cancelled");
   }
 };
-_AbstractJob.n = 0;
-var AbstractJob = _AbstractJob;
+AbstractJob.n = 0;
 var UploadJob = class extends AbstractJob {
   get [Symbol.toStringTag]() {
     return "uploadJob";
   }
-  constructor(stream, mimeType, baseUrl, pipelineId, authorizationHeader, client, requestLogger) {
-    super(baseUrl, pipelineId, authorizationHeader, client, requestLogger);
+  constructor(stream, mimeType, getSession, client, requestLogger) {
+    super(getSession, client, requestLogger);
     this._uploadStream = stream;
     this._mimeType = mimeType;
   }
   async startJob() {
+    const session = await this._getSession();
     const headers = {
-      "Authorization": this._authorizationHeader,
+      "Authorization": `Bearer ${session.accessToken}`,
       "Accept": "application/jsonl",
       "Content-Type": this._mimeType
     };
-    const postUrl = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=queue&processing=sync`;
+    const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
     this._requestLogger.debug("before POST %s with stream as body");
     const response = await this._client.fetch(postUrl, {
       headers,
@@ -8983,26 +9003,27 @@ var UploadJob = class extends AbstractJob {
   }
 };
 var LoadFromJob = class extends AbstractJob {
-  constructor(location, baseUrl, pipelineId, authorizationHeader, client, requestLogger) {
-    super(baseUrl, pipelineId, authorizationHeader, client, requestLogger);
+  constructor(location, getSession, client, requestLogger) {
+    super(getSession, client, requestLogger);
     this._location = location;
   }
   get [Symbol.toStringTag]() {
     return "loadFromJob";
   }
   async startJob() {
-    const headers = {
-      "Authorization": this._authorizationHeader,
-      "Accept": "application/jsonl",
-      "Content-Type": "application/json"
-    };
     const body = {
       "sourceType": "URL",
       "url": this._location
     };
-    const postUrl = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=queue&processing=sync`;
-    this._requestLogger.debug("before PATCH %s with url %s as source", postUrl, this._location);
-    const response = await this._client.fetch(postUrl, {
+    const session = await this._getSession();
+    const headers = {
+      "Authorization": `Bearer ${session.accessToken}`,
+      "Accept": "application/jsonl",
+      "Content-Type": "application/json"
+    };
+    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
+    this._requestLogger.debug("before PATCH %s with url %s as source", patchUrl, this._location);
+    const response = await this._client.fetch(patchUrl, {
       headers,
       method: "PATCH",
       body: JSON.stringify(body),
@@ -9010,7 +9031,7 @@ var LoadFromJob = class extends AbstractJob {
       // @ts-ignore
       dispatcher: this._dispatcher
     });
-    this._requestLogger.debug("after PATCH %s with url %s as source", postUrl, this._location);
+    this._requestLogger.debug("after PATCH %s with url %s as source", patchUrl, this._location);
     return response;
   }
 };
@@ -9045,7 +9066,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
     }
   }
   createHttpClient = async () => {
-    const undici = await import("undici");
+    const undici = __require("undici");
     const agent = new undici.Agent({
       keepAliveTimeout: 1e4,
       connections: 5
@@ -9203,8 +9224,8 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
     if (params.file) {
       return params;
     }
-    const mime = await Promise.resolve().then(() => __toESM(require_mime_types()));
-    const fs = await import("fs");
+    const mime = require_mime_types();
+    const fs = __require("fs");
     let mimeType;
     let stream;
     if (params.filePath) {
@@ -9235,7 +9256,9 @@ var Endpoint = class {
     this._token = null;
     this._expire_token_time = null;
     this._client = null;
-    this._limit = null;
+    this._state = "Idle" /* Idle */;
+    this._stateChangeHandler = null;
+    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
     let rootLogger;
     if (options.logger) {
       rootLogger = options.logger;
@@ -9245,19 +9268,41 @@ var Endpoint = class {
     this._logger = rootLogger.child({ module: "eyepop" });
     this._requestLogger = this._logger.child({ module: "requests" });
   }
+  onStateChanged(handler) {
+    this._stateChangeHandler = handler;
+    return this;
+  }
+  state() {
+    return this._state;
+  }
+  pendingJobs() {
+    return (this._options.jobQueueLength ?? 1024) - this._limit.getPermits();
+  }
   popName() {
     return this._popName;
   }
+  popId() {
+    return this._options.popId || null;
+  }
   async session() {
     await this.currentAccessToken();
     if (this._token == null || this._expire_token_time == null) {
       return Promise.reject("endpoint not connected");
     }
-    const token = {
+    if (this._baseUrl == null || this._pipelineId == null) {
+      await this.reconnect();
+      if (this._baseUrl == null || this._pipelineId == null) {
+        return Promise.reject("endpoint not connected");
+      }
+    }
+    return {
+      eyepopUrl: this._options.eyepopUrl,
+      popId: this._options.popId,
       accessToken: this._token,
-      validUntil: new Date(this._expire_token_time * 1e3)
+      validUntil: this._expire_token_time * 1e3,
+      baseUrl: this._baseUrl,
+      pipelineId: this._pipelineId
     };
-    return token;
   }
   async upload(params) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
@@ -9268,17 +9313,14 @@ var Endpoint = class {
       return Promise.reject("upload for streams requires a mimeType");
     }
     await this._limit.acquire();
-    const job = new UploadJob(
-      params.file,
-      params.mimeType,
-      this._baseUrl,
-      this._pipelineId,
-      await this.authorizationHeader(),
-      this._client,
-      this._requestLogger
-    );
+    this.updateState();
+    const job = new UploadJob(params.file, params.mimeType, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
     return job.start(() => {
-      this._limit?.release();
+      this.jobDone(job);
+    }, (statusCode) => {
+      this.jobStatus(job, statusCode);
     });
   }
   async loadFrom(location) {
@@ -9286,16 +9328,14 @@ var Endpoint = class {
       throw new Error("endpoint not connected, use open() before loadFrom()");
     }
     await this._limit.acquire();
-    const job = new LoadFromJob(
-      location,
-      this._baseUrl,
-      this._pipelineId,
-      await this.authorizationHeader(),
-      this._client,
-      this._requestLogger
-    );
+    this.updateState();
+    const job = new LoadFromJob(location, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
     return job.start(() => {
-      this._limit?.release();
+      this.jobDone(job);
+    }, (statusCode) => {
+      this.jobStatus(job, statusCode);
     });
   }
   // noinspection TypeScriptValidateTypes
@@ -9310,20 +9350,69 @@ var Endpoint = class {
     if (!this._options.popId) {
       return Promise.reject("option popId or environment variable EYEPOP_POP_ID is required");
     }
-    if (this._options.session) {
-      this._token = this._options.session.accessToken;
-      this._expire_token_time = this._options.session.validUntil.getTime() / 1e3;
+    if (this._options.auth && this._options.auth.session) {
+      this._token = this._options.auth.session.accessToken;
+      this._expire_token_time = this._options.auth.session.validUntil / 1e3;
     } else {
-      if (!this._options.secretKey) {
+      if (!this._options.auth || !this._options.auth.secretKey) {
         return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
       }
     }
     this._client = await createHttpClient();
-    this._limit = new Semaphore(this._options.jobQueueLength);
-    const config_url = `${this.eyepopUrl()}/pops/${this._options.popId}/config?auto_start=${this._options.autoStart}`;
+    let result = await this.reconnect();
+    if (this._baseUrl && this._options.stopJobs) {
+      const stop_url = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=preempt&processing=sync`;
+      const body = { "sourceType": "NONE" };
+      const headers = {
+        "Authorization": await this.authorizationHeader(),
+        "Content-Type": "application/json"
+      };
+      this._requestLogger.debug("before PATCH %s", stop_url);
+      let response = await this._client.fetch(stop_url, { method: "PATCH", headers, body: JSON.stringify(body) });
+      if (response.status >= 300) {
+        const message = await response.text();
+        return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+      }
+      this._requestLogger.debug("after PATCH %s", stop_url);
+    }
+    return result;
+  }
+  jobDone(job) {
+    this._limit?.release();
+    this.updateState();
+  }
+  updateState(newState = void 0) {
+    const fromState = this._state;
+    if (newState == void 0) {
+      if (this._limit.getPermits() == this._options.jobQueueLength) {
+        newState = "Idle" /* Idle */;
+      } else {
+        newState = "Busy" /* Busy */;
+      }
+    }
+    this._state = newState;
+    if (this._stateChangeHandler) {
+      this._stateChangeHandler(fromState, this._state);
+    }
+  }
+  jobStatus(job, statusCode) {
+    if (statusCode == 404) {
+      this._pipelineId = null;
+      this._baseUrl = null;
+    } else if (statusCode == 401) {
+      this._token = null;
+      this._expire_token_time = null;
+    }
+  }
+  async reconnect() {
+    if (!this._client) {
+      return Promise.reject("endpoint not initialized");
+    }
+    const config_url = `${this.eyepopUrl()}/pops/${this._options.popId}/config?auto_start=false`;
     const headers = {
       "Authorization": await this.authorizationHeader()
     };
+    this.updateState("FetchConfig" /* FetchConfig */);
     this._requestLogger.debug("before GET %s", config_url);
     let response = await this._client.fetch(config_url, { headers });
     if (response.status == 401) {
@@ -9332,41 +9421,47 @@ var Endpoint = class {
       const headers2 = {
         "Authorization": await this.authorizationHeader()
       };
+      this.updateState("FetchConfig" /* FetchConfig */);
       response = await this._client.fetch(config_url, {
         headers: headers2
         // @ts-ignore
       });
     }
     if (response.status != 200) {
+      this.updateState("Error" /* Error */);
       const message = await response.text();
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-    }
-    const data = await response.json();
-    const config = data;
-    this._baseUrl = config.base_url;
-    this._pipelineId = config.pipeline_id;
-    this._popName = config.name;
-    this._requestLogger.debug("after GET %s: %s / %s", config_url, this._baseUrl, this._pipelineId);
-    if (!this._pipelineId || !this._baseUrl) {
-      return Promise.reject(`Pop not started`);
-    }
-    this._baseUrl = this._baseUrl.replace(/\/+$/, "");
-    if (this._options.stopJobs) {
-      const stop_url = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=preempt&processing=sync`;
-      const body = { "sourceType": "NONE" };
-      const headers2 = {
-        "Authorization": await this.authorizationHeader(),
-        "Content-Type": "application/json"
-      };
-      this._requestLogger.debug("before PATCH %s", stop_url);
-      let response2 = await this._client.fetch(stop_url, { method: "PATCH", headers: headers2, body: JSON.stringify(body) });
-      if (response2.status >= 300) {
-        const message = await response2.text();
-        return Promise.reject(`Unexpected status ${response2.status}: ${message}`);
+    } else {
+      let config = await response.json();
+      if (!config.base_url && this._options.autoStart) {
+        const auto_start_config_url = `${this.eyepopUrl()}/pops/${this._options.popId}/config?auto_start=true`;
+        this._requestLogger.debug("pop was not running, trying to autostart with: %s", auto_start_config_url);
+        const headers2 = {
+          "Authorization": await this.authorizationHeader()
+        };
+        this.updateState("StartingPop" /* StartingPop */);
+        response = await this._client.fetch(auto_start_config_url, {
+          headers: headers2
+          // @ts-ignore
+        });
+        if (response.status != 200) {
+          this.updateState("Error" /* Error */);
+          const message = await response.text();
+          return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+        }
+        config = await response.json();
       }
-      this._requestLogger.debug("after PATCH %s", stop_url);
+      this._baseUrl = config.base_url;
+      this._pipelineId = config.pipeline_id;
+      this._popName = config.name;
+      this._requestLogger.debug("after GET %s: %s / %s", config_url, this._baseUrl, this._pipelineId);
+      if (!this._pipelineId || !this._baseUrl) {
+        return Promise.reject(`Pop not started`);
+      }
+      this._baseUrl = this._baseUrl.replace(/\/+$/, "");
+      this.updateState();
+      return Promise.resolve(this);
     }
-    return this;
   }
   async disconnect(wait = true) {
     if (wait && this._limit) {
@@ -9374,13 +9469,13 @@ var Endpoint = class {
         await this._limit.acquire();
       }
     }
+    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
     if (this._client) {
       await this._client.close();
       this._client = null;
     }
     this._baseUrl = null;
     this._pipelineId = null;
-    this._limit = null;
   }
   async authorizationHeader() {
     return `Bearer ${await this.currentAccessToken()}`;
@@ -9388,12 +9483,13 @@ var Endpoint = class {
   async currentAccessToken() {
     const now = Date.now() / 1e3;
     if (!this._token || this._expire_token_time < now) {
+      this.updateState("Authenticating" /* Authenticating */);
       if (!this._client) {
         return Promise.reject("endpoint not connected");
-      } else if (!this._options.secretKey) {
+      } else if (!this._options.auth || !this._options.auth.secretKey) {
         return Promise.reject("temporary access token expired");
       }
-      const body = { "secret_key": this._options.secretKey };
+      const body = { "secret_key": this._options.auth.secretKey };
       const headers = { "Content-Type": "application/json" };
       const post_url = `${this.eyepopUrl()}/authentication/token`;
       this._requestLogger.debug("before POST %s", post_url);
@@ -9411,6 +9507,7 @@ var Endpoint = class {
       const token = data;
       this._token = token.access_token;
       this._expire_token_time = now + token.expires_in - 60;
+      this.updateState();
     }
     this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - now);
     return this._token;
@@ -9433,17 +9530,19 @@ var _EyePopPlot = class _EyePopPlot {
   }
   prediction(p) {
     if (p && p.objects) {
+      const x_scale = this._context.canvas.width / p.source_width;
+      const y_scale = this._context.canvas.height / p.source_height;
       for (let i = 0; i < p.objects.length; i++) {
-        this.object(p.objects[i]);
+        this.object(p.objects[i], x_scale, y_scale);
       }
     }
   }
-  object(obj) {
+  object(obj, x_scale, y_scale) {
     const context = this._context;
-    const x = obj.x;
-    const y = obj.y;
-    const w = obj.width;
-    const h = obj.height;
+    const x = obj.x * x_scale;
+    const y = obj.y * y_scale;
+    const w = obj.width * x_scale;
+    const h = obj.height * y_scale;
     context.beginPath();
     context.rect(obj.x, obj.y, obj.width, obj.height);
     context.lineWidth = 1;
@@ -9535,11 +9634,50 @@ _EyePopPlot.colors = {
 };
 var EyePopPlot = _EyePopPlot;
 
+// src/shims/browser_session.ts
+var authenticateBrowserSession;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  authenticateBrowserSession = (oauthUrl, eyepopUrl, popId) => {
+    const queryString = window.location.search;
+    const urlParams = new URLSearchParams(queryString);
+    let token = urlParams.get("pop_token");
+    if (token) {
+      urlParams.delete("pop_token");
+      const url = `${window.location.pathname}?${urlParams}`;
+      window.history.replaceState({}, document.title, url);
+      return {
+        eyepopUrl,
+        popId,
+        accessToken: token,
+        validUntil: Date.now() + 60 * 60 * 1e3
+      };
+    } else {
+      const url = `${oauthUrl}?url=${encodeURIComponent(window.location.href)}`;
+      window.location.replace(url);
+      return {
+        eyepopUrl,
+        popId,
+        accessToken: "in-progress",
+        validUntil: 0
+      };
+    }
+  };
+} else {
+  authenticateBrowserSession = (oauthUrl, eyepopUrl, popId) => {
+    return null;
+  };
+}
+
 // src/index.ts
+var readEnv = (env) => {
+  if (typeof process !== "undefined") {
+    return process.env?.[env] ?? void 0;
+  }
+  return void 0;
+};
 var EyePopSdk = class {
   static endpoint({
-    secretKey = readEnv("EYEPOP_SECRET_KEY"),
-    session = void 0,
+    auth = this.defaultAuth,
     popId = readEnv("EYEPOP_POP_ID"),
     eyepopUrl = readEnv("EYEPOP_URL"),
     autoStart = true,
@@ -9548,11 +9686,17 @@ var EyePopSdk = class {
     logger,
     ...opts
   } = {}) {
+    if (auth.oAuth && popId) {
+      let oauthUrl = "https://dashboard.eyepop.ai/sdkauth";
+      if (typeof auth.oAuth == "string") {
+        oauthUrl = auth.oAuth;
+      }
+      auth.session = authenticateBrowserSession(oauthUrl, eyepopUrl ?? "https://api.eyepop.ai", popId) ?? void 0;
+    }
     const options = {
-      secretKey,
-      session,
-      popId,
-      eyepopUrl: eyepopUrl ?? "https://api.eyepop.ai",
+      auth,
+      popId: auth.session ? auth.session.popId : popId,
+      eyepopUrl: auth.session ? auth.session.eyepopUrl : eyepopUrl ?? "https://api.eyepop.ai",
       autoStart,
       stopJobs,
       jobQueueLength,
@@ -9565,14 +9709,14 @@ var EyePopSdk = class {
     return new EyePopPlot(context);
   }
 };
-var readEnv = (env) => {
-  if (typeof process !== "undefined") {
-    return process.env?.[env] ?? void 0;
-  }
-  return void 0;
+EyePopSdk.defaultAuth = {
+  secretKey: readEnv("EYEPOP_SECRET_KEY")
 };
+var src_default = EyePopSdk;
 export {
-  EyePopSdk
+  EndpointState,
+  EyePopSdk,
+  src_default as default
 };
 /*! Bundled license information: