@kitschpatrol/tldraw-cli 4.5.5 → 4.6.1

package/bin/cli.js

@@ -786,7 +786,7 @@ var require_irregular_plurals2 = __commonJS({
 });
 
 // package.json
-var version = "4.5.5";
+var version = "4.6.1";
 
 // node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -17221,13 +17221,16 @@ var TldrawController = class {
           log_default.errorPrefixed("Browser", messageText);
         }
       } else if (messageType === "warn") {
-        log_default.warnPrefixed("Browser", messageText);
+        if (messageText !== "[tldraw] `Store.loadSnapshot` is deprecated and will be removed in a future release. Use `loadSnapshot` from the 'tldraw' package instead.") {
+          log_default.warnPrefixed("Browser", messageText);
+        }
       } else {
         log_default.infoPrefixed("Browser", messageText);
       }
     });
     log_default.info(`Navigating to: ${this.href}`);
     await this.page.goto(this.href, { waitUntil: "networkidle0" });
+    await this.page.waitForFunction("editor !== undefined");
     const shapeCount = await this.page.evaluate("editor.getCurrentPageShapes().length");
     this.isEmpty = shapeCount === 0;
   }
@@ -17308,6 +17311,7 @@ var TldrawController = class {
         await this.setCurrentPage(download.pageId);
         pageChanged = true;
       }
