@oalo-ai/cli 0.1.0 → 0.2.0

package/src/commands/deploy.js

@@ -16,7 +16,7 @@ import { readValue } from "./env.js";
  *   oalo deploy --new [<name>]                 a new app from this repo, its history kept
  *   oalo deploy --new [<name>] --from <url>    a new app from a Git URL, cloned by the Base
  *   oalo deploy --app <slug> --env prod        build and swap the live release
- *   oalo deploy --app <slug> --pull            fetch the app's code from OALO as oalo/<slug>
+ *   oalo deploy --app <slug> --pull            fetch the app's code from Oalo as oalo/<slug>
  *   oalo deploy --app <slug> --replace         make this branch the app's code (old code is tagged)
  *   oalo deploy --app <slug> --history         the live releases it has had
  *   oalo deploy --app <slug> --rollback [--to <sha>]   make an earlier release live again
@@ -118,7 +118,7 @@ export async function deploy(flags) {
   if (result.error) {
     const e = result.error;
     console.error(`deploy failed: ${e.message}`);
-    for (const c of e.box_only || []) console.error(dim(`  on OALO only: ${c}`));
+    for (const c of e.box_only || []) console.error(dim(`  on Oalo only: ${c}`));
     process.exitCode = 1;
     return;
   }
@@ -323,7 +323,7 @@ async function pull(url, token, app, root) {
     const ref = `refs/remotes/oalo/${app}`;
     git(["fetch", "--quiet", "--no-tags", file, `+HEAD:${ref}`], root);
     const sha = git(["rev-parse", ref], root);
-    console.log(`fetched ${app} as it is on OALO (${sha.slice(0, 8)}) into oalo/${app}.`);
+    console.log(`fetched ${app} as it is on Oalo (${sha.slice(0, 8)}) into oalo/${app}.`);
     console.log(dim(`Merge it, then deploy again:\n  git merge oalo/${app}\n  oalo deploy --app ${app}`));
   } finally {
     rmSync(dir, { recursive: true, force: true });
@@ -381,7 +381,7 @@ function fail(message, code) {
  * `--history` lists the live releases; `--rollback` launches the one before the
  * current release (or `--to <sha>`). A rollback builds and checks that commit
  * like any live deploy, so a failing one leaves the current release live. It
- * doesn't touch the app's code on OALO: the next deploy carries on from there.
+ * doesn't touch the app's code on Oalo: the next deploy carries on from there.
  */
 async function releases(url, token, app, flags, opts = {}) {
   const { OaloChannel } = await import("../channel.js");

package/src/commands/env.js

@@ -6,7 +6,7 @@ import { dim } from "../events.js";
 import { parseDotenv, parseAssignment } from "../envfile.js";
 
 /**
- * `oalo env`: an app's environment variables on OALO, per env.
+ * `oalo env`: an app's environment variables on Oalo, per env.
  *
  *   oalo env [--app <slug>] [--env dev|prod] [--json]      list them
  *   oalo env set NAME=value [NAME=value ...] [--secret | --public]
@@ -22,7 +22,7 @@ import { parseDotenv, parseAssignment } from "../envfile.js";
  * the live app at the commit it already runs (no new code), unless
  * --no-restart, to batch several.
  *
- * A server app also gets OALO_URL and OALO_SYNC_TOKEN from OALO itself, a
+ * A server app also gets OALO_URL and OALO_SYNC_TOKEN from Oalo itself, a
  * token for its own env's data. `rotate-token` replaces it: the old one stops
  * working at once, and the preview restarts, or the live app's current commit
  * is relaunched.

package/src/commands/link.js

@@ -98,15 +98,15 @@ export async function link(flags) {
   console.log(`  token    ${credPath}   (never committed)`);
   if (addedRule) console.log(`\n  added .oalo/credentials* to .gitignore`);
 
-  // The coding agent in this project learns OALO from the skill, the one that
+  // The coding agent in this project learns Oalo from the skill, the one that
   // matches this CLI. --no-skill leaves the project alone.
   if (!flags["no-skill"]) {
     try {
       const had = installedSkillVersion();
       const r = installSkill();
-      console.log(`\n  ${had ? "refreshed" : "installed"} the OALO skill for coding agents: ${r.path}${r.agents ? ` (and AGENTS.md)` : ""}`);
+      console.log(`\n  ${had ? "refreshed" : "installed"} the Oalo skill for coding agents: ${r.path}${r.agents ? ` (and AGENTS.md)` : ""}`);
     } catch (e) {
-      console.error(`\n  couldn't install the OALO skill (${e.message}); \`oalo skill\` tries again`);
+      console.error(`\n  couldn't install the Oalo skill (${e.message}); \`oalo skill\` tries again`);
     }
   }
   // A Flutter app from Oalo's template takes Dart, not TypeScript.

package/src/commands/logs.js

@@ -10,7 +10,7 @@ import { dim } from "../events.js";
  *   oalo logs [--app <slug>] [--env dev|prod] [--process web|<worker>] [--limit N] [--follow] [--json]
  *
  * The workspace keeps the last 2,000 lines of each env in memory, so a restart
- * of the workspace empties them. `oalo` lines are OALO's own notes: starts,
+ * of the workspace empties them. `oalo` lines are Oalo's own notes: starts,
  * exits and their status.
  */
 export async function logs(flags, rest, opts = {}) {

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/commands/secrets.js

@@ -4,7 +4,7 @@ import { requireFeature } from "../server.js";
 import { dim } from "../events.js";
 
 /**
- * `oalo secrets`: keys and tokens OALO found committed to an app's code (on
+ * `oalo secrets`: keys and tokens Oalo found committed to an app's code (on
  * import, and in each push or deploy's new commits). Only where each one is
  * and what it looks like: no value is ever kept.
  *

package/src/commands/skill.js

@@ -7,7 +7,7 @@ import { CLI_VERSION } from "../server.js";
 import { dim } from "../events.js";
 
 /**
- * `oalo skill`: teach the coding agent in this project how to work on OALO.
+ * `oalo skill`: teach the coding agent in this project how to work on Oalo.
  *
  *   oalo skill            install .claude/skills/oalo/SKILL.md (Claude Code loads it)
  *   oalo skill --agents   also add the same rules to AGENTS.md, for other agents
@@ -124,9 +124,9 @@ export function skillNotice(cwd = process.cwd()) {
   } catch {
     /* a read-only home: say it every time rather than never */
   }
-  if (sameVersion) return "This project's OALO skill (.claude/skills/oalo/SKILL.md) is older than the one this CLI carries. Run `oalo skill` to update it.";
+  if (sameVersion) return "This project's Oalo skill (.claude/skills/oalo/SKILL.md) is older than the one this CLI carries. Run `oalo skill` to update it.";
   const from = installed === "old" ? "an older CLI" : `CLI ${installed}`;
-  return `This project's OALO skill (.claude/skills/oalo/SKILL.md) is from ${from}; you have ${CLI_VERSION}. Run \`oalo skill\` to update it.`;
+  return `This project's Oalo skill (.claude/skills/oalo/SKILL.md) is from ${from}; you have ${CLI_VERSION}. Run \`oalo skill\` to update it.`;
 }
 
 export async function skill(flags) {
@@ -137,6 +137,6 @@ export async function skill(flags) {
 
   const r = installSkill(process.cwd(), { agents: !!flags.agents });
   console.log(`installed ${r.path}`);
-  if (r.agents) console.log(`${r.agents} the OALO section in AGENTS.md`);
+  if (r.agents) console.log(`${r.agents} the Oalo section in AGENTS.md`);
   console.log(dim(`From CLI ${CLI_VERSION}. Run \`oalo skill\` again after updating the CLI.`));
 }

package/src/commands/typegen.js

@@ -109,7 +109,7 @@ function renderFields(name, fields) {
 }
 
 // The workflows an app can call: their types, and `runWorkflow` to call one
-// from the app's server with the token OALO gives it.
+// from the app's server with the token Oalo gives it.
 function renderWorkflows(workflows) {
   const list = [...workflows].sort((a, b) => a.name.localeCompare(b.name));
   const type = (w) => pascal(w.name);
@@ -172,7 +172,7 @@ function renderServerHelpers() {
   return [
     ``,
     `// ── Server-side helpers ───────────────────────────────────────────────────`,
-    `// They use the OALO_URL and OALO_SYNC_TOKEN OALO gives a server app. Never`,
+    `// They use the OALO_URL and OALO_SYNC_TOKEN Oalo gives a server app. Never`,
     `// call them from a browser: the token must stay on the server.`,
     ``,
     `export interface OaloServerOptions {`,
@@ -186,7 +186,7 @@ function renderServerHelpers() {
     `async function oaloFetch(path: string, init: RequestInit, opts: OaloServerOptions): Promise<unknown> {`,
     `  const url = opts.url ?? oaloEnv("OALO_URL");`,
     `  const token = opts.token ?? oaloEnv("OALO_SYNC_TOKEN");`,
-    `  if (!url || !token) throw new Error("OALO_URL and OALO_SYNC_TOKEN are not set: call OALO from the app's server");`,
+    `  if (!url || !token) throw new Error("OALO_URL and OALO_SYNC_TOKEN are not set: call Oalo from the app's server");`,
     `  const res = await fetch(url.replace(/\\/$/, "") + path, { ...init, headers: { Authorization: \`Bearer \${token}\`, "Content-Type": "application/json" } });`,
     `  const body = (await res.json().catch(() => null)) as { error?: string | { message?: string } } | null;`,
     `  const message = typeof body?.error === "string" ? body.error : body?.error?.message;`,
@@ -263,9 +263,9 @@ function renderServerHelpers() {
     `}`,
     ``,
     `/**`,
-    ` * Check a request to a tool endpoint came from OALO, and for which user. Pass the`,
+    ` * Check a request to a tool endpoint came from Oalo, and for which user. Pass the`,
     ` * method, the path with its query as received, the headers and the RAW body (before`,
-    ` * JSON parsing). Throws when it isn't OALO's, or is over 5 minutes old.`,
+    ` * JSON parsing). Throws when it isn't Oalo's, or is over 5 minutes old.`,
     ` */`,
     `export async function verifyOaloToolCall(`,
     `  req: { method: string; path: string; headers: Headers | Record<string, string | string[] | undefined>; body: string },`,
@@ -280,8 +280,8 @@ function renderServerHelpers() {
     `  const ts = header("x-oalo-timestamp");`,
     `  const sig = header("x-oalo-signature");`,
     `  const user = header("x-oalo-user") ?? "";`,
-    `  if (!ts || !sig || !sig.startsWith("v1=")) throw new Error("not an OALO tool call");`,
-    `  if (!(Math.abs(Date.now() / 1000 - Number(ts)) <= (opts.maxAgeSeconds ?? 300))) throw new Error("the OALO tool call is too old");`,
+    `  if (!ts || !sig || !sig.startsWith("v1=")) throw new Error("not an Oalo tool call");`,
+    `  if (!(Math.abs(Date.now() / 1000 - Number(ts)) <= (opts.maxAgeSeconds ?? 300))) throw new Error("the Oalo tool call is too old");`,
     `  const enc = new TextEncoder();`,
     `  const key = await crypto.subtle.importKey("raw", enc.encode(token), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);`,
     `  const mac = new Uint8Array(await crypto.subtle.sign("HMAC", key, enc.encode([ts, req.method.toUpperCase(), req.path, user, req.body].join("\\n"))));`,
@@ -289,7 +289,7 @@ function renderServerHelpers() {
     `  const got = sig.slice(3);`,
     `  let diff = want.length ^ got.length;`,
     `  for (let i = 0; i < want.length; i++) diff |= want.charCodeAt(i) ^ (got.charCodeAt(i) || 0);`,
-    `  if (diff !== 0) throw new Error("the OALO signature doesn't match");`,
+    `  if (diff !== 0) throw new Error("the Oalo signature doesn't match");`,
     `  return { tool: header("x-oalo-tool") ?? "", bot: header("x-oalo-bot") ?? "", conversation: header("x-oalo-conversation") || null, user: user || null };`,
     `}`,
     ``,

package/src/commands/whoami.js

@@ -34,7 +34,7 @@ export async function whoami(flags) {
   } catch (e) {
     out.problems.push(
       e.code === "unknown_event"
-        ? `${url} runs an older OALO, so it can't say who you are. Your CLI token does work.`
+        ? `${url} runs an older Oalo, so it can't say who you are. Your CLI token does work.`
         : `CLI token: ${e.message}`,
     );
   } finally {

package/src/config.js

@@ -140,7 +140,7 @@ export function ensureGitignored(cwd = process.cwd()) {
   const rule = ".oalo/credentials*";
   const current = existsSync(gi) ? readFileSync(gi, "utf8") : "";
   if (current.includes(rule)) return false;
-  appendFileSync(gi, `${current.endsWith("\n") || !current ? "" : "\n"}\n# OALO — never commit credentials\n${rule}\n`);
+  appendFileSync(gi, `${current.endsWith("\n") || !current ? "" : "\n"}\n# Oalo — never commit credentials\n${rule}\n`);
   return true;
 }