napcat-cli 2.0.0__py3-none-any.whl

napcat_cli/wake_orchestrator.py

@@ -0,0 +1,302 @@
+"""Wake orchestrator — debounce, cooldown, backlog sweep, contextual prompts.
+
+Sits between :class:`napcat_cli.daemon.watch.EventProcessor` and the
+:class:`napcat_cli.wake_backend.Waker`. Events arrive on the daemon's asyncio
+loop; this module offloads the blocking wake (HTTP/subprocess) to a worker
+thread so the loop never blocks, and adds:
+
+- **Debounce**: a burst of same-reason events within ``debounce_seconds``
+  coalesces into one wake.
+- **Cooldown**: per-reason ``cooldown_seconds`` suppresses repeats. ``AT_ME`` and
+  ``REPLY_TO_ME`` bypass cooldown (near-immediate wake) so direct mentions are
+  answered promptly.
+- **NEW_MESSAGE backlog sweep**: if unread messages accumulate longer than
+  ``new_message_idle_seconds`` without a wake, fire a ``NEW_MESSAGE_BACKLOG``
+  wake so the agent scans the inbox.
+- **Contextual prompts**: the wake prompt summarizes *what* happened (who, where,
+  text, counts) instead of a generic "new message".
+- **Legacy fallback**: if no backend is configured but a ``wake_command`` is set,
+  it is run as-is (back-compat for ``echo … >> .agent-wake`` configs).
+"""
+from __future__ import annotations
+
+import queue
+import threading
+import time
+from typing import Any, Callable
+
+from .wake_backend import Waker
+from .wake import render_wake_command
+
+# Reasons that should wake near-immediately and ignore cooldown.
+_IMMEDIATE = {"AT_ME", "REPLY_TO_ME"}
+# Message-class reasons — a wake for any of these counts as "the agent read the inbox".
+_MESSAGE_REASONS = {"AT_ME", "REPLY_TO_ME", "NEW_MESSAGE", "NEW_MESSAGE_BACKLOG",
+                    "GROUP_TRIGGER", "PRIVATE_TRIGGER"}
+
+_PROMPT_FOOTER = (
+    "你可以用 `napcat events` / `napcat alerts` 查看详情，用 `napcat send`/`napcat reply` 回复。"
+)
+
+
+# ---------------------------------------------------------------------------
+# Prompt construction
+# ---------------------------------------------------------------------------
+
+def _event_text(event: dict) -> str:
+    msg = event.get("message") if isinstance(event, dict) else None
+    if msg is None and isinstance(event, dict):
+        msg = event.get("raw_message", "")
+    if isinstance(msg, list):
+        return "".join(
+            (s.get("data") or {}).get("text", "")
+            for s in msg
+            if isinstance(s, dict) and s.get("type") == "text"
+        ).strip()
+    return str(msg or "").strip()
+
+
+def _who(event: dict) -> str:
+    s = event.get("sender") if isinstance(event.get("sender"), dict) else {}
+    nick = s.get("nickname") or event.get("user_id") or "?"
+    return f"{nick}({event.get('user_id', '?')})"
+
+
+def _where(event: dict) -> str:
+    g = event.get("group_id")
+    return f"群{g}" if g else "私聊"
+
+
+def build_prompt(reason: str, events: list[dict]) -> str:
+    """Build a contextual wake prompt for a coalesced batch of events."""
+    events = [e for e in events if isinstance(e, dict)]
+    n = len(events)
+
+    if reason in ("AT_ME", "REPLY_TO_ME"):
+        who = _who(events[-1]) if events else "?"
+        where = _where(events[-1]) if events else "?"
+        text = _event_text(events[-1]) if events else ""
+        verb = "被 @" if reason == "AT_ME" else "被回复"
+        head = f"你在{where}{verb}了" + (f"{n}次" if n > 1 else "")
+        body = f"。最近一条来自 {who}：{text}" if text else ""
+        action = "请尽快查看并回复。" if reason == "AT_ME" else "请查看并酌情回复。"
+        return f"【QQ {reason}】{head}{body}。{action}\n{_PROMPT_FOOTER}"
+
+    if reason == "NEW_MESSAGE_BACKLOG":
+        return f"【QQ 未读积压】有约 {n} 条未读新消息积压了一段时间，请扫一眼收件箱，酌情回复需要回复的。\n{_PROMPT_FOOTER}"
+
+    if reason in ("NEW_MESSAGE", "GROUP_TRIGGER", "PRIVATE_TRIGGER"):
+        text = _event_text(events[-1]) if events else ""
+        return f"【QQ 新消息】收到 {n} 条新消息。最近：{_where(events[-1]) if events else ''} {_who(events[-1]) if events else ''}：{text}\n{_PROMPT_FOOTER}"
+
+    if reason == "NEW_FRIEND":
+        ids = sorted({str(e.get("user_id", "")) for e in events if e.get("user_id")})
+        return f"【QQ 新好友】新增好友 {n} 个：{', '.join(ids)}。可酌情打招呼或忽略。\n{_PROMPT_FOOTER}"
+
+    if reason == "NEW_REQUEST":
+        reqs = []
+        for e in events:
+            rt = e.get("request_type", "?")
+            sub = e.get("sub_type", "")
+            comment = str(e.get("comment", ""))[:40]
+            reqs.append(f"{rt}/{sub} from {e.get('user_id','?')}" + (f"「{comment}」" if comment else ""))
+        return f"【QQ 请求】收到 {n} 个加好友/加群请求：{'; '.join(reqs)}。请决定是否同意（用 napcat api set_friend_add_request/set_group_add_request）。\n{_PROMPT_FOOTER}"
+
+    if reason == "BOT_BANNED":
+        e = events[-1] if events else {}
+        return f"【QQ 被禁言】你在{e.get('group_id','?')}被禁言，操作者 {e.get('operator_id','?')}，时长 {e.get('duration','?')}s。请知悉。"
+
+    if reason == "BOT_KICKED_FROM_GROUP":
+        return f"【QQ 被踢出群】你被踢出/移除了 {n} 个群。请知悉。"
+
+    if reason == "GROUP_ADMIN_CHANGE":
+        return f"【QQ 管理员变动】你的群管理员权限发生变动。请知悉。"
+
+    if reason in ("NEW_POKE", "PROFILE_LIKE"):
+        e = events[-1] if events else {}
+        return f"【QQ 戳一戳】{e.get('sender_id') or e.get('operator_id','?')} 戳了你/赞了你 {n} 次。可酌情互动。"
+
+    if reason == "NEW_GROUP_MEMBER":
+        ids = sorted({str(e.get("user_id", "")) for e in events if e.get("user_id")})
+        return f"【QQ 新群成员】{n} 个新成员加入：{', '.join(ids)}。可酌情欢迎。"
+
+    if reason == "BOT_OFFLINE":
+        return "【QQ 掉线】NapCat bot 连接丢失/离线。请检查容器与登录状态。"
+
+    # generic fallback
+    summaries = "; ".join(str(e.get("summary", ""))[:60] for e in events if e.get("summary"))
+    return f"【QQ 事件 {reason}】{summaries or f'{n} 个事件'}。请查看 napcat events。\n{_PROMPT_FOOTER}"
+
+
+# ---------------------------------------------------------------------------
+# Orchestrator
+# ---------------------------------------------------------------------------
+
+class WakeOrchestrator:
+    def __init__(
+        self,
+        waker: Waker,
+        *,
+        log: Callable[[str], None] = lambda _msg: None,
+        debounce_seconds: float = 3.0,
+        cooldown_seconds: float = 30.0,
+        new_message_idle_seconds: int = 600,
+        legacy_command: str = "",
+        legacy_session: str = "",
+        wake_timeout: float = 120.0,
+    ):
+        self.waker = waker
+        self.log = log
+        self.debounce_seconds = debounce_seconds
+        self.cooldown_seconds = cooldown_seconds
+        self.new_message_idle_seconds = new_message_idle_seconds
+        self.legacy_command = legacy_command
+        self.legacy_session = legacy_session
+        self.wake_timeout = wake_timeout
+
+        self._lock = threading.Lock()
+        self._pending: dict[str, list[dict]] = {}
+        self._timers: dict[str, threading.Timer] = {}
+        self._last_wake: dict[str, float] = {}
+
+        # unread-new-message tracking for backlog sweep (in-memory; best-effort)
+        self._unread_since: float | None = None
+        self._unread_count: int = 0
+        self._last_message_wake: float = 0.0
+
+        self._queue: "queue.Queue[tuple[str, str, list[dict]] | None]" = queue.Queue()
+        self._worker = threading.Thread(target=self._run, name="napcat-wake-worker", daemon=True)
+        self._worker.start()
+
+    # -- public API --------------------------------------------------------
+
+    def submit(self, reason: str, event: dict | None = None) -> None:
+        """Queue a wake for ``reason`` (debounced). Non-blocking."""
+        with self._lock:
+            self._pending.setdefault(reason, []).append(event or {})
+            n = len(self._pending[reason])
+            # (re)start debounce timer
+            old = self._timers.get(reason)
+            if old:
+                old.cancel()
+            # near-immediate for direct mentions (coalesces sub-second bursts), debounce otherwise
+            delay = min(self.debounce_seconds, 1.0) if reason in _IMMEDIATE else self.debounce_seconds
+            t = threading.Timer(delay, self._flush, args=(reason,))
+            t.daemon = True
+            self._timers[reason] = t
+            t.start()
+        self.log(f"[WAKE] queued reason={reason} pending={n} debounce={delay:.1f}s "
+                 f"primary={getattr(self.waker, 'primary', '?')}")
+
+    def note_new_message(self, event_time: float) -> None:
+        """Track an incoming NEW_MESSAGE for backlog detection (not a wake)."""
+        with self._lock:
+            if self._unread_since is None:
+                self._unread_since = event_time or time.time()
+            self._unread_count += 1
+
+    def maybe_backlog_sweep(self, now: float | None = None) -> bool:
+        """Called periodically. Fire a backlog wake if unread messages are stale.
+
+        Returns True if a backlog wake was queued.
+        """
+        now = now or time.time()
+        with self._lock:
+            if self._unread_since is None or self._unread_count == 0:
+                return False
+            idle = now - self._unread_since
+            since_wake = now - self._last_message_wake
+            if idle < self.new_message_idle_seconds:
+                return False
+            if since_wake < self.new_message_idle_seconds:
+                return False
+            count = self._unread_count
+            # consume the unread batch — the agent will read them
+            self._unread_since = None
+            self._unread_count = 0
+            self._last_message_wake = now
+        self.log(f"[WAKE] backlog reason=NEW_MESSAGE_BACKLOG unread={count} "
+                 f"idle={int(idle)}s>={self.new_message_idle_seconds}s")
+        # synthesize a backlog reason via submit/cooldown-bypass
+        with self._lock:
+            self._pending.setdefault("NEW_MESSAGE_BACKLOG", []).extend([{}] * count)
+        self._fire_now("NEW_MESSAGE_BACKLOG", count)
+        return True
+
+    def stop(self) -> None:
+        self._queue.put(None)
+        with self._lock:
+            for t in list(self._timers.values()):
+                t.cancel()
+            self._timers.clear()
+
+    # -- internals ---------------------------------------------------------
+
+    def _flush(self, reason: str) -> None:
+        """Timer callback: apply cooldown, then enqueue a coalesced wake."""
+        with self._lock:
+            self._timers.pop(reason, None)
+            events = self._pending.pop(reason, [])
+            if not events:
+                return
+            now = time.time()
+            if reason not in _IMMEDIATE:
+                last = self._last_wake.get(reason, 0.0)
+                if now - last < self.cooldown_seconds:
+                    self.log(f"[WAKE] suppressed reason={reason} cooldown "
+                             f"age={int(now - last)}s/{int(self.cooldown_seconds)}s buffered={len(events)}")
+                    return
+            self._last_wake[reason] = now
+            if reason in _MESSAGE_REASONS:
+                self._last_message_wake = now
+                # a real message wake consumes unread backlog tracking
+                self._unread_since = None
+                self._unread_count = 0
+        self._enqueue(reason, events)
+
+    def _fire_now(self, reason: str, count: int) -> None:
+        """Bypass debounce/cooldown for synthesized backlog wakes."""
+        with self._lock:
+            events = self._pending.pop(reason, []) or [{"_synthesized": True} for _ in range(count)]
+            self._last_wake[reason] = time.time()
+        self._enqueue(reason, events)
+
+    def _enqueue(self, reason: str, events: list[dict]) -> None:
+        prompt = build_prompt(reason, events)
+        self._queue.put((reason, prompt, events))
+
+    def _run(self) -> None:
+        while True:
+            job = self._queue.get()
+            if job is None:
+                break
+            reason, prompt, events = job
+            try:
+                self._do_wake(reason, prompt, events)
+            except Exception as e:  # never let the worker die
+                self.log(f"wake worker error ({reason}): {e}")
+
+    def _do_wake(self, reason: str, prompt: str, events: list[dict]) -> None:
+        idem = f"napcat-{reason}-{int(time.time())}"
+        ctx = {"reason": reason, "count": len(events)}
+        if self.waker.empty and self.legacy_command:
+            # legacy escape hatch (e.g. echo >> .agent-wake) — run as-is
+            cmd = render_wake_command(self.legacy_command, reason=reason, session=self.legacy_session)
+            self.log(f"[WAKE] deliver reason={reason} transport=legacy cmd={cmd}")
+            import subprocess
+            try:
+                r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
+                self.log(f"[WAKE] deliver reason={reason} transport=legacy ok={r.returncode == 0} exit={r.returncode}")
+                _out = (r.stdout or "").strip()
+                if _out:
+                    self.log(f"[WAKE] reply reason={reason} transport=legacy: {' '.join(_out.split())[:500]}")
+            except Exception as e:
+                self.log(f"[WAKE] deliver reason={reason} transport=legacy ok=False error={e}")
+            return
+        res = self.waker.wake(prompt, reason, ctx, idem_key=idem, timeout=self.wake_timeout)
+        self.log(f"[WAKE] deliver reason={reason} transport={res.transport} ok={res.ok} "
+                 f"elapsed={res.elapsed:.1f}s :: {res.detail}")
+        _reply = (res.extra or {}).get("reply") or ""
+        if _reply.strip():
+            self.log(f"[WAKE] reply reason={reason} transport={res.transport}: "
+                     f"{' '.join(_reply.split())[:500]}")

