openclaw-diag-cli 0.1.2 → 0.2.1

package/ocdiag/timeutil.py

@@ -37,17 +37,6 @@ def fmt_duration(sec) -> str:
     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:

package/ocdiag/tokens.py

@@ -16,10 +16,6 @@ def fmt_tokens(n) -> str:
     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

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "openclaw-diag-cli",
-  "version": "0.1.2",
-  "description": "OpenClaw / ArkClaw read-only diagnostic CLI. Zero-dependency Python scripts wrapped in Node for npx-friendly install.",
+  "version": "0.2.1",
+  "description": "OpenClaw observer-only diagnostic CLI. Zero-dependency Python scripts wrapped in Node for npx-friendly install.",
   "keywords": [
     "openclaw",
-    "arkclaw",
     "diagnostic",
     "cli",
     "ops",

package/tools/oc_session_extract.py

@@ -9,11 +9,12 @@ import json
 import os
 import sys
 from pathlib import Path
-from typing import Iterator, List, Optional, TextIO, Tuple
+from typing import List, Optional, TextIO, Tuple
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
 from ocdiag import paths
+from ocdiag.sensitive import sanitize_text
 
 
 DEFAULT_BASE_DIR = paths.SESSIONS_BASE
@@ -40,6 +41,29 @@ def classify_state(filename: str) -> str:
     return "unknown"
 
 
+def _recent_session_ids(base_dir, limit=5):
+    """Return the most-recently-modified active session UUIDs."""
+    found: List[Tuple[float, str]] = []
+    for ad in glob.glob(os.path.join(base_dir, "*")):
+        sd = os.path.join(ad, "sessions")
+        if not os.path.isdir(sd):
+            continue
+        for entry in os.listdir(sd):
+            if not entry.endswith(".jsonl"):
+                continue
+            if ".trajectory" in entry or ".jsonl.reset." in entry:
+                continue
+            path = os.path.join(sd, entry)
+            try:
+                mtime = os.path.getmtime(path)
+            except OSError:
+                continue
+            sid = entry[:-len(".jsonl")]
+            found.append((mtime, sid))
+    found.sort(reverse=True)
+    return [sid for _, sid in found[:limit]]
+
+
 def find_session_files(session_id, base_dir=DEFAULT_BASE_DIR, agent=None):
     if agent:
         agent_dirs = [os.path.join(base_dir, agent)]
@@ -85,23 +109,57 @@ def write_header(out, path, state):
     out.write(SEPARATOR + "\n\n")
 
 
-def extract_file(path, state, out, pretty=True, type_filter=None):
+def _sanitize_record(obj):
+    """Walk a session record and scrub free-form text content fields.
+
+    Sessions store user/assistant messages under ``message.content``. We don't
+    rewrite tool args or metadata: those keep structure that matters for
+    diagnosis. We only scrub free-form prose where secrets typically live
+    (user-pasted tokens, error tracebacks).
+    """
+    if not isinstance(obj, dict):
+        return obj
+    msg = obj.get("message")
+    if isinstance(msg, dict):
+        content = msg.get("content")
+        if isinstance(content, str):
+            msg["content"] = sanitize_text(content)
+        elif isinstance(content, list):
+            for part in content:
+                if isinstance(part, dict):
+                    for k in ("text", "content"):
+                        v = part.get(k)
+                        if isinstance(v, str):
+                            part[k] = sanitize_text(v)
+        # Also scrub any top-level text-ish fields the gateway may have set.
+        for k in ("text", "summary"):
+            v = msg.get(k)
+            if isinstance(v, str):
+                msg[k] = sanitize_text(v)
+    return obj
+
+
+def extract_file(path, state, out, pretty=True, type_filter=None, sanitize=True):
     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")
+            out.write((sanitize_text(raw) if sanitize else 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 sanitize:
+            obj = _sanitize_record(obj)
         if pretty:
             out.write(json.dumps(obj, indent=2, ensure_ascii=False))
         else:
-            out.write(raw)
+            # Non-pretty mode: emit the (possibly sanitized) JSON or fall back
+            # to the original raw line if we didn't touch it.
+            out.write(json.dumps(obj, ensure_ascii=False) if sanitize else raw)
         out.write("\n\n")
         written += 1
     return written
@@ -178,6 +236,7 @@ def select_files(files, extract_all, _out):
 
 def main() -> int:
     p = argparse.ArgumentParser(
+        prog=os.environ.get("OPENCLAW_DIAG_PROG") or None,
         description="Extract OpenClaw session JSONL files into human-readable format.",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
@@ -192,15 +251,24 @@ def main() -> int:
     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")
+    p.add_argument("--unmask", action="store_true",
+                   help="Disable default sanitization of secret-shaped substrings "
+                        "in message content (off = scrubbed)")
     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 "")
+            f"Error: 找不到 session '{args.session_id}'（在 {args.base_dir} 下）"
+            + (f" agent={args.agent}" if args.agent else "")
             + "\n"
         )
+        suggestions = _recent_session_ids(args.base_dir, limit=5)
+        if suggestions:
+            sys.stderr.write("  最近的 5 个 session：\n")
+            for sid in suggestions:
+                sys.stderr.write(f"    {sid}\n")
+            sys.stderr.write("  提示：完整 UUID 或前缀（至少 8 位）都可。\n")
         return 1
 
     if args.list:
@@ -231,7 +299,7 @@ def main() -> int:
                 summarize_file(path, state, out_fp)
             else:
                 extract_file(path, state, out_fp, pretty=not args.no_pretty,
-                             type_filter=type_filter)
+                             type_filter=type_filter, sanitize=not args.unmask)
     except BrokenPipeError:
         try:
             sys.stdout.flush()

package/tools/oc_session_trace.py

@@ -52,14 +52,6 @@ def fmt_duration(ms: float) -> str:
     return f"{m}m{s:.1f}s"
 
 
-def human_size(n: int) -> str:
-    for unit in ("B", "KB", "MB", "GB"):
-        if n < 1024:
-            return f"{n:.1f} {unit}" if unit != "B" else f"{n} {unit}"
-        n /= 1024
-    return f"{n:.1f} TB"
-
-
 def extract_text(content: Any) -> str:
     if isinstance(content, str):
         return content
@@ -112,6 +104,29 @@ def find_session_file(
     return candidates[0][0] if candidates else None
 
 
+def _recent_session_ids(base_dir: str, limit: int = 5) -> List[str]:
+    """Return the most-recently-modified active session UUIDs (no .reset/.bak/.deleted)."""
+    found: List[Tuple[float, str]] = []
+    for ad in glob.glob(os.path.join(base_dir, "*")):
+        sd = os.path.join(ad, "sessions")
+        if not os.path.isdir(sd):
+            continue
+        for entry in os.listdir(sd):
+            if not entry.endswith(".jsonl"):
+                continue
+            if ".trajectory" in entry or ".jsonl.reset." in entry:
+                continue
+            path = os.path.join(sd, entry)
+            try:
+                mtime = os.path.getmtime(path)
+            except OSError:
+                continue
+            sid = entry[:-len(".jsonl")]
+            found.append((mtime, sid))
+    found.sort(reverse=True)
+    return [sid for _, sid in found[:limit]]
+
+
 def find_trajectory_file(session_file: str) -> Optional[str]:
     d = os.path.dirname(session_file)
     base = os.path.basename(session_file).split(".jsonl")[0]
@@ -634,6 +649,7 @@ def format_json(session_id, session_file, user_msg_index, user_msg_id, analysis,
 
 def main():
     parser = argparse.ArgumentParser(
+        prog=os.environ.get("OPENCLAW_DIAG_PROG") or None,
         description="Trace the processing timeline of a user message in an OpenClaw session.",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
@@ -652,8 +668,14 @@ def main():
 
     session_file = find_session_file(args.session_id, args.base_dir, args.agent)
     if not session_file:
-        print(f"Error: no session file found for '{args.session_id}' under {args.base_dir}",
+        print(f"Error: 找不到 session '{args.session_id}'（在 {args.base_dir} 下）",
               file=sys.stderr)
+        suggestions = _recent_session_ids(args.base_dir, limit=5)
+        if suggestions:
+            print(f"  最近的 5 个 session：", file=sys.stderr)
+            for sid in suggestions:
+                print(f"    {sid}", file=sys.stderr)
+            print(f"  提示：UUID 完整 36 位，前缀也可（至少 8 位）。", file=sys.stderr)
         sys.exit(1)
 
     records = load_records(session_file)