@naviyra/cloud-panel 0.0.0-stage → 0.0.2

package/scripts/setup-local.mjs

@@ -0,0 +1,215 @@
+import { randomBytes } from "node:crypto";
+import { createInterface } from "node:readline/promises";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+export function envAssignment(name, value) {
+  const plain = /^[A-Za-z0-9@._:/+-]+$/.test(value);
+  const encoded = plain
+    ? value
+    : `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+  return `${name}=${encoded}`;
+}
+
+export function applySettings(template, settings) {
+  const replacements = [
+    [
+      "JWT_SECRET=replace-with-at-least-32-random-characters",
+      envAssignment("JWT_SECRET", settings.jwt),
+    ],
+    [
+      "AGENT_TOKEN=replace-with-at-least-32-random-characters",
+      envAssignment("AGENT_TOKEN", settings.token),
+    ],
+    [
+      "ADMIN_PASSWORD=replace-with-a-strong-password",
+      envAssignment("ADMIN_PASSWORD", settings.password),
+    ],
+    [
+      "ADMIN_EMAIL=admin@example.com",
+      envAssignment("ADMIN_EMAIL", settings.email),
+    ],
+    ["POSTGRES_PORT=55432", `POSTGRES_PORT=${settings.postgresPort}`],
+    [
+      "postgresql://naviyra:naviyra@127.0.0.1:55432/naviyra",
+      `postgresql://naviyra:naviyra@127.0.0.1:${settings.postgresPort}/naviyra`,
+    ],
+    [
+      "AGENT_URL=http://127.0.0.1:4001",
+      `AGENT_URL=http://127.0.0.1:${settings.agentPort}`,
+    ],
+    ["AGENT_PORT=4001", `AGENT_PORT=${settings.agentPort}`],
+    ["PANEL_PORT=3000", `PANEL_PORT=${settings.panelPort}`],
+  ];
+  let env = template;
+  for (const [from, to] of replacements) {
+    if (!env.includes(from))
+      throw Error(`Environment template is missing ${from.split("=")[0]}.`);
+    env = env.replace(from, to);
+  }
+  return env;
+}
+
+async function askPort(ask, label, fallback, used, log) {
+  for (;;) {
+    const raw = (await ask(label)).trim();
+    const port = raw === "" ? fallback : Number(raw);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      log("Enter a port from 1 to 65535.");
+      continue;
+    }
+    if (used.includes(port)) {
+      log("That port is already used by another Naviyra service.");
+      continue;
+    }
+    return port;
+  }
+}
+
+export async function promptSettings(ask, askSecret, log = console.log) {
+  log("Enter the panel settings. Press Enter to accept a default.");
+  let email = "";
+  for (;;) {
+    const typed = (await ask("Administrator email [admin@example.com]: ")).trim();
+    email = (typed || "admin@example.com").toLowerCase();
+    if (emailPattern.test(email)) break;
+    log("Enter an email address.");
+  }
+  let password = "";
+  for (;;) {
+    password = await askSecret("Administrator password (12+ characters): ");
+    if (password.length < 12) {
+      log("Use at least 12 characters.");
+      continue;
+    }
+    if (password !== (await askSecret("Confirm password: "))) {
+      log("Passwords do not match.");
+      continue;
+    }
+    break;
+  }
+  const agentPort = await askPort(
+    ask,
+    "Agent port [4001]: ",
+    4001,
+    [3000, 55432],
+    log,
+  );
+  return {
+    email,
+    password,
+    panelPort: 3000,
+    agentPort,
+    postgresPort: 55432,
+  };
+}
+
+function defaultAsk(question) {
+  return new Promise((resolve, reject) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question)
+      .then((answer) => {
+        rl.close();
+        resolve(answer);
+      })
+      .catch((error) => {
+        rl.close();
+        reject(error);
+      });
+  });
+}
+
+function defaultAskSecret(question) {
+  return new Promise((resolve) => {
+    const input = process.stdin;
+    const output = process.stdout;
+    output.write(question);
+    input.setRawMode(true);
+    input.resume();
+    let value = "";
+    const finish = (result) => {
+      input.setRawMode(false);
+      input.pause();
+      input.off("data", onData);
+      output.write("\n");
+      resolve(result);
+    };
+    const onData = (chunk) => {
+      for (const char of chunk.toString("utf8")) {
+        if (char === "\u0003") {
+          input.setRawMode(false);
+          process.exit(130);
+        }
+        if (char === "\r" || char === "\n") {
+          finish(value);
+          return;
+        }
+        if (char === "\u007f" || char === "\b") {
+          if (value) output.write("\b \b");
+          value = value.slice(0, -1);
+          continue;
+        }
+        if (char < " ") continue;
+        value += char;
+        output.write("*");
+      }
+    };
+    input.on("data", onData);
+  });
+}
+
+export async function createLocalEnv(options = {}) {
+  const readExisting = options.readExisting ?? (() => readFile(".env"));
+  try {
+    await readExisting();
+    console.log(".env already exists; left unchanged.");
+    return { created: false };
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const secret = () => randomBytes(32).toString("hex");
+  const tty = options.tty ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const settings = tty
+    ? await promptSettings(
+        options.ask ?? defaultAsk,
+        options.askSecret ?? defaultAskSecret,
+        options.log ?? console.log,
+      )
+    : {
+        email: "admin@example.com",
+        password: secret().slice(0, 24),
+        panelPort: 3000,
+        agentPort: 4001,
+        postgresPort: 55432,
+      };
+  const template = await (options.readTemplate ?? (() => readFile(".env.example", "utf8")))();
+  const env = applySettings(template, {
+    ...settings,
+    jwt: secret(),
+    token: secret(),
+  });
+  await (options.writeEnv ??
+    ((text) => writeFile(".env", text, { flag: "wx", mode: 0o600 })))(env);
+  await mkdir(".runtime", { recursive: true });
+  const login = `Local installation\nURL: http://127.0.0.1:${settings.panelPort}\nEmail: ${settings.email}\nPassword: ${settings.password}\n`;
+  await (options.writeLogin ??
+    ((text) => writeFile(".runtime/local-login.txt", text, { mode: 0o600 })))(login);
+  console.log("Created .env. Sign-in details saved to .runtime/local-login.txt.");
+  return { created: true, settings };
+}
+
+const isMain =
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  createLocalEnv().catch((error) => {
+    console.error(error.message);
+    process.exitCode = 1;
+  });
+}

