@launchsecure/launch-kit 0.0.27 → 0.0.29

package/dist/server/beacon-monitor-entry.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/server/beacon-monitor-entry.ts
+var import_node_crypto = require("node:crypto");
+var import_node_path2 = require("node:path");
+
+// src/server/beacon/ndjson-writer.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+function openNdjsonWriter(opts) {
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(opts.path), { recursive: true });
+  const stream = (0, import_node_fs.createWriteStream)(opts.path, { flags: "a" });
+  let total = 0;
+  let closed = false;
+  stream.on("error", (err) => {
+    opts.onError?.(err);
+  });
+  return {
+    write(event) {
+      if (closed) return;
+      let line;
+      try {
+        line = JSON.stringify(event);
+      } catch (err) {
+        opts.onError?.(err instanceof Error ? err : new Error(String(err)));
+        return;
+      }
+      stream.write(line + "\n");
+      total += 1;
+    },
+    count() {
+      return total;
+    },
+    path() {
+      return opts.path;
+    },
+    close() {
+      return new Promise((resolveClose) => {
+        if (closed) {
+          resolveClose();
+          return;
+        }
+        closed = true;
+        stream.end(() => resolveClose());
+      });
+    }
+  };
+}
+
+// src/server/beacon/server.ts
+var import_node_http = require("node:http");
+var MAX_BODY_BYTES = 1048576;
+var TOKEN_PATH_PREFIX = "/m/";
+function writeCors(res, origin) {
+  res.setHeader("Access-Control-Allow-Origin", origin && origin !== "null" ? origin : "*");
+  res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "content-type");
+  res.setHeader("Access-Control-Max-Age", "600");
+  res.setHeader("Vary", "Origin");
+}
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > MAX_BODY_BYTES) {
+        reject(new Error("payload too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", (err) => reject(err));
+  });
+}
+function isMonitorBatchEnvelope(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (typeof v.sessionId !== "string") return false;
+  if (!Array.isArray(v.events)) return false;
+  if (!v.meta || typeof v.meta !== "object") return false;
+  const meta = v.meta;
+  if (typeof meta.url !== "string" || typeof meta.userAgent !== "string") return false;
+  return true;
+}
+function startBeaconServer(opts) {
+  return new Promise((resolveStart, rejectStart) => {
+    const server = (0, import_node_http.createServer)(async (req, res) => {
+      writeCors(res, req.headers.origin);
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (req.method !== "POST") {
+        res.writeHead(405, { "content-type": "text/plain" });
+        res.end("method not allowed");
+        return;
+      }
+      const url = req.url ?? "/";
+      const pathOnly = url.split("?")[0] ?? "/";
+      if (!pathOnly.startsWith(TOKEN_PATH_PREFIX)) {
+        res.writeHead(404, { "content-type": "text/plain" });
+        res.end("not found");
+        return;
+      }
+      const provided = pathOnly.slice(TOKEN_PATH_PREFIX.length).replace(/\/+$/, "");
+      if (provided !== opts.token) {
+        res.writeHead(403, { "content-type": "text/plain" });
+        res.end("bad token");
+        return;
+      }
+      let bodyText;
+      try {
+        bodyText = await readBody(req);
+      } catch (err) {
+        opts.onBadBatch?.(`body read failed: ${err.message}`, req);
+        res.writeHead(413, { "content-type": "text/plain" });
+        res.end("payload error");
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(bodyText);
+      } catch {
+        opts.onBadBatch?.("invalid JSON", req);
+        res.writeHead(400, { "content-type": "text/plain" });
+        res.end("invalid json");
+        return;
+      }
+      if (!isMonitorBatchEnvelope(parsed)) {
+        opts.onBadBatch?.("schema mismatch", req);
+        res.writeHead(400, { "content-type": "text/plain" });
+        res.end("bad batch shape");
+        return;
+      }
+      try {
+        opts.onBatch(parsed, req);
+      } catch (err) {
+        opts.onServerError?.(err instanceof Error ? err : new Error(String(err)));
+      }
+      res.writeHead(204);
+      res.end();
+    });
+    server.on("error", (err) => {
+      opts.onServerError?.(err);
+      rejectStart(err);
+    });
+    server.listen(opts.port, opts.host, () => {
+      const addr = server.address();
+      const port = addr ? addr.port : opts.port;
+      const url = `http://${opts.host}:${port}/m/${opts.token}`;
+      resolveStart({
+        url,
+        port,
+        close() {
+          return new Promise((resolveClose) => {
+            server.close(() => resolveClose());
+          });
+        }
+      });
+    });
+  });
+}
+
+// src/server/beacon-monitor-entry.ts
+function parseMonitorFlags(argv) {
+  const flags = { port: 9876, host: "127.0.0.1", quiet: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--port") {
+      const n = Number(argv[++i]);
+      if (!Number.isInteger(n) || n < 0 || n > 65535) {
+        die(`--port must be an integer in 0..65535 (got "${argv[i]}")`);
+      }
+      flags.port = n;
+    } else if (a === "--host") {
+      const v = argv[++i];
+      if (!v) die("--host requires a value");
+      flags.host = v;
+    } else if (a === "--out") {
+      const v = argv[++i];
+      if (!v) die("--out requires a path");
+      flags.out = v;
+    } else if (a === "--token") {
+      const v = argv[++i];
+      if (!v) die("--token requires a value");
+      if (!/^[A-Za-z0-9_-]+$/.test(v)) die("--token must be alphanumeric (plus _ or -)");
+      flags.token = v;
+    } else if (a === "--quiet") {
+      flags.quiet = true;
+    } else if (a === "--help" || a === "-h") {
+      printHelp();
+      process.exit(0);
+    } else if (a.startsWith("--")) {
+      die(`unknown flag: ${a}`);
+    } else {
+      die(`unexpected argument: ${a}`);
+    }
+  }
+  return flags;
+}
+function mintToken() {
+  return (0, import_node_crypto.randomBytes)(4).toString("hex");
+}
+async function runMonitor(argv) {
+  const flags = parseMonitorFlags(argv);
+  const token = flags.token ?? mintToken();
+  const projectRoot = process.cwd();
+  const outPath = flags.out ? (0, import_node_path2.resolve)(projectRoot, flags.out) : (0, import_node_path2.resolve)(projectRoot, ".launchsecure", `beacon-${token}.ndjson`);
+  const writer = openNdjsonWriter({
+    path: outPath,
+    onError: (err) => {
+      process.stderr.write(`
+[launch-beacon] ndjson write error: ${err.message}
+`);
+    }
+  });
+  const stats = {
+    events: 0,
+    badBatches: 0,
+    lastKind: "",
+    lastAt: 0
+  };
+  let server;
+  try {
+    server = await startBeaconServer({
+      port: flags.port,
+      host: flags.host,
+      token,
+      onBatch: (batch) => {
+        for (const raw of batch.events) {
+          writer.write(raw);
+          stats.events += 1;
+          const ev = raw;
+          if (typeof ev.kind === "string") stats.lastKind = ev.kind;
+          if (typeof ev.ts === "number") stats.lastAt = ev.ts;
+        }
+        draw();
+      },
+      onBadBatch: (reason) => {
+        stats.badBatches += 1;
+        process.stderr.write(`
+[launch-beacon] bad batch: ${reason}
+`);
+      },
+      onServerError: (err) => {
+        process.stderr.write(`
+[launch-beacon] server error: ${err.message}
+`);
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("EADDRINUSE")) {
+      die(`port ${flags.port} already in use \u2014 pass --port <n> to choose another`);
+    }
+    die(`failed to start: ${msg}`);
+    return;
+  }
+  process.stdout.write(`
+launch-beacon monitor \u2014 listening
+`);
+  process.stdout.write(`  paste URL    ${server.url}
+`);
+  process.stdout.write(`  writing      ${outPath}
+`);
+  process.stdout.write(`  session      ${token}
+
+`);
+  let heartbeatTimer = null;
+  const draw = () => {
+    if (flags.quiet) return;
+    const since = stats.lastAt ? Math.max(0, Math.round((Date.now() - stats.lastAt) / 1e3)) : null;
+    const sinceStr = since === null ? "\u2014" : since < 5 ? "just now" : `${since}s ago`;
+    const lastStr = stats.lastKind ? `${stats.lastKind} (${sinceStr})` : "\u2014";
+    const badStr = stats.badBatches > 0 ? ` | bad: ${stats.badBatches}` : "";
+    const line = `  events: ${stats.events}${badStr} | last: ${lastStr}`;
+    process.stdout.write(`\r\x1B[K${line}`);
+  };
+  if (!flags.quiet) {
+    heartbeatTimer = setInterval(draw, 1e3);
+    draw();
+  }
+  const shutdown = async (signal) => {
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    process.stdout.write(`
+
+[launch-beacon] caught ${signal}, shutting down\u2026
+`);
+    try {
+      await server.close();
+    } catch (err) {
+      process.stderr.write(`[launch-beacon] server close error: ${err.message}
+`);
+    }
+    try {
+      await writer.close();
+    } catch (err) {
+      process.stderr.write(`[launch-beacon] writer close error: ${err.message}
+`);
+    }
+    process.stdout.write(`  events written: ${writer.count()}
+`);
+    process.stdout.write(`  file:           ${outPath}
+`);
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
+function printHelp() {
+  process.stdout.write(
+    `launch-beacon
+
+Usage:
+  launch-beacon monitor [flags]    Start the HTTP receiver for beacon monitor batches
+
+Flags for "monitor":
+  --port <n>       port to listen on (default: 9876)
+  --host <host>    host to bind to (default: 127.0.0.1)
+  --out <path>     output NDJSON file (default: .launchsecure/beacon-<token>.ndjson)
+  --token <str>    use this token instead of a random 8-char hex
+  --quiet          suppress the live heartbeat line
+
+The printed URL is what you paste into the beacon debug panel. Beacon POSTs
+monitor batches there; this process writes each event as a JSON line to the
+output file. Ctrl+C shuts down cleanly.
+`
+  );
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const subcommand = argv[0];
+  if (!subcommand || subcommand === "monitor") {
+    await runMonitor(subcommand === "monitor" ? argv.slice(1) : argv);
+    return;
+  }
+  if (subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+    printHelp();
+    return;
+  }
+  die(`unknown subcommand: ${subcommand}`);
+}
+function die(msg) {
+  process.stderr.write(`[launch-beacon] ${msg}
+`);
+  process.exit(2);
+}
+void main();

package/dist/server/chart-serve.js

@@ -6281,8 +6281,10 @@ async function startChartServer(opts = {}) {
         req.on("end", () => {
           try {
             const newConfig = JSON.parse(body);
+            const existingConfig = loadConfig(reqRoot);
+            const merged = { ...existingConfig, ...newConfig };
             const configPath = import_node_path24.default.join(reqRoot, LAUNCHCHART_CONFIG_FILE);
-            import_node_fs21.default.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+            import_node_fs21.default.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ ok: true }));
           } catch (err) {