openclaw-diag-cli 0.1.0

package/ocdiag/sensitive.py

@@ -0,0 +1,41 @@
+"""Mask sensitive config values (keys, secrets, tokens)."""
+
+from __future__ import annotations
+
+import re
+
+SENSITIVE_PATTERN = re.compile(
+    r"(key|secret|token|password|credential|auth|private|signing)",
+    re.IGNORECASE,
+)
+
+SENSITIVE_KEY_NAMES = {
+    "apikey", "appkey", "appsecret", "secret",
+    "token", "password", "encryptkey", "verificationtoken",
+    "webhook", "accesstoken", "refreshtoken", "signingsecret",
+    "clientsecret",
+}
+
+
+def mask(val) -> str:
+    """Mask a sensitive value, preserving first/last 4 chars for long strings."""
+    s = str(val)
+    if len(s) <= 4:
+        return "****"
+    if len(s) <= 10:
+        return s[:2] + "****"
+    return s[:4] + "****" + s[-4:]
+
+
+def is_sensitive_key(key_path: str) -> bool:
+    """Check if a dotted config key path is sensitive."""
+    last = key_path.rsplit(".", 1)[-1].lower().replace("-", "").replace("_", "")
+    return last in SENSITIVE_KEY_NAMES or SENSITIVE_PATTERN.search(last) is not None
+
+
+def safe_val(key: str, val, max_len: int = 300) -> str:
+    """Return display-safe value: mask if sensitive, truncate if long."""
+    if SENSITIVE_PATTERN.search(key):
+        return mask(val) if val else '""'
+    s = str(val)
+    return s[:max_len] + "..." if len(s) > max_len else s

package/ocdiag/timeutil.py

