oh-langfuse 0.1.25 → 0.1.26

package/scripts/update-langfuse-runtime.mjs

@@ -0,0 +1,178 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { extractVersionFromNpmMetadata, selectUpdateTargets } from "./update-utils.mjs";
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf8"));
+
+const DEFAULT_LANGFUSE_BASE_URL = "http://120.46.221.227:3000";
+const DEFAULT_LANGFUSE_PUBLIC_KEY = "pk-lf-da0c90a7-6e93-4eb7-bb86-c1047c8d187d";
+const DEFAULT_LANGFUSE_SECRET_KEY = "sk-lf-0269b85d-bfdc-442c-bfa3-e737954e3315";
+
+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 detectInstalledTargets(home = os.homedir()) {
+  const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
+  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, "hooks", "codex_langfuse_notify.py")),
+  };
+}
+
+function claudeConfig(home) {
+  const settings = readJsonIfExists(path.join(home, ".claude", "settings.json")) || {};
+  const env = settings.env || {};
+  return {
+    baseUrl: env.LANGFUSE_BASEURL || env.LANGFUSE_HOST || env.CC_LANGFUSE_BASE_URL,
+    publicKey: env.LANGFUSE_PUBLIC_KEY,
+    secretKey: env.LANGFUSE_SECRET_KEY,
+    userId: env.LANGFUSE_USER_ID || env.CC_USER_ID || env.CC_LANGFUSE_USER_ID || env.CLAUDE_USER_ID,
+  };
+}
+
+function codexConfig(home) {
+  const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
+  const config = readJsonIfExists(path.join(codexHome, "langfuse", "config.json")) || {};
+  return {
+    baseUrl: config.baseUrl,
+    publicKey: config.publicKey,
+    secretKey: config.secretKey,
+    userId: config.userId,
+  };
+}
+
+function opencodeConfig(home) {
+  const config = readJsonIfExists(path.join(home, ".config", "opencode-plugin-langfuse", "config.json")) || {};
+  return {
+    baseUrl: process.env.LANGFUSE_BASEURL || process.env.LANGFUSE_HOST,
+    publicKey: process.env.LANGFUSE_PUBLIC_KEY,
+    secretKey: process.env.LANGFUSE_SECRET_KEY,
+    userId: config.userId || config.usrid || process.env.LANGFUSE_USER_ID,
+  };
+}
+
+function mergedConfig(target, args) {
+  const home = os.homedir();
+  const existing = target === "claude" ? claudeConfig(home) : target === "codex" ? codexConfig(home) : opencodeConfig(home);
+  const config = {
+    baseUrl: args.langfuseBaseUrl || args.langfuseHost || args.host || existing.baseUrl || process.env.LANGFUSE_BASEURL || DEFAULT_LANGFUSE_BASE_URL,
+    publicKey: args.publicKey || existing.publicKey || process.env.LANGFUSE_PUBLIC_KEY || DEFAULT_LANGFUSE_PUBLIC_KEY,
+    secretKey: args.secretKey || existing.secretKey || process.env.LANGFUSE_SECRET_KEY || DEFAULT_LANGFUSE_SECRET_KEY,
+    userId: args.userId || args.userid || existing.userId || process.env.LANGFUSE_USER_ID || process.env.CC_USER_ID || "",
+  };
+  if (!config.userId) throw new Error(`Missing user id for ${target}; provide --userId=<employee-id> or run setup first.`);
+  return config;
+}
+
+async function latestVersion(registry = "https://registry.npmjs.org") {
+  const base = registry.replace(/\/+$/, "");
+  const response = await fetch(`${base}/oh-langfuse`, { headers: { accept: "application/json" } });
+  if (!response.ok) throw new Error(`npm registry ${response.status} ${response.statusText}`);
+  return extractVersionFromNpmMetadata(await response.json());
+}
+
+function runNodeScript(script, args, options = {}) {
+  const result = spawnSync(process.execPath, [path.join(rootDir, "scripts", script), ...args], {
+    cwd: rootDir,
+    stdio: "inherit",
+    windowsHide: true,
+    timeout: options.timeoutMs || 900000,
+  });
+  if ((result.status ?? 1) !== 0) {
+    throw new Error(`${script} failed with exit code ${result.status ?? 1}`);
+  }
+}
+
+function setupArgs(target, config, args) {
+  const out = [
+    `--userId=${config.userId}`,
+    `--langfuseBaseUrl=${config.baseUrl}`,
+    `--publicKey=${config.publicKey}`,
+    `--secretKey=${config.secretKey}`,
+  ];
+  if (args.pipIndexUrl) out.push(`--pipIndexUrl=${args.pipIndexUrl}`);
+  if (args.npmRegistry && target === "opencode") out.push(`--npmRegistry=${args.npmRegistry}`);
+  if ((args["skip-plugin-install"] || args.skipPluginInstall) && target === "opencode") out.push("--skip-plugin-install");
+  return out;
+}
+
+function setupScript(target) {
+  if (target === "claude") return "langfuse-setup.mjs";
+  if (target === "codex") return "codex-langfuse-setup.mjs";
+  return "opencode-langfuse-setup.mjs";
+}
+
+function checkScript(target) {
+  if (target === "claude") return "langfuse-check.mjs";
+  if (target === "codex") return "codex-langfuse-check.mjs";
+  return "opencode-langfuse-check.mjs";
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const targetArg = args._[0] || "all";
+  const installed = detectInstalledTargets();
+  const targets = selectUpdateTargets(targetArg, installed);
+  if (!targets.length) {
+    throw new Error("No installed oh-langfuse targets were detected. Run setup first, or specify a target with credentials.");
+  }
+
+  console.log(`[INFO] Running package: ${packageJson.name}@${packageJson.version}`);
+  try {
+    const latest = await latestVersion(args.npmRegistry);
+    console.log(`[INFO] npm latest: ${latest}`);
+    if (latest !== packageJson.version) {
+      console.log(`[INFO] To update a global install, run: npm install -g oh-langfuse@latest`);
+    }
+  } catch (error) {
+    console.log(`[WARN] Could not query npm latest version: ${error.message}`);
+  }
+
+  for (const target of targets) {
+    console.log("");
+    console.log(`[INFO] Updating ${target} runtime...`);
+    const config = mergedConfig(target, args);
+    runNodeScript(setupScript(target), setupArgs(target, config, args));
+    if (!args["skip-check"]) {
+      runNodeScript(checkScript(target), []);
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(`[FAIL] ${error?.message || String(error)}`);
+  process.exit(1);
+});

package/scripts/update-utils.mjs

@@ -0,0 +1,20 @@
+const ALLOWED_TARGETS = new Set(["claude", "opencode", "codex"]);
+
+export function extractVersionFromNpmMetadata(metadata) {
+  const latest = metadata?.["dist-tags"]?.latest;
+  if (typeof latest !== "string" || !latest.trim()) {
+    throw new Error("npm registry metadata does not include dist-tags.latest");
+  }
+  return latest.trim();
+}
+
+export function selectUpdateTargets(target = "all", installed = {}) {
+  const normalized = String(target || "all").trim().toLowerCase();
+  if (normalized === "all") {
+    return ["claude", "opencode", "codex"].filter((name) => Boolean(installed[name]));
+  }
+  if (!ALLOWED_TARGETS.has(normalized)) {
+    throw new Error(`Unsupported update target: ${target}`);
+  }
+  return [normalized];
+}