@baryonlabs/cli 0.2.1 → 0.3.0

package/bin/baryon.js

@@ -14,10 +14,24 @@ import {
 } from "../src/commands.js";
 import { loadConfig, piProviderConfigured, hasConfig } from "../src/config.js";
 import { runPi, resolvePiEntry } from "../src/pi.js";
+import { checkLatest } from "../src/api.js";
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
 import { c, err, log, sym } from "../src/ui.js";
 
+/** Best-effort: warn loudly when a newer CLI exists. The gateway enforces the
+ *  minimum version (426), so cloud use is blocked until you update; this is the
+ *  friendly heads-up. Silent when offline / opted out. */
+async function warnIfOutdated() {
+  const r = await checkLatest();
+  if (r?.outdated) {
+    log(
+      `\n  ${sym.warn} ${c.yellow(`업데이트 필요: @baryonlabs/cli ${r.current} → ${r.latest}`)}\n` +
+        `  ${c.dim("baryon.ai 사용에 최신 버전이 필요합니다.")} ${c.lime("baryon update")} ${c.dim("를 실행하세요.\n")}`,
+    );
+  }
+}
+
 const require = createRequire(import.meta.url);
 
 function showVersion() {
@@ -87,6 +101,7 @@ async function main() {
         );
         return 1;
       }
