@oalo-ai/cli 0.1.1 → 0.2.0

package/src/commands/migrate.js

@@ -0,0 +1,321 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { OaloChannel } from "../channel.js";
+import { resolve as resolveConfig, controlPlane, HOW_TO_CONNECT } from "../config.js";
+import { requireFeature } from "../server.js";
+import { dim } from "../events.js";
+import { buildPlan, PLATFORMS } from "../migrate/plan.js";
+
+/**
+ * `oalo migrate <heroku|railway|render|fly|primcloud>`: what an app on another
+ * platform becomes on Oalo, from the repo's files and that platform's own CLI.
+ *
+ *   oalo migrate heroku [--from-app shop]          the plan; nothing changes
+ *   oalo migrate heroku --apply                    write the Procfile and .oalo/app.json,
+ *                                                  and set the variables on the live app
+ *
+ * It reads fly.toml, railway.json/railway.toml, render.yaml, app.json and the
+ * Procfile; asks the platform's CLI for variables (Heroku, Railway) or secret
+ * names (Fly) and dyno sizes (Heroku); drops what Oalo or the old platform
+ * sets, renames DATABASE_URL to EXTERNAL_DATABASE_URL, and says what doesn't
+ * carry over. Values are never printed or written to a file: they go straight
+ * to the app's prod variables. An existing Procfile is never overwritten, and
+ * .oalo/app.json only gains keys it lacks.
+ */
+export async function migrate(flags, rest, opts = {}) {
+  const platform = rest[1];
+  if (!platform || !PLATFORMS[platform]) {
+    return fail(`usage: oalo migrate <${Object.keys(PLATFORMS).join("|")}> [--from-app <name>] [--env-file <file>] [--apply]`, 2);
+  }
+  const dir = opts.cwd || process.cwd();
+  const run = opts.exec || execCli;
+  const connect = opts.channel || ((o) => new OaloChannel(o));
+  const fromApp = typeof flags["from-app"] === "string" ? flags["from-app"] : null;
+
+  let envFile = null;
+  if (typeof flags["env-file"] === "string") {
+    try {
+      envFile = readFileSync(flags["env-file"], "utf8");
+    } catch (e) {
+      return fail(`can't read ${flags["env-file"]}: ${e.code || e.message}`, 2);
+    }
+  }
+
+  const files = readFiles(dir);
+  const remote = flags["no-cli"] ? { notes: [] } : await askPlatform(platform, fromApp, files, run);
+
+  let plan;
+  try {
+    plan = buildPlan(platform, { files, remote, envFile, fromApp });
+  } catch (e) {
+    return fail(e.message, 1);
+  }
+
+  const cfg = resolveConfig(flags, dir);
+  const app = typeof flags.app === "string" ? flags.app : cfg.appId;
+
+  if (!flags.apply) {
+    if (flags.json) return void console.log(JSON.stringify(publicPlan(plan, app), null, 2));
+    printPlan(plan, app, dir);
+    return;
+  }
+
+  // --apply: files first (never overwriting), then the variables.
+  const wrote = [];
+  if (plan.procfile.action === "write" && !existsSync(join(dir, "Procfile"))) {
+    writeFileSync(join(dir, "Procfile"), plan.procfile.text);
+    wrote.push("Procfile");
+  }
+  if (plan.manifest.action === "write" || plan.manifest.action === "merge") {
+    mkdirSync(join(dir, ".oalo"), { recursive: true });
+    writeFileSync(join(dir, ".oalo", "app.json"), plan.manifest.text);
+    wrote.push(".oalo/app.json");
+  }
+
+  let varsResult = null;
+  if (plan.vars.set.length) {
+    if (!app) {
+      varsResult = { skipped: "no app" };
+    } else {
+      const { url, token } = controlPlane(cfg);
+      if (!url || !token) return fail(`setting the variables needs a CLI token.\n\n${HOW_TO_CONNECT}`, 2);
+      try {
+        await requireFeature(url, "env", "oalo migrate");
+      } catch (e) {
+        return fail(e.message, 1);
+      }
+      const ch = connect({ url, token });
+      try {
+        await ch.connect();
+        const r = await ch.call("env:set", {
+          app,
+          env: "prod",
+          vars: plan.vars.set.map(({ name, value }) => ({ name, value })),
+          restart: false,
+        });
+        varsResult = { app: r.app, saved: r.saved.length, relaunch: !!(r.relaunching || r.next_release) };
+      } catch (e) {
+        return fail(`the files are written, but the variables weren't set: ${e.message}`, 1);
+      } finally {
+        ch.close();
+      }
+    }
+  }
+
+  if (flags.json) return void console.log(JSON.stringify({ ...publicPlan(plan, app), wrote, variables: varsResult }, null, 2));
+
+  console.log(`Moving from ${plan.label}.`);
+  if (wrote.length) console.log(`wrote ${wrote.join(" and ")}: review them, then commit`);
+  else console.log(dim("no files to write"));
+  if (varsResult?.saved != null) {
+    console.log(`set ${varsResult.saved} variable${varsResult.saved === 1 ? "" : "s"} on ${varsResult.app} (prod)`);
+    if (varsResult.relaunch) console.log(dim("the live app gets them at its next release"));
+  } else if (varsResult?.skipped) {
+    console.log(`variables not set yet: this folder isn't linked to an Oalo app. After \`oalo deploy --new\`, run \`oalo migrate ${platform} --apply\` again${fromApp ? ` --from-app ${fromApp}` : ""}${flags["env-file"] ? ` --env-file ${flags["env-file"]}` : ""}.`);
+  }
+  printNeeds(plan);
+  printNext(plan, app, platform, true);
+}
+
+// ── reading ───────────────────────────────────────────────────────────
+
+const LOCKFILES = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lock", "bun.lockb", "npm-shrinkwrap.json"];
+
+export function readFiles(dir) {
+  const read = (name) => {
+    try {
+      return readFileSync(join(dir, name), "utf8");
+    } catch {
+      return null;
+    }
+  };
+  return {
+    procfile: read("Procfile"),
+    appJson: read("app.json"),
+    flyToml: read("fly.toml"),
+    railwayJson: read("railway.json"),
+    railwayToml: read("railway.toml"),
+    renderYaml: read("render.yaml"),
+    dockerfile: read("Dockerfile"),
+    aptfile: existsSync(join(dir, "Aptfile")),
+    packageJson: existsSync(join(dir, "package.json")),
+    lockfile: LOCKFILES.some((f) => existsSync(join(dir, f))),
+    oaloAppJson: read(join(".oalo", "app.json")),
+  };
+}
+
+/** What the platform's own CLI can tell: variables, secret names, dyno sizes. */
+async function askPlatform(platform, fromApp, files, run) {
+  const notes = [];
+  const out = { notes, vars: null, secretNames: null, dynos: null };
+  const flyApp = () => {
+    if (fromApp) return fromApp;
+    const m = files.flyToml?.match(/^\s*app\s*=\s*["']([^"']+)["']/m);
+    return m ? m[1] : null;
+  };
+
+  if (platform === "heroku") {
+    const a = fromApp ? ["-a", fromApp] : [];
+    const cfg = await run("heroku", ["config", "--json", ...a]);
+    if (cfg.ok) out.vars = asObject(cfg.stdout);
+    else notes.push(cliNote("heroku", cfg, "config vars", "heroku config --shell"));
+    const ps = await run("heroku", ["ps", "--json", ...a]);
+    if (ps.ok) out.dynos = asArray(ps.stdout).map((d) => ({ type: d.type, size: d.size }));
+  } else if (platform === "railway") {
+    const a = fromApp ? ["--service", fromApp] : [];
+    const r = await run("railway", ["variable", "list", "--json", ...a]);
+    if (r.ok) out.vars = asObject(r.stdout);
+    else notes.push(cliNote("railway", r, "variables", "railway variable list --kv"));
+  } else if (platform === "fly") {
+    const name = flyApp();
+    const a = name ? ["-a", name] : [];
+    let r = await run("fly", ["secrets", "list", "--json", ...a]);
+    if (!r.ok && r.missing) r = await run("flyctl", ["secrets", "list", "--json", ...a]);
+    if (r.ok) out.secretNames = asArray(r.stdout).map((s) => s.Name || s.name).filter(Boolean);
+    else notes.push(cliNote("fly", r, "secret names", "fly secrets list"));
+  }
+  return out;
+}
+
+function cliNote(cli, r, what, manual) {
+  if (r.missing) return `The ${cli} CLI isn't installed here, so its ${what} weren't read. Install it and sign in, or run \`${manual}\` elsewhere, save the values to a .env file and pass --env-file.`;
+  const why = firstLine(r.stderr) || "it failed";
+  return `\`${cli}\` couldn't list the ${what} (${why}). Sign in and link the project, or pass --from-app, or put them in a .env file and pass --env-file.`;
+}
+
+function execCli(cmd, args) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: 30_000, maxBuffer: 8 * 1024 * 1024, env: process.env }, (err, stdout, stderr) => {
+      if (err && err.code === "ENOENT") return resolve({ ok: false, missing: true, stdout: "", stderr: "" });
+      resolve({ ok: !err, missing: false, stdout: String(stdout || ""), stderr: String(stderr || "") });
+    });
+  });
+}
+
+function asObject(text) {
+  try {
+    const j = JSON.parse(text);
+    if (Array.isArray(j)) return Object.fromEntries(j.map((x) => [x.name ?? x.key, x.value]).filter(([k]) => k));
+    return j && typeof j === "object" ? j : {};
+  } catch {
+    return {};
+  }
+}
+
+function asArray(text) {
+  try {
+    const j = JSON.parse(text);
+    return Array.isArray(j) ? j : [];
+  } catch {
+    return [];
+  }
+}
+
+// Only a short reason, and never anything that looks like a URL with a password.
+function firstLine(s) {
+  const line = String(s || "").split(/\r?\n/).map((x) => x.trim()).find(Boolean) || "";
+  return line.replace(/\/\/[^\s/@]+@/g, "//***@").slice(0, 160);
+}
+
+// ── printing ──────────────────────────────────────────────────────────
+
+/** The plan without any values: what --json prints. */
+function publicPlan(plan, app) {
+  return {
+    platform: plan.platform,
+    app: app || null,
+    procfile: { action: plan.procfile.action, lines: plan.procfile.lines.map(([name, command]) => ({ name, command })) },
+    manifest: { action: plan.manifest.action, sizes: plan.manifest.sizes, health: plan.manifest.health },
+    variables: {
+      set: plan.vars.set.map((v) => ({ name: v.name, from: v.from })),
+      renamed: plan.vars.renamed,
+      dropped: plan.vars.dropped,
+      missing: plan.vars.missing,
+    },
+    needs: plan.warnings,
+  };
+}
+
+function printPlan(plan, app, dir) {
+  console.log(`Moving from ${plan.label}. Nothing changes until you add --apply.\n`);
+
+  const pf = plan.procfile;
+  if (pf.action === "keep") console.log(`Procfile        keep yours (${pf.lines.map(([n]) => n).join(", ") || "no lines"})`);
+  else if (pf.action === "write") {
+    console.log("Procfile        write:");
+    for (const [n, c] of pf.lines) console.log(`                  ${n}: ${c}`);
+  } else console.log(`Procfile        none ${dim("(web starts the usual way for its language, or from the Dockerfile)")}`);
+
+  const m = plan.manifest;
+  if (m.action === "write" || m.action === "merge") {
+    const parts = Object.entries(m.sizes).map(([p, s]) => `${p} ${s.size} (${s.from})`);
+    if (m.health) parts.push(`health ${m.health}`);
+    console.log(`.oalo/app.json  ${m.action === "merge" ? "add" : "write"}: ${parts.join(", ")}`);
+  } else {
+    console.log(`.oalo/app.json  ${m.action === "keep" ? "keep yours" : "none"} ${dim("(every process gets small)")}`);
+  }
+
+  const v = plan.vars;
+  console.log("");
+  if (v.set.length) {
+    console.log(`Variables       ${v.set.length} to set on the live app${app ? ` (${app})` : ""}, values not shown:`);
+    console.log(wrap(v.set.map((x) => x.name).join(", "), 18, 0));
+  } else {
+    console.log("Variables       none read");
+  }
+  for (const r of v.renamed) console.log(`                  ${r.to} from ${r.from} ${dim("(on Oalo, DATABASE_URL is your Base's own Postgres)")}`);
+  if (v.dropped.length) console.log(dim(`                  left out: ${v.dropped.map((d) => `${d.name} (${d.why})`).join(", ")}`));
+  if (v.missing.length) {
+    console.log("                  still needed, values not available here:");
+    for (const x of v.missing) console.log(`                    ${x.name}: ${x.why}`);
+  }
+
+  printNeeds(plan);
+  printNext(plan, app, plan.platform, false);
+  if (!existsSync(join(dir, ".git"))) console.log(dim("\nThis folder isn't a git repo: oalo deploy --new sends commits, so run this in the app's repo."));
+}
+
+function printNeeds(plan) {
+  if (!plan.warnings.length) return;
+  console.log("\nNeeds you");
+  for (const w of plan.warnings) console.log(wrap(`- ${w}`, 2, 2));
+}
+
+function printNext(plan, app, platform, applied) {
+  console.log("\nNext");
+  const steps = [];
+  const files = plan.procfile.action === "write" || plan.manifest.action === "write" || plan.manifest.action === "merge";
+  const later = !app && plan.vars.set.length;
+  if (!applied) steps.push(`oalo migrate ${platform} --apply${later ? "   (writes the files; the variables wait until the app exists)" : ""}`);
+  if (files) steps.push('git add Procfile .oalo/app.json && git commit -m "Move to Oalo"');
+  if (!app) steps.push("oalo deploy --new");
+  if (later) steps.push(`oalo migrate ${platform} --apply   (now it sets the variables)`);
+  if (plan.vars.missing.length) steps.push("oalo env set NAME --secret --env prod   (for each one still needed)");
+  steps.push("oalo env set NAME --env dev   (test values for the preview)");
+  steps.push("your data: keep the database and set EXTERNAL_DATABASE_URL, or copy it in with oalo db restore");
+  steps.push("oalo deploy --env prod");
+  steps.push("move the domain: the app's Custom Domain panel in the dashboard");
+  steps.forEach((s, i) => console.log(`  ${i + 1}. ${s}`));
+  console.log(dim(`\nThe whole walk-through: oalo docs migrating-from-${platform}`));
+}
+
+function wrap(text, indent, hang = indent) {
+  const width = Math.max(40, (process.stdout.columns || 100) - 2);
+  const words = text.split(" ");
+  const lines = [];
+  let line = " ".repeat(indent);
+  for (const w of words) {
+    if (line.trim() && line.length + 1 + w.length > width) {
+      lines.push(line);
+      line = " ".repeat(indent + hang) + w;
+    } else line += (line.trim() ? " " : "") + w;
+  }
+  if (line.trim()) lines.push(line);
+  return lines.join("\n");
+}
+
+function fail(message, code) {
+  console.error(message);
+  process.exitCode = code;
+}

