arri 0.0.5 → 0.0.6

package/dist/chunks/browser.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+/* eslint-env browser */
+
+const clipboard = {};
+
+clipboard.write = async text => {
+	await navigator.clipboard.writeText(text);
+};
+
+clipboard.read = async () => navigator.clipboard.readText();
+
+clipboard.readSync = () => {
+	throw new Error('`.readSync()` is not supported in browsers!');
+};
+
+clipboard.writeSync = () => {
+	throw new Error('`.writeSync()` is not supported in browsers!');
+};
+
+exports.default = clipboard;

package/dist/chunks/browser.mjs

@@ -0,0 +1,19 @@
+/* eslint-env browser */
+
+const clipboard = {};
+
+clipboard.write = async text => {
+	await navigator.clipboard.writeText(text);
+};
+
+clipboard.read = async () => navigator.clipboard.readText();
+
+clipboard.readSync = () => {
+	throw new Error('`.readSync()` is not supported in browsers!');
+};
+
+clipboard.writeSync = () => {
+	throw new Error('`.writeSync()` is not supported in browsers!');
+};
+
+export { clipboard as default };

package/dist/chunks/index.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('node:fs');
+const cli = require('../cli.cjs');
+require('node:tty');
+require('node:path');
+require('stream');
+require('../shared/arri.d77f4d0e.cjs');
+require('os');
+require('path');
+require('util');
+require('events');
+require('fs');
+require('node:process');
+require('node:url');
+require('node:stream');
+require('crypto');
+require('node:fs/promises');
+require('node:os');
+require('module');
+require('perf_hooks');
+require('vm');
+require('url');
+require('assert');
+require('process');
+require('v8');
+require('tty');
+require('node:module');
+require('node:assert');
+require('node:v8');
+require('node:util');
+require('../shared/arri.38ad6cd0.cjs');
+require('fs/promises');
+require('node:http');
+require('node:https');
+require('node:net');
+require('http');
+require('https');
+require('node:child_process');
+
+async function startTunnel(opts) {
+  const {
+    installCloudflared,
+    startCloudflaredTunnel,
+    cloudflaredBinPath,
+    cloudflaredNotice
+  } = await import('./index2.cjs');
+  const url = opts.url || `${opts.protocol || "http"}://${opts.hostname ?? "localhost"}:${opts.port ?? 3e3}`;
+  cli.consola.start(`Starting cloudflared tunnel to ${url}`);
+  if (!fs.existsSync(cloudflaredBinPath)) {
+    cli.consola.log(cloudflaredNotice);
+    const canInstall = await cli.consola.prompt(
+      `Do you agree with the above terms and wish to install the binary from GitHub?`,
+      {
+        type: "confirm"
+      }
+    );
+    if (!canInstall) {
+      cli.consola.fail("Skipping tunnel setup.");
+      return;
+    }
+    await installCloudflared();
+  }
+  const args = [
+    ["--url", url],
+    opts.verifyTLS ? void 0 : ["--no-tls-verify", ""]
+  ].filter(Boolean);
+  const tunnel = await startCloudflaredTunnel(Object.fromEntries(args));
+  const cleanup = async () => {
+    await tunnel.stop();
+  };
+  for (const signal of ["SIGINT", "SIGUSR1", "SIGUSR2"]) {
+    process.once(signal, cleanup);
+  }
+  return {
+    getURL: async () => await tunnel.url,
+    close: async () => {
+      await cleanup();
+    }
+  };
+}
+
+exports.startTunnel = startTunnel;

package/dist/chunks/index.mjs

