@takodotid/circuit 0.19.0 → 0.21.0

package/dist/chunks/{index-dczpxzzm.js → index-v8zgr7wm.js}

@@ -1,11 +1,11 @@
 // src/core/addr.ts
-var familyOf = (address) => address.includes(":") ? "ipv6" : "ipv4";
+var familyOf2 = (address) => address.includes(":") ? "ipv6" : "ipv4";
 var bitsOf = (family) => family === "ipv4" ? 32 : 128;
 function parse(address) {
   if (!address.includes(":")) {
     const octets = address.split(".");
-    const valid2 = octets.length === 4 && octets.every((octet) => /^\d{1,3}$/.test(octet) && Number(octet) <= 255);
-    if (!valid2)
+    const valid = octets.length === 4 && octets.every((octet) => /^\d{1,3}$/.test(octet) && Number(octet) <= 255);
+    if (!valid)
       return null;
     return octets.reduce((value, octet) => value << 8n | BigInt(octet), 0n);
   }
@@ -24,15 +24,15 @@ function parse(address) {
 }
 function split(cidr) {
   const [address, lengthText] = cidr.split("/");
-  const family = familyOf(address);
+  const family = familyOf2(address);
   const length = Number(lengthText);
   const valid = parse(address) !== null && lengthText !== undefined && Number.isInteger(length) && length >= 0 && length <= bitsOf(family);
   if (!valid)
     throw new Error(`'${cidr}' is not an address with a length`);
   return { addr: address, len: length, family };
 }
-var isAddress = (text) => parse(text) !== null;
-function isCidr(text) {
+var isAddress2 = (text) => parse(text) !== null;
+function isCidr2(text) {
   try {
     split(text);
     return true;
@@ -73,10 +73,10 @@ function network(cidr) {
   const { addr, len, family } = split(cidr);
   return `${format(parse(addr) & mask(len, family), family)}/${len}`;
 }
-function contains(outer, inner) {
+function contains2(outer, inner) {
   const outerParts = split(outer);
   const [innerAddress, innerLengthText] = inner.split("/");
-  if (familyOf(innerAddress) !== outerParts.family)
+  if (familyOf2(innerAddress) !== outerParts.family)
     return false;
   const innerLength = innerLengthText === undefined ? bitsOf(outerParts.family) : Number(innerLengthText);
   if (innerLength < outerParts.len)
@@ -84,9 +84,28 @@ function contains(outer, inner) {
   const outerMask = mask(outerParts.len, outerParts.family);
   return (parse(innerAddress) & outerMask) === (parse(outerParts.addr) & outerMask);
 }
+var formatAddress = (value, family) => format(value, family);
+function rangeOf(cidr) {
+  const { addr, len, family } = split(cidr);
+  const hostBits = mask(len, family) ^ (1n << BigInt(bitsOf(family))) - 1n;
+  const first = parse(addr) & mask(len, family);
+  return { first, last: first | hostBits, family };
+}
+function prefixesBetween(first, last, family) {
+  const bits = bitsOf(family);
+  const prefixes = [];
+  for (let start = first;start <= last; ) {
+    let size = 0;
+    while (size < bits && start % (1n << BigInt(size + 1)) === 0n && start + (1n << BigInt(size + 1)) - 1n <= last)
+      size++;
+    prefixes.push(`${format(start, family)}/${bits - size}`);
+    start += 1n << BigInt(size);
+  }
+  return prefixes;
+}
 var netmask = (length) => format(mask(length, "ipv4"), "ipv4");
 var wildcard = (length) => format(mask(length, "ipv4") ^ 0xffffffffn, "ipv4");
-var host = (cidr) => cidr.split("/")[0];
+var host2 = (cidr) => cidr.split("/")[0];
 var NOT_GLOBAL_V4 = [
   "0.0.0.0/8",
   "10.0.0.0/8",
@@ -100,10 +119,10 @@ var NOT_GLOBAL_V4 = [
   "198.51.100.0/24",
   "203.0.113.0/24"
 ];
-function isGlobal(address) {
-  if (familyOf(address) === "ipv6")
-    return contains("2000::/3", address) && !contains("2001:db8::/32", address);
-  return !NOT_GLOBAL_V4.some((prefix) => contains(prefix, address));
+function isGlobal2(address) {
+  if (familyOf2(address) === "ipv6")
+    return contains2("2000::/3", address) && !contains2("2001:db8::/32", address);
+  return !NOT_GLOBAL_V4.some((prefix) => contains2(prefix, address));
 }
 
-export { familyOf, parse, split, isAddress, isCidr, network, contains, netmask, wildcard, host, isGlobal };
+export { familyOf2, parse, split, isAddress2, isCidr2, network, contains2, formatAddress, rangeOf, prefixesBetween, netmask, wildcard, host2, isGlobal2 };

package/dist/chunks/{new-7n8qvtjd.js → new-ny89s7y7.js}

@@ -1,5 +1,3 @@
-import"./index-fq57hya4.js";
-
 // src/cli/new.ts
 import { spawnSync } from "node:child_process";
 import { cpSync, existsSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -87,7 +85,7 @@ async function create(args) {
     if (terminal) {
       console.log(`
 Which is closest to your network?`);
-      names.forEach((name2, index) => console.log(`  ${index + 1}. ${PATTERNS[name2].title}: ${PATTERNS[name2].fits}`));
+      names.forEach((name, index) => console.log(`  ${index + 1}. ${PATTERNS[name].title}: ${PATTERNS[name].fits}`));
     }
     pattern = names[Number(await ask("Number", "1")) - 1];
   }
@@ -120,14 +118,14 @@ Which is closest to your network?`);
     let text = readFileSync(path, "utf8");
     if (asn && asn !== EXAMPLE_ASN)
       text = text.replaceAll(new RegExp(`\\b${EXAMPLE_ASN}\\b`, "g"), asn);
-    for (const [, name2] of text.matchAll(/secret\("([A-Z0-9_]+)"\)/g))
-      secrets.add(name2);
+    for (const [, name] of text.matchAll(/secret\("([A-Z0-9_]+)"\)/g))
+      secrets.add(name);
     writeFileSync(path, text);
   }
   const env = [
     "# Secrets for Circuit. Never commit this file.",
     "# A value is the secret itself, or a 1Password reference, op://vault/item/field, read with the 1Password CLI.",
-    ...[...secrets].sort().map((name2) => onePassword ? `${name2}=op://Network/${name2}/password` : `${name2}=`),
+    ...[...secrets].sort().map((name) => onePassword ? `${name}=op://Network/${name}/password` : `${name}=`),
     ""
   ];
   writeFileSync(join(target, ".env"), env.join(`

package/dist/chunks/server-zapfzhv4.js

@@ -0,0 +1,244 @@
+import {
+  packageRoot
+} from "./index-n4zpd25n.js";
+
+// src/studio/server.ts
+import { execFile as execFile2, spawn } from "node:child_process";
+import { existsSync, readFileSync, watch } from "node:fs";
+import { createServer } from "node:http";
+import { extname, join as join2 } from "node:path";
+
+// src/studio/git.ts
+import { execFile } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+var environment = () => Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("GIT_")));
+function git(cwd, args) {
+  return new Promise((done, fail) => {
+    execFile("git", args, { cwd, env: environment(), maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error)
+        fail(new Error((stderr || error.message).trim()));
+      else
+        done(stdout);
+    });
+  });
+}
+var FORMAT = "--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s";
+function commitsOf(text) {
+  return text.split(`
+`).filter(Boolean).map((line) => {
+    const [commit = "", short = "", author = "", date = "", subject = ""] = line.split("\x1F");
+    return { commit, short, author, date, subject };
+  });
+}
+async function gitTop(directory) {
+  try {
+    return (await git(directory, ["rev-parse", "--show-toplevel"])).trim();
+  } catch {
+    return;
+  }
+}
+async function history(directory, files, limit = 50) {
+  if (!files.length)
+    return [];
+  return commitsOf(await git(directory, ["log", `-n${limit}`, FORMAT, "--", ...files]));
+}
+async function references(directory) {
+  const names = (await git(directory, [
+    "for-each-ref",
+    "--count=100",
+    "--sort=-committerdate",
+    "--format=%(refname:short)",
+    "refs/heads",
+    "refs/remotes",
+    "refs/tags"
+  ])).split(`
+`).filter((name) => name && !name.endsWith("/HEAD"));
+  return { names, commits: commitsOf(await git(directory, ["log", "-n30", FORMAT])) };
+}
+async function commitOf(directory, name) {
+  if (!/^[A-Za-z0-9][\w./@^~-]*$/.test(name))
+    return;
+  try {
+    const [commit] = commitsOf(await git(directory, ["log", "-n1", FORMAT, `${name}^{commit}`, "--"]));
+    return commit;
+  } catch {
+    return;
+  }
+}
+async function networkAt(configDirectory, configPath, commit, gather) {
+  const top = await gitTop(configDirectory);
+  if (!top)
+    throw new Error("the config is not in a git repository");
+  const cache = join(configDirectory, ".circuit", "cache");
+  mkdirSync(cache, { recursive: true });
+  writeFileSync(join(cache, ".gitignore"), `# Written by Circuit Studio: checkouts of other commits, removed once read.
+*
+`);
+  await git(top, ["worktree", "prune"]);
+  const checkout = join(cache, commit.slice(0, 12));
+  await git(top, ["worktree", "add", "--detach", "--force", checkout, commit]);
+  try {
+    const prefix = (await git(configDirectory, ["rev-parse", "--show-prefix"])).trim();
+    return await gather(join(checkout, prefix, basename(configPath)));
+  } finally {
+    await git(top, ["worktree", "remove", "--force", checkout]).catch(() => {});
+  }
+}
+
+// src/studio/server.ts
+var isLoopback = (host) => host === "localhost" || host === "::1" || /^127\.\d+\.\d+\.\d+$/.test(host);
+function hostAllowed(header, port, allowHosts) {
+  if (!header)
+    return false;
+  if (header === `127.0.0.1:${port}` || header === `localhost:${port}` || header === `[::1]:${port}`)
+    return true;
+  const name = header.replace(/:\d+$/, "").toLowerCase();
+  return allowHosts.some((allowed) => {
+    const wanted = allowed.toLowerCase();
+    return wanted === header.toLowerCase() || wanted === name;
+  });
+}
+var IGNORED = /(^|[\\/])(node_modules|\.git|\.circuit[\\/]cache)([\\/]|$)/;
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2"
+};
+function gather(configPath) {
+  const cli = process.argv[1];
+  const args = [...process.execArgv, cli, "studio", "--json", `--config=${configPath}`];
+  return new Promise((done) => {
+    execFile2(process.execPath, args, { maxBuffer: 256 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (!error)
+        return done(stdout);
+      const message = (stderr || error.message).trim();
+      done(JSON.stringify({ error: message }));
+    });
+  });
+}
+function openBrowser(url) {
+  const [command, args] = process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : process.platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
+  const child = spawn(command, args, { stdio: "ignore", detached: true });
+  child.on("error", () => {});
+  child.unref();
+}
+async function studio(options) {
+  const { configPath, root, port } = options;
+  const installed = packageRoot();
+  if (!installed)
+    throw new Error("cannot find where Circuit is installed, so Studio has no page to serve");
+  const pages = join2(installed, "src", "studio", "public");
+  let data = await gather(configPath);
+  const past = new Map;
+  const answer = async (response, work) => {
+    let body;
+    try {
+      const result = await work();
+      body = typeof result === "string" ? result : JSON.stringify(result);
+    } catch (error) {
+      body = JSON.stringify({ error: error.message });
+    }
+    response.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" }).end(body);
+  };
+  const listeners = new Set;
+  const tell = (message) => {
+    for (const listener of listeners)
+      listener.write(`data: ${message}
+
+`);
+  };
+  const server = createServer((request, response) => {
+    if (!hostAllowed(request.headers.host, port, options.allowHosts)) {
+      response.writeHead(403).end();
+      return;
+    }
+    const url = new URL(request.url ?? "/", "http://studio");
+    const path = url.pathname;
+    if (path === "/history") {
+      answer(response, async () => {
+        const name = url.searchParams.get("device") ?? "";
+        const files = JSON.parse(data).files?.[name];
+        if (!files)
+          throw new Error(`no device ${name}`);
+        return history(root, [files.source, files.snapshot].filter((file) => Boolean(file)));
+      });
+      return;
+    }
+    if (path === "/refs") {
+      answer(response, () => references(root));
+      return;
+    }
+    if (path === "/compare") {
+      answer(response, async () => {
+        const asked = url.searchParams.get("ref") ?? "";
+        const commit = await commitOf(root, asked);
+        if (!commit)
+          throw new Error(`${asked} names no commit here`);
+        if (!past.has(commit.commit))
+          past.set(commit.commit, networkAt(root, configPath, commit.commit, gather));
+        const network = await past.get(commit.commit);
+        if (network.startsWith('{"error"'))
+          past.delete(commit.commit);
+        return `{"commit":${JSON.stringify(commit)},"network":${network}}`;
+      });
+      return;
+    }
+    if (path === "/data") {
+      response.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" }).end(data);
+      return;
+    }
+    if (path === "/events") {
+      response.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-store",
+        connection: "keep-alive",
+        "x-accel-buffering": "no"
+      });
+      response.write(`: connected
+
+`);
+      listeners.add(response);
+      request.on("close", () => listeners.delete(response));
+      return;
+    }
+    const name = path === "/" ? "index.html" : path.slice(1);
+    const type = CONTENT_TYPES[extname(name)];
+    const file = join2(pages, name);
+    if (!/^[a-z-]+\.[a-z0-9]+$/.test(name) || !type || !existsSync(file)) {
+      response.writeHead(404).end();
+      return;
+    }
+    response.writeHead(200, { "content-type": type, "cache-control": "no-store" }).end(readFileSync(file));
+  });
+  let timer;
+  watch(root, { recursive: true }, (_event, filename) => {
+    if (filename && IGNORED.test(filename))
+      return;
+    clearTimeout(timer);
+    timer = setTimeout(async () => {
+      data = await gather(configPath);
+      tell("changed");
+      console.log(`${new Date().toLocaleTimeString()}  ${filename ?? "a file"} changed, read again`);
+    }, 300);
+  });
+  watch(pages, () => tell("page"));
+  server.on("error", (error) => {
+    const message = error.code === "EADDRINUSE" ? `port ${port} is in use; choose another with --port=N` : error.message;
+    console.error(message);
+    process.exit(1);
+  });
+  server.listen(port, options.host, () => {
+    const local = isLoopback(options.host);
+    const url = local ? `http://127.0.0.1:${port}` : `http://${options.allowHosts[0] ?? options.host}`;
+    console.log(`Circuit Studio at ${url}, listening on ${options.host}:${port}, watching ${root}. Stop it with Ctrl+C.`);
+    if (options.open && local)
+      openBrowser(url);
+  });
+}
+export {
+  isLoopback,
+  studio
+};