@naviyra/cloud-panel 0.0.0-stage → 0.0.1

package/apps/panel/lib/database-runtime.mjs

@@ -0,0 +1,243 @@
+import { managedRuntime } from "@naviyra/runtime";
+import { randomBytes } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+
+export const databaseEngines = Object.freeze({
+  postgresql: { label: "PostgreSQL", image: "postgres:17", port: 5432 },
+  mysql: { label: "MySQL", image: "mysql:8.4", port: 3306 },
+  mariadb: { label: "MariaDB", image: "mariadb:11.4", port: 3306 },
+});
+const failure = (message) => Object.assign(Error(message), { status: 503 });
+export function databaseEngine(value) {
+  if (typeof value !== "string" || !Object.hasOwn(databaseEngines, value))
+    throw Object.assign(Error("Choose PostgreSQL, MySQL, or MariaDB"), {
+      status: 400,
+    });
+  return databaseEngines[value];
+}
+
+// Never include command arguments or database output in public errors: they can contain secrets.
+function docker(args, options) {
+  return managedRuntime().run(args, options);
+}
+
+export function createDatabaseRuntime(run = docker, sleep = delay) {
+  async function inspect(id) {
+    try {
+      return JSON.parse(await run(["inspect", id]))[0];
+    } catch {
+      throw failure("Could not inspect the managed database");
+    }
+  }
+  async function owned(row) {
+    if (!/^naviyra-db-[0-9a-f-]{36}$/.test(row.runtime_id || ""))
+      throw failure("Invalid managed database identity");
+    const info = await inspect(row.runtime_id);
+    if (info?.Config?.Labels?.["naviyra.database"] !== row.id)
+      throw failure("Managed database ownership does not match");
+    return info;
+  }
+  async function sql(row, statement) {
+    databaseEngine(row.engine);
+    const args =
+      row.engine === "postgresql"
+        ? ["psql", "-U", "postgres", "-d", "postgres", "-v", "ON_ERROR_STOP=1"]
+        : [
+            "sh",
+            "-c",
+            row.engine === "mysql"
+              ? 'MYSQL_PWD="$MYSQL_ROOT_PASSWORD" exec mysql -uroot --protocol=socket'
+              : 'MYSQL_PWD="$MARIADB_ROOT_PASSWORD" exec mariadb -uroot --protocol=socket',
+          ];
+    return run(["exec", "-i", row.runtime_id, ...args], { input: statement });
+  }
+  return {
+    async provision({ id, engine, physical, password }) {
+      const spec = databaseEngine(engine);
+      if (
+        !/^nv_[a-z][a-z0-9_]{1,24}$/.test(physical) ||
+        !/^[A-Za-z0-9_-]+$/.test(password) ||
+        !/^[0-9a-f-]{36}$/.test(id)
+      )
+        throw failure("Invalid database configuration");
+      try {
+        if ((await run(["info", "--format", "{{.OSType}}"])) !== "linux")
+          throw Error();
+      } catch (error) {
+        throw error.status
+          ? error
+          : failure(
+              "Naviyra's managed Docker runtime is unavailable. Run npm run runtime:setup on the server.",
+            );
+      }
+      try {
+        await run(["network", "inspect", "naviyra-databases"]);
+      } catch {
+        try {
+          await run([
+            "network",
+            "create",
+            "--label",
+            "naviyra.managed=true",
+            "naviyra-databases",
+          ]);
+        } catch {
+          await run(["network", "inspect", "naviyra-databases"]);
+        }
+      }
+      try {
+        await run(["image", "inspect", spec.image]);
+      } catch {
+        try {
+          await run(["pull", spec.image], { timeout: 600000 });
+        } catch {
+          throw failure(
+            `Could not download ${spec.label}. Check Docker and its registry network access, then retry.`,
+          );
+        }
+      }
+      const row = {
+        id,
+        engine,
+        runtime_id: `naviyra-db-${id}`,
+        db_user: physical,
+      };
+      const adminPassword = randomBytes(24).toString("base64url");
+      const prefix = engine === "mariadb" ? "MARIADB" : "MYSQL";
+      const env =
+        engine === "postgresql"
+          ? {
+              POSTGRES_PASSWORD: adminPassword,
+              POSTGRES_INITDB_ARGS:
+                "--auth-host=scram-sha-256 --auth-local=trust",
+            }
+          : {
+              [`${prefix}_ROOT_PASSWORD`]: adminPassword,
+              [`${prefix}_DATABASE`]: physical,
+              [`${prefix}_USER`]: physical,
+              [`${prefix}_PASSWORD`]: password,
+            };
+      // Create separately so cleanup can never remove a pre-existing container on name collision.
+      await run(
+        [
+          "create",
+          "--name",
+          row.runtime_id,
+          "--label",
+          `naviyra.database=${id}`,
+          "--restart",
+          "unless-stopped",
+          "--network",
+          "naviyra-databases",
+          "-p",
+          `127.0.0.1::${spec.port}`,
+          ...Object.keys(env).flatMap((key) => ["-e", key]),
+          spec.image,
+        ],
+        { env },
+      );
+      try {
+        await run(["start", row.runtime_id]);
+        let ready = false;
+        for (let attempt = 0; attempt < 90; attempt++) {
+          try {
+            // TCP probes avoid accepting the temporary socket-only initialization server.
+            if (engine === "postgresql")
+              await run([
+                "exec",
+                row.runtime_id,
+                "pg_isready",
+                "-h",
+                "127.0.0.1",
+                "-U",
+                "postgres",
+              ]);
+            else
+              await run([
+                "exec",
+                row.runtime_id,
+                "sh",
+                "-c",
+                engine === "mysql"
+                  ? 'MYSQL_PWD="$MYSQL_PASSWORD" exec mysql -h127.0.0.1 -u"$MYSQL_USER" -D"$MYSQL_DATABASE" -e "SELECT 1"'
+                  : 'MYSQL_PWD="$MARIADB_PASSWORD" exec mariadb -h127.0.0.1 -u"$MARIADB_USER" -D"$MARIADB_DATABASE" -e "SELECT 1"',
+              ]);
+            ready = true;
+            break;
+          } catch {
+            await sleep(2000);
+          }
+        }
+        if (!ready)
+          throw failure(
+            `${spec.label} did not become ready. Check server resources and retry.`,
+          );
+        if (engine === "postgresql") {
+          await sql(
+            row,
+            `CREATE ROLE "${physical}" LOGIN PASSWORD '${password}';\nCREATE DATABASE "${physical}" OWNER "${physical}";\nREVOKE ALL ON DATABASE "${physical}" FROM PUBLIC;\n`,
+          );
+          await run(
+            [
+              "exec",
+              "-e",
+              "PGPASSWORD",
+              row.runtime_id,
+              "psql",
+              "-h",
+              "127.0.0.1",
+              "-U",
+              physical,
+              "-d",
+              physical,
+              "-v",
+              "ON_ERROR_STOP=1",
+              "-c",
+              "SELECT 1",
+            ],
+            { env: { PGPASSWORD: password } },
+          );
+        }
+        const info = await owned(row);
+        const binding = info.NetworkSettings?.Ports?.[`${spec.port}/tcp`]?.[0];
+        const port = Number(binding?.HostPort);
+        if (
+          binding?.HostIp !== "127.0.0.1" ||
+          !Number.isInteger(port) ||
+          port < 1 ||
+          port > 65535
+        )
+          throw failure("Database did not receive a private port");
+        return { runtime_id: row.runtime_id, host: "127.0.0.1", port };
+      } catch (error) {
+        try {
+          await run(["rm", "-f", "-v", row.runtime_id]);
+        } catch {
+          throw failure(
+            `Database setup failed; remove the incomplete container ${row.runtime_id} on the panel server before retrying.`,
+          );
+        }
+        throw error;
+      }
+    },
+    async reset(row, password) {
+      await owned(row);
+      if (
+        !/^nv_[a-z][a-z0-9_]{1,24}$/.test(row.db_user) ||
+        !/^[A-Za-z0-9_-]+$/.test(password)
+      )
+        throw failure("Invalid database credentials");
+      await sql(
+        row,
+        row.engine === "postgresql"
+          ? `ALTER ROLE "${row.db_user}" PASSWORD '${password}';`
+          : `ALTER USER '${row.db_user}'@'%' IDENTIFIED BY '${password}';`,
+      );
+    },
+    async remove(row) {
+      await owned(row);
+      await run(["rm", "-f", "-v", row.runtime_id]);
+    },
+  };
+}
+export const databaseRuntime = createDatabaseRuntime();