@@ -0,0 +1,81 @@
+import { existsSync } from 'node:fs';
+import { c as consola } from '../cli.mjs';
+import 'node:tty';
+import 'node:path';
+import 'stream';
+import '../shared/arri.b4c5ce27.mjs';
+import 'os';
+import 'path';
+import 'util';
+import 'events';
+import 'fs';
+import 'node:process';
+import 'node:url';
+import 'node:stream';
+import 'crypto';
+import 'node:fs/promises';
+import 'node:os';
+import 'module';
+import 'perf_hooks';
+import 'vm';
+import 'url';
+import 'assert';
+import 'process';
+import 'v8';
+import 'tty';
+import 'node:module';
+import 'node:assert';
+import 'node:v8';
+import 'node:util';
+import '../shared/arri.34695f7b.mjs';
+import 'fs/promises';
+import 'node:http';
+import 'node:https';
+import 'node:net';
+import 'http';
+import 'https';
+import 'node:child_process';
+
+async function startTunnel(opts) {
+  const {
+    installCloudflared,
+    startCloudflaredTunnel,
+    cloudflaredBinPath,
+    cloudflaredNotice
+  } = await import('./index2.mjs');
+  const url = opts.url || `${opts.protocol || "http"}://${opts.hostname ?? "localhost"}:${opts.port ?? 3e3}`;
+  consola.start(`Starting cloudflared tunnel to ${url}`);
+  if (!existsSync(cloudflaredBinPath)) {
+    consola.log(cloudflaredNotice);
+    const canInstall = await consola.prompt(
+      `Do you agree with the above terms and wish to install the binary from GitHub?`,
+      {
+        type: "confirm"
+      }
+    );
+    if (!canInstall) {
+      consola.fail("Skipping tunnel setup.");
+      return;
+    }
+    await installCloudflared();
+  }
+  const args = [
+    ["--url", url],
+    opts.verifyTLS ? void 0 : ["--no-tls-verify", ""]
+  ].filter(Boolean);
+  const tunnel = await startCloudflaredTunnel(Object.fromEntries(args));
+  const cleanup = async () => {
+    await tunnel.stop();
+  };
+  for (const signal of ["SIGINT", "SIGUSR1", "SIGUSR2"]) {
+    process.once(signal, cleanup);
+  }
+  return {
+    getURL: async () => await tunnel.url,
+    close: async () => {
+      await cleanup();
+    }
+  };
+}
+
+export { startTunnel };

package/dist/chunks/index2.cjs

