@thatopen/services 0.7.0 → 0.9.0

package/dist/cli.js

@@ -4205,8 +4205,8 @@ class BaseXHR extends Polling {
   /**
    * Sends data.
    *
-   * @param {String} data to send.
-   * @param {Function} called upon flush.
+   * @param {String} data - data to send.
+   * @param {Function} fn - called upon flush.
    * @private
    */
   doWrite(data, fn) {
@@ -4959,7 +4959,7 @@ class SocketWithoutUpgrade extends Emitter {
   /**
    * Sends a packet.
    *
-   * @param {String} type: packet type.
+   * @param {String} type - packet type.
    * @param {String} data.
    * @param {Object} options.
    * @param {Function} fn - callback function.
@@ -5194,11 +5194,12 @@ class SocketWithUpgrade extends SocketWithoutUpgrade {
 }
 let Socket$1 = class Socket extends SocketWithUpgrade {
   constructor(uri, opts = {}) {
-    const o = typeof uri === "object" ? uri : opts;
+    const isOptionsOnly = typeof uri === "object";
+    const o = isOptionsOnly ? { ...uri } : { ...opts };
     if (!o.transports || o.transports && typeof o.transports[0] === "string") {
       o.transports = (o.transports || ["polling", "websocket", "webtransport"]).map((transportName) => transports[transportName]).filter((t) => !!t);
     }
-    super(uri, o);
+    super(isOptionsOnly ? o : uri, o);
   }
 };
 function url(uri, path2 = "", loc) {
@@ -5419,12 +5420,13 @@ class Encoder {
 class Decoder extends Emitter {
   /**
    * Decoder constructor
-   *
-   * @param {function} reviver - custom reviver to pass down to JSON.stringify
    */
-  constructor(reviver) {
+  constructor(opts) {
     super();
-    this.reviver = reviver;
+    this.opts = Object.assign({
+      reviver: void 0,
+      maxAttachments: 10
+    }, typeof opts === "function" ? { reviver: opts } : opts);
   }
   /**
    * Decodes an encoded packet string into packet JSON.
@@ -5484,7 +5486,13 @@ class Decoder extends Emitter {
       if (buf != Number(buf) || str.charAt(i) !== "-") {
         throw new Error("Illegal attachments");
       }
-      p.attachments = Number(buf);
+      const n = Number(buf);
+      if (!isInteger(n) || n < 0) {
+        throw new Error("Illegal attachments");
+      } else if (n > this.opts.maxAttachments) {
+        throw new Error("too many attachments");
+      }
+      p.attachments = n;
     }
     if ("/" === str.charAt(i + 1)) {
       const start = i + 1;
@@ -5525,7 +5533,7 @@ class Decoder extends Emitter {
   }
   tryParse(str) {
     try {
-      return JSON.parse(str, this.reviver);
+      return JSON.parse(str, this.opts.reviver);
     } catch (e) {
       return false;
     }
@@ -5587,6 +5595,9 @@ class BinaryReconstructor {
     this.buffers = [];
   }
 }
+const isInteger = Number.isInteger || function(value2) {
+  return typeof value2 === "number" && isFinite(value2) && Math.floor(value2) === value2;
+};
 function isObject(value2) {
   return Object.prototype.toString.call(value2) === "[object Object]";
 }
@@ -6942,6 +6953,14 @@ class EngineServicesClient {
    * the new token is picked up on every request — expired tokens no
    * longer stick around.
    */
+  /**
+   * Socket origin without namespace or query, for gateways other than the
+   * execution one. `wsUrl` already carries a token that may be stale when a
+   * provider is in play, so callers append their own.
+   */
+  get socketOrigin() {
+    return this.wsUrl.split("?")[0];
+  }
   async resolveAccessToken() {
     return this.accessToken;
   }
@@ -8120,7 +8139,7 @@ const libVersion = (() => {
   }
 })();
 const templatesDir = require$$2.join(__dirname, "..", "src", "cli", "templates");
-const createCommand = new Command2("create").argument("<project-name>", 'Name of the project to create (use "." for current directory)').option("-t, --template <template>", `Template (${TEMPLATES.join(", ")})`, "app").option("--beta", "Use beta engine libraries (@thatopen-platform/*-beta)").description("Scaffold a new ThatOpen app or cloud component project").action(async (projectName, opts) => {
+const createCommand = new Command2("create").argument("<project-name>", 'Name of the project to create (use "." for current directory)').option("-t, --template <template>", `Template (${TEMPLATES.join(", ")})`, "app").option("--beta", "Use beta engine libraries (@thatopen-platform/*-beta)").option("--history", "App only: include the revit-flow commit history panel, already wired").description("Scaffold a new ThatOpen app or cloud component project").action(async (projectName, opts) => {
   const template = opts.template;
   if (!TEMPLATES.includes(template)) {
     console.error(`Unknown template "${opts.template}". Available: ${TEMPLATES.join(", ")}`);
@@ -8159,6 +8178,16 @@ The templates currently require the beta engine libraries. Public (non-beta) eng
   if (isCloud) {
     require$$3.renameSync(require$$2.join(targetDir, "_thatopen"), require$$2.join(targetDir, ".thatopen"));
   }
+  if (!isCloud) {
+    const variant = require$$2.join(targetDir, "src", "main.history.ts");
+    if (require$$3.existsSync(variant)) {
+      if (opts.history) require$$3.renameSync(variant, require$$2.join(targetDir, "src", "main.ts"));
+      else require$$3.rmSync(variant);
+    }
+  } else if (opts.history) {
+    console.error("--history applies to the app template only.");
+    process.exit(1);
+  }
   const pkgPath = require$$2.join(targetDir, "package.json");
   const pkgContent = require$$3.readFileSync(pkgPath, "utf-8").replace(/\{\{PROJECT_NAME\}\}/g, packageName).replace(/\{\{VERSION\}\}/g, libVersion).replace(/"@thatopen\/services": "file:[^"]*"/, `"@thatopen/services": "^${libVersion}"`);
   require$$3.writeFileSync(pkgPath, pkgContent);
@@ -8216,7 +8245,7 @@ Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/js
 JSZip uses the library pako released under the MIT license :
 https://github.com/nodeca/pako/blob/main/LICENSE
 */
-(function(module2, exports$1) {
+(function(module2, exports) {
   !function(e) {
     module2.exports = e();
   }(function() {
@@ -11733,6 +11762,38 @@ function discoveryFile() {
   const appData = process.env.APPDATA || require$$2.join(node_os.homedir(), "AppData", "Roaming");
   return require$$2.join(appData, "ThatOpen", "revit-addin.json");
 }
+function tryDiscoverAddin() {
+  const file = discoveryFile();
+  if (!require$$3.existsSync(file)) return null;
+  try {
+    return JSON.parse(require$$3.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function addinAlive() {
+  const info = tryDiscoverAddin();
+  if (!info) return false;
+  try {
+    const res = await fetch(`http://127.0.0.1:${info.port}/status`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-RevitFlow-Token": info.token },
+      body: "{}",
+      signal: AbortSignal.timeout(4e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function waitForAddin(timeoutMs) {
+  const until = Date.now() + timeoutMs;
+  while (Date.now() < until) {
+    if (await addinAlive()) return true;
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  return false;
+}
 function discoverAddin() {
   const file = discoveryFile();
   if (!require$$3.existsSync(file)) {
@@ -11789,6 +11850,28 @@ async function configureAddin(apiUrl, accessToken) {
     key: accessToken
   });
 }
+function isRevitRunning() {
+  if (process.platform !== "win32") return false;
+  try {
+    return require$$1.execSync('tasklist /FI "IMAGENAME eq Revit.exe" /NH', { encoding: "utf-8" }).toLowerCase().includes("revit.exe");
+  } catch {
+    return false;
+  }
+}
+function startRevit() {
+  const roots = ["C:\\Program Files\\Autodesk"];
+  for (const root of roots) {
+    if (!require$$3.existsSync(root)) continue;
+    for (const dir of require$$3.readdirSync(root)) {
+      if (!/^Revit \d{4}$/.test(dir)) continue;
+      const exe = require$$2.join(root, dir, "Revit.exe");
+      if (!require$$3.existsSync(exe)) continue;
+      require$$1.spawn(exe, [], { detached: true, stdio: "ignore" }).unref();
+      return;
+    }
+  }
+  console.log("      Could not find Revit.exe. Start Revit yourself and this will pick it up.");
+}
 const REVIT_ADDIN_PACKAGE = "@thatopen-platform/flow-revit";
 const revitCommand = new Command2("revit").description(
   "Revit collaboration — drive the That Open Revit add-in from the CLI"
@@ -11815,6 +11898,64 @@ revitCommand.command("inspect").description("Check whether a .rvt is already a w
     console.log("Ask the user for consent, then run publish-central with --convert.");
   }
 });
+revitCommand.command("share").description("Share a .rvt with your team: install if needed, publish the central, open your local").requiredOption("--file <path>", "Absolute path to the .rvt on this machine").requiredOption("--project <id>", "Platform project id (or the dashboard URL)").option("--doc <name>", "Short name for the shared central (default: from the file name)").action(async (opts) => {
+  const cfg = requireResolvedConfig();
+  const file = require$$2.resolve(opts.file);
+  if (!require$$3.existsSync(file)) {
+    console.error(`No such file: ${file}`);
+    process.exit(1);
+  }
+  const project = opts.project.match(/projects\/([a-f0-9]{24})/i)?.[1] ?? opts.project;
+  const doc = opts.doc ?? require$$2.basename(file, ".rvt").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  console.log(`Sharing "${require$$2.basename(file)}" as "${doc}" in project ${project}.
+`);
+  if (!await addinAlive()) {
+    if (!isRevitRunning()) {
+      console.log("[1/5] Installing the Revit add-in...");
+      const client = new EngineServicesClient(cfg.accessToken, cfg.apiUrl);
+      const { dir, cleanup } = await fetchPluginPackage(client, REVIT_ADDIN_PACKAGE, "latest");
+      try {
+        const installer = require$$2.join(dir, "install.ps1");
+        if (!require$$3.existsSync(installer)) throw new Error("The package has no install.ps1.");
+        require$$1.execFileSync("powershell", ["-ExecutionPolicy", "Bypass", "-File", installer], {
+          stdio: "inherit"
+        });
+      } finally {
+        cleanup();
+      }
+      console.log("[2/5] Starting Revit...");
+      startRevit();
+    } else {
+      console.log("[1/5] Waiting for Revit...");
+    }
+    if (!await waitForAddin(3e5)) {
+      console.error(
+        '\nRevit did not report in. If it is open, the add-in may not be installed:\n  close Revit, run "thatopen revit install", and start it again.'
+      );
+      process.exit(1);
+    }
+  } else {
+    console.log("[1/5] Revit is open and the add-in is answering.");
+  }
+  await configureAddin(cfg.apiUrl, cfg.accessToken);
+  console.log("[3/5] Checking the file...");
+  const info = await callAddin("inspect", { file });
+  console.log(
+    info.isCentral ? "      Already a workshared central. Publishing a copy of it." : "      Not a central yet. Converting a COPY. Your file is not modified."
+  );
+  console.log("[4/5] Publishing to the platform (Revit is saving the central, this takes a bit)...");
+  const pub = await callAddin("publish-central", { project, doc, file, convert: true });
+  console.log("[5/5] Creating and opening your local...");
+  const joined = await callAddin("join", { project, doc });
+  console.log(`
+Shared. Central "${doc}" is v${pub.version} in project ${project}.`);
+  console.log(`Your local, now open in Revit:
+  ${joined.local}`);
+  console.log(`
+Teammates join with:
+  thatopen revit join --project ${project} --doc ${doc}`);
+  console.log(`From here, Revit's own Synchronize with Central publishes to the team.`);
+});
 revitCommand.command("publish-central").description("Turn a .rvt into a shared central and upload it to a project").requiredOption("--project <id>", "Platform project id").requiredOption("--doc <name>", "A short name for this central (e.g. tower-central)").requiredOption("--file <path>", "Absolute path to the source .rvt on this machine").option("--convert", "Allow converting a non-central .rvt into one (on a copy; original untouched)").action(async (opts) => {
   await connect();
   console.log(`Publishing "${opts.file}" as central "${opts.doc}"...`);

package/dist/core/client.d.ts

@@ -207,6 +207,12 @@ export declare class EngineServicesClient {
      * the new token is picked up on every request — expired tokens no
      * longer stick around.
      */
+    /**
+     * Socket origin without namespace or query, for gateways other than the
+     * execution one. `wsUrl` already carries a token that may be stale when a
+     * provider is in play, so callers append their own.
+     */
+    protected get socketOrigin(): string;
     protected resolveAccessToken(): Promise<string>;
     /**
      * Protected extension hook for subclasses (e.g. `PlatformClient`) that

package/dist/core/platform-client.d.ts

@@ -1,6 +1,33 @@
 import { EngineServicesClient, EngineServicesClientProps } from './client';
 import { Project, ProjectData } from '../types/projects';
+import { MarkNotificationsReadResultDto, NotificationPageDto, NotificationSubscriptionView } from '../types/notifications';
 
+/**
+ * What arrived on the socket. One callback for all three because a bell
+ * reacts the same way to each: refresh the badge, and the list if open.
+ *
+ * `allRead` is one event for the whole sweep rather than one per
+ * notification, so do not expect an id on it.
+ */
+export type LiveNotificationEvent = {
+    type: 'created';
+    id: string;
+} | {
+    type: 'read';
+    id: string;
+} | {
+    type: 'allRead';
+    batch: number;
+};
+/** Per-automation opt-in. `failures` skips started events entirely. */
+export type NotificationSubscriptionFilterInput = 'all' | 'failures';
+export interface NotificationSubscriptionInput {
+    filter?: NotificationSubscriptionFilterInput;
+    /** Overrides the account-level channel setting for this automation only. */
+    channels?: {
+        email?: boolean;
+    };
+}
 /** Scope by which a permission was granted (or `'none'` if denied). */
 export type PermissionScope = 'global' | 'project' | 'entity' | 'none';
 /** Result of a single permission check. */
@@ -110,4 +137,116 @@ export declare class PlatformClient extends EngineServicesClient {
      * single round-trip; results come back in the same order as `checks`.
      */
     checkPermissionBatch(checks: PermissionCheckEntry[]): Promise<PermissionCheckResult[]>;
+    /**
+     * Lists the signed-in user's notifications, newest first.
+     *
+     * Scoped to whoever the bearer token belongs to — an app cannot read
+     * anyone else's. Muted notifications are included: muting silences the
+     * badge and the delivery channels, it does not hide the record.
+     *
+     * Paginate by passing the previous response's `nextCursor` back in; it is
+     * opaque, so do not build one by hand. A null `nextCursor` means the last
+     * page.
+     *
+     * @example Walk every page:
+     * ```ts
+     * let cursor: string | undefined;
+     * do {
+     *   const page = await client.getNotifications({ cursor });
+     *   render(page.items);
+     *   cursor = page.nextCursor ?? undefined;
+     * } while (cursor);
+     * ```
+     */
+    getNotifications(params?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<NotificationPageDto>;
+    /**
+     * Number of unread notifications, excluding muted ones. This is the bell
+     * badge count, so it is cheap to poll.
+     */
+    getUnreadNotificationCount(): Promise<number>;
+    /**
+     * Marks specific notifications as read. Ids the caller does not own are
+     * ignored rather than rejected, so `updated` can be lower than the number
+     * passed in.
+     */
+    markNotificationsRead(notificationIds: string[]): Promise<MarkNotificationsReadResultDto>;
+    /** Marks every unread notification as read in one call. */
+    markAllNotificationsRead(): Promise<MarkNotificationsReadResultDto>;
+    /**
+     * The automations this user has subscribed to. Nobody is subscribed by
+     * default, so an empty list is the normal state.
+     */
+    getNotificationSubscriptions(): Promise<NotificationSubscriptionView[]>;
+    /**
+     * Removes this user's subscription to one automation.
+     *
+     * Unlike subscribing, which happens through the project routes, this works
+     * for any automation the user is subscribed to and keeps working after the
+     * automation itself is gone — opting out must never be the thing that
+     * fails.
+     */
+    unsubscribeFromAutomation(hookId: string): Promise<{
+        unsubscribed: boolean;
+    }>;
+    /**
+     * Subscribes the signed-in user to one project automation's runs.
+     *
+     * Nobody is subscribed by default, so this is what makes an automation
+     * produce notifications for this user at all. Subscribing again is
+     * harmless: it updates the existing subscription rather than duplicating.
+     *
+     * Read-level access to the project is enough. Someone who can see an
+     * automation can follow it without being able to change it.
+     *
+     * @example Follow only the failures, and email me about them:
+     * ```ts
+     * await client.subscribeToAutomation(projectId, hookId, {
+     *   filter: 'failures',
+     *   channels: { email: true },
+     * });
+     * ```
+     */
+    subscribeToAutomation(projectId: string, hookId: string, input?: NotificationSubscriptionInput): Promise<{
+        subscribed: true;
+    }>;
+    /**
+     * Changes an existing subscription. Only the fields passed are touched, so
+     * sending `channels` alone leaves the filter as it was.
+     *
+     * Throws if the user is not subscribed; use {@link subscribeToAutomation}
+     * to create one.
+     */
+    updateAutomationSubscription(projectId: string, hookId: string, changes: NotificationSubscriptionInput): Promise<{
+        updated: true;
+    }>;
+    /**
+     * Listens for this user's notifications in real time.
+     *
+     * Unlike {@link EngineServicesClient.onExecutionProgress}, which follows one
+     * execution and closes when it ends, this stays connected for the session:
+     * the server puts the socket in a room for the signed-in account and pushes
+     * anything addressed to them.
+     *
+     * The events carry ids rather than the notifications themselves, so treat
+     * them as a signal to refresh. That keeps a burst cheap and means the
+     * server is never the source of a stale render.
+     *
+     * Requires a user JWT. An API access token is rejected by the gateway,
+     * because it identifies a token rather than a person.
+     *
+     * @returns a function that disconnects. Call it on unmount.
+     *
+     * @example
+     * ```ts
+     * const stop = await client.onNotification((event) => {
+     *   if (event.type === 'created') refreshBell();
+     * });
+     * // later
+     * stop();
+     * ```
+     */
+    onNotification(onEvent: (event: LiveNotificationEvent) => void): Promise<() => void>;
 }

package/dist/core/platform-client.live.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/platform-client.notifications.test.d.ts

@@ -0,0 +1 @@
+export {};