napcat_cli/wake_presets.py

@@ -0,0 +1,77 @@
+"""Wake presets — turn NapCatConfig into a :class:`Waker`.
+
+Hermes is the default preset but is *not* required. ``custom`` lets you point the
+HTTP/CLI backends at any agent; ``none`` disables wake. The HTTP key is read
+from ``NAPCAT_WAKE_HTTP_KEY`` (or ``HERMES_API_KEY``) if not set in config, so it
+does not have to live in plaintext ``config.json``.
+"""
+from __future__ import annotations
+
+import os
+
+from .lib.config import NapCatConfig
+from .wake_backend import CliWakeBackend, HttpWakeBackend, Waker
+
+HERMES_DEFAULT_HTTP_URL = "http://127.0.0.1:8642"
+HERMES_DEFAULT_CLI = "hermes --continue {session} -z {prompt} --yolo --pass-session-id"
+HERMES_PATH = "/api/sessions/{session}/chat"
+
+
+def _http_key(cfg: NapCatConfig) -> str:
+    return (
+        cfg.wake_http_key
+        or os.environ.get("NAPCAT_WAKE_HTTP_KEY", "")
+        or os.environ.get("HERMES_API_KEY", "")
+    )
+
+
+def _http_backend(cfg: NapCatConfig, *, fill_defaults: bool) -> HttpWakeBackend | None:
+    base = cfg.wake_http_url or (HERMES_DEFAULT_HTTP_URL if fill_defaults else "")
+    key = _http_key(cfg)
+    if not base or not key:
+        return None
+    return HttpWakeBackend(
+        base_url=base,
+        key=key,
+        session=cfg.wake_session,
+        session_id=cfg.wake_http_session_id,
+        path_template=HERMES_PATH,
+        body_field="input",
+        label="hermes-http" if fill_defaults else "http",
+    )
+
+
+def _cli_backend(cfg: NapCatConfig, *, fill_defaults: bool) -> CliWakeBackend | None:
+    tmpl = cfg.wake_cli_command or (HERMES_DEFAULT_CLI if fill_defaults else "")
+    if not tmpl:
+        return None
+    return CliWakeBackend(tmpl, session=cfg.wake_session,
+                          label="hermes-cli" if fill_defaults else "cli")
+
+
+def build_waker(cfg: NapCatConfig) -> Waker:
+    """Build a Waker from ``cfg.wake_preset`` and the wake_* config fields."""
+    preset = (cfg.wake_preset or "hermes").lower()
+    backends = []
+
+    if preset == "hermes":
+        # Hermes defaults fill empty fields; http is optional (needs key), cli is on by default.
+        http = _http_backend(cfg, fill_defaults=True)
+        cli = _cli_backend(cfg, fill_defaults=True)
+        if http:
+            backends.append(http)
+        if cli:
+            backends.append(cli)
+    elif preset == "custom":
+        http = _http_backend(cfg, fill_defaults=False)
+        cli = _cli_backend(cfg, fill_defaults=False)
+        if http:
+            backends.append(http)
+        if cli:
+            backends.append(cli)
+    # preset == "none": no backends
+
+    primary = (cfg.wake_primary or "auto").lower()
+    if primary not in ("http", "cli", "auto"):
+        primary = "auto"
+    return Waker(backends, primary=primary)