@@ -0,0 +1,230 @@
+'use strict';
+
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const https = require('node:https');
+const childProcess = require('node:child_process');
+const cli = require('../cli.cjs');
+require('node:tty');
+require('stream');
+require('../shared/arri.d77f4d0e.cjs');
+require('os');
+require('path');
+require('util');
+require('events');
+require('fs');
+require('node:process');
+require('node:url');
+require('node:stream');
+require('crypto');
+require('node:fs/promises');
+require('module');
+require('perf_hooks');
+require('vm');
+require('url');
+require('assert');
+require('process');
+require('v8');
+require('tty');
+require('node:module');
+require('node:assert');
+require('node:v8');
+require('node:util');
+require('../shared/arri.38ad6cd0.cjs');
+require('fs/promises');
+require('node:http');
+require('node:net');
+require('http');
+require('https');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const https__default = /*#__PURE__*/_interopDefaultCompat(https);
+
+const CLOUDFLARED_VERSION = process.env.CLOUDFLARED_VERSION || "2023.7.3";
+const RELEASE_BASE = "https://github.com/cloudflare/cloudflared/releases/";
+const cloudflaredBinPath = cli.path.join(
+  os.tmpdir(),
+  "node-untun",
+  process.platform === "win32" ? `cloudflared.${CLOUDFLARED_VERSION}.exe` : `cloudflared.${CLOUDFLARED_VERSION}`
+);
+const cloudflaredNotice = `
+\u{1F525} Your installation of cloudflared software constitutes a symbol of your signature
+   indicating that you accept the terms of the Cloudflare License, Terms and Privacy Policy.
+
+\u276F License:         \`https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/license/\`
+\u276F Terms:           \`https://www.cloudflare.com/terms/\`
+\u276F Privacy Policy:  \`https://www.cloudflare.com/privacypolicy/\`
+`;
+const connRegex = /connection[ =]([\da-z-]+)/i;
+const ipRegex = /ip=([\d.]+)/;
+const locationRegex = /location=([A-Z]+)/;
+const indexRegex = /connIndex=(\d)/;
+
+const LINUX_URL = {
+  arm64: "cloudflared-linux-arm64",
+  arm: "cloudflared-linux-arm",
+  x64: "cloudflared-linux-amd64",
+  ia32: "cloudflared-linux-386"
+};
+const MACOS_URL = {
+  arm64: "cloudflared-darwin-amd64.tgz",
+  x64: "cloudflared-darwin-amd64.tgz"
+};
+const WINDOWS_URL = {
+  x64: "cloudflared-windows-amd64.exe",
+  ia32: "cloudflared-windows-386.exe"
+};
+function resolveBase(version) {
+  if (version === "latest") {
+    return `${RELEASE_BASE}latest/download/`;
+  }
+  return `${RELEASE_BASE}download/${version}/`;
+}
+function installCloudflared(to = cloudflaredBinPath, version = CLOUDFLARED_VERSION) {
+  switch (process.platform) {
+    case "linux": {
+      return installLinux(to, version);
+    }
+    case "darwin": {
+      return installMacos(to, version);
+    }
+    case "win32": {
+      return installWindows(to, version);
+    }
+    default: {
+      throw new Error("Unsupported platform: " + process.platform);
+    }
+  }
+}
+async function installLinux(to, version = CLOUDFLARED_VERSION) {
+  const file = LINUX_URL[process.arch];
+  if (file === void 0) {
+    throw new Error("Unsupported architecture: " + process.arch);
+  }
+  await download(resolveBase(version) + file, to);
+  fs__default.chmodSync(to, "755");
+  return to;
+}
+async function installMacos(to, version = CLOUDFLARED_VERSION) {
+  const file = MACOS_URL[process.arch];
+  if (file === void 0) {
+    throw new Error("Unsupported architecture: " + process.arch);
+  }
+  await download(resolveBase(version) + file, `${to}.tgz`);
+  process.env.DEBUG && console.log(`Extracting to ${to}`);
+  childProcess.execSync(`tar -xzf ${path__default.basename(`${to}.tgz`)}`, { cwd: path__default.dirname(to) });
+  fs__default.unlinkSync(`${to}.tgz`);
+  fs__default.renameSync(`${path__default.dirname(to)}/cloudflared`, to);
+  return to;
+}
+async function installWindows(to, version = CLOUDFLARED_VERSION) {
+  const file = WINDOWS_URL[process.arch];
+  if (file === void 0) {
+    throw new Error("Unsupported architecture: " + process.arch);
+  }
+  await download(resolveBase(version) + file, to);
+  return to;
+}
+function download(url, to, redirect = 0) {
+  if (redirect === 0) {
+    process.env.DEBUG && console.log(`Downloading ${url} to ${to}`);
+  } else {
+    process.env.DEBUG && console.log(`Redirecting to ${url}`);
+  }
+  return new Promise((resolve, reject) => {
+    if (!fs__default.existsSync(path__default.dirname(to))) {
+      fs__default.mkdirSync(path__default.dirname(to), { recursive: true });
+    }
+    let done = true;
+    const file = fs__default.createWriteStream(to);
+    const request = https__default.get(url, (res) => {
+      if (res.statusCode === 302 && res.headers.location !== void 0) {
+        const redirection = res.headers.location;
+        done = false;
+        file.close(() => resolve(download(redirection, to, redirect + 1)));
+        return;
+      }
+      res.pipe(file);
+    });
+    file.on("finish", () => {
+      if (done) {
+        file.close(() => resolve(to));
+      }
+    });
+    request.on("error", (err) => {
+      fs__default.unlink(to, () => reject(err));
+    });
+    file.on("error", (err) => {
+      fs__default.unlink(to, () => reject(err));
+    });
+    request.end();
+  });
+}
+
+function startCloudflaredTunnel(options = {}) {
+  const args = ["tunnel"];
+  for (const [key, value] of Object.entries(options)) {
+    if (typeof value === "string") {
+      args.push(`${key}`, value);
+    } else if (typeof value === "number") {
+      args.push(`${key}`, value.toString());
+    } else if (value === null) {
+      args.push(`${key}`);
+    }
+  }
+  if (args.length === 1) {
+    args.push("--url", "localhost:8080");
+  }
+  const child = childProcess.spawn(cloudflaredBinPath, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (process.env.DEBUG) {
+    child.stdout.pipe(process.stdout);
+    child.stderr.pipe(process.stderr);
+  }
+  const urlRegex = /\|\s+(https?:\/\/\S+)/;
+  let urlResolver = () => void 0;
+  let urlRejector = () => void 0;
+  const url = new Promise(
+    (...pair) => [urlResolver, urlRejector] = pair
+  );
+  const connectionResolvers = [];
+  const connectionRejectors = [];
+  const connections = [];
+  for (let i = 0; i < 1; i++) {
+    connections.push(
+      new Promise(
+        (...pair) => [connectionResolvers[i], connectionRejectors[i]] = pair
+      )
+    );
+  }
+  const parser = (data) => {
+    const str = data.toString();
+    const urlMatch = str.match(urlRegex);
+    urlMatch && urlResolver(urlMatch[1]);
+    const connMatch = str.match(connRegex);
+    const ipMatch = str.match(ipRegex);
+    const locationMatch = str.match(locationRegex);
+    const indexMatch = str.match(indexRegex);
+    if (connMatch && ipMatch && locationMatch && indexMatch) {
+      const [, id] = connMatch;
+      const [, ip] = ipMatch;
+      const [, location] = locationMatch;
+      const [, idx] = indexMatch;
+      connectionResolvers[+idx]?.({ id, ip, location });
+    }
+  };
+  child.stdout.on("data", parser).on("error", urlRejector);
+  child.stderr.on("data", parser).on("error", urlRejector);
+  const stop = () => child.kill("SIGINT");
+  return { url, connections, child, stop };
+}
+
+exports.cloudflaredBinPath = cloudflaredBinPath;
+exports.cloudflaredNotice = cloudflaredNotice;
+exports.installCloudflared = installCloudflared;
+exports.startCloudflaredTunnel = startCloudflaredTunnel;

package/dist/chunks/index2.mjs

@@ -0,0 +1,219 @@
+import { tmpdir } from 'node:os';
+import fs from 'node:fs';
+import path$1 from 'node:path';
+import https from 'node:https';
+import { execSync, spawn } from 'node:child_process';
+import { p as path } from '../cli.mjs';
+import 'node:tty';
+import 'stream';
+import '../shared/arri.b4c5ce27.mjs';
+import 'os';
+import 'path';
+import 'util';
+import 'events';
+import 'fs';
+import 'node:process';
+import 'node:url';
+import 'node:stream';
+import 'crypto';
+import 'node:fs/promises';
+import 'module';
+import 'perf_hooks';
+import 'vm';
+import 'url';
+import 'assert';
+import 'process';
+import 'v8';
+import 'tty';
+import 'node:module';
+import 'node:assert';
+import 'node:v8';
+import 'node:util';
+import '../shared/arri.34695f7b.mjs';
+import 'fs/promises';
+import 'node:http';
+import 'node:net';
+import 'http';
+import 'https';
+
+const CLOUDFLARED_VERSION = process.env.CLOUDFLARED_VERSION || "2023.7.3";
+const RELEASE_BASE = "https://github.com/cloudflare/cloudflared/releases/";
+const cloudflaredBinPath = path.join(
+  tmpdir(),
+  "node-untun",
+  process.platform === "win32" ? `cloudflared.${CLOUDFLARED_VERSION}.exe` : `cloudflared.${CLOUDFLARED_VERSION}`
+);
+const cloudflaredNotice = `
+\u{1F525} Your installation of cloudflared software constitutes a symbol of your signature
+   indicating that you accept the terms of the Cloudflare License, Terms and Privacy Policy.
+
+\u276F License:         \`https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/license/\`
+\u276F Terms:           \`https://www.cloudflare.com/terms/\`
+\u276F Privacy Policy:  \`https://www.cloudflare.com/privacypolicy/\`
+`;
+const connRegex = /connection[ =]([\da-z-]+)/i;
+const ipRegex = /ip=([\d.]+)/;
+const locationRegex = /location=([A-Z]+)/;
+const indexRegex = /connIndex=(\d)/;
+
+const LINUX_URL = {
+  arm64: "cloudflared-linux-arm64",
+  arm: "cloudflared-linux-arm",
+  x64: "cloudflared-linux-amd64",
+  ia32: "cloudflared-linux-386"
+};
+const MACOS_URL = {
+  arm64: "cloudflared-darwin-amd64.tgz",
+  x64: "cloudflared-darwin-amd64.tgz"
+};
+const WINDOWS_URL = {
+  x64: "cloudflared-windows-amd64.exe",
+  ia32: "cloudflared-windows-386.exe"
+};
+function resolveBase(version) {
+  if (version === "latest") {
+    return `${RELEASE_BASE}latest/download/`;
+  }
+  return `${RELEASE_BASE}download/${version}/`;
+}
+function installCloudflared(to = cloudflaredBinPath, version = CLOUDFLARED_VERSION) {
+  switch (process.platform) {
+    case "linux": {
+      return installLinux(to, version);
+    }
+    case "darwin": {
+      return installMacos(to, version);
+    }
+    case "win32": {
+      return installWindows(to, version);
+    }
+    default: {
+      throw new Error("Unsupported platform: " + process.platform);
+    }
+  }
+}
+async function installLinux(to, version = CLOUDFLARED_VERSION) {
+  const file = LINUX_URL[process.arch];
+  if (file === void 0) {
+    throw new Error("Unsupported architecture: " + process.arch);
+  }
+  await download(resolveBase(version) + file, to);
+  fs.chmodSync(to, "755");
+  return to;
+}
+async function installMacos(to, version = CLOUDFLARED_VERSION) {
+  const file = MACOS_URL[process.arch];
+  if (file === void 0) {
+    throw new Error("Unsupported architecture: " + process.arch);
+  }
+  await download(resolveBase(version) + file, `${to}.tgz`);
+  process.env.DEBUG && console.log(`Extracting to ${to}`);
+  execSync(`tar -xzf ${path$1.basename(`${to}.tgz`)}`, { cwd: path$1.dirname(to) });
+  fs.unlinkSync(`${to}.tgz`);
+  fs.renameSync(`${path$1.dirname(to)}/cloudflared`, to);
+  return to;
+}
+async function installWindows(to, version = CLOUDFLARED_VERSION) {
+  const file = WINDOWS_URL[process.arch];
+  if (file === void 0) {
+    throw new Error("Unsupported architecture: " + process.arch);
+  }
+  await download(resolveBase(version) + file, to);
+  return to;
+}
+function download(url, to, redirect = 0) {
+  if (redirect === 0) {
+    process.env.DEBUG && console.log(`Downloading ${url} to ${to}`);
+  } else {
+    process.env.DEBUG && console.log(`Redirecting to ${url}`);
+  }
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(path$1.dirname(to))) {
+      fs.mkdirSync(path$1.dirname(to), { recursive: true });
+    }
+    let done = true;
+    const file = fs.createWriteStream(to);
+    const request = https.get(url, (res) => {
+      if (res.statusCode === 302 && res.headers.location !== void 0) {
+        const redirection = res.headers.location;
+        done = false;
+        file.close(() => resolve(download(redirection, to, redirect + 1)));
+        return;
+      }
+      res.pipe(file);
+    });
+    file.on("finish", () => {
+      if (done) {
+        file.close(() => resolve(to));
+      }
+    });
+    request.on("error", (err) => {
+      fs.unlink(to, () => reject(err));
+    });
+    file.on("error", (err) => {
+      fs.unlink(to, () => reject(err));
+    });
+    request.end();
+  });
+}
+
+function startCloudflaredTunnel(options = {}) {
+  const args = ["tunnel"];
+  for (const [key, value] of Object.entries(options)) {
+    if (typeof value === "string") {
+      args.push(`${key}`, value);
+    } else if (typeof value === "number") {
+      args.push(`${key}`, value.toString());
+    } else if (value === null) {
+      args.push(`${key}`);
+    }
+  }
+  if (args.length === 1) {
+    args.push("--url", "localhost:8080");
+  }
+  const child = spawn(cloudflaredBinPath, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (process.env.DEBUG) {
+    child.stdout.pipe(process.stdout);
+    child.stderr.pipe(process.stderr);
+  }
+  const urlRegex = /\|\s+(https?:\/\/\S+)/;
+  let urlResolver = () => void 0;
+  let urlRejector = () => void 0;
+  const url = new Promise(
+    (...pair) => [urlResolver, urlRejector] = pair
+  );
+  const connectionResolvers = [];
+  const connectionRejectors = [];
+  const connections = [];
+  for (let i = 0; i < 1; i++) {
+    connections.push(
+      new Promise(
+        (...pair) => [connectionResolvers[i], connectionRejectors[i]] = pair
+      )
+    );
+  }
+  const parser = (data) => {
+    const str = data.toString();
+    const urlMatch = str.match(urlRegex);
+    urlMatch && urlResolver(urlMatch[1]);
+    const connMatch = str.match(connRegex);
+    const ipMatch = str.match(ipRegex);
+    const locationMatch = str.match(locationRegex);
+    const indexMatch = str.match(indexRegex);
+    if (connMatch && ipMatch && locationMatch && indexMatch) {
+      const [, id] = connMatch;
+      const [, ip] = ipMatch;
+      const [, location] = locationMatch;
+      const [, idx] = indexMatch;
+      connectionResolvers[+idx]?.({ id, ip, location });
+    }
+  };
+  child.stdout.on("data", parser).on("error", urlRejector);
+  child.stderr.on("data", parser).on("error", urlRejector);
+  const stop = () => child.kill("SIGINT");
+  return { url, connections, child, stop };
+}
+
+export { cloudflaredBinPath, cloudflaredNotice, installCloudflared, startCloudflaredTunnel };