feat: OpenMesh 基础平台与 MD/PDF 转换技能

- 后端: coworker 智能体框架, WS API, 文件上传, 附件处理
- 前端: Open WebUI, 文件全量走 upload API (含 MD/TXT/JSON 等文本类)
- 技能: md-to-office (pandoc + wkhtmltopdf)
- 修复: 上传文件路径丢失, Agent 搜索浪费, 输出文件跑到 uploads/
- 打包: PyInstaller one-dir, 预打包 pandoc/wkhtmltopdf/chromium

coworker/inbox_routing.py

@@ -0,0 +1,164 @@
+"""Multi-inbox routing — named inboxes + delivery bindings.
+
+An inbox is a named queue with optional delivery binding(s): in-app is always the store of
+record; a binding can also mirror items to a Slack channel or Telegram chat. Sessions route to
+an inbox by a per-session override, else the persona's default, else ``"default"``. Bindings
+are bidirectional: an item is delivered to the bound channel with its id embedded, and an
+inbound reply (correlated by that id) resolves the item — so the connectors/mobile are just
+transports of the same items. The gateway wiring is injected (a ``sender`` callable) so this
+module stays testable without touching Slack/Telegram.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import threading
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Callable, Optional
+
+DEFAULT_INBOX = "default"
+# Embeds the item id in a delivered message. Emitted as [ow:…] since the bot's rebrand
+# to OpenWorker (2026-07-22); the legacy [ocw:…] spelling stays parseable so replies to
+# messages sent before the rename still resolve.
+_ID_TOKEN = re.compile(r"\[o(?:c)?w:([0-9a-f]{6,})\]")
+
+
+@dataclass
+class InboxBinding:
+    name: str
+    channel: Optional[str] = None  # None (in-app only) | "slack" | "telegram"
+    target: str = ""  # channel id / chat id for the binding
+
+
+class InboxRouting:
+    def __init__(self, path: Optional[str | Path] = None) -> None:
+        self.path = Path(path) if path else None
+        self._lock = threading.Lock()
+        self._bindings: dict[str, InboxBinding] = {
+            DEFAULT_INBOX: InboxBinding(DEFAULT_INBOX)
+        }
+        self._persona_default: dict[str, str] = {}
+        self._session_override: dict[str, str] = {}
+        self._load()
+
+    def _load(self) -> None:
+        if self.path and self.path.is_file():
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+            for raw in data.get("bindings", []):
+                b = InboxBinding(**raw)
+                self._bindings[b.name] = b
+            self._persona_default = dict(data.get("persona_default", {}))
+            self._session_override = dict(data.get("session_override", {}))
+
+    def _save(self) -> None:
+        if not self.path:
+            return
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(
+            json.dumps(
+                {
+                    "bindings": [asdict(b) for b in self._bindings.values()],
+                    "persona_default": self._persona_default,
+                    "session_override": self._session_override,
+                },
+                indent=2,
+            ),
+            encoding="utf-8",
+        )
+
+    # -- config -----------------------------------------------------------------
+    def set_binding(
+        self, name: str, *, channel: Optional[str] = None, target: str = ""
+    ) -> None:
+        with self._lock:
+            self._bindings[name] = InboxBinding(name, channel, target)
+            self._save()
+
+    def binding_for(self, name: str) -> InboxBinding:
+        return self._bindings.get(name) or InboxBinding(name)
+
+    def set_persona_default(self, persona_id: str, inbox_name: str) -> None:
+        with self._lock:
+            self._persona_default[persona_id] = inbox_name
+            self._save()
+
+    def set_session_override(self, session_id: str, inbox_name: str) -> None:
+        with self._lock:
+            self._session_override[session_id] = inbox_name
+            self._save()
+
+    # -- resolution -------------------------------------------------------------
+    def route_for(self, session_id: str, persona_id: Optional[str] = None) -> str:
+        """Per-session override > persona default > the global default inbox."""
+        if session_id in self._session_override:
+            return self._session_override[session_id]
+        if persona_id and persona_id in self._persona_default:
+            return self._persona_default[persona_id]
+        return DEFAULT_INBOX
+
+    def bindings(self) -> list[dict]:
+        return [asdict(b) for b in self._bindings.values()]
+
+
+# -- delivery + inbound correlation ---------------------------------------------
+Sender = Callable[[str, str, str], None]  # (channel, target, text) -> None
+
+
+def deliver(item, binding: InboxBinding, sender: Optional[Sender]) -> bool:
+    """Mirror an inbox item to its bound channel (if any). The item id is embedded so an inbound
+    reply can be correlated back. In-app-only bindings deliver nothing here. Returns True if a
+    channel message was sent."""
+    if not binding.channel or sender is None:
+        return False
+    text = f"{item.title}\n{item.body}\n[ow:{item.id}]".strip()
+    sender(binding.channel, binding.target, text)
+    return True
+
+
+# Decision keywords for a channel reply. Matched against the reply's LEADING word/emoji
+# only (see _reply_intent). Substring matching turned "disallow" into allow and "note"
+# into deny; whole-word matching anywhere (the interim fix) still inverted negated
+# replies — "I cannot approve this yet" matched \bapprove\b and, with allow checked
+# first, executed the declined action. Leading-word intent keeps "Yes, go ahead" /
+# "No." / "👍" working; everything else is a free-text answer, which the approval path
+# already maps to deny — the safe default for an approval gate.
+_ALLOW_WORDS = frozenset({"approve", "approved", "allow", "allowed", "yes"})
+_DENY_WORDS = frozenset({"deny", "denied", "reject", "rejected", "no"})
+_ALLOW_EMOJI = ("👍", "✅")
+_DENY_EMOJI = ("👎", "❌")
+_TOKEN_TRIM = ".,!?:;'\"()"
+
+
+def _reply_intent(text: str) -> Optional[str]:
+    """Allow/deny intent from the first word (or emoji) of a reply, else None."""
+    first = text.split()[0] if text.split() else ""
+    if first.startswith(_ALLOW_EMOJI):  # startswith: tolerate skin-tone modifiers
+        return "allow"
+    if first.startswith(_DENY_EMOJI):
+        return "deny"
+    word = first.strip(_TOKEN_TRIM).lower()
+    if word in _ALLOW_WORDS:
+        return "allow"
+    if word in _DENY_WORDS:
+        return "deny"
+    return None
+
+
+def resolve_from_reply(
+    reply: str, resolve: Callable[[str, str], bool]
+) -> Optional[bool]:
+    """Correlate an inbound channel reply to its item (by the embedded id) and resolve it.
+
+    Looks for the ``[ow:<id>]`` token (or legacy ``[ocw:…]``) and an allow/deny intent in the
+    reply's leading word; falls back to treating the whole message as a free-text answer.
+    ``resolve(item_id, resolution)`` is the InboxStore.resolve.
+    Returns the resolve() result, or None if no item id was found."""
+    m = _ID_TOKEN.search(reply or "")
+    if not m:
+        return None
+    item_id = m.group(1)
+    text = _ID_TOKEN.sub("", reply).strip()
+    resolution = _reply_intent(text) or text  # free-text answer to a question
+    return resolve(item_id, resolution)