@arp-protocol/cli 0.0.0-stage → 0.0.3

package/dist/chunks/cli-n4qagybd.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+import {
+  generatePrivateKey
+} from "./cli-fbwpcfvp.js";
+
+// ../../packages/protocol/dist/node/serve.js
+import { createServer } from "node:http";
+import { PassThrough } from "node:stream";
+var DEFAULT_SERVE_MAX_BODY_BYTES = 1024 * 1024;
+var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+var TOO_LARGE_GRACE_MS = 1000;
+
+class BodyTooLarge extends Error {
+}
+function bodyOf(message, limit) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    const done = () => {
+      message.off("data", onData);
+      message.off("end", onEnd);
+      message.off("error", onError);
+    };
+    const onData = (chunk) => {
+      const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk instanceof Uint8Array ? chunk : new Uint8Array(0);
+      size += bytes.byteLength;
+      if (size > limit) {
+        done();
+        message.pause();
+        message.on("error", () => {
+          return;
+        });
+        reject(new BodyTooLarge);
+        return;
+      }
+      chunks.push(bytes);
+    };
+    const onEnd = () => {
+      done();
+      const out = new Uint8Array(size);
+      let at = 0;
+      for (const chunk of chunks) {
+        out.set(chunk, at);
+        at += chunk.byteLength;
+      }
+      resolve(out);
+    };
+    const onError = (error) => {
+      done();
+      reject(error);
+    };
+    message.on("data", onData);
+    message.on("end", onEnd);
+    message.on("error", onError);
+  });
+}
+function requestOf(message, body, base) {
+  const headers = new Headers;
+  for (const [name, value] of Object.entries(message.headers)) {
+    if (value === undefined)
+      continue;
+    for (const item of Array.isArray(value) ? value : [value])
+      headers.append(name, item);
+  }
+  return new Request(new URL(message.url ?? "/", base), {
+    method: message.method ?? "GET",
+    headers,
+    body: body === null || body.byteLength === 0 ? null : body
+  });
+}
+async function send(response, out) {
+  const headers = {};
+  response.headers.forEach((value, name) => {
+    headers[name] = value;
+  });
+  out.writeHead(response.status, headers);
+  out.end(response.body === null ? undefined : new Uint8Array(await response.arrayBuffer()));
+}
+function serveFetch(options, handle) {
+  const hostname = options.hostname ?? "127.0.0.1";
+  const maxBodyBytes = options.maxBodyBytes ?? DEFAULT_SERVE_MAX_BODY_BYTES;
+  const base = `http://${hostname}:${options.port}`;
+  const server = createServer((message, out) => {
+    (async () => {
+      try {
+        const hasBody = message.method !== "GET" && message.method !== "HEAD";
+        const body = hasBody ? await bodyOf(message, maxBodyBytes) : null;
+        const ip = message.socket.remoteAddress ?? "unknown";
+        await send(await handle(requestOf(message, body, base), ip), out);
+      } catch (error) {
+        if (out.headersSent) {
+          out.destroy();
+          return;
+        }
+        const tooLarge = error instanceof BodyTooLarge;
+        out.writeHead(tooLarge ? 413 : 500, {
+          "content-type": "application/json",
+          ...tooLarge ? { connection: "close" } : {}
+        });
+        if (tooLarge) {
+          const drop = () => message.socket.destroy();
+          out.once("finish", drop);
+          setTimeout(drop, TOO_LARGE_GRACE_MS).unref();
+        }
+        out.end(JSON.stringify({ error: tooLarge ? "body too large" : "internal error" }));
+      }
+    })();
+  });
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  server.requestTimeout = requestTimeoutMs;
+  server.headersTimeout = Math.min(server.headersTimeout, requestTimeoutMs);
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, hostname, () => resolve(server));
+  });
+}
+function bufferedCopy(stream) {
+  return stream.pipe(new PassThrough);
+}
+async function* linesOf(stream) {
+  const decoder = new TextDecoder;
+  let buffered = "";
+  for await (const chunk of stream) {
+    buffered += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+    let newline = buffered.indexOf(`
+`);
+    while (newline !== -1) {
+      const line = buffered.slice(0, newline).trim();
+      buffered = buffered.slice(newline + 1);
+      newline = buffered.indexOf(`
+`);
+      if (line.length > 0)
+        yield line;
+    }
+  }
+  const rest = buffered.trim();
+  if (rest.length > 0)
+    yield rest;
+}
+// ../../packages/protocol/dist/node/local-state.js
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+function arpHome(env = process.env, home = homedir()) {
+  const configured = env["ARP_HOME"]?.trim();
+  return configured !== undefined && configured !== "" ? configured : join(home, ".arp");
+}
+
+class MovedStateError extends Error {
+  legacy;
+  current;
+  constructor(legacy, current) {
+    super(`${legacy} exists but ${current} does not. State now lives under ~/.arp (or ARP_HOME), ` + `not the working directory. Move it before starting: mv ${legacy} ${current}`);
+    this.legacy = legacy;
+    this.current = current;
+    this.name = "MovedStateError";
+  }
+}
+function refuseMovedState(legacy, current) {
+  if (resolve(legacy) === resolve(current))
+    return;
+  if (existsSync(legacy) && !existsSync(current))
+    throw new MovedStateError(legacy, current);
+}
+function stateFile(override, name, options = {}) {
+  if (override !== undefined && override.trim() !== "")
+    return override.trim();
+  const current = join(arpHome(options.env ?? process.env, options.home ?? homedir()), name);
+  refuseMovedState(join(options.cwd ?? process.cwd(), ".arp", name), current);
+  return current;
+}
+
+class KeyFileError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KeyFileError";
+  }
+}
+var PRIVATE_KEY = /^0x[0-9a-fA-F]{64}$/;
+function readKeyFile(path, options = {}) {
+  const stat = statSync(path);
+  if (!stat.isFile())
+    throw new KeyFileError(`${path} is not a file`);
+  if ((options.platform ?? process.platform) !== "win32" && (stat.mode & 63) !== 0) {
+    throw new KeyFileError(`${path} has mode ${(stat.mode & 511).toString(8)}; it must be 600 (chmod 600 ${path})`);
+  }
+  const raw = readFileSync(path, "utf8").trim();
+  const key = raw.startsWith("0x") ? raw : `0x${raw}`;
+  if (!PRIVATE_KEY.test(key))
+    throw new KeyFileError(`${path} does not hold a 32-byte hex private key`);
+  return key;
+}
+function loadOrCreateKeyFile(path, options = {}) {
+  if (existsSync(path))
+    return { key: readKeyFile(path, options), created: false };
+  const key = (options.generate ?? generatePrivateKey)();
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, `${key}
+`, { mode: 384, flag: "wx" });
+  if ((options.platform ?? process.platform) !== "win32")
+    chmodSync(path, 384);
+  return { key, created: true };
+}
+function appendJsonLine(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(value)}
+`);
+}
+function readJsonLines(path) {
+  if (!existsSync(path))
+    return [];
+  const out = [];
+  for (const line of readFileSync(path, "utf8").split(`
+`)) {
+    if (line.trim().length === 0)
+      continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var HELD_HERE = new Set;
+function lockFile(path) {
+  const lock = `${path}.lock`;
+  mkdirSync(dirname(lock), { recursive: true });
+  for (let attempt = 0;attempt < 2; attempt += 1) {
+    let fd;
+    try {
+      fd = openSync(lock, "wx", 384);
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      const holder = Number(readFileSync(lock, "utf8").trim());
+      const ownLeftover = holder === process.pid && !HELD_HERE.has(lock);
+      if (Number.isInteger(holder) && holder > 0 && !ownLeftover && alive(holder)) {
+        throw new Error(`${path} is held by process ${holder} (${lock}); one process per ledger`);
+      }
+      unlinkSync(lock);
+      continue;
+    }
+    writeSync(fd, `${process.pid}
+`);
+    closeSync(fd);
+    HELD_HERE.add(lock);
+    let held = true;
+    const release = () => {
+      if (!held)
+        return;
+      held = false;
+      HELD_HERE.delete(lock);
+      try {
+        if (readFileSync(lock, "utf8").trim() === String(process.pid))
+          unlinkSync(lock);
+      } catch {}
+    };
+    process.once("exit", release);
+    return { release };
+  }
+  throw new Error(`${lock} could not be taken`);
+}
+function bigintSafe(_key, inner) {
+  return typeof inner === "bigint" ? inner.toString() : inner;
+}
+function jsonResponse(value, status = 200) {
+  return new Response(JSON.stringify(value, bigintSafe, 2), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+function redactUrls(text) {
+  return text.replace(/\b(https?|wss?):\/\/([^/\s?#"']+)[^\s"']*/gi, (_match, scheme, host) => {
+    const bare = host.includes("@") ? host.slice(host.lastIndexOf("@") + 1) : host;
+    return `${scheme}://${bare}/…`;
+  });
+}
+function loopbackHosts(port) {
+  return [`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`];
+}
+function refuseForeignRequest(request, policy) {
+  const host = (request.headers.get("host") ?? "").toLowerCase();
+  if (!policy.hosts.some((allowed) => allowed.toLowerCase() === host)) {
+    return jsonResponse({ error: "this service answers to its own host only" }, 403);
+  }
+  const origin = request.headers.get("origin");
+  if (origin !== null && !(policy.origins ?? []).includes(origin)) {
+    return jsonResponse({ error: `origin ${origin} is not allowed` }, 403);
+  }
+  if (request.method === "POST") {
+    const type = (request.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase();
+    if (type !== "application/json") {
+      return jsonResponse({ error: "content-type must be application/json" }, 415);
+    }
+  }
+  return null;
+}
+export { DEFAULT_SERVE_MAX_BODY_BYTES, DEFAULT_REQUEST_TIMEOUT_MS, serveFetch, bufferedCopy, linesOf, arpHome, MovedStateError, refuseMovedState, stateFile, KeyFileError, readKeyFile, loadOrCreateKeyFile, appendJsonLine, readJsonLines, lockFile, bigintSafe, jsonResponse, redactUrls, loopbackHosts, refuseForeignRequest };