package/src/help.js

@@ -245,18 +245,35 @@ export const COMMANDS = [
   },
   {
     name: "db",
-    summary: "All of an env's data as plain SQL (every app's own tables and the Oalo models), to keep a copy or take it anywhere.",
-    usage: ["oalo db dump [--env dev|prod] [--out <file.sql>] [--force]"],
+    summary: "All of an env's data as plain SQL (every app's own tables and the Oalo models), to keep a copy or take it anywhere. Or load an existing Postgres database into an env.",
+    usage: [
+      "oalo db dump [--env dev|prod] [--out <file.sql>] [--force]",
+      "oalo db restore <file> --env dev|prod [--schema <name>] [--check] [--yes]",
+      "oalo db restore --from-env <VAR> --env dev|prod [--schema <name>] [--check] [--yes]",
+    ],
     flags: [
-      { flag: "--env dev|prod", desc: "Which env's data. Default prod." },
+      { flag: "--env dev|prod", desc: "dump: which env's data. Default prod. restore: which env the data goes into, always on the command line." },
       { flag: "--out <file.sql>", desc: "Where to write it. Default <workspace>-<env>-<date>.sql here." },
       { flag: "--force", desc: "Replace the file if it exists." },
+      { flag: "--from-env <VAR>", desc: "restore: copy from a running database instead of a file. VAR is the environment variable that holds its postgres:// or postgresql:// URL. Only its host is ever shown." },
+      { flag: "--schema <name>", desc: "restore: the source schema to load. Default public, or the only one when there's just one." },
+      { flag: "--check", desc: "restore: do everything but the write, and report what would happen. Nothing is written, so it never asks." },
+      { flag: "--yes", desc: "restore: go ahead with prod without asking. Needed for prod when there's no terminal to ask at." },
     ],
     notes: [
       "Workspace admins only: it holds every member's data. Restore it into any Postgres with psql -f.",
       "Your code is in git (oalo deploy --pull); this is the data. Together they are everything you need to run your apps elsewhere.",
+      "restore loads a dump file made by pg_dump (like Heroku's latest.dump), up to 10 GB, or copies from a database URL. Admins only, and one restore at a time per Base.",
+      "The tables land in the env's schema, owned by the app's database login, so its Procfile `release:` migrations can alter them. Your app reads them at DATABASE_URL.",
+      "It's refused if a table name already exists there, and the names are listed. A failed restore leaves the env as it was.",
+      "The URL is never a flag value, since that stays in your shell history. Put it in a variable and pass --from-env VAR.",
+      "Run it with --check first. prod asks before it writes; without a terminal it needs --yes. Stop writes to the old database before the copy: writes made after it starts are lost.",
     ],
-    exits: { 0: "a whole dump was written", 1: "refused, unreachable, or cut off (the partial file is removed)", 2: "bad arguments, the file exists, or no CLI token" },
+    exits: {
+      0: "a whole dump was written, or the restore (or check) passed",
+      1: "refused, unreachable, cut off (a partial dump is removed), or the restore failed or was declined",
+      2: "bad arguments, the file exists or is missing, or no CLI token",
+    },
   },
   {
     name: "metrics",
@@ -560,6 +577,29 @@ export const COMMANDS = [
     ],
     exits: { 0: "deployed", 1: "refused or failed", 2: "bad arguments, no CLI token, or not in a git repo" },
   },
