@naviyra/cloud-panel 0.0.0-stage → 0.0.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();

package/scripts/windows-boot.mjs

@@ -0,0 +1,259 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+
+export const TASK_NAME = "Naviyra Cloud Panel";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+export function psQuote(value) {
+  return `'${String(value).replaceAll("'", "''")}'`;
+}
+
+export function panelOrigin(envText) {
+  const match = String(envText).match(/^PANEL_PORT=(.*)$/m);
+  const port = Number((match?.[1] ?? "3000").trim());
+  if (!Number.isInteger(port) || port < 1 || port > 65535)
+    return "http://127.0.0.1:3000";
+  return `http://127.0.0.1:${port}`;
+}
+
+export function registrationScript({
+  taskName = TASK_NAME,
+  nodePath,
+  scriptPath,
+  workingDirectory,
+  userId,
+  mode,
+}) {
+  const triggers =
+    mode === "boot"
+      ? `$startup = New-ScheduledTaskTrigger -AtStartup
+$startup.Delay = 'PT30S'
+$logon = New-ScheduledTaskTrigger -AtLogOn -User $user
+$triggers = @($startup, $logon)
+$principal = New-ScheduledTaskPrincipal -UserId $user -LogonType S4U -RunLevel Limited`
+      : `$triggers = New-ScheduledTaskTrigger -AtLogOn -User $user
+$principal = New-ScheduledTaskPrincipal -UserId $user -LogonType Interactive -RunLevel Limited`;
+  return `$ErrorActionPreference = 'Stop'
+$node = ${psQuote(nodePath)}
+$script = ${psQuote(scriptPath)}
+$workdir = ${psQuote(workingDirectory)}
+$user = ${psQuote(userId)}
+$task = ${psQuote(taskName)}
+$action = New-ScheduledTaskAction -Execute $node -Argument ('"' + $script + '"') -WorkingDirectory $workdir
+$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -MultipleInstances IgnoreNew -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1) -ExecutionTimeLimit (New-TimeSpan -Seconds 0)
+${triggers}
+Register-ScheduledTask -TaskName $task -Action $action -Trigger $triggers -Settings $settings -Principal $principal -Force | Out-Null
+Write-Output 'REGISTERED ${mode}'
+`;
+}
+
+function taskScript(command, taskName = TASK_NAME) {
+  const task = psQuote(taskName);
+  if (command === "start")
+    return `$ErrorActionPreference = 'Stop'
+try { Start-ScheduledTask -TaskName ${task} }
+catch {
+  if ($_.Exception.Message -match 'already running|currently running') { exit 0 }
+  throw
+}
+Write-Output 'STARTED'
+`;
+  if (command === "stop")
+    return `Stop-ScheduledTask -TaskName ${task} -ErrorAction SilentlyContinue
+Write-Output 'STOPPED'
+`;
+  return `Unregister-ScheduledTask -TaskName ${task} -Confirm:$false -ErrorAction SilentlyContinue
+Write-Output 'REMOVED'
+`;
+}
+
+export function runPowerShell(script) {
+  return new Promise((resolve) => {
+    const child = spawn(
+      "powershell.exe",
+      ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script],
+      { windowsHide: true, stdio: ["ignore", "pipe", "pipe"] },
+    );
+    let output = "";
+    child.stdout?.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.once("error", (error) => resolve({ code: 1, output: error.message }));
+    child.once("exit", (code) => resolve({ code: code ?? 1, output }));
+  });
+}
+
+function windowsUser() {
+  return new Promise((resolve) => {
+    const child = spawn("whoami.exe", [], {
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let output = "";
+    child.stdout?.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.once("error", () => resolve(""));
+    child.once("exit", (code) => resolve(code === 0 ? output.trim() : ""));
+  });
+}
+
+export async function installBootTask(options = {}) {
+  const installRoot = options.root ?? root;
+  const nodePath = options.nodePath ?? process.execPath;
+  const userId = options.userId ?? (await windowsUser());
+  const run = options.runPowerShell ?? runPowerShell;
+  if (!userId)
+    return { ok: false, message: "Could not determine the Windows account for the startup task." };
+  const scriptPath = path.join(installRoot, "scripts", "service-supervisor.mjs");
+  let last = "Task Scheduler did not accept the startup task.";
+  for (const mode of ["boot", "logon"]) {
+    const result = await run(
+      registrationScript({
+        nodePath,
+        scriptPath,
+        workingDirectory: installRoot,
+        userId,
+        mode,
+      }),
+    );
+    if (result.code === 0 && result.output.includes(`REGISTERED ${mode}`)) {
+      const message =
+        mode === "boot"
+          ? `Registered "${TASK_NAME}" to start at Windows boot as ${userId} and restart if it stops.`
+          : `Registered "${TASK_NAME}" to start when ${userId} signs in and restart if it stops.`;
+      return { ok: true, mode, message };
+    }
+    last = result.output.trim() || last;
+  }
+  return { ok: false, message: last };
+}
+
+export async function startBootTask(run = runPowerShell) {
+  const result = await run(taskScript("start"));
+  if (result.code === 0) return { ok: true };
+  return { ok: false, message: result.output.trim() };
+}
+
+async function servicePid(installRoot) {
+  try {
+    const pid = Number(
+      await readFile(path.join(installRoot, ".runtime", "service.pid"), "utf8"),
+    );
+    return Number.isInteger(pid) && pid > 0 ? pid : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function taskkill(pid) {
+  return new Promise((resolve) => {
+    const child = spawn("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+      windowsHide: true,
+      stdio: "ignore",
+    });
+    child.once("error", resolve);
+    child.once("exit", resolve);
+  });
+}
+
+export async function stopBootTask(options = {}) {
+  const run = options.runPowerShell ?? runPowerShell;
+  const installRoot = options.root ?? root;
+  const pid = await servicePid(installRoot);
+  if (pid && process.platform === "win32") await taskkill(pid);
+  const result = await run(taskScript("stop"));
+  return { ok: result.code === 0, message: result.output.trim() };
+}
+
+export async function removeBootTask(options = {}) {
+  const run = options.runPowerShell ?? runPowerShell;
+  await stopBootTask({ ...options, runPowerShell: run });
+  const result = await run(taskScript("remove"));
+  return {
+    ok: result.code === 0,
+    message:
+      result.code === 0
+        ? `Removed the "${TASK_NAME}" startup task.`
+        : result.output.trim(),
+  };
+}
+
+export async function openPanelWhenReady(installRoot = root) {
+  let envText = "";
+  try {
+    envText = await readFile(path.join(installRoot, ".env"), "utf8");
+  } catch {
+    envText = "";
+  }
+  const origin = panelOrigin(envText);
+  for (let attempt = 0; attempt < 300; attempt++) {
+    try {
+      const response = await fetch(`${origin}/api/me`, {
+        redirect: "manual",
+        signal: AbortSignal.timeout(2000),
+      });
+      const body = await response.json();
+      if (response.status === 401 && body.error === "Please sign in") {
+        const browser = spawn("explorer.exe", [origin], {
+          windowsHide: true,
+          stdio: "ignore",
+        });
+        browser.once("error", () => {});
+        browser.unref();
+        console.log(`Naviyra is ready: ${origin}`);
+        return;
+      }
+    } catch {
+      // The panel build can take several minutes on first start.
+    }
+    await delay(1000);
+  }
+  console.log(
+    `Naviyra is still starting. Open ${origin} when it is ready. Progress is in .runtime/service.log.`,
+  );
+}
+
+async function main() {
+  const command = process.argv[2] || "install";
+  if (!["install", "start", "stop", "remove"].includes(command))
+    throw Error("Usage: node scripts/windows-boot.mjs install|start|stop|remove");
+  if (process.platform !== "win32")
+    throw Error("The Naviyra startup task is only registered on Windows.");
+  await mkdir(path.join(root, ".runtime"), { recursive: true });
+  if (command === "install") {
+    const installed = await installBootTask({ root });
+    if (!installed.ok) throw Error(installed.message);
+    console.log(installed.message);
+    const started = await startBootTask();
+    if (!started.ok) throw Error(started.message || "Could not start the task.");
+    console.log("Naviyra is starting in the background.");
+    return;
+  }
+  if (command === "start") {
+    const started = await startBootTask();
+    if (!started.ok) throw Error(started.message || "Could not start the task.");
+    console.log("Naviyra startup task is running.");
+    return;
+  }
+  const result =
+    command === "stop"
+      ? await stopBootTask({ root })
+      : await removeBootTask({ root });
+  if (!result.ok) throw Error(result.message || `Could not ${command} the task.`);
+  console.log(result.message || `Naviyra startup task ${command} complete.`);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exitCode = 1;
+  });
+}