@takodotid/circuit 0.18.5 → 0.20.0

package/dist/chunks/{index-ex1wcst7.js → index-xm9nma2t.js}

@@ -84,6 +84,25 @@ 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];
@@ -106,4 +125,4 @@ function isGlobal(address) {
   return !NOT_GLOBAL_V4.some((prefix) => contains(prefix, address));
 }
 
-export { familyOf, split, isAddress, isCidr, network, contains, netmask, wildcard, host, isGlobal };
+export { familyOf, parse, split, isAddress, isCidr, network, contains, formatAddress, rangeOf, prefixesBetween, netmask, wildcard, host, isGlobal };

package/dist/chunks/server-5shmsmse.js

@@ -0,0 +1,246 @@
+import {
+  packageRoot
+} from "./index-jtzfw679.js";
+import"./index-xm9nma2t.js";
+import"./index-fq57hya4.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"
+};
+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 name2 = url.searchParams.get("device") ?? "";
+        const files = JSON.parse(data).files?.[name2];
+        if (!files)
+          throw new Error(`no device ${name2}`);
+        return history(root, [files.source, files.snapshot].filter((file2) => Boolean(file2)));
+      });
+      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-z]+$/.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 {
+  studio,
+  isLoopback,
+  hostAllowed
+};