napcat_cli-2.0.0.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: napcat-cli
+Version: 2.0.0
+Summary: Standalone CLI and daemon for NapCat QQ bot management with skills-fs integration
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: textual>=0.40
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# napcat-cli
+
+Standalone CLI and daemon for NapCat QQ bot management with skills-fs integration.
+
+> 📝 **介绍博文：** [napcat-cli 群配置与管理速查](https://yvxi.pages.dev/blog/napcat-cli-group-config/) — 从零配置、群消息收发、Agent Wake 的完整链路。
+
+---
+
+napcat-cli provides a CLI for all NapCat API operations, a WebSocket daemon
+that bridges to a skills-fs HTTP provider, and an agent wake-up mechanism for
+integrating with Hermes or other AI agents.
+
+```bash
+napcat send group 123456 -m "Hello"
+napcat send private 987654 -m "Hi"
+napcat recall 1001
+napcat events --limit 10
+napcat daemon start
+napcat wake --reason NEW_MESSAGE
+```
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `napcat api <endpoint>` | Raw API access (like `gh api`) |
+| `napcat send group <id> -m "msg"` | Send group message |
+| `napcat send private <id> -m "msg"` | Send private message |
+| `napcat reply <id> -m "msg"` | Reply to a message |
+| `napcat recall <msg_id>` | Recall a message |
+| `napcat group <sub>` | Group list, members, settings |
+| `napcat friend <sub>` | Friend list, info |
+| `napcat file <sub>` | File upload, download, list |
+| `napcat events` | Read events from SQLite |
+| `napcat alerts [--clear]` | Pending alerts |
+| `napcat status` | Bot online status |
+| `napcat config get/set` | Configuration management |
+| `napcat daemon start/stop/status/restart` | Watch daemon |
+| `napcat fs tree` | Skills-fs directory tree |
+| `napcat wake [--reason R] [--prompt P] [--transport T] [--dry-run]` | Wake the configured agent (HTTP/CLI, auto-fallback) |
+| `napcat setup` | Interactive setup wizard |
+| `napcat phone` | Textual phone-style TUI |
+
+---
+
+## Setup
+
+```bash
+uv tool install napcat-cli
+napcat setup          # interactive — guides token, data dir, skills-fs, wake
+napcat daemon start
+```
+
+The setup wizard writes two config files:
+
+- `<data_dir>/config.json` — API URL, token, self_id, ports, triggers
+- `<data_dir>/daemon.json` — All fields consumed by `watch.py` including `skills_fs_*` settings
+
+Non-interactive mode uses defaults:
+
+```bash
+napcat setup --non-interactive  # no prompts, validates token
+napcat setup --yes              # skip token validation
+napcat setup --force            # overwrite existing config
+```
+
+---
+
+## Agent Wake
+
+When a notable QQ event arrives, the daemon wakes an external agent (Hermes by
+default) carrying a **contextual prompt** so it can read the inbox and reply.
+The wake mechanism is **generic and pluggable** — Hermes is just the default
+preset; any HTTP endpoint or shell command works.
+
+### Two transports, auto-fallback
+
+| Transport | When it's used | Needs |
+|-----------|----------------|-------|
+| **CLI one-shot** (default) | Always available | `hermes` on PATH |
+| **HTTP API server** | Opt-in (best latency, idempotent, in-session) | `wake_http_url` + `wake_http_key` |
+
+`wake_primary=auto` tries HTTP first (if configured + reachable), else falls back
+to the CLI one-shot. The Hermes CLI backend runs
+`hermes --continue <session> -z "<prompt>" --yolo --pass-session-id`; the HTTP
+backend POSTs to `POST /api/sessions/{id}/chat` (verified per the Hermes API
+docs), with `Authorization: Bearer <key>` and an `Idempotency-Key` header.
+
+### Event routing
+
+| Trigger | Behavior |
+|---------|----------|
+| `AT_ME`, `REPLY_TO_ME` | Near-immediate wake (cooldown bypassed), with who/where/text in the prompt |
+| `GROUP_TRIGGER`, `PRIVATE_TRIGGER` | Debounced wake |
+| `NEW_MESSAGE` (not @) | Tracked, not woken; if unread longer than `wake_new_message_idle_seconds` → a `NEW_MESSAGE_BACKLOG` wake |
+| `NEW_FRIEND`, `NEW_REQUEST`, `BOT_BANNED`, `NEW_POKE`, `GROUP_ADMIN_CHANGE`, `NEW_GROUP_MEMBER`, `BOT_OFFLINE`, … | Debounced + cooldown-bounded wake so the agent perceives them within a reasonable window |
+
+Debounce (`wake_debounce_seconds`, default 3) coalesces a burst into one wake;
+cooldown (`wake_cooldown_seconds`, default 30) suppresses repeats. Every wake is
+logged to `daemon.log` as `[WAKE] trigger / queued / deliver / reply` lines
+(including transport, elapsed time, and the agent's reply), and `daemon.log` is
+size-rotated (2 MB × 5) so it can't fill the disk.
+
+### Configure
+
+The easiest path is the wizard:
+
+```bash
+napcat setup        # choose Hermes preset; CLI one-shot by default, HTTP opt-in
+```
+
+Or set keys directly:
+
+```bash
+napcat config set wake_enabled true
+napcat config set wake_preset hermes        # hermes | custom | none
+napcat config set wake_session napcat-qq
+napcat config set wake_primary auto         # auto | http | cli
+# HTTP (optional). Key also readable from NAPCAT_WAKE_HTTP_KEY / HERMES_API_KEY:
+napcat config set wake_http_url http://127.0.0.1:8642
+napcat config set wake_http_key <API_SERVER_KEY>
+napcat config set wake_new_message_idle_seconds 600
+```
+
+To enable the Hermes HTTP API server (appends to `~/.hermes/.env` and restarts
+the `hermes-gateway.service` systemd unit), answer "y" during `napcat setup`, or
+set `API_SERVER_ENABLED=true` + `API_SERVER_KEY` in `~/.hermes/.env` yourself and
+`sudo systemctl restart hermes-gateway.service`.
+
+### Manual / debug
+
+```bash
+napcat wake                           # reason: manual, contextual default prompt
+napcat wake --reason AT_ME --prompt "hello"
+napcat wake --transport cli           # force a transport for this wake
+napcat wake --dry-run                 # render the HTTP request + CLI command without executing
+napcat wake test                      # per-transport configured + reachable probe
+napcat wake sessions                  # list Hermes sessions (HTTP backend)
+grep '\[WAKE\]' ~/.napcat-data/daemon.log    # see when/why/how wakes fired
+```
+
+The agent replies via `napcat send` / `napcat reply` (or the skills-fs write
+path) — see `napcat_cli/data/SKILL.md`. Legacy `wake_command` shell strings still
+run as a last-resort escape hatch when no backend is configured.
+
+---
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `NAPCAT_API_URL` | `http://127.0.0.1:18801` | NapCat HTTP endpoint |
+| `NAPCAT_TOKEN` | — | API auth token |
+| `NAPCAT_DATA_DIR` | `~/.napcat-data` | Data directory |
+
+---
+
+## skills-fs Integration
+
+The daemon runs an HTTP provider server (port 18820/18821) that skills-fs calls
+to read/write NapCat API endpoints through the virtual filesystem.
+
+When `skills_fs_enabled` is true in `daemon.json`, the daemon spawns skills-fs
+automatically with the configured mountpoint and config file.
+
+Manual start:
+
+```bash
+skills-fs fuse --config ~/.napcat-data/skills-fs.json \
+  --mountpoint ~/.napcat-data/skills/napcat-cli --allow-other
+```
+
+---
+
+## Development
+
+```
+napcat-cli/
+├── napcat_cli/          # Installable package
+│   ├── cli.py           # CLI entry point
+│   ├── wake.py          # Wake command-template renderer
+│   ├── wake_backend.py  # Generic HTTP/CLI wake transports + Waker (auto-fallback)
+│   ├── wake_presets.py  # Hermes/custom/none presets -> Waker
+│   ├── wake_orchestrator.py  # Debounce, cooldown, backlog sweep, contextual prompts
+│   ├── setup_wizard.py  # Setup wizard
+│   ├── daemon/          # Watch daemon, schemas
+│   ├── lib/             # API, config, events
+│   ├── tui/             # Textual TUI
+│   └── data/            # SKILL.md, persona.md
+├── pyproject.toml
+├── tests/
+├── skills-fs/           # Go submodule
+└── tools/               # Dev utilities
+```
+
+```bash
+python -m pytest tests/ -v
+python -m build --wheel
+uv build && uv publish
+```
+
+---
+
+## License
+
+MIT

napcat_cli-2.0.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+napcat_cli/__init__.py,sha256=uLnTthioRitJl0d-k4RSCjX3O_ZePv2fNzogDezNyiY,100
+napcat_cli/cli.py,sha256=k-2YttNxkFITM1HJ81mp7PNL276suviY_TVDLSvHVY8,77544
+napcat_cli/setup_wizard.py,sha256=MmOH5n3JKt81UDbC6JaIB3gaz5CdduAaS73VLM5gIuo,14498
+napcat_cli/wake.py,sha256=bhU70CBYJZwBmMjr-pbO1lzdYY8Fz01uyNGkjTavu7c,1632
+napcat_cli/wake_backend.py,sha256=ilOry4ReFWqLQFB3wiRs6Y5NO2IF66HSSpPeVjVbYcc,15762
+napcat_cli/wake_orchestrator.py,sha256=MVqrPQHxnRRh8W_-JAbb3Y7NktrgIBBZ7MNMmTSJris,13895
+napcat_cli/wake_presets.py,sha256=SxuZIacAX6uROgDg6PSy_DlNqvOZFBgaL4-4WAJL-J0,2707
+napcat_cli/daemon/__init__.py,sha256=ZSASPpn16p4LLYBG82YDOZCRrE1xm5OeLxkf02XizF8,25
+napcat_cli/daemon/schemas.py,sha256=BkCHLHmRCJr13UPsbAm8jUOem18Ejb3C_F4vF6hjAr4,20817
+napcat_cli/daemon/watch.py,sha256=ayrvDPnDyxD8gFlbu64omxq-TsK6nRJ_1exCDAMkppc,88632
+napcat_cli/data/SKILL.md,sha256=htWg2Ui4hC1Y2aC0BMnXk-EQPhnbA9Vvch7aj9IrNj0,13353
+napcat_cli/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+napcat_cli/data/persona.md,sha256=NhpiQ-HUCxN_XHhleqWzMpOXCcK9o6nqtxjzDYNSdnE,5713
+napcat_cli/data/skills-fs-config.json,sha256=jw8xFCHCfg16GeMP1tbazBpOmGAsVCSqAeUyxFafCGg,199
+napcat_cli/data/skills-fs-fragment.json,sha256=fKRHltmtil41wsrkDLWmnud-UU00U4Y15GFwWV3KibA,11418
+napcat_cli/data/references/mounting.md,sha256=n4Vn5yMH7OOJyO-dRSr0fJ46ZyeA__XONmLs8AocPM4,4395
+napcat_cli/data/skills-fs.d/agents-friend-time.md,sha256=OXVFP-w6tPGPNi3AiDOz13EIWAaeUNjjjoCseFINEIk,160
+napcat_cli/data/skills-fs.d/agents-friend.md,sha256=Lne5LA7Sqjm4I1nJPFK-54Vlzh5kmmb3DiEFgGbD6gI,190
+napcat_cli/data/skills-fs.d/agents-friends.md,sha256=DtGv_lm9jXuFnQe9AhUASB941MRC5nvhLFv6Ep8XcRc,185
+napcat_cli/data/skills-fs.d/agents-group-time.md,sha256=IFWWD_7pzjlBUWjTmtKPP6c4B9VTptsuafNJ0bLncx8,162
+napcat_cli/data/skills-fs.d/agents-group.md,sha256=k3yyAtIzkWoQq6fKuEg5Ck5WS3RKNHyol8ZWIEwr31s,126
+napcat_cli/data/skills-fs.d/agents-groups.md,sha256=iLEutqgxjD9LvqaTfKJZ6-HpUCjytCB3RzsRAZLOly8,233
+napcat_cli/data/skills-fs.d/agents-napcat.md,sha256=hcdg1ksk8NFFyz15jnuZaNtuPdVJGTO8rkQ6S1RNVHI,496
+napcat_cli/data/skills-fs.d/persona.md,sha256=NhpiQ-HUCxN_XHhleqWzMpOXCcK9o6nqtxjzDYNSdnE,5713
+napcat_cli/data/skills-fs.d/skill-agents.md,sha256=Jiopoj1xBjsDE5OHrRDOHVBG8amEI-VToJCdzpRH0eI,1793
+napcat_cli/data/skills-fs.d/skill-body.md,sha256=-yoCWvIqAjdFulQ0GJlBU_EaJTO43U-p9MoMZp5z7zw,5424
+napcat_cli/lib/__init__.py,sha256=bOl0q7d8qqfglMmR928vy3xcxci0-HLPCKqpimu8yMQ,26
+napcat_cli/lib/api.py,sha256=xHblnqVgjmEtKZNw6Y-HjNYZedw7h9WFZJEOdGUFd2Q,10329
+napcat_cli/lib/config.py,sha256=ILNCUCwCD1S8Q8m6RBNh2AZZCg7_wL7P4akxmPqkyhk,3827
+napcat_cli/lib/events.py,sha256=dLns-7g2SkjT-9jaxQP_leC5-UvfXoNZ6tXgVB1KFXI,3866
+napcat_cli/lib/events_sqlite.py,sha256=QQyCbTIETfV45aJ61I7lMsF1-kMg8pZbXLSWkb2e7Zg,8185
+napcat_cli/lib/message.py,sha256=S04KDbRGnu22xZzuZbxu02--3DeQ-7cxM3of6xYK9Rk,4581
+napcat_cli/tui/__init__.py,sha256=3kSNNdR0JUY18jUDzMVGXwBPZnBq7WrKLwqB0uIcBz4,62
+napcat_cli/tui/__main__.py,sha256=jR6ewycp8EiotB_V6rKwmF2uVS6eWj0jxSTueLFy330,191
+napcat_cli/tui/api.py,sha256=dWz1kSCQP5tyoavmKiNr6zHZBF6TziPOTgeHYHR5zBk,5795
+napcat_cli/tui/app.py,sha256=FxEaKqZNnGyNANAiHuGAi-lbagu37d8zlaqvFmYau4c,4875
+napcat_cli/tui/chat_list.py,sha256=CfjbLfBmhnqbRQO-AKwt0Wdk9hhLMJhmRl7RNDPAHJA,5543
+napcat_cli/tui/chat_view.py,sha256=EHh6RRa_IO0Ty6AV7uztkk0FPWjmVjYnQrxncvdn5PE,16191
+napcat_cli/tui/styles.tcss,sha256=kJJaBuOMO8FmdigHxn9eOq-__rGAIjaOfiBJ_W2YttA,346
+napcat_cli-2.0.0.dist-info/METADATA,sha256=MSZW6ctrJlksnjd7vem3ax2Xp4HQtNLgXlBqXhIAXxc,7944
+napcat_cli-2.0.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+napcat_cli-2.0.0.dist-info/entry_points.txt,sha256=xISOTwC-m9F5ywJuwDakrMK03ZSdmDn_tIX-8cM1oRg,47
+napcat_cli-2.0.0.dist-info/RECORD,,

napcat_cli-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

napcat_cli-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+napcat = napcat_cli.cli:main