@oalo-ai/cli 0.0.0-stage → 0.1.1

package/src/commands/emit.js

@@ -0,0 +1,124 @@
+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";
+
+/**
+ * `oalo emit <type>`: fire a domain event (form.submitted, order.created, ...)
+ * as if it really happened, to test that a loop's trigger is wired. `oalo run
+ * loop` skips the trigger; this goes through it.
+ *
+ *   oalo emit form.submitted --payload '{"email":"a@b.co"}' [--contact <id>] [--dry-run]
+ *   oalo emit --list
+ *
+ * The loops it fires do real things (email, WhatsApp, invoices), so the server
+ * allows it only for admins and members with Developer access, tags the event
+ * as coming from the CLI and posts it to the team feed. --dry-run lists the
+ * loops that would fire and changes nothing.
+ */
+export async function emit(flags, rest) {
+  const type = rest[1];
+  if (!flags.list && !type) {
+    console.error("usage: oalo emit <event type> [--payload '<json>'] [--contact <id>] [--dry-run]\n       oalo emit --list");
+    process.exitCode = 2;
+    return;
+  }
+
+  let payload = {};
+  if (typeof flags.payload === "string") {
+    try {
+      payload = JSON.parse(flags.payload);
+    } catch (e) {
+      console.error(`--payload must be valid JSON: ${e.message}`);
+      process.exitCode = 2;
+      return;
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+      console.error("--payload must be a JSON object");
+      process.exitCode = 2;
+      return;
+    }
+  }
+
+  const cfg = resolveConfig(flags);
+  const { url, token } = controlPlane(cfg);
+  if (!url || !token) {
+    console.error(`oalo emit needs a CLI token.\n\n${HOW_TO_CONNECT}`);
+    process.exitCode = 2;
+    return;
+  }
+
+  try {
+    await requireFeature(url, "emit", "oalo emit");
+  } catch (e) {
+    console.error(e.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  const ch = new OaloChannel({ url, token });
+  try {
+    await ch.connect();
+
+    if (flags.list) {
+      const { events } = await ch.call("cli_api:event_types", {});
+      if (flags.json) return void console.log(JSON.stringify(events, null, 2));
+      printList(events);
+      return;
+    }
+
+    const params = { type, payload, dry_run: !!flags["dry-run"] };
+    if (typeof flags.contact === "string") params.contact_id = flags.contact;
+    const r = await ch.call("cli_api:emit", params);
+
+    if (flags.json) return void console.log(JSON.stringify(r, null, 2));
+
+    const names = r.loops.map((l) => l.name);
+    if (r.dry_run) {
+      console.log(
+        names.length
+          ? `${type} would fire ${names.length} loop${names.length > 1 ? "s" : ""}: ${names.join(", ")}`
+          : `no enabled loop listens for ${type}${Object.keys(payload).length ? " with this payload" : ""}. Nothing would fire.`,
+      );
+      console.log(dim("dry run: nothing was emitted"));
+    } else {
+      console.log(`emitted ${type} (event ${r.event_id}), tagged as a test from the CLI`);
+      console.log(
+        names.length
+          ? `firing ${names.length} loop${names.length > 1 ? "s" : ""}: ${names.join(", ")}`
+          : "no enabled loop listens for it, so nothing fired",
+      );
+      if (names.length) console.log(dim("watch the runs with: oalo tail"));
+    }
+  } catch (e) {
+    console.error(`emit failed: ${e.message}`);
+    process.exitCode = 1;
+  } finally {
+    ch.close();
+  }
+}
+
+function printList(events) {
+  const byCat = new Map();
+  for (const e of events) {
+    if (!byCat.has(e.category)) byCat.set(e.category, []);
+    byCat.get(e.category).push(e);
+  }
+  const w = Math.max(...events.map((e) => e.event.length));
+  for (const [cat, list] of byCat) {
+    console.log(`\n${cat}`);
+    for (const e of list) {
+      const loops = e.loops.length ? `  -> ${e.loops.join(", ")}` : "";
+      console.log(`  ${e.event.padEnd(w)}  ${firstSentence(e.description)}${loops}`);
+      if (e.payload_fields.length) console.log(dim(`  ${" ".repeat(w)}  payload: ${e.payload_fields.join(", ")}`));
+    }
+  }
+  console.log(dim("\n-> loops in this workspace that listen for the event now"));
+}
+
+// The catalog's descriptions run to a paragraph; the list shows the first
+// sentence and --json has the rest.
+function firstSentence(text = "") {
+  const m = text.match(/^.*?[.!?](\s|$)/);
+  return (m ? m[0] : text).trim();
+}

package/src/commands/env.js

@@ -0,0 +1,223 @@
+import { readFileSync } from "node:fs";
+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 { parseDotenv, parseAssignment } from "../envfile.js";
+
+/**
+ * `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]
+ *   oalo env set NAME --secret                             asks for the value, hidden
+ *   oalo env set --file .env.production --env prod         every line of a .env file
+ *   oalo env unset NAME [NAME ...]
+ *   oalo env rotate-token [--env dev|prod]                 a new OALO_SYNC_TOKEN
+ *
+ * A variable is secret unless its name starts with a browser prefix (VITE_,
+ * EXPO_PUBLIC_, ...) or it's set with --public. Secret values can't be read
+ * back, and only server apps get them: a static app's bundle would show them to
+ * every visitor. A dev change restarts the preview; a prod change relaunches
+ * 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
+ * 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.
+ */
+export async function env(flags, rest, opts = {}) {
+  // Tests pass a stub channel and value reader; real runs use neither.
+  const connect = opts.channel || ((o) => new OaloChannel(o));
+  const read = opts.readValue || readValue;
+
+  const sub = rest[1] || "list";
+  const cfg = resolveConfig(flags);
+  const { url, token } = controlPlane(cfg);
+  if (!url || !token) return fail(`oalo env needs a CLI token.\n\n${HOW_TO_CONNECT}`, 2);
+
+  const app = typeof flags.app === "string" ? flags.app : cfg.appId;
+  if (!app) return fail("which app? Pass --app <slug> (`oalo apps` lists them), or save it with `oalo link --app <slug>`.", 2);
+
+  const target = flags.env || cfg.env || "dev";
+  if (!["dev", "prod"].includes(target)) return fail(`--env must be dev or prod (got ${target})`, 2);
+  if (sub !== "list" && target === "prod" && flags.env !== "prod") {
+    return fail("this project is linked to prod. Changing the live app's variables needs --env prod on the command line.", 2);
+  }
+  if (flags.secret && flags.public) return fail("pick one of --secret and --public", 2);
+
+  let vars;
+  if (sub === "set") {
+    try {
+      vars = await collect(flags, rest.slice(2), read);
+    } catch (e) {
+      return fail(e.message, 2);
+    }
+    if (!vars) return;
+  } else if (sub === "unset") {
+    if (rest.length < 3) return fail("usage: oalo env unset NAME [NAME ...]", 2);
+  } else if (sub !== "list" && sub !== "rotate-token") {
+    return fail(`unknown env command: ${sub}. Use list, set, unset or rotate-token.`, 2);
+  }
+
+  try {
+    await requireFeature(url, "env", "oalo env");
+  } catch (e) {
+    return fail(e.message, 1);
+  }
+
+  const ch = connect({ url, token });
+  try {
+    await ch.connect();
+    if (sub === "list") return await list(ch, app, target, flags);
+    if (sub === "set") return await set(ch, app, target, vars, flags);
+    if (sub === "rotate-token") return await rotateToken(ch, app, target, flags);
+    return await unset(ch, app, target, rest.slice(2), flags);
+  } catch (e) {
+    return fail(e.message, 1);
+  } finally {
+    ch.close();
+  }
+}
+
+async function list(ch, app, env, flags) {
+  const r = await ch.call("env:list", { app, env });
+  if (flags.json) return void console.log(JSON.stringify(r, null, 2));
+
+  const vars = r.vars || [];
+  console.log(dim(`${r.app} (${r.env}), ${vars.length} variable${vars.length === 1 ? "" : "s"}`));
+  const width = Math.max(0, ...vars.map((v) => v.name.length));
+  for (const v of vars) {
+    const when = v.updated_at ? `, set ${v.updated_at.slice(0, 10)}` : "";
+    if (v.secret) {
+      const unused = r.static ? ", not used: static apps only get public variables" : "";
+      console.log(`  ${v.name.padEnd(width)}  ${dim(`secret${when}${unused}`)}`);
+    } else {
+      console.log(`  ${v.name.padEnd(width)}  ${v.value}`);
+    }
+  }
+  if (!vars.length) console.log(dim(`  none yet: oalo env set NAME=value --app ${r.app}${env === "prod" ? " --env prod" : ""}`));
+}
+
+async function set(ch, app, env, vars, flags) {
+  const params = { app, env, vars: vars.map(({ name, value, secret }) => ({ name, value, ...(secret === undefined ? {} : { secret }) })) };
+  if (flags["no-restart"]) params.restart = false;
+
+  const r = await ch.call("env:set", params);
+  if (flags.json) return void console.log(JSON.stringify(r, null, 2));
+
+  const names = r.saved.map((v) => `${v.name}${v.secret ? " (secret)" : ""}`);
+  console.log(`set ${names.join(", ")} on ${r.app} (${r.env})`);
+  report(r);
+
+  const secrets = r.saved.filter((v) => v.secret);
+  if (r.static && secrets.length) {
+    console.error(
+      dim(`${r.app} is a static app, so ${secrets.map((v) => v.name).join(", ")} won't reach it: what a static app's build sees ends up in the browser. Use a public name (VITE_, EXPO_PUBLIC_) or --public for values that are safe to show, and keep keys in a server app.`),
+    );
+  }
+  const typed = secrets.filter((v) => vars.find((x) => x.name === v.name)?.fromArgv);
+  if (typed.length) {
+    console.error(dim(`tip: a value typed on the command line stays in your shell history. \`oalo env set ${typed[0].name} --secret\` asks for it instead.`));
+  }
+}
+
+async function unset(ch, app, env, names, flags) {
+  const r = await ch.call("env:unset", { app, env, names, ...(flags["no-restart"] ? { restart: false } : {}) });
+  if (flags.json) return void console.log(JSON.stringify(r, null, 2));
+
+  if (r.removed.length) console.log(`removed ${r.removed.join(", ")} from ${r.app} (${r.env})`);
+  if (r.missing.length) console.log(dim(`not set, skipped: ${r.missing.join(", ")}`));
+  if (r.removed.length) report(r);
+}
+
+async function rotateToken(ch, app, env, flags) {
+  const r = await ch.call("env:rotate_token", { app, env });
+  if (flags.json) return void console.log(JSON.stringify(r, null, 2));
+
+  console.log(`new OALO_SYNC_TOKEN for ${r.app} (${r.env}); the old one no longer works`);
+  if (r.restarting) console.log(dim("restarting the preview so it picks it up"));
+  else if (r.relaunching) console.log(dim(`relaunching the live app at ${r.relaunching.slice(0, 7)} so it picks it up (a build; follow it with oalo logs --app ${r.app} --env prod)`));
+  else if (r.env === "prod") console.log(dim(`${r.app} isn't live yet: its first release gets the new token`));
+  else console.log(dim("the preview picks it up the next time it starts"));
+}
+
+function report(r) {
+  if (r.restarting) console.log(dim("restarting the preview so it picks them up"));
+  else if (r.relaunching) console.log(dim(`relaunching the live app at ${r.relaunching.slice(0, 7)}, the commit it already runs, so it picks them up (a build; follow it with oalo logs --app ${r.app} --env prod)`));
+  else if (r.next_release) console.log(dim("the live app gets this when it next relaunches: your next `oalo env` change without --no-restart, or a live deploy"));
+  else if (r.env === "prod") console.log(dim(`${r.app} isn't live yet: its first release gets this`));
+  else if (r.env === "dev") console.log(dim("the preview picks this up the next time it starts"));
+}
+
+// ── what to set ─────────────────────────────────────────────────────────
+
+async function collect(flags, args, read) {
+  const secret = flags.secret ? true : flags.public ? false : undefined;
+  const vars = [];
+
+  if (typeof flags.file === "string") {
+    let text;
+    try {
+      text = readFileSync(flags.file, "utf8");
+    } catch (e) {
+      throw new Error(`can't read ${flags.file}: ${e.code || e.message}`);
+    }
+    for (const v of parseDotenv(text)) vars.push({ ...v, secret });
+    if (!vars.length) throw new Error(`${flags.file} has no NAME=value lines`);
+  }
+
+  for (const arg of args) {
+    const a = parseAssignment(arg);
+    if (a) {
+      vars.push({ ...a, secret, fromArgv: true });
+    } else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(arg)) {
+      vars.push({ name: arg, value: await read(arg), secret });
+    } else {
+      throw new Error(`${arg} isn't NAME=value or a NAME`);
+    }
+  }
+
+  if (!vars.length) throw new Error("usage: oalo env set NAME=value [...], oalo env set NAME --secret, or oalo env set --file .env");
+  return vars;
+}
+
+/** A value from stdin when piped, otherwise a prompt that doesn't echo. */
+export async function readValue(name) {
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    let text = "";
+    for await (const chunk of stdin) text += chunk;
+    return text.replace(/\r?\n$/, "");
+  }
+
+  process.stderr.write(`${name} (hidden): `);
+  return new Promise((resolve, reject) => {
+    let value = "";
+    stdin.setRawMode(true);
+    stdin.setEncoding("utf8");
+    stdin.resume();
+    const done = (fn) => {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      process.stderr.write("\n");
+      fn();
+    };
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        if (ch === "\r" || ch === "\n") return done(() => resolve(value));
+        if (ch === "\u0003") return done(() => reject(new Error("cancelled")));
+        if (ch === "\u007f" || ch === "\b") value = value.slice(0, -1);
+        else value += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+function fail(message, code) {
+  console.error(message);
+  process.exitCode = code;
+}