@lacrous/omnicloud 0.2.5 → 0.2.7

package/dist/cli.js

@@ -2,9 +2,11 @@
 
 // src/cli.ts
 import { spawn } from "child_process";
-import { existsSync, readFileSync, realpathSync } from "fs";
+import { randomBytes } from "crypto";
+import { chmodSync, existsSync, readFileSync, realpathSync, writeFileSync } from "fs";
 import { createRequire } from "module";
 import { dirname, join, resolve } from "path";
+import { createInterface } from "readline/promises";
 import { fileURLToPath } from "url";
 var packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 var serverDir = join(packageRoot, "server");
@@ -13,30 +15,36 @@ var pkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
 var USAGE = `omnicloud ${pkg.version}
 
 Usage:
-  omnicloud start [--migrate] [--env <file>]   Run the OmniCloud server
+  omnicloud                                    Start OmniCloud and open it in your browser
+  omnicloud start [--no-open] [--env <file>]   Start the server (opens the browser unless --no-open)
   omnicloud migrate [--env <file>]              Apply database migrations
   omnicloud version                             Print the version
   omnicloud help                                Show this message
 
-Configuration is read from environment variables, then from a .env file in the
-current directory (or the file given with --env). Variables already set in the
-environment are never overwritten. See https://github.com/Lacrous/OmniCloud#configuration.
+Migrations run automatically before the server starts. Configuration is read from
+environment variables, then from a .env file in the current directory (or the file
+given with --env). Variables already set in the environment are never overwritten.
+See https://github.com/Lacrous/OmniCloud#configuration.
 `;
 function parseArgs(argv) {
-  const [command = "help", ...rest] = argv;
+  const [first, ...rest] = argv;
+  const command = first === void 0 || first.startsWith("-") ? "start" : first;
+  const options = first === void 0 || first.startsWith("-") ? argv : rest;
   let migrate2 = false;
   let envFile = null;
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i];
+  let open = true;
+  for (let i = 0; i < options.length; i++) {
+    const arg = options[i];
     if (arg === "--migrate") migrate2 = true;
+    else if (arg === "--no-open") open = false;
     else if (arg === "--env") {
-      const value = rest[++i];
+      const value = options[++i];
       if (!value) throw new Error("--env requires a file path");
       envFile = value;
     } else if (arg?.startsWith("--env=")) envFile = arg.slice("--env=".length);
     else throw new Error(`Unknown option: ${arg}`);
   }
-  return { command, migrate: migrate2, envFile };
+  return { command, migrate: migrate2, envFile, open };
 }
 function parseEnvFile(content) {
   const values = {};
@@ -90,16 +98,72 @@ async function generate(env) {
   const code = await run(process.execPath, [prismaCli(), "generate", "--schema", schemaPath], env);
   if (code !== 0) throw new Error(`Prisma client generation failed (exit ${code}).`);
 }
+function openUrl(url) {
+  const opener = process.platform === "darwin" ? { command: "open", args: [url] } : process.platform === "win32" ? { command: "cmd", args: ["/c", "start", "", url] } : { command: "xdg-open", args: [url] };
+  const child = spawn(opener.command, opener.args, { stdio: "ignore", detached: true });
+  child.on("error", () => {
+    process.stdout.write(`Open ${url} in your browser.
+`);
+  });
+  child.unref();
+}
+async function waitForServer(url, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) return true;
+    } catch {
+    }
+    await new Promise((done) => setTimeout(done, 250));
+  }
+  return false;
+}
+function localUrl(env) {
+  const port = env.PORT && env.PORT.trim() !== "" ? env.PORT.trim() : "4000";
+  const host = env.HOST && env.HOST.trim() !== "" && env.HOST.trim() !== "0.0.0.0" ? env.HOST.trim() : "127.0.0.1";
+  return `http://${host}:${port}`;
+}
 async function start(args, env) {
   if (!existsSync(join(serverDir, "index.js"))) {
     throw new Error("The server bundle is missing. Reinstall @lacrous/omnicloud.");
   }
   await generate(env);
-  if (args.migrate) await migrate(env);
+  await migrate(env);
   env.WEB_DIST_DIR ??= join(serverDir, "web");
   env.NODE_ENV ??= "production";
-  const code = await run(process.execPath, [join(serverDir, "index.js")], env);
-  if (code !== 0) throw new Error(`Server exited with code ${code}.`);
+  const url = localUrl(env);
+  const server = spawn(process.execPath, [join(serverDir, "index.js")], { stdio: "inherit", env });
+  let exited = false;
+  server.on("exit", () => {
+    exited = true;
+  });
+  const forward = (signal) => () => {
+    if (!exited) server.kill(signal);
+  };
+  process.on("SIGINT", forward("SIGINT"));
+  process.on("SIGTERM", forward("SIGTERM"));
+  if (args.open) {
+    const ready = await waitForServer(`${url}/api/health`, 6e4);
+    if (ready) {
+      process.stdout.write(`
+OmniCloud is running at ${url}
+`);
+      openUrl(url);
+    } else if (!exited) {
+      process.stdout.write(`
+OmniCloud did not answer at ${url} yet. Check the log above.
+`);
+    }
+  }
+  await new Promise((resolveExit, rejectExit) => {
+    server.on("exit", (code, signal) => {
+      if (signal) return resolveExit();
+      if (code === 0 || code === null) return resolveExit();
+      rejectExit(new Error(`Server exited with code ${code}.`));
+    });
+    server.on("error", rejectExit);
+  });
 }
 async function main(argv, env = process.env) {
   let args;
@@ -120,7 +184,19 @@ ${USAGE}`);
 `);
     return 0;
   }