package/scripts/start-naviyra.mjs

@@ -0,0 +1,303 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile, writeFile, unlink, access } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import net from "node:net";
+import { setTimeout as delay } from "node:timers/promises";
+
+const root = fileURLToPath(new URL("../", import.meta.url));
+process.chdir(root);
+const lock = path.join(root, ".runtime", "launcher.lock");
+const children = new Set();
+let ownsLock = false;
+let stopping = false;
+
+async function exists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function launch(args, cwd = root) {
+  const child = spawn(process.execPath, args, {
+    cwd,
+    env: process.env,
+    shell: false,
+    windowsHide: true,
+    stdio: "inherit",
+  });
+  children.add(child);
+  child.on("error", (error) => {
+    child.startError = error;
+    children.delete(child);
+  });
+  child.on("exit", () => children.delete(child));
+  return child;
+}
+async function command(args, cwd) {
+  const child = launch(args, cwd);
+  await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) =>
+      code === 0
+        ? resolve()
+        : reject(Error("A startup step failed. See the output above.")),
+    );
+  });
+}
+async function stop() {
+  if (stopping) return;
+  stopping = true;
+  for (const child of children) {
+    if (child.exitCode !== null || !child.pid) continue;
+    if (process.platform === "win32") {
+      await new Promise((resolve) => {
+        const killer = spawn(
+          "taskkill.exe",
+          ["/PID", String(child.pid), "/T", "/F"],
+          { windowsHide: true, stdio: "ignore" },
+        );
+        killer.once("error", resolve);
+        killer.once("exit", resolve);
+      });
+    } else child.kill("SIGTERM");
+  }
+  if (ownsLock) await unlink(lock).catch(() => {});
+}
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
+  process.once(signal, () => {
+    void stop().then(() => {
+      process.exitCode = 0;
+    });
+  });
+
+async function listening(port) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host: "127.0.0.1", port });
+    const finish = (result) => {
+      socket.destroy();
+      resolve(result);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.setTimeout(1500, () => finish(false));
+  });
+}
+async function healthy(url, agent = false) {
+  try {
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(4000),
+      redirect: "manual",
+      headers: agent
+        ? { Authorization: `Bearer ${process.env.AGENT_TOKEN}` }
+        : {},
+    });
+    const body = await response.json();
+    return agent
+      ? response.ok && body.ok === true
+      : response.status === 401 && body.error === "Please sign in";
+  } catch {
+    return false;
+  }
+}
+async function waitFor(url, child, agent = false) {
+  for (let attempt = 0; attempt < 90; attempt++) {
+    if (child.startError)
+      throw Error(
+        "Could not launch a service. Check the Node.js installation.",
+      );
+    if (child.exitCode !== null)
+      throw Error("A service stopped during startup. See the output above.");
+    if (await healthy(url, agent)) return;
+    await delay(1000);
+  }
+  throw Error("A service did not become ready within 90 attempts.");
+}
+function openBrowser(url) {
+  if (process.argv.includes("--no-browser")) return;
+  const file = process.platform === "win32" ? "explorer.exe" : "xdg-open";
+  const browser = spawn(file, [url], { windowsHide: true, stdio: "ignore" });
+  browser.on("error", () => console.log(`Open ${url} in your browser.`));
+  browser.unref();
+}
+
+async function main() {
+  try {
+    console.log("Starting Naviyra…");
+    if (!(await exists(path.join(root, "node_modules", "pg"))))
+      throw Error(
+        "Run npm install once in the Naviyra folder, then double-click Start Naviyra.cmd again.",
+      );
+    if (!(await exists(path.join(root, ".env"))))
+      await command(["scripts/setup-local.mjs"]);
+    process.loadEnvFile(path.join(root, ".env"));
+    const panelPort = Number(process.env.PANEL_PORT || 3000);
+    const agentPort = Number(process.env.AGENT_PORT || 4001);
+    if (
+      ![panelPort, agentPort].every(
+        (port) => Number.isInteger(port) && port > 0 && port < 65536,
+      ) ||
+      panelPort === agentPort
+    )
+      throw Error("PANEL_PORT and AGENT_PORT must be different valid ports.");
+    const origin = `http://127.0.0.1:${panelPort}`;
+    const panelHealth = `${origin}/api/me`;
+    const agentHealth = `http://127.0.0.1:${agentPort}/health`;
+    const configuredAgent = new URL(
+      process.env.AGENT_URL || `http://127.0.0.1:${agentPort}`,
+    );
+    if (
+      !["127.0.0.1", "localhost"].includes(configuredAgent.hostname) ||
+      Number(configuredAgent.port || 80) !== agentPort
+    )
+      throw Error(
+        "The single-click launcher requires AGENT_URL to point to this server's AGENT_PORT.",
+      );
+    const publicOrigin = process.env.PUBLIC_ORIGIN;
+    if (publicOrigin && new URL(publicOrigin).origin !== origin)
+      console.log(
+        `Configured public panel address: ${new URL(publicOrigin).origin}`,
+      );
+    const browserUrl = publicOrigin ? new URL(publicOrigin).origin : origin;
+    await mkdir(path.dirname(lock), { recursive: true });
+    try {
+      await writeFile(lock, String(process.pid), { flag: "wx" });
+      ownsLock = true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const pid = Number(await readFile(lock, "utf8"));
+      if (!Number.isInteger(pid) || pid < 1)
+        throw Error(
+          "The launcher lock is invalid. Remove .runtime/launcher.lock after closing other launchers.",
+        );
+      let alive = true;
+      try {
+        process.kill(pid, 0);
+      } catch (probe) {
+        if (probe.code === "ESRCH") alive = false;
+      }
+      if (!alive) {
+        await unlink(lock);
+        await writeFile(lock, String(process.pid), { flag: "wx" });
+        ownsLock = true;
+      } else {
+        console.log(
+          "Naviyra is already starting or running. Waiting for the panel…",
+        );
+        for (let attempt = 0; attempt < 900; attempt++) {
+          if (
+            (await healthy(panelHealth)) &&
+            (await healthy(agentHealth, true))
+          ) {
+            openBrowser(browserUrl);
+            return;
+          }
+          try {
+            process.kill(pid, 0);
+          } catch {
+            throw Error("The other launcher stopped. Run this launcher again.");
+          }
+          await delay(1000);
+        }
+        throw Error(
+          "The other launcher is still busy. Check its window for progress.",
+        );
+      }
+    }
+
+    console.log("Checking the panel database…");
+    const { default: pg } = await import("pg");
+    async function databaseReady() {
+      const client = new pg.Client({
+        connectionString: process.env.DATABASE_URL,
+        connectionTimeoutMillis: 4000,
+      });
+      try {
+        await client.connect();
+        await client.query("SELECT 1");
+      } finally {
+        await client.end().catch(() => {});
+      }
+    }
+    try {
+      await databaseReady();
+    } catch (error) {
+      if (!["ECONNREFUSED", "3D000"].includes(error.code))
+        throw Error(
+          "Cannot connect to the panel database. Check DATABASE_URL and database credentials.",
+        );
+      await command(["--env-file=.env", "scripts/postgres-local.mjs"]);
+      await databaseReady();
+    }
+    await command(["--env-file=.env", "scripts/migrate.mjs"]);
+    const client = new pg.Client({
+      connectionString: process.env.DATABASE_URL,
+    });
+    let seed;
+    await client.connect();
+    try {
+      seed = !(
+        await client.query("SELECT 1 FROM users WHERE role='admin' LIMIT 1")
+      ).rowCount;
+    } finally {
+      await client.end();
+    }
+    if (seed) await command(["--env-file=.env", "scripts/seed.mjs"]);
+    console.log("Starting Naviyra's private Docker runtime…");
+    await command(["--env-file=.env", "scripts/runtime.mjs", "start"]);
+
+    if (!(await healthy(agentHealth, true))) {
+      if (await listening(agentPort))
+        throw Error(
+          `Port ${agentPort} is occupied by another service or an agent with a different token.`,
+        );
+      console.log("Starting the agent…");
+      const child = launch(["src/server.mjs"], path.join(root, "apps/agent"));
+      await waitFor(agentHealth, child, true);
+      child.once("exit", () => {
+        if (!stopping) {
+          console.error("The agent stopped. Restart Naviyra.");
+          void stop().then(() => {
+            process.exitCode = 1;
+          });
+        }
+      });
+    } else console.log("Agent is already running.");
+
+    if (!(await healthy(panelHealth))) {
+      if (await listening(panelPort))
+        throw Error(`Port ${panelPort} is occupied by another service.`);
+      const next = path.join(root, "node_modules/next/dist/bin/next");
+      const panelRoot = path.join(root, "apps/panel");
+      console.log("Preparing the production panel…");
+      await command([next, "build"], panelRoot);
+      const child = launch(
+        [next, "start", "--hostname", "127.0.0.1", "--port", String(panelPort)],
+        panelRoot,
+      );
+      await waitFor(panelHealth, child);
+      child.once("exit", () => {
+        if (!stopping) {
+          console.error("The panel stopped. Restart Naviyra.");
+          void stop().then(() => {
+            process.exitCode = 1;
+          });
+        }
+      });
+    } else console.log("Panel is already running.");
+    console.log(`\nNaviyra is ready: ${browserUrl}`);
+    openBrowser(browserUrl);
+    if (children.size)
+      console.log(
+        "Keep this window open. Press Ctrl+C to stop the panel and agent started here. Database data is preserved.",
+      );
+    else await stop();
+  } catch (error) {
+    console.error(`\nNaviyra could not start: ${error.message}`);
+    await stop();
+    process.exitCode = 1;
+  }
+}
+await main();