oh-langfuse 0.1.23 → 0.1.25

package/README.md

@@ -2,7 +2,7 @@
 
 `oh-langfuse` 是用于给 Claude Code、OpenCode 和 Codex 配置 Langfuse 追踪的命令行工具。它提供交互式安装向导，也支持 `setup` / `check` 直接命令，方便在用户机器上安装、修复和校验配置。
 
-当前 npm 版本：`0.1.23`
+当前 npm 版本：`0.1.25`
 
 ## 能做什么
 

package/SELF_VERIFY.md

@@ -0,0 +1,25 @@
+# Real self verification
+
+`npm run self:verify` is an end-to-end validation path. It does not only inspect environment variables or local config files.
+
+The script:
+
+1. Runs the real setup command for the selected target unless `--skip-install` is set.
+2. Starts the real Claude Code / OpenCode / Codex CLI with a unique marker.
+3. Polls Langfuse Public API with the configured public/secret key until that marker appears in traces or observations.
+
+Examples:
+
+```bash
+npm run self:verify -- --targets=opencode --userId=h00613222
+npm run self:verify -- --targets=claude,opencode,codex --userId=h00613222
+```
+
+Useful options:
+
+- `--opencodeCmd=<path>`, `--claudeCmd=<path>`, `--codexCmd=<path>`: use a specific CLI binary.
+- `--skip-install`: do not run setup before triggering the CLI.
+- `--skip-trigger`: only poll Langfuse for an existing marker.
+- `--timeoutMs=180000`: adjust Langfuse polling timeout.
+
+This command writes real user-level tool configuration and sends a real validation trace to Langfuse.

package/bin/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import fs from "node:fs";
-import path from "node:path";
-import { createInterface } from "node:readline/promises";
-import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import { fileURLToPath } from "url";
+import { spawnSync } from "child_process";
 
 const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const scriptsDir = path.join(rootDir, "scripts");
@@ -13,6 +13,31 @@ const DEFAULT_LANGFUSE_PUBLIC_KEY = "pk-lf-da0c90a7-6e93-4eb7-bb86-c1047c8d187d"
 const DEFAULT_LANGFUSE_SECRET_KEY = "sk-lf-0269b85d-bfdc-442c-bfa3-e737954e3315";
 const USER_ID_PATTERN = /^[a-z](?:\d{8}|wx\d{7})$/;
 const USER_ID_PATTERN_TEXT = "^[a-z](?:\\d{8}|wx\\d{7})$";
+
+function nodeMajorVersion() {
+  const raw = process.versions && process.versions.node ? process.versions.node : "0.0.0";
+  return Number.parseInt(raw.split(".")[0], 10) || 0;
+}
+
+function assertSupportedNode() {
+  if (nodeMajorVersion() >= 16) return;
+  console.error("oh-langfuse requires Node.js >= 16.");
+  console.error(`Current Node.js: ${process.version}`);
+  console.error("Please upgrade Node.js, then run: npx oh-langfuse@latest");
+  process.exit(1);
+}
+
+function createPromptInterface(options) {
+  const rl = readline.createInterface(options);
+  return {
+    question(query) {
+      return new Promise((resolve) => rl.question(query, resolve));
+    },
+    close() {
+      rl.close();
+    },
+  };
+}
 
 const colorEnabled = process.stdout.isTTY && process.env.NO_COLOR !== "1";
 const ansi = (code) => (colorEnabled ? `\x1b[${code}m` : "");
