loopable-cli 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+var here = dirname(fileURLToPath(import.meta.url));
+var fromSource = here.endsWith("/src");
+var root = join(here, "..");
+var node = process.execPath;
+function usage() {
+  return `Usage:
+  loopable start [--host 127.0.0.1] [--port 4321]
+      App and Dispatcher (production build).
+
+  loopable runner [--url URL] [--token TOKEN]
+      Join this machine as a runner. URL and token also come from
+      LOOPABLE_URL and LOOPABLE_RUNNER_TOKEN.
+
+  loopable dispatcher
+      Dispatcher only.
+`;
+}
+function fail(message) {
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+}
+function parse(argv) {
+  const flags = {
+    host: process.env.HOST ?? "127.0.0.1",
+    port: process.env.PORT ?? "4321"
+  };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => {
+      const value = argv[++i];
+      if (!value) fail(`${arg} needs a value.`);
+      return value;
+    };
+    if (arg === "-h" || arg === "--help") return { command: "help", flags };
+    if (arg === "--host") flags.host = next();
+    else if (arg === "--port") flags.port = next();
+    else if (arg === "--url") flags.url = next();
+    else if (arg === "--token") flags.token = next();
+    else if (arg.startsWith("-")) fail(`Unknown flag: ${arg}`);
+    else rest.push(arg);
+  }
+  return { command: rest[0] ?? "help", flags };
+}
+function prefixLines(label, stream, write) {
+  createInterface({ input: stream }).on("line", (line) => write(`[${label}] ${line}
+`));
+}
+function run(label, file, args, env = {}) {
+  const child = spawn(file, args, {
+    cwd: root,
+    env: { ...process.env, ...env },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (child.stdout) prefixLines(label, child.stdout, (line) => process.stdout.write(line));
+  if (child.stderr) prefixLines(label, child.stderr, (line) => process.stderr.write(line));
+  return child;
+}
+function stop(children) {
+  for (const child of children) {
+    if (child.pid && !child.killed) child.kill("SIGTERM");
+  }
+}
+async function supervise(children) {
+  const shutdown = () => stop(children);
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  const code = await new Promise((resolve) => {
+    let settled = false;
+    for (const child of children) {
+      child.on("exit", (exitCode, signal) => {
+        if (settled) return;
+        settled = true;
+        stop(children);
+        if (signal) resolve(0);
+        else resolve(exitCode ?? 1);
+      });
+    }
+  });
+  process.exit(code);
+}
+function appEntry() {
+  const entry = join(root, ".output/server/index.mjs");
+  if (!existsSync(entry)) fail("App build missing. From a checkout run: pnpm build");
+  return entry;
+}
+function pickEntry(kind) {
+  const source = join(root, `src/${kind}/main.ts`);
+  const bundled = join(root, `dist/${kind}.mjs`);
+  if (fromSource && existsSync(source)) return source;
+  if (existsSync(bundled)) return bundled;
+  if (existsSync(source)) return source;
+  fail(`${kind} build missing. From a checkout run: pnpm build`);
+}
+function nodeArgs(entry) {
+  return entry.endsWith(".ts") ? ["--experimental-strip-types", entry] : [entry];
+}
+function dispatcher() {
+  return run("dispatcher", node, nodeArgs(pickEntry("dispatcher")), {
+    PORT: "",
+    LOOPABLE_DISPATCHER_PORT: ""
+  });
+}
+async function waitFor(child) {
+  return await new Promise((resolve) => {
+    child.on("exit", (code, signal) => resolve(signal ? 0 : code ?? 1));
+  });
+}
+async function main() {
+  const { command, flags } = parse(process.argv.slice(2));
+  if (command === "help") {
+    process.stdout.write(usage());
+    return;
+  }
+  if (command === "runner") {
+    if (flags.url) process.env.LOOPABLE_URL = flags.url;
+    if (flags.token) process.env.LOOPABLE_RUNNER_TOKEN = flags.token;
+    process.exit(
+      await waitFor(
+        spawn(node, nodeArgs(pickEntry("runner")), {
+          cwd: root,
+          env: process.env,
+          stdio: "inherit"
+        })
+      )
+    );
+  }
+  if (command === "dispatcher") {
+    process.exit(
+      await waitFor(
+        spawn(node, nodeArgs(pickEntry("dispatcher")), {
+          cwd: root,
+          env: { ...process.env, PORT: "", LOOPABLE_DISPATCHER_PORT: "" },
+          stdio: "inherit"
+        })
+      )
+    );
+  }
+  if (command === "start") {
+    await supervise([
+      run("app", node, [appEntry()], {
+        PORT: flags.port,
+        HOST: flags.host,
+        NITRO_PORT: flags.port,
+        NITRO_HOST: flags.host,
+        LOOPABLE_SKIP_MIGRATE: "1"
+      }),
+      dispatcher()
+    ]);
+    return;
+  }
+  fail(`Unknown command: ${command}
+
+${usage()}`);
+}
+await main();