openclaw-diag-cli 0.1.0

package/lib/bundle.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Produce a self-contained single-file diag script.
+
+Reads `diag/<NN>_<name>.py`, inlines every `ocdiag/*.py` submodule into a
+runtime bootstrap (registering them in `sys.modules` before the original
+`from ocdiag import ...` statements run), and writes the result to stdout.
+
+Usage:
+    python3 lib/bundle.py gateway > standalone-gateway.py
+    python3 lib/bundle.py 04_gateway > standalone-gateway.py
+
+The bundled script needs only Python 3.8+; no openclaw-diag-cli checkout.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+# ID → script filename, kept in sync with ocdiag/dispatcher.py:MODULES.
+MODULES: List[tuple] = [
+    ("sys_health",     "diag/01_sys_health.py"),
+    ("environment",    "diag/02_environment.py"),
+    ("configuration",  "diag/03_configuration.py"),
+    ("gateway",        "diag/04_gateway.py"),
+    ("recent_errors",  "diag/05_recent_errors.py"),
+    ("cron_jobs",      "diag/06_cron_jobs.py"),
+    ("performance",    "diag/07_performance.py"),
+    ("sessions",       "diag/08_sessions.py"),
+    ("plugin_diag",    "diag/09_plugin_diag.py"),
+    ("shell_history",  "diag/10_shell_history.py"),
+]
+MODULE_BY_ID = {mid: rel for mid, rel in MODULES}
+
+# Order matters: each submodule is exec'd into its own module object, and its
+# `from . import X` / `from ocdiag.X import Y` statements run during exec —
+# so dependencies must already be in sys.modules.
+OCDIAG_SUBMODULE_ORDER = [
+    "paths",
+    "sensitive",
+    "timeutil",
+    "tokens",
+    "jsonlog",
+    "output",
+    "recent_logs",
+    "cli",       # imports `from . import paths`
+]
+
+
+def resolve_script(arg: str) -> Path:
+    if arg in MODULE_BY_ID:
+        return REPO_ROOT / MODULE_BY_ID[arg]
+    candidate = REPO_ROOT / "diag" / arg
+    if candidate.is_file():
+        return candidate
+    candidate_py = REPO_ROOT / "diag" / f"{arg}.py"
+    if candidate_py.is_file():
+        return candidate_py
+    raise SystemExit(
+        f"Error: unknown module id or script: {arg!r}. "
+        f"Use one of: {', '.join(mid for mid, _ in MODULES)}"
+    )
+
+
+def split_header(source: str) -> tuple:
+    """Split a script into (shebang, docstring, body).
+
+    Recognises a single-line `#!/...` shebang and the first triple-quoted
+    docstring. Anything else becomes body.
+    """
+    lines = source.split("\n")
+    i = 0
+    shebang = ""
+    if i < len(lines) and lines[i].startswith("#!"):
+        shebang = lines[i]
+        i += 1
+    # Skip blank lines / comments before docstring
+    while i < len(lines) and (lines[i].strip() == "" or lines[i].lstrip().startswith("#")):
+        i += 1
+    docstring_lines: List[str] = []
+    if i < len(lines) and (lines[i].lstrip().startswith('"""') or lines[i].lstrip().startswith("'''")):
+        quote = '"""' if '"""' in lines[i] else "'''"
+        first = lines[i]
+        docstring_lines.append(first)
+        # Single-line docstring?
+        if first.count(quote) >= 2:
+            i += 1
+        else:
+            i += 1
+            while i < len(lines):
+                docstring_lines.append(lines[i])
+                if quote in lines[i]:
+                    i += 1
+                    break
+                i += 1
+    body = "\n".join(lines[i:])
+    docstring = "\n".join(docstring_lines)
+    return shebang, docstring, body
+
+
+def strip_path_hack(body: str) -> str:
+    """Remove the `sys.path.insert(0, ...parent.parent)` line; the bundle
+    no longer needs to point at a checkout to find the `ocdiag` package."""
+    pattern = re.compile(
+        r"^sys\.path\.insert\(\s*0\s*,\s*str\(\s*Path\(__file__\)\.resolve\(\)\.parent\.parent\s*\)\s*\)\s*\n",
+        re.MULTILINE,
+    )
+    return pattern.sub("", body)
+
+
+def extract_future_imports(body: str) -> tuple:
+    """Pull `from __future__ import ...` lines out of the body so we can put
+    them at the top of the bundled file (Python requires this)."""
+    pattern = re.compile(r"^from\s+__future__\s+import[^\n]*\n", re.MULTILINE)
+    futures = pattern.findall(body)
+    body_without = pattern.sub("", body)
+    return "".join(futures), body_without
+
+
+def read_ocdiag_sources() -> Dict[str, str]:
+    """Read ocdiag/__init__.py and the submodule files we know we need."""
+    out: Dict[str, str] = {}
+    out["ocdiag"] = (REPO_ROOT / "ocdiag" / "__init__.py").read_text(encoding="utf-8")
+    for name in OCDIAG_SUBMODULE_ORDER:
+        out[f"ocdiag.{name}"] = (REPO_ROOT / "ocdiag" / f"{name}.py").read_text(encoding="utf-8")
+    return out
+
+
+def render_bootstrap(sources: Dict[str, str]) -> str:
+    """Render the runtime bootstrap that registers ocdiag modules."""
+    # Use repr() for embedding; Python repr of strings round-trips reliably.
+    parts = ["# ── Inlined ocdiag bootstrap (generated by lib/bundle.py) ──",
+             "import sys as _sys",
+             "import types as _types",
+             "_OCDIAG_SOURCES = {"]
+    parts.append(f"    'ocdiag': {sources['ocdiag']!r},")
+    for name in OCDIAG_SUBMODULE_ORDER:
+        full = f"ocdiag.{name}"
+        parts.append(f"    {full!r}: {sources[full]!r},")
+    parts.append("}")
+    parts.append("")
+    parts.append("def _ocdiag_bootstrap():")
+    parts.append("    if 'ocdiag' in _sys.modules:")
+    parts.append("        return")
+    parts.append("    pkg = _types.ModuleType('ocdiag')")
+    parts.append("    pkg.__path__ = []")
+    parts.append("    pkg.__package__ = 'ocdiag'")
+    parts.append("    _sys.modules['ocdiag'] = pkg")
+    parts.append("    exec(compile(_OCDIAG_SOURCES['ocdiag'], '<ocdiag/__init__.py>', 'exec'), pkg.__dict__)")
+    parts.append(f"    for _name in {OCDIAG_SUBMODULE_ORDER!r}:")
+    parts.append("        full = 'ocdiag.' + _name")
+    parts.append("        m = _types.ModuleType(full)")
+    parts.append("        m.__package__ = 'ocdiag'")
+    parts.append("        _sys.modules[full] = m")
+    parts.append("        setattr(pkg, _name, m)")
+    parts.append("        exec(compile(_OCDIAG_SOURCES[full], '<' + full + '>', 'exec'), m.__dict__)")
+    parts.append("")
+    parts.append("_ocdiag_bootstrap()")
+    parts.append("del _ocdiag_bootstrap")
+    parts.append("# ── End inlined ocdiag ──")
+    return "\n".join(parts)
+
+
+def build_bundle(script_path: Path) -> str:
+    source = script_path.read_text(encoding="utf-8")
+    shebang, docstring, body = split_header(source)
+    if not shebang:
+        shebang = "#!/usr/bin/env python3"
+    body = strip_path_hack(body)
+    futures, body = extract_future_imports(body)
+    sources = read_ocdiag_sources()
+    bootstrap = render_bootstrap(sources)
+    header_comment = (
+        f"# Self-contained bundle of {script_path.relative_to(REPO_ROOT)} "
+        "(generated by openclaw-diag-cli/lib/bundle.py).\n"
+        "# Requires only Python 3.8+ stdlib. No openclaw-diag-cli checkout needed.\n"
+    )
+    chunks = [shebang]
+    if docstring:
+        chunks.append(docstring)
+    if futures:
+        chunks.append(futures.rstrip("\n"))
+    chunks.append(header_comment.rstrip("\n"))
+    chunks.append(bootstrap)
+    chunks.append(body.lstrip("\n"))
+    return "\n".join(chunks)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv or argv[0] in ("-h", "--help"):
+        sys.stdout.write(__doc__ or "")
+        return 0
+    script_path = resolve_script(argv[0])
+    sys.stdout.write(build_bundle(script_path))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/ocdiag/__init__.py