@@ -0,0 +1,77 @@
+"""Timestamp parsing and duration formatting."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Optional
+
+
+def parse_obj_ts(ts_str: Optional[str]) -> Optional[datetime]:
+    """obj.timestamp is ISO 8601."""
+    if not ts_str:
+        return None
+    try:
+        return datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def parse_msg_ts(ms) -> Optional[datetime]:
+    """msg.timestamp is epoch milliseconds."""
+    if ms is None:
+        return None
+    try:
+        return datetime.fromtimestamp(int(ms) / 1000, tz=timezone.utc)
+    except Exception:
+        return None
+
+
+def fmt_duration(sec) -> str:
+    if sec is None:
+        return "?"
+    s = float(sec)
+    if s < 60:
+        return f"{s:.0f}s"
+    if s < 3600:
+        return f"{s/60:.1f}m"
+    return f"{s/3600:.1f}h"
+
+
+def fmt_duration_ms(ms) -> str:
+    if ms is None:
+        return "?"
+    s = float(ms) / 1000.0
+    if s < 60:
+        return f"{s:.1f}s"
+    if s < 3600:
+        return f"{s/60:.1f}min"
+    return f"{s/3600:.1f}h"
+
+
+def fmt_age(ms_delta) -> str:
+    s = abs(float(ms_delta)) / 1000
+    if s < 60:
+        return f"{s:.0f}秒"
+    if s < 3600:
+        return f"{s/60:.0f}分钟"
+    if s < 86400:
+        return f"{s/3600:.1f}小时"
+    return f"{s/86400:.1f}天"
+
+
+def fmt_ts(ms) -> str:
+    if not ms:
+        return "?"
+    try:
+        return datetime.fromtimestamp(int(ms) / 1000).strftime("%Y-%m-%d %H:%M:%S")
+    except Exception:
+        return str(ms)
+
+
+def fmt_hms(ts: Optional[str]) -> str:
+    if not ts:
+        return "?"
+    try:
+        return ts.split("T", 1)[1][:8]
+    except Exception:
+        return ts[:19]

package/ocdiag/tokens.py

@@ -0,0 +1,46 @@
+"""Token / size formatters and percentile helper."""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+
+def fmt_tokens(n) -> str:
+    if n is None:
+        return "?"
+    n = int(n)
+    if n >= 1_000_000:
+        return f"{n/1_000_000:.1f}M"
+    if n >= 1_000:
+        return f"{n/1_000:.1f}K"
+    return str(n)
+
+
+def fmt_k(n) -> str:
+    return fmt_tokens(n)
+
+
+def percentile(sorted_list: List[float], p: float) -> Optional[float]:
+    if not sorted_list:
+        return None
+    k = max(0, min(len(sorted_list) - 1, int(len(sorted_list) * p)))
+    return sorted_list[k]
+
+
+def pct(sorted_vals: List[float], p: float) -> float:
+    if not sorted_vals:
+        return 0.0
+    n = len(sorted_vals)
+    idx = min(n - 1, int(n * p))
+    return sorted_vals[idx]
+
+
+def human_size(b) -> str:
+    b = int(b)
+    if b < 1024:
+        return f"{b}B"
+    if b < 1048576:
+        return f"{b/1024:.1f}KB"
+    if b < 1073741824:
+        return f"{b/1048576:.1f}MB"
+    return f"{b/1073741824:.1f}GB"

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "openclaw-diag-cli",
+  "version": "0.1.0",
+  "description": "OpenClaw / ArkClaw read-only diagnostic CLI. Zero-dependency Python scripts wrapped in Node for npx-friendly install.",
+  "keywords": [
+    "openclaw",
+    "arkclaw",
+    "diagnostic",
+    "cli",
+    "ops",
+    "troubleshooting",
+    "ai-agent"
+  ],
+  "homepage": "https://github.com/wujiaming88/openclaw-diag-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wujiaming88/openclaw-diag-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wujiaming88/openclaw-diag-cli/issues"
+  },
+  "license": "MIT",
+  "author": "wujiaming88",
+  "bin": {
+    "openclaw-diag": "./bin/openclaw-diag.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "ocdiag/",
+    "diag/",
+    "tools/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node bin/openclaw-diag.js list && echo OK"
+  }
+}

package/tools/oc_session_extract.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""Extract OpenClaw session JSONL files into human-readable format."""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Iterator, List, Optional, TextIO, Tuple
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from ocdiag import paths
+
+
+DEFAULT_BASE_DIR = paths.SESSIONS_BASE
+SEPARATOR = "═" * 63
+
+
+def human_size(n: int) -> str:
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024:
+            return f"{n:.1f} {unit}" if unit != "B" else f"{n} {unit}"
+        n /= 1024
+    return f"{n:.1f} PB"
+
+
+def classify_state(filename: str) -> str:
+    if filename.endswith(".jsonl"):
+        return "active"
+    if ".jsonl.deleted." in filename:
+        return "deleted"
+    if ".jsonl.reset." in filename:
+        return "reset"
+    if ".jsonl.bak-" in filename:
+        return "backup"
+    return "unknown"
+
+
+def find_session_files(session_id, base_dir=DEFAULT_BASE_DIR, agent=None):
+    if agent:
+        agent_dirs = [os.path.join(base_dir, agent)]
+    else:
+        agent_dirs = sorted(glob.glob(os.path.join(base_dir, "*")))
+    found = []
+    for agent_dir in agent_dirs:
+        sessions_dir = os.path.join(agent_dir, "sessions")
+        if not os.path.isdir(sessions_dir):
+            continue
+        pattern = os.path.join(sessions_dir, f"{session_id}.jsonl*")
+        for path in sorted(glob.glob(pattern)):
+            name = os.path.basename(path)
+            if ".trajectory" in name:
+                continue
+            state = classify_state(name)
+            found.append((path, state))
+    return found
+
+
+def stream_records(path):
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        for i, line in enumerate(f, start=1):
+            stripped = line.rstrip("\n")
+            if not stripped.strip():
+                continue
+            try:
+                obj = json.loads(stripped)
+                yield i, obj, stripped, None
+            except json.JSONDecodeError as e:
+                yield i, None, stripped, str(e)
+
+
+def write_header(out, path, state):
+    try:
+        size = os.path.getsize(path)
+    except OSError:
+        size = 0
+    out.write(SEPARATOR + "\n")
+    out.write(f"File: {path}\n")
+    out.write(f"Size: {human_size(size)}\n")
+    out.write(f"State: {state}\n")
+    out.write(SEPARATOR + "\n\n")
+
+
+def extract_file(path, state, out, pretty=True, type_filter=None):
+    write_header(out, path, state)
+    written = 0
+    for line_no, obj, raw, err in stream_records(path):
+        if err is not None:
+            out.write(f"--- Record {line_no} [PARSE ERROR: {err}] ---\n")
+            out.write(raw + "\n\n")
+            written += 1
+            continue
+        rtype = obj.get("type", "?") if isinstance(obj, dict) else "?"
+        if type_filter is not None and rtype not in type_filter:
+            continue
+        out.write(f"--- Record {line_no} [type: {rtype}] ---\n")
+        if pretty:
+            out.write(json.dumps(obj, indent=2, ensure_ascii=False))
+        else:
+            out.write(raw)
+        out.write("\n\n")
+        written += 1
+    return written
+
+
+def summarize_file(path, state, out):
+    write_header(out, path, state)
+    counts: dict = {}
+    total = 0
+    earliest: Optional[str] = None
+    latest: Optional[str] = None
+    parse_errors = 0
+    for _, obj, _, err in stream_records(path):
+        total += 1
+        if err is not None:
+            parse_errors += 1
+            continue
+        if not isinstance(obj, dict):
+            counts["<non-object>"] = counts.get("<non-object>", 0) + 1
+            continue
+        rtype = obj.get("type", "<no-type>")
+        counts[rtype] = counts.get(rtype, 0) + 1
+        ts = obj.get("timestamp")
+        if isinstance(ts, str):
+            if earliest is None or ts < earliest:
+                earliest = ts
+            if latest is None or ts > latest:
+                latest = ts
+    out.write(f"Total records: {total}\n")
+    if parse_errors:
+        out.write(f"Parse errors: {parse_errors}\n")
+    out.write("By type:\n")
+    for k in sorted(counts, key=lambda k: -counts[k]):
+        out.write(f"  {k}: {counts[k]}\n")
+    if earliest or latest:
+        out.write(f"Time range: {earliest or '?'}  →  {latest or '?'}\n")
+    out.write("\n")
+
+
+def list_files(files, out):
+    out.write(f"Found {len(files)} file(s):\n\n")
+    for i, (path, state) in enumerate(files, start=1):
+        try:
+            size_s = human_size(os.path.getsize(path))
+        except OSError:
+            size_s = "?"
+        out.write(f"  [{i}] {state:8s} {size_s:>10s}  {path}\n")
+    out.write("\n")
+
+
+def select_files(files, extract_all, _out):
+    if len(files) <= 1 or extract_all:
+        return files
+    list_files(files, sys.stderr)
+    sys.stderr.write("Multiple files found. Enter index (1-based), 'a' for all, or 'q' to quit: ")
+    sys.stderr.flush()
+    try:
+        choice = sys.stdin.readline().strip().lower()
+    except (KeyboardInterrupt, EOFError):
+        return []
+    if choice in ("q", ""):
+        return []
+    if choice == "a":
+        return files
+    try:
+        idx = int(choice)
+        if 1 <= idx <= len(files):
+            return [files[idx - 1]]
+    except ValueError:
+        pass
+    sys.stderr.write(f"Invalid choice: {choice}\n")
+    return []
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(
+        description="Extract OpenClaw session JSONL files into human-readable format.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("session_id", help="Session UUID to extract")
+    p.add_argument("-o", "--output", help="Write output to FILE instead of stdout")
+    p.add_argument("-a", "--all", action="store_true",
+                   help="Extract all versions found (active + deleted + reset + backup)")
+    p.add_argument("--list", action="store_true", help="List found files; do not extract")
+    p.add_argument("--agent", help="Limit search to specific agent directory")
+    p.add_argument("--base-dir", default=DEFAULT_BASE_DIR, help="Override base directory")
+    p.add_argument("--no-pretty", action="store_true", help="Output raw JSON lines")
+    p.add_argument("--types", help="Filter by record type (comma-separated, e.g. 'message,toolCall')")
+    p.add_argument("--summary", action="store_true",
+                   help="Show record-count summary instead of full extraction")
+    args = p.parse_args()
+
+    files = find_session_files(args.session_id, args.base_dir, args.agent)
+    if not files:
+        sys.stderr.write(
+            f"Error: no files found for session ID '{args.session_id}' under {args.base_dir}"
+            + (f" (agent={args.agent})" if args.agent else "")
+            + "\n"
+        )
+        return 1
+
+    if args.list:
+        list_files(files, sys.stdout)
+        return 0
+
+    selected = select_files(files, args.all, sys.stdout)
+    if not selected:
+        sys.stderr.write("No files selected.\n")
+        return 1
+
+    type_filter: Optional[set] = None
+    if args.types:
+        type_filter = {t.strip() for t in args.types.split(",") if t.strip()}
+
+    out_path = args.output
+    out_fp: TextIO
+    close_out = False
+    if out_path:
+        out_fp = open(out_path, "w", encoding="utf-8")
+        close_out = True
+    else:
+        out_fp = sys.stdout
+
+    try:
+        for path, state in selected:
+            if args.summary:
+                summarize_file(path, state, out_fp)
+            else:
+                extract_file(path, state, out_fp, pretty=not args.no_pretty,
+                             type_filter=type_filter)
+    except BrokenPipeError:
+        try:
+            sys.stdout.flush()
+        except BrokenPipeError:
+            pass
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+        return 0
+    except KeyboardInterrupt:
+        sys.stderr.write("\nInterrupted.\n")
+        return 130
+    finally:
+        if close_out:
+            out_fp.close()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())