+      await warnIfOutdated();
       const cfg = loadConfig();
       return runPi(argv, cfg);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baryonlabs/cli",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Baryon CLI — AI 코딩·학습 에이전트. baryon.ai API에 기본 연결된 pi 코딩 에이전트 래퍼. 한 줄 설치, 상용·로컬 모델 전환.",
   "type": "module",
   "bin": {

package/src/api.js

@@ -1,10 +1,51 @@
 // Minimal baryon.ai (OpenAI-compatible) helpers: model discovery + reachability.
-import { DEFAULT_MODELS } from "./constants.js";
+import { CLIENT_VERSION, DEFAULT_MODELS } from "./constants.js";
 
 function joinUrl(base, suffix) {
   return base.replace(/\/+$/, "") + suffix;
 }
 
+/** Compare two semver strings. -1 / 0 / 1, prerelease-insensitive. */
+function cmpSemver(a, b) {
+  const pa = String(a).split("-")[0].split(".").map(Number);
+  const pb = String(b).split("-")[0].split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] || 0;
+    const y = pb[i] || 0;
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  return 0;
+}
+
+/**
+ * Best-effort latest-version check against the npm registry. Returns
+ * { current, latest, outdated } or null on any failure (offline / 폐쇄망 /
+ * timeout / opt-out via BARYON_SKIP_UPDATE_CHECK). Never throws.
+ */
+export async function checkLatest({ timeoutMs = 2500 } = {}) {
+  if (process.env.BARYON_SKIP_UPDATE_CHECK) return null;
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(
+      "https://registry.npmjs.org/@baryonlabs/cli/latest",
+      { signal: ctrl.signal, headers: { accept: "application/json" } },
+    );
+    if (!res.ok) return null;
+    const latest = (await res.json())?.version;
+    if (!latest) return null;
+    return {
+      current: CLIENT_VERSION,
+      latest,
+      outdated: cmpSemver(CLIENT_VERSION, latest) < 0,
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+
 /**
  * Fetch the institution's model catalog from `${baseUrl}/models`.
  * Returns pi-shaped model entries, or null when discovery fails

package/src/commands.js

@@ -1,6 +1,6 @@
 // Built-in baryon subcommands. Anything not matched here is passed to pi.
 import { spawn } from "node:child_process";
-import { discoverModels, ping } from "./api.js";
+import { checkLatest, discoverModels, ping } from "./api.js";
 import {
   hasConfig,
   loadConfig,
@@ -124,6 +124,15 @@ export async function doctor() {
   if (cfg.apiKey) ok(`API 키 설정됨 (${cfg.apiKey.slice(0, 4)}${"•".repeat(6)})`);
   else warn("API 키 없음");
 
+  // CLI version currency (best-effort; silent offline)
+  const ver = await checkLatest();
+  if (ver?.outdated) {
+    warn(`CLI 구버전 ${ver.current} — 최신 ${ver.latest}. baryon.ai 사용에 업데이트 필요 (\`baryon update\`)`);
+    problems++;
+  } else if (ver) {
+    ok(`CLI 최신 버전 (${ver.current})`);
+  }
+
   // pi provider registered?
   if (piProviderConfigured()) ok(`pi 프로바이더 ${c.lime(PROVIDER)} 등록됨 → ${c.dim(PI_MODELS_JSON)}`);
   else {

package/src/config.js

@@ -11,8 +11,18 @@ import {
   PI_AGENT_DIR,
   PI_MODELS_JSON,
   PROVIDER,
+  SESSION_HEADER,
+  SESSION_ID_ENV,
+  CLIENT_HEADER,
+  CLIENT_ENV,
 } from "./constants.js";
 
+/** Headers the baryon provider must always send (resolved by pi from env). */
+const PROVIDER_HEADERS = {
+  [SESSION_HEADER]: `$${SESSION_ID_ENV}`,
+  [CLIENT_HEADER]: `$${CLIENT_ENV}`,
+};
+
 function readJson(file, fallback) {
   try {
     return JSON.parse(fs.readFileSync(file, "utf8"));
@@ -69,6 +79,10 @@ export function syncPiModels({ baseUrl, models }) {
     api: "openai-completions",
     apiKey: `$${API_KEY_ENV}`,
     authHeader: true,
+    // Per-launch session id + client version (resolved by pi from env at request
+    // time): the gateway groups a run's turns into one session and enforces a
+    // minimum CLI version. Both are required by the gateway.
+    headers: { ...PROVIDER_HEADERS },
     models:
       Array.isArray(models) && models.length ? models : DEFAULT_MODELS,
   };
@@ -83,4 +97,22 @@ export function piProviderConfigured() {
   return Boolean(root?.providers?.[PROVIDER]);
 }
 
+/**
+ * Auto-heal older installs: ensure the baryon provider sends the session +
+ * client-version headers. Safe to call on every launch — only writes when
+ * something changed. Returns true if the provider exists (after any patch).
+ */
+export function ensurePiSessionHeader() {
+  const root = readJson(PI_MODELS_JSON, {});
+  const p = root?.providers?.[PROVIDER];
+  if (!p) return false;
+  const need = Object.entries(PROVIDER_HEADERS).some(
+    ([k, v]) => p.headers?.[k] !== v,
+  );
+  if (!need) return true;
+  p.headers = { ...(p.headers || {}), ...PROVIDER_HEADERS };
+  writeJson(PI_MODELS_JSON, root);
+  return true;
+}
+
 export { PI_MODELS_JSON, BARYON_CONFIG };

package/src/constants.js

@@ -1,5 +1,16 @@
 import os from "node:os";
 import path from "node:path";
+import { createRequire } from "node:module";
+
+/** This CLI's version (from package.json). Sent to the gateway for the
+ *  minimum-version gate, so old clients are forced to update. */
+export const CLIENT_VERSION = (() => {
+  try {
+    return createRequire(import.meta.url)("../package.json").version;
+  } catch {
+    return "0.0.0";
+  }
+})();
 
 /** Provider id registered inside pi's models.json */
 export const PROVIDER = "baryon";
@@ -11,6 +22,22 @@ export const DEFAULT_BASE_URL =
 /** Env var pi resolves at request time (apiKey: "$BARYON_API_KEY"). */
 export const API_KEY_ENV = "BARYON_API_KEY";
 
+/**
+ * Session id env var. The baryon provider sends it as `X-Baryon-Session` so the
+ * gateway can group every turn of one `baryon` run into a single session. A
+ * fresh id is minted per launch (see pi.js). The gateway requires it.
+ */
+export const SESSION_ID_ENV = "BARYON_SESSION_ID";
+export const SESSION_HEADER = "X-Baryon-Session";
+
+/**
+ * Client-identity header. The baryon provider sends `baryon-cli/<version>` so
+ * the gateway can enforce a minimum CLI version (BARYON_MIN_CLI_VERSION). The
+ * value is resolved per launch from BARYON_CLIENT (see pi.js).
+ */
+export const CLIENT_ENV = "BARYON_CLIENT";
+export const CLIENT_HEADER = "X-Baryon-Client";
+
 /** Underlying coding agent package + binary. */
 export const PI_PACKAGE = "@earendil-works/pi-coding-agent";
 export const PI_BIN = "pi";

package/src/pi.js

@@ -3,6 +3,7 @@
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import {
@@ -10,7 +11,11 @@ import {
   PI_BIN,
   PI_PACKAGE,
   PROVIDER,
+  SESSION_ID_ENV,
+  CLIENT_ENV,
+  CLIENT_VERSION,
 } from "./constants.js";
+import { ensurePiSessionHeader } from "./config.js";
 
 const require = createRequire(import.meta.url);
 
@@ -98,6 +103,13 @@ export function runPi(args, config, { injectTargeting = true } = {}) {
   if (config.apiKey) env[API_KEY_ENV] = config.apiKey;
   if (config.baseUrl) env.BARYON_BASE_URL = config.baseUrl;
 
+  // One session per launch: mint an id (unless the caller pinned one) and make
+  // sure the provider forwards it + this CLI's version. The gateway requires a
+  // session id and enforces a minimum CLI version.
+  if (!env[SESSION_ID_ENV]) env[SESSION_ID_ENV] = `cli_${randomUUID()}`;
+  env[CLIENT_ENV] = `baryon-cli/${CLIENT_VERSION}`;
+  ensurePiSessionHeader();
+
   return new Promise((resolve, reject) => {
     const child = spawn(process.execPath, [entry, ...finalArgs], {
       stdio: "inherit",