oh-langfuse 0.1.78 → 0.1.80

package/SELF_VERIFY.md

@@ -1,25 +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.
+# 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,15 +1,19 @@
 #!/usr/bin/env node
 import fs from "fs";
 import path from "path";
-import readline from "readline";
-import { fileURLToPath } from "url";
-import { spawnSync } from "child_process";
-import { resolveOpencodeCli } from "../scripts/resolve-opencode-cli.mjs";
+import readline from "readline";
+import { fileURLToPath } from "url";
+import { spawnSync } from "child_process";
+import { resolveOpencodeCli } from "../scripts/resolve-opencode-cli.mjs";
 
 const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const scriptsDir = path.join(rootDir, "scripts");
 
-const DEFAULT_LANGFUSE_BASE_URL = "http://120.46.221.227:3000";
+const DEFAULT_LANGFUSE_BASE_URL = "https://metrics.openharmonyinsight.cn";
+const LEGACY_LANGFUSE_BASE_URLS = new Set([
+  "http://120.46.221.227:3000",
+  "https://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";
 const USER_ID_PATTERN = /^[a-z](?:\d{8}|wx\d{7})$/;
@@ -119,6 +123,11 @@ function hasValue(v) {
   return typeof v === "string" && v.trim().length > 0;
 }
 
+function normalizeLegacyBaseUrl(baseUrl) {
+  const value = String(baseUrl || "").trim().replace(/\/+$/, "");
+  return LEGACY_LANGFUSE_BASE_URLS.has(value) ? DEFAULT_LANGFUSE_BASE_URL : baseUrl;
+}
+
 function normalizeUserId(v) {
   return String(v || "").trim();
 }
@@ -160,13 +169,13 @@ function detectPython() {
   return { ok: false, command: null, version: "", pipOk: false, pipVersion: "" };
 }
 
-function detectOpencode() {
-  const resolved = resolveOpencodeCli();
-  const candidates = [resolved, ...(process.platform === "win32" ? ["opencode.cmd", "opencode"] : ["opencode"])].filter(Boolean);
-  for (const cmd of candidates) {
-    const r = commandExists(cmd, ["--version"]);
-    if (r.ok) return { ok: true, command: cmd, version: r.stdout || r.stderr };
-  }
+function detectOpencode() {
+  const resolved = resolveOpencodeCli();
+  const candidates = [resolved, ...(process.platform === "win32" ? ["opencode.cmd", "opencode"] : ["opencode"])].filter(Boolean);
+  for (const cmd of candidates) {
+    const r = commandExists(cmd, ["--version"]);
+    if (r.ok) return { ok: true, command: cmd, version: r.stdout || r.stderr };
+  }
   return { ok: false, command: null, version: "" };
 }
 
@@ -508,13 +517,13 @@ async function askMultiChoice(rl, label, choices, options = {}) {
 
 function langfuseConfig(overrides = {}) {
   const config = {
-    baseUrl: envDefault("LANGFUSE_BASEURL", envDefault("LANGFUSE_HOST", DEFAULT_LANGFUSE_BASE_URL)),
+    baseUrl: normalizeLegacyBaseUrl(envDefault("LANGFUSE_BASEURL", envDefault("LANGFUSE_HOST", DEFAULT_LANGFUSE_BASE_URL))),
     publicKey: envDefault("LANGFUSE_PUBLIC_KEY", DEFAULT_LANGFUSE_PUBLIC_KEY),
     secretKey: envDefault("LANGFUSE_SECRET_KEY", DEFAULT_LANGFUSE_SECRET_KEY),
     userId: ""
   };
   for (const [key, value] of Object.entries(overrides)) {
-    if (hasValue(value)) config[key] = value;
+    if (hasValue(value)) config[key] = key === "baseUrl" ? normalizeLegacyBaseUrl(value) : value;
   }
   return config;
 }

package/codex_langfuse_notify.py

@@ -745,6 +745,155 @@ def discover_known_skills(extra_roots: Optional[List[Path]] = None) -> set:
     return names
 
 
+def collect_skill_roots(cwd: Path) -> list:
+    """Return absolute <dir>/skills paths that contain SKILL.md, found among
+    cwd itself, cwd's children, and cwd's siblings. Mirrors the OpenCode
+    opencode-skills-discover.mjs collectSkillRoots so skills cloned near the
+    working directory can be linked into the native skills dir."""
+    def _has_skill(d: Path) -> bool:
+        try:
+            if not d.is_dir():
+                return False
+            for entry in d.iterdir():
+                if entry.name == "SKILL.md" and entry.is_file():
+                    return True
+                if entry.is_dir() and not entry.name.startswith(".") and (entry / "SKILL.md").exists():
+                    return True
+        except Exception:
+            pass
+        return False
+
+    candidates = []
+    for sub in (Path("skills"), Path(".opencode") / "skills", Path(".opencode") / "skill"):
+        candidates.append(cwd / sub)
+    try:
+        for entry in cwd.iterdir():
+            if entry.is_dir() and not entry.name.startswith("."):
+                candidates.append(entry / "skills")
+    except Exception:
+        pass
+    parent = cwd.parent
+    if parent != cwd:
+        try:
+            for entry in parent.iterdir():
+                if entry.is_dir() and entry.name != cwd.name and not entry.name.startswith("."):
+                    candidates.append(entry / "skills")
+        except Exception:
+            pass
+
+    roots = []
+    seen = set()
+    for d in candidates:
+        try:
+            if _has_skill(d):
+                key = str(d.resolve())
+                if key not in seen:
+                    seen.add(key)
+                    roots.append(d.resolve())
+        except Exception:
+            continue
+    return roots
+
+
+def _skill_link_exists(link: Path) -> bool:
+    try:
+        return link.exists() or link.is_symlink()
+    except Exception:
+        return False
+
+
+def _create_skill_link(target: Path, link: Path) -> bool:
+    """Create a junction (Windows, no admin) or symlink (Unix) at link -> target.
+    Returns False if link already exists or creation failed.
+
+    On Windows we always use a directory junction (mklink /J): Codex follows
+    junctions but does not follow true symlinks for skill discovery, while
+    Claude Code follows both. Junctions do not require admin/developer mode."""
+    if _skill_link_exists(link):
+        return False
+    try:
+        link.parent.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass
+    if sys.platform == "win32":
+        try:
+            r = subprocess.run(
+                ["cmd", "/c", "mklink", "/J", str(link), str(target)],
+                capture_output=True,
+            )
+            return r.returncode == 0
+        except Exception:
+            return False
+    try:
+        os.symlink(str(target), str(link), target_is_directory=True)
+        return True
+    except OSError:
+        return False
+
+
+def _remove_skill_link(link: Path) -> None:
+    """Remove a junction/symlink we created, without touching the target."""
+    try:
+        if sys.platform == "win32":
+            subprocess.run(["cmd", "/c", "rmdir", str(link)], capture_output=True)
+        else:
+            os.unlink(str(link))
+    except Exception:
+        pass
+
+
+def link_nearby_skills(cwd: Path, native_dir: Path, state_file: Path) -> int:
+    """Symlink nearby repo skills into native_dir so the agent discovers them on
+    the next turn/session. Idempotent; skips names already present (native installs
+    or prior links). Cleans stale links we created whose target is gone. Failures
+    are swallowed so the metrics hook never breaks. Returns newly-linked count."""
+    try:
+        native_dir.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        return 0
+    state = {}
+    try:
+        if state_file.exists():
+            state = json.loads(state_file.read_text("utf-8") or "{}")
+    except Exception:
+        state = {}
+    for link_str, target_str in list(state.items()):
+        link = Path(link_str)
+        target = Path(target_str)
+        try:
+            if _skill_link_exists(link):
+                if not target.exists():
+                    _remove_skill_link(link)
+                    state.pop(link_str, None)
+            else:
+                state.pop(link_str, None)
+        except Exception:
+            pass
+    linked = 0
+    for repo_skills_dir in collect_skill_roots(cwd):
+        try:
+            for skill_dir in repo_skills_dir.iterdir():
+                if not skill_dir.is_dir() or skill_dir.name.startswith("."):
+                    continue
+                if not (skill_dir / "SKILL.md").exists():
+                    continue
+                try:
+                    target = skill_dir.resolve()
+                except Exception:
+                    continue
+                link_path = native_dir / skill_dir.name
+                if _create_skill_link(target, link_path):
+                    state[str(link_path)] = str(target)
+                    linked += 1
+        except Exception:
+            pass
+    try:
+        state_file.write_text(json.dumps(state, ensure_ascii=False), "utf-8")
+    except Exception:
+        pass
+    return linked
+
+
 def _skill_namespace(name: str) -> str:
     return name.split(":", 1)[0] if ":" in name else ""
 
@@ -1377,7 +1526,12 @@ def emit_codex_turn(
     model = first_string(turn.model, meta.get("model"), meta.get("model_provider")) or "codex"
     tool_calls = material.get("tool_calls") or []
     tool_results = material.get("tool_results") or []
-    skill_usages = detect_turn_skill_usages(material, discover_known_skills())
+    cwd = Path.cwd()
+    try:
+        known_skills = discover_known_skills(collect_skill_roots(cwd))
+    except Exception:
+        known_skills = discover_known_skills()
+    skill_usages = detect_turn_skill_usages(material, known_skills)
     interaction_id = build_interaction_id("codex", session_id, turn_num)
     skill_use_events = build_skill_use_events(interaction_id, skill_usages)
     interaction_meta = build_interaction_metadata(
@@ -1516,7 +1670,7 @@ def main() -> int:
         or os.environ.get("LANGFUSE_BASEURL")
         or os.environ.get("LANGFUSE_HOST")
         or config.get("baseUrl")
-        or "https://cloud.langfuse.com"
+        or "https://metrics.openharmonyinsight.cn"
     )
     user_id = (
         find_value(payload, ("user_id", "userId", "username", "userName"))
@@ -1595,6 +1749,12 @@ def main() -> int:
             langfuse.flush()
         except Exception:
             pass
+        # Best-effort: link nearby repo skills into ~/.codex/skills. Runs
+        # AFTER the Langfuse flush so it can never block or break metrics.
+        try:
+            link_nearby_skills(Path.cwd(), CODEX_DIR / "skills", CODEX_DIR / "skills" / ".oh-linked.json")
+        except Exception:
+            pass
         log("INFO", f"Processed {uploaded} Codex turn(s), total {ss.turn_count} for {session_path}")
         return 0
     except Exception as e:

package/langfuse_hook.py

@@ -626,6 +626,156 @@ def discover_known_skills(extra_roots: Optional[List[Path]] = None) -> set:
             continue
     return names
 
+
+def collect_skill_roots(cwd: Path) -> list:
+    """Return absolute <dir>/skills paths that contain SKILL.md, found among
+    cwd itself, cwd's children, and cwd's siblings. Mirrors the OpenCode
+    opencode-skills-discover.mjs collectSkillRoots so skills cloned near the
+    working directory can be linked into the native skills dir."""
+    def _has_skill(d: Path) -> bool:
+        try:
+            if not d.is_dir():
+                return False
+            for entry in d.iterdir():
+                if entry.name == "SKILL.md" and entry.is_file():
+                    return True
+                if entry.is_dir() and not entry.name.startswith(".") and (entry / "SKILL.md").exists():
+                    return True
+        except Exception:
+            pass
+        return False
+
+    candidates = []
+    for sub in (Path("skills"), Path(".opencode") / "skills", Path(".opencode") / "skill"):
+        candidates.append(cwd / sub)
+    try:
+        for entry in cwd.iterdir():
+            if entry.is_dir() and not entry.name.startswith("."):
+                candidates.append(entry / "skills")
+    except Exception:
+        pass
+    parent = cwd.parent
+    if parent != cwd:
+        try:
+            for entry in parent.iterdir():
+                if entry.is_dir() and entry.name != cwd.name and not entry.name.startswith("."):
+                    candidates.append(entry / "skills")
+        except Exception:
+            pass
+
+    roots = []
+    seen = set()
+    for d in candidates:
+        try:
+            if _has_skill(d):
+                key = str(d.resolve())
+                if key not in seen:
+                    seen.add(key)
+                    roots.append(d.resolve())
+        except Exception:
+            continue
+    return roots
+
+
+def _skill_link_exists(link: Path) -> bool:
+    try:
+        return link.exists() or link.is_symlink()
+    except Exception:
+        return False
+
+
+def _create_skill_link(target: Path, link: Path) -> bool:
+    """Create a junction (Windows, no admin) or symlink (Unix) at link -> target.
+    Returns False if link already exists or creation failed.
+
+    On Windows we always use a directory junction (mklink /J): Codex follows
+    junctions but does not follow true symlinks for skill discovery, while
+    Claude Code follows both. Junctions do not require admin/developer mode."""
+    if _skill_link_exists(link):
+        return False
+    try:
+        link.parent.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass
+    if sys.platform == "win32":
+        try:
+            r = subprocess.run(
+                ["cmd", "/c", "mklink", "/J", str(link), str(target)],
+                capture_output=True,
+            )
+            return r.returncode == 0
+        except Exception:
+            return False
+    try:
+        os.symlink(str(target), str(link), target_is_directory=True)
+        return True
+    except OSError:
+        return False
+
+
+def _remove_skill_link(link: Path) -> None:
+    """Remove a junction/symlink we created, without touching the target."""
+    try:
+        if sys.platform == "win32":
+            subprocess.run(["cmd", "/c", "rmdir", str(link)], capture_output=True)
+        else:
+            os.unlink(str(link))
+    except Exception:
+        pass
+
+
+def link_nearby_skills(cwd: Path, native_dir: Path, state_file: Path) -> int:
+    """Symlink nearby repo skills into native_dir so the agent discovers them on
+    the next turn/session. Idempotent; skips names already present (native installs
+    or prior links). Cleans stale links we created whose target is gone. Failures
+    are swallowed so the metrics hook never breaks. Returns newly-linked count."""
+    try:
+        native_dir.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        return 0
+    state = {}
+    try:
+        if state_file.exists():
+            state = json.loads(state_file.read_text("utf-8") or "{}")
+    except Exception:
+        state = {}
+    for link_str, target_str in list(state.items()):
+        link = Path(link_str)
+        target = Path(target_str)
+        try:
+            if _skill_link_exists(link):
+                if not target.exists():
+                    _remove_skill_link(link)
+                    state.pop(link_str, None)
+            else:
+                state.pop(link_str, None)
+        except Exception:
+            pass
+    linked = 0
+    for repo_skills_dir in collect_skill_roots(cwd):
+        try:
+            for skill_dir in repo_skills_dir.iterdir():
+                if not skill_dir.is_dir() or skill_dir.name.startswith("."):
+                    continue
+                if not (skill_dir / "SKILL.md").exists():
+                    continue
+                try:
+                    target = skill_dir.resolve()
+                except Exception:
+                    continue
+                link_path = native_dir / skill_dir.name
+                if _create_skill_link(target, link_path):
+                    state[str(link_path)] = str(target)
+                    linked += 1
+        except Exception:
+            pass
+    try:
+        state_file.write_text(json.dumps(state, ensure_ascii=False), "utf-8")
+    except Exception:
+        pass
+    return linked
+
+
 def _skill_namespace(name: str) -> str:
     return name.split(":", 1)[0] if ":" in name else ""
 
@@ -1067,7 +1217,12 @@ def emit_turn(
     usage_details = get_usage(last_assistant)
 
     tool_calls = _tool_calls_from_assistants(turn.assistant_msgs)
-    skill_usages = detect_turn_skill_usages(turn, tool_calls, discover_known_skills())
+    cwd = Path.cwd()
+    try:
+        known_skills = discover_known_skills(collect_skill_roots(cwd))
+    except Exception:
+        known_skills = discover_known_skills()
+    skill_usages = detect_turn_skill_usages(turn, tool_calls, known_skills)
     interaction_id = build_interaction_id("claude", session_id, turn_num)
     skill_use_events = build_skill_use_events(interaction_id, skill_usages)
     interaction_meta = build_interaction_metadata(
@@ -1173,6 +1328,7 @@ def emit_turn(
 
             trace_span.update(output={"role": "assistant", "content": assistant_text})
 
+
 # ----------------- Main -----------------
 def main() -> int:
     start = time.time()
@@ -1183,7 +1339,7 @@ def main() -> int:
 
     public_key = os.environ.get("CC_LANGFUSE_PUBLIC_KEY") or os.environ.get("LANGFUSE_PUBLIC_KEY")
     secret_key = os.environ.get("CC_LANGFUSE_SECRET_KEY") or os.environ.get("LANGFUSE_SECRET_KEY")
-    host = os.environ.get("CC_LANGFUSE_BASE_URL") or os.environ.get("LANGFUSE_BASEURL") or "https://cloud.langfuse.com"
+    host = os.environ.get("CC_LANGFUSE_BASE_URL") or os.environ.get("LANGFUSE_BASEURL") or "https://metrics.openharmonyinsight.cn"
 
     if not public_key or not secret_key:
         warn("Missing Langfuse public/secret key in hook environment; exiting.")
@@ -1249,6 +1405,13 @@ def main() -> int:
             warn(f"Langfuse flush failed: {e}")
             pass
 
+        # Best-effort: link nearby repo skills into ~/.claude/skills. Runs
+        # AFTER the Langfuse flush so it can never block or break metrics.
+        try:
+            link_nearby_skills(Path.cwd(), Path.home() / ".claude" / "skills", Path.home() / ".claude" / "skills" / ".oh-linked.json")
+        except Exception:
+            pass
+
         dur = time.time() - start
         info(f"Processed {emitted} turns in {dur:.2f}s (session={session_id})")
         return 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.78",
+  "version": "0.1.80",
   "private": false,
   "type": "module",
   "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",
@@ -23,6 +23,7 @@
     "scripts/opencode-langfuse-check.mjs",
     "scripts/opencode-langfuse-run.mjs",
     "scripts/opencode-langfuse-setup.mjs",
+    "scripts/opencode-skills-discover.mjs",
     "scripts/resolve-opencode-cli.mjs",
     "scripts/real-self-verify.mjs",
     "scripts/log-filter-utils.mjs",

package/scripts/auto-update-runtime.mjs

@@ -6,10 +6,10 @@ import { fileURLToPath } from "node:url";
 import { extractVersionFromNpmMetadata, isNewerVersion } from "./update-utils.mjs";
 import { getRuntimeInstallRecord } from "./runtime-state-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 ALLOWED_TARGETS = new Set(["claude", "opencode", "codex"]);
-const OFFICIAL_NPM_REGISTRY = "https://registry.npmjs.org/";
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf8"));
+const ALLOWED_TARGETS = new Set(["claude", "opencode", "codex"]);
+const OFFICIAL_NPM_REGISTRY = "https://registry.npmjs.org/";
 
 const colorEnabled = process.stdout.isTTY && process.env.NO_COLOR !== "1";
 const ansi = (code) => (colorEnabled ? `\x1b[${code}m` : "");
@@ -40,7 +40,7 @@ function parseArgs(argv) {
   return args;
 }
 
-async function latestVersion(packageName, registry = OFFICIAL_NPM_REGISTRY) {
+async function latestVersion(packageName, registry = OFFICIAL_NPM_REGISTRY) {
   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}`);
@@ -106,15 +106,15 @@ function printAlreadyCurrent(target, packageName, version) {
   console.log(paint(`[OK] ${label} Langfuse \u5df2\u662f\u6700\u65b0\uff1a${packageName}@${version}`, t.bold, t.green));
 }
 
-function updateCommandForPackage(packageName, target) {
-  if (packageName === "oh-aicoding-tool") return `npx --registry=${OFFICIAL_NPM_REGISTRY} oh-aicoding-tool@latest langfuse update ${target}`;
-  return `npx --registry=${OFFICIAL_NPM_REGISTRY} ${packageName}@latest update ${target}`;
-}
-
-function updateArgsForPackage(packageName, target) {
-  if (packageName === "oh-aicoding-tool") return ["-y", `--registry=${OFFICIAL_NPM_REGISTRY}`, "oh-aicoding-tool@latest", "langfuse", "update", target];
-  return ["-y", `--registry=${OFFICIAL_NPM_REGISTRY}`, `${packageName}@latest`, "update", target];
-}
+function updateCommandForPackage(packageName, target) {
+  if (packageName === "oh-aicoding-tool") return `npx --registry=${OFFICIAL_NPM_REGISTRY} oh-aicoding-tool@latest langfuse update ${target}`;
+  return `npx --registry=${OFFICIAL_NPM_REGISTRY} ${packageName}@latest update ${target}`;
+}
+
+function updateArgsForPackage(packageName, target) {
+  if (packageName === "oh-aicoding-tool") return ["-y", `--registry=${OFFICIAL_NPM_REGISTRY}`, "oh-aicoding-tool@latest", "langfuse", "update", target];
+  return ["-y", `--registry=${OFFICIAL_NPM_REGISTRY}`, `${packageName}@latest`, "update", target];
+}
 
 function runUpdate(target, packageName, args) {
   const updateArgs = updateArgsForPackage(packageName, target);