@baryonlabs/cli 0.2.2 → 0.3.1

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.2",
+  "version": "0.3.1",
   "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,10 +1,11 @@
 // 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,
   piProviderConfigured,
+  prunePiPackages,
   saveConfig,
   syncPiModels,
   BARYON_CONFIG,
@@ -15,6 +16,7 @@ import {
   DEFAULT_BASE_URL,
   DEFAULT_EXTENSIONS,
   DEFAULT_MODELS,
+  DEPRECATED_EXTENSIONS,
   HOMEPAGE,
   KEYS_URL,
   KEY_PREFIX,
@@ -124,6 +126,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 {
@@ -224,13 +235,29 @@ export function installDefaults() {
     return 0;
   }
 
+  // Self-heal machines broken by a previously-shipped conflicting extension
+  // (e.g. pi-search ↔ pi-web-fetch both registering `web_fetch`, which hard-fails
+  // every run). Remove them from pi's registry + disk before (re)installing.
+  const pruned = prunePiPackages(DEPRECATED_EXTENSIONS);
+  if (pruned.length) warn(`충돌 확장 제거: ${pruned.join(", ")} (자가 치유)`);
+
   log(`  ${sym.info} 기본 확장 설치 중 (${DEFAULT_EXTENSIONS.length}종 · git clone, 잠시 걸립니다)…`);
   let okc = 0;
 
   for (const e of DEFAULT_EXTENSIONS) {
-    const r = spawnSync(process.execPath, [entry, "install", e.src], { encoding: "utf8" });
+    // git clone is flaky under GitHub rate-limiting / transient network — retry
+    // a few times so a single class doesn't end up with "0/N" extensions.
+    let status = 1;
+
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      const r = spawnSync(process.execPath, [entry, "install", e.src], { encoding: "utf8" });
+      status = r.status;
+      if (status === 0) break;
+      // Cross-platform synchronous backoff (no `sleep` binary — Windows lacks it).
+      if (attempt < 3) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2000);
+    }
 
-    if (r.status === 0) {
+    if (status === 0) {
       ok(`${e.name} — ${e.note}`);
       okc++;
     } else {

package/src/config.js

@@ -10,11 +10,20 @@ import {
   DEFAULT_MODELS,
   PI_AGENT_DIR,
   PI_MODELS_JSON,
+  PI_SETTINGS_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"));
@@ -71,9 +80,10 @@ export function syncPiModels({ baseUrl, models }) {
     api: "openai-completions",
     apiKey: `$${API_KEY_ENV}`,
     authHeader: true,
-    // Per-launch session id (resolved by pi from the env at request time) so the
-    // gateway can group a run's turns into one session. Gateway requires it.
-    headers: { [SESSION_HEADER]: `$${SESSION_ID_ENV}` },
+    // 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,
   };
@@ -89,18 +99,61 @@ export function piProviderConfigured() {
 }
 
 /**
- * Auto-heal older installs: ensure the baryon provider sends the session
- * header. Safe to call on every launch — only writes when something changed.
- * Returns true if the provider exists (after any patch).
+ * 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;
-  if (p.headers?.[SESSION_HEADER] === `$${SESSION_ID_ENV}`) return true;
-  p.headers = { ...(p.headers || {}), [SESSION_HEADER]: `$${SESSION_ID_ENV}` };
+  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;
 }
 
+/**
+ * Self-heal installs broken by a deprecated extension: drop its URL from pi's
+ * settings.json `packages` list and remove the cloned dir so pi stops loading
+ * it. Pure fs/JSON → works identically on macOS/Linux/Windows. Returns the list
+ * of names actually removed.
+ */
+export function prunePiPackages(deprecated) {
+  const removed = [];
+  const srcs = new Set(deprecated.map((d) => d.src));
+
+  // 1) drop from settings.json packages[]
+  try {
+    const s = readJson(PI_SETTINGS_JSON, null);
+    if (s && Array.isArray(s.packages)) {
+      const kept = s.packages.filter((u) => !srcs.has(u));
+      if (kept.length !== s.packages.length) {
+        s.packages = kept;
+        writeJson(PI_SETTINGS_JSON, s);
+      }
+    }
+  } catch {
+    /* settings missing/unreadable — nothing to prune */
+  }
+
+  // 2) remove the cloned extension directory (git/github.com/<owner>/<name>)
+  for (const d of deprecated) {
+    const dir = path.join(PI_AGENT_DIR, "git", "github.com", d.owner, d.name);
+    try {
+      if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+        removed.push(d.name);
+      }
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  return removed;
+}
+
 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";
@@ -19,6 +30,14 @@ export const API_KEY_ENV = "BARYON_API_KEY";
 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";
@@ -30,6 +49,8 @@ export const BARYON_CONFIG = path.join(BARYON_DIR, "config.json");
 /** pi's custom-provider/model registry. */
 export const PI_AGENT_DIR = path.join(os.homedir(), ".pi", "agent");
 export const PI_MODELS_JSON = path.join(PI_AGENT_DIR, "models.json");
+/** pi's extension registry — a `{ packages: [<git url>, …] }` list loaded on startup. */
+export const PI_SETTINGS_JSON = path.join(PI_AGENT_DIR, "settings.json");
 
 /**
  * Fallback model catalog used when /models discovery is unavailable
@@ -57,19 +78,36 @@ export const DEFAULT_MODELS = [
 
 /**
  * Extensions installed by default so `baryon` ships with sub-agents, a canvas,
- * an interactive shell, and web access/fetch out of the box. Installed via
+ * an interactive shell, and web access/search out of the box. Installed via
  * `pi install <src>` into ~/.pi/agent/settings.json (loaded on startup).
+ *
+ * Curated for conflict-free startup (verified in a clean container):
+ *  - pi-search removed — it registers a `web_fetch` tool that collides with
+ *    pi-web-fetch, hard-failing extension load on every run.
+ *  - pi-web-fetch removed — requires `puppeteer` (chromium download), which is
+ *    absent in fresh/CI environments, so the extension fails to load. pi-web-access
+ *    already provides browsing + fetch_content + web_search without that dependency.
  */
 export const DEFAULT_EXTENSIONS = [
   { name: "pi-subagents", src: "https://github.com/nicobailon/pi-subagents", note: "서브에이전트(작업 분해·위임·통합)" },
   { name: "pi-canvas", src: "https://github.com/jyaunches/pi-canvas", note: "캔버스" },
   { name: "pi-interactive-shell", src: "https://github.com/nicobailon/pi-interactive-shell", note: "인터랙티브 셸" },
-  { name: "pi-web-access", src: "https://github.com/nicobailon/pi-web-access", note: "웹 액세스(브라우징)" },
-  { name: "pi-web-fetch", src: "https://github.com/georgebashi/pi-web-fetch", note: "웹 페치" },
-  { name: "pi-search", src: "https://github.com/buddingnewinsights/pi-search", note: "웹 검색" },
+  { name: "pi-web-access", src: "https://github.com/nicobailon/pi-web-access", note: "웹 액세스(브라우징·검색·페치)" },
   { name: "pi-parallel-web-search", src: "https://github.com/philipp-spiess/pi-parallel-web-search", note: "병렬 웹 검색" }
 ];
 
+/**
+ * Extensions previously shipped as defaults that BREAK startup and must be
+ * actively removed from existing installs (settings.json + cloned dir):
+ *  - pi-web-fetch: `web_fetch` collides with pi-search; also needs puppeteer.
+ *  - pi-search: `web_fetch` collision; superseded by pi-web-access.
+ * `baryon setup` self-heals an already-broken machine by pruning these.
+ */
+export const DEPRECATED_EXTENSIONS = [
+  { name: "pi-web-fetch", src: "https://github.com/georgebashi/pi-web-fetch", owner: "georgebashi" },
+  { name: "pi-search", src: "https://github.com/buddingnewinsights/pi-search", owner: "buddingnewinsights" }
+];
+
 export const HOMEPAGE = "https://cli.baryon.ai";
 export const SUPPORT_EMAIL = "support@baryon.ai";
 

package/src/pi.js

@@ -12,6 +12,8 @@ import {
   PI_PACKAGE,
   PROVIDER,
   SESSION_ID_ENV,
+  CLIENT_ENV,
+  CLIENT_VERSION,
 } from "./constants.js";
 import { ensurePiSessionHeader } from "./config.js";
 
@@ -102,8 +104,10 @@ export function runPi(args, config, { injectTargeting = true } = {}) {
   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. The gateway requires a session id.
+  // 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) => {