package/apps/panel/lib/databases.mjs

@@ -0,0 +1,292 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import pg from "pg";
+import { db } from "./db.mjs";
+import {
+  databaseEngine,
+  databaseEngines,
+  databaseRuntime,
+} from "./database-runtime.mjs";
+
+const NAME = /^[a-z][a-z0-9_]{1,24}$/;
+const IDENT = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+function fail(message, status) {
+  return Object.assign(Error(message), { status });
+}
+
+function connectionParts() {
+  let url;
+  try {
+    url = new URL(process.env.DATABASE_URL || "");
+  } catch {
+    throw fail("Database server is not available", 500);
+  }
+  if (!["localhost", "127.0.0.1"].includes(url.hostname))
+    throw fail(
+      "Databases can only be created on the local PostgreSQL server",
+      400,
+    );
+  const user = decodeURIComponent(url.username);
+  const database = decodeURIComponent(url.pathname.replace(/^\//, ""));
+  const port = Number(url.port || 5432);
+  if (!IDENT.test(user) || !IDENT.test(database) || !port)
+    throw fail("Database server is not available", 500);
+  return { host: "127.0.0.1", port, user, database, url };
+}
+
+export function databaseName(value, native = true) {
+  const name = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (!NAME.test(name))
+    throw fail(
+      "Use 2–25 characters: lowercase letters, numbers, and underscores",
+      400,
+    );
+  const physical = `nv_${name}`;
+  if (native && process.env.DATABASE_URL) {
+    const { database } = connectionParts();
+    if (["postgres", "template0", "template1", database].includes(physical))
+      throw fail("Choose a different database name", 400);
+  }
+  return { name, physical };
+}
+
+async function withAdmin(run) {
+  const { url } = connectionParts();
+  const admin = new URL(url.href);
+  admin.pathname = "/postgres";
+  const client = new pg.Client({ connectionString: admin.href });
+  await client.connect();
+  try {
+    await client.query("SET statement_timeout = '15s'");
+    return await run(client);
+  } finally {
+    await client.end();
+  }
+}
+
+async function runFormat(client, template, values) {
+  let statement;
+  try {
+    const placeholders = values
+      .map((_, index) => `$${index + 2}::text`)
+      .join(", ");
+    const { rows } = await client.query(
+      `SELECT format($1::text, ${placeholders}) AS statement`,
+      [template, ...values],
+    );
+    statement = rows[0]?.statement;
+  } catch {
+    throw fail("Could not update the database", 500);
+  }
+  if (typeof statement !== "string" || statement.length > 400)
+    throw fail("Could not update the database", 500);
+  try {
+    await client.query(statement);
+  } catch (error) {
+    if (error.code === "42710" || error.code === "42P04")
+      throw fail("A database with that name already exists", 409);
+    throw fail("Could not update the database", 500);
+  }
+}
+
+async function isolate(client) {
+  const { user, database } = connectionParts();
+  for (const name of [database, "postgres"]) {
+    await runFormat(client, "REVOKE CONNECT ON DATABASE %I FROM PUBLIC", [
+      name,
+    ]);
+    await runFormat(client, "GRANT CONNECT ON DATABASE %I TO %I", [name, user]);
+  }
+}
+
+async function dropPhysical(client, dbName, dbUser) {
+  await client.query(
+    "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname=$1 AND pid <> pg_backend_pid()",
+    [dbName],
+  );
+  await runFormat(client, "DROP DATABASE IF EXISTS %I", [dbName]);
+  await runFormat(client, "DROP ROLE IF EXISTS %I", [dbUser]);
+}
+
+function view(row, parts, password) {
+  return {
+    id: row.id,
+    name: row.name,
+    database: row.db_name,
+    user: row.db_user,
+    engine: row.engine || "postgresql",
+    host: row.host || parts.host,
+    port: row.port || parts.port,
+    created_at: row.created_at,
+    ...(password ? { password } : {}),
+  };
+}
+
+export async function listDatabases(userId) {
+  const rows = (
+    await db.query(
+      "SELECT * FROM app_databases WHERE user_id=$1 ORDER BY created_at DESC",
+      [userId],
+    )
+  ).rows;
+  return {
+    engines: Object.entries(databaseEngines).map(([value, spec]) => ({
+      value,
+      label: spec.label,
+    })),
+    databases: rows.map((row) =>
+      view(row, row.runtime_id ? row : connectionParts()),
+    ),
+  };
+}
+
+export async function createDatabase(userId, requested, engine) {
+  // Requests from older clients retain native PostgreSQL behavior.
+  if (engine !== undefined)
+    return createManagedDatabase(userId, requested, engine);
+  const { name, physical } = databaseName(requested);
+  const parts = connectionParts();
+  const password = randomBytes(18).toString("base64url");
+  const id = randomUUID();
+  await withAdmin(async (client) => {
+    await isolate(client);
+    let roleCreated = false;
+    let databaseCreated = false;
+    try {
+      await runFormat(client, "CREATE ROLE %I LOGIN PASSWORD %L", [
+        physical,
+        password,
+      ]);
+      roleCreated = true;
+      await runFormat(client, "CREATE DATABASE %I OWNER %I", [
+        physical,
+        physical,
+      ]);
+      databaseCreated = true;
+      await runFormat(client, "REVOKE ALL ON DATABASE %I FROM PUBLIC", [
+        physical,
+      ]);
+      await runFormat(client, "GRANT ALL PRIVILEGES ON DATABASE %I TO %I", [
+        physical,
+        physical,
+      ]);
+    } catch (error) {
+      try {
+        if (databaseCreated) await dropPhysical(client, physical, physical);
+        else if (roleCreated)
+          await runFormat(client, "DROP ROLE %I", [physical]);
+      } catch {}
+      throw error;
+    }
+  });
+  try {
+    const probeUrl = new URL(parts.url.href);
+    probeUrl.username = physical;
+    probeUrl.password = password;
+    probeUrl.pathname = `/${physical}`;
+    const probe = new pg.Client({ connectionString: probeUrl.href });
+    await probe.connect();
+    try {
+      await probe.query("SELECT 1");
+    } finally {
+      await probe.end();
+    }
+    const row = (
+      await db.query(
+        "INSERT INTO app_databases(id,user_id,name,db_name,db_user) VALUES($1,$2,$3,$4,$4) RETURNING id, name, db_name, db_user, created_at",
+        [id, userId, name, physical],
+      )
+    ).rows[0];
+    return view(row, parts, password);
+  } catch (error) {
+    await withAdmin((client) => dropPhysical(client, physical, physical));
+    if (error.code === "23505")
+      throw fail("A database with that name already exists", 409);
+    throw error.status ? error : fail("Could not create the database", 500);
+  }
+}
+
+async function createManagedDatabase(userId, requested, engine) {
+  databaseEngine(engine);
+  const { name, physical } = databaseName(requested, false);
+  if (
+    (await db.query("SELECT 1 FROM app_databases WHERE name=$1", [name]))
+      .rowCount
+  )
+    throw fail("A database with that name already exists", 409);
+  const id = randomUUID();
+  const password = randomBytes(18).toString("base64url");
+  const runtime = await databaseRuntime.provision({
+    id,
+    engine,
+    physical,
+    password,
+  });
+  try {
+    const row = (
+      await db.query(
+        "INSERT INTO app_databases(id,user_id,name,db_name,db_user,engine,runtime_id,host,port) VALUES($1,$2,$3,$4,$4,$5,$6,$7,$8) RETURNING *",
+        [
+          id,
+          userId,
+          name,
+          physical,
+          engine,
+          runtime.runtime_id,
+          runtime.host,
+          runtime.port,
+        ],
+      )
+    ).rows[0];
+    return view(row, runtime, password);
+  } catch (error) {
+    await databaseRuntime.remove({ id, engine, ...runtime });
+    if (error.code === "23505")
+      throw fail("A database with that name already exists", 409);
+    throw fail("Could not save the database", 500);
+  }
+}
+
+async function owned(userId, id) {
+  const row = (
+    await db.query("SELECT * FROM app_databases WHERE id=$1 AND user_id=$2", [
+      id,
+      userId,
+    ])
+  ).rows[0];
+  if (!row) throw fail("Database not found", 404);
+  if (!row.db_name.startsWith("nv_") || row.db_name !== row.db_user)
+    throw fail("Could not update the database", 500);
+  return row;
+}
+
+export async function resetDatabasePassword(userId, id) {
+  const row = await owned(userId, id);
+  const password = randomBytes(18).toString("base64url");
+  if (row.runtime_id) {
+    await databaseRuntime.reset(row, password);
+    return view(row, row, password);
+  }
+  const parts = connectionParts();
+  await withAdmin((client) =>
+    runFormat(client, "ALTER ROLE %I WITH PASSWORD %L", [
+      row.db_user,
+      password,
+    ]),
+  );
+  return view(row, parts, password);
+}
+
+export async function deleteDatabase(userId, id) {
+  const row = await owned(userId, id);
+  if (row.runtime_id) await databaseRuntime.remove(row);
+  else
+    await withAdmin((client) => dropPhysical(client, row.db_name, row.db_user));
+  await db.query("DELETE FROM app_databases WHERE id=$1 AND user_id=$2", [
+    id,
+    userId,
+  ]);
+  return { ok: true };
+}

package/apps/panel/lib/db.mjs

@@ -0,0 +1,6 @@
+import pg from "pg";
+const globalDb = globalThis;
+export const db =
+  globalDb.naviyraDb ||
+  new pg.Pool({ connectionString: process.env.DATABASE_URL, max: 10 });
+if (process.env.NODE_ENV !== "production") globalDb.naviyraDb = db;

package/apps/panel/next.config.mjs

@@ -0,0 +1,8 @@
+import dotenv from "dotenv";
+import path from "node:path";
+dotenv.config({ path: path.resolve(process.cwd(), "../../.env"), quiet: true });
+export default {
+  poweredByHeader: false,
+  devIndicators: false,
+  serverExternalPackages: ["pg", "bcryptjs", "@naviyra/runtime"],
+};

package/apps/panel/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@naviyra/panel",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev --hostname 127.0.0.1",
+    "build": "next build",
+    "start": "next start --hostname 127.0.0.1"
+  },
+  "dependencies": {
+    "@naviyra/runtime": "1.0.0",
+    "@naviyra/shared": "1.0.0",
+    "bcryptjs": "^3.0.2",
+    "jose": "^6.1.0",
+    "lucide-react": "^0.468.0",
+    "next": "^16.0.0",
+    "pg": "^8.16.3",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
+  }
+}