@@ -0,0 +1,3 @@
+"""ocdiag — shared library for openclaw-diag-cli scripts."""
+
+__version__ = "0.1.0"

package/ocdiag/cli.py

@@ -0,0 +1,39 @@
+"""Common argparse setup for diag scripts."""
+
+from __future__ import annotations
+
+import argparse
+from typing import Optional
+
+from . import paths
+
+
+def build_common_parser(description: str, prog: Optional[str] = None) -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog=prog,
+        description=description,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument(
+        "--config",
+        default=paths.CONFIG,
+        help="Path to openclaw.json",
+    )
+    p.add_argument(
+        "--log-dir",
+        default=paths.LOG_DIR,
+        help="Directory containing openclaw-*.log files",
+    )
+    p.add_argument(
+        "--sessions-base",
+        default=paths.SESSIONS_BASE,
+        help="Base directory containing per-agent session data",
+    )
+    p.add_argument(
+        "--openclaw-home",
+        default=paths.OPENCLAW_HOME,
+        help="OpenClaw home directory (~/.openclaw)",
+    )
+    p.add_argument("--json", action="store_true", help="Emit JSON output")
+    p.add_argument("--no-color", action="store_true", help="Disable colored output")
+    return p

package/ocdiag/dispatcher.py

@@ -0,0 +1,137 @@
+"""Dispatcher: list / run <name> / run all."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import runpy
+import sys
+import time
+from pathlib import Path
+from typing import List
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+# Module ID -> (label, script filename relative to REPO_ROOT)
+MODULES = [
+    ("sys_health",     "系统健康检查",     "diag/01_sys_health.py"),
+    ("environment",    "采集基础环境",     "diag/02_environment.py"),
+    ("configuration",  "采集配置",         "diag/03_configuration.py"),
+    ("gateway",        "采集 Gateway 状态", "diag/04_gateway.py"),
+    ("recent_errors",  "采集近期日志",     "diag/05_recent_errors.py"),
+    ("cron_jobs",      "采集定时任务",     "diag/06_cron_jobs.py"),
+    ("performance",    "采集模型与性能数据", "diag/07_performance.py"),
+    ("sessions",       "采集 Session 数据", "diag/08_sessions.py"),
+    ("plugin_diag",    "采集插件诊断",     "diag/09_plugin_diag.py"),
+    ("shell_history",  "采集命令执行历史",  "diag/10_shell_history.py"),
+]
+
+MODULE_BY_ID = {mid: (label, script) for mid, label, script in MODULES}
+
+
+def cmd_list() -> int:
+    print("Available modules:")
+    for mid, label, _ in MODULES:
+        print(f"  [x] {mid:<16s} {label}")
+    print()
+    print("Usage: ocdiag run <id> | ocdiag run all [--skip id1,id2] [--json]")
+    return 0
+
+
+def run_script(script_rel: str, extra_args: List[str]) -> int:
+    script_path = REPO_ROOT / script_rel
+    if not script_path.is_file():
+        print(f"Error: script not found: {script_path}", file=sys.stderr)
+        return 2
+    saved_argv = sys.argv[:]
+    try:
+        sys.argv = [str(script_path), *extra_args]
+        runpy.run_path(str(script_path), run_name="__main__")
+        return 0
+    except SystemExit as e:
+        try:
+            return int(e.code) if e.code is not None else 0
+        except (TypeError, ValueError):
+            return 1
+    except Exception as e:
+        print(f"  ERROR: {script_path.name} crashed: {type(e).__name__}: {e}",
+              file=sys.stderr)
+        import traceback
+        traceback.print_exc(file=sys.stderr)
+        return 2
+    finally:
+        sys.argv = saved_argv
+
+
+def cmd_run(target: str, extra_args: List[str], skip_ids: List[str]) -> int:
+    json_mode = "--json" in extra_args
+    progress_stream = sys.stderr if json_mode else sys.stdout
+    if target == "all":
+        rc_overall = 0
+        total = sum(1 for mid, _, _ in MODULES if mid not in skip_ids)
+        n = 0
+        for mid, label, script in MODULES:
+            if mid in skip_ids:
+                continue
+            n += 1
+            print(f"\n[{n}/{total}] {label} ({mid})...", flush=True, file=progress_stream)
+            t0 = time.time()
+            rc = run_script(script, extra_args)
+            elapsed = time.time() - t0
+            print(f"[{n}/{total}] {label} ({mid}) ... done ({elapsed:.1f}s)", flush=True, file=progress_stream)
+            if rc != 0:
+                rc_overall = rc
+        return rc_overall
+    if target not in MODULE_BY_ID:
+        print(f"Error: unknown module '{target}'. Use `ocdiag list`.", file=sys.stderr)
+        return 2
+    _, script = MODULE_BY_ID[target]
+    return run_script(script, extra_args)
+
+
+def main(argv=None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+
+    if not argv or argv[0] in ("-h", "--help"):
+        print("ocdiag — OpenClaw 诊断 CLI dispatcher")
+        print()
+        print("Usage:")
+        print("  ocdiag list                      列出所有诊断模块")
+        print("  ocdiag run <id>                  运行单个模块（id 或 all）")
+        print("  ocdiag run all [--skip ids]      运行全部模块，可跳过若干")
+        print()
+        print("--skip 后接逗号分隔的 module id 列表（如 performance,sessions）。")
+        print("其它参数（--config / --log-dir / --json / --no-color）原样传递。")
+        return 0
+
+    cmd, rest = argv[0], argv[1:]
+
+    if cmd == "list":
+        return cmd_list()
+
+    if cmd == "run":
+        if not rest:
+            print("Error: run requires a target (module id or 'all').", file=sys.stderr)
+            return 2
+        target = rest[0]
+        sub = rest[1:]
+        skip_ids: List[str] = []
+        passthrough: List[str] = []
+        i = 0
+        while i < len(sub):
+            a = sub[i]
+            if a == "--skip" and i + 1 < len(sub):
+                skip_ids.extend(s.strip() for s in sub[i + 1].split(",") if s.strip())
+                i += 2
+                continue
+            passthrough.append(a)
+            i += 1
+        return cmd_run(target, passthrough, skip_ids)
+
+    print(f"Error: unknown command '{cmd}'", file=sys.stderr)
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/ocdiag/jsonlog.py

@@ -0,0 +1,65 @@
+"""Helpers for OpenClaw JSON-formatted log entries."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Optional, Tuple
+
+
+def parse_log_msg(obj: Dict[str, Any]) -> str:
+    """Extract human-readable text from an OpenClaw JSON log entry."""
+    texts = []
+    for k in ("0", "1", "2", "3", "msg", "message"):
+        v = obj.get(k, "")
+        if not v or not isinstance(v, str):
+            continue
+        if v.startswith("{"):
+            try:
+                inner = json.loads(v)
+                if isinstance(inner, dict) and inner.get("subsystem"):
+                    continue
+                if isinstance(inner, dict):
+                    texts.append(" ".join(f"{ik}={iv}" for ik, iv in inner.items()))
+                else:
+                    texts.append(v)
+            except (json.JSONDecodeError, AttributeError):
+                texts.append(v)
+        else:
+            texts.append(v)
+    return " | ".join(texts) if texts else ""
+
+
+def get_log_subsystem(obj: Dict[str, Any]) -> str:
+    """Extract subsystem name from an OpenClaw JSON log entry."""
+    for k in ("0", "1", "2", "3"):
+        v = obj.get(k, "")
+        if v and isinstance(v, str) and v.startswith("{"):
+            try:
+                inner = json.loads(v)
+                if isinstance(inner, dict):
+                    return inner.get("subsystem", "") or ""
+            except Exception:
+                pass
+    return ""
+
+
+def parse_name(obj: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
+    """Return (plugin, subsystem) from _meta.name."""
+    meta = obj.get("_meta") or {}
+    name = meta.get("name", "") if isinstance(meta, dict) else ""
+    if not isinstance(name, str) or not name:
+        return None, None
+    try:
+        p = json.loads(name)
+    except Exception:
+        return None, None
+    if not isinstance(p, dict):
+        return None, None
+    return p.get("plugin"), p.get("subsystem")
+
+
+def log_level(obj: Dict[str, Any]) -> str:
+    meta = obj.get("_meta") or {}
+    if isinstance(meta, dict):
+        return meta.get("logLevelName", "") or ""
+    return ""

package/ocdiag/output.py

@@ -0,0 +1,131 @@
+"""Output renderer: human-readable text with optional JSON mode.
+
+Usage:
+    out = Output(module="gateway", json_mode=False)
+    out.section("模块 4：Gateway 状态")
+    out.item("端口 18789: 监听中")
+    out.evidence("ss -tlnp", "...")
+    out.set_data("port", 18789)  # for JSON mode
+    out.done()
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any, Dict, List, Optional, TextIO
+
+
+class Output:
+    def __init__(
+        self,
+        module: str,
+        json_mode: bool = False,
+        no_color: bool = False,
+        stream: Optional[TextIO] = None,
+    ):
+        self.module = module
+        self.json_mode = json_mode
+        self.no_color = no_color
+        self.stream = stream or sys.stdout
+        self._lines: List[str] = []
+        self._data: Dict[str, Any] = {}
+        self._status = "ok"
+        self._error_msg: Optional[str] = None
+
+    # ── human-readable ──
+    def emit(self, text: str = "") -> None:
+        if not self.json_mode:
+            self._lines.append(text)
+
+    def section(self, title: str) -> None:
+        self.emit("")
+        self.emit(f"── {title} ──")
+        self.emit("")
+
+    def subsection(self, title: str) -> None:
+        self.emit("")
+        self.emit(f"  ── {title} ──")
+        self.emit("")
+
+    def item(self, text: str) -> None:
+        self.emit(f"  • {text}")
+
+    def line(self, text: str = "") -> None:
+        self.emit(text)
+
+    def evidence(self, source: str, data: str) -> None:
+        self.emit(f"     [{source}]")
+        if data is None:
+            return
+        for raw in str(data).split("\n")[:100]:
+            self.emit(f"     {raw}")
+
+    # ── JSON mode ──
+    def set_data(self, key: str, value: Any) -> None:
+        self._data[key] = value
+
+    def update_data(self, mapping: Dict[str, Any]) -> None:
+        self._data.update(mapping)
+
+    def add_data_item(self, key: str, value: Any) -> None:
+        if key not in self._data or not isinstance(self._data[key], list):
+            self._data[key] = []
+        self._data[key].append(value)
+
+    def fail(self, message: str) -> None:
+        self._status = "error"
+        self._error_msg = message
+
+    # ── finish ──
+    def done(self) -> int:
+        if self.json_mode:
+            payload: Dict[str, Any] = {
+                "module": self.module,
+                "status": self._status,
+                "data": self._data,
+            }
+            if self._error_msg:
+                payload["error"] = self._error_msg
+            self.stream.write(json.dumps(payload, ensure_ascii=False))
+            self.stream.write("\n")
+        else:
+            for ln in self._lines:
+                self.stream.write(ln + "\n")
+        try:
+            self.stream.flush()
+        except Exception:
+            pass
+        return 0 if self._status == "ok" else 1
+
+
+# Module-level convenience for scripts that just want functional API.
+_active: Optional[Output] = None
+
+
+def init(module: str, json_mode: bool = False, no_color: bool = False) -> Output:
+    global _active
+    _active = Output(module, json_mode=json_mode, no_color=no_color)
+    return _active
+
+
+def current() -> Output:
+    if _active is None:
+        raise RuntimeError("output.init() must be called first")
+    return _active
+
+
+def emit(text: str = "") -> None:
+    current().emit(text)
+
+
+def section(title: str) -> None:
+    current().section(title)
+
+
+def item(text: str) -> None:
+    current().item(text)
+
+
+def evidence(source: str, data: str) -> None:
+    current().evidence(source, data)

package/ocdiag/paths.py

@@ -0,0 +1,48 @@
+"""Filesystem paths used by the diag scripts. Override via environment variables."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def _env_path(name: str, default: str) -> str:
+    v = os.environ.get(name)
+    return v if v else default
+
+
+HOME = os.path.expanduser("~")
+
+OPENCLAW_HOME = _env_path("OPENCLAW_HOME", os.path.join(HOME, ".openclaw"))
+CONFIG = _env_path("OPENCLAW_CONFIG", os.path.join(OPENCLAW_HOME, "openclaw.json"))
+CRON_JOBS = _env_path("OPENCLAW_CRON_JOBS", os.path.join(OPENCLAW_HOME, "cron", "jobs.json"))
+CRON_STATE = _env_path("OPENCLAW_CRON_STATE", os.path.join(OPENCLAW_HOME, "cron", "jobs-state.json"))
+CRON_RUNS_DIR = _env_path("OPENCLAW_CRON_RUNS", os.path.join(OPENCLAW_HOME, "cron", "runs"))
+SESSIONS_BASE = _env_path("OPENCLAW_SESSIONS", os.path.join(OPENCLAW_HOME, "agents"))
+EXTENSIONS_DIR = _env_path("OPENCLAW_EXTENSIONS", os.path.join(OPENCLAW_HOME, "extensions"))
+
+LOG_DIR = _env_path("OPENCLAW_LOG_DIR", "/tmp/openclaw")
+SERVICE_FILE = _env_path(
+    "OPENCLAW_SERVICE_FILE",
+    os.path.join(HOME, ".config", "systemd", "user", "openclaw-gateway.service"),
+)
+SERVICE_ENV_FILE = _env_path(
+    "OPENCLAW_SERVICE_ENV_FILE",
+    os.path.join(HOME, ".config", "systemd", "user", "openclaw-gateway.service.d", "env.conf"),
+)
+
+
+def home() -> str:
+    return HOME
+
+
+def config_path() -> str:
+    return CONFIG
+
+
+def log_dir() -> str:
+    return LOG_DIR
+
+
+def sessions_base() -> str:
+    return SESSIONS_BASE

package/ocdiag/recent_logs.py

@@ -0,0 +1,53 @@
+"""Discover today's openclaw log files."""
+
+from __future__ import annotations
+
+import glob
+import os
+import time
+from datetime import datetime
+from typing import List, Optional
+
+
+def _today_start_epoch() -> float:
+    today = datetime.now().date()
+    return time.mktime(today.timetuple())
+
+
+def discover_recent_logs(log_dir: str) -> List[str]:
+    """Return log files whose mtime >= today 00:00, sorted newest first."""
+    pattern = os.path.join(log_dir, "openclaw-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9].log")
+    matched: List[tuple] = []
+    cutoff = _today_start_epoch()
+    for f in glob.glob(pattern):
+        if not os.path.isfile(f):
+            continue
+        try:
+            m = os.path.getmtime(f)
+        except OSError:
+            continue
+        if m >= cutoff:
+            matched.append((m, f))
+    matched.sort(reverse=True)
+    return [p for _, p in matched]
+
+
+def latest_app_log(log_dir: str) -> Optional[str]:
+    pattern = os.path.join(log_dir, "openclaw-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9].log")
+    matched: List[tuple] = []
+    for f in glob.glob(pattern):
+        try:
+            matched.append((os.path.getmtime(f), f))
+        except OSError:
+            continue
+    if not matched:
+        today = datetime.now().strftime("%Y-%m-%d")
+        candidate = os.path.join(log_dir, f"openclaw-{today}.log")
+        return candidate if os.path.isfile(candidate) else None
+    matched.sort(reverse=True)
+    return matched[0][1]
+
+
+def all_logs(log_dir: str) -> List[str]:
+    pattern = os.path.join(log_dir, "openclaw-*.log")
+    return sorted(glob.glob(pattern))