+  {
+    name: "migrate",
+    summary: "Move an app from Heroku, Railway, Render, Fly.io or Primcloud: its Procfile, sizes, health path and variables, worked out from its files and that platform's CLI.",
+    usage: [
+      "oalo migrate <heroku|railway|render|fly|primcloud> [--from-app <name>] [--env-file <file>] [--json]",
+      "oalo migrate <platform> --apply [--app <slug>]",
+    ],
+    flags: [
+      { flag: "--from-app <name>", desc: "The app or service on the old platform (a Heroku or Fly app, a Railway or Render service). Default: what that platform's CLI is linked to here, or fly.toml's app." },
+      { flag: "--env-file <file>", desc: "More variables, from a .env file (NAME=value lines). They win over what the platform's CLI reported. For Primcloud, and for Fly secrets, which can't be read back." },
+      { flag: "--apply", desc: "Write the Procfile and .oalo/app.json (never over an existing Procfile; app.json only gains keys it lacks), and set the variables on the app's prod env. Without it, nothing changes." },
+      { flag: "--no-cli", desc: "Don't run the old platform's CLI; read only the files here and --env-file." },
+      { flag: "--app <slug>", desc: "The Oalo app the variables go to. Default: the app this folder is linked to (oalo deploy --new links it)." },
+      { flag: "--json", desc: "The plan as JSON: names only, never a value." },
+    ],
+    notes: [
+      "Run it in the app's repo. It reads fly.toml, railway.json or railway.toml, render.yaml, app.json and the Procfile, and asks the platform's CLI for variables (heroku, railway), secret names (fly) and dyno sizes (heroku) when it's installed and signed in.",
+      "Variables: PORT and each platform's own (HEROKU_*, RAILWAY_*, RENDER_*, FLY_*) are left out, and DATABASE_URL becomes EXTERNAL_DATABASE_URL, since DATABASE_URL on Oalo is the Base's own Postgres. Values are never printed or written to a file; --apply sends them to prod without restarting the app.",
+      "It says what doesn't carry over: cron jobs, volumes and disks, private addresses (*.railway.internal, *.flycast), extra replicas, build commands, an Aptfile, a VM bigger than large.",
+      "The order: oalo migrate <platform> (read the plan), --apply, commit, oalo deploy --new, oalo migrate <platform> --apply again (now the app exists, it sets the variables), then the data (oalo db restore) and oalo deploy --env prod. `oalo docs migrating-from-<platform>` walks through it.",
+    ],
+    exits: { 0: "the plan was shown, or applied", 1: "a config file couldn't be read, or the variables couldn't be set", 2: "bad arguments, an unknown platform, or no CLI token" },
+  },
   {
     name: "env",
     summary: "An app's environment variables on Oalo (API keys, settings), per env: list, set, unset, rotate-token.",

package/src/index.js

@@ -32,6 +32,7 @@ import { channels } from "./commands/channels.js";
 import { products } from "./commands/products.js";
 import { metrics, dashboards } from "./commands/metrics.js";
 import { db } from "./commands/db.js";
+import { migrate } from "./commands/migrate.js";
 import { overview, commandHelp, helpJson, COMMANDS } from "./help.js";
 import { parse } from "./args.js";
 
@@ -169,6 +170,9 @@ async function dispatch(cmd) {
     case "db":
       await db(flags, rest);
       break;
+    case "migrate":
+      await migrate(flags, rest);
+      break;
     case "secrets":
       await secrets(flags, rest);
       break;