oh-langfuse 0.1.56 → 0.1.58

package/README.md

@@ -2,12 +2,12 @@
 
 `oh-langfuse` 是用于给 Claude Code、OpenCode、Codex 配置 Langfuse 追踪的命令行工具。它既提供交互式安装向导，也支持 `setup`、`check`、`update`、`auto-update` 等直接命令。
 
-当前 npm 版本：`0.1.56`
+当前 npm 版本：`0.1.58`
 
 ## 能做什么
 
 - 为 Claude Code 安装 `Stop` hook，把会话事件写入 Langfuse。
-- 为 OpenCode 安装并 patch `opencode-plugin-langfuse`，开启 OpenTelemetry，并输出 `Agent Turn` 指标。
+- 为 OpenCode 安装并 patch `opencode-plugin-langfuse`，开启 OpenTelemetry，并输出 `OpenCode Agent Turn` 指标。
 - 为 Codex 安装 `notify` hook，增量读取 session JSONL 并写入 Langfuse。
 - 记录本地 runtime 版本，支持启动前更新检查和手动更新。
 - 校验员工号、环境变量、插件、hook、launcher、命令 shim 是否安装完整。
@@ -51,6 +51,13 @@ npx oh-langfuse@latest update opencode
 npx oh-langfuse@latest update codex
 ```
 
+确认是否已经更新到 npm 最新版本：
+
+```bash
+npx oh-langfuse@latest verify-update all
+npx oh-langfuse@latest verify-update opencode
+```
+
 ## 交互式菜单
 
 运行 `npx oh-langfuse@latest` 会打开菜单：
@@ -72,6 +79,23 @@ npx oh-langfuse@latest update codex
 
 记录 Claude Code / OpenCode / Codex 当前写入本机 runtime 的包名和版本。
 
+`verify-update` 会读取这份记录，并对比 npm `oh-langfuse@latest`：
+
+```bash
+npx oh-langfuse@latest verify-update all
+```
+
+输出示例：
+
+```text
+[OK] OpenCode Langfuse runtime is current: 0.1.58
+[FAIL] Codex Langfuse runtime is outdated: installed 0.1.57, latest 0.1.58
+[FIX] Run: npx oh-langfuse@latest update codex
+[SKIP] Claude not installed
+```
+
+`check` 用于检查配置完整性；`verify-update` 才用于确认本机 runtime 是否已经更新到 npm 最新版本。
+
 OpenCode setup 会生成直接命令 shim：
 
 - Windows：`~/.config/opencode/bin/opencode.cmd`
@@ -98,7 +122,13 @@ npx oh-langfuse@latest auto-update codex
 
 ## Skill 使用统计
 
-当前版本把 skill 使用汇总写入每次交互的 `Agent Turn` observation，不再额外生成独立 `Skill Use` observation。
+当前版本把 skill 使用汇总写入每次交互的 agent-specific `Agent Turn` observation，不再额外生成独立 `Skill Use` observation。
+
+Agent Turn 的 observation name 会带上来源，方便在 Langfuse 后台直接区分：
+
+- `Claude Agent Turn`
+- `OpenCode Agent Turn`
+- `Codex Agent Turn`
 
 常见字段：
 
@@ -116,7 +146,7 @@ Dashboard 统计建议：
 
 ```text
 View: Observations
-Filter: Observation Name equals Agent Turn
+Filter: Observation Name contains Agent Turn
 Metric: Sum skill_use_count
 ```
 
@@ -161,6 +191,8 @@ Linux 环境缺少 `python3-venv/ensurepip` 时，安装器会降级尝试 `pyth
 
 配置后需要重启 Codex，让新的 notify 命令加载。notify hook 会增量读取 `~/.codex/sessions/**/*.jsonl`，并把读取偏移记录到 `~/.codex/langfuse/state.json`。
 
+notify hook 会读取 `~/.codex/langfuse/config.json`（或 `CODEX_HOME/langfuse/config.json`）中的 `baseUrl` / `host`，并把该主机补入 `NO_PROXY`，避免自建 Langfuse 服务被代理干扰。
+
 ## 环境变量
 
 | 变量 | 作用 |

package/bin/cli.js