+      await this.page.waitForFunction("editor !== undefined");
       if (download.frameId === void 0) {
         await this.page.evaluate("editor.selectAll()");
       } else {
@@ -17832,6 +17836,7 @@ function nanoid(size = 21) {
 // src/lib/tldraw-open.ts
 import fs8 from "node:fs/promises";
 import os5 from "node:os";
+import { URL as URL2 } from "node:url";
 
 // node_modules/.pnpm/open@10.1.0/node_modules/open/index.js
 import process7 from "node:process";
@@ -18273,79 +18278,64 @@ defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
 var open_default = open;
 
 // src/lib/tldraw-open.ts
-async function tldrawOpen(tldrPathOrUrl, local = false) {
+var tldrawOpenDefaultOptions = {
+  location: "remote"
+};
+async function tldrawOpen(tldrPathOrUrl, options) {
   const tldrawRemoteUrl = "https://www.tldraw.com";
-  if (tldrPathOrUrl === void 0 && local) {
+  const { location } = { ...tldrawOpenDefaultOptions, ...options };
+  let urlToOpen;
+  const validatedPathOrUrl = tldrPathOrUrl === void 0 ? void 0 : validatePathOrUrl(tldrPathOrUrl, {
+    requireFileExistence: true,
+    validFileExtensions: [".tldr"],
+    validHostnames: ["www.tldraw.com"]
+  });
+  if (location === "local" && validatedPathOrUrl === void 0) {
     const tldrawServer = new LocalTldrawServer();
     await tldrawServer.start();
-    log_default.info(`Opened tldraw.com sketch locally at ${tldrawServer.href}`);
-    process.stdout.write(`${tldrawServer.href}
-`);
-    await open_default(tldrawServer.href, { wait: true });
-    return tldrawServer.href;
-  }
-  if (tldrPathOrUrl === void 0 && !local) {
-    await open_default(tldrawRemoteUrl);
-    log_default.info(`Opened tldraw.com`);
-    process.stdout.write(`${tldrawRemoteUrl}
-`);
-    return tldrawRemoteUrl;
-  }
-  if (tldrPathOrUrl !== void 0) {
-    const validatedPathOrUrl = validatePathOrUrl(tldrPathOrUrl, {
-      requireFileExistence: true,
-      validFileExtensions: [".tldr"],
-      validHostnames: ["www.tldraw.com"]
+    urlToOpen = tldrawServer.href;
+    log_default.info(`Opened blank tldraw sketch locally at "${urlToOpen}"`);
+  } else if (location === "local" && typeof validatedPathOrUrl === "string") {
+    const tldrData = await fs8.readFile(validatedPathOrUrl, "utf8");
+    const tldrawServer = new LocalTldrawServer(tldrData);
+    await tldrawServer.start();
+    urlToOpen = tldrawServer.href;
+    log_default.info(`Opened copy of tldraw sketch "${validatedPathOrUrl}" locally at "${urlToOpen}"`);
+  } else if (location === "local" && validatedPathOrUrl instanceof URL2) {
+    const [savedFile] = await tldrawToImage(validatedPathOrUrl.href, {
+      format: "tldr",
+      name: nanoid(),
+      output: os5.tmpdir()
     });
-    if (typeof validatedPathOrUrl === "string" && local) {
-      const tldrData = await fs8.readFile(validatedPathOrUrl, "utf8");
-      const tldrawServer = new LocalTldrawServer(tldrData);
-      await tldrawServer.start();
-      log_default.info(
-        `Opened copy of tldraw sketch "${validatedPathOrUrl}" locally at "${tldrawServer.href}"`
-      );
-      process.stdout.write(`${tldrawServer.href}
-`);
-      await open_default(tldrawServer.href, { wait: true });
-      return tldrawServer.href;
-    }
-    if (typeof validatedPathOrUrl === "string" && !local) {
-      const remoteUrl = await tldrawToShareUrl(validatedPathOrUrl);
-      log_default.info(
-        `Opened copy of local tldraw sketch "${validatedPathOrUrl}" remotely at "${remoteUrl}"`
-      );
-      await open_default(remoteUrl);
-      process.stdout.write(`${remoteUrl}
-`);
-      return remoteUrl;
-    }
-    if (typeof validatedPathOrUrl !== "string" && local) {
-      const [savedFile] = await tldrawToImage(validatedPathOrUrl.href, {
-        format: "tldr",
-        name: nanoid(),
-        output: os5.tmpdir()
-      });
-      const tldrData = await fs8.readFile(savedFile, "utf8");
-      await fs8.rm(savedFile, { force: true });
-      const tldrawServer = new LocalTldrawServer(tldrData);
-      await tldrawServer.start();
-      log_default.info(
-        `Opened a local copy of tldraw sketch url "${validatedPathOrUrl.href}" locally at ${tldrawServer.href}`
-      );
-      process.stdout.write(`${tldrawServer.href}
-`);
-      await open_default(tldrawServer.href, { wait: true });
-      return tldrawServer.href;
-    }
-    if (typeof validatedPathOrUrl !== "string" && !local) {
-      await open_default(validatedPathOrUrl.href);
-      log_default.info(`Opened tldraw sketch url at ${validatedPathOrUrl.href}`);
-      process.stdout.write(`${validatedPathOrUrl.href}
-`);
-      return validatedPathOrUrl.href;
-    }
+    const tldrData = await fs8.readFile(savedFile, "utf8");
+    await fs8.rm(savedFile, { force: true });
+    const tldrawServer = new LocalTldrawServer(tldrData);
+    await tldrawServer.start();
+    urlToOpen = tldrawServer.href;
+    log_default.info(
+      `Opened a local copy of tldraw sketch url "${validatedPathOrUrl.href}" locally at ${urlToOpen}`
+    );
+  } else if (location === "remote" && validatedPathOrUrl === void 0) {
+    urlToOpen = tldrawRemoteUrl;
+    log_default.info(`Opened tldraw.com`);
+  } else if (location === "remote" && typeof validatedPathOrUrl === "string") {
+    urlToOpen = await tldrawToShareUrl(validatedPathOrUrl);
+    log_default.info(
+      `Opened copy of local tldraw sketch "${validatedPathOrUrl}" remotely at "${urlToOpen}"`
+    );
+  } else if (location === "remote" && validatedPathOrUrl instanceof URL2) {
+    urlToOpen = validatedPathOrUrl.href;
+    log_default.info(`Opened tldraw sketch url at ${urlToOpen}`);
+  } else {
+    throw new Error("Invalid tldrawOpen options");
   }
-  throw new Error("No file or URL provided");
+  const exitPromise = open_default(urlToOpen, {
+    wait: true
+  });
+  return {
+    browserExitPromise: exitPromise,
+    openedSketchUrl: urlToOpen
+  };
 }
 
 // node_modules/.pnpm/plur@5.1.0/node_modules/plur/index.js
@@ -18463,29 +18453,29 @@ await yargsInstance.scriptName("tldraw").command("$0 <command>", "CLI tools for
     }
     return true;
   }),
-  async (argv) => {
-    const filesOrUrls = argv.filesOrUrls.filter((fileOrUrl) => fileOrUrl !== void 0);
-    const {
-      dark,
-      format,
-      frames,
-      name,
-      output,
-      padding,
-      pages,
-      print,
-      scale,
-      stripStyle,
-      transparent,
-      verbose
-    } = argv;
+  async ({
+    dark,
+    filesOrUrls,
+    format,
+    frames,
+    name,
+    output,
+    padding,
+    pages,
+    print,
+    scale,
+    stripStyle,
+    transparent,
+    verbose
+  }) => {
+    const cleanFilesOrUrls = filesOrUrls.filter((fileOrUrl) => fileOrUrl !== void 0);
     log_default.verbose = verbose;
-    log_default.info(`Exporting ${filesOrUrls.length} ${plur("sketch", filesOrUrls.length)}...`);
+    log_default.info(`Exporting ${cleanFilesOrUrls.length} ${plur("sketch", cleanFilesOrUrls.length)}...`);
     let nameIndex = 0;
     const errorReport = [];
-    for (const fileOrUrl of filesOrUrls) {
+    for (const fileOrUrl of cleanFilesOrUrls) {
       try {
-        const resolvedName = filesOrUrls.length > 1 && name !== void 0 ? `${name}-${nameIndex++}` : name;
+        const resolvedName = cleanFilesOrUrls.length > 1 && name !== void 0 ? `${name}-${nameIndex++}` : name;
         const exportList = await tldrawToImage(fileOrUrl, {
           dark,
           format,
@@ -18508,26 +18498,28 @@ await yargsInstance.scriptName("tldraw").command("$0 <command>", "CLI tools for
         );
       }
     }
-    const successCount = filesOrUrls.length - errorReport.length;
+    const successCount = cleanFilesOrUrls.length - errorReport.length;
     if (errorReport.length > 0) {
       log_default.error(
-        `${successCount} of ${filesOrUrls.length} ${plur("sketch", filesOrUrls.length)} exported successfully`
+        `${successCount} of ${cleanFilesOrUrls.length} ${plur("sketch", cleanFilesOrUrls.length)} exported successfully`
       );
       log_default.error(errorReport.join("\n"));
       process.exit(1);
     }
     if (successCount === 0) {
       log_default.error(
-        `${successCount} of ${filesOrUrls.length} ${plur("sketch", filesOrUrls.length)} exported successfully`
+        `${successCount} of ${cleanFilesOrUrls.length} ${plur("sketch", cleanFilesOrUrls.length)} exported successfully`
       );
     } else {
-      log_default.info(`All ${successCount} ${plur("sketch", filesOrUrls.length)} exported successfully`);
+      log_default.info(
+        `All ${successCount} ${plur("sketch", cleanFilesOrUrls.length)} exported successfully`
+      );
     }
     process.exit(0);
   }
 ).command(
   "open [files-or-urls..]",
-  "Open a tldraw `.tldr` file or tldraw.com URL in your default browser with either the official tldraw.com site or a locally-hosted instance of the editor. Call `open` without an argument to open a blank sketch. Sketches opened via URL with the `--local` flag will be temporarily copied to the local system, and will not be kept in sync with tldraw.com. This process does not exit until the browser is closed.",
+  "Open a tldraw `.tldr` file or tldraw.com URL in your default browser with either the official tldraw.com site or a locally-hosted instance of the editor. Call `open` without an argument to open a blank sketch. Sketches opened via URL with the `--local` flag will be temporarily copied to the local system, and will not be kept in sync with tldraw.com. This process does not exit until the browser is closed. Warning: Passing a local .tldr file without the `--local` option will upload and share the sketch on tldraw.com.",
   (yargs2) => yargs2.positional("files-or-urls", {
     array: true,
     default: void 0,
@@ -18543,37 +18535,30 @@ await yargsInstance.scriptName("tldraw").command("$0 <command>", "CLI tools for
     describe: "Enable verbose logging. All verbose logs and prefixed with their log level and are printed to `stderr` for ease of redirection.",
     type: "boolean"
   }),
-  async (argv) => {
-    const filesOrUrls = argv.filesOrUrls?.filter((fileOrUrl) => fileOrUrl !== void 0);
-    const { local, verbose } = argv;
+  async ({ filesOrUrls, local, verbose }) => {
+    const cleanFilesOrUrls = filesOrUrls === void 0 ? [void 0] : filesOrUrls.length > 1 ? filesOrUrls.filter((fileOrUrl) => fileOrUrl !== void 0) : filesOrUrls;
+    const tlDrawOpenOptions = { location: local ? "local" : "remote" };
     log_default.verbose = verbose;
-    const resultPromises = [];
     let errorCount = 0;
-    if (filesOrUrls === void 0 || filesOrUrls.length === 0) {
+    const browserExitPromises = [];
+    for (const fileOrUrl of cleanFilesOrUrls) {
+      console.log("opening----------------------------------");
+      console.log(fileOrUrl);
       try {
-        resultPromises.push(tldrawOpen(void 0, local));
+        const openResult = await tldrawOpen(fileOrUrl, tlDrawOpenOptions);
+        process.stdout.write(`${openResult.openedSketchUrl}
+`);
+        browserExitPromises.push(openResult.browserExitPromise);
       } catch (error) {
         errorCount++;
-        log_default.error(`Failed to open:": ${error instanceof Error ? error.message : "Unknown Error"}`);
-      }
-    } else {
-      for (const fileOrUrl of filesOrUrls) {
-        if (fileOrUrl === void 0 || fileOrUrl === null) continue;
-        try {
-          resultPromises.push(tldrawOpen(fileOrUrl, local));
-        } catch (error) {
-          errorCount++;
-          log_default.error(
-            `Failed to open "${fileOrUrl}": ${error instanceof Error ? error.message : "Unknown Error"}`
-          );
-        }
+        log_default.error(
+          `Failed to open "${fileOrUrl}": ${error instanceof Error ? error.message : "Unknown Error"}`
+        );
       }
     }
     if (local) {
       log_default.info(source_default.yellow(`Note: This process will exit once the browser is closed.`));
-    }
-    await Promise.all(resultPromises);
-    if (local) {
+      await Promise.allSettled(browserExitPromises);
       log_default.info(`Closing local tldraw ${plur("server", filesOrUrls ? filesOrUrls.length : 1)}`);
     }
     if (errorCount === 0) {

package/dist/lib/index.d.ts

@@ -1,2 +1,4 @@
+export { type TldrawOpenOptions, type TldrawOpenResult, tldrawOpen } from './tldraw-open';
 export { type TldrawFormat, type TldrawToImageOptions, tldrawToImage } from './tldraw-to-image';
+export { tldrawToShareUrl } from './tldraw-to-share-url';
 export { default as log } from './utilities/log';

package/dist/lib/index.js

@@ -1031,18 +1031,18 @@ var proto = Object.defineProperties(() => {
     }
   }
 });
-var createStyler = (open, close, parent2) => {
+var createStyler = (open2, close, parent2) => {
   let openAll;
   let closeAll;
   if (parent2 === void 0) {
-    openAll = open;
+    openAll = open2;
     closeAll = close;
   } else {
-    openAll = parent2.openAll + open;
+    openAll = parent2.openAll + open2;
     closeAll = close + parent2.closeAll;
   }
   return {
-    open,
+    open: open2,
     close,
     openAll,
     closeAll,
@@ -17027,13 +17027,16 @@ var TldrawController = class {
           log_default.errorPrefixed("Browser", messageText);
         }
       } else if (messageType === "warn") {
-        log_default.warnPrefixed("Browser", messageText);
+        if (messageText !== "[tldraw] `Store.loadSnapshot` is deprecated and will be removed in a future release. Use `loadSnapshot` from the 'tldraw' package instead.") {
+          log_default.warnPrefixed("Browser", messageText);
+        }
       } else {
         log_default.infoPrefixed("Browser", messageText);
       }
     });
     log_default.info(`Navigating to: ${this.href}`);
     await this.page.goto(this.href, { waitUntil: "networkidle0" });
+    await this.page.waitForFunction("editor !== undefined");
     const shapeCount = await this.page.evaluate("editor.getCurrentPageShapes().length");
     this.isEmpty = shapeCount === 0;
   }
@@ -17114,6 +17117,7 @@ var TldrawController = class {
         await this.setCurrentPage(download.pageId);
         pageChanged = true;
       }
+      await this.page.waitForFunction("editor !== undefined");
       if (download.frameId === void 0) {
         await this.page.evaluate("editor.selectAll()");
       } else {
@@ -17586,7 +17590,562 @@ function sanitizeName(name, format) {
   }
   return path4.basename(name);
 }
+
+// src/lib/tldraw-to-share-url.ts
+async function tldrawToShareUrl(tldrPathOrUrl) {
+  const validatedPathOrUrl = validatePathOrUrl(tldrPathOrUrl, {
+    requireFileExistence: true,
+    validFileExtensions: [".tldr"],
+    validHostnames: ["www.tldraw.com"]
+  });
+  if (typeof validatedPathOrUrl === "string") {
+    const tldrawController = new TldrawController("https://www.tldraw.com");
+    await tldrawController.start();
+    await tldrawController.loadFile(validatedPathOrUrl);
+    const shareUrl = await tldrawController.getShareUrl();
+    await tldrawController.close();
+    return shareUrl;
+  }
+  return validatedPathOrUrl.href;
+}
+
+// node_modules/.pnpm/nanoid@5.0.7/node_modules/nanoid/index.js
+import { webcrypto as crypto } from "node:crypto";
+
+// node_modules/.pnpm/nanoid@5.0.7/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/.pnpm/nanoid@5.0.7/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size -= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// src/lib/tldraw-open.ts
+import fs8 from "node:fs/promises";
+import os5 from "node:os";
+import { URL as URL2 } from "node:url";
+
+// node_modules/.pnpm/open@10.1.0/node_modules/open/index.js
+import process7 from "node:process";
+import { Buffer as Buffer2 } from "node:buffer";
+import path5 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import childProcess from "node:child_process";
+import fs7, { constants as fsConstants } from "node:fs/promises";
+
+// node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
+import process3 from "node:process";
+import os4 from "node:os";
+import fs6 from "node:fs";
+
+// node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+import fs5 from "node:fs";
+
+// node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
+import fs4 from "node:fs";
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    fs4.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs4.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+
+// node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    fs5.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isInsideContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+
+// node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
+var isWsl = () => {
+  if (process3.platform !== "linux") {
+    return false;
+  }
+  if (os4.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    return fs6.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+  } catch {
+    return false;
+  }
+};
+var is_wsl_default = process3.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+// node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+
+// node_modules/.pnpm/default-browser@5.2.1/node_modules/default-browser/index.js
+import { promisify as promisify4 } from "node:util";
+import process6 from "node:process";
+import { execFile as execFile4 } from "node:child_process";
+
+// node_modules/.pnpm/default-browser-id@5.0.0/node_modules/default-browser-id/index.js
+import { promisify } from "node:util";
+import process4 from "node:process";
+import { execFile } from "node:child_process";
+var execFileAsync = promisify(execFile);
+async function defaultBrowserId() {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  return match?.groups.id ?? "com.apple.Safari";
+}
+
+// node_modules/.pnpm/run-applescript@7.0.0/node_modules/run-applescript/index.js
+import process5 from "node:process";
+import { promisify as promisify2 } from "node:util";
+import { execFile as execFile2, execFileSync } from "node:child_process";
+var execFileAsync2 = promisify2(execFile2);
+async function runAppleScript(script, { humanReadableOutput = true } = {}) {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments]);
+  return stdout.trim();
+}
+
+// node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+
+// node_modules/.pnpm/default-browser@5.2.1/node_modules/default-browser/windows.js
+import { promisify as promisify3 } from "node:util";
+import { execFile as execFile3 } from "node:child_process";
+var execFileAsync3 = promisify3(execFile3);
+var windowsBrowserProgIds = {
+  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+  MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
+  // On macOS, it's "com.microsoft.edgemac"
+  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+  // Newer Edge/Win10 releases
+  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" },
+  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+  BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+  BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" }
+};
+var UnknownBrowserError = class extends Error {
+};
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const browser = windowsBrowserProgIds[id];
+  if (!browser) {
+    throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
+  }
+  return browser;
+}
+
+// node_modules/.pnpm/default-browser@5.2.1/node_modules/default-browser/index.js
+var execFileAsync4 = promisify4(execFile4);
+var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser2() {
+  if (process6.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process6.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process6.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+
+// node_modules/.pnpm/open@10.1.0/node_modules/open/index.js
+var __dirname = path5.dirname(fileURLToPath3(import.meta.url));
+var localXdgOpenPath = path5.join(__dirname, "xdg-open");
+var { platform, arch } = process7;
+var getWslDrivesMountPoint = /* @__PURE__ */ (() => {
+  const defaultMountPoint = "/mnt/";
+  let mountPoint;
+  return async function() {
+    if (mountPoint) {
+      return mountPoint;
+    }
+    const configFilePath = "/etc/wsl.conf";
+    let isConfigFileExists = false;
+    try {
+      await fs7.access(configFilePath, fsConstants.F_OK);
+      isConfigFileExists = true;
+    } catch {
+    }
+    if (!isConfigFileExists) {
+      return defaultMountPoint;
+    }
+    const configContent = await fs7.readFile(configFilePath, { encoding: "utf8" });
+    const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+    if (!configMountPoint) {
+      return defaultMountPoint;
+    }
+    mountPoint = configMountPoint.groups.mountPoint.trim();
+    mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+    return mountPoint;
+  };
+})();
+var pTryEach = async (array, mapper) => {
+  let latestError;
+  for (const item of array) {
+    try {
+      return await mapper(item);
+    } catch (error) {
+      latestError = error;
+    }
+  }
+  throw latestError;
+};
+var baseOpen = async (options) => {
+  options = {
+    wait: false,
+    background: false,
+    newInstance: false,
+    allowNonzeroExitCode: false,
+    ...options
+  };
+  if (Array.isArray(options.app)) {
+    return pTryEach(options.app, (singleApp) => baseOpen({
+      ...options,
+      app: singleApp
+    }));
+  }
+  let { name: app, arguments: appArguments = [] } = options.app ?? {};
+  appArguments = [...appArguments];
+  if (Array.isArray(app)) {
+    return pTryEach(app, (appName) => baseOpen({
+      ...options,
+      app: {
+        name: appName,
+        arguments: appArguments
+      }
+    }));
+  }
+  if (app === "browser" || app === "browserPrivate") {
+    const ids = {
+      "com.google.chrome": "chrome",
+      "google-chrome.desktop": "chrome",
+      "org.mozilla.firefox": "firefox",
+      "firefox.desktop": "firefox",
+      "com.microsoft.msedge": "edge",
+      "com.microsoft.edge": "edge",
+      "microsoft-edge.desktop": "edge"
+    };
+    const flags = {
+      chrome: "--incognito",
+      firefox: "--private-window",
+      edge: "--inPrivate"
+    };
+    const browser = await defaultBrowser2();
+    if (browser.id in ids) {
+      const browserName = ids[browser.id];
+      if (app === "browserPrivate") {
+        appArguments.push(flags[browserName]);
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name: apps[browserName],
+          arguments: appArguments
+        }
+      });
+    }
+    throw new Error(`${browser.name} is not supported as a default browser`);
+  }
+  let command;
+  const cliArguments = [];
+  const childProcessOptions = {};
+  if (platform === "darwin") {
+    command = "open";
+    if (options.wait) {
+      cliArguments.push("--wait-apps");
+    }
+    if (options.background) {
+      cliArguments.push("--background");
+    }
+    if (options.newInstance) {
+      cliArguments.push("--new");
+    }
+    if (app) {
+      cliArguments.push("-a", app);
+    }
+  } else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+    const mountPoint = await getWslDrivesMountPoint();
+    command = is_wsl_default ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process7.env.SYSTEMROOT || process7.env.windir || "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+    cliArguments.push(
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand"
+    );
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
+    }
+    const encodedArguments = ["Start"];
+    if (options.wait) {
+      encodedArguments.push("-Wait");
+    }
+    if (app) {
+      encodedArguments.push(`"\`"${app}\`""`);
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(`"${options.target}"`);
+    }
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    }
+    options.target = Buffer2.from(encodedArguments.join(" "), "utf16le").toString("base64");
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname || __dirname === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs7.access(localXdgOpenPath, fsConstants.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {
+      }
+      const useSystemXdgOpen = process7.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+    }
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
+    }
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
+    }
+  }
+  if (platform === "darwin" && appArguments.length > 0) {
+    cliArguments.push("--args", ...appArguments);
+  }
+  if (options.target) {
+    cliArguments.push(options.target);
+  }
+  const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+  if (options.wait) {
+    return new Promise((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("close", (exitCode) => {
+        if (!options.allowNonzeroExitCode && exitCode > 0) {
+          reject(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve(subprocess);
+      });
+    });
+  }
+  subprocess.unref();
+  return subprocess;
+};
+var open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+};
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var apps = {};
+defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+  darwin: "google chrome",
+  win32: "chrome",
+  linux: ["google-chrome", "google-chrome-stable", "chromium"]
+}, {
+  wsl: {
+    ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+    x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+  }
+}));
+defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+  darwin: "firefox",
+  win32: "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
+  linux: "firefox"
+}, {
+  wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+}));
+defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+  darwin: "microsoft edge",
+  win32: "msedge",
+  linux: ["microsoft-edge", "microsoft-edge-dev"]
+}, {
+  wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+}));
+defineLazyProperty(apps, "browser", () => "browser");
+defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+var open_default = open;
+
+// src/lib/tldraw-open.ts
+var tldrawOpenDefaultOptions = {
+  location: "remote"
+};
+async function tldrawOpen(tldrPathOrUrl, options) {
+  const tldrawRemoteUrl = "https://www.tldraw.com";
+  const { location } = { ...tldrawOpenDefaultOptions, ...options };
+  let urlToOpen;
+  const validatedPathOrUrl = tldrPathOrUrl === void 0 ? void 0 : validatePathOrUrl(tldrPathOrUrl, {
+    requireFileExistence: true,
+    validFileExtensions: [".tldr"],
+    validHostnames: ["www.tldraw.com"]
+  });
+  if (location === "local" && validatedPathOrUrl === void 0) {
+    const tldrawServer = new LocalTldrawServer();
+    await tldrawServer.start();
+    urlToOpen = tldrawServer.href;
+    log_default.info(`Opened blank tldraw sketch locally at "${urlToOpen}"`);
+  } else if (location === "local" && typeof validatedPathOrUrl === "string") {
+    const tldrData = await fs8.readFile(validatedPathOrUrl, "utf8");
+    const tldrawServer = new LocalTldrawServer(tldrData);
+    await tldrawServer.start();
+    urlToOpen = tldrawServer.href;
+    log_default.info(`Opened copy of tldraw sketch "${validatedPathOrUrl}" locally at "${urlToOpen}"`);
+  } else if (location === "local" && validatedPathOrUrl instanceof URL2) {
+    const [savedFile] = await tldrawToImage(validatedPathOrUrl.href, {
+      format: "tldr",
+      name: nanoid(),
+      output: os5.tmpdir()
+    });
+    const tldrData = await fs8.readFile(savedFile, "utf8");
+    await fs8.rm(savedFile, { force: true });
+    const tldrawServer = new LocalTldrawServer(tldrData);
+    await tldrawServer.start();
+    urlToOpen = tldrawServer.href;
+    log_default.info(
+      `Opened a local copy of tldraw sketch url "${validatedPathOrUrl.href}" locally at ${urlToOpen}`
+    );
+  } else if (location === "remote" && validatedPathOrUrl === void 0) {
+    urlToOpen = tldrawRemoteUrl;
+    log_default.info(`Opened tldraw.com`);
+  } else if (location === "remote" && typeof validatedPathOrUrl === "string") {
+    urlToOpen = await tldrawToShareUrl(validatedPathOrUrl);
+    log_default.info(
+      `Opened copy of local tldraw sketch "${validatedPathOrUrl}" remotely at "${urlToOpen}"`
+    );
+  } else if (location === "remote" && validatedPathOrUrl instanceof URL2) {
+    urlToOpen = validatedPathOrUrl.href;
+    log_default.info(`Opened tldraw sketch url at ${urlToOpen}`);
+  } else {
+    throw new Error("Invalid tldrawOpen options");
+  }
+  const exitPromise = open_default(urlToOpen, {
+    wait: true
+  });
+  return {
+    browserExitPromise: exitPromise,
+    openedSketchUrl: urlToOpen
+  };
+}
 export {
   log_default as log,
-  tldrawToImage
+  tldrawOpen,
+  tldrawToImage,
+  tldrawToShareUrl
 };

