@oalo-ai/cli 0.0.0-stage → 0.1.0

package/src/server.js

@@ -0,0 +1,73 @@
+import { readFileSync } from "node:fs";
+
+/**
+ * Version handshake with the workspace (GET /api/cli/version).
+ *
+ * A CLI and a box are updated separately, so either can be ahead. A command
+ * that needs new server code checks for its feature first and says which side
+ * is behind, instead of failing halfway with an error that reads like a bug.
+ * A box from before this endpoint answers 404: it supports none of the
+ * features listed here, and so does one whose catch-all route answers with
+ * the dashboard page.
+ */
+
+export const CLI_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
+const NO_FEATURES = { api: 1, min_cli: null, features: [] };
+
+/** `{api, min_cli, features}`, NO_FEATURES for a box that predates the endpoint, or null if unreachable. */
+export async function serverInfo(url) {
+  let res;
+  try {
+    res = await fetch(`${url.replace(/\/$/, "")}/api/cli/version`);
+  } catch {
+    return null;
+  }
+  if (res.status === 404) return NO_FEATURES;
+  if (!res.ok) return null;
+  // An older box can answer 200 with the dashboard's HTML (its catch-all
+  // route), so only a JSON reply with a feature list counts.
+  try {
+    const info = await res.json();
+    return Array.isArray(info?.features) ? info : NO_FEATURES;
+  } catch {
+    return NO_FEATURES;
+  }
+}
+
+/** -1, 0 or 1, comparing dotted versions numerically ("0.10.0" > "0.9.1"). */
+export function compareVersions(a, b) {
+  const pa = String(a).split(".").map(Number);
+  const pb = String(b).split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d) return d > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+/** Why this CLI can't talk to the server, or null when it can. */
+export function cliTooOld(info) {
+  if (info?.min_cli && compareVersions(CLI_VERSION, info.min_cli) < 0) {
+    return `This workspace needs @oalo-ai/cli ${info.min_cli} or newer (you have ${CLI_VERSION}). Update with: npm i -g @oalo-ai/cli`;
+  }
+  return null;
+}
+
+/**
+ * Throw a readable error unless the workspace supports `feature`. `what` names
+ * the command for the message, e.g. "oalo emit". An unreachable server passes:
+ * the command's own connect error says that better.
+ */
+export async function requireFeature(url, feature, what) {
+  const info = await serverInfo(url);
+  if (!info) return null;
+  const old = cliTooOld(info);
+  if (old) throw new Error(old);
+  if (!info.features.includes(feature)) {
+    throw new Error(
+      `${url} runs an older OALO than this CLI, so \`${what}\` isn't available there yet. It will be once the workspace is updated.`,
+    );
+  }
+  return info;
+}

package/src/workspace.js

@@ -0,0 +1,44 @@
+import { OaloChannel } from "./channel.js";
+import { resolve as resolveConfig, controlPlane, HOW_TO_CONNECT } from "./config.js";
+
+/**
+ * Open the build-surface channel with the linked CLI token (control plane).
+ * Falls back to the most recently linked workspace when this project has none,
+ * like `oalo run`. Returns null after printing how to link when there is no
+ * token, so commands can exit 2 without a stack trace.
+ */
+export async function openWorkspace(flags, command) {
+  const cfg = resolveConfig(flags);
+  const { url, token } = controlPlane(cfg);
+
+  if (!url || !token) {
+    console.error(
+      `oalo ${command} needs a CLI token.\n\n${HOW_TO_CONNECT}`,
+    );
+    return null;
+  }
+
+  const ch = new OaloChannel({ url, token });
+  await ch.connect();
+  return { ch, url, env: cfg.env };
+}
+
+/** Print lint findings, most severe first. Returns {errors, warnings, infos}. */
+export function printFindings(findings, { label = "", verbose = false } = {}) {
+  const counts = { errors: 0, warnings: 0, infos: 0 };
+  const mark = { error: "error  ", warning: "warning", info: "info   " };
+
+  for (const f of findings || []) {
+    if (f.severity === "error") counts.errors++;
+    else if (f.severity === "warning") counts.warnings++;
+    else counts.infos++;
+
+    if (f.severity === "info" && !verbose) continue;
+    const where = f.node_id ? `${f.node_id}: ` : f.edge_index != null ? `edge #${f.edge_index}: ` : "";
+    console.log(`  ${mark[f.severity] || f.severity} ${label}${where}${f.detail}`);
+    if (f.suggestion) console.log(`          fix: ${f.suggestion}`);
+  }
+
+  if (counts.infos && !verbose) console.log(`  (${counts.infos} info finding(s) hidden; --verbose shows them)`);
+  return counts;
+}