@@ -794,11 +794,13 @@ function printHelp() {
     "oh-langfuse check codex",
     "oh-langfuse update",
     "oh-langfuse update all",
-    "oh-langfuse update claude",
-    "oh-langfuse update opencode",
-    "oh-langfuse update codex",
-    "oh-langfuse auto-update opencode"
-  ]);
+    "oh-langfuse update claude",
+    "oh-langfuse update opencode",
+    "oh-langfuse update codex",
+    "oh-langfuse verify-update all",
+    "oh-langfuse verify-update opencode",
+    "oh-langfuse auto-update opencode"
+  ]);
   renderSection("Options", [
     `${paint("--dry-run", t.gold)}  Preview actions without writing files or installing packages.`,
     `${paint("--userId=ID", t.gold)}  Provide the Langfuse user id without prompting.`,
@@ -865,17 +867,23 @@ async function main() {
       ];
       return runNodeScript("update-langfuse-runtime.mjs", updateArgs, options);
     }
-    if (cmd === "auto-update") {
-      return runNodeScript("auto-update-runtime.mjs", [
-        target || "all",
-        ...(hasValue(options.npmRegistry) ? [`--npmRegistry=${options.npmRegistry}`] : []),
-        ...(hasValue(options.pipIndexUrl) ? [`--pipIndexUrl=${options.pipIndexUrl}`] : []),
+    if (cmd === "auto-update") {
+      return runNodeScript("auto-update-runtime.mjs", [
+        target || "all",
+        ...(hasValue(options.npmRegistry) ? [`--npmRegistry=${options.npmRegistry}`] : []),
+        ...(hasValue(options.pipIndexUrl) ? [`--pipIndexUrl=${options.pipIndexUrl}`] : []),
         ...(options.skipCheck ? ["--skip-check"] : []),
         ...(options.startupStatus ? ["--startup-status"] : []),
-        ...(options.yes ? ["--yes"] : []),
-      ], { ...options, quiet: true });
-    }
-    if (cmd === "check" && target === "claude") return checkClaude(options);
+        ...(options.yes ? ["--yes"] : []),
+      ], { ...options, quiet: true });
+    }
+    if (cmd === "verify-update") {
+      return runNodeScript("verify-update-runtime.mjs", [
+        target || "all",
+        ...(hasValue(options.npmRegistry) ? [`--npmRegistry=${options.npmRegistry}`] : []),
+      ], { ...options, quiet: true });
+    }
+    if (cmd === "check" && target === "claude") return checkClaude(options);
     if (cmd === "check" && target === "opencode") return checkOpenCode(options);
     if (cmd === "check" && target === "codex") return checkCodex(options);
     if (cmd === "check" && target === "environment") {

package/codex_langfuse_notify.py

@@ -17,15 +17,38 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
-from urllib.parse import urlparse
-
-
-def configure_langfuse_no_proxy() -> None:
-    hosts = ["localhost", "127.0.0.1"]
-    for key in ("LANGFUSE_HOST", "LANGFUSE_BASEURL", "CODEX_LANGFUSE_BASE_URL"):
-        value = os.environ.get(key)
-        if not value:
-            continue
+from urllib.parse import urlparse
+
+
+def codex_langfuse_config_path() -> Path:
+    codex_dir = Path(os.environ.get("CODEX_HOME") or (Path.home() / ".codex"))
+    return codex_dir / "langfuse" / "config.json"
+
+
+def read_langfuse_base_url_from_config() -> Optional[str]:
+    try:
+        path = codex_langfuse_config_path()
+        if not path.exists():
+            return None
+        data = json.loads(path.read_text(encoding="utf-8-sig"))
+        if isinstance(data, dict):
+            value = data.get("baseUrl") or data.get("host")
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+    except Exception:
+        return None
+    return None
+
+
+def configure_langfuse_no_proxy() -> None:
+    hosts = ["localhost", "127.0.0.1"]
+    values = [
+        *(os.environ.get(key) for key in ("LANGFUSE_HOST", "LANGFUSE_BASEURL", "CODEX_LANGFUSE_BASE_URL")),
+        read_langfuse_base_url_from_config(),
+    ]
+    for value in values:
+        if not value:
+            continue
         parsed = urlparse(value if "://" in value else f"http://{value}")
         if parsed.hostname:
             hosts.append(parsed.hostname)
@@ -62,7 +85,8 @@ LOG_FILE = STATE_DIR / "codex_langfuse_notify.log"
 DEBUG = os.environ.get("CODEX_LANGFUSE_DEBUG", "").lower() == "true"
 MAX_CHARS = int(os.environ.get("CODEX_LANGFUSE_MAX_CHARS", "20000"))
 METRICS_SCHEMA_VERSION = "1.1"
-AGENT_NAME = "codex"
+AGENT_NAME = "codex"
+AGENT_TURN_NAME = "Codex Agent Turn"
 
 
 def log(level: str, message: str) -> None:
@@ -839,11 +863,11 @@ def emit_codex_turn(
     with propagate_attributes(
         user_id=user_id,
         session_id=session_id,
-        trace_name="Agent Turn",
-        tags=[AGENT_NAME],
-    ):
-        with langfuse.start_as_current_observation(
-            name="Agent Turn",
+        trace_name=AGENT_TURN_NAME,
+        tags=[AGENT_NAME],
+    ):
+        with langfuse.start_as_current_observation(
+            name=AGENT_TURN_NAME,
             input={"role": "user", "content": user_text},
             output={"role": "assistant", "content": assistant_text},
             metadata={

package/langfuse_hook.py

@@ -66,7 +66,8 @@ LOCK_FILE = STATE_DIR / "langfuse_state.lock"
 DEBUG = os.environ.get("CC_LANGFUSE_DEBUG", "").lower() == "true"
 MAX_CHARS = int(os.environ.get("CC_LANGFUSE_MAX_CHARS", "20000"))
 METRICS_SCHEMA_VERSION = "1.1"
-AGENT_NAME = "claude"
+AGENT_NAME = "claude"
+AGENT_TURN_NAME = "Claude Agent Turn"
 
 # ----------------- Logging -----------------
 def _log(level: str, message: str) -> None:
@@ -882,11 +883,11 @@ def emit_turn(
     with propagate_attributes(
         user_id=user_id,
         session_id=session_id,
-        trace_name="Agent Turn",
-        tags=[AGENT_NAME],
-    ):
-        with langfuse.start_as_current_observation(
-            name="Agent Turn",
+        trace_name=AGENT_TURN_NAME,
+        tags=[AGENT_NAME],
+    ):
+        with langfuse.start_as_current_observation(
+            name=AGENT_TURN_NAME,
             input={"role": "user", "content": user_text},
             output={"role": "assistant", "content": assistant_text},
             metadata={

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "private": false,
   "type": "module",
   "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",
@@ -27,9 +27,11 @@
     "scripts/log-filter-utils.mjs",
     "scripts/metrics-utils.mjs",
     "scripts/runtime-state-utils.mjs",
-    "scripts/update-langfuse-runtime.mjs",
-    "scripts/update-utils.mjs",
-    "langfuse_hook.py",
+    "scripts/update-langfuse-runtime.mjs",
+    "scripts/update-utils.mjs",
+    "scripts/verify-update-runtime.mjs",
+    "scripts/verify-update-utils.mjs",
+    "langfuse_hook.py",
     "codex_langfuse_notify.py",
     "README.md",
     "SELF_VERIFY.md",

package/scripts/opencode-langfuse-setup.mjs

@@ -618,7 +618,7 @@ function getPatchedLangfuseDistIndexJs() {
     "    const total = tokenMetrics.total ?? (tokenMetrics.input !== undefined && tokenMetrics.output !== undefined ? tokenMetrics.input + tokenMetrics.output : undefined);",
     "    const tokenAvailable = [tokenMetrics.input, tokenMetrics.output, total, tokenMetrics.cacheRead, tokenMetrics.reasoning].some((value) => value !== undefined);",
     "    await sdkStartPromise;",
-    "    const span = getMetricsTracer().startSpan('Agent Turn');",
+    "    const span = getMetricsTracer().startSpan('OpenCode Agent Turn');",
     "    const text = messageTextById.get(messageId) || '';",
     "    const skillUsages = dedupeSkillUsages([...(skillUsagesByMessageId.get(messageId) ?? []), ...(skillUsagesBySessionId.get(sessionId) ?? [])]);",
     "    const interactionId = `opencode:${userId || \"unknown\"}:${sessionId || \"unknown\"}:${messageId}`;",

package/scripts/real-self-verify.mjs

@@ -365,18 +365,25 @@ function metricInteractionId(item, target) {
     : metadataValue(item, "interaction_id");
 }
 
-function isAgentTurnObservation(item) {
-  if (item?.name === "Agent Turn" || metadataValue(item, "interaction_count") === 1 || metadataValue(item, "interaction_count") === "1") {
-    return true;
-  }
+function isAgentTurnObservation(item) {
+  if (/^(Claude|OpenCode|Codex) Agent Turn$/.test(String(item?.name || "")) || item?.name === "Agent Turn" || metadataValue(item, "interaction_count") === 1 || metadataValue(item, "interaction_count") === "1") {
+    return true;
+  }
   const metadata = item?.metadata || {};
   const attrs = metadata.attributes || {};
   const isOpencode = metadata.source === "opencode" || attrs["oh.langfuse.source"] === "opencode";
   const hasModel = attrs["ai.model.id"] !== undefined || attrs["ai.model.provider"] !== undefined;
   const isTool = attrs["ai.toolCall.name"] !== undefined || attrs["ai.toolCall.id"] !== undefined;
-  return isOpencode && hasModel && !isTool && item?.type === "GENERATION";
-}
-
+  return isOpencode && hasModel && !isTool && item?.type === "GENERATION";
+}
+
+function expectedAgentTurnName(target) {
+  if (target === "claude") return "Claude Agent Turn";
+  if (target === "opencode") return "OpenCode Agent Turn";
+  if (target === "codex") return "Codex Agent Turn";
+  return "Agent Turn";
+}
+
 async function observationsForTrace(config, traceId, since) {
   if (!traceId) return [];
   const params = { limit: 100, traceId };
@@ -445,11 +452,17 @@ async function verifyMetricObservations(config, found, { since, target, marker =
     throw new Error(`Metric verification failed for ${target}: Skill Use observations should not be emitted as standalone metrics.`);
   }
 
-  if (!interactions.length) {
-    throw new Error(`Metric verification failed for ${target}: Agent Turn observation was not found for trace ${traceId || found.id}.`);
-  }
-
-  const byInteractionId = new Map();
+  if (!interactions.length) {
+    throw new Error(`Metric verification failed for ${target}: Agent Turn observation was not found for trace ${traceId || found.id}.`);
+  }
+
+  const expectedName = expectedAgentTurnName(target);
+  if (!interactions.some((item) => item?.name === expectedName)) {
+    const names = interactions.map((item) => item?.name || "<unnamed>").join(", ");
+    throw new Error(`Metric verification failed for ${target}: expected observation name ${expectedName}, found ${names}.`);
+  }
+
+  const byInteractionId = new Map();
   const seenInteractionIds = new Set();
   for (const item of interactions) {
     const interactionId = metricInteractionId(item, target);
@@ -619,12 +632,12 @@ async function main() {
       }
     }
 
-    const found = await pollLangfuse(config, marker, { ...args, since, target });
-    console.log(`[OK] Langfuse marker found for ${target}: ${found.kind} ${found.id || ""}`.trim());
-    const metrics = await verifyMetricObservations(config, found, { since, target, marker });
-    console.log(`[OK] Langfuse metrics found for ${target}: Agent Turn x${metrics.interactionCount}`);
-    results.push({ target, marker, langfuse: { kind: found.kind, id: found.id || "", traceId: metrics.traceId }, metrics });
-  }
+    const found = await pollLangfuse(config, marker, { ...args, since, target });
+    console.log(`[OK] Langfuse marker found for ${target}: ${found.kind} ${found.id || ""}`.trim());
+    const metrics = await verifyMetricObservations(config, found, { since, target, marker });
+    console.log(`[OK] Langfuse metrics found for ${target}: ${expectedAgentTurnName(target)} x${metrics.interactionCount}`);
+    results.push({ target, marker, langfuse: { kind: found.kind, id: found.id || "", traceId: metrics.traceId }, metrics });
+  }
 
   console.log("");
   console.log(JSON.stringify({ ok: true, package: packageJson.name, marker, results }, null, 2));

package/scripts/verify-update-runtime.mjs

@@ -0,0 +1,162 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { extractVersionFromNpmMetadata } from "./update-utils.mjs";
+import { readRuntimeState, runtimeStatePath } from "./runtime-state-utils.mjs";
+import {
+  buildVerifyUpdateResults,
+  normalizeVerifyTargets,
+  targetLabel,
+  verifyUpdateExitCode,
+} from "./verify-update-utils.mjs";
+
+const colorEnabled = process.stdout.isTTY && process.env.NO_COLOR !== "1";
+const ansi = (code) => (colorEnabled ? `\x1b[${code}m` : "");
+const t = {
+  reset: ansi(0),
+  bold: ansi(1),
+  green: ansi("92"),
+  gold: ansi("93"),
+  red: ansi("91"),
+  cyan: ansi("96"),
+};
+
+function paint(text, ...styles) {
+  if (!colorEnabled) return text;
+  return `${styles.join("")}${text}${t.reset}`;
+}
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (const raw of argv) {
+    if (!raw.startsWith("--")) {
+      args._.push(raw);
+      continue;
+    }
+    const eq = raw.indexOf("=");
+    if (eq === -1) args[raw.slice(2)] = true;
+    else args[raw.slice(2, eq)] = raw.slice(eq + 1);
+  }
+  return args;
+}
+
+function stripBom(s) {
+  return typeof s === "string" && s.charCodeAt(0) === 0xfeff ? s.slice(1) : s;
+}
+
+function readJsonIfExists(p) {
+  try {
+    if (!fs.existsSync(p)) return null;
+    const text = stripBom(fs.readFileSync(p, "utf8"));
+    if (!text.trim()) return null;
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function codexHome(home = os.homedir()) {
+  return process.env.CODEX_HOME || path.join(home, ".codex");
+}
+
+function detectInstalledTargets(home = os.homedir()) {
+  return {
+    claude: fs.existsSync(path.join(home, ".claude", "hooks", "langfuse_hook.py")),
+    opencode:
+      fs.existsSync(path.join(home, ".config", "opencode", "opencode.json")) ||
+      fs.existsSync(path.join(home, ".config", "opencode", "plugins", "opencode-plugin-langfuse")),
+    codex: fs.existsSync(path.join(codexHome(home), "hooks", "codex_langfuse_notify.py")),
+  };
+}
+
+async function latestVersion(packageName, registry = "https://registry.npmjs.org") {
+  const base = registry.replace(/\/+$/, "");
+  const response = await fetch(`${base}/${packageName}`, { headers: { accept: "application/json" } });
+  if (!response.ok) throw new Error(`npm registry ${response.status} ${response.statusText}`);
+  return extractVersionFromNpmMetadata(await response.json());
+}
+
+function targetsToVerify(targetArg, installed, runtimeTargets) {
+  const requested = normalizeVerifyTargets(targetArg);
+  if (String(targetArg || "all").trim().toLowerCase() !== "all") return { targets: requested, skipped: [] };
+
+  const targets = requested.filter((target) => installed[target] || runtimeTargets[target]);
+  const skipped = requested
+    .filter((target) => !installed[target] && !runtimeTargets[target])
+    .map((target) => ({ target, reason: "not_detected" }));
+  return { targets, skipped };
+}
+
+function printResult(result) {
+  const label = targetLabel(result.target);
+  if (result.status === "current") {
+    console.log(paint(`[OK] ${label} Langfuse runtime is current: ${result.packageName}@${result.installedVersion}`, t.bold, t.green));
+    if (result.updatedAt) console.log(`[INFO] ${label} updatedAt: ${result.updatedAt}`);
+    return;
+  }
+  if (result.status === "outdated") {
+    console.log(
+      paint(
+        `[FAIL] ${label} Langfuse runtime is outdated: installed ${result.packageName}@${result.installedVersion}, latest ${result.packageName}@${result.latestVersion}`,
+        t.bold,
+        t.red,
+      ),
+    );
+    const fix =
+      result.packageName === "oh-aicoding-tool"
+        ? `npx oh-aicoding-tool@latest langfuse update ${result.target}`
+        : `npx oh-langfuse@latest update ${result.target}`;
+    console.log(paint(`[FIX] Run: ${fix}`, t.bold, t.cyan));
+    return;
+  }
+  console.log(paint(`[FAIL] ${label} Langfuse runtime record is missing.`, t.bold, t.red));
+  console.log(`[INFO] Runtime state: ${runtimeStatePath()}`);
+  console.log(paint(`[FIX] Run: npx oh-langfuse@latest update ${result.target}`, t.bold, t.cyan));
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const targetArg = args._[0] || "all";
+  const state = readRuntimeState();
+  const runtimeTargets = state.targets || {};
+  const installed = detectInstalledTargets();
+  const { targets, skipped } = targetsToVerify(targetArg, installed, runtimeTargets);
+
+  for (const item of skipped) {
+    console.log(paint(`[SKIP] ${targetLabel(item.target)} not installed`, t.bold, t.gold));
+  }
+
+  if (!targets.length) {
+    console.log(paint("[FAIL] No installed Langfuse runtime targets were found.", t.bold, t.red));
+    console.log(paint("[FIX] Run setup or update first: npx oh-langfuse@latest update all", t.bold, t.cyan));
+    return 2;
+  }
+
+  let latestVersions = {};
+  try {
+    const packageNames = new Set(["oh-langfuse"]);
+    for (const target of targets) {
+      const packageName = String(runtimeTargets[target]?.packageName || "oh-langfuse").trim() || "oh-langfuse";
+      packageNames.add(packageName);
+    }
+    for (const packageName of packageNames) {
+      latestVersions[packageName] = await latestVersion(packageName, args.npmRegistry);
+    }
+  } catch (error) {
+    console.error(paint(`[FAIL] Could not query npm latest version: ${error.message}`, t.bold, t.red));
+    return 3;
+  }
+
+  const results = buildVerifyUpdateResults({ targets, runtimeTargets, latestVersions });
+  for (const result of results) printResult(result);
+  return verifyUpdateExitCode(results);
+}
+
+main()
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((error) => {
+    console.error(paint(`[FAIL] ${error?.message || String(error)}`, t.bold, t.red));
+    process.exitCode = 3;
+  });

package/scripts/verify-update-utils.mjs

@@ -0,0 +1,60 @@
+import { compareSemver } from "./update-utils.mjs";
+
+export const VERIFY_TARGETS = ["claude", "opencode", "codex"];
+
+export function targetLabel(target) {
+  if (target === "claude") return "Claude";
+  if (target === "opencode") return "OpenCode";
+  if (target === "codex") return "Codex";
+  return target;
+}
+
+export function normalizeVerifyTargets(target = "all") {
+  const normalized = String(target || "all").trim().toLowerCase();
+  if (normalized === "all") return [...VERIFY_TARGETS];
+  if (!VERIFY_TARGETS.includes(normalized)) {
+    throw new Error(`Unsupported verify-update target: ${target}`);
+  }
+  return [normalized];
+}
+
+export function buildVerifyUpdateResults({
+  targets = [],
+  runtimeTargets = {},
+  latestVersion = "",
+  latestVersions = {},
+  defaultPackageName = "oh-langfuse",
+} = {}) {
+  return targets.map((target) => {
+    const record = runtimeTargets?.[target] || {};
+    const packageName = String(record.packageName || defaultPackageName).trim() || defaultPackageName;
+    const installedVersion = String(record.packageVersion || "").trim();
+    const packageLatestVersion = String(latestVersions[packageName] || latestVersion || "").trim();
+    const updatedAt = String(record.updatedAt || "").trim();
+    if (!installedVersion) {
+      return {
+        target,
+        packageName,
+        status: "missing",
+        installedVersion: "",
+        latestVersion: packageLatestVersion,
+        updatedAt,
+      };
+    }
+    const cmp = compareSemver(installedVersion, packageLatestVersion);
+    return {
+      target,
+      packageName,
+      status: cmp < 0 ? "outdated" : "current",
+      installedVersion,
+      latestVersion: packageLatestVersion,
+      updatedAt,
+    };
+  });
+}
+
+export function verifyUpdateExitCode(results = []) {
+  if (results.some((item) => item.status === "missing")) return 2;
+  if (results.some((item) => item.status === "outdated")) return 1;
+  return 0;
+}