package/dist/lib/tldraw-open.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { type ChildProcess } from 'node:child_process';
+export type TldrawOpenOptions = {
+    location: 'local' | 'remote';
+};
+export type TldrawOpenResult = {
+    browserExitPromise: Promise<ChildProcess>;
+    openedSketchUrl: string;
+};
+export declare function tldrawOpen(tldrPathOrUrl?: string, options?: Partial<TldrawOpenOptions>): Promise<TldrawOpenResult>;

package/dist/lib/tldraw-to-share-url.d.ts

@@ -0,0 +1 @@
+export declare function tldrawToShareUrl(tldrPathOrUrl: string): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitschpatrol/tldraw-cli",
-  "version": "4.5.5",
+  "version": "4.6.1",
   "type": "module",
   "description": "A CLI tool for exporting tldraw sketch URLs and local .tldr files to SVG or PNG images.",
   "repository": {
@@ -100,8 +100,8 @@
     "preview": "pnpm run preview:tldraw",
     "preview:tldraw": "vite preview",
     "release": "pnpm bumpp --commit 'Release: %s' && pnpm build && pnpm publish --otp $(op read 'op://Personal/Npmjs/one-time password?attribute=otp')",
-    "test": "pnpm run test:lib",
-    "test:lib": "pnpm run build && vitest",
+    "test": "vitest --run",
+    "test:watch": "pnpm run build && vitest",
     "tldraw:copy-assets": "rsync -av --include='/*/' --exclude='/*' --exclude='favicon.ico' ./node_modules/@tldraw/assets/ ./src/tldraw/public/"
   }
 }

