@oalo-ai/cli 0.0.0-stage → 0.1.0

package/src/commands/graphs.js

@@ -0,0 +1,570 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { openWorkspace, printFindings } from "../workspace.js";
+import {
+  flowFile,
+  loopFile,
+  toolFile,
+  toolPaths,
+  writeToolFiles,
+  flowPath,
+  loopPath,
+  catalogPath,
+  readGraphFile,
+  writeGraphFile,
+  removeFile,
+  listGraphFiles,
+  locallyModified,
+  standing,
+  rel,
+  cleanTrigger,
+  triggerKey,
+} from "../graphfiles.js";
+import { dim } from "../events.js";
+
+/**
+ * `oalo pull` / `push` / `status` / `lint`: edit chat flows and loops as files.
+ *
+ * The round trip an agent (or a person) runs:
+ *
+ *   oalo pull            fetch every flow and loop into .oalo/, plus the node catalogs
+ *   (edit .oalo/flows/<bot>/<flow>.json or .oalo/loops/<loop>.json)
+ *   oalo lint            check the drafts; nothing is saved
+ *   oalo push            lint, then save with the version you pulled and strict on
+ *   oalo status          what changed, locally and on the server
+ *
+ * Safety: push sends the pulled `version` as `base_version`, so a save based on
+ * an older copy is refused (`conflict`) instead of overwriting someone's edit;
+ * and it saves with `strict`, so a graph with error-level lint findings is
+ * refused. `--force` drops the version guard, `--no-strict` the lint gate.
+ * Pull never overwrites a file you have edited unless you pass --force.
+ */
+
+// ---- server calls -------------------------------------------------------
+
+const listBots = async (ch) => (await ch.call("chat:bots:list", {}))?.bots ?? [];
+const listFlows = async (ch, botId) => (await ch.call("chat:bots:flows:list", { bot_id: botId }))?.flows ?? [];
+const listLoops = async (ch) => (await ch.call("loops:list_for_org", {}))?.entries ?? [];
+
+async function getFlow(ch, id) {
+  try {
+    return (await ch.call("chat:bots:flows:get", { id }))?.flow ?? null;
+  } catch (e) {
+    if (e.code === "not_found") return null;
+    throw e;
+  }
+}
+
+async function getLoop(ch, name, appId) {
+  try {
+    const params = appId ? { name, app_id: appId } : { name };
+    return (await ch.call("loops:get", params))?.entry ?? null;
+  } catch (e) {
+    if (e.code === "not_found" || /no loop named/.test(e.message)) return null;
+    throw e;
+  }
+}
+
+// An org loop's triggers. `undefined` for an app-pinned loop (triggers are
+// org-level) or a workspace too old to list them, so the file leaves them out.
+async function listTriggers(ch, name, appId) {
+  if (appId) return undefined;
+  try {
+    return (await ch.call("loops:triggers:list", { name }))?.triggers ?? [];
+  } catch {
+    return undefined;
+  }
+}
+
+const listTools = async (ch) => (await ch.call("fn:list_org", {}))?.tools ?? [];
+
+// fn:source, with the source hash as the version (tools have no version number).
+async function getTool(ch, id) {
+  try {
+    const t = await ch.call("fn:source", { tool_id: id });
+    return t ? { ...t, version: t.source_hash } : null;
+  } catch (e) {
+    if (/unknown function/.test(e.message)) return null;
+    throw e;
+  }
+}
+
+const remoteOf = (ch, file) =>
+  file.kind === "flow"
+    ? file.id
+      ? getFlow(ch, file.id)
+      : null
+    : file.kind === "loop"
+      ? getLoop(ch, file.name, file.app_id)
+      : file.id
+        ? getTool(ch, file.id)
+        : null;
+
+async function lintFile(ch, file) {
+  // A tool's code is checked by compiling it, which happens on push.
+  if (file.kind === "tool") return [];
+  if (file.kind === "flow") {
+    return (await ch.call("chat:flows:lint", { graph: file.flow.graph ?? {}, bot_id: file.bot }))?.findings ?? [];
+  }
+  const l = file.loop;
+  const params = { name: file.name, nodes: l.nodes ?? [], edges: l.edges ?? [] };
+  if (l.entry) params.entry = l.entry;
+  return (await ch.call("loops:lint", params))?.findings ?? [];
+}
+
+async function sameNamedRemote(ch, file) {
+  if (file.kind === "loop") return getLoop(ch, file.name, file.app_id);
+  if (file.kind === "tool") {
+    const hit = (await listTools(ch)).find((t) => t.name === file.name);
+    return hit ? getTool(ch, hit.id) : null;
+  }
+  if (file.id) return getFlow(ch, file.id);
+  return (await listFlows(ch, file.bot)).find((f) => f.name === file.flow.name) ?? null;
+}
+
+// ---- helpers --------------------------------------------------------------
+
+function botKey(bots, flow) {
+  const bot = bots.find((b) => b.id === flow.bot_id);
+  return bot?.public_bot_id || String(flow.bot_id);
+}
+
+/** Resolve the files a command acts on: the ones named, or every file. */
+function targetFiles(rest) {
+  const named = rest.slice(1);
+  if (named.length === 0) return listGraphFiles();
+  return named.map((p) => resolvePath(p));
+}
+
+function load(path) {
+  try {
+    return { file: readGraphFile(path) };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/** Write a freshly fetched remote copy, refusing to clobber local edits. */
+function writeFetched(path, next, force, report) {
+  if (existsSync(path) && !force) {
+    const { file } = load(path);
+    if (file && locallyModified(file)) {
+      report.kept.push(rel(path));
+      return;
+    }
+  }
+  writeGraphFile(path, next);
+  report.written.push(rel(path));
+}
+
+// ---- pull ------------------------------------------------------------------
+
+export async function pull(flags, rest) {
+  const what = rest[1] || "all";
+  if (!["all", "flows", "loops", "tools"].includes(what)) {
+    console.error("usage: oalo pull [flows|loops|tools] [--bot <id>] [--name <name>] [--force]");
+    process.exitCode = 2;
+    return;
+  }
+
+  const ws = await openWorkspace(flags, "pull").catch((e) => (console.error(`pull failed: ${e.message}`), null));
+  if (!ws) return void (process.exitCode = process.exitCode || 2);
+  const { ch } = ws;
+  const report = { written: [], kept: [] };
+
+  try {
+    // The node contracts, so a local agent can read them without a server call.
+    for (const surface of ["flow", "loop"]) {
+      const event = surface === "flow" ? "chat:flows:node_catalog" : "loops:node_catalog";
+      const catalog = (await ch.call(event, {}))?.catalog;
+      if (catalog) writeGraphFile(catalogPath(surface), catalog);
+    }
+
+    if (what === "all" || what === "flows") {
+      const bots = await listBots(ch);
+      const chosen = flags.bot
+        ? bots.filter((b) => String(b.id) === String(flags.bot) || b.public_bot_id === flags.bot)
+        : bots;
+
+      if (flags.bot && chosen.length === 0) {
+        console.error(`no bot ${flags.bot} in this workspace`);
+        process.exitCode = 1;
+        return;
+      }
+
+      for (const bot of chosen) {
+        for (const f of await listFlows(ch, bot.id)) {
+          if (flags.name && f.name !== flags.name) continue;
+          const key = botKey(bots, f);
+          writeFetched(flowPath(key, f.name), flowFile(f, key), flags.force, report);
+        }
+      }
+    }
+
+    if (what === "all" || what === "loops") {
+      for (const l of await listLoops(ch)) {
+        if (flags.name && l.name !== flags.name) continue;
+        writeFetched(loopPath(l.name, l.app_id), loopFile(l, await listTriggers(ch, l.name, l.app_id)), flags.force, report);
+      }
+    }
+
+    if (what === "all" || what === "tools") {
+      for (const t of await listTools(ch)) {
+        // Only code tools can be edited and pushed back; others (webhooks,
+        // built-ins, Elixir actions) are configured in the dashboard.
+        if (!["wasm", null, undefined].includes(t.transport)) continue;
+        if (flags.name && t.name !== flags.name) continue;
+        const remote = await getTool(ch, t.id);
+        if (!remote) continue;
+        const paths = toolPaths(t.name);
+        if (existsSync(paths.meta) && !flags.force) {
+          const { file } = load(paths.meta);
+          if (file && locallyModified(file)) {
+            report.kept.push(rel(paths.meta));
+            continue;
+          }
+        }
+        writeToolFiles(t.name, toolFile(remote));
+        report.written.push(rel(paths.meta));
+      }
+    }
+
+    for (const p of report.written) console.log(`pulled  ${p}`);
+    for (const p of report.kept) console.log(`kept    ${p} ${dim("(edited locally; push it, or pull --force to discard)")}`);
+    console.error(dim(`${report.written.length} written, ${report.kept.length} kept. Node catalogs in .oalo/catalog/.`));
+  } catch (e) {
+    console.error(`pull failed: ${e.message}`);
+    process.exitCode = 1;
+  } finally {
+    ch.close();
+  }
+}
+
+// ---- status ----------------------------------------------------------------
+
+export async function status(flags, rest) {
+  const paths = targetFiles(rest);
+  if (paths.length === 0) {
+    console.error("no flow or loop files under .oalo/. Run `oalo pull` first.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const ws = await openWorkspace(flags, "status").catch((e) => (console.error(`status failed: ${e.message}`), null));
+  if (!ws) return void (process.exitCode = process.exitCode || 2);
+  const { ch } = ws;
+  const rows = [];
+
+  try {
+    for (const path of paths) {
+      const { file, error } = load(path);
+      if (error) {
+        rows.push({ path: rel(path), state: "invalid", note: error });
+        continue;
+      }
+      let remote;
+      try {
+        remote = await remoteOf(ch, file);
+      } catch (e) {
+        rows.push({ path: rel(path), state: "error", note: e.message });
+        continue;
+      }
+      const state = standing(file, remote);
+      const note =
+        state === "behind" || state === "conflict"
+          ? `server at v${remote?.version}, file based on v${file.version}`
+          : state === "gone"
+            ? "deleted on the server"
+            : "";
+      rows.push({ path: rel(path), state, note });
+    }
+
+    if (flags.json) {
+      console.log(JSON.stringify(rows, null, 2));
+    } else {
+      for (const r of rows) console.log(`${r.state.padEnd(9)} ${r.path}${r.note ? dim(`  ${r.note}`) : ""}`);
+    }
+    if (rows.some((r) => ["conflict", "invalid", "error"].includes(r.state))) process.exitCode = 1;
+  } catch (e) {
+    console.error(`status failed: ${e.message}`);
+    process.exitCode = 1;
+  } finally {
+    ch.close();
+  }
+}
+
+// ---- lint ------------------------------------------------------------------
+
+export async function lint(flags, rest) {
+  const paths = targetFiles(rest);
+  if (paths.length === 0) {
+    console.error("no flow or loop files under .oalo/. Run `oalo pull` first, or name a file.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const ws = await openWorkspace(flags, "lint").catch((e) => (console.error(`lint failed: ${e.message}`), null));
+  if (!ws) return void (process.exitCode = process.exitCode || 2);
+  const { ch } = ws;
+  let errors = 0;
+
+  try {
+    for (const path of paths) {
+      const { file, error } = load(path);
+      if (error) {
+        console.log(`invalid  ${rel(path)}: ${error}`);
+        errors++;
+        continue;
+      }
+      const findings = await lintFile(ch, file);
+      if (flags.json) {
+        console.log(JSON.stringify({ path: rel(path), findings }));
+        errors += findings.filter((f) => f.severity === "error").length;
+        continue;
+      }
+      console.log(`${rel(path)}`);
+      const c = printFindings(findings, { verbose: flags.verbose });
+      if (c.errors + c.warnings === 0) console.log("  no errors or warnings");
+      errors += c.errors;
+    }
+    if (errors > 0) process.exitCode = 1;
+  } catch (e) {
+    console.error(`lint failed: ${e.message}`);
+    process.exitCode = 1;
+  } finally {
+    ch.close();
+  }
+}
+
+// ---- push ------------------------------------------------------------------
+
+function saveParams(file, { force, strict }) {
+  const base = force || file.version == null ? {} : { base_version: file.version };
+
+  if (file.kind === "tool") {
+    const fields = { source_js: file._source, ...file.tool };
+    if (file.id) {
+      const guard = force || file.version == null ? {} : { base_source_hash: file.version };
+      return { event: "fn:save_source", params: { tool_id: file.id, ...fields, ...guard } };
+    }
+    // A new tool: created on the bot named in the file.
+    return { event: "chat:bots:tools:save_wasm_source", params: { bot_id: file.bot, name: file.name, js_source: file._source, ...file.tool } };
+  }
+
+  if (file.kind === "flow") {
+    return {
+      event: "chat:bots:flows:upsert",
+      params: { bot_id: file.bot, ...(file.id ? { id: file.id } : {}), ...file.flow, ...base, strict },
+    };
+  }
+
+  const params = { name: file.name, ...file.loop, ...base, strict };
+  if (file.app_id) params.app_id = file.app_id;
+  return { event: file.version == null ? "loops:create" : "loops:update", params };
+}
+
+async function pushOne(ch, path, file, flags) {
+  const strict = flags["no-strict"] !== true;
+
+  // Lint first, so the author sees every finding even when the save would
+  // only report the blocking ones.
+  const findings = await lintFile(ch, file);
+  const counts = printFindings(findings, { verbose: flags.verbose });
+
+  if (flags["dry-run"]) return { ok: counts.errors === 0, state: "dry-run" };
+
+  // A file that was never pushed has no version to guard with, and both saves
+  // match by name, so a same-named flow or loop on the server would be
+  // silently replaced. Refuse instead.
+  if (file.version == null && !flags.force) {
+    const existing = await sameNamedRemote(ch, file);
+    if (existing) {
+      return {
+        ok: false,
+        state: "conflict",
+        note: `a ${file.kind} with this name already exists on the server (v${existing.version}). Pull it and edit that file, or push --force to replace it.`,
+      };
+    }
+  }
+  if (strict && counts.errors > 0) return { ok: false, state: "refused", note: `${counts.errors} error(s); fix them or push --no-strict` };
+
+  const { event, params } = saveParams(file, { force: flags.force === true, strict });
+
+  try {
+    if (file.kind === "tool" && !file.id && !file.bot) {
+      return { ok: false, state: "refused", note: "a new tool file needs `bot` (the bot it is created on)" };
+    }
+
+    const reply = await ch.call(event, params);
+
+    if (file.kind === "tool") {
+      const id = file.id || reply?.tool?.id;
+      const remote = id ? await getTool(ch, id) : null;
+      if (remote) writeToolFiles(file.name, toolFile(remote, file.bot));
+      return { ok: true, state: "pushed", note: "compiled and saved" };
+    }
+
+    if (file.kind === "flow") {
+      const next = flowFile(reply.flow, file.bot);
+      const newPath = flowPath(file.bot, next.flow.name);
+      writeGraphFile(newPath, next);
+      if (resolvePath(newPath) !== resolvePath(path)) removeFile(path);
+      return { ok: true, state: "pushed", note: `v${next.version}` };
+    }
+
+    const triggerNotes = Array.isArray(file.triggers) && !file.app_id ? await syncTriggers(ch, file) : { notes: [], failed: [] };
+
+    // Loop saves reply with a version only; read the stored copy back so the
+    // file matches what the server normalised (legacy edge keys, stale entry).
+    const remote = await getLoop(ch, file.name, file.app_id);
+    if (remote) writeGraphFile(loopPath(file.name, file.app_id), loopFile(remote, await listTriggers(ch, file.name, file.app_id)));
+    if (file.app_id) console.log(dim("  app-pinned loop: saved without the version guard or strict check"));
+    for (const n of triggerNotes.notes) console.log(dim(`  ${n}`));
+    if (triggerNotes.failed.length) {
+      return { ok: false, state: "partly pushed", note: `the loop saved (v${remote?.version ?? "?"}), but ${triggerNotes.failed.join("; ")}` };
+    }
+    return { ok: true, state: "pushed", note: remote ? `v${remote.version}` : "" };
+  } catch (e) {
+    if (e.code === "conflict") {
+      // Save the server's copy beside the file, so the merge is a file diff
+      // rather than a lost edit. It becomes the base for the next push.
+      const current = await remoteOf(ch, file).catch(() => null);
+      const theirsPath = path.replace(/\.json$/, ".server.json");
+      let theirs = null;
+      if (current && file.kind === "tool") {
+        // For a tool, the conflicting thing is the code: save theirs beside yours.
+        const t = toolFile(current, file.bot);
+        theirs = t.meta;
+        writeFileSync(path.replace(/\.json$/, ".server.js"), t.source);
+      } else if (current) {
+        theirs = file.kind === "flow" ? flowFile(current, file.bot) : loopFile(current, await listTriggers(ch, file.name, file.app_id));
+        writeGraphFile(theirsPath, theirs);
+      }
+      return {
+        ok: false,
+        state: "conflict",
+        note:
+          `someone saved v${theirs?.version ?? e.reply?.current?.version ?? "?"} since your v${file.version}. ` +
+          (theirs
+            ? file.kind === "tool"
+              ? `Their code is in ${rel(path.replace(/\.json$/, ".server.js"))}: merge it into your .js file, then \`oalo push ${rel(path)} --force\` (a tool has no version to re-base on). `
+              : `Their version is in ${rel(theirsPath)}: copy your changes into it, move it over ${rel(path)}, and push again. `
+            : "") +
+          "Only push --force without merging if their change should be thrown away.",
+      };
+    }
+    if (e.code === "invalid_graph") {
+      // The same linter ran just above, so its findings are already printed.
+      return { ok: false, state: "refused", note: "the server refused the graph: fix the errors above (--no-strict does not skip structural damage)" };
+    }
+    return { ok: false, state: "failed", note: e.message };
+  }
+}
+
+/**
+ * Make the loop's triggers match the file, three-way: add the file's new ones,
+ * remove the ones deleted from it (only those it was pulled with, in
+ * `trigger_base`), and replace one whose settings changed. A trigger added on
+ * the server since the pull is kept. There is no trigger update event, so a
+ * change is a remove and an add.
+ */
+export async function syncTriggers(ch, file) {
+  const notes = [];
+  const failed = [];
+  const server = (await listTriggers(ch, file.name, null)) ?? [];
+  const byId = new Map(server.map((t) => [t.id, t]));
+  const base = new Set(file.trigger_base || []);
+  const wanted = file.triggers.map(cleanTrigger);
+  const keptIds = new Set(wanted.map((t) => t.id).filter(Boolean));
+
+  const add = async (t) => {
+    const { id: _id, enabled: on, ...attrs } = t;
+    try {
+      const before = new Set(((await listTriggers(ch, file.name, null)) ?? []).map((x) => x.id));
+      const after = (await ch.call("loops:triggers:add", { name: file.name, ...attrs }))?.triggers ?? [];
+      notes.push(`trigger added: ${describeTrigger(t)}`);
+      // A trigger is added on; one written with `enabled: false` is then switched off.
+      const added = after.find((x) => !before.has(x.id));
+      if (on === false && added) await ch.call("loops:triggers:set_enabled", { name: file.name, trigger_id: added.id, enabled: false });
+    } catch (e) {
+      failed.push(`the trigger ${describeTrigger(t)} was refused: ${e.reply?.message || e.message}`);
+    }
+  };
+  const remove = async (t) => {
+    await ch.call("loops:triggers:remove", { name: file.name, trigger_id: t.id });
+    notes.push(`trigger removed: ${describeTrigger(t)}`);
+  };
+
+  for (const t of server) {
+    if (base.has(t.id) && !keptIds.has(t.id)) await remove(t);
+  }
+  for (const t of wanted) {
+    const current = t.id ? byId.get(t.id) : null;
+    if (!current) {
+      if (!t.id || !base.has(t.id)) await add(t);
+      continue;
+    }
+    if (triggerKey(current) !== triggerKey(t)) {
+      await remove(current);
+      await add(t);
+    } else if (typeof t.enabled === "boolean" && t.enabled !== current.enabled) {
+      try {
+        await ch.call("loops:triggers:set_enabled", { name: file.name, trigger_id: t.id, enabled: t.enabled });
+        notes.push(`trigger turned ${t.enabled ? "on" : "off"}: ${describeTrigger(t)}`);
+      } catch (e) {
+        failed.push(`turning ${describeTrigger(t)} ${t.enabled ? "on" : "off"} failed: ${e.reply?.error || e.message}`);
+      }
+    }
+  }
+  const theirs = server.filter((t) => !base.has(t.id) && !keptIds.has(t.id));
+  if (theirs.length) notes.push(`kept ${theirs.length} trigger(s) added on the server since your pull`);
+  return { notes, failed };
+}
+
+const describeTrigger = (t) =>
+  [t.type, t.type === "api" && `(input: ${Object.keys(t.input || {}).join(", ") || "none"})`, t.event, t.cron, t.widget_id && `widget ${t.widget_id}`, t.filter && Object.keys(t.filter).length ? `filter ${JSON.stringify(t.filter)}` : null]
+    .filter(Boolean)
+    .join(" ");
+
+export async function push(flags, rest) {
+  const explicit = rest.length > 1;
+  const paths = targetFiles(rest);
+  if (paths.length === 0) {
+    console.error("no flow or loop files under .oalo/. Run `oalo pull` first, or name a file.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const ws = await openWorkspace(flags, "push").catch((e) => (console.error(`push failed: ${e.message}`), null));
+  if (!ws) return void (process.exitCode = process.exitCode || 2);
+  const { ch } = ws;
+  let failed = 0;
+  let pushed = 0;
+
+  try {
+    for (const path of paths) {
+      const { file, error } = load(path);
+      if (error) {
+        console.log(`invalid   ${rel(path)}: ${error}`);
+        failed++;
+        continue;
+      }
+      // Without named files, push only what changed (or is new).
+      if (!explicit && !locallyModified(file) && !flags.all) continue;
+
+      console.log(`${rel(path)}`);
+      const r = await pushOne(ch, path, file, flags);
+      console.log(`  ${r.state}${r.note ? `: ${r.note}` : ""}`);
+      if (r.ok) pushed++;
+      else failed++;
+    }
+
+    if (pushed + failed === 0) console.log("nothing to push: no file differs from what was pulled");
+    if (failed > 0) process.exitCode = 1;
+  } catch (e) {
+    console.error(`push failed: ${e.message}`);
+    process.exitCode = 1;
+  } finally {
+    ch.close();
+  }
+}

package/src/commands/incidents.js

@@ -0,0 +1,44 @@
+import { OaloChannel } from "../channel.js";
+import { resolve as resolveConfig, controlPlane, HOW_TO_CONNECT } from "../config.js";
+import { dim } from "../events.js";
+
+/**
+ * `oalo incidents [--app <slug>]`: a live app's outages and restart bursts,
+ * newest first, as the uptime check saw them (AppBuilder.Uptime): what it
+ * was, when it opened and closed, and the facts (restarts, a memory kill,
+ * the last log lines).
+ */
+export async function incidents(flags, rest, opts = {}) {
+  const cfg = resolveConfig(flags);
+  const { url, token } = controlPlane(cfg);
+  if (!url || !token) return fail(`oalo incidents 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 ch = (opts.channel || ((o) => new OaloChannel(o)))({ url, token });
+  let r;
+  try {
+    await ch.connect();
+    r = await ch.call("incidents:list", { app });
+  } catch (e) {
+    return fail(e.message, 1);
+  } finally {
+    ch.close();
+  }
+  if (flags.json) return void console.log(JSON.stringify(r, null, 2));
+
+  const list = r.incidents || [];
+  if (!list.length) return void console.log(`${r.app}: no incidents. The live app is checked every minute.`);
+  const when = (iso) => String(iso).slice(0, 16).replace("T", " ");
+  for (const i of list) {
+    const state = i.resolved_at ? `${when(i.opened_at)} to ${when(i.resolved_at)}` : `open since ${when(i.opened_at)}`;
+    console.log(`${i.resolved_at ? " " : "!"} ${i.title}  ${dim(state)}`);
+    if (!i.resolved_at || flags.all) console.log(dim(i.detail.split("\n").map((l) => `    ${l}`).join("\n")));
+  }
+  if (list.some((i) => !i.resolved_at)) process.exitCode = 1;
+}
+
+function fail(message, code) {
+  console.error(message);
+  process.exitCode = code;
+}