@@ -260,7 +285,7 @@ function runNodeScript(name, args = [], { dryRun = false } = {}) {
   console.log(paint("Running installer...", t.bold, t.teal));
   console.log(paint("─".repeat(Math.min(terminalWidth(), 64)), t.panel));
   const r = spawnSync(process.execPath, [target, ...args], { stdio: "inherit" });
-  return r.status ?? (r.error ? 1 : 0);
+  return r.status != null ? r.status : r.error ? 1 : 0;
 }
 
 async function askText(rl, label, { defaultValue = "", required = false, validate = null, invalidMessage = "" } = {}) {
@@ -294,7 +319,7 @@ async function askYesNo(rl, label, { defaultValue = false } = {}) {
 
 function rawKeySeq(raw) {
   if (Buffer.isBuffer(raw)) return raw.toString("latin1");
-  return String(raw ?? "");
+  return String(raw == null ? "" : raw);
 }
 
 function parseRawKey(raw) {
@@ -680,8 +705,8 @@ async function checkMenu(rl, options) {
   return claude || opencode || codex;
 }
 
-async function interactiveMain(options) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+async function interactiveMain(options) {
+  const rl = createPromptInterface({ input: process.stdin, output: process.stdout });
   try {
     const action = await askChoice(
       rl,
@@ -727,9 +752,9 @@ async function setupLangfuseMenu(rl, options) {
   if (!targets.length) return 0;
   const config = await collectSharedConfig(rl, options);
   let code = 0;
-  if (targets.includes("claude")) code ||= await setupClaude(rl, { ...options, config });
-  if (targets.includes("opencode")) code ||= await setupOpenCode(rl, { ...options, config });
-  if (targets.includes("codex")) code ||= await setupCodex(rl, { ...options, config });
+  if (targets.includes("claude")) code = code || await setupClaude(rl, { ...options, config });
+  if (targets.includes("opencode")) code = code || await setupOpenCode(rl, { ...options, config });
+  if (targets.includes("codex")) code = code || await setupCodex(rl, { ...options, config });
   return code;
 }
 
@@ -791,7 +816,7 @@ async function main() {
 
   if (!cmd) return await interactiveMain(options);
 
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createPromptInterface({ input: process.stdin, output: process.stdout });
   try {
     if (cmd === "setup" && target === "claude") return await setupClaude(rl, options);
     if (cmd === "setup" && target === "opencode") return await setupOpenCode(rl, options);
@@ -815,9 +840,11 @@ async function main() {
   return 1;
 }
 
-main()
-  .then((code) => process.exit(code))
-  .catch((err) => {
-    console.error(paint(err?.message || String(err), t.red));
-    process.exit(1);
-  });
+assertSupportedNode();
+
+main()
+  .then((code) => process.exit(code))
+  .catch((err) => {
+    console.error(paint((err && err.message) || String(err), t.red));
+    process.exit(1);
+  });

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "private": false,
   "type": "module",
-  "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",
-  "bin": {
+  "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",
+  "engines": {
+    "node": ">=16"
+  },
+  "bin": {
     "oh-langfuse": "bin/cli.js",
     "code-tool-langfuse": "bin/cli.js"
   },
@@ -18,10 +21,12 @@
     "scripts/opencode-langfuse-check.mjs",
     "scripts/opencode-langfuse-run.mjs",
     "scripts/opencode-langfuse-setup.mjs",
-    "scripts/resolve-opencode-cli.mjs",
+    "scripts/resolve-opencode-cli.mjs",
+    "scripts/real-self-verify.mjs",
     "langfuse_hook.py",
     "codex_langfuse_notify.py",
-    "README.md",
+    "README.md",
+    "SELF_VERIFY.md",
     "CODEX_LANGFUSE_PLAN.md",
     "setup-langfuse.bat",
     "setup-langfuse.sh"
@@ -42,8 +47,9 @@
     "opencode:langfuse:run": "node scripts/opencode-langfuse-run.mjs",
     "codex:setup": "node scripts/codex-langfuse-setup.mjs",
     "codex:check": "node scripts/codex-langfuse-check.mjs",
-    "codex:langfuse:setup": "node scripts/codex-langfuse-setup.mjs",
-    "codex:langfuse:check": "node scripts/codex-langfuse-check.mjs"
+    "codex:langfuse:setup": "node scripts/codex-langfuse-setup.mjs",
+    "codex:langfuse:check": "node scripts/codex-langfuse-check.mjs",
+    "self:verify": "node scripts/real-self-verify.mjs"
   },
   "dependencies": {}
 }

package/scripts/langfuse-check.mjs

@@ -26,6 +26,14 @@ function launcherPath(hooksDir) {
     : path.join(hooksDir, "run-langfuse-hook.sh");
 }
 
+function expectedHookCommands(launcher) {
+  if (process.platform !== "win32") return [path.normalize(launcher)];
+  return [
+    path.normalize(launcher),
+    `cmd.exe /d /s /c "${launcher.replace(/"/g, '""')}"`
+  ];
+}
+
 function findLangfuseHook(settings) {
   const stopHooks = settings?.hooks?.Stop;
   if (!Array.isArray(stopHooks)) return null;
@@ -110,7 +118,12 @@ function main() {
   const hook = findLangfuseHook(settings);
   addResult(results, "hooks.Stop contains Langfuse", !!hook, hook ? "OK" : "missing", "Run setup again to register the Stop hook.");
 
-  const launcherFormOk = !!hook && path.normalize(hook.command) === path.normalize(expectedLauncher) && !hook.args?.length;
+  const expectedCommands = expectedHookCommands(expectedLauncher);
+  const hookCommand = hook?.command || "";
+  const launcherFormOk =
+    !!hook &&
+    expectedCommands.some((cmd) => path.normalize(hookCommand) === path.normalize(cmd)) &&
+    !hook.args?.length;
   addResult(
     results,
     "hook command form",

package/scripts/langfuse-setup.mjs

@@ -135,6 +135,11 @@ function cmdQuote(s) {
   return `"${String(s).replace(/"/g, '""')}"`;
 }
 
+function hookCommandForClaude(launcher) {
+  if (process.platform !== "win32") return launcher;
+  return `cmd.exe /d /s /c ${cmdQuote(launcher)}`;
+}
+
 function shQuote(s) {
   return `'${String(s).replace(/'/g, "'\\''")}'`;
 }
@@ -299,7 +304,7 @@ async function main() {
           hooks: [
             {
               type: "command",
-              command: hookLauncher
+              command: hookCommandForClaude(hookLauncher)
             }
           ]
         }

package/scripts/real-self-verify.mjs

@@ -0,0 +1,433 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { resolveOpencodeCli } from "./resolve-opencode-cli.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 (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    if (!raw.startsWith("--")) {
+      args._.push(raw);
+      continue;
+    }
+    const eq = raw.indexOf("=");
+    if (eq !== -1) {
+      args[raw.slice(2, eq)] = raw.slice(eq + 1);
+      continue;
+    }
+    const key = raw.slice(2);
+    const next = argv[i + 1];
+    if (next && !next.startsWith("--")) {
+      args[key] = next;
+      i += 1;
+    } else {
+      args[key] = true;
+    }
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`${packageJson.name} real self verification`);
+  console.log("");
+  console.log("Usage:");
+  console.log("  npm run self:verify -- --targets=opencode --userId=h00613222");
+  console.log("  node scripts/real-self-verify.mjs --targets=claude,opencode,codex --userId=h00613222");
+  console.log("");
+  console.log("What it does:");
+  console.log("  1. Runs the real setup command for each target unless --skip-install is set.");
+  console.log("  2. Starts the actual Claude/OpenCode/Codex CLI with a unique validation marker.");
+  console.log("  3. Polls Langfuse Public API until that marker appears in traces/observations.");
+  console.log("");
+  console.log("Options:");
+  console.log("  --targets=opencode,claude,codex");
+  console.log("  --userId=<id>                    Required unless LANGFUSE_USER_ID is set.");
+  console.log("  --langfuseBaseUrl=<url>           Defaults to package default or LANGFUSE_BASEURL.");
+  console.log("  --publicKey=<key>                 Defaults to package default or LANGFUSE_PUBLIC_KEY.");
+  console.log("  --secretKey=<key>                 Defaults to package default or LANGFUSE_SECRET_KEY.");
+  console.log("  --marker=<text>                   Override generated validation marker.");
+  console.log("  --timeoutMs=180000                Langfuse polling timeout.");
+  console.log("  --triggerTimeoutMs=300000         Per CLI invocation timeout.");
+  console.log("  --skip-install                    Do not run setup first.");
+  console.log("  --skip-trigger                    Only install and poll for a pre-existing marker.");
+  console.log("  --allow-trigger-failure           Poll Langfuse even if the CLI command exits non-zero.");
+  console.log("  --opencodeCmd=<path>              Override OpenCode CLI path.");
+  console.log("  --claudeCmd=<path>                Override Claude CLI path.");
+  console.log("  --codexCmd=<path>                 Override Codex CLI path.");
+  console.log("  --prompt=<text>                   Override the validation prompt.");
+}
+
+function splitTargets(raw) {
+  const value = String(raw || "opencode").trim();
+  const out = value
+    .split(/[, ]+/)
+    .map((x) => x.trim().toLowerCase())
+    .filter(Boolean);
+  const allowed = new Set(["claude", "opencode", "codex"]);
+  for (const target of out) {
+    if (!allowed.has(target)) throw new Error(`Unsupported target: ${target}`);
+  }
+  return out.length ? [...new Set(out)] : ["opencode"];
+}
+
+function makeMarker() {
+  return `real-self-verify-${packageJson.name}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+}
+
+function shellNeeded(command) {
+  return process.platform === "win32" && /\.(cmd|bat)$/i.test(command);
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || rootDir,
+    env: { ...process.env, ...(options.env || {}) },
+    encoding: "utf8",
+    stdio: options.stdio || "pipe",
+    timeout: options.timeoutMs,
+    maxBuffer: 20 * 1024 * 1024,
+    windowsHide: true,
+    shell: shellNeeded(command),
+  });
+  return {
+    command,
+    args,
+    status: result.status ?? (result.error ? 1 : 0),
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error,
+    signal: result.signal,
+  };
+}
+
+function printRunResult(label, result) {
+  const status = result.status === 0 ? "OK" : "FAIL";
+  console.log(`[${status}] ${label}: ${result.command} ${result.args.join(" ")}`);
+  const text = `${result.stdout}\n${result.stderr}`.trim();
+  if (text) {
+    const clipped = text.length > 5000 ? `${text.slice(0, 5000)}\n...<clipped>` : text;
+    console.log(clipped);
+  }
+}
+
+function findOnPath(names) {
+  for (const name of names) {
+    const probe = run(name, ["--version"], { timeoutMs: 15000 });
+    if (probe.status === 0) return name;
+  }
+  return "";
+}
+
+function configFromArgs(args) {
+  return {
+    baseUrl:
+      String(args.langfuseBaseUrl || args.langfuseHost || args.host || process.env.LANGFUSE_BASEURL || process.env.LANGFUSE_HOST || DEFAULT_LANGFUSE_BASE_URL),
+    publicKey: String(args.publicKey || process.env.LANGFUSE_PUBLIC_KEY || DEFAULT_LANGFUSE_PUBLIC_KEY),
+    secretKey: String(args.secretKey || process.env.LANGFUSE_SECRET_KEY || DEFAULT_LANGFUSE_SECRET_KEY),
+    userId: String(args.userId || args.userid || process.env.LANGFUSE_USER_ID || process.env.CC_USER_ID || "").trim(),
+  };
+}
+
+function setupTarget(target, config, args) {
+  const cli = path.join(rootDir, "bin", "cli.js");
+  const setupArgs = [
+    cli,
+    "setup",
+    target,
+    "--yes",
+    `--userId=${config.userId}`,
+    `--langfuseBaseUrl=${config.baseUrl}`,
+    `--publicKey=${config.publicKey}`,
+    `--secretKey=${config.secretKey}`,
+  ];
+  if (args.npmRegistry) setupArgs.push(`--npmRegistry=${args.npmRegistry}`);
+  if (args.pipIndexUrl) setupArgs.push(`--pipIndexUrl=${args.pipIndexUrl}`);
+  if (args["skip-plugin-install"]) setupArgs.push("--skip-plugin-install");
+  if (args["no-set-env"]) setupArgs.push("--no-set-env");
+  const targetCmd = target === "opencode" ? args.opencodeCmd || args.cmd : args.cmd;
+  if (targetCmd) setupArgs.push(`--cmd=${targetCmd}`);
+  const result = run(process.execPath, setupArgs, { stdio: "inherit", timeoutMs: Number(args.setupTimeoutMs || 600000) });
+  return result.status;
+}
+
+function validationPrompt(marker, target, customPrompt) {
+  if (customPrompt) return String(customPrompt).replaceAll("{marker}", marker).replaceAll("{target}", target);
+  return [
+    `This is an automated real self-verification run for ${packageJson.name}.`,
+    `Validation marker: ${marker}`,
+    "Reply with the validation marker exactly once and do not run tools.",
+  ].join("\n");
+}
+
+function triggerClaude(prompt, args, env) {
+  const cmd = String(args.claudeCmd || findOnPath(process.platform === "win32" ? ["claude.cmd", "claude"] : ["claude"]));
+  if (!cmd) return { status: 127, stdout: "", stderr: "Claude CLI not found. Set --claudeCmd=<path>.", command: "claude", args: [] };
+  const candidates = [
+    ["-p", prompt],
+    ["--print", prompt],
+  ];
+  let last = null;
+  for (const candidate of candidates) {
+    last = run(cmd, candidate, { env, timeoutMs: Number(args.triggerTimeoutMs || 300000) });
+    if (last.status === 0) return last;
+  }
+  return last;
+}
+
+function triggerOpenCode(prompt, args, env) {
+  const cmd = resolveOpencodeCli(args.opencodeCmd || args.cmd);
+  if (!cmd) return { status: 127, stdout: "", stderr: "OpenCode CLI not found. Set --opencodeCmd=<path>.", command: "opencode", args: [] };
+  const candidates = [
+    ["run", "--format", "json", "--print-logs", "--log-level", "INFO", prompt],
+    ["run", "--format", "json", prompt],
+    ["run", prompt],
+    [prompt],
+  ];
+  let last = null;
+  for (const candidate of candidates) {
+    last = run(cmd, candidate, { env, timeoutMs: Number(args.triggerTimeoutMs || 300000) });
+    if (last.status === 0) return last;
+  }
+  return last;
+}
+
+function triggerCodex(prompt, args, env) {
+  const cmd = String(args.codexCmd || findOnPath(process.platform === "win32" ? ["codex.cmd", "codex"] : ["codex"]));
+  if (!cmd) return { status: 127, stdout: "", stderr: "Codex CLI not found. Set --codexCmd=<path>.", command: "codex", args: [] };
+  const candidates = [
+    ["exec", prompt],
+    ["exec", "--skip-git-repo-check", prompt],
+  ];
+  let last = null;
+  for (const candidate of candidates) {
+    last = run(cmd, candidate, { env, timeoutMs: Number(args.triggerTimeoutMs || 300000) });
+    if (last.status === 0) return last;
+  }
+  return last;
+}
+
+function apiBase(baseUrl) {
+  const trimmed = String(baseUrl || "").replace(/\/+$/, "");
+  return trimmed.endsWith("/api/public") ? trimmed : `${trimmed}/api/public`;
+}
+
+function basicAuth(publicKey, secretKey) {
+  return `Basic ${Buffer.from(`${publicKey}:${secretKey}`, "utf8").toString("base64")}`;
+}
+
+async function langfuseGet(config, pathname, params = {}) {
+  const url = new URL(`${apiBase(config.baseUrl)}${pathname}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null && String(value) !== "") url.searchParams.set(key, String(value));
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), Number(process.env.LANGFUSE_VERIFY_REQUEST_TIMEOUT_MS || 15000));
+  const response = await fetch(url, {
+    headers: {
+      accept: "application/json",
+      authorization: basicAuth(config.publicKey, config.secretKey),
+    },
+    signal: controller.signal,
+  }).finally(() => clearTimeout(timeout));
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    const error = new Error(`Langfuse API ${response.status} ${response.statusText}: ${body.slice(0, 500)}`);
+    error.status = response.status;
+    throw error;
+  }
+  return await response.json();
+}
+
+async function langfuseGetLenient(config, pathname, params = {}) {
+  try {
+    return await langfuseGet(config, pathname, params);
+  } catch (error) {
+    if (error.status !== 400) throw error;
+    const fallback = {};
+    for (const key of ["limit", "page", "userId", "fields"]) {
+      if (params[key] !== undefined) fallback[key] = params[key];
+    }
+    return await langfuseGet(config, pathname, fallback);
+  }
+}
+
+function dataArray(value) {
+  if (Array.isArray(value)) return value;
+  if (Array.isArray(value?.data)) return value.data;
+  if (Array.isArray(value?.items)) return value.items;
+  return [];
+}
+
+function containsMarker(value, marker) {
+  try {
+    return JSON.stringify(value).includes(marker);
+  } catch {
+    return false;
+  }
+}
+
+function idOf(value) {
+  return value?.id || value?.traceId || value?.trace_id || "";
+}
+
+async function findLangfuseMarker(config, marker, { since, target }) {
+  const baseParams = {
+    limit: 100,
+    fromTimestamp: since.toISOString(),
+  };
+  const traceQueries = [
+    { ...baseParams, userId: config.userId },
+    baseParams,
+  ];
+
+  for (const params of traceQueries) {
+    let traces;
+    try {
+      traces = await langfuseGetLenient(config, "/traces", params);
+    } catch (error) {
+      if (error.status === 404) continue;
+      throw error;
+    }
+    for (const trace of dataArray(traces)) {
+      if (containsMarker(trace, marker)) return { kind: "trace-list", target, id: idOf(trace), item: trace };
+    }
+    for (const trace of dataArray(traces).slice(0, 25)) {
+      const id = idOf(trace);
+      if (!id) continue;
+      try {
+        const detail = await langfuseGet(config, `/traces/${encodeURIComponent(id)}`);
+        if (containsMarker(detail, marker)) return { kind: "trace-detail", target, id, item: detail };
+      } catch (error) {
+        if (error.status !== 404) throw error;
+      }
+    }
+  }
+
+  const observationQueries = [
+    ["/observations", { ...baseParams, userId: config.userId }],
+    ["/observations", baseParams],
+    ["/v2/observations", { ...baseParams, fields: "core,basic,usage", userId: config.userId }],
+    ["/v2/observations", { ...baseParams, fields: "core,basic,usage" }],
+  ];
+  for (const [pathname, params] of observationQueries) {
+    try {
+      const observations = await langfuseGetLenient(config, pathname, params);
+      for (const observation of dataArray(observations)) {
+        if (containsMarker(observation, marker)) return { kind: pathname, target, id: idOf(observation), item: observation };
+      }
+    } catch (error) {
+      if (error.status === 404 || error.status === 400) continue;
+      throw error;
+    }
+  }
+
+  return null;
+}
+
+async function pollLangfuse(config, marker, options) {
+  const timeoutMs = Number(options.timeoutMs || 180000);
+  const pollMs = Number(options.pollMs || 5000);
+  const deadline = Date.now() + timeoutMs;
+  const since = options.since || new Date(Date.now() - 10 * 60 * 1000);
+  let lastError = null;
+
+  while (Date.now() <= deadline) {
+    try {
+      const found = await findLangfuseMarker(config, marker, { since, target: options.target });
+      if (found) return found;
+      console.log(`[WAIT] Langfuse has not returned marker yet (${marker}).`);
+    } catch (error) {
+      lastError = error;
+      console.log(`[WAIT] Langfuse query failed: ${error.message}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+
+  if (lastError) throw new Error(`Timed out waiting for marker. Last Langfuse error: ${lastError.message}`);
+  throw new Error(`Timed out waiting for marker in Langfuse: ${marker}`);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help || args.h) {
+    printHelp();
+    return 0;
+  }
+
+  const config = configFromArgs(args);
+  if (!config.userId) throw new Error("Missing --userId or LANGFUSE_USER_ID. Real verification needs a user id to install and filter traces.");
+  const targets = splitTargets(args.targets || args.target || args._[0]);
+  const marker = String(args.marker || makeMarker());
+  const since = new Date();
+  const results = [];
+
+  console.log(`[INFO] Package: ${packageJson.name}@${packageJson.version}`);
+  console.log(`[INFO] Targets: ${targets.join(", ")}`);
+  console.log(`[INFO] Langfuse: ${config.baseUrl}`);
+  console.log(`[INFO] User ID: ${config.userId}`);
+  console.log(`[INFO] Marker: ${marker}`);
+  console.log("");
+
+  for (const target of targets) {
+    if (!args["skip-install"]) {
+      const code = setupTarget(target, config, args);
+      if (code !== 0) throw new Error(`Setup failed for ${target} with exit code ${code}.`);
+    }
+
+    const prompt = validationPrompt(marker, target, args.prompt);
+    const env = {
+      TRACE_TO_LANGFUSE: "true",
+      LANGFUSE_PUBLIC_KEY: config.publicKey,
+      LANGFUSE_SECRET_KEY: config.secretKey,
+      LANGFUSE_BASEURL: config.baseUrl,
+      LANGFUSE_HOST: config.baseUrl,
+      LANGFUSE_USER_ID: config.userId,
+      CC_USER_ID: config.userId,
+      CC_LANGFUSE_USER_ID: config.userId,
+      CODEX_LANGFUSE_USER_ID: config.userId,
+      OHAI_REAL_SELF_VERIFY_MARKER: marker,
+      OHAI_REAL_SELF_VERIFY_TARGET: target,
+    };
+
+    if (!args["skip-trigger"]) {
+      const trigger =
+        target === "claude"
+          ? triggerClaude(prompt, args, env)
+          : target === "opencode"
+            ? triggerOpenCode(prompt, args, env)
+            : triggerCodex(prompt, args, env);
+      printRunResult(`${target} trigger`, trigger);
+      if (trigger.status !== 0 && !args["allow-trigger-failure"]) {
+        throw new Error(`${target} trigger failed before Langfuse polling. Use --allow-trigger-failure to poll anyway.`);
+      }
+    }
+
+    const found = await pollLangfuse(config, marker, { ...args, since, target });
+    console.log(`[OK] Langfuse marker found for ${target}: ${found.kind} ${found.id || ""}`.trim());
+    results.push({ target, marker, langfuse: { kind: found.kind, id: found.id || "" } });
+  }
+
+  console.log("");
+  console.log(JSON.stringify({ ok: true, package: packageJson.name, marker, results }, null, 2));
+  return 0;
+}
+
+main()
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((error) => {
+    console.error(`[FAIL] ${error?.message || String(error)}`);
+    process.exitCode = 1;
+  });