@oalo-ai/cli 0.0.0-stage → 0.1.0

package/src/index.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+import { link } from "./commands/link.js";
+import { login, logout } from "./commands/login.js";
+import { typegen } from "./commands/typegen.js";
+import { mcp } from "./commands/mcp.js";
+import { tail } from "./commands/tail.js";
+import { call } from "./commands/call.js";
+import { run } from "./commands/run.js";
+import { pull, push, status, lint } from "./commands/graphs.js";
+import { qa } from "./commands/qa.js";
+import { rehearse } from "./commands/rehearse.js";
+import { skill, skillNotice } from "./commands/skill.js";
+import { dim } from "./events.js";
+import { CLI_VERSION } from "./server.js";
+import { whoami } from "./commands/whoami.js";
+import { emit } from "./commands/emit.js";
+import { data } from "./commands/data.js";
+import { tokens } from "./commands/tokens.js";
+import { docs } from "./commands/docs.js";
+import { deploy } from "./commands/deploy.js";
+import { apps } from "./commands/apps.js";
+import { env } from "./commands/env.js";
+import { loops, flows } from "./commands/switches.js";
+import { logs } from "./commands/logs.js";
+import { secrets } from "./commands/secrets.js";
+import { dockerfile } from "./commands/dockerfile.js";
+import { bots } from "./commands/bots.js";
+import { sources } from "./commands/sources.js";
+import { setup } from "./commands/setup.js";
+import { incidents } from "./commands/incidents.js";
+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 { overview, commandHelp, helpJson, COMMANDS } from "./help.js";
+import { parse } from "./args.js";
+
+const { flags, rest } = parse(process.argv.slice(2));
+const cmd = rest[0];
+
+/**
+ * Print, then exit once the text has been flushed. `console.log` then
+ * `process.exit()` truncates piped output at the 8 KB pipe buffer: Node writes
+ * to a pipe asynchronously and exit drops what is still queued, so
+ * `oalo help --json | jq` broke as soon as the help grew past 8 KB.
+ */
+function finish(text, code, stream = process.stdout) {
+  stream.write(text + "\n", () => process.exit(code));
+}
+
+// Help is a first-class command, not an error path.
+//
+// `oalo --help` used to exit 1, which breaks `oalo --help && ...` and tells a
+// script the tool failed when it did exactly what was asked. An explicit help
+// request exits 0; only an INVALID invocation is non-zero.
+if ((flags.version || cmd === "version") && !flags.help) {
+  finish(CLI_VERSION, 0);
+} else if (cmd === "help" || flags.help) {
+  const topic = cmd === "help" ? rest[1] : cmd;
+
+  if (flags.json) {
+    finish(helpJson(), 0);
+  } else if (topic) {
+    const detail = commandHelp(topic);
+    if (detail) finish(detail, 0);
+    else finish(`unknown command: ${topic}\n\n${overview()}`, 2, process.stderr);
+  } else {
+    finish(overview(), 0);
+  }
+} else if (!cmd) {
+  // No command at all is a usage error, so it stays non-zero, on stderr so it
+  // cannot be mistaken for output.
+  finish(overview(), 1, process.stderr);
+} else if (!COMMANDS.some((c) => c.name === cmd)) {
+  finish(`unknown command: ${cmd}\n\n${overview()}`, 2, process.stderr);
+} else {
+  // A project whose installed skill is from another CLI version hears about
+  // it once (stderr, so piped output and --json stay clean). Not under mcp,
+  // whose stdio is the protocol, nor where the skill is being written.
+  if (cmd && !["mcp", "skill", "link", "help"].includes(cmd)) {
+    try {
+      const notice = skillNotice();
+      if (notice) console.error(dim(notice));
+    } catch {
+      /* never in the way of the command */
+    }
+  }
+
+  await dispatch(cmd);
+}
+
+async function dispatch(cmd) {
+  switch (cmd) {
+    case "login":
+      await login(flags, rest);
+      break;
+    case "logout":
+      await logout(flags);
+      break;
+    case "whoami":
+      await whoami(flags);
+      break;
+    case "link":
+      await link(flags);
+      break;
+    case "typegen":
+      await typegen(flags);
+      break;
+    case "tail":
+      await tail(flags);
+      break;
+    case "call":
+      await call(flags, rest);
+      break;
+    case "run":
+      await run(flags, rest);
+      break;
+    case "emit":
+      await emit(flags, rest);
+      break;
+    case "data":
+      await data(flags, rest);
+      break;
+    case "tokens":
+      await tokens(flags, rest);
+      break;
+    case "docs":
+      await docs(flags, rest);
+      break;
+    case "deploy":
+      await deploy(flags);
+      break;
+    case "apps":
+      await apps(flags);
+      break;
+    case "env":
+      await env(flags, rest);
+      break;
+    case "logs":
+      await logs(flags, rest);
+      break;
+    case "dockerfile":
+      await dockerfile(flags, rest);
+      break;
+    case "bots":
+      await bots(flags, rest);
+      break;
+    case "sources":
+      await sources(flags, rest);
+      break;
+    case "setup":
+      await setup(flags, rest);
+      break;
+    case "incidents":
+      await incidents(flags, rest);
+      break;
+    case "channels":
+      await channels(flags, rest);
+      break;
+    case "products":
+      await products(flags, rest);
+      break;
+    case "metrics":
+      await metrics(flags, rest);
+      break;
+    case "dashboards":
+      await dashboards(flags, rest);
+      break;
+    case "db":
+      await db(flags, rest);
+      break;
+    case "secrets":
+      await secrets(flags, rest);
+      break;
+    case "loops":
+      await loops(flags, rest);
+      break;
+    case "flows":
+      await flows(flags, rest);
+      break;
+    case "pull":
+      await pull(flags, rest);
+      break;
+    case "push":
+      await push(flags, rest);
+      break;
+    case "status":
+      await status(flags, rest);
+      break;
+    case "lint":
+      await lint(flags, rest);
+      break;
+    case "qa":
+      await qa(flags, rest);
+      break;
+    case "rehearse":
+      await rehearse(flags);
+      break;
+    case "skill":
+      await skill(flags);
+      break;
+    case "mcp":
+      await mcp(flags);
+      break;
+    case "coord": {
+      // coord uses bun:sqlite and is TypeScript; the shipped binary is Bun-compiled.
+      if (typeof Bun === "undefined") {
+        console.error("oalo coord needs the oalo binary (Bun runtime). Run it with `bun src/index.js coord ...` in development.");
+        process.exit(1);
+      }
+      const { coord } = await import("./commands/coord.ts");
+      await coord(flags, rest);
+      break;
+    }
+  }
+}