-  loadEnvFile(resolve(args.envFile ?? ".env"), env);
+  const envPath = resolve(args.envFile ?? ".env");
+  if (args.command === "start" && !existsSync(envPath) && !env.DATABASE_URL) {
+    const outcome = await firstRunSetup(envPath);
+    if (outcome === "not-interactive") {
+      process.stderr.write(
+        `omnicloud: no configuration found. Create ${envPath} (see https://github.com/Lacrous/OmniCloud#configuration) or run omnicloud in a terminal.
+`
+      );
+      return 1;
+    }
+    if (outcome !== "saved") return 1;
+  }
+  loadEnvFile(envPath, env);
   try {
     if (args.command === "migrate") {
       await migrate(env);
@@ -141,6 +217,71 @@ ${USAGE}`);
 ${USAGE}`);
   return 2;
 }
+function buildEnvFile(values) {
+  return [
+    "# Written by `omnicloud` on first run. Keep this file private.",
+    `DATABASE_URL=${values.databaseUrl}`,
+    `TELEGRAM_API_ID=${values.apiId}`,
+    `TELEGRAM_API_HASH=${values.apiHash}`,
+    `OMNICLOUD_ENCRYPTION_KEY=${values.encryptionKey}`,
+    ""
+  ].join("\n");
+}
+function validateSetup(values) {
+  if (!/^postgres(ql)?:\/\/.+@.+\/.+$/.test(values.databaseUrl)) {
+    return "DATABASE_URL must look like postgresql://user:password@host:5432/database";
+  }
+  if (!/^[1-9][0-9]*$/.test(values.apiId)) {
+    return "TELEGRAM_API_ID must be the number shown at my.telegram.org";
+  }
+  if (!/^[0-9a-f]{32}$/i.test(values.apiHash)) {
+    return "TELEGRAM_API_HASH must be the 32-character value shown at my.telegram.org";
+  }
+  return null;
+}
+async function firstRunSetup(envPath) {
+  if (!process.stdin.isTTY) return "not-interactive";
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    process.stdout.write(
+      "\nWelcome to OmniCloud. No .env file was found, so let's create one.\n\n1. PostgreSQL database\n   Format: postgresql://USER:PASSWORD@HOST:PORT/DATABASE\n   The default docker setup uses postgresql://omnicloud:omnicloud@127.0.0.1:5432/omnicloud\n\n2. Telegram API credentials\n   Open https://my.telegram.org, log in, choose 'API development tools',\n   and create an application. Copy the api_id and api_hash.\n\n"
+    );
+    const databaseUrl = (await rl.question("DATABASE_URL: ")).trim();
+    const apiId = (await rl.question("TELEGRAM_API_ID: ")).trim();
+    const apiHash = (await rl.question("TELEGRAM_API_HASH: ")).trim();
+    const problem = validateSetup({ databaseUrl, apiId, apiHash });
+    if (problem) {
+      process.stderr.write(`
+omnicloud: ${problem}
+Run omnicloud again to retry.
+`);
+      return "invalid";
+    }
+    const answer = (await rl.question(`
+Save these settings to ${envPath}? [Y/n] `)).trim().toLowerCase();
+    if (answer === "n" || answer === "no") {
+      process.stdout.write("Nothing was saved.\n");
+      return "declined";
+    }
+    writeFileSync(
+      envPath,
+      buildEnvFile({
+        databaseUrl,
+        apiId,
+        apiHash,
+        encryptionKey: randomBytes(32).toString("hex")
+      }),
+      { mode: 384 }
+    );
+    chmodSync(envPath, 384);
+    process.stdout.write(`Saved ${envPath}. A private encryption key was generated for you.
+
+`);
+    return "saved";
+  } finally {
+    rl.close();
+  }
+}
 function isEntryPoint() {
   const entry = process.argv[1];
   if (!entry) return false;
@@ -154,8 +295,10 @@ if (isEntryPoint()) {
   main(process.argv.slice(2)).then((code) => process.exit(code));
 }
 export {
+  buildEnvFile,
   loadEnvFile,
   main,
   parseArgs,
-  parseEnvFile
+  parseEnvFile,
+  validateSetup
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lacrous/omnicloud",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "SDK and core building blocks for OmniCloud — self-hosted cloud storage powered by your Telegram account.",
   "license": "MIT",
   "type": "module",
@@ -48,9 +48,9 @@
     "prisma": "^6.2.0"
   },
   "devDependencies": {
-    "@omnicloud/core": "0.2.5",
-    "@omnicloud/shared": "0.2.5",
-    "@omnicloud/telegram": "0.2.5",
+    "@omnicloud/core": "0.2.7",
+    "@omnicloud/shared": "0.2.7",
+    "@omnicloud/telegram": "0.2.7",
     "@types/node": "^22.10.0",
     "esbuild": "0.25.12",
     "tsup": "^8.3.0",

package/server/index.js

@@ -4685,7 +4685,7 @@ function encryptionCheck(configured) {
 }
 
 // ../../apps/api/src/routes/storage.ts
-var VERSION = "0.2.5";
+var VERSION = "0.2.7";
 function registerStorageRoutes(app2, container2) {
   app2.get("/api/health", async () => {
     const database = await probeDatabase(container2);