@cliftonc/cfld 0.2.2 → 0.2.4

package/dist/cli.js

@@ -637,13 +637,13 @@ async function startRunner(options) {
         );
         return;
       }
-      const delay = BACKOFF_MS[Math.min(rapidFailures, BACKOFF_MS.length - 1)];
+      const delay2 = BACKOFF_MS[Math.min(rapidFailures, BACKOFF_MS.length - 1)];
       options.onStatus?.("reconnecting");
       restartTimer = setTimeout(() => {
         if (stopped) return;
         options.onStatus?.("connecting");
         spawnOnce();
-      }, delay);
+      }, delay2);
       restartTimer.unref();
     });
   };
@@ -700,13 +700,15 @@ function startChild(options) {
   const exited = new Promise((resolve) => {
     markExited = resolve;
   });
+  const ownPgid = getpgid(process.pid);
   const trackedPgids = /* @__PURE__ */ new Set();
+  const track = (g) => {
+    if (g > 1 && g !== process.pid && g !== ownPgid) trackedPgids.add(g);
+  };
+  if (child.pid !== void 0) track(child.pid);
   const trackTree = () => {
-    const pid = child.pid;
-    if (pid === void 0) return;
-    for (const g of descendantPgids(pid)) {
-      if (g > 1 && g !== process.pid) trackedPgids.add(g);
-    }
+    if (child.pid === void 0) return;
+    for (const g of descendantPgids(child.pid)) track(g);
   };
   const poll = setInterval(trackTree, options.pollTreeMs ?? 1500);
   poll.unref();
@@ -729,8 +731,6 @@ function startChild(options) {
   });
   const signalTree = (signal) => {
     trackTree();
-    const pid = child.pid;
-    if (pid !== void 0) trySignalGroup(pid, signal);
     for (const g of trackedPgids) trySignalGroup(g, signal);
   };
   return {
@@ -738,15 +738,15 @@ function startChild(options) {
     get pid() {
       return child.pid;
     },
+    treeAlive() {
+      if (trackedPgids.size === 0) return false;
+      const live = livePgids();
+      for (const g of trackedPgids) if (live.has(g)) return true;
+      return false;
+    },
     stop() {
-      if (stopped) return;
       stopped = true;
-      clearInterval(poll);
       signalTree("SIGINT");
-      const t = setTimeout(() => {
-        if (child.exitCode === null && !child.signalCode) signalTree("SIGKILL");
-      }, 4e3);
-      t.unref();
     },
     kill() {
       clearInterval(poll);
@@ -793,18 +793,36 @@ function trySignalGroup(pgid, signal) {
   } catch {
   }
 }
-function reapChild(child, graceMs = 3e3) {
+function getpgid(pid) {
+  try {
+    const n = Number(execSync(`ps -o pgid= -p ${pid}`, { encoding: "utf8" }).trim());
+    return Number.isInteger(n) ? n : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function livePgids() {
+  const live = /* @__PURE__ */ new Set();
+  try {
+    for (const line of execSync("ps -A -o pgid=", { encoding: "utf8" }).split("\n")) {
+      const n = Number(line.trim());
+      if (Number.isInteger(n) && n > 0) live.add(n);
+    }
+  } catch {
+  }
+  return live;
+}
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+async function reapChild(child, graceMs = 3e3) {
   child.stop();
-  return new Promise((resolve) => {
-    const done2 = () => {
-      clearTimeout(grace);
-      child.kill();
-      resolve();
-    };
-    const grace = setTimeout(done2, graceMs);
-    grace.unref();
-    child.exited.then(done2);
-  });
+  await Promise.race([child.exited, delay(Math.min(graceMs, 1200))]);
+  const deadline = Date.now() + graceMs + 5e3;
+  for (; ; ) {
+    child.kill();
+    if (!child.treeAlive()) return;
+    if (Date.now() >= deadline) return;
+    await delay(200);
+  }
 }
 function wireLines2(child, stream, onLine) {
   const source = stream === "stdout" ? child.stdout : child.stderr;
@@ -1155,44 +1173,45 @@ async function runCommand(flags) {
   }
   const primary = routes[0];
   const certPath = await ensureCert(zone, { interactive });
-  const result = await reconcile(
-    { slug, tunnelName, zone, certPath, routes, projectDir: cwd, force: flags.force },
-    {
-      onStep: (s) => step(s),
-      confirmOverwrite: interactive ? (h, t) => askConfirm(`${h} already points to ${t}. Repoint it to this tunnel?`) : void 0
-    }
-  );
-  done(result.created ? `Created tunnel ${tunnelName}` : `Reusing tunnel ${tunnelName}`);
-  for (const r of routes) done(`DNS ${r.hostname} \u2192 :${r.port}`);
-  writeProjectConfig(cwd, {
-    name: slug,
-    zone,
-    uuid: result.uuid,
-    hostname: primary.hostname,
-    port: primary.port,
-    envKey
-  });
-  if (ensureGitignored(cwd, ".cfld.json")) info("Added .cfld.json to .gitignore.");
-  await launch(result, {
+  await launch({
     cwd,
+    slug,
+    zone,
     envKey,
     noEnv: flags.noEnv,
+    noUi: flags.noUi,
+    url: `https://${primary.hostname}`,
     port: primary.port,
-    exec: flags.exec
+    tunnelName,
+    exec: flags.exec,
+    runReconcile: (events) => reconcile(
+      { slug, tunnelName, zone, certPath, routes, projectDir: cwd, force: flags.force },
+      events
+    ),
+    onReconciled: (result, notify) => {
+      writeProjectConfig(cwd, {
+        name: slug,
+        zone,
+        uuid: result.uuid,
+        hostname: primary.hostname,
+        port: primary.port,
+        envKey
+      });
+      if (ensureGitignored(cwd, ".cfld.json")) notify("Added .cfld.json to .gitignore.");
+    }
   });
 }
-async function launch(result, ctx) {
-  const metricsPort = await findFreePort();
-  const url = `https://${result.hostname}`;
+async function launch(ctx) {
+  const url = ctx.url;
   const target = `localhost:${ctx.port}`;
-  const interactive = isInteractive();
+  const interactive = isInteractive() && !ctx.noUi;
   let dashboard;
   if (interactive) {
-    const { startDashboard } = await import("./dashboard-Q6WI32AK.js");
+    const { startDashboard } = await import("./dashboard-GA37Z4H4.js");
     dashboard = startDashboard({
       url,
       target,
-      tunnelName: result.tunnelName,
+      tunnelName: ctx.tunnelName,
       status: "connecting",
       connections: 0,
       requests: 0,
@@ -1202,8 +1221,10 @@ async function launch(result, ctx) {
       devLogs: []
     });
   } else {
-    step("Connecting to Cloudflare edge\u2026");
+    step("Setting up your tunnel\u2026");
   }
+  const setupStep = (s) => dashboard ? dashboard.log(s, "tunnel") : step(s);
+  const setupDone = (s) => dashboard ? dashboard.log(s, "tunnel") : done(s);
   const emitLine = (line) => {
     const formatted = formatLogLine(line);
     if (!formatted) return;
@@ -1228,25 +1249,19 @@ async function launch(result, ctx) {
     dashboard?.stop();
     if (opts.reason) note(`
 ${opts.reason}`);
-    const exit = () => setTimeout(() => process.exit(opts.code ?? 0), 100).unref();
-    if (child) reapChild(child).then(exit);
-    else exit();
+    const finish = () => process.exit(opts.code ?? 0);
+    if (child) reapChild(child).then(finish, finish);
+    else finish();
   };
-  runner = await startRunner({
-    configPath: result.configPath,
-    tunnelName: result.tunnelName,
-    certPath: result.certPath,
-    metricsPort,
-    onLine: (line) => emitLine(line),
-    onStatus: (status) => {
-      if (status === "reconnecting") dashboard?.update({ status: "reconnecting" });
-      else if (status === "connecting" && !dashboard) note("Reconnecting\u2026");
-    },
-    onFatal: (message) => {
-      warn(message);
-      shutdown({ code: 1 });
-    }
-  });
+  process.once(
+    "SIGINT",
+    () => shutdown({ reason: "Stopping \u2014 your URL is preserved. Re-run `cfld`." })
+  );
+  process.once(
+    "SIGTERM",
+    () => shutdown({ reason: "Stopping \u2014 your URL is preserved." })
+  );
+  process.once("SIGHUP", () => shutdown({ reason: "Terminal closed \u2014 stopping." }));
   if (ctx.exec) {
     if (!dashboard) step(`Starting \`${describeCommand(ctx.exec)}\`\u2026`);
     child = startChild({
@@ -1264,16 +1279,42 @@ ${opts.reason}`);
       }
     });
   }
-  if (!dashboard) {
-    process.once(
-      "SIGINT",
-      () => shutdown({ reason: "Stopping \u2014 your URL is preserved. Re-run `cfld`." })
-    );
-    process.once(
-      "SIGTERM",
-      () => shutdown({ reason: "Stopping \u2014 your URL is preserved." })
-    );
-  }
+  const result = await ctx.runReconcile({
+    onStep: (s) => setupStep(s),
+    confirmOverwrite: interactive ? (h, t) => {
+      const ask = () => askConfirm(`${h} already points to ${t}. Repoint it to this tunnel?`);
+      return dashboard ? dashboard.suspend(ask) : ask();
+    } : void 0
+  }).catch(async (err) => {
+    dashboard?.stop();
+    if (child) await reapChild(child);
+    throw err;
+  });
+  if (shuttingDown) return;
+  setupDone(
+    result.created ? `Created tunnel ${result.tunnelName}` : `Reusing tunnel ${result.tunnelName}`
+  );
+  for (const r of result.routes) setupDone(`DNS ${r.hostname} \u2192 :${r.port}`);
+  ctx.onReconciled?.(
+    result,
+    (msg) => dashboard ? dashboard.log(msg, "tunnel") : info(msg)
+  );
+  const metricsPort = await findFreePort();
+  runner = await startRunner({
+    configPath: result.configPath,
+    tunnelName: result.tunnelName,
+    certPath: result.certPath,
+    metricsPort,
+    onLine: (line) => emitLine(line),
+    onStatus: (status) => {
+      if (status === "reconnecting") dashboard?.update({ status: "reconnecting" });
+      else if (status === "connecting" && !dashboard) note("Reconnecting\u2026");
+    },
+    onFatal: (message) => {
+      warn(message);
+      shutdown({ code: 1 });
+    }
+  });
   const ready = await waitForReady(metricsPort).catch((err) => {
     child?.stop();
     runner?.stop();
@@ -1411,7 +1452,7 @@ async function startQuickTunnel(port, opts = {}) {
 async function quickCommand(flags) {
   const port = await resolvePort2(flags);
   const target = `localhost:${port}`;
-  const interactive = isInteractive();
+  const interactive = isInteractive() && !flags.noUi;
   const metricsPort = await findFreePort();
   const envKey = flags.envKey ?? "PUBLIC_URL";
   if (!interactive) step(`Starting an ephemeral tunnel to ${target}\u2026`);
@@ -1444,9 +1485,9 @@ async function quickCommand(flags) {
     dashboard?.stop();
     note(`
 ${opts.reason ?? "Stopped ephemeral tunnel."}`);
-    const exit = () => setTimeout(() => process.exit(opts.code ?? 0), 100).unref();
-    if (child) reapChild(child).then(exit);
-    else exit();
+    const finish = () => process.exit(opts.code ?? 0);
+    if (child) reapChild(child).then(finish, finish);
+    else finish();
   };
   tunnel = await startQuickTunnel(port, { metricsPort, onLine: emitLine });
   const url = tunnel.url;
@@ -1468,7 +1509,7 @@ ${opts.reason ?? "Stopped ephemeral tunnel."}`);
     });
   }
   if (interactive) {
-    const { startDashboard } = await import("./dashboard-Q6WI32AK.js");
+    const { startDashboard } = await import("./dashboard-GA37Z4H4.js");
     dashboard = startDashboard({
       url,
       target,
@@ -1484,10 +1525,9 @@ ${opts.reason ?? "Stopped ephemeral tunnel."}`);
       ephemeral: true
     });
   }
-  if (!dashboard) {
-    process.once("SIGINT", () => shutdown());
-    process.once("SIGTERM", () => shutdown());
-  }
+  process.once("SIGINT", () => shutdown());
+  process.once("SIGTERM", () => shutdown());
+  process.once("SIGHUP", () => shutdown());
   if (child) {
     if (!dashboard) step(`Waiting for your dev server on :${port}\u2026`);
     const up = await waitForPort(port, { signal: childAbort.signal });
@@ -1839,24 +1879,27 @@ async function upCommand(name) {
   }
   const slug = entry.name.replace(/^cfld-/, "");
   const routes = entry.routes?.length ? entry.routes : [{ hostname: entry.hostname, port: entry.port }];
-  const result = await reconcile(
-    {
-      slug,
-      tunnelName: entry.name,
-      zone: entry.zone,
-      certPath: cert,
-      routes,
-      projectDir: entry.projectDir
-    },
-    { onStep: (s) => step(s) }
-  );
-  done(result.created ? `Created tunnel ${entry.name}` : `Reusing tunnel ${entry.name}`);
-  await launch(result, {
+  await launch({
     cwd: entry.projectDir,
+    slug,
+    zone: entry.zone,
     envKey: "PUBLIC_URL",
     noEnv: true,
     // don't touch a .env we may not be sitting in
-    port: entry.port
+    url: `https://${entry.hostname}`,
+    port: entry.port,
+    tunnelName: entry.name,
+    runReconcile: (events) => reconcile(
+      {
+        slug,
+        tunnelName: entry.name,
+        zone: entry.zone,
+        certPath: cert,
+        routes,
+        projectDir: entry.projectDir
+      },
+      events
+    )
   });
 }
 
@@ -2237,6 +2280,7 @@ ${pc7.bold("Options")}
   --zone <domain>   Cloudflare domain to use (e.g. example.com)
   --env <KEY>       .env key to write the URL to (default: PUBLIC_URL)
   --no-env          Don't write the URL to .env
+  --no-ui           Plain line-by-line output instead of the live dashboard
   --exec <cmd>      Dev command to run + supervise (shell form of \`-- <cmd>\`)
   --force           Skip confirmation (destroy)
   -h, --help        Show this help
@@ -2257,6 +2301,7 @@ async function main(rawArgv) {
       zone: { type: "string" },
       env: { type: "string" },
       "no-env": { type: "boolean" },
+      "no-ui": { type: "boolean" },
       exec: { type: "string" },
       quick: { type: "boolean" },
       force: { type: "boolean" },
@@ -2280,6 +2325,7 @@ async function main(rawArgv) {
     zone: values.zone,
     envKey: values.env,
     noEnv: values["no-env"],
+    noUi: values["no-ui"],
     quick: values.quick,
     force: values.force,
     reauth: values.reauth,

package/dist/{dashboard-Q6WI32AK.js → dashboard-GA37Z4H4.js}

@@ -126,14 +126,18 @@ function startDashboard(initial) {
     tunnelLogs: [...initial.tunnelLogs],
     devLogs: [...initial.devLogs]
   };
-  process.stdout.write(ENTER_ALT_SCREEN);
-  const instance = render(/* @__PURE__ */ jsx(Dashboard, { ...state }), {
+  const mount = () => render(/* @__PURE__ */ jsx(Dashboard, { ...state }), {
     stdout: process.stdout,
     // We drive graceful shutdown ourselves; ink's Ctrl-C simply resolves
     // waitUntilExit, and the caller then stops the runner (preserving state).
     exitOnCtrlC: true
   });
-  const rerender = () => instance.rerender(/* @__PURE__ */ jsx(Dashboard, { ...state }));
+  process.stdout.write(ENTER_ALT_SCREEN);
+  let instance = mount();
+  let paused = false;
+  const rerender = () => {
+    if (!paused) instance.rerender(/* @__PURE__ */ jsx(Dashboard, { ...state }));
+  };
   let altActive = true;
   const leaveAltScreen = () => {
     if (!altActive) return;
@@ -141,6 +145,7 @@ function startDashboard(initial) {
     process.stdout.write(LEAVE_ALT_SCREEN);
   };
   const onResize = () => {
+    if (paused) return;
     instance.clear();
     rerender();
   };
@@ -159,6 +164,20 @@ function startDashboard(initial) {
       }
       rerender();
     },
+    async suspend(fn) {
+      paused = true;
+      instance.unmount();
+      leaveAltScreen();
+      try {
+        return await fn();
+      } finally {
+        process.stdout.write(ENTER_ALT_SCREEN);
+        altActive = true;
+        instance = mount();
+        paused = false;
+        rerender();
+      }
+    },
     waitUntilExit() {
       return instance.waitUntilExit();
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cliftonc/cfld",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Zero-token, persistent Cloudflare tunnel CLI for local dev — same public HTTPS URL every run.",
   "type": "module",
   "bin": {