oh-langfuse 0.1.57 → 0.1.59

package/README.md

@@ -2,7 +2,7 @@
 
 `oh-langfuse` 是用于给 Claude Code、OpenCode、Codex 配置 Langfuse 追踪的命令行工具。它既提供交互式安装向导，也支持 `setup`、`check`、`update`、`auto-update` 等直接命令。
 
-当前 npm 版本：`0.1.57`
+当前 npm 版本：`0.1.59`
 
 ## 能做什么
 
@@ -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.59
+[FAIL] Codex Langfuse runtime is outdated: installed 0.1.58, latest 0.1.59
+[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`
@@ -167,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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "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/real-self-verify.mjs

@@ -632,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/update-langfuse-runtime.mjs

@@ -254,7 +254,9 @@ async function main() {
   printUpdateSummary(targets);
 }
 
-main().catch((error) => {
-  console.error(`[FAIL] ${error?.message || String(error)}`);
-  process.exit(1);
-});
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(`[FAIL] ${error?.message || String(error)}`);
+    process.exit(1);
+  });

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.exit(code);
+  })
+  .catch((error) => {
+    console.error(paint(`[FAIL] ${error?.message || String(error)}`, t.bold, t.red));
+    process.exit(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;
+}