package/readme.md

@@ -88,10 +88,10 @@ Usage:
 tldraw <command>
 ```
 
-| Command  | Argument            | Description                                                                                                                                                                                                                                                                                                                                                                                                                |
-| -------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `export` | `<files-or-urls..>` | Export a local tldraw ".tldr" file or a tldraw\.com URL to an svg, png, json, or tldr file. Prints the absolute path(s) to the exported image(s) to stdout.                                                                                                                                                                                                                                                                |
-| `open`   | `[files-or-urls..]` | Open a tldraw `.tldr` file or tldraw\.com URL in your default browser with either the official tldraw\.com site or a locally-hosted instance of the editor. Call `open` without an argument to open a blank sketch. Sketches opened via URL with the `--local` flag will be temporarily copied to the local system, and will not be kept in sync with tldraw\.com. This process does not exit until the browser is closed. |
+| Command  | Argument            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| -------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `export` | `<files-or-urls..>` | Export a local tldraw ".tldr" file or a tldraw\.com URL to an svg, png, json, or tldr file. Prints the absolute path(s) to the exported image(s) to stdout.                                                                                                                                                                                                                                                                                                                                                                                  |
+| `open`   | `[files-or-urls..]` | Open a tldraw `.tldr` file or tldraw\.com URL in your default browser with either the official tldraw\.com site or a locally-hosted instance of the editor. Call `open` without an argument to open a blank sketch. Sketches opened via URL with the `--local` flag will be temporarily copied to the local system, and will not be kept in sync with tldraw\.com. This process does not exit until the browser is closed. Warning: Passing a local .tldr file without the `--local` option will upload and share the sketch on tldraw\.com. |
 
 | Option      | Alias | Description         | Type      |
 | ----------- | ----- | ------------------- | --------- |
@@ -133,7 +133,7 @@ tldraw export <files-or-urls..>
 
 #### Subcommand: `tldraw open`
 
-Open a tldraw `.tldr` file or tldraw\.com URL in your default browser with either the official tldraw\.com site or a locally-hosted instance of the editor. Call `open` without an argument to open a blank sketch. Sketches opened via URL with the `--local` flag will be temporarily copied to the local system, and will not be kept in sync with tldraw\.com. This process does not exit until the browser is closed.
+Open a tldraw `.tldr` file or tldraw\.com URL in your default browser with either the official tldraw\.com site or a locally-hosted instance of the editor. Call `open` without an argument to open a blank sketch. Sketches opened via URL with the `--local` flag will be temporarily copied to the local system, and will not be kept in sync with tldraw\.com. This process does not exit until the browser is closed. Warning: Passing a local .tldr file without the `--local` option will upload and share the sketch on tldraw\.com.
 
 Usage:
 
@@ -290,9 +290,15 @@ The remote sketch is copied to a locally-hosted instance of tldraw, which is the
 
 ### API
 
-The `export` command's functionality is also provided in module form for use in TypeScript or JavaScript Node projects.
+The `tldraw-cli` command line functionality is also provided in module form for programmatic use in TypeScript or JavaScript Node projects.
 
-The library exports a single async function, `tldrawToImage`, which takes an options argument mirroring the arguments available via the command line. The same default values apply:
+The library exports two async function, `tldrawToImage`, and `tldrawOpen`.
+
+#### `tldrawToImage`
+
+This mirrors the `tldraw export` CLI command.
+
+It takes an options argument mirroring the arguments available via the command line. The same default values apply:
 
 ```ts
  async function tldrawToImage(
@@ -367,7 +373,63 @@ log.verbose = false
 await tldrawToImage('https://www.tldraw.com/s/v2_c_JsxJk8dag6QsrqExukis4')
 ```
 
-_Note that the library provided is ESM-only, and requires a Node-compatible runtime. TypeScript type definitions are included._
+#### `tldrawOpen`
+
+Mirrors the `tldraw open` CLI command.
+
+> \[!CAUTION]
+> Passing a local .tldr file with the `location: 'remote'` option will upload and share your sketch on tldraw\.com.
+
+```tsx
+async function tldrawOpen(
+  tldrPathOrUrl?: string,
+  options?: Partial<{
+    location: 'local' | 'remote'
+  }>,
+): Promise<{
+  browserExitPromise: Promise<ChildProcess>
+  openedSketchUrl: string
+}>
+```
+
+It's important to note that the returned result includes `browserExitPromise`, which resolves when the user has completely exited the web browser used to open the tldr file or url.
+
+You _must_ await the `browserExitPromise` (or somehow keep script's process alive) if you're opening a tldr file with the \`location: 'local'\`. This prevents the local server from closing prematurely, which would interfere with any server-dependent actions in tldraw.
+
+Example of opening a local file:
+
+```ts
+import { tldrawOpen } from 'tldraw-cli'
+
+const { browserExitPromise } = await tldrawOpen('./sketch.tldr', {
+  location: 'local',
+})
+
+// Wait for the browser to close to keep
+// the local tldraw instance running!
+await browserExitPromise
+```
+
+While opening the file remotely on tldraw\.com is more casual:
+
+```ts
+import { tldrawOpen } from 'tldraw-cli'
+
+await tldrawOpen('./sketch.tldr', {
+  location: 'remote',
+})
+```
+
+#### `tldrawToShareUrl`
+
+```ts
+async function tldrawToShareUrl(tldrPathOrUrl: string): Promise<string>
+```
+
+Returns a live "share" url for a given local or remote tldraw sketch URL.
+
+> \[!CAUTION]
+> Passing a local .tldr file to this function will upload and share your local file to tldraw\.com.
 
 ## Background