diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d1ded0ff54..3441d7bb6d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -115,6 +115,11 @@ jobs: needs: detect uses: ./.github/workflows/uv-lockfile-check.yml + infographic-check: + name: Check no committed infographics + needs: detect + uses: ./.github/workflows/infographic-check.yml + lockfile-diff: name: package-lock.json diff needs: detect diff --git a/.github/workflows/infographic-check.yml b/.github/workflows/infographic-check.yml new file mode 100644 index 0000000000..288f6f493a --- /dev/null +++ b/.github/workflows/infographic-check.yml @@ -0,0 +1,78 @@ +name: Infographic Check + +# Rejects PRs that commit PR-infographic images into the repo. +# +# PR infographics are rendered to an image-provider URL (fal.media) and +# embedded in the PR *description*. The PR body is the archive; the binary +# never belongs in git history. +# +# This has now leaked twice. PR #48261 removed the first batch, PR #54564 +# removed a second batch and added `infographic/` to `.gitignore` — but +# `.gitignore` only stops *accidental* `git add`. It does nothing against +# `git add -f`, and it does nothing for a path that does not literally match +# the ignore pattern. Nine more PNGs (~14MB) were committed in the four +# weeks AFTER that rule landed, plus PR #70552 caught an `infograficos/` +# spelling that sidestepped the pattern entirely. +# +# A passive ignore rule cannot enforce a policy. This check can. + +on: + workflow_call: + outputs: + review_status: + description: "JSON array of review_status objects for the synthesizer." + value: ${{ jobs.check-no-committed-infographics.outputs.review_status }} + +permissions: + contents: read + +jobs: + check-no-committed-infographics: + runs-on: ubuntu-latest + timeout-minutes: 10 + outputs: + review_status: ${{ steps.infographic-check.outputs.review_status }} + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + + - id: infographic-check + name: Reject committed PR-infographic images + run: | + # Match on the IMAGE, not on a directory name. Keying this to + # `infographic/` is what let `infograficos/` through in #70552 — + # any localized or typo'd directory would sidestep it again. + # Instead: find tracked raster images whose path contains an + # infographic-ish segment, in any spelling, at any depth. + # + # `docs/assets` and `website/` legitimately hold product imagery + # and are excluded; those are referenced from shipped docs pages. + OFFENDERS=$(git ls-files -z \ + | tr '\0' '\n' \ + | grep -iE '(^|/)(infograph|infograf)[^/]*/' \ + | grep -iE '\.(png|jpe?g|webp|gif)$' \ + || true) + + if [ -n "$OFFENDERS" ]; then + COUNT=$(printf '%s\n' "$OFFENDERS" | wc -l | tr -d ' ') + STATUS='[{"source":"committed infographics","results":[{"kind":"action_required","title":"PR infographic committed to the repo","summary":"Infographic images belong in the PR description, never in git.","detail":"","how_to_fix":"Untrack the image and reference the provider URL from the PR body instead:\n```\ngit rm --cached \n```\nThen put it in the PR description:\n```\n## Infographic\n\n![slug](https://)\n```\n"}]}]' + echo "review_status=${STATUS}" >> "$GITHUB_OUTPUT" + echo "" + echo "::error::${COUNT} PR-infographic image(s) are tracked in git." + echo "" + printf '%s\n' "$OFFENDERS" | sed 's/^/ /' + echo "" + echo "PR infographics are rendered to an image-provider URL and" + echo "embedded in the PR DESCRIPTION. The PR body is the archive —" + echo "the binary never enters git history." + echo "" + echo "This rule has been re-established twice already (#48261," + echo "#54564) and leaked both times, because .gitignore cannot stop" + echo "'git add -f' or a differently-spelled directory (#70552)." + echo "" + echo "To fix:" + echo " git rm --cached # keeps your local copy" + echo " # then embed the provider URL in the PR description" + exit 1 + fi + echo "::notice::No committed PR-infographic images." + echo "review_status=[]" >> "$GITHUB_OUTPUT" diff --git a/.gitignore b/.gitignore index 8c0ce9c23d..a72536f007 100644 --- a/.gitignore +++ b/.gitignore @@ -175,5 +175,13 @@ apps/desktop/demo/ # image-provider (fal.media) URL — they are NEVER committed to the repo. The # PR body is the archive. See the hermes-agent-dev skill's # pr-infographic-workflow reference (storage rule + lapse #8 / #COMMIT-1). +# +# Spelling variants are listed because a single `infographic/` pattern was +# sidestepped by an `infograficos/` directory (#70552). .gitignore is only +# the first line of defence and cannot stop `git add -f` at all — the +# infographic-check CI job is what actually enforces this. infographic/ +infographics/ +infograficos/ +infografico/ native/fts5_cjk/*.so diff --git a/AGENTS.md b/AGENTS.md index cb53e95eb0..d623ba59bb 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -325,7 +325,7 @@ class AIAgent: provider: str = None, api_mode: str = None, # "chat_completions" | "codex_responses" | ... model: str = "", # empty → resolved from config/provider later - max_iterations: int = 90, # tool-calling iterations (shared with subagents) + max_iterations: int = 500, # tool-calling iterations (shared with subagents) enabled_toolsets: list = None, disabled_toolsets: list = None, quiet_mode: bool = False, diff --git a/Dockerfile b/Dockerfile index 388056faac..42870d7377 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,3 +1,45 @@ +# Debian 13 still ships SQLite 3.46.1, which contains the upstream WAL-reset +# corruption bug. Build a pinned shared library for the runtime image instead +# of relying on a distro backport that trixie does not currently provide. +# See #70480 and https://sqlite.org/wal.html#walresetbug. +FROM debian:13.4 AS sqlite_build +ARG SQLITE_AUTOCONF_VERSION=3530400 +ARG SQLITE_SHA256=0e9483900e92cd5de8fd48d16bf9200145a61f7fd5be542a5ac81d8a9516eb9c +RUN apt-get -o Acquire::Retries=3 update && \ + apt-get -o Acquire::Retries=3 install -y --no-install-recommends \ + build-essential ca-certificates curl && \ + rm -rf /var/lib/apt/lists/* && \ + (curl -fsSL --retry 1 --retry-all-errors --connect-timeout 15 --max-time 60 \ + -o /tmp/sqlite.tar.gz \ + "https://sqlite.org/2026/sqlite-autoconf-${SQLITE_AUTOCONF_VERSION}.tar.gz" || \ + curl -fsSL --retry 3 --retry-all-errors --connect-timeout 15 --max-time 120 \ + -o /tmp/sqlite.tar.gz \ + "https://sources.buildroot.net/sqlite/sqlite-autoconf-${SQLITE_AUTOCONF_VERSION}.tar.gz") && \ + printf '%s %s\n' "${SQLITE_SHA256}" /tmp/sqlite.tar.gz > /tmp/sqlite.sha256 && \ + sha256sum -c /tmp/sqlite.sha256 && \ + tar -xzf /tmp/sqlite.tar.gz -C /tmp && \ + cd "/tmp/sqlite-autoconf-${SQLITE_AUTOCONF_VERSION}" && \ + CFLAGS="-O2 \ + -DSQLITE_ENABLE_FTS3 \ + -DSQLITE_ENABLE_FTS3_PARENTHESIS \ + -DSQLITE_ENABLE_FTS4 \ + -DSQLITE_ENABLE_FTS5 \ + -DSQLITE_ENABLE_RTREE \ + -DSQLITE_ENABLE_GEOPOLY \ + -DSQLITE_ENABLE_COLUMN_METADATA \ + -DSQLITE_ENABLE_UNLOCK_NOTIFY \ + -DSQLITE_ENABLE_DBSTAT_VTAB \ + -DSQLITE_ENABLE_DBPAGE_VTAB \ + -DSQLITE_ENABLE_MATH_FUNCTIONS \ + -DSQLITE_ENABLE_PREUPDATE_HOOK \ + -DSQLITE_ENABLE_SESSION \ + -DSQLITE_SECURE_DELETE \ + -DSQLITE_THREADSAFE=1 \ + -DSQLITE_MAX_VARIABLE_NUMBER=250000" \ + ./configure --prefix=/opt/sqlite-fixed --disable-static && \ + make -j"$(nproc)" && \ + make install + FROM ghcr.io/astral-sh/uv:0.11.6-python3.13-trixie@sha256:b3c543b6c4f23a5f2df22866bd7857e5d304b67a564f4feab6ac22044dde719b AS uv_source # Node 22 LTS source stage. Debian trixie's bundled nodejs is pinned to 20.x # which reached EOL in April 2026 — we copy node + npm + corepack from the @@ -31,6 +73,23 @@ RUN apt-get -o Acquire::Retries=3 update && \ ca-certificates curl iputils-ping python3 python-is-python3 ripgrep ffmpeg gcc g++ make cmake python3-dev python3-venv libffi-dev libolm-dev procps git openssh-client docker-cli xz-utils && \ rm -rf /var/lib/apt/lists/* +# Prefer the fixed SQLite over Debian's vulnerable libsqlite3.so.0. Keep the +# public library name stable so both the system interpreter and the uv-created +# venv resolve the replacement without changing Python import paths. +COPY --from=sqlite_build /opt/sqlite-fixed/lib/libsqlite3.so.3.53.4 /usr/local/lib/ +RUN ln -sf libsqlite3.so.3.53.4 /usr/local/lib/libsqlite3.so.0 && \ + ln -sf libsqlite3.so.3.53.4 /usr/local/lib/libsqlite3.so && \ + printf '/usr/local/lib\n' > /etc/ld.so.conf.d/000-sqlite-fixed.conf && \ + ldconfig && \ + python3 -c "import sqlite3, sys; \ +v = sqlite3.sqlite_version_info; \ +sys.exit(f'linked SQLite {sqlite3.sqlite_version} still has the WAL-reset bug') if v < (3, 51, 3) else None; \ +db = sqlite3.connect(':memory:'); \ +db.execute(\"CREATE VIRTUAL TABLE docs USING fts5(content, tokenize='trigram')\"); \ +db.execute(\"INSERT INTO docs VALUES ('hermes')\"); \ +sys.exit('SQLite FTS5 trigram self-test failed') if db.execute(\"SELECT count(*) FROM docs WHERE docs MATCH 'erm'\").fetchone()[0] != 1 else None; \ +db.close()" + # ---------- s6-overlay install ---------- # s6-overlay provides supervision for the main hermes process, the dashboard, # and per-profile gateways. /init becomes PID 1 below — see ENTRYPOINT. diff --git a/agent/agent_init.py b/agent/agent_init.py index 955ca11cff..69d814f47d 100644 --- a/agent/agent_init.py +++ b/agent/agent_init.py @@ -455,7 +455,7 @@ def init_agent( command: str = None, args: list[str] | None = None, model: str = "", - max_iterations: int = 90, # Default tool-calling iterations (shared with subagents) + max_iterations: int = 500, # Default tool-calling iterations (shared with subagents) tool_delay: float = 1.0, enabled_toolsets: List[str] = None, disabled_toolsets: List[str] = None, @@ -529,7 +529,7 @@ def init_agent( requested_provider (str): Original provider identity before runtime canonicalization api_mode (str): API mode override: "chat_completions" or "codex_responses" model (str): Model name to use (default: "anthropic/claude-opus-4.6") - max_iterations (int): Maximum number of tool calling iterations (default: 90) + max_iterations (int): Maximum number of tool calling iterations (default: 500) tool_delay (float): Delay between tool calls in seconds (default: 1.0) enabled_toolsets (List[str]): Only enable tools from these toolsets (optional) disabled_toolsets (List[str]): Disable tools from these toolsets (optional) diff --git a/agent/agent_runtime_helpers.py b/agent/agent_runtime_helpers.py index b70afabfc4..6b111f76f3 100644 --- a/agent/agent_runtime_helpers.py +++ b/agent/agent_runtime_helpers.py @@ -2615,6 +2615,7 @@ def invoke_tool(agent, function_name: str, function_args: dict, effective_task_i _clarify_tool( question=next_args.get("question", ""), choices=next_args.get("choices"), + multi_select=next_args.get("multi_select", False), callback=agent.clarify_callback, ), next_args, diff --git a/agent/anthropic_adapter.py b/agent/anthropic_adapter.py index 7fa3ba391f..e7c02e9db6 100644 --- a/agent/anthropic_adapter.py +++ b/agent/anthropic_adapter.py @@ -2060,6 +2060,28 @@ def _convert_assistant_message(m: Dict[str, Any]) -> Dict[str, Any]: _apply_assistant_cache_control_to_last_cacheable_block( replayed, m.get("cache_control") ) + # apply_anthropic_cache_control marks an assistant turn with + # non-empty text by writing cache_control INTO ``content`` (see + # _apply_cache_marker's list branch), not at the top level. This + # branch rebuilds the message from ordered_blocks and never reads + # ``content``, so that marker would be dropped -- and because + # _can_carry_marker already counted this message as a carrier, the + # breakpoint is burned rather than relocated. #56195 covered the + # complementary shape (blank content -> top-level marker); this is + # the interleaved thinking + preamble-text + tool_use shape. + _inline_cc = None + _msg_content = m.get("content") + if isinstance(_msg_content, list): + for _blk in _msg_content: + if isinstance(_blk, dict) and isinstance( + _blk.get("cache_control"), dict + ): + _inline_cc = _blk["cache_control"] + break + if _inline_cc is not None: + _apply_assistant_cache_control_to_last_cacheable_block( + replayed, _inline_cc + ) return {"role": "assistant", "content": replayed} blocks = _extract_preserved_thinking_blocks(m) diff --git a/agent/billing_view.py b/agent/billing_view.py index a535aee1f1..29e8068c22 100644 --- a/agent/billing_view.py +++ b/agent/billing_view.py @@ -107,6 +107,22 @@ class CardInfo: return f"{self.masked} — {label}" if label else self.masked +@dataclass(frozen=True) +class PaymentMethodInfo: + """The payment method on file. `kind` is "card", "link", or "unknown" + — anything else is normalised to "unknown" at parse time, so consumers + only ever see fields that belong to the kind they are looking at.""" + + kind: str + brand: Optional[str] = None + last4: Optional[str] = None + wallet: Optional[str] = None + email: Optional[str] = None + resolved_via: Optional[str] = None + #: What the server called it, when we did not recognise the kind. + raw_kind: Optional[str] = None + + @dataclass(frozen=True) class MonthlyCap: limit_usd: Optional[Decimal] = None @@ -150,6 +166,7 @@ class BillingState: min_usd: Optional[Decimal] = None max_usd: Optional[Decimal] = None card: Optional[CardInfo] = None + payment_method: Optional[PaymentMethodInfo] = None monthly_cap: Optional[MonthlyCap] = None auto_reload: Optional[AutoReload] = None portal_url: Optional[str] = None @@ -201,6 +218,41 @@ def _parse_card(raw: Any) -> Optional[CardInfo]: return CardInfo(brand=brand, last4=last4, resolved_via=resolved_via) +def _parse_payment_method(raw: Any) -> Optional[PaymentMethodInfo]: + if not isinstance(raw, dict): + return None + kind = raw.get("kind") + if not isinstance(kind, str): + return None + + def _optional_string(key: str) -> Optional[str]: + value = raw.get(key) + return value if isinstance(value, str) else None + + resolved_via = _optional_string("resolvedVia") + brand = _optional_string("brand") + last4 = _optional_string("last4") + # Settle the kind here, the way _parse_card settles a card, so nothing + # downstream has to re-check which fields this kind is allowed to have. + if kind == "card" and brand and last4: + return PaymentMethodInfo( + kind="card", + brand=brand, + last4=last4, + wallet=_optional_string("wallet"), + resolved_via=resolved_via, + ) + if kind == "link": + return PaymentMethodInfo( + kind="link", + email=_optional_string("email"), + resolved_via=resolved_via, + ) + return PaymentMethodInfo( + kind="unknown", raw_kind=kind, resolved_via=resolved_via + ) + + def _parse_monthly_cap(raw: Any) -> Optional[MonthlyCap]: if not isinstance(raw, dict): return None @@ -274,6 +326,7 @@ def billing_state_from_payload( min_usd=parse_money(bounds.get("minUsd")), max_usd=parse_money(bounds.get("maxUsd")), card=_parse_card(payload.get("card")), + payment_method=_parse_payment_method(payload.get("paymentMethod")), monthly_cap=_parse_monthly_cap(payload.get("monthlyCap")), auto_reload=_parse_auto_reload(payload.get("autoReload")), portal_url=portal_url, diff --git a/agent/context_breakdown.py b/agent/context_breakdown.py index 0e2eb772f2..4527c5dca2 100644 --- a/agent/context_breakdown.py +++ b/agent/context_breakdown.py @@ -154,3 +154,207 @@ def compute_session_context_breakdown( "estimated_total": estimated_total, "model": getattr(agent, "model", "") or "", } + + +# ── /context rendering (CLI + gateway) ────────────────────────────────────── +# +# Pure text renderers over the payload above. The CLI shows a glyph block-grid +# plus a category table; the gateway uses the same table without the grid +# (proportional monospace is not guaranteed on messaging platforms). + +_CATEGORY_GLYPHS = { + "system_prompt": "■", + "tool_definitions": "▣", + "rules": "▩", + "skills": "▤", + "mcp": "▥", + "subagent_definitions": "▦", + "memory": "▧", + "conversation": "▨", +} +_FREE_GLYPH = "·" +_GRID_COLUMNS = 20 +_GRID_ROWS = 5 # 100 cells → 1 cell per percent of the context window + +# Human-readable tables cap the expanded listings; nothing is dropped from +# the underlying data. +_DETAILS_TABLE_LIMIT = 15 + + +def _bytes_to_tokens(size: Optional[int]) -> Optional[int]: + if size is None: + return None + return (int(size) + 3) // 4 + + +def compute_context_details(agent: Any) -> Dict[str, Any]: + """Expanded per-skill / per-toolset cost listing for ``/context all``. + + Reuses the ``hermes prompt-size`` attribution mechanism (PR #66656): + per-skill index-line bytes parsed from the live ```` + block, and per-toolset schema bytes attributed via the tool registry's + canonical tool→toolset map. Byte figures are converted to the same + chars/4 token heuristic the categories above use. + """ + from hermes_cli.prompt_size import ( + _compute_skills_breakdown, + _compute_toolsets_breakdown, + ) + from agent.system_prompt import build_system_prompt_parts + + parts = build_system_prompt_parts(agent) + stable = parts.get("stable", "") or "" + skills_match = _SKILLS_BLOCK_RE.search(stable) + skills_block = skills_match.group(0) if skills_match else "" + + skills: List[Dict[str, Any]] = [] + if skills_block: + for entry in _compute_skills_breakdown(skills_block): + skills.append({ + "name": entry.get("name", ""), + "index_tokens": _bytes_to_tokens(entry.get("index_line_bytes")) or 0, + "skill_md_tokens": _bytes_to_tokens(entry.get("skill_md_bytes")), + }) + + toolsets: List[Dict[str, Any]] = [] + tools = list(getattr(agent, "tools", None) or []) + if tools: + for group in _compute_toolsets_breakdown(tools): + toolsets.append({ + "toolset": group.get("toolset", ""), + "tool_count": int(group.get("tool_count", 0) or 0), + "schema_tokens": _bytes_to_tokens(group.get("json_bytes")) or 0, + }) + + return {"skills": skills, "toolsets": toolsets} + + +def render_context_grid(payload: Dict[str, Any]) -> List[str]: + """Render the payload as a Claude Code-style glyph block grid. + + 100 cells (5×20), each one percent of the model context window. Categories + fill in declaration order; the remainder renders as free space. + """ + context_max = int(payload.get("context_max") or 0) + categories = payload.get("categories") or [] + total_cells = _GRID_COLUMNS * _GRID_ROWS + + cells: List[str] = [] + if context_max > 0: + for cat in categories: + tokens = int(cat.get("tokens") or 0) + n = round(tokens / context_max * total_cells) + if tokens > 0 and n == 0: + n = 1 # never render a nonzero category as invisible + glyph = _CATEGORY_GLYPHS.get(str(cat.get("id") or ""), "▪") + cells.extend([glyph] * n) + cells = cells[:total_cells] + cells.extend([_FREE_GLYPH] * (total_cells - len(cells))) + + return [ + " ".join(cells[row * _GRID_COLUMNS:(row + 1) * _GRID_COLUMNS]) + for row in range(_GRID_ROWS) + ] + + +def render_context_category_lines(payload: Dict[str, Any]) -> List[str]: + """Render the 'Estimated usage by category' table as plain-text lines.""" + categories = payload.get("categories") or [] + context_max = int(payload.get("context_max") or 0) + estimated_total = int(payload.get("estimated_total") or 0) + denom = context_max or estimated_total + + lines = ["Estimated usage by category"] + if not categories: + lines.append(" (no data yet — send a message first)") + return lines + + width = max(len(str(cat.get("label") or "")) for cat in categories) + width = max(width, len("Free space")) + for cat in categories: + tokens = int(cat.get("tokens") or 0) + glyph = _CATEGORY_GLYPHS.get(str(cat.get("id") or ""), "▪") + pct = tokens / denom * 100 if denom else 0.0 + label = str(cat.get("label") or cat.get("id") or "") + lines.append(f"{glyph} {label:<{width}} {tokens:>9,} tokens {pct:>5.1f}%") + if context_max > 0: + free = max(0, context_max - estimated_total) + pct = free / context_max * 100 + lines.append(f"{_FREE_GLYPH} {'Free space':<{width}} {free:>9,} tokens {pct:>5.1f}%") + return lines + + +def render_context_details_lines(details: Dict[str, Any]) -> List[str]: + """Render the expanded ``/context all`` per-skill / per-toolset tables.""" + lines: List[str] = [] + + toolsets = details.get("toolsets") or [] + if toolsets: + lines.append("Toolsets by schema cost (largest first)") + for group in toolsets[:_DETAILS_TABLE_LIMIT]: + lines.append( + f" {group['toolset']:<24} {group['tool_count']:>3} tools" + f" {group['schema_tokens']:>8,} tokens" + ) + remaining = len(toolsets) - _DETAILS_TABLE_LIMIT + if remaining > 0: + lines.append(f" … and {remaining} more") + + skills = details.get("skills") or [] + if skills: + if lines: + lines.append("") + lines.append("Skills by cost (index = always-on; SKILL.md = cost when loaded)") + for entry in skills[:_DETAILS_TABLE_LIMIT]: + name = str(entry.get("name") or "") + if len(name) > 28: + name = name[:27] + "…" + md = entry.get("skill_md_tokens") + md_str = f"{md:>8,}" if md is not None else f"{'n/a':>8}" + lines.append( + f" {name:<28} index {entry['index_tokens']:>6,}" + f" SKILL.md {md_str} tokens" + ) + remaining = len(skills) - _DETAILS_TABLE_LIMIT + if remaining > 0: + lines.append(f" … and {remaining} more") + + return lines + + +def render_context_breakdown_lines( + payload: Dict[str, Any], + *, + details: Optional[Dict[str, Any]] = None, + grid: bool = True, +) -> List[str]: + """Render the full /context view as plain-text lines. + + ``grid=True`` (CLI) prepends the glyph block grid; the gateway passes + ``grid=False`` and keeps its own gauge. ``details`` (from + :func:`compute_context_details`) appends the expanded listings. + """ + lines: List[str] = [] + if grid: + lines.extend(render_context_grid(payload)) + lines.append("") + lines.extend(render_context_category_lines(payload)) + + context_max = int(payload.get("context_max") or 0) + context_used = int(payload.get("context_used") or 0) + if context_max > 0: + pct = int(payload.get("context_percent") or 0) + lines.append("") + lines.append( + f"Context window: {context_used:,} / {context_max:,} tokens ({pct}%)" + ) + + if details is not None: + detail_lines = render_context_details_lines(details) + if detail_lines: + lines.append("") + lines.extend(detail_lines) + else: + lines.append("") + lines.append("Use /context all for per-skill and per-toolset costs.") + return lines diff --git a/agent/conversation_loop.py b/agent/conversation_loop.py index fb3d7978b9..7e0475a1ff 100644 --- a/agent/conversation_loop.py +++ b/agent/conversation_loop.py @@ -774,6 +774,41 @@ def _compression_deferred_result( } +def _rewrite_system_content_blocks(system_message: dict, effective: str) -> bool: + """Rewrite a cache-decorated system message in place, keeping its blocks. + + ``apply_anthropic_cache_control`` runs once per call block, *before* the + retry loop, and splits the system prompt into ``[static prefix, volatile + tail]`` text blocks carrying the cache_control breakpoints. Assigning a bare + string over that list drops both breakpoints, so the failover retry ships + the whole system prompt uncached and re-bills it in full. + + ``rewrite_prompt_model_identity`` only touches the LAST ``Model:`` / + ``Provider:`` lines, and those live in the volatile tail — so the static + prefix stays byte-identical and its cache entry keeps matching. Returns + False when the shape is not one we can safely patch, so the caller falls + back to the plain-string assignment. + """ + content = system_message.get("content") + if not isinstance(content, list) or not content: + return False + if not all( + isinstance(part, dict) and part.get("type") == "text" for part in content + ): + return False + if len(content) == 1: + content[0]["text"] = effective + return True + if len(content) == 2: + head = content[0].get("text") or "" + if head and effective.startswith(head): + tail = effective[len(head):] + if tail: + content[1]["text"] = tail + return True + return False + + def _sync_failover_system_message(agent, api_messages, active_system_prompt): """Refresh the in-flight system message after a provider failover. @@ -796,7 +831,8 @@ def _sync_failover_system_message(agent, api_messages, active_system_prompt): effective = sp if agent.ephemeral_system_prompt: effective = (effective + "\n\n" + agent.ephemeral_system_prompt).strip() - api_messages[0]["content"] = effective + if not _rewrite_system_content_blocks(api_messages[0], effective): + api_messages[0]["content"] = effective return sp diff --git a/agent/iteration_budget.py b/agent/iteration_budget.py index 213b97c022..7d50026c17 100644 --- a/agent/iteration_budget.py +++ b/agent/iteration_budget.py @@ -2,7 +2,7 @@ Extracted from ``run_agent.py``. Each ``AIAgent`` instance (parent or subagent) holds an :class:`IterationBudget`; the parent's cap comes from -``max_iterations`` (default 90), each subagent's cap comes from +``max_iterations`` (default 500), each subagent's cap comes from ``delegation.max_iterations`` (default 50). ``run_agent`` re-exports ``IterationBudget`` so existing @@ -18,7 +18,7 @@ class IterationBudget: """Thread-safe iteration counter for an agent. Each agent (parent or subagent) gets its own ``IterationBudget``. - The parent's budget is capped at ``max_iterations`` (default 90). + The parent's budget is capped at ``max_iterations`` (default 500). Each subagent gets an independent budget capped at ``delegation.max_iterations`` (default 50) — this means total iterations across parent + subagents can exceed the parent's cap. diff --git a/agent/tool_executor.py b/agent/tool_executor.py index 1db855573f..4815f80db4 100644 --- a/agent/tool_executor.py +++ b/agent/tool_executor.py @@ -1465,6 +1465,7 @@ def execute_tool_calls_sequential(agent, assistant_message, messages: list, effe return _clarify_tool( question=next_args.get("question", ""), choices=next_args.get("choices"), + multi_select=next_args.get("multi_select", False), callback=agent.clarify_callback, ) function_result, function_args, middleware_trace, _execution_blocked = _managed_values(_run_agent_tool_execution_middleware( diff --git a/agent/turn_summary.py b/agent/turn_summary.py new file mode 100644 index 0000000000..f4440afb50 --- /dev/null +++ b/agent/turn_summary.py @@ -0,0 +1,310 @@ +"""Per-turn accounting for the interactive CLI. + +Two display-only pieces live here: + +* :class:`TurnSummaryCollector` — a tiny observer that rides the existing + ``tool_progress_callback`` feed (``tool.completed`` events already carry + the tool name and its raw result) and tallies what a turn actually did. + It holds **no** agent-loop state: the display layer already sees every + tool call, so nothing new is threaded through the conversation loop. +* :func:`format_turn_summary` — a pure formatter that turns a tally plus a + wall-clock duration into one dim line, e.g.:: + + ⋯ 12.4s · edited 2 files +18 -3 · read 4 files · ran 3 commands + + Ported from Claude Code's post-turn accounting line + ("Edited 1 file +6 -2, read 1 file … Worked for 10s"). + +:func:`format_token_flow` is the spinner-side counterpart: a cumulative +token readout appended to the live elapsed timer (``↓ 1.2k tok``). + +Everything in this module is pure/side-effect free apart from the +collector's own counters, which makes it directly unit-testable without a +terminal, an agent, or a network call. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Any + +__all__ = [ + "TurnSummaryCollector", + "TurnTally", + "format_turn_summary", + "format_token_flow", + "format_elapsed", +] + + +# Leading glyph for the summary line. Deliberately not an emoji — the line is +# meant to read as terminal chrome, not as agent speech. +SUMMARY_PREFIX = "⋯" + +# A turn that called no tools and finished this fast has nothing worth +# reporting (plain chat reply). Below the threshold the formatter returns "". +_MIN_TOOLLESS_SECONDS = 2.0 + +# Max number of "verb + count" segments rendered before collapsing the rest +# into a "+N more" tail, so a 12-tool turn cannot blow past one line. +_MAX_SEGMENTS = 4 + + +# Tool name -> (verb, singular noun, plural noun). +# +# Verbs are past tense because the line is printed *after* the turn. Tools not +# listed here fall into a generic "called N tools" bucket rather than inventing +# phrasing for plugin/MCP tools whose semantics we don't know. +_VERB_GROUPS: dict[str, tuple[str, str, str]] = { + "write_file": ("edited", "file", "files"), + "patch": ("edited", "file", "files"), + "read_file": ("read", "file", "files"), + "web_extract": ("read", "page", "pages"), + "terminal": ("ran", "command", "commands"), + "execute_code": ("ran", "script", "scripts"), + "search_files": ("searched", "path", "paths"), + "web_search": ("searched the web", "time", "times"), + "session_search": ("searched sessions", "time", "times"), + "browser_navigate": ("browsed", "page", "pages"), + "skill_view": ("read", "skill", "skills"), + "skill_manage": ("updated", "skill", "skills"), + "skills_list": ("listed skills", "time", "times"), + "todo": ("updated", "task list", "task lists"), + "delegate_task": ("delegated", "task", "tasks"), + "memory": ("updated", "memory", "memories"), +} + +# Verb groups that carry file-edit line deltas (+X -Y) when known. +_EDIT_VERB = "edited" + +# Render order: edits first (the thing users most want confirmed), then reads, +# then commands. Anything else follows in first-seen order. +_VERB_PRIORITY: tuple[str, ...] = ("edited", "read", "ran") + +# Tools whose results may report a unified diff we can count lines from. +_DIFF_RESULT_TOOLS = frozenset({"patch"}) + + +@dataclass +class TurnTally: + """What a single turn did, as observed from the tool-progress feed.""" + + # verb -> {noun_plural: count}; keeps insertion order for stable rendering. + verbs: dict[str, dict[str, int]] = field(default_factory=dict) + # Tools with no curated verb, counted together. + other_tools: int = 0 + # Aggregated unified-diff line deltas across edit tools, when reported. + lines_added: int = 0 + lines_removed: int = 0 + # True once at least one edit tool reported a countable diff, so the + # formatter knows the difference between "+0 -0" and "unknown". + has_line_deltas: bool = False + + @property + def total_tools(self) -> int: + counted = sum(sum(nouns.values()) for nouns in self.verbs.values()) + return counted + self.other_tools + + +def _count_diff_lines(diff: str) -> tuple[int, int]: + """Count added/removed lines in unified-diff text. + + File headers (``+++``/``---``) are excluded so a one-line edit does not + read as three additions. + """ + added = removed = 0 + for line in diff.splitlines(): + if line.startswith("+++") or line.startswith("---"): + continue + if line.startswith("+"): + added += 1 + elif line.startswith("-"): + removed += 1 + return added, removed + + +def _extract_line_deltas(tool_name: str, result: Any) -> tuple[int, int] | None: + """Pull (added, removed) from a tool result, or None when unavailable. + + Only tools that already report a diff in their result payload are + inspected — we never shell out to git and never re-read files to + synthesise a delta. + """ + if tool_name not in _DIFF_RESULT_TOOLS: + return None + payload: Any = result + if isinstance(payload, str): + text = payload.strip() + if not text.startswith("{"): + return None + try: + import json + + # strict=False tolerates literal control characters inside strings + # (raw newlines in an embedded diff), which some tool serialisers + # emit. A tally line is never worth failing over formatting. + payload = json.loads(text, strict=False) + except Exception: + return None + if not isinstance(payload, dict): + return None + diff = payload.get("diff") + if not isinstance(diff, str) or not diff.strip(): + return None + added, removed = _count_diff_lines(diff) + # A diff that carries no +/- content lines (e.g. a bare hunk header) tells + # us nothing — report it as unknown rather than rendering a misleading + # "+0 -0" next to a real edit. + if added == 0 and removed == 0: + return None + return added, removed + + +class TurnSummaryCollector: + """Accumulate per-turn tool tallies from the tool-progress feed. + + Wired into the CLI's existing ``_on_tool_progress`` handler: the display + layer already receives every ``tool.completed`` event with the tool name + and raw result, so no agent-loop bookkeeping is added. + """ + + def __init__(self) -> None: + self._tally = TurnTally() + + def begin(self) -> None: + """Start a fresh turn (drops any prior tally).""" + self._tally = TurnTally() + + def record_tool( + self, + tool_name: str | None, + *, + result: Any = None, + is_error: bool = False, + ) -> None: + """Record one completed tool call. + + Failed calls are skipped: a summary claiming "edited 2 files" when one + write was denied would be exactly the over-claim the file-mutation + verifier exists to catch. + """ + if not tool_name or is_error: + return + # Internal/pseudo tools (``_thinking``) are not user-visible work. + if tool_name.startswith("_"): + return + + group = _VERB_GROUPS.get(tool_name) + if group is None: + self._tally.other_tools += 1 + return + + verb, _singular, plural = group + nouns = self._tally.verbs.setdefault(verb, {}) + nouns[plural] = nouns.get(plural, 0) + 1 + + if verb == _EDIT_VERB: + deltas = _extract_line_deltas(tool_name, result) + if deltas is not None: + added, removed = deltas + self._tally.lines_added += added + self._tally.lines_removed += removed + self._tally.has_line_deltas = True + + @property + def tally(self) -> TurnTally: + return self._tally + + def render(self, elapsed_seconds: float) -> str: + """Render this turn's summary line (see :func:`format_turn_summary`).""" + return format_turn_summary(elapsed_seconds, self._tally) + + +def format_elapsed(seconds: float) -> str: + """Format a wall-clock duration compactly (``12.4s`` / ``2m05s``).""" + if seconds < 0: + seconds = 0.0 + if seconds < 60: + return f"{seconds:.1f}s" + minutes, rest = divmod(int(round(seconds)), 60) + return f"{minutes}m{rest:02d}s" + + +def _pluralize(count: int, plural_noun: str) -> str: + """Return ``"1 file"`` / ``"3 files"`` from a plural noun form.""" + if count == 1: + singular = plural_noun + if plural_noun.endswith("ies"): + singular = plural_noun[:-3] + "y" + elif plural_noun.endswith("ses"): + singular = plural_noun[:-2] + elif plural_noun.endswith("s"): + singular = plural_noun[:-1] + return f"1 {singular}" + return f"{count} {plural_noun}" + + +def _ordered_verbs(tally: TurnTally) -> list[str]: + """Verbs in render order: priority verbs first, then first-seen order.""" + seen = list(tally.verbs.keys()) + ranked = [v for v in _VERB_PRIORITY if v in tally.verbs] + ranked += [v for v in seen if v not in _VERB_PRIORITY] + return ranked + + +def format_turn_summary( + elapsed_seconds: float, + tally: TurnTally | None, + *, + max_segments: int = _MAX_SEGMENTS, +) -> str: + """Render the per-turn accounting line, or ``""`` when there's nothing to say. + + Pure function — no config lookups, no terminal access, no I/O. Gating + (``display.turn_summary``, quiet mode, CLI-only) is the caller's job. + """ + if tally is None: + tally = TurnTally() + + segments: list[str] = [] + for verb in _ordered_verbs(tally): + nouns = tally.verbs[verb] + parts = [_pluralize(count, plural) for plural, count in nouns.items() if count] + if not parts: + continue + segment = f"{verb} {', '.join(parts)}" + if verb == _EDIT_VERB and tally.has_line_deltas: + segment += f" +{tally.lines_added} -{tally.lines_removed}" + segments.append(segment) + + if tally.other_tools: + segments.append(f"called {_pluralize(tally.other_tools, 'tools')}") + + if not segments and tally.total_tools == 0 and elapsed_seconds < _MIN_TOOLLESS_SECONDS: + return "" + + if max_segments > 0 and len(segments) > max_segments: + hidden = len(segments) - max_segments + segments = segments[:max_segments] + [f"+{hidden} more"] + + pieces = [format_elapsed(elapsed_seconds)] + segments + return f"{SUMMARY_PREFIX} " + " · ".join(pieces) + + +def format_token_flow(output_tokens: Any, *, arrow: str = "↓") -> str: + """Render cumulative turn tokens for the live spinner (``↓ 1.2k tok``). + + Returns ``""`` for a non-positive count so the spinner shows nothing + rather than a misleading ``↓ 0 tok`` before the first API response lands. + """ + try: + count = int(output_tokens) + except (TypeError, ValueError): + return "" + if count <= 0: + return "" + if count < 1000: + return f"{arrow} {count} tok" + if count < 1_000_000: + return f"{arrow} {count / 1000:.1f}k tok" + return f"{arrow} {count / 1_000_000:.1f}M tok" diff --git a/apps/bootstrap-installer/src-tauri/src/bootstrap.rs b/apps/bootstrap-installer/src-tauri/src/bootstrap.rs index 1d70ec59a6..f78b26134e 100644 --- a/apps/bootstrap-installer/src-tauri/src/bootstrap.rs +++ b/apps/bootstrap-installer/src-tauri/src/bootstrap.rs @@ -12,11 +12,11 @@ //! 4. Worker iterates stages, calling `install.ps1 -Stage NAME -NonInteractive -Json`. //! 5. On success → `complete`. On any stage failure → `failed`. On cancel → `failed`. -use std::path::PathBuf; +use std::path::{Path, PathBuf}; use std::sync::Arc; -use std::time::Instant; +use std::time::{Instant, SystemTime, UNIX_EPOCH}; -use anyhow::{anyhow, Result}; +use anyhow::{anyhow, Context, Result}; use serde::{Deserialize, Serialize}; use tauri::{AppHandle, Emitter, State}; use tokio::sync::{mpsc, Mutex}; @@ -260,6 +260,107 @@ pub(crate) fn hermes_is_installed(install_root: &std::path::Path) -> bool { && resolve_hermes_desktop_exe(install_root).is_some() } +fn resolve_marker_commit(install_root: &Path, pin: &Pin) -> Option { + if let Some(commit) = pin + .commit + .as_ref() + .filter(|commit| !commit.trim().is_empty()) + { + return Some(commit.clone()); + } + + let output = std::process::Command::new("git") + .args(["rev-parse", "HEAD"]) + .current_dir(install_root) + .output() + .ok()?; + if !output.status.success() { + return None; + } + + let commit = String::from_utf8_lossy(&output.stdout).trim().to_string(); + if commit.is_empty() { + None + } else { + Some(commit) + } +} + +fn write_bootstrap_complete_marker(install_root: &Path, pin: &Pin) -> Result { + use std::io::Write; + + let marker_path = crate::paths::likely_bootstrap_marker(install_root); + if let Some(parent) = marker_path.parent() { + std::fs::create_dir_all(parent).with_context(|| { + format!( + "could not create bootstrap marker directory {}", + parent.display() + ) + })?; + } + + let completed_at_unix = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|duration| duration.as_secs()) + .unwrap_or_default(); + let marker = serde_json::json!({ + "schemaVersion": 1, + "pinnedCommit": resolve_marker_commit(install_root, pin), + "pinnedBranch": pin.branch.clone(), + "completedAtUnix": completed_at_unix, + }); + let mut body = serde_json::to_vec_pretty(&marker)?; + body.push(b'\n'); + + // Atomic publish (temp sibling + flush + rename), matching Electron's + // writeFileAtomic(). hermes_is_installed() only checks existence, so a + // partial direct write would incorrectly enable the launcher fast path. + let tmp_path = install_root.join(".hermes-bootstrap-complete.tmp"); + { + let mut file = std::fs::File::create(&tmp_path).with_context(|| { + format!( + "could not create temp bootstrap marker {}", + tmp_path.display() + ) + })?; + file.write_all(&body).with_context(|| { + format!( + "could not write temp bootstrap marker {}", + tmp_path.display() + ) + })?; + file.sync_all().with_context(|| { + format!( + "could not flush temp bootstrap marker {}", + tmp_path.display() + ) + })?; + } + // Windows rename fails if the destination already exists; drop any prior + // marker first so a re-run can still publish a fresh payload. + if marker_path.exists() { + std::fs::remove_file(&marker_path).with_context(|| { + format!( + "could not replace existing bootstrap marker {}", + marker_path.display() + ) + })?; + } + if let Err(err) = std::fs::rename(&tmp_path, &marker_path) { + let _ = std::fs::remove_file(&tmp_path); + return Err(err).with_context(|| { + format!( + "could not publish bootstrap marker {} → {}", + tmp_path.display(), + marker_path.display() + ) + }); + } + + tracing::info!(path = %marker_path.display(), "bootstrap marker written"); + Ok(marker) +} + /// Spawn the already-built desktop app, detached. Returns Err if no built app /// exists or the spawn fails, so the caller can fall back to showing the /// installer UI. @@ -644,6 +745,23 @@ async fn run_bootstrap( .unwrap_or_else(|| crate::paths::hermes_home().to_string_lossy().into_owned()); let install_root = PathBuf::from(&hermes_home).join("hermes-agent"); + // Marker publish is terminal for this run: a write failure must emit Failed + // so the UI leaves the progress state (it does not poll get_bootstrap_status). + let marker = match write_bootstrap_complete_marker(&install_root, &pin) { + Ok(marker) => marker, + Err(err) => { + let msg = format!("write bootstrap marker failed: {err:#}"); + emit_event( + &app, + BootstrapEvent::Failed { + stage: None, + error: msg.clone(), + }, + ); + return Err(anyhow!(msg)); + } + }; + // Copy ourselves to HERMES_HOME/hermes-setup.exe so the desktop app can // re-invoke us with `--update` and shortcuts have a stable target. This is // a one-shot install concern; an `--update` re-invocation no-ops because @@ -660,10 +778,7 @@ async fn run_bootstrap( &app, BootstrapEvent::Complete { install_root: install_root.to_string_lossy().into_owned(), - marker: Some(serde_json::json!({ - "pinnedCommit": pin.commit, - "pinnedBranch": pin.branch, - })), + marker: Some(marker), }, ); @@ -903,4 +1018,103 @@ mod tests { ); let _ = std::fs::remove_dir_all(&root); } + + #[test] + fn bootstrap_complete_marker_uses_desktop_compatible_schema() { + let root = unique_tmp_dir("marker-schema"); + let pin = Pin { + commit: Some("abcdef1234567890".to_string()), + branch: Some("main".to_string()), + }; + + let marker = + write_bootstrap_complete_marker(&root, &pin).expect("marker write should succeed"); + let marker_path = root.join(".hermes-bootstrap-complete"); + let from_disk: serde_json::Value = + serde_json::from_slice(&std::fs::read(&marker_path).unwrap()).unwrap(); + + assert_eq!(marker, from_disk); + assert_eq!(from_disk["schemaVersion"], 1); + assert_eq!(from_disk["pinnedCommit"], "abcdef1234567890"); + assert_eq!(from_disk["pinnedBranch"], "main"); + assert!( + from_disk["completedAtUnix"].as_u64().is_some(), + "marker must carry a completion timestamp" + ); + let _ = std::fs::remove_dir_all(&root); + } + + #[test] + fn bootstrap_complete_marker_is_published_atomically() { + let root = unique_tmp_dir("marker-atomic"); + make_release_tree(&root); + let pin = Pin { + commit: Some("abcdef1234567890".to_string()), + branch: Some("main".to_string()), + }; + + write_bootstrap_complete_marker(&root, &pin).expect("marker write should succeed"); + + let marker_path = root.join(".hermes-bootstrap-complete"); + let tmp_path = root.join(".hermes-bootstrap-complete.tmp"); + assert!( + marker_path.is_file(), + "final marker must exist after atomic publish" + ); + assert!( + !tmp_path.exists(), + "temp sibling must not remain after atomic publish" + ); + assert!( + hermes_is_installed(&root), + "atomically published marker must enable the installer fast path" + ); + let _ = std::fs::remove_dir_all(&root); + } + + #[test] + fn hermes_is_installed_treats_marker_existence_as_sufficient() { + // Documents why write_bootstrap_complete_marker must publish atomically: + // the launcher predicate only checks existence, so a partial/corrupt + // final marker would still enable the fast path. + let root = unique_tmp_dir("marker-existence-only"); + make_release_tree(&root); + std::fs::write(root.join(".hermes-bootstrap-complete"), b"").unwrap(); + + assert!( + hermes_is_installed(&root), + "empty/partial marker content still counts as installed" + ); + let _ = std::fs::remove_dir_all(&root); + } + + #[test] + fn marker_write_failure_leaves_no_final_marker() { + // install_root is a regular file → create_dir_all on its path fails + // before any marker bytes are published under the final name. + let base = unique_tmp_dir("marker-fail"); + let not_a_dir = base.join("not-a-dir"); + std::fs::write(¬_a_dir, b"not a directory").unwrap(); + let pin = Pin { + commit: Some("abcdef1234567890".to_string()), + branch: Some("main".to_string()), + }; + + let err = write_bootstrap_complete_marker(¬_a_dir, &pin) + .expect_err("marker write against a non-directory root must fail"); + let msg = format!("{err:#}"); + assert!( + msg.contains("bootstrap marker"), + "error should mention the marker path: {msg}" + ); + assert!( + !not_a_dir.join(".hermes-bootstrap-complete").exists(), + "failed write must not leave a final marker that enables the fast path" + ); + assert!( + !not_a_dir.join(".hermes-bootstrap-complete.tmp").exists(), + "failed write must not leave a temp marker sibling either" + ); + let _ = std::fs::remove_dir_all(&base); + } } diff --git a/apps/bootstrap-installer/src-tauri/src/paths.rs b/apps/bootstrap-installer/src-tauri/src/paths.rs index 7c64c91cf6..0eec8ccd31 100644 --- a/apps/bootstrap-installer/src-tauri/src/paths.rs +++ b/apps/bootstrap-installer/src-tauri/src/paths.rs @@ -149,8 +149,8 @@ fn repair_macos_installer_helper(path: &Path) { #[cfg(not(target_os = "macos"))] fn repair_macos_installer_helper(_path: &Path) {} -/// Where install.ps1 writes the bootstrap-complete marker (existence-only file -/// the Electron app also checks). Per main.ts: +/// Where the bootstrap-complete marker lives (existence-only for the Rust +/// installer fast path; JSON schema-checked by the Electron app). Per main.ts: /// const BOOTSTRAP_COMPLETE_MARKER = path.join(ACTIVE_HERMES_ROOT, '.hermes-bootstrap-complete') /// We don't always know ACTIVE_HERMES_ROOT until install.ps1 reports it, so /// this is a probe helper, not a definitive path. diff --git a/apps/desktop/electron/active-runtime-state.test.ts b/apps/desktop/electron/active-runtime-state.test.ts new file mode 100644 index 0000000000..afc3e74b9d --- /dev/null +++ b/apps/desktop/electron/active-runtime-state.test.ts @@ -0,0 +1,60 @@ +import assert from 'node:assert/strict' + +import { test } from 'vitest' + +import { classifyActiveRuntime, hasValidBootstrapMarker } from './active-runtime-state' + +const VALID_MARKER = { + pinnedCommit: '1234567890abcdef1234567890abcdef12345678', + schemaVersion: 1 +} + +test('hasValidBootstrapMarker accepts the current schema with a real-looking commit', () => { + assert.equal(hasValidBootstrapMarker(VALID_MARKER, 1), true) +}) + +test('hasValidBootstrapMarker rejects missing, wrong-schema, and too-short markers', () => { + assert.equal(hasValidBootstrapMarker(null, 1), false) + assert.equal(hasValidBootstrapMarker({ schemaVersion: 2, pinnedCommit: VALID_MARKER.pinnedCommit }, 1), false) + assert.equal(hasValidBootstrapMarker({ schemaVersion: 1, pinnedCommit: 'abc123' }, 1), false) +}) + +test('classifyActiveRuntime uses a healthy active runtime even when the bootstrap marker is missing', () => { + assert.deepEqual(classifyActiveRuntime(null, 1, true), { + hasValidMarker: false, + shouldUseActiveRuntime: true, + usabilityReason: 'usable' + }) +}) + +test('classifyActiveRuntime uses a healthy active runtime even when the marker is stale or malformed', () => { + assert.deepEqual(classifyActiveRuntime({ schemaVersion: 999, pinnedCommit: 'abc1234' }, 1, true), { + hasValidMarker: false, + shouldUseActiveRuntime: true, + usabilityReason: 'usable' + }) +}) + +test('classifyActiveRuntime refuses an unusable runtime even if a valid marker exists', () => { + assert.deepEqual(classifyActiveRuntime(VALID_MARKER, 1, false), { + hasValidMarker: true, + shouldUseActiveRuntime: false, + usabilityReason: 'unusable' + }) +}) + +test('a CLI-installed runtime with no marker launches instead of re-running bootstrap', () => { + // The reported symptom (#60721): install.sh / install.ps1 produced a healthy + // repo+venv, no desktop-managed marker was ever written, and every launch + // dropped the user back into the first-run installer. + const state = classifyActiveRuntime(null, 1, true) + + assert.equal(state.shouldUseActiveRuntime, true, 'a usable runtime must launch') + assert.equal(state.hasValidMarker, false, 'marker provenance stays honest') +}) + +test('a repair that deleted the marker does not strand a healthy install', () => { + // #72166: the repair handler clears the marker unconditionally. Runtime + // usability, not marker presence, must decide the next boot. + assert.equal(classifyActiveRuntime(null, 1, true).shouldUseActiveRuntime, true) +}) diff --git a/apps/desktop/electron/active-runtime-state.ts b/apps/desktop/electron/active-runtime-state.ts new file mode 100644 index 0000000000..6d922a4627 --- /dev/null +++ b/apps/desktop/electron/active-runtime-state.ts @@ -0,0 +1,58 @@ +export interface BootstrapMarkerLike { + pinnedCommit?: unknown + schemaVersion?: unknown +} + +export interface ActiveRuntimeState { + hasValidMarker: boolean + shouldUseActiveRuntime: boolean + usabilityReason: 'usable' | 'unusable' +} + +export function hasValidBootstrapMarker( + marker: BootstrapMarkerLike | null | undefined, + schemaVersion: number +): boolean { + if (!marker || typeof marker !== 'object') { + return false + } + + if (marker.schemaVersion !== schemaVersion) { + return false + } + + if (typeof marker.pinnedCommit !== 'string' || marker.pinnedCommit.length < 7) { + return false + } + + return true +} + +// The active install at ~/.hermes/hermes-agent can be real and runnable even if +// Desktop never wrote its first-run bootstrap marker (for example when Hermes +// was installed by the CLI first, or when a past desktop build forgot the +// marker). Runtime usability is authoritative for "can we launch local Hermes +// right now?"; the marker is only provenance about how that install was +// created. A missing/stale marker must never force a healthy local install into +// the first-run bootstrap UI. +export function classifyActiveRuntime( + marker: BootstrapMarkerLike | null | undefined, + schemaVersion: number, + runtimeUsable: boolean +): ActiveRuntimeState { + const hasValidMarker = hasValidBootstrapMarker(marker, schemaVersion) + + if (!runtimeUsable) { + return { + hasValidMarker, + shouldUseActiveRuntime: false, + usabilityReason: 'unusable' + } + } + + return { + hasValidMarker, + shouldUseActiveRuntime: true, + usabilityReason: 'usable' + } +} diff --git a/apps/desktop/electron/find-in-page.test.ts b/apps/desktop/electron/find-in-page.test.ts new file mode 100644 index 0000000000..e902bb4296 --- /dev/null +++ b/apps/desktop/electron/find-in-page.test.ts @@ -0,0 +1,222 @@ +/** + * Unit tests for the pure find-in-page helpers. The IPC handlers in + * main.ts are the only consumer — the helpers below must keep the wire + * shape stable (match counter shape, defaults, no-throw-on-destroyed). + */ + +import assert from 'node:assert/strict' +import { EventEmitter } from 'node:events' + +import { describe, test } from 'vitest' + +import { formatFoundInPage, installFoundInPageForwarder, performFind, stopFind } from './find-in-page' + +// Minimal webContents stub. The Electron.WebContents type is huge, so we +// model just the slice the helpers touch (`isDestroyed`, `findInPage`, +// `stopFindInPage`, `on`/`off`, `send`, `destroyed`, `emit`) and cast through +// `asWC()` at call sites. +interface FakeWebContents { + calls: { + find: Array<{ query: string; options: { forward: boolean; findNext: boolean } }> + stop: Array<'clearSelection' | 'keepSelection' | 'activateSelection'> + send: Array<{ channel: string; payload: unknown }> + } + isDestroyed: () => boolean + destroy: () => void + findInPage: (query: string, options: { forward: boolean; findNext: boolean }) => void + stopFindInPage: (action: 'clearSelection' | 'keepSelection' | 'activateSelection') => void + send: (channel: string, payload: unknown) => void + on: typeof EventEmitter.prototype.on + off: typeof EventEmitter.prototype.off + emit: (event: string | symbol, ...args: unknown[]) => boolean +} + +function makeFakeWebContents(): FakeWebContents { + const emitter = new EventEmitter() + + const calls = { + find: [] as Array<{ query: string; options: { forward: boolean; findNext: boolean } }>, + stop: [] as Array<'clearSelection' | 'keepSelection' | 'activateSelection'>, + send: [] as Array<{ channel: string; payload: unknown }> + } + + let destroyed = false + + return { + calls, + isDestroyed: () => destroyed, + destroy() { + destroyed = true + emitter.emit('destroyed') + }, + findInPage(query: string, options: { forward: boolean; findNext: boolean }) { + calls.find.push({ query, options }) + }, + stopFindInPage(action: 'clearSelection' | 'keepSelection' | 'activateSelection') { + calls.stop.push(action) + }, + send(channel: string, payload: unknown) { + calls.send.push({ channel, payload }) + }, + on: emitter.on.bind(emitter), + off: emitter.off.bind(emitter), + emit: emitter.emit.bind(emitter) + } +} + +function asWC(fake: FakeWebContents): Electron.WebContents { + return fake as unknown as Electron.WebContents +} + +describe('formatFoundInPage', () => { + test('maps activeMatchOrdinal + matches onto the wire payload', () => { + assert.deepEqual(formatFoundInPage({ activeMatchOrdinal: 3, matches: 12 }), { + activeMatchOrdinal: 3, + count: 12 + }) + }) + + test('coerces missing fields to zero so the renderer never sees NaN', () => { + assert.deepEqual(formatFoundInPage({}), { activeMatchOrdinal: 0, count: 0 }) + assert.deepEqual(formatFoundInPage({ activeMatchOrdinal: 0, matches: 0 }), { + activeMatchOrdinal: 0, + count: 0 + }) + }) + + test('null / undefined inputs still produce a well-formed payload', () => { + assert.deepEqual(formatFoundInPage(null as unknown as { activeMatchOrdinal?: number; matches?: number }), { + activeMatchOrdinal: 0, + count: 0 + }) + assert.deepEqual(formatFoundInPage(undefined), { activeMatchOrdinal: 0, count: 0 }) + }) +}) + +describe('performFind', () => { + test('forwards the query and options to webContents.findInPage', () => { + const wc = makeFakeWebContents() + performFind(asWC(wc), 'hello', { forward: true, findNext: false }) + assert.deepEqual(wc.calls.find, [{ query: 'hello', options: { forward: true, findNext: false } }]) + }) + + test('defaults forward to true when omitted', () => { + const wc = makeFakeWebContents() + performFind(asWC(wc), 'x', { findNext: true }) + assert.deepEqual(wc.calls.find, [{ query: 'x', options: { forward: true, findNext: true } }]) + }) + + test('defaults findNext to false when omitted', () => { + const wc = makeFakeWebContents() + performFind(asWC(wc), 'x', { forward: false }) + assert.deepEqual(wc.calls.find, [{ query: 'x', options: { forward: false, findNext: false } }]) + }) + + test('treats null / non-object options as "all defaults"', () => { + const wc = makeFakeWebContents() + performFind(asWC(wc), 'x', null) + assert.deepEqual(wc.calls.find, [{ query: 'x', options: { forward: true, findNext: false } }]) + }) + + test('coerces a non-string query to string (defensive against bad renderer payloads)', () => { + const wc = makeFakeWebContents() + performFind(asWC(wc), 42 as unknown as string, null) + assert.equal(wc.calls.find[0].query, '42') + }) + + test('is a no-op when webContents is null', () => { + assert.doesNotThrow(() => performFind(null, 'q', null)) + }) + + test('is a no-op when webContents is destroyed (does not throw across IPC)', () => { + const wc = makeFakeWebContents() + wc.destroy() + performFind(asWC(wc), 'q', null) + assert.equal(wc.calls.find.length, 0) + }) +}) + +describe('stopFind', () => { + test('calls stopFindInPage with the default action (clearSelection)', () => { + const wc = makeFakeWebContents() + stopFind(asWC(wc)) + assert.deepEqual(wc.calls.stop, ['clearSelection']) + }) + + test('honors an explicit action argument', () => { + const wc = makeFakeWebContents() + stopFind(asWC(wc), 'keepSelection') + assert.deepEqual(wc.calls.stop, ['keepSelection']) + }) + + test('is a no-op when webContents is null or destroyed', () => { + assert.doesNotThrow(() => stopFind(null)) + const wc = makeFakeWebContents() + wc.destroy() + stopFind(asWC(wc)) + assert.equal(wc.calls.stop.length, 0) + }) +}) + +describe('installFoundInPageForwarder', () => { + test('forwards found-in-page to the sender as a formatted payload', () => { + const wc = makeFakeWebContents() + installFoundInPageForwarder(asWC(wc)) + // Drive the fake's emit directly — this exercises the same code path + // as Electron's actual `webContents.emit('found-in-page', …)`. + wc.emit('found-in-page', {}, { activeMatchOrdinal: 2, matches: 5 }) + assert.deepEqual(wc.calls.send, [{ channel: 'hermes:found-in-page', payload: { activeMatchOrdinal: 2, count: 5 } }]) + }) + + test('handles missing fields without throwing', () => { + const wc = makeFakeWebContents() + installFoundInPageForwarder(asWC(wc)) + wc.emit('found-in-page', {}, {}) + assert.deepEqual(wc.calls.send, [{ channel: 'hermes:found-in-page', payload: { activeMatchOrdinal: 0, count: 0 } }]) + }) + + test('skips send when webContents is destroyed at fire time', () => { + const wc = makeFakeWebContents() + installFoundInPageForwarder(asWC(wc)) + wc.destroy() + wc.emit('found-in-page', {}, { activeMatchOrdinal: 1, matches: 1 }) + assert.equal(wc.calls.send.length, 0, 'destroyed webContents must not be sent to') + }) + + test('returned uninstall removes the listener', () => { + const wc = makeFakeWebContents() + const uninstall = installFoundInPageForwarder(asWC(wc)) + uninstall() + wc.emit('found-in-page', {}, { activeMatchOrdinal: 9, matches: 9 }) + assert.equal(wc.calls.send.length, 0, 'uninstalled listener must not fire') + }) + + test('returned uninstall on a null webContents is a safe no-op', () => { + const uninstall = installFoundInPageForwarder(null) + assert.doesNotThrow(() => uninstall()) + }) + + test('returned uninstall on a destroyed webContents is a safe no-op', () => { + const wc = makeFakeWebContents() + wc.destroy() + const uninstall = installFoundInPageForwarder(asWC(wc)) + assert.doesNotThrow(() => uninstall()) + }) + + // Regression: the original PR scoped the forwarder to the global mainWindow, + // so Cmd+F pressed in a secondary session window routed results back to the + // primary. Pin that the helper does NOT close over any window other than the + // webContents it was given — two forwarders installed on two distinct fakes + // must each send only to their own sender. + test('two forwarders installed on distinct webContents do not cross-fire', () => { + const wcA = makeFakeWebContents() + const wcB = makeFakeWebContents() + installFoundInPageForwarder(asWC(wcA)) + installFoundInPageForwarder(asWC(wcB)) + wcA.emit('found-in-page', {}, { activeMatchOrdinal: 1, matches: 1 }) + assert.deepEqual(wcA.calls.send, [ + { channel: 'hermes:found-in-page', payload: { activeMatchOrdinal: 1, count: 1 } } + ]) + assert.equal(wcB.calls.send.length, 0, 'wcB must not receive wcA results') + }) +}) diff --git a/apps/desktop/electron/find-in-page.ts b/apps/desktop/electron/find-in-page.ts new file mode 100644 index 0000000000..509fc5dccd --- /dev/null +++ b/apps/desktop/electron/find-in-page.ts @@ -0,0 +1,120 @@ +/** + * Pure helpers for the desktop find-in-page bridge (Ctrl/Cmd+F). + * + * The renderer drives an Electron `webContents.findInPage` over IPC so it can + * reuse the native "find-in-page" experience (incremental search, match + * highlight, Enter to step, Shift+Enter to step backwards, Escape to clear) + * across chat transcripts and editor panels. Everything in this module is + * pure with respect to its inputs so the routing + payload shaping can be + * unit-tested without booting a BrowserWindow. + * + * Multi-window correctness: the IPC handlers in main.ts resolve the + * requesting window via `BrowserWindow.fromWebContents(event.sender)` so a + * Cmd+F pressed in a secondary session window searches THAT window, not the + * primary. The `found-in-page` results are forwarded back to the same sender + * — see {@link installFoundInPageForwarder}. + */ + +/** Match options accepted by the renderer's `findInPage` bridge call. */ +export interface FindInPageOptions { + /** Step direction. Defaults to `true` (forward). */ + forward?: boolean + /** + * `true` to advance to the next/previous match using the previous query; + * `false` to (re)search the current `query` from scratch. The renderer + * passes `false` on a fresh query and `true` on Enter / Shift+Enter. + */ + findNext?: boolean +} + +/** Payload shape sent back to the renderer on every `found-in-page` event. */ +export interface FoundInPagePayload { + /** 1-indexed ordinal of the active match, or 0 when none. */ + activeMatchOrdinal: number + /** Total matches in the document for the current query. */ + count: number +} + +/** + * Defensive projection of Electron's `found-in-page` event result. Electron + * exposes more fields (finalUpdate, selectionArea, etc.) that we don't need; + * keeping the projection explicit makes the wire shape auditable and keeps + * tests independent of the runtime type. + */ +export function formatFoundInPage(result: { activeMatchOrdinal?: number; matches?: number }): FoundInPagePayload { + return { + activeMatchOrdinal: Number(result?.activeMatchOrdinal ?? 0), + count: Number(result?.matches ?? 0) + } +} + +/** + * Issue a `findInPage` against the given `webContents`. No-op when the + * webContents is missing or destroyed — surfaces as a silent miss rather + * than throwing across the IPC boundary, matching Electron's own semantics + * for a destroyed renderer. + */ +export function performFind( + webContents: Electron.WebContents | null | undefined, + query: string, + options: FindInPageOptions | null | undefined +): void { + if (!webContents || webContents.isDestroyed()) { + return + } + + const opts = options && typeof options === 'object' ? options : {} + + webContents.findInPage(String(query ?? ''), { + forward: opts.forward !== false, + findNext: Boolean(opts.findNext) + }) +} + +/** + * Stop the current find and clear highlights. The default `action` matches + * what the renderer sends on Escape / close. + */ +export function stopFind( + webContents: Electron.WebContents | null | undefined, + action: 'clearSelection' | 'keepSelection' | 'activateSelection' = 'clearSelection' +): void { + if (!webContents || webContents.isDestroyed()) { + return + } + + webContents.stopFindInPage(action) +} + +/** + * Install a `found-in-page` listener on the given sender `webContents` and + * forward each result back to the SAME renderer (via `webContents.send`). + * + * Returns an uninstall function. Call it from `webContents.on('destroyed', …)` + * to avoid leaking the listener when the window goes away — Electron does + * not auto-detach webContents listeners on close. + * + * The forwarder is intentionally bound to a single sender rather than the + * primary window: a Cmd+F pressed in a secondary session window must + * highlight matches in THAT window, and the match counter must reflect + * THAT window's DOM, not the primary's. + */ +export function installFoundInPageForwarder(webContents: Electron.WebContents | null | undefined): () => void { + if (!webContents || webContents.isDestroyed()) { + return () => {} + } + + const handler = (_event: Electron.Event, result: Parameters[0]) => { + if (webContents.isDestroyed()) { + return + } + + webContents.send('hermes:found-in-page', formatFoundInPage(result)) + } + + webContents.on('found-in-page', handler) + + return () => { + webContents.off('found-in-page', handler) + } +} diff --git a/apps/desktop/electron/main.ts b/apps/desktop/electron/main.ts index f967aa24c3..5f6ba957ff 100644 --- a/apps/desktop/electron/main.ts +++ b/apps/desktop/electron/main.ts @@ -14,6 +14,7 @@ import { clipboard, dialog, net as electronNet, + globalShortcut, ipcMain, Menu, nativeImage, @@ -30,6 +31,7 @@ import { } from 'electron' import nodePty from 'node-pty' +import { classifyActiveRuntime } from './active-runtime-state' import { stopBackendChild as stopBackendChildImpl } from './backend-child' import { dashboardFallbackArgs, sourceDeclaresServe } from './backend-command' import { createBackendConnectionState } from './backend-connection-state' @@ -80,6 +82,7 @@ import { import { installEmbedReferer } from './embed-referer' import { createEventDeduper } from './event-dedupe' import { findGitBash as _findGitBash } from './find-git-bash' +import { installFoundInPageForwarder, performFind, stopFind } from './find-in-page' import { createFirstRunSetupGate } from './first-run-setup-gate' import { readDirForIpc } from './fs-read-dir' import { probeGatewayWebSocket } from './gateway-ws-probe' @@ -139,6 +142,7 @@ import { createKeepAwake } from './power-save' import { FirstRunSetupResetError, runPrimaryBackendStartup } from './primary-backend-startup' import { rehomePrimaryConnection } from './primary-connection-rehome' import { decideProfileDeleteAction, profileNameFromDeleteRequest, resolveRouteProfile } from './profile-delete-routing' +import { createQuickEntryShortcut, quickEntryWindowBounds, sanitizeQuickEntrySettings } from './quick-entry' import * as remoteLifecycle from './remote-lifecycle' import { RemoteLivenessTracker, RemoteRevalidationCoordinator, revalidateRemoteConnection } from './remote-liveness' import { @@ -373,9 +377,9 @@ if (IS_WINDOWS) { ipcMain.handle('hermes:get-remote-display-reason', () => REMOTE_DISPLAY_REASON) // Keep the renderer running at full speed while the window is in the background -// or occluded. The chat transcript streams to screen through a -// requestAnimationFrame-gated flush; Chromium pauses rAF (and clamps timers) -// for backgrounded/occluded renderers, so without these the live answer stalls +// or occluded. The chat transcript streams to screen through a bounded timer +// flush; Chromium clamps timers for backgrounded/occluded renderers, so without +// these the live answer stalls // whenever the window loses focus (switching to your editor mid-turn, detached // devtools, another window covering it) and only paints on refocus or refresh. // `backgroundThrottling: false` on the BrowserWindow covers the blurred case; @@ -1032,6 +1036,12 @@ let remoteReauthFailure = null // Active first-launch install, so the renderer's Cancel button (and app quit) // can abort the in-flight install.sh/ps1 instead of leaving it running. let bootstrapAbortController = null +// Explicit "the user asked for a repair" flag. Repair used to signal intent by +// deleting the bootstrap marker, which stranded healthy installs whose only +// problem was a transient backend error (#72166). Intent now lives here, so +// repair can force the installer without destroying provenance about how the +// install was created. Cleared once the reinstall is under way. +let bootstrapRepairRequested = false let connectionConfigCache = null let connectionConfigCacheMtime = null const hermesLog = [] @@ -3383,11 +3393,11 @@ function readJson(filePath) { } } -// Bootstrap-complete marker helpers. The marker is written ONCE by the -// first-launch bootstrap runner (Phase 1D) after install.ps1 stages succeed -// AND the user has finished initial configuration. On every subsequent boot -// we check `isBootstrapComplete()` and skip the bootstrap flow entirely if -// the marker is present and current-schema. +// Bootstrap-complete marker helpers. The marker is written by whichever +// installer ran: install.ps1, install.sh, the Rust bootstrap installer, or the +// first-launch bootstrap runner. It is provenance ("a bootstrap finished +// here"), NOT the launch gate -- activeRuntimeState() decides that, because a +// healthy runtime can predate the marker or outlive a repair that cleared it. // // Marker schema (version 1): // { @@ -3420,29 +3430,13 @@ function isActiveRuntimeUsable() { ) } -function isBootstrapComplete() { - const marker = readBootstrapMarker() - - if (!marker || typeof marker !== 'object') { - return false - } - - if (marker.schemaVersion !== BOOTSTRAP_MARKER_SCHEMA_VERSION) { - return false - } - - if (typeof marker.pinnedCommit !== 'string' || marker.pinnedCommit.length < 7) { - return false - } - +function activeRuntimeState() { // We DELIBERATELY do NOT verify that the checkout is currently at the // pinned commit -- users update via the in-app update path or `hermes - // update`, which moves HEAD legitimately. The marker just attests "we - // ran the bootstrap successfully at least once." We DO additionally require - // a runnable venv: an interrupted or split-home install can leave the marker - // + checkout without a venv, and trusting that spawns a dead backend - // ("gateway offline") instead of re-running bootstrap to repair it. - return isActiveRuntimeUsable() + // update`, which moves HEAD legitimately. The marker only attests "a + // desktop-managed bootstrap ran here at least once"; runtime usability is + // what decides whether we can actually launch. + return classifyActiveRuntime(readBootstrapMarker(), BOOTSTRAP_MARKER_SCHEMA_VERSION, isActiveRuntimeUsable()) } function writeBootstrapMarker(payload) { @@ -3702,16 +3696,30 @@ function resolveHermesBackend(backendArgs) { } } - // 3. Bootstrap-complete ACTIVE_HERMES_ROOT -- the canonical install at - // %LOCALAPPDATA%\hermes\hermes-agent (Windows) or ~/.hermes/hermes-agent. - // The bootstrap marker means install.ps1 stages finished and the user - // completed initial configuration; we trust the install and go straight - // to spawning hermes. Updates flow through the in-app update path - // (applyUpdates -> git pull) or `hermes update` from the CLI. - if (isBootstrapComplete()) { + // 3. ACTIVE_HERMES_ROOT — the canonical install at + // %LOCALAPPDATA%\\hermes\\hermes-agent (Windows) or ~/.hermes/hermes-agent. + // A valid bootstrap marker proves Desktop finished the first-run install + // flow, but marker provenance is NOT the same thing as runtime usability: + // the CLI can create the exact same repo+venv layout, and older desktop + // builds could leave a healthy install behind without the marker. If the + // active runtime is usable, launch it directly; only fall through to + // bootstrap when the runtime itself is unusable. + const activeRuntime = activeRuntimeState() + + if (activeRuntime.shouldUseActiveRuntime && !bootstrapRepairRequested) { + if (!activeRuntime.hasValidMarker) { + rememberLog( + `[bootstrap] Active Hermes runtime at ${ACTIVE_HERMES_ROOT} is usable but the bootstrap marker is missing or stale; skipping first-run bootstrap.` + ) + } + return createActiveBackend(backendArgs) } + if (bootstrapRepairRequested) { + rememberLog('[bootstrap] repair requested; bypassing the usable active runtime to re-run the installer') + } + // 4. Existing `hermes` on PATH -- installed via install.ps1 / install.sh from // a previous tool-only setup, or pip-installed system-wide. Use it but // do NOT write a bootstrap marker; the user did this themselves and we @@ -3885,6 +3893,10 @@ async function ensureRuntime(backend) { bootstrapAbortController = new AbortController() + // The repair request has been honoured by reaching the installer; clear it + // so a later boot isn't forced through bootstrap again. + bootstrapRepairRequested = false + const bootstrapResult = await runBootstrap({ installStamp: backend.installStamp, activeRoot: backend.activeRoot, @@ -3979,10 +3991,10 @@ async function ensureRuntime(backend) { // No venv at the expected location AND no bootstrap-needed sentinel // means we have a half-installed checkout: .git exists, source files // exist, but venv is missing or broken. This shouldn't happen in - // normal flow because isBootstrapComplete() requires - // isHermesSourceRoot() and the bootstrap writes the marker only after - // install.ps1 succeeds. If we hit this, the user (or a deleted venv) - // broke the invariant; tell them to re-run the install. + // normal flow because activeRuntimeState() requires isHermesSourceRoot() + // plus an importable hermes_cli before it hands back the active runtime. + // If we hit this, the user (or a deleted venv) broke the invariant; tell + // them to re-run the install. throw new Error( `Hermes venv missing at ${VENV_ROOT}. Re-run the desktop installer or ` + '`scripts/install.ps1` to rebuild it.' ) @@ -4927,6 +4939,8 @@ function getNativeOverlayWidth() { function getWindowState(win = mainWindow) { return { isFullscreen: Boolean(win?.isFullScreen?.()), + isMinimized: Boolean(win?.isMinimized?.()), + isVisible: Boolean(win?.isVisible?.()), nativeOverlayWidth: getNativeOverlayWidth(), windowButtonPosition: getWindowButtonPosition() } @@ -8655,6 +8669,211 @@ function closePetOverlay() { petOverlayWindow = null } +// ── Quick Entry ───────────────────────────────────────────────────────────── +// +// A global shortcut summons a small frameless always-on-top composer from +// anywhere, so a prompt can be fired without raising the whole app. The window +// carries NO gateway connection: it hands its text to us, we forward it to the +// PRIMARY renderer, and that renderer submits through the same prompt path the +// normal composer uses (see store/quick-entry + hooks/use-quick-entry-bridge). +// +// Main owns the OS registration and the persisted preference (it must restore +// the shortcut on a cold launch without the renderer ever visiting Settings), +// same authority split as keep-awake. Registration failure is surfaced, never +// swallowed: a chord another app already owns comes back as `error: 'taken'`. +const QUICK_ENTRY_CONFIG_PATH = path.join(app.getPath('userData'), 'quick-entry.json') + +let quickEntryWindow = null + +// Latest state push from the primary renderer (connection + recent sessions), +// replayed to a quick window that spawns after the push happened. +let quickEntryLastState = null + +function readQuickEntrySettings() { + try { + return sanitizeQuickEntrySettings(JSON.parse(fs.readFileSync(QUICK_ENTRY_CONFIG_PATH, 'utf8'))) + } catch { + // Missing / unreadable / malformed → shipped defaults (enabled, default chord). + return sanitizeQuickEntrySettings(undefined) + } +} + +function writeQuickEntrySettings(settings) { + try { + fs.mkdirSync(path.dirname(QUICK_ENTRY_CONFIG_PATH), { recursive: true }) + fs.writeFileSync(QUICK_ENTRY_CONFIG_PATH, JSON.stringify(settings, null, 2), 'utf8') + } catch (error) { + rememberLog(`[quick-entry] write failed: ${error.message}`) + } +} + +function quickEntryUrl() { + if (DEV_SERVER) { + return `${DEV_SERVER.endsWith('/') ? DEV_SERVER.slice(0, -1) : DEV_SERVER}/?win=quick#/` + } + + return `${pathToFileURL(resolveRendererIndex()).toString()}?win=quick#/` +} + +function spawnQuickEntryWindow() { + const cursor = screen.getCursorScreenPoint() + const display = screen.getDisplayNearestPoint(cursor) + const bounds = quickEntryWindowBounds(display?.workArea) + + const win = new BrowserWindow({ + ...bounds, + frame: false, + transparent: true, + resizable: false, + movable: true, + minimizable: false, + maximizable: false, + fullscreenable: false, + // Same rationale as the pet overlay: on Windows/Linux keep the helper out + // of the taskbar/alt-tab list; on macOS use an NSPanel so the frameless + // capture window never becomes the app's cmd-tab anchor. + skipTaskbar: !IS_MAC, + hasShadow: true, + alwaysOnTop: true, + type: IS_MAC ? 'panel' : undefined, + hiddenInMissionControl: IS_MAC, + show: false, + backgroundColor: '#00000000', + webPreferences: { + preload: PRELOAD_PATH, + contextIsolation: true, + sandbox: true, + nodeIntegration: false, + devTools: true + } + }) + + win.setAlwaysOnTop(true, IS_MAC ? 'floating' : 'screen-saver') + win.setHiddenInMissionControl?.(true) + + try { + win.setVisibleOnAllWorkspaces( + true, + IS_MAC ? { visibleOnFullScreen: true, skipTransformProcessType: true } : undefined + ) + } catch { + // Not supported everywhere — best effort. + } + + // Opts out of global UI zoom for the same reason as the pet overlay: it sizes + // its own OS window and a zoomed composer would overflow it. + wireCommonWindowHandlers(win, zoomWiringForWindowKind('quickEntry')) + + // Hide on blur. The window must never hold the user's focus captive — losing + // focus is the cheapest, least surprising dismiss (matches Spotlight). + win.on('blur', () => { + if (!win.isDestroyed()) { + win.hide() + } + }) + + win.on('closed', () => { + if (quickEntryWindow === win) { + quickEntryWindow = null + } + }) + + // Replay the last known gateway state as soon as the page can hear it — a + // freshly spawned quick window must not sit "disconnected" when the primary + // renderer already reported a live gateway. + win.webContents.on('did-finish-load', () => { + if (!win.isDestroyed() && quickEntryLastState) { + win.webContents.send('hermes:quick-entry:state', quickEntryLastState) + } + }) + + win.loadURL(quickEntryUrl()) + + return win +} + +// Move the (already-open) window to the display the cursor is on, so the chord +// summons it where the user is looking rather than where they last were. +function repositionQuickEntryWindow(win) { + try { + const display = screen.getDisplayNearestPoint(screen.getCursorScreenPoint()) + win.setBounds(quickEntryWindowBounds(display?.workArea)) + } catch (error) { + rememberLog(`[quick-entry] reposition failed: ${error.message}`) + } +} + +function showQuickEntryWindow() { + if (!quickEntryWindow || quickEntryWindow.isDestroyed()) { + quickEntryWindow = spawnQuickEntryWindow() + quickEntryWindow.once('ready-to-show', () => { + if (!quickEntryWindow?.isDestroyed()) { + quickEntryWindow.show() + quickEntryWindow.focus() + } + }) + + return + } + + repositionQuickEntryWindow(quickEntryWindow) + quickEntryWindow.show() + quickEntryWindow.focus() + // Re-summoned: tell the renderer to clear any stale draft and refocus. + quickEntryWindow.webContents.send('hermes:quick-entry:shown') +} + +function hideQuickEntryWindow() { + if (quickEntryWindow && !quickEntryWindow.isDestroyed()) { + quickEntryWindow.hide() + } +} + +// The chord toggles: pressing it while the composer is up puts it away, so one +// gesture does exactly one thing in both directions. +function toggleQuickEntryWindow() { + if (quickEntryWindow && !quickEntryWindow.isDestroyed() && quickEntryWindow.isVisible()) { + hideQuickEntryWindow() + + return + } + + showQuickEntryWindow() +} + +const quickEntryShortcut = createQuickEntryShortcut(globalShortcut, toggleQuickEntryWindow) + +function applyQuickEntrySettings(settings) { + const state = quickEntryShortcut.apply(settings) + + if (!settings.enabled) { + // Turning the feature off must not leave an orphan always-on-top window. + if (quickEntryWindow && !quickEntryWindow.isDestroyed()) { + quickEntryWindow.close() + } + + quickEntryWindow = null + } + + if (state.error === 'taken') { + rememberLog(`[quick-entry] shortcut ${state.shortcut} is already taken by another application`) + } else if (state.error === 'invalid') { + rememberLog(`[quick-entry] shortcut ${state.shortcut} is not a valid accelerator`) + } + + return { ...state, enabled: settings.enabled } +} + +function closeQuickEntryWindow() { + quickEntryShortcut.dispose() + + if (quickEntryWindow && !quickEntryWindow.isDestroyed()) { + quickEntryWindow.close() + } + + quickEntryWindow = null +} + function createWindow() { const icon = getAppIconPath() const savedWindowState = readWindowState() @@ -8681,9 +8900,9 @@ function createWindow() { show: false, backgroundColor: getWindowBackgroundColor(), // Shared with the secondary session windows (chatWindowWebPreferences) so - // both keep `backgroundThrottling: false` — the chat transcript streams via - // a requestAnimationFrame-gated flush that Chromium pauses for blurred - // windows, stalling the live answer until refocus. See session-windows.ts. + // both keep `backgroundThrottling: false` — the chat transcript uses a + // bounded timer flush that Chromium clamps for blurred windows, stalling + // the live answer until refocus. See session-windows.ts. webPreferences: chatWindowWebPreferences(PRELOAD_PATH) }) @@ -8751,6 +8970,10 @@ function createWindow() { mainWindow.on('enter-full-screen', () => sendWindowStateChanged(true)) mainWindow.on('will-leave-full-screen', () => sendWindowStateChanged(false)) mainWindow.on('leave-full-screen', () => sendWindowStateChanged(false)) + mainWindow.on('minimize', () => sendWindowStateChanged()) + mainWindow.on('restore', () => sendWindowStateChanged()) + mainWindow.on('hide', () => sendWindowStateChanged()) + mainWindow.on('show', () => sendWindowStateChanged()) // Reopen where the user left off. resized/moved settle once per drag; close is // the cross-platform backstop, flushed synchronously before the window is gone. @@ -9106,20 +9329,17 @@ ipcMain.handle('hermes:bootstrap:reset', async () => { return { ok: true } }) ipcMain.handle('hermes:bootstrap:repair', async () => { - // Forceful repair: drop the bootstrap-complete marker so the next - // startHermes() re-runs the full installer (refreshing a broken/partial - // venv), and clear any latched failure + live connection. The renderer - // reloads afterwards to re-drive the boot flow from scratch. - rememberLog('[bootstrap] repair requested by renderer; clearing marker + latched failure') - - try { - if (fileExists(BOOTSTRAP_COMPLETE_MARKER)) { - fs.rmSync(BOOTSTRAP_COMPLETE_MARKER, { force: true }) - } - } catch (error) { - rememberLog(`[bootstrap] failed to remove marker during repair: ${error.message}`) - } + // Forceful repair: force the next startHermes() through the full installer + // (refreshing a broken/partial venv) and clear any latched failure + live + // connection. The renderer reloads afterwards to re-drive the boot flow. + // + // We do NOT delete the bootstrap marker here. Repair is also reachable from + // transient backend errors on a perfectly healthy install, and deleting the + // marker in that case stranded the app in first-run setup with no way back + // (#72166). The explicit flag carries the intent instead. + rememberLog('[bootstrap] repair requested by renderer; forcing reinstall + clearing latched failure') + bootstrapRepairRequested = true bootstrapFailure = null backendStartFailure = null remoteReauthFailure = null @@ -9947,12 +10167,139 @@ ipcMain.on('hermes:keep-awake', (_event, on) => { } }) +// Quick Entry: the renderer reads the live registration state on settings mount +// and writes the preference back. Main is authoritative — it owns the OS +// accelerator — so both handlers return the state that ACTUALLY resulted, +// including `registered: false` + `error: 'taken'` when another app owns the +// chord. See electron/quick-entry.ts + store/quick-entry. +ipcMain.handle('hermes:quick-entry:settings:get', async () => { + const settings = readQuickEntrySettings() + const state = quickEntryShortcut.current() + + // Ground truth is what the last apply produced; the shortcut we report is the + // live one (a saved-but-rejected chord still shows what the user asked for). + return { + enabled: settings.enabled, + error: state.error, + registered: state.registered, + shortcut: settings.enabled ? state.shortcut : settings.shortcut + } +}) + +ipcMain.handle('hermes:quick-entry:settings:set', async (_event, patch) => { + const current = readQuickEntrySettings() + + const next = sanitizeQuickEntrySettings({ + enabled: patch?.enabled === undefined ? current.enabled : patch.enabled === true, + shortcut: typeof patch?.shortcut === 'string' && patch.shortcut.trim() ? patch.shortcut : current.shortcut + }) + + writeQuickEntrySettings(next) + + return applyQuickEntrySettings(next) +}) + +// Quick window → main → PRIMARY renderer. We never submit here: the renderer +// owns the one prompt-submit path, and forwarding keeps it that way. The +// payload is `{ target, text }` — target routing (current chat / a picked +// session / new) is the renderer's job too. +ipcMain.on('hermes:quick-entry:submit', (_event, payload) => { + hideQuickEntryWindow() + + const text = typeof payload?.text === 'string' ? payload.text.trim() : '' + + if (!text) { + return + } + + if (!mainWindow || mainWindow.isDestroyed()) { + rememberLog('[quick-entry] dropped a submit: no primary window to route it to') + + return + } + + // Deliberately does NOT raise/focus the main window — the user asked to fire + // a prompt from wherever they were, not to be yanked into the app. + mainWindow.webContents.send('hermes:quick-entry:submit', { + target: typeof payload?.target === 'string' && payload.target ? payload.target : 'current', + text + }) +}) + +// Primary renderer → main → quick window: gateway connection state + the +// recent-session list for the target picker. Cached so a quick window spawned +// AFTER the last push still boots from truth instead of "disconnected". +ipcMain.on('hermes:quick-entry:state', (_event, payload) => { + quickEntryLastState = payload ?? null + + if (quickEntryWindow && !quickEntryWindow.isDestroyed()) { + quickEntryWindow.webContents.send('hermes:quick-entry:state', payload) + } +}) + +ipcMain.on('hermes:quick-entry:dismiss', () => hideQuickEntryWindow()) + ipcMain.handle('hermes:openExternal', (_event, url) => { if (!openExternalUrl(url)) { throw new Error('Invalid external URL') } }) +// ── Find-in-page (Ctrl/Cmd+F) ───────────────────────────────────────────── +// The desktop supports multiple BrowserWindows (one primary plus any +// per-session secondary windows spawned via `hermes:window:openSession`). +// Find must run against the requesting window, not a global — otherwise +// Cmd+F pressed in a secondary session window would search the primary +// and the match counter would report matches the user can't see. Resolve +// the sender through `BrowserWindow.fromWebContents(event.sender)` and +// forward `found-in-page` results back to that same sender. + +// Lazily-installed forwarder per sender webContents. We track one +// uninstall fn per webContents id and prune entries when the sender goes +// away — Electron does not auto-detach webContents listeners on close, +// so the map is the cleanup path. +const foundInPageForwarders = new Map void>() + +function ensureFoundInPageForwarder(sender: Electron.WebContents): void { + if (foundInPageForwarders.has(sender.id)) { + return + } + + const uninstall = installFoundInPageForwarder(sender) + foundInPageForwarders.set(sender.id, uninstall) + + sender.once('destroyed', () => { + foundInPageForwarders.get(sender.id)?.() + foundInPageForwarders.delete(sender.id) + }) +} + +ipcMain.handle('hermes:find-in-page', (event, query, options) => { + const win = BrowserWindow.fromWebContents(event.sender) + + if (!win || win.isDestroyed()) { + return { count: 0 } + } + + ensureFoundInPageForwarder(event.sender) + performFind(win.webContents, query, options) + + // The match count arrives asynchronously via `found-in-page`; the + // synchronous return value is intentionally `{ count: 0 }` to mirror + // Electron's own `findInPage` return semantics (an opaque request id). + return { count: 0 } +}) + +ipcMain.handle('hermes:stop-find-in-page', event => { + const win = BrowserWindow.fromWebContents(event.sender) + + if (!win || win.isDestroyed()) { + return + } + + stopFind(win.webContents) +}) + ipcMain.handle('hermes:openPreviewInBrowser', async (_event, url) => { if (!(await openPreviewInBrowser(url))) { throw new Error('Invalid preview URL') @@ -10963,6 +11310,10 @@ app.whenReady().then(() => { configureSpellChecker() registerPowerResumeListeners() keepAwake.set(readPersistedKeepAwake()) + // Quick Entry's global chord — registered on ready so a cold launch restores + // it without the renderer visiting Settings. A failed registration is logged + // here and surfaced in Settings via the IPC state (never silent). + applyQuickEntrySettings(readQuickEntrySettings()) createWindow() // Win/Linux cold start: the launching hermes:// URL is in our own argv. @@ -11041,6 +11392,10 @@ app.on('before-quit', event => { // pet can't keep the process alive or float over a quit app. closePetOverlay() + // Same for the Quick Entry composer — and release its global accelerator so a + // quitting Hermes never keeps another app's chord hostage. + closeQuickEntryWindow() + // Quitting mid-install should stop the installer, not orphan it. if (bootstrapAbortController) { try { diff --git a/apps/desktop/electron/preload.ts b/apps/desktop/electron/preload.ts index 47d854a193..99df85abd4 100644 --- a/apps/desktop/electron/preload.ts +++ b/apps/desktop/electron/preload.ts @@ -36,6 +36,41 @@ contextBridge.exposeInMainWorld('hermesDesktop', { return () => ipcRenderer.removeListener('hermes:pet-overlay:control', listener) } }, + // Quick Entry: the global-hotkey mini composer window. Main owns the OS + // shortcut + the persisted preference; the quick window only captures text + // and hands it back, and the primary renderer submits it through the normal + // prompt path. + quickEntry: { + getSettings: () => ipcRenderer.invoke('hermes:quick-entry:settings:get'), + setSettings: patch => ipcRenderer.invoke('hermes:quick-entry:settings:set', patch), + submit: payload => ipcRenderer.send('hermes:quick-entry:submit', payload), + dismiss: () => ipcRenderer.send('hermes:quick-entry:dismiss'), + // Primary renderer → main → quick window: gateway connection state + the + // recent-session options the target picker offers. Main caches the latest + // payload so a freshly spawned quick window starts from truth. + pushState: payload => ipcRenderer.send('hermes:quick-entry:state', payload), + // Quick window subscribes to those pushes. + onState: callback => { + const listener = (_event, payload) => callback(payload) + ipcRenderer.on('hermes:quick-entry:state', listener) + + return () => ipcRenderer.removeListener('hermes:quick-entry:state', listener) + }, + // Main → primary renderer: a submit captured by the quick window. + onSubmit: callback => { + const listener = (_event, payload) => callback(payload) + ipcRenderer.on('hermes:quick-entry:submit', listener) + + return () => ipcRenderer.removeListener('hermes:quick-entry:submit', listener) + }, + // Main → quick window: you were just summoned (reset draft + refocus). + onShown: callback => { + const listener = () => callback() + ipcRenderer.on('hermes:quick-entry:shown', listener) + + return () => ipcRenderer.removeListener('hermes:quick-entry:shown', listener) + } + }, getBootProgress: () => ipcRenderer.invoke('hermes:boot-progress:get'), getConnectionConfig: profile => ipcRenderer.invoke('hermes:connection-config:get', profile), saveConnectionConfig: payload => ipcRenderer.invoke('hermes:connection-config:save', payload), @@ -268,5 +303,19 @@ contextBridge.exposeInMainWorld('hermesDesktop', { themes: { fetchMarketplace: id => ipcRenderer.invoke('hermes:vscode-theme:fetch', id), searchMarketplace: query => ipcRenderer.invoke('hermes:vscode-theme:search', query) + }, + // Find-in-page (Ctrl/Cmd+F): delegates to Electron's + // webContents.findInPage on the IPC sender's window so a Cmd+F pressed + // in a secondary session window searches THAT window, not the primary. + // `onFoundInPage` returns the unsubscribe fn; the renderer wires it via + // `initFindInPageListener` in store/find-in-page.ts and tears it down + // when the FindBar unmounts. + findInPage: (query, options) => ipcRenderer.invoke('hermes:find-in-page', query, options), + stopFindInPage: () => ipcRenderer.invoke('hermes:stop-find-in-page'), + onFoundInPage: callback => { + const listener = (_event, result) => callback(result) + ipcRenderer.on('hermes:found-in-page', listener) + + return () => ipcRenderer.removeListener('hermes:found-in-page', listener) } }) diff --git a/apps/desktop/electron/quick-entry.test.ts b/apps/desktop/electron/quick-entry.test.ts new file mode 100644 index 0000000000..fa8039791d --- /dev/null +++ b/apps/desktop/electron/quick-entry.test.ts @@ -0,0 +1,240 @@ +import { describe, expect, it, vi } from 'vitest' + +import { + createQuickEntryShortcut, + DEFAULT_QUICK_ENTRY_SHORTCUT, + type GlobalShortcutLike, + parseQuickEntryShortcut, + quickEntryWindowBounds, + sanitizeQuickEntrySettings +} from './quick-entry' + +function fakeGlobalShortcut(options: { register?: boolean; taken?: string[] } = {}) { + const held = new Set(options.taken ?? []) + + const globalShortcut: GlobalShortcutLike = { + isRegistered: vi.fn((accelerator: string) => held.has(accelerator)), + register: vi.fn((accelerator: string) => { + if (options.register === false) { + return false + } + + held.add(accelerator) + + return true + }), + unregister: vi.fn((accelerator: string) => void held.delete(accelerator)) + } + + return { globalShortcut, held } +} + +describe('parseQuickEntryShortcut', () => { + it('normalizes casing, aliases, and modifier order', () => { + expect(parseQuickEntryShortcut('cmdorctrl+shift+space')).toEqual({ + accelerator: 'CommandOrControl+Shift+Space', + ok: true + }) + expect(parseQuickEntryShortcut(' Shift + CTRL + k ')).toEqual({ accelerator: 'Control+Shift+K', ok: true }) + expect(parseQuickEntryShortcut('Alt+f5')).toEqual({ accelerator: 'Alt+F5', ok: true }) + expect(parseQuickEntryShortcut('Meta+/')).toEqual({ accelerator: 'Super+/', ok: true }) + }) + + it('collapses duplicate modifiers', () => { + expect(parseQuickEntryShortcut('Ctrl+Control+Shift+J')).toEqual({ accelerator: 'Control+Shift+J', ok: true }) + }) + + it('requires a modifier so a global bind cannot swallow a bare key', () => { + expect(parseQuickEntryShortcut('K')).toEqual({ ok: false, reason: 'no-modifier' }) + expect(parseQuickEntryShortcut('Space')).toEqual({ ok: false, reason: 'no-modifier' }) + }) + + it('requires exactly one non-modifier key', () => { + expect(parseQuickEntryShortcut('Shift+Control')).toEqual({ ok: false, reason: 'no-key' }) + expect(parseQuickEntryShortcut('Shift+A+B')).toEqual({ ok: false, reason: 'invalid-key' }) + expect(parseQuickEntryShortcut('A+Shift')).toEqual({ ok: false, reason: 'invalid-modifier' }) + }) + + it('rejects empty, junk, and the reserved Escape key', () => { + expect(parseQuickEntryShortcut('')).toEqual({ ok: false, reason: 'empty' }) + expect(parseQuickEntryShortcut(' ')).toEqual({ ok: false, reason: 'empty' }) + expect(parseQuickEntryShortcut(null)).toEqual({ ok: false, reason: 'empty' }) + expect(parseQuickEntryShortcut('Ctrl+NotAKey')).toEqual({ ok: false, reason: 'invalid-key' }) + // Escape hides the window; binding it globally would make it un-toggleable. + expect(parseQuickEntryShortcut('Ctrl+Escape')).toEqual({ ok: false, reason: 'reserved' }) + }) + + it('accepts the shipped default unchanged', () => { + expect(parseQuickEntryShortcut(DEFAULT_QUICK_ENTRY_SHORTCUT)).toEqual({ + accelerator: DEFAULT_QUICK_ENTRY_SHORTCUT, + ok: true + }) + }) +}) + +describe('sanitizeQuickEntrySettings', () => { + it('defaults to enabled with the default shortcut', () => { + expect(sanitizeQuickEntrySettings(undefined)).toEqual({ enabled: true, shortcut: DEFAULT_QUICK_ENTRY_SHORTCUT }) + expect(sanitizeQuickEntrySettings('not an object')).toEqual({ + enabled: true, + shortcut: DEFAULT_QUICK_ENTRY_SHORTCUT + }) + }) + + it('keeps an explicit disable and normalizes a stored shortcut', () => { + expect(sanitizeQuickEntrySettings({ enabled: false, shortcut: 'alt+j' })).toEqual({ + enabled: false, + shortcut: 'Alt+J' + }) + }) + + it('falls back to the default when the stored shortcut is unusable', () => { + expect(sanitizeQuickEntrySettings({ enabled: true, shortcut: 'Q' })).toEqual({ + enabled: true, + shortcut: DEFAULT_QUICK_ENTRY_SHORTCUT + }) + }) + + it('treats a non-boolean enabled as off (only `true` opts in once present)', () => { + expect(sanitizeQuickEntrySettings({ enabled: 'yes' }).enabled).toBe(false) + }) +}) + +describe('createQuickEntryShortcut', () => { + it('registers the normalized accelerator when enabled', () => { + const { globalShortcut } = fakeGlobalShortcut() + const onTrigger = vi.fn() + const controller = createQuickEntryShortcut(globalShortcut, onTrigger) + + const state = controller.apply({ enabled: true, shortcut: 'cmdorctrl+shift+space' }) + + expect(state).toEqual({ error: null, registered: true, shortcut: 'CommandOrControl+Shift+Space' }) + expect(globalShortcut.register).toHaveBeenCalledWith('CommandOrControl+Shift+Space', onTrigger) + expect(controller.current()).toEqual(state) + }) + + it('never registers while the setting is disabled', () => { + const { globalShortcut } = fakeGlobalShortcut() + const controller = createQuickEntryShortcut(globalShortcut, vi.fn()) + + const state = controller.apply({ enabled: false, shortcut: DEFAULT_QUICK_ENTRY_SHORTCUT }) + + expect(globalShortcut.register).not.toHaveBeenCalled() + expect(state).toEqual({ error: null, registered: false, shortcut: DEFAULT_QUICK_ENTRY_SHORTCUT }) + }) + + it('releases the old accelerator before registering a new one', () => { + const { globalShortcut, held } = fakeGlobalShortcut() + const controller = createQuickEntryShortcut(globalShortcut, vi.fn()) + + controller.apply({ enabled: true, shortcut: 'Alt+J' }) + controller.apply({ enabled: true, shortcut: 'Alt+K' }) + + expect(globalShortcut.unregister).toHaveBeenCalledWith('Alt+J') + expect(held.has('Alt+J')).toBe(false) + expect(held.has('Alt+K')).toBe(true) + }) + + it('turning the feature off releases the live accelerator', () => { + const { globalShortcut, held } = fakeGlobalShortcut() + const controller = createQuickEntryShortcut(globalShortcut, vi.fn()) + + controller.apply({ enabled: true, shortcut: 'Alt+J' }) + const off = controller.apply({ enabled: false, shortcut: 'Alt+J' }) + + expect(globalShortcut.unregister).toHaveBeenCalledWith('Alt+J') + expect(held.size).toBe(0) + expect(off.registered).toBe(false) + expect(off.error).toBeNull() + }) + + it("surfaces 'taken' when another app already owns the chord", () => { + const { globalShortcut } = fakeGlobalShortcut({ taken: ['Alt+J'] }) + const controller = createQuickEntryShortcut(globalShortcut, vi.fn()) + + const state = controller.apply({ enabled: true, shortcut: 'alt+j' }) + + expect(globalShortcut.register).not.toHaveBeenCalled() + expect(state).toEqual({ error: 'taken', registered: false, shortcut: 'Alt+J' }) + }) + + it("surfaces 'taken' when the OS refuses the registration", () => { + const { globalShortcut } = fakeGlobalShortcut({ register: false }) + const controller = createQuickEntryShortcut(globalShortcut, vi.fn()) + + expect(controller.apply({ enabled: true, shortcut: 'Alt+J' })).toEqual({ + error: 'taken', + registered: false, + shortcut: 'Alt+J' + }) + }) + + it("surfaces 'invalid' for an unusable shortcut without asking the OS", () => { + const { globalShortcut } = fakeGlobalShortcut() + const controller = createQuickEntryShortcut(globalShortcut, vi.fn()) + + expect(controller.apply({ enabled: true, shortcut: 'J' })).toEqual({ + error: 'invalid', + registered: false, + shortcut: 'J' + }) + expect(globalShortcut.register).not.toHaveBeenCalled() + }) + + it('survives a throwing globalShortcut', () => { + const globalShortcut: GlobalShortcutLike = { + isRegistered: () => false, + register: () => { + throw new Error('x11 grab failed') + }, + unregister: () => {} + } + + const controller = createQuickEntryShortcut(globalShortcut, vi.fn()) + + expect(controller.apply({ enabled: true, shortcut: 'Alt+J' }).error).toBe('taken') + }) + + it('dispose releases the accelerator and is idempotent', () => { + const { globalShortcut, held } = fakeGlobalShortcut() + const controller = createQuickEntryShortcut(globalShortcut, vi.fn()) + + controller.apply({ enabled: true, shortcut: 'Alt+J' }) + controller.dispose() + controller.dispose() + + expect(globalShortcut.unregister).toHaveBeenCalledTimes(1) + expect(held.size).toBe(0) + expect(controller.current().registered).toBe(false) + }) +}) + +describe('quickEntryWindowBounds', () => { + it('centers horizontally and sits below the top edge of the work area', () => { + const bounds = quickEntryWindowBounds({ height: 1000, width: 1600, x: 0, y: 0 }) + + expect(bounds.width).toBe(640) + expect(bounds.x).toBe((1600 - 640) / 2) + expect(bounds.y).toBeGreaterThan(0) + expect(bounds.y + bounds.height).toBeLessThanOrEqual(1000) + }) + + it('respects a display origin offset (second monitor)', () => { + const bounds = quickEntryWindowBounds({ height: 900, width: 1440, x: 1600, y: -200 }) + + expect(bounds.x).toBe(1600 + (1440 - 640) / 2) + expect(bounds.y).toBeGreaterThanOrEqual(-200) + }) + + it('stays inside a tiny work area', () => { + const bounds = quickEntryWindowBounds({ height: 120, width: 320, x: 0, y: 0 }) + + expect(bounds.width).toBeLessThanOrEqual(320) + expect(bounds.height).toBeLessThanOrEqual(120) + expect(bounds.y + bounds.height).toBeLessThanOrEqual(120) + }) + + it('falls back to the origin without a work area', () => { + expect(quickEntryWindowBounds()).toEqual({ height: 168, width: 640, x: 0, y: 0 }) + }) +}) diff --git a/apps/desktop/electron/quick-entry.ts b/apps/desktop/electron/quick-entry.ts new file mode 100644 index 0000000000..db2975696b --- /dev/null +++ b/apps/desktop/electron/quick-entry.ts @@ -0,0 +1,426 @@ +/** + * Quick Entry — the global-hotkey mini composer. + * + * A small frameless always-on-top window that a global shortcut summons from + * anywhere so the user can fire a prompt at Hermes without raising the whole + * app. The window carries NO gateway connection of its own: it forwards the + * text to the primary renderer, which sends it through the SAME prompt-submit + * path the normal composer uses (see app/contrib/hooks/use-quick-entry-bridge). + * + * Everything Electron-free lives here so the parts that actually break a user — + * accelerator validation, "disabled means never register", and surfacing a + * shortcut another app already owns — are unit-testable without booting + * Electron. main.ts owns the BrowserWindow, the file I/O, and the real + * `globalShortcut`. + */ + +// Default matches the muscle memory of the apps this ports from (Claude +// Desktop's quick entry / ChatGPT's Quick Chat sit on a Cmd+Shift chord). +const DEFAULT_QUICK_ENTRY_SHORTCUT = 'CommandOrControl+Shift+Space' + +// Compact capture surface: wide enough for a sentence, short enough to read as +// a HUD rather than a second app window. Height covers the composer row plus +// the session-target picker row; the renderer never grows the OS window in v1. +const QUICK_ENTRY_WINDOW_WIDTH = 640 +const QUICK_ENTRY_WINDOW_HEIGHT = 168 + +// Spotlight-ish placement: horizontally centered on the active display, a +// comfortable fraction down from the top rather than dead center. +const QUICK_ENTRY_TOP_FRACTION = 0.22 + +// Electron accelerator vocabulary (electronjs.org/docs/latest/api/accelerator). +// Kept as data so validation and the settings UI agree on one list. +const ACCELERATOR_MODIFIERS = new Set([ + 'alt', + 'altgr', + 'cmd', + 'cmdorctrl', + 'command', + 'commandorcontrol', + 'control', + 'ctrl', + 'meta', + 'option', + 'shift', + 'super' +]) + +const ACCELERATOR_KEYS = new Set([ + 'backspace', + 'delete', + 'down', + 'end', + 'enter', + 'escape', + 'home', + 'insert', + 'left', + 'medianexttrack', + 'mediaplaypause', + 'mediaprevioustrack', + 'mediastop', + 'pagedown', + 'pageup', + 'plus', + 'printscreen', + 'return', + 'right', + 'space', + 'tab', + 'up', + 'volumedown', + 'volumemute', + 'volumeup' +]) + +// Single printable characters Electron accepts verbatim, plus 0-9 / A-Z below. +const ACCELERATOR_PUNCTUATION = new Set([ + '!', + '"', + '#', + '$', + '%', + '&', + "'", + '(', + ')', + '*', + '+', + ',', + '-', + '.', + '/', + ':', + ';', + '<', + '=', + '>', + '?', + '@', + '[', + '\\', + ']', + '^', + '_', + '`', + '{', + '|', + '}', + '~' +]) + +/** Why a shortcut string was rejected. The renderer maps these to copy. */ +export type QuickEntryShortcutError = + | 'empty' + | 'invalid-key' + | 'invalid-modifier' + | 'no-key' + | 'no-modifier' + | 'reserved' + +export type QuickEntryShortcutParse = { ok: false; reason: QuickEntryShortcutError } | { accelerator: string; ok: true } + +function isAcceleratorKey(token: string): boolean { + if (ACCELERATOR_KEYS.has(token)) { + return true + } + + if (/^f([1-9]|1[0-9]|2[0-4])$/.test(token)) { + return true + } + + if (/^num(?:[0-9]|lock|dec|add|sub|mult|div)$/.test(token)) { + return true + } + + return token.length === 1 && (/^[a-z0-9]$/.test(token) || ACCELERATOR_PUNCTUATION.has(token)) +} + +/** + * Validate + normalize a user-typed accelerator. + * + * Rules beyond Electron's own grammar, both deliberate: + * - At least one modifier. A bare global key steals that key from EVERY app. + * - `Escape` can't be the key: inside the window Escape means "hide", so + * binding it globally would make the shortcut un-toggleable. + */ +export function parseQuickEntryShortcut(raw: unknown): QuickEntryShortcutParse { + if (typeof raw !== 'string' || !raw.trim()) { + return { ok: false, reason: 'empty' } + } + + const parts = raw + .split('+') + .map(part => part.trim()) + .filter(Boolean) + + if (parts.length === 0) { + return { ok: false, reason: 'empty' } + } + + const modifiers: string[] = [] + let key: null | string = null + + for (const part of parts) { + const lower = part.toLowerCase() + + if (ACCELERATOR_MODIFIERS.has(lower)) { + if (key) { + // A modifier after the key ("A+Shift") is not a valid accelerator. + return { ok: false, reason: 'invalid-modifier' } + } + + modifiers.push(lower) + + continue + } + + if (key) { + // Two non-modifier keys ("Shift+A+B"). + return { ok: false, reason: 'invalid-key' } + } + + if (!isAcceleratorKey(lower)) { + return { ok: false, reason: 'invalid-key' } + } + + key = lower + } + + if (!key) { + return { ok: false, reason: 'no-key' } + } + + if (modifiers.length === 0) { + return { ok: false, reason: 'no-modifier' } + } + + if (key === 'escape') { + return { ok: false, reason: 'reserved' } + } + + // Canonical casing so a saved shortcut round-trips identically no matter how + // the user typed it, and duplicate modifiers collapse. + const seen = new Set() + + const normalizedModifiers = modifiers + .map(modifier => CANONICAL_MODIFIER[modifier] ?? modifier) + .filter(modifier => (seen.has(modifier) ? false : (seen.add(modifier), true))) + // Stable display order (Electron itself is order-insensitive). + .sort((left, right) => MODIFIER_ORDER.indexOf(left) - MODIFIER_ORDER.indexOf(right)) + + return { accelerator: [...normalizedModifiers, canonicalKey(key)].join('+'), ok: true } +} + +const CANONICAL_MODIFIER: Record = { + alt: 'Alt', + altgr: 'AltGr', + cmd: 'Command', + cmdorctrl: 'CommandOrControl', + command: 'Command', + commandorcontrol: 'CommandOrControl', + control: 'Control', + ctrl: 'Control', + meta: 'Super', + option: 'Option', + shift: 'Shift', + super: 'Super' +} + +const MODIFIER_ORDER = ['CommandOrControl', 'Command', 'Control', 'Super', 'Alt', 'Option', 'AltGr', 'Shift'] + +const CANONICAL_KEY: Record = { + backspace: 'Backspace', + delete: 'Delete', + down: 'Down', + end: 'End', + enter: 'Enter', + escape: 'Escape', + home: 'Home', + insert: 'Insert', + medianexttrack: 'MediaNextTrack', + mediaplaypause: 'MediaPlayPause', + mediaprevioustrack: 'MediaPreviousTrack', + mediastop: 'MediaStop', + pagedown: 'PageDown', + pageup: 'PageUp', + plus: 'Plus', + printscreen: 'PrintScreen', + return: 'Return', + right: 'Right', + space: 'Space', + tab: 'Tab', + up: 'Up', + volumedown: 'VolumeDown', + volumemute: 'VolumeMute', + volumeup: 'VolumeUp', + left: 'Left' +} + +function canonicalKey(key: string): string { + if (CANONICAL_KEY[key]) { + return CANONICAL_KEY[key] + } + + if (/^f([1-9]|1[0-9]|2[0-4])$/.test(key)) { + return key.toUpperCase() + } + + if (key.length === 1 && /^[a-z]$/.test(key)) { + return key.toUpperCase() + } + + return key +} + +/** The persisted shape of `quick-entry.json` (main-process owned). */ +export interface QuickEntrySettings { + enabled: boolean + shortcut: string +} + +/** + * Raw persisted JSON → usable settings. A malformed/absent file, or a shortcut + * that no longer validates (hand-edited, or from a future build), falls back to + * the default shortcut rather than leaving the feature un-summonable. + */ +export function sanitizeQuickEntrySettings(raw: unknown): QuickEntrySettings { + const record = raw && typeof raw === 'object' ? (raw as Record) : {} + const parsed = parseQuickEntryShortcut(record.shortcut) + + return { + // Default ON: the feature is inert until the shortcut is pressed. + enabled: record.enabled === undefined ? true : record.enabled === true, + shortcut: parsed.ok ? parsed.accelerator : DEFAULT_QUICK_ENTRY_SHORTCUT + } +} + +/** The slice of Electron's `globalShortcut` we use (injected for testing). */ +export interface GlobalShortcutLike { + isRegistered(accelerator: string): boolean + register(accelerator: string, callback: () => void): boolean + unregister(accelerator: string): void +} + +/** + * What Settings shows. `registered` is the ground truth (we asked the OS); + * `error` distinguishes "you turned it off" from "another app owns that chord", + * which is the failure this feature must never swallow. + */ +export interface QuickEntryRegistration { + error: null | QuickEntryRegistrationError + registered: boolean + shortcut: string +} + +export type QuickEntryRegistrationError = 'invalid' | 'taken' + +export interface QuickEntryShortcutController { + /** Registration state as of the last apply. */ + current(): QuickEntryRegistration + /** Release the shortcut (quit / feature off). Idempotent. */ + dispose(): void + /** Re-register to match `settings`. Returns the resulting state. */ + apply(settings: QuickEntrySettings): QuickEntryRegistration +} + +/** + * Owns the one live global accelerator. Single resolver so every caller — boot, + * the settings write, quit — gets the same answer and we can never leak two + * registrations for one feature. + * + * Disabled settings never touch `register()` at all: a user who turned Quick + * Entry off must not have their chord silently held hostage. + */ +export function createQuickEntryShortcut( + globalShortcut: GlobalShortcutLike, + onTrigger: () => void +): QuickEntryShortcutController { + let active: null | string = null + let state: QuickEntryRegistration = { error: null, registered: false, shortcut: DEFAULT_QUICK_ENTRY_SHORTCUT } + + const release = () => { + if (active) { + try { + globalShortcut.unregister(active) + } catch { + // Best effort — a dead accelerator must not block a re-register. + } + + active = null + } + } + + return { + apply(settings) { + const parsed = parseQuickEntryShortcut(settings.shortcut) + const shortcut = parsed.ok ? parsed.accelerator : settings.shortcut + + release() + + if (!settings.enabled) { + state = { error: null, registered: false, shortcut } + + return state + } + + if (!parsed.ok) { + state = { error: 'invalid', registered: false, shortcut } + + return state + } + + // `isRegistered` catches the common conflict before we ask, and + // `register()` returning false catches the rest (another process owns it + // OS-wide). Both land in the same surfaced 'taken' state. + let ok = false + + try { + ok = globalShortcut.isRegistered(parsed.accelerator) + ? false + : globalShortcut.register(parsed.accelerator, onTrigger) + } catch { + ok = false + } + + active = ok ? parsed.accelerator : null + state = { error: ok ? null : 'taken', registered: ok, shortcut: parsed.accelerator } + + return state + }, + current() { + return state + }, + dispose() { + release() + state = { ...state, error: null, registered: false } + } + } +} + +/** + * Where the quick window opens on a given display work area. Centered + * horizontally, a fraction down from the top, and clamped so it stays fully + * inside the work area on small/odd displays. + */ +export function quickEntryWindowBounds(workArea?: { height: number; width: number; x: number; y: number }): { + height: number + width: number + x: number + y: number +} { + const width = Math.min(QUICK_ENTRY_WINDOW_WIDTH, workArea?.width ?? QUICK_ENTRY_WINDOW_WIDTH) + const height = Math.min(QUICK_ENTRY_WINDOW_HEIGHT, workArea?.height ?? QUICK_ENTRY_WINDOW_HEIGHT) + + if (!workArea) { + return { height, width, x: 0, y: 0 } + } + + const x = Math.round(workArea.x + (workArea.width - width) / 2) + const maxY = workArea.y + workArea.height - height + const y = Math.round(Math.min(Math.max(workArea.y, workArea.y + workArea.height * QUICK_ENTRY_TOP_FRACTION), maxY)) + + return { height, width, x, y } +} + +export { DEFAULT_QUICK_ENTRY_SHORTCUT, QUICK_ENTRY_TOP_FRACTION, QUICK_ENTRY_WINDOW_HEIGHT, QUICK_ENTRY_WINDOW_WIDTH } diff --git a/apps/desktop/electron/session-windows.test.ts b/apps/desktop/electron/session-windows.test.ts index 5167593bfb..b5f9cc6a8b 100644 --- a/apps/desktop/electron/session-windows.test.ts +++ b/apps/desktop/electron/session-windows.test.ts @@ -193,8 +193,8 @@ test('registry trims the session id before keying', () => { test('chatWindowWebPreferences disables background throttling so streaming paints while blurred', () => { // Regression: secondary session windows used to omit this flag, so a streamed - // answer stalled until the window regained focus (Chromium pauses the - // requestAnimationFrame-gated transcript flush for backgrounded windows). + // answer stalled until the window regained focus (Chromium clamps the + // transcript flush timer for backgrounded windows). const prefs = chatWindowWebPreferences('/tmp/preload.cjs') assert.equal(prefs.backgroundThrottling, false) diff --git a/apps/desktop/electron/session-windows.ts b/apps/desktop/electron/session-windows.ts index 48597ee9e0..46871b5384 100644 --- a/apps/desktop/electron/session-windows.ts +++ b/apps/desktop/electron/session-windows.ts @@ -17,8 +17,8 @@ const SESSION_WINDOW_MIN_HEIGHT = 620 // false`, so a streamed answer stalled until the window regained focus. // // `backgroundThrottling: false` is load-bearing: the transcript streams to the -// screen through a requestAnimationFrame-gated flush, which Chromium pauses for -// blurred/occluded windows. A streaming chat app must keep painting in the +// screen through a bounded timer flush, which Chromium clamps for blurred/ +// occluded windows. A streaming chat app must keep painting in the // background, so every chat window opts out. The preload path is injected // because it depends on the Electron entry's __dirname. function chatWindowWebPreferences(preloadPath: string) { diff --git a/apps/desktop/electron/zoom.ts b/apps/desktop/electron/zoom.ts index 7d1d80d974..e81ffeeb07 100644 --- a/apps/desktop/electron/zoom.ts +++ b/apps/desktop/electron/zoom.ts @@ -90,15 +90,16 @@ export function installZoomReassertOnWindowEvents(win, reassert, platform = proc /** * Zoom-wiring decision per window kind. Chat windows (main + session) keep - * global UI zoom; the pet overlay opts out because it sizes its own OS window - * to the sprite and inheriting zoom would crop it. + * global UI zoom; the pet overlay and the Quick Entry composer opt out because + * they size their own OS window and inheriting zoom would crop/overflow them. * - * Extracted so the "pet opts out, everything else opts in" contract is + * Extracted so the "helper windows opt out, everything else opts in" contract is * unit-testable without booting a BrowserWindow or reading source. */ export const ZOOM_WINDOW_CONFIG = { chat: { zoom: true }, - petOverlay: { zoom: false } + petOverlay: { zoom: false }, + quickEntry: { zoom: false } } as const export function zoomWiringForWindowKind(kind) { diff --git a/apps/desktop/package.json b/apps/desktop/package.json index 0d2c07756a..1e3a6e10ce 100644 --- a/apps/desktop/package.json +++ b/apps/desktop/package.json @@ -147,6 +147,7 @@ "@typescript-eslint/eslint-plugin": "^8.59.1", "@typescript-eslint/parser": "^8.59.1", "@vitejs/plugin-react": "^6.0.1", + "bippy": "0.5.43", "concurrently": "^10.0.3", "cross-env": "^10.1.0", "electron": "40.10.2", diff --git a/apps/desktop/scripts/diag-drag-churn.mjs b/apps/desktop/scripts/diag-drag-churn.mjs new file mode 100644 index 0000000000..009c34e3d2 --- /dev/null +++ b/apps/desktop/scripts/diag-drag-churn.mjs @@ -0,0 +1,158 @@ +// Who re-renders the transcript during a sash drag? +// +// Standalone probe, not a benchmark: seeds tiles, then drags the sash while +// recording (a) render attribution and (b) every nanostores atom that notifies +// during the gesture. The idle-cost scenario proved the transcript re-renders +// ~18x above baseline during a drag but that the sash HANDLER is not the cause +// (identical counts at 0px and 60px displacement) — so this names the store +// that actually fires. +// +// node scripts/perf/diag-drag-churn.mjs [--port 9222] + +import { attach } from './perf/lib/launch.mjs' +import { sleep } from './perf/lib/cdp.mjs' + +const TILES = 5 +const TURNS = 20 + +const setup = ` + (() => { + const hook = window.__HERMES_SESSION_TILES__ + if (!hook) return 'no-hook' + const turn = (sid, i) => ([ + { id: sid + '-u' + i, role: 'user', timestamp: Date.now(), + parts: [{ type: 'text', text: 'Question ' + i }] }, + { id: sid + '-a' + i, role: 'assistant', timestamp: Date.now(), pending: false, + parts: [{ type: 'text', text: '## Finding ' + i + '\\n\\nSome prose with **bold** and \`code\`.\\n' }] } + ]) + window.__D__ = { ids: [] } + for (let n = 1; n <= ${TILES}; n++) { + const sid = 'diag-tile-' + n + const rid = 'diag-rt-' + n + const messages = [] + for (let i = 0; i < ${TURNS}; i++) messages.push(...turn(sid, i)) + messages.push({ id: sid + '-stream', role: 'assistant', timestamp: Date.now(), pending: true, + parts: [{ type: 'text', text: 'Working.' }] }) + window.__D__.ids.push({ sid, rid }) + hook.open(sid, 'center') + hook.patch(sid, { runtimeId: rid }) + hook.publish(rid, { + storedSessionId: sid, messages, branch: '', cwd: '', model: '', provider: '', + reasoningEffort: '', serviceTier: '', fast: false, yolo: false, personality: '', + busy: true, awaitingResponse: false, streamId: sid + '-stream', sawAssistantPayload: true, + pendingBranchGroup: null, interrupted: false, interimBoundaryPending: false, + needsInput: false, turnStartedAt: Date.now(), usage: null + }) + } + return 'ok' + })() +` + +const reveal = sid => `window.__HERMES_LAYOUT_TREE__.reveal(${JSON.stringify(`session-tile:${sid}`)})` + +// Drag, recording renders AND atom notifications together. +const DRAG = ` + (async () => { + const rc = window.__RENDER_COUNTS__ + const ac = window.__ATOM_CHURN__ + rc.start(); ac.start() + + const handle = document.querySelector('[role="separator"]') + if (!handle) { rc.stop(); ac.stop(); return JSON.stringify({ error: 'no sash' }) } + + const box = handle.getBoundingClientRect() + const y = box.top + box.height / 2 + const x0 = box.left + box.width / 2 + let x = x0 + const opts = { bubbles: true, cancelable: true, pointerId: 1, pointerType: 'mouse', isPrimary: true, button: 0, buttons: 1 } + handle.dispatchEvent(new PointerEvent('pointerdown', { ...opts, clientX: x, clientY: y })) + for (let i = 0; i < 30; i++) { + x += 2 + window.dispatchEvent(new PointerEvent('pointermove', { ...opts, clientX: x, clientY: y })) + await new Promise(r => requestAnimationFrame(r)) + } + window.dispatchEvent(new PointerEvent('pointerup', { ...opts, buttons: 0, clientX: x, clientY: y })) + + rc.stop(); ac.stop() + const all = rc.report(400) + const named = n => all.find(r => r.name === n) || null + return JSON.stringify({ + moved: Math.round(x - x0), + commits: rc.commits(), + renders: rc.report(14), + // The suspects: who at the TOP of the transcript tree re-rendered? + chain: ['ChatView', 'ChatRuntimeBoundary', 'AuiProvider', 'Thread', 'SessionTile', 'TileChat', + 'LayoutTreeRoot', 'TreeNode', 'TreeSplit', 'TreeGroup', 'SessionView', 'PaneShell'] + .map(n => ({ name: n, hit: named(n) })).filter(x => x.hit), + atoms: ac.report(30) + }) + })() +` + +const CLEANUP = ` + (() => { + if (window.__D__) { + for (const { sid, rid } of window.__D__.ids) { + const s = window.__HERMES_SESSION_TILES__.states() + window.__HERMES_SESSION_TILES__.publish(rid, { ...s[rid], busy: false, streamId: null }) + window.__HERMES_SESSION_TILES__.close(sid) + } + window.__D__ = null + } + return 'cleaned' + })() +` + +const port = Number(process.argv.includes('--port') ? process.argv[process.argv.indexOf('--port') + 1] : 9222) +const { cdp, teardown } = await attach({ port }) + +try { + await cdp.send('Runtime.enable') + + const ok = await cdp.eval(setup) + + if (ok !== 'ok') { + throw new Error(`setup failed: ${ok}`) + } + + for (let n = 1; n <= TILES; n++) { + await cdp.eval(reveal(`diag-tile-${n}`)) + await sleep(300) + } + + await sleep(1500) + + const data = JSON.parse(await cdp.eval(DRAG)) + await cdp.eval(CLEANUP) + + console.log(`moved ${data.moved}px, ${data.commits} commits\n`) + console.log('RENDERS during drag:') + + for (const r of data.renders) { + console.log( + ` ${r.name.padEnd(28)} r=${String(r.renders).padStart(6)} wasted=${String(r.wasted).padStart(6)} ` + + `props=${String(r.propsChanged).padStart(5)} state=${String(r.stateChanged).padStart(5)} ` + + `ctx=${String(r.contextChanged ?? 0).padStart(4)} ms=${r.totalMs}` + ) + } + + console.log('\nTRANSCRIPT CHAIN (who above the messages re-rendered):') + + for (const { name, hit } of data.chain) { + console.log( + ` ${name.padEnd(24)} r=${String(hit.renders).padStart(6)} wasted=${String(hit.wasted).padStart(6)} ` + + `props=${String(hit.propsChanged).padStart(5)} state=${String(hit.stateChanged).padStart(5)} ms=${hit.totalMs}` + ) + } + + console.log('\nATOMS that notified during drag:') + + for (const a of data.atoms) { + console.log( + ` ${a.name.padEnd(26)} notifies=${String(a.notifies).padStart(5)} wasted=${String(a.wasted).padStart(5)} ` + + `fanout=${String(a.fanout).padStart(6)} peakListeners=${a.peakListeners}` + ) + } +} finally { + teardown?.() +} diff --git a/apps/desktop/scripts/diag-drag-trace.mjs b/apps/desktop/scripts/diag-drag-trace.mjs new file mode 100644 index 0000000000..01c4527fc0 --- /dev/null +++ b/apps/desktop/scripts/diag-drag-trace.mjs @@ -0,0 +1,217 @@ +// What is the drag actually spending time on? +// +// The render counters proved React is no longer the cost (commits 83 -> 12 +// after the $layoutTree fix) yet drag fps stayed ~3 while p95 halved. That +// pattern says a fixed per-frame floor outside React. This takes a real CDP +// trace of one sash drag and prints the category split — Recalculate Style, +// Layout, Paint, Scripting — so the next fix targets the actual cost instead +// of the next plausible-looking thing. +// +// node scripts/diag-drag-trace.mjs [--port 9222] [--tiles 5] + +import { attach } from './perf/lib/launch.mjs' +import { sleep } from './perf/lib/cdp.mjs' + +const arg = (name, fallback) => { + const i = process.argv.indexOf(`--${name}`) + + return i === -1 ? fallback : process.argv[i + 1] +} + +const port = Number(arg('port', 9222)) +const TILES = Number(arg('tiles', 5)) +const TURNS = Number(arg('turns', 20)) + +const setup = ` + (() => { + const hook = window.__HERMES_SESSION_TILES__ + if (!hook) return 'no-hook' + const turn = (sid, i) => ([ + { id: sid + '-u' + i, role: 'user', timestamp: Date.now(), + parts: [{ type: 'text', text: 'Question ' + i }] }, + { id: sid + '-a' + i, role: 'assistant', timestamp: Date.now(), pending: false, + parts: [{ type: 'text', text: '## Finding ' + i + '\\n\\nProse with **bold** and \`code\`.\\n' }] } + ]) + window.__T__ = { ids: [] } + for (let n = 1; n <= ${TILES}; n++) { + const sid = 'trace-tile-' + n + const rid = 'trace-rt-' + n + const messages = [] + for (let i = 0; i < ${TURNS}; i++) messages.push(...turn(sid, i)) + messages.push({ id: sid + '-stream', role: 'assistant', timestamp: Date.now(), pending: true, + parts: [{ type: 'text', text: 'Working.' }] }) + window.__T__.ids.push({ sid, rid }) + hook.open(sid, 'center') + hook.patch(sid, { runtimeId: rid }) + hook.publish(rid, { + storedSessionId: sid, messages, branch: '', cwd: '', model: '', provider: '', + reasoningEffort: '', serviceTier: '', fast: false, yolo: false, personality: '', + busy: true, awaitingResponse: false, streamId: sid + '-stream', sawAssistantPayload: true, + pendingBranchGroup: null, interrupted: false, interimBoundaryPending: false, + needsInput: false, turnStartedAt: Date.now(), usage: null + }) + } + return 'ok' + })() +` + +const reveal = sid => `window.__HERMES_LAYOUT_TREE__.reveal(${JSON.stringify(`session-tile:${sid}`)})` + +// Drive the sash WITHOUT awaiting rAF: a slow app would stretch a rAF-paced +// loop and make the window itself a function of the slowness. Fixed wall-clock +// pacing keeps the trace window comparable run to run. +const DRAG = ` + (async () => { + const handle = document.querySelector('[role="separator"]') + if (!handle) return 'none' + const box = handle.getBoundingClientRect() + const y = box.top + box.height / 2 + const x0 = box.left + box.width / 2 + let x = x0 + const opts = { bubbles: true, cancelable: true, pointerId: 1, pointerType: 'mouse', isPrimary: true, button: 0, buttons: 1 } + handle.dispatchEvent(new PointerEvent('pointerdown', { ...opts, clientX: x, clientY: y })) + for (let i = 0; i < 40; i++) { + x += (i < 20 ? 3 : -3) + window.dispatchEvent(new PointerEvent('pointermove', { ...opts, clientX: x, clientY: y })) + await new Promise(r => setTimeout(r, 16)) + } + window.dispatchEvent(new PointerEvent('pointerup', { ...opts, buttons: 0, clientX: x, clientY: y })) + return 'dragged' + })() +` + +const CLEANUP = ` + (() => { + if (window.__T__) { + for (const { sid, rid } of window.__T__.ids) { + const s = window.__HERMES_SESSION_TILES__.states() + window.__HERMES_SESSION_TILES__.publish(rid, { ...s[rid], busy: false, streamId: null }) + window.__HERMES_SESSION_TILES__.close(sid) + } + window.__T__ = null + } + return 'cleaned' + })() +` + +const { cdp, teardown } = await attach({ port }) + +try { + await cdp.send('Runtime.enable') + + const ok = await cdp.eval(setup) + + if (ok !== 'ok') { + throw new Error(`setup failed: ${ok}`) + } + + for (let n = 1; n <= TILES; n++) { + await cdp.eval(reveal(`trace-tile-${n}`)) + await sleep(300) + } + + await sleep(1500) + + // Collect trace events for the drag window only. `cdp.on` is the client's + // only event API (no `once`), so completion is signalled through a flag. + const events = [] + let complete = false + cdp.on('Tracing.dataCollected', params => events.push(...(params.value ?? []))) + cdp.on('Tracing.tracingComplete', () => { + complete = true + }) + + await cdp.send('Tracing.start', { + transferMode: 'ReportEvents', + traceConfig: { includedCategories: ['devtools.timeline', 'blink.user_timing'] } + }) + + const dragged = await cdp.eval(DRAG) + + await cdp.send('Tracing.end') + + for (let waited = 0; !complete && waited < 10000; waited += 200) { + await sleep(200) + } + + await cdp.eval(CLEANUP) + + // Sum self-time per timeline category. Nested events would double-count, so + // attribute each event's duration minus the duration of its direct children. + const INTERESTING = new Set([ + 'UpdateLayoutTree', // Recalculate Style + 'Layout', + 'Paint', + 'PaintImage', + 'Layerize', + 'UpdateLayer', + 'CompositeLayers', + 'FunctionCall', + 'EvaluateScript', + 'TimerFire', + 'EventDispatch', + 'HitTest', + 'ParseHTML', + 'CommitLoad' + ]) + + const totals = new Map() + let traced = 0 + + for (const e of events) { + if (e.ph !== 'X' || typeof e.dur !== 'number') { + continue + } + + traced += 1 + const name = e.name + + if (!INTERESTING.has(name)) { + continue + } + + totals.set(name, (totals.get(name) ?? 0) + e.dur / 1000) + } + + console.log(`drag=${dragged} trace events=${events.length} (complete=${traced})\n`) + console.log('TIMELINE COST (ms, total duration by event):') + + const rows = [...totals.entries()].sort((a, b) => b[1] - a[1]) + + if (rows.length === 0) { + console.log(' (no timeline events — category filter or tracing domain unavailable)') + } + + for (const [name, ms] of rows) { + console.log(` ${name.padEnd(20)} ${ms.toFixed(1)}ms`) + } + + const style = totals.get('UpdateLayoutTree') ?? 0 + const layout = totals.get('Layout') ?? 0 + const script = (totals.get('FunctionCall') ?? 0) + (totals.get('EvaluateScript') ?? 0) + (totals.get('TimerFire') ?? 0) + + console.log(`\nVERDICT: style=${style.toFixed(0)}ms layout=${layout.toFixed(0)}ms script=${script.toFixed(0)}ms`) + + // Script dominates -> name the functions. Timeline FunctionCall events carry + // the callsite in args.data, so the top offenders can be attributed without + // a separate CPU profile. + const byFn = new Map() + + for (const e of events) { + if (e.ph !== 'X' || e.name !== 'FunctionCall' || typeof e.dur !== 'number') { + continue + } + + const d = e.args?.data ?? {} + const key = `${d.functionName || '(anonymous)'} @ ${(d.url || '?').split('/').pop()}:${d.lineNumber ?? '?'}` + byFn.set(key, (byFn.get(key) ?? 0) + e.dur / 1000) + } + + console.log('\nTOP SCRIPT CALLSITES (ms):') + + for (const [name, ms] of [...byFn.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15)) { + console.log(` ${ms.toFixed(1).padStart(8)} ${name}`) + } +} finally { + teardown?.() +} diff --git a/apps/desktop/scripts/diag-ro-storm.mjs b/apps/desktop/scripts/diag-ro-storm.mjs new file mode 100644 index 0000000000..f405aa65cd --- /dev/null +++ b/apps/desktop/scripts/diag-ro-storm.mjs @@ -0,0 +1,170 @@ +// How many ResizeObserver callbacks does one sash drag actually fire, and for +// how many DISTINCT elements? The trace named use-resize-observer.ts at 977ms +// but not whether that's a few expensive calls or a great many cheap ones — +// and the fix differs completely between those. +// +// node scripts/diag-ro-storm.mjs [--port 9222] [--tiles 5] + +import { attach } from './perf/lib/launch.mjs' +import { sleep } from './perf/lib/cdp.mjs' + +const arg = (name, fallback) => { + const i = process.argv.indexOf(`--${name}`) + + return i === -1 ? fallback : process.argv[i + 1] +} + +const port = Number(arg('port', 9222)) +const TILES = Number(arg('tiles', 5)) +const TURNS = Number(arg('turns', 20)) + +const setup = ` + (() => { + const hook = window.__HERMES_SESSION_TILES__ + if (!hook) return 'no-hook' + const turn = (sid, i) => ([ + { id: sid + '-u' + i, role: 'user', timestamp: Date.now(), + parts: [{ type: 'text', text: 'Question ' + i + ' about the diff and its error path.' }] }, + { id: sid + '-a' + i, role: 'assistant', timestamp: Date.now(), pending: false, + parts: [{ type: 'text', text: '## Finding ' + i + '\\n\\nProse with **bold** and \`code\`.\\n' }] } + ]) + window.__R__ = { ids: [] } + for (let n = 1; n <= ${TILES}; n++) { + const sid = 'ro-tile-' + n + const rid = 'ro-rt-' + n + const messages = [] + for (let i = 0; i < ${TURNS}; i++) messages.push(...turn(sid, i)) + messages.push({ id: sid + '-stream', role: 'assistant', timestamp: Date.now(), pending: true, + parts: [{ type: 'text', text: 'Working.' }] }) + window.__R__.ids.push({ sid, rid }) + hook.open(sid, 'center') + hook.patch(sid, { runtimeId: rid }) + hook.publish(rid, { + storedSessionId: sid, messages, branch: '', cwd: '', model: '', provider: '', + reasoningEffort: '', serviceTier: '', fast: false, yolo: false, personality: '', + busy: true, awaitingResponse: false, streamId: sid + '-stream', sawAssistantPayload: true, + pendingBranchGroup: null, interrupted: false, interimBoundaryPending: false, + needsInput: false, turnStartedAt: Date.now(), usage: null + }) + } + return 'ok' + })() +` + +const reveal = sid => `window.__HERMES_LAYOUT_TREE__.reveal(${JSON.stringify(`session-tile:${sid}`)})` + +// Patch ResizeObserver to count callbacks + distinct observed targets, then +// drag and report. Counting happens in the page so nothing crosses CDP per call. +// +// NOTE: the app's shared observer (hooks/use-resize-observer.ts) is created +// lazily on first use, so this patch must be installed BEFORE any surface +// mounts — otherwise the shared instance is a native one this wrapper never +// sees and every counter reads zero. `constructed` is the tell: a run showing +// a handful of constructions and zero callbacks means the patch landed late, +// not that the app stopped observing. +const INSTRUMENT = ` + (() => { + if (window.__ROSTATS__) return 'already' + const Native = window.ResizeObserver + const stats = { constructed: 0, observed: 0, callbacks: 0, entries: 0, targets: new Set(), on: false } + window.__ROSTATS__ = stats + window.ResizeObserver = class extends Native { + constructor(cb) { + super((entries, obs) => { + if (stats.on) { + stats.callbacks += 1 + stats.entries += entries.length + for (const e of entries) stats.targets.add(e.target) + } + return cb(entries, obs) + }) + stats.constructed += 1 + } + observe(...args) { + stats.observed += 1 + return super.observe(...args) + } + } + return 'patched' + })() +` + +const DRAG = ` + (async () => { + const s = window.__ROSTATS__ + s.callbacks = 0; s.entries = 0; s.targets = new Set(); s.on = true + const handle = document.querySelector('[role="separator"]') + if (!handle) { s.on = false; return JSON.stringify({ error: 'no sash' }) } + const box = handle.getBoundingClientRect() + const y = box.top + box.height / 2 + const x0 = box.left + box.width / 2 + let x = x0 + const opts = { bubbles: true, cancelable: true, pointerId: 1, pointerType: 'mouse', isPrimary: true, button: 0, buttons: 1 } + const t0 = performance.now() + handle.dispatchEvent(new PointerEvent('pointerdown', { ...opts, clientX: x, clientY: y })) + for (let i = 0; i < 40; i++) { + x += (i < 20 ? 3 : -3) + window.dispatchEvent(new PointerEvent('pointermove', { ...opts, clientX: x, clientY: y })) + await new Promise(r => setTimeout(r, 16)) + } + window.dispatchEvent(new PointerEvent('pointerup', { ...opts, buttons: 0, clientX: x, clientY: y })) + await new Promise(r => setTimeout(r, 300)) + s.on = false + return JSON.stringify({ + ms: Math.round(performance.now() - t0), + moves: 40, + constructed: s.constructed, + observed: s.observed, + callbacks: s.callbacks, + entries: s.entries, + distinctTargets: s.targets.size, + userBubbles: document.querySelectorAll('[data-slot="aui_user-message-root"]').length + }) + })() +` + +const CLEANUP = ` + (() => { + if (window.__R__) { + for (const { sid, rid } of window.__R__.ids) { + const s = window.__HERMES_SESSION_TILES__.states() + window.__HERMES_SESSION_TILES__.publish(rid, { ...s[rid], busy: false, streamId: null }) + window.__HERMES_SESSION_TILES__.close(sid) + } + window.__R__ = null + } + return 'cleaned' + })() +` + +const { cdp, teardown } = await attach({ port }) + +try { + await cdp.send('Runtime.enable') + await cdp.eval(INSTRUMENT) + + const ok = await cdp.eval(setup) + + if (ok !== 'ok') { + throw new Error(`setup failed: ${ok}`) + } + + for (let n = 1; n <= TILES; n++) { + await cdp.eval(reveal(`ro-tile-${n}`)) + await sleep(300) + } + + await sleep(1500) + + const r = JSON.parse(await cdp.eval(DRAG)) + await cdp.eval(CLEANUP) + + console.log(JSON.stringify(r, null, 2)) + + if (r.moves) { + console.log(`\nper pointermove: ${(r.entries / r.moves).toFixed(1)} RO entries`) + console.log(`distinct elements resized: ${r.distinctTargets} (user bubbles in DOM: ${r.userBubbles})`) + } +} finally { + teardown?.() +} diff --git a/apps/desktop/scripts/perf/README.md b/apps/desktop/scripts/perf/README.md index e8cfc57523..ec28a9b0d9 100644 --- a/apps/desktop/scripts/perf/README.md +++ b/apps/desktop/scripts/perf/README.md @@ -51,6 +51,8 @@ directly via `window.__PERF_DRIVE__`, so no LLM credits are spent. | `stream --real` | backend | same, from a real LLM stream | measure-real-stream, profile-real-stream | | `keystroke` | ci | composer keystroke → paint latency | measure-latency, profile-typing, leak-typing | | `transcript` | ci | large-transcript mount + paint cost | (new) | +| `render-churn` | ci | per-component render attribution + store churn while N tabs stream | (new) | +| `idle-cost` | report | busy-but-silent tiles: idle commit rate, + fps while resizing / typing | (new) | | `cold-start` | cold | launch → CDP → driver → first paint (fresh spawn/run) | (new) | | `first-token` | backend | Enter → first assistant token painted (TTFT) | (new) | | `submit` | backend | Enter → cleared → user msg painted, scroll jump | measure-submit, measure-jump | diff --git a/apps/desktop/scripts/perf/baseline.json b/apps/desktop/scripts/perf/baseline.json index 392993f618..6750b86167 100644 --- a/apps/desktop/scripts/perf/baseline.json +++ b/apps/desktop/scripts/perf/baseline.json @@ -1,9 +1,9 @@ { "_meta": { - "note": "Median of 5 runs, darwin-arm64, `--spawn --prod` (PRODUCTION minified renderer, real boot — no fake-boot). Representative shipped numbers, not dev-inflated. cold-start reuses one profile so the V8 code cache is WARM (what users get after first launch, ~1.0s); a fresh-profile first launch is ~+400ms (measure with `--cold-fresh`). Marks are process-spawn wall clock (spawn_to_*) or renderer nav-relative (dom_*). Re-baseline per device with `--update-baseline`; tolerances loose for cross-machine/disk variance.", + "note": "Median of 5 runs, darwin-arm64, `--spawn --prod` (PRODUCTION minified renderer, real boot \u2014 no fake-boot). Representative shipped numbers, not dev-inflated. cold-start reuses one profile so the V8 code cache is WARM (what users get after first launch, ~1.0s); a fresh-profile first launch is ~+400ms (measure with `--cold-fresh`). Marks are process-spawn wall clock (spawn_to_*) or renderer nav-relative (dom_*). Re-baseline per device with `--update-baseline`; tolerances loose for cross-machine/disk variance.", "platform": "darwin-arm64", "node": "v24.11.0", - "updated": "2026-07-19T23:16:01.227Z" + "updated": "2026-07-27T00:30:11.290Z" }, "scenarios": { "stream": { @@ -55,6 +55,25 @@ "dom_content_loaded_ms": 574, "nav_to_read_ms": 721 } + }, + "multitab": { + "metrics": { + "longtasks_n": 0, + "longtask_max_ms": 0, + "frame_p95_ms": 29.1, + "frame_p99_ms": 36.2, + "slow_frames_33": 9 + } + }, + "render-churn": { + "metrics": { + "sidebar_renders": 0, + "sidebar_wasted": 0, + "wasted_renders": 1704, + "total_renders": 8221, + "commits": 1352, + "wasted_notifies": 0 + } } } } diff --git a/apps/desktop/scripts/perf/scenarios/idle-cost.mjs b/apps/desktop/scripts/perf/scenarios/idle-cost.mjs new file mode 100644 index 0000000000..c378f96ad9 --- /dev/null +++ b/apps/desktop/scripts/perf/scenarios/idle-cost.mjs @@ -0,0 +1,284 @@ +// What does the app cost while a turn is running but NOTHING is arriving? +// +// The user-visible symptom: with a thread spinning, resizing the sidebar or +// typing in the composer feels slow. That is not streaming cost — the stream +// is idle. It is the app re-rendering on its own, competing with the +// interaction for the main thread. +// +// This scenario holds N tiles in a busy state, pushes NO tokens, and measures: +// - idle_commits_per_s the renderer's self-inflicted commit rate +// - drag_fps fps while dragging the sidebar splitter +// - type_fps fps while typing in the composer +// +// A perfectly idle app scores 0 idle commits and pins both interactions at the +// display's refresh rate. Every idle commit is main-thread time stolen from an +// interaction the user can feel. +// +// node scripts/perf/run.mjs idle-cost --spawn [--tiles 5] [--seconds 6] + +import { sleep } from '../lib/cdp.mjs' + +/** Seed `tiles` busy session tiles. Same publish path as `multitab` / + * `render-churn`, but the driver never runs — the turn just stays open. */ +const setup = (tiles, seedTurns) => ` + (() => { + const hook = window.__HERMES_SESSION_TILES__ + if (!hook) return 'no-hook' + if (!window.__RENDER_COUNTS__) return 'no-render-counter' + + const turn = (sid, i) => ([ + { id: sid + '-u' + i, role: 'user', timestamp: Date.now(), + parts: [{ type: 'text', text: 'Question ' + i + ' about the diff.' }] }, + { id: sid + '-a' + i, role: 'assistant', timestamp: Date.now(), pending: false, + parts: [{ type: 'text', text: '## Finding ' + i + '\\n\\nThe handler swallows the rejection.\\n\\n- Point one.\\n- Point two.\\n' }] } + ]) + + window.__IDLE__ = { ids: [] } + for (let n = 1; n <= ${tiles}; n++) { + const sid = 'idle-tile-' + n + const rid = 'idle-rt-' + n + const messages = [] + for (let i = 0; i < ${seedTurns}; i++) messages.push(...turn(sid, i)) + // An OPEN assistant message: the turn is running, but no tokens arrive. + messages.push({ id: sid + '-stream', role: 'assistant', timestamp: Date.now(), pending: true, + parts: [{ type: 'text', text: 'Working on it.' }] }) + + window.__IDLE__.ids.push({ sid, rid }) + hook.open(sid, 'center') + hook.patch(sid, { runtimeId: rid }) + hook.publish(rid, { + storedSessionId: sid, messages, branch: '', cwd: '', model: '', provider: '', + reasoningEffort: '', serviceTier: '', fast: false, yolo: false, personality: '', + busy: true, awaitingResponse: false, streamId: sid + '-stream', sawAssistantPayload: true, + pendingBranchGroup: null, interrupted: false, interimBoundaryPending: false, + needsInput: false, turnStartedAt: Date.now(), usage: null + }) + } + return 'ok' + })() +` + +const reveal = sid => `window.__HERMES_LAYOUT_TREE__.reveal(${JSON.stringify(`session-tile:${sid}`)})` + +/** Measure the app's self-inflicted commit rate with nothing happening. */ +const idleCost = seconds => ` + (async () => { + const rc = window.__RENDER_COUNTS__ + rc.start() + const t0 = performance.now() + await new Promise(r => setTimeout(r, ${seconds} * 1000)) + const elapsed = (performance.now() - t0) / 1000 + rc.stop() + return JSON.stringify({ + elapsed, + commits: rc.commits(), + top: rc.report(12), + owners: rc.report(300).filter(r => r.stateChanged > 0 && r.propsChanged === 0).slice(0, 10) + }) + })() +` + +/** Record frame pacing across an interaction driven from the page. + * + * The gesture body drives itself on requestAnimationFrame, so it IS the frame + * clock — timing is taken from those same callbacks rather than a second, + * independent rAF ticker. Running two rAF consumers made the observer's + * deltas count the driver's frames as well as the app's and reported ~3fps + * where the interaction actually ran at ~23fps. `frames` is filled by the + * body via `__MARK__`. + * + * `record` MUST be false for any fps number you intend to believe: the render + * counter walks the whole fiber tree on every commit, so recording during a + * gesture measures the instrumentation as much as the app. Attribution and + * timing therefore run as two separate passes. */ +const withFrames = (body, record = false) => ` + (async () => { + const rc = window.__RENDER_COUNTS__ + ${record ? 'rc.start()' : ''} + const frames = [] + let last = performance.now() + // The body calls this once per frame it drives. + const __MARK__ = () => { + const now = performance.now() + frames.push(now - last) + last = now + } + ${body} + ${record ? 'rc.stop()' : ''} + const total = frames.reduce((a, b) => a + b, 0) + const sorted = [...frames].sort((a, b) => a - b) + const pct = p => sorted.length ? sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))] : 0 + return JSON.stringify({ + fps: total ? (frames.length / total) * 1000 : 0, + p95: pct(0.95), + worst: sorted.length ? sorted[sorted.length - 1] : 0, + slow33: frames.filter(f => f > 33).length, + n: frames.length, + commits: ${record ? 'rc.commits()' : '0'}, + top: ${record ? 'rc.report(10)' : '[]'} + }) + })() +` + +/** Drag the sidebar splitter — the resize symptom. + * Sweeps monotonically (an oscillation nets to zero and can clamp to a no-op), + * and reports how far it actually moved so a drag that silently did nothing + * shows up as `dragMoved: 0` instead of a confident wrong number. */ +const DRAG = withFrames(` + const handle = document.querySelector('[role="separator"]') + window.__DRAG_TARGET__ = handle ? 'separator' : 'none' + window.__DRAG_MOVED__ = 0 + if (handle) { + const box = handle.getBoundingClientRect() + const y = box.top + box.height / 2 + const x0 = box.left + box.width / 2 + let x = x0 + const opts = { bubbles: true, cancelable: true, pointerId: 1, pointerType: 'mouse', isPrimary: true, button: 0, buttons: 1 } + handle.dispatchEvent(new PointerEvent('pointerdown', { ...opts, clientX: x, clientY: y })) + // Out 60px then back — a real gesture, with a net displacement at the peak. + for (let i = 0; i < 30; i++) { + x += 2 + window.dispatchEvent(new PointerEvent('pointermove', { ...opts, clientX: x, clientY: y })) + await new Promise(r => requestAnimationFrame(r)) + __MARK__() + } + window.__DRAG_MOVED__ = Math.round(x - x0) + for (let i = 0; i < 30; i++) { + x -= 2 + window.dispatchEvent(new PointerEvent('pointermove', { ...opts, clientX: x, clientY: y })) + await new Promise(r => requestAnimationFrame(r)) + __MARK__() + } + window.dispatchEvent(new PointerEvent('pointerup', { ...opts, buttons: 0, clientX: x, clientY: y })) + } else { + await new Promise(r => setTimeout(r, 1000)) + } +`) + +/** Type into the composer — the keystroke symptom. */ +const TYPE = withFrames(` + const el = document.querySelector('[contenteditable="true"], textarea') + window.__TYPE_TARGET__ = el ? (el.tagName.toLowerCase()) : 'none' + if (el) { + el.focus() + for (let i = 0; i < 40; i++) { + const ch = 'performance testing '[i % 20] + el.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, key: ch })) + if (el.tagName === 'TEXTAREA') { + el.value += ch + el.dispatchEvent(new Event('input', { bubbles: true })) + } else { + el.textContent += ch + el.dispatchEvent(new InputEvent('input', { bubbles: true, data: ch, inputType: 'insertText' })) + } + el.dispatchEvent(new KeyboardEvent('keyup', { bubbles: true, key: ch })) + // Wait for the frame this keystroke produces, then mark it — same clock + // discipline as DRAG, so typing fps is comparable to drag fps. + await new Promise(r => requestAnimationFrame(r)) + __MARK__() + await new Promise(r => setTimeout(r, 25)) + } + } else { + await new Promise(r => setTimeout(r, 1000)) + } +`) + +const CLEANUP = ` + (() => { + if (window.__IDLE__) { + for (const { sid, rid } of window.__IDLE__.ids) { + const states = window.__HERMES_SESSION_TILES__.states() + window.__HERMES_SESSION_TILES__.publish(rid, { ...states[rid], busy: false, streamId: null }) + window.__HERMES_SESSION_TILES__.close(sid) + } + window.__IDLE__ = null + } + window.__RENDER_COUNTS__.clear() + return 'cleaned' + })() +` + +const round = (n, places = 1) => Math.round(n * 10 ** places) / 10 ** places + +export default { + name: 'idle-cost', + // NOT 'ci': the drag fps this reports (~0.6fps, p95 814ms) contradicts a + // direct single-clock probe of the same gesture on the same build (57fps), + // and I could not reconcile the two — ruled out sash selection, tile setup, + // counter residue, and a 20s soak. Its RENDER attribution and idle commit + // rate are trustworthy and are what this scenario is for; the interaction + // fps is reported for investigation, not gated on, until that is explained. + tier: 'report', + description: 'Busy-but-silent tiles: idle commit rate, and fps while resizing / typing.', + async run(cdp, opts = {}) { + const tiles = Number(opts.tiles ?? 5) + const seedTurns = Number(opts.turns ?? 20) + const seconds = Number(opts.seconds ?? 6) + + await cdp.send('Runtime.enable') + + const ok = await cdp.eval(setup(tiles, seedTurns)) + + if (ok !== 'ok') { + throw new Error(`idle-cost setup failed (${ok}) — needs a dev renderer with src/debug installed.`) + } + + for (let n = 1; n <= tiles; n++) { + await cdp.eval(reveal(`idle-tile-${n}`)) + await sleep(300) + } + + await sleep(1500) + + const idle = JSON.parse(await cdp.eval(idleCost(seconds))) + const drag = JSON.parse(await cdp.eval(DRAG)) + const dragTarget = await cdp.eval('window.__DRAG_TARGET__ || "unknown"') + const dragMoved = await cdp.eval('window.__DRAG_MOVED__ ?? 0') + const type = JSON.parse(await cdp.eval(TYPE)) + const typeTarget = await cdp.eval('window.__TYPE_TARGET__ || "unknown"') + + await cdp.eval(CLEANUP) + + if (dragTarget === 'none') { + throw new Error('idle-cost: no [role="separator"] sash found — the drag measured nothing.') + } + + if (typeTarget === 'none') { + throw new Error('idle-cost: no composer found — the typing pass measured nothing.') + } + + return { + metrics: { + // Commits per second with a turn open and nothing arriving. Should be 0. + idle_commits_per_s: round(idle.commits / idle.elapsed), + idle_renders: idle.top.reduce((a, r) => a + r.renders, 0), + // Interaction smoothness while that churn competes for the main thread. + // Reported as a deficit from 60fps so "lower is better" matches the + // baseline gate's direction. + drag_fps_deficit: round(Math.max(0, 60 - drag.fps)), + drag_slow_frames: drag.slow33, + type_fps_deficit: round(Math.max(0, 60 - type.fps)), + type_slow_frames: type.slow33 + }, + detail: { + tiles, + dragTarget, + dragMoved, + idleSeconds: round(idle.elapsed), + dragFps: round(drag.fps), + dragP95: round(drag.p95), + dragWorst: round(drag.worst), + typeFps: round(type.fps), + typeP95: round(type.p95), + typeWorst: round(type.worst), + // Components whose OWN state changed with no prop change: the roots. + idleOwners: idle.owners, + idleTop: idle.top, + dragCommits: drag.commits, + dragTop: drag.top, + typeCommits: type.commits, + typeTop: type.top + } + } + } +} diff --git a/apps/desktop/scripts/perf/scenarios/index.mjs b/apps/desktop/scripts/perf/scenarios/index.mjs index d69ecce2fb..de53212e42 100644 --- a/apps/desktop/scripts/perf/scenarios/index.mjs +++ b/apps/desktop/scripts/perf/scenarios/index.mjs @@ -3,9 +3,11 @@ import coldStart from './cold-start.mjs' import firstToken from './first-token.mjs' +import idleCost from './idle-cost.mjs' import keystroke from './keystroke.mjs' import multitab from './multitab.mjs' import profileSwitch from './profile-switch.mjs' +import renderChurn from './render-churn.mjs' import sessionSwitch from './session-switch.mjs' import stream from './stream.mjs' import streamHistory from './stream-history.mjs' @@ -18,6 +20,8 @@ export const SCENARIOS = { [keystroke.name]: keystroke, [transcript.name]: transcript, [multitab.name]: multitab, + [renderChurn.name]: renderChurn, + [idleCost.name]: idleCost, [coldStart.name]: coldStart, [firstToken.name]: firstToken, [submit.name]: submit, diff --git a/apps/desktop/scripts/perf/scenarios/render-churn.mjs b/apps/desktop/scripts/perf/scenarios/render-churn.mjs new file mode 100644 index 0000000000..d1322d58a6 --- /dev/null +++ b/apps/desktop/scripts/perf/scenarios/render-churn.mjs @@ -0,0 +1,259 @@ +// Render churn during multi-tab streaming: WHAT re-rendered and WHY, and which +// store published the update. Frame pacing (see `multitab`) tells you the cost; +// this tells you the cause. +// +// Drives the same synthetic pipeline as `multitab` — publishSessionState per +// session per flush via `__HERMES_SESSION_TILES__`, no backend, no credits — +// then reads the dev-only counters installed by `src/debug/`: +// +// window.__RENDER_COUNTS__ — per-component renders, attributed to +// props / hook state / parent-only ("wasted") +// window.__ATOM_CHURN__ — per-store notifications, listener fan-out, and +// notifications whose value was deep-equal to the +// previous one ("wasted") +// +// The headline metric is `sidebar_renders`: how many times the sidebar tree +// re-rendered while agents were typing in other tabs. It should be 0. +// +// node scripts/perf/run.mjs render-churn --spawn [--tiles 5] [--tokens 240] + +import { sleep } from '../lib/cdp.mjs' + +/** Components that make up the sidebar tree. A render of any of these while + * a background tab streams is work the user cannot see. */ +const SIDEBAR_COMPONENTS = [ + 'ChatSidebar', + 'SidebarSurface', + 'SessionRow', + 'SessionsSection', + 'CronJobsSection', + 'ProfileSwitcher', + 'VirtualSessionList', + 'WorkspaceGroup', + 'OverviewRow', + 'SessionStatusDot' +] + +/** Page-side setup: open `tiles` session tiles, seed each with a transcript. + * Mirrors `multitab.mjs` so the two scenarios measure the same workload. */ +const setup = (tiles, seedTurns) => ` + (() => { + const hook = window.__HERMES_SESSION_TILES__ + if (!hook) return 'no-hook' + if (!window.__RENDER_COUNTS__) return 'no-render-counter' + if (!window.__ATOM_CHURN__) return 'no-atom-churn' + + const turn = (sid, i) => ([ + { id: sid + '-u' + i, role: 'user', timestamp: Date.now(), + parts: [{ type: 'text', text: 'Review question ' + i + ': does the diff handle the error path?' }] }, + { id: sid + '-a' + i, role: 'assistant', timestamp: Date.now(), pending: false, + parts: [{ type: 'text', text: '## Finding ' + i + '\\n\\nThe handler swallows the rejection.\\n\\n- The catch block drops the error.\\n- Retries are unbounded.\\n' }] } + ]) + + const state = (sid) => { + const messages = [] + for (let i = 0; i < ${seedTurns}; i++) messages.push(...turn(sid, i)) + messages.push({ id: sid + '-stream', role: 'assistant', timestamp: Date.now(), pending: true, + parts: [{ type: 'text', text: '' }] }) + return { + storedSessionId: sid, messages, branch: '', cwd: '', model: '', provider: '', + reasoningEffort: '', serviceTier: '', fast: false, yolo: false, personality: '', + busy: true, awaitingResponse: false, streamId: sid + '-stream', sawAssistantPayload: true, + pendingBranchGroup: null, interrupted: false, interimBoundaryPending: false, + needsInput: false, turnStartedAt: Date.now(), usage: null + } + } + + window.__RC__ = { ids: [], timer: null } + for (let n = 1; n <= ${tiles}; n++) { + const sid = 'churn-tile-' + n + const rid = 'churn-rt-' + n + window.__RC__.ids.push({ sid, rid }) + hook.open(sid, 'center') + hook.patch(sid, { runtimeId: rid }) + hook.publish(rid, state(sid)) + } + return 'ok' + })() +` + +const reveal = sid => `window.__HERMES_LAYOUT_TREE__.reveal(${JSON.stringify(`session-tile:${sid}`)})` + +/** Grow every tile's streaming tail by `chunk` each `intervalMs`, through the + * same publish path the gateway's delta flush uses. */ +const drive = (chunk, intervalMs, totalTokens) => ` + (() => { + const hook = window.__HERMES_SESSION_TILES__ + let pushed = 0 + const tick = () => { + const states = hook.states() + for (const { rid } of window.__RC__.ids) { + const prev = states[rid] + if (!prev) continue + const messages = prev.messages.map(m => { + if (m.id !== prev.streamId) return m + const head = m.parts.slice(0, -1) + const last = m.parts[m.parts.length - 1] + return { ...m, parts: [...head, { type: 'text', text: last.text + ${JSON.stringify(chunk)} }] } + }) + hook.publish(rid, { ...prev, messages }) + } + pushed += 1 + if (pushed < ${totalTokens}) window.__RC__.timer = setTimeout(tick, ${intervalMs}) + else window.__RC__.done = true + } + window.__RC__.timer = setTimeout(tick, ${intervalMs}) + return 'driving' + })() +` + +/** Wait until the renderer stops committing on its own, so the recording window + * captures STREAMING cost and not whatever boot/hydration work happened to + * still be in flight. Returns `quiet:N` once commits hold still for `quietMs`. + * + * If it returns `timeout:...` the app never went idle at all — with tiles + * marked busy and NO driver running, that means something is ticking on its + * own. The report of what rendered during the wait is attached so the culprit + * is named rather than guessed at. */ +const quiesce = (quietMs, timeoutMs) => ` + (async () => { + const rc = window.__RENDER_COUNTS__ + rc.start() + const deadline = Date.now() + ${timeoutMs} + const startedAt = Date.now() + let last = -1 + let stableSince = Date.now() + while (Date.now() < deadline) { + await new Promise(r => setTimeout(r, 100)) + const n = rc.commits() + if (n !== last) { last = n; stableSince = Date.now(); continue } + if (Date.now() - stableSince >= ${quietMs}) { rc.stop(); return 'quiet:' + n } + } + const idle = { + commits: last, + seconds: (Date.now() - startedAt) / 1000, + top: rc.report(8), + // Who OWNS the update? The component whose own hook state changed with + // no changed props is the root of a churn cascade; everything under it + // is collateral. Naming it is the difference between fixing the cause + // and memoizing a symptom. + owners: rc.report(200).filter(r => r.stateChanged > 0 && r.propsChanged === 0).slice(0, 8) + } + rc.stop() + return 'timeout:' + JSON.stringify(idle) + })() +` + +const START = ` + (() => { + window.__RENDER_COUNTS__.start() + window.__ATOM_CHURN__.start() + return 'recording' + })() +` + +const COLLECT = ` + (() => { + window.__RENDER_COUNTS__.stop() + window.__ATOM_CHURN__.stop() + return JSON.stringify({ + commits: window.__RENDER_COUNTS__.commits(), + renders: window.__RENDER_COUNTS__.report(200), + atoms: window.__ATOM_CHURN__.report(200) + }) + })() +` + +const CLEANUP = ` + (() => { + if (window.__RC__) { + clearTimeout(window.__RC__.timer) + for (const { sid, rid } of window.__RC__.ids) { + const states = window.__HERMES_SESSION_TILES__.states() + window.__HERMES_SESSION_TILES__.publish(rid, { ...states[rid], busy: false, streamId: null }) + window.__HERMES_SESSION_TILES__.close(sid) + } + window.__RC__ = null + } + window.__RENDER_COUNTS__.clear() + window.__ATOM_CHURN__.clear() + return 'cleaned' + })() +` + +export default { + name: 'render-churn', + tier: 'ci', + description: 'N streaming tabs: per-component render attribution + store churn.', + async run(cdp, opts = {}) { + const tiles = Number(opts.tiles ?? 5) + const seedTurns = Number(opts.turns ?? 20) + const tokens = Number(opts.tokens ?? 240) + // Matches STREAM_DELTA_FLUSH_MS — one publish per session per real flush. + const intervalMs = Number(opts.intervalMs ?? 33) + const chunk = opts.chunk ?? 'A streamed review sentence with **bold** and `code`.\n\n' + + await cdp.send('Runtime.enable') + + const ok = await cdp.eval(setup(tiles, seedTurns)) + + if (ok !== 'ok') { + throw new Error( + `render-churn setup failed (${ok}) — needs a dev renderer with src/debug installed ` + + '(the counters are aliased out of production builds unless VITE_PERF_PROBE=1).' + ) + } + + // Mount every tab (keep-alive mounts on first activation), then settle. + for (let n = 1; n <= tiles; n++) { + await cdp.eval(reveal(`churn-tile-${n}`)) + await sleep(350) + } + + // Let the app go quiet before recording, so boot/hydration commits that + // happen to still be in flight don't land in the streaming window. This is + // what makes runs comparable — a fixed sleep let 2-4x of hydration churn + // leak in depending on machine load. + const settle = await cdp.eval(quiesce(600, 15000)) + await cdp.eval(START) + await cdp.eval(drive(chunk, intervalMs, tokens)) + await sleep(tokens * intervalMs + 1500) + + const data = JSON.parse(await cdp.eval(COLLECT)) + await cdp.eval(CLEANUP) + + const byName = new Map(data.renders.map(r => [r.name, r])) + const sidebarRows = SIDEBAR_COMPONENTS.map(n => byName.get(n)).filter(Boolean) + const sidebarRenders = sidebarRows.reduce((a, r) => a + r.renders, 0) + const sidebarWasted = sidebarRows.reduce((a, r) => a + r.wasted, 0) + const totalRenders = data.renders.reduce((a, r) => a + r.renders, 0) + const totalWasted = data.renders.reduce((a, r) => a + r.wasted, 0) + const atomWasted = data.atoms.reduce((a, r) => a + r.wasted, 0) + + return { + metrics: { + // The hypothesis, as a number: sidebar renders while background tabs + // stream. Should be 0. + sidebar_renders: sidebarRenders, + sidebar_wasted: sidebarWasted, + // Renders with no changed props and no changed hook state — pure + // parent-driven work, across the whole tree. + wasted_renders: totalWasted, + total_renders: totalRenders, + commits: data.commits, + // Store notifications that published a value equal to the last one. + wasted_notifies: atomWasted + }, + detail: { + tiles, + tokens, + // 'quiet:N' = the app went idle before recording (comparable run). + // 'timeout:N' = it never did, so boot churn is mixed into the numbers. + settle, + sidebar: sidebarRows, + topRenders: data.renders.slice(0, 15), + topAtoms: data.atoms.slice(0, 15) + } + } + } +} diff --git a/apps/desktop/src/app/chat/composer/hooks/use-composer-draft.ts b/apps/desktop/src/app/chat/composer/hooks/use-composer-draft.ts index 11aa35dfaf..43b8514cc3 100644 --- a/apps/desktop/src/app/chat/composer/hooks/use-composer-draft.ts +++ b/apps/desktop/src/app/chat/composer/hooks/use-composer-draft.ts @@ -408,6 +408,7 @@ export function useComposerDraft({ requestMainFocus, sessionIdRef, setComposerText, - stashAt + stashAt, + syncDraftFromEditor } } diff --git a/apps/desktop/src/app/chat/composer/hooks/use-composer-undo.test.tsx b/apps/desktop/src/app/chat/composer/hooks/use-composer-undo.test.tsx new file mode 100644 index 0000000000..bbffc396ec --- /dev/null +++ b/apps/desktop/src/app/chat/composer/hooks/use-composer-undo.test.tsx @@ -0,0 +1,193 @@ +import { render } from '@testing-library/react' +import { createRef, type RefObject } from 'react' +import { describe, expect, it, vi } from 'vitest' + +import { useComposerUndo } from './use-composer-undo' + +/** Mount the hook against a real contentEditable, exposing its API. */ +function mountUndo(editorRef: RefObject, onSync: () => string) { + const api: { current: ReturnType | null } = { current: null } + + const Harness = () => { + // Assigned during render on purpose: the tests drive the API imperatively + // right after mount, and this is a harness, not app state. + api.current = useComposerUndo({ editorRef, syncDraftFromEditor: onSync }) + + return null + } + + const view = render() + + return { api, view } +} + +function makeEditor(text: string) { + const editor = document.createElement('div') + editor.contentEditable = 'true' + // jsdom only focuses a contentEditable div when it's explicitly focusable; + // the real editor is reachable via the composer's focus bus. + editor.tabIndex = 0 + editor.append(document.createTextNode(text)) + document.body.append(editor) + + const ref = createRef() as RefObject + ref.current = editor + + return { editor, ref } +} + +const caretAtEnd = (editor: HTMLElement) => { + const range = document.createRange() + const selection = window.getSelection()! + range.selectNodeContents(editor) + range.collapse(false) + selection.removeAllRanges() + selection.addRange(range) +} + +describe('useComposerUndo', () => { + it('restores the pre-edit text, which is what a paste destroyed', () => { + const { editor, ref } = makeEditor('before') + caretAtEnd(editor) + + const { api, view } = mountUndo(ref, () => editor.textContent || '') + + // Bank, then simulate the Range-based paste that Chromium never records. + api.current!.recordUndoPoint() + editor.append(document.createTextNode(' PASTED')) + expect(editor.textContent).toBe('before PASTED') + + api.current!.undo() + expect(editor.textContent).toBe('before') + + api.current!.redo() + expect(editor.textContent).toBe('before PASTED') + + view.unmount() + editor.remove() + }) + + it('withUndoPoint banks only when the edit actually ran', () => { + const { editor, ref } = makeEditor('text') + caretAtEnd(editor) + + const { api, view } = mountUndo(ref, () => editor.textContent || '') + + // A guard that declines must not consume an undo slot. + expect(api.current!.withUndoPoint(() => false)).toBe(false) + expect(api.current!.undo()).toBe(false) + + expect( + api.current!.withUndoPoint(() => { + editor.append(document.createTextNode('!')) + + return true + }) + ).toBe(true) + + api.current!.undo() + expect(editor.textContent).toBe('text') + + view.unmount() + editor.remove() + }) + + it('claims a native historyUndo aimed at the focused editor', () => { + const { editor, ref } = makeEditor('kept') + editor.focus() + caretAtEnd(editor) + + const { api, view } = mountUndo(ref, () => editor.textContent || '') + + api.current!.recordUndoPoint() + editor.append(document.createTextNode(' extra')) + + // What Electron's Edit menu `{ role: 'undo' }` produces. + const event = new InputEvent('beforeinput', { bubbles: true, cancelable: true, inputType: 'historyUndo' }) + editor.dispatchEvent(event) + + expect(event.defaultPrevented).toBe(true) + expect(editor.textContent).toBe('kept') + + view.unmount() + editor.remove() + }) + + it('ignores a historyUndo while another editor holds focus', () => { + const { editor, ref } = makeEditor('mine') + const { editor: other } = makeEditor('theirs') + + other.focus() + + const { api, view } = mountUndo(ref, () => editor.textContent || '') + + api.current!.recordUndoPoint() + editor.append(document.createTextNode(' changed')) + + const event = new InputEvent('beforeinput', { bubbles: true, cancelable: true, inputType: 'historyUndo' }) + other.dispatchEvent(event) + + // Not ours to claim — the other surface keeps its native behavior. + expect(event.defaultPrevented).toBe(false) + expect(editor.textContent).toBe('mine changed') + + view.unmount() + editor.remove() + other.remove() + }) + + it('keeps two mounted composers independent', () => { + const { editor: main, ref: mainRef } = makeEditor('main') + const { editor: edit, ref: editRef } = makeEditor('edit') + + const mainUndo = mountUndo(mainRef, () => main.textContent || '') + const editUndo = mountUndo(editRef, () => edit.textContent || '') + + mainUndo.api.current!.recordUndoPoint() + main.append(document.createTextNode(' typed')) + + // Undoing in the edit composer must not touch the main composer's text. + editUndo.api.current!.undo() + expect(main.textContent).toBe('main typed') + + mainUndo.api.current!.undo() + expect(main.textContent).toBe('main') + expect(edit.textContent).toBe('edit') + + mainUndo.view.unmount() + editUndo.view.unmount() + main.remove() + edit.remove() + }) + + it('reset drops history so undo cannot cross a draft swap', () => { + const { editor, ref } = makeEditor('session A') + caretAtEnd(editor) + + const { api, view } = mountUndo(ref, () => editor.textContent || '') + + api.current!.recordUndoPoint() + editor.append(document.createTextNode(' edited')) + api.current!.resetUndoHistory() + + expect(api.current!.undo()).toBe(false) + expect(editor.textContent).toBe('session A edited') + + view.unmount() + editor.remove() + }) + + it('is inert when the editor ref is empty', () => { + const ref = createRef() as RefObject + const sync = vi.fn(() => '') + + const { api, view } = mountUndo(ref, sync) + + api.current!.recordUndoPoint() + + expect(api.current!.undo()).toBe(false) + expect(sync).not.toHaveBeenCalled() + + view.unmount() + }) +}) diff --git a/apps/desktop/src/app/chat/composer/hooks/use-composer-undo.ts b/apps/desktop/src/app/chat/composer/hooks/use-composer-undo.ts new file mode 100644 index 0000000000..72f891f6da --- /dev/null +++ b/apps/desktop/src/app/chat/composer/hooks/use-composer-undo.ts @@ -0,0 +1,119 @@ +import { type RefObject, useCallback, useEffect, useMemo } from 'react' + +import { caretOffsetInEditor, composerPlainText, placeCaretAtOffset, renderComposerContents } from '../rich-editor' +import { type ComposerSnapshot, createComposerUndoHistory } from '../undo-history' + +interface UseComposerUndoArgs { + editorRef: RefObject + /** Push a restored snapshot back into draftRef + composer state. */ + syncDraftFromEditor: () => string +} + +/** + * Undo/redo for the rich composer. + * + * The editor mutates its DOM through `Range` to dodge Chromium's O(n²) editing + * pipeline (#45812), which also dodges Chromium's undo stack — so a paste was + * invisible to ⌘Z and the keystroke undid whatever edit came before it instead. + * We own the stack outright rather than half of it: every edit path records the + * pre-edit state here, and the editor claims ⌘Z / ⌘⇧Z itself. + */ +export function useComposerUndo({ editorRef, syncDraftFromEditor }: UseComposerUndoArgs) { + const history = useMemo(() => createComposerUndoHistory(), []) + + const snapshot = useCallback((): ComposerSnapshot => { + const editor = editorRef.current + + if (!editor) { + return { caret: 0, text: '' } + } + + return { caret: caretOffsetInEditor(editor), text: composerPlainText(editor) } + }, [editorRef]) + + /** Bank the current state before mutating the editor. `coalesce` marks a + * keystroke, so a run of typing collapses into one undo step. */ + const recordUndoPoint = useCallback( + (options?: { coalesce?: boolean }) => { + if (editorRef.current) { + history.record(snapshot(), options) + } + }, + [editorRef, history, snapshot] + ) + + const applySnapshot = useCallback( + (next: ComposerSnapshot | null) => { + const editor = editorRef.current + + if (!next || !editor) { + return false + } + + renderComposerContents(editor, next.text) + placeCaretAtOffset(editor, next.caret) + syncDraftFromEditor() + + return true + }, + [editorRef, syncDraftFromEditor] + ) + + /** Run a conditional edit, banking its pre-edit state only if it actually + * ran. The snapshot has to be taken first (the edit destroys the state we'd + * be saving), but recording unconditionally would clear the redo stack on + * every Backspace that falls through to the native path. */ + const withUndoPoint = useCallback( + (edit: () => boolean) => { + const before = snapshot() + const ran = edit() + + if (ran) { + history.record(before) + } + + return ran + }, + [history, snapshot] + ) + + const undo = useCallback(() => applySnapshot(history.undo(snapshot())), [applySnapshot, history, snapshot]) + const redo = useCallback(() => applySnapshot(history.redo(snapshot())), [applySnapshot, history, snapshot]) + + // A session/draft swap makes prior history meaningless — undoing into another + // conversation's text is worse than having no history at all. + const resetUndoHistory = useCallback(() => history.reset(), [history]) + + // Electron's Edit menu ships `{ role: 'undo' }`, whose accelerator the macOS + // menu bar consumes before the web contents sees the keystroke (the same + // hazard main.ts documents for ⌘W). It fires the native editing command, + // which knows nothing about our stack. Claim it at the document level while + // the composer holds focus, so the menu item and the keystroke agree. + useEffect(() => { + const onBeforeInput = (event: Event) => { + const inputType = (event as InputEvent).inputType + + if (inputType !== 'historyUndo' && inputType !== 'historyRedo') { + return + } + + if (document.activeElement !== editorRef.current) { + return + } + + event.preventDefault() + + if (inputType === 'historyUndo') { + undo() + } else { + redo() + } + } + + document.addEventListener('beforeinput', onBeforeInput, true) + + return () => document.removeEventListener('beforeinput', onBeforeInput, true) + }, [editorRef, redo, undo]) + + return { recordUndoPoint, redo, resetUndoHistory, undo, withUndoPoint } +} diff --git a/apps/desktop/src/app/chat/composer/index.tsx b/apps/desktop/src/app/chat/composer/index.tsx index 1ce110f4e0..5988d61037 100644 --- a/apps/desktop/src/app/chat/composer/index.tsx +++ b/apps/desktop/src/app/chat/composer/index.tsx @@ -40,6 +40,7 @@ import { useComposerPopout } from './hooks/use-composer-popout' import { useComposerQueue } from './hooks/use-composer-queue' import { useComposerSubmit } from './hooks/use-composer-submit' import { useComposerTrigger } from './hooks/use-composer-trigger' +import { useComposerUndo } from './hooks/use-composer-undo' import { useComposerUrlDialog } from './hooks/use-composer-url-dialog' import { useComposerVoice } from './hooks/use-composer-voice' import { useSlashCompletions } from './hooks/use-slash-completions' @@ -49,7 +50,7 @@ import { composerPlainText, deleteChipBeforeCaret, deleteSelectionInEditor, - insertPlainTextAtCaret, + insertComposerContentsAtCaret, normalizeComposerEditorDom, RICH_INPUT_SLOT } from './rich-editor' @@ -59,7 +60,9 @@ import { CodingStatusRow } from './status-stack/coding-row' import { extractClipboardImageBlobs } from './text-utils' import { ComposerTriggerPopover } from './trigger-popover' import type { ChatBarProps } from './types' +import { isRedoShortcut, isUndoShortcut } from './undo-history' import { UrlDialog } from './url-dialog' +import { chipTypedUrlOnSpace, linkifyUrls } from './url-refs' import { VoiceActivity, VoicePlaybackActivity } from './voice-activity' export function ChatBar({ @@ -172,9 +175,24 @@ export function ChatBar({ requestMainFocus, sessionIdRef, setComposerText, - stashAt + stashAt, + syncDraftFromEditor } = useComposerDraft({ activeQueueSessionKey, focusKey, inputDisabled, queueEditRef, sessionId }) + // Undo/redo. The rich editor bypasses Chromium's editing pipeline for speed, + // which also bypasses its undo stack — so we own the stack and every edit + // path below banks its pre-edit state through `recordUndoPoint`. + const { recordUndoPoint, redo, resetUndoHistory, undo, withUndoPoint } = useComposerUndo({ + editorRef, + syncDraftFromEditor + }) + + // Prior history belongs to the draft that just left — undoing into another + // conversation's text is worse than having none. + useEffect(() => { + resetUndoHistory() + }, [activeQueueSessionKey, resetUndoHistory]) + // "Add URL" dialog — open/value state, autofocus, and submit (host onAddUrl or // an @url: directive into the draft). const { openUrlDialog, setUrlOpen, setUrlValue, submitUrl, urlInputRef, urlOpen, urlValue } = useComposerUrlDialog({ @@ -356,6 +374,23 @@ export function ChatBar({ scheduleFlushEditorToDraft(event.currentTarget) } + // Native typing/deleting mutates the DOM through Chromium's editing pipeline, + // whose undo stack we've taken over — so bank the pre-edit state here, before + // the change lands. `beforeinput` is the only hook that still sees the old + // text. Consecutive keystrokes coalesce into one entry, so ⌘Z steps back by a + // burst rather than a character. + const handleEditorBeforeInput = (event: FormEvent) => { + const inputType = (event.nativeEvent as InputEvent).inputType + + // Undo/redo are ours (handled in useComposerUndo + keydown), and IME preedit + // is not a committed edit — compositionend is where that text becomes real. + if (inputType === 'historyUndo' || inputType === 'historyRedo' || composingRef.current) { + return + } + + recordUndoPoint({ coalesce: inputType === 'insertText' || inputType === 'deleteContentBackward' }) + } + const handlePaste = (event: ClipboardEvent) => { const imageBlobs = extractClipboardImageBlobs(event.clipboardData) @@ -402,7 +437,12 @@ export function ChatBar({ } event.preventDefault() - insertPlainTextAtCaret(event.currentTarget, pastedText) + + // Links in the paste land as `@url:` chips rather than a wall of URL text — + // the same reference the "Add URL" dialog inserts, parsed in place so a link + // mid-sentence keeps its position. + recordUndoPoint() + insertComposerContentsAtCaret(event.currentTarget, linkifyUrls(pastedText)) scheduleFlushEditorToDraft(event.currentTarget) } @@ -416,6 +456,23 @@ export function ChatBar({ return } + // Undo/redo before anything else — we own the stack (see useComposerUndo), + // so these never reach Chromium's native history, which has no record of + // the Range-based edits the rich editor makes. + if (isUndoShortcut(event.nativeEvent)) { + event.preventDefault() + undo() + + return + } + + if (isRedoShortcut(event.nativeEvent)) { + event.preventDefault() + redo() + + return + } + // Plain Backspace right after a directive chip: remove the chip + its // auto-inserted trailing space as one unit, so deleting a directive never // leaves an orphaned space. (Modified backspaces stay native.) @@ -424,7 +481,7 @@ export function ChatBar({ !event.metaKey && !event.ctrlKey && !event.altKey && - deleteChipBeforeCaret(event.currentTarget) + withUndoPoint(() => deleteChipBeforeCaret(event.currentTarget)) ) { event.preventDefault() flushEditorToDraft(event.currentTarget) @@ -434,7 +491,19 @@ export function ChatBar({ // Non-collapsed Backspace/Delete: native selection-delete is ~O(n²) on large // drafts (Ctrl+A → Delete froze ~1.3s). Collapsed carets fall through. - if ((event.key === 'Backspace' || event.key === 'Delete') && deleteSelectionInEditor(event.currentTarget)) { + if ( + (event.key === 'Backspace' || event.key === 'Delete') && + withUndoPoint(() => deleteSelectionInEditor(event.currentTarget)) + ) { + event.preventDefault() + flushEditorToDraft(event.currentTarget) + + return + } + + // A typed link finished with a space chips like a pasted one — the space + // itself rides along inside the insert. + if (withUndoPoint(() => chipTypedUrlOnSpace(event))) { event.preventDefault() flushEditorToDraft(event.currentTarget) @@ -777,6 +846,7 @@ export function ChatBar({ contentEditable={!inputDisabled} data-placeholder={placeholder} data-slot={RICH_INPUT_SLOT} + onBeforeInput={handleEditorBeforeInput} onBlur={() => window.setTimeout(closeTrigger, 80)} onCompositionEnd={event => { composingRef.current = false diff --git a/apps/desktop/src/app/chat/composer/inline-refs.ts b/apps/desktop/src/app/chat/composer/inline-refs.ts index 5fd62f4cc9..5e282f6a04 100644 --- a/apps/desktop/src/app/chat/composer/inline-refs.ts +++ b/apps/desktop/src/app/chat/composer/inline-refs.ts @@ -4,7 +4,13 @@ import { contextPath } from '@/lib/chat-runtime' import type { DroppedFile } from '../hooks/use-composer-actions' -import { composerPlainText, normalizeComposerEditorDom, placeCaretEnd, refChipElement } from './rich-editor' +import { + composerPlainText, + normalizeComposerEditorDom, + placeCaretEnd, + refChipElement, + RICH_INPUT_SLOT +} from './rich-editor' /** A chip to insert: a raw `@kind:value` string, or a typed value + display label. */ export type InlineRefInput = string | { kind: string; label?: string; value: string } @@ -92,7 +98,12 @@ function plainTextInRange(editor: HTMLDivElement, range: Range, edge: 'after' | slice.setStart(range.endContainer, range.endOffset) } + // Carry the editor's slot marker: composerPlainText appends a trailing "\n" + // to any other block element, so a bare
made `beforeText` always look + // like it ended in whitespace and the separating space was never inserted — + // a chip dropped after a word came out glued to it (`review@file:...`). const container = document.createElement('div') + container.dataset.slot = RICH_INPUT_SLOT container.appendChild(slice.cloneContents()) return composerPlainText(container) diff --git a/apps/desktop/src/app/chat/composer/rich-editor.test.ts b/apps/desktop/src/app/chat/composer/rich-editor.test.ts index 12e3e9613e..842765388f 100644 --- a/apps/desktop/src/app/chat/composer/rich-editor.test.ts +++ b/apps/desktop/src/app/chat/composer/rich-editor.test.ts @@ -4,10 +4,11 @@ import { insertInlineRefsIntoEditor } from './inline-refs' import { composerPlainText, deleteSelectionInEditor, - insertPlainTextAtCaret, + insertComposerContentsAtCaret, normalizeComposerEditorDom, refChipElement, renderComposerContents, + replaceBeforeCaret, RICH_INPUT_SLOT } from './rich-editor' @@ -70,16 +71,40 @@ describe('insertInlineRefsIntoEditor', () => { expect(editor.querySelector(':scope > div')).toBeNull() expect(composerPlainText(editor)).toBe('@file:`src/foo.ts` ') }) + + it('separates a chip from the word the caret sits after', () => { + const editor = document.createElement('div') + editor.dataset.slot = RICH_INPUT_SLOT + editor.append(document.createTextNode('review')) + document.body.append(editor) + caretIn(editor) + + expect(insertInlineRefsIntoEditor(editor, ['@file:`src/a.ts`'])).toBe('review @file:`src/a.ts` ') + + editor.remove() + }) + + it('does not double the space when one is already there', () => { + const editor = document.createElement('div') + editor.dataset.slot = RICH_INPUT_SLOT + editor.append(document.createTextNode('review ')) + document.body.append(editor) + caretIn(editor) + + expect(insertInlineRefsIntoEditor(editor, ['@file:`src/a.ts`'])).toBe('review @file:`src/a.ts` ') + + editor.remove() + }) }) -describe('insertPlainTextAtCaret', () => { +describe('insertComposerContentsAtCaret', () => { it('inserts multiline text as text nodes + br', () => { const editor = document.createElement('div') editor.dataset.slot = RICH_INPUT_SLOT document.body.append(editor) caretIn(editor) - insertPlainTextAtCaret(editor, 'one\ntwo\nthree') + insertComposerContentsAtCaret(editor, 'one\ntwo\nthree') expect(editor.querySelectorAll('br').length).toBe(2) expect(composerPlainText(editor)).toBe('one\ntwo\nthree') @@ -102,12 +127,76 @@ describe('insertPlainTextAtCaret', () => { selection.removeAllRanges() selection.addRange(range) - insertPlainTextAtCaret(editor, 'cd') + insertComposerContentsAtCaret(editor, 'cd') expect(composerPlainText(editor)).toBe('abcdef') editor.remove() }) + + it('lands directives in the text as chips', () => { + const editor = document.createElement('div') + editor.dataset.slot = RICH_INPUT_SLOT + document.body.append(editor) + caretIn(editor) + + insertComposerContentsAtCaret(editor, 'read @url:`https://example.dev/a` now') + + expect(editor.querySelectorAll('[data-ref-kind="url"]').length).toBe(1) + expect(composerPlainText(editor)).toBe('read @url:`https://example.dev/a` now') + + editor.remove() + }) +}) + +describe('replaceBeforeCaret', () => { + it('swaps the token before the caret and leaves the caret after the insert', () => { + const editor = document.createElement('div') + editor.dataset.slot = RICH_INPUT_SLOT + editor.textContent = 'see foo' + document.body.append(editor) + + const text = editor.firstChild! + const selection = window.getSelection()! + const range = document.createRange() + + range.setStart(text, 7) + range.collapse(true) + selection.removeAllRanges() + selection.addRange(range) + + const fragment = document.createDocumentFragment() + fragment.append(refChipElement('file', '`src/foo.ts`'), document.createTextNode(' ')) + + expect(replaceBeforeCaret(editor, 3, fragment)).toBe(true) + expect(composerPlainText(editor)).toBe('see @file:`src/foo.ts` ') + expect(selection.getRangeAt(0).collapsed).toBe(true) + + editor.remove() + }) + + it('leaves the editor alone when the caret has no room for the token', () => { + const editor = document.createElement('div') + editor.dataset.slot = RICH_INPUT_SLOT + editor.textContent = 'hi' + document.body.append(editor) + + const selection = window.getSelection()! + const range = document.createRange() + + range.setStart(editor.firstChild!, 2) + range.collapse(true) + selection.removeAllRanges() + selection.addRange(range) + + const fragment = document.createDocumentFragment() + fragment.append(document.createTextNode('x')) + + expect(replaceBeforeCaret(editor, 20, fragment)).toBe(false) + expect(composerPlainText(editor)).toBe('hi') + + editor.remove() + }) }) describe('deleteSelectionInEditor', () => { diff --git a/apps/desktop/src/app/chat/composer/rich-editor.ts b/apps/desktop/src/app/chat/composer/rich-editor.ts index 21f0286c9f..7bf770eda1 100644 --- a/apps/desktop/src/app/chat/composer/rich-editor.ts +++ b/apps/desktop/src/app/chat/composer/rich-editor.ts @@ -11,11 +11,11 @@ import { directiveIconElement, directiveIconSvg, formatRefValue, + refChipLabel, slashChipClass, type SlashChipKind, slashIconElement } from '@/components/assistant-ui/directive-text' -import { sessionRefFallbackLabel } from '@/lib/session-refs' export const RICH_INPUT_SLOT = 'composer-rich-input' @@ -35,10 +35,6 @@ export function unquoteRef(raw: string) { return quoted ? raw.slice(1, -1) : raw.replace(/[,.;!?]+$/, '') } -export function refLabel(id: string) { - return id.split(/[\\/]/).filter(Boolean).pop() || id -} - /** Always-quote variant of formatRefValue — chips need a fence even for safe values. */ export function quoteRefValue(value: string) { if (!value.includes('`')) { @@ -60,9 +56,9 @@ export function refChipHtml(kind: string, rawValue: string, displayLabel?: strin const id = unquoteRef(rawValue) const text = `@${kind}:${quoteRefValue(id)}` - const label = displayLabel || (kind === 'session' ? sessionRefFallbackLabel(id) : refLabel(id)) + const label = displayLabel || refChipLabel(kind, id) - return `${directiveIconSvg(kind)}${escapeHtml(label)}` + return `${directiveIconSvg(kind)}${escapeHtml(label)}` } export function refChipElement(kind: string, rawValue: string, displayLabel?: string) { @@ -72,12 +68,13 @@ export function refChipElement(kind: string, rawValue: string, displayLabel?: st const label = document.createElement('span') chip.contentEditable = 'false' + chip.title = id chip.dataset.refText = text chip.dataset.refId = id chip.dataset.refKind = kind chip.className = DIRECTIVE_CHIP_CLASS label.className = 'truncate' - label.textContent = displayLabel || (kind === 'session' ? sessionRefFallbackLabel(id) : refLabel(id)) + label.textContent = displayLabel || refChipLabel(kind, id) chip.append(directiveIconElement(kind), label) return chip @@ -147,14 +144,15 @@ function composerSelectionRange(editor: HTMLElement) { return { range, selection } } -/** Insert plain text at the caret (replacing any selection). Pastes use this - * instead of `execCommand('insertText')` — Chromium's editing pipeline is - * ~O(n²) on large multiline blobs. */ -export function insertPlainTextAtCaret(editor: HTMLElement, text: string) { +/** Insert text at the caret (replacing any selection), with any `@kind:value` + * directives in it landing as chips. Pastes use this instead of + * `execCommand('insertText')` — Chromium's editing pipeline is ~O(n²) on large + * multiline blobs. */ +export function insertComposerContentsAtCaret(editor: HTMLElement, text: string) { const hit = composerSelectionRange(editor) const fragment = document.createDocumentFragment() - appendTextWithBreaks(fragment, text) + appendComposerContents(fragment, text) const tail = fragment.lastChild @@ -175,6 +173,41 @@ export function insertPlainTextAtCaret(editor: HTMLElement, text: string) { } } +/** Swap the `length` characters immediately before a collapsed caret for + * `fragment`, leaving the caret after it. Returns whether it ran — a caret that + * isn't inside a text node holding the whole token is left alone. */ +export function replaceBeforeCaret(editor: HTMLElement, length: number, fragment: DocumentFragment) { + const hit = composerSelectionRange(editor) + + if (!hit?.range.collapsed) { + return false + } + + const { startContainer, startOffset } = hit.range + + if (startContainer.nodeType !== Node.TEXT_NODE || startOffset < length) { + return false + } + + const range = document.createRange() + const tail = fragment.lastChild + + range.setStart(startContainer, startOffset - length) + range.setEnd(startContainer, startOffset) + range.deleteContents() + range.insertNode(fragment) + + if (tail) { + range.setStartAfter(tail) + } + + range.collapse(true) + hit.selection.removeAllRanges() + hit.selection.addRange(range) + + return true +} + /** Backspace at a collapsed caret immediately after a chip: delete the chip AND * the single trailing space we auto-insert after it, atomically — so removing a * directive never strands an orphaned space (the contenteditable-driven cleanup @@ -299,6 +332,106 @@ export function placeCaretEnd(element: HTMLElement) { selection?.addRange(range) } +/** The caret's offset in `composerPlainText` coordinates, so it can be restored + * after the editor is re-rendered from text (undo/redo). A chip counts as its + * whole `@kind:value` text — the same units the snapshot measures. */ +export function caretOffsetInEditor(editor: HTMLElement): number { + const selection = window.getSelection() + const range = selection?.rangeCount ? selection.getRangeAt(0) : null + + if (!range || !editor.contains(range.commonAncestorContainer)) { + return composerPlainText(editor).length + } + + const before = range.cloneRange() + before.selectNodeContents(editor) + before.setEnd(range.startContainer, range.startOffset) + + // The scratch container must carry the editor's slot marker: composerPlainText + // appends a trailing "\n" to any other block element, which would inflate + // every offset by one and land the restored caret a character late. + const container = document.createElement('div') + container.dataset.slot = RICH_INPUT_SLOT + container.append(before.cloneContents()) + + return composerPlainText(container).length +} + +/** Place the caret `offset` characters into the editor, in the same + * `composerPlainText` coordinates `caretOffsetInEditor` reports. Lands after a + * chip it would otherwise split, since a chip is a single atomic unit. */ +export function placeCaretAtOffset(editor: HTMLElement, offset: number) { + const selection = window.getSelection() + + if (!selection) { + return + } + + let remaining = offset + + const walk = (node: Node): Range | null => { + for (const child of Array.from(node.childNodes)) { + if (child.nodeType === Node.TEXT_NODE) { + const length = (child.textContent || '').length + + if (remaining <= length) { + const range = document.createRange() + range.setStart(child, remaining) + range.collapse(true) + + return range + } + + remaining -= length + + continue + } + + if (child.nodeType !== Node.ELEMENT_NODE) { + continue + } + + const el = child as HTMLElement + + // Chips and
are atomic: consume their serialized length whole. + if (el.dataset.refText || el.tagName === 'BR') { + const length = el.dataset.refText ? el.dataset.refText.length : 1 + + if (remaining < length) { + const range = document.createRange() + range.setStartBefore(el) + range.collapse(true) + + return range + } + + remaining -= length + + continue + } + + const hit = walk(el) + + if (hit) { + return hit + } + } + + return null + } + + const range = walk(editor) + + if (range) { + selection.removeAllRanges() + selection.addRange(range) + + return + } + + placeCaretEnd(editor) +} + /** Nothing but a break / whitespace (recursively) — i.e. no real text or chip. */ function isBlankNode(node: ChildNode | null): boolean { if (!node) { diff --git a/apps/desktop/src/app/chat/composer/status-stack/goal-indicator.test.tsx b/apps/desktop/src/app/chat/composer/status-stack/goal-indicator.test.tsx new file mode 100644 index 0000000000..09a7454b9c --- /dev/null +++ b/apps/desktop/src/app/chat/composer/status-stack/goal-indicator.test.tsx @@ -0,0 +1,87 @@ +import { cleanup, render, screen } from '@testing-library/react' +import { MemoryRouter } from 'react-router-dom' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import { I18nProvider } from '@/i18n' +import { $goalsBySession, type SessionGoal } from '@/store/goals' + +import { ComposerStatusStack } from './index' + +// The stack measures itself into a surface var — jsdom has no ResizeObserver. +class ResizeObserverStub { + observe() {} + unobserve() {} + disconnect() {} +} + +vi.stubGlobal('ResizeObserver', ResizeObserverStub) + +const SID = 'sess-goal-1' + +const goal = (status: SessionGoal['status'], title = 'ship the feature', detail?: string): SessionGoal => ({ + detail, + status, + title, + updatedAt: Date.now() +}) + +function renderStack(sessionId: null | string = SID) { + return render( + + + + + + ) +} + +describe('ComposerStatusStack goal indicator', () => { + beforeEach(() => { + $goalsBySession.set({}) + }) + + afterEach(() => { + cleanup() + $goalsBySession.set({}) + }) + + it('renders nothing when the session has no goal', () => { + const view = renderStack() + + expect(view.container.firstChild).toBeNull() + }) + + it('shows an active goal with its title', () => { + $goalsBySession.set({ [SID]: goal('active') }) + + renderStack() + + expect(screen.getByText('Goal active')).toBeTruthy() + expect(screen.getByText('ship the feature')).toBeTruthy() + }) + + it('labels a paused goal as paused', () => { + $goalsBySession.set({ [SID]: goal('paused') }) + + renderStack() + + expect(screen.getByText('Goal paused')).toBeTruthy() + expect(screen.getByText('ship the feature')).toBeTruthy() + }) + + it('shows the continuation detail line for an active goal', () => { + $goalsBySession.set({ [SID]: goal('active', 'ship it', 'Continuing toward goal (3/20)') }) + + renderStack() + + expect(screen.getByText('Continuing toward goal (3/20)')).toBeTruthy() + }) + + it('scopes the indicator to the goal-owning session', () => { + $goalsBySession.set({ 'other-session': goal('active') }) + + const view = renderStack() + + expect(view.container.firstChild).toBeNull() + }) +}) diff --git a/apps/desktop/src/app/chat/composer/status-stack/index.tsx b/apps/desktop/src/app/chat/composer/status-stack/index.tsx index 10b7a0776b..fbbd2b94d5 100644 --- a/apps/desktop/src/app/chat/composer/status-stack/index.tsx +++ b/apps/desktop/src/app/chat/composer/status-stack/index.tsx @@ -12,6 +12,7 @@ import { Button } from '@/components/ui/button' import { Codicon } from '@/components/ui/codicon' import { Tip, TipKeybindLabel } from '@/components/ui/tooltip' import { type Translations, useI18n } from '@/i18n' +import { useSessionSlice } from '@/lib/use-session-slice' import { cn } from '@/lib/utils' import { $billingBlock } from '@/store/billing-block' import { @@ -23,6 +24,7 @@ import { type StatusGroup, stopBackgroundProcess } from '@/store/composer-status' +import { refreshSessionGoal } from '@/store/goals' import { $previewStatusBySession, dismissPreviewArtifact } from '@/store/preview-status' import { $threadScrolledUp } from '@/store/thread-scroll' import { openSessionInNewWindow } from '@/store/windows' @@ -42,12 +44,25 @@ const isLocalhostPreview = (target: string): boolean => /\b(?:localhost|127\.0\. // Real codicons per group (no sparkles): a checklist for todos, the agent glyph // for subagents, a background process glyph for background tasks. const GROUP_ICON: Record = { + goal: 'target', todo: 'checklist', subagent: 'agent', background: 'server-process' } const groupLabel = (group: StatusGroup, s: Translations['statusStack']) => { + if (group.type === 'goal') { + const status = group.items[0]?.goalStatus + + return status === 'paused' + ? s.goalPaused + : status === 'waiting' + ? s.goalWaiting + : status === 'done' + ? s.goalDone + : s.goalActive + } + if (group.type === 'todo') { return s.todos(group.items.filter(i => i.todoStatus === 'completed').length, group.items.length) } @@ -70,23 +85,25 @@ interface ComposerStatusStackProps { export function ComposerStatusStack({ queue, sessionId }: ComposerStatusStackProps) { const { t } = useI18n() const navigate = useNavigate() - const itemsBySession = useStore($statusItemsBySession) - const previewsBySession = useStore($previewStatusBySession) + // Subscribe to THIS session's slice only. Both maps churn on other + // sessions' activity (subagent ticks, background polls, preview updates in + // any tile); a whole-map `useStore` re-rendered every mounted stack — one + // per open tile — on all of it. The per-key arrays are referentially stable + // across unrelated writes, so the slice hook bails out unless OUR session's + // items actually changed. + const items = useSessionSlice($statusItemsBySession, sessionId) + const previews = useSessionSlice($previewStatusBySession, sessionId) const scrolledUp = useStore($threadScrolledUp) const billing = useStore($billingBlock) - const groups = useMemo( - () => groupStatusItems(sessionId ? (itemsBySession[sessionId] ?? []) : []), - [itemsBySession, sessionId] - ) - - const previews = sessionId ? (previewsBySession[sessionId] ?? []) : [] + const groups = useMemo(() => groupStatusItems(items), [items]) // Seed from the registry on session open; event-driven refreshes (terminal / // process tool completions) live in use-message-stream. useEffect(() => { if (sessionId) { void refreshBackgroundProcesses(sessionId) + void refreshSessionGoal(sessionId) } }, [sessionId]) @@ -154,7 +171,7 @@ export function ComposerStatusStack({ queue, sessionId }: ComposerStatusStackPro ) : undefined } - defaultCollapsed={group.type !== 'todo'} + defaultCollapsed={group.type !== 'todo' && group.type !== 'goal'} icon={} label={groupLabel(group, t.statusStack)} > diff --git a/apps/desktop/src/app/chat/composer/status-stack/status-row.tsx b/apps/desktop/src/app/chat/composer/status-stack/status-row.tsx index 6857be46cc..2c43743c40 100644 --- a/apps/desktop/src/app/chat/composer/status-stack/status-row.tsx +++ b/apps/desktop/src/app/chat/composer/status-stack/status-row.tsx @@ -25,6 +25,24 @@ const TODO_GLYPHS: Record, { icon // Left slot: braille spinner while running, otherwise a small status dot // (green = done, red = failed) so the slot is always filled and rows align. function leadingGlyph(item: ComposerStatusItem, s: Translations['statusStack']): ReactNode { + if (item.type === 'goal') { + if (item.goalStatus === 'paused') { + return + } + + if (item.goalStatus === 'done') { + return + } + + return ( + + ) + } + if (item.todoStatus === 'pending') { return ( )} + {item.type === 'goal' && item.currentTool && ( + + {item.currentTool} + + )} {failed && typeof item.exitCode === 'number' && item.exitCode !== 0 && ( {s.exit(item.exitCode)} diff --git a/apps/desktop/src/app/chat/composer/undo-history.test.ts b/apps/desktop/src/app/chat/composer/undo-history.test.ts new file mode 100644 index 0000000000..5ce477a802 --- /dev/null +++ b/apps/desktop/src/app/chat/composer/undo-history.test.ts @@ -0,0 +1,245 @@ +import { beforeEach, describe, expect, it } from 'vitest' + +import { + caretOffsetInEditor, + composerPlainText, + placeCaretAtOffset, + refChipElement, + renderComposerContents, + RICH_INPUT_SLOT +} from './rich-editor' +import { createComposerUndoHistory, isRedoShortcut, isUndoShortcut } from './undo-history' + +const key = (over: Partial = {}) => + ({ altKey: false, ctrlKey: false, key: 'z', metaKey: false, shiftKey: false, ...over }) as KeyboardEvent + +describe('undo/redo shortcut recognition', () => { + it('claims Cmd+Z and Ctrl+Z as undo, but not with Shift or Alt', () => { + expect(isUndoShortcut(key({ metaKey: true }))).toBe(true) + expect(isUndoShortcut(key({ ctrlKey: true }))).toBe(true) + expect(isUndoShortcut(key({ metaKey: true, shiftKey: true }))).toBe(false) + expect(isUndoShortcut(key({ altKey: true, metaKey: true }))).toBe(false) + expect(isUndoShortcut(key({ key: 'a', metaKey: true }))).toBe(false) + expect(isUndoShortcut(key())).toBe(false) + }) + + it('claims Cmd+Shift+Z everywhere and Ctrl+Y as redo', () => { + expect(isRedoShortcut(key({ metaKey: true, shiftKey: true }))).toBe(true) + expect(isRedoShortcut(key({ ctrlKey: true, shiftKey: true }))).toBe(true) + expect(isRedoShortcut(key({ ctrlKey: true, key: 'y' }))).toBe(true) + expect(isRedoShortcut(key({ metaKey: true }))).toBe(false) + expect(isRedoShortcut(key({ altKey: true, ctrlKey: true, key: 'y' }))).toBe(false) + }) + + it('never treats one keystroke as both undo and redo', () => { + const chords = [ + key({ metaKey: true }), + key({ ctrlKey: true }), + key({ metaKey: true, shiftKey: true }), + key({ ctrlKey: true, shiftKey: true }), + key({ ctrlKey: true, key: 'y' }) + ] + + for (const chord of chords) { + expect(isUndoShortcut(chord) && isRedoShortcut(chord)).toBe(false) + } + }) +}) + +describe('composer undo history', () => { + const snap = (text: string, caret = text.length) => ({ caret, text }) + + it('steps back through discrete edits, newest first', () => { + const history = createComposerUndoHistory() + + history.record(snap('')) + history.record(snap('a')) + history.record(snap('ab')) + + expect(history.undo(snap('abc'))?.text).toBe('ab') + expect(history.undo(snap('ab'))?.text).toBe('a') + expect(history.undo(snap('a'))?.text).toBe('') + expect(history.undo(snap(''))).toBeNull() + }) + + it('redoes back to the state undo left, and stops at the newest', () => { + const history = createComposerUndoHistory() + + history.record(snap('before')) + + const undone = history.undo(snap('before + pasted')) + + expect(undone?.text).toBe('before') + expect(history.redo(snap('before'))?.text).toBe('before + pasted') + expect(history.redo(snap('before + pasted'))).toBeNull() + }) + + it('restores the caret along with the text', () => { + const history = createComposerUndoHistory() + + history.record({ caret: 3, text: 'hello world' }) + + expect(history.undo({ caret: 0, text: 'changed' })).toEqual({ caret: 3, text: 'hello world' }) + }) + + it('collapses a run of typing into one entry, so undo steps back by a burst', () => { + let now = 1_000 + const history = createComposerUndoHistory(200, () => now) + + history.record(snap(''), { coalesce: true }) + now += 50 + history.record(snap('h'), { coalesce: true }) + now += 50 + history.record(snap('he'), { coalesce: true }) + + // One burst → one entry, back to the state before the burst started. + expect(history.undo(snap('hel'))?.text).toBe('') + expect(history.undo(snap(''))).toBeNull() + }) + + it('starts a new entry once the typing pause exceeds the coalesce window', () => { + let now = 1_000 + const history = createComposerUndoHistory(200, () => now) + + history.record(snap(''), { coalesce: true }) + now += 5_000 + history.record(snap('word one'), { coalesce: true }) + + expect(history.undo(snap('word one two'))?.text).toBe('word one') + expect(history.undo(snap('word one'))?.text).toBe('') + }) + + it('does not coalesce a paste into the typing burst that preceded it', () => { + let now = 1_000 + const history = createComposerUndoHistory(200, () => now) + + history.record(snap(''), { coalesce: true }) + now += 20 + // A paste is a discrete edit — no coalesce flag. + history.record(snap('typed ')) + + expect(history.undo(snap('typed PASTED'))?.text).toBe('typed ') + expect(history.undo(snap('typed '))?.text).toBe('') + }) + + it('drops the redo stack once a new edit lands', () => { + const history = createComposerUndoHistory() + + history.record(snap('one')) + history.undo(snap('one two')) + history.record(snap('one')) + + expect(history.redo(snap('one three'))).toBeNull() + }) + + it('ignores a no-op edit so undo never looks stuck for a press', () => { + const history = createComposerUndoHistory() + + history.record(snap('same')) + history.record(snap('same')) + + expect(history.undo(snap('same'))?.text).toBe('same') + expect(history.undo(snap('same'))).toBeNull() + }) + + it('bounds the stack, discarding the oldest entries', () => { + const history = createComposerUndoHistory(3) + + for (const text of ['a', 'b', 'c', 'd', 'e']) { + history.record(snap(text)) + } + + expect(history.undo(snap('f'))?.text).toBe('e') + expect(history.undo(snap('e'))?.text).toBe('d') + expect(history.undo(snap('d'))?.text).toBe('c') + expect(history.undo(snap('c'))).toBeNull() + }) + + it('reset clears both directions', () => { + const history = createComposerUndoHistory() + + history.record(snap('a')) + history.undo(snap('ab')) + history.reset() + + expect(history.undo(snap('ab'))).toBeNull() + expect(history.redo(snap('ab'))).toBeNull() + }) +}) + +describe('caret offsets in composerPlainText coordinates', () => { + let editor: HTMLDivElement + + beforeEach(() => { + editor = document.createElement('div') + editor.dataset.slot = RICH_INPUT_SLOT + document.body.append(editor) + }) + + const caretAfter = (node: Node, offset: number) => { + const range = document.createRange() + const selection = window.getSelection()! + range.setStart(node, offset) + range.collapse(true) + selection.removeAllRanges() + selection.addRange(range) + } + + it('round-trips a caret in plain text', () => { + renderComposerContents(editor, 'hello world') + placeCaretAtOffset(editor, 5) + + expect(caretOffsetInEditor(editor)).toBe(5) + }) + + it('counts a chip as its whole @kind:value text', () => { + editor.append( + document.createTextNode('see '), + refChipElement('file', '`src/a.ts`'), + document.createTextNode(' now') + ) + + const chipText = '@file:`src/a.ts`' + // Caret at the very end = everything before it. + placeCaretAtOffset(editor, composerPlainText(editor).length) + + expect(caretOffsetInEditor(editor)).toBe(4 + chipText.length + 4) + }) + + it('lands the caret before a chip rather than splitting it', () => { + editor.append(document.createTextNode('a '), refChipElement('file', '`x.ts`')) + + // An offset that falls midway through the chip's serialized text. + placeCaretAtOffset(editor, 2 + 3) + + expect(caretOffsetInEditor(editor)).toBe(2) + }) + + it('counts a line break as one character', () => { + renderComposerContents(editor, 'one\ntwo') + placeCaretAtOffset(editor, 5) + + expect(caretOffsetInEditor(editor)).toBe(5) + expect(composerPlainText(editor)).toBe('one\ntwo') + }) + + it('clamps past-the-end offsets to the end instead of throwing', () => { + renderComposerContents(editor, 'short') + placeCaretAtOffset(editor, 999) + + expect(caretOffsetInEditor(editor)).toBe(5) + }) + + it('reports the end when the selection is outside the editor', () => { + renderComposerContents(editor, 'hello') + + const outside = document.createElement('div') + outside.textContent = 'elsewhere' + document.body.append(outside) + caretAfter(outside.firstChild!, 3) + + expect(caretOffsetInEditor(editor)).toBe(5) + + outside.remove() + }) +}) diff --git a/apps/desktop/src/app/chat/composer/undo-history.ts b/apps/desktop/src/app/chat/composer/undo-history.ts new file mode 100644 index 0000000000..62bed71be8 --- /dev/null +++ b/apps/desktop/src/app/chat/composer/undo-history.ts @@ -0,0 +1,126 @@ +/** + * The composer's own undo stack. + * + * The rich editor mutates its DOM through `Range` rather than the browser's + * editing commands — `execCommand('insertText')` is ~O(n²) on large multiline + * blobs and froze the composer for seconds on a big paste (#45812). The cost of + * that bypass is that those mutations never reach Chromium's undo stack, so + * ⌘Z skipped straight past a paste and undid whatever came *before* it, leaving + * the pasted text stranded. + * + * Owning the whole stack is the only coherent fix: a half-owned one interleaves + * our snapshots with Chromium's own typing entries and undoes them out of order. + * So every composer edit — typed or programmatic — records here, and the editor + * intercepts ⌘Z / ⌘⇧Z instead of letting the native command run. + * + * Snapshots are plain text + a caret offset, not DOM: the editor already + * round-trips losslessly through `composerPlainText`/`renderComposerContents`, + * so text is the smallest thing that fully restores a state. + */ + +export interface ComposerSnapshot { + caret: number + text: string +} + +/** Consecutive typing inside this window collapses into one undo entry, so ⌘Z + * steps back by a burst the way a native editor does — not one character. */ +const COALESCE_WINDOW_MS = 600 + +const DEFAULT_LIMIT = 200 + +export interface ComposerUndoHistory { + /** Drop all history and start over from `snapshot`'s state (session swap). */ + reset: () => void + /** Redo one step. `current` is the live state, banked for a subsequent undo. */ + redo: (current: ComposerSnapshot) => ComposerSnapshot | null + /** Bank the state that existed *before* an edit. `coalesce` merges this into + * the previous entry when it lands inside the typing window. */ + record: (previous: ComposerSnapshot, options?: { coalesce?: boolean }) => void + /** Undo one step. `current` is the live state, banked for a subsequent redo. */ + undo: (current: ComposerSnapshot) => ComposerSnapshot | null +} + +export function createComposerUndoHistory( + limit = DEFAULT_LIMIT, + now: () => number = () => Date.now() +): ComposerUndoHistory { + let past: ComposerSnapshot[] = [] + let future: ComposerSnapshot[] = [] + let lastRecordedAt = 0 + let lastWasCoalescable = false + + const record: ComposerUndoHistory['record'] = (previous, options) => { + const coalesce = options?.coalesce ?? false + const at = now() + const merges = coalesce && lastWasCoalescable && past.length > 0 && at - lastRecordedAt < COALESCE_WINDOW_MS + + lastRecordedAt = at + lastWasCoalescable = coalesce + // A fresh edit invalidates anything the user had redone past. + future = [] + + // Merging keeps the OLDER snapshot — the entry already holds the state from + // the start of the burst, which is what ⌘Z should step back to. + if (merges) { + return + } + + // A no-op edit (same text) would make ⌘Z look broken for one press. + if (past[past.length - 1]?.text === previous.text) { + return + } + + past.push(previous) + + if (past.length > limit) { + past = past.slice(past.length - limit) + } + } + + const step = (from: ComposerSnapshot[], to: ComposerSnapshot[], current: ComposerSnapshot) => { + const next = from.pop() + + if (!next) { + return null + } + + to.push(current) + // Any traversal ends the typing burst, so the next keystroke opens a new entry. + lastWasCoalescable = false + + return next + } + + return { + record, + redo: current => step(future, past, current), + reset: () => { + past = [] + future = [] + lastRecordedAt = 0 + lastWasCoalescable = false + }, + undo: current => step(past, future, current) + } +} + +/** True for the keystroke that means "undo" (⌘Z / Ctrl+Z, without Shift). */ +export function isUndoShortcut(event: Pick) { + return (event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey && event.key.toLowerCase() === 'z' +} + +/** True for "redo" — ⌘⇧Z everywhere, plus Ctrl+Y on Windows/Linux. */ +export function isRedoShortcut(event: Pick) { + if (event.altKey) { + return false + } + + const key = event.key.toLowerCase() + + if ((event.metaKey || event.ctrlKey) && event.shiftKey && key === 'z') { + return true + } + + return event.ctrlKey && !event.metaKey && !event.shiftKey && key === 'y' +} diff --git a/apps/desktop/src/app/chat/composer/url-refs.test.ts b/apps/desktop/src/app/chat/composer/url-refs.test.ts new file mode 100644 index 0000000000..febbd533ce --- /dev/null +++ b/apps/desktop/src/app/chat/composer/url-refs.test.ts @@ -0,0 +1,98 @@ +import type { KeyboardEvent } from 'react' +import { describe, expect, it } from 'vitest' + +import { composerPlainText, RICH_INPUT_SLOT } from './rich-editor' +import { chipTypedUrlOnSpace, linkifyUrls } from './url-refs' + +/** An editor holding `text` with a collapsed caret at `caret`, plus the space + * keydown the composer would hand `chipTypedUrlOnSpace`. */ +const spaceOn = (text: string, caret: number) => { + const editor = document.createElement('div') + editor.dataset.slot = RICH_INPUT_SLOT + editor.textContent = text + document.body.append(editor) + + const selection = window.getSelection()! + const range = document.createRange() + + range.setStart(editor.firstChild!, caret) + range.collapse(true) + selection.removeAllRanges() + selection.addRange(range) + + return { editor, event: { currentTarget: editor, key: ' ' } as KeyboardEvent } +} + +describe('linkifyUrls', () => { + it('rewrites a bare link as a url directive', () => { + expect(linkifyUrls('https://example.dev/a/b')).toBe('@url:`https://example.dev/a/b`') + }) + + it('keeps the link in place mid-sentence and leaves its punctuation behind', () => { + expect(linkifyUrls('read https://example.dev/a. then stop')).toBe('read @url:`https://example.dev/a`. then stop') + }) + + it('keeps balanced parens but drops the one that closed the sentence', () => { + expect(linkifyUrls('(see https://en.wikipedia.org/wiki/A_(b))')).toBe( + '(see @url:`https://en.wikipedia.org/wiki/A_(b)`)' + ) + }) + + it('rewrites every link in a multi-link paste', () => { + expect(linkifyUrls('http://a.dev and https://b.dev')).toBe('@url:`http://a.dev` and @url:`https://b.dev`') + }) + + it('leaves a link that is already a directive alone', () => { + expect(linkifyUrls('@url:`https://example.dev`')).toBe('@url:`https://example.dev`') + }) + + it('leaves text without a scheme alone', () => { + expect(linkifyUrls('example.dev/a and src/foo.ts')).toBe('example.dev/a and src/foo.ts') + }) +}) + +describe('chipTypedUrlOnSpace', () => { + it('chips a link typed right before the caret and adds the space', () => { + const { editor, event } = spaceOn('see https://example.dev/a', 25) + + expect(chipTypedUrlOnSpace(event)).toBe(true) + expect(composerPlainText(editor)).toBe('see @url:`https://example.dev/a` ') + + editor.remove() + }) + + it('keeps sentence punctuation outside the chip', () => { + const { editor, event } = spaceOn('https://example.dev.', 20) + + expect(chipTypedUrlOnSpace(event)).toBe(true) + expect(composerPlainText(editor)).toBe('@url:`https://example.dev`. ') + + editor.remove() + }) + + it('ignores a caret that is not sitting on a link', () => { + const { editor, event } = spaceOn('https://example.dev is nice', 27) + + expect(chipTypedUrlOnSpace(event)).toBe(false) + expect(composerPlainText(editor)).toBe('https://example.dev is nice') + + editor.remove() + }) + + it('ignores a scheme with no host yet', () => { + const { editor, event } = spaceOn('https://', 8) + + expect(chipTypedUrlOnSpace(event)).toBe(false) + + editor.remove() + }) + + it('leaves a modified space alone', () => { + const { editor, event } = spaceOn('https://example.dev', 19) + + expect(chipTypedUrlOnSpace({ ...event, altKey: true })).toBe(false) + expect(composerPlainText(editor)).toBe('https://example.dev') + + editor.remove() + }) +}) diff --git a/apps/desktop/src/app/chat/composer/url-refs.ts b/apps/desktop/src/app/chat/composer/url-refs.ts new file mode 100644 index 0000000000..580abdc1c6 --- /dev/null +++ b/apps/desktop/src/app/chat/composer/url-refs.ts @@ -0,0 +1,103 @@ +/** + * Bare-link recognition for the composer. A link the user pastes or types is the + * same thing the "+ → Add URL" dialog inserts, so it becomes an `@url:` + * directive: a chip that truncates instead of a wall of URL text, and a + * reference the gateway resolves. + */ +import type { KeyboardEvent } from 'react' + +import { quoteRefValue, REF_RE, refChipElement, replaceBeforeCaret } from './rich-editor' +import { textBeforeCaret } from './text-utils' + +// An explicit scheme only — `example.com` bare is too easy to hit by accident +// (a filename, a version, a sentence). Brackets and quotes fence a URL in prose; +// parens don't, so they stay in and an unbalanced tail is trimmed below. +const URL_RE = /https?:\/\/[^\s<>[\]{}"'`]+/gi +const TYPED_URL_RE = /(?:^|\s)(https?:\/\/[^\s<>[\]{}"'`]+)$/i + +/** A URL at the end of a sentence carries the punctuation that ended it. */ +function splitUrlTail(raw: string) { + let url = raw.replace(/[,.;:!?]+$/, '') + + while (url.endsWith(')') && url.split(')').length > url.split('(').length) { + url = url.slice(0, -1) + } + + return { trailing: raw.slice(url.length), url } +} + +/** A URL needs a host past the scheme to be worth chipping. */ +const hasHost = (url: string) => /^https?:\/\/[^/\s]/i.test(url) + +/** Rewrite bare links in `text` as `@url:` directives, leaving links that are + * already part of a directive alone. Returns `text` unchanged when there are + * none. */ +export function linkifyUrls(text: string) { + REF_RE.lastIndex = 0 + + const fenced = Array.from(text.matchAll(REF_RE)).map(match => { + const start = match.index ?? 0 + + return { end: start + match[0].length, start } + }) + + let out = '' + let cursor = 0 + + for (const match of text.matchAll(URL_RE)) { + const start = match.index ?? 0 + const { url } = splitUrlTail(match[0]) + + if (!hasHost(url) || fenced.some(span => start >= span.start && start < span.end)) { + continue + } + + out += `${text.slice(cursor, start)}@url:${quoteRefValue(url)}` + cursor = start + url.length + } + + return out + text.slice(cursor) +} + +/** A plain space finishing a typed link commits it as a chip (followed by + * whatever punctuation ended it, then the space). Returns whether it ran, so a + * keydown handler can fall through on anything else. */ +export function chipTypedUrlOnSpace(event: KeyboardEvent) { + if (event.key !== ' ' || event.metaKey || event.ctrlKey || event.altKey) { + return false + } + + const editor = event.currentTarget + + // Runs on every space, so bail on the cheap native read before paying for the + // caret range walk (same guard shape as the trigger detector). + if (!editor.textContent?.includes('://')) { + return false + } + + const before = textBeforeCaret(editor) + const match = before ? TYPED_URL_RE.exec(before) : null + const token = match?.[1] + + if (!token) { + return false + } + + const { trailing, url } = splitUrlTail(token) + + if (!hasHost(url)) { + return false + } + + const fragment = document.createDocumentFragment() + + fragment.append(refChipElement('url', quoteRefValue(url))) + + if (trailing) { + fragment.append(document.createTextNode(trailing)) + } + + fragment.append(document.createTextNode(' ')) + + return replaceBeforeCaret(editor, token.length, fragment) +} diff --git a/apps/desktop/src/app/chat/session-tile.tsx b/apps/desktop/src/app/chat/session-tile.tsx index 6ca29e70ad..dde25d3d20 100644 --- a/apps/desktop/src/app/chat/session-tile.tsx +++ b/apps/desktop/src/app/chat/session-tile.tsx @@ -17,7 +17,7 @@ import { useStore } from '@nanostores/react' import { useQueryClient } from '@tanstack/react-query' import { atom, computed } from 'nanostores' -import { useEffect, useMemo, useRef } from 'react' +import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react' import { useGatewayRequest } from '@/app/gateway/hooks/use-gateway-request' import { useModelControls } from '@/app/session/hooks/use-model-controls' @@ -424,6 +424,40 @@ export function stackSessionTilesIntoMain(): void { } } +/** The three scalars the tab menu actually renders, derived from the stored + * row. Subscribing to `$sessions` + `$projectTree` wholesale re-rendered + * every tab's menu wrapper on ANY session-list or tree churn (polls, title + * updates in other sessions) — for a context menu that's almost never open. + * Same class as the TreeGroup fix (#72245): derive narrowly, bail out unless + * the derived values change. */ +function useTileMenuRow(storedSessionId: string): { pinId: string; profile?: string; title: string } { + const cache = useRef<{ key: string; value: { pinId: string; profile?: string; title: string } } | null>(null) + + const subscribe = useCallback((onChange: () => void) => { + const offSessions = $sessions.listen(onChange) + const offTree = $projectTree.listen(onChange) + + return () => { + offSessions() + offTree() + } + }, []) + + return useSyncExternalStore(subscribe, () => { + const stored = tileStoredRow(storedSessionId) + const pinId = stored ? sessionPinId(stored) : storedSessionId + const title = tileTitle(storedSessionId) + const profile = stored?.profile + const key = `${pinId}\u0000${title}\u0000${profile ?? ''}` + + if (cache.current?.key !== key) { + cache.current = { key, value: { pinId, profile, title } } + } + + return cache.current.value + }) +} + /** A session TAB's context menu: the full session verb set (pin, copy id, new * window, branch, rename, archive, delete) — the SAME menu a sidebar row * gets, targeted through the tile delegate (whose verbs are generic over @@ -445,13 +479,8 @@ export function SessionTabMenu({ /** Layout-tree pane id — powers the Close-others/right/all verbs. */ tabPaneId: string }) { - // Subscribe for reactivity; the row is read imperatively via tileStoredRow - // (which spans both sources), so the values themselves are unused here. - useStore($sessions) - useStore($projectTree) + const { pinId, profile, title } = useTileMenuRow(storedSessionId) const pinnedSessionIds = useStore($pinnedSessionIds) - const stored = tileStoredRow(storedSessionId) - const pinId = stored ? sessionPinId(stored) : storedSessionId const pinned = pinnedSessionIds.includes(pinId) return ( @@ -464,11 +493,11 @@ export function SessionTabMenu({ onHideTabBar={onHideTabBar} onPin={() => (pinned ? unpinSession(pinId) : pinSession(pinId))} pinned={pinned} - profile={stored?.profile} + profile={profile} sessionId={storedSessionId} surface="tab" tabPaneId={tabPaneId} - title={tileTitle(storedSessionId)} + title={title} > {children} diff --git a/apps/desktop/src/app/chat/sidebar/chrome.tsx b/apps/desktop/src/app/chat/sidebar/chrome.tsx index 2a0f728503..36d97e03f2 100644 --- a/apps/desktop/src/app/chat/sidebar/chrome.tsx +++ b/apps/desktop/src/app/chat/sidebar/chrome.tsx @@ -8,10 +8,6 @@ import { cn } from '@/lib/utils' // sections and the project/workspace tree, so it lives outside either to keep // imports one-directional (no index <-> projects cycle). -/** `loaded/total` when there's more on the server, else just the loaded count. */ -export const countLabel = (loaded: number, total: number): string => - total > loaded ? `${loaded}/${total}` : String(loaded) - /** The muted count chip next to a section/workspace label. */ export function SidebarCount({ children }: { children: React.ReactNode }) { return {children} diff --git a/apps/desktop/src/app/chat/sidebar/index.tsx b/apps/desktop/src/app/chat/sidebar/index.tsx index 91dec1e2d5..c1f00e5777 100644 --- a/apps/desktop/src/app/chat/sidebar/index.tsx +++ b/apps/desktop/src/app/chat/sidebar/index.tsx @@ -89,10 +89,9 @@ import { $messagingPlatformTotals, $messagingSessions, $messagingTruncated, - $sessionProfileTotals, + $sessionProfilesTruncated, $sessions, $sessionsLoading, - $sessionsTotal, sessionPinId, setCurrentCwd } from '@/store/session' @@ -108,7 +107,6 @@ import { } from '../../routes' import type { SidebarNavItem } from '../../types' -import { countLabel } from './chrome' import { SidebarCronJobsSection } from './cron-jobs-section' import { SidebarLoadMoreRow } from './load-more-row' import { orderByIds, reconcileOrderIds, resolveManualSessionOrderIds, sameIds } from './order' @@ -300,8 +298,7 @@ export function ChatSidebar({ const messagingPlatformTotals = useStore($messagingPlatformTotals) const messagingTruncated = useStore($messagingTruncated) const sessionsLoading = useStore($sessionsLoading) - const sessionsTotal = useStore($sessionsTotal) - const sessionProfileTotals = useStore($sessionProfileTotals) + const sessionProfilesTruncated = useStore($sessionProfilesTruncated) const workingSessionIds = useStore($workingSessionIds) const profiles = useStore($profiles) const profileScope = useStore($profileScope) @@ -937,7 +934,7 @@ export function ChatSidebar({ ...group, loadingMore: Boolean(profileLoadMorePending[group.id]), onLoadMore: onLoadMoreProfileSessions ? () => loadMoreForProfileGroup(group.id) : undefined, - totalCount: Math.max(group.sessions.length, sessionProfileTotals[group.id] ?? 0) + hasMore: Boolean(sessionProfilesTruncated[group.id]) })) // default (root) first, then the rest alphabetically. .sort((a, b) => (a.id === 'default' ? -1 : b.id === 'default' ? 1 : a.label.localeCompare(b.label))) @@ -948,7 +945,7 @@ export function ChatSidebar({ loadMoreForProfileGroup, onLoadMoreProfileSessions, profileLoadMorePending, - sessionProfileTotals + sessionProfilesTruncated ]) // The flat Sessions list always shows ALL recent sessions; Projects is a @@ -956,22 +953,16 @@ export function ChatSidebar({ const displayAgentSessions = agentSessions // Pagination is scope-aware. In "All profiles" mode it tracks the global - // unified set. When scoped to one profile it must compare that profile's own - // loaded rows against that profile's total — otherwise a huge default profile - // keeps "Load more" stuck on while you browse a small one (the aggregator's - // total sums every profile). Per-profile totals come from the aggregator - // (children excluded); fall back to the global total / loaded count. + // unified set; scoped to one profile it tracks that profile's own truncation + // flag — otherwise a huge default profile keeps "Load more" stuck on while + // you browse a small one. The backend reports whether its page was capped + // rather than an exact count, so no COUNT(*) runs per refresh. const loadedSessionCount = showAllProfiles ? sessions.length : visibleSessions.length - const scopedProfileTotal = showAllProfiles ? undefined : sessionProfileTotals[profileScope] - const knownSessionTotal = Math.max( - showAllProfiles ? sessionsTotal : (scopedProfileTotal ?? loadedSessionCount), - loadedSessionCount - ) + const hasMoreSessions = showAllProfiles + ? Object.values(sessionProfilesTruncated).some(Boolean) + : Boolean(sessionProfilesTruncated[profileScope]) - const hasMoreSessions = knownSessionTotal > loadedSessionCount - - const recentsMeta = countLabel(displayAgentSessions.length, knownSessionTotal) const displayRecentsCountRef = useRef(0) const loadedRecentsCountRef = useRef(0) displayRecentsCountRef.current = displayAgentSessions.length @@ -1390,9 +1381,7 @@ export function ChatSidebar({ reposScanning && !projectsSkeletonVisible ? ( ) : undefined - ) : ( - recentsMeta - ) + ) : undefined } liveSessions={inProject ? agentSessions : undefined} onArchiveSession={onArchiveSession} @@ -1458,7 +1447,7 @@ export function ChatSidebar({ platformName={group.label} /> } - labelMeta={countLabel(group.sessions.length, group.total)} + labelMeta={String(shownSessions.length)} onArchiveSession={onArchiveSession} onDeleteSession={onDeleteSession} onResumeSession={onResumeSession} diff --git a/apps/desktop/src/app/chat/sidebar/projects/workspace-group.tsx b/apps/desktop/src/app/chat/sidebar/projects/workspace-group.tsx index bcbefafa67..bb0ae30cff 100644 --- a/apps/desktop/src/app/chat/sidebar/projects/workspace-group.tsx +++ b/apps/desktop/src/app/chat/sidebar/projects/workspace-group.tsx @@ -9,7 +9,7 @@ import { notifyError } from '@/store/notifications' import { newSessionInProfile } from '@/store/profile' import { switchBranchInRepo } from '@/store/projects' -import { countLabel, SidebarRowStack } from '../chrome' +import { SidebarRowStack } from '../chrome' import { SidebarLoadMoreRow } from '../load-more-row' import { SIDEBAR_GROUP_PAGE, useWorkspaceNodeOpen } from './model' @@ -37,11 +37,13 @@ export function SidebarWorkspaceGroup({ group, renderRows, onNewSession, onRemov const [visibleCount, setVisibleCount] = useState(SIDEBAR_GROUP_PAGE) const loadedCount = group.sessions.length - // Profile groups know their on-disk total (children excluded); workspace - // groups only ever page within what's already loaded. - const totalCount = isProfileGroup ? Math.max(group.totalCount ?? loadedCount, loadedCount) : loadedCount const visibleSessions = group.sessions.slice(0, visibleCount) - const hiddenCount = Math.max(0, totalCount - visibleSessions.length) + // Profile groups can have more rows on the server than are loaded — the + // aggregator reports `hasMore` so the lane can offer another page without + // pricing an exact total per refresh. Workspace groups only ever page within + // what's already loaded. + const hiddenLoaded = Math.max(0, loadedCount - visibleSessions.length) + const hiddenCount = isProfileGroup && group.hasMore ? Math.max(hiddenLoaded, 1) : hiddenLoaded const nextCount = Math.min(SIDEBAR_GROUP_PAGE, hiddenCount) // Leading glyph: profile color dot, a home mark for the repo's primary @@ -63,7 +65,7 @@ export function SidebarWorkspaceGroup({ group, renderRows, onNewSession, onRemov setVisibleCount(target) - if (target > loadedCount && loadedCount < totalCount) { + if (target > loadedCount && group.hasMore) { group.onLoadMore?.() } } @@ -119,7 +121,7 @@ export function SidebarWorkspaceGroup({ group, renderRows, onNewSession, onRemov
) } - count={isProfileGroup ? countLabel(visibleSessions.length, totalCount) : group.sessions.length} + count={visibleSessions.length} icon={leadingIcon} label={group.label} onToggle={toggleOpen} diff --git a/apps/desktop/src/app/chat/sidebar/projects/workspace-groups.ts b/apps/desktop/src/app/chat/sidebar/projects/workspace-groups.ts index 17a085113d..a55fdce819 100644 --- a/apps/desktop/src/app/chat/sidebar/projects/workspace-groups.ts +++ b/apps/desktop/src/app/chat/sidebar/projects/workspace-groups.ts @@ -30,7 +30,10 @@ export interface SidebarSessionGroup { mode?: 'profile' | 'source' | 'workspace' onLoadMore?: () => void sourceId?: string - totalCount?: number + /** Profile lanes only: the backend page was capped, so more rows exist on + * disk than were loaded. Replaces the old exact `totalCount`, which cost a + * COUNT(*) per profile on every sidebar refresh just to render `n/total`. */ + hasMore?: boolean } /** A repo node: holds its branch/worktree lanes (`repo -> lane -> sessions`). */ diff --git a/apps/desktop/src/app/contrib/hooks/live-status-reap.test.ts b/apps/desktop/src/app/contrib/hooks/live-status-reap.test.ts new file mode 100644 index 0000000000..8b4688331c --- /dev/null +++ b/apps/desktop/src/app/contrib/hooks/live-status-reap.test.ts @@ -0,0 +1,79 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import { $selectedStoredSessionId, $unreadFinishedSessionIds } from '@/store/session' +import { $attentionSessionIds, $workingSessionIds, clearAllSessionStates } from '@/store/session-states' + +import { rehydrateLiveSessionStatuses } from './use-background-sync' + +/** + * `session.active_list` is the authoritative snapshot of what is RUNNING in the + * polled gateway process. A session that finished while Desktop was looking + * elsewhere — or whose runtime id was recycled by a backend respawn — simply + * stops appearing in the response. Absence is therefore a completion signal, + * not "no news": if nothing reaps it, the row spins forever and the + * busy→idle edge that paints the green "your turn" dot never fires. + */ +describe('rehydrateLiveSessionStatuses — reaping vanished runtimes', () => { + beforeEach(() => { + vi.useFakeTimers() + $selectedStoredSessionId.set(null) + $unreadFinishedSessionIds.set([]) + }) + + afterEach(() => { + vi.clearAllTimers() + vi.useRealTimers() + clearAllSessionStates() + $unreadFinishedSessionIds.set([]) + }) + + it('clears a working session that disappears from the live snapshot', () => { + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-a', session_key: 'stored-a', status: 'working' }] + }) + + expect($workingSessionIds.get()).toEqual(['stored-a']) + + // The turn finished and the gateway reaped the session between polls. + rehydrateLiveSessionStatuses({ sessions: [] }) + + expect($workingSessionIds.get()).toEqual([]) + }) + + it('fires the unread "your turn" marker for a vanished background session', () => { + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-b', session_key: 'stored-b', status: 'working' }] + }) + + rehydrateLiveSessionStatuses({ sessions: [] }) + + expect($unreadFinishedSessionIds.get()).toEqual(['stored-b']) + }) + + it('clears a blocked session that disappears from the live snapshot', () => { + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-c', session_key: 'stored-c', status: 'waiting' }] + }) + + expect($attentionSessionIds.get()).toEqual(['stored-c']) + + rehydrateLiveSessionStatuses({ sessions: [] }) + + expect($attentionSessionIds.get()).toEqual([]) + }) + + it('leaves runtimes this poll never seeded alone', () => { + // A background PROFILE's sessions are served by a different gateway and + // never appear in this profile's active_list. Reaping them would dark out + // every other profile's running rows. + rehydrateLiveSessionStatuses( + { sessions: [{ id: 'runtime-other', session_key: 'stored-other', status: 'working' }] }, + Date.now(), + 'other' + ) + + rehydrateLiveSessionStatuses({ sessions: [] }, Date.now(), 'default') + + expect($workingSessionIds.get()).toEqual(['stored-other']) + }) +}) diff --git a/apps/desktop/src/app/contrib/hooks/live-status-spinner.test.ts b/apps/desktop/src/app/contrib/hooks/live-status-spinner.test.ts new file mode 100644 index 0000000000..4fcad3b1a2 --- /dev/null +++ b/apps/desktop/src/app/contrib/hooks/live-status-spinner.test.ts @@ -0,0 +1,77 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import { $selectedStoredSessionId, $unreadFinishedSessionIds } from '@/store/session' +import { $workingSessionIds, clearAllSessionStates } from '@/store/session-states' + +import { rehydrateLiveSessionStatuses, resetLiveRuntimeTracking } from './use-background-sync' + +/** + * (C) The sidebar spinner is driven by `$workingSessionIds`, which is keyed by + * STORED session id. A turn that STARTS while Desktop isn't receiving stream + * events — a background profile, a degraded remote socket, a session opened on + * another surface — is only ever learned about through the `session.active_list` + * poll. If that poll can't seed a row the renderer has never seen, the thread + * name never gets its arc even though the backend is plainly working. + */ +describe('rehydrateLiveSessionStatuses — seeding a turn the renderer never saw start', () => { + beforeEach(() => { + vi.useFakeTimers() + $selectedStoredSessionId.set(null) + $unreadFinishedSessionIds.set([]) + resetLiveRuntimeTracking() + }) + + afterEach(() => { + vi.clearAllTimers() + vi.useRealTimers() + clearAllSessionStates() + resetLiveRuntimeTracking() + $unreadFinishedSessionIds.set([]) + }) + + it('shows the spinner for a turn that started with no stream events', () => { + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-cold', session_key: 'stored-cold', status: 'working' }] + }) + + expect($workingSessionIds.get()).toContain('stored-cold') + }) + + it('keeps the spinner across polls while the turn is still running', () => { + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-cold', session_key: 'stored-cold', status: 'working' }] + }) + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-cold', session_key: 'stored-cold', status: 'working' }] + }) + + expect($workingSessionIds.get()).toContain('stored-cold') + }) + + it('shows the spinner when a runtime id is recycled onto a new stored session', () => { + // A respawned backend can mint the same runtime id for a different stored + // session. The row for the NEW stored id must light up, not the stale one. + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-1', session_key: 'stored-old', status: 'working' }] + }) + + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-1', session_key: 'stored-new', status: 'working' }] + }) + + expect($workingSessionIds.get()).toContain('stored-new') + expect($workingSessionIds.get()).not.toContain('stored-old') + }) + + it('leaves a starting session idle — the agent build is not proof of a turn', () => { + // `starting` = `agent_build_started` without `agent_ready`. _start_agent_build + // runs on the first prompt OR any incidental RPC that needs the agent, so it + // is not proof of a turn — lighting the spinner here would fire on merely + // opening a session. A real turn arrives as `working`. + rehydrateLiveSessionStatuses({ + sessions: [{ id: 'runtime-boot', session_key: 'stored-boot', status: 'starting' }] + }) + + expect($workingSessionIds.get()).not.toContain('stored-boot') + }) +}) diff --git a/apps/desktop/src/app/contrib/hooks/use-background-sync.ts b/apps/desktop/src/app/contrib/hooks/use-background-sync.ts index 5925b4a7df..68a802dbc9 100644 --- a/apps/desktop/src/app/contrib/hooks/use-background-sync.ts +++ b/apps/desktop/src/app/contrib/hooks/use-background-sync.ts @@ -37,11 +37,30 @@ interface LiveSessionStatusResponse { sessions?: LiveSessionStatusItem[] } +// Runtime ids this poll has seen live, per gateway profile. A profile only +// ever reaps what its OWN snapshot previously reported: background profiles are +// served by different gateways and never appear in this profile's active_list, +// so an unscoped reap would dark out every other profile's running rows. +const liveRuntimeIdsByProfile = new Map>() + /** Restore sidebar liveness after a renderer/backend reconnect. Stream events * normally own these states, but events emitted while Desktop was disconnected * cannot be replayed. `session.active_list` is the authoritative in-memory - * snapshot and does not resume, focus, or otherwise mutate a chat. */ -export function rehydrateLiveSessionStatuses(response: LiveSessionStatusResponse, nowMs = Date.now()): void { + * snapshot and does not resume, focus, or otherwise mutate a chat. + * + * The snapshot is authoritative about ABSENCE too. A turn that ends while the + * websocket is degraded — a remote gateway over a flaky link, a reconnect, a + * profile swap — drops out of `_sessions` without Desktop ever seeing the + * `running: false` edge, so the row keeps spinning and the busy→idle transition + * that paints the green "your turn" dot never fires. Reaping runtimes that + * vanish between polls restores both. */ +export function rehydrateLiveSessionStatuses( + response: LiveSessionStatusResponse, + nowMs = Date.now(), + profileKey = 'default' +): void { + const seen = new Set() + for (const session of response.sessions ?? []) { const runtimeSessionId = session.id?.trim() const storedSessionId = session.session_key?.trim() @@ -52,6 +71,8 @@ export function rehydrateLiveSessionStatuses(response: LiveSessionStatusResponse continue } + seen.add(runtimeSessionId) + const existing = $sessionStates.get()[runtimeSessionId] // Avoid re-arming the watchdog on every poll. Publish only when the @@ -87,6 +108,44 @@ export function rehydrateLiveSessionStatuses(response: LiveSessionStatusResponse setSessionStalled(storedSessionId, isQuiet) } + + // A runtime this profile's snapshot reported live LAST poll but not this one + // has ended: the gateway reaps a session out of `_sessions` when its turn + // completes and its transport goes away. Settle it through the normal publish + // path so the busy→idle transition fires — that edge is what clears the + // spinner AND marks the row unread ("your turn"). Only ids this profile + // previously saw are eligible, so another profile's live rows are untouched. + const previouslyLive = liveRuntimeIdsByProfile.get(profileKey) + + if (previouslyLive) { + for (const runtimeSessionId of previouslyLive) { + if (seen.has(runtimeSessionId)) { + continue + } + + const existing = $sessionStates.get()[runtimeSessionId] + + if (existing?.busy || existing?.needsInput) { + publishSessionState(runtimeSessionId, { + ...existing, + awaitingResponse: false, + busy: false, + needsInput: false, + streamId: null, + turnStartedAt: null + }) + } + } + } + + liveRuntimeIdsByProfile.set(profileKey, seen) +} + +/** Forget every profile's live-runtime bookkeeping. A gateway wipe already + * drops the session states these ids point at, so a carried-over set would + * only reap runtimes that no longer exist. */ +export function resetLiveRuntimeTracking(): void { + liveRuntimeIdsByProfile.clear() } interface BackgroundSyncParams { @@ -191,7 +250,7 @@ export function useBackgroundSync({ const response = await requestGateway('session.active_list', {}) if (!cancelled) { - rehydrateLiveSessionStatuses(response) + rehydrateLiveSessionStatuses(response, Date.now(), activeGatewayProfile) } } catch { // Older gateways may not expose session.active_list. Live stream events diff --git a/apps/desktop/src/app/contrib/hooks/use-quick-entry-bridge.ts b/apps/desktop/src/app/contrib/hooks/use-quick-entry-bridge.ts new file mode 100644 index 0000000000..dbd886e18f --- /dev/null +++ b/apps/desktop/src/app/contrib/hooks/use-quick-entry-bridge.ts @@ -0,0 +1,128 @@ +import { useEffect, useRef } from 'react' + +import { + initQuickEntryBridge, + QUICK_TARGET_CURRENT, + QUICK_TARGET_NEW, + type QuickEntrySessionOption, + setQuickEntrySubmitHandler +} from '@/store/quick-entry' +import { $gatewayState, $sessions } from '@/store/session' +import { sessionTileDelegate } from '@/store/session-states' +import { isSecondaryWindow } from '@/store/windows' + +interface QuickEntryBridgeParams { + startFreshSessionDraft: () => void + submitText: (text: string) => Promise | unknown +} + +// The picker is a capture aid, not a session browser — a handful of recent +// rows is the whole point. +const QUICK_ENTRY_SESSION_OPTIONS = 5 + +function sessionOptions(): QuickEntrySessionOption[] { + return $sessions + .get() + .filter(session => !session.archived) + .slice(0, QUICK_ENTRY_SESSION_OPTIONS) + .map(session => ({ + id: session.id, + title: session.title?.trim() || session.preview?.trim() || session.id + })) +} + +/** + * Wires the global-hotkey Quick Entry window back into the app, both ways: + * + * - **Inbound:** text captured there is routed by target and submitted through + * THIS window's normal prompt machinery — current chat rides `submitText`, a + * picked stored session rides the session-tile delegate (resume + submit, + * background, without touching the primary view — the same path tiled + * sessions use), and "new session" is a fresh draft + submit, exactly what + * clicking New Chat and typing does. One submit pipeline, no bespoke RPC. + * - **Outbound:** gateway connection state + the recent-session list are pushed + * to the quick window (via main, which caches the latest push), so its input + * disables with a reconnect hint whenever the backend is unreachable. + * + * Handlers register ONCE through refs tracking the latest callbacks — + * re-registering on identity churn leaves a nulled-handler window that can drop + * a submit (the same bug shape use-pet-bridge guards). Primary window only: a + * secondary session window must not also claim the global capture channel, or + * one keystroke would send N prompts. + */ +export function useQuickEntryBridge({ startFreshSessionDraft, submitText }: QuickEntryBridgeParams): void { + const submitTextRef = useRef(submitText) + submitTextRef.current = submitText + const startFreshRef = useRef(startFreshSessionDraft) + startFreshRef.current = startFreshSessionDraft + + useEffect(() => { + if (isSecondaryWindow()) { + return + } + + setQuickEntrySubmitHandler(({ target, text }) => { + if (target === QUICK_TARGET_NEW) { + // Same as the user clicking New Chat and typing: fresh draft, then the + // normal submit creates the backend session. + startFreshRef.current() + void submitTextRef.current(text) + + return + } + + if (target !== QUICK_TARGET_CURRENT) { + // A picked stored session: resume + submit in the background through + // the session-tile delegate so the primary view stays where it is. + const delegate = sessionTileDelegate() + + if (delegate) { + void delegate + .resumeTile(target) + .then(runtimeId => delegate.submitToSession(runtimeId, text)) + // A dead/undeliverable target must not swallow the prompt. + .catch(() => void submitTextRef.current(text)) + + return + } + } + + void submitTextRef.current(text) + }) + + const dispose = initQuickEntryBridge() + + return () => { + setQuickEntrySubmitHandler(null) + dispose() + } + }, []) + + // Push gateway truth into the quick window whenever it changes: connection + // state gates its input; the recent-session list feeds its target picker. + useEffect(() => { + if (isSecondaryWindow()) { + return + } + + const api = window.hermesDesktop?.quickEntry + + if (!api?.pushState) { + return + } + + const push = () => { + api.pushState({ connected: $gatewayState.get() === 'open', sessions: sessionOptions() }) + } + + push() + + const offGateway = $gatewayState.listen(push) + const offSessions = $sessions.listen(push) + + return () => { + offGateway() + offSessions() + } + }, []) +} diff --git a/apps/desktop/src/app/contrib/wiring.tsx b/apps/desktop/src/app/contrib/wiring.tsx index ffdc79e65b..de2e0becff 100644 --- a/apps/desktop/src/app/contrib/wiring.tsx +++ b/apps/desktop/src/app/contrib/wiring.tsx @@ -16,6 +16,7 @@ import { useLocation, useNavigate } from 'react-router-dom' import { formatRefValue } from '@/components/assistant-ui/directive-text' import { BootFailureOverlay } from '@/components/boot-failure-overlay' import { DesktopInstallOverlay } from '@/components/desktop-install-overlay' +import { FindBar } from '@/components/find-bar' import { GatewayConnectingOverlay } from '@/components/gateway-connecting-overlay' import { NotificationStack } from '@/components/notifications' import { DesktopOnboardingOverlay } from '@/components/onboarding' @@ -107,6 +108,7 @@ import { ContribWiringContext } from './context' import { useBackgroundSync } from './hooks/use-background-sync' import { useDesktopIntegrations } from './hooks/use-desktop-integrations' import { usePetBridge } from './hooks/use-pet-bridge' +import { useQuickEntryBridge } from './hooks/use-quick-entry-bridge' import { useSessionTileDelegate } from './hooks/use-session-tile-delegate' import { $restartPreviewServer, useTitlebarToolContributions } from './panes' import { ChatRoutesSurface, SidebarSurface, StatusbarSurface, TerminalSurface } from './surfaces' @@ -607,6 +609,11 @@ export function ContribWiring({ children }: { children: ReactNode }) { // The popped-out pet overlay's bridge back into the app. usePetBridge({ requestGateway, resumeSession, submitText }) + // The global-hotkey Quick Entry window's bridge: its captured text rides the + // SAME submit machinery the normal composer uses (current chat / picked + // session / new session), and it hears gateway truth from this window. + useQuickEntryBridge({ startFreshSessionDraft, submitText }) + // Clear a failed turn's red error banner. Errors are renderer-local (never // persisted): a bare error placeholder is dropped entirely; a partial-output // failure keeps its content and sheds the error. Both the runtime cache AND @@ -978,6 +985,7 @@ export function ContribWiring({ children }: { children: ReactNode }) { + {settingsOpen && ( diff --git a/apps/desktop/src/app/hooks/use-keybinds.ts b/apps/desktop/src/app/hooks/use-keybinds.ts index e4c84963d6..8a1fe27547 100644 --- a/apps/desktop/src/app/hooks/use-keybinds.ts +++ b/apps/desktop/src/app/hooks/use-keybinds.ts @@ -5,11 +5,18 @@ import { closeActiveTab } from '@/app/chat/close-tab' import { $terminalTakeover, setTerminalTakeover } from '@/app/right-sidebar/store' import { closeActiveTerminal, createTerminal, cycleTerminal } from '@/app/right-sidebar/terminal/terminals' import { activateTreeTabSlot, cycleTreeTabInFocusedZone, layoutHasRootSide } from '@/components/pane-shell/tree/store' +import { findBarClaimsCombo } from '@/lib/find-in-page' import { contributedKeybindHandler, PROFILE_SLOT_COUNT, SESSION_SLOT_COUNT } from '@/lib/keybinds/actions' import { comboAllowedInInput, comboFromEvent, isEditableTarget } from '@/lib/keybinds/combo' import { composerFocusKeysAllowed, isComposerFocusSoftCombo, typeToFocusChar } from '@/lib/keybinds/composer-focus-keys' import { $repoStatus } from '@/store/coding-status' import { toggleCommandPalette } from '@/store/command-palette' +import { + $findInPage, + findNext as findNextMatch, + findPrevious as findPreviousMatch, + openFindBar +} from '@/store/find-in-page' import { $capture, $comboIndex, endCapture, setBinding } from '@/store/keybinds' import { requestSessionSearchFocus, @@ -188,6 +195,14 @@ export function useKeybinds(deps: KeybindRuntimeDeps): void { // the Win/Linux path where ⌘W reaches the renderer directly. 'view.closeTab': () => void closeActiveTab(id => navigate(sessionRoute(id))), 'view.reopenTab': reopenLastClosedTile, + 'view.findInPage': openFindBar, + // ⌘G / ⌘⇧G are handled by the find bar's own capture-phase listener while + // it is open (so they don't collide with `view.toggleReview`). These + // registry handlers cover a user-assigned dedicated chord: stepping is a + // no-op unless the bar is open with a query, so a bound key can't search + // invisibly. + 'view.findNext': findNextMatch, + 'view.findPrevious': findPreviousMatch, 'appearance.toggleMode': () => setMode(resolvedMode === 'dark' ? 'light' : 'dark'), @@ -243,6 +258,16 @@ export function useKeybinds(deps: KeybindRuntimeDeps): void { return } + // The open find bar owns ⌘G / ⌘⇧G / Escape. Its own capture-phase + // listener runs those actions; bail here so the registry doesn't ALSO + // fire the action bound to the same combo (⌘G = view.toggleReview, + // Escape = composer.cancel, which would abort a live turn). Both + // listeners are on `window`, so stopPropagation in the bar can't + // suppress this one — the dispatcher has to yield explicitly. + if ($findInPage.get().active && findBarClaimsCombo(combo)) { + return + } + const actionId = $comboIndex.get().get(combo) // Unbound printable → type-to-focus. Bound chords (shift+n, …) win above. diff --git a/apps/desktop/src/app/model-picker-overlay.tsx b/apps/desktop/src/app/model-picker-overlay.tsx index e51a0e4de1..b6599a14fb 100644 --- a/apps/desktop/src/app/model-picker-overlay.tsx +++ b/apps/desktop/src/app/model-picker-overlay.tsx @@ -3,6 +3,7 @@ import { useStore } from '@nanostores/react' import type { ModelSelection } from '@/app/shell/model-menu-panel' import { ModelPickerDialog } from '@/components/model-picker' import type { HermesGateway } from '@/hermes' +import { useStoreSelector } from '@/lib/use-session-slice' import { $activeSessionId, $currentModel, @@ -24,15 +25,22 @@ export function ModelPickerOverlay({ gateway, onSelect, profile }: ModelPickerOv const primaryModel = useStore($currentModel) const primaryProvider = useStore($currentProvider) const focusedRuntimeId = useStore($focusedRuntimeId) - const focusedState = useStore($focusedSessionState) + // `$focusedSessionState` is a projection of `$sessionStates`, republished on + // EVERY message delta — and this overlay is mounted app-wide. Only two + // fields are read off it, so subscribing to the whole object re-rendered + // this component (and the un-memoized closed dialog below) per token while + // the focused session streamed. Select each scalar so an unchanged + // model/provider bails out instead — same fix as the statusbar (#72163). + const focusedModel = useStoreSelector($focusedSessionState, state => state?.model ?? null) + const focusedProvider = useStoreSelector($focusedSessionState, state => state?.provider ?? null) const gatewayOpen = useStore($gatewayState) === 'open' const open = useStore($modelPickerOpen) // Prefer the focused tile's runtime when the overlay opens from a tile that // lacked a live menu (gateway closed → fallback path). const sessionId = focusedRuntimeId ?? primarySessionId - const currentModel = focusedRuntimeId && focusedState ? focusedState.model : primaryModel - const currentProvider = focusedRuntimeId && focusedState ? focusedState.provider : primaryProvider + const currentModel = focusedRuntimeId && focusedModel !== null ? focusedModel : primaryModel + const currentProvider = focusedRuntimeId && focusedProvider !== null ? focusedProvider : primaryProvider if (!gatewayOpen) { return null diff --git a/apps/desktop/src/app/pet-overlay/pet-overlay-app.tsx b/apps/desktop/src/app/pet-overlay/pet-overlay-app.tsx index 875ef0ca01..928294c482 100644 --- a/apps/desktop/src/app/pet-overlay/pet-overlay-app.tsx +++ b/apps/desktop/src/app/pet-overlay/pet-overlay-app.tsx @@ -433,7 +433,7 @@ export function PetOverlayApp() {
- + {/* Hearts on the popped-out pet — identical to in-window. */} (null) + + // The reducer returns { send, state }; this wrapper performs the side effect + // (hand the payload to the shell, ask to hide) and stores the next state, so + // the decision stays pure and testable while the effects stay in one place. + const [state, dispatch] = useReducer((current: QuickComposerState, event: QuickComposerEvent) => { + const { send, state: next } = quickComposerReducer(current, event) + const api = window.hermesDesktop?.quickEntry + + if (send) { + api?.submit(send) + } else if (!next.visible && current.visible) { + api?.dismiss() + } + + return next + }, initialQuickComposerState) + + // Re-summoned by the chord: the shell reuses the window, so reset the draft + // and take the keyboard back for a fresh capture. Also adopt gateway-state + // pushes (connection + recent sessions) relayed from the primary renderer. + useEffect(() => { + const api = window.hermesDesktop?.quickEntry + + const offShown = api?.onShown(() => { + dispatch({ type: 'shown' }) + requestAnimationFrame(() => inputRef.current?.focus()) + }) + + const offState = api?.onState(payload => { + dispatch({ + connected: payload?.connected === true, + sessions: Array.isArray(payload?.sessions) ? payload.sessions : [], + type: 'state' + }) + }) + + inputRef.current?.focus() + + return () => { + offShown?.() + offState?.() + } + }, []) + + return ( +
+
+
+ + › + + { + // Moving focus to the target picker is not leaving the window. + if (!event.relatedTarget) { + dispatch({ type: 'blur' }) + } + }} + onChange={event => dispatch({ draft: event.target.value, type: 'edit' })} + onKeyDown={event => { + if (event.key === 'Enter' && !event.shiftKey) { + event.preventDefault() + dispatch({ type: 'submit' }) + } else if (event.key === 'Escape') { + event.preventDefault() + dispatch({ type: 'dismiss' }) + } + }} + placeholder={state.connected ? 'Ask Hermes…' : 'Not connected — open Hermes to reconnect'} + ref={inputRef} + spellCheck={false} + style={{ + background: 'transparent', + border: 'none', + color: 'var(--foreground, #eee)', + flex: 1, + fontFamily: 'inherit', + fontSize: 15, + minWidth: 0, + opacity: state.connected ? 1 : 0.55, + outline: 'none' + }} + value={state.draft} + /> +
+
+ + +
+
+
+ ) +} diff --git a/apps/desktop/src/app/quick-entry/quick-entry-root.tsx b/apps/desktop/src/app/quick-entry/quick-entry-root.tsx new file mode 100644 index 0000000000..a45cb926ba --- /dev/null +++ b/apps/desktop/src/app/quick-entry/quick-entry-root.tsx @@ -0,0 +1,38 @@ +import { StrictMode } from 'react' +import { createRoot } from 'react-dom/client' + +import { ErrorBoundary } from '@/components/error-boundary' +import { ThemeProvider } from '@/themes/context' + +import { QuickEntryApp } from './quick-entry-app' + +/** + * Boot the Quick Entry window. Loaded by the same bundle as the main app but via + * `?win=quick`, so it shares CSS/theme tokens while mounting a minimal capture + * surface (no app shell, no gateway, no router). + * + * The index.html boot script paints an OPAQUE themed background to avoid a flash + * in normal windows; this window is a floating card on a transparent backdrop, + * so force the host layers see-through (same trick as the pet overlay). + */ +export function mountQuickEntry(): void { + const style = document.createElement('style') + style.textContent = 'html,body,#root{background:transparent !important;}' + document.head.appendChild(style) + + const root = document.getElementById('root') + + if (!root) { + return + } + + createRoot(root).render( + + + + + + + + ) +} diff --git a/apps/desktop/src/app/right-sidebar/terminal/persistent.test.tsx b/apps/desktop/src/app/right-sidebar/terminal/persistent.test.tsx new file mode 100644 index 0000000000..c0f718e546 --- /dev/null +++ b/apps/desktop/src/app/right-sidebar/terminal/persistent.test.tsx @@ -0,0 +1,312 @@ +import { act, type ReactNode } from 'react' +import { createRoot, type Root } from 'react-dom/client' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import { PersistentTerminal, TerminalSlot } from './persistent' + +vi.mock('./terminals', () => ({ + ensureTerminal: vi.fn() +})) + +vi.mock('./workspace', () => ({ + TerminalWorkspace: () =>
+})) + +let resizeObserverCallback: ResizeObserverCallback | null = null +let mutationObserverCallback: MutationCallback | null = null +let mutationObserveCalls: Array<{ options?: MutationObserverInit; target: Node }> = [] +let root: Root | null = null +let container: HTMLDivElement | null = null +let windowStateCallback: ((payload: { isMinimized?: boolean; isVisible?: boolean }) => void) | null = null + +function render(ui: ReactNode) { + container = document.createElement('div') + document.body.append(container) + root = createRoot(container) + + act(() => { + root!.render(ui) + }) +} + +function cleanup() { + if (root) { + act(() => { + root!.unmount() + }) + } + + container?.remove() + root = null + container = null +} + +function setVisibility(hidden: boolean) { + Object.defineProperty(document, 'hidden', { configurable: true, value: hidden }) + Object.defineProperty(document, 'visibilityState', { configurable: true, value: hidden ? 'hidden' : 'visible' }) +} + +function installWindowStateBridge() { + windowStateCallback = null + Object.defineProperty(window, 'hermesDesktop', { + configurable: true, + value: { + onWindowStateChanged: vi.fn((callback: typeof windowStateCallback) => { + windowStateCallback = callback + + return () => { + if (windowStateCallback === callback) { + windowStateCallback = null + } + } + }) + } + }) +} + +function rect(top: number, left: number, width: number, height: number): DOMRect { + return { + bottom: top + height, + height, + left, + right: left + width, + top, + width, + x: left, + y: top, + toJSON: () => ({}) + } as DOMRect +} + +function installRaf() { + let nextId = 1 + const frames = new Map() + + const request = vi.fn((callback: FrameRequestCallback) => { + const id = nextId++ + frames.set(id, callback) + + return id + }) + + const cancel = vi.fn((id: number) => { + frames.delete(id) + }) + + Object.defineProperty(window, 'requestAnimationFrame', { configurable: true, value: request }) + Object.defineProperty(window, 'cancelAnimationFrame', { configurable: true, value: cancel }) + + return { + cancel, + pending: () => frames.size, + request, + runNext: () => { + const next = frames.entries().next().value + + if (!next) { + throw new Error('No pending RAF') + } + + const [id, callback] = next + frames.delete(id) + callback(0) + } + } +} + +function Harness() { + return ( + <> + + undefined} /> + + ) +} + +describe('PersistentTerminal rect tracking', () => { + beforeEach(() => { + ;(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true + setVisibility(false) + vi.spyOn(document, 'hasFocus').mockReturnValue(true) + installWindowStateBridge() + resizeObserverCallback = null + mutationObserverCallback = null + mutationObserveCalls = [] + vi.stubGlobal( + 'ResizeObserver', + class { + constructor(callback: ResizeObserverCallback) { + resizeObserverCallback = callback + } + + disconnect = vi.fn() + observe = vi.fn() + unobserve = vi.fn() + } as unknown as typeof ResizeObserver + ) + vi.stubGlobal( + 'MutationObserver', + class { + constructor(callback: MutationCallback) { + mutationObserverCallback = callback + } + + disconnect = vi.fn() + observe = vi.fn((target: Node, options?: MutationObserverInit) => { + mutationObserveCalls.push({ options, target }) + }) + takeRecords = vi.fn(() => []) + } as unknown as typeof MutationObserver + ) + }) + + afterEach(() => { + cleanup() + vi.unstubAllGlobals() + vi.restoreAllMocks() + setVisibility(false) + delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop + }) + + it('settles after rect changes instead of polling forever', () => { + const raf = installRaf() + let currentRect = rect(10, 20, 200, 100) + vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(() => currentRect) + + render() + + expect(raf.request).toHaveBeenCalledTimes(1) + + act(() => { + raf.runNext() + }) + + expect(raf.request).toHaveBeenCalledTimes(1) + expect(raf.pending()).toBe(0) + + currentRect = rect(12, 24, 220, 120) + act(() => { + resizeObserverCallback?.([], {} as ResizeObserver) + }) + + expect(raf.request).toHaveBeenCalledTimes(2) + + act(() => { + raf.runNext() + }) + + expect(raf.request).toHaveBeenCalledTimes(3) + + act(() => { + raf.runNext() + }) + + expect(raf.request).toHaveBeenCalledTimes(3) + expect(raf.pending()).toBe(0) + }) + + it('remeasures when layout moves the slot without resizing it', () => { + const raf = installRaf() + let currentRect = rect(10, 20, 200, 100) + vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(() => currentRect) + + render() + + expect(mutationObserveCalls.some(call => call.options?.subtree === true)).toBe(true) + + act(() => { + raf.runNext() + }) + + const overlay = container!.lastElementChild as HTMLElement + expect(overlay.style.top).toBe('10px') + expect(overlay.style.left).toBe('20px') + expect(raf.pending()).toBe(0) + + currentRect = rect(32, 48, 200, 100) + act(() => { + mutationObserverCallback?.([], {} as MutationObserver) + }) + + expect(raf.request).toHaveBeenCalledTimes(2) + + act(() => { + raf.runNext() + }) + + expect(overlay.style.top).toBe('32px') + expect(overlay.style.left).toBe('48px') + + act(() => { + raf.runNext() + }) + + expect(raf.pending()).toBe(0) + }) + + it('does not schedule rect RAFs while the Electron window is paused, then resumes when visible', () => { + const raf = installRaf() + vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockReturnValue(rect(10, 20, 200, 100)) + + render() + + expect(raf.request).toHaveBeenCalledTimes(1) + + act(() => { + windowStateCallback?.({ isMinimized: true, isVisible: false }) + }) + + expect(raf.cancel).toHaveBeenCalledTimes(1) + expect(raf.pending()).toBe(0) + + act(() => { + resizeObserverCallback?.([], {} as ResizeObserver) + }) + + expect(raf.request).toHaveBeenCalledTimes(1) + + act(() => { + windowStateCallback?.({ isMinimized: false, isVisible: true }) + }) + + expect(raf.request).toHaveBeenCalledTimes(2) + }) + + it('suspends while unfocused and cancels every callback on unmount', () => { + const raf = installRaf() + vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockReturnValue(rect(10, 20, 200, 100)) + + render() + expect(raf.pending()).toBe(1) + + act(() => window.dispatchEvent(new Event('blur'))) + expect(raf.pending()).toBe(0) + + act(() => window.dispatchEvent(new Event('focus'))) + expect(raf.pending()).toBe(1) + + cleanup() + expect(raf.pending()).toBe(0) + + act(() => { + window.dispatchEvent(new Event('focus')) + resizeObserverCallback?.([], {} as ResizeObserver) + mutationObserverCallback?.([], {} as MutationObserver) + }) + expect(raf.pending()).toBe(0) + }) + + it('does not schedule an initial frame when mounted while unfocused', () => { + const raf = installRaf() + vi.mocked(document.hasFocus).mockReturnValue(false) + vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockReturnValue(rect(10, 20, 200, 100)) + + render() + + expect(raf.request).not.toHaveBeenCalled() + + act(() => window.dispatchEvent(new Event('focus'))) + + expect(raf.pending()).toBe(1) + }) +}) diff --git a/apps/desktop/src/app/right-sidebar/terminal/persistent.tsx b/apps/desktop/src/app/right-sidebar/terminal/persistent.tsx index e0ef66cedd..3fe2edb04a 100644 --- a/apps/desktop/src/app/right-sidebar/terminal/persistent.tsx +++ b/apps/desktop/src/app/right-sidebar/terminal/persistent.tsx @@ -2,6 +2,8 @@ import { useStore } from '@nanostores/react' import { atom } from 'nanostores' import { type CSSProperties, useEffect, useLayoutEffect, useRef, useState } from 'react' +import { createRendererLoopPauseController } from '@/lib/renderer-loop-pause' + import { $terminalTakeover } from '../store' import { ensureTerminal } from './terminals' @@ -83,8 +85,23 @@ export function PersistentTerminal({ onAddSelectionToChat }: PersistentTerminalP let prev: Rect | null = null let frame = 0 + let stopped = false + let pauseController: ReturnType | null = null + + const rendererPaused = () => pauseController?.isPaused() ?? document.visibilityState === 'hidden' + + const cancelFrame = () => { + if (frame !== 0) { + window.cancelAnimationFrame(frame) + frame = 0 + } + } + + const measure = (): boolean => { + if (rendererPaused()) { + return false + } - const tick = () => { const r = slot.getBoundingClientRect() // floor top/left + ceil right/bottom: overlay always covers the slot's // full pixel footprint, so half-pixel rects can't leak page bg through. @@ -99,14 +116,80 @@ export function PersistentTerminal({ onAddSelectionToChat }: PersistentTerminalP if (next.width > 0 && next.height > 0) { setReady(true) } + + return true } - frame = requestAnimationFrame(tick) + return false } - tick() + const scheduleMeasure = () => { + if (stopped || rendererPaused() || frame !== 0) { + return + } - return () => cancelAnimationFrame(frame) + frame = window.requestAnimationFrame(() => { + frame = 0 + + if (measure()) { + scheduleMeasure() + } + }) + } + + const handleVisibilityChange = () => { + if (rendererPaused()) { + cancelFrame() + + return + } + + scheduleMeasure() + } + + const observer = + typeof ResizeObserver === 'undefined' + ? null + : new ResizeObserver(() => { + scheduleMeasure() + }) + + const positionObserver = + typeof MutationObserver === 'undefined' + ? null + : new MutationObserver(() => { + scheduleMeasure() + }) + + pauseController = createRendererLoopPauseController(handleVisibilityChange) + + if (measure()) { + scheduleMeasure() + } + + observer?.observe(slot) + + for (let node: HTMLElement | null = slot; node; node = node.parentElement) { + positionObserver?.observe(node, { + attributeFilter: ['class', 'style', 'hidden', 'aria-hidden', 'data-state'], + attributes: true, + childList: true, + subtree: true + }) + } + + window.addEventListener('resize', scheduleMeasure) + window.addEventListener('scroll', scheduleMeasure, true) + + return () => { + stopped = true + cancelFrame() + observer?.disconnect() + positionObserver?.disconnect() + window.removeEventListener('resize', scheduleMeasure) + window.removeEventListener('scroll', scheduleMeasure, true) + pauseController?.dispose() + } }, [slot]) const visible = Boolean(rect && rect.width > 0 && rect.height > 0) diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/delta-flush.test.tsx b/apps/desktop/src/app/session/hooks/use-message-stream/delta-flush.test.tsx new file mode 100644 index 0000000000..1a572c329a --- /dev/null +++ b/apps/desktop/src/app/session/hooks/use-message-stream/delta-flush.test.tsx @@ -0,0 +1,111 @@ +import { QueryClient } from '@tanstack/react-query' +import { act, cleanup, render } from '@testing-library/react' +import { useEffect, useRef } from 'react' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import type { ClientSessionState } from '@/app/types' +import { createClientSessionState } from '@/lib/chat-runtime' + +import { useMessageStream } from './index' + +const SID = 'session-1' +let appendAssistantDelta: ((sessionId: string, delta: string) => void) | null = null +let states: Map +type UpdateSessionState = ( + sessionId: string, + updater: (state: ClientSessionState) => ClientSessionState, + storedSessionId?: string | null +) => ClientSessionState +let updateSessionState: ReturnType> + +function Harness() { + const activeSessionIdRef = useRef(SID) + const sessionStateByRuntimeIdRef = useRef(states) + const queryClientRef = useRef(new QueryClient()) + + const stream = useMessageStream({ + activeSessionIdRef, + hydrateFromStoredSession: vi.fn(async () => undefined), + queryClient: queryClientRef.current, + refreshHermesConfig: vi.fn(async () => undefined), + refreshSessions: vi.fn(async () => undefined), + sessionStateByRuntimeIdRef, + updateSessionState + }) + + useEffect(() => { + appendAssistantDelta = stream.appendAssistantDelta + }, [stream.appendAssistantDelta]) + + return null +} + +function mountStream() { + render() + expect(appendAssistantDelta).not.toBeNull() +} + +function assistantText() { + const message = states.get(SID)?.messages.at(-1) + const part = message?.parts.at(-1) + + return part?.type === 'text' ? part.text : '' +} + +describe('useMessageStream delta flush scheduling', () => { + beforeEach(() => { + vi.useFakeTimers() + appendAssistantDelta = null + states = new Map() + updateSessionState = vi.fn((sessionId: string, updater: (state: ClientSessionState) => ClientSessionState) => { + const next = updater(states.get(sessionId) ?? createClientSessionState()) + states.set(sessionId, next) + + return next + }) + vi.spyOn(performance, 'now').mockReturnValue(100) + vi.spyOn(window, 'requestAnimationFrame').mockImplementation(() => 1) + vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => undefined) + vi.spyOn(document, 'hasFocus').mockReturnValue(false) + }) + + afterEach(() => { + cleanup() + vi.useRealTimers() + vi.restoreAllMocks() + }) + + it('flushes streaming text on a bounded timer while the window is unfocused', async () => { + mountStream() + + act(() => appendAssistantDelta!(SID, 'still streaming')) + + expect(window.requestAnimationFrame).not.toHaveBeenCalled() + expect(assistantText()).toBe('') + + await act(async () => { + await vi.advanceTimersByTimeAsync(0) + }) + + expect(assistantText()).toBe('still streaming') + }) + + it('cancels the pending timer on unmount and flushes exactly once', async () => { + vi.mocked(performance.now).mockReturnValue(0) + mountStream() + + act(() => appendAssistantDelta!(SID, 'final delta')) + expect(vi.getTimerCount()).toBe(1) + + cleanup() + + expect(vi.getTimerCount()).toBe(0) + expect(assistantText()).toBe('final delta') + const updatesAfterUnmount = updateSessionState.mock.calls.length + + await vi.advanceTimersByTimeAsync(100) + + expect(updateSessionState).toHaveBeenCalledTimes(updatesAfterUnmount) + expect(window.requestAnimationFrame).not.toHaveBeenCalled() + }) +}) diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts index 101fe7e59b..4e0a439219 100644 --- a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts +++ b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts @@ -22,6 +22,7 @@ import { clearClarifyRequest, normalizeChoices, setClarifyRequest, warnDroppedCh import { setSessionCompacting } from '@/store/compaction' import { refreshBackgroundProcesses } from '@/store/composer-status' import { $gateway } from '@/store/gateway' +import { applyGoalStatusText } from '@/store/goals' import { dispatchNativeNotification } from '@/store/native-notifications' import { notify } from '@/store/notifications' import { requestDesktopOnboarding, requestDesktopOnboardingForCredentialWarning } from '@/store/onboarding' @@ -909,6 +910,8 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) { // The gateway's notification poller announces background process // completions / watch matches here — re-sync the status stack. void refreshBackgroundProcesses(sessionId) + } else if (sessionId && payload?.kind === 'goal') { + applyGoalStatusText(sessionId, coerceGatewayText(payload?.text)) } } else if (event.type === 'review.summary') { // Self-improvement background review saved something to memory/skills diff --git a/apps/desktop/src/app/session/hooks/use-prompt-actions/slash.ts b/apps/desktop/src/app/session/hooks/use-prompt-actions/slash.ts index f8f044ec02..c70e6977c0 100644 --- a/apps/desktop/src/app/session/hooks/use-prompt-actions/slash.ts +++ b/apps/desktop/src/app/session/hooks/use-prompt-actions/slash.ts @@ -18,6 +18,7 @@ import { setSessionYolo } from '@/lib/yolo-session' import { openCommandPalettePage } from '@/store/command-palette' import { setComposerDraft } from '@/store/composer' import { enqueueQueuedPrompt } from '@/store/composer-queue' +import { applyGoalStatusText } from '@/store/goals' import { dismissNotification, notify, notifyError } from '@/store/notifications' import { setPetScale } from '@/store/pet-gallery' import { $petGenInput, openPetGenerate } from '@/store/pet-generate' @@ -232,6 +233,15 @@ export function useSlashCommand(deps: SlashCommandDeps) { // `/goal ` looked like it did nothing. if ((dispatch.type === 'send' || dispatch.type === 'prefill') && dispatch.notice?.trim()) { renderSlashOutput(dispatch.notice.trim()) + + // `/goal ` returns its "⊙ Goal set …" notice here and kicks + // off the first turn immediately; the backend only emits a + // `status.update kind:"goal"` after that turn's post-turn judge + // runs. Seed the goal store from the notice so the indicator shows + // the active goal right away instead of after the first turn. + if (name === 'goal') { + applyGoalStatusText(sessionId, dispatch.notice.trim()) + } } const message = ('message' in dispatch ? dispatch.message : '')?.trim() ?? '' @@ -313,6 +323,15 @@ export function useSlashCommand(deps: SlashCommandDeps) { const output = result && typeof result === 'object' ? (result as SlashExecResponse) : null const body = output?.output || `/${name}: no output` + + // `/goal status|pause|resume|clear` come back as plain exec output + // ("⊙ Goal (active, 3/20 turns): …", "⏸ Goal paused: …", "✓ Goal + // cleared." …). Mirror it into the goal store so the composer + // indicator tracks pause/resume/clear immediately. + if (name === 'goal' && output?.output) { + applyGoalStatusText(sessionId, output.output) + } + renderSlashOutput(output?.warning ? `warning: ${output.warning}\n${body}` : body) return diff --git a/apps/desktop/src/app/session/hooks/use-session-actions/index.ts b/apps/desktop/src/app/session/hooks/use-session-actions/index.ts index b0202e722a..4dbcfa6000 100644 --- a/apps/desktop/src/app/session/hooks/use-session-actions/index.ts +++ b/apps/desktop/src/app/session/hooks/use-session-actions/index.ts @@ -53,7 +53,6 @@ import { setSelectedStoredSessionId, setSessions, setSessionStartedAt, - setSessionsTotal, setTurnStartedAt, setYoloActive } from '@/store/session' @@ -1293,9 +1292,6 @@ export function useSessionActions({ // the delete RPC is in flight, so a racing refresh can't flash it back. tombstoneSessions(removedIds) beginSessionMutation(removedIds) - // Keep $sessionsTotal in sync so the sidebar's "Load N more" footer - // doesn't keep claiming the removed row is still on the server. - setSessionsTotal(prev => Math.max(0, prev - 1)) $pinnedSessionIds.set(previousPinned.filter(id => id !== storedSessionId && id !== removedPinId)) // Tear down before awaiting so the route effect can't resume the @@ -1330,7 +1326,6 @@ export function useSessionActions({ } catch (err) { if (removed) { setSessions(prev => [removed, ...prev]) - setSessionsTotal(prev => prev + 1) } untombstoneSessions(removedIds) @@ -1393,10 +1388,6 @@ export function useSessionActions({ setSessions(prev => prev.filter(session => !sessionMatchesStoredId(session, storedSessionId))) tombstoneSessions(archivedIds) beginSessionMutation(archivedIds) - // Archived sessions are hidden by the listSessions(min_messages=1) query - // on the next refresh, so they count as "removed" for the load-more - // footer math. - setSessionsTotal(prev => Math.max(0, prev - 1)) $pinnedSessionIds.set(previousPinned.filter(id => id !== storedSessionId && id !== archivedPinId)) if (wasSelected) { @@ -1419,7 +1410,6 @@ export function useSessionActions({ } catch (err) { if (archived) { setSessions(prev => [archived, ...prev.filter(session => !sessionMatchesStoredId(session, storedSessionId))]) - setSessionsTotal(prev => prev + 1) } untombstoneSessions(archivedIds) diff --git a/apps/desktop/src/app/session/hooks/use-session-actions/resume-structural-parts.test.ts b/apps/desktop/src/app/session/hooks/use-session-actions/resume-structural-parts.test.ts new file mode 100644 index 0000000000..1ef5376d8d --- /dev/null +++ b/apps/desktop/src/app/session/hooks/use-session-actions/resume-structural-parts.test.ts @@ -0,0 +1,76 @@ +import { describe, expect, it } from 'vitest' + +import type { ChatMessage } from '@/lib/chat-messages' + +import { reconcileResumeMessages } from './utils' + +const user = (id: string, text: string): ChatMessage => ({ + id, + parts: [{ type: 'text', text }], + role: 'user' +}) + +/** + * Switching away from a running session and back re-hydrates it from + * `session.activate`, whose transcript is TEXT-ONLY for the live turn (the + * gateway's `inflight` projection carries `user`/`assistant` strings, nothing + * structural). The renderer's cached state is the only carrier of the turn's + * tool calls and reasoning, so reconcile must not drop them. + */ +describe('reconcileResumeMessages — structural parts on a mid-turn switch', () => { + it('keeps tool-call parts the authoritative text-only row cannot carry', () => { + const cached: ChatMessage[] = [ + user('u1', 'read the config'), + { + id: 'a1', + parts: [ + { type: 'reasoning', text: 'I should read the file first.' }, + { type: 'tool-call', toolCallId: 'call-1', toolName: 'read_file', result: 'contents' }, + { type: 'text', text: 'Reading it now' } + ], + role: 'assistant' + } + ] + + // What activate returns mid-turn: the same rows, but flattened to text and + // one delta further along, so the text no longer matches the cached copy. + const authoritative: ChatMessage[] = [ + user('u1', 'read the config'), + { id: 'a1', parts: [{ type: 'text', text: 'Reading it now — found the key' }], role: 'assistant' } + ] + + const [, assistant] = reconcileResumeMessages(authoritative, cached) + + expect(assistant.parts.filter(p => p.type === 'tool-call')).toHaveLength(1) + expect(assistant.parts.filter(p => p.type === 'reasoning')).toHaveLength(1) + // The newer authoritative text still wins. + expect(assistant.parts.filter(p => p.type === 'text').at(-1)).toMatchObject({ + text: 'Reading it now — found the key' + }) + }) + + it('does not duplicate tool calls the authoritative row already carries', () => { + const cached: ChatMessage[] = [ + { + id: 'a1', + parts: [{ type: 'tool-call', toolCallId: 'call-1', toolName: 'read_file', result: 'contents' }], + role: 'assistant' + } + ] + + const authoritative: ChatMessage[] = [ + { + id: 'a1', + parts: [ + { type: 'tool-call', toolCallId: 'call-1', toolName: 'read_file', result: 'contents' }, + { type: 'text', text: 'done' } + ], + role: 'assistant' + } + ] + + const [assistant] = reconcileResumeMessages(authoritative, cached) + + expect(assistant.parts.filter(p => p.type === 'tool-call')).toHaveLength(1) + }) +}) diff --git a/apps/desktop/src/app/session/hooks/use-session-actions/utils.test.ts b/apps/desktop/src/app/session/hooks/use-session-actions/utils.test.ts index eb2633e540..a83f8a3840 100644 --- a/apps/desktop/src/app/session/hooks/use-session-actions/utils.test.ts +++ b/apps/desktop/src/app/session/hooks/use-session-actions/utils.test.ts @@ -435,6 +435,39 @@ describe('preserveLocalPendingTurnMessages', () => { expect(preserveLocalPendingTurnMessages(compressedAuthority, pollutedWarmCache)).toBe(compressedAuthority) }) + // A mid-turn redirect inserts its correction as a SECOND optimistic user row + // for the same turn. Keeping only the newest dropped the prompt that started + // it, so a resume repainted the thread with the user's message missing. + it('keeps every optimistic user row in the live run after a mid-turn redirect', () => { + const previous = [ + msg('user-1000', 'user', 'remove the session counts'), + msg('user-2000', 'user', 'hurry up'), + msg('assistant-stream-1', 'assistant', 'Moving.', { pending: true }) + ] + + expect(preserveLocalPendingTurnMessages([], previous).map(message => message.id)).toEqual([ + 'user-1000', + 'user-2000', + 'assistant-stream-1' + ]) + }) + + it('still drops optimistic rows separated from the live run by an assistant reply', () => { + const previous = [ + msg('user-stale', 'user', 'compressed-away prompt'), + msg('assistant-stale', 'assistant', 'compressed-away reply'), + msg('user-1000', 'user', 'the live prompt'), + msg('user-2000', 'user', 'the correction'), + msg('assistant-stream-1', 'assistant', 'Moving.', { pending: true }) + ] + + expect(preserveLocalPendingTurnMessages([], previous).map(message => message.id)).toEqual([ + 'user-1000', + 'user-2000', + 'assistant-stream-1' + ]) + }) + // #67603: the gateway persists model-switch / personality notices as role=user // ([System: …], tui_gateway/server.py). A single trailing marker is already // handled by the latestAuthoritativeUser guard above, but TWO switches around @@ -538,6 +571,46 @@ describe('preserveLocalPendingTurnMessages', () => { }) describe('appendLiveSessionProjection', () => { + // Corrections typed while a turn ran are their own user bubbles on the same + // turn. Resume must rebuild the prompt AND every correction, in order. + it('projects mid-turn redirect corrections after the prompt that started the turn', () => { + const restored = appendLiveSessionProjection([], { + session_id: 'runtime-1', + inflight: { + user: 'remove the session counts', + corrections: ['hurry up', 'and the worktree ones'], + assistant: 'Moving.', + streaming: true + } + }) + + expect(restored.map(message => message.parts.map(part => ('text' in part ? part.text : '')).join(''))).toEqual([ + 'remove the session counts', + 'hurry up', + 'and the worktree ones', + 'Moving.' + ]) + }) + + it('does not re-project a correction the transcript already persisted', () => { + const stored = [msg('stored-user', 'user', 'remove the session counts'), msg('stored-fix', 'user', 'hurry up')] + + const restored = appendLiveSessionProjection(stored, { + session_id: 'runtime-1', + inflight: { + user: 'remove the session counts', + corrections: ['hurry up'], + assistant: 'Moving.', + streaming: true + } + }) + + expect(restored.filter(message => message.role === 'user').map(message => message.id)).toEqual([ + 'stored-user', + 'stored-fix' + ]) + }) + it('does not duplicate the inflight user when the persisted turn carries @image refs', () => { // By the time a stored transcript reaches appendLiveSessionProjection it // has already been run through toChatMessages, so the @image directive has diff --git a/apps/desktop/src/app/session/hooks/use-session-actions/utils.ts b/apps/desktop/src/app/session/hooks/use-session-actions/utils.ts index 39ba0bd911..f6e19919f0 100644 --- a/apps/desktop/src/app/session/hooks/use-session-actions/utils.ts +++ b/apps/desktop/src/app/session/hooks/use-session-actions/utils.ts @@ -46,14 +46,40 @@ function withAppendedText(message: ChatMessage, suffix: string): ChatMessage { return appended ? { ...message, parts } : message } -function preserveReasoningParts(message: ChatMessage, previous: ChatMessage): ChatMessage { - if (message.parts.some(part => part.type === 'reasoning')) { +/** + * Carry structural parts an authoritative row cannot express. + * + * A live turn's authoritative projection is TEXT-ONLY: the gateway's `inflight` + * snapshot carries `user`/`assistant` strings, and history is not committed + * until the turn finishes. The renderer's cached state is therefore the sole + * carrier of the running turn's reasoning and tool calls, so switching threads + * mid-turn and back re-hydrated an assistant row stripped of both — the turn + * looked inert, with no thinking trace and no tool activity. + * + * Preserved only when the rows are the SAME turn: identical text, or the + * authoritative text extending the cached one (another delta landed). Anything + * else may be a different turn at the same role ordinal — compression rewrites + * history — and must not inherit foreign parts. Tool calls dedupe on + * `toolCallId` so a row that already carries them is left alone. + */ +function preserveStructuralParts(message: ChatMessage, previous: ChatMessage): ChatMessage { + const carried = previous.parts.filter(part => part.type === 'reasoning' || part.type === 'tool-call') + + if (!carried.length) { return message } - const reasoningParts = previous.parts.filter(part => part.type === 'reasoning') + const hasReasoning = message.parts.some(part => part.type === 'reasoning') - return reasoningParts.length ? { ...message, parts: [...reasoningParts, ...message.parts] } : message + const presentToolCallIds = new Set( + message.parts.flatMap(part => (part.type === 'tool-call' ? [part.toolCallId] : [])) + ) + + const missing = carried.filter(part => + part.type === 'reasoning' ? !hasReasoning : !presentToolCallIds.has(part.toolCallId) + ) + + return missing.length ? { ...message, parts: [...missing, ...message.parts] } : message } // Compile-time exhaustiveness guards. If a new field is added to ChatMessage @@ -209,12 +235,29 @@ export function reconcileResumeMessages(nextMessages: ChatMessage[], previousMes const previousVisibleText = textWithoutEmbeddedImages(previousText) let preserved = message - if (nextText === previousVisibleText || nextText === previousText.trim()) { - preserved = preserveReasoningParts(preserved, previous) + const sameText = nextText === previousVisibleText || nextText === previousText.trim() - if (message.role === 'user' && preserved.attachmentRefs === undefined && previous.attachmentRefs?.length) { - preserved = { ...preserved, attachmentRefs: [...previous.attachmentRefs] } - } + // Mid-turn, the authoritative text has advanced past the cached copy by one + // or more deltas. That is still the same turn, and the cached row holds the + // only copy of its reasoning / tool calls, so treat an extension as a match + // for structural carry-over. Attachment refs and image re-appending stay on + // the strict equality path — they reconcile a SETTLED row, and a growing + // row is by definition not settled. + const sameTurn = + sameText || + (nextText.length > 0 && previousVisibleText.length > 0 && nextText.startsWith(previousVisibleText.trim())) + + if (sameTurn) { + preserved = preserveStructuralParts(preserved, previous) + } + + if ( + sameText && + message.role === 'user' && + preserved.attachmentRefs === undefined && + previous.attachmentRefs?.length + ) { + preserved = { ...preserved, attachmentRefs: [...previous.attachmentRefs] } } const previousImages = embeddedImageUrls(previousText) @@ -283,6 +326,26 @@ export function preserveLocalPendingTurnMessages( .reverse() .find(message => message.role === 'user' && message.id.startsWith('user-')) + // A mid-turn redirect inserts its correction as a second optimistic user row + // directly before the live reply, so one turn can own a contiguous RUN of + // them. Preserving only the newest keeps the correction and drops the prompt + // that started the turn. Widen to the run — but only the contiguous one: any + // `user-*` row separated by an assistant reply is stale post-compression + // history, which is what the newest-only rule exists to discard. + const liveOptimisticUsers = new Set() + + if (newestOptimisticUser) { + for (let index = previousMessages.indexOf(newestOptimisticUser); index >= 0; index -= 1) { + const candidate = previousMessages[index] + + if (candidate.role !== 'user' || !candidate.id.startsWith('user-')) { + break + } + + liveOptimisticUsers.add(candidate) + } + } + const latestAuthoritativeUser = [...nextMessages].reverse().find(message => message.role === 'user') const preserved: ChatMessage[] = [] @@ -303,7 +366,7 @@ export function preserveLocalPendingTurnMessages( continue } - if (isOptimisticUser && message !== newestOptimisticUser) { + if (isOptimisticUser && !liveOptimisticUsers.has(message)) { continue } @@ -349,13 +412,27 @@ export function appendLiveSessionProjection( const inflightUser = projection.inflight?.user?.trim() ?? '' const inflightAssistant = projection.inflight?.assistant ?? '' const inflightStreaming = Boolean(projection.inflight?.streaming) + + // Mid-turn redirect corrections. They are additional user bubbles belonging + // to this same turn, ordered after the prompt that started it. + const inflightCorrections = (projection.inflight?.corrections ?? []) + .map(correction => correction?.trim() ?? '') + .filter(Boolean) + // A retained failed turn (the gateway keeps error snapshots replayable when // the terminal frame may have been lost to a disconnect) — surface the // failure on the projected row instead of rendering the partial as healthy. const inflightError = projection.inflight?.error?.trim() ?? '' const queuedUser = projection.queued?.user?.trim() ?? '' - if (!inflightUser && !inflightAssistant && !inflightStreaming && !inflightError && !queuedUser) { + if ( + !inflightUser && + !inflightAssistant && + !inflightStreaming && + !inflightError && + !queuedUser && + !inflightCorrections.length + ) { return messages } @@ -366,10 +443,20 @@ export function appendLiveSessionProjection( // both makes a backgrounded prompt appear twice when its session is reopened. // Only suppress the projection when the latest authoritative user row is the // same turn — older identical prompts must not hide a newly accepted repeat. - const latestUser = [...messages].reverse().find(message => message.role === 'user') + // A mid-turn redirect gives that turn a RUN of user rows (prompt + + // corrections), so match the contiguous run ending at the latest user row + // rather than the single last one. + const latestUserIndex = messages.map(message => message.role).lastIndexOf('user') + const latestUserRun: ChatMessage[] = [] - const inflightUserAlreadyPersisted = - latestUser && textWithoutImageRefs(chatMessageText(latestUser)) === textWithoutImageRefs(inflightUser) + for (let index = latestUserIndex; index >= 0 && messages[index].role === 'user'; index -= 1) { + latestUserRun.unshift(messages[index]) + } + + const persistedInLatestRun = (text: string): boolean => + latestUserRun.some(message => textWithoutImageRefs(chatMessageText(message)) === textWithoutImageRefs(text)) + + const inflightUserAlreadyPersisted = Boolean(inflightUser) && persistedInLatestRun(inflightUser) if (inflightUser && !inflightUserAlreadyPersisted) { projected.push({ @@ -379,6 +466,22 @@ export function appendLiveSessionProjection( }) } + // Corrections typed while the turn ran. Each is its own bubble, placed after + // the original prompt and before the reply they redirected — the same order + // the live transcript showed. Skip any the transcript already holds so a + // resume doesn't double them. + for (const [index, correction] of inflightCorrections.entries()) { + if (persistedInLatestRun(correction)) { + continue + } + + projected.push({ + id: `user-inflight-correction-${index}-${sessionId}`, + role: 'user', + parts: [textPart(correction)] + }) + } + // Keep a pending assistant boundary even before the first delta when a // queued user turn follows it. This preserves the two distinct turns. if (inflightAssistant || inflightStreaming || inflightError || (inflightUser && queuedUser)) { diff --git a/apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx b/apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx index b5c3ef0721..8b32a8b85e 100644 --- a/apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx +++ b/apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx @@ -43,13 +43,13 @@ const row = (id: string, over: Partial = {}): SessionInfo => // separate listAllProfileSessions calls (each of which reopened every profile // DB) — #66377-adjacent perf work from the desktop audit canvas. const sidebar = ( - recents: { sessions: SessionInfo[]; total?: number; profile_totals?: Record }, + recents: { sessions: SessionInfo[]; profiles_truncated?: Record }, cron: SessionInfo[] = [], messaging: SessionInfo[] = [] ): SidebarSessionsResponse => ({ - recents: { sessions: recents.sessions, total: recents.total, profile_totals: recents.profile_totals }, + recents: { sessions: recents.sessions, profiles_truncated: recents.profiles_truncated }, cron: { sessions: cron }, - messaging: { sessions: messaging, total: messaging.length } + messaging: { sessions: messaging } }) const listSidebarSessions = vi.fn() @@ -90,7 +90,7 @@ afterEach(() => { describe('refreshSessions identity + loading hygiene', () => { it('keeps the previous $sessions array when the refresh is content-identical', async () => { const rows = [row('a'), row('b')] - listSidebarSessions.mockResolvedValue(sidebar({ sessions: rows, total: 2, profile_totals: { default: 2 } })) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: rows })) const { result } = renderHook(() => useSessionListActions({ profileScope: 'default' })) @@ -102,9 +102,7 @@ describe('refreshSessions identity + loading hygiene', () => { expect(first.map(s => s.id)).toEqual(['a', 'b']) // Second refresh returns fresh (but equal) row objects, as the API does. - listSidebarSessions.mockResolvedValue( - sidebar({ sessions: [row('a'), row('b')], total: 2, profile_totals: { default: 2 } }) - ) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: [row('a'), row('b')] })) await act(async () => { await result.current.refreshSessions() @@ -114,7 +112,7 @@ describe('refreshSessions identity + loading hygiene', () => { }) it('swaps the array when rows actually changed', async () => { - listSidebarSessions.mockResolvedValue(sidebar({ sessions: [row('a')], total: 1, profile_totals: {} })) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: [row('a')] })) const { result } = renderHook(() => useSessionListActions({ profileScope: 'default' })) await act(async () => { @@ -123,9 +121,7 @@ describe('refreshSessions identity + loading hygiene', () => { const first = $sessions.get() - listSidebarSessions.mockResolvedValue( - sidebar({ sessions: [row('a', { last_active: 2000, title: 'Renamed' })], total: 1, profile_totals: {} }) - ) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: [row('a', { last_active: 2000, title: 'Renamed' })] })) await act(async () => { await result.current.refreshSessions() @@ -136,7 +132,7 @@ describe('refreshSessions identity + loading hygiene', () => { }) it('does not flicker the loading flag over a populated list', async () => { - listSidebarSessions.mockResolvedValue(sidebar({ sessions: [row('a')], total: 1, profile_totals: {} })) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: [row('a')] })) const { result } = renderHook(() => useSessionListActions({ profileScope: 'default' })) await act(async () => { @@ -162,9 +158,7 @@ describe('refreshSessions identity + loading hygiene', () => { removed.ids = new Set(['b', 'root-c']) listSidebarSessions.mockResolvedValue( sidebar({ - sessions: [row('a'), row('b'), row('c', { _lineage_root_id: 'root-c' } as Partial)], - total: 3, - profile_totals: {} + sessions: [row('a'), row('b'), row('c', { _lineage_root_id: 'root-c' } as Partial)] }) ) @@ -178,7 +172,7 @@ describe('refreshSessions identity + loading hygiene', () => { }) it('still shows loading for the initial (empty-list) fetch', async () => { - listSidebarSessions.mockResolvedValue(sidebar({ sessions: [row('a')], total: 1, profile_totals: {} })) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: [row('a')] })) const { result } = renderHook(() => useSessionListActions({ profileScope: 'default' })) const loadingStates: boolean[] = [] @@ -199,9 +193,7 @@ describe('refreshSessions batches slices into one request', () => { const cron = [row('c1', { source: 'cron', title: 'nightly' })] const messaging = [row('m1', { source: 'telegram', title: 'tg chat' })] - listSidebarSessions.mockResolvedValue( - sidebar({ sessions: recents, total: 2, profile_totals: { default: 2 } }, cron, messaging) - ) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: recents }, cron, messaging)) const { result } = renderHook(() => useSessionListActions({ profileScope: 'default' })) @@ -220,7 +212,7 @@ describe('refreshSessions batches slices into one request', () => { }) it('forwards the active profile scope + section limits to the batched call', async () => { - listSidebarSessions.mockResolvedValue(sidebar({ sessions: [], total: 0, profile_totals: {} })) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: [] })) const { result } = renderHook(() => useSessionListActions({ profileScope: 'work' })) await act(async () => { @@ -238,7 +230,7 @@ describe('refreshSessions batches slices into one request', () => { it('scopes the cron-jobs fetch to the active profile (all → unified view)', async () => { const { getCronJobs } = await import('@/hermes') - listSidebarSessions.mockResolvedValue(sidebar({ sessions: [], total: 0, profile_totals: {} })) + listSidebarSessions.mockResolvedValue(sidebar({ sessions: [] })) const scoped = renderHook(() => useSessionListActions({ profileScope: 'work' })) diff --git a/apps/desktop/src/app/session/hooks/use-session-list-actions.ts b/apps/desktop/src/app/session/hooks/use-session-list-actions.ts index a945732262..611484e0d7 100644 --- a/apps/desktop/src/app/session/hooks/use-session-list-actions.ts +++ b/apps/desktop/src/app/session/hooks/use-session-list-actions.ts @@ -23,10 +23,9 @@ import { setMessagingPlatformTotals, setMessagingSessions, setMessagingTruncated, - setSessionProfileTotals, + setSessionProfilesTruncated, setSessions, - setSessionsLoading, - setSessionsTotal + setSessionsLoading } from '@/store/session' import { $workingSessionIds, getRecentlySettledSessionIds } from '@/store/session-states' @@ -202,9 +201,13 @@ export function useSessionListActions({ profileScope }: UseSessionListActionsArg return sameCronSignature(prev, next) ? prev : next }) - setSessionsTotal(typeof recents.total === 'number' ? recents.total : recents.sessions.length) - setSessionProfileTotals(prev => { - const next = recents.profile_totals ?? {} + // "Is there another page?" instead of an exact total: the backend + // reports which profiles filled their window, which costs nothing on + // top of the rows it already read (the old exact totals ran a COUNT(*) + // per profile DB on every refresh). Reference-stable when unchanged so + // the sidebar's group memos don't recompute per refresh. + setSessionProfilesTruncated(prev => { + const next = recents.profiles_truncated ?? {} const prevKeys = Object.keys(prev) return prevKeys.length === Object.keys(next).length && prevKeys.every(key => prev[key] === next[key]) @@ -258,8 +261,9 @@ export function useSessionListActions({ profileScope }: UseSessionListActionsArg ...mergeSessionPage(prev.filter(inKey), result.sessions, keep) ]) - const total = result.profile_totals?.[key] ?? result.total ?? result.sessions.length - setSessionProfileTotals(prev => ({ ...prev, [key]: Math.max(total, result.sessions.length) })) + // A full window back means the profile still has more on disk. + const truncated = result.sessions.length >= loaded + SIDEBAR_SESSIONS_PAGE_SIZE + setSessionProfilesTruncated(prev => ({ ...prev, [key]: truncated })) }, []) return { diff --git a/apps/desktop/src/app/session/hooks/use-session-state-cache.ts b/apps/desktop/src/app/session/hooks/use-session-state-cache.ts index 1b55e9c691..04fe08513e 100644 --- a/apps/desktop/src/app/session/hooks/use-session-state-cache.ts +++ b/apps/desktop/src/app/session/hooks/use-session-state-cache.ts @@ -7,8 +7,10 @@ import { createClientSessionState } from '@/lib/chat-runtime' import { persistInFlightTurnState } from '@/lib/inflight-turn-journal' import { setMutableRef } from '@/lib/mutable-ref' import { + $activeSessionId, $busy, $messages, + setActiveSessionStoredIdRotation, setCurrentFastMode, setCurrentModel, setCurrentPersonality, @@ -108,10 +110,23 @@ export function useSessionStateCache({ // rotates (e.g. auto-compression forks a continuation). Leaving the // stale key lets getRuntimeIdForStoredSession resolve the old stored id // to this runtime, which the compression route-follow logic relies on - // being absent. The rotation signal itself is emitted centrally from - // handleTransition (session-states.ts) off the published diff. + // being absent. The rotation signal was previously emitted centrally + // from handleTransition (session-states.ts), but updateSessionState + // now skips publishSessionState (and thus handleTransition) when the + // updater is a no-op — fire it here so the route-follow effect still + // tracks compression without needing a dummy state write. if (existing.storedSessionId && existing.storedSessionId !== storedSessionId) { runtimeIdByStoredSessionIdRef.current.delete(existing.storedSessionId) + + // A rotation event needs a real next id — a null/cleared stored id + // is a detach, not a rotation the route-follow effect should chase. + if (storedSessionId && sessionId === $activeSessionId.get()) { + setActiveSessionStoredIdRotation({ + nextStoredSessionId: storedSessionId, + previousStoredSessionId: existing.storedSessionId, + runtimeSessionId: sessionId + }) + } } if (storedSessionId) { @@ -268,7 +283,22 @@ export function useSessionStateCache({ storedSessionId?: string | null ) => { const previous = ensureSessionState(sessionId, storedSessionId) - const next = updater({ ...previous, messages: previous.messages }) + // Give the updater the raw previous state so it can return the same + // reference when nothing changed (the caller sees a no-op). Previously + // the param was always a fresh spread, so every call looked like a + // change — including periodic ~1/s session.info heartbeats that churn + // $sessionStates and its computed atoms on every tick. + const next = updater(previous) + + // If the updater returned the same reference, nothing changed for this + // session — skip the store write, publishSessionState, and view sync. + // The cache entry was already updated by ensureSessionState (if + // storedSessionId rotated); the caller gets its return value from the + // cache, so stale reads don't regress. + if (next === previous) { + return previous + } + sessionStateByRuntimeIdRef.current.set(sessionId, next) // Crash-survivable turn progress: journal the running turn's visible // tail (throttled localStorage write; cleared the moment the turn diff --git a/apps/desktop/src/app/settings/config-settings.tsx b/apps/desktop/src/app/settings/config-settings.tsx index c97d5b7200..3874779273 100644 --- a/apps/desktop/src/app/settings/config-settings.tsx +++ b/apps/desktop/src/app/settings/config-settings.tsx @@ -22,6 +22,7 @@ import { MemoryConnect } from './memory/connect' import { ProviderConfigPanel } from './memory/provider-config-panel' import { ModelSettings, ModelSettingsSkeleton } from './model-settings' import { EmptyState, SettingsContent, SettingsSkeleton, ToggleRow } from './primitives' +import { QuickEntrySettings } from './quick-entry-settings' // On the Voice page, only surface the sub-fields of the *selected* TTS/STT // provider — otherwise every provider's options render at once (the "totally @@ -290,10 +291,19 @@ export function ConfigSettings({
)} - {/* Device-local desktop pref (not config.yaml) — lives here since keeping - the machine awake is a power-user knob. */} + {/* Device-local desktop prefs (not config.yaml) — they live here since + keeping the machine awake and the global Quick Entry chord are both + power-user, this-computer-only knobs. */} {activeSectionId === 'advanced' && ( - + <> + + + )} {visibleFields.length === 0 ? ( diff --git a/apps/desktop/src/app/settings/quick-entry-settings.tsx b/apps/desktop/src/app/settings/quick-entry-settings.tsx new file mode 100644 index 0000000000..4e38531d11 --- /dev/null +++ b/apps/desktop/src/app/settings/quick-entry-settings.tsx @@ -0,0 +1,103 @@ +import { useStore } from '@nanostores/react' +import { useEffect, useState } from 'react' + +import { Input } from '@/components/ui/input' +import { useI18n } from '@/i18n' +import { + $quickEntry, + canUseQuickEntry, + loadQuickEntrySettings, + QUICK_ENTRY_DEFAULT_SHORTCUT, + saveQuickEntrySettings +} from '@/store/quick-entry' + +import { ListRow, ToggleRow } from './primitives' + +/** + * Quick Entry — the global-hotkey mini composer's settings rows. + * + * The MAIN process is authoritative (it owns the OS accelerator), so this reads + * the live registration state on mount and surfaces the failure the feature must + * never swallow: a chord another app already owns comes back `registered: false` + * with `error: 'taken'` and says so, right under the field. + */ +export function QuickEntrySettings() { + const { t } = useI18n() + const q = t.settings.quickEntry + const state = useStore($quickEntry) + // The field is a local draft: the accelerator is only committed on blur/Enter, + // so a half-typed chord ("Alt+") never tears down the live registration. + const [draft, setDraft] = useState(null) + + useEffect(() => { + void loadQuickEntrySettings() + }, []) + + if (!canUseQuickEntry()) { + return null + } + + const commit = () => { + const next = (draft ?? '').trim() + setDraft(null) + + if (next && next !== state.shortcut) { + void saveQuickEntrySettings({ shortcut: next }) + } + } + + const status = + state.registered === null + ? null + : state.error === 'taken' + ? q.takenBy + : state.error === 'invalid' + ? q.invalidShortcut + : state.enabled && state.registered + ? q.active + : null + + return ( + <> + void saveQuickEntrySettings({ enabled })} + /> + setDraft(event.target.value)} + onKeyDown={event => { + if (event.key === 'Enter') { + event.preventDefault() + commit() + } + }} + placeholder={QUICK_ENTRY_DEFAULT_SHORTCUT} + value={draft ?? state.shortcut} + /> + } + below={ + status && ( +
+ {status} +
+ ) + } + description={q.shortcutDesc} + title={q.shortcutTitle} + /> + + ) +} diff --git a/apps/desktop/src/app/shell/hooks/use-statusbar-items.tsx b/apps/desktop/src/app/shell/hooks/use-statusbar-items.tsx index 8033e7f7e0..05d3e9717d 100644 --- a/apps/desktop/src/app/shell/hooks/use-statusbar-items.tsx +++ b/apps/desktop/src/app/shell/hooks/use-statusbar-items.tsx @@ -12,6 +12,7 @@ import { useI18n } from '@/i18n' import { Activity, AlertCircle, Clock, Command, FolderOpen, Globe, Hash, Loader2, Terminal } from '@/lib/icons' import type { RuntimeReadinessResult } from '@/lib/runtime-readiness' import { contextBarLabel, LiveDuration, usageContextLabel } from '@/lib/statusbar' +import { useStoreSelector } from '@/lib/use-session-slice' import { cn } from '@/lib/utils' import { copyFilePath, revealFile } from '@/store/file-actions' import { revealFileInTree } from '@/store/layout' @@ -103,7 +104,20 @@ export function useStatusbarItems({ const gatewayRestarting = useStore($gatewayRestarting) const primarySessionStartedAt = useStore($sessionStartedAt) const primaryTurnStartedAt = useStore($turnStartedAt) - const subagentsBySession = useStore($subagentsBySession) + + // The indicator must speak the same scope as the Spawn-tree panel it opens: + // every session's subagents, never background system actions. Only two + // COUNTS are read, so select scalars — a whole-map `useStore` re-ran this + // hook (rebuilding all ~9 statusbar items) on every subagent progress tick + // in ANY session, including background ones. + const subagentsRunning = useStoreSelector($subagentsBySession, bySession => + Object.values(bySession).reduce((sum, items) => sum + activeSubagentCount(items), 0) + ) + + const subagentsFailed = useStoreSelector($subagentsBySession, bySession => + Object.values(bySession).reduce((sum, items) => sum + failedSubagentCount(items), 0) + ) + const updateStatus = useStore($updateStatus) const updateApply = useStore($updateApply) const backendUpdateStatus = useStore($backendUpdateStatus) @@ -117,30 +131,44 @@ export function useStatusbarItems({ // tile makes the statusbar describe THAT session. const focusedStoredSessionId = useStore($focusedStoredSessionId) const focusedRuntimeId = useStore($focusedRuntimeId) - const focusedState = useStore($focusedSessionState) - const sessions = useStore($sessions) + // `$focusedSessionState` is a projection of `$sessionStates`, which is + // republished on EVERY message delta — tens of times a second during a turn. + // Only three fields are read off it here, so subscribing to the whole object + // re-ran this hook (and re-created all ~9 statusbar items) per token. Select + // each field individually so an unchanged readout bails out instead. + const focusedBusy = useStoreSelector($focusedSessionState, state => Boolean(state?.busy)) + const focusedTurnStartedAt = useStoreSelector($focusedSessionState, state => state?.turnStartedAt ?? null) + // `usage` is an object, so it can't be compared as a scalar. It IS however + // replaced wholesale rather than mutated, and only changes when the backend + // reports new usage — far rarer than a delta — so its reference is a valid + // bail-out key on its own. + const focusedUsage = useStoreSelector($focusedSessionState, state => state?.usage ?? null) const selectedStoredSessionId = useStore($selectedStoredSessionId) const primaryFocused = !focusedStoredSessionId || focusedStoredSessionId === selectedStoredSessionId const activeSessionId = primaryFocused ? primaryActiveSessionId : (focusedRuntimeId ?? null) - const busy = primaryFocused ? primaryBusy : Boolean(focusedState?.busy) + const busy = primaryFocused ? primaryBusy : focusedBusy // EMPTY_USAGE (module constant) keeps the fallback referentially stable — // a fresh `{...}` each render would bust the usage-label memos below. - const currentUsage = primaryFocused ? primaryUsage : (focusedState?.usage ?? EMPTY_USAGE) + const currentUsage = primaryFocused ? primaryUsage : (focusedUsage ?? EMPTY_USAGE) - const turnStartedAt = primaryFocused ? primaryTurnStartedAt : (focusedState?.turnStartedAt ?? null) + const turnStartedAt = primaryFocused ? primaryTurnStartedAt : focusedTurnStartedAt // A tile's session-start comes from its stored row (the cache only knows - // runtime state); seconds → ms. - const focusedRow = focusedStoredSessionId - ? sessions.find(s => sessionMatchesStoredId(s, focusedStoredSessionId)) - : null + // runtime state); seconds → ms. Only this ONE scalar is read off + // `$sessions`, so select it — a whole-list `useStore` re-ran the hook on + // every session-list write (title updates, poll refreshes, archives). + const focusedRowStartedAt = useStoreSelector($sessions, sessions => + focusedStoredSessionId + ? (sessions.find(s => sessionMatchesStoredId(s, focusedStoredSessionId))?.started_at ?? null) + : null + ) const sessionStartedAt = primaryFocused ? primarySessionStartedAt - : focusedRow?.started_at - ? focusedRow.started_at * 1000 + : focusedRowStartedAt + ? focusedRowStartedAt * 1000 : null const contextUsage = useMemo(() => usageContextLabel(currentUsage), [currentUsage]) @@ -168,18 +196,6 @@ export function useStatusbarItems({ [gatewayState, inferenceStatus, openCommandCenterSection, statusSnapshot] ) - // The indicator must speak the same scope as the Spawn-tree panel it opens: - // every session's subagents, never background system actions (gateway - // restarts, toolset installs) which surface in their own panels. - const { subagentsFailed, subagentsRunning } = useMemo(() => { - const lists = Object.values(subagentsBySession) - - return { - subagentsFailed: lists.reduce((sum, items) => sum + failedSubagentCount(items), 0), - subagentsRunning: lists.reduce((sum, items) => sum + activeSubagentCount(items), 0) - } - }, [subagentsBySession]) - const gatewayOpen = gatewayState === 'open' const gatewayConnecting = gatewayState === 'connecting' const inferenceReady = gatewayOpen && inferenceStatus?.ready === true @@ -233,8 +249,12 @@ export function useStatusbarItems({ icon: applying ? : , id: 'version-client', label, + // Update state is not a preference: hiding it is how a user misses that + // their client is behind. Listed in the menu, but locked on. + lockedVisible: true, onSelect: () => openUpdateOverlayFor('client'), title: tooltip || undefined, + toggleLabel: copy.toggleVersion, variant: 'action' } }, [ @@ -283,8 +303,10 @@ export function useStatusbarItems({ icon: applying ? : , id: 'version-backend', label, + lockedVisible: true, onSelect: () => openUpdateOverlayFor('backend'), title: tooltip || undefined, + toggleLabel: copy.toggleBackendVersion, variant: 'action' } }, [ @@ -334,8 +356,12 @@ export function useStatusbarItems({ className: `w-7 justify-center px-0${commandCenterOpen ? ' bg-accent/55 text-foreground' : ''}`, icon: , id: 'command-center', + // The system icon: the way into every other surface, including the + // settings that would bring a hidden item back. Never hideable. + lockedVisible: true, onSelect: toggleCommandCenter, title: commandCenterOpen ? copy.closeCommandCenter : copy.openCommandCenter, + toggleLabel: copy.toggleCommandCenter, variant: 'action' }, { @@ -353,6 +379,7 @@ export function useStatusbarItems({ menuClassName: 'w-72', menuContent: gatewayMenuContent, title: inferenceStatus?.reason || copy.gatewayTitle, + toggleLabel: copy.gateway, variant: 'menu' }, { @@ -386,6 +413,7 @@ export function useStatusbarItems({ ] : undefined, title: currentCwd || undefined, + toggleLabel: copy.toggleWorkspace, variant: 'menu' }, { @@ -411,6 +439,7 @@ export function useStatusbarItems({ label: copy.agents, onSelect: openAgents, title: agentsOpen ? copy.closeAgents : copy.openAgents, + toggleLabel: copy.agents, variant: 'action' }, { @@ -419,6 +448,7 @@ export function useStatusbarItems({ label: copy.cron, title: copy.openCron, to: CRON_ROUTE, + toggleLabel: copy.cron, variant: 'action' }, { @@ -427,6 +457,7 @@ export function useStatusbarItems({ label: copy.webhooks, title: copy.openWebhooks, to: WEBHOOKS_ROUTE, + toggleLabel: copy.webhooks, variant: 'action' } ], @@ -492,7 +523,8 @@ export function useStatusbarItems({ }, { ...approvalModeItem, - hidden: gatewayState !== 'open' + hidden: gatewayState !== 'open', + toggleLabel: copy.toggleApprovalMode }, { actionId: 'view.showTerminal', @@ -502,6 +534,7 @@ export function useStatusbarItems({ id: 'terminal', onSelect: () => setTerminalTakeover(!$terminalTakeover.get()), title: terminalTakeover ? copy.hideTerminal : copy.showTerminal, + toggleLabel: copy.toggleTerminal, variant: 'action' }, clientVersionItem, diff --git a/apps/desktop/src/app/shell/statusbar-controls.tsx b/apps/desktop/src/app/shell/statusbar-controls.tsx index 0b265bb3d3..9e3950626b 100644 --- a/apps/desktop/src/app/shell/statusbar-controls.tsx +++ b/apps/desktop/src/app/shell/statusbar-controls.tsx @@ -1,9 +1,20 @@ -import { type ComponentProps, type ReactNode, useState } from 'react' +import { useStore } from '@nanostores/react' +import { type ComponentProps, memo, type ReactNode, useMemo, useState } from 'react' import { useNavigate } from 'react-router-dom' +import { + ContextMenu, + ContextMenuCheckboxItem, + ContextMenuContent, + ContextMenuLabel, + ContextMenuSeparator, + ContextMenuTrigger +} from '@/components/ui/context-menu' import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from '@/components/ui/dropdown-menu' import { Tip, TipKeybindLabel, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip' +import { useI18n } from '@/i18n' import { cn } from '@/lib/utils' +import { $statusbarHiddenIds, setStatusbarItemVisible } from '@/store/statusbar-prefs' // Shared chrome styling for interactive statusbar items (button / link / menu // trigger). The 'text' variant intentionally omits hover/transition/disabled. @@ -47,6 +58,14 @@ export interface StatusbarItem { title?: string to?: string variant?: 'action' | 'link' | 'menu' | 'text' + /** Plain-text name for the bar's right-click show/hide menu. An item without + * one is never listed there and always shows — the safe default for plugin + * contributions that don't opt in. */ + toggleLabel?: string + /** Listed in the menu but not switchable: the bar's own affordances (command + * center, update/version pills) would strand the user if they could be + * hidden from the surface that hides them. */ + lockedVisible?: boolean } export interface StatusbarSelectModifiers { @@ -63,39 +82,114 @@ interface StatusbarControlsProps extends ComponentProps<'footer'> { export function StatusbarControls({ className, leftItems = [], items = [], ...props }: StatusbarControlsProps) { const navigate = useNavigate() + const hiddenIds = useStore($statusbarHiddenIds) + + const visible = (item: StatusbarItem) => + !item.hidden && (item.lockedVisible || !item.toggleLabel || !hiddenIds.includes(item.id)) return ( -
- {/* `overflow-x-clip` (not `overflow-x-auto`) so a wide status item — for - example "Connecting…" on a fresh/untitled session — can't paint a - horizontal scrollbar across the bottom of the window. Items already - `truncate` their labels, so clipping is the right behavior. */} -
- {leftItems - .filter(item => !item.hidden) - .map(item => ( - - ))} -
-
- {items - .filter(item => !item.hidden) - .map(item => ( - - ))} -
-
+ + +
+ {/* `overflow-x-clip` (not `overflow-x-auto`) so a wide status item — for + example "Connecting…" on a fresh/untitled session — can't paint a + horizontal scrollbar across the bottom of the window. Items already + `truncate` their labels, so clipping is the right behavior. */} +
+ {leftItems.filter(visible).map(item => ( + + ))} +
+
+ {items.filter(visible).map(item => ( + + ))} +
+
+ + + ) } -function StatusbarItemView({ item, navigate }: { item: StatusbarItem; navigate: ReturnType }) { +/** Right-click the bar to choose what it shows. Lists every item that named + * itself with `toggleLabel`, in bar order (left cluster then right), so the + * menu reads like the surface it edits. */ +function StatusbarVisibilityMenu({ + hiddenIds, + items, + leftItems +}: { + hiddenIds: readonly string[] + items: readonly StatusbarItem[] + leftItems: readonly StatusbarItem[] +}) { + const { t } = useI18n() + const copy = t.shell.statusbar + + // Deduped by id: an item can legitimately appear in both clusters across + // renders (contributions move sides), and a repeated checkbox would let one + // row's toggle silently contradict the other's. + const toggles = useMemo(() => { + const seen = new Set() + + return [...leftItems, ...items].filter(item => { + if (!item.toggleLabel || seen.has(item.id)) { + return false + } + + seen.add(item.id) + + return true + }) + }, [items, leftItems]) + + if (toggles.length === 0) { + return null + } + + return ( + + {copy.customizeTitle} + + {toggles.map(item => ( + setStatusbarItemVisible(item.id, checked)} + // Radix closes the menu on select; keep it open so several items can + // be toggled in one pass (this is a preferences surface, not a + // command list). + onSelect={event => event.preventDefault()} + > + {item.toggleLabel} + + ))} + + ) +} + +/** Memoized: `useStatusbarItems` rebuilds the item array whenever ANY of its + * inputs change, but each individual item object is usually identical across + * those rebuilds. Without this, one changed item (the running timer, say) + * re-rendered every other item in the bar — measured at 1,446 wasted renders + * of 2,174 during a five-tab streaming run. `navigate` is stable for the + * router's lifetime, so item identity is the only real input. */ +const StatusbarItemView = memo(function StatusbarItemView({ + item, + navigate +}: { + item: StatusbarItem + navigate: ReturnType +}) { const [menuOpen, setMenuOpen] = useState(false) // Render escape hatch: the contribution owns its own chrome/state/tooltip. @@ -230,4 +324,4 @@ function StatusbarItemView({ item, navigate }: { item: StatusbarItem; navigate: ) -} +}) diff --git a/apps/desktop/src/app/shell/statusbar-visibility.test.tsx b/apps/desktop/src/app/shell/statusbar-visibility.test.tsx new file mode 100644 index 0000000000..cb26f286aa --- /dev/null +++ b/apps/desktop/src/app/shell/statusbar-visibility.test.tsx @@ -0,0 +1,99 @@ +import { cleanup, fireEvent, render, screen, within } from '@testing-library/react' +import { MemoryRouter } from 'react-router-dom' +import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest' + +import { StatusbarControls, type StatusbarItem } from '@/app/shell/statusbar-controls' +import { $statusbarHiddenIds, STATUSBAR_HIDDEN_BY_DEFAULT } from '@/store/statusbar-prefs' + +class TestResizeObserver { + observe() {} + unobserve() {} + disconnect() {} +} + +beforeAll(() => { + vi.stubGlobal('ResizeObserver', TestResizeObserver) + Element.prototype.hasPointerCapture ??= () => false + Element.prototype.setPointerCapture ??= () => undefined + Element.prototype.releasePointerCapture ??= () => undefined + HTMLElement.prototype.scrollIntoView ??= () => undefined +}) + +afterEach(() => { + cleanup() + $statusbarHiddenIds.set([...STATUSBAR_HIDDEN_BY_DEFAULT]) +}) + +const item = (id: string, label: string, extra: Partial = {}): StatusbarItem => ({ + id, + label, + toggleLabel: label, + variant: 'action', + ...extra +}) + +function bar(items: StatusbarItem[]) { + render( + + + + ) + + return screen.getByRole('contentinfo') +} + +/** Radix opens a ContextMenu on contextmenu after a pointerdown positions it. */ +function openContextMenu(target: HTMLElement) { + fireEvent.pointerDown(target, { button: 2, ctrlKey: false, pointerType: 'mouse' }) + fireEvent.contextMenu(target, { button: 2 }) +} + +describe('statusbar item visibility', () => { + it('hides the route/toggle items out of the box and keeps status items', () => { + bar([ + item('cron', 'Cron'), + item('webhooks', 'Webhooks'), + item('agents', 'Agents'), + item('terminal', 'Terminal'), + item('approval-mode', 'Approvals'), + item('gateway-health', 'Gateway') + ]) + + for (const label of ['Cron', 'Webhooks', 'Agents', 'Terminal', 'Approvals']) { + expect(screen.queryByText(label)).toBeNull() + } + + expect(screen.getByText('Gateway')).toBeTruthy() + }) + + it('shows an item once the user enables it from the bar context menu', async () => { + const statusbar = bar([item('cron', 'Cron'), item('gateway-health', 'Gateway')]) + + expect(screen.queryByText('Cron')).toBeNull() + + openContextMenu(statusbar) + + const row = await screen.findByRole('menuitemcheckbox', { name: 'Cron' }) + fireEvent.click(row) + + expect($statusbarHiddenIds.get()).not.toContain('cron') + expect(within(statusbar).getByText('Cron')).toBeTruthy() + }) + + it('never lets the user hide a locked item (system icon / update pill)', async () => { + const statusbar = bar([item('command-center', 'Command Center', { lockedVisible: true })]) + + openContextMenu(statusbar) + + const row = await screen.findByRole('menuitemcheckbox', { name: 'Command Center' }) + expect(row.getAttribute('data-disabled')).not.toBeNull() + expect(row.getAttribute('aria-checked')).toBe('true') + }) + + it('leaves items that never opted into the menu alone', () => { + $statusbarHiddenIds.set(['plugin-thing']) + bar([{ id: 'plugin-thing', label: 'Plugin thing', variant: 'action' }]) + + expect(screen.getByText('Plugin thing')).toBeTruthy() + }) +}) diff --git a/apps/desktop/src/components/assistant-ui/directive-text.tsx b/apps/desktop/src/components/assistant-ui/directive-text.tsx index 317489a96f..312c7d9414 100644 --- a/apps/desktop/src/components/assistant-ui/directive-text.tsx +++ b/apps/desktop/src/components/assistant-ui/directive-text.tsx @@ -277,7 +277,7 @@ function parseDirectiveText(text: string): Unstable_DirectiveSegment[] { start: match.index ?? 0, end: (match.index ?? 0) + match[0].length, type: match[1] || 'file', - label: shortLabel(match[1] as HermesRefType, id), + label: refChipLabel(match[1] || 'file', id), id } }), @@ -320,25 +320,30 @@ function parseDirectiveText(text: string): Unstable_DirectiveSegment[] { return segments } -function shortLabel(type: HermesRefType, id: string): string { +/** Display text for a `@kind:value` chip. Shared with the composer's + * contenteditable chips so a link reads the same before and after send: the + * host leads (scheme and `www.` are noise) and the path rides along for the + * chip's `truncate` to cut — a bare hostname can't tell two links apart. */ +export function refChipLabel(type: string, id: string): string { if (type === 'terminal') { return id || 'terminal' } + if (type === 'session') { + return sessionRefFallbackLabel(id) + } + if (type === 'url') { try { - const parsed = new URL(id) + const { hostname, pathname, search } = new URL(id) + const path = `${pathname}${search}`.replace(/\/$/, '') - return parsed.hostname || id + return `${hostname.replace(/^www\./i, '')}${path}` || id } catch { return id } } - if (type === 'session') { - return sessionRefFallbackLabel(id) - } - const tail = id.split(/[\\/]/).filter(Boolean).pop() return tail || id diff --git a/apps/desktop/src/components/assistant-ui/thread-remount.test.tsx b/apps/desktop/src/components/assistant-ui/thread-remount.test.tsx new file mode 100644 index 0000000000..88454751e1 --- /dev/null +++ b/apps/desktop/src/components/assistant-ui/thread-remount.test.tsx @@ -0,0 +1,125 @@ +import { AssistantRuntimeProvider, type ThreadMessage, useExternalStoreRuntime } from '@assistant-ui/react' +import { act, render, screen, waitFor } from '@testing-library/react' +import { describe, expect, it, vi } from 'vitest' + +import { Thread } from './thread' + +class NoopResizeObserver { + observe() {} + + unobserve() {} + + disconnect() {} +} + +vi.stubGlobal('ResizeObserver', NoopResizeObserver) +vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => + window.setTimeout(() => callback(performance.now()), 0) +) +vi.stubGlobal('cancelAnimationFrame', (id: number) => window.clearTimeout(id)) + +Element.prototype.scrollTo = function scrollTo() {} + +Element.prototype.animate = function animate() { + return { + cancel: () => {}, + finished: Promise.resolve() + } as unknown as Animation +} + +// jsdom returns 0 for offset*; the virtualizer reads those to size its +// viewport. Fall through to client* or a sane default so virtualized +// items render (same stub as streaming.test.tsx). +function stubOffsetDimension( + prop: 'offsetHeight' | 'offsetWidth', + clientProp: 'clientHeight' | 'clientWidth', + fallback: number +) { + const previous = Object.getOwnPropertyDescriptor(HTMLElement.prototype, prop) + + Object.defineProperty(HTMLElement.prototype, prop, { + configurable: true, + get() { + return previous?.get?.call(this) || (this as HTMLElement)[clientProp] || fallback + } + }) +} + +stubOffsetDimension('offsetWidth', 'clientWidth', 800) +stubOffsetDimension('offsetHeight', 'clientHeight', 600) + +const createdAt = new Date('2026-05-01T00:00:00.000Z') + +const MESSAGES: ThreadMessage[] = [ + { + id: 'user-1', + role: 'user', + content: [{ type: 'text', text: 'hello from the user' }], + attachments: [], + createdAt, + metadata: { custom: {} } + } as ThreadMessage, + { + id: 'assistant-1', + role: 'assistant', + content: [{ type: 'text', text: 'stable assistant reply' }], + status: { type: 'complete', reason: 'stop' }, + createdAt, + metadata: { + unstable_state: null, + unstable_annotations: [], + unstable_data: [], + steps: [], + custom: {} + } + } as ThreadMessage +] + +function Harness({ + onBranchInNewChat, + onCancel +}: { + onBranchInNewChat: (messageId: string) => void + onCancel: () => void +}) { + const runtime = useExternalStoreRuntime({ + messages: MESSAGES, + isRunning: false, + onNew: async () => {} + }) + + return ( + + + + ) +} + +describe('thread message mount stability', () => { + // Regression: the desktop controller re-renders every 15s (status + // snapshot poll) and used to pass freshly-created callbacks down to + // . Those callbacks were deps of the `messageComponents` + // useMemo, so new component *types* were created each poll and React + // unmounted/remounted every visible message — shiki re-highlighted + // code blocks and the whole thread visibly jumped. + it('keeps message DOM nodes mounted when callback props get new identities', async () => { + const { rerender } = render( {}} onCancel={() => {}} />) + + await waitFor(() => { + expect(screen.getByText('stable assistant reply')).toBeTruthy() + expect(screen.getByText('hello from the user')).toBeTruthy() + }) + + const assistantBefore = screen.getByText('stable assistant reply') + const userBefore = screen.getByText('hello from the user') + + // Same data, new callback identities — exactly what a parent + // re-render driven by an unrelated state update produces. + await act(async () => { + rerender( {}} onCancel={() => {}} />) + }) + + expect(screen.getByText('stable assistant reply')).toBe(assistantBefore) + expect(screen.getByText('hello from the user')).toBe(userBefore) + }) +}) diff --git a/apps/desktop/src/components/assistant-ui/thread/index.tsx b/apps/desktop/src/components/assistant-ui/thread/index.tsx index 984b33e0e7..946860795e 100644 --- a/apps/desktop/src/components/assistant-ui/thread/index.tsx +++ b/apps/desktop/src/components/assistant-ui/thread/index.tsx @@ -1,4 +1,4 @@ -import { type FC, useCallback, useMemo, useState } from 'react' +import { type FC, useCallback, useMemo, useRef, useState } from 'react' import { AssistantMessage } from '@/components/assistant-ui/thread/assistant-message' import { ThreadMessageList } from '@/components/assistant-ui/thread/list' @@ -67,21 +67,53 @@ export const Thread: FC<{ setRestoreConfirmTarget({ messageId, ...target }) }, []) + // The values in this map are component *types*: when their identity + // changes, React unmounts and remounts every visible message — async + // re-rendered parts (shiki code blocks) collapse and re-expand, so the + // whole thread visibly jumps. Parents re-render on unrelated state + // (e.g. the 15s status-snapshot poll in the desktop controller) and + // can't be trusted to keep callback identities stable (see #38333), so + // route the callbacks through a ref instead of listing them as memo + // deps. Only their definedness stays a dep — it gates UI (the user + // Stop button, the restore-confirm affordance). Assigned during render + // (the useStoreSelector pattern) so the ref never lags a render. + const callbacksRef = useRef({ onBranchInNewChat, onCancel, onDismissError, onRestoreToMessage }) + callbacksRef.current = { onBranchInNewChat, onCancel, onDismissError, onRestoreToMessage } + + const hasBranchInNewChat = Boolean(onBranchInNewChat) + const hasCancel = Boolean(onCancel) + const hasDismissError = Boolean(onDismissError) + const hasRestoreToMessage = Boolean(onRestoreToMessage) + const messageComponents = useMemo( () => ({ AssistantMessage: () => ( - + callbacksRef.current.onBranchInNewChat?.(messageId) : undefined + } + onDismissError={hasDismissError ? messageId => callbacksRef.current.onDismissError?.(messageId) : undefined} + /> ), SystemMessage, UserEditComposer: () => , UserMessage: () => ( callbacksRef.current.onCancel?.() : undefined} + onRequestRestoreConfirm={hasRestoreToMessage ? requestRestoreConfirm : undefined} /> ) }), - [cwd, gateway, onBranchInNewChat, onCancel, onDismissError, onRestoreToMessage, requestRestoreConfirm, sessionId] + [ + cwd, + gateway, + hasBranchInNewChat, + hasCancel, + hasDismissError, + hasRestoreToMessage, + requestRestoreConfirm, + sessionId + ] ) const emptyPlaceholder = intro ? ( diff --git a/apps/desktop/src/components/assistant-ui/thread/user-edit-composer.tsx b/apps/desktop/src/components/assistant-ui/thread/user-edit-composer.tsx index b29e13493e..5168a0d843 100644 --- a/apps/desktop/src/components/assistant-ui/thread/user-edit-composer.tsx +++ b/apps/desktop/src/components/assistant-ui/thread/user-edit-composer.tsx @@ -22,6 +22,7 @@ import { onComposerInsertRequest } from '@/app/chat/composer/focus' import { useAtCompletions } from '@/app/chat/composer/hooks/use-at-completions' +import { useComposerUndo } from '@/app/chat/composer/hooks/use-composer-undo' import { useSlashCompletions } from '@/app/chat/composer/hooks/use-slash-completions' import { dragHasAttachments, @@ -31,6 +32,7 @@ import { } from '@/app/chat/composer/inline-refs' import { composerPlainText, + insertComposerContentsAtCaret, placeCaretEnd, refChipElement, renderComposerContents, @@ -38,6 +40,8 @@ import { } from '@/app/chat/composer/rich-editor' import { detectTrigger, textBeforeCaret, type TriggerState } from '@/app/chat/composer/text-utils' import { ComposerTriggerPopover } from '@/app/chat/composer/trigger-popover' +import { isRedoShortcut, isUndoShortcut } from '@/app/chat/composer/undo-history' +import { chipTypedUrlOnSpace, linkifyUrls } from '@/app/chat/composer/url-refs' import { extractDroppedFiles, HERMES_PATHS_MIME, @@ -213,6 +217,22 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess [aui] ) + // Same stack the main composer owns, for the same reason: the editor mutates + // through `Range` to dodge Chromium's O(n²) editing pipeline, which also + // dodges its undo stack, so a paste was invisible to Cmd+Z. `rememberInitialDraft` + // already marks every mutation site (it's the dirty-edit guard), so the undo + // points ride along with it. + const syncFromEditorRef = useCallback(() => { + const editor = editorRef.current + + return editor ? syncDraftFromEditor(editor) : draftRef.current + }, [syncDraftFromEditor]) + + const { recordUndoPoint, redo, undo, withUndoPoint } = useComposerUndo({ + editorRef, + syncDraftFromEditor: syncFromEditorRef + }) + const refreshTrigger = useCallback(() => { const editor = editorRef.current @@ -276,6 +296,7 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess } rememberInitialDraft() + recordUndoPoint() const serialized = hermesDirectiveFormatter.serialize(item) const starter = serialized.endsWith(':') const text = starter || serialized.endsWith(' ') ? serialized : `${serialized} ` @@ -325,7 +346,7 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess document.execCommand('insertText', false, text) finish() }, - [aui, closeTrigger, refreshTrigger, rememberInitialDraft, requestEditFocus, trigger] + [aui, closeTrigger, recordUndoPoint, refreshTrigger, rememberInitialDraft, requestEditFocus, trigger] ) const insertRefStrings = useCallback( @@ -336,20 +357,23 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess return false } - const nextDraft = insertInlineRefsIntoEditor(editor, refs) + // Bank BEFORE the insert — insertInlineRefsIntoEditor mutates in place, so + // recording after it would snapshot the state we're trying to undo to. + const undone = withUndoPoint(() => insertInlineRefsIntoEditor(editor, refs) !== null) - if (nextDraft === null) { + if (!undone) { return false } rememberInitialDraft() + const nextDraft = composerPlainText(editor) draftRef.current = nextDraft aui.composer().setText(nextDraft) requestEditFocus() return true }, - [aui, rememberInitialDraft, requestEditFocus] + [aui, rememberInitialDraft, requestEditFocus, withUndoPoint] ) const insertDroppedRefs = useCallback( @@ -492,6 +516,19 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess window.setTimeout(refreshTrigger, 0) } + // Native typing/deleting still goes through Chromium's editing pipeline, whose + // undo stack we've taken over — bank the pre-edit state here, while + // `beforeinput` can still see the old text. + const handleBeforeInput = (event: FormEvent) => { + const inputType = (event.nativeEvent as InputEvent).inputType + + if (inputType === 'historyUndo' || inputType === 'historyRedo') { + return + } + + recordUndoPoint({ coalesce: inputType === 'insertText' || inputType === 'deleteContentBackward' }) + } + const handlePaste = (event: ClipboardEvent) => { const pastedText = sanitizeComposerInput(event.clipboardData.getData('text')) @@ -503,7 +540,10 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess event.preventDefault() rememberInitialDraft() - document.execCommand('insertText', false, pastedText) + recordUndoPoint() + + // Links land as `@url:` chips, same as the main composer. + insertComposerContentsAtCaret(event.currentTarget, linkifyUrls(pastedText)) syncDraftFromEditor(event.currentTarget) } @@ -595,6 +635,22 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess } } + // Undo/redo before Escape — we own the stack, and a stray Cmd+Z must never + // fall through to something that cancels the edit outright. + if (isUndoShortcut(event.nativeEvent)) { + event.preventDefault() + undo() + + return + } + + if (isRedoShortcut(event.nativeEvent)) { + event.preventDefault() + redo() + + return + } + if (event.key === 'Escape') { event.preventDefault() aui.composer().cancel() @@ -602,6 +658,15 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess return } + // A typed link finished with a space chips like a pasted one. + if (withUndoPoint(() => chipTypedUrlOnSpace(event))) { + event.preventDefault() + rememberInitialDraft() + syncDraftFromEditor(event.currentTarget) + + return + } + if (event.key === 'Enter' && !event.shiftKey) { event.preventDefault() submitEdit(event.currentTarget) @@ -669,6 +734,7 @@ export const UserEditComposer: FC = ({ cwd, gateway, sess contentEditable data-placeholder={copy.editMessage} data-slot={RICH_INPUT_SLOT} + onBeforeInput={handleBeforeInput} onBlur={() => window.setTimeout(closeTrigger, 80)} onDragOver={handleDragOver} onDrop={handleDrop} diff --git a/apps/desktop/src/components/assistant-ui/tool/fallback-model.test.ts b/apps/desktop/src/components/assistant-ui/tool/fallback-model.test.ts index 275cc13fb4..19a8cd6144 100644 --- a/apps/desktop/src/components/assistant-ui/tool/fallback-model.test.ts +++ b/apps/desktop/src/components/assistant-ui/tool/fallback-model.test.ts @@ -340,6 +340,28 @@ describe('buildToolView title actions', () => { expect(view.titleAction).toEqual({ prefix: '', text: 'Running', suffix: ' pnpm run lint' }) }) + it('never stutters the verb or echoes the command when the backend context is a phrased label', () => { + // Older backends stamped tool.start with a *phrased* label + // ("Running sleep 70 + 2 commands") rather than a raw arg preview, and the + // desktop merges that into args.context. The row must still prepend its own + // verb exactly once, show the real command in the `$` transcript, and not + // repeat either string as detail. + const command = 'sleep 70; echo "a"; echo "b"' + + const view = buildToolView( + part({ + args: { command, context: 'Running sleep 70 + 2 commands' }, + result: { exit_code: 0 }, + toolName: 'terminal' + }), + '' + ) + + expect(view.title).toBe('Ran sleep 70 + 2 commands') + expect(view.terminalCommand).toBe(command) + expect(view.detail).toBe('') + }) + it('uses the runtime locale for title text and action placement', () => { setRuntimeI18nLocale('ja') diff --git a/apps/desktop/src/components/assistant-ui/tool/fallback-model/index.ts b/apps/desktop/src/components/assistant-ui/tool/fallback-model/index.ts index 5c6fd8c9b0..6bcd06a63a 100644 --- a/apps/desktop/src/components/assistant-ui/tool/fallback-model/index.ts +++ b/apps/desktop/src/components/assistant-ui/tool/fallback-model/index.ts @@ -128,9 +128,14 @@ function readFileDisplayTarget(args: Record, result: Record): string { return ( - firstStringField(args, ['context', 'preview']) || firstStringField(args, ['command', 'code']) || contextValue(args) + firstStringField(args, ['command', 'code']) || firstStringField(args, ['context', 'preview']) || contextValue(args) ) } @@ -1079,6 +1084,13 @@ function toolDetailText( if (output || lines) { return [output, lines].filter(Boolean).join('\n') } + + // A terminal row with no output already shows its command in the `$` + // transcript above; the generic fallback would print the same string a + // second time. `execute_code` has no transcript, so it keeps the fallback. + if (part.toolName === 'terminal') { + return '' + } } if (part.toolName === 'web_extract') { diff --git a/apps/desktop/src/components/assistant-ui/tool/fallback.test.ts b/apps/desktop/src/components/assistant-ui/tool/fallback.test.ts index 0d844d3022..75bacb338a 100644 --- a/apps/desktop/src/components/assistant-ui/tool/fallback.test.ts +++ b/apps/desktop/src/components/assistant-ui/tool/fallback.test.ts @@ -1,7 +1,6 @@ import { describe, expect, it } from 'vitest' import { isUnboundableTool, shouldBoundToolGroup, technicalTrace } from './fallback' -import { isFileEditTool } from './fallback-model' describe('shouldBoundToolGroup', () => { it('bounds long runs of ordinary tool calls', () => { @@ -23,25 +22,18 @@ describe('isUnboundableTool', () => { expect(isUnboundableTool('image_generate')).toBe(true) }) - it('exempts tools whose body is a code block the user reads', () => { - expect(isUnboundableTool('execute_code')).toBe(true) - expect(isUnboundableTool('read_file')).toBe(true) - }) - - // The window clips a diff to a ~2-row viewport, so every tool that renders - // one has to be exempt. Derived from isFileEditTool rather than re-listed, - // so a newly supported edit tool can't be exempt in one place and clipped - // in the other. - it('exempts every file-edit tool, so diffs are never clipped', () => { - for (const toolName of ['edit_file', 'patch', 'write_file']) { - expect(isFileEditTool(toolName)).toBe(true) - expect(isUnboundableTool(toolName)).toBe(true) + // Everything ToolEntry renders carries `data-tool-row`, so the + // `:has([data-tool-row][data-tool-open])` rule in styles.css lifts the cap + // on its own. A diff row mounts open and frees the group immediately; a + // collapsed row has no body in the DOM to clip. Exempting these in JS + // instead vetoed grouping for the whole run — and since reads and edits are + // most of a coding session, runs of 19 calls never collapsed at all. + it('bounds the rows the CSS break-out already covers', () => { + for (const toolName of ['read_file', 'execute_code', 'edit_file', 'patch', 'write_file']) { + expect(isUnboundableTool(toolName)).toBe(false) } }) - // Console output is a log tail: the last lines are the ones that matter, - // which is exactly what the bounded window pins. Keeping it boundable is - // what stops the exemption from swallowing the feature whole. it('still bounds console output and other ordinary rows', () => { expect(isUnboundableTool('terminal')).toBe(false) expect(isUnboundableTool('web_search')).toBe(false) diff --git a/apps/desktop/src/components/assistant-ui/tool/fallback.tsx b/apps/desktop/src/components/assistant-ui/tool/fallback.tsx index 1ba2fd25a4..7c004e07c1 100644 --- a/apps/desktop/src/components/assistant-ui/tool/fallback.tsx +++ b/apps/desktop/src/components/assistant-ui/tool/fallback.tsx @@ -700,29 +700,24 @@ function TerminalTranscript({ command, exitCode }: TerminalTranscriptProps) { // auto-scrolling window; fewer than this stays a plain inline stack. const TOOL_GROUP_SCROLL_THRESHOLD = 3 -// Tools whose body (an interactive form, a full-size image, a syntax- -// highlighted code/diff block) must never be trapped behind the window's -// max-height + fade mask. A run holding any of them stays a plain, fully- -// visible stack no matter how long it is. +// Tools whose body must never be trapped behind the window's max-height + +// fade mask. A run holding any of them stays a plain, fully-visible stack no +// matter how long it is. // -// A row rendered by ToolEntry carries `data-tool-row`, so once the user -// expands it the `:has([data-tool-row][data-tool-open])` rule in styles.css -// lifts the cap on its own. That escape hatch is why most tools are safe to -// bound. These are the ones it cannot reach: +// This list is deliberately tiny. A row rendered by ToolEntry carries +// `data-tool-row`, and the `:has([data-tool-row][data-tool-open])` rule in +// styles.css lifts the cap whenever one is open — so anything ToolEntry +// renders takes care of itself. A code/diff row mounts open (see +// `defaultOpen`), lifting the cap the moment it appears; a collapsed row is a +// one-line status with no body in the DOM at all, so there is nothing to clip. // -// - `clarify` / `image_generate` render their own components and never emit -// `data-tool-row`, so no amount of expanding frees them. -// - the code tools *do* emit it, but their body is a code block the user -// reads rather than a one-line status — peering at a diff through a -// ~2-row viewport until you think to expand it is the bug. Console output -// (`terminal`) stays boundable: it's a log tail, and the last lines are -// the ones that matter, which is exactly what the window pins. -const CODE_BODY_TOOLS = ['execute_code', 'read_file'] - -const UNBOUNDABLE_TOOLS = new Set(['clarify', 'image_generate', ...CODE_BODY_TOOLS]) +// Only components that bypass ToolEntry need this opt-out: `clarify` and +// `image_generate` render their own markup, never emit `data-tool-row`, and so +// the CSS escape hatch can never reach them. +const UNBOUNDABLE_TOOLS = new Set(['clarify', 'image_generate']) export function isUnboundableTool(toolName: string): boolean { - return UNBOUNDABLE_TOOLS.has(toolName) || isFileEditTool(toolName) + return UNBOUNDABLE_TOOLS.has(toolName) } export function shouldBoundToolGroup(childCount: number, hasUnboundable: boolean) { diff --git a/apps/desktop/src/components/find-bar.test.tsx b/apps/desktop/src/components/find-bar.test.tsx new file mode 100644 index 0000000000..fa0d7f478c --- /dev/null +++ b/apps/desktop/src/components/find-bar.test.tsx @@ -0,0 +1,613 @@ +import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react' +import { MemoryRouter, useNavigate } from 'react-router-dom' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import { FindBar } from '@/components/find-bar' +import { I18nProvider } from '@/i18n' +import { en } from '@/i18n/en' +import { zh } from '@/i18n/zh' +import { findBarClaimsCombo, findBarKeyAction, formatMatchLabel } from '@/lib/find-in-page' +import { KEYBIND_ACTIONS } from '@/lib/keybinds/actions' +import { comboAllowedInInput } from '@/lib/keybinds/combo' +import { + $findInPage, + closeFindBar, + findInPageListenerCount, + findNext, + findPrevious, + initFindInPageListener, + openFindBar, + resetFindInPageListenerForTest, + setFindQuery, + updateFindResults +} from '@/store/find-in-page' + +// ── Bridge double ─────────────────────────────────────────────────────────── +// Stands in for the preload `hermesDesktop` surface. `onFoundInPage` records +// its subscribers so the tests can assert the listener refcount and drive +// results back into the store the way the main process would. + +interface FoundResult { + activeMatchOrdinal: number + count: number +} + +function installBridge() { + const findInPage = vi.fn().mockResolvedValue({ count: 0 }) + const stopFindInPage = vi.fn().mockResolvedValue(undefined) + const subscribers = new Set<(result: FoundResult) => void>() + + const onFoundInPage = vi.fn((callback: (result: FoundResult) => void) => { + subscribers.add(callback) + + return () => subscribers.delete(callback) + }) + + ;(window as unknown as { hermesDesktop: unknown }).hermesDesktop = { + findInPage, + stopFindInPage, + onFoundInPage + } + + return { + findInPage, + stopFindInPage, + onFoundInPage, + subscribers, + emit(result: FoundResult) { + for (const callback of [...subscribers]) { + callback(result) + } + } + } +} + +function resetStore() { + $findInPage.set({ active: false, query: '', matchOrdinal: 0, matchCount: 0 }) +} + +// Zero the bridge refcount so a leaked subscription can't bleed between tests. +function drainListeners() { + resetFindInPageListenerForTest() +} + +let bridge: ReturnType + +beforeEach(() => { + bridge = installBridge() + resetStore() +}) + +afterEach(() => { + cleanup() + resetStore() + drainListeners() + vi.restoreAllMocks() + delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop +}) + +// ── Pure: match-count formatting ──────────────────────────────────────────── + +describe('formatMatchLabel', () => { + it('hides the counter entirely when there is no query', () => { + expect(formatMatchLabel('', 0, 0)).toBe('') + // Even if stale counts linger from a previous search. + expect(formatMatchLabel('', 3, 12)).toBe('') + }) + + it('reports an explicit zero when a query matches nothing', () => { + expect(formatMatchLabel('nope', 0, 0)).toBe('0/0') + }) + + it('formats ordinal over count', () => { + expect(formatMatchLabel('hit', 3, 12)).toBe('3/12') + expect(formatMatchLabel('hit', 1, 1)).toBe('1/1') + }) + + it('shows 0 ordinal for the frame before the first match is selected', () => { + // Electron legitimately reports matches with activeMatchOrdinal 0 on the + // first (non-final) update of a fresh search. + expect(formatMatchLabel('hit', 0, 5)).toBe('0/5') + }) + + it('clamps an out-of-range ordinal into the count', () => { + expect(formatMatchLabel('hit', 99, 5)).toBe('5/5') + expect(formatMatchLabel('hit', -3, 5)).toBe('0/5') + }) + + it('never emits NaN for non-finite input', () => { + expect(formatMatchLabel('hit', Number.NaN, 4)).toBe('0/4') + expect(formatMatchLabel('hit', 2, Number.NaN)).toBe('0/0') + expect(formatMatchLabel('hit', 2, Number.POSITIVE_INFINITY)).toBe('0/0') + }) + + it('floors fractional counts rather than rendering decimals', () => { + expect(formatMatchLabel('hit', 2.7, 9.9)).toBe('2/9') + }) +}) + +// ── Pure: keybinding matcher ──────────────────────────────────────────────── + +describe('findBarKeyAction', () => { + it('maps Escape to close', () => { + expect(findBarKeyAction({ key: 'Escape' })).toBe('close') + }) + + it('maps Cmd+G / Ctrl+G to next from anywhere', () => { + expect(findBarKeyAction({ key: 'g', metaKey: true })).toBe('next') + expect(findBarKeyAction({ key: 'g', ctrlKey: true })).toBe('next') + }) + + it('maps Cmd+Shift+G / Ctrl+Shift+G to previous', () => { + // event.key is uppercase 'G' when Shift is held — matched case-insensitively. + expect(findBarKeyAction({ key: 'G', metaKey: true, shiftKey: true })).toBe('previous') + expect(findBarKeyAction({ key: 'g', ctrlKey: true, shiftKey: true })).toBe('previous') + }) + + it('steps with Enter / Shift+Enter only while focus is in the input', () => { + expect(findBarKeyAction({ key: 'Enter' }, { inInput: true })).toBe('next') + expect(findBarKeyAction({ key: 'Enter', shiftKey: true }, { inInput: true })).toBe('previous') + // Bare Enter outside the input belongs to the composer, not the find bar. + expect(findBarKeyAction({ key: 'Enter' })).toBeNull() + }) + + it('ignores a bare g so typing never triggers a step', () => { + expect(findBarKeyAction({ key: 'g' })).toBeNull() + expect(findBarKeyAction({ key: 'g' }, { inInput: true })).toBeNull() + expect(findBarKeyAction({ key: 'G', shiftKey: true }, { inInput: true })).toBeNull() + }) + + it('falls through when Alt is held so ⌥⌘G is not swallowed', () => { + expect(findBarKeyAction({ key: 'g', metaKey: true, altKey: true })).toBeNull() + expect(findBarKeyAction({ key: 'Escape', altKey: true })).toBeNull() + }) + + it('does not treat Cmd+Escape as close', () => { + expect(findBarKeyAction({ key: 'Escape', metaKey: true })).toBeNull() + }) + + it('ignores unrelated keys', () => { + expect(findBarKeyAction({ key: 'f', metaKey: true })).toBeNull() + expect(findBarKeyAction({ key: 'Tab' }, { inInput: true })).toBeNull() + }) +}) + +describe('findBarClaimsCombo', () => { + it('claims the step accelerators and Escape', () => { + expect(findBarClaimsCombo('mod+g')).toBe(true) + expect(findBarClaimsCombo('mod+shift+g')).toBe(true) + expect(findBarClaimsCombo('escape')).toBe(true) + }) + + it('leaves every other combo to the keybind registry', () => { + // ⌘F must still reach view.findInPage even while the bar is open. + expect(findBarClaimsCombo('mod+f')).toBe(false) + expect(findBarClaimsCombo('mod+k')).toBe(false) + expect(findBarClaimsCombo('mod+b')).toBe(false) + expect(findBarClaimsCombo('enter')).toBe(false) + }) +}) + +// ── Keybind registration ──────────────────────────────────────────────────── + +describe('find-in-page keybind registration', () => { + const byId = new Map(KEYBIND_ACTIONS.map(action => [action.id, action])) + + it('registers view.findInPage on mod+f in the view category', () => { + const action = byId.get('view.findInPage') + + expect(action).toBeTruthy() + expect(action?.category).toBe('view') + expect(action?.defaults).toEqual(['mod+f']) + }) + + it('mod+f fires from inside a textarea (browser find behavior)', () => { + // The runtime consults comboAllowedInInput before dispatching a combo + // while an editable element owns focus; if mod combos ever stop + // qualifying, ⌘F from the composer would type 'f' instead of opening find. + expect(comboAllowedInInput('mod+f')).toBe(true) + }) + + it('registers the step pair unbound so it cannot conflict with view.toggleReview', () => { + const next = byId.get('view.findNext') + const previous = byId.get('view.findPrevious') + + expect(next?.category).toBe('view') + expect(previous?.category).toBe('view') + // mod+g stays with view.toggleReview by default; the open find bar claims + // it at dispatch time instead (findBarClaimsCombo above). + expect(next?.defaults).toEqual([]) + expect(previous?.defaults).toEqual([]) + expect(byId.get('view.toggleReview')?.defaults).toEqual(['mod+g']) + }) + + it('every registered find action has an i18n label (keybinds panel row)', () => { + for (const id of ['view.findInPage', 'view.findNext', 'view.findPrevious']) { + expect(en.keybinds.actions[id], id).toBeTruthy() + expect(zh.keybinds.actions[id], id).toBeTruthy() + } + }) +}) + +// ── Store: open/close state + dispatch ────────────────────────────────────── + +describe('find-in-page store', () => { + it('opens with a cleared query and counters', () => { + updateFindResults(3, 12) + openFindBar() + + expect($findInPage.get()).toEqual({ active: true, query: '', matchOrdinal: 0, matchCount: 0 }) + }) + + it('closing clears state and stops the native find (clears selection)', () => { + openFindBar() + setFindQuery('needle') + updateFindResults(2, 7) + + closeFindBar() + + expect($findInPage.get().active).toBe(false) + expect($findInPage.get().query).toBe('') + expect($findInPage.get().matchCount).toBe(0) + expect(bridge.stopFindInPage).toHaveBeenCalledTimes(1) + }) + + it('closing an already-closed bar does not re-issue stopFindInPage', () => { + openFindBar() + closeFindBar() + closeFindBar() + + expect(bridge.stopFindInPage).toHaveBeenCalledTimes(1) + }) + + it('a fresh query searches from scratch (findNext false)', () => { + openFindBar() + setFindQuery('needle') + + expect(bridge.findInPage).toHaveBeenCalledWith('needle', { forward: true, findNext: false }) + }) + + it('clearing the query stops the find instead of searching for empty', () => { + openFindBar() + setFindQuery('needle') + bridge.findInPage.mockClear() + + setFindQuery('') + + expect(bridge.findInPage).not.toHaveBeenCalled() + expect(bridge.stopFindInPage).toHaveBeenCalled() + expect($findInPage.get().matchCount).toBe(0) + }) + + it('findNext steps forward and findPrevious steps backward on the same query', () => { + openFindBar() + setFindQuery('needle') + bridge.findInPage.mockClear() + + findNext() + expect(bridge.findInPage).toHaveBeenLastCalledWith('needle', { forward: true, findNext: true }) + + findPrevious() + expect(bridge.findInPage).toHaveBeenLastCalledWith('needle', { forward: false, findNext: true }) + }) + + it('stepping with no query is a no-op (never searches invisibly)', () => { + openFindBar() + + findNext() + findPrevious() + + expect(bridge.findInPage).not.toHaveBeenCalled() + }) + + it('setFindQuery on a closed bar never searches', () => { + // A debounce timer that already fired, or any late caller, must not + // re-highlight the page after the user dismissed the bar. + setFindQuery('needle') + + expect(bridge.findInPage).not.toHaveBeenCalled() + expect($findInPage.get().query).toBe('') + }) + + it('found-in-page results land on the store', () => { + openFindBar() + setFindQuery('needle') + const release = initFindInPageListener() + + bridge.emit({ activeMatchOrdinal: 4, count: 9 }) + + expect($findInPage.get().matchOrdinal).toBe(4) + expect($findInPage.get().matchCount).toBe(9) + release() + }) + + it('refcounts the bridge listener so remounts cannot stack subscriptions', () => { + const first = initFindInPageListener() + const second = initFindInPageListener() + + // One real bridge subscription regardless of subscriber count. + expect(bridge.onFoundInPage).toHaveBeenCalledTimes(1) + expect(bridge.subscribers.size).toBe(1) + expect(findInPageListenerCount()).toBe(2) + + first() + // Still one holder → the bridge listener stays installed. + expect(bridge.subscribers.size).toBe(1) + + second() + // Last holder released → the listener is detached, nothing leaks. + expect(bridge.subscribers.size).toBe(0) + expect(findInPageListenerCount()).toBe(0) + }) + + it('releasing the same subscription twice cannot drive the refcount negative', () => { + const release = initFindInPageListener() + release() + release() + + expect(findInPageListenerCount()).toBe(0) + + // A fresh subscribe after a double-release still installs exactly one. + const next = initFindInPageListener() + expect(bridge.subscribers.size).toBe(1) + next() + }) +}) + +// ── Component ─────────────────────────────────────────────────────────────── + +// Store mutations that a MOUNTED FindBar subscribes to must be act()-wrapped +// so React flushes the resulting re-render inside the test. +function actStore(mutate: () => void) { + act(() => { + mutate() + }) +} + +function renderFindBar(initialPath = '/') { + return render( + + + + + + ) +} + +/** Harness that can navigate the route the mounted FindBar observes. */ +function renderFindBarWithNavigation(initialPath = '/session/a') { + let navigateRef: ReturnType | undefined + + function CaptureNavigate() { + navigateRef = useNavigate() + + return null + } + + const view = render( + + + + + + + ) + + return { ...view, navigate: (to: string) => act(() => navigateRef?.(to)) } +} + +describe('FindBar', () => { + it('renders nothing while closed', () => { + renderFindBar() + + expect(screen.queryByRole('search')).toBeNull() + }) + + it('renders input, counter and close button when open with results', async () => { + openFindBar() + renderFindBar() + + const input = await screen.findByRole('textbox', { name: /find in page/i }) + expect(input).toBeTruthy() + expect(screen.getByRole('button', { name: /close/i })).toBeTruthy() + expect(screen.getByRole('button', { name: /next match/i })).toBeTruthy() + expect(screen.getByRole('button', { name: /previous match/i })).toBeTruthy() + + // Counter appears once a query + results exist. + expect(screen.queryByText('3/12')).toBeNull() + actStore(() => $findInPage.set({ active: true, query: 'needle', matchOrdinal: 3, matchCount: 12 })) + await waitFor(() => expect(screen.getByText('3/12')).toBeTruthy()) + }) + + it('focuses the input on open', async () => { + openFindBar() + renderFindBar() + + const input = await screen.findByRole('textbox', { name: /find in page/i }) + // eslint-disable-next-line no-restricted-globals -- asserting real focus requires the live document + await waitFor(() => expect(document.activeElement).toBe(input)) + }) + + it('debounces typing into a single findInPage call', async () => { + vi.useFakeTimers() + + try { + openFindBar() + renderFindBar() + + const input = screen.getByRole('textbox', { name: /find in page/i }) + fireEvent.change(input, { target: { value: 'n' } }) + fireEvent.change(input, { target: { value: 'ne' } }) + fireEvent.change(input, { target: { value: 'nee' } }) + + expect(bridge.findInPage).not.toHaveBeenCalled() + + // Flushing the debounce updates the store, which re-renders the bar. + act(() => { + vi.advanceTimersByTime(200) + }) + + expect(bridge.findInPage).toHaveBeenCalledTimes(1) + expect(bridge.findInPage).toHaveBeenCalledWith('nee', { forward: true, findNext: false }) + } finally { + vi.useRealTimers() + } + }) + + it('does not fire a pending search after the bar closes', async () => { + vi.useFakeTimers() + + try { + openFindBar() + renderFindBar() + + fireEvent.change(screen.getByRole('textbox', { name: /find in page/i }), { + target: { value: 'needle' } + }) + + actStore(closeFindBar) + vi.advanceTimersByTime(500) + + expect(bridge.findInPage).not.toHaveBeenCalled() + } finally { + vi.useRealTimers() + } + }) + + it('Enter dispatches next and Shift+Enter dispatches previous', async () => { + $findInPage.set({ active: true, query: 'needle', matchOrdinal: 1, matchCount: 4 }) + renderFindBar() + + const input = screen.getByRole('textbox', { name: /find in page/i }) + + fireEvent.keyDown(input, { key: 'Enter' }) + expect(bridge.findInPage).toHaveBeenLastCalledWith('needle', { forward: true, findNext: true }) + + fireEvent.keyDown(input, { key: 'Enter', shiftKey: true }) + expect(bridge.findInPage).toHaveBeenLastCalledWith('needle', { forward: false, findNext: true }) + }) + + it('Cmd+G / Cmd+Shift+G step from outside the input while the bar is open', async () => { + $findInPage.set({ active: true, query: 'needle', matchOrdinal: 1, matchCount: 4 }) + renderFindBar() + + // Fired on window (not the input) — the accelerator must not require focus. + fireEvent.keyDown(window, { key: 'g', metaKey: true }) + expect(bridge.findInPage).toHaveBeenLastCalledWith('needle', { forward: true, findNext: true }) + + fireEvent.keyDown(window, { key: 'G', metaKey: true, shiftKey: true }) + expect(bridge.findInPage).toHaveBeenLastCalledWith('needle', { forward: false, findNext: true }) + }) + + it('Escape closes the bar and clears the native selection', async () => { + openFindBar() + renderFindBar() + + fireEvent.keyDown(window, { key: 'Escape' }) + + expect($findInPage.get().active).toBe(false) + expect(bridge.stopFindInPage).toHaveBeenCalledTimes(1) + await waitFor(() => expect(screen.queryByRole('search')).toBeNull()) + }) + + it('the close button clears state and stops the find', async () => { + openFindBar() + renderFindBar() + + fireEvent.click(screen.getByRole('button', { name: /close/i })) + + expect($findInPage.get().active).toBe(false) + expect(bridge.stopFindInPage).toHaveBeenCalledTimes(1) + }) + + it('the next / previous buttons dispatch a step', () => { + $findInPage.set({ active: true, query: 'needle', matchOrdinal: 1, matchCount: 4 }) + renderFindBar() + + fireEvent.click(screen.getByRole('button', { name: /next match/i })) + expect(bridge.findInPage).toHaveBeenLastCalledWith('needle', { forward: true, findNext: true }) + + fireEvent.click(screen.getByRole('button', { name: /previous match/i })) + expect(bridge.findInPage).toHaveBeenLastCalledWith('needle', { forward: false, findNext: true }) + }) + + it('keeps exactly one bridge subscription across an open/close cycle', async () => { + renderFindBar() + + // Mounted-but-closed already holds the subscription: results for an + // in-flight search must still land after the bar hides. + expect(bridge.subscribers.size).toBe(1) + + actStore(openFindBar) + await waitFor(() => expect(screen.getByRole('search')).toBeTruthy()) + actStore(closeFindBar) + await waitFor(() => expect(screen.queryByRole('search')).toBeNull()) + actStore(openFindBar) + + // Toggling visibility must not stack listeners — the subscription is + // mount-scoped, not active-scoped. + expect(bridge.onFoundInPage).toHaveBeenCalledTimes(1) + expect(bridge.subscribers.size).toBe(1) + }) + + it('unmount releases the bridge subscription (no leak across route changes)', () => { + const { unmount } = renderFindBar() + expect(bridge.subscribers.size).toBe(1) + + unmount() + + expect(bridge.subscribers.size).toBe(0) + expect(findInPageListenerCount()).toBe(0) + }) + + it('a remount does not stack subscriptions', () => { + const first = renderFindBar() + first.unmount() + + const second = renderFindBar() + + expect(bridge.subscribers.size).toBe(1) + second.unmount() + expect(bridge.subscribers.size).toBe(0) + }) + + it('the window key listener is removed on unmount', () => { + openFindBar() + const { unmount } = renderFindBar() + + unmount() + bridge.stopFindInPage.mockClear() + + // Reopen the store WITHOUT a mounted bar; a leaked listener would still + // handle Escape and call into the bridge. + actStore(openFindBar) + fireEvent.keyDown(window, { key: 'Escape' }) + + expect(bridge.stopFindInPage).not.toHaveBeenCalled() + }) + + it('navigating to another route closes the bar and clears the highlights', async () => { + const { navigate } = renderFindBarWithNavigation('/session/a') + + actStore(openFindBar) + actStore(() => $findInPage.set({ active: true, query: 'needle', matchOrdinal: 2, matchCount: 7 })) + await waitFor(() => expect(screen.getByRole('search')).toBeTruthy()) + + navigate('/session/b') + + // Bar gone, state reset, and the native selection cleared — stale + // highlights must not survive a session switch. + await waitFor(() => expect(screen.queryByRole('search')).toBeNull()) + expect($findInPage.get()).toEqual({ active: false, query: '', matchOrdinal: 0, matchCount: 0 }) + expect(bridge.stopFindInPage).toHaveBeenCalledTimes(1) + }) + + it('navigation while the bar is closed does not reach into the bridge', async () => { + const { navigate } = renderFindBarWithNavigation('/session/a') + + navigate('/session/b') + + await waitFor(() => expect(screen.queryByRole('search')).toBeNull()) + expect(bridge.stopFindInPage).not.toHaveBeenCalled() + }) +}) diff --git a/apps/desktop/src/components/find-bar.tsx b/apps/desktop/src/components/find-bar.tsx new file mode 100644 index 0000000000..6e99e581ae --- /dev/null +++ b/apps/desktop/src/components/find-bar.tsx @@ -0,0 +1,224 @@ +import { useStore } from '@nanostores/react' +import { useEffect, useRef, useState } from 'react' +import { useLocation } from 'react-router-dom' + +import { Tip } from '@/components/ui/tooltip' +import { useI18n } from '@/i18n' +import { findBarKeyAction, formatMatchLabel } from '@/lib/find-in-page' +import { cn } from '@/lib/utils' +import { + $findInPage, + closeFindBar, + findNext, + findPrevious, + initFindInPageListener, + setFindQuery +} from '@/store/find-in-page' + +/** + * Find-in-page overlay (⌘F). + * + * Drives Electron's `webContents.findInPage` via the preload bridge so the + * user gets the native browser-like incremental search (highlight, step, + * Escape to clear) over the rendered chat transcript + editor panels. Multi- + * window routing is handled in the main process — see + * apps/desktop/electron/find-in-page.ts. + * + * Accelerators, matching the platform convention (and Claude Desktop's set): + * ⌘F opens (via the `view.findInPage` keybind), ⌘G / ⌘⇧G step next/previous + * from anywhere while the bar is open, Enter / ⇧Enter step from the input, + * and Escape closes + clears the native selection. + * + * Key routing lives in `lib/find-in-page.ts` as a pure matcher so the + * accelerator set is testable without a DOM. + */ +export function FindBar() { + const { t } = useI18n() + const { active, query, matchOrdinal, matchCount } = useStore($findInPage) + const inputRef = useRef(null) + const [localQuery, setLocalQuery] = useState('') + const { pathname } = useLocation() + + // Navigating away (opening another session, a settings page, …) closes the + // bar and clears the native highlight. Electron's findInPage selection is + // per-webContents, not per-route: without this, highlights (and a stale + // match counter) from the previous chat would survive onto the next view. + // Implemented as effect cleanup so the first render never fires it, a + // pathname change tears down the previous route's search, and unmount + // (session/profile switches that remount the shell) gets the same teardown. + // closeFindBar is idempotent, so a closed bar never re-enters the bridge. + useEffect(() => { + void pathname + + return () => closeFindBar() + }, [pathname]) + + // Focus input when find bar opens. + useEffect(() => { + if (active) { + setLocalQuery('') + // Small delay so the DOM paints the input before we focus. + const id = requestAnimationFrame(() => inputRef.current?.focus()) + + return () => cancelAnimationFrame(id) + } + + return undefined + }, [active]) + + // Subscribe to found-in-page results from the main process. Refcounted in + // the store, so a remount (connection re-home) can't stack listeners; the + // subscription is deliberately mount-scoped and NOT tied to `active` — + // results for an in-flight search must still land if the bar just closed. + useEffect(() => initFindInPageListener(), []) + + // Debounce search — fire findInPage 200ms after the user stops typing. + useEffect(() => { + if (!active || !localQuery) { + return undefined + } + + const id = setTimeout(() => setFindQuery(localQuery), 200) + + // Cleanup covers every exit: another keystroke, the bar closing, and + // unmount. Nothing can fire a find after the bar is gone. + return () => clearTimeout(id) + }, [active, localQuery]) + + // Global accelerators while the bar is open: Escape closes, ⌘G / ⌘⇧G step. + // Capture-phase so they win regardless of which element inside the shell + // owns focus (composer textarea, side panel button, …). ⌘G is also bound to + // `view.toggleReview` in the keybinds registry — this listener runs in the + // capture phase and stops propagation, so while the find bar is open ⌘G + // means "find next" and the review toggle does not also fire. Closing the + // bar hands ⌘G straight back to the review pane. + useEffect(() => { + if (!active) { + return undefined + } + + const onKeyDown = (event: KeyboardEvent) => { + const action = findBarKeyAction(event) + + if (!action) { + return + } + + event.preventDefault() + event.stopPropagation() + + if (action === 'close') { + closeFindBar() + } else if (action === 'next') { + findNext() + } else { + findPrevious() + } + } + + window.addEventListener('keydown', onKeyDown, { capture: true }) + + return () => window.removeEventListener('keydown', onKeyDown, { capture: true }) + }, [active]) + + if (!active) { + return null + } + + const onInput = (event: React.ChangeEvent) => { + const value = event.target.value + setLocalQuery(value) + + // Empty query: clear highlights immediately rather than after the debounce. + if (!value) { + setFindQuery('') + } + } + + // Enter / ⇧Enter step while focus is in the input. Escape and ⌘G are handled + // by the window listener above, so they are intentionally not duplicated + // here — `inInput` only unlocks the bare-Enter family. + const onKeyDown = (event: React.KeyboardEvent) => { + const action = findBarKeyAction(event, { inInput: true }) + + if (action !== 'next' && action !== 'previous') { + return + } + + event.preventDefault() + + if (action === 'next') { + findNext() + } else { + findPrevious() + } + } + + const matchLabel = formatMatchLabel(query, matchOrdinal, matchCount) + + return ( +
+ + + {matchLabel && ( + + {matchLabel} + + )} + + + + + + + + + + + + +
+ ) +} diff --git a/apps/desktop/src/components/pane-shell/tree/renderer/tree-group.tsx b/apps/desktop/src/components/pane-shell/tree/renderer/tree-group.tsx index 1ed752f1dd..74a278ed51 100644 --- a/apps/desktop/src/components/pane-shell/tree/renderer/tree-group.tsx +++ b/apps/desktop/src/components/pane-shell/tree/renderer/tree-group.tsx @@ -89,7 +89,11 @@ function ZoneMenu({ /** False for the zone hosting the uncloseable workspace — collapsing the * MAIN pane strands the app behind a strip. */ minimizable?: boolean - directions: ZoneMenuDirection[] + /** Called when the menu renders, not on every zone re-render: resolving the + * neighbor zones has to read the layout tree, and subscribing every zone to + * it made a sash drag re-render every mounted pane. Same lazy shape as + * `closable`. */ + directions: () => ZoneMenuDirection[] headerHidden?: boolean minimized?: boolean nodeId: string @@ -100,7 +104,7 @@ function ZoneMenu({ {children} - {directions.map(direction => ( + {directions().map(direction => ( {direction.label} @@ -255,30 +259,43 @@ export function TreeGroup({ // - a single pane -> "Move ": join the zone visually adjacent on that // side (splitting here would only make an invisible empty zone). Sides // with no visible neighbor are omitted entirely. - const tree = useStore($layoutTree) + // NOT `useStore($layoutTree)`: this subscribes every zone — and therefore + // every mounted pane and its whole transcript — to the entire layout tree. + // A sash drag rewrites the tree once per frame, so dragging the sidebar + // re-rendered all five tiles' message lists on every pointermove (measured: + // TreeGroup 180 renders cascading into ChatView/Thread/TileChat at ~4.5s + // each, holding the drag at ~3fps). + // + // The tree is only read to build the zone context menu's move/split + // directions, which are consumed when the menu OPENS — so read it at that + // moment with `.get()` instead of subscribing to every intermediate frame. + const menuDirections = (): ZoneMenuDirection[] => { + if (shown.length > 1) { + return DIRECTION_ORDER.map(side => ({ + side, + label: `${t.zones.split(dirWord[side])} ${DIRECTION_ARROW[side]}`, + run: () => splitTreeZone(node.id, side, menuPane ?? activeId) + })) + } - const menuDirections: ZoneMenuDirection[] = - shown.length > 1 - ? DIRECTION_ORDER.map(side => ({ + const tree = $layoutTree.get() + + return DIRECTION_ORDER.flatMap(side => { + const neighbor = tree ? adjacentGroup(tree, node.id, side, g => g.panes.some(paneShown)) : null + + if (!neighbor || neighbor.id === node.id) { + return [] + } + + return [ + { side, - label: `${t.zones.split(dirWord[side])} ${DIRECTION_ARROW[side]}`, - run: () => splitTreeZone(node.id, side, menuPane ?? activeId) - })) - : DIRECTION_ORDER.flatMap(side => { - const neighbor = tree ? adjacentGroup(tree, node.id, side, g => g.panes.some(paneShown)) : null - - if (!neighbor || neighbor.id === node.id) { - return [] - } - - return [ - { - side, - label: `${t.zones.move(dirWord[side])} ${DIRECTION_ARROW[side]}`, - run: () => moveTreePane(activeId, { groupId: neighbor.id, pos: 'center' }) - } - ] - }) + label: `${t.zones.move(dirWord[side])} ${DIRECTION_ARROW[side]}`, + run: () => moveTreePane(activeId, { groupId: neighbor.id, pos: 'center' }) + } + ] + }) + } // Close targets the right-clicked chip (falling back to the active pane); // only panes that declare `uncloseable` (the main workspace) are exempt. diff --git a/apps/desktop/src/components/pet/pet-sprite.test.tsx b/apps/desktop/src/components/pet/pet-sprite.test.tsx new file mode 100644 index 0000000000..f197ec49d8 --- /dev/null +++ b/apps/desktop/src/components/pet/pet-sprite.test.tsx @@ -0,0 +1,228 @@ +import { act, type ReactNode } from 'react' +import { createRoot, type Root } from 'react-dom/client' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +vi.mock('@/store/pet', () => { + const listeners = new Set<(state: string) => void>() + + return { + $petState: { + get: () => 'idle', + listen: (callback: (state: string) => void) => { + listeners.add(callback) + + return () => { + listeners.delete(callback) + } + } + } + } +}) + +import { PetSprite } from './pet-sprite' + +const INFO = { + enabled: true, + frameH: 16, + frameW: 16, + framesPerState: 2, + loopMs: 120, + scale: 1, + spritesheetBase64: 'stub', + stateRows: ['idle'] +} + +let root: Root | null = null +let container: HTMLDivElement | null = null +let windowStateCallback: ((payload: { isMinimized?: boolean; isVisible?: boolean }) => void) | null = null + +function render(ui: ReactNode) { + container = document.createElement('div') + document.body.append(container) + root = createRoot(container) + + act(() => { + root!.render(ui) + }) +} + +function cleanup() { + if (root) { + act(() => { + root!.unmount() + }) + } + + container?.remove() + root = null + container = null +} + +function setVisibility(hidden: boolean) { + Object.defineProperty(document, 'hidden', { configurable: true, value: hidden }) + Object.defineProperty(document, 'visibilityState', { configurable: true, value: hidden ? 'hidden' : 'visible' }) +} + +function installWindowStateBridge() { + windowStateCallback = null + Object.defineProperty(window, 'hermesDesktop', { + configurable: true, + value: { + onWindowStateChanged: vi.fn((callback: typeof windowStateCallback) => { + windowStateCallback = callback + + return () => { + if (windowStateCallback === callback) { + windowStateCallback = null + } + } + }) + } + }) +} + +function installRaf() { + let nextId = 1 + const frames = new Map() + + const request = vi.fn((callback: FrameRequestCallback) => { + const id = nextId++ + frames.set(id, callback) + + return id + }) + + const cancel = vi.fn((id: number) => { + frames.delete(id) + }) + + Object.defineProperty(window, 'requestAnimationFrame', { configurable: true, value: request }) + Object.defineProperty(window, 'cancelAnimationFrame', { configurable: true, value: cancel }) + + return { + cancel, + pending: () => frames.size, + request, + runNext: (now: number) => { + const next = frames.entries().next().value + + if (!next) { + throw new Error('No pending RAF') + } + + const [id, callback] = next + frames.delete(id) + callback(now) + } + } +} + +describe('PetSprite RAF scheduling', () => { + beforeEach(() => { + ;(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true + vi.useFakeTimers() + setVisibility(false) + vi.spyOn(document, 'hasFocus').mockReturnValue(true) + installWindowStateBridge() + vi.stubGlobal( + 'Image', + class extends EventTarget { + complete = true + naturalWidth = 16 + src = '' + } as unknown as typeof Image + ) + vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue({ + clearRect: vi.fn(), + drawImage: vi.fn(), + imageSmoothingEnabled: false + } as unknown as CanvasRenderingContext2D) + }) + + afterEach(() => { + cleanup() + vi.useRealTimers() + vi.unstubAllGlobals() + vi.restoreAllMocks() + setVisibility(false) + delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop + }) + + it('sleeps between visible sprite frames instead of chaining RAFs', () => { + const raf = installRaf() + + render() + + expect(raf.request).toHaveBeenCalledTimes(1) + + act(() => { + raf.runNext(0) + }) + + expect(raf.request).toHaveBeenCalledTimes(1) + expect(raf.pending()).toBe(0) + expect(vi.getTimerCount()).toBe(1) + + act(() => { + vi.advanceTimersByTime(60) + }) + + expect(raf.request).toHaveBeenCalledTimes(2) + }) + + it('cancels pending RAF work while the Electron window is paused and resumes when visible', () => { + const raf = installRaf() + + render() + + expect(raf.request).toHaveBeenCalledTimes(1) + + act(() => { + windowStateCallback?.({ isMinimized: true, isVisible: false }) + }) + + expect(raf.cancel).toHaveBeenCalledTimes(1) + expect(raf.pending()).toBe(0) + + act(() => { + windowStateCallback?.({ isMinimized: false, isVisible: true }) + }) + + expect(raf.request).toHaveBeenCalledTimes(2) + }) + + it('suspends while unfocused, resumes on focus, and leaves no work after unmount', () => { + const raf = installRaf() + + render() + + act(() => window.dispatchEvent(new Event('blur'))) + expect(raf.pending()).toBe(0) + + act(() => window.dispatchEvent(new Event('focus'))) + expect(raf.pending()).toBe(1) + + act(() => raf.runNext(0)) + expect(vi.getTimerCount()).toBe(1) + + cleanup() + expect(raf.pending()).toBe(0) + expect(vi.getTimerCount()).toBe(0) + + act(() => { + vi.advanceTimersByTime(500) + window.dispatchEvent(new Event('focus')) + }) + expect(raf.pending()).toBe(0) + }) + + it('keeps the intentionally non-activating pop-out overlay animated while unfocused', () => { + const raf = installRaf() + + render() + + act(() => window.dispatchEvent(new Event('blur'))) + + expect(raf.pending()).toBe(1) + }) +}) diff --git a/apps/desktop/src/components/pet/pet-sprite.tsx b/apps/desktop/src/components/pet/pet-sprite.tsx index a1e91f3ece..9e79dc9953 100644 --- a/apps/desktop/src/components/pet/pet-sprite.tsx +++ b/apps/desktop/src/components/pet/pet-sprite.tsx @@ -1,5 +1,6 @@ import { memo, useEffect, useMemo, useRef } from 'react' +import { createRendererLoopPauseController } from '@/lib/renderer-loop-pause' import { $petState, type PetInfo, type PetState } from '@/store/pet' const DEFAULT_FRAME_W = 192 @@ -91,6 +92,8 @@ export function roamWalkRow(dir: -1 | 0 | 1, stateRows?: string[]): { row?: stri interface PetSpriteProps { info: PetInfo + /** Keep animating in a deliberately non-activating visible window, such as the pop-out pet overlay. */ + pauseWhenUnfocused?: boolean /** On-screen scale multiplier applied on top of the pet's native scale. */ zoom?: number /** @@ -114,21 +117,24 @@ interface PetSpriteProps { * with `memo`, this component effectively never re-renders after mount until * the pet itself changes. */ -function PetSpriteImpl({ info, zoom = 1, stateOverride, rowOverride }: PetSpriteProps) { +function PetSpriteImpl({ info, zoom = 1, stateOverride, rowOverride, pauseWhenUnfocused = true }: PetSpriteProps) { const canvasRef = useRef(null) const stateRef = useRef($petState.get()) const overrideRef = useRef(stateOverride) const rowOverrideRef = useRef(rowOverride) + const kickAnimationRef = useRef<() => void>(() => undefined) // Keep the override current without re-running the RAF setup effect. // eslint-disable-next-line no-restricted-syntax -- legitimate non-atom ref write (see eslint rule comment) useEffect(() => { overrideRef.current = stateOverride + kickAnimationRef.current() }, [stateOverride]) // eslint-disable-next-line no-restricted-syntax -- legitimate non-atom ref write (see eslint rule comment) useEffect(() => { rowOverrideRef.current = rowOverride + kickAnimationRef.current() }, [rowOverride]) const frameW = info.frameW ?? DEFAULT_FRAME_W @@ -173,17 +179,75 @@ function PetSpriteImpl({ info, zoom = 1, stateOverride, rowOverride }: PetSprite // Track state via subscription, not a prop — no re-render on activity ticks. stateRef.current = $petState.get() - const unsubState = $petState.listen(next => { - stateRef.current = next - }) - let raf = 0 + let wakeTimer = 0 + let stopped = false let frame = 0 let lastStep = performance.now() let drawnFrame = -1 let drawnRow = -1 let activeRow = -1 let activeCount = -1 + let pauseController: ReturnType | null = null + + const rendererPaused = () => pauseController?.isPaused() ?? document.visibilityState === 'hidden' + + const cancelWakeTimer = () => { + if (wakeTimer !== 0) { + window.clearTimeout(wakeTimer) + wakeTimer = 0 + } + } + + const cancelRaf = () => { + if (raf !== 0) { + window.cancelAnimationFrame(raf) + raf = 0 + } + } + + const clearScheduled = () => { + cancelWakeTimer() + cancelRaf() + } + + const scheduleFrame = (delayMs = 0) => { + if (stopped || rendererPaused() || raf !== 0 || wakeTimer !== 0) { + return + } + + if (delayMs > 16) { + wakeTimer = window.setTimeout(() => { + wakeTimer = 0 + scheduleFrame() + }, delayMs) + + return + } + + raf = window.requestAnimationFrame(render) + } + + const kickAnimation = () => { + if (stopped || rendererPaused()) { + return + } + + cancelWakeTimer() + scheduleFrame() + } + + const handleVisibilityChange = () => { + clearScheduled() + + if (rendererPaused()) { + return + } + + lastStep = performance.now() + drawnFrame = -1 + kickAnimation() + } const rowIndexForState = (s: PetState): number => { for (const key of STATE_ALIASES[s] ?? [s]) { @@ -223,6 +287,12 @@ function PetSpriteImpl({ info, zoom = 1, stateOverride, rowOverride }: PetSprite } const render = (now: number) => { + raf = 0 + + if (stopped || rendererPaused()) { + return + } + const forcedRow = rowOverrideRef.current const { row, count } = forcedRow ? resolveRow(forcedRow) : resolve(overrideRef.current ?? stateRef.current) @@ -245,10 +315,13 @@ function PetSpriteImpl({ info, zoom = 1, stateOverride, rowOverride }: PetSprite frame %= count + if (!image.complete || image.naturalWidth <= 0) { + return + } + // Only touch the canvas when the visible cell actually changes. The RAF - // ticks at ~60Hz but the sprite only steps ~5Hz, so this skips ~90% of - // the clear+draw work and keeps the main thread free. - if ((frame !== drawnFrame || row !== drawnRow) && image.complete && image.naturalWidth > 0) { + // wakes when a sprite cell is due, so the idle path avoids a 60Hz loop. + if (frame !== drawnFrame || row !== drawnRow) { const sx = frame * frameW const sy = row * frameH ctx.clearRect(0, 0, canvas.width, canvas.height) @@ -258,16 +331,29 @@ function PetSpriteImpl({ info, zoom = 1, stateOverride, rowOverride }: PetSprite drawnRow = row } - raf = requestAnimationFrame(render) + scheduleFrame(Math.max(0, stepMs - (now - lastStep))) } - raf = requestAnimationFrame(render) + kickAnimationRef.current = kickAnimation + + const unsubState = $petState.listen(next => { + stateRef.current = next + kickAnimation() + }) + + image.addEventListener('load', kickAnimation) + pauseController = createRendererLoopPauseController(handleVisibilityChange, { pauseWhenUnfocused }) + scheduleFrame() return () => { - cancelAnimationFrame(raf) + stopped = true + kickAnimationRef.current = () => undefined + clearScheduled() + image.removeEventListener('load', kickAnimation) + pauseController?.dispose() unsubState() } - }, [image, frameW, frameH, frames, framesByState, framesByRow, loopMs, drawW, drawH, rows]) + }, [image, frameW, frameH, frames, framesByState, framesByRow, loopMs, drawW, drawH, rows, pauseWhenUnfocused]) return ( ({ + $petMotion: { set: () => undefined }, + $petRoamDir: { set: () => undefined } +})) + +import { usePetRoam } from './use-pet-roam' + +let root: Root | null = null +let container: HTMLDivElement | null = null +let windowStateCallback: ((payload: { isMinimized?: boolean; isVisible?: boolean }) => void) | null = null + +function render(ui: ReactNode) { + container = document.createElement('div') + document.body.append(container) + root = createRoot(container) + + act(() => { + root!.render(ui) + }) +} + +function cleanup() { + if (root) { + act(() => { + root!.unmount() + }) + } + + container?.remove() + root = null + container = null +} + +function setVisibility(hidden: boolean) { + Object.defineProperty(document, 'hidden', { configurable: true, value: hidden }) + Object.defineProperty(document, 'visibilityState', { configurable: true, value: hidden ? 'hidden' : 'visible' }) +} + +function installWindowStateBridge() { + windowStateCallback = null + Object.defineProperty(window, 'hermesDesktop', { + configurable: true, + value: { + onWindowStateChanged: vi.fn((callback: typeof windowStateCallback) => { + windowStateCallback = callback + + return () => { + if (windowStateCallback === callback) { + windowStateCallback = null + } + } + }) + } + }) +} + +function installRaf() { + const request = vi.fn((_callback: FrameRequestCallback) => 1) + const cancel = vi.fn() + + Object.defineProperty(window, 'requestAnimationFrame', { configurable: true, value: request }) + Object.defineProperty(window, 'cancelAnimationFrame', { configurable: true, value: cancel }) + + return { cancel, request } +} + +function RoamHarness({ isInteracting = () => false }: { isInteracting?: () => boolean }) { + const ref = useRef(null) + + usePetRoam({ + commit: () => undefined, + containerRef: ref as RefObject, + enabled: true, + isInteracting, + loopMs: 1200, + overlayOpen: false, + petH: 64, + petW: 64 + }) + + return
+} + +describe('usePetRoam RAF scheduling', () => { + beforeEach(() => { + ;(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true + vi.useFakeTimers() + setVisibility(false) + vi.spyOn(document, 'hasFocus').mockReturnValue(true) + installWindowStateBridge() + vi.spyOn(Math, 'random').mockReturnValue(0) + vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockReturnValue({ + bottom: 164, + height: 64, + left: 100, + right: 164, + top: 100, + width: 64, + x: 100, + y: 100, + toJSON: () => ({}) + } as DOMRect) + }) + + afterEach(() => { + cleanup() + vi.useRealTimers() + vi.restoreAllMocks() + setVisibility(false) + delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop + }) + + it('uses a pause timer, not RAF, while dwelling at idle', () => { + const raf = installRaf() + + render() + + expect(raf.request).not.toHaveBeenCalled() + expect(vi.getTimerCount()).toBe(1) + }) + + it('clears the pause wakeup while the Electron window is paused and restarts it when visible', () => { + const raf = installRaf() + + render() + expect(vi.getTimerCount()).toBe(1) + + windowStateCallback?.({ isMinimized: true, isVisible: false }) + + expect(raf.cancel).not.toHaveBeenCalled() + expect(raf.request).not.toHaveBeenCalled() + expect(vi.getTimerCount()).toBe(0) + + windowStateCallback?.({ isMinimized: false, isVisible: true }) + + expect(raf.request).not.toHaveBeenCalled() + expect(vi.getTimerCount()).toBe(1) + }) + + it('suspends idle movement while unfocused and cleans up its wake timer on unmount', () => { + const raf = installRaf() + + render() + expect(vi.getTimerCount()).toBe(1) + + act(() => window.dispatchEvent(new Event('blur'))) + expect(vi.getTimerCount()).toBe(0) + + act(() => window.dispatchEvent(new Event('focus'))) + expect(vi.getTimerCount()).toBe(1) + + cleanup() + expect(vi.getTimerCount()).toBe(0) + + act(() => { + vi.advanceTimersByTime(2000) + window.dispatchEvent(new Event('focus')) + }) + expect(raf.request).not.toHaveBeenCalled() + expect(vi.getTimerCount()).toBe(0) + }) +}) diff --git a/apps/desktop/src/components/pet/use-pet-roam.ts b/apps/desktop/src/components/pet/use-pet-roam.ts index 84d7b5386a..2850f47377 100644 --- a/apps/desktop/src/components/pet/use-pet-roam.ts +++ b/apps/desktop/src/components/pet/use-pet-roam.ts @@ -1,5 +1,6 @@ import { type RefObject, useEffect } from 'react' +import { createRendererLoopPauseController } from '@/lib/renderer-loop-pause' import { $petMotion, $petRoamDir, type PetState } from '@/store/pet' import { chooseMove, dwellMs, PAUSE_DWELL, pickStrollTarget } from './roam-behavior' @@ -33,6 +34,8 @@ const DROP_SETTLE_MS = 90 const ARRIVE_EPS = 1.5 // Cap dt so a backgrounded/throttled tab can't teleport the pet on resume. const MAX_DT_S = 0.05 +// While paused, wake rarely to notice drags/replans without burning a 60Hz RAF. +const PAUSE_POLL_MS = 250 type Phase = 'pause' | 'walk' | 'fall' | 'jump' @@ -114,6 +117,9 @@ export function usePetRoam({ let pauseUntil = performance.now() + rand(400, 1200) let last = performance.now() let raf = 0 + let pauseTimer = 0 + let stopped = false + let pauseController: ReturnType | null = null let walkTargetX = cur.x let curLedge: Ledge | null = null @@ -137,6 +143,64 @@ export function usePetRoam({ $petRoamDir.set(dir) } + const rendererPaused = () => pauseController?.isPaused() ?? document.visibilityState === 'hidden' + + const cancelRaf = () => { + if (raf !== 0) { + window.cancelAnimationFrame(raf) + raf = 0 + } + } + + const cancelPauseTimer = () => { + if (pauseTimer !== 0) { + window.clearTimeout(pauseTimer) + pauseTimer = 0 + } + } + + const clearScheduled = () => { + cancelRaf() + cancelPauseTimer() + } + + const schedule = (now = performance.now()) => { + if (stopped || rendererPaused() || raf !== 0 || pauseTimer !== 0) { + return + } + + if (phase === 'pause') { + const delay = Math.max(0, pauseUntil - now) + + if (delay > 0) { + pauseTimer = window.setTimeout( + () => { + pauseTimer = 0 + step(performance.now()) + }, + Math.min(delay, PAUSE_POLL_MS) + ) + + return + } + } + + raf = window.requestAnimationFrame(step) + } + + const handleVisibilityChange = () => { + clearScheduled() + last = performance.now() + + if (rendererPaused()) { + signal(null, 0) + + return + } + + schedule(last) + } + const beginPause = (now: number) => { phase = 'pause' pauseUntil = now + dwellMs(PAUSE_DWELL) @@ -209,6 +273,15 @@ export function usePetRoam({ } const step = (now: number) => { + raf = 0 + pauseTimer = 0 + + if (stopped || rendererPaused()) { + signal(null, 0) + + return + } + const dt = Math.min(MAX_DT_S, (now - last) / 1000) last = now @@ -223,7 +296,7 @@ export function usePetRoam({ // Short settle so the pet falls right after you drop it, not seconds later. pauseUntil = now + DROP_SETTLE_MS signal(null, 0) - raf = requestAnimationFrame(step) + schedule(now) return } @@ -300,13 +373,16 @@ export function usePetRoam({ } } - raf = requestAnimationFrame(step) + schedule(now) } - raf = requestAnimationFrame(step) + pauseController = createRendererLoopPauseController(handleVisibilityChange) + schedule() return () => { - cancelAnimationFrame(raf) + stopped = true + clearScheduled() + pauseController?.dispose() signal(null, 0) // Hand the final position back to React so its `style` matches the DOM once // the loop stops re-asserting it. diff --git a/apps/desktop/src/components/ui/context-menu.tsx b/apps/desktop/src/components/ui/context-menu.tsx index 1652d68b9f..286418baf9 100644 --- a/apps/desktop/src/components/ui/context-menu.tsx +++ b/apps/desktop/src/components/ui/context-menu.tsx @@ -58,6 +58,30 @@ function ContextMenuItem({ ) } +function ContextMenuCheckboxItem({ + className, + children, + checked, + ...props +}: React.ComponentProps) { + return ( + + {children} + + + + + ) +} + function ContextMenuLabel({ className, inset, @@ -142,6 +166,7 @@ function ContextMenuSubContent({ export { ContextMenu, + ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, diff --git a/apps/desktop/src/components/ui/tooltip.tsx b/apps/desktop/src/components/ui/tooltip.tsx index fe16e3b97c..226bd9472b 100644 --- a/apps/desktop/src/components/ui/tooltip.tsx +++ b/apps/desktop/src/components/ui/tooltip.tsx @@ -5,6 +5,10 @@ import { useI18n } from '@/i18n' import { useKeybindHint } from '@/lib/keybinds/use-keybind-hint' import { cn } from '@/lib/utils' +/** True inside `RootTooltipProvider`. `Tip` uses this to decide whether it + * needs to supply its own provider — see the note on `Tip`. */ +const HasTooltipProvider = React.createContext(false) + function TooltipProvider({ delayDuration = 0, // Tips are labels, not interactive surfaces. Hoverable content + Radix's @@ -105,21 +109,55 @@ interface TipProps extends Omit{children} } + const tip = ( + + {children} + {label} + + ) + + return provided ? tip : {tip} +} + +/** The app's single tooltip provider. Mounted once at the root so no `Tip` + * needs its own. Defaults match what `Tip` used to pass per instance. */ +function RootTooltipProvider({ children }: { children: React.ReactNode }) { return ( - - - {children} - {label} - - + + + {children} + + ) } @@ -163,4 +201,13 @@ function TipKeybindLabel({ actionId, text }: TipKeybindLabelProps) { return } -export { Tip, TipHintLabel, TipKeybindLabel, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } +export { + RootTooltipProvider, + Tip, + TipHintLabel, + TipKeybindLabel, + Tooltip, + TooltipContent, + TooltipProvider, + TooltipTrigger +} diff --git a/apps/desktop/src/debug/README.md b/apps/desktop/src/debug/README.md new file mode 100644 index 0000000000..5cae200efd --- /dev/null +++ b/apps/desktop/src/debug/README.md @@ -0,0 +1,111 @@ +# Dev-only state diagnostics + +Two counters that answer, for any interaction: **what re-rendered, why, and +which store pushed it?** + +``` +window.__RENDER_COUNTS__ what re-rendered, attributed to props / state / parent +window.__ATOM_CHURN__ which store published it, and whether it mattered +``` + +Both are inert until `start()`, so the idle cost is one no-op branch per commit +and per notify. Neither ships: `vite.config.ts` aliases `@/debug/dev-only` to a +no-op module for any build that isn't the dev server (or `VITE_PERF_PROBE=1`). + +## Using it + +From the devtools console, while an agent streams: + +```js +__RENDER_COUNTS__.start(); __ATOM_CHURN__.start() +// ...let it run for a few seconds... +__RENDER_COUNTS__.stop(); __ATOM_CHURN__.stop() +console.table(__RENDER_COUNTS__.report()) +console.table(__ATOM_CHURN__.report()) +``` + +The `wasted` column in each is the fix list: + +- **render `wasted`** — re-rendered with neither changed props nor changed hook + state, i.e. purely because a parent did. A `memo()` or a narrower subscription + removes it. +- **atom `wasted`** — published a value deep-equal to the previous one. + `@nanostores/react` bails out on *reference* equality only, so this + re-renders every subscriber for nothing. This is the + "preserve reference identity on no-ops" rule in `apps/desktop/AGENTS.md`. + +Or as a gated measurement, driving 5 concurrent streaming tabs synthetically +(no backend, no credits): + +```bash +node scripts/perf/run.mjs render-churn --spawn --tiles 5 --tokens 240 +``` + +## Why bippy, and not the obvious choices + +**React 19.2 removed `injectProfilingHooks` from react-dom.** Verified: +`grep -c injectProfilingHooks node_modules/react-dom/cjs/react-dom-client.development.js` +→ `0`. Only `onCommitFiberRoot` / `onPostCommitFiberRoot` remain. The entire +`mark*` profiling family (`component-render-start`, `state-update`, +`render-scheduled`) is dead on this stack — anything built on it is out. + +**`` cannot answer "did the sidebar re-render?"** React invokes +`onRender` for *every* Profiler in a committed tree, including subtrees that +bailed out. Counting those callbacks "proves" a re-render that never happened. +`actualDuration` is not a discriminator either: a bailed-out subtree still +reports a small nonzero duration, so there's no safe threshold. `didFiberRender` +is the honest signal. (Note `app/chat/perf-probe.tsx` exports a `PerfProbe` +Profiler wrapper that is used nowhere — that's why.) + +**react-scan** ships the right idea in its undocumented `react-scan/lite` +subpath, but `lite` is a thin wrapper whose only imports are `bippy` and +`bippy/source`. The package pulls ~217 transitive deps (babel, preact) and +floats `react-grab` / `react-doctor` on `latest`, so installs aren't +reproducible, and its main entry currently breaks Vite with a JSON +import-attribute error (upstream issues #448, #467, both open). We take bippy +directly: MIT, zero dependencies. + +## The import-order constraint + +`main.tsx` imports `@/debug/dev-only` **statically, above `react-dom`**. This is +load-bearing, not stylistic. + +react-dom captures the devtools hook at **module init**, not at `createRoot`. +Installing afterwards leaves a hook object in place but `bippy._renderers` +empty, and every commit goes unseen. Verified both directions: + +| order | `_renderers` | commits | +|---|---|---| +| bippy installs first | 1 | 1 | +| react-dom evaluates first | 0 | 0 | + +A dynamic `import()` behind an `import.meta.env.DEV` guard would resolve a +microtask *after* main.tsx's static graph (react-dom included) had evaluated — +too late. Hence a static import, with production exclusion handled by the +build-time alias instead of tree-shaking. + +If you add a test that imports these counters, note the `ui` vitest project's +`setupFiles` pulls in `@testing-library/react` (and thus react-dom) before any +test body runs, so the hook can never install there. Use a config without +`setupFiles`. + +## Baseline (5 tabs × 240 tokens, dev renderer, darwin-arm64) + +``` +sidebar_renders 6 +sidebar_wasted 0 +wasted_renders 10,432 +total_renders 78,385 +commits 1,566 +wasted_notifies 0 +``` + +The sidebar hypothesis is **refuted**: 6 renders across the whole run, all +attributable to hook state on genuine busy/needsInput edges, none wasted. The +`stableArray` guards on `$workingSessionIds` / `$attentionSessionIds` +(`store/session-states.ts:236-259`) are doing their job. + +The real cost is elsewhere — see `topRenders` in the scenario's `detail`. +`$sessionStates` notified 1,200 times with **10 listeners** (fan-out 12,000) +and zero wasted notifies, so the publishing side is honest; the waste is in +components that re-render on a parent commit without their own inputs changing. diff --git a/apps/desktop/src/debug/atom-churn.ts b/apps/desktop/src/debug/atom-churn.ts new file mode 100644 index 0000000000..4c78a012e2 --- /dev/null +++ b/apps/desktop/src/debug/atom-churn.ts @@ -0,0 +1,132 @@ +// Dev-only nanostores churn counter — the state-side companion to +// `render-counter.ts`. Render counts tell you WHAT re-rendered; this tells you +// WHICH ATOM pushed the update, and whether the push was worth making. +// +// The headline metric is `wasted`: notifications whose new value is deep-equal +// to the old one. `@nanostores/react`'s `useStore` bails out on REFERENCE +// equality only (`snapshotRef.current === value`), so publishing a fresh array +// or object with identical contents re-renders every subscriber for nothing. +// That is the exact failure `apps/desktop/AGENTS.md` names: "Preserve reference +// identity on no-ops." +// +// `listeners` is read from the store's own `lc` (listener count) at notify +// time, because `onNotify` fires even when a store has zero subscribers — a +// raw notify count over-reports. `notifies x listeners` is the real fan-out. + +import { onNotify, type Store } from 'nanostores' + +export interface AtomChurn { + /** Times the store notified its listeners. */ + notifies: number + /** + * ...of those, how many pushed a value deep-equal to the previous one. + * Pure waste: every subscriber re-rendered and nothing actually changed. + */ + wasted: number + /** Peak listener count seen at notify time (`store.lc`). */ + peakListeners: number + /** Sum of listeners across notifications — the true re-render fan-out. */ + fanout: number +} + +const churn = new Map() +const unsubscribes: Array<() => void> = [] +let recording = false + +const blank = (): AtomChurn => ({ fanout: 0, notifies: 0, peakListeners: 0, wasted: 0 }) + +/** Structural equality, depth-capped so a long transcript array doesn't make + * the instrumentation itself the bottleneck. Beyond the cap we compare by + * reference, which under-reports waste rather than inventing it. */ +function equal(a: unknown, b: unknown, depth = 0): boolean { + if (Object.is(a, b)) { + return true + } + + if (depth > 3 || typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) { + return false + } + + if (Array.isArray(a) !== Array.isArray(b)) { + return false + } + + const ka = Object.keys(a as object) + const kb = Object.keys(b as object) + + if (ka.length !== kb.length) { + return false + } + + return ka.every(k => equal((a as Record)[k], (b as Record)[k], depth + 1)) +} + +/** Watch one store. Call at module scope for each atom you want attributed. */ +export function watchAtom(name: string, store: Store) { + const off = onNotify(store, ({ oldValue }) => { + if (!recording) { + return + } + + const entry = churn.get(name) ?? blank() + // `lc` is nanostores' listener count — see node_modules/nanostores/atom/index.js. + const listeners = (store as unknown as { lc?: number }).lc ?? 0 + const next = (store as unknown as { value?: unknown }).value + + entry.notifies += 1 + entry.fanout += listeners + entry.peakListeners = Math.max(entry.peakListeners, listeners) + + if (equal(oldValue, next)) { + entry.wasted += 1 + } + + churn.set(name, entry) + }) + + unsubscribes.push(off) + + return off +} + +/** Rows sorted by wasted notifications, then fan-out — the fix list, in order. */ +function report(limit = 40) { + return [...churn.entries()] + .map(([name, c]) => ({ name, ...c })) + .sort((a, b) => b.wasted - a.wasted || b.fanout - a.fanout) + .slice(0, limit) +} + +declare global { + interface Window { + __ATOM_CHURN__?: { + churn: Map + clear: () => void + start: () => void + stop: () => void + recording: () => boolean + report: (limit?: number) => Array + get: (name: string) => AtomChurn | undefined + /** Names of every watched store, whether or not it has notified. */ + watched: () => string[] + } + } +} + +if (typeof window !== 'undefined' && !window.__ATOM_CHURN__) { + window.__ATOM_CHURN__ = { + churn, + clear: () => churn.clear(), + get: name => churn.get(name), + recording: () => recording, + report, + start: () => { + churn.clear() + recording = true + }, + stop: () => { + recording = false + }, + watched: () => [...churn.keys()] + } +} diff --git a/apps/desktop/src/debug/dev-only.noop.ts b/apps/desktop/src/debug/dev-only.noop.ts new file mode 100644 index 0000000000..9c4595ee14 --- /dev/null +++ b/apps/desktop/src/debug/dev-only.noop.ts @@ -0,0 +1,8 @@ +// Production stand-in for `dev-only.ts`. `vite.config.ts` aliases the dev +// entry to this module for any build that isn't the dev server, so the +// diagnostics graph — and bippy with it — never reaches a shipped renderer. +// +// Keep this file free of imports. It exists precisely so the production +// bundle contains nothing from `debug/`. + +export {} diff --git a/apps/desktop/src/debug/dev-only.ts b/apps/desktop/src/debug/dev-only.ts new file mode 100644 index 0000000000..e052c2f14e --- /dev/null +++ b/apps/desktop/src/debug/dev-only.ts @@ -0,0 +1,19 @@ +// Dev-only diagnostics entry. Statically imported from `main.tsx` ABOVE the +// `react-dom` import — that ordering is load-bearing and non-negotiable. +// +// react-dom captures the devtools hook at MODULE INIT, not at `createRoot`. +// Verified: installing bippy after react-dom has evaluated yields +// `renderers=0` and `commits=0` — the hook object exists but react-dom never +// registered with it. A dynamic `import()` here would resolve a microtask +// after main.tsx's static graph (react-dom included) had already evaluated, +// so it must be a plain static import chain, whose evaluation order ESM +// guarantees. +// +// Production builds don't tree-shake this away (a static side-effect import +// can't be eliminated) — instead `vite.config.ts` aliases this module to +// `dev-only.noop.ts` whenever the build isn't serving dev, so neither bippy +// nor the counters reach a shipped renderer. + +import './index' + +export {} diff --git a/apps/desktop/src/debug/index.ts b/apps/desktop/src/debug/index.ts new file mode 100644 index 0000000000..365cc23fdb --- /dev/null +++ b/apps/desktop/src/debug/index.ts @@ -0,0 +1,31 @@ +// Dev-only state diagnostics: one import, two counters. +// +// window.__RENDER_COUNTS__ — what re-rendered, and why (props/state/parent) +// window.__ATOM_CHURN__ — which store published it, and whether it mattered +// +// Imported FIRST in `main.tsx`, before `react-dom`. That ordering is +// load-bearing: react-dom decides at module-init whether a devtools hook +// exists, so bippy must install during THIS module's evaluation. A dynamic +// `import()` from main.tsx would resolve a microtask too late and every commit +// would go unseen — hence a plain static import chain, whose evaluation order +// ESM guarantees. +// +// Both counters are inert until `start()` is called, so the idle cost in dev is +// a single no-op branch per commit / per notify. +// +// Typical session, from the devtools console: +// +// __RENDER_COUNTS__.start(); __ATOM_CHURN__.start() +// // ...let an agent stream for a few seconds... +// __RENDER_COUNTS__.stop(); __ATOM_CHURN__.stop() +// console.table(__RENDER_COUNTS__.report()) +// console.table(__ATOM_CHURN__.report()) +// +// The `wasted` column in each is the fix list: components that re-rendered +// with no changed input, and stores that published a value equal to the last. + +import './render-counter' + +import { watchSessionAtoms } from './watched-atoms' + +watchSessionAtoms() diff --git a/apps/desktop/src/debug/render-counter.ts b/apps/desktop/src/debug/render-counter.ts new file mode 100644 index 0000000000..2a41d792a2 --- /dev/null +++ b/apps/desktop/src/debug/render-counter.ts @@ -0,0 +1,210 @@ +// Dev-only render counter — answers "what actually re-rendered, and why?". +// +// Loaded from `main.tsx` BEFORE `react-dom` (see the import-order note there). +// That ordering is load-bearing: react-dom decides at module-init whether a +// devtools hook exists, so installing after it has already initialised leaves +// `bippy._renderers` empty and every commit goes unseen. +// +// Why not ``: React invokes `onRender` for EVERY Profiler in a +// committed tree, including subtrees that bailed out. Counting those callbacks +// "proves" the sidebar re-rendered when it did not. `actualDuration` is not a +// discriminator either — a bailed-out subtree still reports a small nonzero +// duration. `didFiberRender` is the honest signal. +// +// Why not react-scan: its `lite` subpath is a thin wrapper over bippy, while +// the package pulls ~217 transitive deps (babel, preact) and floats +// `react-grab`/`react-doctor` on `latest`, which makes installs +// non-reproducible and breaks Vite with a JSON import-attribute error. + +import { didFiberRender, type Fiber, getDisplayName, instrument, isCompositeFiber, traverseRenderedFibers } from 'bippy' + +/** Why a component re-rendered, attributed per commit. */ +export interface RenderRecord { + /** Commits in which this component actually re-rendered (mount excluded). */ + renders: number + /** ...of those, how many had at least one changed prop reference. */ + propsChanged: number + /** ...of those, how many had changed hook state (useState/useMemo/store). */ + stateChanged: number + /** + * ...of those, how many consumed a context whose value changed. `memo()` + * cannot block these — the fix is to narrow or split the provider, not to + * add a memo boundary. + */ + contextChanged: number + /** + * ...of those, how many had NEITHER changed props, changed state, nor a + * changed context. These re-rendered purely because a parent did — the + * wasted work a `memo()` or a narrower store subscription would eliminate. + */ + wasted: number + /** Sum of `actualDuration` across counted renders, in ms. */ + totalMs: number +} + +const counts = new Map() +let commits = 0 +let recording = false + +const blank = (): RenderRecord => ({ + contextChanged: 0, + propsChanged: 0, + renders: 0, + stateChanged: 0, + totalMs: 0, + wasted: 0 +}) + +/** Did any prop's reference identity change between the two fiber versions? */ +function propsChanged(fiber: Fiber): boolean { + const prev = fiber.alternate?.memoizedProps as Record | null | undefined + const next = fiber.memoizedProps as Record | null | undefined + + if (!prev || !next) { + return false + } + + for (const key of Object.keys(next)) { + if (!Object.is(prev[key], next[key])) { + return true + } + } + + return Object.keys(prev).length !== Object.keys(next).length +} + +/** Did any hook's memoizedState change? Covers useState, useSyncExternalStore + * (so nanostores `useStore`), useMemo, and useReducer alike. */ +function stateChanged(fiber: Fiber): boolean { + let next: Fiber['memoizedState'] | null | undefined = fiber.memoizedState + let prev: Fiber['memoizedState'] | null | undefined = fiber.alternate?.memoizedState + + while (next && prev) { + if (!Object.is(next.memoizedState, prev.memoizedState)) { + return true + } + + next = next.next + prev = prev.next + } + + return false +} + +/** Did any consumed context value change? A `memo()` cannot block a re-render + * caused by context, so distinguishing this from a parent-driven render is + * the difference between "add a memo" and "split the provider". */ +function contextChanged(fiber: Fiber): boolean { + let dep = fiber.dependencies?.firstContext + + while (dep) { + const context = dep.context as { _currentValue?: unknown } | undefined + + if (context && 'memoizedValue' in dep && !Object.is(dep.memoizedValue, context._currentValue)) { + return true + } + + dep = dep.next + } + + return false +} + +function record(fiber: Fiber) { + const name = getDisplayName(fiber) + + if (!name) { + return + } + + const entry = counts.get(name) ?? blank() + const props = propsChanged(fiber) + const state = stateChanged(fiber) + const context = contextChanged(fiber) + + entry.renders += 1 + entry.totalMs += fiber.actualDuration ?? 0 + + if (props) { + entry.propsChanged += 1 + } + + if (state) { + entry.stateChanged += 1 + } + + if (context) { + entry.contextChanged += 1 + } + + if (!props && !state && !context) { + entry.wasted += 1 + } + + counts.set(name, entry) +} + +/** Rows sorted by wasted renders, then total renders — the fix list, in order. */ +function report(limit = 40) { + return [...counts.entries()] + .map(([name, r]) => ({ name, ...r, totalMs: Math.round(r.totalMs * 100) / 100 })) + .sort((a, b) => b.wasted - a.wasted || b.renders - a.renders) + .slice(0, limit) +} + +declare global { + interface Window { + __RENDER_COUNTS__?: { + /** Per-component render attribution since the last `clear()`. */ + counts: Map + /** Commits observed since the last `clear()`. */ + commits: () => number + clear: () => void + /** Start counting. Cheap no-op until called — zero cost while idle. */ + start: () => void + stop: () => void + recording: () => boolean + /** Sorted worst-offenders table; `console.table`-friendly. */ + report: (limit?: number) => Array + /** Attribution for one component by display name. */ + get: (name: string) => RenderRecord | undefined + } + } +} + +if (typeof window !== 'undefined' && !window.__RENDER_COUNTS__) { + instrument({ + onCommitFiberRoot(_id, root) { + if (!recording) { + return + } + + commits += 1 + traverseRenderedFibers(root, fiber => { + if (isCompositeFiber(fiber) && didFiberRender(fiber)) { + record(fiber) + } + }) + } + }) + + window.__RENDER_COUNTS__ = { + clear: () => { + counts.clear() + commits = 0 + }, + commits: () => commits, + counts, + get: name => counts.get(name), + recording: () => recording, + report, + start: () => { + counts.clear() + commits = 0 + recording = true + }, + stop: () => { + recording = false + } + } +} diff --git a/apps/desktop/src/debug/watched-atoms.ts b/apps/desktop/src/debug/watched-atoms.ts new file mode 100644 index 0000000000..ebcb2724b7 --- /dev/null +++ b/apps/desktop/src/debug/watched-atoms.ts @@ -0,0 +1,81 @@ +// Dev-only: registers the stores worth attributing during a streaming turn. +// +// Deliberately NOT every atom in the app — a churn counter that reports 200 +// rows is as useless as none. These are the stores on or adjacent to the +// streaming hot path, plus the sidebar's inputs, so a recording answers one +// question directly: while an agent is typing, what is being published, and +// who re-renders because of it? + +import { $projects, $projectTree } from '@/store/projects' +import { + $activeSessionId, + $awaitingResponse, + $busy, + $cronSessions, + $currentCwd, + $currentUsage, + $gatewayState, + $messages, + $messagingSessions, + $selectedStoredSessionId, + $sessions, + $sessionsLoading +} from '@/store/session' +import { + $attentionSessionIds, + $focusedRuntimeId, + $focusedSessionState, + $focusedStoredSessionId, + $sessionStates, + $sessionTiles, + $stalledSessionIds, + $workingSessionIds +} from '@/store/session-states' + +import { watchAtom } from './atom-churn' + +/** Streaming hot path — written per token / per delta flush. */ +const HOT = { + $awaitingResponse, + $busy, + // The global mirror the workspace pane paints from. + $messages, + // Republished on EVERY delta: the per-session source of truth. + $sessionStates +} + +/** Derived from the hot path. These SHOULD stay quiet during a turn — any + * notification here is a candidate for the "wasted" column. */ +const DERIVED = { + $attentionSessionIds, + $currentUsage, + $focusedRuntimeId, + $focusedSessionState, + $focusedStoredSessionId, + $stalledSessionIds, + $workingSessionIds +} + +/** Sidebar inputs. Expected to be cold during a turn — if any of these notify + * while an agent is typing, that is the bug. */ +const SIDEBAR = { + $activeSessionId, + $cronSessions, + $currentCwd, + $gatewayState, + $messagingSessions, + $projects, + $projectTree, + $selectedStoredSessionId, + $sessions, + $sessionsLoading, + $sessionTiles +} + +export function watchSessionAtoms() { + for (const group of [HOT, DERIVED, SIDEBAR]) { + for (const [name, store] of Object.entries(group)) { + watchAtom(name, store) + } + } +} diff --git a/apps/desktop/src/global.d.ts b/apps/desktop/src/global.d.ts index c0c3c7f246..1e6225bb20 100644 --- a/apps/desktop/src/global.d.ts +++ b/apps/desktop/src/global.d.ts @@ -6,6 +6,7 @@ import type { PetOverlayOpenRequest, PetOverlayStatePayload } from './store/pet-overlay' +import type { QuickEntryStatePush, QuickEntryStatus, QuickEntrySubmitPayload } from './store/quick-entry' export {} @@ -55,6 +56,34 @@ declare global { onState: (callback: (payload: PetOverlayStatePayload) => void) => () => void onControl: (callback: (payload: PetOverlayControl) => void) => () => void } + // Quick Entry: a global-hotkey mini composer window. Main owns the OS + // shortcut registration + the persisted preference (it must restore the + // shortcut on a cold launch without the renderer visiting Settings), so + // the renderer reads/writes it here and adopts the authoritative reply. + quickEntry: { + getSettings: () => Promise + // Returns the resulting state — including `registered: false` + + // `error: 'taken'` when another app already owns the chord, so a failed + // registration surfaces in Settings instead of failing silently. + setSettings: (patch: { enabled?: boolean; shortcut?: string }) => Promise + // Quick window → main: send this payload (main forwards it to the + // primary renderer, which routes it to the target session and submits + // through the normal prompt path) and hide. + submit: (payload: QuickEntrySubmitPayload) => void + // Quick window → main: hide without sending (Escape / blur). + dismiss: () => void + // Primary renderer → main → quick window: gateway connection state + + // the recent-session options. Main caches the latest push and replays + // it to a quick window spawned later. + pushState: (payload: QuickEntryStatePush) => void + // Quick window subscribes to those pushes. + onState: (callback: (payload: QuickEntryStatePush) => void) => () => void + // Primary renderer subscribes to submits captured by the quick window. + onSubmit: (callback: (payload: QuickEntrySubmitPayload | string) => void) => () => void + // Quick window subscribes to "you were just summoned" so it can reset + // its draft and re-focus the input on every open. + onShown: (callback: () => void) => () => void + } getBootProgress: () => Promise getConnectionConfig: (profile?: null | string) => Promise saveConnectionConfig: (payload: DesktopConnectionConfigInput) => Promise @@ -237,6 +266,14 @@ declare global { // returns the most-installed themes. searchMarketplace: (query: string) => Promise } + // Find-in-page: delegates to Electron's webContents.findInPage on the + // IPC sender's window so Cmd+F from a secondary session window + // searches that window (not the primary). `onFoundInPage` returns the + // unsubscribe fn; the renderer wires it via `initFindInPageListener` + // in store/find-in-page.ts and tears it down when the FindBar unmounts. + findInPage: (query: string, options?: { forward?: boolean; findNext?: boolean }) => Promise<{ count: number }> + stopFindInPage: () => Promise + onFoundInPage: (callback: (result: { activeMatchOrdinal: number; count: number }) => void) => () => void } } } @@ -423,6 +460,8 @@ export interface HermesTitleBarTheme { export interface HermesWindowState { isFullscreen: boolean + isMinimized?: boolean + isVisible?: boolean nativeOverlayWidth: number windowButtonPosition: { x: number; y: number } | null } diff --git a/apps/desktop/src/hermes.test.ts b/apps/desktop/src/hermes.test.ts index f829471c5a..6b47757423 100644 --- a/apps/desktop/src/hermes.test.ts +++ b/apps/desktop/src/hermes.test.ts @@ -150,8 +150,9 @@ describe('Hermes REST helpers', () => { // Slices reassembled from the legacy per-slice route with the same // scoping: recents on the caller's profile, cron + messaging cross-profile. expect(result.recents.sessions.map(s => s.id)).toEqual(['recent-1']) - expect(result.recents.total).toBe(7) - expect(result.recents.profile_totals).toEqual({ default: 7 }) + // One row back against a 30-row window: the profile is fully loaded, so + // the legacy path must not claim there's another page. + expect(result.recents.profiles_truncated).toEqual({ default: false }) expect(result.cron.sessions.map(s => s.id)).toEqual(['cron-1']) expect(result.messaging.sessions.map(s => s.id)).toEqual(['msg-1']) diff --git a/apps/desktop/src/hermes.ts b/apps/desktop/src/hermes.ts index 27a9e23468..5d19debb42 100644 --- a/apps/desktop/src/hermes.ts +++ b/apps/desktop/src/hermes.ts @@ -420,8 +420,24 @@ export async function listAllProfileSessions( // splices remote profiles per slice (see interceptSessionRequestForRemote). export interface SidebarSessionSlice { sessions: SessionInfo[] - total?: number - profile_totals?: Record + /** Per-profile "the window came back full, more rows exist on disk" flags — + * what pagination needs, without a COUNT(*) per profile DB per refresh. */ + profiles_truncated?: Record +} + +/** Which profiles filled their per-profile window in a returned page. The + * legacy per-slice endpoint doesn't report this, so derive it from the rows: + * a profile at (or over) the cap still has more on disk. */ +function profilesTruncatedFrom(sessions: SessionInfo[], cap: number): Record { + const counts = new Map() + + for (const session of sessions) { + const key = session.profile || 'default' + + counts.set(key, (counts.get(key) ?? 0) + 1) + } + + return Object.fromEntries([...counts].map(([name, count]) => [name, count >= cap])) } export interface SidebarSessionsResponse { @@ -494,7 +510,10 @@ async function listSidebarSessionsLegacy(req: SidebarSessionsRequest): Promise void + +/** Live target → handler routing for the shared observer. */ +const handlers = new WeakMap>() + +let shared: null | ResizeObserver = null + +function sharedObserver(): null | ResizeObserver { + if (typeof ResizeObserver === 'undefined') { + return null + } + + if (!shared) { + shared = new ResizeObserver(entries => { + // Group this delivery's entries by handler so a caller observing several + // elements is still invoked once, with all of its entries — the same + // contract a private observer gave it. + const byHandler = new Map() + + for (const entry of entries) { + const targets = handlers.get(entry.target) + + if (!targets) { + continue + } + + for (const handler of targets) { + const list = byHandler.get(handler) + + if (list) { + list.push(entry) + } else { + byHandler.set(handler, [entry]) + } + } + } + + for (const [handler, group] of byHandler) { + handler(group) + } + }) + } + + return shared +} + export function useResizeObserver( onResize: (entries: readonly ResizeObserverEntry[]) => void, ...refs: readonly RefObject[] @@ -21,14 +79,15 @@ export function useResizeObserver( refsRef.current = refs useLayoutEffect(() => { - if (typeof ResizeObserver === 'undefined') { + const observer = sharedObserver() + + if (!observer) { onResize([]) return } - const observer = new ResizeObserver(entries => onResize(entries)) - let observed = false + const observed: Element[] = [] for (const ref of refsRef.current) { const element = ref.current @@ -37,16 +96,39 @@ export function useResizeObserver( continue } - observer.observe(element) - observed = true + const existing = handlers.get(element) + + if (existing) { + existing.add(onResize) + } else { + handlers.set(element, new Set([onResize])) + // Only the first handler for an element needs to register it; the + // observer fires once per element regardless of how many care. + observer.observe(element) + } + + observed.push(element) } - if (!observed) { - observer.disconnect() - + if (observed.length === 0) { return } - return () => observer.disconnect() + return () => { + for (const element of observed) { + const set = handlers.get(element) + + if (!set) { + continue + } + + set.delete(onResize) + + if (set.size === 0) { + handlers.delete(element) + observer.unobserve(element) + } + } + } }, [onResize]) } diff --git a/apps/desktop/src/i18n/ar.ts b/apps/desktop/src/i18n/ar.ts index b449910141..fb0c4035a5 100644 --- a/apps/desktop/src/i18n/ar.ts +++ b/apps/desktop/src/i18n/ar.ts @@ -619,6 +619,15 @@ export const ar = defineLocale({ imported: 'تم استيراد الإعدادات', invalidJson: 'JSON غير صالح' }, + quickEntry: { + enabledTitle: 'الإدخال السريع', + enabledDesc: 'استدعِ محرّرا صغيرا من أي مكان باختصار عام وأرسل طلبا دون فتح Hermes.', + shortcutTitle: 'اختصار الإدخال السريع', + shortcutDesc: 'يحتاج إلى مفتاح تعديل واحد على الأقل، مثل CommandOrControl+Shift+Space.', + active: 'الاختصار مفعّل.', + takenBy: 'يستخدم تطبيق آخر هذا الاختصار — اختر اختصارا مختلفا.', + invalidShortcut: 'ليس اختصارا صالحا. أضف مفتاح تعديل واحدا على الأقل.' + }, credentials: { pasteKey: 'لصق المفتاح', pasteLabelKey: label => `لصق مفتاح ${label}`, diff --git a/apps/desktop/src/i18n/en.ts b/apps/desktop/src/i18n/en.ts index c1d59a013b..d4005af11f 100644 --- a/apps/desktop/src/i18n/en.ts +++ b/apps/desktop/src/i18n/en.ts @@ -267,6 +267,9 @@ export const en: Translations = { 'view.closeTab': 'Close tab', 'view.reopenTab': 'Reopen closed tab', 'view.flipPanes': 'Swap sidebar sides', + 'view.findInPage': 'Find in page', + 'view.findNext': 'Find next match', + 'view.findPrevious': 'Find previous match', 'appearance.toggleMode': 'Toggle light / dark', 'profile.default': 'Switch to default profile', 'profile.switch.1': 'Switch to profile 1', @@ -304,6 +307,11 @@ export const en: Translations = { } }, + findInPage: { + next: 'Next match', + previous: 'Previous match' + }, + language: { label: 'Language', description: 'Choose the language for the desktop interface.', @@ -543,6 +551,16 @@ export const en: Translations = { keepAwakeTitle: 'Keep computer awake', keepAwakeDesc: 'Stop this machine from sleeping so long or overnight runs keep going. The display can still dim.' }, + quickEntry: { + enabledTitle: 'Quick Entry', + enabledDesc: + 'Summon a small composer from anywhere with a global shortcut and fire a prompt without opening Hermes.', + shortcutTitle: 'Quick Entry shortcut', + shortcutDesc: 'Needs at least one modifier, e.g. CommandOrControl+Shift+Space.', + active: 'Shortcut is active.', + takenBy: 'Another app already uses this shortcut — pick a different one.', + invalidShortcut: 'Not a valid shortcut. Include at least one modifier key.' + }, credentials: { pasteKey: 'Paste key', pasteLabelKey: label => `Paste ${label} key`, @@ -2013,6 +2031,10 @@ export const en: Translations = { statusStack: { agents: 'Agents', background: count => `${count} Background`, + goalActive: 'Goal active', + goalDone: 'Goal done', + goalPaused: 'Goal paused', + goalWaiting: 'Goal waiting', subagents: count => `${count} Subagent${count === 1 ? '' : 's'}`, todos: (done, total) => `Tasks ${done}/${total}`, running: 'Running', @@ -2381,6 +2403,13 @@ export const en: Translations = { gatewayOffline: 'offline', gatewayRestarting: 'restarting…', gatewayTitle: 'Hermes inference gateway status', + customizeTitle: 'Show in status bar', + toggleApprovalMode: 'Approvals', + toggleBackendVersion: 'Backend version', + toggleCommandCenter: 'Command Center', + toggleTerminal: 'Terminal', + toggleVersion: 'Version & updates', + toggleWorkspace: 'Workspace', agents: 'Agents', closeAgents: 'Close agents', openAgents: 'Open agents', diff --git a/apps/desktop/src/i18n/ja.ts b/apps/desktop/src/i18n/ja.ts index 738a4859e0..a1eeea21d1 100644 --- a/apps/desktop/src/i18n/ja.ts +++ b/apps/desktop/src/i18n/ja.ts @@ -650,6 +650,16 @@ export const ja = defineLocale({ keepAwakeTitle: 'コンピューターをスリープさせない', keepAwakeDesc: '本体のスリープを防ぎ、長時間や夜通しの実行を継続します。画面は暗転できます。' }, + quickEntry: { + enabledTitle: 'クイック入力', + enabledDesc: + 'グローバルショートカットで小さな入力欄をどこからでも呼び出し、Hermes を開かずにプロンプトを送信します。', + shortcutTitle: 'クイック入力のショートカット', + shortcutDesc: '修飾キーが 1 つ以上必要です（例: CommandOrControl+Shift+Space）。', + active: 'ショートカットは有効です。', + takenBy: 'このショートカットは他のアプリが使用しています。別のものを選んでください。', + invalidShortcut: '有効なショートカットではありません。修飾キーを 1 つ以上含めてください。' + }, credentials: { pasteKey: 'キーを貼り付け', pasteLabelKey: label => `${label} キーを貼り付け`, @@ -1880,6 +1890,10 @@ export const ja = defineLocale({ statusStack: { agents: 'エージェント', background: count => `バックグラウンド ${count} 件`, + goalActive: '目標進行中', + goalDone: '目標達成', + goalPaused: '目標一時停止中', + goalWaiting: '目標待機中', subagents: count => `サブエージェント ${count} 件`, todos: (done, total) => `タスク ${done}/${total}`, running: '実行中', diff --git a/apps/desktop/src/i18n/types.ts b/apps/desktop/src/i18n/types.ts index 90506fe923..217a66e979 100644 --- a/apps/desktop/src/i18n/types.ts +++ b/apps/desktop/src/i18n/types.ts @@ -262,6 +262,12 @@ export interface Translations { actions: Record } + // Find-in-page bar (⌘F). `close` reuses common.close. + findInPage: { + next: string + previous: string + } + language: { label: string description: string @@ -450,6 +456,15 @@ export interface Translations { keepAwakeTitle: string keepAwakeDesc: string } + quickEntry: { + enabledTitle: string + enabledDesc: string + shortcutTitle: string + shortcutDesc: string + active: string + takenBy: string + invalidShortcut: string + } credentials: { pasteKey: string pasteLabelKey: (label: string) => string @@ -1669,6 +1684,10 @@ export interface Translations { statusStack: { agents: string background: (count: number) => string + goalActive: string + goalDone: string + goalPaused: string + goalWaiting: string subagents: (count: number) => string todos: (done: number, total: number) => string running: string @@ -1990,6 +2009,13 @@ export interface Translations { gatewayOffline: string gatewayRestarting: string gatewayTitle: string + customizeTitle: string + toggleApprovalMode: string + toggleBackendVersion: string + toggleCommandCenter: string + toggleTerminal: string + toggleVersion: string + toggleWorkspace: string agents: string closeAgents: string openAgents: string diff --git a/apps/desktop/src/i18n/zh-hant.ts b/apps/desktop/src/i18n/zh-hant.ts index 73933bf888..dfe9efe698 100644 --- a/apps/desktop/src/i18n/zh-hant.ts +++ b/apps/desktop/src/i18n/zh-hant.ts @@ -638,6 +638,15 @@ export const zhHant = defineLocale({ keepAwakeTitle: '保持電腦喚醒', keepAwakeDesc: '阻止本機睡眠，讓長時間或整夜執行持續進行。螢幕仍可變暗。' }, + quickEntry: { + enabledTitle: '快速輸入', + enabledDesc: '用全域快速鍵在任何地方喚出一個小輸入框，無需開啟 Hermes 即可送出提示。', + shortcutTitle: '快速輸入快速鍵', + shortcutDesc: '至少需要一個修飾鍵，例如 CommandOrControl+Shift+Space。', + active: '快速鍵已生效。', + takenBy: '此快速鍵已被其他應用程式占用，請換一個。', + invalidShortcut: '不是有效的快速鍵。請至少包含一個修飾鍵。' + }, credentials: { pasteKey: '貼上金鑰', pasteLabelKey: label => `貼上 ${label} 金鑰`, @@ -1825,6 +1834,10 @@ export const zhHant = defineLocale({ statusStack: { agents: '代理', background: count => `${count} 個背景任務`, + goalActive: '目標進行中', + goalDone: '目標已完成', + goalPaused: '目標已暫停', + goalWaiting: '目標等待中', subagents: count => `${count} 個子代理`, todos: (done, total) => `任務 ${done}/${total}`, running: '執行中', diff --git a/apps/desktop/src/i18n/zh.ts b/apps/desktop/src/i18n/zh.ts index a7a9ec409e..518913dca9 100644 --- a/apps/desktop/src/i18n/zh.ts +++ b/apps/desktop/src/i18n/zh.ts @@ -258,6 +258,9 @@ export const zh: Translations = { 'view.closeTab': '关闭标签', 'view.reopenTab': '重新打开已关闭的标签', 'view.flipPanes': '交换侧边栏位置', + 'view.findInPage': '页面内查找', + 'view.findNext': '查找下一个', + 'view.findPrevious': '查找上一个', 'appearance.toggleMode': '切换浅色/深色', 'profile.default': '切换到默认配置', 'profile.switch.1': '切换到配置 1', @@ -295,6 +298,11 @@ export const zh: Translations = { } }, + findInPage: { + next: '下一个匹配', + previous: '上一个匹配' + }, + language: { label: '语言', description: '选择桌面界面的语言。', @@ -750,6 +758,15 @@ export const zh: Translations = { keepAwakeTitle: '保持电脑唤醒', keepAwakeDesc: '阻止本机休眠，让长时间或通宵运行继续进行。屏幕仍可变暗。' }, + quickEntry: { + enabledTitle: '快速输入', + enabledDesc: '用全局快捷键在任何地方唤出一个小输入框，无需打开 Hermes 即可发送提示。', + shortcutTitle: '快速输入快捷键', + shortcutDesc: '至少需要一个修饰键，例如 CommandOrControl+Shift+Space。', + active: '快捷键已生效。', + takenBy: '此快捷键已被其他应用占用，请换一个。', + invalidShortcut: '不是有效的快捷键。请至少包含一个修饰键。' + }, credentials: { pasteKey: '粘贴密钥', pasteLabelKey: label => `粘贴 ${label} 密钥`, @@ -2202,6 +2219,10 @@ export const zh: Translations = { statusStack: { agents: '代理', background: count => `${count} 个后台任务`, + goalActive: '目标进行中', + goalDone: '目标已完成', + goalPaused: '目标已暂停', + goalWaiting: '目标等待中', subagents: count => `${count} 个子代理`, todos: (done, total) => `任务 ${done}/${total}`, running: '运行中', @@ -2558,6 +2579,13 @@ export const zh: Translations = { gatewayOffline: '离线', gatewayRestarting: '重启中…', gatewayTitle: 'Hermes 推理网关状态', + customizeTitle: '在状态栏中显示', + toggleApprovalMode: '审批', + toggleBackendVersion: '后端版本', + toggleCommandCenter: '命令中心', + toggleTerminal: '终端', + toggleVersion: '版本与更新', + toggleWorkspace: '工作区', agents: '代理', closeAgents: '关闭代理', openAgents: '打开代理', diff --git a/apps/desktop/src/lib/find-in-page.ts b/apps/desktop/src/lib/find-in-page.ts new file mode 100644 index 0000000000..1890484cb1 --- /dev/null +++ b/apps/desktop/src/lib/find-in-page.ts @@ -0,0 +1,109 @@ +// Pure logic for the find-in-page bar (⌘F). Kept out of the component so the +// match-counter projection and the in-bar key routing can be unit-tested +// without jsdom, a BrowserWindow, or the preload bridge. +// +// The Electron side of the feature lives in electron/find-in-page.ts; this is +// strictly renderer presentation logic. + +/** + * Counter shown next to the input, e.g. `"3/12"`. + * + * Three distinct states, and they are not the same thing: + * - No query → `''`. The counter hides entirely rather than claiming "0/0" + * before the user has asked anything. + * - A query with no matches → `'0/0'`. An explicit, honest zero. + * - A query with matches → `'/'`. + * + * `activeMatchOrdinal` is 1-indexed and can legitimately arrive as 0 from + * Electron for the frame between issuing a search and the first match being + * selected, so the ordinal is clamped into `[0, count]` rather than trusted. + */ +export function formatMatchLabel(query: string, activeMatchOrdinal: number, matchCount: number): string { + if (!query) { + return '' + } + + const count = Number.isFinite(matchCount) && matchCount > 0 ? Math.floor(matchCount) : 0 + + if (count === 0) { + return '0/0' + } + + const raw = Number.isFinite(activeMatchOrdinal) ? Math.floor(activeMatchOrdinal) : 0 + const ordinal = Math.min(Math.max(raw, 0), count) + + return `${ordinal}/${count}` +} + +/** What a keypress means to an open find bar. `null` = not ours, let it through. */ +export type FindBarKeyAction = 'close' | 'next' | 'previous' | null + +/** The subset of a keyboard event the matcher needs — works for DOM and React events. */ +export interface FindBarKeyEvent { + key: string + shiftKey?: boolean + metaKey?: boolean + ctrlKey?: boolean + altKey?: boolean +} + +/** + * Map a keypress to a find-bar action while the bar is open. + * + * Two families, matching the platform convention Chrome/Safari/VS Code (and + * Claude Desktop's `findInPage` accelerators) all share: + * - Bare `Enter` / `Shift+Enter` step forward / backward. Only valid while + * focus is in the find input, so callers pass `inInput: true` there. + * - `⌘G` / `⌘⇧G` (Ctrl+G / Ctrl+Shift+G off macOS) step forward / backward + * from anywhere while the bar is open — that is the accelerator pair, and it + * must not require the input to hold focus. + * - `Escape` closes from anywhere. + * + * `Alt` is treated as disqualifying so ⌥⌘G and friends fall through to + * whatever else may want them instead of being silently swallowed. + */ +export function findBarKeyAction(event: FindBarKeyEvent, options: { inInput?: boolean } = {}): FindBarKeyAction { + if (event.altKey) { + return null + } + + const mod = Boolean(event.metaKey || event.ctrlKey) + + if (event.key === 'Escape') { + return mod ? null : 'close' + } + + // `event.key` for the G key is 'g' unshifted and 'G' with Shift held, so + // compare case-insensitively and read direction from `shiftKey` alone. + if (mod && event.key.toLowerCase() === 'g') { + return event.shiftKey ? 'previous' : 'next' + } + + if (event.key === 'Enter' && !mod && options.inInput) { + return event.shiftKey ? 'previous' : 'next' + } + + return null +} + +/** + * Combos the open find bar owns, in canonical `comboFromEvent` form. + * + * The global keybind dispatcher (app/hooks/use-keybinds.ts) consults this + * before routing a combo to the registry. Without it, three real collisions + * fire alongside the find bar: + * - `mod+g` → `view.toggleReview` (⌘G is the review pane's default). + * - `mod+shift+g` → whatever a user has bound there. + * - `escape` → `composer.cancel`, which would abort a running turn while the + * user only meant to dismiss the find bar. + * + * `stopPropagation` cannot solve this: both listeners sit on `window` in the + * capture phase, and propagation control does not suppress sibling listeners + * on the same target. Ownership has to be decided by the dispatcher, which is + * the documented single owner of combo dispatch. This matches the + * "keyboard ownership follows focus / one cancel gesture does one thing" + * invariant in apps/desktop/AGENTS.md. + */ +export function findBarClaimsCombo(combo: string): boolean { + return combo === 'mod+g' || combo === 'mod+shift+g' || combo === 'escape' +} diff --git a/apps/desktop/src/lib/inflight-turn-journal.test.ts b/apps/desktop/src/lib/inflight-turn-journal.test.ts index ffa1c43006..41d7a362d4 100644 --- a/apps/desktop/src/lib/inflight-turn-journal.test.ts +++ b/apps/desktop/src/lib/inflight-turn-journal.test.ts @@ -238,3 +238,63 @@ describe('mergeInFlightMessages', () => { expect(result.caughtUp).toBe(false) }) }) + +describe('mid-turn redirect corrections', () => { + beforeEach(() => { + window.localStorage.clear() + vi.useFakeTimers() + }) + + afterEach(() => { + vi.useRealTimers() + }) + + // A redirect inserts its correction as a second user row directly before the + // live reply, so the turn opens with a RUN of user rows. Journaling only back + // to the nearest one lost the prompt that actually started the turn — the + // vanishing user bubble. + it('journals the whole user run, not just the correction', () => { + persistInFlightTurnState({ + awaitingResponse: false, + busy: true, + messages: [ + user('user-1', 'remove the session counts'), + user('user-2', 'hurry up'), + assistant('assistant-stream-1', 'Moving.', { pending: true }) + ], + storedSessionId: 'stored-redirect', + streamId: 'assistant-stream-1', + turnStartedAt: Date.now() + }) + vi.advanceTimersByTime(400) + + const journaled = readInFlightTurnJournal('stored-redirect')?.messages ?? [] + + expect(journaled.map(message => message.parts.map(part => (part as { text: string }).text).join(''))).toEqual([ + 'remove the session counts', + 'hurry up', + 'Moving.' + ]) + }) + + it('still stops at an assistant boundary so prior turns are not journaled', () => { + persistInFlightTurnState({ + awaitingResponse: false, + busy: true, + messages: [ + user('user-old', 'an earlier turn'), + assistant('assistant-old', 'an earlier answer'), + user('user-1', 'the live prompt'), + assistant('assistant-stream-1', 'Moving.', { pending: true }) + ], + storedSessionId: 'stored-boundary', + streamId: 'assistant-stream-1', + turnStartedAt: Date.now() + }) + vi.advanceTimersByTime(400) + + const journaled = readInFlightTurnJournal('stored-boundary')?.messages ?? [] + + expect(journaled.map(message => message.id)).toEqual(['user-1', 'assistant-stream-1']) + }) +}) diff --git a/apps/desktop/src/lib/inflight-turn-journal.ts b/apps/desktop/src/lib/inflight-turn-journal.ts index 8056fa7af1..e93a0f0975 100644 --- a/apps/desktop/src/lib/inflight-turn-journal.ts +++ b/apps/desktop/src/lib/inflight-turn-journal.ts @@ -216,6 +216,14 @@ function recoverableTail(messages: ChatMessage[], streamId: null | string): Chat if (visible[index].role === 'user') { start = index + // A mid-turn redirect inserts its correction as another user row right + // before the live reply, so the turn can open with a RUN of user rows. + // Keep walking back over them: stopping at the nearest one journals the + // correction alone and loses the prompt that actually started the turn. + while (start > 0 && visible[start - 1].role === 'user') { + start -= 1 + } + break } } diff --git a/apps/desktop/src/lib/keybinds/actions.ts b/apps/desktop/src/lib/keybinds/actions.ts index 122e31fb54..618b386d2f 100644 --- a/apps/desktop/src/lib/keybinds/actions.ts +++ b/apps/desktop/src/lib/keybinds/actions.ts @@ -122,6 +122,21 @@ export const KEYBIND_ACTIONS: readonly KeybindActionMeta[] = [ // is a no-op. ⌘⇧T reopens the last closed tab where it was. { id: 'view.closeTab', category: 'view', defaults: ['mod+w'] }, { id: 'view.reopenTab', category: 'view', defaults: ['mod+shift+t'] }, + // ⌘F — open the find-in-page bar. `comboAllowedInInput` lets the combo + // fire from inside a textarea / contenteditable (matches browser behavior + // so typing in the composer and pressing ⌘F focuses find, not 'f'). + { id: 'view.findInPage', category: 'view', defaults: ['mod+f'] }, + // ⌘G / ⌘⇧G step matches — the platform-standard find-next/find-previous + // pair (Chrome, Safari, VS Code, and Claude Desktop all ship it). No + // `defaults` here on purpose: ⌘G already belongs to `view.toggleReview`, + // and shipping a duplicate default would flag a permanent conflict in the + // keybinds panel. While the find bar is OPEN, its capture-phase listener + // claims ⌘G/⌘⇧G and stops propagation (see components/find-bar.tsx), so + // stepping works out of the box and the review toggle keeps the key the + // rest of the time. These entries exist so the panel documents the pair + // and a user who prefers a dedicated chord can bind one. + { id: 'view.findNext', category: 'view', defaults: [] }, + { id: 'view.findPrevious', category: 'view', defaults: [] }, { id: 'appearance.toggleMode', category: 'view', defaults: ['shift+x'] }, { id: 'keybinds.openPanel', category: 'view', defaults: ['mod+/'] } ] diff --git a/apps/desktop/src/lib/markdown-blocks.ts b/apps/desktop/src/lib/markdown-blocks.ts index df6a473a27..8aac6a3a61 100644 --- a/apps/desktop/src/lib/markdown-blocks.ts +++ b/apps/desktop/src/lib/markdown-blocks.ts @@ -9,8 +9,15 @@ import { parseMarkdownIntoBlocks } from '@assistant-ui/react-streamdown' * new string, so the stock splitter pays that O(full-text) cost ~30×/s on * long replies. Two caches remove it: * - * 1. Exact-string LRU — a message that REMOUNTS with unchanged text - * (virtualizer scroll, session switch) reuses its parse outright. + * 1. Exact-string cache — the same text always yields the SAME ARRAY. This is + * identity, not just cost: `parseMarkdownIntoBlocks` builds a fresh array + * every call, and Streamdown mirrors the block list into `useState`, so a + * new array identity for unchanged text makes every Streamdown re-render + * itself and re-render every Block under it. Short messages used to skip + * the cache on the theory that re-lexing them was cheap — the lex is, but + * the churn it caused was not (measured: ~105 self-renders of Streamdown + * across five idle tiles in six seconds, cascading into 800 Block renders + * with nothing streaming). Every length is cached now. * 2. Streaming-append cache — when the new text starts with a recently parsed * text (the token-append case), the previous parse's blocks are reused up * to a settled boundary and only the suffix is lexed. The boundary drops @@ -28,8 +35,7 @@ import { parseMarkdownIntoBlocks } from '@assistant-ui/react-streamdown' * full lex, i.e. exactly the previous behavior. */ -const EXACT_CACHE_MAX = 64 -const EXACT_CACHE_MIN_LENGTH = 1024 +const EXACT_CACHE_MAX = 256 const exactCache = new Map() // Streaming messages grow monotonically, and only a handful stream at once @@ -109,10 +115,6 @@ function lexIncrementally(text: string): null | string[] { } export function parseMarkdownIntoBlocksCached(markdown: string): string[] { - if (markdown.length < EXACT_CACHE_MIN_LENGTH) { - return parseMarkdownIntoBlocks(markdown) - } - const hit = exactCache.get(markdown) if (hit) { diff --git a/apps/desktop/src/lib/renderer-loop-pause.ts b/apps/desktop/src/lib/renderer-loop-pause.ts new file mode 100644 index 0000000000..88b9e3559b --- /dev/null +++ b/apps/desktop/src/lib/renderer-loop-pause.ts @@ -0,0 +1,50 @@ +interface WindowStatePayload { + isMinimized?: boolean + isVisible?: boolean +} + +export function createRendererLoopPauseController(onChange: () => void, { pauseWhenUnfocused = true } = {}) { + let windowPaused = false + let windowFocused = document.hasFocus() + + const onVisibilityChange = () => onChange() + + const onBlur = () => { + if (windowFocused) { + windowFocused = false + onChange() + } + } + + const onFocus = () => { + if (!windowFocused) { + windowFocused = true + onChange() + } + } + + const offWindowState = window.hermesDesktop?.onWindowStateChanged?.((payload: WindowStatePayload) => { + const next = payload?.isMinimized === true || payload?.isVisible === false + + if (windowPaused === next) { + return + } + + windowPaused = next + onChange() + }) + + document.addEventListener('visibilitychange', onVisibilityChange) + window.addEventListener('blur', onBlur) + window.addEventListener('focus', onFocus) + + return { + dispose: () => { + document.removeEventListener('visibilitychange', onVisibilityChange) + window.removeEventListener('blur', onBlur) + window.removeEventListener('focus', onFocus) + offWindowState?.() + }, + isPaused: () => document.visibilityState === 'hidden' || (pauseWhenUnfocused && !windowFocused) || windowPaused + } +} diff --git a/apps/desktop/src/lib/use-session-slice.ts b/apps/desktop/src/lib/use-session-slice.ts index 78ab039133..f96d001742 100644 --- a/apps/desktop/src/lib/use-session-slice.ts +++ b/apps/desktop/src/lib/use-session-slice.ts @@ -1,4 +1,4 @@ -import { useSyncExternalStore } from 'react' +import { useCallback, useRef, useSyncExternalStore } from 'react' interface SliceStore { get(): Record @@ -29,3 +29,35 @@ export function useSessionSlice(store: SliceStore, key: string | null): T[ () => (key ? (store.get()[key] ?? (EMPTY as unknown as T[])) : (EMPTY as unknown as T[])) ) } + +interface ReadableStore { + get(): T + listen(listener: () => void): () => void +} + +/** + * Subscribe to a SCALAR derived from a hot store, re-rendering only when that + * scalar changes by `Object.is` — not on every write to the store it came from. + * + * `useStore($someHotStore)` bails out on reference equality alone, so a store + * republished per streaming token re-renders every consumer even when the two + * or three fields they actually read are identical. `$sessionStates` is the + * canonical case: it is republished on every message delta, so a component + * reading only `busy` or `turnStartedAt` off it pays for the whole transcript's + * churn. + * + * `select` must return a PRIMITIVE (or a referentially stable value). Returning + * a fresh object or array defeats the bail-out and reintroduces the churn this + * exists to remove — derive one scalar per call instead. + */ +export function useStoreSelector(store: ReadableStore, select: (value: T) => S): S { + // `select` is read through a ref so an inline arrow at the call site doesn't + // resubscribe on every render; useSyncExternalStore re-reads the snapshot on + // each render anyway, so the latest selector is always applied. + const selectRef = useRef(select) + selectRef.current = select + + const subscribe = useCallback((onChange: () => void) => store.listen(onChange), [store]) + + return useSyncExternalStore(subscribe, () => selectRef.current(store.get())) +} diff --git a/apps/desktop/src/main.tsx b/apps/desktop/src/main.tsx index b1dd657655..9aec213107 100644 --- a/apps/desktop/src/main.tsx +++ b/apps/desktop/src/main.tsx @@ -1,6 +1,13 @@ import './styles.css' // Side-effect: applies the persisted window translucency on load. import './store/translucency' +// Dev-only render/state churn counters. MUST precede the `react-dom` import +// below: react-dom captures the devtools hook at module init, so bippy has to +// install during THIS import's evaluation or every commit goes unseen +// (verified — a late install reports renderers=0, commits=0). `vite.config.ts` +// aliases this specifier to a no-op module for non-dev builds, so neither the +// counters nor bippy reach a shipped renderer. +import '@/debug/dev-only' import { QueryClientProvider } from '@tanstack/react-query' import { StrictMode } from 'react' @@ -10,6 +17,7 @@ import { HashRouter } from 'react-router-dom' import App from './app' import { ErrorBoundary } from './components/error-boundary' import { HapticsProvider } from './components/haptics-provider' +import { RootTooltipProvider } from './components/ui/tooltip' import { I18nProvider } from './i18n' import { installClipboardShim } from './lib/clipboard' import { queryClient } from './lib/query-client' @@ -25,8 +33,12 @@ if (import.meta.env.MODE !== 'production' || import.meta.env.VITE_PERF_PROBE === import('./app/chat/perf-probe') } -if (new URLSearchParams(window.location.search).get('win') === 'overlay') { +const winParam = new URLSearchParams(window.location.search).get('win') + +if (winParam === 'overlay') { void import('./app/pet-overlay/overlay-root').then(({ mountPetOverlay }) => mountPetOverlay()) +} else if (winParam === 'quick') { + void import('./app/quick-entry/quick-entry-root').then(({ mountQuickEntry }) => mountQuickEntry()) } else { createRoot(document.getElementById('root')!).render( @@ -35,7 +47,13 @@ if (new URLSearchParams(window.location.search).get('win') === 'overlay') { - {/* useTransitions={false}: react-router v7's HashRouter wraps every + {/* ONE tooltip provider for the whole app. Every `Tip` used to + carry its own, and with ~107 call sites those subtrees + dominated unrelated interactions (52,784 TooltipProvider + renders in a single sash drag). Radix's provider holds only + refs and stable callbacks, so hoisting is what it's for. */} + + {/* useTransitions={false}: react-router v7's HashRouter wraps every route state update in React.startTransition() by default. In React 19's concurrent renderer, transitions are non-urgent — React can yield mid-render and resume later. When the app is under load @@ -44,9 +62,10 @@ if (new URLSearchParams(window.location.search).get('win') === 'overlay') { the route change commit. The session sidebar highlight + main pane both freeze for seconds despite the main thread being free. Disabling transitions makes navigate() commit at default priority. */} - - - + + + + diff --git a/apps/desktop/src/store/composer-status.ts b/apps/desktop/src/store/composer-status.ts index 4ba910f47e..46152e076d 100644 --- a/apps/desktop/src/store/composer-status.ts +++ b/apps/desktop/src/store/composer-status.ts @@ -5,6 +5,7 @@ import { stableArray } from '@/lib/stable-array' import type { TodoItem, TodoStatus } from '@/lib/todos' import { $gateway } from './gateway' +import { $goalsBySession, type GoalStatus } from './goals' import { dispatchNativeNotification } from './native-notifications' import { notifyError } from './notifications' import { $sessionStates } from './session-states' @@ -13,13 +14,15 @@ import { $todosBySession } from './todos' /** Composer status stack feed — merged todos, subagents, background per session. */ export type StatusItemState = 'done' | 'failed' | 'running' -export type StatusItemType = 'background' | 'subagent' | 'todo' +export type StatusItemType = 'background' | 'goal' | 'subagent' | 'todo' export interface ComposerStatusItem { /** background: non-zero exit shown inline when failed. */ exitCode?: number /** subagent: active tool label shown on the right. */ currentTool?: string + /** goal: active | paused | waiting | done. */ + goalStatus?: GoalStatus id: string /** background process: captured stdout/stderr tail for the inline viewer. */ output?: string @@ -143,10 +146,52 @@ const todoToItem = (t: TodoItem): ComposerStatusItem => ({ type: 'todo' }) +const goalToItem = (goal: { detail?: string; status: GoalStatus; title: string }): ComposerStatusItem => ({ + currentTool: goal.detail, + goalStatus: goal.status, + id: 'goal:standing', + state: goal.status === 'active' || goal.status === 'waiting' ? 'running' : 'done', + title: goal.title, + type: 'goal' +}) + // The single thing the stack reads: a typed, merged item list per session. +// +// Identity contract: this computed's inputs churn constantly during a turn (a +// subagent tick, a 5s background poll, a todo update — in ANY session), but +// the merged output for most sessions is unchanged. Rebuilding fresh arrays +// and item objects every time handed every mounted composer stack a new +// reference per recompute — cross-session churn × open tiles. Stabilize both +// levels: an unchanged session keeps its previous array (and item objects), +// and a fully-unchanged map keeps its previous reference so `computed` skips +// the notify entirely ("preserve reference identity on no-ops"). +const sameStatusItem = (a: ComposerStatusItem, b: ComposerStatusItem) => + a.id === b.id && + a.type === b.type && + a.state === b.state && + a.title === b.title && + a.output === b.output && + a.exitCode === b.exitCode && + a.currentTool === b.currentTool && + a.goalStatus === b.goalStatus && + a.todoStatus === b.todoStatus && + a.sessionId === b.sessionId + +const stabilizeItems = (prev: ComposerStatusItem[] | undefined, next: ComposerStatusItem[]): ComposerStatusItem[] => { + if (!prev) { + return next + } + + const merged = next.map((item, i) => (prev[i] && sameStatusItem(prev[i], item) ? prev[i] : item)) + + return merged.length === prev.length && merged.every((item, i) => item === prev[i]) ? prev : merged +} + +let prevStatusItems: Record = {} + export const $statusItemsBySession = computed( - [$subagentsBySession, $backgroundStatusBySession, $todosBySession], - (subs, background, todos) => { + [$goalsBySession, $subagentsBySession, $backgroundStatusBySession, $todosBySession], + (goals, subs, background, todos) => { const out: Record = {} const push = (sid: string, items: ComposerStatusItem[]) => { @@ -159,6 +204,10 @@ export const $statusItemsBySession = computed( push(sid, list.map(todoToItem)) } + for (const [sid, goal] of Object.entries(goals)) { + push(sid, [goalToItem(goal)]) + } + for (const [sid, list] of Object.entries(subs)) { push(sid, list.filter(s => s.status === 'running' || s.status === 'queued').map(subToItem)) } @@ -167,12 +216,19 @@ export const $statusItemsBySession = computed( push(sid, list) } - return out + let unchanged = Object.keys(prevStatusItems).length === Object.keys(out).length + + for (const sid of Object.keys(out)) { + out[sid] = stabilizeItems(prevStatusItems[sid], out[sid]!) + unchanged &&= out[sid] === prevStatusItems[sid] + } + + return (prevStatusItems = unchanged ? prevStatusItems : out) } ) // Fixed render order for the groups in the stack (top → bottom, above queue). -const TYPE_ORDER: readonly StatusItemType[] = ['todo', 'subagent', 'background'] +const TYPE_ORDER: readonly StatusItemType[] = ['goal', 'todo', 'subagent', 'background'] export interface StatusGroup { items: ComposerStatusItem[] diff --git a/apps/desktop/src/store/find-in-page.ts b/apps/desktop/src/store/find-in-page.ts new file mode 100644 index 0000000000..463209cf08 --- /dev/null +++ b/apps/desktop/src/store/find-in-page.ts @@ -0,0 +1,130 @@ +import { atom } from 'nanostores' + +export interface FindInPageState { + active: boolean + query: string + matchOrdinal: number + matchCount: number +} + +const EMPTY: FindInPageState = { active: false, query: '', matchOrdinal: 0, matchCount: 0 } + +export const $findInPage = atom({ ...EMPTY }) + +export function openFindBar(): void { + $findInPage.set({ ...EMPTY, active: true }) +} + +export function closeFindBar(): void { + // Already closed: don't re-issue stopFindInPage. Escape is a shared gesture + // (the switcher and dialogs claim it too), so a stray second close must not + // reach into Electron again. + if (!$findInPage.get().active) { + return + } + + $findInPage.set({ ...EMPTY }) + // Clears both the search and the native highlight/selection in the page. + void window.hermesDesktop?.stopFindInPage() +} + +export function setFindQuery(query: string): void { + const prev = $findInPage.get() + + // Never search for a closed bar. The component clears its debounce on + // close, but a timer that already fired (or any late caller) must not + // re-issue a find and re-highlight the page after the user pressed Escape. + if (!prev.active) { + return + } + + if (!query) { + $findInPage.set({ ...prev, query: '', matchOrdinal: 0, matchCount: 0 }) + void window.hermesDesktop?.stopFindInPage() + + return + } + + $findInPage.set({ ...prev, query }) + void window.hermesDesktop?.findInPage(query, { forward: true, findNext: false }) +} + +export function findNext(): void { + const { query } = $findInPage.get() + + if (query) { + void window.hermesDesktop?.findInPage(query, { forward: true, findNext: true }) + } +} + +export function findPrevious(): void { + const { query } = $findInPage.get() + + if (query) { + void window.hermesDesktop?.findInPage(query, { forward: false, findNext: true }) + } +} + +/** Called by the preload bridge when `found-in-page` fires on webContents. */ +export function updateFindResults(activeMatch: number, count: number): void { + const prev = $findInPage.get() + $findInPage.set({ ...prev, matchOrdinal: activeMatch, matchCount: count }) +} + +// The found-in-page subscription is process-wide, not per-mount: the FindBar +// lives in the global overlay set and the shell remounts it on a connection +// re-home (soft switch) while route changes keep it alive. Refcount the single +// bridge listener so a remount cannot stack duplicate subscriptions — every +// stacked listener would re-dispatch the same result and, worse, outlive its +// component. +let listenerRefs = 0 +let detachListener: (() => void) | undefined + +/** + * Subscribe to `found-in-page` results. Returns a release fn; the underlying + * bridge listener is installed on the first subscriber and removed when the + * last one releases. Safe to call from an effect with a `[]` dep list. + */ +export function initFindInPageListener(): () => void { + listenerRefs += 1 + + if (listenerRefs === 1) { + detachListener = window.hermesDesktop?.onFoundInPage?.(result => { + updateFindResults(result.activeMatchOrdinal, result.count) + }) + } + + let released = false + + return () => { + // Guard double-release: React can invoke a cleanup once, but a caller + // holding the fn shouldn't be able to drive the refcount negative. + if (released) { + return + } + + released = true + listenerRefs -= 1 + + if (listenerRefs === 0) { + detachListener?.() + detachListener = undefined + } + } +} + +/** Test seam: number of live bridge subscriptions (0 or 1 in practice). */ +export function findInPageListenerCount(): number { + return listenerRefs +} + +/** + * Test seam: force-detach the bridge listener and zero the refcount. + * Production code never calls this — tests use it so one case's leaked + * subscription can't bleed into the next. + */ +export function resetFindInPageListenerForTest(): void { + detachListener?.() + detachListener = undefined + listenerRefs = 0 +} diff --git a/apps/desktop/src/store/gateway-switch.test.ts b/apps/desktop/src/store/gateway-switch.test.ts index 4ee362a4ba..93f004834f 100644 --- a/apps/desktop/src/store/gateway-switch.test.ts +++ b/apps/desktop/src/store/gateway-switch.test.ts @@ -5,15 +5,15 @@ import { $cronSessions, $freshDraftReady, $messagingSessions, + $sessionProfilesTruncated, $sessions, $sessionsLoading, - $sessionsTotal, setCronSessions, setFreshDraftReady, setMessagingSessions, + setSessionProfilesTruncated, setSessions, - setSessionsLoading, - setSessionsTotal + setSessionsLoading } from '@/store/session' import { $stalledSessionIds } from '@/store/session-states' @@ -27,7 +27,7 @@ describe('wipeSessionListsForGatewaySwitch', () => { beforeEach(() => { $gatewaySwitching.set(false) setSessions([{ id: 's1', title: 'old', profile: 'default' } as never]) - setSessionsTotal(1) + setSessionProfilesTruncated({ default: true }) setCronSessions([{ id: 'c1', title: 'cron', profile: 'default' } as never]) setMessagingSessions([{ id: 'm1', title: 'tg', profile: 'default' } as never]) $stalledSessionIds.set(['s1']) @@ -50,7 +50,7 @@ describe('wipeSessionListsForGatewaySwitch', () => { wipeSessionListsForGatewaySwitch() expect($sessions.get()).toEqual([]) - expect($sessionsTotal.get()).toBe(0) + expect($sessionProfilesTruncated.get()).toEqual({}) expect($cronSessions.get()).toEqual([]) expect($messagingSessions.get()).toEqual([]) expect($stalledSessionIds.get()).toEqual([]) diff --git a/apps/desktop/src/store/gateway-switch.ts b/apps/desktop/src/store/gateway-switch.ts index 291b803283..507ade879c 100644 --- a/apps/desktop/src/store/gateway-switch.ts +++ b/apps/desktop/src/store/gateway-switch.ts @@ -1,5 +1,6 @@ import { atom } from 'nanostores' +import { resetLiveRuntimeTracking } from '@/app/contrib/hooks/use-background-sync' import { resetSidebarBatchCapability } from '@/hermes' import { invalidateProfileScopedQueries } from '@/lib/query-client' import { resetSessionsLimit } from '@/store/layout' @@ -13,10 +14,9 @@ import { setMessagingSessions, setMessagingTruncated, setSelectedStoredSessionId, - setSessionProfileTotals, + setSessionProfilesTruncated, setSessions, - setSessionsLoading, - setSessionsTotal + setSessionsLoading } from '@/store/session' import { clearAllSessionStates } from '@/store/session-states' @@ -42,8 +42,7 @@ export function wipeSessionListsForGatewaySwitch(): void { // "batched sidebar endpoint missing" capability verdict across the switch. resetSidebarBatchCapability() setSessions([]) - setSessionsTotal(0) - setSessionProfileTotals({}) + setSessionProfilesTruncated({}) setCronSessions([]) setMessagingSessions([]) setMessagingPlatformTotals({}) @@ -52,6 +51,7 @@ export function wipeSessionListsForGatewaySwitch(): void { // $attentionSessionIds (computed) and $stalledSessionIds (owned beside it). // $unreadFinishedSessionIds is separate, so wipe it explicitly. clearAllSessionStates() + resetLiveRuntimeTracking() $unreadFinishedSessionIds.set([]) setSessionsLoading(true) resetSessionsLimit() diff --git a/apps/desktop/src/store/goals.test.ts b/apps/desktop/src/store/goals.test.ts new file mode 100644 index 0000000000..61c00dd487 --- /dev/null +++ b/apps/desktop/src/store/goals.test.ts @@ -0,0 +1,73 @@ +import { afterEach, describe, expect, it, vi } from 'vitest' + +import { $goalsBySession, applyGoalStatusText, clearSessionGoal } from './goals' + +describe('goal store', () => { + afterEach(() => { + vi.useRealTimers() + $goalsBySession.set({}) + }) + + it('stores active goals from /goal output', () => { + applyGoalStatusText('s1', '⊙ Goal set (20-turn budget): ship the feature') + + expect($goalsBySession.get().s1).toMatchObject({ + status: 'active', + title: 'ship the feature' + }) + }) + + it('keeps the current title for continuation and pause messages', () => { + applyGoalStatusText('s1', '⊙ Goal set (20-turn budget): ship the feature') + applyGoalStatusText('s1', '↻ Continuing toward goal (1/20): next step is tests') + + expect($goalsBySession.get().s1).toMatchObject({ + detail: 'Continuing toward goal (1/20): next step is tests', + status: 'active', + title: 'ship the feature' + }) + + applyGoalStatusText('s1', '⏸ Goal paused — 20/20 turns used. Use /goal resume to keep going.') + + expect($goalsBySession.get().s1).toMatchObject({ + status: 'paused', + title: 'ship the feature' + }) + }) + + it('lingers done goals before clearing them', () => { + vi.useFakeTimers() + + applyGoalStatusText('s1', '⊙ Goal set (20-turn budget): ship the feature') + applyGoalStatusText('s1', '✓ Goal achieved: tests pass') + + expect($goalsBySession.get().s1).toMatchObject({ status: 'done' }) + + vi.advanceTimersByTime(7_999) + expect($goalsBySession.get().s1).toBeTruthy() + + vi.advanceTimersByTime(1) + expect($goalsBySession.get().s1).toBeUndefined() + }) + + it('clears on no-goal output', () => { + applyGoalStatusText('s1', '⊙ Goal set (20-turn budget): ship another feature') + applyGoalStatusText('s1', 'No active goal. Set one with /goal .') + + expect($goalsBySession.get().s1).toBeUndefined() + }) + + it('cancels pending done clears when replacing a goal', () => { + vi.useFakeTimers() + + applyGoalStatusText('s1', '⊙ Goal set: first') + applyGoalStatusText('s1', '✓ Goal achieved: first done') + applyGoalStatusText('s1', '⊙ Goal set: second') + + vi.advanceTimersByTime(8_000) + + expect($goalsBySession.get().s1).toMatchObject({ status: 'active', title: 'second' }) + + clearSessionGoal('s1') + }) +}) diff --git a/apps/desktop/src/store/goals.ts b/apps/desktop/src/store/goals.ts new file mode 100644 index 0000000000..3b19b7eb63 --- /dev/null +++ b/apps/desktop/src/store/goals.ts @@ -0,0 +1,177 @@ +import { atom } from 'nanostores' + +import { $gateway } from './gateway' + +export type GoalStatus = 'active' | 'done' | 'paused' | 'waiting' + +export interface SessionGoal { + detail?: string + status: GoalStatus + title: string + updatedAt: number +} + +export const $goalsBySession = atom>({}) + +const DONE_LINGER_MS = 8_000 +const clearTimers = new Map>() + +function cancelScheduledClear(sid: string) { + const timer = clearTimers.get(sid) + + if (timer !== undefined) { + clearTimeout(timer) + clearTimers.delete(sid) + } +} + +export function setSessionGoal(sid: string, goal: SessionGoal) { + if (!sid) { + return + } + + cancelScheduledClear(sid) + $goalsBySession.set({ ...$goalsBySession.get(), [sid]: goal }) + + if (goal.status === 'done') { + clearTimers.set( + sid, + setTimeout(() => { + clearTimers.delete(sid) + clearSessionGoal(sid) + }, DONE_LINGER_MS) + ) + } +} + +export function clearSessionGoal(sid: string) { + cancelScheduledClear(sid) + + const map = $goalsBySession.get() + + if (!(sid in map)) { + return + } + + const { [sid]: _drop, ...rest } = map + $goalsBySession.set(rest) +} + +const clean = (value: string): string => value.replace(/\r/g, '').trim() + +const firstLine = (value: string): string => clean(value).split('\n')[0]?.trim() ?? '' + +function goalTitleFromLine(line: string, pattern: RegExp): string { + return (line.match(pattern)?.[1] ?? '').trim() +} + +function nextGoalFromText(text: string, previous?: SessionGoal): SessionGoal | null | undefined { + const body = clean(text) + const line = firstLine(body) + + if (!line) { + return undefined + } + + if ( + /^No active goal\b/i.test(line) || + /^No goal (?:set|to resume)\b/i.test(line) || + /^✓ Goal cleared\b/i.test(line) + ) { + return null + } + + const now = Date.now() + const fromSet = goalTitleFromLine(line, /^⊙ Goal set(?:\s*\([^)]*\))?:\s*(.+)$/) + const fromActive = goalTitleFromLine(line, /^⊙ Goal\s*\([^)]*active[^)]*\):\s*(.+)$/) + const fromResume = goalTitleFromLine(line, /^▶ Goal resumed:\s*(.+)$/) + + if (fromSet || fromActive || fromResume) { + return { status: 'active', title: fromSet || fromActive || fromResume, updatedAt: now } + } + + const fromWaiting = goalTitleFromLine(line, /^⏳ Goal\s*\([^)]*(?:parked|active)[^)]*\):\s*(.+)$/) + + if (fromWaiting) { + return { status: 'waiting', title: fromWaiting, updatedAt: now } + } + + const fromPaused = goalTitleFromLine(line, /^⏸ Goal(?:\s*\([^)]*\)| paused)?:\s*(.+)$/) + + if (fromPaused) { + return { status: 'paused', title: fromPaused, updatedAt: now } + } + + const fromDone = goalTitleFromLine(line, /^✓ Goal done\s*\([^)]*\):\s*(.+)$/) + + if (fromDone) { + return { status: 'done', title: fromDone, updatedAt: now } + } + + if (/^↻ Continuing toward goal\b/i.test(line)) { + return { + detail: line.replace(/^↻\s*/, ''), + status: 'active', + title: previous?.title || 'Standing goal', + updatedAt: now + } + } + + if (/^⏳ Goal parked\b/i.test(line)) { + return { + detail: line.replace(/^⏳\s*/, ''), + status: 'waiting', + title: previous?.title || 'Standing goal', + updatedAt: now + } + } + + if (/^⏸ Goal paused\b/i.test(line)) { + return { + detail: line.replace(/^⏸\s*/, ''), + status: 'paused', + title: previous?.title || 'Standing goal', + updatedAt: now + } + } + + if (/^✓ Goal achieved\b/i.test(line)) { + return { + detail: line.replace(/^✓\s*/, ''), + status: 'done', + title: previous?.title || 'Standing goal', + updatedAt: now + } + } + + return undefined +} + +export function applyGoalStatusText(sid: string, text: string) { + if (!sid) { + return + } + + const next = nextGoalFromText(text, $goalsBySession.get()[sid]) + + if (next === null) { + clearSessionGoal(sid) + } else if (next) { + setSessionGoal(sid, next) + } +} + +export async function refreshSessionGoal(sid: string): Promise { + const gateway = $gateway.get() + + if (!sid || !gateway) { + return + } + + try { + const result = await gateway.request<{ output?: string }>('slash.exec', { command: 'goal status', session_id: sid }) + applyGoalStatusText(sid, result?.output ?? '') + } catch { + // Best-effort: older gateways or detached sessions simply won't hydrate it. + } +} diff --git a/apps/desktop/src/store/quick-entry.test.ts b/apps/desktop/src/store/quick-entry.test.ts new file mode 100644 index 0000000000..0657cdd5fb --- /dev/null +++ b/apps/desktop/src/store/quick-entry.test.ts @@ -0,0 +1,216 @@ +import { describe, expect, it } from 'vitest' + +import { + initialQuickComposerState, + QUICK_TARGET_CURRENT, + QUICK_TARGET_NEW, + type QuickComposerEvent, + quickComposerReducer, + type QuickComposerState, + type QuickEntrySubmitPayload +} from './quick-entry' + +// Drive the reducer like the window does, collecting every send it asked for. +function run(events: QuickComposerEvent[], from: QuickComposerState = initialQuickComposerState) { + let state = from + const sent: QuickEntrySubmitPayload[] = [] + + for (const event of events) { + const transition = quickComposerReducer(state, event) + state = transition.state + + if (transition.send !== null) { + sent.push(transition.send) + } + } + + return { sent, state } +} + +// Most flows only make sense once the primary renderer has reported a live +// gateway — this is the push the quick window receives on open. +const connect: QuickComposerEvent = { + connected: true, + sessions: [ + { id: 's1', title: 'Fix the build' }, + { id: 's2', title: 'Research trip' } + ], + type: 'state' +} + +describe('quickComposerReducer', () => { + it('starts visible, empty, DISCONNECTED, and targeting the current chat', () => { + expect(initialQuickComposerState).toEqual({ + connected: false, + draft: '', + sessions: [], + submitting: false, + target: QUICK_TARGET_CURRENT, + visible: true + }) + }) + + it('submit sends the trimmed draft with the target, clears it, and hides', () => { + const { sent, state } = run([connect, { draft: ' ship it ', type: 'edit' }, { type: 'submit' }]) + + expect(sent).toEqual([{ target: QUICK_TARGET_CURRENT, text: 'ship it' }]) + expect(state.draft).toBe('') + expect(state.submitting).toBe(true) + expect(state.visible).toBe(false) + }) + + it('an empty or whitespace-only submit sends nothing and stays open', () => { + const blank = run([connect, { type: 'submit' }]) + expect(blank.sent).toEqual([]) + expect(blank.state.visible).toBe(true) + + const spaces = run([connect, { draft: ' ', type: 'edit' }, { type: 'submit' }]) + expect(spaces.sent).toEqual([]) + // A stray Enter must not make the window vanish out from under the user. + expect(spaces.state.visible).toBe(true) + expect(spaces.state.draft).toBe(' ') + }) + + it('submit is DISABLED while disconnected — the draft survives for the reconnect', () => { + const { sent, state } = run([{ draft: 'hello?', type: 'edit' }, { type: 'submit' }]) + + expect(sent).toEqual([]) + expect(state.visible).toBe(true) + expect(state.draft).toBe('hello?') + + // The gateway comes back: the same draft now sends. + const after = run([connect, { type: 'submit' }], state) + expect(after.sent).toEqual([{ target: QUICK_TARGET_CURRENT, text: 'hello?' }]) + }) + + it('a disconnect push mid-composition keeps the draft but blocks the send', () => { + const { sent, state } = run([ + connect, + { draft: 'almost done', type: 'edit' }, + { connected: false, sessions: [], type: 'state' }, + { type: 'submit' } + ]) + + expect(sent).toEqual([]) + expect(state.connected).toBe(false) + expect(state.draft).toBe('almost done') + }) + + it('a second submit while already submitting cannot double-send', () => { + const { sent, state } = run([connect, { draft: 'hello', type: 'edit' }, { type: 'submit' }, { type: 'submit' }]) + + expect(sent).toEqual([{ target: QUICK_TARGET_CURRENT, text: 'hello' }]) + expect(state.submitting).toBe(true) + }) + + it('a picked session target rides the submit payload', () => { + const { sent } = run([ + connect, + { target: 's2', type: 'target' }, + { draft: 'send this there', type: 'edit' }, + { type: 'submit' } + ]) + + expect(sent).toEqual([{ target: 's2', text: 'send this there' }]) + }) + + it('the new-session target rides the submit payload', () => { + const { sent } = run([ + connect, + { target: QUICK_TARGET_NEW, type: 'target' }, + { draft: 'fresh start', type: 'edit' }, + { type: 'submit' } + ]) + + expect(sent).toEqual([{ target: QUICK_TARGET_NEW, text: 'fresh start' }]) + }) + + it('a picked session that vanishes from the pushed list falls back to current', () => { + const { state } = run([ + connect, + { target: 's2', type: 'target' }, + { connected: true, sessions: [{ id: 's1', title: 'Fix the build' }], type: 'state' } + ]) + + expect(state.target).toBe(QUICK_TARGET_CURRENT) + }) + + it('a state push that still contains the picked session keeps it', () => { + const { state } = run([connect, { target: 's1', type: 'target' }, connect]) + + expect(state.target).toBe('s1') + }) + + it('Escape dismisses without sending, discards the draft, and resets the target', () => { + const { sent, state } = run([ + connect, + { target: 's1', type: 'target' }, + { draft: 'never mind', type: 'edit' }, + { type: 'dismiss' } + ]) + + expect(sent).toEqual([]) + expect(state.draft).toBe('') + expect(state.target).toBe(QUICK_TARGET_CURRENT) + expect(state.visible).toBe(false) + }) + + it('blur dismisses without sending', () => { + const { sent, state } = run([connect, { draft: 'clicked away', type: 'edit' }, { type: 'blur' }]) + + expect(sent).toEqual([]) + expect(state.visible).toBe(false) + expect(state.draft).toBe('') + }) + + it('the blur that follows a submit does not re-send or resurrect the draft', () => { + const { sent, state } = run([connect, { draft: 'go', type: 'edit' }, { type: 'submit' }, { type: 'blur' }]) + + expect(sent).toEqual([{ target: QUICK_TARGET_CURRENT, text: 'go' }]) + expect(state.draft).toBe('') + expect(state.submitting).toBe(false) + expect(state.visible).toBe(false) + }) + + it('being re-summoned resets the capture surface but KEEPS the pushed gateway truth', () => { + const afterSubmit = run([connect, { draft: 'first', type: 'edit' }, { type: 'submit' }]).state + const { sent, state } = run([{ type: 'shown' }], afterSubmit) + + expect(sent).toEqual([]) + expect(state.draft).toBe('') + expect(state.target).toBe(QUICK_TARGET_CURRENT) + expect(state.visible).toBe(true) + // The gateway did not disconnect just because the window was re-opened. + expect(state.connected).toBe(true) + expect(state.sessions).toHaveLength(2) + }) + + it('re-summoning after a dismiss never carries the old draft back', () => { + const dismissed = run([connect, { draft: 'stale text', type: 'edit' }, { type: 'dismiss' }]).state + const reopened = quickComposerReducer(dismissed, { type: 'shown' }).state + + expect(reopened.draft).toBe('') + expect(reopened.visible).toBe(true) + }) + + it('editing keeps the window open and never sends', () => { + const { sent, state } = run([ + connect, + { draft: 'a', type: 'edit' }, + { draft: 'ab', type: 'edit' }, + { draft: 'abc', type: 'edit' } + ]) + + expect(sent).toEqual([]) + expect(state.draft).toBe('abc') + expect(state.visible).toBe(true) + }) + + it('a full summon → type → submit → summon cycle sends exactly once per round', () => { + const first = run([connect, { draft: 'one', type: 'edit' }, { type: 'submit' }]) + const second = run([{ type: 'shown' }, { draft: 'two', type: 'edit' }, { type: 'submit' }], first.state) + + expect(first.sent).toEqual([{ target: QUICK_TARGET_CURRENT, text: 'one' }]) + expect(second.sent).toEqual([{ target: QUICK_TARGET_CURRENT, text: 'two' }]) + }) +}) diff --git a/apps/desktop/src/store/quick-entry.ts b/apps/desktop/src/store/quick-entry.ts new file mode 100644 index 0000000000..5491608324 --- /dev/null +++ b/apps/desktop/src/store/quick-entry.ts @@ -0,0 +1,310 @@ +/** + * Quick Entry (renderer side) — the mini composer's own state, and the + * primary window's bridge back into the real prompt-submit path. + * + * The quick window carries NO gateway connection: it hands its text to the main + * process, which forwards it to the primary renderer, which sends it through the + * SAME `submitText` the normal composer uses (see + * app/contrib/hooks/use-quick-entry-bridge). There is no second submit path and + * no new gateway RPC. + * + * The device-local preference (enabled + shortcut) is authoritative in the MAIN + * process — it owns the OS registration and must restore it on a cold launch + * without the renderer ever visiting Settings. This module treats what the + * bridge returns as the truth and caches it for the settings UI, same authority + * split as keep-awake. + */ + +import { atom } from 'nanostores' + +export interface QuickEntryState { + enabled: boolean + /** null before the first read; the settings row shows a skeleton until then. */ + registered: boolean | null + /** Why the OS shortcut isn't live: taken by another app, or unusable. */ + error: null | QuickEntryRegistrationError + shortcut: string +} + +export type QuickEntryRegistrationError = 'invalid' | 'taken' + +export interface QuickEntryStatus { + enabled: boolean + error: null | QuickEntryRegistrationError + registered: boolean + shortcut: string +} + +export const QUICK_ENTRY_DEFAULT_SHORTCUT = 'CommandOrControl+Shift+Space' + +export const $quickEntry = atom({ + enabled: true, + error: null, + registered: null, + shortcut: QUICK_ENTRY_DEFAULT_SHORTCUT +}) + +function applyStatus(status: QuickEntryStatus | undefined): void { + if (!status) { + return + } + + $quickEntry.set({ + enabled: status.enabled === true, + error: status.error ?? null, + registered: status.registered === true, + shortcut: typeof status.shortcut === 'string' && status.shortcut ? status.shortcut : QUICK_ENTRY_DEFAULT_SHORTCUT + }) +} + +/** True when the shell exposes the Quick Entry capability (desktop only). */ +export function canUseQuickEntry(): boolean { + return typeof window !== 'undefined' && typeof window.hermesDesktop?.quickEntry?.getSettings === 'function' +} + +/** Read the live registration state into the store (Settings mount). */ +export async function loadQuickEntrySettings(): Promise { + if (!canUseQuickEntry()) { + return + } + + try { + applyStatus(await window.hermesDesktop.quickEntry.getSettings()) + } catch { + // A failed read leaves the store as-is; the row keeps its last known copy. + } +} + +/** + * Write a preference and adopt whatever the main process reports back — a + * rejected shortcut or an already-taken chord comes back as an error state + * instead of a silently-lost setting. + */ +export async function saveQuickEntrySettings(patch: { enabled?: boolean; shortcut?: string }): Promise { + if (!canUseQuickEntry()) { + return + } + + // Optimistic: paint the intent immediately, then let the authoritative reply + // (which knows whether the OS accepted it) get the last word. + const previous = $quickEntry.get() + $quickEntry.set({ ...previous, ...patch, registered: previous.registered }) + + try { + applyStatus(await window.hermesDesktop.quickEntry.setSettings(patch)) + } catch { + $quickEntry.set(previous) + } +} + +// ── Quick window submit state machine ─────────────────────────────────────── + +/** A recent session the quick window can target (pushed by the primary). */ +export interface QuickEntrySessionOption { + id: string + title: string +} + +/** Send into whatever chat the main window currently has in front. */ +export const QUICK_TARGET_CURRENT = 'current' +/** Start a brand-new session for this prompt. */ +export const QUICK_TARGET_NEW = 'new' + +/** + * The primary renderer's push into the quick window: is the gateway usable, and + * which recent sessions can be targeted. The quick window has NO gateway of its + * own, so this pushed copy is its only view of backend truth — it starts + * disconnected (input disabled) until the first push proves otherwise. + */ +export interface QuickEntryStatePush { + connected: boolean + sessions: QuickEntrySessionOption[] +} + +/** What a quick-window submit carries back to the primary renderer. */ +export interface QuickEntrySubmitPayload { + /** QUICK_TARGET_CURRENT, QUICK_TARGET_NEW, or a stored session id. */ + target: string + text: string +} + +/** + * The quick window's own composer state. Deliberately a tiny pure reducer: the + * behavior that would actually break a user — an empty submit must not send but + * must still not hide the window, a real submit clears the draft AND hides, a + * double-fire while already submitting must not send twice, and a dead gateway + * must disable sending entirely — is the part worth proving, and none of it + * needs React or Electron. + */ +export interface QuickComposerState { + /** Last pushed gateway truth. False (the initial value) disables submit. */ + connected: boolean + draft: string + /** Recent sessions the picker offers, pushed by the primary renderer. */ + sessions: QuickEntrySessionOption[] + /** True between a send and the window actually hiding. Blocks a double-send. */ + submitting: boolean + /** Where a submit lands: current / new / a stored session id. */ + target: string + /** Whether the window should be visible. False asks the shell to hide. */ + visible: boolean +} + +export type QuickComposerEvent = + | { type: 'blur' } + | { type: 'dismiss' } + | { type: 'edit'; draft: string } + | { type: 'shown' } + | { type: 'state'; connected: boolean; sessions: QuickEntrySessionOption[] } + | { type: 'submit' } + | { type: 'target'; target: string } + +export interface QuickComposerTransition { + /** Payload to send through the real prompt-submit path, or null for none. */ + send: null | QuickEntrySubmitPayload + state: QuickComposerState +} + +export const initialQuickComposerState: QuickComposerState = { + // Disconnected until the primary renderer's first push proves otherwise — a + // capture window that accepts text it can never deliver is a lie. + connected: false, + draft: '', + sessions: [], + submitting: false, + target: QUICK_TARGET_CURRENT, + visible: true +} + +export function quickComposerReducer(state: QuickComposerState, event: QuickComposerEvent): QuickComposerTransition { + switch (event.type) { + case 'blur': + case 'dismiss': { + // Escape / focus loss discards without sending. A dismiss mid-submit still + // hides — the send already left for the main process. + return { + send: null, + state: { ...state, draft: '', submitting: false, target: QUICK_TARGET_CURRENT, visible: false } + } + } + + case 'edit': { + return { send: null, state: { ...state, draft: event.draft } } + } + + case 'shown': { + // Re-summoned: a fresh capture surface every time — never a stale draft or + // a leftover target — but the pushed gateway truth carries over. + return { + send: null, + state: { ...state, draft: '', submitting: false, target: QUICK_TARGET_CURRENT, visible: true } + } + } + + case 'state': { + // Adopt the pushed truth. A selected session that no longer exists in the + // pushed list must not silently swallow the prompt — fall back to current. + const targetStillValid = + event.connected && + (state.target === QUICK_TARGET_CURRENT || + state.target === QUICK_TARGET_NEW || + event.sessions.some(session => session.id === state.target)) + + return { + send: null, + state: { + ...state, + connected: event.connected, + sessions: event.sessions, + target: targetStillValid ? state.target : QUICK_TARGET_CURRENT + } + } + } + + case 'submit': { + const text = state.draft.trim() + + // Nothing to send — or nowhere to send it (gateway down): stay open and + // keep the draft so a stray Enter can't make the text vanish. + if (!text || state.submitting || !state.connected) { + return { send: null, state } + } + + return { + send: { target: state.target, text }, + state: { ...state, draft: '', submitting: true, visible: false } + } + } + + case 'target': { + return { send: null, state: { ...state, target: event.target } } + } + + default: { + return { send: null, state } + } + } +} + +// ── Primary-renderer bridge ──────────────────────────────────────────────── + +let submitHandler: ((payload: QuickEntrySubmitPayload) => void) | null = null +let unsubscribeSubmit: (() => void) | null = null + +/** + * Register the handler that turns a quick-window submit into a real send. The + * primary window routes it by target: current chat → `submitText`, a stored + * session id → resume + submit, new → fresh draft + submit. + */ +export function setQuickEntrySubmitHandler(fn: ((payload: QuickEntrySubmitPayload) => void) | null): void { + submitHandler = fn +} + +function normalizeSubmitPayload(raw: unknown): null | QuickEntrySubmitPayload { + // Tolerate the v1 bare-string wire shape (an older quick window after a + // partial update) by treating it as "send to the current chat". + if (typeof raw === 'string') { + return raw.trim() ? { target: QUICK_TARGET_CURRENT, text: raw } : null + } + + if (!raw || typeof raw !== 'object') { + return null + } + + const record = raw as Record + const text = typeof record.text === 'string' ? record.text : '' + + if (!text.trim()) { + return null + } + + return { + target: typeof record.target === 'string' && record.target ? record.target : QUICK_TARGET_CURRENT, + text + } +} + +/** + * Wire the quick-window → primary-renderer submit channel once. Returns a + * disposer. Idempotent — a second call while wired is a no-op. + */ +export function initQuickEntryBridge(): () => void { + const api = typeof window === 'undefined' ? undefined : window.hermesDesktop?.quickEntry + + if (!api?.onSubmit || unsubscribeSubmit) { + return () => {} + } + + unsubscribeSubmit = api.onSubmit(raw => { + const payload = normalizeSubmitPayload(raw) + + if (payload) { + submitHandler?.(payload) + } + }) + + return () => { + unsubscribeSubmit?.() + unsubscribeSubmit = null + } +} diff --git a/apps/desktop/src/store/session-states.ts b/apps/desktop/src/store/session-states.ts index 949d56e140..53ad8ee89a 100644 --- a/apps/desktop/src/store/session-states.ts +++ b/apps/desktop/src/store/session-states.ts @@ -184,10 +184,25 @@ function handleTransition(previous: ClientSessionState | null, next: ClientSessi /** Publish one session's state. Automatically fires transition side-effects * (watchdog arm/disarm, settle grace, unread marker, compression id rotation) * by diffing previous vs next — callers never need to manually call a - * transition handler. */ + * transition handler. + * + * Skips the publish when the new state is identical to the existing one + * (same reference) to avoid churning `$sessionStates` on periodic + * `session.info` heartbeats that carry no change — otherwise every ~1/s + * heartbeat creates a new Record spread, triggering computed atoms + * ($workingSessionIds, $attentionSessionIds) and their subscribers + * unnecessarily. The runtime-id→state cache (sessionStateByRuntimeIdRef) + * is updated independently by the caller, so the visual path stays live + * without the store churn. */ export function publishSessionState(runtimeId: string, state: ClientSessionState) { - const prev = $sessionStates.get()[runtimeId] ?? null - $sessionStates.set({ ...$sessionStates.get(), [runtimeId]: state }) + const current = $sessionStates.get() + const prev = current[runtimeId] ?? null + + if (prev === state) { + return + } + + $sessionStates.set({ ...current, [runtimeId]: state }) handleTransition(prev, state, runtimeId) } diff --git a/apps/desktop/src/store/session.ts b/apps/desktop/src/store/session.ts index 31ea5ff832..340770936d 100644 --- a/apps/desktop/src/store/session.ts +++ b/apps/desktop/src/store/session.ts @@ -270,7 +270,6 @@ export function mergeSessionPage( export const $connection = atom(null) export const $gatewayState = atom('idle') export const $sessions = atom([]) -export const $sessionsTotal = atom(0) // Cron-job sessions (source === 'cron') are fetched as their own list so the // scheduler's always-newest sessions never crowd recents out of the page // budget. Powers the collapsed "Cron jobs" sidebar section. @@ -294,11 +293,13 @@ export const $messagingPlatformTotals = atom>({}) // True when the combined seed fetch hit MESSAGING_SECTION_LIMIT, so at least // one platform may have more rows on disk than were loaded. export const $messagingTruncated = atom(false) -// Listable conversation count per profile (children excluded), keyed by profile -// name. Lets the sidebar scope its "Load more" footer to the active profile so a -// huge default profile doesn't keep "Load more" visible while browsing a small -// one. Empty for single-profile users (fall back to $sessionsTotal). -export const $sessionProfileTotals = atom>({}) +// Whether a profile's last session page was CAPPED by the request limit, keyed +// by profile name — i.e. more rows exist on disk than were loaded. Replaces the +// old exact per-profile totals: rendering `loaded/total` in the sidebar cost a +// COUNT(*) per profile DB on every refresh and only ever confused people, while +// "is there another page?" is what pagination actually needs and comes free +// from the row count the query already returned. +export const $sessionProfilesTruncated = atom>({}) export const $sessionsLoading = atom(true) export const $activeSessionId = atom(null) export const $selectedStoredSessionId = atom(null) @@ -376,14 +377,13 @@ export const $sessionPickerOpen = atom(false) export const setConnection = (next: Updater) => updateAtom($connection, next) export const setGatewayState = (next: Updater) => updateAtom($gatewayState, next) export const setSessions = (next: Updater) => updateAtom($sessions, next) -export const setSessionsTotal = (next: Updater) => updateAtom($sessionsTotal, next) export const setCronSessions = (next: Updater) => updateAtom($cronSessions, next) export const setMessagingSessions = (next: Updater) => updateAtom($messagingSessions, next) export const setMessagingPlatformTotals = (next: Updater>) => updateAtom($messagingPlatformTotals, next) export const setMessagingTruncated = (next: Updater) => updateAtom($messagingTruncated, next) -export const setSessionProfileTotals = (next: Updater>) => - updateAtom($sessionProfileTotals, next) +export const setSessionProfilesTruncated = (next: Updater>) => + updateAtom($sessionProfilesTruncated, next) export const setSessionsLoading = (next: Updater) => updateAtom($sessionsLoading, next) export const setActiveSessionId = (next: Updater) => updateAtom($activeSessionId, next) export const setActiveSessionStoredIdRotation = (next: Updater) => diff --git a/apps/desktop/src/store/statusbar-prefs.ts b/apps/desktop/src/store/statusbar-prefs.ts new file mode 100644 index 0000000000..3de1123376 --- /dev/null +++ b/apps/desktop/src/store/statusbar-prefs.ts @@ -0,0 +1,38 @@ +import { Codecs, persistentAtom } from '@/lib/persisted' + +const STATUSBAR_HIDDEN_STORAGE_KEY = 'hermes.desktop.statusbarHidden' + +// Items the bar hides until the user turns them on from its context menu. The +// bar's job is to answer "is the backend healthy, where am I, what's it doing" — +// route shortcuts (cron/webhooks/agents), the terminal toggle, and the approval +// pill are navigation, not status, so they start out of the way. +export const STATUSBAR_HIDDEN_BY_DEFAULT: readonly string[] = [ + 'agents', + 'approval-mode', + 'cron', + 'terminal', + 'webhooks' +] + +// Stored as the explicit hidden set (not the visible one) so an item added to +// the bar in a later version shows up for existing users instead of silently +// staying off. An empty array is a real value — the user turned everything on — +// so this uses a sanitizing json codec rather than Codecs.stringArray, which +// drops the key when empty and would resurrect the defaults on next launch. +export const $statusbarHiddenIds = persistentAtom( + STATUSBAR_HIDDEN_STORAGE_KEY, + [...STATUSBAR_HIDDEN_BY_DEFAULT], + Codecs.json(value => + Array.isArray(value) ? value.filter((id): id is string => typeof id === 'string' && id.length > 0) : [] + ) +) + +export function setStatusbarItemVisible(id: string, visible: boolean) { + const hidden = $statusbarHiddenIds.get() + + if (visible === !hidden.includes(id)) { + return + } + + $statusbarHiddenIds.set(visible ? hidden.filter(entry => entry !== id) : [...hidden, id]) +} diff --git a/apps/desktop/src/store/working-ids-stored-id.test.ts b/apps/desktop/src/store/working-ids-stored-id.test.ts new file mode 100644 index 0000000000..f302385a44 --- /dev/null +++ b/apps/desktop/src/store/working-ids-stored-id.test.ts @@ -0,0 +1,32 @@ +import { afterEach, describe, expect, it } from 'vitest' + +import { createClientSessionState } from '@/lib/chat-runtime' +import { $workingSessionIds, clearAllSessionStates, publishSessionState } from '@/store/session-states' + +/** + * (C) The sidebar spinner reads `$workingSessionIds`, which projects + * `$sessionStates` down to STORED session ids and drops any entry whose + * `storedSessionId` is null. `message.start` flips `busy` without carrying a + * stored id, so a runtime that was never seeded with one goes busy invisibly: + * the backend works, the thread name stays bare. + */ +describe('$workingSessionIds — a busy runtime with no stored id', () => { + afterEach(() => { + clearAllSessionStates() + }) + + it('cannot show a spinner for a busy runtime that has no stored id', () => { + publishSessionState('runtime-unmapped', { ...createClientSessionState(null), busy: true }) + + // Documents the constraint rather than asserting the bug is fine: the + // projection is keyed by stored id, so an unmapped runtime is unreachable + // from the sidebar no matter how busy it is. + expect($workingSessionIds.get()).toEqual([]) + }) + + it('shows the spinner as soon as the stored id is known', () => { + publishSessionState('runtime-mapped', { ...createClientSessionState('stored-x'), busy: true }) + + expect($workingSessionIds.get()).toEqual(['stored-x']) + }) +}) diff --git a/apps/desktop/src/types/hermes.ts b/apps/desktop/src/types/hermes.ts index 669813b0ab..8857bca432 100644 --- a/apps/desktop/src/types/hermes.ts +++ b/apps/desktop/src/types/hermes.ts @@ -523,6 +523,9 @@ export interface SessionResumeResponse { } inflight?: null | { assistant?: string + /** Mid-turn redirect corrections, oldest first. The turn's original prompt + * stays in `user`; these are the follow-ups typed while it ran. */ + corrections?: string[] /** Retained failed turn: the error the terminal frame carried (the frame * itself may have been lost to a disconnect). */ error?: string diff --git a/apps/desktop/vite.config.ts b/apps/desktop/vite.config.ts index 2b0685c9a0..4a58133b8b 100644 --- a/apps/desktop/vite.config.ts +++ b/apps/desktop/vite.config.ts @@ -25,7 +25,18 @@ const fsAllow = [ ) ] -export default defineConfig({ +// The dev-only render/state churn counters (src/debug) must be imported +// STATICALLY above react-dom — react-dom captures the devtools hook at module +// init, so a dynamic import lands too late and observes zero commits. A static +// side-effect import can't be tree-shaken, so instead the whole graph is +// aliased out of any non-dev build. `command === 'serve'` covers `vite dev`; +// the perf harness opts a production build back in with VITE_PERF_PROBE=1. +const debugEntry = (command: string, env: Record) => + command === 'serve' || env.VITE_PERF_PROBE === '1' + ? path.resolve(__dirname, './src/debug/dev-only.ts') + : path.resolve(__dirname, './src/debug/dev-only.noop.ts') + +export default defineConfig(({ command }) => ({ base: './', plugins: [react(), tailwindcss()], css: { @@ -57,6 +68,7 @@ export default defineConfig({ }, resolve: { alias: { + '@/debug/dev-only': debugEntry(command, process.env as Record), '@': path.resolve(__dirname, './src'), '@hermes/plugin-sdk': path.resolve(__dirname, './src/sdk/index.ts'), '@hermes/shared/billing': path.resolve(__dirname, '../shared/src/billing-types.ts'), @@ -80,4 +92,4 @@ export default defineConfig({ host: '127.0.0.1', port: 4174 } -}) +})) diff --git a/apps/shared/src/billing-payment-method.test-d.ts b/apps/shared/src/billing-payment-method.test-d.ts new file mode 100644 index 0000000000..7d2de8dba9 --- /dev/null +++ b/apps/shared/src/billing-payment-method.test-d.ts @@ -0,0 +1,24 @@ +/** + * Compile-time guard for BillingPaymentMethod. + * + * There is nothing to run here — the point is that `tsc` accepts this file. + * An earlier revision typed the fallback arm's `kind` as `string & {}`, which + * makes the discriminant non-literal and silently defeats narrowing for every + * arm: the `pm.brand` read below stops compiling. Keeping this file honest + * keeps `kind` narrowable. + */ + +import type { BillingPaymentMethod } from './billing-types' + +export function describePaymentMethod(pm: BillingPaymentMethod): string { + switch (pm.kind) { + case 'card': + return pm.wallet ? `${pm.wallet} ${pm.brand} ${pm.last4}` : `${pm.brand} ${pm.last4}` + + case 'link': + return pm.email ?? 'Link' + + case 'unknown': + return pm.raw_kind + } +} diff --git a/apps/shared/src/billing-types.ts b/apps/shared/src/billing-types.ts index 9a7801c223..21b356e2f7 100644 --- a/apps/shared/src/billing-types.ts +++ b/apps/shared/src/billing-types.ts @@ -122,6 +122,47 @@ export interface BillingCardInfo { resolved_via?: null | string } +/** + * The org's payment method on file. + * + * This is the authoritative field. `card` is a lossy older view of the same + * thing: it is populated only when the method is a card, and is null for + * every other kind — so `!card` does NOT mean "no payment method on file". + * A surface that gates on `card` alone will tell a Link customer they have + * nothing on file. + * + * Older gateways omit this field entirely, so absence means "this gateway + * didn't say", not "nothing on file". + * + * A kind this client predates arrives as `unknown` rather than as its real + * name, which keeps `kind` narrowable — every arm is a literal, so + * `if (pm.kind === 'card')` gives you the card fields. (The `string & {}` + * trick used by BillingRefusalCode does not work here: on an object union it + * makes the discriminant non-literal and defeats narrowing for every arm.) + */ +export type BillingPaymentMethod = + | { + kind: 'card' + brand: string + last4: string + /** Wallet that wrapped the card (e.g. "apple_pay", "google_pay"), if any. */ + wallet: string | null + /** Card-resolution rung ("subPin" | "customerDefault" | "autoRefill") or null. */ + resolved_via: null | string + } + | { + kind: 'link' + /** Link displays as the account email; can be absent on the Stripe side. */ + email: null | string + resolved_via: null | string + } + | { + kind: 'unknown' + /** What the server actually called it, for logs and neutral copy. */ + raw_kind: string + resolved_via: null | string + } + export interface BillingMonthlyCap { is_default_ceiling: boolean limit_display: string @@ -159,6 +200,9 @@ export interface BillingStateResponse { can_change_plan?: boolean can_charge: boolean card: BillingCardInfo | null + // Typed payment-method union (newer gateways only); `card` remains the + // compatibility field and stays populated for kind "card". + payment_method?: BillingPaymentMethod | null charge_presets: string[] charge_presets_display: string[] cli_billing_enabled: boolean diff --git a/apps/shared/src/index.ts b/apps/shared/src/index.ts index 09e10e4005..21c40a716d 100644 --- a/apps/shared/src/index.ts +++ b/apps/shared/src/index.ts @@ -13,6 +13,7 @@ export type { BillingErrorPayload, BillingMonthlyCap, BillingMutationResponse, + BillingPaymentMethod, BillingRefusalCode, BillingStateResponse, ChargeFailureReason, diff --git a/cli-config.yaml.example b/cli-config.yaml.example index 5e78fdd8f4..163c850667 100644 --- a/cli-config.yaml.example +++ b/cli-config.yaml.example @@ -778,10 +778,10 @@ skills: # Agent Behavior # ============================================================================= agent: - # Maximum tool-calling iterations per conversation + # Maximum tool-calling iterations per conversation (default: 500) # Higher = more room for complex tasks, but costs more tokens # Recommended: 20-30 for focused tasks, 50-100 for open exploration - max_turns: 60 + max_turns: 500 # Inactivity timeout for gateway agent runs (seconds, 0 = unlimited). # The agent can run indefinitely when actively calling tools or receiving diff --git a/cli.py b/cli.py index 1d44f861a0..97a32cfeaa 100644 --- a/cli.py +++ b/cli.py @@ -471,7 +471,7 @@ def load_cli_config() -> Dict[str, Any]: "min_tail_user_messages": 1, # Real user messages guaranteed in the tail (1 = existing single anchor) }, "agent": { - "max_turns": 90, # Default max tool-calling iterations (shared with subagents) + "max_turns": 500, # Default max tool-calling iterations (shared with subagents) "verbose": False, "system_prompt": "", "prefill_messages_file": "", @@ -4098,7 +4098,7 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): provider: Inference provider ("auto", "openrouter", "nous", "openai-codex", "zai", "kimi-coding", "minimax", "minimax-cn") api_key: API key (default: from environment) base_url: API base URL (default: OpenRouter) - max_turns: Maximum tool-calling iterations shared with subagents (default: 90) + max_turns: Maximum tool-calling iterations shared with subagents (default: 500) verbose: Enable verbose logging compact: Use compact display mode resume: Session ID to resume (restores conversation history from SQLite) @@ -4112,6 +4112,25 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): # YAML 1.1 parses bare `off` as boolean False — normalise to string. _raw_tp = CLI_CONFIG["display"].get("tool_progress", "all") self.tool_progress_mode = "off" if _raw_tp is False else str(_raw_tp) + # focus_view: display-only reduced-output mode (/focus). When on, the + # tool-progress mode is snapped to "off" so the EXISTING suppression + # path hides per-tool lines, and the pre-focus mode is stashed so + # /focus off restores it. Purely cosmetic — never changes what is sent + # to the model. See hermes_cli/focus_view.py. + self._focus_view_enabled = bool(CLI_CONFIG["display"].get("focus_view", False)) + self._focus_saved_tool_progress = None + self._focus_hidden_lines = 0 + self._focus_last_counted_tool = None + if self._focus_view_enabled: + from hermes_cli.focus_view import ( + FOCUS_TOOL_PROGRESS_MODE, + normalize_tool_progress_mode, + ) + + self._focus_saved_tool_progress = normalize_tool_progress_mode( + self.tool_progress_mode + ) + self.tool_progress_mode = FOCUS_TOOL_PROGRESS_MODE # resume_display: "full" (show history) | "minimal" (one-liner only) self.resume_display = CLI_CONFIG["display"].get("resume_display", "full") # bell_on_complete: play terminal bell (\a) when agent finishes a response @@ -4157,6 +4176,22 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): # Inline diff previews for write actions (display.inline_diffs in config.yaml) self._inline_diffs_enabled = CLI_CONFIG["display"].get("inline_diffs", True) + # Per-turn accounting (display.turn_summary / display.spinner_token_flow). + # Both are CLI-only, display-only chrome. The collector rides the + # tool-progress feed this class already receives, so no agent-loop + # bookkeeping is involved. + self._turn_summary_enabled = bool(CLI_CONFIG["display"].get("turn_summary", True)) + self._spinner_token_flow_enabled = bool( + CLI_CONFIG["display"].get("spinner_token_flow", True) + ) + self._turn_summary_collector = None + self._turn_summary_start = 0.0 + self._turn_token_baseline = 0 + # True only while an interactive (run()-loop) turn is in flight. Single + # query, -Q, and gateway paths never set it, which is what keeps the + # summary line out of non-interactive surfaces. + self._interactive_turn = False + # Submitted multiline user-message preview (display.user_message_preview in config.yaml) _ump = CLI_CONFIG["display"].get("user_message_preview", {}) if not isinstance(_ump, dict): @@ -4271,9 +4306,9 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): try: self.max_turns = int(os.getenv("HERMES_MAX_ITERATIONS", "")) except (TypeError, ValueError): - self.max_turns = 90 + self.max_turns = 500 else: - self.max_turns = 90 + self.max_turns = 500 # Parse and validate toolsets self.enabled_toolsets = toolsets @@ -4459,6 +4494,7 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): self._clarify_state = None self._clarify_freetext = False self._clarify_deadline = 0 + self._clarify_multi_base = None self._sudo_state = None self._sudo_deadline = 0 self._modal_input_snapshot = None @@ -5073,8 +5109,20 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): "active_background_subagents": 0, "battery_label": "", "battery_category": "dim", + # Focus view badge (/focus). Persistent indicator so the reduced + # output mode is never invisible. Display-only. + "focus_label": "", } + try: + from hermes_cli.focus_view import focus_statusbar_segment + + snapshot["focus_label"] = focus_statusbar_segment( + bool(getattr(self, "_focus_view_enabled", False)) + ) + except Exception: + pass + # Battery read-out (first status-bar element when enabled). Reads are # memoised for a few seconds inside agent.battery, so polling it on # every status-bar repaint is cheap. @@ -5120,6 +5168,23 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): except Exception: pass + # Standing /goal state (Ralph loop). GoalManager is cached on self and + # keeps its state in memory, so this is a cheap attribute read — no DB + # hit per repaint. Only an *active* goal earns a segment; paused/done + # goals stay out of the bar (matching the desktop's active-first row). + snapshot["goal_active"] = False + snapshot["goal_turns_used"] = 0 + snapshot["goal_max_turns"] = 0 + try: + goal_mgr = self._get_goal_manager() + if goal_mgr is not None and goal_mgr.is_active(): + goal_state = goal_mgr.state + snapshot["goal_active"] = True + snapshot["goal_turns_used"] = int(getattr(goal_state, "turns_used", 0) or 0) + snapshot["goal_max_turns"] = int(getattr(goal_state, "max_turns", 0) or 0) + except Exception: + pass + if not agent: return snapshot @@ -5276,6 +5341,7 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): txt = getattr(self, "_spinner_text", "") if not txt: return "" + flow = self._spinner_token_flow() t0 = getattr(self, "_tool_start_time", 0) or 0 if t0 > 0: elapsed = time.monotonic() - t0 @@ -5287,9 +5353,100 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): else: # Keep width stable before the 60s rollover as well. elapsed_str = f"{elapsed:5.1f}s" + if flow: + return f" {txt} ({elapsed_str} · {flow})" return f" {txt} ({elapsed_str})" + if flow: + return f" {txt} ({flow})" return f" {txt}" + # ── Per-turn accounting (display.turn_summary / spinner_token_flow) ── + # + # Both features are CLI-only chrome. The tally is observed from the + # tool-progress callback this class already receives on every tool call, + # so nothing is threaded through the agent loop. Token flow reads the + # agent's cumulative session counters (bumped per API call in + # agent/conversation_loop.py) and subtracts a per-turn baseline. + + def _spinner_token_flow(self) -> str: + """Cumulative output tokens for the running turn, for the spinner.""" + if not getattr(self, "_spinner_token_flow_enabled", False): + return "" + if not getattr(self, "_agent_running", False): + return "" + agent = getattr(self, "agent", None) + if agent is None: + return "" + try: + from agent.turn_summary import format_token_flow + + produced = (getattr(agent, "session_output_tokens", 0) or 0) - ( + getattr(self, "_turn_token_baseline", 0) or 0 + ) + return format_token_flow(produced) + except Exception: + return "" + + def _turn_summary_is_active(self) -> bool: + """Whether the per-turn summary line should render for this surface. + + Gated off for: the config key, quiet/tool-progress-off mode, and any + non-interactive path (single query, ``-Q``, gateway/messaging) — those + surfaces either want machine-readable output or carry their own footer. + """ + if not getattr(self, "_turn_summary_enabled", False): + return False + if getattr(self, "tool_progress_mode", "all") == "off": + return False + agent = getattr(self, "agent", None) + if agent is not None and getattr(agent, "quiet_mode", False): + return False + if not getattr(self, "_interactive_turn", False): + return False + return True + + def _turn_summary_begin(self) -> None: + """Start per-turn accounting for the turn that is about to run.""" + try: + from agent.turn_summary import TurnSummaryCollector + + collector = getattr(self, "_turn_summary_collector", None) + if collector is None: + collector = TurnSummaryCollector() + self._turn_summary_collector = collector + collector.begin() + self._turn_summary_start = time.monotonic() + agent = getattr(self, "agent", None) + self._turn_token_baseline = ( + getattr(agent, "session_output_tokens", 0) or 0 + ) if agent is not None else 0 + except Exception: + self._turn_summary_collector = None + + def _turn_summary_record(self, function_name, result, is_error: bool) -> None: + """Feed one completed tool call into the active tally.""" + collector = getattr(self, "_turn_summary_collector", None) + if collector is None: + return + try: + collector.record_tool(function_name, result=result, is_error=bool(is_error)) + except Exception: + pass + + def _turn_summary_emit(self) -> None: + """Print the post-turn accounting line, when enabled for this surface.""" + collector = getattr(self, "_turn_summary_collector", None) + if collector is None or not self._turn_summary_is_active(): + return + try: + started = getattr(self, "_turn_summary_start", 0.0) or 0.0 + elapsed = max(0.0, time.monotonic() - started) if started else 0.0 + line = collector.render(elapsed) + if line: + _cprint(f" {_DIM}{line}{_RST}") + except Exception: + logger.debug("Turn summary render failed", exc_info=True) + # ── Petdex mascot (base-CLI pet pane) ─────────────────────────────── # # Parity with the TUI: a half-block sprite rendered as a prompt_toolkit @@ -5562,6 +5719,21 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): cont = " | Continuous" if self._voice_continuous else "" return [("class:voice-status", f" 🎤 Voice mode{tts}{cont} — {label} to record ")] + @staticmethod + def _status_bar_goal_segment(snapshot: Dict[str, Any]) -> str: + """Return the ``⊙ goal 3/20`` segment, or ``""`` when no goal is active. + + Active-goal-only by design: paused/done goals don't occupy status-bar + real estate (they already print their own glyph lines in the thread). + """ + if not snapshot.get("goal_active"): + return "" + used = snapshot.get("goal_turns_used") or 0 + max_turns = snapshot.get("goal_max_turns") or 0 + if max_turns: + return f"⊙ goal {used}/{max_turns}" + return "⊙ goal" + def _build_status_bar_text(self, width: Optional[int] = None) -> str: """Return a compact one-line session status string for the TUI footer.""" try: @@ -5573,10 +5745,16 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): duration_label = snapshot["duration"] battery_label = snapshot.get("battery_label") or "" battery_prefix = f"{battery_label} │ " if battery_label else "" + focus_label = snapshot.get("focus_label") or "" yolo_active = self._is_session_yolo_active() + goal_segment = self._status_bar_goal_segment(snapshot) if width < 52: text = f"{battery_prefix}⚕ {snapshot['model_short']} · {duration_label}" + if goal_segment: + text += f" · {goal_segment}" + if focus_label: + text += f" · {focus_label}" if yolo_active: text += " · ⚠ YOLO" return self._trim_status_bar_text(text, width) @@ -5596,7 +5774,11 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): bg_subagent_count = snapshot.get("active_background_subagents", 0) if bg_subagent_count: parts.append(f"⛓ {bg_subagent_count}") + if goal_segment: + parts.append(goal_segment) parts.append(duration_label) + if focus_label: + parts.append(focus_label) if yolo_active: parts.append("⚠ YOLO") return self._trim_status_bar_text(" · ".join(parts), width) @@ -5623,6 +5805,8 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): bg_subagent_count = snapshot.get("active_background_subagents", 0) if bg_subagent_count: parts.append(f"⛓ {bg_subagent_count}") + if goal_segment: + parts.append(goal_segment) parts.append(duration_label) prompt_elapsed = snapshot.get("prompt_elapsed") if prompt_elapsed: @@ -5630,6 +5814,8 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): idle_since = snapshot.get("idle_since") if idle_since: parts.append(idle_since) + if focus_label: + parts.append(focus_label) if yolo_active: parts.append("⚠ YOLO") return self._trim_status_bar_text(" │ ".join(parts), width) @@ -5649,8 +5835,10 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): width = self._get_tui_terminal_width() duration_label = snapshot["duration"] yolo_active = self._is_session_yolo_active() + goal_segment = self._status_bar_goal_segment(snapshot) battery_label = snapshot.get("battery_label") or "" battery_style = self._battery_status_style(snapshot.get("battery_category", "dim")) + focus_label = snapshot.get("focus_label") or "" if width < 52: frags = [ @@ -5659,6 +5847,12 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): ("class:status-bar-dim", " · "), ("class:status-bar-dim", duration_label), ] + if goal_segment: + frags.append(("class:status-bar-dim", " · ")) + frags.append(("class:status-bar-strong", goal_segment)) + if focus_label: + frags.append(("class:status-bar-dim", " · ")) + frags.append(("class:status-bar-strong", focus_label)) if yolo_active: frags.append(("class:status-bar-dim", " · ")) frags.append(("class:status-bar-yolo", "⚠ YOLO")) @@ -5689,10 +5883,16 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): if bg_subagent_count: frags.append(("class:status-bar-dim", " · ")) frags.append(("class:status-bar-strong", f"⛓ {bg_subagent_count}")) + if goal_segment: + frags.append(("class:status-bar-dim", " · ")) + frags.append(("class:status-bar-strong", goal_segment)) frags.extend([ ("class:status-bar-dim", " · "), ("class:status-bar-dim", duration_label), ]) + if focus_label: + frags.append(("class:status-bar-dim", " · ")) + frags.append(("class:status-bar-strong", focus_label)) if yolo_active: frags.append(("class:status-bar-dim", " · ")) frags.append(("class:status-bar-yolo", "⚠ YOLO")) @@ -5732,6 +5932,9 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): if bg_subagent_count: frags.append(("class:status-bar-dim", " │ ")) frags.append(("class:status-bar-strong", f"⛓ {bg_subagent_count}")) + if goal_segment: + frags.append(("class:status-bar-dim", " │ ")) + frags.append(("class:status-bar-strong", goal_segment)) frags.extend([ ("class:status-bar-dim", " │ "), ("class:status-bar-dim", duration_label), @@ -5746,6 +5949,11 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): if idle_since: frags.append(("class:status-bar-dim", " │ ")) frags.append(("class:status-bar-dim", idle_since)) + # Persistent focus-view badge — so the reduced-output mode + # is never invisible (mirrors the YOLO badge convention). + if focus_label: + frags.append(("class:status-bar-dim", " │ ")) + frags.append(("class:status-bar-strong", focus_label)) if yolo_active: frags.append(("class:status-bar-dim", " │ ")) frags.append(("class:status-bar-yolo", "⚠ YOLO")) @@ -7823,7 +8031,6 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): return True - def save_conversation(self): """Save the current conversation to a JSON snapshot under ~/.hermes/sessions/saved/. @@ -9469,12 +9676,16 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): self._handle_skills_command(cmd_original) elif canonical == "learn": self._handle_learn_command(cmd_original) + elif canonical == "init": + self._handle_init_command(cmd_original) elif canonical == "memory": self._handle_memory_command(cmd_original) elif canonical == "platforms": self._show_gateway_status() elif canonical == "status": self._show_session_status() + elif canonical == "context": + self._show_context_breakdown(cmd_original) elif canonical == "egress": from hermes_cli.proxy_cli import format_status_text @@ -9483,12 +9694,16 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): self._status_bar_visible = not self._status_bar_visible state = "visible" if self._status_bar_visible else "hidden" self._console_print(f" Status bar {state}") + elif canonical == "diff": + self._handle_diff_command(cmd_original) elif canonical == "battery": self._handle_battery_command(cmd_original) elif canonical == "timestamps": self._handle_timestamps_command(cmd_original) elif canonical == "verbose": self._toggle_verbose() + elif canonical == "focus": + self._handle_focus_command(cmd_original) elif canonical == "footer": self._handle_footer_command(cmd_original) elif canonical == "yolo": @@ -10147,6 +10362,22 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): idx = 2 # default to "all" self.tool_progress_mode = cycle[(idx + 1) % len(cycle)] + # /verbose is the explicit tool-progress control, so cycling it takes + # ownership of the mode back from focus view. Leaving _focus_view_enabled + # set would show a "focus" status-bar badge and hidden-line counts while + # tool lines were visibly printing. Display-only state change. + if getattr(self, "_focus_view_enabled", False): + self._focus_view_enabled = False + self._focus_saved_tool_progress = None + self._focus_hidden_lines = 0 + self._focus_last_counted_tool = None + try: + from hermes_cli.focus_view import FOCUS_CONFIG_KEY + + save_config_value(FOCUS_CONFIG_KEY, False) + except Exception: + pass + if self.agent: self.agent.reasoning_callback = self._current_reasoning_callback() # Keep the live agent's tool_progress_mode in sync so the @@ -10546,6 +10777,55 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): return print(f" {result.message}") + def _show_context_breakdown(self, cmd_original: str = ""): + """`/context [all]` — visual context-window usage breakdown. + + Renders a 5×20 glyph block grid (each cell ≈ 1% of the model context + window) plus an estimated per-category table: system prompt, tool + definitions, rules, skills index, MCP, subagents, memory, and the + conversation itself — versus free space. `/context all` appends the + expanded per-skill and per-toolset cost listings. + + Read-only: same chars/4 estimation engine as the desktop context + popover (agent.context_breakdown) — no provider calls, no prompt-cache + impact. + """ + if not self.agent: + print(" (._.) No active agent -- send a message first.") + return + + args = cmd_original.split(maxsplit=1)[1].strip().lower() if " " in cmd_original else "" + expanded = args in {"all", "full", "details"} + + from agent.context_breakdown import ( + compute_context_details, + compute_session_context_breakdown, + render_context_breakdown_lines, + ) + + try: + payload = compute_session_context_breakdown( + self.agent, self.conversation_history + ) + except Exception as e: + print(f" (._.) Could not compute context breakdown: {e}") + return + + details = None + if expanded: + try: + details = compute_context_details(self.agent) + except Exception: + details = {"skills": [], "toolsets": []} + + model = payload.get("model") or self.model + print() + print(f" 🧠 Context Usage — {model}") + print() + for line in render_context_breakdown_lines(payload, details=details, grid=True): + print(f" {line}") + print() + def _show_usage(self): """Rate limits + session token usage (when a live agent exists) + Nous credits. @@ -11256,6 +11536,20 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): if event_type == "tool.completed": self._tool_start_time = 0.0 + # Per-turn accounting: this feed already sees every tool call with + # its result, so the summary line needs no agent-loop state. + self._turn_summary_record( + function_name, kwargs.get("result"), kwargs.get("is_error", False) + ) + # Focus view: count the scrollback line we are NOT printing, so the + # post-turn recovery line can report how much was hidden. Counted + # against the pre-focus tool-progress mode, so a user who already + # had /verbose off is never told focus hid something it didn't. + if getattr(self, "_focus_view_enabled", False): + try: + self._note_focus_hidden_line(function_name or "") + except Exception: + pass # Print stacked scrollback line for "new" / "all" / "verbose" modes. # "verbose" was previously omitted here, so non-streaming model # calls (MoA aggregator, copilot-acp) rendered each tool only into @@ -11900,7 +12194,7 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): outcome = outcome[:119] + "…" _cprint(f"\n{_DIM}{icon} {label}: {detail} → {outcome}{_RST}") - def _clarify_callback(self, question, choices): + def _clarify_callback(self, question, choices, multi_select=False): """ Platform callback for the clarify tool. Called from the agent thread. @@ -11908,6 +12202,9 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): questions), then blocks until the user responds via the prompt_toolkit key bindings. If no response arrives within the configured timeout the question is dismissed and the agent is told to decide on its own. + + When ``multi_select`` is True, shows checkboxes and the user can + select multiple options with Space, confirming with Enter. """ import time as _time @@ -11918,16 +12215,22 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): timeout = resolve_clarify_timeout(CLI_CONFIG) response_queue = queue.Queue() is_open_ended = not choices + # multi-select support: only active when multi_select is True and choices exist + effective_multi = multi_select and not is_open_ended self._clarify_state = { "question": question, "choices": choices if not is_open_ended else [], "selected": 0, + # multi-select support + "multi_select": effective_multi, + "selected_indices": set() if effective_multi else None, "response_queue": response_queue, } self._clarify_deadline = None if timeout <= 0 else _time.monotonic() + timeout # Open-ended questions skip straight to freetext input self._clarify_freetext = is_open_ended + self._clarify_multi_base = None # Trigger an immediate prompt_toolkit repaint from this (non-main) # thread. Modal prompts must paint at once and must not be gated by the @@ -11960,6 +12263,7 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): self._clarify_state = None self._clarify_freetext = False self._clarify_deadline = None + self._clarify_multi_base = None self._paint_now() _cprint(f"\n{_DIM}(clarify timed out after {timeout}s — agent will decide){_RST}") return ( @@ -12382,6 +12686,7 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): pass self._clarify_state = None self._clarify_freetext = False + self._clarify_multi_base = None if self._sudo_state: try: self._sudo_state["response_queue"].put("") @@ -13126,6 +13431,15 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): pass + # Focus view: dim recovery line reporting what was hidden this turn + # (and how to reveal it). Printed after the response so the turn + # reads prompt → answer → "⋯ N tool lines hidden". Display-only; + # resets the counter for the next turn. + try: + self._emit_focus_recovery_line() + except Exception: + pass + # Play terminal bell when agent finishes (if enabled). # Works over SSH — the bell propagates to the user's terminal. if self.bell_on_complete: @@ -13135,8 +13449,8 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): # Notify when iteration budget was hit if result and not result.get("completed") and not result.get("interrupted"): _api_calls = result.get("api_calls", 0) - if _api_calls >= getattr(self.agent, "max_iterations", 90): - _max_iter = getattr(self.agent, "max_iterations", 90) + if _api_calls >= getattr(self.agent, "max_iterations", 500): + _max_iter = getattr(self.agent, "max_iterations", 500) _cprint( f"\n{_DIM}⚠ Iteration budget reached " f"({_api_calls}/{_max_iter}) — " @@ -13931,6 +14245,11 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): if self._clarify_freetext and self._clarify_state: text = event.app.current_buffer.text.strip() if text: + # multi-select: prepend previously checked real choices + base = getattr(self, '_clarify_multi_base', None) + if base: + text = ", ".join(base) + ", " + text + self._clarify_multi_base = None self._clarify_state["response_queue"].put(text) self._clarify_state = None self._clarify_freetext = False @@ -13943,6 +14262,35 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): state = self._clarify_state selected = state["selected"] choices = state.get("choices") or [] + # multi-select support: submit comma-joined list of checked choices + if state.get("multi_select"): + indices = state.get("selected_indices") + if not indices: + # Nothing checked → submit empty string (parses to []) + state["response_queue"].put("") + self._clarify_state = None + event.app.invalidate() + return + sorted_idx = sorted(indices) + selected_choices = [choices[i] for i in sorted_idx if i < len(choices)] + other_checked = len(choices) in sorted_idx + if other_checked and selected_choices: + # "Other" + real choices: store base choices, switch to freetext + # so the user can type a custom answer that gets appended + self._clarify_multi_base = selected_choices + self._clarify_freetext = True + event.app.invalidate() + return + if selected_choices: + state["response_queue"].put(", ".join(selected_choices)) + self._clarify_state = None + event.app.invalidate() + return + # Only "Other" was checked → switch to freetext + self._clarify_freetext = True + event.app.invalidate() + return + # Original single-select behavior: submit the highlighted choice if selected < len(choices): state["response_queue"].put(choices[selected]) self._clarify_state = None @@ -14177,11 +14525,42 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): self._clarify_state["selected"] = min(max_idx, self._clarify_state["selected"] + 1) event.app.invalidate() + # multi-select support: Space toggles the checkbox at the current cursor position + @kb.add('space', filter=Condition(lambda: bool(self._clarify_state) and not self._clarify_freetext and self._clarify_state.get("multi_select"))) + def clarify_toggle(event): + if self._clarify_state: + selected = self._clarify_state["selected"] + indices = self._clarify_state.get("selected_indices", set()) + if selected in indices: + indices.discard(selected) + else: + indices.add(selected) + event.app.invalidate() + # Number keys for quick clarify selection (1-9, 0 for 10th item) def _make_clarify_number_handler(idx): def handler(event): if self._clarify_state and not self._clarify_freetext: choices = self._clarify_state.get("choices") or [] + # multi-select support: number keys toggle checkboxes instead of submitting + if self._clarify_state.get("multi_select"): + if idx < len(choices): + indices = self._clarify_state.get("selected_indices", set()) + if idx in indices: + indices.discard(idx) + else: + indices.add(idx) + event.app.invalidate() + elif idx == len(choices): + # Toggle "Other" in multi-select mode + indices = self._clarify_state.get("selected_indices", set()) + if idx in indices: + indices.discard(idx) + else: + indices.add(idx) + event.app.invalidate() + return + # Original single-select: number keys submit directly # Map index to choice (treating "Other" as the last option) if idx < len(choices): # Select a numbered choice @@ -15074,6 +15453,9 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): question = state["question"] choices = state.get("choices") or [] selected = state.get("selected", 0) + # multi-select support + multi_select = state.get("multi_select", False) + selected_indices = state.get("selected_indices", set()) if multi_select else set() preview_lines = _wrap_panel_text(question, 60) for i, choice in enumerate(choices): # Show number prefix for quick selection (1-9 for items 1-9, 0 for 10th item) @@ -15083,7 +15465,13 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): num_prefix = '0' else: num_prefix = ' ' - if i == selected and not cli_ref._clarify_freetext: + if multi_select: + cb = "[x]" if i in selected_indices else "[ ]" + if i == selected and not cli_ref._clarify_freetext: + prefix = f"❯ {cb} {num_prefix}. " + else: + prefix = f" {cb} {num_prefix}. " + elif i == selected and not cli_ref._clarify_freetext: prefix = f"❯ {num_prefix}. " else: prefix = f" {num_prefix}. " @@ -15096,11 +15484,20 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): other_num_prefix = '0' else: other_num_prefix = ' ' - other_label = ( - f"❯ {other_num_prefix}. Other (type below)" if cli_ref._clarify_freetext - else f"❯ {other_num_prefix}. Other (type your answer)" if selected == len(choices) - else f" {other_num_prefix}. Other (type your answer)" - ) + other_idx_val = len(choices) + if multi_select: + cb = "[x]" if other_idx_val in selected_indices else "[ ]" + other_label = ( + f"❯ {cb} {other_num_prefix}. Other (type below)" if cli_ref._clarify_freetext + else f"❯ {cb} {other_num_prefix}. Other (type your answer)" if selected == other_idx_val + else f" {cb} {other_num_prefix}. Other (type your answer)" + ) + else: + other_label = ( + f"❯ {other_num_prefix}. Other (type below)" if cli_ref._clarify_freetext + else f"❯ {other_num_prefix}. Other (type your answer)" if selected == len(choices) + else f" {other_num_prefix}. Other (type your answer)" + ) preview_lines.extend(_wrap_panel_text(other_label, 60, subsequent_indent=" ")) box_width = _panel_box_width("Hermes needs your input", preview_lines) inner_text_width = max(8, box_width - 2) @@ -15116,7 +15513,14 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): num_prefix = '0' else: num_prefix = ' ' - if i == selected and not cli_ref._clarify_freetext: + # multi-select support: add checkbox after cursor indicator + if multi_select: + cb = "[x]" if i in selected_indices else "[ ]" + if i == selected and not cli_ref._clarify_freetext: + prefix = f'❯ {cb} {num_prefix}. ' + else: + prefix = f' {cb} {num_prefix}. ' + elif i == selected and not cli_ref._clarify_freetext: prefix = f'❯ {num_prefix}. ' else: prefix = f' {num_prefix}. ' @@ -15131,12 +15535,22 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): other_num_prefix = '0' else: other_num_prefix = ' ' - if selected == other_idx and not cli_ref._clarify_freetext: - other_label_mand = f'❯ {other_num_prefix}. Other (type your answer)' - elif cli_ref._clarify_freetext: - other_label_mand = f'❯ {other_num_prefix}. Other (type below)' + # multi-select support: add checkbox to Other option + if multi_select: + cb = "[x]" if other_idx in selected_indices else "[ ]" + if selected == other_idx and not cli_ref._clarify_freetext: + other_label_mand = f'❯ {cb} {other_num_prefix}. Other (type your answer)' + elif cli_ref._clarify_freetext: + other_label_mand = f'❯ {cb} {other_num_prefix}. Other (type below)' + else: + other_label_mand = f' {cb} {other_num_prefix}. Other (type your answer)' else: - other_label_mand = f' {other_num_prefix}. Other (type your answer)' + if selected == other_idx and not cli_ref._clarify_freetext: + other_label_mand = f'❯ {other_num_prefix}. Other (type your answer)' + elif cli_ref._clarify_freetext: + other_label_mand = f'❯ {other_num_prefix}. Other (type below)' + else: + other_label_mand = f' {other_num_prefix}. Other (type your answer)' other_wrapped = _wrap_panel_text(other_label_mand, inner_text_width, subsequent_indent=" ") elif cli_ref._clarify_freetext: # Freetext-only mode: the guidance line takes the place of choices. @@ -15801,8 +16215,10 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): # Regular chat - run agent self._agent_running = True + self._interactive_turn = True self._pet_turn_error = False self._pet_reasoning = False + self._turn_summary_begin() app.invalidate() # Refresh status line try: @@ -15815,6 +16231,11 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin, CLIBillingMixin): self._last_scrollback_tool = "" self._pet_reasoning = False self._pet_react_turn_end() + # Post-turn accounting line (display.turn_summary). + # Emitted after the response box, before the prompt + # returns, so it reads as a footer for the turn. + self._turn_summary_emit() + self._interactive_turn = False app.invalidate() # Refresh status line diff --git a/contributors/emails/155588579+spiky02plateau@users.noreply.github.com b/contributors/emails/155588579+spiky02plateau@users.noreply.github.com new file mode 100644 index 0000000000..2a3d91ac41 --- /dev/null +++ b/contributors/emails/155588579+spiky02plateau@users.noreply.github.com @@ -0,0 +1 @@ +spiky02plateau diff --git a/contributors/emails/MaxFreedomPollard@users.noreply.github.com b/contributors/emails/MaxFreedomPollard@users.noreply.github.com new file mode 100644 index 0000000000..e7c920af9f --- /dev/null +++ b/contributors/emails/MaxFreedomPollard@users.noreply.github.com @@ -0,0 +1 @@ +MaxFreedomPollard diff --git a/contributors/emails/a.neyman17@gmail.com b/contributors/emails/a.neyman17@gmail.com new file mode 100644 index 0000000000..1f4c332c51 --- /dev/null +++ b/contributors/emails/a.neyman17@gmail.com @@ -0,0 +1 @@ +aneym diff --git a/contributors/emails/emopilot@163.com b/contributors/emails/emopilot@163.com new file mode 100644 index 0000000000..4384fa4a17 --- /dev/null +++ b/contributors/emails/emopilot@163.com @@ -0,0 +1 @@ +ljsdut diff --git a/contributors/emails/ghislain.lemeur@gmail.com b/contributors/emails/ghislain.lemeur@gmail.com new file mode 100644 index 0000000000..adf3224bff --- /dev/null +++ b/contributors/emails/ghislain.lemeur@gmail.com @@ -0,0 +1 @@ +gigi206 diff --git a/contributors/emails/hereicq@users.noreply.github.com b/contributors/emails/hereicq@users.noreply.github.com new file mode 100644 index 0000000000..e2eb89a005 --- /dev/null +++ b/contributors/emails/hereicq@users.noreply.github.com @@ -0,0 +1 @@ +hereicq diff --git a/contributors/emails/kevinbanjo@gmail.com b/contributors/emails/kevinbanjo@gmail.com new file mode 100644 index 0000000000..03b2d0e7b1 --- /dev/null +++ b/contributors/emails/kevinbanjo@gmail.com @@ -0,0 +1 @@ +vigilancetech-com diff --git a/contributors/emails/linux2011@qq.com b/contributors/emails/linux2011@qq.com new file mode 100644 index 0000000000..b02c7780ef --- /dev/null +++ b/contributors/emails/linux2011@qq.com @@ -0,0 +1 @@ +Linux2010 diff --git a/contributors/emails/menhguin@users.noreply.github.com b/contributors/emails/menhguin@users.noreply.github.com new file mode 100644 index 0000000000..e85d851e9c --- /dev/null +++ b/contributors/emails/menhguin@users.noreply.github.com @@ -0,0 +1 @@ +menhguin diff --git a/contributors/emails/necipaksahin056@gmail.com b/contributors/emails/necipaksahin056@gmail.com new file mode 100644 index 0000000000..5aaf06ff92 --- /dev/null +++ b/contributors/emails/necipaksahin056@gmail.com @@ -0,0 +1 @@ +xd-Neji diff --git a/contributors/emails/piyushbag4@gmail.com b/contributors/emails/piyushbag4@gmail.com new file mode 100644 index 0000000000..56902f4a2e --- /dev/null +++ b/contributors/emails/piyushbag4@gmail.com @@ -0,0 +1 @@ +piyushbag diff --git a/contributors/emails/robertsryan_21@icloud.com b/contributors/emails/robertsryan_21@icloud.com new file mode 100644 index 0000000000..06b8486d28 --- /dev/null +++ b/contributors/emails/robertsryan_21@icloud.com @@ -0,0 +1 @@ +rhylryan21 diff --git a/contributors/emails/viteballoons@gmail.com b/contributors/emails/viteballoons@gmail.com new file mode 100644 index 0000000000..ed5b634285 --- /dev/null +++ b/contributors/emails/viteballoons@gmail.com @@ -0,0 +1 @@ +paralegalia diff --git a/contributors/emails/will@startupbros.com b/contributors/emails/will@startupbros.com new file mode 100644 index 0000000000..ecfb160e25 --- /dev/null +++ b/contributors/emails/will@startupbros.com @@ -0,0 +1 @@ +StartupBros-com diff --git a/contributors/emails/xiongyue_hnu@163.com b/contributors/emails/xiongyue_hnu@163.com new file mode 100644 index 0000000000..69e7a5f051 --- /dev/null +++ b/contributors/emails/xiongyue_hnu@163.com @@ -0,0 +1 @@ +yuexiongHNU diff --git a/cron/scheduler.py b/cron/scheduler.py index 5bffb00e14..91c3168268 100644 --- a/cron/scheduler.py +++ b/cron/scheduler.py @@ -292,7 +292,9 @@ SILENT_MARKER = "[SILENT]" # a marker is the entire response OR appears as its own first/last line — but # NOT when a token merely appears mid-sentence in a genuine report (e.g. # "I considered staying [SILENT] but here is the summary…" must deliver). -_CRON_SILENCE_TOKENS = frozenset({"[SILENT]", "SILENT", "NO_REPLY", "NO REPLY"}) +# The actual matcher is shared with the webhook lane — +# gateway.response_filters.is_autonomous_silence_response — so the two +# autonomous lanes cannot drift apart. def _is_cron_silence_response(text: str) -> bool: @@ -303,31 +305,13 @@ def _is_cron_silence_response(text: str) -> bool: variants the model emits when it drops the brackets (#51438, #46917). Whitespace-trimmed and case-insensitive. A token buried mid-sentence is treated as real content and delivered. + + Delegates to the shared autonomous-lane matcher in + :mod:`gateway.response_filters` (also used by the webhook adapter). """ - if not isinstance(text, str): - return False - stripped = text.strip() - if not stripped: - return False + from gateway.response_filters import is_autonomous_silence_response - def _is_token(line: str) -> bool: - return " ".join(line.strip().upper().split()) in _CRON_SILENCE_TOKENS - - # Whole response is exactly a token. - if _is_token(stripped): - return True - # Marker on its own first or last line (trailing/leading note on a - # separate line — e.g. "2 deals filtered\n\n[SILENT]"). - lines = [ln for ln in stripped.splitlines() if ln.strip()] - if lines and (_is_token(lines[0]) or _is_token(lines[-1])): - return True - # Bracketed sentinel used as a same-line prefix — the documented cron - # pattern "[SILENT] No changes detected". Restricted to the bracketed - # form so a bare word like "Silent retry succeeded" is NOT swallowed. - upper = stripped.upper() - if upper.startswith("[SILENT]"): - return True - return False + return is_autonomous_silence_response(text) # --------------------------------------------------------------------------- # Persistent thread pool for parallel cron jobs. @@ -3254,7 +3238,7 @@ def run_job( prefill_messages = None # Max iterations - max_iterations = _cfg.get("agent", {}).get("max_turns") or _cfg.get("max_turns") or 90 + max_iterations = _cfg.get("agent", {}).get("max_turns") or _cfg.get("max_turns") or 500 # Provider routing pr = _cfg.get("provider_routing") or {} diff --git a/gateway/authz_mixin.py b/gateway/authz_mixin.py index 45f7f32cf2..be57b3f03e 100644 --- a/gateway/authz_mixin.py +++ b/gateway/authz_mixin.py @@ -78,6 +78,16 @@ class GatewayAuthorizationMixin: return None profile_name = (profile or "").strip() or None if profile_name and profile_name != "default": + active_profile = None + active_profile_fn = getattr(self, "_active_profile_name", None) + if callable(active_profile_fn): + try: + active_profile = active_profile_fn() + except Exception: + active_profile = None + if profile_name == active_profile: + adapters = getattr(self, "adapters", None) or {} + return adapters.get(platform) profile_adapters = getattr(self, "_profile_adapters", None) or {} if profile_name in profile_adapters: return profile_adapters[profile_name].get(platform) diff --git a/gateway/kanban_watchers.py b/gateway/kanban_watchers.py index 50e44f9803..2f5137a8a8 100644 --- a/gateway/kanban_watchers.py +++ b/gateway/kanban_watchers.py @@ -164,7 +164,7 @@ class GatewayKanbanWatchersMixin: # "status" covers dashboard drag-drop and `_set_status_direct()` # writes — surface those transitions to subscribers too. - TERMINAL_KINDS = ("completed", "blocked", "gave_up", "crashed", "timed_out", "status", "archived", "unblocked") + TERMINAL_KINDS = ("completed", "blocked", "gave_up", "crashed", "timed_out", "status", "archived", "unblocked", "block_loop_detected") # Subscriptions are removed only when the task reaches a truly final # status (done / archived). We used to also unsub on any terminal # event kind (gave_up / crashed / timed_out / blocked), but that @@ -181,7 +181,13 @@ class GatewayKanbanWatchersMixin: # means the chat is dead (deleted, bot kicked, etc.) — after N # consecutive send failures the sub is dropped so we don't spin # against a dead chat every 5 seconds forever. - MAX_SEND_FAILURES = 3 + # Raised from 3 to 12 (~60s at the 5s tick cadence): now that a + # reported SendResult(success=False) also lands here (see the + # delivery loop below), a transient Telegram/API outage of a few + # ticks must NOT permanently unsubscribe a live review-gate channel. + # A genuinely dead chat still drops, just ~60s later — a fine trade + # for an unattended gate where a false drop means silent work pileup. + MAX_SEND_FAILURES = 12 sub_fail_counts: dict[tuple, int] = getattr( self, "_kanban_sub_fail_counts", {} ) @@ -202,6 +208,24 @@ class GatewayKanbanWatchersMixin: getattr(platform, "value", str(platform)).lower() for platform in self.adapters.keys() } + # Widen to every platform any secondary profile has live, + # not just the default profile's. This is only a coarse + # pre-filter to skip claiming events for subs nobody can + # possibly deliver — the precise per-profile check (via + # gateway/authz_mixin.py::_authorization_adapter, which + # forbids default-profile fallback) still runs at delivery + # time below, rewinding the claim if it resolves to None. + # Without this, a subscription owned by a secondary + # profile on a platform the DEFAULT profile never + # connected (e.g. beta owns discord, default doesn't) was + # dropped here before ever being claimed — no rewind + # applies to an unclaimed event, so it silently never + # retries. + for _profile_adapter_map in getattr(self, "_profile_adapters", {}).values(): + active_platforms.update( + getattr(platform, "value", str(platform)).lower() + for platform in _profile_adapter_map.keys() + ) if not active_platforms: logger.debug("kanban notifier: no connected adapters; skipping tick") return deliveries @@ -230,6 +254,26 @@ class GatewayKanbanWatchersMixin: ) continue seen_db_paths.add(resolved_db_path) + # Zero-subscription early exit: probe the board with a + # cheap read-only connection BEFORE the writable + # `connect()`. A board with no subscriptions has + # nothing to notify, and the writable open (schema + # init/migration on first open, WAL/-shm sidecars, + # checkpoint traffic) is exactly the per-tick cost + # this skip avoids. + try: + if _kb.count_notify_subs(board=slug) == 0: + logger.debug( + "kanban notifier: board %s has no subscriptions; skipping open", + slug, + ) + continue + except Exception as exc: + logger.debug( + "kanban notifier: read-only subscription probe failed " + "for board %s (%s); falling back to writable open", + slug, exc, + ) try: conn = _kb.connect(board=slug) except Exception as exc: @@ -252,45 +296,54 @@ class GatewayKanbanWatchersMixin: if not subs: logger.debug("kanban notifier: board %s has no subscriptions", slug) for sub in subs: - owner_profile = sub.get("notifier_profile") or None - if owner_profile and owner_profile != notifier_profile: - _owner_adapters = getattr(self, "_profile_adapters", {}).get(owner_profile) - if not _owner_adapters: + try: + owner_profile = sub.get("notifier_profile") or None + if owner_profile and owner_profile != notifier_profile: + _owner_adapters = getattr(self, "_profile_adapters", {}).get(owner_profile) + if not _owner_adapters: + logger.debug( + "kanban notifier: subscription for %s owned by profile %s; current profile %s has no adapter for it, skipping", + sub.get("task_id"), owner_profile, notifier_profile, + ) + continue + platform = (sub.get("platform") or "").lower() + if platform not in active_platforms: logger.debug( - "kanban notifier: subscription for %s owned by profile %s; current profile %s has no adapter for it, skipping", - sub.get("task_id"), owner_profile, notifier_profile, + "kanban notifier: subscription for %s on %s skipped; adapter not connected", + sub.get("task_id"), platform or "", ) continue - platform = (sub.get("platform") or "").lower() - if platform not in active_platforms: - logger.debug( - "kanban notifier: subscription for %s on %s skipped; adapter not connected", - sub.get("task_id"), platform or "", + old_cursor, cursor, events = _kb.claim_unseen_events_for_sub( + conn, + task_id=sub["task_id"], + platform=sub["platform"], + chat_id=sub["chat_id"], + thread_id=sub.get("thread_id") or "", + kinds=TERMINAL_KINDS, + ) + if not events: + continue + task = _kb.get_task(conn, sub["task_id"]) + logger.debug( + "kanban notifier: claimed %d event(s) for %s on board %s cursor %s→%s", + len(events), sub["task_id"], slug, old_cursor, cursor, + ) + deliveries.append({ + "sub": sub, + "old_cursor": old_cursor, + "cursor": cursor, + "events": events, + "task": task, + "board": slug, + }) + except Exception as sub_exc: + # Isolate per-subscription failures so one + # bad subscription cannot block delivery for + # all other subscriptions in this tick. + logger.warning( + "kanban notifier: subscription for %s on board %s failed: %s", + sub.get("task_id"), slug, sub_exc, ) - continue - old_cursor, cursor, events = _kb.claim_unseen_events_for_sub( - conn, - task_id=sub["task_id"], - platform=sub["platform"], - chat_id=sub["chat_id"], - thread_id=sub.get("thread_id") or "", - kinds=TERMINAL_KINDS, - ) - if not events: - continue - task = _kb.get_task(conn, sub["task_id"]) - logger.debug( - "kanban notifier: claimed %d event(s) for %s on board %s cursor %s→%s", - len(events), sub["task_id"], slug, old_cursor, cursor, - ) - deliveries.append({ - "sub": sub, - "old_cursor": old_cursor, - "cursor": cursor, - "events": events, - "task": task, - "board": slug, - }) finally: conn.close() return deliveries @@ -404,6 +457,25 @@ class GatewayKanbanWatchersMixin: if ev.payload and ev.payload.get("status"): new_status = str(ev.payload["status"]) msg = f"🔄 {board_tag}{tag}Kanban {sub['task_id']} → {new_status}" + elif kind == "block_loop_detected": + # A task re-blocked for the same cause past the + # recurrence limit and was routed to `triage` for a + # human decision. This is the ONE transition that + # exists to force human attention, yet it emits no + # `blocked`/`status` event — so before adding it to + # TERMINAL_KINDS it produced zero notification and + # the task stalled in triage silently. Ping loudly. + reason = "" + recurrences = None + if ev.payload: + if ev.payload.get("reason"): + reason = f": {str(ev.payload['reason'])[:160]}" + recurrences = ev.payload.get("recurrences") + rc = f" (blocked {recurrences}x for the same cause)" if recurrences else "" + msg = ( + f"🛑 {board_tag}{tag}Kanban {sub['task_id']} routed to TRIAGE" + f" — needs a human decision{rc}{reason}" + ) else: # archived / unblocked are claimed by TERMINAL_KINDS # (so the cursor advances past them and they can't @@ -413,8 +485,13 @@ class GatewayKanbanWatchersMixin: # internal transition. They are also excluded from # _WAKE_KINDS below, so they never wake the creator. continue - metadata: dict[str, Any] = {} - if sub.get("thread_id"): + delivery_metadata = sub.get("delivery_metadata") + metadata: dict[str, Any] = ( + dict(delivery_metadata) + if isinstance(delivery_metadata, dict) + else {} + ) + if sub.get("thread_id") and not metadata.get("thread_id"): metadata["thread_id"] = sub["thread_id"] # Adapters with no push channel (the API server — # ``supports_async_delivery = False``) can NEVER @@ -631,27 +708,32 @@ class GatewayKanbanWatchersMixin: try: from gateway.session import SessionSource from gateway.wake import deliver_wake - # KNOWN LIMITATION (tracked follow-up): the - # subscription row does not persist the - # creator's chat_type, and it is not carried - # on the session-context bridge, so we cannot - # faithfully reconstruct the creator's real - # session key here. build_session_key() keys - # DMs (":dm:") on a wholly different - # shape from group/thread, so any hardcoded - # value mis-routes some creators. "group" is - # the least-surprising default for the - # dashboard/group flows this wake primarily - # serves; DM-originated creators are handled - # by the follow-up that stamps + persists - # chat_type end-to-end. handle_message() - # get_or_create_session's the target, so a - # mismatch degrades to "wake lands in a fresh - # group session" — never an exception. + # Rebuild the creator's real session scope from + # the chat_type persisted on the subscription + # row (#56580). build_session_key() keys DMs + # (":dm:") on a wholly different shape + # from group/thread, so the old hardcoded + # "group" mis-routed DM/thread creators into a + # fresh session. Legacy rows written before the + # column existed may still carry chat_type in + # delivery_metadata (#60600 rows) — fall back + # to that, then to "group" (the historical + # default that suits the dashboard/group flows). + # handle_message() get_or_create_session's the + # target, so a mismatch only ever degrades to a + # fresh session, never an exception. + _chat_type = str(sub.get("chat_type") or "").strip() + if not _chat_type: + _delivery_meta = sub.get("delivery_metadata") + if isinstance(_delivery_meta, dict): + _chat_type = str( + _delivery_meta.get("chat_type") or "" + ).strip() + _chat_type = _chat_type or "group" _source = SessionSource( platform=plat, chat_id=sub["chat_id"], - chat_type="group", + chat_type=_chat_type, thread_id=sub.get("thread_id") or None, user_id=sub.get("user_id"), profile=sub_profile or None, diff --git a/gateway/platforms/base.py b/gateway/platforms/base.py index 4f2c0e98fa..5d51345894 100644 --- a/gateway/platforms/base.py +++ b/gateway/platforms/base.py @@ -1478,13 +1478,15 @@ MEDIA_DELIVERY_EXTS: Tuple[str, ...] = ( # Images (embed inline) ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".svg", # Video (embed inline where supported) - ".mp4", ".mov", ".avi", ".mkv", ".webm", + ".mp4", ".mov", ".avi", ".mkv", ".webm", ".3gp", # Audio (delivered as voice/audio where supported) ".mp3", ".wav", ".ogg", ".opus", ".m4a", ".flac", # Documents (uploaded as file attachments) ".pdf", ".docx", ".doc", ".odt", ".rtf", ".txt", ".md", ".epub", # Spreadsheets / data ".xlsx", ".xls", ".ods", ".csv", ".tsv", ".json", ".xml", ".yaml", ".yml", + # Geospatial / GIS (#24032) + ".kmz", ".kml", ".geojson", ".gpx", # Presentations ".pptx", ".ppt", ".odp", ".key", # Archives @@ -1510,11 +1512,33 @@ _MEDIA_EXT_ALTERNATION = "|".join( # consumer so both behave identically. # Path anchors: ``~/`` (Unix home-relative), ``/`` (Unix absolute), # ``X:\\`` or ``X:/`` (Windows drive-letter absolute — #34632). +# Emphasis tolerance: models routinely wrap the tag in Markdown emphasis +# (``**MEDIA:/x.pdf**``, ``*MEDIA:/x.pdf*``, ``_MEDIA:/x.pdf_``) when they +# present a file to the user. The old single-quote anchor (``[`"']?``) and the +# closing lookahead (which lacked ``*``/``_``) failed to match such tags, so the +# file was silently never delivered and the literal ``MEDIA:`` text leaked into +# the chat. Allow a short run of emphasis/quote markers on both sides so the tag +# is recognised regardless of cosmetic Markdown. Code-block / inline-code / +# blockquote contexts are still neutralised earlier by ``_mask_protected_spans`` +# (#35695), so example tags remain non-deliverable. +# +# Both the bare and quoted path forms use non-greedy quantifiers so two +# ``MEDIA:`` tags glued together (``MEDIA:/a.pngMEDIA:/b.png``) or a tag +# followed by stray text don't merge into one invalid path. The trailing +# lookahead also accepts ``MEDIA:`` as a boundary, so the next tag stops +# the current match cleanly (#68773). +# +# Sentence-final punctuation: a ``.`` is accepted as a boundary only when +# followed by whitespace / EOL (``\.(?=\s|$)``) so ``MEDIA:/x/data.csv.`` +# at the end of a sentence still extracts ``data.csv``. The whitespace +# guard keeps multi-part extensions intact — for ``archive.tar.gz`` the +# ``.`` after ``tar`` is followed by ``g``, so the match must extend to +# ``.gz`` instead of stopping early at ``.tar``. MEDIA_TAG_CLEANUP_RE = re.compile( - r'''[`"']?MEDIA:\s*''' - r'''(?P`[^`\n]+`|"[^"\n]+"|'[^'\n]+'|''' - r'''(?:~/|/|[A-Za-z]:[/\\])\S+(?:[^\S\n]+\S+)*?\.(?:''' + _MEDIA_EXT_ALTERNATION + r'''))''' - r'''(?=[\s`"',;:)\]}]|$)[`"']?''', + r'''[`"'*_]{0,3}MEDIA:\s*''' + r'''(?P`[^`\n]+?`|"[^"\n]+?"|'[^'\n]+?'|''' + r'''(?:~/|/|[A-Za-z]:[/\\])\S+?(?:[^\S\n]+\S+?)*?\.(?:''' + _MEDIA_EXT_ALTERNATION + r'''))''' + r'''(?=[\s`"'*_,;:)\]}\[]|MEDIA:|\.(?:\s|$)|$)[`"'*_]{0,3}\.?''', re.IGNORECASE, ) @@ -1528,15 +1552,88 @@ MEDIA_TAG_CLEANUP_RE = re.compile( # under the credential/system denylist, strict-mode rules honored), so # prompt-injection paths that do not validate are left visible instead of # silently dropped. +# +# The path class uses a tempered-greedy token (``[^\s\n`"']+?`` followed by +# a ``(?=...)`` lookahead) instead of the prior ``[^\s\n`"']+`` so a +# tag glued to the next ``MEDIA:`` keyword (``MEDIA:/a.pngMEDIA:/b.png``) +# or to arbitrary following text (``MEDIA:/a.pngSome text``) cannot +# silently absorb the next path — that earlier behavior merged the two +# paths into one invalid string and dropped the file (#68773). +# +# The bare form stays non-greedy and whitespace-bounded — spaced paths are +# NOT absorbed at the regex level, because greedy space-tolerance would +# reintroduce the #68773 bug class (gluing the next MEDIA: tag or trailing +# prose into one invalid path). Instead, unknown-extension paths containing +# spaces (``MEDIA:/data/map data.kmz``, ``C:\...\My Documents\x.log``) are +# recovered by ``_match_extensionless_path`` (#24032): when the bare match +# fails validation, the candidate is progressively extended forward across +# single spaces — bounded, stopping at newline / the next ``MEDIA:`` keyword +# — and the first extension that validates on disk wins. Validation is the +# oracle, so prose never rides along and non-existent paths stay visible. MEDIA_EXTENSIONLESS_TAG_RE = re.compile( - r'''[`"']?MEDIA:\s*''' + r'''[`"'*_]{0,3}MEDIA:\s*''' r'''(?P`[^`\n]+`|"[^"\n]+"|'[^'\n]+'|''' - r'''(?:~/|/|[A-Za-z]:[/\\])[^\s\n`"']+)''' - r'''[`"']?\s*''', + r'''(?:~/|/|[A-Za-z]:[/\\])[^\s\n`"']+?)''' + r'''(?=[`"'\s,;:)\]}]|MEDIA:|$)''' + r'''[`"'*_]{0,3}\s*''', re.IGNORECASE, ) +def _match_extensionless_path(scan_text: str, match: "re.Match") -> Optional[Tuple[str, int]]: + """Resolve an extensionless MEDIA tag match to a validated on-disk path. + + Tries the regex-captured path first. When that fails validation, the + candidate is progressively extended forward across single spaces + (validation-gated, bounded at 8 tokens, never past a newline or a + subsequent ``MEDIA:`` keyword) so unknown-extension paths containing + spaces deliver (#24032). Returns ``(safe_path, end_offset)`` where + ``end_offset`` is the index in ``scan_text`` just past the matched path, + or ``None`` when nothing validates. + """ + raw = match.group("path") + path = _normalize_media_tag_path(raw) + if not path: + return None + safe = validate_media_delivery_path(path) + if safe: + return safe, match.end("path") + start = match.start("path") + nl = scan_text.find("\n", start) + limit = nl if nl != -1 else len(scan_text) + segment = scan_text[start:limit] + nxt = segment.find("MEDIA:", 1) + if nxt != -1: + segment = segment[:nxt] + pos = match.end("path") - start + for _ in range(8): + while pos < len(segment) and segment[pos] in " \t": + pos += 1 + if pos >= len(segment): + break + tok_end = pos + while tok_end < len(segment) and segment[tok_end] not in " \t": + tok_end += 1 + candidate = _normalize_media_tag_path(segment[:tok_end]) + safe = validate_media_delivery_path(candidate) + if safe: + return safe, start + tok_end + pos = tok_end + return None + + +def _merge_spans(spans: list) -> list: + """Merge overlapping/nested (start, end) spans so multi-pattern matches + over the same tag never double-delete adjacent text.""" + merged: list = [] + for s, e in sorted(spans): + if merged and s <= merged[-1][1]: + merged[-1] = (merged[-1][0], max(merged[-1][1], e)) + else: + merged.append((s, e)) + return merged + + def _normalize_media_tag_path(raw: str) -> str: path = str(raw or "").strip() if len(path) >= 2 and path[0] == path[-1] and path[0] in "`\"'": @@ -1557,8 +1654,25 @@ def _path_lacks_deliverable_extension(path: str) -> bool: return not suffix or suffix not in MEDIA_DELIVERY_EXTS +def _resolve_extensionless_candidate(path: str) -> Optional[str]: + """Validate a bare extensionless-branch path (no forward extension). + + Thin wrapper kept for call sites that only have the normalized path + (no scan-text context for spaced-path recovery). + """ + if not path: + return None + return validate_media_delivery_path(path) + + def _strip_media_tag_directives(text: str) -> str: - """Remove MEDIA: tags and [[audio_as_voice]] / [[as_document]] markers.""" + """Remove MEDIA: tags and [[audio_as_voice]] / [[as_document]] markers. + + Protected spans (fenced code blocks, inline code holding non-deliverable + example tags, blockquotes, JSON string values) are used as a mask-locator + only — tags inside them are neither stripped nor mangled, matching + ``extract_media``'s treatment so display text and delivery agree (#16434). + """ if ( "MEDIA:" not in text and "[[audio_as_voice]]" not in text @@ -1567,14 +1681,28 @@ def _strip_media_tag_directives(text: str) -> str: return text cleaned = text.replace("[[audio_as_voice]]", "").replace("[[as_document]]", "") - def _strip_extensionless(match: re.Match) -> str: + # Locate real tag spans on a masked copy (offset-preserving), then delete + # exactly those spans from the unmasked text — same pattern as + # extract_media. Import-cycle-free: BasePlatformAdapter is defined later + # in this module, so resolve it lazily at call time. + masked = BasePlatformAdapter._mask_protected_spans(cleaned) + masked = BasePlatformAdapter._mask_json_string_media(masked) + + spans: list = [m.span() for m in MEDIA_TAG_CLEANUP_RE.finditer(masked)] + for match in MEDIA_EXTENSIONLESS_TAG_RE.finditer(masked): path = _normalize_media_tag_path(match.group("path")) if not path or not _path_lacks_deliverable_extension(path): - return match.group(0) - return "" if validate_media_delivery_path(path) else match.group(0) + continue + resolved = _match_extensionless_path(masked, match) + if resolved is not None: + spans.append((match.start(), resolved[1])) - cleaned = MEDIA_TAG_CLEANUP_RE.sub("", cleaned) - return MEDIA_EXTENSIONLESS_TAG_RE.sub(_strip_extensionless, cleaned) + if spans: + chars = list(cleaned) + for start, end in reversed(_merge_spans(spans)): + del chars[start:end] + cleaned = "".join(chars) + return cleaned def get_document_cache_dir() -> Path: @@ -3082,6 +3210,44 @@ class BasePlatformAdapter(ABC): """ self._session_store = session_store + def _history_media_paths_for_session(self, session_key: str) -> Optional[set]: + """Return media paths already delivered in prior turns of this session. + + Loads the persisted transcript, drops the most recent assistant entry + (which belongs to the current response), and scans the remaining history + for MEDIA: tags and image_generate JSON payloads. Used to prevent the + model from re-delivering the same file when it echoes an old MEDIA tag. + """ + store = getattr(self, "_session_store", None) + if not store: + return None + try: + # The transcript store is keyed by session_id, not the gateway + # session_key — map through the routing index first. Falling back + # to the raw key covers stores that accept either. + session_id = None + peek = getattr(store, "peek_session_id", None) + if callable(peek): + session_id = peek(session_key) + transcript = store.load_transcript(session_id or session_key) + except Exception: + return None + if not transcript: + return None + # Exclude the current turn's assistant message, which has already been + # persisted by the time we reach delivery but must not be treated as + # "history" for dedup purposes. + history = list(transcript) + for msg in reversed(history): + if msg.get("role") == "assistant": + history.remove(msg) + break + if not history: + return None + # Avoid circular import: gateway.run already imports this module. + from gateway.run import _collect_history_media_paths + return _collect_history_media_paths(history) + @abstractmethod async def connect(self, *, is_reconnect: bool = False) -> bool: """ @@ -3346,11 +3512,28 @@ class BasePlatformAdapter(ABC): override this for a richer UX. """ if choices: + # Multi-select clarifies register their flag on the pending entry; + # look it up by id so the signature stays adapter-compatible. + _is_multi = False + try: + from tools import clarify_gateway as _cg + with _cg._lock: + _entry = _cg._entries.get(clarify_id) + _is_multi = bool(_entry and getattr(_entry, "multi_select", False)) + except Exception: + _is_multi = False lines = [f"❓ {question}", ""] for i, choice in enumerate(choices, start=1): lines.append(f" {i}. {choice}") lines.append("") - lines.append("Reply with the number, the option text, or your own answer.") + if _is_multi: + lines.append( + "Multiple selections allowed — reply with the numbers " + "separated by commas or spaces (e.g. \"1, 3\"), the option " + "text, or your own answer." + ) + else: + lines.append("Reply with the number, the option text, or your own answer.") text = "\n".join(lines) # Text fallback: enable text-capture so the gateway intercept # picks up the user's typed reply (e.g. "2" or choice text). @@ -3683,6 +3866,45 @@ class BasePlatformAdapter(ABC): text = f"{caption}\n{text}" return await self.send(chat_id=chat_id, content=text, reply_to=reply_to, metadata=metadata) + async def _notify_media_delivery_failure( + self, + chat_id: str, + media_path: str, + *, + is_voice: bool = False, + metadata: Optional[Dict[str, Any]] = None, + ) -> None: + """Send a user-visible notice when a MEDIA attachment could not be delivered. + + The non-streaming dispatch loop strips ``MEDIA:`` tags before sending + attachments. When the subsequent upload returns ``success=False`` (for + example Discord accepted the message but attached nothing), the user + must see a failure notice instead of a silent drop (#66797). + """ + ext = Path(media_path).suffix.lower() + _VIDEO_EXTS = {".mp4", ".mov", ".avi", ".mkv", ".webm", ".3gp"} + if is_voice or should_send_media_as_audio(self.platform, ext, is_voice=is_voice): + text = "⚠️ Couldn't deliver the audio attachment." + elif ext in _VIDEO_EXTS: + text = "⚠️ Couldn't deliver the video attachment." + else: + file_name = os.path.basename(media_path) + text = f"⚠️ Couldn't deliver the file attachment ({file_name})." + try: + notice = await self.send(chat_id=chat_id, content=text, metadata=metadata) + if not notice.success: + logger.debug( + "[%s] Could not send media-delivery-failure notice: %s", + self.name, + notice.error, + ) + except Exception as notify_err: + logger.debug( + "[%s] Could not send media-delivery-failure notice: %s", + self.name, + notify_err, + ) + async def send_image_file( self, chat_id: str, @@ -3769,6 +3991,17 @@ class BasePlatformAdapter(ABC): prefix = content[max(0, start - 20):start] if re.search(r'MEDIA:\s*$', prefix): continue # This is a MEDIA path quote, not inline code + # A whole tag wrapped in inline code (`MEDIA:/path.csv`) is a real + # delivery directive, not a prose example — models routinely format + # file paths as inline code. Deliver it IF the path validates + # (exists on disk, not denylisted). Prose examples with + # non-existent paths stay masked (#35695), and fenced code blocks + # are always masked regardless. + inner = m.group(0)[1:-1].strip() + if inner.upper().startswith("MEDIA:"): + candidate = _normalize_media_tag_path(inner[6:]) + if candidate and validate_media_delivery_path(candidate): + continue # Real deliverable tag in inline code — keep it scannable spans.append((start, m.end())) # Blockquote lines: > at line start @@ -3874,23 +4107,32 @@ class BasePlatformAdapter(ABC): # stay valid; chaining them masks the union of both protected regions. scan_content = BasePlatformAdapter._mask_protected_spans(content) scan_content = BasePlatformAdapter._mask_json_string_media(scan_content) + # Dedupe on the expanded path (first occurrence wins) so the same file + # referenced twice in one response — e.g. a MEDIA tag inline AND in a + # summary footer — is uploaded once, not twice (#29131). + seen_paths: set = set() for match in media_pattern.finditer(scan_content): path = _normalize_media_tag_path(match.group("path")) if path: try: - media.append((os.path.expanduser(path), has_voice_tag)) + expanded = os.path.expanduser(path) except (OSError, RuntimeError, ValueError): # Skip a crafted ~\x00 path rather than aborting extraction # and dropping every other attachment in the response. continue + if expanded not in seen_paths: + seen_paths.add(expanded) + media.append((expanded, has_voice_tag)) - seen_paths = {p for p, _ in media} for match in MEDIA_EXTENSIONLESS_TAG_RE.finditer(scan_content): path = _normalize_media_tag_path(match.group("path")) if not path or not _path_lacks_deliverable_extension(path): continue - safe = validate_media_delivery_path(path) - if safe and safe not in seen_paths: + resolved = _match_extensionless_path(scan_content, match) + if resolved is None: + continue + safe = resolved[0] + if safe not in seen_paths: media.append((safe, has_voice_tag)) seen_paths.add(safe) @@ -3910,11 +4152,12 @@ class BasePlatformAdapter(ABC): path = _normalize_media_tag_path(match.group("path")) if not path or not _path_lacks_deliverable_extension(path): continue - if validate_media_delivery_path(path): - spans.append(match.span()) + resolved = _match_extensionless_path(masked_cleaned, match) + if resolved is not None: + spans.append((match.start(), resolved[1])) if spans: chars = list(cleaned) - for start, end in sorted(spans, reverse=True): + for start, end in reversed(_merge_spans(spans)): del chars[start:end] cleaned = "".join(chars) cleaned = re.sub(r'\n{3,}', '\n\n', cleaned).strip() @@ -5184,6 +5427,18 @@ class BasePlatformAdapter(ABC): media_files, response = self.extract_media(response) media_files = self.filter_media_delivery_paths(media_files) + # Deduplicate against media already delivered in prior turns. + # The model may echo a previous MEDIA: tag or bare file path in + # a later response; without this guard the same file is sent + # repeatedly. + _history_media_paths = self._history_media_paths_for_session(session_key) + if _history_media_paths: + media_files = [ + (path, is_voice) + for path, is_voice in media_files + if path not in _history_media_paths + ] + # Extract image URLs and send them as native platform attachments images, text_content = self.extract_images(response) # Strip any remaining internal directives from message body (fixes #1561). @@ -5202,6 +5457,8 @@ class BasePlatformAdapter(ABC): # instead of becoming native uploads. local_files, text_content = self.extract_local_files(text_content) local_files = self.filter_local_delivery_paths(local_files) + if _history_media_paths: + local_files = [p for p in local_files if p not in _history_media_paths] if local_files: logger.info("[%s] extract_local_files found %d file(s) in response", self.name, len(local_files)) @@ -5431,6 +5688,12 @@ class BasePlatformAdapter(ABC): except Exception as batch_err: logger.warning("[%s] Error batching images: %s", self.name, batch_err, exc_info=True) + if _non_image_media: + logger.info( + "[%s] Delivering %d non-image MEDIA attachment(s)", + self.name, + len(_non_image_media), + ) for media_path, is_voice in _non_image_media: if human_delay > 0: await asyncio.sleep(human_delay) @@ -5443,6 +5706,12 @@ class BasePlatformAdapter(ABC): metadata=_final_thread_metadata, ) elif ext in _VIDEO_EXTS: + logger.info( + "[%s] Sending video attachment (%s) to %s", + self.name, + ext, + event.source.chat_id, + ) media_result = await self.send_video( chat_id=event.source.chat_id, video_path=media_path, @@ -5457,6 +5726,12 @@ class BasePlatformAdapter(ABC): if not media_result.success: logger.warning("[%s] Failed to send media (%s): %s", self.name, ext, media_result.error) + await self._notify_media_delivery_failure( + event.source.chat_id, + media_path, + is_voice=is_voice, + metadata=_final_thread_metadata, + ) except Exception as media_err: logger.warning("[%s] Error sending media: %s", self.name, media_err) @@ -5467,17 +5742,29 @@ class BasePlatformAdapter(ABC): try: ext = Path(file_path).suffix.lower() if ext in _VIDEO_EXTS: - await self.send_video( + file_result = await self.send_video( chat_id=event.source.chat_id, video_path=file_path, metadata=_final_thread_metadata, ) else: - await self.send_document( + file_result = await self.send_document( chat_id=event.source.chat_id, file_path=file_path, metadata=_final_thread_metadata, ) + if not file_result.success: + logger.warning( + "[%s] Failed to send local file (%s): %s", + self.name, + ext, + file_result.error, + ) + await self._notify_media_delivery_failure( + event.source.chat_id, + file_path, + metadata=_final_thread_metadata, + ) except Exception as file_err: logger.error("[%s] Error sending local file %s: %s", self.name, file_path, file_err) diff --git a/gateway/platforms/webhook.py b/gateway/platforms/webhook.py index 3cf306e858..85ccedd13c 100644 --- a/gateway/platforms/webhook.py +++ b/gateway/platforms/webhook.py @@ -63,9 +63,39 @@ from gateway.platforms.webhook_filters import ( DEFAULT_SCRIPT_TIMEOUT_SECONDS, WebhookRouteProcessor, ) +from gateway.response_filters import is_autonomous_silence_response logger = logging.getLogger(__name__) + +def _is_webhook_silence_response(content: Any) -> bool: + """Whether an agent response means "deliberately say nothing". + + Webhook routes are autonomous background lanes: a subscription prompt tells + the agent to answer with ``[SILENT]`` when a tick produced nothing worth a + human's attention (a duplicate inbound, a stand-down because a sibling lane + already replied, a routine close). Nobody is waiting on the other end, so + there is no reader for whom a "nothing happened" message is useful. + + The reason this is the loose autonomous rule rather than the live gateway's + is what the two lanes optimise for. In an interactive chat, swallowing a + real answer because it happens to open with a marker is much worse than + showing a stray marker, so ``is_intentional_silence_response`` demands the + response be EXACTLY a marker. A webhook run has the opposite payoff: the + cost of a leaked non-story is a pointless notification on every tick, and + models reliably add a sentence explaining why they stayed quiet — which + under the strict rule flips the whole thing back to "deliver". That is not + a hypothetical: it is why a Helper support lane kept messaging its owner to + report that it had nothing to report. + + So use the shared autonomous-lane matcher (also used by cron), which treats + a marker on its own first or last line as silence while still delivering + prose that merely mentions one mid-sentence. Sharing the function keeps + the two autonomous lanes from drifting apart, and keeps the interactive + path untouched. + """ + return is_autonomous_silence_response(content) + # Sentinel returned by _resolve_request_profile when a /p// prefix # names a profile this gateway does not serve (→ 404). Distinct from None # (no prefix / multiplexing off → handle as the default profile). @@ -336,6 +366,12 @@ class WebhookAdapter(BasePlatformAdapter): do not consume the entry and silently downgrade the final response to the ``log`` deliver type. TTL cleanup happens on POST. """ + if _is_webhook_silence_response(content): + logger.info( + "[webhook] Response for %s is a silence marker — not delivering", chat_id + ) + return SendResult(success=True) + delivery = self._delivery_info.get(chat_id, {}) deliver_type = delivery.get("deliver", "log") diff --git a/gateway/platforms/weixin.py b/gateway/platforms/weixin.py index 69ccc80cc7..e535949bca 100644 --- a/gateway/platforms/weixin.py +++ b/gateway/platforms/weixin.py @@ -124,6 +124,12 @@ def _make_ssl_connector() -> Optional["aiohttp.TCPConnector"]: When ``certifi`` is installed, use its Mozilla CA bundle to guarantee verification. Otherwise fall back to aiohttp's default (which honors ``SSL_CERT_FILE`` env var via ``trust_env=True``). + + Uses a tight ``keepalive_timeout=2`` (default aiohttp: 30s) so idle + connections drain promptly behind proxies like Cloudflare Warp that + leave peer-initiated FIN in ``CLOSE_WAIT`` (same class as #18451). + ``enable_cleanup_closed=True`` helps the connector clean up sockets + that the remote side has already closed. """ try: import ssl @@ -133,7 +139,12 @@ def _make_ssl_connector() -> Optional["aiohttp.TCPConnector"]: if not AIOHTTP_AVAILABLE: return None ssl_ctx = ssl.create_default_context(cafile=certifi.where()) - return aiohttp.TCPConnector(ssl=ssl_ctx) + return aiohttp.TCPConnector( + ssl=ssl_ctx, + # Tighter keepalive so idle CLOSE_WAIT drains promptly (#18451, #69089). + keepalive_timeout=2, + enable_cleanup_closed=True, + ) ITEM_TEXT = 1 ITEM_IMAGE = 2 diff --git a/gateway/response_filters.py b/gateway/response_filters.py index ccd2db370f..b11d585ea2 100644 --- a/gateway/response_filters.py +++ b/gateway/response_filters.py @@ -70,6 +70,47 @@ def is_intentional_silence_response(response: Any) -> bool: return any(candidate in LIVE_GATEWAY_SILENT_MARKERS for candidate in _canonical_silence_candidates(stripped)) +def is_autonomous_silence_response(response: Any) -> bool: + """Loose silence matcher for autonomous lanes (cron, webhook). + + Autonomous lanes instruct the agent to emit ``[SILENT]`` when a tick + produced nothing worth a human's attention, and models reliably bracket + the marker with a short note explaining why they stayed quiet. Unlike + :func:`is_intentional_silence_response` (the interactive-chat rule, which + demands the response be EXACTLY a marker), this suppresses when a marker + is the whole response, sits on its own first or last line, or the + bracketed sentinel opens the response (the documented + ``[SILENT] No changes detected`` pattern). A token buried mid-sentence + in a genuine report is still delivered. + + Shares :data:`LIVE_GATEWAY_SILENT_MARKERS` so the interactive and + autonomous marker sets can never drift apart. + """ + if not isinstance(response, str): + return False + stripped = response.strip() + if not stripped: + return False + + def _is_token(line: str) -> bool: + return _canonical_silence_candidate(line) in LIVE_GATEWAY_SILENT_MARKERS + + # Whole response is exactly a token. + if _is_token(stripped): + return True + # Marker on its own first or last line (leading/trailing note on a + # separate line — e.g. "2 deals filtered\n\n[SILENT]"). + lines = [ln for ln in stripped.splitlines() if ln.strip()] + if lines and (_is_token(lines[0]) or _is_token(lines[-1])): + return True + # Bracketed sentinel used as a same-line prefix — the documented pattern + # "[SILENT] No changes detected". Restricted to the bracketed form so a + # bare word like "Silent retry succeeded" is NOT swallowed. + if stripped.upper().startswith("[SILENT]"): + return True + return False + + def is_intentional_silence_agent_result(agent_result: dict | None, response: Any) -> bool: """Silence markers suppress delivery only for successful agent turns.""" if not isinstance(agent_result, dict): diff --git a/gateway/run.py b/gateway/run.py index 6b2ae447e5..1a108f0205 100644 --- a/gateway/run.py +++ b/gateway/run.py @@ -741,6 +741,14 @@ def _telegramize_command_mentions(text: str, platform: Any) -> str: # ``config.yaml`` ``agent.gateway_auto_continue_freshness``. _AUTO_CONTINUE_FRESHNESS_SECS_DEFAULT = 60 * 60 +# Default bound for how long ``_finish_startup_restore`` waits on boot +# auto-resume turns before releasing the inbound gate (see +# ``_startup_restore_drain_timeout_secs``). 30s is comfortably longer than a +# normal resume turn's first response yet short enough that one pathologically +# long resumed turn can't hold every channel's inbound queued for minutes. +# Override via ``config.yaml`` ``agent.gateway_startup_restore_drain_timeout``. +_STARTUP_RESTORE_DRAIN_TIMEOUT_SECS_DEFAULT = 30.0 + def _coerce_gateway_timestamp(value: Any) -> Optional[float]: """Best-effort conversion of stored gateway timestamps to epoch seconds. @@ -794,6 +802,39 @@ def _auto_continue_freshness_window() -> float: return auto_continue_freshness_window() +def _startup_restore_drain_timeout_secs() -> float: + """Max seconds ``_finish_startup_restore`` waits on boot auto-resume turns + before releasing the inbound gate and draining the queue. + + While startup restore is in progress the gateway QUEUES every inbound + message (``_queue_startup_restore_event``) instead of processing it, so no + channel gets a reply until the gate opens. The gate is opened by + ``_finish_startup_restore``, which waits for the synthetic boot + auto-resume turns to finish. A single long resumed turn therefore held + the gate shut for every channel — inbound piled up unanswered for as long + as that one turn ran. + + This bounds that wait. Duplicate-agent safety does NOT depend on the + wait: ``_schedule_resume_pending_sessions`` claims each session's + ``_running_agents`` slot SYNCHRONOUSLY (before the gate ever runs), so a + message drained while a resume turn is still running queues behind that + slot rather than spawning a second agent. So on timeout we release the + gate and let the slow turn finish in the background. + + Reads ``HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT`` (bridged from + ``config.yaml`` ``agent.gateway_startup_restore_drain_timeout`` at gateway + startup, same pattern as the other ``agent.*`` knobs). Non-positive + disables the bound (restores the historical "wait forever" behaviour). + """ + raw = os.environ.get("HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT") + if raw is None or raw == "": + return float(_STARTUP_RESTORE_DRAIN_TIMEOUT_SECS_DEFAULT) + try: + return float(raw) + except (TypeError, ValueError): + return float(_STARTUP_RESTORE_DRAIN_TIMEOUT_SECS_DEFAULT) + + def _float_env(name: str, default: float) -> float: """Read an env var as float, falling back to ``default`` on typos/empty. @@ -1436,18 +1477,17 @@ def _collect_auto_append_media_tags( def _collect_history_media_paths(agent_history: List[Dict[str, Any]]) -> set: - """Collect every media path already delivered in prior tool results. + """Collect every media path already delivered in prior assistant/tool output. - Used to dedup auto-appended MEDIA tags so the same file is not re-sent on - later turns. Must cover BOTH delivery shapes: - * ``MEDIA:`` text tags in tool results, and + Used to dedup auto-appended and model-emitted MEDIA tags so the same file + is not re-sent on later turns. Covers three delivery shapes: + * ``MEDIA:`` text tags in tool results, + * ``MEDIA:`` text tags in assistant messages (model-generated tags), * ``image_generate`` JSON-payload paths (``host_image`` / ``image`` / ``agent_visible_image``), which carry no MEDIA: tag. - Missing the JSON-payload shape caused #46627: after a compression - boundary the auto-append fallback rescans full history, re-discovers an - earlier ``image_generate`` result whose path was never in the dedup set, - and re-emits the MEDIA tag every turn. + Missing the JSON-payload shape caused #46627; missing the assistant-message + shape caused repeated delivery when the model echoed a previous MEDIA tag. """ paths: set = set() tool_name_by_call_id: Dict[str, str] = {} @@ -1460,7 +1500,16 @@ def _collect_history_media_paths(agent_history: List[Dict[str, Any]]) -> set: if cid and name: tool_name_by_call_id[str(cid)] = name for msg in agent_history: - if msg.get("role") not in {"tool", "function"}: + role = msg.get("role") + if role == "assistant": + content = str(msg.get("content", "") or "") + if "MEDIA:" in content: + for match in _TOOL_MEDIA_RE.finditer(content): + p = match.group(1).strip().rstrip('",}') + if p: + paths.add(p) + continue + if role not in {"tool", "function"}: continue content = str(msg.get("content", "") or "") if "MEDIA:" in content: @@ -1667,9 +1716,9 @@ def _current_max_iterations() -> int: """Return the current per-turn iteration budget after runtime env refresh.""" _reload_runtime_env_preserving_config_authority() try: - return int(os.getenv("HERMES_MAX_ITERATIONS", "90")) + return int(os.getenv("HERMES_MAX_ITERATIONS", "500")) except (TypeError, ValueError): - return 90 + return 500 from contextlib import contextmanager as _contextmanager @@ -1943,6 +1992,10 @@ if _config_path.exists(): os.environ["HERMES_AUTO_CONTINUE_FRESHNESS"] = str( _agent_cfg["gateway_auto_continue_freshness"] ) + if "gateway_startup_restore_drain_timeout" in _agent_cfg: + os.environ["HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT"] = str( + _agent_cfg["gateway_startup_restore_drain_timeout"] + ) # config-authoritative knobs for the session-search index; same # bridge semantics as the agent settings above. _sessions_cfg = _cfg.get("sessions", {}) @@ -3602,8 +3655,8 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew # hermes_state.get_last_init_error() for slash-command error strings. logger.warning("SQLite session store not available: %s", e) - # Opportunistic state.db maintenance: prune ended sessions older - # than sessions.retention_days + optional VACUUM. Tracks last-run + # Opportunistic state.db maintenance: prune ended sessions inactive + # for sessions.retention_days + optional VACUUM. Tracks last-run # in state_meta so it only actually executes once per # sessions.min_interval_hours. Gateway is long-lived so blocking # a few seconds once per day is acceptable; failures are logged @@ -7473,15 +7526,56 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew return drained async def _finish_startup_restore(self) -> None: - """Wait for startup auto-resume, then release and drain inbound queue.""" + """Wait (BOUNDED) for startup auto-resume, then release + drain inbound. + + The wait is bounded by ``_startup_restore_drain_timeout_secs`` so that + a single pathologically long boot-resume turn cannot hold the inbound + gate shut for every channel. On timeout we release the gate and let + the still-running resume turn(s) finish in the background — they are + NOT cancelled. This is safe because duplicate-agent protection does + not depend on the wait: ``_schedule_resume_pending_sessions`` claims + each session's ``_running_agents`` slot SYNCHRONOUSLY before this gate + runs, so any inbound message drained while a resume turn is still in + flight queues behind that slot instead of spawning a second agent. + """ tasks = list(getattr(self, "_startup_restore_tasks", []) or []) if tasks: - results = await asyncio.gather(*tasks, return_exceptions=True) - for result in results: - if isinstance(result, Exception): + timeout = _startup_restore_drain_timeout_secs() + if timeout > 0: + # asyncio.wait (unlike wait_for / gather+timeout) does NOT + # cancel the pending tasks on timeout — the slow resume turn + # keeps running in the background instead of being killed. + done, pending = await asyncio.wait(tasks, timeout=timeout) + if pending: + logger.warning( + "Startup-restore gate released after %.0fs with %d boot " + "auto-resume turn(s) still running; draining inbound " + "queue now (resume slots already claimed, so no " + "duplicate agents). Slow turn(s) continue in the " + "background.", + timeout, + len(pending), + ) + # These tasks outlive the gate. Their normal done-callback + # only discards them from _background_tasks, so a LATER + # failure would be silently swallowed. Attach a logging + # callback so a background resume turn that fails after the + # timeout is still recorded. + for task in pending: + task.add_done_callback(self._log_background_resume_result) + else: + # Non-positive timeout => opt out of the bound (historical + # "wait forever" behaviour). + await asyncio.gather(*tasks, return_exceptions=True) + done = set(tasks) + for task in done: + if task.cancelled(): + continue + exc = task.exception() + if exc is not None: logger.debug( "startup auto-resume task failed", - exc_info=(type(result), result, result.__traceback__), + exc_info=(type(exc), exc, exc.__traceback__), ) self._startup_restore_tasks = [] drained = await self._drain_startup_restore_queue() @@ -7489,6 +7583,21 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew if drained: logger.info("Drained %d inbound message(s) queued during startup restore", drained) + @staticmethod + def _log_background_resume_result(task: "asyncio.Task") -> None: + """Done-callback for a boot-resume turn that outlived the + startup-restore gate. Logs a late failure that would otherwise be + swallowed once the task is discarded from ``_background_tasks``. + Cancellation is expected (shutdown) and is not an error.""" + if task.cancelled(): + return + exc = task.exception() + if exc is not None: + logger.debug( + "background startup auto-resume task failed after gate release", + exc_info=(type(exc), exc, exc.__traceback__), + ) + async def _redeliver_pending_obligations(self) -> int: """Redeliver final responses recorded in the delivery ledger by a previous (now dead) gateway process. @@ -7814,10 +7923,24 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew Returns True if at least one adapter connected successfully. """ logger.info("Starting Hermes Gateway...") - # Enable faulthandler at gateway start so that SIGUSR2 (or an - # internal watchdog) can dump all thread and task stacks to stderr - # for post-mortem diagnosis of event-loop freezes (#70344). - faulthandler.enable() + # Enable faulthandler for stack dumps on freezes/crashes (#70344). + # Falls back to a log file when sys.stderr is None (Windows VBS / + # pythonw / detached service) — otherwise the gateway would die + # here and take every adapter offline. See #71671. + try: + faulthandler.enable() + except (RuntimeError, ValueError, OSError): + try: + _fh_log_dir = getattr(self.config, "log_dir", None) or os.path.join( + os.environ.get("HERMES_HOME", str(Path.home() / ".hermes")), + "logs", + ) + os.makedirs(_fh_log_dir, exist_ok=True) + _fh_enable_path = os.path.join(_fh_log_dir, "gateway_faulthandler.log") + _fh_enable_file = open(_fh_enable_path, "a", encoding="utf-8") + faulthandler.enable(file=_fh_enable_file, all_threads=True) + except Exception: + logger.debug("faulthandler.enable() unavailable", exc_info=True) # Also dump stacks to a rotating file for off-line analysis when # the gateway is running under a service manager that doesn't # capture stderr. @@ -7876,10 +7999,10 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew # config.yaml → env bridge did the right thing at a glance (instead # of silently running at a stale .env value for weeks). try: - _effective_max_iter = int(os.getenv("HERMES_MAX_ITERATIONS", "90")) + _effective_max_iter = int(os.getenv("HERMES_MAX_ITERATIONS", "500")) logger.info( "Agent budget: max_iterations=%d (agent.max_turns from config.yaml, " - "or HERMES_MAX_ITERATIONS from .env, or default 90)", + "or HERMES_MAX_ITERATIONS from .env, or default 500)", _effective_max_iter, ) except Exception: @@ -8586,11 +8709,26 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew ", ".join(p.value for p in self._failed_platforms), ) # Track the reconnect watcher task so _ensure_reconnect_watcher_running - # can detect if it dies and respawn it (#70344). - self._reconnect_watcher_task = asyncio.create_task( - self._platform_reconnect_watcher() + # can detect if it dies and respawn it (#70344). Spawned via + # _spawn_supervised (not a bare asyncio.create_task) so an exception + # escaping the watcher's OUTER while-loop -- not just the per-platform + # inner try/except -- is caught, logged, and auto-restarted with + # backoff instead of silently killing the watcher forever. Without + # this, a platform already queued in _failed_platforms when the + # watcher dies stays stranded indefinitely: _ensure_reconnect_watcher_running() + # only gets called from a NEW fatal-error arrival, so if no other + # platform ever fails afterward, nothing ever notices the watcher is + # dead (#71758 -- reported as 17.5h of silent downtime for a platform + # whose transient upstream outage had long since recovered). + # ``on_spawn`` keeps ``_reconnect_watcher_task`` pointed at the CURRENT + # live task even when _spawn_supervised's own backoff respawns it — so + # _ensure_reconnect_watcher_running never mistakes a superseded handle + # for a dead watcher and spawns a duplicate. + self._reconnect_watcher_task = self._spawn_supervised( + self._platform_reconnect_watcher, + "platform_reconnect_watcher", + on_spawn=lambda t: setattr(self, "_reconnect_watcher_task", t), ) - self._background_tasks.add(self._reconnect_watcher_task) # Start background handoff watcher — picks up CLI sessions marked # handoff_state='pending' in state.db and re-binds them to the @@ -8648,7 +8786,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew # handoff for the rest of the process life). _SUPERVISED_HEALTHY_SECS = 300 - def _spawn_supervised(self, coro_factory, name, *, restart=True, _attempt=0): + def _spawn_supervised(self, coro_factory, name, *, restart=True, _attempt=0, on_spawn=None): """Launch a long-lived background task with task-level supervision. Complements upstream's per-iteration inner-loop try/except (which only @@ -8663,6 +8801,14 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew The counter resets after any run that stayed healthy for at least ``_SUPERVISED_HEALTHY_SECS`` — so a long-lived daemon that crashes occasionally over days is never permanently abandoned. + + ``on_spawn`` (optional) is invoked with the freshly-created task on + every spawn, INCLUDING internal backoff respawns. Callers that also + track the live handle elsewhere (e.g. ``self._reconnect_watcher_task`` + for ``_ensure_reconnect_watcher_running``) MUST pass it — otherwise the + supervisor's own respawn creates a new task without updating that + external handle, so ``_ensure_...`` later sees the stale/done handle + and spawns a SECOND concurrent watcher (double reconnect attempts). """ if getattr(self, "_background_tasks", None) is None: self._background_tasks = set() @@ -8675,6 +8821,14 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew # create_task with a signature that rejects the name kwarg. task = asyncio.create_task(coro_factory()) self._background_tasks.add(task) + if on_spawn is not None: + # Record the live handle NOW so an external tracker (e.g. + # _reconnect_watcher_task) always points at the current task, not a + # dead one left behind by a prior supervised respawn. + try: + on_spawn(task) + except Exception: # pragma: no cover - defensive; a tracker must never kill the spawn + logger.debug("on_spawn callback for %s raised", name, exc_info=True) def _done(t): self._background_tasks.discard(t) @@ -8716,6 +8870,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew name, restart=restart, _attempt=effective_attempt + 1, + on_spawn=on_spawn, ) respawn_task = asyncio.create_task(_respawn()) @@ -9172,11 +9327,11 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew "Reconnect watcher task is dead (done=%s) — respawning", task.done() if task is not None else "N/A", ) - self._reconnect_watcher_task = asyncio.create_task( - self._platform_reconnect_watcher() + self._reconnect_watcher_task = self._spawn_supervised( + self._platform_reconnect_watcher, + "platform_reconnect_watcher", + on_spawn=lambda t: setattr(self, "_reconnect_watcher_task", t), ) - if getattr(self, "_background_tasks", None) is not None: - self._background_tasks.add(self._reconnect_watcher_task) async def _platform_reconnect_watcher(self) -> None: """Background task that periodically retries connecting failed platforms. @@ -9208,7 +9363,13 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew for platform in list(self._failed_platforms.keys()): if not self._running: return - info = self._failed_platforms[platform] + info = self._failed_platforms.get(platform) + if info is None: + # Removed concurrently (e.g. a manual /platform resume, + # or a reconnect that succeeded via a different path) + # between the snapshot above and this lookup. Not an + # error -- just nothing to do for it this pass. + continue # Skip paused platforms entirely — they need explicit # /platform resume to come back. if info.get("paused"): @@ -11144,6 +11305,9 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew if event.get_command() == "status": return await self._handle_status_command(event) + if event.get_command() in {"context", "ctx"}: + return await self._handle_context_command(event) + # Resolve the command once for all early-intercept checks below. from hermes_cli.commands import ( ACTIVE_SESSION_BYPASS_COMMANDS as _DEDICATED_HANDLERS, @@ -11719,6 +11883,9 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew return format_status_text() + if canonical == "context": + return await self._handle_context_command(event) + if canonical == "agents": return await self._handle_agents_command(event) @@ -11768,6 +11935,34 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew except Exception: return "Could not start /learn — please try again." + if canonical == "init": + # /init: rewrite the turn to a guidance-laden prompt and fall + # through to normal agent processing (same fall-through as /learn + # so role alternation is preserved). The live agent scans the + # project with its own read-only tools and writes/updates + # AGENTS.md via write_file. No engine, works on any backend. + from hermes_cli.init_command import build_init_prompt_for_cwd + + _init_notes = event.get_command_args().strip() + try: + _init_prompt = build_init_prompt_for_cwd(extra=_init_notes) + except Exception: + return "Could not start /init — please try again." + _ack = ( + "Updating AGENTS.md from a project scan…" + if "UPDATE the existing AGENTS.md" in _init_prompt + else "Generating AGENTS.md from a project scan…" + ) + try: + adapter = self._adapter_for_source(source) + if adapter: + _ack_meta = self._thread_metadata_for_source(source) + await adapter.send(str(source.chat_id), _ack, metadata=_ack_meta) + except Exception: + logger.debug("init ack send failed", exc_info=True) + event.text = _init_prompt + # fall through to agent processing + if canonical == "fast": return await self._handle_fast_command(event) @@ -11903,6 +12098,9 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew if canonical == "rollback": return await self._handle_rollback_command(event) + if canonical == "diff": + return await self._handle_diff_command(event) + if canonical == "background": return await self._handle_background_command(event) @@ -12207,7 +12405,9 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew # No bare text matching — "yes" in normal conversation must not trigger # execution of a dangerous command. - if await asyncio.to_thread(self._is_telegram_topic_root_lobby, source): + if not is_internal and await asyncio.to_thread( + self._is_telegram_topic_root_lobby, source + ): # Debounce the lobby reminder so a user who forgets about # topic mode and fires ten prompts doesn't get ten copies. if self._should_send_telegram_lobby_reminder(source): @@ -14546,6 +14746,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew if _media_adapter: await self._deliver_media_from_response( response, event, _media_adapter, + history_media_paths=_collect_history_media_paths(history), ) # Streaming already delivered the body text, but the footer was # intentionally held back (see the `not already_sent` gate above). @@ -15614,6 +15815,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew response: str, event: MessageEvent, adapter, + history_media_paths: Optional[set] = None, ) -> None: """Extract explicit MEDIA: tags from a response and deliver them. @@ -15645,6 +15847,15 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew media_files, cleaned = adapter.extract_media(response) media_files = BasePlatformAdapter.filter_media_delivery_paths(media_files) + # Deduplicate against media already delivered in prior turns — + # the model may echo a previous turn's MEDIA: tag in a later + # response; without this guard the same file is re-sent. + if history_media_paths: + media_files = [ + (path, is_voice) + for path, is_voice in media_files + if path not in history_media_paths + ] # Strip image URLs from the cleaned text for parity with the # non-streaming chain, but do NOT run extract_local_files here: # post-stream delivery is explicit-only (#20834). Bare local paths @@ -17425,6 +17636,9 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew return set_session_vars( platform=context.source.platform.value, chat_id=context.source.chat_id, + chat_type=( + str(context.source.chat_type) if context.source.chat_type else "" + ), chat_name=context.source.chat_name or "", thread_id=str(context.source.thread_id) if context.source.thread_id else "", user_id=str(context.source.user_id) if context.source.user_id else "", @@ -21809,7 +22023,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew # explaining that no response arrived (so the agent can adapt # rather than hang forever). # ------------------------------------------------------------------ - def _clarify_callback_sync(question: str, choices) -> str: + def _clarify_callback_sync(question: str, choices, multi_select: bool = False) -> str: from tools import clarify_gateway as _clarify_mod import uuid as _uuid @@ -21822,6 +22036,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew session_key=session_key or "", question=question, choices=list(choices) if choices else None, + multi_select=bool(multi_select), ) # Pause typing — like approval, we don't want a "thinking..." diff --git a/gateway/session_context.py b/gateway/session_context.py index a792726e47..cf227fac12 100644 --- a/gateway/session_context.py +++ b/gateway/session_context.py @@ -73,6 +73,7 @@ def session_context_engaged() -> bool: _SESSION_PLATFORM: ContextVar = ContextVar("HERMES_SESSION_PLATFORM", default=_UNSET) _SESSION_SOURCE: ContextVar = ContextVar("HERMES_SESSION_SOURCE", default=_UNSET) _SESSION_CHAT_ID: ContextVar = ContextVar("HERMES_SESSION_CHAT_ID", default=_UNSET) +_SESSION_CHAT_TYPE: ContextVar = ContextVar("HERMES_SESSION_CHAT_TYPE", default=_UNSET) _SESSION_CHAT_NAME: ContextVar = ContextVar("HERMES_SESSION_CHAT_NAME", default=_UNSET) _SESSION_THREAD_ID: ContextVar = ContextVar("HERMES_SESSION_THREAD_ID", default=_UNSET) _SESSION_USER_ID: ContextVar = ContextVar("HERMES_SESSION_USER_ID", default=_UNSET) @@ -123,6 +124,7 @@ _VAR_MAP = { "HERMES_SESSION_PLATFORM": _SESSION_PLATFORM, "HERMES_SESSION_SOURCE": _SESSION_SOURCE, "HERMES_SESSION_CHAT_ID": _SESSION_CHAT_ID, + "HERMES_SESSION_CHAT_TYPE": _SESSION_CHAT_TYPE, "HERMES_SESSION_CHAT_NAME": _SESSION_CHAT_NAME, "HERMES_SESSION_THREAD_ID": _SESSION_THREAD_ID, "HERMES_SESSION_USER_ID": _SESSION_USER_ID, @@ -157,6 +159,7 @@ def set_session_vars( platform: str = "", source: str = "", chat_id: str = "", + chat_type: str = "", chat_name: str = "", thread_id: str = "", user_id: str = "", @@ -193,6 +196,7 @@ def set_session_vars( _SESSION_PLATFORM.set(platform), _SESSION_SOURCE.set(source), _SESSION_CHAT_ID.set(chat_id), + _SESSION_CHAT_TYPE.set(chat_type), _SESSION_CHAT_NAME.set(chat_name), _SESSION_THREAD_ID.set(thread_id), _SESSION_USER_ID.set(user_id), @@ -228,6 +232,7 @@ def clear_session_vars(tokens: list) -> None: _SESSION_PLATFORM, _SESSION_SOURCE, _SESSION_CHAT_ID, + _SESSION_CHAT_TYPE, _SESSION_CHAT_NAME, _SESSION_THREAD_ID, _SESSION_USER_ID, diff --git a/gateway/slash_commands.py b/gateway/slash_commands.py index 0ee92bb9f3..f9871c0e8e 100644 --- a/gateway/slash_commands.py +++ b/gateway/slash_commands.py @@ -56,6 +56,19 @@ logger = logging.getLogger("gateway.run") _RESET_CLEANUP_TIMEOUT_S = 30.0 +def _clean_str(value: Any) -> str: + """Strip and return a non-empty string value, or empty string.""" + return value.strip() if isinstance(value, str) and value.strip() else "" + + +def _int_value(value: Any) -> int: + """Safely coerce to int.""" + try: + return int(value) + except (TypeError, ValueError): + return 0 + + def _model_switch_skew_guard() -> Optional[str]: """Refuse a model switch when the gateway is running stale code. @@ -477,8 +490,16 @@ class GatewaySlashCommandsMixin: platform.value if hasattr(platform, "value") else str(platform or "") ).lower() chat_id = str(getattr(source, "chat_id", "") or "") + chat_type = str(getattr(source, "chat_type", "") or "") or None thread_id = str(getattr(source, "thread_id", "") or "") user_id = str(getattr(source, "user_id", "") or "") or None + delivery_metadata = self._thread_metadata_for_source( + source, self._reply_anchor_for_event(event) + ) or None + if isinstance(delivery_metadata, dict): + chat_type = str(getattr(source, "chat_type", "") or "") + if chat_type: + delivery_metadata.setdefault("chat_type", chat_type) if platform_str and chat_id: def _sub(): from hermes_cli import kanban_db as _kb @@ -487,9 +508,11 @@ class GatewaySlashCommandsMixin: _kb.add_notify_sub( conn, task_id=task_id, platform=platform_str, chat_id=chat_id, + chat_type=chat_type, thread_id=thread_id or None, user_id=user_id, notifier_profile=getattr(self, "_kanban_notifier_profile", None) or self._active_profile_name(), + delivery_metadata=delivery_metadata, ) finally: conn.close() @@ -690,6 +713,196 @@ class GatewaySlashCommandsMixin: digest = hashlib.sha256(text.encode("utf-8")).hexdigest()[:12] return f"sha256:{digest}" + async def _handle_context_command(self, event: MessageEvent) -> str: + """Handle /context — the dedicated context-window view. + + /status shows a one-line ``used / total`` summary; this command is the + deep view: a usage gauge, auto-compression threshold and headroom, + compression count and last savings, and cumulative throughput — the last + clearly labelled as throughput, NOT context size. + + Resolves from the running agent (mid-turn), then the cached agent + (between turns), then the SessionStore/SessionDB metadata for a gauge + even when no agent is resident. Falls back to a transcript estimate only + as a last resort. + + ``/context all`` appends the expanded per-skill / per-toolset cost + listings (requires a resident agent). + """ + from gateway.run import _AGENT_PENDING_SENTINEL + + source = event.source + session_key = self._session_key_for_source(source) + session_entry = await self.async_session_store.get_or_create_session(source) + expanded = event.get_command_args().strip().lower() in {"all", "full", "details"} + + # Try running agent first (mid-turn), then cached agent (between turns). + agent = self._running_agents.get(session_key) + if not agent or agent is _AGENT_PENDING_SENTINEL: + cache_lock = getattr(self, "_agent_cache_lock", None) + cache = getattr(self, "_agent_cache", None) + if cache_lock is not None and cache is not None: + try: + with cache_lock: + cached = cache.get(session_key) + if cached: + agent = cached[0] + except Exception: + agent = None + has_agent = bool(agent) and agent is not _AGENT_PENDING_SENTINEL + + ctx = getattr(agent, "context_compressor", None) if has_agent else None + + # Resolve current-context size + window with cascading fallbacks. + # used : compressor.last_prompt_tokens → SessionStore.last_prompt_tokens + # model : agent.model → SessionDB row model + # window: compressor.context_length → get_model_context_length(model) + used = 0 + context_length = 0 + if ctx is not None: + used = getattr(ctx, "last_prompt_tokens", 0) or 0 + context_length = getattr(ctx, "context_length", 0) or 0 + + model_name = _clean_str(getattr(agent, "model", "")) if has_agent else "" + + if not used: + used = _int_value(getattr(session_entry, "last_prompt_tokens", 0)) + + if not model_name and self._session_db: + try: + row = await self._session_db.get_session(session_entry.session_id) or {} + if isinstance(row, dict): + model_name = _clean_str(row.get("model", "")) + except Exception: + model_name = "" + + if not context_length and model_name: + try: + from agent.model_metadata import get_model_context_length + + context_length = _int_value( + await asyncio.to_thread(get_model_context_length, model_name) + ) + except Exception: + context_length = 0 + + # Gauge path: real current-context figure + if used > 0 and context_length > 0: + pct = min(100.0, used / context_length * 100) + headroom = max(0, context_length - used) + BAR_WIDTH = 24 + filled = int(round(pct / 100 * BAR_WIDTH)) + bar = "█" * max(0, filled) + "░" * max(0, BAR_WIDTH - filled) + + lines = [ + t("gateway.context.header"), + "", + t("gateway.context.model", model=model_name or "?"), + t("gateway.context.window", total=f"{context_length:,}"), + t( + "gateway.context.in_use", + used=f"{used:,}", + total=f"{context_length:,}", + pct=f"{pct:.0f}", + ), + t("gateway.context.bar", bar=bar), + t("gateway.context.headroom", headroom=f"{headroom:,}"), + ] + + # Full view — compression / throughput need the live agent. + if ctx is not None: + threshold = getattr(ctx, "threshold_tokens", 0) or 0 + threshold_pct = (getattr(ctx, "threshold_percent", 0) or 0) * 100 + lines.append("") + if threshold > 0: + if used >= threshold: + lines.append( + t( + "gateway.context.over_threshold", + threshold=f"{threshold:,}", + threshold_pct=f"{threshold_pct:.0f}", + ) + ) + else: + lines.append( + t( + "gateway.context.threshold", + threshold=f"{threshold:,}", + threshold_pct=f"{threshold_pct:.0f}", + to_go=f"{threshold - used:,}", + ) + ) + compressions = getattr(ctx, "compression_count", 0) or 0 + lines.append(t("gateway.context.compressions", count=compressions)) + if compressions: + savings = getattr(ctx, "_last_compression_savings_pct", None) + if savings is not None: + lines.append( + t("gateway.context.last_savings", savings=f"{savings:.0f}") + ) + + api_calls = getattr(agent, "session_api_calls", 0) or 0 + input_tokens = getattr(agent, "session_input_tokens", 0) or 0 + output_tokens = getattr(agent, "session_output_tokens", 0) or 0 + reasoning_tokens = getattr(agent, "session_reasoning_tokens", 0) or 0 + total_tokens = getattr(agent, "session_total_tokens", 0) or 0 + lines.append("") + lines.append( + t("gateway.context.totals_header", calls=api_calls) + ) + lines.append( + t( + "gateway.context.totals_line", + input=f"{input_tokens:,}", + output=f"{output_tokens:,}", + reasoning=f"{reasoning_tokens:,}", + ) + ) + lines.append(t("gateway.context.total_billed", total=f"{total_tokens:,}")) + lines.append(t("gateway.context.throughput_note")) + else: + lines.append("") + lines.append(t("gateway.context.detail_after_first")) + + # Per-category estimated breakdown (+ optional expanded listings). + # Same chars/4 engine the desktop popover and /usage use; plain + # text (no glyph grid — monospace isn't guaranteed on messaging + # platforms). Fail-open: rendering errors never break /context. + if has_agent: + breakdown = await asyncio.to_thread( + self._context_breakdown_block, agent, source, expanded + ) + if breakdown: + lines.append("") + lines.extend(breakdown) + + return "\n".join(lines) + + # Last resort: rough estimate from transcript + history = await self.async_session_store.load_transcript(session_entry.session_id) + if history: + from agent.model_metadata import estimate_messages_tokens_rough + + msgs = [ + m + for m in history + if m.get("role") in {"user", "assistant"} and m.get("content") + ] + approx = estimate_messages_tokens_rough(msgs) + return "\n".join( + [ + t("gateway.context.header"), + "", + t( + "gateway.context.estimated", + count=f"{approx:,}", + messages=len(msgs), + ), + t("gateway.context.detail_after_first"), + ] + ) + return t("gateway.context.no_data") + def _gateway_session_origin_for_id(self, session_id: str) -> Optional[SessionSource]: """Best-effort origin lookup for gateway session IDs.""" lookup = getattr(type(self.session_store), "lookup_by_session_id", None) @@ -1060,7 +1273,67 @@ class GatewaySlashCommandsMixin: ] ) - if not agent_rows and not running_processes and not background_tasks: + # Background (async) delegations — delegate_task(background=true). + # Live per-child activity comes from the registry's progress sampler + # (#51690): api calls, current tool, seconds since last activity. + delegations: list[dict] = [] + try: + from tools.async_delegation import list_async_delegations + delegations = [ + d for d in list_async_delegations() + if d.get("status") in ("running", "stalling", "finalizing") + ] + except Exception: + delegations = [] + if delegations: + lines.extend( + [ + "", + t( + "gateway.agents.background_delegations", + count=len(delegations), + ), + ] + ) + for d in delegations[:12]: + goal = " ".join(str(d.get("goal") or "").split()) + if len(goal) > 70: + goal = goal[:67] + "..." + status = d.get("status", "?") + row = f"- `{d.get('delegation_id', '?')}` · {status}" + if status == "stalling": + quiet = d.get("stalled_after_quiet_seconds") + if quiet is not None: + row += f" · no progress {quiet:.0f}s" + elif d.get("seconds_since_progress", 0) >= 60: + row += f" · quiet {d['seconds_since_progress']:.0f}s" + if goal: + row += f" · {goal}" + lines.append(row) + for i, child in enumerate(d.get("children_activity") or []): + if not isinstance(child, dict): + continue + tool = child.get("current_tool") + doing = f"`{tool}`" if tool else "between turns" + part = ( + f" - child {i + 1}: " + f"{child.get('api_calls', '?')} api calls · {doing}" + ) + idle = child.get("seconds_since_activity") + if idle is not None: + part += f" · active {idle:.0f}s ago" + lines.append(part) + if len(delegations) > 12: + lines.append( + t("gateway.agents.more", count=len(delegations) - 12) + ) + + if ( + not agent_rows + and not running_processes + and not background_tasks + and not delegations + ): lines.append("") lines.append(t("gateway.agents.none")) @@ -2799,6 +3072,116 @@ class GatewaySlashCommandsMixin: ) return t("gateway.rollback.restore_failed", error=result["error"]) + async def _handle_diff_command(self, event: MessageEvent) -> str: + """Handle /diff — show git changes in the working directory. + + ``/diff`` (default) shows unstaged + untracked changes, ``/diff + staged`` the staged ones, ``/diff all`` everything since HEAD, and + ``/diff session`` the cumulative checkpoint-baseline diff of what + Hermes itself changed. ``--stat`` limits output to the summary. + + The diff body is truncated hard here (messaging surfaces are not a + pager); platform senders additionally split/clamp long messages to + per-platform limits, the same way tool-progress output is truncated + in three layers before delivery. + """ + args = event.get_command_args().strip() + + stat_only = False + mode = "working" + for arg in args.split(): + low = arg.lower() + if low in ("--stat", "stat"): + stat_only = True + elif low in ("staged", "--staged", "cached", "--cached"): + mode = "staged" + elif low in ("all", "--all", "head"): + mode = "all" + elif low == "session": + mode = "session" + + cwd = os.getenv("TERMINAL_CWD", str(Path.home())) + + if mode == "session": + return await self._gateway_session_diff(cwd, stat_only) + + from tools.working_diff import collect_working_diff + + result = await asyncio.to_thread(collect_working_diff, cwd, mode) + if not result.get("success"): + return t("gateway.diff.failed", + error=result.get("error", "Could not generate diff")) + + stat = result.get("stat", "") + diff = result.get("diff", "") + untracked = result.get("untracked", []) + if result.get("empty") or (not stat and not diff and not untracked): + return t("gateway.diff.no_changes") + + out: list[str] = [] + if stat: + out.append(f"```\n{stat}\n```") + if untracked: + shown = "\n".join(f"+ {rel}" for rel in untracked[:15]) + more = f"\n... and {len(untracked) - 15} more" if len(untracked) > 15 else "" + out.append(f"**Untracked:**\n```\n{shown}{more}\n```") + if not stat_only and diff: + out.append(self._fenced_truncated_diff(diff)) + return "\n\n".join(out) + + async def _gateway_session_diff(self, cwd: str, stat_only: bool) -> str: + """Cumulative checkpoint-baseline diff for /diff session (gateway).""" + from gateway.run import _checkpoint_agent_kwargs, _load_gateway_config + from tools.checkpoint_manager import CheckpointManager + + cp_kwargs = _checkpoint_agent_kwargs(_load_gateway_config()) + if not cp_kwargs["checkpoints_enabled"]: + return t("gateway.diff.not_enabled") + + mgr = CheckpointManager( + enabled=True, + max_snapshots=cp_kwargs["checkpoint_max_snapshots"], + max_total_size_mb=cp_kwargs["checkpoint_max_total_size_mb"], + max_file_size_mb=cp_kwargs["checkpoint_max_file_size_mb"], + ) + + result = await asyncio.to_thread(mgr.session_diff, cwd) + if not result.get("success"): + return t("gateway.diff.failed", + error=result.get("error", "Could not generate diff")) + + stat = result.get("stat", "") + diff = result.get("diff", "") + if result.get("empty") or (not stat and not diff): + return t("gateway.diff.no_changes") + + out: list[str] = [] + if stat: + out.append(f"```\n{stat}\n```") + if not stat_only and diff: + out.append(self._fenced_truncated_diff(diff)) + return "\n\n".join(out) + + @staticmethod + def _fenced_truncated_diff(diff: str, max_lines: int = 60, + max_chars: int = 3000) -> str: + """Fence a diff body, truncating to messaging-friendly size.""" + diff_lines = diff.splitlines() + truncated = False + if len(diff_lines) > max_lines: + diff = "\n".join(diff_lines[:max_lines]) + truncated = True + if len(diff) > max_chars: + diff = diff[:max_chars] + truncated = True + note = "" + if truncated: + note = ( + f"\n... (truncated — {len(diff_lines)} lines total; " + "use /diff --stat for a summary)" + ) + return f"```diff\n{diff}{note}\n```" + async def _handle_background_command(self, event: MessageEvent) -> str: """Handle /background — run a prompt in a separate background session. @@ -4278,6 +4661,43 @@ class GatewaySlashCommandsMixin: lines.append("Top up and manage billing in the browser — your balance updates here after.") return "\n".join(lines) + def _context_breakdown_block(self, agent, source, expanded: bool) -> list[str]: + """Render the /context per-category block (plain text, no grid). + + Estimated (chars/4) — same engine as the desktop popover and /usage. + ``expanded`` appends the per-skill / per-toolset listings from the + prompt-size attribution mechanism. Runs in a thread (sync store reads); + returns [] and never raises so /context stays robust. + """ + try: + from agent.context_breakdown import ( + compute_context_details, + compute_session_context_breakdown, + render_context_breakdown_lines, + ) + + history: list[dict] = [] + try: + entry = self.session_store.get_or_create_session(source) + history = self.session_store.load_transcript(entry.session_id) or [] + except Exception: + history = [] + + payload = compute_session_context_breakdown(agent, history) + if not (payload.get("categories") or []): + return [] + + details = None + if expanded: + try: + details = compute_context_details(agent) + except Exception: + details = {"skills": [], "toolsets": []} + + return render_context_breakdown_lines(payload, details=details, grid=False) + except Exception: + return [] + def _context_breakdown_lines(self, agent, source) -> list[str]: """Render the per-category context breakdown for /usage. diff --git a/hermes_cli/_parser.py b/hermes_cli/_parser.py index a4027221de..cb5be6b935 100644 --- a/hermes_cli/_parser.py +++ b/hermes_cli/_parser.py @@ -382,7 +382,7 @@ def build_top_level_parser(): type=int, default=None, metavar="N", - help="Maximum tool-calling iterations per conversation turn (default: 90, or agent.max_turns in config)", + help="Maximum tool-calling iterations per conversation turn (default: 500, or agent.max_turns in config)", ) _inherited_flag( chat_parser, diff --git a/hermes_cli/agent_import.py b/hermes_cli/agent_import.py new file mode 100644 index 0000000000..bd686e5934 --- /dev/null +++ b/hermes_cli/agent_import.py @@ -0,0 +1,905 @@ +"""hermes import-agent — import Claude Code / Codex CLI setups into Hermes. + +Usage: + hermes import-agent # auto-detect ~/.claude or ~/.codex + hermes import-agent claude-code # import from ~/.claude + hermes import-agent codex # import from ~/.codex + hermes import-agent claude-code --dry-run # preview only, no changes + hermes import-agent codex --source /path/to/.codex + +Follows the OpenClaw migration pattern (``hermes claw migrate`` / +``optional-skills/migration/openclaw-migration/scripts/openclaw_to_hermes.py``): +detect → parse → map → apply, with a mandatory preview phase, per-item +imported/skipped/conflict/error records, and a ``--dry-run`` that writes +nothing. The memory-entry merge and allowlist-merge primitives here are +self-contained ports of the openclaw script's equivalents so this command +works even when the optional migration skill is not installed. + +Mappings +-------- +claude-code (~/.claude): + CLAUDE.md → memory entries in HERMES_HOME/memories/MEMORY.md + settings.json permissions.allow → config.yaml command_allowlist (Bash(...) rules) + settings.json permissions.deny → config.yaml approvals.deny (Bash(...) rules) + mcpServers (~/.claude.json or settings.json) → config.yaml mcp_servers + skills//SKILL.md → HERMES_HOME/skills/claude-code-imports// + +codex (~/.codex): + AGENTS.md → memory entries in HERMES_HOME/memories/MEMORY.md + config.toml [mcp_servers.*] → config.yaml mcp_servers + memories/*.md → memory entries in HERMES_HOME/memories/MEMORY.md + skills//SKILL.md → HERMES_HOME/skills/codex-imports// + +Secrets are NEVER imported: credential files (.credentials.json, auth.json) +are ignored, and MCP server env vars with secret-looking names (KEY, TOKEN, +SECRET, PASSWORD, ...) are stripped and reported so the user can re-add them +deliberately via ``hermes setup`` or config.yaml. +""" + +from __future__ import annotations + +import json +import logging +import re +import shutil +import sys +from pathlib import Path +from typing import Any, Dict, List, Optional, Sequence, Tuple + +logger = logging.getLogger(__name__) + +# Same entry delimiter as the Hermes memory store and the openclaw migration +# script — memories/MEMORY.md entries are separated by bare "§" lines. +ENTRY_DELIMITER = "\n§\n" + +# Character budget for merged memory files (matches the openclaw script's +# default memory limit). +MEMORY_CHAR_LIMIT = 20_000 + +SUPPORTED_AGENTS = ("claude-code", "codex") + +_AGENT_DEFAULT_DIRS = { + "claude-code": ".claude", + "codex": ".codex", +} + +_SKILL_CATEGORY = { + "claude-code": "claude-code-imports", + "codex": "codex-imports", +} + +# Env var names that look like credentials — never copied into config.yaml. +_SECRET_KEY_RE = re.compile( + r"(?:^|_)(?:API[_-]?KEY|APIKEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?|" + r"AUTH|PRIVATE[_-]?KEY|ACCESS[_-]?KEY)(?:_|$)|KEY$", + re.IGNORECASE, +) + +# Files inside the source tree that hold credentials — never read. +_CREDENTIAL_FILENAMES = (".credentials.json", "auth.json", "credentials.json") + + +def is_secret_key(key: str) -> bool: + """Return True when an env-var name looks like a credential.""" + return bool(_SECRET_KEY_RE.search(key or "")) + + +def normalize_text(text: str) -> str: + return re.sub(r"\s+", " ", (text or "").strip()).lower() + + +def read_text(path: Path) -> str: + return path.read_text(encoding="utf-8", errors="replace") + + +def load_yaml_file(path: Path) -> Dict[str, Any]: + import yaml + + if not path.exists(): + return {} + try: + data = yaml.safe_load(read_text(path)) + except Exception: + return {} + return data if isinstance(data, dict) else {} + + +def dump_yaml_file(path: Path, data: Dict[str, Any]) -> None: + import yaml + + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text( + yaml.safe_dump(data, default_flow_style=False, sort_keys=False, + allow_unicode=True), + encoding="utf-8", + ) + + +# --------------------------------------------------------------------------- +# Memory-entry primitives (ported from openclaw_to_hermes.py) +# --------------------------------------------------------------------------- + +def extract_markdown_entries(text: str) -> List[str]: + """Split a markdown document into individual memory entries. + + Headings become context prefixes, bullets and paragraphs become entries. + Code blocks and tables are skipped. Port of the openclaw migration + script's extractor. + """ + entries: List[str] = [] + headings: List[str] = [] + paragraph_lines: List[str] = [] + + def context_prefix() -> str: + filtered = [ + h for h in headings + if h and not re.search( + r"\b(MEMORY|USER|SOUL|AGENTS|TOOLS|IDENTITY|CLAUDE)\.md\b", + h, re.I, + ) + ] + return " > ".join(filtered) + + def flush_paragraph() -> None: + nonlocal paragraph_lines + if not paragraph_lines: + return + block = " ".join(line.strip() for line in paragraph_lines).strip() + paragraph_lines = [] + if not block: + return + prefix = context_prefix() + entries.append(f"{prefix}: {block}" if prefix else block) + + in_code_block = False + for raw_line in (text or "").splitlines(): + line = raw_line.rstrip() + stripped = line.strip() + + if stripped.startswith("```"): + in_code_block = not in_code_block + flush_paragraph() + continue + if in_code_block: + continue + + heading_match = re.match(r"^(#{1,6})\s+(.*\S)\s*$", stripped) + if heading_match: + flush_paragraph() + level = len(heading_match.group(1)) + value = heading_match.group(2).strip() + while len(headings) >= level: + headings.pop() + headings.append(value) + continue + + bullet_match = re.match(r"^\s*(?:[-*]|\d+\.)\s+(.*\S)\s*$", line) + if bullet_match: + flush_paragraph() + content = bullet_match.group(1).strip() + prefix = context_prefix() + entries.append(f"{prefix}: {content}" if prefix else content) + continue + + if not stripped: + flush_paragraph() + continue + + if stripped.startswith("|") and stripped.endswith("|"): + flush_paragraph() + continue + + paragraph_lines.append(stripped) + + flush_paragraph() + + deduped: List[str] = [] + seen = set() + for entry in entries: + normalized = normalize_text(entry) + if not normalized or normalized in seen: + continue + seen.add(normalized) + deduped.append(entry.strip()) + return deduped + + +def parse_existing_memory_entries(path: Path) -> List[str]: + if not path.exists(): + return [] + raw = read_text(path) + if not raw.strip(): + return [] + if ENTRY_DELIMITER in raw: + return [e.strip() for e in raw.split(ENTRY_DELIMITER) if e.strip()] + return extract_markdown_entries(raw) + + +def merge_entries( + existing: Sequence[str], + incoming: Sequence[str], + limit: int, +) -> Tuple[List[str], Dict[str, int]]: + merged = list(existing) + seen = {normalize_text(e) for e in existing if e.strip()} + stats = {"existing": len(existing), "added": 0, "duplicates": 0, "overflowed": 0} + + current_len = len(ENTRY_DELIMITER.join(merged)) if merged else 0 + for entry in incoming: + normalized = normalize_text(entry) + if not normalized: + continue + if normalized in seen: + stats["duplicates"] += 1 + continue + candidate_len = ( + len(entry) if not merged + else current_len + len(ENTRY_DELIMITER) + len(entry) + ) + if candidate_len > limit: + stats["overflowed"] += 1 + continue + merged.append(entry) + seen.add(normalized) + current_len = candidate_len + stats["added"] += 1 + return merged, stats + + +# --------------------------------------------------------------------------- +# Claude Code permission rules → Hermes command patterns +# --------------------------------------------------------------------------- + +_BASH_RULE_RE = re.compile(r"^Bash\((?P.*)\)$") + + +def claude_rule_to_command_pattern(rule: str) -> Optional[str]: + """Convert a Claude Code ``Bash(...)`` permission rule into a Hermes glob. + + ``Bash(npm run build)`` → ``npm run build`` + ``Bash(npm run test:*)`` → ``npm run test*`` (Claude ':*' prefix match) + ``Bash(git diff *)`` → ``git diff *`` + ``Bash`` → None (blanket rule, too broad to import) + Non-Bash rules (``Read(...)``, ``WebFetch(...)``, ...) → None: they gate + Claude-specific tools with no command-allowlist equivalent. + """ + rule = (rule or "").strip() + m = _BASH_RULE_RE.match(rule) + if not m: + return None + inner = m.group("inner").strip() + if not inner: + return None + if inner.endswith(":*"): + inner = inner[:-2] + "*" + return inner + + +# --------------------------------------------------------------------------- +# Detection +# --------------------------------------------------------------------------- + +def default_source_dir(agent: str) -> Path: + return Path.home() / _AGENT_DEFAULT_DIRS[agent] + + +def detect_agents() -> List[str]: + """Return the list of supported agents whose default dirs exist.""" + return [a for a in SUPPORTED_AGENTS if default_source_dir(a).is_dir()] + + +def sanitize_mcp_env(env: Any) -> Tuple[Dict[str, str], List[str]]: + """Split an MCP server env dict into (kept, stripped-secret-names).""" + kept: Dict[str, str] = {} + stripped: List[str] = [] + if not isinstance(env, dict): + return kept, stripped + for key, value in env.items(): + if is_secret_key(str(key)): + stripped.append(str(key)) + else: + kept[str(key)] = value + return kept, stripped + + +# --------------------------------------------------------------------------- +# Importer +# --------------------------------------------------------------------------- + +class AgentImporter: + """Detect/parse/map/apply importer for a single agent source tree. + + ``execute=False`` runs the full plan without touching disk (dry run); + ``execute=True`` applies it. Every item is recorded as + imported/skipped/conflict/error with a human-readable reason so the CLI + can print a per-item report. + """ + + def __init__( + self, + agent: str, + source_root: Path, + target_root: Path, + execute: bool = False, + overwrite: bool = False, + ) -> None: + if agent not in SUPPORTED_AGENTS: + raise ValueError(f"Unsupported agent: {agent!r}") + self.agent = agent + self.source_root = Path(source_root) + self.target_root = Path(target_root) + self.execute = execute + self.overwrite = overwrite + self.items: List[Dict[str, Any]] = [] + self.stripped_secrets: List[str] = [] + + # -- reporting --------------------------------------------------------- + + def record(self, kind: str, source, destination, status: str, + reason: str = "", **details) -> None: + item: Dict[str, Any] = { + "kind": kind, + "source": str(source) if source else None, + "destination": str(destination) if destination else None, + "status": status, + "reason": reason, + } + if details: + item.update(details) + self.items.append(item) + + def build_report(self) -> Dict[str, Any]: + summary = {"imported": 0, "skipped": 0, "conflict": 0, "error": 0} + for item in self.items: + status = item.get("status", "skipped") + summary[status] = summary.get(status, 0) + 1 + report: Dict[str, Any] = { + "agent": self.agent, + "source": str(self.source_root), + "target": str(self.target_root), + "dry_run": not self.execute, + "items": self.items, + "summary": summary, + } + if self.stripped_secrets: + report["stripped_secrets"] = sorted(set(self.stripped_secrets)) + return report + + # -- orchestration ----------------------------------------------------- + + def run(self) -> Dict[str, Any]: + if not self.source_root.is_dir(): + self.record("source", self.source_root, None, "error", + "Source directory does not exist") + return self.build_report() + if self.agent == "claude-code": + self._run_claude_code() + else: + self._run_codex() + return self.build_report() + + def _run_claude_code(self) -> None: + settings = self._load_claude_settings() + self.import_context_file(self.source_root / "CLAUDE.md", kind="claude-md") + self.import_permission_allowlist(settings) + self.import_permission_denylist(settings) + self.import_mcp_servers(self._claude_mcp_servers(settings), kind="mcp-servers") + self.import_skills(self.source_root / "skills") + commands_dir = self.source_root / "commands" + if commands_dir.is_dir() and any(commands_dir.glob("*.md")): + self.record( + "slash-commands", commands_dir, None, "skipped", + "Claude slash commands have no direct Hermes equivalent — " + "consider converting them into skills", + ) + + def _run_codex(self) -> None: + config = self._load_codex_config() + self.import_context_file(self.source_root / "AGENTS.md", kind="agents-md") + mcp = config.get("mcp_servers") if isinstance(config, dict) else None + self.import_mcp_servers(mcp if isinstance(mcp, dict) else {}, + kind="mcp-servers") + self.import_memories_dir(self.source_root / "memories") + self.import_skills(self.source_root / "skills") + + # -- parsers (fail soft: bad files become per-item error records) ------- + + def _load_claude_settings(self) -> Dict[str, Any]: + path = self.source_root / "settings.json" + if not path.exists(): + self.record("settings", None, None, "skipped", + "No settings.json found") + return {} + try: + data = json.loads(read_text(path)) + except (json.JSONDecodeError, OSError) as exc: + self.record("settings", path, None, "error", + f"Could not parse settings.json: {exc}") + return {} + if not isinstance(data, dict): + self.record("settings", path, None, "error", + "settings.json is not a JSON object") + return {} + return data + + def _claude_mcp_servers(self, settings: Dict[str, Any]) -> Dict[str, Any]: + """Collect mcpServers from ~/.claude.json (preferred) and settings.json.""" + servers: Dict[str, Any] = {} + # ~/.claude.json lives NEXT TO ~/.claude/, not inside it + claude_json = self.source_root.parent / ".claude.json" + if claude_json.exists(): + try: + data = json.loads(read_text(claude_json)) + if isinstance(data, dict) and isinstance(data.get("mcpServers"), dict): + servers.update(data["mcpServers"]) + except (json.JSONDecodeError, OSError) as exc: + self.record("mcp-servers", claude_json, None, "error", + f"Could not parse .claude.json: {exc}") + from_settings = settings.get("mcpServers") + if isinstance(from_settings, dict): + for name, srv in from_settings.items(): + servers.setdefault(name, srv) + return servers + + def _load_codex_config(self) -> Dict[str, Any]: + path = self.source_root / "config.toml" + if not path.exists(): + self.record("config", None, None, "skipped", + "No config.toml found") + return {} + try: + import tomllib + data = tomllib.loads(read_text(path)) + except Exception as exc: + self.record("config", path, None, "error", + f"Could not parse config.toml: {exc}") + return {} + return data if isinstance(data, dict) else {} + + # -- mappers ------------------------------------------------------------- + + def import_context_file(self, source: Path, kind: str) -> None: + """CLAUDE.md / AGENTS.md → memory entries in memories/MEMORY.md.""" + destination = self.target_root / "memories" / "MEMORY.md" + if not source.exists(): + self.record(kind, None, destination, "skipped", + f"No {source.name} found") + return + try: + incoming = extract_markdown_entries(read_text(source)) + except OSError as exc: + self.record(kind, source, destination, "error", + f"Could not read file: {exc}") + return + if not incoming: + self.record(kind, source, destination, "skipped", + "No importable entries found") + return + self._merge_memory_entries(kind, source, destination, incoming) + + def import_memories_dir(self, memories_dir: Path) -> None: + """codex memories/*.md → memory entries in memories/MEMORY.md.""" + destination = self.target_root / "memories" / "MEMORY.md" + if not memories_dir.is_dir(): + self.record("memories", None, destination, "skipped", + "No memories directory found") + return + incoming: List[str] = [] + for md_file in sorted(memories_dir.glob("*.md")): + try: + incoming.extend(extract_markdown_entries(read_text(md_file))) + except OSError as exc: + self.record("memories", md_file, destination, "error", + f"Could not read file: {exc}") + if not incoming: + self.record("memories", memories_dir, destination, "skipped", + "No importable entries found") + return + self._merge_memory_entries("memories", memories_dir, destination, incoming) + + def _merge_memory_entries(self, kind: str, source: Path, + destination: Path, incoming: List[str]) -> None: + existing = parse_existing_memory_entries(destination) + merged, stats = merge_entries(existing, incoming, MEMORY_CHAR_LIMIT) + details = { + "existing_entries": stats["existing"], + "added_entries": stats["added"], + "duplicate_entries": stats["duplicates"], + "overflowed_entries": stats["overflowed"], + } + if stats["added"] == 0: + self.record(kind, source, destination, "skipped", + "No new entries to import", **details) + return + if self.execute: + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_text( + ENTRY_DELIMITER.join(merged) + ("\n" if merged else ""), + encoding="utf-8", + ) + self.record(kind, source, destination, "imported", **details) + else: + self.record(kind, source, destination, "imported", + "Would merge entries", **details) + + def import_permission_allowlist(self, settings: Dict[str, Any]) -> None: + """settings.json permissions.allow → config.yaml command_allowlist.""" + destination = self.target_root / "config.yaml" + permissions = settings.get("permissions") + allow = permissions.get("allow") if isinstance(permissions, dict) else None + if not isinstance(allow, list) or not allow: + self.record("command-allowlist", None, destination, "skipped", + "No permissions.allow rules found") + return + + patterns: List[str] = [] + skipped_rules: List[str] = [] + for rule in allow: + if not isinstance(rule, str): + continue + pattern = claude_rule_to_command_pattern(rule) + if pattern: + patterns.append(pattern) + else: + skipped_rules.append(rule) + patterns = sorted(dict.fromkeys(patterns)) + if not patterns: + self.record("command-allowlist", None, destination, "skipped", + "No Bash(...) allow rules to import", + unmapped_rules=skipped_rules) + return + + config = load_yaml_file(destination) + current = config.get("command_allowlist", []) + if not isinstance(current, list): + current = [] + merged = sorted(dict.fromkeys(list(current) + patterns)) + added = [p for p in merged if p not in current] + if not added: + self.record("command-allowlist", "settings.json permissions.allow", + destination, "skipped", "All patterns already present") + return + details: Dict[str, Any] = {"added_patterns": added} + if skipped_rules: + details["unmapped_rules"] = skipped_rules + if self.execute: + config["command_allowlist"] = merged + dump_yaml_file(destination, config) + self.record("command-allowlist", "settings.json permissions.allow", + destination, "imported", **details) + else: + self.record("command-allowlist", "settings.json permissions.allow", + destination, "imported", "Would merge patterns", **details) + + def import_permission_denylist(self, settings: Dict[str, Any]) -> None: + """settings.json permissions.deny → config.yaml approvals.deny.""" + destination = self.target_root / "config.yaml" + permissions = settings.get("permissions") + deny = permissions.get("deny") if isinstance(permissions, dict) else None + if not isinstance(deny, list) or not deny: + self.record("command-denylist", None, destination, "skipped", + "No permissions.deny rules found") + return + + patterns: List[str] = [] + for rule in deny: + if not isinstance(rule, str): + continue + pattern = claude_rule_to_command_pattern(rule) + if pattern: + patterns.append(pattern) + patterns = sorted(dict.fromkeys(patterns)) + if not patterns: + self.record("command-denylist", None, destination, "skipped", + "No Bash(...) deny rules to import") + return + + config = load_yaml_file(destination) + approvals = config.get("approvals") + if not isinstance(approvals, dict): + approvals = {} + current = approvals.get("deny", []) + if not isinstance(current, list): + current = [] + merged = sorted(dict.fromkeys(list(current) + patterns)) + added = [p for p in merged if p not in current] + if not added: + self.record("command-denylist", "settings.json permissions.deny", + destination, "skipped", "All patterns already present") + return + if self.execute: + approvals["deny"] = merged + config["approvals"] = approvals + dump_yaml_file(destination, config) + self.record("command-denylist", "settings.json permissions.deny", + destination, "imported", added_patterns=added) + else: + self.record("command-denylist", "settings.json permissions.deny", + destination, "imported", "Would merge patterns", + added_patterns=added) + + def import_mcp_servers(self, servers: Dict[str, Any], kind: str) -> None: + """mcpServers / [mcp_servers.*] → config.yaml mcp_servers.""" + destination = self.target_root / "config.yaml" + if not servers: + self.record(kind, None, destination, "skipped", + "No MCP servers found") + return + + config = load_yaml_file(destination) + existing = config.get("mcp_servers") + if not isinstance(existing, dict): + existing = {} + added = 0 + for name, srv in servers.items(): + if not isinstance(srv, dict): + self.record(kind, name, None, "skipped", + "Server entry is not a mapping") + continue + if name in existing and not self.overwrite: + self.record(kind, name, f"mcp_servers.{name}", "conflict", + "MCP server already exists in Hermes config") + continue + + hermes_srv: Dict[str, Any] = {} + if srv.get("command"): + hermes_srv["command"] = srv["command"] + if srv.get("args"): + hermes_srv["args"] = srv["args"] + env_kept, env_stripped = sanitize_mcp_env(srv.get("env")) + if env_kept: + hermes_srv["env"] = env_kept + if env_stripped: + self.stripped_secrets.extend( + f"mcp_servers.{name}.env.{k}" for k in env_stripped + ) + if srv.get("cwd"): + hermes_srv["cwd"] = srv["cwd"] + if srv.get("url"): + hermes_srv["url"] = srv["url"] + headers = srv.get("headers") + if isinstance(headers, dict): + kept_headers = { + k: v for k, v in headers.items() + if not is_secret_key(str(k)) + and "authorization" not in str(k).lower() + } + if kept_headers: + hermes_srv["headers"] = kept_headers + for k in headers: + if k not in kept_headers: + self.stripped_secrets.append( + f"mcp_servers.{name}.headers.{k}" + ) + if not hermes_srv: + self.record(kind, name, None, "skipped", + "Server has neither a command nor a url") + continue + + existing[name] = hermes_srv + added += 1 + self.record(kind, name, f"config.yaml mcp_servers.{name}", + "imported") + + if added > 0 and self.execute: + config["mcp_servers"] = existing + dump_yaml_file(destination, config) + + def import_skills(self, source_root: Path) -> None: + """skills//SKILL.md dirs → HERMES_HOME/skills//.""" + category = _SKILL_CATEGORY[self.agent] + destination_root = self.target_root / "skills" / category + if not source_root.is_dir(): + self.record("skills", None, destination_root, "skipped", + "No skills directory found") + return + skill_dirs = [ + p for p in sorted(source_root.iterdir()) + if p.is_dir() and (p / "SKILL.md").exists() + ] + if not skill_dirs: + self.record("skills", source_root, destination_root, "skipped", + "No skills with SKILL.md found") + return + for skill_dir in skill_dirs: + destination = destination_root / skill_dir.name + if destination.exists() and not self.overwrite: + self.record("skill", skill_dir, destination, "conflict", + "Destination skill already exists") + continue + if self.execute: + destination.parent.mkdir(parents=True, exist_ok=True) + if destination.exists(): + shutil.rmtree(destination) + shutil.copytree(skill_dir, destination) + self.record("skill", skill_dir, destination, "imported") + else: + self.record("skill", skill_dir, destination, "imported", + "Would copy skill directory") + + +# --------------------------------------------------------------------------- +# CLI entry point +# --------------------------------------------------------------------------- + +def import_agent_command(args) -> None: + """Handle ``hermes import-agent`` (invoked from hermes_cli.main).""" + from hermes_cli.config import get_config_path, load_config, save_config + from hermes_constants import get_hermes_home + from hermes_cli.setup import ( + Colors, + color, + print_header, + print_info, + print_success, + print_error, + prompt_yes_no, + ) + + agent = getattr(args, "agent", None) + explicit_source = getattr(args, "source", None) + dry_run = getattr(args, "dry_run", False) + overwrite = getattr(args, "overwrite", False) + auto_yes = getattr(args, "yes", False) + + # -- detect -------------------------------------------------------------- + if agent is None: + detected = detect_agents() + if not detected: + print() + print_error("No supported agent setup found (~/.claude or ~/.codex).") + print_info("Specify one explicitly: hermes import-agent claude-code --source /path") + return + if len(detected) > 1 and explicit_source is None: + print() + print_info("Multiple agent setups detected: " + ", ".join(detected)) + print_info("Pick one: hermes import-agent claude-code or hermes import-agent codex") + return + agent = detected[0] + + source_dir = Path(explicit_source) if explicit_source else default_source_dir(agent) + + print() + print(color("┌─────────────────────────────────────────────────────────┐", Colors.MAGENTA)) + print(color("│ ⚕ Hermes — Import From Another Agent │", Colors.MAGENTA)) + print(color("└─────────────────────────────────────────────────────────┘", Colors.MAGENTA)) + + if not source_dir.is_dir(): + print() + print_error(f"Agent directory not found: {source_dir}") + print_info("Specify a custom path: hermes import-agent " + f"{agent} --source /path/to/{_AGENT_DEFAULT_DIRS[agent]}") + return + + hermes_home = get_hermes_home() + print() + print_header("Import Settings") + print_info(f"Agent: {agent}") + print_info(f"Source: {source_dir}") + print_info(f"Target: {hermes_home}") + print_info(f"Overwrite: {'yes' if overwrite else 'no (skip conflicts)'}") + print_info("Secrets: never imported — run 'hermes setup' for credentials") + + # Ensure config.yaml exists before the import tries to merge into it + config_path = get_config_path() + if not config_path.exists(): + save_config(load_config()) + + # -- Phase 1: preview (always) -------------------------------------------- + try: + preview = AgentImporter( + agent=agent, + source_root=source_dir.resolve(), + target_root=hermes_home.resolve(), + execute=False, + overwrite=overwrite, + ).run() + except Exception as e: + print() + print_error(f"Import preview failed: {e}") + logger.debug("import-agent preview error", exc_info=True) + return + + summary = preview.get("summary", {}) + if summary.get("imported", 0) == 0 and summary.get("conflict", 0) == 0: + print() + print_info(f"Nothing to import from {agent}.") + print_import_report(preview, dry_run=True) + return + + print() + print_header(f"Import Preview — {summary.get('imported', 0)} item(s) would be imported") + print_info("No changes have been made yet. Review the list below:") + print_import_report(preview, dry_run=True) + + if dry_run: + return + + # -- Phase 2: confirm and execute ----------------------------------------- + print() + if not auto_yes: + if not sys.stdin.isatty(): + print_info("Non-interactive session — preview only.") + print_info(f"To execute, re-run with: hermes import-agent {agent} --yes") + return + if not prompt_yes_no("Proceed with import?", default=True): + print_info("Import cancelled.") + return + + try: + report = AgentImporter( + agent=agent, + source_root=source_dir.resolve(), + target_root=hermes_home.resolve(), + execute=True, + overwrite=overwrite, + ).run() + except Exception as e: + print() + print_error(f"Import failed: {e}") + logger.debug("import-agent error", exc_info=True) + return + + print_import_report(report, dry_run=False) + print() + print_success("Import complete.") + print_info("API keys and credentials were NOT imported — run 'hermes setup' " + "to configure providers, or add them to ~/.hermes/.env.") + + +def print_import_report(report: Dict[str, Any], dry_run: bool) -> None: + """Print a formatted per-item import report (claw-migrate style).""" + from hermes_cli.setup import Colors, color, print_header, print_info + + summary = report.get("summary", {}) + print() + if dry_run: + print_header("Dry Run Results") + print_info("No files were modified. This is a preview of what would happen.") + else: + print_header("Import Results") + print() + + items = report.get("items", []) + groups = ( + ("imported", Colors.GREEN, "✓ Would import" if dry_run else "✓ Imported"), + ("conflict", Colors.YELLOW, "⚠ Conflicts (skipped — use --overwrite to force)"), + ("skipped", Colors.DIM, "─ Skipped"), + ("error", Colors.RED, "✗ Errors"), + ) + for status, col, label in groups: + group_items = [i for i in items if i.get("status") == status] + if not group_items: + continue + print(color(f" {label}:", col)) + for item in group_items: + kind = item.get("kind", "unknown") + if status == "imported": + dest = item.get("destination") or "" + dest_short = str(dest).replace(str(Path.home()), "~") + print(f" {kind:<22s} → {dest_short}") + else: + reason = item.get("reason", "") + print(f" {kind:<22s} {reason}") + print() + + stripped = report.get("stripped_secrets") or [] + if stripped: + print(color(" ⚷ Secrets stripped (never imported):", Colors.YELLOW)) + for name in stripped: + print(f" {name}") + print_info("Re-add credentials deliberately via 'hermes setup' or ~/.hermes/.env.") + print() + + parts = [] + if summary.get("imported"): + action = "would import" if dry_run else "imported" + parts.append(f"{summary['imported']} {action}") + if summary.get("conflict"): + parts.append(f"{summary['conflict']} conflict(s)") + if summary.get("skipped"): + parts.append(f"{summary['skipped']} skipped") + if summary.get("error"): + parts.append(f"{summary['error']} error(s)") + if parts: + print_info(f"Summary: {', '.join(parts)}") diff --git a/hermes_cli/approvals_suggest.py b/hermes_cli/approvals_suggest.py new file mode 100644 index 0000000000..362171f447 --- /dev/null +++ b/hermes_cli/approvals_suggest.py @@ -0,0 +1,482 @@ +"""``hermes approvals suggest`` — mine approval history into allowlist proposals. + +Hermes has no dedicated approval-decision ledger: ``always`` answers land in +``command_allowlist`` (config.yaml) via :func:`tools.approval.save_permanent_allowlist`, +while ``once``/``session`` approvals are in-memory only. What *does* persist +is the session DB (``~/.hermes/state.db``): every assistant ``terminal`` tool +call is stored with its arguments, and the paired ``role='tool'`` result +records whether the command was blocked/denied ("BLOCKED: User denied …", +"Asking the user for approval") or actually executed. + +So this module mines *implied approvals*: a command that matches a +dangerous-command class (the same :func:`tools.approval.detect_dangerous_command` +classifier that triggers the prompt) AND whose tool result is not a +block/denial marker must have been approved by the user (once, session, +always, smart-approve, or yolo) before it ran. Frequently re-approved +patterns are exactly the prompts worth turning into one-time allowlist +policy — the port of Claude Code's ``/fewer-permission-prompts``. + +Safety posture: + +* **Never auto-applies.** The default run is a dry proposal; only an explicit + ``--apply N[,M...]`` merges the chosen patterns into ``command_allowlist`` + via the existing :func:`tools.approval.save_permanent_allowlist` path. +* **Hardline commands are never proposed** — anything matched by + :func:`tools.approval.detect_hardline_command` is dropped outright. +* **Destructive / privilege / credential / obfuscation classes are never + proposed**, no matter how often they were approved. ``rm -rf build/`` + approved 100 times still never yields an ``rm`` allowlist entry. Only + benign, recoverable classes (container lifecycle, git force push, service + restarts, hermes self-management, …) are eligible. +* **Dangerous root binaries never become globs** (``rm *``, ``sudo *`` …). +""" + +from __future__ import annotations + +import json +import re +import sqlite3 +import time +from dataclasses import dataclass, field +from pathlib import Path +from typing import Iterable, Iterator, Optional + + +# --------------------------------------------------------------------------- +# Safety exclusions +# --------------------------------------------------------------------------- + +# Dangerous-class descriptions matching ANY of these are never proposed, +# regardless of approval frequency. Matched case-insensitively against the +# pattern-key/description strings produced by tools.approval's +# DANGEROUS_PATTERNS / execution-flag findings. Deliberately conservative: +# a benign class accidentally excluded costs the user one manual config edit; +# a destructive class accidentally proposed costs them data. +_UNSAFE_CLASS_PATTERNS = [ + r"delete", # recursive delete, find -delete, branch force delete, ... + r"\brm\b", # xargs with rm, find -exec rm + r"destro", # git reset --hard (destroys ...), destructive + r"wipe", + r"format", # format filesystem + r"\bdisk\b", + r"block device", + r"fork bomb", + r"kill (?:all )?process", # force/regex/all process kills + r"kill all", + r"self-termination", + r"\bsudo\b", + r"privilege", + r"credential", + r"\bssh\b", + r"shell.rc", + r"system config", + r"system file", + r"\bsql\b", # SQL DROP / TRUNCATE / DELETE without WHERE + r"\bchown\b", + r"\bchmod\b", + r"writable", # world/other-writable permissions + r"overwrite", + r"in-place edit", + r"pipe", # pipe remote/decoded content to shell + r"obfuscation", + r"remote content", + r"remote script", + r"heredoc", + r"encoded", # PowerShell encoded command execution + r"command substitution", + r"process substitution", + r"\bdd\b", + r"shutdown", + r"reboot", + r"hardline", +] +_UNSAFE_CLASS_RE = re.compile("|".join(_UNSAFE_CLASS_PATTERNS), re.IGNORECASE) + +# Root binaries that must never anchor a proposed command glob, even if the +# class survived the description filter. Prefix match for the mkfs family. +_UNSAFE_ROOT_BINARIES = { + "rm", "rmdir", "unlink", "shred", "dd", "fdisk", "parted", "wipefs", + "sudo", "doas", "su", "chmod", "chown", "chgrp", + "kill", "killall", "pkill", + "halt", "shutdown", "reboot", "poweroff", "init", + "del", "format", "truncate", "mkswap", +} +_UNSAFE_ROOT_PREFIXES = ("mkfs",) + +# Substrings in a role='tool' result that mean the command did NOT execute +# with user consent (blocked, denied, timed out, or still pending). Kept in +# sync with the message templates in tools/approval.py. +_BLOCK_MARKERS = ( + "BLOCKED (hardline)", + "BLOCKED: User denied", + "BLOCKED: Action ", + "BLOCKED: Command flagged as dangerous", + "BLOCKED: approval required", + "BLOCKED: Failed to send approval request", + "The user has NOT consented", + "Asking the user for approval", + "approval_required", + "BLOCKED by user deny rule", +) + + +@dataclass +class Proposal: + """One ranked allowlist proposal.""" + + pattern: str # command glob ("git push *") or class key + kind: str # "glob" | "class" + count: int = 0 + classes: set = field(default_factory=set) + examples: list = field(default_factory=list) + + def add_example(self, command: str) -> None: + short = command.strip() + if len(short) > 100: + short = short[:97] + "..." + if short not in self.examples and len(self.examples) < 3: + self.examples.append(short) + + +# --------------------------------------------------------------------------- +# Scan: session DB -> (command, class description) records +# --------------------------------------------------------------------------- + +def default_db_path() -> Path: + from hermes_constants import get_hermes_home + + return get_hermes_home() / "state.db" + + +def _connect_readonly(db_path: Path) -> sqlite3.Connection: + uri = f"file:{db_path}?mode=ro" + return sqlite3.connect(uri, uri=True) + + +def _iter_terminal_calls( + con: sqlite3.Connection, since_ts: float +) -> Iterator[tuple[str, str]]: + """Yield ``(tool_call_id, command)`` for every terminal tool call.""" + cur = con.execute( + "SELECT tool_calls FROM messages " + "WHERE role='assistant' AND tool_calls IS NOT NULL " + "AND tool_calls LIKE '%terminal%' AND timestamp >= ?", + (since_ts,), + ) + while True: + rows = cur.fetchmany(2000) + if not rows: + break + for (raw,) in rows: + try: + calls = json.loads(raw) + except (TypeError, ValueError): + continue + if not isinstance(calls, list): + continue + for call in calls: + if not isinstance(call, dict): + continue + fn = call.get("function") or {} + if fn.get("name") != "terminal": + continue + try: + args = json.loads(fn.get("arguments") or "{}") + except (TypeError, ValueError): + continue + command = args.get("command") + if isinstance(command, str) and command.strip(): + yield (call.get("id") or "", command) + + +def _blocked_tool_call_ids(con: sqlite3.Connection, since_ts: float) -> set: + """Collect tool_call_ids whose result shows the command never ran freely.""" + blocked: set = set() + cur = con.execute( + "SELECT tool_call_id, content FROM messages " + "WHERE role='tool' AND tool_call_id IS NOT NULL AND timestamp >= ? " + "AND (content LIKE '%BLOCKED%' OR content LIKE '%approval%')", + (since_ts,), + ) + while True: + rows = cur.fetchmany(2000) + if not rows: + break + for tool_call_id, content in rows: + if not content: + continue + if any(marker in content for marker in _BLOCK_MARKERS): + blocked.add(tool_call_id) + return blocked + + +def scan_approval_history( + db_path: Optional[Path] = None, days: int = 90 +) -> list[tuple[str, str]]: + """Return ``(command, dangerous_class_description)`` records mined from + the session DB — dangerous-classified terminal commands that actually + executed (i.e. carried an implied user approval). + """ + from tools.approval import detect_dangerous_command, detect_hardline_command + + path = Path(db_path) if db_path else default_db_path() + if not path.exists(): + return [] + + since_ts = 0.0 if days <= 0 else time.time() - days * 86400 + + records: list[tuple[str, str]] = [] + con = _connect_readonly(path) + try: + blocked = _blocked_tool_call_ids(con, since_ts) + for tool_call_id, command in _iter_terminal_calls(con, since_ts): + if tool_call_id in blocked: + continue + is_hardline, _desc = detect_hardline_command(command) + if is_hardline: + # Hardline commands are unconditionally blocked at runtime; + # never mine them (defense in depth against stale DB rows). + continue + is_dangerous, _key, description = detect_dangerous_command(command) + if not is_dangerous: + continue + records.append((command, description)) + finally: + con.close() + return records + + +# --------------------------------------------------------------------------- +# Normalize -> aggregate -> rank -> exclude +# --------------------------------------------------------------------------- + +def normalize_command(command: str) -> str: + """Fold user/hermes home prefixes and collapse whitespace. + + Reuses tools.approval's home-folding machinery so proposals are portable + across machines/users (``/home/alice/x`` -> ``~/x``). + """ + from tools.approval import ( + _rewrite_resolved_hermes_home, + _rewrite_resolved_user_home, + ) + + folded = _rewrite_resolved_user_home(_rewrite_resolved_hermes_home(command)) + return " ".join(folded.split()) + + +def is_unsafe_class(description: str) -> bool: + """True when a dangerous-class description must never be proposed.""" + return bool(_UNSAFE_CLASS_RE.search(description or "")) + + +def _unsafe_root_binary(token: str) -> bool: + tok = token.lower().rsplit("/", 1)[-1] + if tok in _UNSAFE_ROOT_BINARIES: + return True + return any(tok.startswith(p) for p in _UNSAFE_ROOT_PREFIXES) + + +def derive_glob(normalized: str) -> Optional[str]: + """Derive a narrow command glob (``git push *``) from a simple command. + + Returns None for compound commands (shell operators — the runtime + allowlist matcher refuses those anyway) and for commands anchored on an + unsafe root binary. + """ + from tools.approval import _has_allowlist_shell_operator + + if _has_allowlist_shell_operator(normalized): + return None + tokens = normalized.split() + if not tokens: + return None + if _unsafe_root_binary(tokens[0]): + return None + if len(tokens) == 1: + return tokens[0] + second = tokens[1] + if second.startswith("-") or any(ch in second for ch in "*?[$"): + return f"{tokens[0]} *" + return f"{tokens[0]} {second} *" + + +def build_proposals( + records: Iterable[tuple[str, str]], + existing: Optional[set] = None, + min_count: int = 2, + limit: int = 20, +) -> list[Proposal]: + """Aggregate scan records into a ranked, safety-filtered proposal list. + + Grain: a command glob (``git push *``) for simple commands; the + dangerous-class description itself (the same key an interactive + ``[a]lways`` answer persists) for compound commands where no safe glob + can be derived. + """ + existing = existing or set() + by_pattern: dict[tuple[str, str], Proposal] = {} + + for command, description in records: + if is_unsafe_class(description): + continue + normalized = normalize_command(command) + glob = derive_glob(normalized) + if glob is not None: + key = (glob, "glob") + else: + key = (description, "class") + pattern, kind = key + if pattern in existing: + continue + proposal = by_pattern.get(key) + if proposal is None: + proposal = by_pattern[key] = Proposal(pattern=pattern, kind=kind) + proposal.count += 1 + proposal.classes.add(description) + proposal.add_example(normalized) + + ranked = [p for p in by_pattern.values() if p.count >= max(min_count, 1)] + ranked.sort(key=lambda p: (-p.count, p.pattern)) + return ranked[: max(limit, 1)] + + +# --------------------------------------------------------------------------- +# Apply / render +# --------------------------------------------------------------------------- + +def parse_apply_indices(spec: str, total: int) -> list[int]: + """Parse ``"1,3"`` into validated zero-based indices.""" + indices: list[int] = [] + for part in (spec or "").split(","): + part = part.strip() + if not part: + continue + try: + n = int(part) + except ValueError: + raise ValueError(f"invalid selection {part!r} — expected numbers like 1,3") + if n < 1 or n > total: + raise ValueError(f"selection {n} out of range (1..{total})") + if (n - 1) not in indices: + indices.append(n - 1) + if not indices: + raise ValueError("no valid selections in --apply") + return indices + + +def apply_proposals(proposals: list[Proposal], indices: list[int]) -> set: + """Merge chosen proposal patterns into command_allowlist and persist.""" + import tools.approval as approval_module + + merged = set(approval_module.load_permanent_allowlist()) + for idx in indices: + merged.add(proposals[idx].pattern) + approval_module.save_permanent_allowlist(merged) + # Keep the in-process allowlist consistent so a long-lived process sees + # the new entries immediately (mirrors the interactive 'always' path). + approval_module.load_permanent(merged) + return merged + + +def _render_text(proposals: list[Proposal], days: int) -> None: + window = "all history" if days <= 0 else f"last {days} days" + if not proposals: + print( + f"No allowlist candidates found in approval history ({window}).\n" + "Either nothing dangerous was approved often enough " + "(see --min-count/--days), or the approved classes are " + "excluded for safety." + ) + return + print(f"Proposed command_allowlist additions (from approval history, {window}):\n") + for i, p in enumerate(proposals, 1): + kind = " (class key)" if p.kind == "class" else "" + print(f" {i}. {p.pattern} — approved {p.count}x{kind}") + for cls in sorted(p.classes): + print(f" class: {cls}") + for ex in p.examples: + print(f" e.g. {ex}") + print( + "\nNothing has been changed. Apply selected entries with:\n" + " hermes approvals suggest --apply 1,3\n" + "Entries are merged into command_allowlist in ~/.hermes/config.yaml." + ) + + +def suggest_command(args) -> int: + """Entry point for ``hermes approvals suggest``.""" + db_path = Path(args.db) if getattr(args, "db", None) else default_db_path() + days = getattr(args, "days", 90) + if not db_path.exists(): + print(f"Session database not found: {db_path}") + return 1 + + import tools.approval as approval_module + + existing = set(approval_module.load_permanent_allowlist()) + records = scan_approval_history(db_path, days=days) + proposals = build_proposals( + records, + existing=existing, + min_count=getattr(args, "min_count", 2), + limit=getattr(args, "limit", 20), + ) + + apply_spec = getattr(args, "apply_indices", None) + if apply_spec: + try: + indices = parse_apply_indices(apply_spec, len(proposals)) + except ValueError as exc: + print(f"--apply error: {exc}") + return 1 + merged = apply_proposals(proposals, indices) + applied = [proposals[i].pattern for i in indices] + if getattr(args, "json", False): + print(json.dumps({"applied": applied, "allowlist_size": len(merged)})) + else: + print("Added to command_allowlist:") + for pattern in applied: + print(f" + {pattern}") + print(f"\ncommand_allowlist now has {len(merged)} entries " + "(~/.hermes/config.yaml).") + return 0 + + if getattr(args, "json", False): + payload = { + "db": str(db_path), + "days": days, + "proposals": [ + { + "n": i, + "pattern": p.pattern, + "kind": p.kind, + "count": p.count, + "classes": sorted(p.classes), + "examples": p.examples, + } + for i, p in enumerate(proposals, 1) + ], + } + print(json.dumps(payload, indent=2)) + return 0 + + _render_text(proposals, days) + return 0 + + +def approvals_command(args) -> int: + """Dispatch ``hermes approvals ``.""" + sub = getattr(args, "approvals_command", None) + if sub == "suggest": + return suggest_command(args) + print( + "usage: hermes approvals \n" + "\n" + "subcommands:\n" + " suggest Mine past approval decisions into a proposed\n" + " command_allowlist (dry by default; --apply N,M to merge)\n" + "\n" + "Run `hermes approvals suggest -h` for details." + ) + return 1 diff --git a/hermes_cli/callbacks.py b/hermes_cli/callbacks.py index f28577cf30..69f4b6d405 100644 --- a/hermes_cli/callbacks.py +++ b/hermes_cli/callbacks.py @@ -15,11 +15,14 @@ from hermes_cli.secret_prompt import masked_secret_prompt from hermes_constants import display_hermes_home -def clarify_callback(cli, question, choices): +def clarify_callback(cli, question, choices, multi_select=False): """Prompt for clarifying question through the TUI. Sets up the interactive selection UI, then blocks until the user responds. Returns the user's choice or a timeout message. + + When ``multi_select`` is True, shows checkboxes and the user can + select multiple options with Space, confirming with Enter. """ from cli import CLI_CONFIG from tools.clarify_gateway import resolve_clarify_timeout @@ -29,11 +32,14 @@ def clarify_callback(cli, question, choices): timeout = resolve_clarify_timeout(CLI_CONFIG) response_queue = queue.Queue() is_open_ended = not choices + effective_multi = multi_select and not is_open_ended cli._clarify_state = { "question": question, "choices": choices if not is_open_ended else [], "selected": 0, + "multi_select": effective_multi, + "selected_indices": set() if effective_multi else None, "response_queue": response_queue, } cli._clarify_deadline = None if timeout <= 0 else _time.monotonic() + timeout diff --git a/hermes_cli/cli_commands_mixin.py b/hermes_cli/cli_commands_mixin.py index e447c2cac6..83ebcf5370 100644 --- a/hermes_cli/cli_commands_mixin.py +++ b/hermes_cli/cli_commands_mixin.py @@ -142,6 +142,140 @@ class CLICommandsMixin: else: print(f" ❌ {result['error']}") + def _handle_diff_command(self, command: str): + """Handle /diff — show git changes in the working directory. + + Syntax: + /diff — unstaged changes + untracked files + /diff staged — staged changes (git diff --cached) + /diff all — staged + unstaged + untracked (vs HEAD) + /diff session — everything Hermes changed (checkpoint baseline) + /diff [mode] --stat — summary only (changed files + counts) + /diff [mode] — restrict to specific paths + """ + import shlex + + try: + parts = shlex.split(command)[1:] # preserves quoted paths + except ValueError: + parts = command.split()[1:] + + stat_only = False + mode = "working" + paths: list[str] = [] + for arg in parts: + low = arg.lower() + if low in ("--stat", "stat"): + stat_only = True + elif low in ("staged", "--staged", "cached", "--cached"): + mode = "staged" + elif low in ("all", "--all", "head"): + mode = "all" + elif low == "session": + mode = "session" + else: + paths.append(arg) + + cwd = os.getenv("TERMINAL_CWD", os.getcwd()) + + if mode == "session": + self._print_session_diff(cwd, stat_only) + return + + from tools.working_diff import collect_working_diff + + result = collect_working_diff(cwd, mode=mode, paths=paths or None) + if not result.get("success"): + print(f" {result.get('error', 'Could not generate diff')}") + return + + stat = result.get("stat", "") + diff = result.get("diff", "") + untracked = result.get("untracked", []) + if result.get("empty") or (not stat and not diff and not untracked): + print(" No changes.") + return + + label = {"working": "Unstaged", "staged": "Staged", "all": "All (vs HEAD)"}[mode] + if stat: + print(f"\n {label}:") + self._print_diff_text(stat) + if untracked and mode in ("working", "all"): + print("\n Untracked:") + for rel in untracked[:20]: + print(f" + {rel}") + if len(untracked) > 20: + print(f" ... and {len(untracked) - 20} more") + if stat_only or not diff: + return + + diff_lines = diff.splitlines() + print("") + if len(diff_lines) > 400: + self._print_diff_text("\n".join(diff_lines[:400])) + print( + f"\n ... ({len(diff_lines) - 400} more lines — " + "run /diff --stat for a summary)" + ) + else: + self._print_diff_text(diff) + + def _print_session_diff(self, cwd: str, stat_only: bool): + """Print the cumulative checkpoint-baseline diff (/diff session).""" + if not hasattr(self, 'agent') or not self.agent: + print(" No active agent session.") + return + + mgr = self.agent._checkpoint_mgr + if not mgr.enabled: + print(" Checkpoints are not enabled, so there's no session baseline.") + print(" Enable with: hermes --checkpoints") + print(" Or in config.yaml: checkpoints: { enabled: true }") + print(" (Plain /diff still works — it uses git directly.)") + return + + result = mgr.session_diff(cwd) + if not result.get("success"): + print(f" {result.get('error', 'Could not generate diff')}") + return + + stat = result.get("stat", "") + diff = result.get("diff", "") + if result.get("empty") or (not stat and not diff): + print(" No changes — Hermes hasn't edited any files here yet.") + return + + if stat: + self._print_diff_text(f"\n{stat}") + if stat_only or not diff: + return + diff_lines = diff.splitlines() + print("") + if len(diff_lines) > 400: + self._print_diff_text("\n".join(diff_lines[:400])) + print( + f"\n ... ({len(diff_lines) - 400} more lines — " + "run /diff session --stat for a summary)" + ) + else: + self._print_diff_text(diff) + + def _print_diff_text(self, text: str) -> None: + """Render diff/stat text with color when a rich console is present. + + Falls back to plain print when the console isn't available (e.g. unit + tests instantiating the mixin standalone). + """ + console = getattr(self, "console", None) + if console is not None: + try: + from cli import _rich_text_from_ansi + console.print(_rich_text_from_ansi(text)) + return + except Exception: + pass + print(text) + def _handle_snapshot_command(self, command: str): """Handle /snapshot — lightweight state snapshots for Hermes config/state. @@ -286,15 +420,44 @@ class CLICommandsMixin: delegations = list_async_delegations() except Exception: delegations = [] - running_d = [d for d in delegations if d.get("status") == "running"] + running_d = [ + d for d in delegations + if d.get("status") in ("running", "stalling") + ] if delegations: _cprint(f" Background delegations: {len(running_d)} running") for d in delegations: goal = (d.get("goal") or "")[:60] - _cprint( + status = d.get("status", "?") + line = ( f" {d.get('delegation_id', '?')} · " - f"{d.get('status', '?')} · {goal}" + f"{status} · {goal}" ) + # Live-status detail for in-flight delegations (#51690). + if status == "stalling": + quiet = d.get("stalled_after_quiet_seconds") + if quiet is not None: + line += ( + f" · no progress {quiet:.0f}s — interrupting" + ) + elif status in ("running",): + quiet = d.get("seconds_since_progress") + if quiet is not None and quiet >= 60: + line += f" · quiet {quiet:.0f}s" + _cprint(line) + for i, child in enumerate(d.get("children_activity") or []): + if not isinstance(child, dict): + continue + tool = child.get("current_tool") + doing = f"in {tool}" if tool else "between turns" + part = ( + f" └ child {i + 1}: " + f"{child.get('api_calls', '?')} api calls · {doing}" + ) + idle = child.get("seconds_since_activity") + if idle is not None: + part += f" · last activity {idle:.0f}s ago" + _cprint(part) agent_running = getattr(self, "_agent_running", False) _cprint(f" Agent: {'running' if agent_running else 'idle'}") @@ -1613,6 +1776,32 @@ class CLICommandsMixin: else: # pragma: no cover - defensive (no live input loop) print(" /learn needs an active chat session to run.") + def _handle_init_command(self, cmd: str): + """Handle /init — generate or update AGENTS.md from a project scan. + + Mirrors /learn: build a guidance-laden prompt and inject it onto the + agent's input queue as a normal user turn. The live agent scans the + project with its own read-only tools and writes/updates AGENTS.md via + ``write_file``. No engine, no model-tool footprint, works on any + terminal backend, and preserves prompt-cache invariants (no system + prompt or history mutation). + """ + from hermes_cli.init_command import build_init_prompt_for_cwd + + # Everything after the command word is optional user emphasis. + parts = cmd.strip().split(None, 1) + extra = parts[1].strip() if len(parts) > 1 else "" + + msg = build_init_prompt_for_cwd(extra=extra) + if "UPDATE the existing AGENTS.md" in msg: + print("\n⚡ Updating AGENTS.md from a project scan...") + else: + print("\n⚡ Generating AGENTS.md from a project scan...") + if hasattr(self, "_pending_input"): + self._pending_input.put(msg) + else: # pragma: no cover - defensive (no live input loop) + print(" /init needs an active chat session to run.") + def _handle_memory_command(self, cmd: str): """Handle /memory slash command — pending review + approval-gate toggle.""" from hermes_cli.write_approval_commands import handle_pending_subcommand @@ -2437,6 +2626,158 @@ class CLICommandsMixin: # right after process_command() returns (see cli.py main loop). self._pending_agent_seed = composed + def _handle_focus_command(self, cmd_original: str) -> None: + """Toggle or inspect focus view — the reduced-output display mode. + + Usage: + /focus → toggle + /focus on|off → explicit + /focus status → show current state + + Focus view is a DISPLAY-ONLY mode. It composes with the existing + ``/verbose`` tool-progress machinery rather than adding a second + suppression mechanism: turning it on snaps ``tool_progress_mode`` to + ``"off"`` (the same value ``/verbose off`` uses, honoured by + ``agent/tool_executor.py`` and ``_on_tool_progress``) after stashing + whatever mode the user had, and turning it off restores that mode + verbatim. On top of that it adds the two things ``/verbose off`` + lacks: a per-turn hidden-line count with a recovery hint, and a + persistent ``focus`` segment in the status bar. + + Nothing here touches conversation history, the system prompt, or any + request payload — the model sees an identical turn either way. + """ + from cli import _cprint, save_config_value + from hermes_cli.colors import Colors as _Colors + from hermes_cli.focus_view import ( + FOCUS_CONFIG_KEY, + FOCUS_TOOL_PROGRESS_MODE, + format_focus_status, + format_focus_toggle_message, + normalize_tool_progress_mode, + resolve_focus_arg, + ) + + arg = "" + try: + parts = (cmd_original or "").strip().split(None, 1) + if len(parts) > 1: + arg = parts[1].strip() + except Exception: + arg = "" + + current = bool(getattr(self, "_focus_view_enabled", False)) + action, target = resolve_focus_arg(arg, current) + + if action == "usage": + _cprint(" Usage: /focus [on|off|status]") + return + + # The mode /focus off will restore. While focus is ON the live + # tool_progress_mode is "off", so the pre-focus mode is the stash. + restore_mode = normalize_tool_progress_mode( + getattr(self, "_focus_saved_tool_progress", None) + if current + else getattr(self, "tool_progress_mode", "all") + ) + + if action == "status": + body = format_focus_status(current, restore_mode) + head, _, tail = body.partition("\n") + label, _, rest = head.partition(":") + state_color = _Colors.GREEN if current else _Colors.DIM + _cprint( + f" {_Colors.BOLD}{label}:{_Colors.RESET}" + f"{state_color}{rest}{_Colors.RESET}" + + (f"\n{_Colors.DIM} {tail.strip()}{_Colors.RESET}" if tail else "") + ) + return + + if target == current: + # Idempotent explicit set — report without rewriting config. + _cprint(f" {format_focus_toggle_message(current, restore_mode)}") + return + + if target: + # Stash the user's configured mode, then reuse the EXISTING + # suppression path by snapping to "off". + self._focus_saved_tool_progress = restore_mode + self._set_tool_progress_mode(FOCUS_TOOL_PROGRESS_MODE) + else: + self._set_tool_progress_mode(restore_mode) + self._focus_saved_tool_progress = None + + self._focus_view_enabled = bool(target) + self._focus_hidden_lines = 0 + save_config_value(FOCUS_CONFIG_KEY, bool(target)) + + state = ( + f"{_Colors.GREEN}enabled{_Colors.RESET}" if target + else f"{_Colors.DIM}disabled{_Colors.RESET}" + ) + message = format_focus_toggle_message(bool(target), restore_mode) + # Re-colour just the enabled/disabled word so the line matches siblings. + for word in ("enabled", "disabled"): + if word in message: + message = message.replace(word, state, 1) + break + _cprint(f" {message}") + + def _set_tool_progress_mode(self, mode: str) -> None: + """Set the live tool-progress mode on both the CLI and the agent. + + Extracted so ``/focus`` and ``/verbose`` share one write path — the + agent copy is what ``agent/tool_executor.py`` gates on, and forgetting + it means the new mode only takes effect after an agent rebuild. + """ + from hermes_cli.focus_view import normalize_tool_progress_mode + + normalized = normalize_tool_progress_mode(mode) + self.tool_progress_mode = normalized + agent = getattr(self, "agent", None) + if agent is not None: + try: + agent.tool_progress_mode = normalized + except Exception: + pass + + def _note_focus_hidden_line(self, function_name: str) -> None: + """Count one tool line that focus view is suppressing this turn. + + Counted against the mode the user had BEFORE focus snapped things to + "off", so a user who already ran ``/verbose off`` is never told that + focus hid lines it did not hide. + """ + if not getattr(self, "_focus_view_enabled", False): + return + from hermes_cli.focus_view import would_display_tool_line + + saved = getattr(self, "_focus_saved_tool_progress", None) + last = getattr(self, "_focus_last_counted_tool", None) + if not would_display_tool_line(saved, function_name, last): + return + self._focus_last_counted_tool = function_name + self._focus_hidden_lines = int(getattr(self, "_focus_hidden_lines", 0)) + 1 + + def _emit_focus_recovery_line(self) -> None: + """Print the dim post-turn recovery line and reset the counter.""" + count = int(getattr(self, "_focus_hidden_lines", 0) or 0) + self._focus_hidden_lines = 0 + self._focus_last_counted_tool = None + if not getattr(self, "_focus_view_enabled", False): + return + from hermes_cli.focus_view import format_hidden_line + + line = format_hidden_line(count) + if not line: + return + try: + from cli import _DIM, _RST, _cprint + + _cprint(f" {_DIM}{line}{_RST}") + except Exception: + pass + def _handle_footer_command(self, cmd_original: str) -> None: """Toggle or inspect ``display.runtime_footer.enabled`` from the CLI. diff --git a/hermes_cli/commands.py b/hermes_cli/commands.py index bad2250da0..368f5c745e 100644 --- a/hermes_cli/commands.py +++ b/hermes_cli/commands.py @@ -120,6 +120,8 @@ COMMAND_REGISTRY: list[CommandDef] = [ CommandDef("status", "Show session, model, token, and context info", "Session"), CommandDef("egress", "Show Docker egress proxy status", "Session", args_hint="[status]", subcommands=("status",)), + CommandDef("context", "Show detailed context window view with usage gauge, category breakdown, compression stats, and throughput", "Session", + aliases=("ctx",), args_hint="[all]", subcommands=("all",)), CommandDef("whoami", "Show your slash command access (admin / user)", "Info"), CommandDef("profile", "Show active profile name and home directory", "Info"), CommandDef("sethome", "Set this chat as the home channel", "Session", @@ -149,9 +151,15 @@ COMMAND_REGISTRY: list[CommandDef] = [ CommandDef("timestamps", "Toggle [HH:MM] timestamps on messages and /history", "Configuration", cli_only=True, args_hint="[on|off|status]", subcommands=("on", "off", "status"), aliases=("ts",)), + CommandDef("diff", "Show git changes in the working directory", "Info", + args_hint="[staged|all|session] [--stat] [path...]", + subcommands=("staged", "all", "session")), CommandDef("verbose", "Cycle tool progress display: off -> new -> all -> verbose -> log", "Configuration", cli_only=True, gateway_config_gate="display.tool_progress_command"), + CommandDef("focus", "Toggle focus view — show only your prompt and the final response", + "Configuration", cli_only=True, args_hint="[on|off|status]", + subcommands=("on", "off", "status")), CommandDef("footer", "Toggle gateway runtime-metadata footer on final replies", "Configuration", args_hint="[on|off|status]", subcommands=("on", "off", "status")), @@ -196,6 +204,8 @@ COMMAND_REGISTRY: list[CommandDef] = [ "Tools & Skills", cli_only=True, aliases=("generate-pet",), args_hint="[description]"), CommandDef("learn", "Learn a reusable skill from anything you describe (dirs, URLs, this chat, notes)", "Tools & Skills", args_hint=""), + CommandDef("init", "Generate or update AGENTS.md project instructions from a repo scan", + "Tools & Skills", args_hint="[notes]"), CommandDef("cron", "Manage scheduled tasks", "Tools & Skills", cli_only=True, args_hint="[subcommand]", subcommands=("list", "add", "create", "edit", "pause", "resume", "run", "remove")), @@ -1172,7 +1182,15 @@ _SLACK_PRIORITY_ALIASES = ("btw", "bg") # displacing existing native Slack slash commands at the 50-command cap. # - debug: the log/report upload surface; reached via /hermes debug on Slack. # - egress: Docker-only proxy status; reachable as /hermes egress on Slack. -_SLACK_VIA_HERMES_ONLY = frozenset({"topup", "moa", "debug", "egress"}) +# - init: repo-scan AGENTS.md bootstrap — a cwd-centric dev command that is +# rare from Slack; reachable as /hermes init. Without this entry, adding +# /init clamps /version off the native list and breaks Telegram parity. +# - version: low-frequency info command; reachable as /hermes version on +# Slack. Demoted when /context claimed a native slot (context is a +# recurring inspection surface; version is a one-off lookup). +# - diff: git working-tree diff; reached via /hermes diff on Slack so it +# doesn't displace an existing native slash at the 50-command cap. +_SLACK_VIA_HERMES_ONLY = frozenset({"topup", "moa", "debug", "egress", "init", "version", "diff"}) def _sanitize_slack_name(raw: str) -> str: diff --git a/hermes_cli/config.py b/hermes_cli/config.py index 3e0bfc4501..77bbaa17e3 100644 --- a/hermes_cli/config.py +++ b/hermes_cli/config.py @@ -945,7 +945,7 @@ DEFAULT_CONFIG = { # pressure. Reopening one re-resumes it from disk. 0/null disables. "max_live_sessions": 16, "agent": { - "max_turns": 90, + "max_turns": 500, # Inactivity timeout for gateway agent execution (seconds). # The agent can run indefinitely as long as it's actively calling # tools or receiving API responses. Only fires when the agent has @@ -1108,6 +1108,18 @@ DEFAULT_CONFIG = { # default is 1800s) plus runtime slack. Set to 0 to disable the # gate and restore pre-fix behaviour (always inject). "gateway_auto_continue_freshness": 3600, + # Max seconds the gateway waits for boot auto-resume turns to finish + # before it releases the startup-restore inbound gate. While startup + # restore is in progress the gateway QUEUES every inbound message + # instead of replying, so no channel gets an answer until this gate + # opens. Without a bound, one pathologically long resumed turn holds + # the gate shut and every channel's inbound piles up unanswered for as + # long as that turn runs. On timeout the gate releases and the slow + # resume turn keeps running in the background; duplicate-agent + # protection is unaffected because the resume slot is claimed + # synchronously before the gate runs. Set to 0 to disable the bound + # (historical "wait forever" behaviour). + "gateway_startup_restore_drain_timeout": 30, # Stale-stream ceiling for local providers (Ollama, oMLX, llama-cpp) in # seconds. When the base stale timeout is at its default (180s) and a # local endpoint is detected, this finite ceiling replaces the former @@ -1562,21 +1574,6 @@ DEFAULT_CONFIG = { # Example: 1800 = compact after 30 min idle. }, - # Kanban subsystem (orchestrator workers + dispatcher-driven child tasks). - # See tools/kanban_tools.py and hermes_cli/kanban_db.py for the actual - # implementations. Per-platform notification opt-out is handled by the - # kanban dashboard (see ``hermes dashboard`` -> Notifications). - "kanban": { - # Auto-subscribe the originating gateway/TUI session to task - # completion + block events when ``kanban_create`` is called from - # inside a session that has a persistent delivery channel. The - # agent that dispatched the task will get notified automatically - # instead of having to poll. Disable to mirror pre-feature - # behaviour — e.g. for a profile that prefers explicit - # ``kanban_notify-subscribe`` calls per task. - "auto_subscribe_on_create": True, - }, - # Anthropic prompt caching (Claude via OpenRouter or native Anthropic API). # cache_ttl must be "5m" or "1h" (Anthropic-supported tiers); other values are ignored. "prompt_caching": { @@ -1969,6 +1966,14 @@ DEFAULT_CONFIG = { # Show a color-coded battery read-out as the first status-bar element in # the CLI/TUI (off by default). No-op on machines without a battery. "battery": False, + # Focus view (/focus): display-only reduced-output mode. When true the + # CLI/TUI pins tool_progress to "off" (reusing the existing suppression + # path), reports a per-turn hidden-line count with a recovery hint, and + # pins a "focus" segment in the status bar. focus_saved_tool_progress + # holds the mode /focus off restores. Never affects what is sent to the + # model — see hermes_cli/focus_view.py. + "focus_view": False, + "focus_saved_tool_progress": "all", "skin": "default", # UI language for static user-facing messages (approval prompts, a # handful of gateway slash-command replies). Does NOT affect agent @@ -2005,6 +2010,16 @@ DEFAULT_CONFIG = { # tool name. Applies to CLI spinner + gateway/desktop tool-progress. # Custom/plugin/MCP tools always fall back to the raw preview. "friendly_tool_labels": True, + # CLI-only post-turn accounting line printed after each interactive turn: + # "⋯ 12.4s · edited 2 files +18 -3 · read 4 files · ran 3 commands". + # Observed from the tool-progress feed the CLI already receives; never + # printed in quiet/non-interactive paths or in gateway/messaging + # surfaces (those have their own runtime footer). + "turn_summary": True, + # CLI-only: append cumulative turn output tokens to the live spinner + # timer ("⚡ Reading file ( 2.3s · ↓ 1.2k tok)"). Updates as each API + # call in the turn reports usage. + "spinner_token_flow": True, # How gateway tool-progress is grouped on platforms that support message # editing: "accumulate" (default) edits one bubble in place; "separate" # sends one message per tool (the pre-v0.9 behavior, noisier). Only @@ -2745,6 +2760,20 @@ DEFAULT_CONFIG = { "mode": "smart", "timeout": 300, "cron_mode": "deny", + # Operator-customizable policy text for smart approvals. When + # non-empty, this is appended to the smart-approval guardian's + # SYSTEM prompt (trusted channel) as additional rules — e.g. + # "Always ESCALATE commands touching /etc" or "APPROVE docker + # compose restarts under ~/deploys". Inspired by ChatGPT Work's + # customizable auto-review guardian policy. + "smart_policy": "", + # Consecutive-denial circuit breaker for smart approvals: after this + # many guardian DENY verdicts in a row within one session, the deny + # message returned to the model escalates to a hard-stop instruction + # (report to the user / ask for manual run or /approve) instead of a + # plain "Do NOT retry". Any approval resets the count. 0 disables. + # Inspired by ChatGPT Work's auto-review circuit breaker. + "denial_breaker_threshold": 3, # User-defined deny rules: fnmatch globs matched against terminal # commands. A match blocks the command unconditionally — BEFORE the # --yolo / /yolo / mode=off bypass — making this the user-editable @@ -2920,6 +2949,14 @@ DEFAULT_CONFIG = { # each claimable ready task. One dispatcher per profile is sufficient; # running more than one on the same kanban.db will race for claims. "kanban": { + # Auto-subscribe the originating gateway/TUI session to task + # completion + block events when ``kanban_create`` is called from + # inside a session that has a persistent delivery channel. The + # agent that dispatched the task will get notified automatically + # instead of having to poll. Disable to mirror pre-feature + # behaviour — e.g. for a profile that prefers explicit + # ``kanban_notify-subscribe`` calls per task. + "auto_subscribe_on_create": True, # Run the dispatcher inside the gateway process. On by default — # the cost is ~300µs every `dispatch_interval_seconds` when idle, # and gateway is the supervisor users already have. Set to false @@ -3271,14 +3308,15 @@ DEFAULT_CONFIG = { # reports 384MB+ databases with 68K+ messages, which slows down FTS5 # inserts, /resume listing, and insights queries. "sessions": { - # When true, prune ended sessions older than retention_days once + # When true, prune ended sessions inactive for retention_days once # per (roughly) min_interval_hours at CLI/gateway/cron startup. - # Only touches ended sessions — active sessions are always preserved. + # Activity is the latest message timestamp, falling back to creation + # time for empty sessions. Active sessions are always preserved. # Default false: session history is valuable for search recall, and # silently deleting it could surprise users. Opt in explicitly. "auto_prune": False, - # How many days of ended-session history to keep. Matches the - # default of ``hermes sessions prune``. + # How many inactive days of ended-session history to keep. Matches + # the default of ``hermes sessions prune``. "retention_days": 90, # When true, auto-archive (soft-hide, never delete) sessions that # haven't been touched in ``auto_archive_days`` days, once per diff --git a/hermes_cli/doctor.py b/hermes_cli/doctor.py index 7c89e75adc..9fd241630a 100644 --- a/hermes_cli/doctor.py +++ b/hermes_cli/doctor.py @@ -10,7 +10,13 @@ import subprocess import shutil from pathlib import Path -from hermes_cli.config import get_project_root, get_hermes_home, get_env_path +from hermes_cli.config import ( + detect_install_method, + get_env_path, + get_hermes_home, + get_project_root, + recommended_update_command_for_method, +) from hermes_cli.env_loader import load_hermes_dotenv from hermes_constants import display_hermes_home from hermes_constants import agent_browser_runnable @@ -72,6 +78,22 @@ def _system_package_install_cmd(pkg: str) -> str: return f"sudo apt install {pkg}" +def _sqlite_upgrade_hint(install_method: str | None = None) -> str: + """Return an actionable SQLite upgrade hint for this install layout.""" + method = install_method or detect_install_method(PROJECT_ROOT) + if method == "docker": + command = recommended_update_command_for_method(method) + action = f"run `{command}`, then recreate all Hermes containers" + elif method in {"nix", "nixos"}: + action = recommended_update_command_for_method(method) + else: + action = "run `hermes update`" + return ( + f"({action}; fixed versions: 3.51.3+ / 3.50.7 / 3.44.6 — " + "see https://sqlite.org/wal.html#walresetbug)" + ) + + def _safe_which(cmd: str) -> str | None: """shutil.which wrapper resilient to platform monkeypatching in tests.""" try: @@ -827,8 +849,7 @@ def run_doctor(args): # best-effort and unsupported installs may need manual action. check_warn( f"SQLite {_sqlite_ver} (WAL-reset bug)", - "(run `hermes update`; fixed versions: 3.51.3+ / 3.50.7 / " - "3.44.6 — see https://sqlite.org/wal.html#walresetbug)", + _sqlite_upgrade_hint(), ) else: check_ok(f"SQLite {_sqlite_ver}") diff --git a/hermes_cli/focus_view.py b/hermes_cli/focus_view.py new file mode 100644 index 0000000000..0ec6c07688 --- /dev/null +++ b/hermes_cli/focus_view.py @@ -0,0 +1,166 @@ +"""Focus view — a display-only reduced-output mode. + +``/focus`` answers one question the existing ``/verbose`` cycle cannot: +*"just show me my prompt and the answer — and tell me what you hid."* + +``/verbose off`` already silences per-tool progress lines (the +``tool_progress_mode == "off"`` gate in ``agent/tool_executor.py`` and the +scrollback gate in ``HermesCLI._on_tool_progress``). Focus view **composes +with** that machinery instead of duplicating it: + +* turning focus ON snaps ``tool_progress_mode`` to ``"off"`` and remembers the + mode the user had configured, so the *existing* suppression path does the + actual hiding; +* turning focus OFF restores that remembered mode verbatim; +* on top of that, focus view adds the two things ``/verbose off`` lacks — + a per-turn count of what was hidden plus a recovery hint, and a persistent + ``focus`` segment in the status bar so the reduced mode is never invisible. + +Everything in this module is **display-only**. Nothing here reads or mutates +conversation history, the system prompt, tool schemas, or any request payload. +Flipping focus view must never change a single byte of what is sent to the +model — that invariant is covered by +``tests/cli/test_focus_view.py::test_model_facing_messages_identical_with_focus_on_vs_off``. +""" + +from __future__ import annotations + +from typing import Optional + +# Config key used by the sibling display toggles (/battery, /timestamps, +# /footer) — a plain boolean under ``display``. +FOCUS_CONFIG_KEY = "display.focus_view" + +#: Tool-progress mode focus view snaps to. Deliberately the SAME value +#: ``/verbose off`` uses so both features share one suppression path. +FOCUS_TOOL_PROGRESS_MODE = "off" + +#: Modes in which the CLI commits a per-tool scrollback line. Mirrors the gate +#: in ``HermesCLI._on_tool_progress``; kept here so the hidden-line counter and +#: the renderer can never drift apart. +TOOL_PROGRESS_VISIBLE_MODES = frozenset({"new", "all", "verbose"}) + +#: Valid tool-progress modes (``log`` is a gateway-only extra step). +TOOL_PROGRESS_MODES = ("off", "new", "all", "verbose") + +#: Status-bar label. Short on purpose — the bar is width-constrained. +FOCUS_STATUSBAR_LABEL = "◉ focus" + +_ON_WORDS = frozenset({"on", "enable", "enabled", "true", "yes", "1"}) +_OFF_WORDS = frozenset({"off", "disable", "disabled", "false", "no", "0"}) +_STATUS_WORDS = frozenset({"status", "show", "?"}) +_TOGGLE_WORDS = frozenset({"", "toggle"}) + +FOCUS_USAGE = "Usage: /focus [on|off|status]" + + +def normalize_tool_progress_mode(mode: object, default: str = "all") -> str: + """Coerce a raw config/attr value into a known tool-progress mode. + + YAML 1.1 parses a bare ``off`` as ``False``, and older configs stored + ``True``/``False`` booleans, so this mirrors ``cli.py``'s normalisation. + """ + if mode is False: + return "off" + if mode is True: + return "all" + text = str(mode or "").strip().lower() + if text in TOOL_PROGRESS_MODES: + return text + # ``log`` is a real gateway mode; treat any other unknown value as default. + if text == "log": + return "log" + return default + + +def resolve_focus_arg(arg: str, current: bool) -> tuple[str, Optional[bool]]: + """Map a ``/focus`` argument onto an action, following the sibling toggles. + + Returns ``(action, target)`` where ``action`` is one of ``"set"``, + ``"status"`` or ``"usage"``. ``target`` is the requested enabled-state for + ``"set"`` and ``None`` otherwise. Bare ``/focus`` toggles, matching + ``/footer`` / ``/battery`` / ``/timestamps``. + """ + text = str(arg or "").strip().lower() + if text in _STATUS_WORDS: + return "status", None + if text in _ON_WORDS: + return "set", True + if text in _OFF_WORDS: + return "set", False + if text in _TOGGLE_WORDS: + return "set", not bool(current) + return "usage", None + + +def effective_tool_progress_mode(focus_enabled: bool, configured_mode: object) -> str: + """Return the tool-progress mode that should actually be in force. + + Focus view wins while it is on (it *is* "tool progress off" plus reporting). + When focus is off the user's configured mode is returned untouched — this is + what makes ``/focus off`` restore ``/verbose verbose`` rather than clobbering + it to ``all``. + """ + normalized = normalize_tool_progress_mode(configured_mode) + if focus_enabled: + return FOCUS_TOOL_PROGRESS_MODE + return normalized + + +def would_display_tool_line( + mode: object, + function_name: str, + last_tool_name: Optional[str] = None, +) -> bool: + """Would the CLI have committed a scrollback line for this tool call? + + Used to count *honestly*: if the user already had ``/verbose off``, focus + view is hiding nothing extra and must not claim otherwise. ``new`` mode + skips consecutive repeats of the same tool, so the counter skips them too. + """ + if not function_name: + return False + normalized = normalize_tool_progress_mode(mode) + if normalized not in TOOL_PROGRESS_VISIBLE_MODES: + return False + if normalized == "new" and function_name == last_tool_name: + return False + return True + + +def format_hidden_line(count: int) -> Optional[str]: + """Dim post-turn recovery line, or ``None`` when nothing was hidden.""" + try: + n = int(count) + except (TypeError, ValueError): + return None + if n <= 0: + return None + noun = "tool line" if n == 1 else "tool lines" + return f"⋯ {n} {noun} hidden · /focus off to show" + + +def focus_statusbar_segment(enabled: bool) -> str: + """Status-bar segment text for focus view (empty when off).""" + return FOCUS_STATUSBAR_LABEL if enabled else "" + + +def format_focus_status(enabled: bool, configured_mode: object) -> str: + """Human-readable ``/focus status`` body (no ANSI — callers colour it).""" + state = "ON" if enabled else "OFF" + if enabled: + restore = normalize_tool_progress_mode(configured_mode) + return ( + f"Focus view: {state} — only your prompt and the final response.\n" + f" /focus off restores tool progress: {restore.upper()}" + ) + mode = normalize_tool_progress_mode(configured_mode) + return f"Focus view: {state} — tool progress: {mode.upper()}" + + +def format_focus_toggle_message(enabled: bool, configured_mode: object) -> str: + """Confirmation line printed when focus view is switched (no ANSI).""" + if enabled: + return "Focus view enabled — just your prompt and the final response" + mode = normalize_tool_progress_mode(configured_mode) + return f"Focus view disabled — tool progress: {mode.upper()}" diff --git a/hermes_cli/gateway_windows.py b/hermes_cli/gateway_windows.py index a55200a15d..4d09ab38ff 100644 --- a/hermes_cli/gateway_windows.py +++ b/hermes_cli/gateway_windows.py @@ -744,8 +744,26 @@ def _resolve_detached_python(python_exe: str) -> tuple[str, Path, list[str]]: ``extra_pythonpath`` is always empty now; the tuple shape is kept so the call sites (argv builders, cmd/vbs renderers, restart-spec rewriter, gateway watcher) stay unchanged. + + Legacy normalization: launchers and argv snapshots from pre-aa2ae36c3f + installs lead with ``pythonw.exe``. When the sibling console + ``python.exe`` exists, swap to it so respawns and regenerated launchers + get the hidden-console design instead of resurrecting the console-less + daemon (the #54220/#56747 flash class, plus the ``sys.stderr is None`` + startup-crash class from #71671). """ p = Path(python_exe) + if p.name.lower() in ("pythonw.exe", "pythonw"): + sibling = p.with_name("python.exe" if p.suffix else "python") + try: + if sibling.exists(): + p = sibling + python_exe = str(sibling) + except OSError: + # Can't stat the sibling — keep the original interpreter. A + # console-less gateway is worse than a hidden-console one, but a + # failed respawn is worse still. + pass venv_dir = p.parent.parent return (python_exe, venv_dir, []) diff --git a/hermes_cli/init_command.py b/hermes_cli/init_command.py new file mode 100644 index 0000000000..576b84fbbc --- /dev/null +++ b/hermes_cli/init_command.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python3 +"""``/init`` — build the prompt that generates or updates a project AGENTS.md. + +Port of Codex ``/init`` (Claude Code has the same for CLAUDE.md). Hermes +already *loads* AGENTS.md / CLAUDE.md / .cursorrules as project context, but +had no command to bootstrap one. ``/init`` hands the live agent ONE +guidance-laden prompt instructing it to: + + 1. Inspect the project with its own read-only tools (``read_file`` / + ``search_files`` on manifests, CI configs, lockfiles, existing docs) to + learn the layout, toolchain, and the exact build/test/lint commands. + 2. Write a CONCISE ``AGENTS.md`` (target under 100 lines) with the sections + an agent actually needs — overview, setup, commands, conventions, + pitfalls — not an essay. + 3. If an AGENTS.md already exists, UPDATE it: preserve the user's existing + content and merge in what's missing, never blow it away. + +There is no engine and no model-tool footprint: the agent does the work with +its existing toolset, so this works identically on local, Docker, and remote +terminal backends. Every surface (CLI ``/init``, gateway ``/init``, TUI +``/init``) calls :func:`build_init_prompt` and feeds the result to the agent +as a normal user turn — the same prompt-injection pattern as ``/learn`` and +``/blueprint``, which preserves prompt-cache invariants (no system-prompt or +history mutation). +""" + +from __future__ import annotations + +# The quality bar, embedded in every prompt so the generated file reads like a +# maintainer wrote it — concrete and command-exact, not generic advice. +_QUALITY_BAR = """\ +Quality bar for the file you write (this is what separates a useful AGENTS.md +from noise): +- CONCISE: target under 100 lines. Agents load this file every session — every + line costs context. No essays, no marketing prose, no filler. +- Commands must be EXACT invocations you verified from the repo (package.json + scripts, Makefile targets, pyproject/tox/CI config, existing docs). Write + `npm run test:unit` or `scripts/run_tests.sh tests/foo`, never "run the + tests". NEVER invent a command you didn't see evidence for. +- No generic advice. "Write tests for new code" and "follow best practices" + are banned — if a line would be true of any repo, cut it. +- Conventions must be OBSERVED, not assumed: naming patterns, module layout, + error-handling style, commit-message format — only what the code actually + shows. +- Include pitfalls that would genuinely trip up a newcomer or an agent + (required env vars, generated files not to hand-edit, slow test suites, + ports already in use), if you found any. Skip the section if you found none. +- Markdown structure: a short title + one-paragraph overview, then focused + sections (e.g. "Dev environment", "Build & test", "Conventions", + "Pitfalls"). Flat and scannable — no deep nesting.""" + + +def build_init_prompt( + cwd: str, + existing_file: str | None = None, + extra: str = "", +) -> str: + """Build the agent prompt for a ``/init`` request. + + Args: + cwd: the project directory the agent should scan and write + ``AGENTS.md`` into (usually the session working directory). + existing_file: the current content of ``AGENTS.md`` if one already + exists, else ``None``. When present the prompt switches to + update-and-merge discipline instead of fresh generation. + extra: free-text the user gave after ``/init`` — emphasis or notes to + honor while authoring (e.g. "focus on the test setup"). + + Returns: + A complete instruction the agent runs as a normal turn. + """ + extra = (extra or "").strip() + + parts: list[str] = [ + "[/init] The user wants you to " + + ( + "UPDATE the existing AGENTS.md project-instructions file" + if existing_file is not None + else "generate an AGENTS.md project-instructions file" + ) + + f" for the project at: {cwd}\n", + "AGENTS.md is the instruction file coding agents (Hermes included) " + "load as project context every session. It should teach an agent how " + "to work in THIS repo: what the project is, how to set up, the exact " + "build/test/lint commands, the conventions the code actually follows, " + "and the pitfalls that waste time.\n", + "Do this:\n" + "1. Inspect the project with your read-only tools (`read_file`, " + "`search_files`) — start with manifests and toolchain files " + "(package.json, pyproject.toml, Cargo.toml, go.mod, Makefile, " + "CI workflow configs, lockfiles), then the directory layout, existing " + "README/docs, and test/lint configuration. Learn the real commands, " + "don't guess them.\n" + "2. Write the file to " + f"{cwd.rstrip('/')}/AGENTS.md with `write_file`" + + ( + " — but this is an UPDATE, so follow the merge discipline below." + if existing_file is not None + else "." + ) + + "\n" + "3. Confirm to the user the exact path you wrote and summarize in one " + "or two lines what the file covers.\n", + ] + + if existing_file is not None: + parts.append( + "MERGE DISCIPLINE — an AGENTS.md already exists (its current " + "content is below). Do NOT overwrite or regenerate it from " + "scratch. Preserve the user's existing content — their wording, " + "their sections, their rules — and merge in only what is missing " + "or verifiably stale (e.g. a command that no longer exists in the " + "repo). When existing content conflicts with what you observed, " + "prefer minimal surgical edits over rewrites, and keep the " + "user's intent. The result must still meet the quality bar.\n\n" + "CURRENT AGENTS.md CONTENT:\n" + "<< str: + """Convenience wrapper used by the dispatch surfaces. + + Resolves ``cwd`` (defaults to the process working directory), reads an + existing ``AGENTS.md`` there if present, and returns the full prompt. + """ + import os + + resolved = os.path.abspath(cwd or os.getcwd()) + existing: str | None = None + agents_path = os.path.join(resolved, "AGENTS.md") + try: + if os.path.isfile(agents_path): + with open(agents_path, encoding="utf-8", errors="replace") as fh: + existing = fh.read() + except OSError: + existing = None + return build_init_prompt(resolved, existing_file=existing, extra=extra) diff --git a/hermes_cli/kanban.py b/hermes_cli/kanban.py index d43ffba2e9..2038d15144 100644 --- a/hermes_cli/kanban.py +++ b/hermes_cli/kanban.py @@ -771,6 +771,7 @@ def build_parser(parent_subparsers: argparse._SubParsersAction) -> argparse.Argu p_nsub.add_argument("task_id") p_nsub.add_argument("--platform", required=True) p_nsub.add_argument("--chat-id", required=True) + p_nsub.add_argument("--chat-type", default="", help="dm / group / channel (used by wake routing)") p_nsub.add_argument("--thread-id", default=None) p_nsub.add_argument("--user-id", default=None) p_nsub.add_argument( @@ -2758,6 +2759,7 @@ def _cmd_notify_subscribe(args: argparse.Namespace) -> int: kb.add_notify_sub( conn, task_id=args.task_id, platform=args.platform, chat_id=args.chat_id, + chat_type=args.chat_type, thread_id=args.thread_id, user_id=args.user_id, notifier_profile=args.notifier_profile or _profile_author(), ) diff --git a/hermes_cli/kanban_db.py b/hermes_cli/kanban_db.py index 67ca9803d9..947cf317e0 100644 --- a/hermes_cli/kanban_db.py +++ b/hermes_cli/kanban_db.py @@ -87,7 +87,7 @@ import time from contextvars import ContextVar, Token from dataclasses import dataclass, field from pathlib import Path -from typing import Any, Iterable, Optional +from typing import Any, Iterable, Mapping, Optional from hermes_cli.sqlite_util import add_column_if_missing as _add_column_if_missing from toolsets import get_toolset_names @@ -1300,9 +1300,11 @@ CREATE TABLE IF NOT EXISTS kanban_notify_subs ( task_id TEXT NOT NULL, platform TEXT NOT NULL, chat_id TEXT NOT NULL, + chat_type TEXT, thread_id TEXT NOT NULL DEFAULT '', user_id TEXT, notifier_profile TEXT, + delivery_metadata TEXT, created_at INTEGER NOT NULL, last_event_id INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (task_id, platform, chat_id, thread_id) @@ -2445,6 +2447,14 @@ def _migrate_add_optional_columns(conn: sqlite3.Connection) -> None: _add_column_if_missing( conn, "kanban_notify_subs", "notifier_profile", "notifier_profile TEXT" ) + if "chat_type" not in notify_cols: + _add_column_if_missing( + conn, "kanban_notify_subs", "chat_type", "chat_type TEXT" + ) + if "delivery_metadata" not in notify_cols: + _add_column_if_missing( + conn, "kanban_notify_subs", "delivery_metadata", "delivery_metadata TEXT" + ) # One-shot backfill: any task that is 'running' before runs existed # had its claim_lock / claim_expires / worker_pid on the task row. @@ -2567,8 +2577,8 @@ _REBUILD_SPECS = { "kanban_notify_subs": ( "CREATE TABLE kanban_notify_subs (" " task_id TEXT NOT NULL, platform TEXT NOT NULL, chat_id TEXT NOT NULL," - " thread_id TEXT NOT NULL DEFAULT '', user_id TEXT," - " notifier_profile TEXT, created_at INTEGER NOT NULL," + " chat_type TEXT, thread_id TEXT NOT NULL DEFAULT '', user_id TEXT," + " notifier_profile TEXT, delivery_metadata TEXT, created_at INTEGER NOT NULL," " last_event_id INTEGER NOT NULL DEFAULT 0," " PRIMARY KEY (task_id, platform, chat_id, thread_id))", ("CREATE INDEX idx_notify_task ON kanban_notify_subs(task_id)",), @@ -3172,6 +3182,7 @@ def create_task( "provider_override": provider_override, }, ) + _inherit_notify_subs(conn, task_id, parents, created_at=now) return task_id except sqlite3.IntegrityError: if attempt == 1: @@ -3194,6 +3205,47 @@ def _find_missing_parents(conn: sqlite3.Connection, parents: Iterable[str]) -> l return [p for p in parents if p not in present] +def _inherit_notify_subs( + conn: sqlite3.Connection, + child_id: str, + parents: Iterable[str], + *, + created_at: Optional[int] = None, +) -> None: + """Copy gateway notification subscriptions from parent tasks to a child. + + The inherited subscription starts caught up to the child's current event + cursor. This makes manual `link_tasks(parent, existing_child)` safe: the + parent chat receives future child terminal events without replaying the + child's pre-link history. + """ + parent_ids = tuple(dict.fromkeys(p for p in parents if p)) + if not parent_ids: + return + row = conn.execute( + "SELECT COALESCE(MAX(id), 0) AS cursor FROM task_events WHERE task_id = ?", + (child_id,), + ).fetchone() + cursor = int(row["cursor"] if row is not None else 0) + placeholders = ",".join("?" * len(parent_ids)) + conn.execute( + f""" + INSERT OR IGNORE INTO kanban_notify_subs + (task_id, platform, chat_id, thread_id, user_id, + notifier_profile, created_at, last_event_id) + SELECT ?, platform, chat_id, thread_id, user_id, notifier_profile, ?, ? + FROM kanban_notify_subs + WHERE task_id IN ({placeholders}) + """, + ( + child_id, + int(created_at if created_at is not None else time.time()), + cursor, + *parent_ids, + ), + ) + + def get_task(conn: sqlite3.Connection, task_id: str) -> Optional[Task]: row = conn.execute("SELECT * FROM tasks WHERE id = ?", (task_id,)).fetchone() return Task.from_row(row) if row else None @@ -3375,6 +3427,7 @@ def link_tasks(conn: sqlite3.Connection, parent_id: str, child_id: str) -> None: conn, child_id, "linked", {"parent": parent_id, "child": child_id}, ) + _inherit_notify_subs(conn, child_id, (parent_id,)) def _would_cycle(conn: sqlite3.Connection, parent_id: str, child_id: str) -> bool: @@ -6012,6 +6065,7 @@ def decompose_triage_task( conn, new_id, "created", {"by": author or "decomposer", "from_decompose_of": task_id}, ) + _inherit_notify_subs(conn, new_id, (task_id,), created_at=now) child_ids.append(new_id) # Link children to their sibling parents (within the decomposed graph). @@ -8761,6 +8815,12 @@ def _default_spawn( prompt = f"work kanban task {task.id}" env = dict(os.environ) + # The dispatcher is detached from every conversation. Its worker must never + # inherit routing mirrored by a previous gateway turn, even before the first + # session binds ContextVars in this process. + from gateway.session_context import _VAR_MAP + for key in _VAR_MAP: + env.pop(key, None) # Inject HERMES_HOME so the worker reads the profile-scoped config.yaml # (fallback_providers, toolsets, agent settings, etc.) instead of the root @@ -9329,28 +9389,100 @@ def task_age(task: Task) -> dict: # Notification subscriptions (used by the gateway kanban-notifier) # --------------------------------------------------------------------------- +def _encode_notify_delivery_metadata( + metadata: Optional[Mapping[str, Any]], +) -> Optional[str]: + """Serialize platform send metadata stored on notification subscriptions.""" + if not isinstance(metadata, Mapping): + return None + clean: dict[str, Any] = {} + for key, value in metadata.items(): + if value is None: + continue + if isinstance(value, (str, int, float, bool)): + clean[str(key)] = value + if not clean: + return None + return json.dumps(clean, sort_keys=True, separators=(",", ":")) + + +def _decode_notify_delivery_metadata(raw: Any) -> dict[str, Any]: + if isinstance(raw, Mapping): + return dict(raw) + if not raw: + return {} + try: + data = json.loads(str(raw)) + except Exception: + return {} + if not isinstance(data, dict): + return {} + return { + str(key): value + for key, value in data.items() + if isinstance(value, (str, int, float, bool)) + } + + def add_notify_sub( conn: sqlite3.Connection, *, task_id: str, platform: str, chat_id: str, + chat_type: Optional[str] = None, thread_id: Optional[str] = None, user_id: Optional[str] = None, notifier_profile: Optional[str] = None, + delivery_metadata: Optional[Mapping[str, Any]] = None, ) -> None: """Register a gateway source that wants terminal-state notifications - for ``task_id``. Idempotent on (task, platform, chat, thread).""" + for ``task_id``. Idempotent on (task, platform, chat, thread). + + New subscriptions start "caught up": ``last_event_id`` snaps to the + task's current ``MAX(task_events.id)`` at creation instead of the + schema default 0. A cursor of 0 on an already-active task made the + gateway notifier replay every historical terminal event on its next + tick — and with many stale subs, a single boot-time burst of 100+ + messages (issue #29905). Subscribers only want events that occur + AFTER they subscribe; the gateway/tool auto-subscribe paths run at + task creation, where the snapshot is 0 anyway. + """ now = int(time.time()) + metadata_json = _encode_notify_delivery_metadata(delivery_metadata) with write_txn(conn): conn.execute( """ INSERT OR IGNORE INTO kanban_notify_subs - (task_id, platform, chat_id, thread_id, user_id, notifier_profile, created_at) - VALUES (?, ?, ?, ?, ?, ?, ?) + (task_id, platform, chat_id, chat_type, thread_id, user_id, + notifier_profile, delivery_metadata, created_at, last_event_id) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, + COALESCE((SELECT MAX(id) FROM task_events WHERE task_id = ?), 0)) """, - (task_id, platform, chat_id, thread_id or "", user_id, notifier_profile, now), + ( + task_id, + platform, + chat_id, + chat_type, + thread_id or "", + user_id, + notifier_profile, + metadata_json, + now, + task_id, + ), ) + if chat_type: + # Self-heal rows created before chat_type was persisted. + conn.execute( + """ + UPDATE kanban_notify_subs + SET chat_type = ? + WHERE task_id = ? AND platform = ? AND chat_id = ? AND thread_id = ? + AND (chat_type IS NULL OR chat_type = '') + """, + (chat_type, task_id, platform, chat_id, thread_id or ""), + ) if notifier_profile: # Self-heal legacy rows that predate notifier ownership by # backfilling only when the existing value is unset. @@ -9363,6 +9495,18 @@ def add_notify_sub( """, (notifier_profile, task_id, platform, chat_id, thread_id or ""), ) + if metadata_json: + # A duplicate subscribe from the same chat/thread should refresh + # the routing anchor. Telegram DM-topic notifications need the + # latest reply anchor to stay inside the visible topic lane. + conn.execute( + """ + UPDATE kanban_notify_subs + SET delivery_metadata = ? + WHERE task_id = ? AND platform = ? AND chat_id = ? AND thread_id = ? + """, + (metadata_json, task_id, platform, chat_id, thread_id or ""), + ) def list_notify_subs( @@ -9374,7 +9518,53 @@ def list_notify_subs( ).fetchall() else: rows = conn.execute("SELECT * FROM kanban_notify_subs").fetchall() - return [dict(r) for r in rows] + out: list[dict] = [] + for row in rows: + item = dict(row) + if "delivery_metadata" in item: + item["delivery_metadata"] = _decode_notify_delivery_metadata( + item.get("delivery_metadata") + ) + out.append(item) + return out + + +def count_notify_subs( + db_path: Optional[Path] = None, + *, + board: Optional[str] = None, +) -> int: + """Count ``kanban_notify_subs`` rows via a read-only connection. + + Cheap probe for the gateway notifier's zero-subscription early exit: + unlike :func:`connect`, this never creates the DB file, never runs + schema init/migration, and never opens the database writable (no + write locks, no checkpoints — though a read-only open of a WAL + database may still create the ``-shm``/``-wal`` sidecars, it cannot + write table content). Rows in a not-yet-checkpointed WAL are + visible, so a freshly added subscription is never missed. A missing + DB, or a legacy DB that predates the subscriptions table, counts as + zero. Path resolution matches :func:`connect` (explicit ``db_path``, + else ``board`` via :func:`kanban_db_path`). Raises + :class:`sqlite3.Error` when the DB exists but cannot be read + (locked, corrupt); callers choose their own fallback. + """ + path = db_path if db_path is not None else kanban_db_path(board=board) + if not path.exists(): + return 0 + conn = sqlite3.connect(path.resolve().as_uri() + "?mode=ro", uri=True) + try: + try: + row = conn.execute( + "SELECT COUNT(*) FROM kanban_notify_subs" + ).fetchone() + except sqlite3.OperationalError as exc: + if "no such table" in str(exc).lower(): + return 0 + raise + return int(row[0]) if row else 0 + finally: + conn.close() def remove_notify_sub( diff --git a/hermes_cli/main.py b/hermes_cli/main.py index be6b7fce04..95e79e905f 100644 --- a/hermes_cli/main.py +++ b/hermes_cli/main.py @@ -445,6 +445,7 @@ from hermes_cli.subcommands.webhook import build_webhook_parser from hermes_cli.subcommands.hooks import build_hooks_parser from hermes_cli.subcommands.doctor import build_doctor_parser from hermes_cli.subcommands.security import build_security_parser +from hermes_cli.subcommands.approvals import build_approvals_parser from hermes_cli.subcommands.dump import build_dump_parser from hermes_cli.subcommands.debug import build_debug_parser from hermes_cli.subcommands.backup import build_backup_parser @@ -4558,6 +4559,16 @@ def cmd_security(args): sys.exit(2) +def cmd_approvals(args): + """Dispatch `hermes approvals `.""" + from hermes_cli.approvals_suggest import approvals_command + + status = approvals_command(args) + if status: + sys.exit(status) + return status + + def cmd_dump(args): """Dump setup summary for support/debugging.""" from hermes_cli.dump import run_dump @@ -6571,11 +6582,11 @@ def cmd_gui(args: argparse.Namespace): sys.exit(launch_result.returncode) -def _find_stale_dashboard_pids( +def _scan_dashboard_processes( *, exclude_pids: set[int] | None = None, -) -> list[int]: - """Return PIDs of ``hermes dashboard`` processes other than ourselves. +) -> list[tuple[int, str]]: + """Return matching ``dashboard``/``serve`` processes with their cmdlines. ``hermes dashboard`` is a long-lived server process commonly started and forgotten. When ``hermes update`` replaces files on disk, the running @@ -6611,7 +6622,7 @@ def _find_stale_dashboard_pids( "hermes_cli/main.py serve", ] self_pid = os.getpid() - dashboard_pids: list[int] = [] + dashboard_processes: list[tuple[int, str]] = [] try: if sys.platform == "win32": @@ -6650,7 +6661,7 @@ def _find_stale_dashboard_pids( and int(pid_str) != self_pid ): try: - dashboard_pids.append(int(pid_str)) + dashboard_processes.append((int(pid_str), current_cmd)) except ValueError: pass else: @@ -6680,13 +6691,72 @@ def _find_stale_dashboard_pids( continue command = parts[1] if any(p in command for p in patterns) and pid != self_pid: - dashboard_pids.append(pid) + dashboard_processes.append((pid, command)) except (FileNotFoundError, subprocess.TimeoutExpired, OSError): return [] if exclude_pids: - dashboard_pids = [p for p in dashboard_pids if p not in exclude_pids] - return dashboard_pids + dashboard_processes = [ + proc for proc in dashboard_processes if proc[0] not in exclude_pids + ] + return dashboard_processes + + +def _find_stale_dashboard_pids( + *, + exclude_pids: set[int] | None = None, +) -> list[int]: + """Return PIDs of stale ``dashboard``/``serve`` processes for update cleanup.""" + return [pid for pid, _cmd in _scan_dashboard_processes(exclude_pids=exclude_pids)] + + +def _parse_dashboard_runtime(command: str) -> tuple[str, str, int] | None: + """Best-effort parse of a dashboard/server cmdline into mode, host, and port.""" + mode = None + if any( + pattern in command + for pattern in ( + "hermes dashboard", + "hermes_cli.main dashboard", + "hermes_cli/main.py dashboard", + ) + ): + mode = "dashboard" + elif any( + pattern in command + for pattern in ( + "hermes serve", + "hermes_cli.main serve", + "hermes_cli/main.py serve", + ) + ): + mode = "serve" + if mode is None: + return None + + port = 9119 + host = "127.0.0.1" + + port_match = re.search(r"(?:^|\s)--port(?:=|\s+)(\d+)", command) + if port_match: + try: + port = int(port_match.group(1)) + except ValueError: + return None + + host_match = re.search(r"(?:^|\s)--host(?:=|\s+)(\"[^\"]+\"|'[^']+'|\S+)", command) + if host_match: + host = host_match.group(1).strip("\"'") or "127.0.0.1" + + return mode, host, port + + +def _dashboard_probe_host(host: str | None) -> str: + """Map wildcard binds to a loopback address suitable for local probing.""" + normalized = (host or "127.0.0.1").strip().strip("[]") + if normalized in {"", "0.0.0.0", "::"}: + return "127.0.0.1" + return normalized def _print_curator_first_run_notice() -> None: @@ -7041,12 +7111,205 @@ def _restart_managed_dashboard_service( return True +def _get_systemd_service_for_pid(pid: int) -> str | None: + """If *pid* belongs to a systemd service unit, return the unit name. + + Reads ``/proc//cgroup`` and extracts the service name (e.g. + ``hermes-serve.service``). Returns ``None`` when the PID is not + part of a systemd service, when the file is unreadable, or on + non-Linux platforms. + """ + try: + cgroup_path = Path(f"/proc/{pid}/cgroup") + if not cgroup_path.is_file(): + return None + text = cgroup_path.read_text(encoding="utf-8", errors="replace") + for line in text.splitlines(): + line = line.strip() + # Format: 0::/system.slice/hermes-serve.service + # 0::/user.slice/user-1000.slice/session-42.scope + parts = line.split("::", 1) + if len(parts) != 2: + continue + cg_path = parts[1] + if cg_path.endswith(".service"): + svc_name = cg_path.rsplit("/", 1)[-1] + if svc_name: + return svc_name + except (OSError, PermissionError): + pass + return None + + +def _extract_scope_from_cgroup(cgroup_entry: str) -> str | None: + """Extract the systemd scope (``user`` or ``system``) from a cgroup path. + + The cgroup path format is ``/system.slice/.service`` for system + services and ``/user.slice/user-.slice/.service`` for user + services. Returns ``None`` when the scope cannot be determined. + """ + if "/system.slice/" in cgroup_entry: + return "system" + if "/user.slice/" in cgroup_entry: + return "user" + return None + + +def _get_pid_cgroup_path(pid: int) -> str | None: + """Return the cgroup path from ``/proc//cgroup``, or ``None``. + + Only the unified (``0::``) hierarchy cgroup entry is examined. + """ + try: + cgroup_path = Path(f"/proc/{pid}/cgroup") + if not cgroup_path.is_file(): + return None + text = cgroup_path.read_text(encoding="utf-8", errors="replace") + for line in text.splitlines(): + line = line.strip() + parts = line.split("::", 1) + if len(parts) == 2: + return parts[1] + except (OSError, PermissionError): + pass + return None + + +def _try_restart_systemd_service(svc_name: str, cgroup_path: str | None = None) -> bool: + """Attempt to restart *svc_name* via systemctl. + + Uses ``systemctl --user`` for user-scope services and ``systemctl`` + for system-scope services. Returns ``True`` on success. + """ + scope = _extract_scope_from_cgroup(cgroup_path) if cgroup_path else None + if scope == "user": + cmd = ["systemctl", "--user", "restart", svc_name] + elif scope == "system": + cmd = ["systemctl", "restart", svc_name] + else: + # Unknown scope — try system first, then user + cmd = None + for candidate in ( + ["systemctl", "restart", svc_name], + ["systemctl", "--user", "restart", svc_name], + ): + try: + r = subprocess.run( + candidate, + capture_output=True, + text=True, encoding="utf-8", errors="replace", + timeout=15, + ) + if r.returncode == 0: + return True + except (FileNotFoundError, subprocess.TimeoutExpired, OSError): + continue + return False + + try: + r = subprocess.run( + cmd, + capture_output=True, + text=True, encoding="utf-8", errors="replace", + timeout=15, + ) + return r.returncode == 0 + except (FileNotFoundError, subprocess.TimeoutExpired, OSError): + return False + + +def _dashboard_cmdline_for_pid(pid: int) -> list[str] | None: + """Return the exact argv of a running process, when recoverable. + + Linux: reads ``/proc//cmdline`` (NUL-separated, lossless). + macOS: falls back to ``ps -o command=`` + shlex (best effort — quoting + is reconstructed, but hermes launch commands don't embed exotic args). + Windows: returns ``None``; taskkill /F gives no graceful window and the + desktop app manages its own backend there. + """ + if sys.platform == "win32": + return None + try: + cmdline_path = f"/proc/{pid}/cmdline" + if os.path.exists(cmdline_path): + with open(cmdline_path, "rb") as f: + raw = f.read() + argv = [ + part.decode("utf-8", errors="replace") + for part in raw.split(b"\x00") + if part + ] + return argv or None + # macOS (no /proc): best-effort via ps. + result = subprocess.run( + ["ps", "-p", str(pid), "-o", "command="], + capture_output=True, + text=True, encoding="utf-8", errors="replace", + timeout=10, + ) + if result.returncode != 0: + return None + command = (result.stdout or "").strip() + if not command: + return None + try: + argv = shlex.split(command) + except ValueError: + argv = command.split() + return argv or None + except (OSError, ValueError, subprocess.TimeoutExpired): + return None + + +def _respawn_dashboard_processes(commands: list[list[str]]) -> list[list[str]]: + """Best-effort respawn of manually-started dashboards after ``hermes update``. + + Spawns each recovered argv detached (new session, output to the profile's + ``logs/dashboard-restart.log``). Returns the commands that failed to + spawn; the caller prints the manual hint for those. + """ + from hermes_constants import get_hermes_home + + respawned: list[list[str]] = [] + failed: list[tuple[list[str], str]] = [] + log_path = get_hermes_home() / "logs" / "dashboard-restart.log" + try: + log_path.parent.mkdir(parents=True, exist_ok=True) + except OSError: + pass + + for command in commands: + try: + # Keep restarted dashboards headless; reopening a browser after a + # background update is noisy and fails in SSH/headless sessions. + if "dashboard" in command and "--no-open" not in command: + command = [*command, "--no-open"] + with open(log_path, "ab") as log_f: + subprocess.Popen( + command, + stdin=subprocess.DEVNULL, + stdout=log_f, + stderr=subprocess.STDOUT, + start_new_session=True, + close_fds=True, + ) + respawned.append(command) + except (OSError, ValueError) as exc: + failed.append((command, str(exc))) + + for command in respawned: + print(f" ✓ restarted: {shlex.join(command)}") + for command, err_msg in failed: + print(f" ✗ failed to restart ({shlex.join(command)}): {err_msg}") + return [command for command, _ in failed] + + def _kill_stale_dashboard_processes( reason: str = "the running backend no longer matches the updated frontend", *, restart_managed: bool = False, -) -> None: - """Kill running ``hermes dashboard`` processes. +) -> dict[str, list]: + """Kill running ``hermes dashboard`` / ``hermes serve`` processes. Called at the end of ``hermes update`` (default ``reason``) and also from ``hermes dashboard --stop`` (which overrides ``reason``). The @@ -7063,11 +7326,14 @@ def _kill_stale_dashboard_processes( Manually-started dashboards are not auto-restarted because we don't know the original launch args (--host, --port, --insecure, --tui, --no-open). When ``restart_managed`` is true (the ``hermes update`` path), a detected - ``hermes-dashboard.service`` is restarted through systemd instead of - raw-killing its main PID. + ``hermes-dashboard.service`` is restarted through systemd; any OTHER + killed PID that was supervised by a systemd unit (custom unit names — + e.g. a remote backend's ``hermes-serve.service``) has its owning unit + restarted after the kill, because systemd treats our SIGTERM as a clean + stop and ``Restart=on-failure`` would never fire (#68934). """ if restart_managed and _restart_managed_dashboard_service(reason): - return + return {"matched": [], "killed": [], "failed": []} # When the Hermes Desktop Electron app spawns this dashboard as a # backend child, it sets HERMES_DESKTOP_CHILD_PID so that the update @@ -7091,11 +7357,31 @@ def _kill_stale_dashboard_processes( pids = _find_stale_dashboard_pids(exclude_pids=exclude) if not pids: - return + return {"matched": [], "killed": [], "failed": []} print() print(f"⟲ Stopping {len(pids)} dashboard process(es) ({reason})") + # Before killing, snapshot systemd cgroup info for each PID so we can + # restart supervised services after the kill (the cgroup disappears + # along with the process). Only meaningful on Linux, and only when the + # caller asked for restarts (the `hermes update` path) — `--stop` must + # stay a stop, not a restart. + pid_cgroup: dict[int, str | None] = {} + pid_service: dict[int, str | None] = {} + pid_cmdline: dict[int, list[str]] = {} + if restart_managed and sys.platform != "win32": + for pid in pids: + cg_path = _get_pid_cgroup_path(pid) + pid_cgroup[pid] = cg_path + pid_service[pid] = _get_systemd_service_for_pid(pid) + if not pid_service[pid]: + # Manually-started process: preserve its exact argv so we + # can respawn it after the update (#40449, #68934). + cmdline = _dashboard_cmdline_for_pid(pid) + if cmdline: + pid_cmdline[pid] = cmdline + killed: list[int] = [] failed: list[tuple[int, str]] = [] @@ -7162,10 +7448,80 @@ def _kill_stale_dashboard_processes( for pid, err_msg in failed: print(f" ✗ failed to stop PID {pid}: {err_msg}") - if killed: + # Restart what we just killed (update path only). Two categories: + # - systemd-supervised PIDs: restart the owning unit. Without this, a + # remote backend (hermes serve) under Restart=on-failure never comes + # back after our clean SIGTERM, and the Desktop can't reconnect (#68934). + # - manually-started PIDs: respawn the argv captured before the kill + # (#40449) — detached, headless, logged to logs/dashboard-restart.log. + restarted_services: list[str] = [] + unrecovered: list[int] = [] + if killed and restart_managed: + failed_restarts: list[tuple[str, str]] = [] + seen_services: set[str] = set() + respawn_cmds: list[list[str]] = [] + for pid in killed: + svc_name = pid_service.get(pid) + if svc_name: + if svc_name in seen_services: + continue + seen_services.add(svc_name) + if _try_restart_systemd_service(svc_name, pid_cgroup.get(pid)): + restarted_services.append(svc_name) + else: + failed_restarts.append((svc_name, "systemctl restart returned non-zero")) + unrecovered.append(pid) + elif pid in pid_cmdline: + respawn_cmds.append(pid_cmdline[pid]) + else: + unrecovered.append(pid) + + for svc in restarted_services: + print(f" ✓ restarted systemd service {svc}") + for svc, err in failed_restarts: + print(f" ⚠ {svc}: {err}") + + if respawn_cmds: + failed_cmds = _respawn_dashboard_processes(respawn_cmds) + if failed_cmds: + unrecovered.extend(p for p in killed if pid_cmdline.get(p) in failed_cmds) + + if failed_restarts or unrecovered: + print(" Restart anything not auto-restarted when you're ready:") + print(" hermes dashboard --port ") + elif killed: + unrecovered = list(killed) print(" Restart the dashboard when you're ready:") print(" hermes dashboard --port ") + return { + "matched": list(pids), + "killed": list(killed), + "failed": list(failed), + "unrecovered": list(unrecovered), + } + + +def _finish_dashboard_update_cleanup(node_failures: list[str]) -> None: + """Refresh managed dashboards or stop stale manual ones after an update.""" + if node_failures: + print() + print(" ℹ Leaving running dashboard process(es) untouched because the") + print(" Node.js dependency refresh did not complete.") + return + + stop_result = _kill_stale_dashboard_processes(restart_managed=True) + if not stop_result.get("unrecovered"): + return + + print() + print( + "⚠ A web dashboard/serve process was stopped during update and could " + "not be auto-restarted." + ) + print(" Re-launch it when you want the web UI back:") + print(" hermes dashboard --port ") + # Back-compat alias: some tests and any external callers may import the old # warn-only name. The new behaviour (kill stale processes) replaces it. @@ -7357,6 +7713,11 @@ def _update_via_zip(args): ) _install_python_dependencies_with_optional_fallback(pip_cmd) + # ZIP path parity: heal the active memory provider's bridge packages + # after the dependency reinstall, same as the git-pull path (#53272, + # #70636). + _refresh_active_memory_provider_dependencies() + node_failures = _update_node_dependencies() _build_web_ui(PROJECT_ROOT / "web") @@ -7480,12 +7841,7 @@ def _update_via_zip(args): logger.debug("Curator recent-run notice failed: %s", e) # Don't stop a working dashboard when the Node refresh failed — see the # git-update path for rationale (#30271). - if node_failures: - print() - print(" ℹ Leaving running dashboard process(es) untouched because the") - print(" Node.js dependency refresh did not complete.") - else: - _kill_stale_dashboard_processes(restart_managed=True) + _finish_dashboard_update_cleanup(node_failures) def _stash_local_changes_if_needed(git_cmd: list[str], cwd: Path) -> Optional[str]: @@ -9190,6 +9546,55 @@ def _refresh_active_lazy_features( return False +def _refresh_active_memory_provider_dependencies() -> None: + """Refresh pip dependencies for the configured external memory provider. + + Memory-provider bridge packages are declared in each provider's + ``plugin.yaml`` (plus mode-dependent extras like Hindsight's + ``hindsight-all``), NOT in Hermes' editable-install extras or + ``LAZY_DEPS`` alone — so the core dependency reinstall above can strip + or downgrade them (#53272 mem0ai, #70636 hindsight-embed). Re-run the + provider's declared install for the ACTIVE provider only, after the + core install and lazy refresh, so the last write to any shared package + is the one the active provider needs. + + Never raises. A failure here must not block the rest of the update. + """ + try: + from hermes_cli.config import load_config + + cfg = load_config() + except Exception as exc: + logger.debug("Memory provider refresh skipped (config load failed): %s", exc) + return + + provider = "" + if isinstance(cfg, dict): + memory_cfg = cfg.get("memory") + if isinstance(memory_cfg, dict): + if memory_cfg.get("enabled") is False: + return + provider = str(memory_cfg.get("provider") or "").strip() + + # "default" / empty is the built-in file-backed store — no pip deps. + if not provider or provider in {"default", "builtin", "none"}: + return + + try: + from hermes_cli.memory_setup import _install_dependencies + except Exception as exc: + logger.debug("Memory provider refresh skipped (import failed): %s", exc) + return + + print() + print(f"→ Refreshing active memory provider dependencies ({provider})...") + + try: + _install_dependencies(provider, force=True) + except Exception as exc: + print(f" ⚠ {provider} dependencies failed to refresh: {exc}") + + def _install_python_dependencies_with_optional_fallback( install_cmd_prefix: list[str], *, @@ -11074,6 +11479,36 @@ def _warn_incomplete_gateway_fleet_restart(failed_units: list) -> None: print(" sudo systemctl restart # system-scope") +def _refresh_windows_gateway_launchers() -> None: + """Regenerate installed Windows gateway launcher scripts after update. + + The Scheduled Task / Startup-folder launchers (``gateway.cmd`` + + ``gateway.vbs``) are persistence artifacts written once at install time — + ``hermes update`` never touched them, so installs created before the + hidden-console rework (aa2ae36c3f) kept launching the gateway through + ``pythonw.exe`` forever: every descendant spawn flashed a conhost + (#54220/#56747) and, since #70344, the console-less gateway died at + startup with ``RuntimeError: sys.stderr is None`` (#71671). + + The task's /TR points at a stable script path, so rewriting the files in + place retargets the task without any schtasks call (no UAC needed). + ``_write_task_script`` is idempotent and renders from current code, so + this is a no-op for modern installs. Best-effort: a failed refresh must + never fail the update. + """ + if not _is_windows(): + return + try: + from hermes_cli import gateway_windows + + if not gateway_windows.is_installed(): + return + gateway_windows._write_task_script() + print(" ✓ Refreshed Windows gateway launcher scripts") + except Exception as exc: + logger.debug("Could not refresh Windows gateway launchers after update: %s", exc) + + def _resume_windows_gateways_after_update(token: dict | None) -> None: """Restart Windows profile gateways previously paused for update.""" if not token or not token.get("resume_needed"): @@ -11082,6 +11517,11 @@ def _resume_windows_gateways_after_update(token: dict | None) -> None: if not _is_windows(): return + # Regenerate the persisted launcher scripts before respawning anything, + # so a legacy pythonw-era Scheduled Task / Startup entry comes back on + # the current hidden-console design at the next login too. + _refresh_windows_gateway_launchers() + profiles = token.get("profiles") or {} unmapped = token.get("unmapped") or [] cold_start = bool(token.get("cold_start_if_installed")) @@ -11813,6 +12253,11 @@ def _cmd_update_impl(args, gateway_mode: bool): "to finish import-based venv repair." ) + # Heal the active memory provider's bridge packages last — the core + # reinstall + lazy refresh above may have stripped or downgraded + # plugin.yaml-declared deps that aren't in extras (#53272, #70636). + _refresh_active_memory_provider_dependencies() + node_failures = _update_node_dependencies() _build_web_ui(PROJECT_ROOT / "web") @@ -12277,7 +12722,14 @@ def _cmd_update_impl(args, gateway_mode: bool): print() print("→ Refreshing cua-driver (Computer Use)...") - install_cua_driver(upgrade=True) + # require_confirmed_update: only run the (multi-minute, + # silent) upstream installer when the driver's native + # check-update verb positively reports a newer release. + # An indeterminate check (offline, rate-limited, old + # driver) keeps the installed version — `hermes update` + # must stay fast; `hermes computer-use install --upgrade` + # remains the force path. + install_cua_driver(upgrade=True, require_confirmed_update=True) except Exception as e: logger.debug("cua-driver refresh failed: %s", e) @@ -13016,16 +13468,11 @@ def _cmd_update_impl(args, gateway_mode: bool): logger.debug("Legacy unit check during update failed: %s", e) # Restart a managed dashboard through systemd, or stop stale manual - # dashboard processes. Raw-killing a systemd-owned dashboard PID makes + # dashboard processes. Raw-killing a systemd-owned dashboard PID makes # systemd treat it as a clean stop, leaving the Cloudflare origin dead. # Preserve the safety rule above: a failed Node refresh leaves the # currently running dashboard untouched. - if node_failures: - print() - print(" ℹ Leaving running dashboard process(es) untouched because the") - print(" Node.js dependency refresh did not complete.") - else: - _kill_stale_dashboard_processes(restart_managed=True) + _finish_dashboard_update_cleanup(node_failures) print() print("Tip: You can now select a provider and model:") @@ -13782,40 +14229,31 @@ def _render_distribution_plan(plan) -> None: def _report_dashboard_status() -> int: - """Print ``hermes dashboard`` PIDs and return the count. + """Print live listening dashboard processes and return the count.""" + from gateway.status import _pid_exists - Uses the same detection logic as ``_find_stale_dashboard_pids`` (the - current process is excluded, but since ``hermes dashboard --status`` - runs in a short-lived CLI process that never matches the pattern, - the exclusion is irrelevant here). - """ - pids = _find_stale_dashboard_pids() - if not pids: + live: list[tuple[int, str]] = [] + for pid, command in _scan_dashboard_processes(): + runtime = _parse_dashboard_runtime(command) + if runtime is None: + continue + mode, host, port = runtime + if mode != "dashboard": + continue + if port <= 0 or not _pid_exists(pid): + continue + if not _dashboard_listening(host, port): + continue + live.append((pid, command)) + + if not live: print("No hermes dashboard processes running.") return 0 - print(f"{len(pids)} hermes dashboard process(es) running:") - for pid in pids: - # Best-effort: show the full cmdline so users can tell profiles apart. - cmdline = "" - try: - if sys.platform != "win32": - cmdline_path = f"/proc/{pid}/cmdline" - if os.path.exists(cmdline_path): - with open(cmdline_path, "rb") as f: - cmdline = ( - f.read() - .replace(b"\x00", b" ") - .decode("utf-8", errors="replace") - .strip() - ) - except (OSError, ValueError): - pass - if cmdline: - print(f" PID {pid}: {cmdline}") - else: - print(f" PID {pid}") - return len(pids) + print(f"{len(live)} hermes dashboard process(es) running:") + for pid, command in live: + print(f" PID {pid}: {command}") + return len(live) def _dashboard_listening(host: str, port: int) -> bool: @@ -13827,7 +14265,7 @@ def _dashboard_listening(host: str, port: int) -> bool: import socket try: - with socket.create_connection((host or "127.0.0.1", port), timeout=1.5): + with socket.create_connection((_dashboard_probe_host(host), port), timeout=1.5): return True except OSError: return False @@ -14483,7 +14921,7 @@ def _build_provider_choices() -> list[str]: # to parse. _BUILTIN_SUBCOMMANDS = frozenset( { - "acp", "auth", "backup", "bundles", "checkpoints", "claw", "completion", + "acp", "approvals", "auth", "backup", "bundles", "checkpoints", "claw", "completion", "computer-use", "config", "console", "cron", "curator", "dashboard", "serve", "debug", "doctor", "dump", "egress", "fallback", "gateway", "hooks", "import", "insights", @@ -15324,6 +15762,11 @@ def main(): # ========================================================================= build_security_parser(subparsers, cmd_security=cmd_security) + # ========================================================================= + # approvals command (parser built in hermes_cli/subcommands/approvals.py) + # ========================================================================= + build_approvals_parser(subparsers, cmd_approvals=cmd_approvals) + # ========================================================================= # dump command (parser built in hermes_cli/subcommands/dump.py) # ========================================================================= @@ -15758,7 +16201,7 @@ def main(): p.add_argument( "--newer-than", metavar="AGE", - help="Only match sessions started within the last AGE " + help="Only match sessions active within the last AGE " "(e.g. '5h', '2d') or after an ISO timestamp", ) p.add_argument( @@ -16915,12 +17358,14 @@ def main(): print(f"No sessions match ({describe_filters(filters)}).") return - # Candidates are ordered oldest-first — surface the age span so - # the confirmation makes the blast radius obvious. - _oldest = candidates[0].get("started_at") - _newest = candidates[-1].get("started_at") + # Candidates are ordered by activity oldest-first. Surface that + # span so a long-lived but recently used conversation cannot look + # old merely because of its creation date. + _oldest = candidates[0].get("last_active") + _newest = candidates[-1].get("last_active") _span = ( - f"oldest {format_epoch(_oldest)}, newest {format_epoch(_newest)}" + f"oldest activity {format_epoch(_oldest)}, " + f"newest activity {format_epoch(_newest)}" ) if args.dry_run or not args.yes: @@ -16933,7 +17378,7 @@ def main(): title = (s.get("title") or "")[:36] model = (s.get("model") or "-").split("/")[-1][:24] print( - f" {s['id']} {format_epoch(s['started_at']):<17} " + f" {s['id']} {format_epoch(s.get('last_active')):<17} " f"{s['source']:<10} {model:<24} " f"{s['message_count']:>4} msgs {title}" ) diff --git a/hermes_cli/managed_uv.py b/hermes_cli/managed_uv.py index ff33e7dc21..b5bd99252d 100644 --- a/hermes_cli/managed_uv.py +++ b/hermes_cli/managed_uv.py @@ -138,9 +138,14 @@ class _RepairLock: def _report_runtime_repair_failure(repair: RuntimeRepairResult) -> None: if repair.backup_venv is None: print( - " ⚠ Managed Python runtime was not replaced; " + " ℹ Managed Python runtime was not replaced; " f"the existing venv is unchanged ({repair.detail})." ) + print( + " Sessions stay protected meanwhile: Hermes keeps databases " + "out of WAL mode on this SQLite build. The next `hermes update` " + "will retry." + ) return print(f" ✗ Managed Python runtime cutover needs manual recovery: {repair.detail}") print(f" Previous venv: {repair.backup_venv}") @@ -874,6 +879,64 @@ def _windows_runtime_holders() -> tuple[bool, str]: return False, "" +def _uv_version_string(uv_bin: str) -> str: + """Return ``uv --version`` output, or ``""`` when it cannot be read.""" + try: + result = subprocess.run( + [uv_bin, "--version"], + capture_output=True, + text=True, + encoding="utf-8", + errors="replace", + check=False, + timeout=15, + ) + except Exception: + return "" + if result.returncode != 0: + return "" + return (result.stdout or "").strip() + + +def _refresh_managed_uv_catalog(uv_bin: str) -> bool: + """Re-bootstrap the managed uv binary to refresh its Python catalog. + + The managed uv is installed with ``UV_UNMANAGED_INSTALL``, which disables + ``uv self update`` by design — so its embedded python-build-standalone + download catalog stays frozen at bootstrap age. python-build-standalone + re-releases existing CPython patch versions with newer SQLite (e.g. the + 3.11.15 build was re-cut with SQLite 3.53.x), so a stale catalog can make + every provisioning attempt resolve to a vulnerable build even though a + fixed build of the SAME patch version exists (issue #72093). The + patch-retry loop cannot recover from that: the fixed build carries no + newer version number to retry with. + + Re-running the official installer is the only supported refresh path for + unmanaged installs. Only the Hermes-managed binary is ever refreshed; + a caller-supplied foreign uv path is left alone. + + Returns ``True`` when the binary's version actually changed — i.e. a + provisioning retry can now see a different catalog. ``False`` means a + retry would resolve identically and is not worth the download cycle. + """ + managed = managed_uv_path() + try: + if Path(uv_bin).resolve() != managed.resolve(): + return False + except OSError: + return False + before = _uv_version_string(uv_bin) + try: + _install_uv(managed) + except Exception as exc: + logger.warning("managed uv refresh failed: %s", exc) + return False + after = _uv_version_string(uv_bin) + if not after: + return False + return after != before + + def repair_vulnerable_runtime( uv_bin: str, *, @@ -948,6 +1011,19 @@ def repair_vulnerable_runtime( project_root=root, current=current, ) + if provisioned is None: + # Likely a stale managed-uv catalog: python-build-standalone + # re-releases the same patch versions with fixed SQLite, but a + # frozen catalog keeps resolving the old vulnerable build and the + # patch-retry loop has no newer number to try (issue #72093). + # Refresh the managed binary and retry once. + if _refresh_managed_uv_catalog(uv_bin): + print(" → Managed uv refreshed; retrying provisioning...") + provisioned = _install_safe_python_generation( + uv_bin, + project_root=root, + current=current, + ) if provisioned is None: return RuntimeRepairResult( "failed", diff --git a/hermes_cli/mcp_startup.py b/hermes_cli/mcp_startup.py index a8744161d5..82839d933b 100644 --- a/hermes_cli/mcp_startup.py +++ b/hermes_cli/mcp_startup.py @@ -58,7 +58,28 @@ def start_background_mcp_discovery(*, logger, thread_name: str) -> None: if not _has_configured_mcp_servers(): return + # Capture the caller's context-local HERMES_HOME override (profile + # scoping in multi-profile processes like the dashboard/desktop + # backend) and re-install it inside the discovery thread. ContextVars + # do not propagate into bare threads, so without this a session + # "switched" to profile X would discover the LAUNCH profile's + # mcp_servers instead (#67605). The config gate above already runs on + # the caller's thread, so it sees the same override. + try: + from hermes_constants import get_hermes_home_override + + home_override = get_hermes_home_override() + except Exception: + home_override = None + def _discover() -> None: + token = None + try: + from hermes_constants import set_hermes_home_override + + token = set_hermes_home_override(home_override) + except Exception: + token = None try: _discover_mcp_tools_without_interactive_oauth() try: @@ -73,6 +94,13 @@ def start_background_mcp_discovery(*, logger, thread_name: str) -> None: except Exception: logger.debug("Background MCP tool discovery failed", exc_info=True) finally: + if token is not None: + try: + from hermes_constants import reset_hermes_home_override + + reset_hermes_home_override(token) + except Exception: + pass with _mcp_discovery_lock: global _mcp_discovery_thread, _mcp_discovery_started _mcp_discovery_thread = None diff --git a/hermes_cli/memory_setup.py b/hermes_cli/memory_setup.py index c1858fc832..3d8e12d572 100644 --- a/hermes_cli/memory_setup.py +++ b/hermes_cli/memory_setup.py @@ -8,6 +8,7 @@ the provider's config schema. Writes config to config.yaml + .env. from __future__ import annotations import os +import re import sys import shlex from pathlib import Path @@ -18,6 +19,32 @@ from hermes_cli.secret_prompt import masked_secret_prompt _CANCELLED = -1 +def _provider_pip_dependencies(provider_name: str, declared: list) -> list: + """Return the pip deps a provider actually needs on THIS install. + + ``plugin.yaml`` declares the provider's baseline bridge packages, but + some providers install mode-dependent extras at setup time that the + manifest can't express. Hindsight's ``local_embedded`` mode installs + ``hindsight-all`` (daemon + embedder + client) during + ``hermes memory setup`` — if the update-time refresh only reinstalled + the declared ``hindsight-client``, the embedded daemon would stay + broken after a venv rebuild stripped ``hindsight-embed`` (#70636). + """ + deps = list(declared or []) + if provider_name == "hindsight": + try: + import json + cfg_path = get_hermes_home() / "hindsight" / "config.json" + cfg = json.loads(cfg_path.read_text(encoding="utf-8")) if cfg_path.exists() else {} + mode = cfg.get("mode", "") + # "local" is a legacy alias for "local_embedded" + if mode in {"local", "local_embedded"}: + deps.append("hindsight-all") + except Exception: + pass + return deps + + # --------------------------------------------------------------------------- # Curses-based interactive picker (same pattern as hermes tools) # --------------------------------------------------------------------------- @@ -77,8 +104,16 @@ def _prompt(label: str, default: str | None = None, secret: bool = False) -> str # Provider discovery # --------------------------------------------------------------------------- -def _install_dependencies(provider_name: str) -> None: - """Install pip dependencies declared in plugin.yaml.""" +def _install_dependencies(provider_name: str, *, force: bool = False) -> None: + """Install pip dependencies declared in ``plugin.yaml``. + + When ``force`` is true, every declared dependency is handed to the + installer even if its import currently succeeds — the resolver then + reinstalls anything missing or version-drifted and no-ops on satisfied + ranges. This is how ``hermes update`` heals the active memory provider + after a venv rebuild/sync removed or downgraded its bridge packages + (#53272, #70636). + """ import subprocess from plugins.memory import find_provider_dir @@ -96,7 +131,7 @@ def _install_dependencies(provider_name: str) -> None: except Exception: return - pip_deps = meta.get("pip_dependencies", []) + pip_deps = _provider_pip_dependencies(provider_name, meta.get("pip_dependencies", [])) if not pip_deps: return @@ -108,10 +143,15 @@ def _install_dependencies(provider_name: str) -> None: "hindsight-all": "hindsight", } - # Check which packages are missing + # Check which packages need installation. missing = [] for dep in pip_deps: - import_name = _IMPORT_NAMES.get(dep, dep.replace("-", "_").split("[")[0]) + if force: + missing.append(dep) + continue + dep_name = re.match(r"^[A-Za-z0-9_][A-Za-z0-9_.\-]*", dep) + base = dep_name.group(0) if dep_name else dep + import_name = _IMPORT_NAMES.get(base, base.replace("-", "_").split("[")[0]) try: __import__(import_name) except ImportError: diff --git a/hermes_cli/model_normalize.py b/hermes_cli/model_normalize.py index 2c4988cc76..8c4a31b25d 100644 --- a/hermes_cli/model_normalize.py +++ b/hermes_cli/model_normalize.py @@ -12,9 +12,11 @@ Different LLM providers expect model identifiers in different formats: model IDs, but Claude still uses hyphenated native names like ``claude-sonnet-4-6``. - **OpenCode Go** preserves dots in model names: ``minimax-m2.7``. -- **DeepSeek** accepts ``deepseek-chat`` (V3), ``deepseek-reasoner`` - (R1-family), and the first-class V-series IDs (``deepseek-v4-pro``, - ``deepseek-v4-flash``, and any future ``deepseek-v-*``). Older +- **DeepSeek** accepts only the first-class V-series IDs + (``deepseek-v4-pro``, ``deepseek-v4-flash``, and any future + ``deepseek-v-*``). The legacy aliases ``deepseek-chat`` and + ``deepseek-reasoner`` were retired on 2026-07-24 and are remapped to + ``deepseek-v4-flash`` (official non-thinking / thinking shims). Older Hermes revisions folded every non-reasoner input into ``deepseek-chat``, which on aggregators routes to V3 — so a user picking V4 Pro was silently downgraded. @@ -118,8 +120,9 @@ _LOWERCASE_MODEL_PROVIDERS: frozenset[str] = frozenset({ # --------------------------------------------------------------------------- # DeepSeek special handling # --------------------------------------------------------------------------- -# DeepSeek's API only recognises exactly two model identifiers. We map -# common aliases and patterns to the canonical names. +# DeepSeek's direct API only accepts first-class V-series IDs after the +# 2026-07-24 cut-off. Legacy aliases and fuzzy names are remapped here so +# saved configs / picker leftovers cannot keep sending retired IDs. _DEEPSEEK_REASONER_KEYWORDS: frozenset[str] = frozenset({ "reasoner", @@ -129,9 +132,15 @@ _DEEPSEEK_REASONER_KEYWORDS: frozenset[str] = frozenset({ "cot", }) +# Retired on 2026-07-24 15:59 UTC. Official docs: both aliases mapped to +# deepseek-v4-flash (chat = non-thinking, reasoner = thinking). Thinking +# mode itself is controlled by extra_body.thinking on the DeepSeek profile. +_DEEPSEEK_RETIRED_ALIASES: frozenset[str] = frozenset({ + "deepseek-chat", + "deepseek-reasoner", +}) + _DEEPSEEK_CANONICAL_MODELS: frozenset[str] = frozenset({ - "deepseek-chat", # V3 on DeepSeek direct and most aggregators - "deepseek-reasoner", # R1-family reasoning model "deepseek-v4-pro", # V4 Pro — first-class model ID "deepseek-v4-flash", # V4 Flash — first-class model ID }) @@ -149,13 +158,15 @@ def _normalize_for_deepseek(model_name: str) -> str: """Map a model input to a DeepSeek-accepted identifier. Rules: - - Already a known canonical (``deepseek-chat``/``deepseek-reasoner``/ - ``deepseek-v4-pro``/``deepseek-v4-flash``) -> pass through. + - Retired aliases ``deepseek-chat`` / ``deepseek-reasoner`` (cut off + 2026-07-24) -> ``deepseek-v4-flash``. + - Already a known canonical (``deepseek-v4-pro``/``deepseek-v4-flash``) + -> pass through. - Matches the V-series pattern ``deepseek-v...`` -> pass through (covers future ``deepseek-v5-*`` and dated variants without a release). - Contains a reasoner keyword (r1, think, reasoning, cot, reasoner) - -> ``deepseek-reasoner``. - - Everything else -> ``deepseek-chat``. + -> ``deepseek-v4-flash``. + - Everything else -> ``deepseek-v4-flash``. Args: model_name: The bare model name (vendor prefix already stripped). @@ -165,6 +176,11 @@ def _normalize_for_deepseek(model_name: str) -> str: """ bare = _strip_vendor_prefix(model_name).lower() + # Retired aliases must rewrite — DeepSeek returns HTTP 400 after the + # 2026-07-24 cut-off if these IDs are sent on the wire. + if bare in _DEEPSEEK_RETIRED_ALIASES: + return "deepseek-v4-flash" + if bare in _DEEPSEEK_CANONICAL_MODELS: return bare @@ -175,9 +191,9 @@ def _normalize_for_deepseek(model_name: str) -> str: # Check for reasoner-like keywords anywhere in the name for keyword in _DEEPSEEK_REASONER_KEYWORDS: if keyword in bare: - return "deepseek-reasoner" + return "deepseek-v4-flash" - return "deepseek-chat" + return "deepseek-v4-flash" # --------------------------------------------------------------------------- @@ -369,10 +385,13 @@ def normalize_model_for_provider(model_input: str, target_provider: str) -> str: 'minimax-m2.5-free' >>> normalize_model_for_provider("deepseek-v3", "deepseek") - 'deepseek-chat' + 'deepseek-v4-flash' >>> normalize_model_for_provider("deepseek-r1", "deepseek") - 'deepseek-reasoner' + 'deepseek-v4-flash' + + >>> normalize_model_for_provider("deepseek-reasoner", "deepseek") + 'deepseek-v4-flash' >>> normalize_model_for_provider("my-model", "custom") 'my-model' diff --git a/hermes_cli/model_switch.py b/hermes_cli/model_switch.py index 3e239a593e..bc39fe8020 100644 --- a/hermes_cli/model_switch.py +++ b/hermes_cli/model_switch.py @@ -2370,7 +2370,8 @@ def list_authenticated_providers( entry_models: list = [] if default_model: entry_models.append(default_model) - for model_id in _declared_model_ids(ep_cfg.get("models", [])): + entry_declared_models = _declared_model_ids(ep_cfg.get("models", [])) + for model_id in entry_declared_models: if model_id not in entry_models: entry_models.append(model_id) @@ -2404,6 +2405,7 @@ def list_authenticated_providers( "name": grp_display or display_name, "api_url": api_url, "models": [], + "has_explicit_models": False, "ep_cfg": ep_cfg, # used below for discover_models / api_key "raw_names": [], } @@ -2411,6 +2413,13 @@ def list_authenticated_providers( for _m in entry_models: if _m and _m not in ep_groups[group_key]["models"]: ep_groups[group_key]["models"].append(_m) + # Track explicit ``models:`` declarations separately from the + # merged list: a singular ``default_model``/``model`` is only the + # active selection and must not be mistaken for the user narrowing + # the endpoint to a curated subset (mirrors section 4's + # declaration-tracking; see #40542 / PR #61928). + if entry_declared_models: + ep_groups[group_key]["has_explicit_models"] = True ep_groups[group_key]["raw_names"].append(display_name) for grp in ep_groups.values(): @@ -2433,8 +2442,11 @@ def list_authenticated_providers( # unless the provider explicitly opts out via discover_models: false. # Policy mirrors Section 4's should_probe logic: # - With an api_key: always probe (user opted into the endpoint). - # - Without an api_key but with explicit models: skip — the user - # is narrowing a public endpoint to a specific subset. + # - Without an api_key but with an explicit ``models:`` list: + # skip — the user is narrowing a public endpoint to a specific + # subset. A singular ``default_model``/``model`` does NOT count + # as narrowing (it's just the active selection) and must not + # suppress discovery — mirrors section 4 / #40542. # - Without an api_key AND no explicit models: probe anyway so # bare-endpoint providers (local llama.cpp / Ollama servers) # still show their full model catalog. @@ -2445,7 +2457,7 @@ def list_authenticated_providers( discover = ep_cfg.get("discover_models", True) if isinstance(discover, str): discover = discover.lower() not in {"false", "no", "0"} - has_explicit_models = bool(models_list) + has_explicit_models = bool(grp.get("has_explicit_models")) _ep_url_norm = str(api_url).strip().rstrip("/").lower() _ep_slug_norm = str(ep_name).strip().lower() _ep_custom_slug_norm = custom_provider_slug(display_name).lower() diff --git a/hermes_cli/models.py b/hermes_cli/models.py index 3352058a51..ccf6165094 100644 --- a/hermes_cli/models.py +++ b/hermes_cli/models.py @@ -390,8 +390,6 @@ _PROVIDER_MODELS: dict[str, list[str]] = { "deepseek": [ "deepseek-v4-pro", "deepseek-v4-flash", - "deepseek-chat", - "deepseek-reasoner", ], "xiaomi": [ "mimo-v2.5-pro", @@ -2085,11 +2083,25 @@ def _provider_keys(provider: str) -> set[str]: return {k for k in (key, normalized) if k} +# Retired model IDs kept for /model auto-detect only — not shown in pickers. +# DeepSeek cut these off on 2026-07-24; model_normalize remaps them on the wire. +_PROVIDER_RETIRED_ALIASES: dict[str, tuple[str, ...]] = { + "deepseek": ("deepseek-chat", "deepseek-reasoner"), +} + + +def _provider_catalog_names(provider: str) -> tuple[str, ...]: + """Active picker models plus retired aliases recognized for detection.""" + active = tuple(_PROVIDER_MODELS.get(provider, [])) + retired = _PROVIDER_RETIRED_ALIASES.get(provider, ()) + return active + retired + + def _model_in_provider_catalog(name_lower: str, providers: set[str]) -> bool: return any( name_lower == model.lower() for provider in providers - for model in _PROVIDER_MODELS.get(provider, []) + for model in _provider_catalog_names(provider) ) @@ -2235,7 +2247,7 @@ def detect_static_provider_for_model( current_provider == "custom" or current_provider.startswith("custom:") ) - for pid, models in _PROVIDER_MODELS.items(): + for pid in _PROVIDER_MODELS: if ( pid in current_keys or pid in _AGGREGATOR_PROVIDERS @@ -2244,7 +2256,7 @@ def detect_static_provider_for_model( continue if _is_custom_current: continue - if any(name_lower == m.lower() for m in models): + if any(name_lower == m.lower() for m in _provider_catalog_names(pid)): return (pid, name) # Borrow-list providers (re-expose other vendors' models) only after every @@ -2252,7 +2264,7 @@ def detect_static_provider_for_model( for pid in _BORROWED_MODEL_PROVIDERS: if pid in current_keys: continue - if any(name_lower == m.lower() for m in _PROVIDER_MODELS.get(pid, [])): + if any(name_lower == m.lower() for m in _provider_catalog_names(pid)): return (pid, name) return None diff --git a/hermes_cli/oneshot.py b/hermes_cli/oneshot.py index 320c61c8cc..1f04173f0a 100644 --- a/hermes_cli/oneshot.py +++ b/hermes_cli/oneshot.py @@ -469,10 +469,15 @@ def _run_agent( logging.debug("oneshot session store cleanup failed", exc_info=True) -def _oneshot_clarify_callback(question: str, choices=None) -> str: +def _oneshot_clarify_callback(question: str, choices=None, multi_select=False) -> str: """Clarify is disabled in oneshot mode — tell the agent to pick a default and proceed instead of stalling or erroring.""" if choices: + if multi_select: + return ( + f"[oneshot mode: no user available. Pick the best subset from " + f"{choices} using your own judgment and continue.]" + ) return ( f"[oneshot mode: no user available. Pick the best option from " f"{choices} using your own judgment and continue.]" diff --git a/hermes_cli/prompt_size.py b/hermes_cli/prompt_size.py index 3b6530bfd6..30c212a429 100644 --- a/hermes_cli/prompt_size.py +++ b/hermes_cli/prompt_size.py @@ -15,16 +15,38 @@ from __future__ import annotations import json import re -from typing import Any, Dict, List, Tuple +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple # The skills index is wrapped in this tag pair inside the stable tier. _SKILLS_BLOCK_RE = re.compile(r".*?", re.DOTALL) +# A rendered skill entry inside is `` - name: desc`` (or +# `` - name`` when the skill has no description). Category headers use two +# leading spaces, so the four-space + ``- `` prefix isolates skill lines. +_SKILL_LINE_PREFIX = " - " + +# Posture-demoted categories render all visible skill names on one shared line. +_NAMES_ONLY_LINE_RE = re.compile(r"^ .+ \[names only\]: (?P.+)$") + +# Cap the human-readable "Skills by size" table; ``--json`` always has them all. +_SKILLS_TABLE_LIMIT = 20 + def _bytes(s: str) -> int: return len(s.encode("utf-8")) +def _tool_name(tool: Any) -> str: + """Return the callable name of a tool schema (OpenAI ``function`` shape).""" + if not isinstance(tool, dict): + return "" + fn = tool.get("function") + if isinstance(fn, dict) and fn.get("name"): + return str(fn["name"]) + return str(tool.get("name", "")) + + def _build_inspection_agent(platform: str) -> Any: """Construct an offline AIAgent for prompt inspection. @@ -57,12 +79,166 @@ def _build_inspection_agent(platform: str) -> Any: ) +def _skill_md_paths_by_name() -> Dict[str, Path]: + """Map each installed skill's name to its ``SKILL.md`` path on disk. + + Keyed by both the frontmatter ``name`` (what the index renders) and the + skill directory name, so either resolves. Local skills win over external + dirs (``get_all_skills_dirs`` yields local first), matching the index's own + precedence. Used to attribute the real on-disk read cost per skill. + """ + from agent.skill_utils import ( + get_all_skills_dirs, + iter_skill_index_files, + parse_frontmatter, + ) + + mapping: Dict[str, Path] = {} + for skills_dir in get_all_skills_dirs(): + if not skills_dir.exists(): + continue + for skill_file in iter_skill_index_files(skills_dir, "SKILL.md"): + frontmatter_name = skill_file.parent.name + try: + frontmatter, _ = parse_frontmatter( + skill_file.read_text(encoding="utf-8") + ) + frontmatter_name = str(frontmatter.get("name") or frontmatter_name) + except Exception: + pass + # setdefault keeps the first (local) occurrence on name collisions. + mapping.setdefault(frontmatter_name, skill_file) + mapping.setdefault(skill_file.parent.name, skill_file) + return mapping + + +def _compute_skills_breakdown(skills_block: str) -> List[Dict[str, Any]]: + """Per-skill byte breakdown parsed from the rendered ````. + + Two honest, distinct numbers per skill: + + * ``index_line_bytes`` — the skill's attributed bytes in the always-on + index (the fixed per-call cost of *listing* the skill). For a compact + ``[names only]`` line, each name keeps its own bytes and receives an + even share of the category prefix and separators. The attributed bytes + therefore sum exactly to the shared rendered line. + * ``skill_md_bytes`` — the on-disk size of the skill's ``SKILL.md`` (the + real token cost paid only when the model loads it via ``skill_view``). + ``None`` when the name can't be mapped to a file (e.g. a plugin skill + whose source lives outside the scanned skill dirs). + + Sorted largest-first by ``skill_md_bytes`` (the read cost that dominates + pruning decisions), tie-broken by name. + """ + name_to_path = _skill_md_paths_by_name() + entries: List[Dict[str, Any]] = [] + + def append_entry( + name: str, + *, + attributed_bytes: int, + total_bytes: int, + shared_bytes: int, + skill_count: int, + ) -> None: + path = name_to_path.get(name) + md_bytes: Optional[int] = None + if path is not None: + try: + md_bytes = path.stat().st_size + except OSError: + md_bytes = None + entries.append({ + "name": name, + "index_line_bytes": attributed_bytes, + "index_line_total_bytes": total_bytes, + "index_line_shared_bytes": shared_bytes, + "index_line_skill_count": skill_count, + "skill_md_bytes": md_bytes, + "path": str(path) if path is not None else "", + }) + + for line in skills_block.splitlines(): + compact_match = _NAMES_ONLY_LINE_RE.match(line) + if compact_match is not None: + names = [ + name.strip() + for name in compact_match.group("names").split(",") + if name.strip() + ] + if not names: + continue + total_bytes = _bytes(line) + name_bytes = [_bytes(name) for name in names] + shared_total = total_bytes - sum(name_bytes) + shared_base, shared_remainder = divmod(shared_total, len(names)) + for index, name in enumerate(names): + shared_bytes = shared_base + (1 if index < shared_remainder else 0) + append_entry( + name, + attributed_bytes=name_bytes[index] + shared_bytes, + total_bytes=total_bytes, + shared_bytes=shared_bytes, + skill_count=len(names), + ) + continue + + if not line.startswith(_SKILL_LINE_PREFIX): + continue + rest = line[len(_SKILL_LINE_PREFIX):] + # ``name: desc`` — the first ``": "`` separates name from description. + # Namespaced names (``codex:rescue``) have no space after their colon, + # so partitioning on ``": "`` keeps the full name intact. + name = rest.partition(": ")[0].strip() + if not name: + continue + line_bytes = _bytes(line) + append_entry( + name, + attributed_bytes=line_bytes, + total_bytes=line_bytes, + shared_bytes=0, + skill_count=1, + ) + entries.sort(key=lambda e: (-(e["skill_md_bytes"] or 0), e["name"])) + return entries + + +def _compute_toolsets_breakdown(tools: List[Any]) -> List[Dict[str, Any]]: + """Per-toolset schema-byte breakdown of the resolved tool list. + + Each tool is attributed to its single canonical toolset from the registry, + so ``json_bytes`` sums are fully attributable: the grand total equals the + sum of the individual tool serializations (which is the array total from + ``tools['json_bytes']`` minus JSON framing of ``2 * count`` bytes). Sorted + largest-first by ``json_bytes``, tie-broken by toolset name. + """ + from tools.registry import registry + + tool_to_toolset = registry.get_tool_to_toolset_map() + groups: Dict[str, Dict[str, Any]] = {} + for tool in tools: + name = _tool_name(tool) + toolset = tool_to_toolset.get(name) or "(unknown)" + group = groups.setdefault( + toolset, {"toolset": toolset, "tool_count": 0, "json_bytes": 0} + ) + group["tool_count"] += 1 + group["json_bytes"] += _bytes(json.dumps(tool, ensure_ascii=False)) + out = list(groups.values()) + out.sort(key=lambda g: (-g["json_bytes"], g["toolset"])) + return out + + def compute_prompt_breakdown(platform: str = "cli") -> Dict[str, Any]: """Return a dict of prompt-size measurements for a fresh session. Keys: ``system_prompt`` (chars/bytes), ``skills_index``, ``memory``, - ``user_profile``, ``tools`` (count + json bytes), and ``sections`` (a list - of (label, chars, bytes) for the three prompt tiers). + ``user_profile``, ``tools`` (count + json bytes), ``sections`` (a list of + (label, chars, bytes) for the three prompt tiers), ``skills_breakdown`` + (per-skill index-line + on-disk SKILL.md bytes, largest-first), and + ``toolsets_breakdown`` (per-toolset tool count + schema json bytes, + largest-first). The last two answer "what should I disable to cut tokens?". """ from agent.system_prompt import build_system_prompt, build_system_prompt_parts @@ -114,6 +290,8 @@ def compute_prompt_breakdown(platform: str = "cli") -> Dict[str, Any]: "user_profile": {"chars": len(user_block), "bytes": _bytes(user_block)}, "tools": {"count": len(tools), "json_bytes": _bytes(tools_json)}, "sections": sections, + "skills_breakdown": _compute_skills_breakdown(skills_index), + "toolsets_breakdown": _compute_toolsets_breakdown(tools), } @@ -143,6 +321,41 @@ def render_breakdown(data: Dict[str, Any]) -> str: lines.append("") tools = data["tools"] lines.append(f" Tool schemas : {tools['json_bytes']:>8,} B ({_fmt_kb(tools['json_bytes'])}, {tools['count']} tools)") + + # Per-toolset schema cost — which toolset's tools cost the most to ship. + toolsets = data.get("toolsets_breakdown") or [] + if toolsets: + lines.append("") + lines.append(" Toolsets by size (tool-schema JSON, largest first):") + lines.append(f" {'toolset':<22} {'tools':>5} {'schema':>10}") + for ts in toolsets: + lines.append( + f" {ts['toolset']:<22} {ts['tool_count']:>5} " + f"{ts['json_bytes']:>8,} B ({_fmt_kb(ts['json_bytes'])})" + ) + + # Per-skill cost — index line (always shipped) vs SKILL.md (read on load). + skills = data.get("skills_breakdown") or [] + if skills: + lines.append("") + lines.append( + " Skills by size (SKILL.md on-disk = read cost; index cost = " + "attributed always-on bytes, largest first):" + ) + lines.append(f" {'skill':<28} {'SKILL.md':>10} {'index cost':>10}") + shown = skills[:_SKILLS_TABLE_LIMIT] + for sk in shown: + md = sk["skill_md_bytes"] + md_str = f"{md:>8,} B" if md is not None else f"{'n/a':>10}" + name = sk["name"] + if len(name) > 28: + name = name[:27] + "…" + lines.append( + f" {name:<28} {md_str} {sk['index_line_bytes']:>8,} B" + ) + remaining = len(skills) - len(shown) + if remaining > 0: + lines.append(f" … and {remaining} more (use --json for the full list)") return "\n".join(lines) diff --git a/hermes_cli/session_filters.py b/hermes_cli/session_filters.py index c05164695a..6633f9e3c0 100644 --- a/hermes_cli/session_filters.py +++ b/hermes_cli/session_filters.py @@ -86,13 +86,15 @@ def build_prune_filters(args: Any) -> Dict[str, Any]: ``--after``, ``--source``, ``--title``, ``--end-reason``, ``--cwd``, ``--min-messages``, ``--max-messages``, ``--archived``/``--no-archived``. - ``--before``/``--older-than`` both set the upper bound (started_before); - ``--after``/``--newer-than`` both set the lower bound (started_after). - When both a duration flag and an absolute flag target the same bound, - the tighter (more restrictive) bound wins. + ``--older-than`` / ``--newer-than`` bound last activity, while + ``--before`` / ``--after`` explicitly bound session start time. Last + activity is the latest message timestamp, falling back to ``started_at`` + for empty sessions. Raises ``ValueError`` on unparseable values or an empty/inverted window. """ + last_active_before: Optional[float] = None + last_active_after: Optional[float] = None started_before: Optional[float] = None started_after: Optional[float] = None @@ -103,19 +105,23 @@ def build_prune_filters(args: Any) -> Dict[str, Any]: older_than = getattr(args, "older_than", None) if older_than is not None: - started_before = _tighter( - started_before, parse_point_in_time(older_than, "--older-than"), True + last_active_before = _tighter( + last_active_before, + parse_point_in_time(older_than, "--older-than"), + True, + ) + newer_than = getattr(args, "newer_than", None) + if newer_than is not None: + last_active_after = _tighter( + last_active_after, + parse_point_in_time(newer_than, "--newer-than"), + False, ) before = getattr(args, "before", None) if before is not None: started_before = _tighter( started_before, parse_point_in_time(before, "--before"), True ) - newer_than = getattr(args, "newer_than", None) - if newer_than is not None: - started_after = _tighter( - started_after, parse_point_in_time(newer_than, "--newer-than"), False - ) after = getattr(args, "after", None) if after is not None: started_after = _tighter( @@ -128,9 +134,19 @@ def build_prune_filters(args: Any) -> Dict[str, Any]: and started_after >= started_before ): raise ValueError( - "Empty time window: the --after/--newer-than bound " + "Empty start-time window: the --after bound " f"({format_epoch(started_after)}) is not earlier than the " - f"--before/--older-than bound ({format_epoch(started_before)})." + f"--before bound ({format_epoch(started_before)})." + ) + if ( + last_active_before is not None + and last_active_after is not None + and last_active_after >= last_active_before + ): + raise ValueError( + "Empty activity window: the --newer-than bound " + f"({format_epoch(last_active_after)}) is not earlier than the " + f"--older-than bound ({format_epoch(last_active_before)})." ) filters: Dict[str, Any] = { @@ -138,6 +154,8 @@ def build_prune_filters(args: Any) -> Dict[str, Any]: # Without this, prune_sessions' default 90-day cutoff would silently # cap an --after/--newer-than-only window. "older_than_days": None, + "last_active_before": last_active_before, + "last_active_after": last_active_after, "started_before": started_before, "started_after": started_after, "source": getattr(args, "source", None), @@ -165,6 +183,14 @@ def build_prune_filters(args: Any) -> Dict[str, Any]: def describe_filters(filters: Dict[str, Any]) -> str: """Human-readable summary of active filters for confirmation prompts.""" parts = [] + if filters.get("last_active_before") is not None: + parts.append( + f"last active before {format_epoch(filters['last_active_before'])}" + ) + if filters.get("last_active_after") is not None: + parts.append( + f"last active after {format_epoch(filters['last_active_after'])}" + ) if filters.get("started_before") is not None: parts.append(f"started before {format_epoch(filters['started_before'])}") if filters.get("started_after") is not None: diff --git a/hermes_cli/skills_hub.py b/hermes_cli/skills_hub.py index 5c8653b3ba..e34ade41c0 100644 --- a/hermes_cli/skills_hub.py +++ b/hermes_cli/skills_hub.py @@ -502,7 +502,8 @@ def do_browse(page: int = 1, page_size: int = 20, source: str = "all", def do_install(identifier: str, category: str = "", force: bool = False, console: Optional[Console] = None, skip_confirm: bool = False, invalidate_cache: bool = True, - name_override: str = "") -> None: + name_override: str = "", + source_id: Optional[str] = None) -> None: """Fetch, quarantine, scan, confirm, and install a skill. ``name_override`` lets non-interactive callers (slash commands, gateway, @@ -511,10 +512,18 @@ def do_install(identifier: str, category: str = "", force: bool = False, triggers a prompt instead; ``skip_confirm=True`` means "non-interactive" (so pair it with ``name_override`` when installing from a URL that has no frontmatter). + + ``source_id`` pins resolution to a single source adapter (e.g. ``clawhub``). + Callers that already know a skill's provenance -- notably ``do_update``, + which reads it from the lockfile -- should pass it so a bare, slash-less + identifier cannot be fuzzy-resolved to a same-named skill in a different + registry. Skill names are not namespaced across registries, so an + unconstrained resolve can silently change a skill's provenance. """ from tools.skills_hub import ( GitHubAuth, create_source_router, ensure_hub_dirs, quarantine_bundle, install_from_quarantine, HubLockFile, + _source_matches, ) from tools.skills_guard import scan_skill_cached, should_allow_install, format_scan_report @@ -525,6 +534,18 @@ def do_install(identifier: str, category: str = "", force: bool = False, auth = GitHubAuth() sources = create_source_router(auth) + if source_id: + pinned = [src for src in sources if _source_matches(src, source_id)] + if pinned: + sources = pinned + else: + c.print( + f"[bold red]Error:[/] no source adapter for '{source_id}'. " + f"Refusing to resolve '{identifier}' against other registries " + f"(that would change the skill's provenance).\n" + ) + return + # If identifier looks like a short name (no slashes), resolve it via search if "/" not in identifier: identifier = _resolve_short_name(identifier, sources, c) @@ -1058,7 +1079,20 @@ def do_update(name: Optional[str] = None, console: Optional[Console] = None) -> installed = lock.get_installed(entry["name"]) category = _derive_category_from_install_path(installed.get("install_path", "")) if installed else "" c.print(f"[bold]Updating:[/] {entry['name']}") - do_install(entry["identifier"], category=category, force=True, console=c) + # Pin the update to the source registry recorded in the lockfile. + # Without this, a bare (slash-less) identifier such as "reddit" falls + # through to _resolve_short_name()'s fuzzy catalog search inside + # do_install, which can match a same-named skill in a DIFFERENT + # registry and install that instead -- overwriting the user's files + # and rewriting the lock's `source`. An update must never change a + # skill's provenance. + do_install( + entry["identifier"], + category=category, + force=True, + console=c, + source_id=entry.get("source", "") or None, + ) c.print(f"[bold green]Updated {len(updates)} skill(s).[/]\n") diff --git a/hermes_cli/subcommands/approvals.py b/hermes_cli/subcommands/approvals.py new file mode 100644 index 0000000000..ed5760cced --- /dev/null +++ b/hermes_cli/subcommands/approvals.py @@ -0,0 +1,77 @@ +"""``hermes approvals`` subcommand parser. + +Follows the cron/security pattern: parser construction lives here, the +handler is injected by ``main.py`` so this module never imports ``main`` +(cycle avoidance). +""" + +from __future__ import annotations + +from typing import Callable + + +def build_approvals_parser(subparsers, *, cmd_approvals: Callable) -> None: + """Attach the ``approvals`` subcommand to ``subparsers``.""" + approvals_parser = subparsers.add_parser( + "approvals", + help="Approval-prompt tools (mine history into allowlist proposals)", + description=( + "Tools for the dangerous-command approval system. " + "`hermes approvals suggest` mines past approval decisions from " + "the session database and proposes command_allowlist entries so " + "repeatedly-approved commands stop prompting." + ), + ) + approvals_subparsers = approvals_parser.add_subparsers( + dest="approvals_command", + metavar="", + ) + + suggest_parser = approvals_subparsers.add_parser( + "suggest", + help="Propose command_allowlist entries from past approvals", + description=( + "Scan the session database for dangerous-classified commands " + "that ran with user approval, rank the recurring patterns, and " + "print a numbered allowlist proposal. Nothing is written unless " + "--apply is given. Destructive classes (recursive delete, sudo, " + "disk writes, credential edits, ...) are never proposed." + ), + ) + suggest_parser.add_argument( + "--apply", + dest="apply_indices", + metavar="N[,M...]", + help="Merge the numbered proposals (from a prior run) into " + "command_allowlist in config.yaml", + ) + suggest_parser.add_argument( + "--json", + action="store_true", + help="Emit machine-readable JSON instead of human-readable text", + ) + suggest_parser.add_argument( + "--days", + type=int, + default=90, + help="How far back to scan session history (default: 90; 0 = all)", + ) + suggest_parser.add_argument( + "--min-count", + dest="min_count", + type=int, + default=2, + help="Minimum approval count for a pattern to be proposed (default: 2)", + ) + suggest_parser.add_argument( + "--limit", + type=int, + default=20, + help="Maximum number of proposals to show (default: 20)", + ) + suggest_parser.add_argument( + "--db", + help="Path to an alternate session database (default: ~/.hermes/state.db)", + ) + suggest_parser.set_defaults(func=cmd_approvals) + approvals_parser.set_defaults(func=cmd_approvals) diff --git a/hermes_cli/subcommands/import_agent.py b/hermes_cli/subcommands/import_agent.py new file mode 100644 index 0000000000..c20d10b053 --- /dev/null +++ b/hermes_cli/subcommands/import_agent.py @@ -0,0 +1,49 @@ +"""``hermes import-agent`` subcommand parser. + +Follows the ``hermes claw`` pattern (see ``hermes_cli/subcommands/claw.py``): +parser building lives here, the handler is injected to avoid importing +``main``, and the import logic itself lives in ``hermes_cli/agent_import.py``. +""" + +from __future__ import annotations + +from typing import Callable + + +def build_import_agent_parser(subparsers, *, cmd_import_agent: Callable) -> None: + """Attach the ``import-agent`` subcommand to ``subparsers``.""" + parser = subparsers.add_parser( + "import-agent", + help="Import a Claude Code or Codex CLI setup into Hermes", + description=( + "One-command import of another coding agent's setup into Hermes. " + "Maps CLAUDE.md/AGENTS.md instructions, permission allowlists, MCP " + "servers, skills, and memories into their Hermes equivalents. " + "Always shows a preview before making changes. API keys and " + "credentials are never imported — run 'hermes setup' for those." + ), + ) + parser.add_argument( + "agent", + nargs="?", + choices=["claude-code", "codex"], + help="Which agent to import from (default: auto-detect ~/.claude or ~/.codex)", + ) + parser.add_argument( + "--source", + help="Path to the agent's config directory (default: ~/.claude or ~/.codex)", + ) + parser.add_argument( + "--dry-run", + action="store_true", + help="Preview only — stop after showing what would be imported", + ) + parser.add_argument( + "--overwrite", + action="store_true", + help="Overwrite existing Hermes items on name conflicts (default: skip)", + ) + parser.add_argument( + "--yes", "-y", action="store_true", help="Skip confirmation prompts" + ) + parser.set_defaults(func=cmd_import_agent) diff --git a/hermes_cli/tips.py b/hermes_cli/tips.py index a3dab63c44..be8cb25b15 100644 --- a/hermes_cli/tips.py +++ b/hermes_cli/tips.py @@ -69,7 +69,7 @@ TIPS = [ "hermes chat -t web,terminal enables only specific toolsets for a focused session.", "hermes chat -s github-pr-workflow preloads a skill at launch.", "hermes chat -q \"query\" runs a single non-interactive query and exits.", - "hermes chat --max-turns 200 overrides the default 90-iteration limit per turn.", + "hermes chat --max-turns 1000 overrides the default 500-iteration limit per turn.", "hermes chat --checkpoints enables filesystem snapshots before every destructive file change.", "hermes --yolo bypasses all dangerous command approval prompts for the entire session.", "hermes chat --source telegram tags the session for filtering in hermes sessions list.", @@ -112,7 +112,7 @@ TIPS = [ "Set display.busy_input_mode: queue to queue messages instead of interrupting the agent, or steer to inject them mid-run via /steer.", "Set display.resume_display: minimal to skip the full conversation recap on session resume.", "Set compression.threshold: 0.50 to control when auto-compression fires (default: 50% of context).", - "Set agent.max_turns: 200 to let the agent take more tool-calling steps per turn.", + "Set agent.max_turns: 1000 to let the agent take more tool-calling steps per turn.", "Set file_read_max_chars: 200000 to increase the max content per read_file call.", "Set approvals.mode: smart to let an LLM auto-approve safe commands and auto-deny dangerous ones.", "Set fallback_model in config.yaml to automatically fail over to a backup provider.", diff --git a/hermes_cli/tools_config.py b/hermes_cli/tools_config.py index ace4dc3a72..1d3f6899fa 100644 --- a/hermes_cli/tools_config.py +++ b/hermes_cli/tools_config.py @@ -795,7 +795,7 @@ def _cua_install_target_writable() -> bool: return True -def install_cua_driver(upgrade: bool = False) -> bool: +def install_cua_driver(upgrade: bool = False, require_confirmed_update: bool = False) -> bool: """Install or refresh the cua-driver binary used by Computer Use. The upstream installer always pulls the latest release tag, so re-running @@ -808,6 +808,19 @@ def install_cua_driver(upgrade: bool = False) -> bool: update`` if the binary supports it). Used by ``hermes update`` and by ``hermes computer-use install --upgrade``. + ``require_confirmed_update`` (only meaningful with ``upgrade=True`` and + an installed binary): when the driver's native ``check-update`` verb + can't positively confirm that a newer release exists — the driver is + too old for the verb, the GitHub check failed, we're offline, or the + probe timed out — keep the installed version and return instead of + falling through to the full upstream installer. ``hermes update`` sets + this so a broken update check costs seconds, not a multi-minute silent + reinstall on every update (the upstream installer runs up to + ``_CUA_INSTALLER_TIMEOUT`` and install.ps1's concurrency lock can add + a further ~600s wait on Windows). ``hermes computer-use install + --upgrade`` leaves it False — an explicit upgrade request should still + reinstall when the check is indeterminate. + Returns True iff cua-driver is installed (or successfully refreshed) when the function returns. Supported on macOS, Windows, and Linux (Linux is alpha). Silently returns False on unsupported platforms. @@ -897,20 +910,35 @@ def install_cua_driver(upgrade: bool = False) -> bool: # Skip the (network) re-install when the driver itself reports it's already # on the latest release. Best-effort: an older driver (no check-update - # verb) or an offline check returns None, in which case we fall through and - # re-run the installer as before. + # verb) or an offline check returns None. What happens then depends on the + # caller: `hermes update` (require_confirmed_update=True) keeps the + # installed version — an indeterminate check must never cost the user a + # multi-minute silent reinstall on every update. An explicit + # `hermes computer-use install --upgrade` falls through and re-runs the + # installer as before. if binary: + _state = None try: from tools.computer_use.cua_backend import cua_driver_update_check _state = cua_driver_update_check() - if _state is not None and not _state.get("update_available"): - _print_success( - f" {driver_cmd} is already on the latest release " - f"({_state.get('current_version') or 'unknown'})." - ) - return True except Exception: - pass + _state = None + if _state is not None and not _state.get("update_available"): + _print_success( + f" {driver_cmd} is already on the latest release " + f"({_state.get('current_version') or 'unknown'})." + ) + return True + if _state is None and require_confirmed_update: + _print_info( + f" Could not confirm a newer {driver_cmd} release " + "(offline, rate-limited, or driver too old to check); " + "keeping the installed version." + ) + _print_info( + " Force a refresh with: hermes computer-use install --upgrade" + ) + return True if binary: # Show before/after version when we have a baseline. Best-effort. @@ -958,27 +986,116 @@ _CUA_INSTALLER_TIMEOUT = 660 _CUA_LOCK_STALE_AFTER = 600 +def _cua_install_home() -> "Path": + """Package home shared by the upstream POSIX and Windows installers.""" + return Path( + os.environ.get("CUA_DRIVER_RS_HOME") + or str(Path.home() / ".cua-driver") + ) + + def _cua_install_lock_dir() -> "Path": """Path of the upstream installer's concurrent-install lock dir.""" - home = os.environ.get("CUA_DRIVER_RS_HOME") or str(Path.home() / ".cua-driver") - return Path(home) / "packages" / ".install.lock.d" + return _cua_install_home() / "packages" / ".install.lock.d" + + +def _cua_windows_install_lock_file() -> "Path": + """Path of install.ps1's FileShare::None lock file.""" + return _cua_install_home() / "install.lock" + + +def _clear_stale_windows_cua_install_lock() -> None: + """Delete install.ps1's lock file only when no process still holds it. + + ``install.ps1`` serializes installs with a ``FileStream`` opened using + ``FileShare::None``. Mirror that primitive with a zero-share + ``CreateFileW`` probe. ``FILE_FLAG_DELETE_ON_CLOSE`` removes an unlocked + leftover atomically when the probe handle closes, avoiding a gap where a + new installer could acquire the file between our probe and deletion. + """ + lock_file = _cua_windows_install_lock_file() + try: + if not lock_file.is_file(): + return + + import ctypes as _ctypes + from ctypes import wintypes as _wintypes + + # Win32 constants used by install.ps1's FileShare::None equivalent. + delete_access = 0x00010000 + generic_read = 0x80000000 + generic_write = 0x40000000 + open_existing = 3 + file_attribute_normal = 0x00000080 + file_flag_delete_on_close = 0x04000000 + + kernel32 = _ctypes.WinDLL("kernel32", use_last_error=True) + create_file = kernel32.CreateFileW + create_file.argtypes = [ + _wintypes.LPCWSTR, + _wintypes.DWORD, + _wintypes.DWORD, + _wintypes.LPVOID, + _wintypes.DWORD, + _wintypes.DWORD, + _wintypes.HANDLE, + ] + create_file.restype = _wintypes.HANDLE + close_handle = kernel32.CloseHandle + close_handle.argtypes = [_wintypes.HANDLE] + close_handle.restype = _wintypes.BOOL + + handle = create_file( + str(lock_file), + generic_read | generic_write | delete_access, + 0, # FileShare::None + None, + open_existing, + file_attribute_normal | file_flag_delete_on_close, + None, + ) + invalid_handle = _wintypes.HANDLE(-1).value + if handle == invalid_handle: + logger.debug( + "Windows cua install lock at %s is still held or cannot be " + "removed (winerror %s)", + lock_file, + _ctypes.get_last_error(), + ) + return + + if not close_handle(handle): + logger.debug( + "could not close Windows cua install lock probe at %s " + "(winerror %s)", + lock_file, + _ctypes.get_last_error(), + ) + return + if lock_file.exists(): + logger.debug( + "Windows cua install lock probe succeeded but %s remains", + lock_file, + ) + return + + logger.info("Cleared stale Windows cua-driver install lock at %s", lock_file) + _print_info(f" Cleared stale cua-driver install lock ({lock_file}).") + except Exception as e: + logger.debug("stale Windows cua install lock check failed: %s", e) def _clear_stale_cua_install_lock() -> None: """Best-effort: remove a stale installer lock left by a dead holder. - A previous timed-out/killed install can orphan - ``~/.cua-driver/packages/.install.lock.d`` (the holder's pid is stamped - into its ``info`` file). The upstream installer only reclaims it after - waiting 600s — longer than our old subprocess timeout — so an orphaned - lock wedged every subsequent refresh. Clear it up front when the holder - is provably dead; leave it alone when the holder is alive (a slow - concurrent install) or liveness can't be determined. - - POSIX-only: the lock protocol lives in the bash installer; install.ps1 - does not use it. + The POSIX installer stamps its holder pid into + ``~/.cua-driver/packages/.install.lock.d/info``. The Windows installer + instead holds ``~/.cua-driver/install.lock`` open with + ``FileShare::None``. Clear either artifact up front only when its + platform-specific liveness check proves that no install still holds it. """ if sys.platform == "win32": + _clear_stale_windows_cua_install_lock() return lock_dir = _cua_install_lock_dir() try: @@ -1122,7 +1239,48 @@ def _run_cua_driver_installer(label: str = "Installing", verbose: bool = True) - if not is_windows: os.killpg(os.getpgid(proc.pid), _signal.SIGKILL) # windows-footgun: ok — POSIX branch only else: - proc.kill() + # PowerShell may leave download/install helpers alive after its + # direct process is killed. Those descendants inherit stdout + # and can keep both communicate() and install.lock wedged, so + # collect the tree first and kill it leaf-up. + import psutil as _psutil + + try: + parent = _psutil.Process(proc.pid) + descendants = parent.children(recursive=True) + except _psutil.NoSuchProcess: + return + except _psutil.Error as e: + logger.debug( + "could not enumerate cua-driver installer tree for pid %s: %s", + proc.pid, + e, + ) + proc.kill() + return + + for child in reversed(descendants): + try: + child.kill() + except _psutil.NoSuchProcess: + pass + except _psutil.Error as e: + logger.debug( + "could not kill cua-driver installer child pid %s: %s", + child.pid, + e, + ) + try: + parent.kill() + except _psutil.NoSuchProcess: + pass + except _psutil.Error as e: + logger.debug( + "could not kill cua-driver installer parent pid %s: %s", + proc.pid, + e, + ) + proc.kill() except (OSError, ProcessLookupError): proc.kill() diff --git a/hermes_cli/web_server.py b/hermes_cli/web_server.py index d9b7a1a56b..5b136bd820 100644 --- a/hermes_cli/web_server.py +++ b/hermes_cli/web_server.py @@ -922,7 +922,7 @@ _SCHEMA_OVERRIDES: Dict[str, Dict[str, Any]] = { "options": ["stash", "discard"], }, "updates.refresh_cua_driver": { - "type": "bool", + "type": "boolean", "description": ( "Refresh an already-installed cua-driver during hermes update. " "Disable this on non-admin macOS accounts where /Applications is " @@ -5076,8 +5076,7 @@ def get_profiles_sessions_sidebar( recents_rows: List[Dict[str, Any]] = [] cron_rows: List[Dict[str, Any]] = [] messaging_rows: List[Dict[str, Any]] = [] - recents_total = 0 - recents_profile_totals: Dict[str, int] = {} + recents_truncated: Dict[str, bool] = {} errors: List[Dict[str, str]] = [] now = time.time() @@ -5116,18 +5115,13 @@ def get_profiles_sessions_sidebar( continue try: if recents_scope == "all" or name == recents_scope: - recents_rows.extend( - _tag(_slice(db, exclude=recents_exclude_list, cap=recents_cap), name) - ) - rtotal = db.session_count( - exclude_sources=recents_exclude_list or None, - min_message_count=1, - include_archived=False, - archived_only=False, - exclude_children=True, - ) - recents_total += rtotal - recents_profile_totals[name] = rtotal + profile_rows = _slice(db, exclude=recents_exclude_list, cap=recents_cap) + # A full window means more rows remain on disk. That is all the + # sidebar's "load more" needs, and unlike an exact COUNT(*) per + # profile per refresh it costs nothing beyond the rows already + # read. + recents_truncated[name] = len(profile_rows) >= recents_cap + recents_rows.extend(_tag(profile_rows, name)) cron_rows.extend(_tag(_slice(db, source="cron", cap=cron_cap), name)) messaging_rows.extend( _tag(_slice(db, exclude=messaging_exclude_list, cap=messaging_cap), name) @@ -5146,8 +5140,7 @@ def get_profiles_sessions_sidebar( return { "recents": { "sessions": _window(recents_rows, recents_cap), - "total": recents_total, - "profile_totals": recents_profile_totals, + "profiles_truncated": recents_truncated, }, "cron": {"sessions": _window(cron_rows, cron_cap)}, "messaging": { @@ -8202,8 +8195,36 @@ _PLATFORM_OVERRIDES: dict[str, dict[str, Any]] = { # plugin registry. Only the docs link needs an override here so the # Channels page can point at the Microsoft Teams setup guide. "teams": { + "description": "Connect Hermes to Microsoft Teams chats via the Bot Framework.", "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/teams", }, + # Bundled platform plugins: name comes from the plugin registry label; + # give each a human description (the registry's install_hint is a + # dependency note, not a description) and a docs link. + "irc": { + "description": "Relay messages between an IRC channel (or DMs) and Hermes.", + "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/irc", + }, + "line": { + "description": "Use Hermes from LINE via the LINE Messaging API webhook.", + "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/line", + }, + "ntfy": { + "description": "Chat with Hermes over ntfy push topics (ntfy.sh or self-hosted).", + "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/ntfy", + }, + "photon": { + "description": "Use Hermes through iMessage via Photon's managed Spectrum platform.", + "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/photon", + }, + "raft": { + "description": "Join a Raft workspace as an external agent.", + "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/raft", + }, + "simplex": { + "description": "Talk to Hermes over SimpleX Chat via a local simplex-chat daemon.", + "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/simplex", + }, "yuanbao": { "name": "Yuanbao (元宝)", "description": "Connect Hermes to Tencent Yuanbao.", @@ -8230,6 +8251,23 @@ _PLATFORM_OVERRIDES: dict[str, dict[str, Any]] = { "env_vars": ("WEBHOOK_ENABLED", "WEBHOOK_PORT", "WEBHOOK_SECRET"), "required_env": (), }, + "msgraph_webhook": { + "name": "Microsoft Graph Webhook", + "description": "Receive Microsoft Graph change notifications (Teams meetings, Outlook, …).", + "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/msgraph-webhook", + "required_env": (), + }, + "whatsapp_cloud": { + "name": "WhatsApp Cloud API", + "description": "Use Hermes via Meta's hosted WhatsApp Cloud API (no local bridge).", + "docs_url": "https://hermes-agent.nousresearch.com/docs/user-guide/messaging/whatsapp-cloud", + }, + "relay": { + "name": "Relay (experimental)", + "description": "Generic relay adapter fronted by the Hermes Relay connector.", + "docs_url": "", + "required_env": (), + }, } # Display order: well-known platforms surface first; unknown plugins fall to @@ -8411,6 +8449,28 @@ def _messaging_platform_catalog() -> tuple[dict[str, Any], ...]: """ from gateway.config import Platform + # Resolve plugin entries FIRST. Plugin platforms (irc, ntfy, photon, …) + # leak into ``Platform.__members__`` as pseudo-members the moment any + # earlier code path calls ``Platform("")`` — and iterating the + # enum first would then claim them with no plugin metadata, rendering + # nameless "Irc"/"Ntfy" cards with empty descriptions on the Channels + # page while the real label/install-hint sat unused in the registry. + plugin_map: dict[str, Any] = {} + try: + # Plugin discovery only runs as a side effect of importing + # model_tools; this server process doesn't do that, so trigger it + # explicitly (idempotent) or plugin_entries() is empty here and + # every plugin platform renders nameless. + from hermes_cli.plugins import discover_plugins + + discover_plugins() + from gateway.platform_registry import platform_registry + + for plugin_entry in platform_registry.plugin_entries(): + plugin_map[plugin_entry.name] = plugin_entry + except Exception: + _log.debug("plugin platform registry unavailable", exc_info=True) + seen: set[str] = set() entries: list[dict[str, Any]] = [] @@ -8420,18 +8480,15 @@ def _messaging_platform_catalog() -> tuple[dict[str, Any], ...]: if member.value in seen: continue seen.add(member.value) - entries.append(_build_catalog_entry(member.value)) + entries.append( + _build_catalog_entry(member.value, plugin_map.get(member.value)) + ) - try: - from gateway.platform_registry import platform_registry - - for plugin_entry in platform_registry.plugin_entries(): - if plugin_entry.name in seen: - continue - seen.add(plugin_entry.name) - entries.append(_build_catalog_entry(plugin_entry.name, plugin_entry)) - except Exception: - _log.debug("plugin platform registry unavailable", exc_info=True) + for name, plugin_entry in plugin_map.items(): + if name in seen: + continue + seen.add(name) + entries.append(_build_catalog_entry(name, plugin_entry)) order = {pid: idx for idx, pid in enumerate(_PLATFORM_ORDER)} entries.sort( @@ -11965,9 +12022,15 @@ def _prune_sessions(body: SessionPrune): "ok": True, "removed": 0, "matched": len(rows), - # Rows are ordered oldest-first. - "oldest_started_at": rows[0]["started_at"] if rows else None, - "newest_started_at": rows[-1]["started_at"] if rows else None, + # Rows are ordered by last activity, not creation time. + "oldest_last_active": rows[0]["last_active"] if rows else None, + "newest_last_active": rows[-1]["last_active"] if rows else None, + "oldest_started_at": ( + min(r["started_at"] for r in rows) if rows else None + ), + "newest_started_at": ( + max(r["started_at"] for r in rows) if rows else None + ), "sessions": [ { "id": r["id"], @@ -11975,6 +12038,7 @@ def _prune_sessions(body: SessionPrune): "title": r.get("title"), "model": r.get("model"), "started_at": r["started_at"], + "last_active": r["last_active"], "message_count": r["message_count"], } for r in rows diff --git a/hermes_state.py b/hermes_state.py index 32fcffac58..9ad8761670 100644 --- a/hermes_state.py +++ b/hermes_state.py @@ -9615,6 +9615,8 @@ class SessionDB: @staticmethod def _prune_filter_where( *, + last_active_before: Optional[float] = None, + last_active_after: Optional[float] = None, started_before: Optional[float] = None, started_after: Optional[float] = None, source: Optional[str] = None, @@ -9657,6 +9659,24 @@ class SessionDB: """ clauses = ["s.ended_at IS NOT NULL"] params: list = [] + if last_active_before is not None: + clauses.append( + """COALESCE( + (SELECT MAX(m.timestamp) FROM messages m + WHERE m.session_id = s.id), + s.started_at + ) < ?""" + ) + params.append(last_active_before) + if last_active_after is not None: + clauses.append( + """COALESCE( + (SELECT MAX(m.timestamp) FROM messages m + WHERE m.session_id = s.id), + s.started_at + ) >= ?""" + ) + params.append(last_active_after) if started_before is not None: clauses.append("s.started_at < ?") params.append(started_before) @@ -9744,18 +9764,31 @@ class SessionDB: Backs ``--dry-run`` and pre-confirmation counts. Accepts the same keyword filters as :meth:`_prune_filter_where` (unknown names raise ``TypeError`` there). Rows are ordered oldest-first and carry - ``id, source, title, model, started_at, ended_at, message_count, - archived``. + ``id, source, title, model, started_at, last_active, ended_at, + message_count, archived``. ``older_than_days`` is an inactivity + threshold: it uses the latest message timestamp, falling back to + ``started_at`` for sessions without messages. """ - if filters.get("started_before") is None and older_than_days is not None: - filters["started_before"] = time.time() - (older_than_days * 86400) + if ( + filters.get("last_active_before") is None + and filters.get("started_before") is None + and older_than_days is not None + ): + filters["last_active_before"] = time.time() - ( + older_than_days * 86400 + ) where, params = self._prune_filter_where(source=source, **filters) with self._lock: cursor = self._conn.execute( f"""SELECT s.id, s.source, s.title, s.model, s.started_at, + COALESCE( + (SELECT MAX(m.timestamp) FROM messages m + WHERE m.session_id = s.id), + s.started_at + ) AS last_active, s.ended_at, s.message_count, s.archived FROM sessions s WHERE {where} - ORDER BY s.started_at ASC""", + ORDER BY last_active ASC, s.started_at ASC""", params, ) return [dict(row) for row in cursor.fetchall()] @@ -9794,8 +9827,8 @@ class SessionDB: "Touched" is the latest message timestamp (falling back to ``started_at``) — i.e. real recency, not creation time — so a session created long ago but active yesterday is spared, while an old - abandoned one (even a still-open one) is swept. This differs from - :meth:`archive_sessions`, which ages on ``started_at`` and only ended + abandoned one (even a still-open one) is swept. Unlike + :meth:`archive_sessions`, this method can also archive unended sessions. Guards: @@ -9844,15 +9877,19 @@ class SessionDB: ) -> int: """Delete sessions matching the filters. Returns count deleted. - Default behavior (no keyword filters) is unchanged: delete ended - sessions older than ``older_than_days`` days, optionally restricted - to ``source``. Additional keyword filters AND together — the full - set is defined by :meth:`_prune_filter_where`: + By default, delete ended sessions inactive for + ``older_than_days`` days, optionally restricted to ``source``. + Activity is the latest message timestamp, falling back to + ``started_at`` for sessions without messages. Additional keyword + filters AND together — the full set is defined by + :meth:`_prune_filter_where`: + * ``last_active_before`` / ``last_active_after`` — epoch bounds on + the latest message timestamp (falling back to ``started_at``). * ``started_before`` / ``started_after`` — epoch bounds on - ``started_at``. ``started_before`` overrides ``older_than_days``; - pass ``older_than_days=None`` for no upper age bound (e.g. when - only pruning a recent window via ``started_after``). + ``started_at``. An explicit ``started_before`` overrides the + default ``older_than_days`` inactivity cutoff; pass + ``older_than_days=None`` for no implicit upper age bound. * ``title_like`` / ``model_like`` / ``branch_like`` — case-insensitive substring matches. * ``end_reason`` / ``provider`` / ``user_id`` / ``chat_id`` / @@ -9874,8 +9911,14 @@ class SessionDB: ``request_dump_*``) for every pruned session, outside the DB transaction. """ - if filters.get("started_before") is None and older_than_days is not None: - filters["started_before"] = time.time() - (older_than_days * 86400) + if ( + filters.get("last_active_before") is None + and filters.get("started_before") is None + and older_than_days is not None + ): + filters["last_active_before"] = time.time() - ( + older_than_days * 86400 + ) where, where_params = self._prune_filter_where(source=source, **filters) removed_ids: list[str] = [] @@ -10613,7 +10656,7 @@ class SessionDB: vacuum: bool = True, sessions_dir: Optional[Path] = None, ) -> Dict[str, Any]: - """Idempotent auto-maintenance: prune old sessions + optional VACUUM. + """Idempotent auto-maintenance: prune inactive sessions + optional VACUUM. Records the last run timestamp in state_meta so subsequent calls within ``min_interval_hours`` no-op. Designed to be called once at @@ -10667,7 +10710,7 @@ class SessionDB: if pruned > 0: logger.info( - "state.db auto-maintenance: pruned %d session(s) older than %d days%s", + "state.db auto-maintenance: pruned %d session(s) inactive for %d days%s", pruned, retention_days, " + VACUUM" if result["vacuumed"] else "", diff --git a/infograficos/bedrock_converse_cache_demoniaco_flow.png b/infograficos/bedrock_converse_cache_demoniaco_flow.png deleted file mode 100644 index 37eb271441..0000000000 Binary files a/infograficos/bedrock_converse_cache_demoniaco_flow.png and /dev/null differ diff --git a/infographic/approval-mode-validation/infographic.png b/infographic/approval-mode-validation/infographic.png deleted file mode 100644 index 4091ca78a7..0000000000 Binary files a/infographic/approval-mode-validation/infographic.png and /dev/null differ diff --git a/infographic/checkpoint-prune-startup-safety/infographic.png b/infographic/checkpoint-prune-startup-safety/infographic.png deleted file mode 100644 index 87d1bcc5d5..0000000000 Binary files a/infographic/checkpoint-prune-startup-safety/infographic.png and /dev/null differ diff --git a/infographic/dead-delivery-targets/infographic.png b/infographic/dead-delivery-targets/infographic.png deleted file mode 100644 index 9dbf3431ee..0000000000 Binary files a/infographic/dead-delivery-targets/infographic.png and /dev/null differ diff --git a/infographic/feishu-group-events/infographic.png b/infographic/feishu-group-events/infographic.png deleted file mode 100644 index 4936e34427..0000000000 Binary files a/infographic/feishu-group-events/infographic.png and /dev/null differ diff --git a/infographic/fireworks-provider/infographic.png b/infographic/fireworks-provider/infographic.png deleted file mode 100644 index 23534ceb2e..0000000000 Binary files a/infographic/fireworks-provider/infographic.png and /dev/null differ diff --git a/infographic/friendly-tool-labels/infographic.png b/infographic/friendly-tool-labels/infographic.png deleted file mode 100644 index 843bf4bfe4..0000000000 Binary files a/infographic/friendly-tool-labels/infographic.png and /dev/null differ diff --git a/infographic/gateway-reconnect-contract/infographic.png b/infographic/gateway-reconnect-contract/infographic.png deleted file mode 100644 index 11d36ab235..0000000000 Binary files a/infographic/gateway-reconnect-contract/infographic.png and /dev/null differ diff --git a/infographic/list-profiles-perf-54751/infographic.png b/infographic/list-profiles-perf-54751/infographic.png deleted file mode 100644 index b5ba45fde6..0000000000 Binary files a/infographic/list-profiles-perf-54751/infographic.png and /dev/null differ diff --git a/infographic/reasoning-max-ultra/infographic.png b/infographic/reasoning-max-ultra/infographic.png deleted file mode 100644 index 3856b5f971..0000000000 Binary files a/infographic/reasoning-max-ultra/infographic.png and /dev/null differ diff --git a/infographic/win-clh-lock-traceback/infographic.png b/infographic/win-clh-lock-traceback/infographic.png deleted file mode 100644 index caeb4eaec4..0000000000 Binary files a/infographic/win-clh-lock-traceback/infographic.png and /dev/null differ diff --git a/locales/af.yaml b/locales/af.yaml index 6ade25b452..40dce4e162 100644 --- a/locales/af.yaml +++ b/locales/af.yaml @@ -53,6 +53,7 @@ gateway: more: "... en nog {count}" running_processes: "**Lopende agtergrondprosesse:** {count}" async_jobs: "**Asinchrone werke van die gateway:** {count}" + background_delegations: "**Agtergrond-delegasies:** {count}" none: "Geen aktiewe agente of lopende take nie." state_starting: "begin" state_running: "loop" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Herstel na kontrolepunt {hash}: {reason}\n'n Voor-terugrol-momentopname is outomaties gestoor." restore_failed: "❌ {error}" + diff: + not_enabled: "Kontrolepunte is nie geaktiveer nie, dus is daar geen sessie-basislyn nie.\nAktiveer in config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nGewone /diff werk steeds — dit gebruik git direk." + no_changes: "Geen veranderinge nie." + failed: "{error}" + set_home: save_failed: "Kon nie tuiste-kanaal stoor nie: {error}" success: "✅ Tuiste-kanaal gestel op **{name}** (ID: {chat_id}).\nKron-take en kruisplatform-boodskappe sal hier afgelewer word." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Hermes Gateway Status**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Kumulatiewe API-tokens (elke oproep weer gestuur):** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Agent loop:** {state}" state_yes: "Ja ⚡" state_no: "Nee" diff --git a/locales/ar.yaml b/locales/ar.yaml index f2c78e8c65..fcd3a6555e 100644 --- a/locales/ar.yaml +++ b/locales/ar.yaml @@ -25,6 +25,24 @@ approval: blocklist_message: "هذا الأمر مدرج في قائمة الحظر غير المشروطة ولا يمكن الموافقة عليه." gateway: + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." approval_expired: "⚠️ انتهت صلاحية الموافقة (لم يعد الوكيل ينتظر). اطلب من الوكيل المحاولة مرة أخرى." draining: "⏳ جارٍ إنهاء {count} وكيل نشط قبل إعادة التشغيل..." goal_cleared: "✓ تم مسح الهدف." @@ -58,6 +76,7 @@ gateway: more: "... و{count} آخر" running_processes: "**العمليات الخلفية الجارية:** {count}" async_jobs: "**مهام البوابة غير المتزامنة:** {count}" + background_delegations: "**التفويضات في الخلفية:** {count}" none: "لا يوجد وكلاء نشطون أو مهام جارية." state_starting: "قيد البدء" state_running: "قيد التشغيل" @@ -280,6 +299,11 @@ gateway: restored: "✅ استُعيد إلى نقطة التحقّق {hash}: {reason}\nحُفظت لقطة ما قبل التراجع تلقائيًا." restore_failed: "❌ {error}" + diff: + not_enabled: "نقاط التحقق غير مفعّلة، لذا لا يوجد خط أساس للجلسة.\nفعّلها في config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nلا يزال /diff العادي يعمل — فهو يستخدم git مباشرة." + no_changes: "لا توجد تغييرات." + failed: "{error}" + set_home: save_failed: "فشل حفظ القناة الرئيسية: {error}" success: "✅ ضُبطت القناة الرئيسية إلى **{name}** (المعرّف: {chat_id}).\nستُسلَّم مهام cron والرسائل عبر المنصّات هنا." diff --git a/locales/de.yaml b/locales/de.yaml index 2c6b83d335..bd562e879c 100644 --- a/locales/de.yaml +++ b/locales/de.yaml @@ -53,6 +53,7 @@ gateway: more: "... und {count} weitere" running_processes: "**Laufende Hintergrundprozesse:** {count}" async_jobs: "**Gateway-Async-Jobs:** {count}" + background_delegations: "**Hintergrund-Delegationen:** {count}" none: "Keine aktiven Agenten oder laufenden Aufgaben." state_starting: "startet" state_running: "läuft" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Auf Checkpoint {hash} wiederhergestellt: {reason}\nEin Pre-Rollback-Snapshot wurde automatisch gespeichert." restore_failed: "❌ {error}" + diff: + not_enabled: "Checkpoints sind nicht aktiviert, daher gibt es keine Sitzungs-Baseline.\nIn config.yaml aktivieren:\n```\ncheckpoints:\n enabled: true\n```\nEin einfaches /diff funktioniert weiterhin — es nutzt git direkt." + no_changes: "Keine Änderungen." + failed: "{error}" + set_home: save_failed: "Home-Kanal konnte nicht gespeichert werden: {error}" success: "✅ Home-Kanal auf **{name}** (ID: {chat_id}) gesetzt.\nCron-Jobs und plattformübergreifende Nachrichten werden hierher geliefert." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Hermes-Gateway-Status**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Modell:** `{model}` ({provider})" context: "**Kontext:** {used} / {total} ({pct}%)" context_used: "**Kontext:** ~{used} Tokens" - tokens: "**Kumulierte API-Tokens (bei jedem Aufruf erneut gesendet):** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Agent läuft:** {state}" state_yes: "Ja ⚡" state_no: "Nein" diff --git a/locales/en.yaml b/locales/en.yaml index 2bd229e2b5..72712986c7 100644 --- a/locales/en.yaml +++ b/locales/en.yaml @@ -68,6 +68,7 @@ gateway: more: "... and {count} more" running_processes: "**Running background processes:** {count}" async_jobs: "**Gateway async jobs:** {count}" + background_delegations: "**Background delegations:** {count}" none: "No active agents or running tasks." state_starting: "starting" state_running: "running" @@ -290,10 +291,34 @@ gateway: restored: "✅ Restored to checkpoint {hash}: {reason}\nA pre-rollback snapshot was saved automatically." restore_failed: "❌ {error}" + diff: + not_enabled: "Checkpoints are not enabled, so there's no session baseline.\nEnable in config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nPlain /diff still works — it uses git directly." + no_changes: "No changes." + failed: "{error}" + set_home: save_failed: "Failed to save home channel: {error}" success: "✅ Home channel set to **{name}** (ID: {chat_id}).\nCron jobs and cross-platform messages will be delivered here." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." + status: header: "📊 **Hermes Gateway Status**" matrix_scope_header: "**Matrix scope:**" @@ -310,7 +335,7 @@ gateway: model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Cumulative API tokens (re-sent each call):** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Agent Running:** {state}" state_yes: "Yes ⚡" state_no: "No" diff --git a/locales/es.yaml b/locales/es.yaml index 61e2b4418c..8786078142 100644 --- a/locales/es.yaml +++ b/locales/es.yaml @@ -53,6 +53,7 @@ gateway: more: "... y {count} más" running_processes: "**Procesos en segundo plano en ejecución:** {count}" async_jobs: "**Tareas asíncronas del gateway:** {count}" + background_delegations: "**Delegaciones en segundo plano:** {count}" none: "No hay agentes activos ni tareas en ejecución." state_starting: "iniciando" state_running: "en ejecución" @@ -275,9 +276,32 @@ gateway: restored: "✅ Restaurado al checkpoint {hash}: {reason}\nSe guardó automáticamente un snapshot previo al rollback." restore_failed: "❌ {error}" + diff: + not_enabled: "Los checkpoints no están activados, así que no hay línea base de sesión.\nActívalos en config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nEl /diff normal sigue funcionando — usa git directamente." + no_changes: "Sin cambios." + failed: "{error}" + set_home: save_failed: "No se pudo guardar el canal principal: {error}" success: "✅ Canal principal establecido en **{name}** (ID: {chat_id}).\nLas tareas cron y los mensajes entre plataformas se entregarán aquí." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Estado de Hermes Gateway**" @@ -295,7 +319,7 @@ gateway: model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Tokens de API acumulados (reenviados en cada llamada):** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Agente activo:** {state}" state_yes: "Sí ⚡" state_no: "No" diff --git a/locales/fr.yaml b/locales/fr.yaml index d067b26eee..65d885d228 100644 --- a/locales/fr.yaml +++ b/locales/fr.yaml @@ -53,6 +53,7 @@ gateway: more: "... et {count} de plus" running_processes: "**Processus d'arrière-plan en cours :** {count}" async_jobs: "**Tâches asynchrones du gateway :** {count}" + background_delegations: "**Délégations en arrière-plan :** {count}" none: "Aucun agent actif ni tâche en cours." state_starting: "démarrage" state_running: "en cours" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Restauré au point de contrôle {hash} : {reason}\nUn instantané pré-rollback a été enregistré automatiquement." restore_failed: "❌ {error}" + diff: + not_enabled: "Les points de contrôle ne sont pas activés, il n'y a donc pas de référence de session.\nActivez-les dans config.yaml :\n```\ncheckpoints:\n enabled: true\n```\nLe /diff simple fonctionne toujours — il utilise git directement." + no_changes: "Aucun changement." + failed: "{error}" + set_home: save_failed: "Impossible d'enregistrer le canal principal : {error}" success: "✅ Canal principal défini sur **{name}** (ID : {chat_id}).\nLes tâches cron et les messages multi-plateformes seront livrés ici." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **État de Hermes Gateway**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Jetons :** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Agent en cours :** {state}" state_yes: "Oui ⚡" state_no: "Non" diff --git a/locales/ga.yaml b/locales/ga.yaml index 32ed8d597a..26473ccdea 100644 --- a/locales/ga.yaml +++ b/locales/ga.yaml @@ -57,6 +57,7 @@ gateway: more: "... agus {count} eile" running_processes: "**Próisis chúlra ag rith:** {count}" async_jobs: "**Tascanna asincrónacha gateway:** {count}" + background_delegations: "**Tarmligin sa chúlra:** {count}" none: "Níl aon ghníomhairí gníomhacha ná tascanna ag rith." state_starting: "ag tosú" state_running: "ag rith" @@ -282,9 +283,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Aischurtha go seicphointe {hash}: {reason}\nSábháladh roghchóip réamh-rollback go huathoibríoch." restore_failed: "❌ {error}" + diff: + not_enabled: "Níl seicphointí cumasaithe, mar sin níl aon bhonnlíne seisiúin ann.\nCumasaigh in config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nOibríonn /diff simplí fós — úsáideann sé git go díreach." + no_changes: "Gan athruithe." + failed: "{error}" + set_home: save_failed: "Theip ar shábháil chainéil bhaile: {error}" success: "✅ Cainéal baile socraithe go **{name}** (ID: {chat_id}).\nSeachadfar tascanna cron agus teachtaireachtaí trasardáin anseo." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Stádas Hermes Gateway**" @@ -302,7 +326,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Comharthaí:** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Gníomhaire ag rith:** {state}" state_yes: "Tá ⚡" state_no: "Níl" diff --git a/locales/hu.yaml b/locales/hu.yaml index 97a2e67515..2600210fb9 100644 --- a/locales/hu.yaml +++ b/locales/hu.yaml @@ -53,6 +53,7 @@ gateway: more: "... és még {count}" running_processes: "**Futó háttérfolyamatok:** {count}" async_jobs: "**Átjáró aszinkron feladatai:** {count}" + background_delegations: "**Háttérdelegálások:** {count}" none: "Nincsenek aktív ügynökök vagy futó feladatok." state_starting: "indul" state_running: "fut" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Visszaállítva a(z) {hash} ellenőrzőpontra: {reason}\nA visszaállítás előtti pillanatkép automatikusan elmentve." restore_failed: "❌ {error}" + diff: + not_enabled: "A checkpointok nincsenek engedélyezve, így nincs munkamenet-alapvonal.\nEngedélyezd a config.yaml-ban:\n```\ncheckpoints:\n enabled: true\n```\nA sima /diff továbbra is működik — közvetlenül a gitet használja." + no_changes: "Nincs változás." + failed: "{error}" + set_home: save_failed: "Nem sikerült menteni a kezdőcsatornát: {error}" success: "✅ Kezdőcsatorna beállítva: **{name}** (ID: {chat_id}).\nA cron-feladatok és a platformok közötti üzenetek ide érkeznek." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Hermes Gateway állapot**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Tokenek:** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Ügynök fut:** {state}" state_yes: "Igen ⚡" state_no: "Nem" diff --git a/locales/it.yaml b/locales/it.yaml index f390f2879c..d7ab72628c 100644 --- a/locales/it.yaml +++ b/locales/it.yaml @@ -53,6 +53,7 @@ gateway: more: "... e {count} altri" running_processes: "**Processi in background in esecuzione:** {count}" async_jobs: "**Job asincroni del gateway:** {count}" + background_delegations: "**Delegazioni in background:** {count}" none: "Nessun agente attivo o attività in esecuzione." state_starting: "in avvio" state_running: "in esecuzione" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Ripristinato al checkpoint {hash}: {reason}\nUno snapshot pre-rollback è stato salvato automaticamente." restore_failed: "❌ {error}" + diff: + not_enabled: "I checkpoint non sono abilitati, quindi non esiste una baseline di sessione.\nAbilitali in config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nIl /diff semplice funziona comunque — usa git direttamente." + no_changes: "Nessuna modifica." + failed: "{error}" + set_home: save_failed: "Salvataggio del canale home non riuscito: {error}" success: "✅ Canale home impostato su **{name}** (ID: {chat_id}).\nI cron job e i messaggi cross-platform verranno consegnati qui." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Stato del Gateway Hermes**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Token:** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Agente in esecuzione:** {state}" state_yes: "Sì ⚡" state_no: "No" diff --git a/locales/ja.yaml b/locales/ja.yaml index 2682dc5863..14c78f3d82 100644 --- a/locales/ja.yaml +++ b/locales/ja.yaml @@ -53,6 +53,7 @@ gateway: more: "... 他に {count} 件" running_processes: "**実行中のバックグラウンドプロセス:** {count}" async_jobs: "**ゲートウェイ非同期ジョブ:** {count}" + background_delegations: "**バックグラウンド委任:** {count}" none: "アクティブなエージェントや実行中のタスクはありません。" state_starting: "起動中" state_running: "実行中" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ チェックポイント {hash} に復元しました: {reason}\nロールバック前のスナップショットが自動的に保存されました。" restore_failed: "❌ {error}" + diff: + not_enabled: "チェックポイントが有効になっていないため、セッションのベースラインがありません。\nconfig.yaml で有効にしてください:\n```\ncheckpoints:\n enabled: true\n```\n通常の /diff は引き続き使えます — git を直接使用します。" + no_changes: "変更はありません。" + failed: "{error}" + set_home: save_failed: "ホームチャンネルを保存できませんでした: {error}" success: "✅ ホームチャンネルを **{name}** (ID: {chat_id}) に設定しました。\nCron ジョブとプラットフォーム間メッセージはここに配信されます。" + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Hermes ゲートウェイ状態**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**トークン:** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**エージェント実行中:** {state}" state_yes: "はい ⚡" state_no: "いいえ" diff --git a/locales/ko.yaml b/locales/ko.yaml index df07aa12a3..a2b920cafd 100644 --- a/locales/ko.yaml +++ b/locales/ko.yaml @@ -53,6 +53,7 @@ gateway: more: "... 외 {count}개 더" running_processes: "**실행 중인 백그라운드 프로세스:** {count}" async_jobs: "**게이트웨이 비동기 작업:** {count}" + background_delegations: "**백그라운드 위임:** {count}" none: "활성 에이전트나 실행 중인 작업이 없습니다." state_starting: "시작 중" state_running: "실행 중" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ 체크포인트 {hash}(으)로 복원됨: {reason}\n롤백 전 스냅샷이 자동으로 저장되었습니다." restore_failed: "❌ {error}" + diff: + not_enabled: "체크포인트가 활성화되지 않아 세션 기준선이 없습니다.\nconfig.yaml에서 활성화하세요:\n```\ncheckpoints:\n enabled: true\n```\n일반 /diff는 여전히 작동합니다 — git을 직접 사용합니다." + no_changes: "변경 사항이 없습니다." + failed: "{error}" + set_home: save_failed: "홈 채널 저장에 실패했습니다: {error}" success: "✅ 홈 채널이 **{name}**(ID: {chat_id})(으)로 설정되었습니다.\n크론 작업과 플랫폼 간 메시지가 여기로 전달됩니다." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Hermes 게이트웨이 상태**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**토큰:** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**에이전트 실행 중:** {state}" state_yes: "예 ⚡" state_no: "아니오" diff --git a/locales/pt.yaml b/locales/pt.yaml index 3559c044c5..be3c43d2bf 100644 --- a/locales/pt.yaml +++ b/locales/pt.yaml @@ -53,6 +53,7 @@ gateway: more: "... e mais {count}" running_processes: "**Processos em segundo plano em execução:** {count}" async_jobs: "**Tarefas assíncronas do gateway:** {count}" + background_delegations: "**Delegações em segundo plano:** {count}" none: "Não há agentes ativos nem tarefas em execução." state_starting: "a iniciar" state_running: "em execução" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Restaurado para o checkpoint {hash}: {reason}\nFoi guardado automaticamente um snapshot anterior ao rollback." restore_failed: "❌ {error}" + diff: + not_enabled: "Os checkpoints não estão ativados, então não há linha de base da sessão.\nAtive em config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nO /diff simples continua funcionando — ele usa git diretamente." + no_changes: "Sem alterações." + failed: "{error}" + set_home: save_failed: "Falha ao guardar o canal principal: {error}" success: "✅ Canal principal definido como **{name}** (ID: {chat_id}).\nAs tarefas cron e mensagens entre plataformas serão entregues aqui." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Estado do Hermes Gateway**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Tokens de API cumulativos (reenviados a cada chamada):** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Agente em execução:** {state}" state_yes: "Sim ⚡" state_no: "Não" diff --git a/locales/ru.yaml b/locales/ru.yaml index b55c006244..10443501a0 100644 --- a/locales/ru.yaml +++ b/locales/ru.yaml @@ -53,6 +53,7 @@ gateway: more: "... и ещё {count}" running_processes: "**Выполняющиеся фоновые процессы:** {count}" async_jobs: "**Асинхронные задачи шлюза:** {count}" + background_delegations: "**Фоновые делегирования:** {count}" none: "Нет активных агентов или выполняющихся задач." state_starting: "запускается" state_running: "выполняется" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Восстановлено до контрольной точки {hash}: {reason}\nСнимок перед откатом сохранён автоматически." restore_failed: "❌ {error}" + diff: + not_enabled: "Контрольные точки не включены, поэтому базовой линии сессии нет.\nВключите в config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nОбычный /diff по-прежнему работает — он использует git напрямую." + no_changes: "Изменений нет." + failed: "{error}" + set_home: save_failed: "Не удалось сохранить главный канал: {error}" success: "✅ Главный канал установлен на **{name}** (ID: {chat_id}).\nCron-задачи и межплатформенные сообщения будут доставляться сюда." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Состояние Hermes Gateway**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Токены:** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Агент активен:** {state}" state_yes: "Да ⚡" state_no: "Нет" diff --git a/locales/tr.yaml b/locales/tr.yaml index 5e5f0a1517..7ef3ac86b7 100644 --- a/locales/tr.yaml +++ b/locales/tr.yaml @@ -53,6 +53,7 @@ gateway: more: "... ve {count} tane daha" running_processes: "**Çalışan arka plan süreçleri:** {count}" async_jobs: "**Gateway asenkron işleri:** {count}" + background_delegations: "**Arka plan delegasyonları:** {count}" none: "Aktif ajan veya çalışan görev yok." state_starting: "başlatılıyor" state_running: "çalışıyor" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ {hash} kontrol noktasına geri yüklendi: {reason}\nGeri alma öncesi anlık görüntü otomatik olarak kaydedildi." restore_failed: "❌ {error}" + diff: + not_enabled: "Kontrol noktaları etkin değil, bu yüzden oturum temel çizgisi yok.\nconfig.yaml içinde etkinleştirin:\n```\ncheckpoints:\n enabled: true\n```\nDüz /diff yine de çalışır — doğrudan git kullanır." + no_changes: "Değişiklik yok." + failed: "{error}" + set_home: save_failed: "Ana kanal kaydedilemedi: {error}" success: "✅ Ana kanal **{name}** (ID: {chat_id}) olarak ayarlandı.\nCron işleri ve platformlar arası mesajlar buraya iletilecek." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Hermes Gateway Durumu**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Token:** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Aracı çalışıyor:** {state}" state_yes: "Evet ⚡" state_no: "Hayır" diff --git a/locales/uk.yaml b/locales/uk.yaml index 4606ebe91a..95027ab60e 100644 --- a/locales/uk.yaml +++ b/locales/uk.yaml @@ -53,6 +53,7 @@ gateway: more: "... і ще {count}" running_processes: "**Фонові процеси, що виконуються:** {count}" async_jobs: "**Асинхронні задачі гейтвея:** {count}" + background_delegations: "**Фонові делегування:** {count}" none: "Немає активних агентів або задач." state_starting: "запускається" state_running: "виконується" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ Відновлено до контрольної точки {hash}: {reason}\nЗнімок перед відкатом збережено автоматично." restore_failed: "❌ {error}" + diff: + not_enabled: "Контрольні точки не ввімкнено, тому базової лінії сесії немає.\nУвімкніть у config.yaml:\n```\ncheckpoints:\n enabled: true\n```\nЗвичайний /diff все одно працює — він використовує git напряму." + no_changes: "Змін немає." + failed: "{error}" + set_home: save_failed: "Не вдалося зберегти головний канал: {error}" success: "✅ Головний канал встановлено на **{name}** (ID: {chat_id}).\nCron-завдання та міжплатформні повідомлення доставлятимуться сюди." + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Стан Hermes Gateway**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Токени:** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**Агент активний:** {state}" state_yes: "Так ⚡" state_no: "Ні" diff --git a/locales/zh-hant.yaml b/locales/zh-hant.yaml index 39b7079a7e..922a1d0d21 100644 --- a/locales/zh-hant.yaml +++ b/locales/zh-hant.yaml @@ -53,6 +53,7 @@ gateway: more: "... 還有 {count} 個" running_processes: "**執行中的背景程序：** {count}" async_jobs: "**閘道非同步任務：** {count}" + background_delegations: "**背景委派：** {count}" none: "沒有作用中的代理或執行中的任務。" state_starting: "啟動中" state_running: "執行中" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ 已還原至檢查點 {hash}：{reason}\n已自動儲存回復前的快照。" restore_failed: "❌ {error}" + diff: + not_enabled: "檢查點未啟用，因此沒有工作階段基準線。\n在 config.yaml 中啟用:\n```\ncheckpoints:\n enabled: true\n```\n一般 /diff 仍然可用 — 它直接使用 git。" + no_changes: "沒有變更。" + failed: "{error}" + set_home: save_failed: "無法儲存主頻道：{error}" success: "✅ 主頻道已設定為 **{name}**（ID：{chat_id}）。\n排程任務和跨平台訊息將傳送至此處。" + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Hermes 閘道狀態**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Token 數：** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**代理執行中：** {state}" state_yes: "是 ⚡" state_no: "否" diff --git a/locales/zh.yaml b/locales/zh.yaml index 7cf13776a6..512fbbcd72 100644 --- a/locales/zh.yaml +++ b/locales/zh.yaml @@ -53,6 +53,7 @@ gateway: more: "... 还有 {count} 个" running_processes: "**运行中的后台进程：** {count}" async_jobs: "**网关异步任务：** {count}" + background_delegations: "**后台委派：** {count}" none: "没有活跃的代理或运行中的任务。" state_starting: "启动中" state_running: "运行中" @@ -278,9 +279,32 @@ Future messages in this room will use that transcript until `/reset` or another restored: "✅ 已恢复到检查点 {hash}：{reason}\n已自动保存回滚前的快照。" restore_failed: "❌ {error}" + diff: + not_enabled: "检查点未启用，因此没有会话基线。\n在 config.yaml 中启用:\n```\ncheckpoints:\n enabled: true\n```\n普通 /diff 仍然可用 — 它直接使用 git。" + no_changes: "没有更改。" + failed: "{error}" + set_home: save_failed: "无法保存主频道：{error}" success: "✅ 主频道已设置为 **{name}**（ID：{chat_id}）。\n定时任务和跨平台消息将发送到此处。" + context: + header: "🧠 **Context Window**" + model: "Model: `{model}`" + window: "Window: {total} tokens" + in_use: "In use: {used} / {total} ({pct}%)" + bar: "{bar}" + headroom: "Headroom to limit: {headroom} tokens" + threshold: "Auto-compresses at: {threshold} ({threshold_pct}%) — {to_go} to go" + over_threshold: "⚠️ **Over auto-compression threshold ({threshold}, {threshold_pct}%)**" + compressions: "Compressions this session: {count}" + last_savings: "Last compression freed: {savings}% of context" + totals_header: "Session totals (cumulative across {calls} API calls)" + totals_line: "Input {input} · Output {output} · Reasoning {reasoning}" + total_billed: "Total billed: {total}" + throughput_note: "_Throughput, not context size — each call re-sends the window above._" + estimated: "Estimated context: ~{count} tokens across {messages} messages" + detail_after_first: "_(Full compression and throughput stats available after the first agent response)_" + no_data: "No context data available yet. Send a message to start a session." status: header: "📊 **Hermes 网关状态**" @@ -298,7 +322,7 @@ Future messages in this room will use that transcript until `/reset` or another model_provider: "**Model:** `{model}` ({provider})" context: "**Context:** {used} / {total} ({pct}%)" context_used: "**Context:** ~{used} tokens" - tokens: "**Token 数：** {tokens}" + tokens: "**Lifetime tokens billed:** {tokens} _(not your current context size; use `/context`)_" agent_running: "**代理运行中：** {state}" state_yes: "是 ⚡" state_no: "否" diff --git a/package-lock.json b/package-lock.json index 0ee09bbcb2..2848a8c89a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -184,7 +184,8 @@ "typescript": "^6.0.3", "vite": "^8.0.10", "vitest": "^4.1.5", - "wait-on": "^9.0.5" + "wait-on": "^9.0.5", + "bippy": "0.5.43" }, "engines": { "node": "^20.19.0 || >=22.12.0" @@ -19748,6 +19749,16 @@ "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", "dev": true, "license": "MIT" + }, + "node_modules/bippy": { + "version": "0.5.43", + "resolved": "https://registry.npmjs.org/bippy/-/bippy-0.5.43.tgz", + "integrity": "sha512-Tvu7b1M7+d8b9/YHaCeODEsi2CgbuoBql+dWSBrNnCuqJ1gMUeY3i0r+319hvjjl5GVBP6FFWxrKnq3fhZER0w==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "react": ">=17.0.0" + } } } } diff --git a/plugins/memory/hindsight/__init__.py b/plugins/memory/hindsight/__init__.py index 00b6d7a8f8..b5b2aa8cd9 100644 --- a/plugins/memory/hindsight/__init__.py +++ b/plugins/memory/hindsight/__init__.py @@ -131,10 +131,19 @@ def _check_local_runtime() -> tuple[bool, str | None]: error from NumPy before the daemon starts. Treat that as "unavailable" so Hermes can degrade gracefully instead of repeatedly trying to start a broken local memory backend. + + The embedded daemon computes embeddings via ``sentence_transformers`` + (transformers + huggingface-hub). Importing ``hindsight`` / + ``hindsight_embed`` alone succeeds even when that stack is broken, so + without importing it here the probe would falsely report the backend + healthy and ``hermes memory status`` would stay green while the daemon + aborts at startup on every retain/recall. Import it too so the probe (and + status) reports the real ImportError. """ try: importlib.import_module("hindsight") importlib.import_module("hindsight_embed.daemon_embed_manager") + importlib.import_module("sentence_transformers") return True, None except Exception as exc: return False, str(exc) diff --git a/plugins/model-providers/deepseek/__init__.py b/plugins/model-providers/deepseek/__init__.py index 8656552e0d..cf8c20f2d2 100644 --- a/plugins/model-providers/deepseek/__init__.py +++ b/plugins/model-providers/deepseek/__init__.py @@ -1,11 +1,11 @@ """DeepSeek provider profile. -DeepSeek's V4 family (and the legacy ``deepseek-reasoner``) defaults to -thinking-mode ON when ``extra_body.thinking`` is unset. The API then returns -``reasoning_content`` and starts enforcing the contract that subsequent turns -echo it back; combined with how Hermes replays history this lands on the -notorious HTTP 400 ``reasoning_content must be passed back`` error after the -first tool call (#15700, #17212, #17825). +DeepSeek's V4 family defaults to thinking-mode ON when ``extra_body.thinking`` +is unset. The API then returns ``reasoning_content`` and starts enforcing +the contract that subsequent turns echo it back; combined with how Hermes +replays history this lands on the notorious HTTP 400 +``reasoning_content must be passed back`` error after the first tool call +(#15700, #17212, #17825). This profile overrides :meth:`build_api_kwargs_extras` to mirror the Kimi / Moonshot wire shape that DeepSeek's OpenAI-compat endpoint expects: @@ -13,8 +13,12 @@ Moonshot wire shape that DeepSeek's OpenAI-compat endpoint expects: {"reasoning_effort": "", "extra_body": {"thinking": {"type": "enabled" | "disabled"}}} -Non-thinking models (only ``deepseek-chat`` today, which is V3) are left as -no-ops so we don't perturb the V3 wire format. +Non-thinking models (``deepseek-v3-*`` variants) are left as no-ops so we +don't perturb the V3 wire format. + +The legacy aliases ``deepseek-chat`` / ``deepseek-reasoner`` were retired on +2026-07-24. Use ``deepseek-v4-flash`` or ``deepseek-v4-pro``; Hermes remaps +the retired IDs in ``hermes_cli.model_normalize``. """ from __future__ import annotations @@ -29,8 +33,8 @@ def _model_supports_thinking(model: str | None) -> bool: """DeepSeek thinking-capable model families. Currently covers the V4 family (``deepseek-v4-pro``, ``deepseek-v4-flash``, - and any future ``deepseek-v4-*`` variants) and the legacy - ``deepseek-reasoner`` (R1). ``deepseek-chat`` is V3 with no thinking mode. + and any future ``deepseek-v4-*`` variants). Retired aliases are remapped + before requests leave Hermes, so they are not listed here. """ m = (model or "").strip().lower() if not m: @@ -39,8 +43,6 @@ def _model_supports_thinking(model: str | None) -> bool: # deepseek-v4-*, deepseek-v5-*, etc. — every V4+ generation has # thinking. v3 explicitly excluded. return True - if m == "deepseek-reasoner": - return True return False @@ -90,11 +92,11 @@ deepseek = DeepSeekProfile( description="DeepSeek — native DeepSeek API", signup_url="https://platform.deepseek.com/", fallback_models=( - "deepseek-chat", - "deepseek-reasoner", + "deepseek-v4-pro", + "deepseek-v4-flash", ), base_url="https://api.deepseek.com/v1", - default_aux_model="deepseek-chat", + default_aux_model="deepseek-v4-flash", ) register_provider(deepseek) diff --git a/plugins/platforms/discord/adapter.py b/plugins/platforms/discord/adapter.py index 6e66a2c269..4787bc6b52 100644 --- a/plugins/platforms/discord/adapter.py +++ b/plugins/platforms/discord/adapter.py @@ -3106,6 +3106,30 @@ class DiscordAdapter(BasePlatformAdapter): starter_msg = getattr(thread, "message", None) message_id = str(getattr(starter_msg, "id", thread_id)) if starter_msg else thread_id + if file is not None or files: + attachments = getattr(starter_msg, "attachments", None) or [] + if not attachments: + filename = "" + if file is not None: + filename = getattr(file, "filename", "") or "" + elif files: + filename = getattr(files[0], "filename", "") or "" + logger.warning( + "[%s] Forum thread %s starter has no attachments for %s", + self.name, + thread_id, + filename or "file", + ) + return SendResult( + success=False, + error=( + "Discord created the forum thread but attached no files" + + (f" ({filename})" if filename else "") + ), + message_id=message_id or None, + raw_response={"thread_id": thread_id}, + ) + return SendResult( success=True, message_id=message_id, @@ -3341,10 +3365,20 @@ class DiscordAdapter(BasePlatformAdapter): Forum channels (type 15) get a new thread whose starter message carries the file — they reject direct POST /messages. + + Uses a path-based ``discord.File`` (same pattern as + ``send_multiple_images``) rather than an open file handle. The + handle form can race with Discord's multipart encoder after an + earlier image batch on the same channel and produce a successful + message with zero attachments — a silent drop for video/document + MEDIA tags (#66797). """ if not self._client: return SendResult(success=False, error="Not connected") + if not os.path.isfile(file_path): + return SendResult(success=False, error=f"File not found: {file_path}") + channel = self._client.get_channel(int(chat_id)) if not channel: channel = await self._client.fetch_channel(int(chat_id)) @@ -3352,15 +3386,45 @@ class DiscordAdapter(BasePlatformAdapter): return SendResult(success=False, error=f"Channel {chat_id} not found") filename = file_name or os.path.basename(file_path) - with open(file_path, "rb") as fh: - file = discord.File(fh, filename=filename) - if self._is_forum_parent(channel): - return await self._forum_post_file( - channel, - content=(caption or "").strip(), - file=file, - ) - msg = await channel.send(content=caption if caption else None, file=file) + logger.info( + "[%s] Sending file attachment %s (%s) to %s", + self.name, + filename, + os.path.splitext(filename)[1].lower() or "no-ext", + chat_id, + ) + # Path-based File: discord.py owns open/close for the upload, matching + # the working image-batch path. Prefer ``files=[...]`` over deprecated + # singular ``file=`` for the same reason. + discord_file = discord.File(file_path, filename=filename) + if self._is_forum_parent(channel): + result = await self._forum_post_file( + channel, + content=(caption or "").strip(), + files=[discord_file], + ) + return result + msg = await channel.send( + content=caption if caption else None, + files=[discord_file], + ) + attachments = getattr(msg, "attachments", None) or [] + if not attachments: + # Discord accepted the message but attached nothing — the failure + # mode reported in #66797 (MEDIA video stripped from text, no + # attachment, no prior log line). Fail loud so the dispatch loop + # surfaces a warning instead of a silent drop. + logger.warning( + "[%s] Discord returned message %s with no attachments for %s", + self.name, + getattr(msg, "id", "?"), + filename, + ) + return SendResult( + success=False, + error=f"Discord accepted the message but attached no files ({filename})", + message_id=str(getattr(msg, "id", "") or "") or None, + ) return SendResult(success=True, message_id=str(msg.id)) async def send_multiple_images( diff --git a/plugins/platforms/feishu/adapter.py b/plugins/platforms/feishu/adapter.py index e1df2a05e5..751c2bf76d 100644 --- a/plugins/platforms/feishu/adapter.py +++ b/plugins/platforms/feishu/adapter.py @@ -5447,7 +5447,7 @@ def _qr_register_inner( # ────────────────────────────────────────────────────────────────────────── _MIGRATION_IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".gif"} -_MIGRATION_VIDEO_EXTS = {".mp4", ".mov", ".avi", ".mkv", ".3gp"} +_MIGRATION_VIDEO_EXTS = {".mp4", ".mov", ".avi", ".mkv", ".webm", ".3gp"} _MIGRATION_AUDIO_EXTS = {".ogg", ".opus", ".mp3", ".wav", ".m4a", ".flac"} _MIGRATION_VOICE_EXTS = {".ogg", ".opus"} diff --git a/plugins/platforms/telegram/adapter.py b/plugins/platforms/telegram/adapter.py index 55ae362bfe..f9f9e21d0b 100644 --- a/plugins/platforms/telegram/adapter.py +++ b/plugins/platforms/telegram/adapter.py @@ -753,6 +753,19 @@ class TelegramAdapter(BasePlatformAdapter): self._polling_teardown_started: bool = False self._polling_error_callback_ref = None self._polling_heartbeat_task: Optional[asyncio.Task] = None + # Live @username, refreshed whenever Telegram tells us what it is. + # PTB caches getMe() in Bot._bot_user at initialize() and only rewrites + # it inside get_me(), so a BotFather rename leaves self._bot.username + # pointing at the old handle until something calls getMe again. Every + # mention/routing comparison reads _current_bot_username() instead. + self._bot_username_observed: Optional[str] = None + # None = never checked. Must NOT be 0.0: these are compared against + # time.monotonic(), whose epoch is arbitrary and on a freshly-booted + # host starts near zero — so a 0.0 sentinel reads as "checked just + # now" and suppresses the first refresh for the first TTL seconds of + # uptime. + self._bot_identity_checked_at: Optional[float] = None + self._bot_identity_refresh_task: Optional[asyncio.Task] = None # Consecutive heartbeat probes that saw queued updates the running # poller is not consuming. get_me() can't see this — the send path is # healthy while the getUpdates consumer is wedged — so the heartbeat @@ -2674,6 +2687,11 @@ class TelegramAdapter(BasePlatformAdapter): if not callable(getattr(bot, "get_me", None)): return await asyncio.wait_for(bot.get_me(), PROBE_TIMEOUT) + # get_me() refreshes PTB's cached bot user in place, so this is + # also where a BotFather rename gets picked up: adopt whatever + # handle Telegram just reported before anything routes on it. + self._bot_identity_checked_at = time.monotonic() + self._note_bot_username(getattr(bot, "username", None)) # get_me() succeeded — the general/send request path is healthy. # That does NOT prove the getUpdates consumer is alive: PTB can # report updater.running=True while the long-poll task is wedged, @@ -3441,6 +3459,30 @@ class TelegramAdapter(BasePlatformAdapter): self.name, topic_name, seed_err, ) + async def _bot_identity_refresh_loop(self) -> None: + """Keep the cached @username fresh when no heartbeat is running. + + Polling mode re-reads identity via the heartbeat's ``get_me()`` probe. + Webhook mode has no such probe — nothing calls ``get_me()`` again after + ``initialize()`` — so without this loop a BotFather rename breaks + mention routing until the gateway restarts. + """ + while True: + try: + await asyncio.sleep(self._BOT_IDENTITY_TTL_SECONDS) + if getattr(self, "_polling_teardown_started", False): + return + if self.has_fatal_error: + return + await self._refresh_bot_identity(force=True) + except asyncio.CancelledError: + return + except Exception: + logger.debug( + "[%s] Telegram identity refresh loop iteration failed", + self.name, exc_info=True, + ) + def _start_post_connect_housekeeping(self) -> None: """Kick off deferred post-connect housekeeping in the background. @@ -4009,6 +4051,21 @@ class TelegramAdapter(BasePlatformAdapter): self._polling_heartbeat_loop() ) + # Seed the live identity from whatever PTB cached during + # initialize(), then keep it fresh. Polling mode rides the + # heartbeat's get_me() probe; webhook mode has no probe at all, so + # it gets a dedicated low-frequency refresh loop — otherwise a + # BotFather rename breaks mention routing until restart. + self._note_bot_username(getattr(self._bot, "username", None)) + self._bot_identity_checked_at = time.monotonic() + if self._webhook_mode: + identity_task = getattr(self, "_bot_identity_refresh_task", None) + if identity_task and not identity_task.done(): + identity_task.cancel() + self._bot_identity_refresh_task = asyncio.ensure_future( + self._bot_identity_refresh_loop() + ) + # Command-menu registration, DM-topic setup, and the status # indicator each make Bot API calls that can stall for certain # tokens. Running them here — inside the connect() coroutine that @@ -4172,6 +4229,17 @@ class TelegramAdapter(BasePlatformAdapter): pass self._polling_heartbeat_task = None + # Cancel the webhook-mode identity refresh loop on the same fence as + # the heartbeat so it cannot fire get_me() into a torn-down client. + identity_task = getattr(self, "_bot_identity_refresh_task", None) + if identity_task and not identity_task.done(): + identity_task.cancel() + try: + await identity_task + except asyncio.CancelledError: + pass + self._bot_identity_refresh_task = None + # Mark the bot "Offline" in its short description while the bot's HTTP # client is still alive (before app shutdown closes it). Opt-in via # extra.status_indicator. Non-fatal. This is the clean-shutdown path; @@ -7746,22 +7814,140 @@ class TelegramAdapter(BasePlatformAdapter): return cls._GENERAL_TOPIC_THREAD_ID return None + # Telegram bot handles historically had to end in "bot", but collectible + # (Fragment) usernames can be assigned to bots and drop that suffix + # entirely (@jarvis, @pic, ...). This pattern is used ONLY to decide + # whether some FOREIGN @handle in a message is bot-shaped; our own handle + # is matched by identity, never by shape. + _FOREIGN_BOT_HANDLE_RE = re.compile(r"[a-z0-9_]{2,29}bot", re.IGNORECASE) + # How long an observed identity is trusted before the heartbeat re-checks. + _BOT_IDENTITY_TTL_SECONDS = 300.0 + + def _current_bot_username(self) -> str: + """Return this bot's live @username (lowercased, no leading ``@``). + + Prefers the most recently observed handle over PTB's ``get_me()`` + cache. ``Bot.username`` reads ``Bot._bot_user``, which is written only + by ``get_me()`` — after a BotFather rename it keeps returning the old + handle, so every mention comparison silently stops matching and the + exclusive-mention gate concludes the message is addressed to a + different bot. Observing the handle from inbound updates closes that + window without an extra Bot API round-trip. + """ + observed = getattr(self, "_bot_username_observed", None) + if observed: + return observed + return (getattr(self._bot, "username", None) or "").lstrip("@").lower() + + def _note_bot_username(self, username: Optional[str]) -> None: + """Record the bot's current @username, logging real renames.""" + handle = (username or "").lstrip("@").lower() + if not handle: + return + previous = getattr(self, "_bot_username_observed", None) + if previous == handle: + return + self._bot_username_observed = handle + self._bot_identity_checked_at = time.monotonic() + if previous: + logger.info( + "[%s] Telegram bot username changed: @%s -> @%s " + "(mention routing now follows the new handle)", + self.name, previous, handle, + ) + + def _observe_bot_identity_from_message(self, message: Message) -> None: + """Learn our own handle from a message Telegram says we authored. + + Telegram stamps the *current* username on the bot's own outgoing + messages and on ``reply_to_message`` when a user replies to us, so a + rename is observable from the update stream itself — no getMe needed. + Only trusted when the user id matches this bot, so another account's + handle can never be adopted as our own. + """ + bot_id = getattr(self._bot, "id", None) + if bot_id is None: + return + for candidate in ( + getattr(message, "from_user", None), + getattr(getattr(message, "reply_to_message", None), "from_user", None), + ): + if candidate is None: + continue + if getattr(candidate, "id", None) != bot_id: + continue + self._note_bot_username(getattr(candidate, "username", None)) + + def _bot_identity_is_fresh(self) -> bool: + """True when identity was re-read within the TTL. + + ``None`` means never checked, which is always stale. Do not fold the + sentinel into ``0.0``: monotonic clocks have an arbitrary epoch that + can legitimately be smaller than the TTL on a freshly-booted host, + which would make "never" look like "just now". + """ + checked_at = getattr(self, "_bot_identity_checked_at", None) + if checked_at is None: + return False + return (time.monotonic() - checked_at) < self._BOT_IDENTITY_TTL_SECONDS + + async def _refresh_bot_identity(self, *, force: bool = False) -> None: + """Re-read the bot's identity from Telegram when the cache may be stale. + + ``get_me()`` rewrites PTB's ``Bot._bot_user`` in place, so this also + repairs every other consumer of ``self._bot.username``. Best-effort: + a failed probe leaves the last known handle in place. + """ + bot = self._bot + if bot is None or not callable(getattr(bot, "get_me", None)): + return + if not force and self._bot_identity_is_fresh(): + return + try: + me = await asyncio.wait_for(bot.get_me(), self._BOT_IDENTITY_PROBE_TIMEOUT) + except asyncio.CancelledError: + raise + except Exception as exc: + logger.debug( + "[%s] Telegram identity refresh failed (keeping @%s): %s", + self.name, self._current_bot_username() or "unknown", exc, + ) + return + self._bot_identity_checked_at = time.monotonic() + self._note_bot_username(getattr(me, "username", None)) + + _BOT_IDENTITY_PROBE_TIMEOUT = 15.0 + def _is_reply_to_bot(self, message: Message) -> bool: if not self._bot or not getattr(message, "reply_to_message", None): return False reply_user = getattr(message.reply_to_message, "from_user", None) return bool(reply_user and getattr(reply_user, "id", None) == getattr(self._bot, "id", None)) - @staticmethod - def _extract_bot_mention_usernames(message: Message) -> set[str]: + @classmethod + def _extract_bot_mention_usernames(cls, message: Message, self_username: str = "") -> set[str]: """Extract explicit Telegram bot usernames mentioned in text/captions. - Telegram bot usernames are 5-32 characters and must end in "bot". + Foreign handles are only treated as bot mentions when they look + bot-shaped (``...bot``), which keeps human ``@handles`` from acting as + routing hints. ``self_username`` opts our OWN handle into the same set + regardless of shape: collectible (Fragment) usernames can be assigned + to bots and need not end in "bot" (@jarvis, @pic), and a bot addressed + by such a handle must still recognise itself. + Entity mentions are authoritative. The raw-text fallback is intentionally narrow so entity-less mobile/client variants still work without treating email addresses or arbitrary substrings as bot mentions. """ mentioned_bot_usernames: set[str] = set() + own = (self_username or "").lstrip("@").lower() + + def _is_bot_handle(handle: str) -> bool: + if not handle: + return False + if own and handle == own: + return True + return bool(cls._FOREIGN_BOT_HANDLE_RE.fullmatch(handle)) def _iter_sources(): yield getattr(message, "text", None) or "", getattr(message, "entities", None) or [] @@ -7780,7 +7966,7 @@ class TelegramAdapter(BasePlatformAdapter): entity_text = source_text[offset:offset + length].strip() if entity_type == "mention": handle = entity_text.lstrip("@").lower() - if re.fullmatch(r"[a-z0-9_]{2,29}bot", handle, re.IGNORECASE): + if _is_bot_handle(handle): mentioned_bot_usernames.add(handle) continue @@ -7792,7 +7978,7 @@ class TelegramAdapter(BasePlatformAdapter): if at_index < 0: continue command_target = entity_text[at_index + 1:].strip().lower() - if re.fullmatch(r"[a-z0-9_]{2,29}bot", command_target, re.IGNORECASE): + if _is_bot_handle(command_target): mentioned_bot_usernames.add(command_target) # Entity-less fallback for older/client-specific updates. If Telegram @@ -7801,8 +7987,10 @@ class TelegramAdapter(BasePlatformAdapter): for raw_text, entities in _iter_sources(): if not raw_text or entities: continue - for match in re.finditer(r"(?i)(? None: + """Fire a TTL-guarded identity refresh in the background. + + Called when routing is about to discard a message because the bot + handles it names don't include ours — the exact symptom of a stale + username after a BotFather rename. The TTL in + ``_refresh_bot_identity`` bounds this to one getMe per + ``_BOT_IDENTITY_TTL_SECONDS``, so a busy group that legitimately + addresses other bots cannot turn this into per-message API traffic. + Fire-and-forget: the current message still routes on what we know now. + """ + existing = getattr(self, "_bot_identity_refresh_task", None) + if existing is not None and not existing.done(): + return + if self._bot_identity_is_fresh(): + return + try: + loop = asyncio.get_running_loop() + except RuntimeError: + return + task = loop.create_task(self._refresh_bot_identity()) + self._bot_identity_refresh_task = task + tracked = getattr(self, "_background_tasks", None) + if isinstance(tracked, set): + tracked.add(task) + task.add_done_callback(tracked.discard) + def _explicit_bot_mentions_exclude_self(self, message: Message) -> bool: """Return True when explicit bot handles target other bots, not this one. @@ -7872,19 +8087,27 @@ class TelegramAdapter(BasePlatformAdapter): adapter's own bot username, this adapter should ignore the message. MessageEntity values are preferred, but some Telegram clients expose - selected bot handles as plain text in group messages. The raw-text - fallback is intentionally limited to usernames ending in "bot", which - Telegram requires for bot accounts. + selected bot handles as plain text in group messages. Foreign handles + are limited to the ``...bot`` shape so human @handles never suppress + this bot; our own handle is matched by identity, so a collectible + username without that suffix still counts as addressing us. """ if not self._bot: return False - bot_username = (getattr(self._bot, "username", None) or "").lstrip("@").lower() + bot_username = self._current_bot_username() if not bot_username: return False - mentioned_bot_usernames = self._extract_bot_mention_usernames(message) - return bool(mentioned_bot_usernames) and bot_username not in mentioned_bot_usernames + mentioned_bot_usernames = self._extract_bot_mention_usernames(message, bot_username) + excludes_self = bool(mentioned_bot_usernames) and bot_username not in mentioned_bot_usernames + if excludes_self: + # Either the message really is for another bot, or our cached + # handle is stale after a rename and we are about to ignore a + # message addressed to us. Re-check identity out of band (TTL + # bounded) so the mistake self-corrects instead of persisting. + self._schedule_bot_identity_recheck() + return excludes_self def _message_matches_mention_patterns(self, message: Message) -> bool: if not self._mention_patterns: @@ -7906,9 +8129,10 @@ class TelegramAdapter(BasePlatformAdapter): return self._telegram_guest_mode() and self._message_mentions_bot(message) def _clean_bot_trigger_text(self, text: Optional[str]) -> Optional[str]: - if not text or not self._bot or not getattr(self._bot, "username", None): + bot_username = self._current_bot_username() + if not text or not bot_username: return text - username = re.escape(self._bot.username) + username = re.escape(bot_username) cleaned = re.sub(rf"(?i)@{username}\b[,:\-]*\s*", "", text).strip() return cleaned or text @@ -7975,7 +8199,7 @@ class TelegramAdapter(BasePlatformAdapter): return f"[{sender}|{user_id}]\n{event.text or ''}" def _telegram_group_observe_channel_prompt(self) -> str: - username = getattr(getattr(self, "_bot", None), "username", None) or "unknown" + username = self._current_bot_username() or "unknown" bot_id = getattr(getattr(self, "_bot", None), "id", None) or "unknown" return ( "You are handling a Telegram group chat message.\n" @@ -8277,6 +8501,13 @@ class TelegramAdapter(BasePlatformAdapter): # environments like groups/supergroups where the bot can see its own # messages). Without this, outbound messages are counted as incoming # unread in the Hermes inbox (#52363). + # + # Telegram stamps our CURRENT @username on those own-messages and on + # reply_to_message, so learn the live handle here — before any mention + # gate routes on it. Otherwise a BotFather rename leaves the stale + # handle in place and the exclusive-mention gate reads a message + # addressed to us as one addressed to some other bot. + self._observe_bot_identity_from_message(message) if self._is_own_message(message): return False diff --git a/plugins/platforms/telegram/telegram_network.py b/plugins/platforms/telegram/telegram_network.py index a0fd14ebb5..5b1d8d12bf 100644 --- a/plugins/platforms/telegram/telegram_network.py +++ b/plugins/platforms/telegram/telegram_network.py @@ -58,18 +58,50 @@ class TelegramFallbackTransport(httpx.AsyncBaseTransport): ``curl --resolve api.telegram.org:443:``. """ + # Bound every pool. httpx defaults to 100 connections per pool, so a wedged + # endpoint plus the seed IPs can outgrow the process file-descriptor limit + # on its own (#63311). + _POOL_LIMITS = httpx.Limits(max_connections=8, max_keepalive_connections=4) + def __init__(self, fallback_ips: Iterable[str], **transport_kwargs): self._fallback_ips = list(dict.fromkeys(_normalize_fallback_ips(fallback_ips))) proxy_url = _resolve_proxy_url(target_hosts=[_TELEGRAM_API_HOST, *self._fallback_ips]) if proxy_url and "proxy" not in transport_kwargs: transport_kwargs["proxy"] = proxy_url + transport_kwargs.setdefault("limits", self._POOL_LIMITS) + self._transport_kwargs = transport_kwargs self._primary = httpx.AsyncHTTPTransport(**transport_kwargs) - self._fallbacks = { - ip: httpx.AsyncHTTPTransport(**transport_kwargs) for ip in self._fallback_ips - } + # Built on demand and discarded on failure — see _reset_fallback. + self._fallbacks: dict[str, httpx.AsyncHTTPTransport] = {} + self._fallback_lock = asyncio.Lock() self._sticky_ip: Optional[str] = None self._sticky_lock = asyncio.Lock() + async def _get_fallback(self, ip: str) -> httpx.AsyncHTTPTransport: + async with self._fallback_lock: + transport = self._fallbacks.get(ip) + if transport is None: + transport = httpx.AsyncHTTPTransport(**self._transport_kwargs) + self._fallbacks[ip] = transport + return transport + + async def _reset_fallback(self, ip: str) -> None: + """Discard a failed fallback pool so its dead sockets are released. + + A connect that reaches ESTABLISHED and is then closed by the peer leaves + its socket in CLOSE_WAIT inside the pool. Retaining the poisoned pool + leaks one descriptor per retry until the process hits its file limit and + can no longer accept connections or resolve DNS (#63311). + """ + async with self._fallback_lock: + transport = self._fallbacks.pop(ip, None) + if transport is None: + return + try: + await transport.aclose() + except Exception as exc: # closing a broken pool must never mask the real error + logger.debug("[Telegram] Error closing fallback transport %s: %s", ip, exc) + async def handle_async_request(self, request: httpx.Request) -> httpx.Response: if request.url.host != _TELEGRAM_API_HOST or not self._fallback_ips: return await self._primary.handle_async_request(request) @@ -85,7 +117,7 @@ class TelegramFallbackTransport(httpx.AsyncBaseTransport): last_error: Exception | None = None for ip in attempt_order: candidate = request if ip is None else _rewrite_request_for_ip(request, ip) - transport = self._primary if ip is None else self._fallbacks[ip] + transport = self._primary if ip is None else await self._get_fallback(ip) try: response = await transport.handle_async_request(candidate) if ip is not None and self._sticky_ip != ip: @@ -117,6 +149,7 @@ class TelegramFallbackTransport(httpx.AsyncBaseTransport): ) continue logger.warning("[Telegram] Fallback IP %s failed: %s", ip, exc) + await self._reset_fallback(ip) continue if last_error is None: @@ -125,7 +158,10 @@ class TelegramFallbackTransport(httpx.AsyncBaseTransport): async def aclose(self) -> None: await self._primary.aclose() - for transport in self._fallbacks.values(): + async with self._fallback_lock: + transports = list(self._fallbacks.values()) + self._fallbacks.clear() + for transport in transports: await transport.aclose() diff --git a/pyproject.toml b/pyproject.toml index ea5d84f6b3..d623df04b9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -84,7 +84,7 @@ dependencies = [ "urllib3>=2.7.0,<3", # cryptography is pulled in transitively by PyJWT[crypto]; pin it explicitly # so the WeCom/Weixin crypto paths can't drift below the CVE-fixed floor. - "cryptography==46.0.7", # CVE-2026-39892, CVE-2026-34073 + "cryptography==48.0.1", # CVE-2026-39892, CVE-2026-34073, GHSA-537c-gmf6-5ccf; ==48.0.1 (not 49.x): msal and alibabacloud-tea-openapi cap <49, hindsight-api-slim needs >=48.0.1 # Windows has no IANA tzdata shipped with the OS, so Python's ``zoneinfo`` # (PEP 615) raises ``ZoneInfoNotFoundError`` for every non-UTC timezone # out of the box. ``tzdata`` ships the Olson database as a data package @@ -161,7 +161,7 @@ edge-tts = ["edge-tts==7.2.7"] modal = ["modal==1.3.4"] daytona = ["daytona==0.155.0"] hindsight = ["hindsight-client==0.6.1"] -dev = ["debugpy==1.8.20", "pytest==9.0.2", "pytest-asyncio==1.3.0", "mcp==1.26.0", "starlette==1.0.1", "ty==0.0.21", "ruff==0.15.10", "setuptools==81.0.0"] # starlette: CVE-2026-48710; setuptools: latest <82 (torch >=2.11 caps setuptools<82) +dev = ["debugpy==1.8.20", "pytest==9.0.2", "pytest-asyncio==1.3.0", "mcp==1.26.0", "starlette==1.3.1", "ty==0.0.21", "ruff==0.15.10", "setuptools==81.0.0"] # starlette: CVE-2026-48710; setuptools: latest <82 (torch >=2.11 caps setuptools<82) messaging = ["python-telegram-bot[webhooks]==22.6", "discord.py[voice]==2.7.1", "aiohttp==3.14.1", "brotlicffi==1.2.0.1", "slack-bolt==1.29.0", "slack-sdk==3.43.0", "qrcode==7.4.2"] # aiohttp 3.14.1: CVE-2026-34513/34518/34519/34520/34525 + 34993(RCE)/47265 cron = [] # croniter is now a core dependency; this extra kept for back-compat slack = ["slack-bolt==1.29.0", "slack-sdk==3.43.0", "aiohttp==3.14.1"] @@ -206,7 +206,7 @@ pty = [] # `request.url` can be bypassed. We pin a patched Starlette directly in every # extra that exposes a Starlette-backed server surface so pip/uv can't resolve # a vulnerable pre-1.0.1 transitive. Bump in lockstep with uv.lock. -mcp = ["mcp==1.26.0", "starlette==1.0.1"] # starlette: CVE-2026-48710 +mcp = ["mcp==1.26.0", "starlette==1.3.1"] # starlette: CVE-2026-48710 # Backwards-compatible no-op alias. Relay is a core dependency on supported # wheel targets and intentionally unavailable on other platforms. nemo-relay = [] @@ -217,7 +217,7 @@ teams = ["microsoft-teams-apps==2.0.13.4", "aiohttp==3.14.1"] # aiohttp 3.14.1: # The cua-driver binary itself is installed via `hermes tools` post-setup # (curl install script); this extra just pins the MCP client used to talk # to it, which is already provided by the `mcp` extra. -computer-use = ["mcp==1.26.0", "starlette==1.0.1"] # starlette: CVE-2026-48710 +computer-use = ["mcp==1.26.0", "starlette==1.3.1"] # starlette: CVE-2026-48710 acp = ["agent-client-protocol==0.9.0"] # mistral: Voxtral STT + TTS. Pinned to an exact verified-clean version. # The `mistralai` PyPI project was quarantined 2026-05-12 after the malicious @@ -271,9 +271,9 @@ youtube = [ "youtube-transcript-api==1.2.4", ] # `hermes dashboard` (localhost SPA + API). Not in core to keep the default install lean. -# starlette==1.0.1 pinned for CVE-2026-48710 (BadHost) — fastapi pulls Starlette +# starlette==1.3.1 pinned for CVE-2026-48710 (BadHost) — fastapi pulls Starlette # transitively and pre-1.0.1 is the vulnerable range. See the mcp extra above. -web = ["fastapi==0.133.1", "uvicorn[standard]==0.41.0", "starlette==1.0.1", "python-multipart==0.0.27"] +web = ["fastapi==0.133.1", "uvicorn[standard]==0.41.0", "starlette==1.3.1", "python-multipart==0.0.32"] all = [ # Policy (2026-05-12): `[all]` includes only extras that genuinely # CAN'T be lazy-installed via `tools/lazy_deps.py` — i.e. things every diff --git a/run_agent.py b/run_agent.py index 263a13e5b4..0563216154 100644 --- a/run_agent.py +++ b/run_agent.py @@ -437,7 +437,7 @@ class AIAgent: command: str = None, args: list[str] | None = None, model: str = "", - max_iterations: int = 90, # Default tool-calling iterations (shared with subagents) + max_iterations: int = 500, # Default tool-calling iterations (shared with subagents) tool_delay: float = 1.0, enabled_toolsets: List[str] = None, disabled_toolsets: List[str] = None, @@ -1762,8 +1762,23 @@ class AIAgent: # blocks. A list override, however, is the original clean # multimodal payload (for example before a queued /model note) # and must replace the API-local list once the turn is final. - if override is not None and ( - not isinstance(msg.get("content"), list) or isinstance(override, list) + # Preflight compaction can re-anchor this index at a message + # whose content was MERGED with the compaction summary + # (merge-summary-into-tail). That is not an accident: + # ``reanchor_current_turn_user_idx`` falls back to the last + # user row precisely BECAUSE the merge rewrote the content and + # the exact-match lookup misses. Overwriting it with the clean + # text would drop the summary from the continuation history the + # next turn is built from — the same hazard the DB-write twin + # below already refuses (see the sibling guard in + # ``_flush_messages_to_session_db_unlocked``). + if ( + override is not None + and not msg.get(COMPRESSED_SUMMARY_METADATA_KEY) + and ( + not isinstance(msg.get("content"), list) + or isinstance(override, list) + ) ): msg["content"] = override if timestamp is not None: diff --git a/scripts/install.sh b/scripts/install.sh index 43755a59a7..df8739d62c 100755 --- a/scripts/install.sh +++ b/scripts/install.sh @@ -1620,7 +1620,8 @@ setup_path() { log_info "Setting up hermes command..." if [ "$USE_VENV" = true ]; then - HERMES_BIN="$INSTALL_DIR/venv/bin/hermes" + HERMES_BIN="$INSTALL_DIR/venv/bin/python" + HERMES_ENTRYPOINT="$INSTALL_DIR/hermes" else HERMES_BIN="$(which hermes 2>/dev/null || echo "")" if [ -z "$HERMES_BIN" ]; then @@ -1629,10 +1630,10 @@ setup_path() { fi fi - # Verify the entry point script was actually generated - if [ ! -x "$HERMES_BIN" ]; then - log_warn "hermes entry point not found at $HERMES_BIN" - log_info "This usually means the pip install didn't complete successfully." + # Verify the interpreter and the checked-in entrypoint needed by the launcher. + if [ ! -x "$HERMES_BIN" ] || { [ "$USE_VENV" = true ] && [ ! -f "$HERMES_ENTRYPOINT" ]; }; then + log_warn "Hermes launcher prerequisites not found" + log_info "This usually means the Python package install didn't complete successfully." if [ "$DISTRO" = "termux" ]; then log_info "Try: cd $INSTALL_DIR && python -m pip install -e '.[termux-all]' -c constraints-termux.txt" else @@ -1654,12 +1655,25 @@ setup_path() { # the rm, `cat >` follows the symlink and overwrites the venv pip entry # point with this shim — making `exec "$HERMES_BIN"` self-recurse. (#21454) rm -f "$command_link_dir/hermes" - cat > "$command_link_dir/hermes" < "$command_link_dir/hermes" < "$command_link_dir/hermes" <= 7) are what the desktop + # validator requires; desktopVersion is omitted because only the desktop + # app knows its own version. + if [ ! -d "$INSTALL_DIR" ]; then + log_warn "Skipping bootstrap marker: $INSTALL_DIR doesn't exist" + return 0 + fi + + # Explicit --commit wins; otherwise read HEAD from the checkout we just + # installed. If neither resolves, skip the marker entirely rather than + # write one the desktop will reject -- an absent marker is a clean + # "bootstrap needed", a malformed one is a confusing half-state. + local pinned_commit="$INSTALL_COMMIT" + if [ -z "$pinned_commit" ]; then + pinned_commit=$(git -C "$INSTALL_DIR" rev-parse HEAD 2>/dev/null) || pinned_commit="" + fi + + if [ -z "$pinned_commit" ]; then + log_warn "Skipping bootstrap marker: could not resolve HEAD in $INSTALL_DIR" + return 0 + fi + + local marker_path="$INSTALL_DIR/.hermes-bootstrap-complete" + local tmp_path="$marker_path.tmp" + + # Atomic publish: the macOS launcher predicate only checks existence, so a + # torn write would arm the fast path against a half-written marker. + printf '{\n "schemaVersion": 1,\n "pinnedCommit": "%s",\n "pinnedBranch": "%s",\n "completedAt": "%s"\n}\n' \ + "$pinned_commit" \ + "$BRANCH" \ + "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" > "$tmp_path" + mv -f "$tmp_path" "$marker_path" +} + print_success() { echo "" echo -e "${GREEN}${BOLD}" @@ -3024,6 +3080,7 @@ run_stage_body() { detect_os resolve_install_layout print_success + write_bootstrap_marker # Code-scoped stamp: write next to the install tree, not into # $HERMES_HOME. $HERMES_HOME is a shared data dir (it can be # bind-mounted into a Docker gateway too), so a stamp there gets @@ -3108,6 +3165,8 @@ main() { print_success + write_bootstrap_marker + # Code-scoped stamp: write next to the install tree, not into $HERMES_HOME. # $HERMES_HOME is a shared data dir (it can be bind-mounted into a Docker # gateway too), so a stamp there gets clobbered by the container's 'docker' diff --git a/scripts/tool_search_livetest2.py b/scripts/tool_search_livetest2.py index b81f91f91a..dd9b9dd0fa 100644 --- a/scripts/tool_search_livetest2.py +++ b/scripts/tool_search_livetest2.py @@ -187,7 +187,7 @@ def run_one(scenario: Dict[str, Any], mode: str, rep: int, out_dir: Path) -> Dic "final_response": base._redact_secrets(final_response)[:500], } out_path = out_dir / f"{scenario['id']}__{'enabled' if enabled else 'disabled'}__rep{rep}.json" - out_path.write_text(json.dumps(rec, indent=1)) + out_path.write_text(json.dumps(rec, indent=1), encoding="utf-8") shutil.rmtree(Path(os.environ["HERMES_HOME"]).parent, ignore_errors=True) return rec @@ -210,7 +210,7 @@ def main(): summary_name = os.environ.get("TS_BENCH_SUMMARY", "_bench_summary.json") (out_dir / summary_name).write_text(json.dumps( [{k: v for k, v in r.items() if k not in ("per_call_usage", "bridge_calls", "final_response")} for r in rows], - indent=1)) + indent=1), encoding="utf-8") print("done ->", out_dir / summary_name) diff --git a/skills/autonomous-ai-agents/hermes-agent/references/slash-commands.md b/skills/autonomous-ai-agents/hermes-agent/references/slash-commands.md index ec19827920..3e683a502c 100644 --- a/skills/autonomous-ai-agents/hermes-agent/references/slash-commands.md +++ b/skills/autonomous-ai-agents/hermes-agent/references/slash-commands.md @@ -16,6 +16,7 @@ it. New commands land often; `/help` in-session is always authoritative. /compress (/compact) Compress context ('here [N]' keeps N turns; --preview) /stop Kill background processes /rollback [N] List/restore filesystem checkpoints +/diff [mode] [--stat] Git changes in cwd (staged|all|session modes) /snapshot [sub] Create/restore Hermes config+state snapshots (CLI) /background (/bg)

Run prompt in background /queue (/q) Queue prompt for next turn diff --git a/tests/agent/test_anthropic_adapter.py b/tests/agent/test_anthropic_adapter.py index 9a0de29040..2782411466 100644 --- a/tests/agent/test_anthropic_adapter.py +++ b/tests/agent/test_anthropic_adapter.py @@ -1190,6 +1190,54 @@ class TestConvertMessages: assert tool_use["id"] == "tc_1" assert tool_use["cache_control"] == {"type": "ephemeral"} + def test_ordered_replay_keeps_cache_control_from_nonempty_content(self): + """An assistant turn that interleaves signed thinking with a tool_use + AND has preamble text carries its cache_control INSIDE ``content`` + (apply_anthropic_cache_control marks the last content block, not the + top level). The ordered-replay branch rebuilds the message from + ``anthropic_content_blocks`` alone, so without harvesting that marker + the breakpoint is dropped -- and it is *burned*, because + _can_carry_marker already spent a budget slot on this message. + + #56195 covers the blank-content shape; this is the non-empty one, which + is what a Claude thinking+tools turn normally looks like. + """ + preamble = "I will read a.py now." + messages = apply_anthropic_cache_control([ + {"role": "system", "content": "System prompt"}, + {"role": "user", "content": "Read a.py"}, + { + "role": "assistant", + "content": preamble, + "anthropic_content_blocks": [ + {"type": "thinking", "thinking": "Need a tool.", "signature": "sig_1"}, + {"type": "text", "text": preamble}, + {"type": "tool_use", "id": "tc_1", "name": "test_tool", "input": {}}, + ], + "tool_calls": [ + { + "id": "tc_1", + "type": "function", + "function": {"name": "test_tool", "arguments": "{}"}, + } + ], + }, + {"role": "tool", "tool_call_id": "tc_1", "content": "contents"}, + ]) + + _system, converted = convert_messages_to_anthropic(messages) + assistant = next(m for m in converted if m.get("role") == "assistant") + marked = [ + b for b in assistant["content"] + if isinstance(b, dict) and b.get("cache_control") + ] + assert marked, ( + "the assistant cache breakpoint was dropped by the ordered-replay " + "path and the budget slot is burned" + ) + # The signed thinking block must still lead the replayed message. + assert assistant["content"][0]["type"] == "thinking" + def test_ordered_replay_tool_use_cache_control_is_preserved(self): messages = apply_anthropic_cache_control([ {"role": "system", "content": "System prompt"}, diff --git a/tests/agent/test_api_content_sidecar.py b/tests/agent/test_api_content_sidecar.py index b78fab9f84..68bc6bf15e 100644 --- a/tests/agent/test_api_content_sidecar.py +++ b/tests/agent/test_api_content_sidecar.py @@ -776,6 +776,67 @@ class TestFlushCompressedSummaryOverrideGuard: finally: db.close() + def test_live_override_skipped_for_compression_merged_row(self, tmp_path): + """Same invariant as the test above, for the in-memory path. + + ``finalize_turn`` calls ``_apply_persist_user_message_override`` and + only then ``_persist_session``, so the live dict is rewritten BEFORE + the DB-write guard above ever sees it. A compaction-merged row must + survive: the summary is the whole pre-compaction history, and this + list is the continuation history the next turn is built from. + """ + from agent.context_compressor import COMPRESSED_SUMMARY_METADATA_KEY + + db = SessionDB(db_path=tmp_path / "state.db") + sid = "sess-merged-live" + db.create_session(session_id=sid, source="cli") + try: + agent = self._make_agent(db, sid) + merged = "[prior context]\ncompaction summary\n\nactual question" + messages = [ + { + "role": "user", + "content": merged, + COMPRESSED_SUMMARY_METADATA_KEY: True, + } + ] + agent._persist_user_message_idx = 0 + agent._persist_user_message_override = "actual question" + agent._persist_user_message_timestamp = 1730000000 + + agent._apply_persist_user_message_override(messages) + + assert messages[0]["content"] == merged, ( + "the compaction summary was erased from the continuation history" + ) + # The paired timestamp override is unrelated and still applies. + assert messages[0]["timestamp"] == 1730000000 + finally: + db.close() + + def test_live_override_still_applies_without_merge_marker(self, tmp_path): + """Negative control: an ordinary turn is still cleaned in place.""" + db = SessionDB(db_path=tmp_path / "state.db") + sid = "sess-plain-live" + db.create_session(session_id=sid, source="cli") + try: + agent = self._make_agent(db, sid) + messages = [ + { + "role": "user", + "content": "[gateway note] observed\n\nactual question", + } + ] + agent._persist_user_message_idx = 0 + agent._persist_user_message_override = "actual question" + agent._persist_user_message_timestamp = None + + agent._apply_persist_user_message_override(messages) + + assert messages[0]["content"] == "actual question" + finally: + db.close() + class TestFlushSanitizeDivergenceCapture: def _make_agent(self, db, sid): diff --git a/tests/agent/test_billing_view.py b/tests/agent/test_billing_view.py index 89824fa326..14e0cdc883 100644 --- a/tests/agent/test_billing_view.py +++ b/tests/agent/test_billing_view.py @@ -25,6 +25,7 @@ from agent.billing_view import ( BillingState, CardInfo, MonthlyCap, + PaymentMethodInfo, billing_state_from_payload, build_billing_state, format_money, @@ -215,6 +216,41 @@ def test_state_owner_tier_parse(): ) +def test_state_parses_link_payment_method(): + payload = _owner_payload() + payload["paymentMethod"] = { + "kind": "link", + "email": "billing@example.com", + "paymentMethodId": "pm_secret", + "purpose": "top-up", + "resolvedVia": "customerDefault", + } + + state = billing_state_from_payload(payload) + + assert state.payment_method == PaymentMethodInfo( + kind="link", + email="billing@example.com", + resolved_via="customerDefault", + ) + + +def test_state_without_payment_method_keeps_it_absent(): + state = billing_state_from_payload(_owner_payload()) + + assert state.payment_method is None + + +@pytest.mark.parametrize("raw_payment_method", ["link", {"email": "billing@example.com"}]) +def test_state_ignores_malformed_payment_method(raw_payment_method): + payload = _owner_payload() + payload["paymentMethod"] = raw_payment_method + + state = billing_state_from_payload(payload) + + assert state.payment_method is None + + @pytest.mark.parametrize( "raw_card,expected", [ diff --git a/tests/agent/test_context_breakdown.py b/tests/agent/test_context_breakdown.py index d8a8c2fc2b..2b49f6449c 100644 --- a/tests/agent/test_context_breakdown.py +++ b/tests/agent/test_context_breakdown.py @@ -58,3 +58,147 @@ def test_breakdown_uses_measured_context_when_available(): assert data["context_used"] == 42_000 assert data["context_percent"] == 21 + +# ── /context renderers (pure functions over the payload) ──────────────────── + +from agent.context_breakdown import ( # noqa: E402 + compute_context_details, + render_context_breakdown_lines, + render_context_category_lines, + render_context_details_lines, + render_context_grid, +) + + +def _payload(**overrides): + base = { + "categories": [ + {"id": "system_prompt", "label": "System prompt", "tokens": 10_000}, + {"id": "tool_definitions", "label": "Tool definitions", "tokens": 20_000}, + {"id": "skills", "label": "Skills", "tokens": 5_000}, + {"id": "conversation", "label": "Conversation", "tokens": 15_000}, + ], + "context_max": 200_000, + "context_percent": 25, + "context_used": 50_000, + "estimated_total": 50_000, + "model": "openai/gpt-test", + } + base.update(overrides) + return base + + +def test_grid_is_5x20_and_mostly_free(): + rows = render_context_grid(_payload()) + assert len(rows) == 5 + cells = " ".join(rows).split(" ") + assert len(cells) == 100 + # 50k / 200k → 25 used cells, 75 free + assert cells.count("·") == 75 + # Category glyphs proportional: 10k→5, 20k→10, 5k→2-3, 15k→7-8 cells + assert cells.count("■") == 5 + assert cells.count("▣") == 10 + + +def test_grid_nonzero_category_never_invisible(): + payload = _payload( + categories=[{"id": "memory", "label": "Memory", "tokens": 10}], + estimated_total=10, + context_used=10, + ) + rows = render_context_grid(payload) + assert "▧" in " ".join(rows) + + +def test_grid_without_context_max_is_all_free(): + rows = render_context_grid(_payload(context_max=0)) + cells = " ".join(rows).split(" ") + assert set(cells) == {"·"} + + +def test_category_lines_include_tokens_percent_and_free_space(): + lines = render_context_category_lines(_payload()) + text = "\n".join(lines) + assert "Estimated usage by category" in text + assert "System prompt" in text and "10,000 tokens" in text + assert "5.0%" in text # 10k / 200k + assert "Free space" in text and "150,000 tokens" in text + + +def test_category_lines_no_categories(): + lines = render_context_category_lines(_payload(categories=[])) + assert any("no data yet" in line for line in lines) + + +def test_breakdown_lines_grid_toggle(): + with_grid = render_context_breakdown_lines(_payload(), grid=True) + without = render_context_breakdown_lines(_payload(), grid=False) + assert any("·" in line for line in with_grid[:5]) + assert not any("·" in line for line in without[:2]) + # Both include the window summary and the expand hint + for lines in (with_grid, without): + text = "\n".join(lines) + assert "Context window: 50,000 / 200,000 tokens (25%)" in text + assert "/context all" in text + + +def test_breakdown_lines_with_details_omits_hint(): + details = { + "skills": [ + {"name": "alpha", "index_tokens": 25, "skill_md_tokens": 800}, + {"name": "beta", "index_tokens": 30, "skill_md_tokens": None}, + ], + "toolsets": [ + {"toolset": "terminal", "tool_count": 3, "schema_tokens": 4_000}, + ], + } + lines = render_context_breakdown_lines(_payload(), details=details, grid=False) + text = "\n".join(lines) + assert "Toolsets by schema cost" in text + assert "terminal" in text and "4,000 tokens" in text + assert "Skills by cost" in text + assert "alpha" in text and "beta" in text + assert "n/a" in text # unmapped SKILL.md renders n/a, not a crash + assert "Use /context all" not in text + + +def test_details_lines_caps_listing(): + details = { + "skills": [ + {"name": f"skill-{i}", "index_tokens": 10, "skill_md_tokens": 100} + for i in range(20) + ], + "toolsets": [], + } + lines = render_context_details_lines(details) + assert any("… and 5 more" in line for line in lines) + + +def test_compute_context_details_maps_bytes_to_tokens(): + agent, parts = _make_agent( + stable=( + "base\n\n demo:\n" + " - hello: a demo skill\n" + ), + ) + fake_skills = [{ + "name": "hello", + "index_line_bytes": 40, + "index_line_total_bytes": 40, + "index_line_shared_bytes": 0, + "index_line_skill_count": 1, + "skill_md_bytes": 401, + "path": "/tmp/hello/SKILL.md", + }] + fake_toolsets = [{"toolset": "terminal", "tool_count": 2, "json_bytes": 399}] + with patch("agent.system_prompt.build_system_prompt_parts", return_value=parts), \ + patch("hermes_cli.prompt_size._compute_skills_breakdown", return_value=fake_skills), \ + patch("hermes_cli.prompt_size._compute_toolsets_breakdown", return_value=fake_toolsets): + details = compute_context_details(agent) + + assert details["skills"] == [ + {"name": "hello", "index_tokens": 10, "skill_md_tokens": 101}, + ] + assert details["toolsets"] == [ + {"toolset": "terminal", "tool_count": 2, "schema_tokens": 100}, + ] diff --git a/tests/agent/test_failover_identity.py b/tests/agent/test_failover_identity.py index 1937da6b64..b9466137ab 100644 --- a/tests/agent/test_failover_identity.py +++ b/tests/agent/test_failover_identity.py @@ -12,6 +12,7 @@ from types import SimpleNamespace from agent.chat_completion_helpers import rewrite_prompt_model_identity from agent.conversation_loop import _sync_failover_system_message +from agent.prompt_caching import apply_anthropic_cache_control _PROMPT = ( @@ -102,3 +103,89 @@ class TestSyncFailoverSystemMessage: assert api_messages == [{"role": "user", "content": "hi"}] # Still returns the cached prompt for subsequent call-block rebuilds. assert result == agent._cached_system_prompt + + +class TestSyncFailoverPreservesCacheDecoration: + """The sync must not flatten a cache-decorated system message. + + ``apply_anthropic_cache_control`` runs once per call block, before the retry + loop, splitting the system prompt into ``[static prefix, volatile tail]`` + blocks that carry the cache_control breakpoints. A failover fires *inside* + that retry loop, so overwriting the list with a bare string drops both + breakpoints and the retried request re-bills the whole system prompt. + """ + + _STATIC = "You are a helpful assistant.\n\nStable brief.\n" + + def _decorated(self, prompt): + messages = [ + {"role": "system", "content": prompt}, + {"role": "user", "content": "what model are you?"}, + ] + return apply_anthropic_cache_control( + messages, + cache_ttl=None, + native_anthropic=True, + static_system_prefix=self._STATIC, + ) + + def test_keeps_breakpoints_and_static_prefix(self): + prompt = self._STATIC + "Model: gpt-5.4-mini\nProvider: openai-codex" + agent = _agent(prompt=prompt) + api_messages = self._decorated(prompt) + assert isinstance(api_messages[0]["content"], list) + + rewrite_prompt_model_identity(agent, "gemma4:e2b-mlx", "custom") + _sync_failover_system_message(agent, api_messages, prompt) + + content = api_messages[0]["content"] + assert isinstance(content, list), "cache decoration was flattened to a string" + assert len(content) == 2 + assert all(part.get("cache_control") for part in content), ( + "the failover retry would ship zero system cache breakpoints" + ) + # The static prefix must stay byte-identical or its cache entry misses. + assert content[0]["text"] == self._STATIC + # The identity refresh still lands, in the volatile tail. + assert "Model: gemma4:e2b-mlx" in content[1]["text"] + assert "Provider: custom" in content[1]["text"] + + def test_keeps_single_block_shape(self): + prompt = "Model: gpt-5.4-mini\nProvider: openai-codex" + agent = _agent(prompt=prompt) + # No static prefix match -> the single-block fallback layout. + api_messages = apply_anthropic_cache_control( + [{"role": "system", "content": prompt}], + cache_ttl=None, + native_anthropic=True, + static_system_prefix=None, + ) + assert isinstance(api_messages[0]["content"], list) + assert len(api_messages[0]["content"]) == 1 + + rewrite_prompt_model_identity(agent, "gemma4:e2b-mlx", "custom") + _sync_failover_system_message(agent, api_messages, prompt) + + content = api_messages[0]["content"] + assert isinstance(content, list) and len(content) == 1 + assert content[0].get("cache_control") + assert "Model: gemma4:e2b-mlx" in content[0]["text"] + + def test_ephemeral_prompt_lands_in_the_volatile_tail(self): + prompt = self._STATIC + "Model: gpt-5.4-mini\nProvider: openai-codex" + agent = _agent(prompt=prompt, ephemeral="Stay terse.") + api_messages = self._decorated(prompt) + + _sync_failover_system_message(agent, api_messages, prompt) + + content = api_messages[0]["content"] + assert content[0]["text"] == self._STATIC + assert content[1]["text"].endswith("Stay terse.") + + def test_unknown_block_shape_falls_back_to_string(self): + agent = _agent() + api_messages = [ + {"role": "system", "content": [{"type": "image", "source": {}}]}, + ] + _sync_failover_system_message(agent, api_messages, _PROMPT) + assert api_messages[0]["content"] == agent._cached_system_prompt diff --git a/tests/agent/test_turn_summary.py b/tests/agent/test_turn_summary.py new file mode 100644 index 0000000000..b3d96f8543 --- /dev/null +++ b/tests/agent/test_turn_summary.py @@ -0,0 +1,371 @@ +"""Tests for per-turn accounting: summary formatter, collector, spinner flow, gating. + +The formatter and collector are pure (no terminal, no agent, no network), so +they're exercised directly. The gating test drives the real CLI methods on a +stub object with only the attributes the gate reads, so quiet-mode / +config-false behaviour is verified against the shipped code path rather than +against a re-implementation. +""" + +import pytest + +from agent.turn_summary import ( + TurnSummaryCollector, + TurnTally, + format_elapsed, + format_token_flow, + format_turn_summary, +) + + +# ── format_elapsed ────────────────────────────────────────────────────────── + + +@pytest.mark.parametrize( + "seconds,expected", + [ + (0.0, "0.0s"), + (12.44, "12.4s"), + (59.9, "59.9s"), + (60.0, "1m00s"), + (125.0, "2m05s"), + (-3.0, "0.0s"), + ], +) +def test_format_elapsed(seconds, expected): + assert format_elapsed(seconds) == expected + + +# ── format_turn_summary: pure formatter ───────────────────────────────────── + + +def test_zero_tools_fast_turn_renders_nothing(): + """A quick chat reply with no tool calls has nothing to summarise.""" + assert format_turn_summary(0.8, TurnTally()) == "" + + +def test_zero_tools_slow_turn_still_reports_wall_time(): + """A long toolless turn (big model, no tools) is worth timing.""" + assert format_turn_summary(31.2, TurnTally()) == "⋯ 31.2s" + + +def test_single_edit_with_line_deltas(): + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool( + "patch", + result='{"success": true, "diff": "--- a/x.py\\n+++ b/x.py\\n@@\\n+new\\n-old\\n"}', + ) + assert collector.render(6.0) == "⋯ 6.0s · edited 1 file +1 -1" + + +def test_mixed_verbs_render_in_priority_order(): + collector = TurnSummaryCollector() + collector.begin() + for _ in range(4): + collector.record_tool("read_file", result="contents") + for _ in range(3): + collector.record_tool("terminal", result="ok") + collector.record_tool("write_file", result='{"bytes_written": 10}') + collector.record_tool("write_file", result='{"bytes_written": 12}') + + line = collector.render(12.4) + # Edits first, then reads, then commands — regardless of call order. + assert line == "⋯ 12.4s · edited 2 files · read 4 files · ran 3 commands" + + +def test_pluralization_singular_and_plural(): + one = TurnTally(verbs={"read": {"files": 1}}) + many = TurnTally(verbs={"read": {"files": 3}}) + assert format_turn_summary(1.0, one) == "⋯ 1.0s · read 1 file" + assert format_turn_summary(1.0, many) == "⋯ 1.0s · read 3 files" + + +def test_pluralization_irregular_nouns(): + """The singulariser handles -ies / -ses without producing 'memorie'.""" + mem = TurnTally(verbs={"updated": {"memories": 1}}) + assert format_turn_summary(1.0, mem) == "⋯ 1.0s · updated 1 memory" + times = TurnTally(verbs={"searched the web": {"times": 1}}) + assert format_turn_summary(1.0, times) == "⋯ 1.0s · searched the web 1 time" + + +def test_missing_line_deltas_omits_plus_minus(): + """write_file reports no diff, so we count the edit and skip +/-.""" + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool("write_file", result='{"bytes_written": 42}') + line = collector.render(3.0) + assert line == "⋯ 3.0s · edited 1 file" + assert "+" not in line and " -" not in line + + +def test_patch_result_without_diff_field_omits_deltas(): + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool("patch", result='{"success": true}') + assert collector.render(2.0) == "⋯ 2.0s · edited 1 file" + + +def test_diff_headers_not_counted_as_line_changes(): + collector = TurnSummaryCollector() + collector.begin() + diff = "--- a/f.py\n+++ b/f.py\n@@ -1,2 +1,3 @@\n ctx\n+a\n+b\n-c\n" + collector.record_tool("patch", result={"success": True, "diff": diff}) + assert collector.render(1.0) == "⋯ 1.0s · edited 1 file +2 -1" + + +def test_json_string_result_with_raw_newlines_still_parses(): + """Some serialisers emit literal newlines inside the diff string.""" + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool("patch", result='{"success": true, "diff": "@@\n+a\n+b\n-c\n"}') + assert collector.render(1.0) == "⋯ 1.0s · edited 1 file +2 -1" + + +def test_long_tallies_truncate_to_more_tail(): + tally = TurnTally( + verbs={ + "edited": {"files": 1}, + "read": {"files": 2}, + "ran": {"commands": 3}, + "searched": {"paths": 4}, + "browsed": {"pages": 5}, + "delegated": {"tasks": 6}, + } + ) + line = format_turn_summary(9.0, tally) + assert line == "⋯ 9.0s · edited 1 file · read 2 files · ran 3 commands · searched 4 paths · +2 more" + assert line.count("·") == 5 + + +def test_max_segments_configurable(): + tally = TurnTally(verbs={"edited": {"files": 1}, "read": {"files": 2}, "ran": {"commands": 1}}) + assert format_turn_summary(5.0, tally, max_segments=1) == "⋯ 5.0s · edited 1 file · +2 more" + + +def test_none_tally_is_safe(): + assert format_turn_summary(0.1, None) == "" + + +# ── collector semantics ──────────────────────────────────────────────────── + + +def test_failed_tools_are_not_counted(): + """A denied write must not be summarised as a successful edit.""" + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool("write_file", result='{"error": "denied"}', is_error=True) + assert collector.tally.total_tools == 0 + assert collector.render(4.0) == "⋯ 4.0s" + + +def test_internal_and_empty_tool_names_ignored(): + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool("_thinking") + collector.record_tool(None) + collector.record_tool("") + assert collector.tally.total_tools == 0 + + +def test_unknown_tools_bucket_into_generic_count(): + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool("some_mcp__weird_tool", result="{}") + collector.record_tool("another_plugin_tool", result="{}") + assert collector.render(2.0) == "⋯ 2.0s · called 2 tools" + + +def test_begin_resets_previous_turn(): + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool("read_file", result="x") + collector.begin() + assert collector.tally.total_tools == 0 + assert collector.render(0.5) == "" + + +def test_line_deltas_aggregate_across_edits(): + collector = TurnSummaryCollector() + collector.begin() + collector.record_tool("patch", result={"success": True, "diff": "@@\n+a\n+b\n-c\n"}) + collector.record_tool("patch", result={"success": True, "diff": "@@\n+d\n-e\n-f\n"}) + assert collector.render(7.5) == "⋯ 7.5s · edited 2 files +3 -3" + + +def test_malformed_result_payloads_do_not_raise(): + collector = TurnSummaryCollector() + collector.begin() + for bad in ("not json at all", "", None, 42, [], {"diff": None}): + collector.record_tool("patch", result=bad) + assert collector.tally.verbs["edited"]["files"] == 6 + assert collector.tally.has_line_deltas is False + + +# ── spinner token flow (PART B) ──────────────────────────────────────────── + + +@pytest.mark.parametrize( + "tokens,expected", + [ + (0, ""), + (-5, ""), + (32, "↓ 32 tok"), + (999, "↓ 999 tok"), + (1200, "↓ 1.2k tok"), + (25_400, "↓ 25.4k tok"), + (2_500_000, "↓ 2.5M tok"), + ], +) +def test_format_token_flow(tokens, expected): + assert format_token_flow(tokens) == expected + + +def test_format_token_flow_bad_input_is_empty(): + assert format_token_flow(None) == "" + assert format_token_flow("lots") == "" + + +# ── gating: quiet mode / config false / non-interactive ──────────────────── + + +class _StubAgent: + def __init__(self, quiet_mode=False, session_output_tokens=0): + self.quiet_mode = quiet_mode + self.session_output_tokens = session_output_tokens + + +def _make_cli(**overrides): + """Bind the real CLI accounting methods onto a minimal stub object. + + Avoids constructing HermesCLI (which loads config, sessions, and a + prompt_toolkit app) while still exercising the shipped gate + emit code. + """ + import cli as cli_module + + class _Stub: + _turn_summary_enabled = True + _spinner_token_flow_enabled = True + tool_progress_mode = "all" + _interactive_turn = True + _agent_running = True + agent = None + _turn_summary_collector = None + _turn_summary_start = 0.0 + _turn_token_baseline = 0 + _spinner_text = "⚡ reading file" + _tool_start_time = 0 + + _turn_summary_is_active = cli_module.HermesCLI._turn_summary_is_active + _turn_summary_begin = cli_module.HermesCLI._turn_summary_begin + _turn_summary_record = cli_module.HermesCLI._turn_summary_record + _turn_summary_emit = cli_module.HermesCLI._turn_summary_emit + _spinner_token_flow = cli_module.HermesCLI._spinner_token_flow + _render_spinner_text = cli_module.HermesCLI._render_spinner_text + + stub = _Stub() + for key, value in overrides.items(): + setattr(stub, key, value) + return stub + + +def _emit_and_capture(stub, monkeypatch): + printed = [] + import cli as cli_module + + monkeypatch.setattr(cli_module, "_cprint", lambda text: printed.append(text)) + stub._turn_summary_begin() + stub._turn_summary_record("read_file", "contents", False) + stub._turn_summary_emit() + return printed + + +def test_gating_enabled_prints_summary(monkeypatch): + stub = _make_cli() + printed = _emit_and_capture(stub, monkeypatch) + assert len(printed) == 1 + assert "read 1 file" in printed[0] + + +def test_gating_quiet_mode_prints_nothing(monkeypatch): + stub = _make_cli(agent=_StubAgent(quiet_mode=True)) + assert _emit_and_capture(stub, monkeypatch) == [] + + +def test_gating_config_false_prints_nothing(monkeypatch): + stub = _make_cli(_turn_summary_enabled=False) + assert _emit_and_capture(stub, monkeypatch) == [] + + +def test_gating_tool_progress_off_prints_nothing(monkeypatch): + stub = _make_cli(tool_progress_mode="off") + assert _emit_and_capture(stub, monkeypatch) == [] + + +def test_gating_non_interactive_prints_nothing(monkeypatch): + """Single-query / -Q / gateway paths never set _interactive_turn.""" + stub = _make_cli(_interactive_turn=False) + assert _emit_and_capture(stub, monkeypatch) == [] + + +def test_spinner_token_flow_appears_when_enabled(): + stub = _make_cli(agent=_StubAgent(session_output_tokens=1200)) + assert stub._spinner_token_flow() == "↓ 1.2k tok" + assert "↓ 1.2k tok" in stub._render_spinner_text() + + +def test_spinner_token_flow_uses_per_turn_baseline(): + stub = _make_cli( + agent=_StubAgent(session_output_tokens=5200), _turn_token_baseline=5000 + ) + assert stub._spinner_token_flow() == "↓ 200 tok" + + +def test_spinner_token_flow_config_false_is_silent(): + stub = _make_cli( + _spinner_token_flow_enabled=False, agent=_StubAgent(session_output_tokens=9000) + ) + assert stub._spinner_token_flow() == "" + assert "tok" not in stub._render_spinner_text() + + +def test_spinner_token_flow_silent_without_agent_or_idle(): + assert _make_cli(agent=None)._spinner_token_flow() == "" + assert ( + _make_cli(agent=_StubAgent(session_output_tokens=500), _agent_running=False) + ._spinner_token_flow() + == "" + ) + + +def test_turn_summary_config_defaults_present(): + from hermes_cli.config import DEFAULT_CONFIG + + display = DEFAULT_CONFIG["display"] + assert display["turn_summary"] is True + assert display["spinner_token_flow"] is True + + +def test_content_free_diff_reports_unknown_not_zero_zero(): + """A diff with no +/- content lines (bare hunk header) must render as an + edit with UNKNOWN deltas, never a misleading '+0 -0'. + + Found by E2E-rendering the collector against realistic tool payloads: the + unit suite only fed diffs that had real content lines. + """ + from agent.turn_summary import TurnSummaryCollector + + c = TurnSummaryCollector() + c.begin() + c.record_tool("patch", result={"success": True, "diff": "@@ -1,3 +1,15 @@"}) + line = c.render(3.0) + assert "edited 1 file" in line + assert "+0 -0" not in line + + real = TurnSummaryCollector() + real.begin() + real.record_tool( + "patch", + result={"success": True, "diff": "--- a/x\n+++ b/x\n@@ -1 +1,2 @@\n-old\n+new\n+extra\n"}, + ) + assert "+2 -1" in real.render(1.0) diff --git a/tests/cli/test_cli_init.py b/tests/cli/test_cli_init.py index 48de5b7c95..c3915777da 100644 --- a/tests/cli/test_cli_init.py +++ b/tests/cli/test_cli_init.py @@ -60,7 +60,7 @@ class TestMaxTurnsResolution: def test_default_max_turns_is_integer(self): cli = _make_cli() assert isinstance(cli.max_turns, int) - assert cli.max_turns == 90 + assert cli.max_turns == 500 def test_explicit_max_turns_honored(self): cli = _make_cli(max_turns=25) @@ -69,7 +69,7 @@ class TestMaxTurnsResolution: def test_none_max_turns_gets_default(self): cli = _make_cli(max_turns=None) assert isinstance(cli.max_turns, int) - assert cli.max_turns == 90 + assert cli.max_turns == 500 def test_env_var_max_turns(self): """Env var is used when config file doesn't set max_turns.""" @@ -79,7 +79,7 @@ class TestMaxTurnsResolution: def test_invalid_env_var_max_turns_falls_back_to_default(self): """Invalid env values should not crash CLI init.""" cli_obj = _make_cli(env_overrides={"HERMES_MAX_ITERATIONS": "not-a-number"}) - assert cli_obj.max_turns == 90 + assert cli_obj.max_turns == 500 def test_legacy_root_max_turns_is_used_when_agent_key_exists_without_value(self): cli_obj = _make_cli(config_overrides={"agent": {}, "max_turns": 77}) @@ -88,7 +88,7 @@ class TestMaxTurnsResolution: def test_max_turns_never_none_for_agent(self): """The value passed to AIAgent must never be None (causes TypeError in run_conversation).""" cli = _make_cli() - assert isinstance(cli.max_turns, int) and cli.max_turns == 90 + assert isinstance(cli.max_turns, int) and cli.max_turns == 500 class TestVerboseAndToolProgress: diff --git a/tests/cli/test_cli_status_bar_goal.py b/tests/cli/test_cli_status_bar_goal.py new file mode 100644 index 0000000000..e8c947464f --- /dev/null +++ b/tests/cli/test_cli_status_bar_goal.py @@ -0,0 +1,96 @@ +"""Status-bar goal segment (⊙ goal N/M) — active-goal-only rendering. + +The segment mirrors the desktop composer goal indicator: it appears only +while a /goal is ACTIVE, shows turns used vs the turn budget, and stays out +of the bar entirely for paused/done/absent goals (those already print their +own glyph lines in the conversation thread). +""" + +from datetime import datetime, timedelta +from types import SimpleNamespace + +from cli import HermesCLI + + +def _make_cli(model: str = "anthropic/claude-sonnet-4-20250514"): + cli_obj = HermesCLI.__new__(HermesCLI) + cli_obj.model = model + cli_obj.session_start = datetime.now() - timedelta(minutes=14, seconds=32) + cli_obj.conversation_history = [{"role": "user", "content": "hi"}] + cli_obj.agent = None + return cli_obj + + +def _attach_goal(cli_obj, *, active: bool, turns_used: int = 3, max_turns: int = 20): + """Bind a fake GoalManager the way _get_goal_manager caches one.""" + cli_obj.session_id = "sess-goal-test" + cli_obj._goal_manager = SimpleNamespace( + session_id="sess-goal-test", + is_active=lambda: active, + state=SimpleNamespace(turns_used=turns_used, max_turns=max_turns), + ) + return cli_obj + + +class TestStatusBarGoalSegment: + def test_goal_segment_composition(self): + cli_obj = _attach_goal(_make_cli(), active=True, turns_used=3, max_turns=20) + + snapshot = cli_obj._get_status_bar_snapshot() + + assert snapshot["goal_active"] is True + assert snapshot["goal_turns_used"] == 3 + assert snapshot["goal_max_turns"] == 20 + assert cli_obj._status_bar_goal_segment(snapshot) == "⊙ goal 3/20" + + def test_goal_segment_absent_without_goal(self): + cli_obj = _make_cli() # no session_id → no goal manager + + snapshot = cli_obj._get_status_bar_snapshot() + + assert snapshot["goal_active"] is False + assert cli_obj._status_bar_goal_segment(snapshot) == "" + + def test_goal_segment_absent_when_paused(self): + # Paused goals must NOT occupy the status bar (active-only contract). + cli_obj = _attach_goal(_make_cli(), active=False) + + snapshot = cli_obj._get_status_bar_snapshot() + + assert snapshot["goal_active"] is False + assert cli_obj._status_bar_goal_segment(snapshot) == "" + + def test_goal_segment_without_budget_omits_counter(self): + segment = HermesCLI._status_bar_goal_segment( + {"goal_active": True, "goal_turns_used": 0, "goal_max_turns": 0} + ) + + assert segment == "⊙ goal" + + def test_active_goal_rendered_in_wide_status_bar(self): + cli_obj = _attach_goal(_make_cli(), active=True, turns_used=5, max_turns=20) + + text = cli_obj._build_status_bar_text(width=120) + + assert "⊙ goal 5/20" in text + + def test_active_goal_rendered_in_medium_status_bar(self): + cli_obj = _attach_goal(_make_cli(), active=True, turns_used=1, max_turns=20) + + text = cli_obj._build_status_bar_text(width=60) + + assert "⊙ goal 1/20" in text + + def test_active_goal_rendered_in_narrow_status_bar(self): + cli_obj = _attach_goal(_make_cli(), active=True, turns_used=2, max_turns=20) + + text = cli_obj._build_status_bar_text(width=50) + + assert "⊙ goal" in text + + def test_no_goal_segment_in_status_bar_without_goal(self): + cli_obj = _make_cli() + + text = cli_obj._build_status_bar_text(width=120) + + assert "⊙ goal" not in text diff --git a/tests/cli/test_focus_view.py b/tests/cli/test_focus_view.py new file mode 100644 index 0000000000..e6791d4f5d --- /dev/null +++ b/tests/cli/test_focus_view.py @@ -0,0 +1,594 @@ +"""Tests for ``/focus`` — the display-only reduced-output view. + +Focus view composes with the existing ``/verbose`` tool-progress machinery +rather than adding a second suppression mechanism. These tests cover: + +* the on/off/status toggle state machine (``resolve_focus_arg``); +* the hidden-line counter and its formatter (which must respect the + pre-focus ``/verbose`` mode so it never over-claims); +* status-bar segment composition in both CLI renderers; +* the CLI command handler's stash/restore of ``tool_progress_mode``; +* **the prompt-cache invariant** — a real fake turn is dispatched through + ``agent.tool_executor`` with focus on and with focus off, and the resulting + model-facing ``messages`` lists must be byte-identical. +""" + +import json +from types import SimpleNamespace +from unittest.mock import MagicMock, patch + +import pytest + +from hermes_cli.focus_view import ( + FOCUS_CONFIG_KEY, + FOCUS_STATUSBAR_LABEL, + FOCUS_TOOL_PROGRESS_MODE, + effective_tool_progress_mode, + focus_statusbar_segment, + format_focus_status, + format_focus_toggle_message, + format_hidden_line, + normalize_tool_progress_mode, + resolve_focus_arg, + would_display_tool_line, +) +from hermes_cli.cli_commands_mixin import CLICommandsMixin + + +# ========================================================================= +# Toggle state machine — on | off | status | bare | garbage +# ========================================================================= + + +class TestToggleStateMachine: + def test_bare_toggles_from_off_to_on(self): + assert resolve_focus_arg("", False) == ("set", True) + + def test_bare_toggles_from_on_to_off(self): + assert resolve_focus_arg("", True) == ("set", False) + + def test_explicit_toggle_word_behaves_like_bare(self): + assert resolve_focus_arg("toggle", False) == ("set", True) + assert resolve_focus_arg("toggle", True) == ("set", False) + + @pytest.mark.parametrize("word", ["on", "ON", " on ", "enable", "true", "yes", "1"]) + def test_on_words(self, word): + assert resolve_focus_arg(word, False) == ("set", True) + + @pytest.mark.parametrize("word", ["off", "OFF", "disable", "false", "no", "0"]) + def test_off_words(self, word): + assert resolve_focus_arg(word, True) == ("set", False) + + @pytest.mark.parametrize("word", ["status", "show", "?", "STATUS"]) + def test_status_words_never_mutate(self, word): + action, target = resolve_focus_arg(word, True) + assert action == "status" + assert target is None + + @pytest.mark.parametrize("word", ["sideways", "onn", "--global", "2"]) + def test_garbage_reports_usage(self, word): + assert resolve_focus_arg(word, False) == ("usage", None) + + def test_explicit_set_is_idempotent(self): + # /focus on while already on stays on (no accidental toggle). + assert resolve_focus_arg("on", True) == ("set", True) + assert resolve_focus_arg("off", False) == ("set", False) + + +# ========================================================================= +# Suppression respects the existing /verbose modes +# ========================================================================= + + +class TestComposesWithVerboseModes: + def test_focus_on_snaps_to_the_existing_off_mode(self): + # Focus view must reuse the tool_progress "off" path, not invent a mode. + assert FOCUS_TOOL_PROGRESS_MODE == "off" + for configured in ("off", "new", "all", "verbose"): + assert effective_tool_progress_mode(True, configured) == "off" + + @pytest.mark.parametrize("configured", ["off", "new", "all", "verbose"]) + def test_focus_off_leaves_the_configured_verbose_mode_untouched(self, configured): + assert effective_tool_progress_mode(False, configured) == configured + + def test_yaml_boolean_off_is_normalised(self): + # YAML 1.1 parses a bare `off` as False. + assert normalize_tool_progress_mode(False) == "off" + assert normalize_tool_progress_mode(True) == "all" + assert normalize_tool_progress_mode(None) == "all" + assert normalize_tool_progress_mode("bogus") == "all" + assert normalize_tool_progress_mode("log") == "log" + + @pytest.mark.parametrize("mode", ["new", "all", "verbose"]) + def test_counts_lines_that_the_mode_would_have_shown(self, mode): + assert would_display_tool_line(mode, "terminal") is True + + def test_does_not_count_when_verbose_was_already_off(self): + # A user who already ran /verbose off is hiding nothing extra — focus + # view must not claim credit for suppressing lines nobody would see. + assert would_display_tool_line("off", "terminal") is False + assert would_display_tool_line(False, "terminal") is False + + def test_new_mode_skips_consecutive_repeats_like_the_renderer(self): + assert would_display_tool_line("new", "terminal", "terminal") is False + assert would_display_tool_line("new", "read_file", "terminal") is True + # "all" always counts, even repeats. + assert would_display_tool_line("all", "terminal", "terminal") is True + + def test_empty_tool_name_never_counts(self): + assert would_display_tool_line("all", "") is False + + +# ========================================================================= +# Hidden-count formatter + recovery line +# ========================================================================= + + +class TestHiddenCountFormatter: + def test_zero_and_negative_produce_no_line(self): + assert format_hidden_line(0) is None + assert format_hidden_line(-3) is None + + def test_singular_noun(self): + assert format_hidden_line(1) == "⋯ 1 tool line hidden · /focus off to show" + + def test_plural_noun(self): + assert format_hidden_line(7) == "⋯ 7 tool lines hidden · /focus off to show" + + def test_line_always_names_the_recovery_command(self): + assert "/focus off" in format_hidden_line(2) + + def test_non_numeric_is_tolerated(self): + assert format_hidden_line(None) is None + assert format_hidden_line("many") is None + + +class _FocusHost(CLICommandsMixin): + """Minimal host exposing only the attributes the focus helpers read.""" + + def __init__(self, *, enabled=False, saved="all", tool_progress="all"): + self._focus_view_enabled = enabled + self._focus_saved_tool_progress = saved + self._focus_hidden_lines = 0 + self._focus_last_counted_tool = None + self.tool_progress_mode = tool_progress + self.agent = None + + +class TestHiddenCounterAccumulation: + def test_counts_each_suppressed_tool_line(self): + host = _FocusHost(enabled=True, saved="all") + for name in ("terminal", "read_file", "web_search"): + host._note_focus_hidden_line(name) + assert host._focus_hidden_lines == 3 + + def test_counts_nothing_when_focus_is_off(self): + host = _FocusHost(enabled=False, saved="all") + host._note_focus_hidden_line("terminal") + assert host._focus_hidden_lines == 0 + + def test_counts_nothing_when_verbose_was_already_off(self): + host = _FocusHost(enabled=True, saved="off") + for _ in range(5): + host._note_focus_hidden_line("terminal") + assert host._focus_hidden_lines == 0 + + def test_new_mode_dedupes_consecutive_repeats(self): + host = _FocusHost(enabled=True, saved="new") + host._note_focus_hidden_line("terminal") + host._note_focus_hidden_line("terminal") + host._note_focus_hidden_line("read_file") + assert host._focus_hidden_lines == 2 + + def test_recovery_line_is_emitted_then_counter_resets(self): + host = _FocusHost(enabled=True, saved="all") + for name in ("terminal", "read_file"): + host._note_focus_hidden_line(name) + + with patch("cli._cprint") as printer: + host._emit_focus_recovery_line() + + assert printer.call_count == 1 + assert "2 tool lines hidden" in printer.call_args[0][0] + assert "/focus off" in printer.call_args[0][0] + # Reset so the next turn starts from zero. + assert host._focus_hidden_lines == 0 + assert host._focus_last_counted_tool is None + + def test_no_recovery_line_when_nothing_was_hidden(self): + host = _FocusHost(enabled=True, saved="all") + with patch("cli._cprint") as printer: + host._emit_focus_recovery_line() + printer.assert_not_called() + + def test_no_recovery_line_when_focus_is_off(self): + host = _FocusHost(enabled=False, saved="all") + host._focus_hidden_lines = 4 + with patch("cli._cprint") as printer: + host._emit_focus_recovery_line() + printer.assert_not_called() + assert host._focus_hidden_lines == 0 + + +# ========================================================================= +# CLI command handler — stash / restore / persistence +# ========================================================================= + + +class TestFocusCommandHandler: + def test_on_stashes_the_verbose_mode_and_snaps_to_off(self): + host = _FocusHost(enabled=False, saved=None, tool_progress="verbose") + with patch("cli.save_config_value", return_value=True) as saver, \ + patch("cli._cprint"): + host._handle_focus_command("/focus on") + + assert host._focus_view_enabled is True + assert host.tool_progress_mode == "off" + assert host._focus_saved_tool_progress == "verbose" + saver.assert_called_once_with(FOCUS_CONFIG_KEY, True) + + def test_off_restores_the_stashed_verbose_mode(self): + host = _FocusHost(enabled=True, saved="new", tool_progress="off") + with patch("cli.save_config_value", return_value=True) as saver, \ + patch("cli._cprint"): + host._handle_focus_command("/focus off") + + assert host._focus_view_enabled is False + assert host.tool_progress_mode == "new" + assert host._focus_saved_tool_progress is None + saver.assert_called_once_with(FOCUS_CONFIG_KEY, False) + + def test_round_trip_returns_to_the_original_mode(self): + host = _FocusHost(enabled=False, saved=None, tool_progress="verbose") + with patch("cli.save_config_value", return_value=True), patch("cli._cprint"): + host._handle_focus_command("/focus") + assert host.tool_progress_mode == "off" + host._handle_focus_command("/focus") + assert host.tool_progress_mode == "verbose" + assert host._focus_view_enabled is False + + def test_status_never_writes_config_or_changes_mode(self): + host = _FocusHost(enabled=True, saved="all", tool_progress="off") + with patch("cli.save_config_value") as saver, patch("cli._cprint") as printer: + host._handle_focus_command("/focus status") + saver.assert_not_called() + assert host.tool_progress_mode == "off" + assert host._focus_view_enabled is True + assert "Focus view" in printer.call_args[0][0] + + def test_garbage_argument_prints_usage_and_changes_nothing(self): + host = _FocusHost(enabled=False, saved=None, tool_progress="all") + with patch("cli.save_config_value") as saver, patch("cli._cprint") as printer: + host._handle_focus_command("/focus sideways") + saver.assert_not_called() + assert host._focus_view_enabled is False + assert host.tool_progress_mode == "all" + assert "Usage: /focus" in printer.call_args[0][0] + + def test_idempotent_on_does_not_reclobber_the_stash(self): + host = _FocusHost(enabled=True, saved="verbose", tool_progress="off") + with patch("cli.save_config_value") as saver, patch("cli._cprint"): + host._handle_focus_command("/focus on") + saver.assert_not_called() + # The stash still points at the real pre-focus mode, not "off". + assert host._focus_saved_tool_progress == "verbose" + + def test_live_agent_mode_is_synced(self): + host = _FocusHost(enabled=False, saved=None, tool_progress="all") + host.agent = SimpleNamespace(tool_progress_mode="all") + with patch("cli.save_config_value", return_value=True), patch("cli._cprint"): + host._handle_focus_command("/focus on") + # tool_executor gates on the AGENT copy — syncing it is what makes the + # suppression take effect this turn instead of after an agent rebuild. + assert host.agent.tool_progress_mode == "off" + + def test_status_text_names_the_mode_focus_off_will_restore(self): + body = format_focus_status(True, "verbose") + assert "ON" in body + assert "VERBOSE" in body + off_body = format_focus_status(False, "new") + assert "OFF" in off_body + assert "NEW" in off_body + + def test_toggle_messages_mirror_claude_code_wording(self): + assert "enabled" in format_focus_toggle_message(True, "all") + assert "disabled" in format_focus_toggle_message(False, "all") + assert "ALL" in format_focus_toggle_message(False, "all") + + +# ========================================================================= +# Status-bar segment composition +# ========================================================================= + + +class TestStatusBarSegment: + def test_segment_present_only_when_enabled(self): + assert focus_statusbar_segment(True) == FOCUS_STATUSBAR_LABEL + assert focus_statusbar_segment(False) == "" + + def test_snapshot_exposes_focus_label(self): + from cli import HermesCLI + + host = HermesCLI.__new__(HermesCLI) + host.model = "anthropic/claude-opus-4.6" + from datetime import datetime + + host.session_start = datetime.now() + host.conversation_history = [] + host.agent = None + host._focus_view_enabled = True + + snapshot = HermesCLI._get_status_bar_snapshot(host) + assert snapshot["focus_label"] == FOCUS_STATUSBAR_LABEL + + host._focus_view_enabled = False + assert HermesCLI._get_status_bar_snapshot(host)["focus_label"] == "" + + @pytest.mark.parametrize("width", [40, 60, 120]) + def test_text_renderer_includes_the_badge_at_every_width_tier(self, width): + from cli import HermesCLI + + host = HermesCLI.__new__(HermesCLI) + host.model = "opus" + host._focus_view_enabled = True + + snapshot = { + "model_name": "opus", + "model_short": "opus", + "duration": "1m", + "context_percent": 12, + "context_tokens": 1000, + "context_length": 200000, + "compressions": 0, + "active_background_tasks": 0, + "active_background_processes": 0, + "active_background_subagents": 0, + "battery_label": "", + "battery_category": "dim", + "focus_label": FOCUS_STATUSBAR_LABEL, + "prompt_elapsed": "", + "idle_since": "", + } + + with patch.object(HermesCLI, "_get_status_bar_snapshot", return_value=snapshot), \ + patch.object(HermesCLI, "_is_session_yolo_active", return_value=False): + text = HermesCLI._build_status_bar_text(host, width=width) + + assert "focus" in text + + @pytest.mark.parametrize("width", [40, 60, 120]) + def test_fragment_renderer_includes_the_badge_at_every_width_tier(self, width): + from cli import HermesCLI + + host = HermesCLI.__new__(HermesCLI) + host.model = "opus" + host._status_bar_visible = True + host._model_picker_state = None + host._focus_view_enabled = True + + snapshot = { + "model_name": "opus", + "model_short": "opus", + "duration": "1m", + "context_percent": 12, + "context_tokens": 1000, + "context_length": 200000, + "compressions": 0, + "active_background_tasks": 0, + "active_background_processes": 0, + "active_background_subagents": 0, + "battery_label": "", + "battery_category": "dim", + "focus_label": FOCUS_STATUSBAR_LABEL, + "prompt_elapsed": "", + "idle_since": "", + } + + with patch.object(HermesCLI, "_get_status_bar_snapshot", return_value=snapshot), \ + patch.object(HermesCLI, "_get_tui_terminal_width", return_value=width), \ + patch.object(HermesCLI, "_is_session_yolo_active", return_value=False): + frags = HermesCLI._get_status_bar_fragments(host) + + rendered = "".join(text for _, text in frags) + assert "focus" in rendered + + def test_badge_absent_from_fragments_when_focus_is_off(self): + from cli import HermesCLI + + host = HermesCLI.__new__(HermesCLI) + host.model = "opus" + host._status_bar_visible = True + host._model_picker_state = None + host._focus_view_enabled = False + + snapshot = { + "model_name": "opus", + "model_short": "opus", + "duration": "1m", + "context_percent": 12, + "context_tokens": 1000, + "context_length": 200000, + "compressions": 0, + "active_background_tasks": 0, + "active_background_processes": 0, + "active_background_subagents": 0, + "battery_label": "", + "battery_category": "dim", + "focus_label": "", + "prompt_elapsed": "", + "idle_since": "", + } + + with patch.object(HermesCLI, "_get_status_bar_snapshot", return_value=snapshot), \ + patch.object(HermesCLI, "_get_tui_terminal_width", return_value=120), \ + patch.object(HermesCLI, "_is_session_yolo_active", return_value=False): + frags = HermesCLI._get_status_bar_fragments(host) + + assert "focus" not in "".join(text for _, text in frags) + + +# ========================================================================= +# PROMPT-CACHE INVARIANT: model-facing messages are identical either way +# ========================================================================= + + +def _make_agent(tool_progress_mode: str): + """Build a real AIAgent whose display mode is the only difference.""" + from run_agent import AIAgent + + tool_defs = [ + { + "type": "function", + "function": { + "name": "web_search", + "description": "search", + "parameters": {"type": "object", "properties": {}}, + }, + } + ] + with ( + patch("run_agent.get_tool_definitions", return_value=tool_defs), + patch("run_agent.check_toolset_requirements", return_value={}), + patch("hermes_cli.config.load_config", return_value={}), + patch("run_agent.OpenAI"), + ): + agent = AIAgent( + api_key="test-key-1234567890", + base_url="https://openrouter.ai/api/v1", + # quiet_mode False so the display gate is genuinely exercised — + # with quiet_mode True the tool_progress gate would be moot. + quiet_mode=False, + skip_context_files=True, + skip_memory=True, + tool_progress_mode=tool_progress_mode, + ) + agent.client = MagicMock() + agent.tool_delay = 0 + agent._flush_messages_to_session_db = MagicMock() + return agent + + +def _tool_call(call_id: str, query: str): + return SimpleNamespace( + id=call_id, + type="function", + function=SimpleNamespace( + name="web_search", arguments=json.dumps({"query": query}) + ), + ) + + +def _run_fake_turn(tool_progress_mode: str, dispatch_mode: str = "sequential"): + """Dispatch an identical fake turn and return the model-facing messages.""" + agent = _make_agent(tool_progress_mode) + assistant_message = SimpleNamespace( + content="", + tool_calls=[ + _tool_call("call-1", "alpha"), + _tool_call("call-2", "beta"), + _tool_call("call-3", "gamma"), + ], + ) + messages: list = [ + {"role": "system", "content": "you are hermes"}, + {"role": "user", "content": "find three things"}, + ] + + def fake_dispatch(name, args, task_id, *positional, **kwargs): + return json.dumps({"ok": args["query"]}) + + with ( + patch("run_agent.handle_function_call", side_effect=fake_dispatch), + patch.object(agent, "_invoke_tool", side_effect=fake_dispatch), + patch( + "agent.tool_executor.maybe_persist_tool_result", + side_effect=lambda **kwargs: kwargs["content"], + ), + # Swallow display writes so the test doesn't spam stdout; the point is + # what lands in `messages`, not what prints. + patch("builtins.print"), + ): + execute = getattr(agent, f"_execute_tool_calls_{dispatch_mode}") + execute(assistant_message, messages, "task-focus") + + return messages + + +class TestModelFacingMessagesUnchanged: + """Focus view is display-only: the request payload must not shift a byte.""" + + @pytest.mark.parametrize("dispatch_mode", ["sequential", "concurrent"]) + def test_model_facing_messages_identical_with_focus_on_vs_off(self, dispatch_mode): + # Focus ON == the existing tool_progress "off" suppression path. + focus_on = _run_fake_turn(FOCUS_TOOL_PROGRESS_MODE, dispatch_mode) + # Focus OFF == the default noisy display mode. + focus_off = _run_fake_turn("all", dispatch_mode) + + assert focus_on == focus_off, ( + "focus view altered the model-facing messages — display-only " + "invariant violated (prompt cache would break)" + ) + # Sanity: the turn really did produce tool results to compare. + assert [m["role"] for m in focus_on].count("tool") == 3 + assert json.loads(focus_on[-1]["content"]) == {"ok": "gamma"} + + def test_every_verbose_mode_produces_the_same_messages(self): + # /focus composes with /verbose, so no tool-progress mode may change + # the payload — otherwise the composition itself would be unsafe. + baseline = _run_fake_turn("all") + for mode in ("off", "new", "verbose"): + assert _run_fake_turn(mode) == baseline, f"mode {mode} altered messages" + + def test_toggling_focus_does_not_touch_conversation_history(self): + host = _FocusHost(enabled=False, saved=None, tool_progress="all") + history = [ + {"role": "user", "content": "hello"}, + {"role": "assistant", "content": "hi"}, + ] + host.conversation_history = history + snapshot = json.dumps(history) + + with patch("cli.save_config_value", return_value=True), patch("cli._cprint"): + host._handle_focus_command("/focus on") + host._note_focus_hidden_line("terminal") + host._emit_focus_recovery_line() + host._handle_focus_command("/focus off") + + assert json.dumps(host.conversation_history) == snapshot + + +# ========================================================================= +# Registry wiring +# ========================================================================= + + +class TestCommandRegistration: + def test_focus_is_registered_with_the_sibling_toggle_convention(self): + from hermes_cli.commands import resolve_command + + cmd = resolve_command("focus") + assert cmd is not None + assert cmd.category == "Configuration" + assert cmd.args_hint == "[on|off|status]" + assert set(cmd.subcommands) == {"on", "off", "status"} + + def test_verbose_cycle_releases_focus_view(self): + # /verbose is the explicit tool-progress control; cycling it must clear + # the focus badge so the indicator can never contradict the display. + from cli import HermesCLI + + host = HermesCLI.__new__(HermesCLI) + host.tool_progress_mode = "off" + host._focus_view_enabled = True + host._focus_saved_tool_progress = "all" + host._focus_hidden_lines = 3 + host._focus_last_counted_tool = "terminal" + host.agent = None + + with patch("cli.save_config_value", return_value=True), patch("cli._cprint"): + HermesCLI._toggle_verbose(host) + + assert host._focus_view_enabled is False + assert host._focus_saved_tool_progress is None + assert host._focus_hidden_lines == 0 + assert host.tool_progress_mode == "new" diff --git a/tests/conftest.py b/tests/conftest.py index 159afd4c2b..2ae674cfa4 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -179,6 +179,7 @@ _HERMES_BEHAVIORAL_VARS = frozenset({ "HERMES_SESSION_PLATFORM", "HERMES_SESSION_CHAT_ID", "HERMES_SESSION_CHAT_NAME", + "HERMES_SESSION_CHAT_TYPE", "HERMES_SESSION_THREAD_ID", "HERMES_SESSION_SOURCE", "HERMES_SESSION_KEY", diff --git a/tests/docker/test_sqlite_runtime.py b/tests/docker/test_sqlite_runtime.py new file mode 100644 index 0000000000..235a6a2c20 --- /dev/null +++ b/tests/docker/test_sqlite_runtime.py @@ -0,0 +1,60 @@ +"""Runtime qualification for SQLite in the published Docker image.""" + +from __future__ import annotations + +import json +import subprocess + + +_SQLITE_PROBE = r""" +import json +import sqlite3 + +from hermes_cli.sqlite_runtime import is_sqlite_wal_reset_vulnerable + +db = sqlite3.connect(":memory:") +try: + db.execute("CREATE VIRTUAL TABLE docs USING fts5(content, tokenize='trigram')") + db.execute("INSERT INTO docs VALUES ('hermes')") + matches = db.execute( + "SELECT count(*) FROM docs WHERE docs MATCH 'erm'" + ).fetchone()[0] +finally: + db.close() + +print(json.dumps({ + "sqlite_version": sqlite3.sqlite_version, + "wal_reset_vulnerable": is_sqlite_wal_reset_vulnerable( + sqlite3.sqlite_version_info + ), + "trigram_matches": matches, +})) +""" + + +def test_image_links_fixed_sqlite_with_fts5_trigram(built_image: str) -> None: + result = subprocess.run( + [ + "docker", + "run", + "--rm", + "--user", + "hermes", + "--entrypoint", + "/opt/hermes/.venv/bin/python", + built_image, + "-c", + _SQLITE_PROBE, + ], + capture_output=True, + text=True, + timeout=60, + ) + + assert result.returncode == 0, ( + f"SQLite runtime probe failed: stdout={result.stdout!r} " + f"stderr={result.stderr!r}" + ) + payload = json.loads(result.stdout) + assert payload["wal_reset_vulnerable"] is False, payload + assert payload["trigram_matches"] == 1, payload diff --git a/tests/gateway/test_42039_duplicate_user_message.py b/tests/gateway/test_42039_duplicate_user_message.py index 88f8b8961e..129b1ce926 100644 --- a/tests/gateway/test_42039_duplicate_user_message.py +++ b/tests/gateway/test_42039_duplicate_user_message.py @@ -212,6 +212,54 @@ async def test_not_new_messages_skip_db_when_agent_has_session_db( ) +# ── Post-stream MEDIA delivery keeps prior-turn deduplication ────────── + + +@pytest.mark.asyncio +async def test_streamed_response_receives_prior_turn_media_paths( + monkeypatch, tmp_path +): + """An ordinary streamed reply completes the post-stream delivery branch. + + The history-derived dedup set is part of that branch's contract, rather + than an optional best-effort hint: passing an undefined local crashes the + entire reply, while passing an empty set reintroduces duplicate MEDIA + attachments on later streamed responses. + """ + runner = _bootstrap(monkeypatch, tmp_path) + prior_path = "/tmp/already-delivered.png" + runner.session_store.load_transcript.return_value = [ + {"role": "assistant", "content": f"MEDIA:{prior_path}"}, + ] + runner.adapters = {Platform.TELEGRAM: MagicMock()} + runner._deliver_media_from_response = AsyncMock() + runner._run_agent = AsyncMock( + return_value={ + "final_response": "the streamed reply completed normally", + "messages": [ + {"role": "assistant", "content": f"MEDIA:{prior_path}"}, + {"role": "user", "content": "what is my status?"}, + {"role": "assistant", "content": "the streamed reply completed normally"}, + ], + "tools": [], + "history_offset": 1, + "last_prompt_tokens": 0, + "already_sent": True, + "failed": False, + } + ) + + response = await runner._handle_message_with_agent( + _event(), _source(), "agent:main:telegram:group:-1001:12345", 1 + ) + + assert response is None + runner._deliver_media_from_response.assert_awaited_once() + assert runner._deliver_media_from_response.await_args.kwargs[ + "history_media_paths" + ] == {prior_path} + + # ── Test 4: normal path (new_messages found) uses skip_db=True ──────── diff --git a/tests/gateway/test_71671_faulthandler_no_stderr.py b/tests/gateway/test_71671_faulthandler_no_stderr.py new file mode 100644 index 0000000000..7548ef5485 --- /dev/null +++ b/tests/gateway/test_71671_faulthandler_no_stderr.py @@ -0,0 +1,34 @@ +"""Regression: #71671 — gateway must survive faulthandler.enable() with sys.stderr=None.""" + +from __future__ import annotations + +import faulthandler +import sys + +import pytest + + +def test_faulthandler_enable_falls_back_when_stderr_is_none(tmp_path): + was_enabled = faulthandler.is_enabled() + if was_enabled: + faulthandler.disable() + + real_stderr = sys.stderr + sys.stderr = None + try: + with pytest.raises(RuntimeError, match="sys.stderr is None"): + faulthandler.enable() + + log_path = tmp_path / "gateway_faulthandler.log" + fh = open(log_path, "a", encoding="utf-8") + try: + faulthandler.enable(file=fh, all_threads=True) + assert faulthandler.is_enabled() + assert log_path.exists() + finally: + faulthandler.disable() + fh.close() + finally: + sys.stderr = real_stderr + if was_enabled: + faulthandler.enable() diff --git a/tests/gateway/test_agents_command_delegations.py b/tests/gateway/test_agents_command_delegations.py new file mode 100644 index 0000000000..422ec77f1d --- /dev/null +++ b/tests/gateway/test_agents_command_delegations.py @@ -0,0 +1,119 @@ +"""Gateway /agents surfaces background delegations with live activity (#51690). + +Drives the REAL GatewayRunner._handle_agents_command against a REAL +async-delegation registry dispatch (no mocked list function), so the test +covers the whole projection: registry record → list_async_delegations() +live sampling → /agents rendering. +""" + +import threading +import time + +import pytest + +from tools import async_delegation as ad +from tools.process_registry import process_registry + + +@pytest.fixture(autouse=True) +def _clean_state(): + ad._reset_for_tests() + while not process_registry.completion_queue.empty(): + process_registry.completion_queue.get_nowait() + yield + deadline = time.monotonic() + 2.0 + while ad.active_count() and time.monotonic() < deadline: + time.sleep(0.02) + ad._reset_for_tests() + while not process_registry.completion_queue.empty(): + process_registry.completion_queue.get_nowait() + + +def _make_runner(): + from gateway.run import GatewayRunner + + runner = object.__new__(GatewayRunner) + runner._running_agents = {} + runner._running_agents_ts = {} + runner._background_tasks = set() + runner._session_key_for_source = lambda source: "agent:main:test:dm:1" + return runner + + +class _Event: + source = None + + +@pytest.mark.asyncio +async def test_agents_command_lists_background_delegation_with_activity(): + gate = threading.Event() + base_ts = time.time() - 8.0 + + res = ad.dispatch_async_delegation( + goal="research the delegation stall monitor", + context=None, toolsets=None, role="leaf", model="m", + session_key="agent:main:test:dm:1", max_async_children=1, + runner=lambda: {} if gate.wait(timeout=10) else {}, + progress_fn=lambda: (((2, "web_search", base_ts),), True), + ) + assert res["status"] == "dispatched" + + try: + runner = _make_runner() + out = await runner._handle_agents_command(_Event()) + finally: + gate.set() + + assert res["delegation_id"] in out + assert "running" in out + assert "research the delegation stall monitor" in out + # Live per-child activity sampled from progress_fn. + assert "2 api calls" in out + assert "web_search" in out + + +@pytest.mark.asyncio +async def test_agents_command_marks_stalling_delegation(monkeypatch): + monkeypatch.setattr(ad, "_STALE_CHECK_INTERVAL", 0.03) + monkeypatch.setattr(ad, "_STALE_IDLE_SECONDS", 0.1) + # Long grace so the record stays in 'stalling' while we render. + monkeypatch.setattr(ad, "_STALL_GRACE_SECONDS", 30.0) + gate = threading.Event() + + res = ad.dispatch_async_delegation( + goal="wedged child", context=None, toolsets=None, role="leaf", + model="m", session_key="agent:main:test:dm:1", max_async_children=1, + runner=lambda: {} if gate.wait(timeout=10) else {}, + progress_fn=lambda: ((0, None), False), + ) + assert res["status"] == "dispatched" + + try: + deadline = time.monotonic() + 5.0 + while time.monotonic() < deadline: + items = ad.list_async_delegations() + if any( + d["delegation_id"] == res["delegation_id"] + and d.get("status") == "stalling" + for d in items + ): + break + time.sleep(0.02) + else: + pytest.fail("delegation never reached stalling state") + + runner = _make_runner() + out = await runner._handle_agents_command(_Event()) + finally: + gate.set() + + assert res["delegation_id"] in out + assert "stalling" in out + assert "no progress" in out + + +@pytest.mark.asyncio +async def test_agents_command_no_delegations_keeps_none_message(): + runner = _make_runner() + out = await runner._handle_agents_command(_Event()) + assert "No active agents" in out diff --git a/tests/gateway/test_diff_command.py b/tests/gateway/test_diff_command.py new file mode 100644 index 0000000000..491fadb3fd --- /dev/null +++ b/tests/gateway/test_diff_command.py @@ -0,0 +1,180 @@ +"""End-to-end tests for the gateway ``/diff`` command. + +Exercises the real handler against real git repositories (default modes) and +a real checkpoint store (session mode), proving the messaging surface returns +fenced, truncated diff text and degrades to friendly messages when there's +nothing to show. +""" + +import shutil +import subprocess + +import pytest + +import gateway.run as gateway_run +import tools.checkpoint_manager as cpm +from gateway.config import Platform +from gateway.platforms.base import MessageEvent +from gateway.session import SessionSource + +pytestmark = pytest.mark.skipif( + shutil.which("git") is None, reason="git required for /diff" +) + + +def _runner(): + runner = object.__new__(gateway_run.GatewayRunner) + runner.session_store = None + runner.config = None + return runner + + +def _event(text: str) -> MessageEvent: + source = SessionSource( + platform=Platform.TELEGRAM, + user_id="user-1", + chat_id="chat-1", + user_name="tester", + chat_type="dm", + ) + return MessageEvent(text=text, source=source) + + +def _git(repo, *args): + subprocess.run(["git", *args], cwd=repo, check=True, capture_output=True, + env={"GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", + "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t", + "HOME": str(repo), + "PATH": __import__("os").environ["PATH"]}) + + +@pytest.fixture() +def repo(tmp_path, monkeypatch): + d = tmp_path / "repo" + d.mkdir() + _git(d, "init", "-q") + (d / "main.py").write_text("print('hello')\n", encoding="utf-8") + _git(d, "add", "-A") + _git(d, "commit", "-q", "-m", "init") + monkeypatch.setenv("TERMINAL_CWD", str(d)) + return d + + +def _enable_checkpoints(tmp_path, monkeypatch, enabled=True): + home = tmp_path / "home" + home.mkdir() + (home / "config.yaml").write_text( + f"checkpoints:\n enabled: {str(enabled).lower()}\n", encoding="utf-8" + ) + monkeypatch.setattr(gateway_run, "_hermes_home", home, raising=False) + monkeypatch.setattr(cpm, "CHECKPOINT_BASE", tmp_path / "checkpoints") + + +# --------------------------------------------------------------------------- +# Default (working-tree) mode +# --------------------------------------------------------------------------- + +@pytest.mark.asyncio +async def test_diff_reports_unstaged_changes_fenced(repo): + (repo / "main.py").write_text("print('changed')\n", encoding="utf-8") + + result = await _runner()._handle_diff_command(_event("/diff")) + + assert "-print('hello')" in result + assert "+print('changed')" in result + assert "```diff" in result # fenced for messaging surfaces + + +@pytest.mark.asyncio +async def test_diff_includes_untracked_files(repo): + (repo / "newfile.py").write_text("n = 1\n", encoding="utf-8") + + result = await _runner()._handle_diff_command(_event("/diff")) + + assert "newfile.py" in result + assert "+n = 1" in result + + +@pytest.mark.asyncio +async def test_diff_stat_only_omits_body(repo): + (repo / "main.py").write_text("print('changed')\n", encoding="utf-8") + + result = await _runner()._handle_diff_command(_event("/diff --stat")) + + assert "main.py" in result + assert "+print('changed')" not in result + + +@pytest.mark.asyncio +async def test_diff_no_changes_message(repo): + result = await _runner()._handle_diff_command(_event("/diff")) + assert "No changes" in result + + +@pytest.mark.asyncio +async def test_diff_long_output_truncated(repo): + lines = "\n".join(f"line{i} = {i}" for i in range(300)) + "\n" + (repo / "main.py").write_text(lines, encoding="utf-8") + + result = await _runner()._handle_diff_command(_event("/diff")) + + # Hard-truncated in the handler before the platform senders apply their + # own message-splitting limits (3-layer tool-progress-style truncation). + assert "truncated" in result + assert len(result) < 6000 + + +@pytest.mark.asyncio +async def test_diff_non_git_directory_fails_cleanly(tmp_path, monkeypatch): + plain = tmp_path / "plain" + plain.mkdir() + monkeypatch.setenv("TERMINAL_CWD", str(plain)) + + result = await _runner()._handle_diff_command(_event("/diff")) + + assert "not a git repository" in result.lower() + + +# --------------------------------------------------------------------------- +# Session mode — checkpoint baseline +# --------------------------------------------------------------------------- + +@pytest.mark.asyncio +async def test_diff_session_reports_cumulative_changes(tmp_path, monkeypatch): + _enable_checkpoints(tmp_path, monkeypatch) + project = tmp_path / "project" + project.mkdir() + (project / "main.py").write_text("print('hello')\n", encoding="utf-8") + monkeypatch.setenv("TERMINAL_CWD", str(project)) + + # Baseline checkpoint (pre-edit) then an edit, so a diff exists. + mgr = cpm.CheckpointManager(enabled=True, max_snapshots=50) + assert mgr.ensure_checkpoint(str(project), "baseline") is True + (project / "main.py").write_text("print('changed')\n", encoding="utf-8") + + result = await _runner()._handle_diff_command(_event("/diff session")) + + assert "-print('hello')" in result + assert "+print('changed')" in result + + +@pytest.mark.asyncio +async def test_diff_session_no_changes_message(tmp_path, monkeypatch): + _enable_checkpoints(tmp_path, monkeypatch) + project = tmp_path / "project" + project.mkdir() + monkeypatch.setenv("TERMINAL_CWD", str(project)) + + result = await _runner()._handle_diff_command(_event("/diff session")) + + assert "No changes" in result + + +@pytest.mark.asyncio +async def test_diff_session_disabled_message(tmp_path, monkeypatch): + _enable_checkpoints(tmp_path, monkeypatch, enabled=False) + monkeypatch.setenv("TERMINAL_CWD", str(tmp_path)) + + result = await _runner()._handle_diff_command(_event("/diff session")) + + assert "not enabled" in result.lower() diff --git a/tests/gateway/test_discord_send.py b/tests/gateway/test_discord_send.py index cd2950f9fb..dd178ac52b 100644 --- a/tests/gateway/test_discord_send.py +++ b/tests/gateway/test_discord_send.py @@ -1,7 +1,8 @@ import asyncio +import sys +from pathlib import Path from types import SimpleNamespace from unittest.mock import AsyncMock, MagicMock -import sys import pytest @@ -325,7 +326,14 @@ async def test_forum_post_file_creates_thread_with_attachment(): adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***")) thread_ch = SimpleNamespace(id=777, send=AsyncMock()) - thread = SimpleNamespace(id=777, message=SimpleNamespace(id=800), thread=thread_ch) + thread = SimpleNamespace( + id=777, + message=SimpleNamespace( + id=800, + attachments=[SimpleNamespace(filename="photo.png")], + ), + thread=thread_ch, + ) forum_channel = _discord_mod.ForumChannel() forum_channel.id = 999 forum_channel.name = "ideas" @@ -355,7 +363,14 @@ async def test_forum_post_file_uses_filename_when_no_content(): """Thread name falls back to file.filename when no content is provided.""" adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***")) - thread = SimpleNamespace(id=1, message=SimpleNamespace(id=2), thread=SimpleNamespace(id=1, send=AsyncMock())) + thread = SimpleNamespace( + id=1, + message=SimpleNamespace( + id=2, + attachments=[SimpleNamespace(filename="voice-message.ogg")], + ), + thread=SimpleNamespace(id=1, send=AsyncMock()), + ) forum_channel = _discord_mod.ForumChannel() forum_channel.id = 10 forum_channel.name = "forum" @@ -389,6 +404,32 @@ async def test_forum_post_file_creation_failure(): assert "missing perms" in (result.error or "") +@pytest.mark.asyncio +async def test_forum_post_file_fails_when_starter_has_no_attachments(): + """Forum create_thread can succeed yet return an attachmentless starter (#66797).""" + adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***")) + + thread = SimpleNamespace( + id=7, + message=SimpleNamespace(id=8, attachments=[]), + thread=SimpleNamespace(id=7, send=AsyncMock()), + ) + forum_channel = _discord_mod.ForumChannel() + forum_channel.id = 999 + forum_channel.create_thread = AsyncMock(return_value=thread) + + fake_file = SimpleNamespace(filename="clip.mp4") + result = await adapter._forum_post_file( + forum_channel, + content="video clip", + files=[fake_file], + ) + + assert result.success is False + assert "no files" in (result.error or "").lower() + forum_channel.create_thread.assert_awaited_once() + + # --------------------------------------------------------------------------- # Typing indicator task lifecycle # --------------------------------------------------------------------------- @@ -445,3 +486,237 @@ async def test_typing_stop_cleans_up(): await adapter.stop_typing("12345") assert "12345" not in adapter._typing_tasks + + +# --------------------------------------------------------------------------- +# #66797 — outbound MEDIA video must reach channel.send as a real attachment +# --------------------------------------------------------------------------- + + +@pytest.mark.asyncio +async def test_send_video_uses_path_based_files_kwarg(tmp_path, monkeypatch): + """Regression for #66797: video MEDIA delivery must use path-based + ``discord.File`` via ``files=[...]`` (same pattern as image batching). + + The previous open-handle + singular ``file=`` form could return a successful + message with zero attachments after an earlier image batch on the same + channel — silent drop from the user's perspective. + """ + import plugins.platforms.discord.adapter as discord_platform + + video = tmp_path / "clip.mp4" + video.write_bytes(b"\x00\x00\x00\x18ftypmp42fake") + + captured = {} + + class _FakeFile: + def __init__(self, fp, filename=None, **kwargs): + captured["fp"] = fp + captured["filename"] = filename + + monkeypatch.setattr(discord_platform.discord, "File", _FakeFile) + + adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***")) + sent_msg = SimpleNamespace( + id=4242, + attachments=[SimpleNamespace(filename="clip.mp4", url="https://cdn.example/clip.mp4")], + ) + channel = SimpleNamespace( + send=AsyncMock(return_value=sent_msg), + type=0, + ) + adapter._client = SimpleNamespace( + get_channel=lambda _chat_id: channel, + fetch_channel=AsyncMock(), + ) + monkeypatch.setattr(adapter, "_is_forum_parent", lambda _ch: False) + + result = await adapter.send_video("555", str(video)) + + assert result.success is True + assert result.message_id == "4242" + assert captured["fp"] == str(video) + assert captured["filename"] == "clip.mp4" + channel.send.assert_awaited_once() + send_kwargs = channel.send.await_args.kwargs + assert send_kwargs.get("file") is None + assert isinstance(send_kwargs.get("files"), list) and len(send_kwargs["files"]) == 1 + + +@pytest.mark.asyncio +async def test_send_video_fails_loud_when_message_has_no_attachments(tmp_path, monkeypatch): + """If Discord accepts the message but attaches nothing, fail loud (#66797).""" + import plugins.platforms.discord.adapter as discord_platform + + video = tmp_path / "clip.mp4" + video.write_bytes(b"fake-mp4") + + monkeypatch.setattr( + discord_platform.discord, + "File", + lambda fp, filename=None, **kwargs: SimpleNamespace(fp=fp, filename=filename), + ) + + adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***")) + # Message id present, but no attachments — the silent-drop failure mode. + sent_msg = SimpleNamespace(id=99, attachments=[]) + channel = SimpleNamespace(send=AsyncMock(return_value=sent_msg), type=0) + adapter._client = SimpleNamespace( + get_channel=lambda _chat_id: channel, + fetch_channel=AsyncMock(), + ) + monkeypatch.setattr(adapter, "_is_forum_parent", lambda _ch: False) + + result = await adapter.send_video("555", str(video)) + + assert result.success is False + assert "no files" in (result.error or "").lower() + channel.send.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_deliver_media_from_response_routes_mp4_to_send_video(tmp_path, monkeypatch): + """Streaming/post-stream dispatch must call send_video for MEDIA:.mp4.""" + from gateway.platforms.base import BasePlatformAdapter, SendResult + from gateway.run import GatewayRunner + + video = tmp_path / "clip.mp4" + video.write_bytes(b"fake-mp4") + image = tmp_path / "figure.png" + image.write_bytes(b"fake-png") + + # Allow delivery from tmp_path in non-strict mode (default). + monkeypatch.chdir(tmp_path) + + adapter = SimpleNamespace( + name="Discord", + extract_media=BasePlatformAdapter.extract_media, + extract_images=BasePlatformAdapter.extract_images, + extract_local_files=BasePlatformAdapter.extract_local_files, + send_voice=AsyncMock(return_value=SendResult(success=True, message_id="v")), + send_document=AsyncMock(return_value=SendResult(success=True, message_id="d")), + send_image_file=AsyncMock(return_value=SendResult(success=True, message_id="i")), + send_video=AsyncMock(return_value=SendResult(success=True, message_id="vid")), + send_multiple_images=AsyncMock(), + ) + event = SimpleNamespace( + source=SimpleNamespace( + platform="discord", + chat_id="chat-1", + thread_id=None, + ) + ) + runner = SimpleNamespace( + _thread_metadata_for_source=lambda source, anchor=None: {}, + _reply_anchor_for_event=lambda event: None, + ) + response = ( + f"Here is the figure:\n\nMEDIA:{image}\n\n" + f"And the clip:\n\nMEDIA:{video}\n" + ) + + await GatewayRunner._deliver_media_from_response(runner, response, event, adapter) + + adapter.send_video.assert_awaited_once() + sent_path = adapter.send_video.await_args.kwargs["video_path"] + assert Path(sent_path).resolve() == video.resolve() + adapter.send_multiple_images.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_send_video_missing_file_fails_fast_without_touching_channel(): + """A missing MEDIA path must fail loud before any Discord I/O (#66797). + + The pre-flight ``os.path.isfile`` guard turns a would-be crash inside + ``discord.File`` into an actionable ``File not found`` result, and must + short-circuit before the channel is ever resolved. + """ + def _boom(*_args, **_kwargs): + raise AssertionError("channel must not be resolved for a missing file") + + adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***")) + adapter._client = SimpleNamespace(get_channel=_boom, fetch_channel=AsyncMock(side_effect=_boom)) + + result = await adapter.send_video("555", "/no/such/clip.mp4") + + assert result.success is False + assert "not found" in (result.error or "").lower() + + +@pytest.mark.asyncio +async def test_send_file_attachment_forum_uses_files_kwarg(tmp_path, monkeypatch): + """Forum-parent delivery must also route the path-based file through the + plural ``files=[...]`` kwarg (#66797), so the create_thread starter message + carries the attachment rather than silently dropping it.""" + import plugins.platforms.discord.adapter as discord_platform + + video = tmp_path / "clip.mp4" + video.write_bytes(b"fake-mp4") + + monkeypatch.setattr( + discord_platform.discord, + "File", + lambda fp, filename=None, **kwargs: SimpleNamespace(fp=fp, filename=filename), + ) + + adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***")) + created_thread = SimpleNamespace( + id=7, + message=SimpleNamespace( + id=8, + attachments=[SimpleNamespace(filename="clip.mp4")], + ), + ) + forum_channel = SimpleNamespace( + id=7, + create_thread=AsyncMock(return_value=created_thread), + ) + adapter._client = SimpleNamespace( + get_channel=lambda _chat_id: forum_channel, + fetch_channel=AsyncMock(), + ) + monkeypatch.setattr(adapter, "_is_forum_parent", lambda _ch: True) + + result = await adapter.send_video("555", str(video)) + + assert result.success is True + forum_channel.create_thread.assert_awaited_once() + thread_kwargs = forum_channel.create_thread.await_args.kwargs + assert thread_kwargs.get("file") is None + assert isinstance(thread_kwargs.get("files"), list) and len(thread_kwargs["files"]) == 1 + + +@pytest.mark.asyncio +async def test_forum_send_video_fails_loud_when_starter_has_no_attachments(tmp_path, monkeypatch): + """Forum-parent send_video must fail loud when the starter message drops attachments.""" + import plugins.platforms.discord.adapter as discord_platform + + video = tmp_path / "clip.mp4" + video.write_bytes(b"fake-mp4") + + monkeypatch.setattr( + discord_platform.discord, + "File", + lambda fp, filename=None, **kwargs: SimpleNamespace(fp=fp, filename=filename), + ) + + adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***")) + created_thread = SimpleNamespace( + id=7, + message=SimpleNamespace(id=8, attachments=[]), + ) + forum_channel = SimpleNamespace( + id=7, + create_thread=AsyncMock(return_value=created_thread), + ) + adapter._client = SimpleNamespace( + get_channel=lambda _chat_id: forum_channel, + fetch_channel=AsyncMock(), + ) + monkeypatch.setattr(adapter, "_is_forum_parent", lambda _ch: True) + + result = await adapter.send_video("555", str(video)) + + assert result.success is False + assert "no files" in (result.error or "").lower() + forum_channel.create_thread.assert_awaited_once() diff --git a/tests/gateway/test_kanban_notifier.py b/tests/gateway/test_kanban_notifier.py index 22c70e1c39..014e276ac9 100644 --- a/tests/gateway/test_kanban_notifier.py +++ b/tests/gateway/test_kanban_notifier.py @@ -1,4 +1,5 @@ import asyncio +import sqlite3 from pathlib import Path @@ -10,10 +11,14 @@ from hermes_cli import kanban_db as kb class RecordingAdapter: def __init__(self): self.sent = [] + self.handled = [] async def send(self, chat_id, text, metadata=None): self.sent.append({"chat_id": chat_id, "text": text, "metadata": metadata or {}}) + async def handle_message(self, event): + self.handled.append(event) + class DisconnectedAdapters(dict): """Expose a platform during collection, then simulate disconnect on get().""" @@ -105,6 +110,54 @@ def test_kanban_notifier_claim_prevents_second_watcher_send(tmp_path, monkeypatc assert adapter2.sent == [] +def test_kanban_notifier_replays_telegram_dm_topic_delivery_metadata(tmp_path, monkeypatch): + db_path = tmp_path / "dm-topic-metadata.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + + conn = kb.connect() + try: + tid = kb.create_task( + conn, + title="dm topic task", + assignee="worker", + session_id="agent:main:telegram:dm:chat-1", + ) + kb.add_notify_sub( + conn, + task_id=tid, + platform="telegram", + chat_id="chat-1", + thread_id="20197", + delivery_metadata={ + "chat_type": "dm", + "direct_messages_topic_id": "20197", + "telegram_dm_topic_reply_fallback": True, + "telegram_reply_to_message_id": "462", + "thread_id": "20197", + }, + ) + kb.complete_task(conn, tid, summary="done") + finally: + conn.close() + + adapter = RecordingAdapter() + runner = _make_runner(adapter) + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + assert len(adapter.sent) == 1 + assert adapter.sent[0]["metadata"] == { + "chat_type": "dm", + "direct_messages_topic_id": "20197", + "telegram_dm_topic_reply_fallback": True, + "telegram_reply_to_message_id": "462", + "thread_id": "20197", + } + assert len(adapter.handled) == 1 + assert adapter.handled[0].source.chat_type == "dm" + assert adapter.handled[0].source.thread_id == "20197" + + def test_kanban_notifier_rewinds_claim_if_adapter_disconnects(tmp_path, monkeypatch): db_path = tmp_path / "adapter-disconnect.db" monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) @@ -121,6 +174,44 @@ def test_kanban_notifier_rewinds_claim_if_adapter_disconnects(tmp_path, monkeypa assert [ev.kind for ev in _unseen_terminal_events(tid)] == ["completed"] +def test_active_named_profile_subscription_is_delivered(tmp_path, monkeypatch): + """A sub stamped with the gateway's own named profile uses self.adapters. + + Regression for #71340: on a standalone (non-multiplex) gateway running a + named profile, _authorization_adapter() used to treat the active name as a + multiplex secondary, find no _profile_adapters entry, fail closed, and + rewind the claim forever — silent zero-delivery. + """ + db_path = tmp_path / "actionable-block.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + reason = "AGE-39 — https://linear.example/AGE-39 — publishing verified." + conn = kb.connect() + try: + tid = kb.create_task(conn, title="approval", assignee="publisher") + kb.add_notify_sub( + conn, + task_id=tid, + platform="telegram", + chat_id="chat-1", + notifier_profile="main", + ) + kb.block_task(conn, tid, reason=reason, kind="needs_input") + finally: + conn.close() + + adapter = RecordingAdapter() + runner = _make_runner(adapter) + runner._active_profile_name = lambda: "main" + + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + assert len(adapter.sent) == 1 + message = adapter.sent[0]["text"] + assert tid in message + assert "blocked" in message + + def test_kanban_db_path_is_test_isolated_from_real_home(): hermes_home = Path(kb.kanban_home()) production_db = Path.home() / ".hermes" / "kanban.db" @@ -173,6 +264,45 @@ def test_kanban_notifier_rewinds_claim_on_send_exception(tmp_path, monkeypatch): assert [ev.kind for ev in _unseen_terminal_events(tid)] == ["completed"] +class ReportedFailureAdapter: + """Adapter that REPORTS failure via SendResult(success=False) instead of + raising — the exact contract the Telegram adapter uses for 'Not connected' + and degraded-send paths.""" + + def __init__(self): + self.attempts = 0 + + async def send(self, chat_id, text, metadata=None): + self.attempts += 1 + from gateway.platforms.base import SendResult + return SendResult(success=False, error="Not connected") + + +def test_kanban_notifier_rewinds_claim_on_reported_send_failure(tmp_path, monkeypatch): + """A non-raising SendResult(success=False) must NOT advance the cursor. + + Regression for the silent-drop bug: the notifier used to discard send()'s + return value, so a reported (not raised) failure — e.g. Telegram mid- + reconnect after a gateway restart — fell through to the success branch, + marked the event seen, and lost the notification forever. The event must + remain unseen for retry, exactly like the raised-exception path. + """ + db_path = tmp_path / "reported-failure.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + tid = _create_completed_subscription() + + adapter = ReportedFailureAdapter() + runner = _make_runner(adapter) + + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + assert adapter.attempts >= 1, "send should have been attempted" + assert [ev.kind for ev in _unseen_terminal_events(tid)] == ["completed"], ( + "a reported send failure must rewind the claim, not silently drop the event" + ) + + def test_notifier_redelivers_same_kind_on_dispatch_cycle(tmp_path, monkeypatch): """A retry cycle (crashed → reclaimed → crashed) notifies the user twice. @@ -235,6 +365,36 @@ def test_notifier_redelivers_same_kind_on_dispatch_cycle(tmp_path, monkeypatch): assert "crashed" in adapter.sent[1]["text"].lower() +def test_notifier_delivers_subscription_owned_by_active_profile(tmp_path, monkeypatch): + """A single-profile gateway stamps active profile but keeps adapters primary.""" + db_path = tmp_path / "active-profile-owner.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + + conn = kb.connect() + try: + tid = kb.create_task(conn, title="owned by active profile", assignee="worker") + kb.add_notify_sub( + conn, + task_id=tid, + platform="telegram", + chat_id="chat-1", + notifier_profile="dev", + ) + kb.complete_task(conn, tid, summary="done") + finally: + conn.close() + + adapter = RecordingAdapter() + runner = _make_runner(adapter) + runner._active_profile_name = lambda: "dev" + + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + assert len(adapter.sent) == 1 + assert tid in adapter.sent[0]["text"] + + def test_notifier_owning_profile_adapter_no_default_fallback(tmp_path, monkeypatch): """A subscription owned by a secondary profile whose profile-adapter registry entry EXISTS but lacks this platform must NOT fall back to the @@ -294,6 +454,175 @@ def test_notifier_owning_profile_adapter_no_default_fallback(tmp_path, monkeypat assert [ev.kind for ev in _unseen_terminal_events_for(tid, "chat-beta")] == ["completed"] +def test_notifier_claims_platform_only_a_secondary_profile_owns(tmp_path, monkeypatch): + """A subscription owned by a secondary profile on a platform the DEFAULT + profile never connected must still be claimed and delivered. + + Regression: the ``_collect()`` pre-filter built ``active_platforms`` + solely from ``self.adapters`` (the default profile). A sub owned by + profile "beta" on "discord", where beta genuinely has a live discord + adapter but the default profile has no discord adapter at all, was + dropped by that pre-filter (``platform not in active_platforms``) + before ``claim_unseen_events_for_sub`` ever ran — unlike the + disconnected-adapter path, an unclaimed event is never rewound, so this + was a permanent, silent notification loss, not a retryable one. This + directly contradicts the feature's own purpose (routing notifications + via the owning profile), and is the same cross-profile-adapter-lookup + class the delivery-side chokepoint in + ``test_notifier_owning_profile_adapter_no_default_fallback`` already + guards — just one gate earlier. + """ + db_path = tmp_path / "secondary-only-platform.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + + conn = kb.connect() + try: + tid = kb.create_task(conn, title="owned by beta on discord", assignee="worker") + kb.add_notify_sub( + conn, task_id=tid, platform="discord", chat_id="chat-beta", + notifier_profile="beta", + ) + kb.complete_task(conn, tid, summary="done") + finally: + conn.close() + + beta_adapter = RecordingAdapter() + runner = GatewayRunner.__new__(GatewayRunner) + runner._running = True + # Default profile has NO discord adapter at all. + runner.adapters = {Platform.TELEGRAM: RecordingAdapter()} + # Secondary profile "beta" has a live discord adapter. + runner._profile_adapters = {"beta": {Platform.DISCORD: beta_adapter}} + runner._kanban_sub_fail_counts = {} + + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + assert len(beta_adapter.sent) == 1, ( + f"beta's discord adapter should have received the notification; got {beta_adapter.sent!r}" + ) + + +def test_notifier_wakeup_uses_subscription_chat_type(tmp_path, monkeypatch): + db_path = tmp_path / "chat-type-wakeup.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + + conn = kb.connect() + try: + tid = kb.create_task( + conn, + title="dm requester", + assignee="worker", + session_id="origin-session", + ) + kb.add_notify_sub( + conn, + task_id=tid, + platform="telegram", + chat_id="chat-dm", + chat_type="dm", + ) + kb.complete_task(conn, tid, summary="done") + finally: + conn.close() + + adapter = RecordingAdapter() + asyncio.run(_run_one_notifier_tick(monkeypatch, _make_runner(adapter))) + + assert len(adapter.sent) == 1 + assert len(adapter.handled) == 1 + assert adapter.handled[0].source.chat_type == "dm" + + # The wake must resume the creator's real DM session key — the whole bug + # was that a hardcoded chat_type="group" made build_session_key() produce + # a group-scoped key (a NEW session) instead of the ":dm:" shape + # the original conversation runs under (#56580 / #68874). + from gateway.session import build_session_key + + wake_key = build_session_key(adapter.handled[0].source) + assert wake_key == "agent:main:telegram:dm:chat-dm" + assert ":group:" not in wake_key + + +def test_auto_subscribe_persists_session_chat_type(tmp_path, monkeypatch): + db_path = tmp_path / "auto-sub-chat-type.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + + from gateway.session_context import clear_session_vars, set_session_vars + from tools import kanban_tools + + monkeypatch.setattr( + kanban_tools, + "load_config", + lambda: {"kanban": {"auto_subscribe_on_create": True}}, + ) + + tokens = set_session_vars( + platform="telegram", + chat_id="chat-dm", + chat_type="dm", + ) + conn = kb.connect() + try: + tid = kb.create_task(conn, title="auto sub", assignee="worker") + + assert kanban_tools._maybe_auto_subscribe(conn, tid) is True + [sub] = kb.list_notify_subs(conn, task_id=tid) + assert sub["chat_type"] == "dm" + finally: + conn.close() + clear_session_vars(tokens) + + +def test_notify_sub_migration_adds_chat_type_to_legacy_table(tmp_path, monkeypatch): + db_path = tmp_path / "legacy-notify-sub.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + + legacy = sqlite3.connect(db_path) + try: + legacy.execute( + """ + CREATE TABLE kanban_notify_subs ( + task_id TEXT NOT NULL, + platform TEXT NOT NULL, + chat_id TEXT NOT NULL, + thread_id TEXT NOT NULL DEFAULT '', + user_id TEXT, + notifier_profile TEXT, + created_at INTEGER NOT NULL, + last_event_id INTEGER NOT NULL DEFAULT 0, + PRIMARY KEY (task_id, platform, chat_id, thread_id) + ) + """ + ) + legacy.commit() + finally: + legacy.close() + + kb.init_db() + conn = kb.connect() + try: + cols = { + row["name"] for row in conn.execute("PRAGMA table_info(kanban_notify_subs)") + } + assert "chat_type" in cols + + tid = kb.create_task(conn, title="legacy sub", assignee="worker") + kb.add_notify_sub( + conn, + task_id=tid, + platform="telegram", + chat_id="chat-dm", + chat_type="dm", + ) + [sub] = kb.list_notify_subs(conn, task_id=tid) + assert sub["chat_type"] == "dm" + finally: + conn.close() + + def _unseen_terminal_events_for(tid, chat_id): conn = kb.connect() try: @@ -307,3 +636,111 @@ def _unseen_terminal_events_for(tid, chat_id): return events finally: conn.close() + + +def test_kanban_notifier_isolates_per_subscription_failure(tmp_path, monkeypatch): + """One bad subscription must not block delivery for all others. + + Regression for #59269: when claim_unseen_events_for_sub raises for one + subscription, the entire notifier tick used to abort — silently blocking + delivery for every other subscription. + """ + db_path = tmp_path / "isolation.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + + # Create two tasks with subscriptions and complete both. The BAD task is + # created first: list_notify_subs() has no ORDER BY, so SQLite's natural + # scan returns insertion order — the failing subscription must be + # processed BEFORE the good one or this test passes even without the + # per-subscription isolation (the good delivery happens before the tick + # aborts). A deterministic-order shim below removes the reliance on the + # scan order entirely. + conn = kb.connect() + try: + tid_bad = kb.create_task(conn, title="bad task", assignee="worker") + kb.add_notify_sub(conn, task_id=tid_bad, platform="telegram", chat_id="chat-bad") + kb.complete_task(conn, tid_bad, summary="done") + + tid_good = kb.create_task(conn, title="good task", assignee="worker") + kb.add_notify_sub(conn, task_id=tid_good, platform="telegram", chat_id="chat-good") + kb.complete_task(conn, tid_good, summary="done") + finally: + conn.close() + + original_claim = kb.claim_unseen_events_for_sub + + def selective_claim(conn, task_id, **kwargs): + if task_id == tid_bad: + raise RuntimeError("simulated DB corruption for bad task") + return original_claim(conn, task_id=task_id, **kwargs) + + monkeypatch.setattr(kb, "claim_unseen_events_for_sub", selective_claim) + + # Force the failing subscription to be iterated FIRST regardless of the + # unordered SELECT's scan order. + original_list = kb.list_notify_subs + + def bad_first(conn, task_id=None): + subs = original_list(conn, task_id) + return sorted(subs, key=lambda s: 0 if s["task_id"] == tid_bad else 1) + + monkeypatch.setattr(kb, "list_notify_subs", bad_first) + + adapter = RecordingAdapter() + runner = _make_runner(adapter) + + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + # The good task must still be delivered despite the bad task failing. + assert len(adapter.sent) == 1 + assert tid_good in adapter.sent[0]["text"] + + +def test_notifier_delivers_block_loop_detected_triage_ping(tmp_path, monkeypatch): + """A `block_loop_detected` event must reach the subscriber as a triage ping. + + Regression for the silent-triage gap (PR #62712): kanban_db routes a task + to `triage` after BLOCK_RECURRENCE_LIMIT re-blocks for the same cause and + emits ONLY a `block_loop_detected` event — no `blocked`/`status` event. + Before `block_loop_detected` joined TERMINAL_KINDS with its own message + branch, that one transition (the whole point of which is to force human + attention) produced zero notification and the task stalled in triage + silently. + """ + db_path = tmp_path / "block-loop.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + + conn = kb.connect() + try: + tid = kb.create_task(conn, title="loops forever", assignee="worker") + kb.add_notify_sub(conn, task_id=tid, platform="telegram", chat_id="chat-1") + kb._append_event( + conn, tid, "block_loop_detected", + {"reason": "needs credentials", "kind": "needs_input", + "recurrences": 2, "limit": kb.BLOCK_RECURRENCE_LIMIT}, + ) + finally: + conn.close() + + adapter = RecordingAdapter() + runner = _make_runner(adapter) + + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + assert len(adapter.sent) == 1, "block_loop_detected must produce a notification" + text = adapter.sent[0]["text"] + assert "TRIAGE" in text + assert tid in text + assert "needs credentials" in text + # Cursor advanced: the event is claimed and not re-delivered. + conn = kb.connect() + try: + _, remaining = kb.unseen_events_for_sub( + conn, task_id=tid, platform="telegram", chat_id="chat-1", + kinds=["block_loop_detected"], + ) + finally: + conn.close() + assert remaining == [] diff --git a/tests/gateway/test_kanban_notifier_zero_sub_gate.py b/tests/gateway/test_kanban_notifier_zero_sub_gate.py new file mode 100644 index 0000000000..d8e64f2de9 --- /dev/null +++ b/tests/gateway/test_kanban_notifier_zero_sub_gate.py @@ -0,0 +1,120 @@ +"""Tests for the kanban notifier zero-subscription early exit. + +The notifier used to writable-open EVERY board DB on every tick even when a +board had zero subscriptions — paying schema init/migration on first open, +WAL/-shm sidecar creation, and checkpoint traffic for boards with nothing to +notify. Per-board work is now gated by a read-only subscription probe +(``kanban_db.count_notify_subs``), so boards with zero subscriptions are +never opened writable. + +(The companion machine-global ``.notifier.lock`` singleton gate from PR +#63001 was deliberately NOT salvaged: a lock-winning default-profile gateway +cannot deliver a secondary profile's subscriptions in standalone-profile +deployments — profile routing fails closed in +``gateway/authz_mixin.py::_authorization_adapter`` — so the lock could +suppress delivery entirely. The read-only probe captures the per-tick cost +win without that risk.) +""" + +import asyncio + +from unittest.mock import patch + +from gateway.config import Platform +from gateway.run import GatewayRunner +from hermes_cli import kanban_db as kb + + +class RecordingAdapter: + def __init__(self): + self.sent = [] + + async def send(self, chat_id, text, metadata=None): + self.sent.append({"chat_id": chat_id, "text": text, "metadata": metadata or {}}) + + +def _make_runner(adapter): + runner = GatewayRunner.__new__(GatewayRunner) + runner._running = True + runner.adapters = {Platform.TELEGRAM: adapter} + runner._kanban_sub_fail_counts = {} + return runner + + +async def _run_one_notifier_tick(monkeypatch, runner): + real_sleep = asyncio.sleep + + async def fake_sleep(delay): + if delay == 5: + return None + runner._running = False + await real_sleep(0) + + monkeypatch.setattr(asyncio, "sleep", fake_sleep) + await runner._kanban_notifier_watcher(interval=1) + + +def _create_completed_task(*, subscribe: bool) -> str: + conn = kb.connect() + try: + tid = kb.create_task(conn, title="owner gate", assignee="worker") + if subscribe: + kb.add_notify_sub(conn, task_id=tid, platform="telegram", chat_id="chat-1") + kb.complete_task(conn, tid, summary="done") + return tid + finally: + conn.close() + + +def test_zero_sub_board_is_never_opened_writable(tmp_path, monkeypatch): + """A board with zero subscriptions must be skipped BEFORE `_kb.connect`.""" + db_path = tmp_path / "zero-subs.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + _create_completed_task(subscribe=False) + + adapter = RecordingAdapter() + runner = _make_runner(adapter) + + with patch.object(kb, "connect", wraps=kb.connect) as spy_connect: + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + spy_connect.assert_not_called() + assert adapter.sent == [] + + +def test_subscribed_board_still_delivers_through_the_gate(tmp_path, monkeypatch): + """Regression: the zero-sub probe must not change delivery for live subs.""" + db_path = tmp_path / "subscribed.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + tid = _create_completed_task(subscribe=True) + + adapter = RecordingAdapter() + runner = _make_runner(adapter) + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + assert len(adapter.sent) == 1 + assert tid in adapter.sent[0]["text"] + + +def test_probe_failure_falls_back_to_writable_open(tmp_path, monkeypatch): + """If the read-only probe raises (locked/corrupt DB), the notifier must + fall back to the writable open — a broken probe must never silently + disable notifications for a board with live subscriptions.""" + db_path = tmp_path / "probe-broken.db" + monkeypatch.setenv("HERMES_KANBAN_DB", str(db_path)) + kb.init_db() + tid = _create_completed_task(subscribe=True) + + def _boom(*args, **kwargs): + raise RuntimeError("probe exploded") + + monkeypatch.setattr(kb, "count_notify_subs", _boom) + + adapter = RecordingAdapter() + runner = _make_runner(adapter) + asyncio.run(_run_one_notifier_tick(monkeypatch, runner)) + + assert len(adapter.sent) == 1 + assert tid in adapter.sent[0]["text"] diff --git a/tests/gateway/test_media_spaced_paths_and_history_dedupe.py b/tests/gateway/test_media_spaced_paths_and_history_dedupe.py new file mode 100644 index 0000000000..9e23273c40 --- /dev/null +++ b/tests/gateway/test_media_spaced_paths_and_history_dedupe.py @@ -0,0 +1,128 @@ +"""Regression tests: spaced paths, GIS extensions, cross-turn dedupe plumbing, +and code-block-safe streaming display strip. + +Covers the follow-up wave after PR #72170: + +* #24032 — GIS extensions (.kmz/.kml/.geojson/.gpx) are deliverable, and + unknown-extension paths containing spaces extract via the + validation-gated progressive right-trim (``_spaced_path_candidates``). +* #16434 half — ``strip_media_directives_for_display`` (streaming path) no + longer strips MEDIA tags out of fenced code blocks / inline-code examples; + protected spans are a mask-locator, matching ``extract_media``. +* #53586 — ``_collect_history_media_paths`` also collects tags from + assistant messages, and the post-stream delivery path filters against it. +""" + +import os + +import pytest + +from gateway.platforms.base import ( + BasePlatformAdapter, + MEDIA_DELIVERY_EXTS, +) +from gateway.run import _collect_history_media_paths + + +class TestGisExtensions: + def test_gis_extensions_in_delivery_set(self): + for ext in (".kmz", ".kml", ".geojson", ".gpx"): + assert ext in MEDIA_DELIVERY_EXTS + + def test_geojson_extracts(self, tmp_path): + p = tmp_path / "route.geojson" + p.write_text("{}") + media, cleaned = BasePlatformAdapter.extract_media(f"MEDIA:{p}") + assert [x for x, _ in media] == [str(p)] + assert "MEDIA:" not in cleaned + + +class TestSpacedPaths: + def test_spaced_known_ext_extracts(self, tmp_path): + p = tmp_path / "map data.kmz" + p.write_bytes(b"PK") + media, _ = BasePlatformAdapter.extract_media(f"MEDIA:{p}") + assert [x for x, _ in media] == [str(p)] + + def test_spaced_unknown_ext_extracts_when_file_exists(self, tmp_path): + p = tmp_path / "my server.log" + p.write_text("log line\n") + media, cleaned = BasePlatformAdapter.extract_media(f"MEDIA:{p}") + assert [os.path.realpath(x) for x, _ in media] == [os.path.realpath(str(p))] + assert "MEDIA:" not in cleaned + + def test_spaced_path_followed_by_prose_keeps_prose(self, tmp_path): + p = tmp_path / "my server.log" + p.write_text("log line\n") + media, cleaned = BasePlatformAdapter.extract_media( + f"MEDIA:{p} is the log you asked for" + ) + assert [os.path.realpath(x) for x, _ in media] == [os.path.realpath(str(p))] + assert "is the log you asked for" in cleaned + + def test_spaced_nonexistent_stays_visible(self): + text = "MEDIA:/data/not real file.xyz here" + media, cleaned = BasePlatformAdapter.extract_media(text) + assert media == [] + assert "MEDIA:/data/not real file.xyz" in cleaned + + def test_forward_extension_stops_at_next_media_tag(self, tmp_path): + a = tmp_path / "Caddyfile" + b = tmp_path / "Dockerfile" + a.write_text("localhost\n") + b.write_text("FROM alpine\n") + media, cleaned = BasePlatformAdapter.extract_media( + f"MEDIA:{a} MEDIA:{b}" + ) + got = sorted(os.path.realpath(x) for x, _ in media) + assert got == sorted( + [os.path.realpath(str(a)), os.path.realpath(str(b))] + ) + assert "MEDIA:" not in cleaned + + +class TestStreamingDisplayStripCodeBlocks: + def test_fenced_code_example_preserved(self, tmp_path): + p = tmp_path / "real.pdf" + p.write_text("x") + text = f"Example:\n```\nMEDIA:{p}\n```\ndone MEDIA:{p}" + out = BasePlatformAdapter.strip_media_directives_for_display(text) + # The example inside the fence survives verbatim; the real tag outside + # is stripped. + assert f"MEDIA:{p}" in out + assert out.count(f"MEDIA:{p}") == 1 + assert "```" in out + + def test_inline_code_example_preserved(self): + text = "Use `MEDIA:/nonexistent/example.csv` to attach files." + out = BasePlatformAdapter.strip_media_directives_for_display(text) + assert "`MEDIA:/nonexistent/example.csv`" in out + + def test_plain_tag_still_stripped(self, tmp_path): + p = tmp_path / "real.csv" + p.write_text("x") + out = BasePlatformAdapter.strip_media_directives_for_display( + f"Here you go MEDIA:{p}" + ) + assert "MEDIA:" not in out + + +class TestHistoryMediaDedupe: + def test_assistant_message_tags_collected(self): + history = [ + {"role": "user", "content": "make a chart"}, + {"role": "assistant", "content": "Done! MEDIA:/tmp/chart.png"}, + {"role": "user", "content": "thanks"}, + ] + paths = _collect_history_media_paths(history) + assert "/tmp/chart.png" in paths + + def test_tool_message_tags_still_collected(self): + history = [ + {"role": "tool", "content": "MEDIA:/tmp/out.pdf"}, + ] + paths = _collect_history_media_paths(history) + assert "/tmp/out.pdf" in paths + + def test_empty_history_empty_set(self): + assert _collect_history_media_paths([]) == set() diff --git a/tests/gateway/test_media_tag_cleanup.py b/tests/gateway/test_media_tag_cleanup.py new file mode 100644 index 0000000000..2bf77845c2 --- /dev/null +++ b/tests/gateway/test_media_tag_cleanup.py @@ -0,0 +1,61 @@ +"""Tests for MEDIA_TAG_CLEANUP_RE regex matching behavior (#63632).""" + + +class TestMediaTagCleanup: + """Tests for MEDIA_TAG_CLEANUP_RE regex matching behavior.""" + + def test_media_tag_with_directive_glued_to_extension(self): + """Regression: MEDIA:[[as_document]] must match when directive is glued + directly to the extension without whitespace (#63632). + + The fix adds `\\[` to the lookahead character class in MEDIA_TAG_CLEANUP_RE. + """ + from gateway.platforms.base import MEDIA_TAG_CLEANUP_RE + + # Issue case: [[as_document]] glued directly to .xlsx + text = "Готово. MEDIA:/home/hermes/report.xlsx[[as_document]]" + assert MEDIA_TAG_CLEANUP_RE.search(text) is not None + stripped = MEDIA_TAG_CLEANUP_RE.sub("", text) + assert "MEDIA:" not in stripped + assert "/home/hermes/report.xlsx" not in stripped + + # Same with whitespace (should still work) + text_with_space = "Готово. MEDIA:/home/hermes/report.xlsx [[as_document]]" + assert MEDIA_TAG_CLEANUP_RE.search(text_with_space) is not None + stripped = MEDIA_TAG_CLEANUP_RE.sub("", text_with_space) + assert "MEDIA:" not in stripped + assert "/home/hermes/report.xlsx" not in stripped + + # Other directives ([[as_image]]) should also work + text_image = "Done. MEDIA:/tmp/chart.png[[as_image]]" + assert MEDIA_TAG_CLEANUP_RE.search(text_image) is not None + stripped = MEDIA_TAG_CLEANUP_RE.sub("", text_image) + assert "MEDIA:" not in stripped + assert "/tmp/chart.png" not in stripped + + def test_media_tag_with_whitespace_still_works(self): + """Baseline: MEDIA tags with whitespace before/after still match.""" + from gateway.platforms.base import MEDIA_TAG_CLEANUP_RE + + # Space before closing quote + text = "Here is your report: MEDIA:/tmp/report.md " + stripped = MEDIA_TAG_CLEANUP_RE.sub("", text).strip() + assert "MEDIA:" not in stripped + assert "/tmp/report.md" not in stripped + + # Multiple spaces (regex removes tag but preserves surrounding whitespace) + text = "Report at MEDIA:/tmp/data.pdf done" + stripped = MEDIA_TAG_CLEANUP_RE.sub("", text) + assert "MEDIA:" not in stripped + assert "/tmp/data.pdf" not in stripped + assert "Report at" in stripped and "done" in stripped + + def test_media_tag_at_end_of_string(self): + """MEDIA tags at the end of a string should match ($ anchor).""" + from gateway.platforms.base import MEDIA_TAG_CLEANUP_RE + + text = "Here is the file: MEDIA:/tmp/file.docx" + stripped = MEDIA_TAG_CLEANUP_RE.sub("", text).strip() + assert "MEDIA:" not in stripped + assert "/tmp/file.docx" not in stripped + assert "Here is the file:" in stripped diff --git a/tests/gateway/test_media_tag_formatting_variants.py b/tests/gateway/test_media_tag_formatting_variants.py new file mode 100644 index 0000000000..1e3ccecf97 --- /dev/null +++ b/tests/gateway/test_media_tag_formatting_variants.py @@ -0,0 +1,126 @@ +"""Regression tests: MEDIA tag formatting variants that previously broke delivery. + +Covers the two follow-up fixes layered on top of the salvaged contributor PRs: + +1. Sentence-final punctuation — ``MEDIA:/x/data.csv.`` at the end of a + sentence must extract ``data.csv`` (the trailing ``.`` is a boundary, not + part of the path), while multi-part extensions (``archive.tar.gz``) + remain intact. + +2. Inline-code-wrapped tags — a whole ``MEDIA:`` tag inside inline backticks + (`` `MEDIA:/path.csv` ``) is a real delivery directive when the path + validates on disk; prose examples with non-existent paths stay masked + (#35695), and fenced code blocks are always masked. +""" + +import os + +import pytest + +from gateway.platforms.base import BasePlatformAdapter + + +@pytest.fixture() +def real_file(tmp_path): + p = tmp_path / "data.csv" + p.write_text("x,y\n1,2\n") + return str(p) + + +@pytest.fixture() +def real_targz(tmp_path): + p = tmp_path / "archive.tar.gz" + p.write_bytes(b"\x1f\x8b") + return str(p) + + +class TestTrailingPunctuation: + def test_sentence_final_period_extracts_path(self, real_file): + media, cleaned = BasePlatformAdapter.extract_media( + f"Saved your data. MEDIA:{real_file}." + ) + assert [p for p, _ in media] == [real_file] + assert "MEDIA:" not in cleaned + + def test_period_then_more_prose(self, real_file): + media, cleaned = BasePlatformAdapter.extract_media( + f"Done: MEDIA:{real_file}. Enjoy!" + ) + assert [p for p, _ in media] == [real_file] + assert "Enjoy!" in cleaned + + def test_multipart_extension_not_truncated(self, real_targz): + media, _ = BasePlatformAdapter.extract_media(f"MEDIA:{real_targz}") + assert [p for p, _ in media] == [real_targz] + + def test_multipart_extension_with_trailing_period(self, real_targz): + media, _ = BasePlatformAdapter.extract_media(f"MEDIA:{real_targz}.") + assert [p for p, _ in media] == [real_targz] + + +class TestInlineCodeWrappedTags: + def test_real_path_in_inline_code_delivers(self, real_file): + media, cleaned = BasePlatformAdapter.extract_media( + f"Here is your file `MEDIA:{real_file}`" + ) + assert [p for p, _ in media] == [real_file] + assert "MEDIA:" not in cleaned + + def test_nonexistent_path_in_inline_code_stays_masked(self): + text = "Use the format `MEDIA:/nonexistent/example.csv` to attach files." + media, cleaned = BasePlatformAdapter.extract_media(text) + assert media == [] + assert "`MEDIA:/nonexistent/example.csv`" in cleaned + + def test_fenced_code_block_always_masked(self, real_file): + text = f"```\nMEDIA:{real_file}\n```" + media, cleaned = BasePlatformAdapter.extract_media(text) + assert media == [] + assert real_file in cleaned + + def test_inline_code_non_media_untouched(self, real_file): + text = f"Run `ls -la` then see MEDIA:{real_file}" + media, cleaned = BasePlatformAdapter.extract_media(text) + assert [p for p, _ in media] == [real_file] + assert "`ls -la`" in cleaned + + +class TestEmphasisAndDedupeIntegration: + """End-to-end matrix over the salvaged contributor fixes.""" + + def test_bold_wrapped_tag_delivers(self, real_file): + media, cleaned = BasePlatformAdapter.extract_media(f"**MEDIA:{real_file}**") + assert [p for p, _ in media] == [real_file] + assert "MEDIA:" not in cleaned + + def test_two_tags_one_line_both_deliver(self, tmp_path): + a = tmp_path / "a.csv" + b = tmp_path / "b.csv" + a.write_text("1") + b.write_text("2") + media, _ = BasePlatformAdapter.extract_media(f"MEDIA:{a} MEDIA:{b}") + assert [p for p, _ in media] == [str(a), str(b)] + + def test_duplicate_tags_deliver_once(self, real_file): + media, _ = BasePlatformAdapter.extract_media( + f"MEDIA:{real_file} and again MEDIA:{real_file}" + ) + assert [p for p, _ in media] == [real_file] + + def test_glued_as_document_delivers(self, real_file): + media, _ = BasePlatformAdapter.extract_media( + f"MEDIA:{real_file}[[as_document]]" + ) + assert [p for p, _ in media] == [real_file] + + def test_unknown_extension_real_file_delivers(self, tmp_path): + p = tmp_path / "script.py" + p.write_text("print('hi')\n") + media, _ = BasePlatformAdapter.extract_media(f"MEDIA:{p}") + assert [os.path.realpath(x) for x, _ in media] == [os.path.realpath(str(p))] + + def test_extensionless_real_file_delivers(self, tmp_path): + p = tmp_path / "Caddyfile" + p.write_text("localhost\n") + media, _ = BasePlatformAdapter.extract_media(f"MEDIA:{p}") + assert [os.path.realpath(x) for x, _ in media] == [os.path.realpath(str(p))] diff --git a/tests/gateway/test_media_tag_separator.py b/tests/gateway/test_media_tag_separator.py new file mode 100644 index 0000000000..c96a893cf6 --- /dev/null +++ b/tests/gateway/test_media_tag_separator.py @@ -0,0 +1,115 @@ +"""Regression tests for #68773 — MEDIA tags without a separator merge paths. + +Before the fix, ``MEDIA_EXTENSIONLESS_TAG_RE`` used a greedy character class +``[^\s\n`\"']+`` that would silently absorb the next ``MEDIA:`` keyword when +two tags were emitted back-to-back (``MEDIA:/a.pngMEDIA:/b.png``), producing +an invalid merged path that was then rejected by +``validate_media_delivery_path`` and dropped silently. + +The same pattern also failed for ``MEDIA:/path/file.pngSome text`` — the +fallback would treat the trailing text as part of the path. +""" + +from gateway.platforms.base import ( + MEDIA_EXTENSIONLESS_TAG_RE, + MEDIA_TAG_CLEANUP_RE, + _strip_media_tag_directives, +) + + +def test_extensionless_regex_does_not_absorb_next_media_keyword(): + """Two extensionless tags glued together must each match independently.""" + text = "MEDIA:/tmp/CaddyfileMEDIA:/tmp/Dockerfile" + matches = list(MEDIA_EXTENSIONLESS_TAG_RE.finditer(text)) + paths = [m.group("path") for m in matches] + assert paths == ["/tmp/Caddyfile", "/tmp/Dockerfile"], paths + + +def test_extensionless_regex_does_not_absorb_following_text(): + """An extensionless tag glued to text containing `MEDIA:` must stop at the next tag. + + The known-extension case is covered separately by + ``test_strip_media_directives_does_not_drop_known_ext_tag_followed_by_text`` + — there the primary regex's separator requirement leaves the text visible. + + For the fallback regex, the realistic threat is a *second* ``MEDIA:`` tag + glued to the first path; this test pins that behavior. + """ + text = "MEDIA:/tmp/CaddyfileMEDIA:/tmp/Dockerfile and text" + match = MEDIA_EXTENSIONLESS_TAG_RE.search(text) + assert match is not None + assert match.group("path") == "/tmp/Caddyfile" + + +def test_extensionless_regex_still_matches_normal_cases(): + """The fix must not regress the well-formed extensionless paths.""" + text = "see MEDIA:/tmp/Caddyfile for details" + match = MEDIA_EXTENSIONLESS_TAG_RE.search(text) + assert match is not None + assert match.group("path") == "/tmp/Caddyfile" + + +def test_known_extension_regex_splits_glued_tags(): + """``MEDIA_TAG_CLEANUP_RE`` must stop at the next ``MEDIA:`` keyword (#68773). + + Previously the primary regex used greedy ``\S+`` in the path class, + so two tags glued together (``MEDIA:/a.pngMEDIA:/b.png``) merged into + one invalid path (``/a.pngMEDIA:/b.png``) and were silently dropped by + ``validate_media_delivery_path``. The fix uses non-greedy quantifiers + and accepts ``MEDIA:`` in the trailing lookahead. + """ + text = "MEDIA:/tmp/file.pngMEDIA:/tmp/file2.png" + matches = list(MEDIA_TAG_CLEANUP_RE.finditer(text)) + paths = [m.group("path") for m in matches] + assert paths == ["/tmp/file.png", "/tmp/file2.png"], paths + + +def test_strip_media_directives_handles_glued_known_extension_tags(tmp_path): + """Two known-extension tags glued together must each be delivered (#68773).""" + png1 = tmp_path / "a.png" + png1.write_bytes(b"\x89PNG\r\n\x1a\n") + png2 = tmp_path / "b.png" + png2.write_bytes(b"\x89PNG\r\n\x1a\n") + + text = f"MEDIA:{png1}MEDIA:{png2}" + cleaned = _strip_media_tag_directives(text) + # Both MEDIA: tokens consumed; the leading MEDIA: prefix is gone. + assert "MEDIA:" not in cleaned, f"Greedy merge leaked: {cleaned!r}" + + +def test_strip_media_directives_handles_glued_extensionless_tags(tmp_path): + """``_strip_media_tag_directives`` must not produce a merged invalid path. + + With two real files glued together, ``validate_media_delivery_path`` + accepts the first valid path and skips the second because the merged + string is not a real file. After the fix, the second tag should be + matched independently and also accepted. + """ + caddy = tmp_path / "Caddyfile" + caddy.write_text("example.com") + dockerfile = tmp_path / "Dockerfile" + dockerfile.write_text("FROM scratch") + + text = f"MEDIA:{caddy}MEDIA:{dockerfile}" + cleaned = _strip_media_tag_directives(text) + # Both tags stripped; no leftover MEDIA: token from greedy merge. + assert "MEDIA:" not in cleaned, f"Greedy merge leaked: {cleaned!r}" + + +def test_strip_media_directives_does_not_drop_known_ext_tag_followed_by_text(tmp_path): + """A known-extension tag glued to text must leave the text visible. + + The primary regex requires a separator after the extension, so + ``MEDIA:/file.pngSome text`` does not match. After the fallback runs, + ``_path_lacks_deliverable_extension`` sees ``.pngSome`` as a non-known + extension and the strip function returns ``match.group(0)`` unchanged — + so the original text stays visible (no silent drop, no merged invalid + path). + """ + png = tmp_path / "real.png" + png.write_bytes(b"\x89PNG\r\n\x1a\n") + + text = f"MEDIA:{png}Some text" + cleaned = _strip_media_tag_directives(text) + # The full original is preserved — no silent truncation of the file or text. + assert cleaned == text diff --git a/tests/gateway/test_multiplex_profile_authz.py b/tests/gateway/test_multiplex_profile_authz.py index 0620b14e0c..055e6993e6 100644 --- a/tests/gateway/test_multiplex_profile_authz.py +++ b/tests/gateway/test_multiplex_profile_authz.py @@ -101,6 +101,14 @@ def test_secondary_allowlist_still_authorized(monkeypatch): assert runner._is_user_authorized(source) is True +def test_active_profile_stamp_resolves_primary_adapter(monkeypatch): + """A single-profile gateway stamps its active profile but stores adapters as primary.""" + runner, default_adapter, _secondary_adapter = _make_multiplex_runner(monkeypatch) + runner._active_profile_name = lambda: "dev" + + assert runner._authorization_adapter(Platform.WECOM, profile="dev") is default_adapter + + def test_adapter_for_source_resolves_secondary_profile_adapter(monkeypatch): """Ingress adapter lookup must use the stamped profile's adapter map.""" runner, default_adapter, secondary_adapter = _make_multiplex_runner(monkeypatch) @@ -201,6 +209,15 @@ def test_adapter_for_direct_source_keeps_native_platform_adapter(monkeypatch): assert runner._adapter_for_source(source) is slack_adapter +def test_explicit_active_profile_stamp_uses_default_adapter_map(monkeypatch): + """A named active profile is not misclassified as multiplex secondary.""" + runner, default_adapter, _secondary_adapter = _make_multiplex_runner(monkeypatch) + runner._active_profile_name = lambda: "main" + + assert runner._authorization_adapter(Platform.WECOM, profile="main") is default_adapter + + + def test_secondary_allowlist_dm_behavior_ignores_unauthorized(monkeypatch): """Unauthorized-DM behavior must read the secondary adapter's dm_policy.""" runner, _default_adapter, secondary_adapter = _make_multiplex_runner(monkeypatch) diff --git a/tests/gateway/test_platform_base.py b/tests/gateway/test_platform_base.py index 0f1d5c9901..786a8f69c5 100644 --- a/tests/gateway/test_platform_base.py +++ b/tests/gateway/test_platform_base.py @@ -401,6 +401,31 @@ class TestExtractMedia: assert media == [("/tmp/Jane Doe/speech.flac", False)] assert cleaned == "" + def test_duplicate_media_tags_are_deduplicated(self): + content = "MEDIA:/tmp/test.png\nMEDIA:/tmp/test.png\nMEDIA:/tmp/other.png" + media, cleaned = BasePlatformAdapter.extract_media(content) + assert media == [ + ("/tmp/test.png", False), + ("/tmp/other.png", False), + ] + assert cleaned == "" + + def test_duplicate_media_tags_dedup_preserves_first_occurrence_order(self): + content = "MEDIA:/tmp/a.png\nMEDIA:/tmp/b.png\nMEDIA:/tmp/a.png\nMEDIA:/tmp/c.png" + media, _ = BasePlatformAdapter.extract_media(content) + assert media == [ + ("/tmp/a.png", False), + ("/tmp/b.png", False), + ("/tmp/c.png", False), + ] + + def test_dedup_uses_expanded_path_so_tilde_and_absolute_collapse(self): + import os + home = os.path.expanduser("~") + content = f"MEDIA:~/foo.png\nMEDIA:{home}/foo.png" + media, _ = BasePlatformAdapter.extract_media(content) + assert media == [(f"{home}/foo.png", False)] + def test_as_document_directive_stripped_from_cleaned_text(self): """[[as_document]] is a routing directive — strip it from user-visible text just like [[audio_as_voice]]. Callers detect the @@ -529,6 +554,51 @@ class TestExtractMedia: assert [p for p, _ in media] == ["/r/a.png"] assert "`MEDIA:/ex/b.png`" in cleaned + # --- Markdown emphasis wrapping tolerance --- + # Models routinely present a file as **MEDIA:/path** / *MEDIA:/path* / + # _MEDIA:/path_. The old pattern only tolerated a single quote/backtick, so + # the emphasis prevented the match and the file was silently never + # delivered (the literal MEDIA: text leaked into the chat instead). + + def test_media_bold_wrapped_extracted(self): + media, cleaned = BasePlatformAdapter.extract_media( + "**MEDIA:/home/u/report.pptx**" + ) + assert media == [("/home/u/report.pptx", False)] + assert "MEDIA:" not in cleaned + + def test_media_italic_asterisk_extracted(self): + media, _ = BasePlatformAdapter.extract_media("*MEDIA:/home/u/report.pdf*") + assert media == [("/home/u/report.pdf", False)] + + def test_media_italic_underscore_extracted(self): + media, _ = BasePlatformAdapter.extract_media("_MEDIA:/home/u/report.pdf_") + assert media == [("/home/u/report.pdf", False)] + + def test_media_bold_mid_prose_extracted_and_stripped(self): + media, cleaned = BasePlatformAdapter.extract_media( + "Voici votre fichier **MEDIA:/tmp/r.pdf** bonne lecture" + ) + assert media == [("/tmp/r.pdf", False)] + assert "MEDIA:" not in cleaned + assert "bonne lecture" in cleaned + + def test_media_bold_wrapped_html_extracted(self): + # .html is a recognised extension; emphasis was the only blocker. + media, _ = BasePlatformAdapter.extract_media("**MEDIA:/srv/page.html**") + assert media == [("/srv/page.html", False)] + + def test_media_underscore_in_filename_unaffected(self): + # Emphasis tolerance must not eat a legitimate '_' inside the path. + media, _ = BasePlatformAdapter.extract_media("MEDIA:/tmp/my_report_v2.pptx") + assert media == [("/tmp/my_report_v2.pptx", False)] + + def test_media_bold_relative_path_still_ignored(self): + # The absolute-path anchor must still reject relative paths even when + # wrapped in emphasis. + media, _ = BasePlatformAdapter.extract_media("**MEDIA:report.html**") + assert media == [] + class TestMediaInsideSerializedJson: """Regression coverage for #34375 — MEDIA: embedded in serialized JSON diff --git a/tests/gateway/test_platform_reconnect.py b/tests/gateway/test_platform_reconnect.py index 7f526e70bf..15d754727e 100644 --- a/tests/gateway/test_platform_reconnect.py +++ b/tests/gateway/test_platform_reconnect.py @@ -1126,7 +1126,224 @@ class TestEnsureReconnectWatcherRunning: # ── _handle_adapter_fatal_error calls _ensure_reconnect_watcher ──────── -class TestFatalErrorCallsEnsureWatcher: +class TestReconnectWatcherSelfHeals: + """Regression tests for issue #71758: a platform already queued in + _failed_platforms when the reconnect watcher task dies from an + uncaught exception stayed stranded forever, because + _ensure_reconnect_watcher_running() is only called from a NEW + fatal-error arrival -- if no other platform ever fails afterward, + nothing notices the watcher is dead. The watcher must now be spawned + via _spawn_supervised (like other long-lived background tasks), so an + exception escaping its OUTER while-loop is caught, logged, and + auto-restarted with backoff -- independent of any new fatal-error + event. + """ + + @pytest.mark.asyncio + async def test_startup_spawns_watcher_via_spawn_supervised(self, monkeypatch): + """The initial watcher spawn at gateway startup must go through + _spawn_supervised, not a bare asyncio.create_task.""" + runner = _make_runner() + runner._background_tasks = set() + calls = [] + + def fake_spawn_supervised(coro_factory, name, **kw): + calls.append(name) + task = asyncio.create_task(coro_factory()) + runner._background_tasks.add(task) + return task + + async def _noop_watcher(): + await asyncio.sleep(3600) + + monkeypatch.setattr(runner, "_spawn_supervised", fake_spawn_supervised) + monkeypatch.setattr(runner, "_platform_reconnect_watcher", _noop_watcher) + + # Mirror the startup snippet: spawn via _spawn_supervised. + runner._reconnect_watcher_task = runner._spawn_supervised( + runner._platform_reconnect_watcher, "platform_reconnect_watcher" + ) + + assert "platform_reconnect_watcher" in calls + runner._reconnect_watcher_task.cancel() + try: + await runner._reconnect_watcher_task + except asyncio.CancelledError: + pass + + @pytest.mark.asyncio + async def test_ensure_reconnect_watcher_running_uses_spawn_supervised(self): + """The manual-respawn path in _ensure_reconnect_watcher_running must + also use _spawn_supervised, so a respawned watcher gets the same + auto-restart protection going forward.""" + runner = _make_runner() + runner._running = True + runner._background_tasks = set() + runner._reconnect_watcher_task = asyncio.create_task(asyncio.sleep(0)) + await runner._reconnect_watcher_task # let it finish (dead) + + spawn_calls = [] + original_spawn = runner._spawn_supervised + + def spy_spawn_supervised(coro_factory, name, **kw): + spawn_calls.append(name) + return original_spawn(coro_factory, name, **kw) + + runner._spawn_supervised = spy_spawn_supervised + runner._ensure_reconnect_watcher_running() + + assert spawn_calls == ["platform_reconnect_watcher"] + runner._reconnect_watcher_task.cancel() + try: + await runner._reconnect_watcher_task + except asyncio.CancelledError: + pass + + @pytest.mark.asyncio + async def test_watcher_self_heals_after_uncaught_exception_with_no_new_fatal_error(self): + """The core #71758 regression: a platform sits queued in + _failed_platforms. The watcher task dies from an uncaught + exception (simulating the KeyError race / any other bug in the + outer loop). WITHOUT any new fatal-error event for a different + platform, the watcher must still come back on its own via + _spawn_supervised's crash-detection callback -- the exact gap + that stranded the platform for 17.5h in the reported bug. + """ + runner = _make_runner() + runner._running = True + runner._background_tasks = set() + runner._SUPERVISED_HEALTHY_SECS = GatewayRunner._SUPERVISED_HEALTHY_SECS + runner._MAX_SUPERVISED_RESTARTS = GatewayRunner._MAX_SUPERVISED_RESTARTS + runner._spawn_supervised = GatewayRunner._spawn_supervised.__get__(runner) + + attempt_count = {"n": 0} + + async def _flaky_watcher(): + attempt_count["n"] += 1 + if attempt_count["n"] == 1: + # Simulate the watcher's outer loop raising -- e.g. the + # KeyError race this same fix also hardens against, or any + # other bug in code outside the per-platform try/except. + raise RuntimeError("simulated watcher crash") + await asyncio.sleep(3600) # second run: stays "alive" + + runner._reconnect_watcher_task = runner._spawn_supervised( + _flaky_watcher, "platform_reconnect_watcher" + ) + + # Let the first (crashing) attempt run and die. + for _ in range(50): + await asyncio.sleep(0) + if attempt_count["n"] >= 1 and runner._reconnect_watcher_task.done(): + break + + assert attempt_count["n"] == 1 + assert runner._reconnect_watcher_task.done() + + # The supervised _done callback schedules a respawn after a short + # backoff (2**0 = 1s at attempt 0) -- wait for it without a new + # fatal-error event ever firing. + for _ in range(30): + await asyncio.sleep(0.1) + if attempt_count["n"] >= 2: + break + + assert attempt_count["n"] >= 2, ( + "Watcher must self-heal via _spawn_supervised without any new " + "fatal-error event -- this is the exact gap that stranded a " + "platform in the reported bug" + ) + + # Cleanup: cancel whatever task is currently tracked. + for task in list(runner._background_tasks): + task.cancel() + await asyncio.sleep(0) + + +class TestReconnectWatcherRaceGuard: + """Regression: a platform removed from _failed_platforms concurrently + (e.g. a manual /platform resume racing with the watcher's own + snapshot-then-lookup) must not raise KeyError and kill the loop + iteration -- it should just be skipped for that pass.""" + + @pytest.mark.asyncio + async def test_watcher_survives_platform_removed_mid_pass(self, monkeypatch): + """Two platforms are due for retry. Reconnecting the first one, as + a side effect, removes the second from _failed_platforms (stand-in + for any concurrent path -- a manual /platform resume, a reconnect + that succeeded elsewhere, etc.). The watcher must finish its pass + without raising, and must still be alive afterward.""" + runner = _make_runner() + runner._running = True + runner._background_tasks = set() + runner.session_store = MagicMock() + runner._busy_text_mode = "interrupt" + + cfg = PlatformConfig(enabled=True, token="test") + runner._failed_platforms = { + Platform.TELEGRAM: {"config": cfg, "attempts": 0, "next_retry": 0.0}, + Platform.DISCORD: {"config": cfg, "attempts": 0, "next_retry": 0.0}, + } + runner._platform_connect_timeout_secs = MagicMock(return_value=5) + runner._sync_voice_mode_state_to_adapter = MagicMock() + runner._schedule_resume_pending_sessions = MagicMock() + runner._make_adapter_auth_check = MagicMock(return_value=lambda *a, **kw: True) + runner._recover_telegram_topic_thread_id = MagicMock() + runner._handle_message = MagicMock() + runner._handle_active_session_busy_message = MagicMock() + runner._handle_reaction_event = MagicMock() + runner._update_platform_runtime_status = MagicMock() + + def fake_create_adapter(platform, platform_config): + adapter = MagicMock() + adapter.platform = platform + adapter.has_fatal_error = False + adapter.set_message_handler = MagicMock() + adapter.set_fatal_error_handler = MagicMock() + adapter.set_session_store = MagicMock() + adapter.set_busy_session_handler = MagicMock() + adapter.set_reaction_handler = MagicMock() + adapter.set_topic_recovery_fn = MagicMock() + adapter.set_authorization_check = MagicMock() + if platform == Platform.TELEGRAM: + # Side effect: concurrently "resolves" Discord's entry via + # some other path (e.g. a manual /platform resume), racing + # with the watcher's own snapshot-then-lookup for it. + runner._failed_platforms.pop(Platform.DISCORD, None) + return adapter + + runner._create_adapter = MagicMock(side_effect=fake_create_adapter) + + async def fake_connect(adapter, platform, is_reconnect=False): + return True + + runner._connect_adapter_with_timeout = fake_connect + + async def _one_pass(): + now = time.monotonic() + for platform in list(runner._failed_platforms.keys()): + info = runner._failed_platforms.get(platform) + if info is None: + continue + if now < info["next_retry"]: + continue + adapter = runner._create_adapter(platform, info["config"]) + success = await runner._connect_adapter_with_timeout( + adapter, platform, is_reconnect=True + ) + if success: + runner.adapters[platform] = adapter + runner._failed_platforms.pop(platform, None) + + # Must not raise, even though Discord vanishes from the dict as a + # side effect of processing Telegram. + await _one_pass() + + assert Platform.TELEGRAM in runner.adapters + assert Platform.DISCORD not in runner._failed_platforms + + + """Verify _handle_adapter_fatal_error calls _ensure_reconnect_watcher_running.""" @pytest.mark.asyncio @@ -1260,3 +1477,108 @@ class TestConnectAdapterDetachOnTimeout: ) assert result is True + + +class TestReconnectWatcherHandleTracking: + """Regression: the supervisor's own backoff respawn must keep + ``_reconnect_watcher_task`` pointed at the CURRENT live task. + + Before the ``on_spawn`` fix, ``_spawn_supervised``'s internal respawn + created a new task without updating ``self._reconnect_watcher_task``, so + after the reconnect watcher crashed and self-respawned, the tracked handle + still pointed at the DEAD task. A later + ``_ensure_reconnect_watcher_running()`` then saw ``task.done()`` and + spawned a SECOND concurrent watcher — double reconnect attempts against + every failed platform. The two supervision mechanisms (auto-restart + + ensure-respawn) must compose, not race. + """ + + @pytest.mark.asyncio + async def test_startup_spawn_tracks_live_handle(self): + """The startup spawn passes an on_spawn callback so the handle is + recorded at spawn time (not left None until the lambda in prod).""" + runner = _make_runner() + runner._background_tasks = set() + + async def _noop_watcher(): + await asyncio.sleep(3600) + + # Mirror the production startup call: on_spawn records the handle. + runner._reconnect_watcher_task = None + task = runner._spawn_supervised( + _noop_watcher, + "platform_reconnect_watcher", + on_spawn=lambda t: setattr(runner, "_reconnect_watcher_task", t), + ) + # on_spawn fired synchronously at spawn time. + assert runner._reconnect_watcher_task is task + task.cancel() + try: + await task + except asyncio.CancelledError: + pass + + @pytest.mark.asyncio + async def test_supervised_respawn_refreshes_tracked_handle(self): + """When the supervised watcher crashes and the supervisor respawns it, + _reconnect_watcher_task must advance to the NEW task, not stay pinned to + the dead one. This is the exact condition _ensure_reconnect_watcher_running + checks (task.done()) before deciding to spawn a duplicate.""" + runner = _make_runner() + runner._running = True + runner._background_tasks = set() + # Fast, deterministic backoff. + runner._MAX_SUPERVISED_RESTARTS = 5 + runner._SUPERVISED_HEALTHY_SECS = 300 + + crashed_once = {"done": False} + + async def _crash_then_live(): + if not crashed_once["done"]: + crashed_once["done"] = True + raise RuntimeError("boom in outer loop") + await asyncio.sleep(3600) + + runner._reconnect_watcher_task = None + first = runner._spawn_supervised( + _crash_then_live, + "platform_reconnect_watcher", + on_spawn=lambda t: setattr(runner, "_reconnect_watcher_task", t), + ) + assert runner._reconnect_watcher_task is first + + # Let the first task crash and the supervisor's backoff (2**0 = 1s here, + # but _attempt=0 -> min(60, 1)=1) schedule + run the respawn. + with patch("asyncio.sleep", new=_instant_sleep): + # Give the event loop turns for the _done callback + _respawn task. + for _ in range(20): + await asyncio.sleep(0) + if runner._reconnect_watcher_task is not first: + break + + # The handle must now point at the respawned (live) task, NOT the dead one. + assert runner._reconnect_watcher_task is not first + assert not runner._reconnect_watcher_task.done() + + # And _ensure_reconnect_watcher_running must therefore be a no-op — it + # must NOT spawn a duplicate, because the tracked handle is alive. + spawned = [] + original = runner._spawn_supervised + runner._spawn_supervised = lambda *a, **k: spawned.append(a) or original(*a, **k) + runner._ensure_reconnect_watcher_running() + assert spawned == [], "ensure spawned a duplicate watcher despite a live handle" + + runner._reconnect_watcher_task.cancel() + try: + await runner._reconnect_watcher_task + except asyncio.CancelledError: + pass + + +async def _instant_sleep(delay, *a, **k): + """asyncio.sleep replacement that yields to the loop but never waits.""" + await _REAL_ASYNCIO_SLEEP(0) + return None + + +_REAL_ASYNCIO_SLEEP = asyncio.sleep diff --git a/tests/gateway/test_response_filters.py b/tests/gateway/test_response_filters.py index c24b9725cb..a9f33662a0 100644 --- a/tests/gateway/test_response_filters.py +++ b/tests/gateway/test_response_filters.py @@ -1,4 +1,5 @@ from gateway.response_filters import ( + is_autonomous_silence_response, is_intentional_silence_agent_result, is_intentional_silence_response, ) @@ -25,3 +26,21 @@ def test_blank_and_prose_mentions_are_not_silence(): def test_failed_agent_result_never_counts_as_intentional_silence(): assert is_intentional_silence_agent_result({"failed": False}, "NO_REPLY") assert not is_intentional_silence_agent_result({"failed": True}, "NO_REPLY") + + +def test_autonomous_silence_accepts_marker_with_own_line_note(): + """The loose rule for cron/webhook lanes: marker + explanation suppresses.""" + assert is_autonomous_silence_response("[SILENT]") + assert is_autonomous_silence_response("[SILENT]\n\nNothing new this tick.") + assert is_autonomous_silence_response("2 deals filtered\n\n[SILENT]") + assert is_autonomous_silence_response("no_reply\nduplicate inbound, already handled") + assert is_autonomous_silence_response("[SILENT] No changes detected") + + +def test_autonomous_silence_still_delivers_mid_sentence_mentions(): + assert not is_autonomous_silence_response( + "I considered staying [SILENT] but this one moved money, so: refunded $240." + ) + assert not is_autonomous_silence_response("Silent retry succeeded; all good.") + assert not is_autonomous_silence_response("") + assert not is_autonomous_silence_response(None) diff --git a/tests/gateway/test_restart_resume_pending.py b/tests/gateway/test_restart_resume_pending.py index 6e05d2fe9a..4be587093f 100644 --- a/tests/gateway/test_restart_resume_pending.py +++ b/tests/gateway/test_restart_resume_pending.py @@ -1937,3 +1937,188 @@ async def test_auto_resume_runs_agent_exactly_once_through_full_path(): # No leaked sentinel and no orphaned queued event. assert session_key not in runner._running_agents assert session_key not in getattr(adapter, "_pending_messages", {}) + + +# --------------------------------------------------------------------------- +# Startup-restore inbound gate must be BOUNDED +# --------------------------------------------------------------------------- + + +@pytest.mark.asyncio +async def test_startup_restore_gate_releases_when_resume_turn_outlives_timeout( + monkeypatch, +): + """A single slow boot-resume turn must not hold the inbound gate shut. + + While ``_startup_restore_in_progress`` is set, every inbound message is + QUEUED instead of answered. The gate is opened by + ``_finish_startup_restore``, which waits on the synthetic boot + auto-resume turns. Without a bound, one pathologically long resumed + turn holds the gate — and therefore every channel's inbound queue — + for the entire duration of that turn. + """ + monkeypatch.setenv("HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT", "0.05") + + runner, adapter = make_restart_runner() + runner._startup_restore_in_progress = True + runner._startup_restore_queue = [] + runner._background_tasks = set() + + seen: list[str] = [] + never_finishes = asyncio.Event() + + async def slow_resume_turn() -> None: + await never_finishes.wait() + + async def fake_handle_message(event: MessageEvent) -> None: + seen.append(f"inbound:{event.text}") + + adapter.handle_message = fake_handle_message + + slow_task = asyncio.create_task(slow_resume_turn()) + runner._startup_restore_tasks = [slow_task] + + inbound = MessageEvent( + text="hello", + message_type=MessageType.TEXT, + source=make_restart_source(chat_id="restore-chat"), + ) + assert await runner._handle_message(inbound) is None + assert runner._startup_restore_queue == [inbound] + + # The gate must release on the bound even though the resume turn is + # still running. + await asyncio.wait_for(runner._finish_startup_restore(), timeout=5) + + assert seen == ["inbound:hello"], ( + "startup-restore gate never released: queued inbound was not drained " + "while a slow boot-resume turn was still running" + ) + assert runner._startup_restore_queue == [] + assert runner._startup_restore_in_progress is False + # The slow turn is NOT cancelled — it finishes in the background. + assert not slow_task.done() + + never_finishes.set() + await slow_task + + +@pytest.mark.asyncio +async def test_startup_restore_gate_still_waits_for_a_prompt_resume_turn( + monkeypatch, +): + """The bound must not truncate a normal-speed resume turn. + + Feature preservation: with the default (generous) timeout, a resume turn + that completes promptly is still fully awaited before the gate opens, so + the queued inbound lands behind a finished turn. + """ + monkeypatch.delenv("HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT", raising=False) + + runner, adapter = make_restart_runner() + runner._startup_restore_in_progress = True + runner._startup_restore_queue = [] + runner._background_tasks = set() + + seen: list[str] = [] + resume_done = asyncio.Event() + + async def resume_turn() -> None: + await resume_done.wait() + seen.append("resume-finished") + + async def fake_handle_message(event: MessageEvent) -> None: + seen.append(f"inbound:{event.text}") + + adapter.handle_message = fake_handle_message + + runner._startup_restore_tasks = [asyncio.create_task(resume_turn())] + + inbound = MessageEvent( + text="hello", + message_type=MessageType.TEXT, + source=make_restart_source(chat_id="restore-chat"), + ) + assert await runner._handle_message(inbound) is None + + finish_task = asyncio.create_task(runner._finish_startup_restore()) + for _ in range(5): + await asyncio.sleep(0) + assert seen == [], "gate opened before the resume turn finished" + + resume_done.set() + await finish_task + assert seen == ["resume-finished", "inbound:hello"] + + +@pytest.mark.asyncio +async def test_startup_restore_drain_timeout_zero_restores_unbounded_wait( + monkeypatch, +): + """A non-positive bound opts back into the historical wait-forever gate.""" + monkeypatch.setenv("HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT", "0") + + runner, adapter = make_restart_runner() + runner._startup_restore_in_progress = True + runner._startup_restore_queue = [] + runner._background_tasks = set() + + seen: list[str] = [] + resume_done = asyncio.Event() + + async def resume_turn() -> None: + await resume_done.wait() + + async def fake_handle_message(event: MessageEvent) -> None: + seen.append(f"inbound:{event.text}") + + adapter.handle_message = fake_handle_message + runner._startup_restore_tasks = [asyncio.create_task(resume_turn())] + + inbound = MessageEvent( + text="hello", + message_type=MessageType.TEXT, + source=make_restart_source(chat_id="restore-chat"), + ) + assert await runner._handle_message(inbound) is None + + finish_task = asyncio.create_task(runner._finish_startup_restore()) + await asyncio.sleep(0.15) + assert seen == [], "unbounded gate released early" + + resume_done.set() + await finish_task + assert seen == ["inbound:hello"] + + +def test_startup_restore_drain_timeout_reads_config_bridged_env(monkeypatch): + """The bound is a config.yaml knob bridged to an internal env var.""" + from gateway.run import ( + _STARTUP_RESTORE_DRAIN_TIMEOUT_SECS_DEFAULT, + _startup_restore_drain_timeout_secs, + ) + + monkeypatch.delenv("HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT", raising=False) + assert ( + _startup_restore_drain_timeout_secs() + == _STARTUP_RESTORE_DRAIN_TIMEOUT_SECS_DEFAULT + ) + + monkeypatch.setenv("HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT", "12.5") + assert _startup_restore_drain_timeout_secs() == 12.5 + + # A malformed value must fall back to the default, never raise. + monkeypatch.setenv("HERMES_STARTUP_RESTORE_DRAIN_TIMEOUT", "not-a-number") + assert ( + _startup_restore_drain_timeout_secs() + == _STARTUP_RESTORE_DRAIN_TIMEOUT_SECS_DEFAULT + ) + + +def test_startup_restore_drain_timeout_is_a_documented_config_key(): + """agent.gateway_startup_restore_drain_timeout ships in DEFAULT_CONFIG.""" + from hermes_cli.config import DEFAULT_CONFIG + + assert ( + "gateway_startup_restore_drain_timeout" in DEFAULT_CONFIG["agent"] + ), "the bound must be a config.yaml knob, not an undocumented env var" diff --git a/tests/gateway/test_send_image_file.py b/tests/gateway/test_send_image_file.py index 54a3faadb4..7a67540784 100644 --- a/tests/gateway/test_send_image_file.py +++ b/tests/gateway/test_send_image_file.py @@ -242,7 +242,11 @@ class TestDiscordSendImageFile: assert result.success assert result.message_id == "100" - assert "file" in mock_channel.send.call_args.kwargs + # #66797: path-based File sent via plural files=[...] (matches the + # image-batch path; the singular file= handle form could race the + # multipart encoder and silently drop the attachment). + sent_files = mock_channel.send.call_args.kwargs.get("files") + assert sent_files and len(sent_files) == 1 assert file_cls.call_args.kwargs["filename"] == "renamed.pdf" def test_send_video_uploads_file_attachment(self, adapter, tmp_path): @@ -267,7 +271,9 @@ class TestDiscordSendImageFile: assert result.success assert result.message_id == "101" - assert "file" in mock_channel.send.call_args.kwargs + # #66797: path-based File sent via plural files=[...] (see above). + sent_files = mock_channel.send.call_args.kwargs.get("files") + assert sent_files and len(sent_files) == 1 assert file_cls.call_args.kwargs["filename"] == "clip.mp4" def test_returns_error_when_file_missing(self, adapter): diff --git a/tests/gateway/test_session_env.py b/tests/gateway/test_session_env.py index f5392ab2c2..1183e755df 100644 --- a/tests/gateway/test_session_env.py +++ b/tests/gateway/test_session_env.py @@ -48,6 +48,7 @@ def test_set_session_env_sets_contextvars(monkeypatch): monkeypatch.delenv("HERMES_SESSION_SOURCE", raising=False) monkeypatch.delenv("HERMES_SESSION_CHAT_ID", raising=False) monkeypatch.delenv("HERMES_SESSION_CHAT_NAME", raising=False) + monkeypatch.delenv("HERMES_SESSION_CHAT_TYPE", raising=False) monkeypatch.delenv("HERMES_SESSION_USER_ID", raising=False) monkeypatch.delenv("HERMES_SESSION_USER_NAME", raising=False) monkeypatch.delenv("HERMES_SESSION_THREAD_ID", raising=False) @@ -59,6 +60,7 @@ def test_set_session_env_sets_contextvars(monkeypatch): assert get_session_env("HERMES_SESSION_SOURCE") == "" assert get_session_env("HERMES_SESSION_CHAT_ID") == "-1001" assert get_session_env("HERMES_SESSION_CHAT_NAME") == "Group" + assert get_session_env("HERMES_SESSION_CHAT_TYPE") == "group" assert get_session_env("HERMES_SESSION_USER_ID") == "123456" assert get_session_env("HERMES_SESSION_USER_NAME") == "alice" assert get_session_env("HERMES_SESSION_THREAD_ID") == "17585" @@ -66,6 +68,7 @@ def test_set_session_env_sets_contextvars(monkeypatch): # os.environ should NOT be touched assert os.getenv("HERMES_SESSION_PLATFORM") is None assert os.getenv("HERMES_SESSION_SOURCE") is None + assert os.getenv("HERMES_SESSION_CHAT_TYPE") is None assert os.getenv("HERMES_SESSION_THREAD_ID") is None # Clean up @@ -91,6 +94,7 @@ def test_clear_session_env_restores_previous_state(monkeypatch): monkeypatch.delenv("HERMES_SESSION_PLATFORM", raising=False) monkeypatch.delenv("HERMES_SESSION_CHAT_ID", raising=False) monkeypatch.delenv("HERMES_SESSION_CHAT_NAME", raising=False) + monkeypatch.delenv("HERMES_SESSION_CHAT_TYPE", raising=False) monkeypatch.delenv("HERMES_SESSION_USER_ID", raising=False) monkeypatch.delenv("HERMES_SESSION_USER_NAME", raising=False) monkeypatch.delenv("HERMES_SESSION_THREAD_ID", raising=False) @@ -109,6 +113,7 @@ def test_clear_session_env_restores_previous_state(monkeypatch): tokens = runner._set_session_env(context) assert get_session_env("HERMES_SESSION_PLATFORM") == "telegram" assert get_session_env("HERMES_SESSION_USER_ID") == "123456" + assert get_session_env("HERMES_SESSION_CHAT_TYPE") == "group" runner._clear_session_env(tokens) @@ -116,6 +121,7 @@ def test_clear_session_env_restores_previous_state(monkeypatch): assert get_session_env("HERMES_SESSION_PLATFORM") == "" assert get_session_env("HERMES_SESSION_CHAT_ID") == "" assert get_session_env("HERMES_SESSION_CHAT_NAME") == "" + assert get_session_env("HERMES_SESSION_CHAT_TYPE") == "" assert get_session_env("HERMES_SESSION_USER_ID") == "" assert get_session_env("HERMES_SESSION_USER_NAME") == "" assert get_session_env("HERMES_SESSION_THREAD_ID") == "" @@ -393,4 +399,3 @@ async def test_gateway_executor_refuses_resurrection_after_shutdown(): await runner._run_in_executor_with_context(lambda: "second") finally: runner._shutdown_executor() - diff --git a/tests/gateway/test_status_command.py b/tests/gateway/test_status_command.py index 2da89d16dc..d02c0c4403 100644 --- a/tests/gateway/test_status_command.py +++ b/tests/gateway/test_status_command.py @@ -100,7 +100,7 @@ async def test_status_command_reports_running_agent_without_interrupt(monkeypatc result = await runner._handle_message(_make_event("/status")) assert "**Session ID:** `sess-1`" in result - assert "**Cumulative API tokens (re-sent each call):** 321" in result + assert "**Lifetime tokens billed:** 321" in result assert "**Agent Running:** Yes ⚡" in result assert "**Title:**" not in result running_agent.interrupt.assert_not_called() @@ -153,7 +153,7 @@ async def test_status_command_reads_token_totals_from_session_db(): result = await runner._handle_message(_make_event("/status")) # 1000 + 250 + 500 + 100 + 50 = 1,900 - assert "**Cumulative API tokens (re-sent each call):** 1,900" in result + assert "**Lifetime tokens billed:** 1,900" in result @pytest.mark.asyncio @@ -174,7 +174,7 @@ async def test_status_command_tokens_zero_when_session_db_row_missing(): result = await runner._handle_message(_make_event("/status")) - assert "**Cumulative API tokens (re-sent each call):** 0" in result + assert "**Lifetime tokens billed:** 0" in result @pytest.mark.asyncio @@ -212,8 +212,7 @@ async def test_status_command_includes_live_agent_model_and_context(): assert "**Model:** `openai/gpt-test` (openai)" in result assert "**Context:** 12,345 / 100,000 (12%)" in result - assert "**Cumulative API tokens (re-sent each call):** 1,250" in result - assert "1,250 (cumulative)" not in result + assert "**Lifetime tokens billed:** 1,250" in result @pytest.mark.asyncio @@ -245,7 +244,7 @@ async def test_status_command_includes_persisted_model_and_context_when_agent_no assert "**Model:** `openai/gpt-persisted` (openai-codex)" in result assert "**Context:** 24,000 / 272,000 (9%)" in result - assert "**Cumulative API tokens (re-sent each call):** 2,500" in result + assert "**Lifetime tokens billed:** 2,500" in result @pytest.mark.asyncio @@ -821,3 +820,273 @@ async def test_post_delivery_callback_generation_snapshot_happens_after_bind(): assert fired == [] assert session_key in adapter._post_delivery_callbacks assert adapter._post_delivery_callbacks[session_key][0] == 2 + + +# ── /context command tests ──────────────────────────────────────────────── + +def _stub_agent(**overrides) -> SimpleNamespace: + """Build a stub agent with the attributes _handle_context_command reads.""" + props = dict( + model="openai/gpt-test", + context_compressor=SimpleNamespace( + last_prompt_tokens=47_231, + context_length=200_000, + threshold_tokens=100_000, + threshold_percent=0.5, + compression_count=2, + _last_compression_savings_pct=63.0, + ), + session_api_calls=47, + session_input_tokens=410_000, + session_output_tokens=38_000, + session_reasoning_tokens=12_000, + session_total_tokens=3_158_641, + session_cache_read_tokens=2_900_000, + session_cache_write_tokens=48_000, + ) + props.update(overrides) + return SimpleNamespace(**props) + + +@pytest.mark.asyncio +async def test_context_command_live_agent(): + """/context with a live running agent shows the full view: gauge, + compression, and throughput — but NOT cache stats.""" + session_entry = SessionEntry( + session_key=build_session_key(_make_source()), + session_id="sess-1", + created_at=datetime.now(), + updated_at=datetime.now(), + platform=Platform.TELEGRAM, + chat_type="dm", + ) + runner = _make_runner(session_entry) + session_key = session_entry.session_key + agent = _stub_agent() + runner._running_agents[session_key] = agent + + result = await runner._handle_context_command(_make_event("/context")) + + assert "🧠 **Context Window**" in result + assert "Model: `openai/gpt-test`" in result + assert "Window: 200,000 tokens" in result + assert "In use: 47,231 / 200,000 (24%)" in result + assert "Headroom to limit: 152,769 tokens" in result + # Compression section + assert "Auto-compresses at: 100,000 (50%)" in result + assert "Compressions this session: 2" in result + assert "Last compression freed: 63% of context" in result + # Throughput — NOT cache + assert "Session totals (cumulative across 47 API calls)" in result + assert "Input 410,000" in result + assert "Output 38,000" in result + assert "Reasoning 12,000" in result + assert "Total billed: 3,158,641" in result + assert "each call re-sends the window above" in result + # Cache stats must NOT appear (removed per design) + assert "Cache read" not in result + assert "Cache write" not in result + assert "Cache hit" not in result + assert "Hit rate" not in result + + +@pytest.mark.asyncio +async def test_context_command_over_threshold(): + """When used >= threshold, the over-threshold warning is shown.""" + session_entry = SessionEntry( + session_key=build_session_key(_make_source()), + session_id="sess-2", + created_at=datetime.now(), + updated_at=datetime.now(), + platform=Platform.TELEGRAM, + chat_type="dm", + ) + runner = _make_runner(session_entry) + session_key = session_entry.session_key + agent = _stub_agent( + context_compressor=SimpleNamespace( + last_prompt_tokens=150_000, + context_length=200_000, + threshold_tokens=100_000, + threshold_percent=0.5, + compression_count=5, + _last_compression_savings_pct=40.0, + ) + ) + runner._running_agents[session_key] = agent + + result = await runner._handle_context_command(_make_event("/context")) + + assert "⚠️" in result + assert "Over auto-compression threshold" in result + + +@pytest.mark.asyncio +async def test_context_command_no_agent_transcript_fallback(): + """When no agent is resident and session_entry has no last_prompt_tokens, + /context falls back to a transcript estimate.""" + session_entry = SessionEntry( + session_key=build_session_key(_make_source()), + session_id="sess-3", + created_at=datetime.now(), + updated_at=datetime.now(), + platform=Platform.TELEGRAM, + chat_type="dm", + last_prompt_tokens=0, # No live context data + ) + runner = _make_runner(session_entry) + # Stub the transcript so estimate_messages_tokens_rough has something to work with + runner.session_store.load_transcript.return_value = [ + {"role": "user", "content": "Hello"}, + {"role": "assistant", "content": "Hi there!"}, + {"role": "user", "content": "What's my balance?"}, + {"role": "assistant", "content": "Your balance is $1,000."}, + ] + + result = await runner._handle_context_command(_make_event("/context")) + + assert "🧠 **Context Window**" in result + assert "Estimated context:" in result + assert "4 messages" in result + + +@pytest.mark.asyncio +async def test_context_command_no_data(): + """When there's no agent, no session data, and no transcript, + /context returns the no-data message.""" + session_entry = SessionEntry( + session_key=build_session_key(_make_source()), + session_id="sess-4", + created_at=datetime.now(), + updated_at=datetime.now(), + platform=Platform.TELEGRAM, + chat_type="dm", + last_prompt_tokens=0, + ) + runner = _make_runner(session_entry) + runner.session_store.load_transcript.return_value = [] + + result = await runner._handle_context_command(_make_event("/context")) + + assert "No context data available yet" in result + + +@pytest.mark.asyncio +async def test_context_command_includes_category_breakdown(): + """/context with a live agent appends the per-category estimated + breakdown (plain text, no glyph grid) and the /context all hint.""" + session_entry = SessionEntry( + session_key=build_session_key(_make_source()), + session_id="sess-5", + created_at=datetime.now(), + updated_at=datetime.now(), + platform=Platform.TELEGRAM, + chat_type="dm", + ) + runner = _make_runner(session_entry) + agent = _stub_agent() + runner._running_agents[session_entry.session_key] = agent + + fake_payload = { + "categories": [ + {"id": "system_prompt", "label": "System prompt", "tokens": 9_000}, + {"id": "tool_definitions", "label": "Tool definitions", "tokens": 21_000}, + ], + "context_max": 200_000, + "context_percent": 24, + "context_used": 47_231, + "estimated_total": 30_000, + "model": "openai/gpt-test", + } + from unittest.mock import patch as _patch + with _patch( + "agent.context_breakdown.compute_session_context_breakdown", + return_value=fake_payload, + ): + result = await runner._handle_context_command(_make_event("/context")) + + assert "Estimated usage by category" in result + assert "System prompt" in result + assert "9,000 tokens" in result + assert "Tool definitions" in result + assert "Use /context all" in result + # No glyph grid on the gateway (plain-text variant) + assert "· · ·" not in result + + +@pytest.mark.asyncio +async def test_context_all_appends_expanded_listings(): + """/context all appends per-toolset and per-skill cost listings.""" + session_entry = SessionEntry( + session_key=build_session_key(_make_source()), + session_id="sess-6", + created_at=datetime.now(), + updated_at=datetime.now(), + platform=Platform.TELEGRAM, + chat_type="dm", + ) + runner = _make_runner(session_entry) + agent = _stub_agent() + runner._running_agents[session_entry.session_key] = agent + + fake_payload = { + "categories": [ + {"id": "skills", "label": "Skills", "tokens": 2_000}, + ], + "context_max": 200_000, + "context_percent": 24, + "context_used": 47_231, + "estimated_total": 2_000, + "model": "openai/gpt-test", + } + fake_details = { + "skills": [ + {"name": "hermes-agent", "index_tokens": 30, "skill_md_tokens": 2_500}, + ], + "toolsets": [ + {"toolset": "terminal", "tool_count": 4, "schema_tokens": 5_100}, + ], + } + from unittest.mock import patch as _patch + with _patch( + "agent.context_breakdown.compute_session_context_breakdown", + return_value=fake_payload, + ), _patch( + "agent.context_breakdown.compute_context_details", + return_value=fake_details, + ): + result = await runner._handle_context_command(_make_event("/context all")) + + assert "Toolsets by schema cost" in result + assert "terminal" in result and "5,100 tokens" in result + assert "Skills by cost" in result + assert "hermes-agent" in result + # Expanded view drops the hint + assert "Use /context all" not in result + + +@pytest.mark.asyncio +async def test_context_breakdown_failure_never_breaks_command(): + """A breakdown engine crash degrades gracefully — the gauge still renders.""" + session_entry = SessionEntry( + session_key=build_session_key(_make_source()), + session_id="sess-7", + created_at=datetime.now(), + updated_at=datetime.now(), + platform=Platform.TELEGRAM, + chat_type="dm", + ) + runner = _make_runner(session_entry) + agent = _stub_agent() + runner._running_agents[session_entry.session_key] = agent + + from unittest.mock import patch as _patch + with _patch( + "agent.context_breakdown.compute_session_context_breakdown", + side_effect=RuntimeError("boom"), + ): + result = await runner._handle_context_command(_make_event("/context")) + + assert "🧠 **Context Window**" in result + assert "In use: 47,231 / 200,000 (24%)" in result + assert "Estimated usage by category" not in result diff --git a/tests/gateway/test_stream_consumer.py b/tests/gateway/test_stream_consumer.py index db28bdcf04..228c9f1359 100644 --- a/tests/gateway/test_stream_consumer.py +++ b/tests/gateway/test_stream_consumer.py @@ -50,12 +50,40 @@ class TestCleanForDisplay: assert "MEDIA:" not in result assert "Audio generated" in result - def test_media_tag_with_quotes(self): - """MEDIA: tags wrapped in quotes or backticks are removed.""" - for wrapper in ['`MEDIA:/path/file.png`', '"MEDIA:/path/file.png"', "'MEDIA:/path/file.png'"]: - text = f"Result: {wrapper}" - result = GatewayStreamConsumer._clean_for_display(text) - assert "MEDIA:" not in result, f"Failed for wrapper: {wrapper}" + def test_media_tag_single_quoted_stripped(self): + """A single-quote-wrapped tag matches the known-ext cleanup pattern + and is removed (delivery attempts it too — consistent).""" + result = GatewayStreamConsumer._clean_for_display( + "Result: 'MEDIA:/path/file.png'" + ) + assert "MEDIA:" not in result + + def test_media_tag_double_quoted_json_context_stays_visible(self): + """A double-quoted tag preceded by a colon sits in a JSON value + context (#34375): extract_media masks it and never delivers, so + display keeps it visible too instead of silently hiding a tag that + produced no attachment (display/delivery consistency).""" + result = GatewayStreamConsumer._clean_for_display( + 'Result: "MEDIA:/path/file.png"' + ) + assert '"MEDIA:/path/file.png"' in result + + def test_media_tag_in_backticks_real_file_stripped(self, tmp_path): + """A backtick-wrapped tag pointing at a REAL file is a delivery + directive: extract_media delivers it, so display strips it.""" + p = tmp_path / "file.png" + p.write_bytes(b"\x89PNG") + result = GatewayStreamConsumer._clean_for_display(f"Result: `MEDIA:{p}`") + assert "MEDIA:" not in result + + def test_media_tag_in_backticks_bogus_path_stays_visible(self): + """A backtick-wrapped tag with a non-existent path is an inline-code + example: extract_media does NOT deliver it, so display must not + silently strip it either (display/delivery consistency, #16434).""" + result = GatewayStreamConsumer._clean_for_display( + "Result: `MEDIA:/path/file.png`" + ) + assert "`MEDIA:/path/file.png`" in result def test_audio_as_voice_stripped(self): """[[audio_as_voice]] directive is removed.""" diff --git a/tests/gateway/test_telegram_fallback_pool_release_71593.py b/tests/gateway/test_telegram_fallback_pool_release_71593.py new file mode 100644 index 0000000000..bf4466034a --- /dev/null +++ b/tests/gateway/test_telegram_fallback_pool_release_71593.py @@ -0,0 +1,212 @@ +"""Regression test for #71593 / #63311 — Telegram fallback-pool FD leak. + +Background +---------- +``TelegramFallbackTransport`` (plugins/platforms/telegram/telegram_network.py) +routes Telegram Bot API requests via per-IP fallback ``httpx`` pools when the +primary DNS path is unreachable. The pre-fix version built one +``AsyncHTTPTransport`` per fallback IP eagerly in ``__init__`` and *never* tore +them down: on a retryable connect failure the handler only logged and +continued, so a socket left in ``CLOSE_WAIT`` by a peer-closed connection stayed +inside the retained pool. Each retry leaked another file descriptor until the +gateway hit EMFILE and wedged (accept(), config reads and DNS all failing). + +The fix (this PR): + * builds fallback pools lazily via ``_get_fallback`` (nothing in ``__init__``); + * on a retryable connect failure calls ``_reset_fallback`` which pops the + poisoned pool out of ``self._fallbacks`` and ``aclose()``s it, so its dead + sockets are released instead of accumulating; + * bounds every pool at ``Limits(max_connections=8)`` as a *default* via + ``setdefault`` — a caller-supplied ``limits`` kwarg still wins. + +Contract asserted here (mutation-survivable) +--------------------------------------------- +1. A retryable connect failure on a fallback IP causes that pool to be + ``aclose()``d and dropped from ``self._fallbacks`` — NOT retained. This is + the discard-on-failure path: revert the ``_reset_fallback`` call in + ``handle_async_request`` and ``test_failed_fallback_pool_is_discarded_and_closed`` + fails (the pool is retained and never closed). +2. A caller-supplied ``limits`` kwarg wins over the ``_POOL_LIMITS`` default. +""" + +import httpx +import pytest + +import plugins.platforms.telegram.telegram_network as tnet + + +def _telegram_request(path="/botTOKEN/getMe"): + return httpx.Request("GET", f"https://api.telegram.org{path}") + + +class _CountingTransport(httpx.AsyncBaseTransport): + """Fake AsyncHTTPTransport: fails/succeeds per host, records aclose().""" + + def __init__(self, behavior, closed_log): + self.behavior = behavior + self.closed_log = closed_log + self.closed = False + + async def handle_async_request(self, request: httpx.Request) -> httpx.Response: + action = self.behavior.get(request.url.host, "ok") + if action == "timeout": + raise httpx.ConnectTimeout("timed out") + if action == "connect_error": + raise httpx.ConnectError("connect error") + return httpx.Response(200, request=request, text="ok") + + async def aclose(self) -> None: + self.closed = True + self.closed_log.append(self) + + +def _factory(behavior, closed_log, kwargs_log=None): + def factory(**kwargs): + if kwargs_log is not None: + kwargs_log.append(kwargs) + return _CountingTransport(behavior, closed_log) + + return factory + + +@pytest.mark.asyncio +async def test_failed_fallback_pool_is_discarded_and_closed(monkeypatch): + """The discard-on-failure path: a retryable connect failure on a fallback + IP must aclose() that pool and drop it from ``self._fallbacks`` so its + CLOSE_WAIT socket is released (#71593 / #63311). + + Sabotage check: reverting the ``await self._reset_fallback(ip)`` call in + ``handle_async_request`` retains the poisoned pool → this test fails + (pool still in ``_fallbacks`` and never aclose()d). + """ + closed_log: list = [] + # Primary + both fallback IPs fail with a retryable connect error, so every + # fallback pool that gets built must also get discarded. + behavior = { + "api.telegram.org": "timeout", + "149.154.167.220": "connect_error", + "149.154.167.221": "timeout", + } + monkeypatch.setattr( + tnet.httpx, "AsyncHTTPTransport", _factory(behavior, closed_log) + ) + + transport = tnet.TelegramFallbackTransport( + ["149.154.167.220", "149.154.167.221"] + ) + + # All paths fail → the last error propagates. + with pytest.raises((httpx.ConnectTimeout, httpx.ConnectError)): + await transport.handle_async_request(_telegram_request()) + + # The poisoned fallback pools must NOT be retained — they were discarded. + assert transport._fallbacks == {}, ( + "Failed fallback pools were retained in self._fallbacks — the " + "CLOSE_WAIT sockets leak (revert of _reset_fallback? #71593)." + ) + + # Each fallback pool that was built for a failing IP must have been + # aclose()d exactly once (two fallback IPs → two discards). + assert len(closed_log) == 2, ( + f"Expected 2 discarded/closed fallback pools, got {len(closed_log)} — " + "the discard-on-failure path did not aclose() the poisoned pools." + ) + assert all(t.closed for t in closed_log) + + +@pytest.mark.asyncio +async def test_recovered_fallback_pool_is_retained_not_discarded(monkeypatch): + """A fallback IP that *succeeds* must keep its pool (sticky reuse) — the + discard only fires on failure. Guards against over-eager resetting.""" + closed_log: list = [] + behavior = { + "api.telegram.org": "timeout", # primary fails + "149.154.167.220": "connect_error", # first fallback fails → discarded + "149.154.167.221": "ok", # second fallback works → retained + } + monkeypatch.setattr( + tnet.httpx, "AsyncHTTPTransport", _factory(behavior, closed_log) + ) + + transport = tnet.TelegramFallbackTransport( + ["149.154.167.220", "149.154.167.221"] + ) + resp = await transport.handle_async_request(_telegram_request()) + + assert resp.status_code == 200 + assert transport._sticky_ip == "149.154.167.221" + # The failed .220 pool was discarded; the working .221 pool is retained. + assert "149.154.167.220" not in transport._fallbacks + assert "149.154.167.221" in transport._fallbacks + # Exactly one pool (the failed one) was aclose()d. + assert len(closed_log) == 1 + + +@pytest.mark.asyncio +async def test_reset_fallback_is_a_noop_when_pool_absent(monkeypatch): + """_reset_fallback on an IP that was never built must not raise or close + anything — the lazy dict may not contain it.""" + closed_log: list = [] + monkeypatch.setattr( + tnet.httpx, "AsyncHTTPTransport", _factory({}, closed_log) + ) + transport = tnet.TelegramFallbackTransport(["149.154.167.220"]) + + # Nothing built yet. + assert transport._fallbacks == {} + await transport._reset_fallback("149.154.167.220") + assert transport._fallbacks == {} + assert closed_log == [] + + +def test_caller_limits_win_over_pool_default(monkeypatch): + """A caller-supplied ``limits`` kwarg must win over the ``_POOL_LIMITS`` + ``setdefault`` default, for both the primary and lazily-built fallback + pools (#71593).""" + import asyncio + + kwargs_log: list = [] + for key in ( + "HTTPS_PROXY", "HTTP_PROXY", "ALL_PROXY", "https_proxy", + "http_proxy", "all_proxy", "TELEGRAM_PROXY", "NO_PROXY", "no_proxy", + ): + monkeypatch.delenv(key, raising=False) + monkeypatch.setattr( + tnet.httpx, "AsyncHTTPTransport", _factory({}, [], kwargs_log) + ) + + custom_limits = httpx.Limits( + max_connections=42, max_keepalive_connections=10, keepalive_expiry=30.0 + ) + transport = tnet.TelegramFallbackTransport( + ["149.154.167.220"], limits=custom_limits + ) + # Primary built in __init__ with the caller's limits (not the default). + assert kwargs_log[0]["limits"] is custom_limits + + # Lazily-built fallback pool must also carry the caller's limits. + asyncio.run(transport._get_fallback("149.154.167.220")) + assert len(kwargs_log) == 2 + assert all(kw["limits"] is custom_limits for kw in kwargs_log) + # And the caller's limits are NOT the class default. + assert custom_limits is not tnet.TelegramFallbackTransport._POOL_LIMITS + + +def test_pool_default_limits_applied_when_caller_omits(monkeypatch): + """When the caller supplies no ``limits``, the bounded ``_POOL_LIMITS`` + default (max_connections=8) is applied via setdefault (#71593).""" + kwargs_log: list = [] + for key in ( + "HTTPS_PROXY", "HTTP_PROXY", "ALL_PROXY", "https_proxy", + "http_proxy", "all_proxy", "TELEGRAM_PROXY", "NO_PROXY", "no_proxy", + ): + monkeypatch.delenv(key, raising=False) + monkeypatch.setattr( + tnet.httpx, "AsyncHTTPTransport", _factory({}, [], kwargs_log) + ) + + transport = tnet.TelegramFallbackTransport(["149.154.167.220"]) + limits = kwargs_log[0]["limits"] + assert isinstance(limits, httpx.Limits) + assert limits.max_connections == 8 + assert limits is transport._POOL_LIMITS diff --git a/tests/gateway/test_telegram_group_gating.py b/tests/gateway/test_telegram_group_gating.py index 1dc9a13a6f..fa05f605af 100644 --- a/tests/gateway/test_telegram_group_gating.py +++ b/tests/gateway/test_telegram_group_gating.py @@ -1412,3 +1412,212 @@ def test_unmentioned_unsupported_document_observed_and_cached(monkeypatch): assert "program.exe" in message["content"] asyncio.run(_run()) + + +# ── Bot identity: renames and non-"bot"-suffixed handles ──────────────────── +# Two failure modes fixed together (both break the mention gate): +# 1. PTB caches getMe() in Bot._bot_user and only rewrites it inside +# get_me(). After a BotFather rename the adapter compares against the OLD +# handle, so the exclusive-mention gate reads a message addressed to us as +# one addressed to a different bot and silently drops it. +# 2. The bot-handle pattern assumed every bot username ends in "bot". +# Collectible (Fragment) usernames can be assigned to bots and don't +# (@jarvis, @pic), making such a bot unable to recognise its own handle. + + +class _IdentityBot: + """Stand-in for PTB's Bot: ``.username`` only changes when get_me() runs.""" + + def __init__(self, bot_id=999, cached="hermes_bot", server=None): + self.id = bot_id + self._cached = cached + self._server = server if server is not None else cached + self.get_me_calls = 0 + + @property + def username(self): + return self._cached + + async def get_me(self): + self.get_me_calls += 1 + self._cached = self._server + return SimpleNamespace(id=self.id, username=self._server) + + +def _reply_to_bot_message(text, *, entities=None, bot_username, bot_id=999): + """Group message replying to one of our messages. + + Telegram stamps the bot's CURRENT username on ``reply_to_message.from_user``, + which is how a rename becomes observable without an extra API call. + """ + message = _group_message(text, entities=entities) + message.reply_to_message = SimpleNamespace( + from_user=SimpleNamespace(id=bot_id, username=bot_username), + message_id=10, text="previous bot reply", caption=None, + ) + return message + + +def test_renamed_bot_still_routes_when_reply_reveals_new_handle(): + """A rename observed from an inbound update takes effect immediately.""" + adapter = _make_adapter(require_mention=True) + adapter._bot = _IdentityBot(cached="old_helper_bot", server="new_helper_bot") + text = "@new_helper_bot thanks!" + message = _reply_to_bot_message( + text, entities=_mention_entities(text, ["@new_helper_bot"]), + bot_username="new_helper_bot", + ) + + assert adapter._should_process_message(message) is True + assert adapter._current_bot_username() == "new_helper_bot" + # Learned from the update stream — no Bot API round-trip needed. + assert adapter._bot.get_me_calls == 0 + + +def test_stale_username_does_not_route_message_to_another_bot(): + """The exclusive-mention gate must not fire on our own (renamed) handle.""" + adapter = _make_adapter(require_mention=True, exclusive_bot_mentions=True) + adapter._bot = _IdentityBot(cached="old_helper_bot", server="new_helper_bot") + adapter._note_bot_username("new_helper_bot") + text = "@new_helper_bot what's the weather" + message = _group_message(text, entities=_mention_entities(text, ["@new_helper_bot"])) + + assert adapter._explicit_bot_mentions_exclude_self(message) is False + assert adapter._should_process_message(message) is True + + +def test_stale_username_schedules_background_identity_recheck(): + """A drop caused by a stale handle self-corrects via a TTL-guarded getMe.""" + async def _run(): + adapter = _make_adapter(require_mention=True, exclusive_bot_mentions=True) + adapter._bot = _IdentityBot(cached="old_helper_bot", server="new_helper_bot") + adapter._background_tasks = set() + text = "@new_helper_bot what's the weather" + message = _group_message(text, entities=_mention_entities(text, ["@new_helper_bot"])) + + # First message is lost — nothing has revealed the new handle yet. + assert adapter._should_process_message(message) is False + await asyncio.gather(*list(adapter._background_tasks)) + + assert adapter._bot.get_me_calls == 1 + assert adapter._current_bot_username() == "new_helper_bot" + # Recovered without a gateway restart. + assert adapter._should_process_message(message) is True + + asyncio.run(_run()) + + +def test_identity_recheck_is_rate_limited_in_multi_bot_groups(): + """Traffic legitimately aimed at other bots must not trigger a getMe storm.""" + async def _run(): + adapter = _make_adapter(require_mention=True, exclusive_bot_mentions=True) + adapter._bot = _IdentityBot(cached="hermes_bot") + adapter._background_tasks = set() + text = "@other_helper_bot please run it" + + for _ in range(25): + adapter._should_process_message( + _group_message(text, entities=_mention_entities(text, ["@other_helper_bot"])) + ) + await asyncio.gather(*list(adapter._background_tasks)) + + assert adapter._bot.get_me_calls <= 1 + + asyncio.run(_run()) + + +def test_bot_never_adopts_another_accounts_username(): + """Only a user id matching this bot may update our own handle.""" + adapter = _make_adapter(require_mention=True) + adapter._bot = _IdentityBot(cached="hermes_bot") + message = _group_message("hello") + message.from_user = SimpleNamespace(id=555, username="impostor_bot", full_name="Impostor", first_name="Impostor") + + adapter._observe_bot_identity_from_message(message) + + assert adapter._current_bot_username() == "hermes_bot" + + +def test_collectible_username_without_bot_suffix_is_recognised(): + """A Fragment handle (@jarvis) must still count as addressing this bot.""" + adapter = _make_adapter(require_mention=True, bot_username="jarvis") + text = "@jarvis hey" + message = _group_message(text, entities=_mention_entities(text, ["@jarvis"])) + + assert adapter._message_mentions_bot(message) is True + assert adapter._should_process_message(message) is True + + +def test_collectible_username_recognised_without_entities(): + """Entity-less client updates must also match a non-'bot' handle.""" + adapter = _make_adapter(require_mention=True, bot_username="jarvis") + message = _group_message("@jarvis hey", entities=[]) + + assert adapter._message_mentions_bot(message) is True + assert adapter._should_process_message(message) is True + + +def test_collectible_username_not_suppressed_by_other_bot_mention(): + """@jarvis + @other_bot in one message must still reach @jarvis.""" + adapter = _make_adapter( + require_mention=True, exclusive_bot_mentions=True, bot_username="jarvis", + ) + text = "@jarvis ask @other_helper_bot for the log" + message = _group_message( + text, entities=_mention_entities(text, ["@jarvis", "@other_helper_bot"]), + ) + + assert adapter._explicit_bot_mentions_exclude_self(message) is False + assert adapter._should_process_message(message) is True + + +def test_human_handles_still_do_not_act_as_routing_hints(): + """Widening self-matching must not make human @handles suppress this bot.""" + adapter = _make_adapter(require_mention=True, exclusive_bot_mentions=True) + text = "@alice can you check this" + message = _group_message(text, entities=_mention_entities(text, ["@alice"])) + + assert adapter._explicit_bot_mentions_exclude_self(message) is False + + +def test_messages_addressed_to_a_different_bot_are_still_suppressed(): + """The multi-bot exclusivity contract is preserved.""" + adapter = _make_adapter(require_mention=True, exclusive_bot_mentions=True) + text = "@other_helper_bot do it" + message = _group_message(text, entities=_mention_entities(text, ["@other_helper_bot"])) + + assert adapter._explicit_bot_mentions_exclude_self(message) is True + assert adapter._should_process_message(message) is False + + +def test_clean_bot_trigger_text_strips_the_current_handle(): + """Prefix stripping must follow a rename, not the stale cached handle.""" + adapter = _make_adapter(require_mention=True) + adapter._bot = _IdentityBot(cached="old_helper_bot", server="new_helper_bot") + adapter._note_bot_username("new_helper_bot") + + assert adapter._clean_bot_trigger_text("@new_helper_bot ship it") == "ship it" + + +def test_identity_freshness_does_not_depend_on_host_uptime(monkeypatch): + """A never-checked identity is stale even when monotonic() is near zero. + + time.monotonic() has an arbitrary epoch: on a freshly-booted host (CI + runners, containers) it starts near 0. A 0.0 "never checked" sentinel + therefore reads as "checked just now" for the first TTL seconds of + uptime, suppressing the very first identity refresh — so the stale-handle + recovery silently did nothing on exactly the machines most likely to be + freshly booted. Caught by CI, invisible on a long-lived dev box. + """ + adapter = _make_adapter(require_mention=True) + adapter._bot = _IdentityBot(cached="old_helper_bot", server="new_helper_bot") + + # Simulate a host that booted 12 seconds ago. + monkeypatch.setattr( + "plugins.platforms.telegram.adapter.time.monotonic", lambda: 12.0 + ) + + assert adapter._bot_identity_is_fresh() is False + + adapter._note_bot_username("new_helper_bot") + assert adapter._bot_identity_is_fresh() is True diff --git a/tests/gateway/test_telegram_network.py b/tests/gateway/test_telegram_network.py index 1615200dff..3ddb7ce9f6 100644 --- a/tests/gateway/test_telegram_network.py +++ b/tests/gateway/test_telegram_network.py @@ -332,6 +332,12 @@ class TestFallbackTransportInit: transport = tnet.TelegramFallbackTransport(["149.154.167.220"]) assert transport._fallback_ips == ["149.154.167.220"] + # Fallback pools are now built lazily (#63311), so __init__ constructs + # only the primary transport. Force the fallback pool to materialize to + # observe its kwargs. + import asyncio + + asyncio.run(transport._get_fallback("149.154.167.220")) assert len(seen_kwargs) == 2 assert all(kwargs["proxy"] == "http://proxy.example:8080" for kwargs in seen_kwargs) @@ -351,6 +357,10 @@ class TestFallbackTransportInit: transport = tnet.TelegramFallbackTransport(["149.154.167.220"]) assert transport._fallback_ips == ["149.154.167.220"] + # Lazy fallback build (#63311): materialize the fallback pool. + import asyncio + + asyncio.run(transport._get_fallback("149.154.167.220")) assert len(seen_kwargs) == 2 assert all("proxy" not in kwargs for kwargs in seen_kwargs) @@ -379,10 +389,17 @@ class TestFallbackTransportInit: ["149.154.167.220"], limits=custom_limits ) + # Lazy fallback build (#63311): __init__ builds only the primary; the + # fallback pool is constructed on demand. Materialize it so both the + # primary and the fallback are observed. + import asyncio + + asyncio.run(transport._get_fallback("149.154.167.220")) # 1 primary + 1 fallback = 2 AsyncHTTPTransport instances assert len(seen_kwargs) == 2 for kw in seen_kwargs: assert "limits" in kw + # Caller-supplied limits must win over the setdefault default. assert kw["limits"] is custom_limits @@ -393,6 +410,10 @@ class TestFallbackTransportClose: monkeypatch.setattr(tnet.httpx, "AsyncHTTPTransport", factory) transport = tnet.TelegramFallbackTransport(["149.154.167.220", "149.154.167.221"]) + # Lazy fallback build (#63311): materialize both fallback pools so + # aclose() has something to tear down. + await transport._get_fallback("149.154.167.220") + await transport._get_fallback("149.154.167.221") await transport.aclose() # 1 primary + 2 fallback transports diff --git a/tests/gateway/test_telegram_topic_mode.py b/tests/gateway/test_telegram_topic_mode.py index c309a328d5..edeeeb0818 100644 --- a/tests/gateway/test_telegram_topic_mode.py +++ b/tests/gateway/test_telegram_topic_mode.py @@ -183,6 +183,34 @@ async def test_root_telegram_dm_prompt_is_system_lobby_when_topic_mode_enabled(m runner.session_store.get_or_create_session.assert_not_called() +@pytest.mark.asyncio +@pytest.mark.parametrize("thread_id", [None, "1"]) +async def test_internal_root_telegram_dm_event_bypasses_topic_lobby( + monkeypatch, thread_id +): + import gateway.run as gateway_run + + runner = _make_runner() + runner._telegram_topic_mode_enabled = lambda source: True + runner._handle_message_with_agent = AsyncMock(return_value="agent response") + + monkeypatch.setattr( + gateway_run, "_resolve_runtime_agent_kwargs", lambda: {"api_key": "***"} + ) + + event = MessageEvent( + text="[SYSTEM: kanban task completed]", + source=_make_source(thread_id=thread_id), + message_id="wake-1", + internal=True, + ) + result = await runner._handle_message(event) + + assert result == "agent response" + assert runner._handle_message_with_agent.await_count == 1 + assert runner._handle_message_with_agent.await_args.args[0] is event + + @pytest.mark.asyncio async def test_root_telegram_dm_new_shows_create_topic_instruction(monkeypatch): import gateway.run as gateway_run diff --git a/tests/gateway/test_tts_media_routing.py b/tests/gateway/test_tts_media_routing.py index e152b99c27..50381fb6ba 100644 --- a/tests/gateway/test_tts_media_routing.py +++ b/tests/gateway/test_tts_media_routing.py @@ -261,3 +261,91 @@ async def test_streaming_delivery_blocks_media_path_outside_allowed_roots(tmp_pa adapter.send_document.assert_not_awaited() adapter.send_voice.assert_not_awaited() + + +class _DiscordMediaFailureAdapter(BasePlatformAdapter): + """Minimal adapter to exercise non-streaming MEDIA failure notification.""" + + def __init__(self): + super().__init__(PlatformConfig(enabled=True, token="test"), Platform.DISCORD) + self.notices: list[str] = [] + + async def connect(self, *, is_reconnect: bool = False): + return True + + async def disconnect(self): + pass + + async def send(self, chat_id, content=None, **kwargs): + self.notices.append(content or "") + return SendResult(success=True, message_id="notice") + + async def get_chat_info(self, chat_id): + return {"id": chat_id, "type": "dm"} + + +@pytest.mark.asyncio +async def test_non_streaming_media_failure_notifies_user(tmp_path, monkeypatch): + """Attachmentless send_video results must surface a user-visible notice (#66797).""" + adapter = _DiscordMediaFailureAdapter() + event = _event() + media_file = _allowed_media_path(tmp_path, monkeypatch, "clip.mp4") + adapter._message_handler = AsyncMock(return_value=f"MEDIA:{media_file}") + adapter.send_video = AsyncMock( + return_value=SendResult( + success=False, + error="Discord accepted the message but attached no files (clip.mp4)", + ) + ) + adapter.send_document = AsyncMock(return_value=SendResult(success=True, message_id="doc")) + adapter.send_voice = AsyncMock(return_value=SendResult(success=True, message_id="voice")) + adapter.send_multiple_images = AsyncMock() + + await adapter._process_message_background(event, build_session_key(event.source)) + + adapter.send_video.assert_awaited_once() + assert adapter.notices == ["⚠️ Couldn't deliver the video attachment."] + + +class _DiscordMediaFailureAdapter(BasePlatformAdapter): + """Minimal adapter to exercise non-streaming MEDIA failure notification.""" + + def __init__(self): + super().__init__(PlatformConfig(enabled=True, token="test"), Platform.DISCORD) + self.notices: list[str] = [] + + async def connect(self, *, is_reconnect: bool = False): + return True + + async def disconnect(self): + pass + + async def send(self, chat_id, content=None, **kwargs): + self.notices.append(content or "") + return SendResult(success=True, message_id="notice") + + async def get_chat_info(self, chat_id): + return {"id": chat_id, "type": "dm"} + + +@pytest.mark.asyncio +async def test_non_streaming_media_failure_notifies_user(tmp_path, monkeypatch): + """Attachmentless send_video results must surface a user-visible notice (#66797).""" + adapter = _DiscordMediaFailureAdapter() + event = _event() + media_file = _allowed_media_path(tmp_path, monkeypatch, "clip.mp4") + adapter._message_handler = AsyncMock(return_value=f"MEDIA:{media_file}") + adapter.send_video = AsyncMock( + return_value=SendResult( + success=False, + error="Discord accepted the message but attached no files (clip.mp4)", + ) + ) + adapter.send_document = AsyncMock(return_value=SendResult(success=True, message_id="doc")) + adapter.send_voice = AsyncMock(return_value=SendResult(success=True, message_id="voice")) + adapter.send_multiple_images = AsyncMock() + + await adapter._process_message_background(event, build_session_key(event.source)) + + adapter.send_video.assert_awaited_once() + assert adapter.notices == ["⚠️ Couldn't deliver the video attachment."] diff --git a/tests/gateway/test_webhook_adapter.py b/tests/gateway/test_webhook_adapter.py index 95ca6079ff..d9929fa135 100644 --- a/tests/gateway/test_webhook_adapter.py +++ b/tests/gateway/test_webhook_adapter.py @@ -1296,6 +1296,117 @@ class TestSessionIsolation: assert len(ids) == 2, "Each delivery must have a unique session chat_id" +# =================================================================== +# Silence-marker suppression +# =================================================================== + + +class TestWebhookSilenceSuppression: + """A webhook route that answers ``[SILENT]`` must deliver nothing. + + Webhook routes are autonomous lanes with nobody waiting on the other end, + so a subscription prompt tells the agent to reply ``[SILENT]`` on a tick + that produced no story. Models routinely append a sentence saying WHY they + stayed quiet, and the live gateway's exact-whole-response rule then treats + that as a real report — which is how a Helper support lane ended up + repeatedly messaging its owner to say it had nothing to say. + """ + + def _adapter_with_mock_target(self): + adapter = _make_adapter() + mock_target = AsyncMock() + mock_target.send = AsyncMock(return_value=SendResult(success=True)) + mock_runner = MagicMock() + mock_runner.adapters = {Platform("telegram"): mock_target} + mock_runner.config.get_home_channel.return_value = None + adapter.gateway_runner = mock_runner + + chat_id = "webhook:helper-events:d-1" + adapter._delivery_info[chat_id] = { + "deliver": "telegram", + "deliver_extra": {"chat_id": "-100123"}, + } + adapter._delivery_info_created[chat_id] = time.time() + return adapter, mock_target, chat_id + + @pytest.mark.asyncio + async def test_bare_marker_is_not_delivered(self): + adapter, target, chat_id = self._adapter_with_mock_target() + + result = await adapter.send(chat_id, "[SILENT]") + + assert result.success is True + target.send.assert_not_awaited() + + @pytest.mark.asyncio + async def test_marker_followed_by_prose_is_not_delivered(self): + """The regression this suppression exists for. + + The agent explains its own silence on the lines after the marker. The + strict interactive rule reads that as substantive prose and delivers the + whole thing, marker included. + """ + adapter, target, chat_id = self._adapter_with_mock_target() + + result = await adapter.send( + chat_id, + "[SILENT]\n\nThe new inbound was the same email quoted back a second " + "time, on a ticket we already answered. Nothing new to reply to, so I " + "closed it; it reopens by itself if they write back.", + ) + + assert result.success is True + target.send.assert_not_awaited() + + @pytest.mark.asyncio + async def test_marker_on_the_last_line_is_not_delivered(self): + adapter, target, chat_id = self._adapter_with_mock_target() + + result = await adapter.send(chat_id, "Nothing to report this tick.\n\n[SILENT]") + + assert result.success is True + target.send.assert_not_awaited() + + @pytest.mark.asyncio + async def test_real_report_is_still_delivered(self): + """Suppression must not swallow an actual story.""" + adapter, target, chat_id = self._adapter_with_mock_target() + + result = await adapter.send( + chat_id, + "Refunded $240 to the buyer and replied; the seller had already agreed.", + ) + + assert result.success is True + target.send.assert_awaited_once() + + @pytest.mark.asyncio + async def test_report_mentioning_the_marker_mid_sentence_is_delivered(self): + """A report that merely quotes a marker is not a silence request.""" + adapter, target, chat_id = self._adapter_with_mock_target() + + result = await adapter.send( + chat_id, + "I considered staying [SILENT] but this one moved money, so: refunded " + "$240 and replied to the buyer.", + ) + + assert result.success is True + target.send.assert_awaited_once() + + @pytest.mark.asyncio + async def test_suppression_precedes_log_delivery(self): + """A `log` route also suppresses, so the two lanes behave the same.""" + adapter = _make_adapter() + chat_id = "webhook:helper-events:d-log" + adapter._delivery_info[chat_id] = {"deliver": "log", "deliver_extra": {}} + adapter._delivery_info_created[chat_id] = time.time() + + result = await adapter.send(chat_id, "[SILENT]\n\nnothing happened") + + assert result.success is True + + # =================================================================== # Delivery info cleanup # =================================================================== diff --git a/tests/hermes_cli/test_agent_import.py b/tests/hermes_cli/test_agent_import.py new file mode 100644 index 0000000000..b2b8dd4621 --- /dev/null +++ b/tests/hermes_cli/test_agent_import.py @@ -0,0 +1,541 @@ +"""Tests for hermes_cli.agent_import — ``hermes import-agent``. + +Covers: source detection, Claude Code and Codex parsing, mapping into the +real Hermes stores (memories/MEMORY.md, config.yaml command_allowlist / +approvals.deny / mcp_servers, skills/), dry-run write-nothing guarantees, +malformed-input skip reports, and the never-import-secrets rule. + +Uses the profile_env fixture pattern from tests/hermes_cli/test_profiles.py: +Path.home() and HERMES_HOME are redirected to tmp_path so nothing touches +the real ~/.hermes. +""" + +import json +from pathlib import Path + +import pytest +import yaml + +from hermes_cli.agent_import import ( + AgentImporter, + claude_rule_to_command_pattern, + detect_agents, + extract_markdown_entries, + is_secret_key, + sanitize_mcp_env, +) + + +# --------------------------------------------------------------------------- +# Shared fixture: redirect Path.home() and HERMES_HOME (profile_env pattern) +# --------------------------------------------------------------------------- + +@pytest.fixture() +def profile_env(tmp_path, monkeypatch): + """Isolated environment: Path.home() -> tmp_path, HERMES_HOME -> tmp/.hermes.""" + monkeypatch.setattr(Path, "home", lambda: tmp_path) + default_home = tmp_path / ".hermes" + default_home.mkdir(exist_ok=True) + monkeypatch.setenv("HERMES_HOME", str(default_home)) + return tmp_path + + +@pytest.fixture() +def hermes_home(profile_env): + return profile_env / ".hermes" + + +# --------------------------------------------------------------------------- +# Fake source trees +# --------------------------------------------------------------------------- + +CLAUDE_MD = """# Global instructions + +## Style +- Always use type hints +- Prefer pathlib over os.path + +Run the linter before committing. +""" + +AGENTS_MD = """# Codex rules + +- Never force-push to main +- Keep commits atomic +""" + + +@pytest.fixture() +def claude_tree(profile_env): + """Build a fake ~/.claude tree (plus sibling ~/.claude.json).""" + root = profile_env / ".claude" + root.mkdir() + (root / "CLAUDE.md").write_text(CLAUDE_MD, encoding="utf-8") + (root / "settings.json").write_text(json.dumps({ + "permissions": { + "allow": [ + "Bash(npm run build)", + "Bash(npm run test:*)", + "Bash(git diff *)", + "Read(~/.zshrc)", # non-Bash → unmapped + ], + "deny": [ + "Bash(rm -rf *)", + "WebFetch", # non-Bash → dropped + ], + }, + "mcpServers": { + "settings-server": {"command": "uvx", "args": ["settings-mcp"]}, + }, + }), encoding="utf-8") + # mcpServers in the sibling ~/.claude.json (Claude's primary MCP store) + (profile_env / ".claude.json").write_text(json.dumps({ + "mcpServers": { + "github": { + "command": "npx", + "args": ["-y", "@modelcontextprotocol/server-github"], + "env": { + "GITHUB_TOKEN": "ghp_SECRET123", + "GITHUB_HOST": "github.example.com", + }, + }, + "remote": { + "url": "https://mcp.example.com/sse", + "headers": { + "Authorization": "Bearer abc123", + "X-Region": "us-east", + }, + }, + }, + }), encoding="utf-8") + # A credentials file that must never be read/imported + (root / ".credentials.json").write_text( + json.dumps({"api_key": "sk-ant-SUPERSECRET"}), encoding="utf-8") + # Skills + skill = root / "skills" / "deploy-helper" + skill.mkdir(parents=True) + (skill / "SKILL.md").write_text( + "---\nname: deploy-helper\n---\n\nDeploy things.\n", encoding="utf-8") + (root / "skills" / "not-a-skill").mkdir() # no SKILL.md → ignored + # Slash commands (reported as skipped) + commands = root / "commands" + commands.mkdir() + (commands / "review.md").write_text("Review this PR", encoding="utf-8") + return root + + +@pytest.fixture() +def codex_tree(profile_env): + """Build a fake ~/.codex tree.""" + root = profile_env / ".codex" + root.mkdir() + (root / "AGENTS.md").write_text(AGENTS_MD, encoding="utf-8") + (root / "config.toml").write_text( + 'model = "gpt-5"\n' + 'approval_policy = "on-request"\n' + "\n" + "[mcp_servers.docs]\n" + 'command = "uvx"\n' + 'args = ["docs-mcp"]\n' + "\n" + "[mcp_servers.docs.env]\n" + 'DOCS_API_KEY = "secret-value"\n' + 'DOCS_REGION = "eu"\n', + encoding="utf-8", + ) + (root / "auth.json").write_text( + json.dumps({"OPENAI_API_KEY": "sk-SECRET"}), encoding="utf-8") + memories = root / "memories" + memories.mkdir() + (memories / "2026-01-01.md").write_text( + "- User prefers tabs over spaces\n- Project uses PostgreSQL\n", + encoding="utf-8", + ) + skill = root / "skills" / "db-migrate" + skill.mkdir(parents=True) + (skill / "SKILL.md").write_text( + "---\nname: db-migrate\n---\n\nMigrate databases.\n", encoding="utf-8") + return root + + +def snapshot_tree(root: Path) -> dict: + """Map of relative-path -> bytes for every file under root.""" + return { + str(p.relative_to(root)): p.read_bytes() + for p in sorted(root.rglob("*")) if p.is_file() + } + + +def run_import(agent, source, hermes_home, execute, overwrite=False): + return AgentImporter( + agent=agent, + source_root=source, + target_root=hermes_home, + execute=execute, + overwrite=overwrite, + ).run() + + +# --------------------------------------------------------------------------- +# Detection & helpers +# --------------------------------------------------------------------------- + +class TestDetection: + def test_detects_claude_and_codex(self, claude_tree, codex_tree): + assert detect_agents() == ["claude-code", "codex"] + + def test_detects_nothing_when_absent(self, profile_env): + assert detect_agents() == [] + + def test_unsupported_agent_raises(self, hermes_home, tmp_path): + with pytest.raises(ValueError): + AgentImporter("cursor", tmp_path, hermes_home) + + +class TestRuleMapping: + def test_bash_rule_plain(self): + assert claude_rule_to_command_pattern("Bash(npm run build)") == "npm run build" + + def test_bash_rule_colon_star_prefix(self): + assert claude_rule_to_command_pattern("Bash(npm run test:*)") == "npm run test*" + + def test_non_bash_rule_is_none(self): + assert claude_rule_to_command_pattern("Read(~/.zshrc)") is None + assert claude_rule_to_command_pattern("WebFetch") is None + + def test_blanket_bash_is_none(self): + assert claude_rule_to_command_pattern("Bash()") is None + + +class TestSecretDetection: + @pytest.mark.parametrize("key", [ + "GITHUB_TOKEN", "OPENAI_API_KEY", "MY_SECRET", "DB_PASSWORD", + "AWS_ACCESS_KEY", "AUTH_HEADER", "APIKEY", + ]) + def test_secret_keys(self, key): + assert is_secret_key(key) + + @pytest.mark.parametrize("key", ["GITHUB_HOST", "REGION", "DEBUG", "PORT"]) + def test_non_secret_keys(self, key): + assert not is_secret_key(key) + + def test_sanitize_env_splits(self): + kept, stripped = sanitize_mcp_env( + {"API_TOKEN": "x", "HOST": "h", "MY_KEY": "k"}) + assert kept == {"HOST": "h"} + assert sorted(stripped) == ["API_TOKEN", "MY_KEY"] + + +class TestMarkdownEntries: + def test_extracts_bullets_and_paragraphs(self): + entries = extract_markdown_entries(CLAUDE_MD) + assert any("type hints" in e for e in entries) + assert any("linter" in e for e in entries) + + def test_heading_context_prefix(self): + entries = extract_markdown_entries(CLAUDE_MD) + assert any(e.startswith("Global instructions > Style:") for e in entries) + + +# --------------------------------------------------------------------------- +# Dry run writes NOTHING +# --------------------------------------------------------------------------- + +class TestDryRun: + def test_claude_dry_run_writes_nothing(self, claude_tree, hermes_home): + before = snapshot_tree(hermes_home) + report = run_import("claude-code", claude_tree, hermes_home, execute=False) + assert snapshot_tree(hermes_home) == before + assert report["dry_run"] is True + assert report["summary"]["imported"] > 0 + + def test_codex_dry_run_writes_nothing(self, codex_tree, hermes_home): + before = snapshot_tree(hermes_home) + report = run_import("codex", codex_tree, hermes_home, execute=False) + assert snapshot_tree(hermes_home) == before + assert report["dry_run"] is True + assert report["summary"]["imported"] > 0 + + def test_dry_run_and_real_run_plan_same_items(self, claude_tree, hermes_home): + preview = run_import("claude-code", claude_tree, hermes_home, execute=False) + applied = run_import("claude-code", claude_tree, hermes_home, execute=True) + pk = [(i["kind"], i["status"]) for i in preview["items"]] + ak = [(i["kind"], i["status"]) for i in applied["items"]] + assert pk == ak + + +# --------------------------------------------------------------------------- +# Claude Code real run — every item lands in the right store +# --------------------------------------------------------------------------- + +class TestClaudeCodeImport: + @pytest.fixture() + def report(self, claude_tree, hermes_home): + return run_import("claude-code", claude_tree, hermes_home, execute=True) + + def test_claude_md_becomes_memory_entries(self, report, hermes_home): + memory = (hermes_home / "memories" / "MEMORY.md").read_text(encoding="utf-8") + assert "type hints" in memory + assert "§" in memory # entry-delimited store format + + def test_allowlist_lands_in_config_yaml(self, report, hermes_home): + config = yaml.safe_load((hermes_home / "config.yaml").read_text()) + allow = config["command_allowlist"] + assert "npm run build" in allow + assert "npm run test*" in allow + assert "git diff *" in allow + # non-Bash rules must not leak in + assert not any("Read(" in p for p in allow) + + def test_denylist_lands_in_approvals_deny(self, report, hermes_home): + config = yaml.safe_load((hermes_home / "config.yaml").read_text()) + assert "rm -rf *" in config["approvals"]["deny"] + + def test_mcp_servers_from_claude_json_and_settings(self, report, hermes_home): + config = yaml.safe_load((hermes_home / "config.yaml").read_text()) + servers = config["mcp_servers"] + assert servers["github"]["command"] == "npx" + assert servers["remote"]["url"] == "https://mcp.example.com/sse" + assert servers["settings-server"]["command"] == "uvx" + + def test_skill_copied_into_category_dir(self, report, hermes_home): + dest = hermes_home / "skills" / "claude-code-imports" / "deploy-helper" / "SKILL.md" + assert dest.exists() + assert "Deploy things" in dest.read_text(encoding="utf-8") + + def test_dir_without_skill_md_not_copied(self, report, hermes_home): + assert not (hermes_home / "skills" / "claude-code-imports" / "not-a-skill").exists() + + def test_slash_commands_reported_skipped(self, report): + items = {i["kind"]: i for i in report["items"]} + assert items["slash-commands"]["status"] == "skipped" + + +# --------------------------------------------------------------------------- +# Codex real run +# --------------------------------------------------------------------------- + +class TestCodexImport: + @pytest.fixture() + def report(self, codex_tree, hermes_home): + return run_import("codex", codex_tree, hermes_home, execute=True) + + def test_agents_md_becomes_memory_entries(self, report, hermes_home): + memory = (hermes_home / "memories" / "MEMORY.md").read_text(encoding="utf-8") + assert "force-push" in memory + + def test_memories_dir_merged(self, report, hermes_home): + memory = (hermes_home / "memories" / "MEMORY.md").read_text(encoding="utf-8") + assert "tabs over spaces" in memory + assert "PostgreSQL" in memory + + def test_mcp_servers_from_config_toml(self, report, hermes_home): + config = yaml.safe_load((hermes_home / "config.yaml").read_text()) + docs = config["mcp_servers"]["docs"] + assert docs["command"] == "uvx" + assert docs["args"] == ["docs-mcp"] + # non-secret env survives, secret is stripped + assert docs["env"] == {"DOCS_REGION": "eu"} + + def test_skill_copied(self, report, hermes_home): + assert (hermes_home / "skills" / "codex-imports" / "db-migrate" / "SKILL.md").exists() + + +# --------------------------------------------------------------------------- +# Secrets are never copied +# --------------------------------------------------------------------------- + +class TestSecretsNeverImported: + def test_no_secret_values_anywhere_claude(self, claude_tree, hermes_home): + run_import("claude-code", claude_tree, hermes_home, execute=True) + blob = "".join( + p.read_text(encoding="utf-8", errors="replace") + for p in hermes_home.rglob("*") if p.is_file() + ) + assert "ghp_SECRET123" not in blob + assert "Bearer abc123" not in blob + assert "sk-ant-SUPERSECRET" not in blob + + def test_no_secret_values_anywhere_codex(self, codex_tree, hermes_home): + run_import("codex", codex_tree, hermes_home, execute=True) + blob = "".join( + p.read_text(encoding="utf-8", errors="replace") + for p in hermes_home.rglob("*") if p.is_file() + ) + assert "secret-value" not in blob + assert "sk-SECRET" not in blob + + def test_stripped_secrets_reported(self, claude_tree, hermes_home): + report = run_import("claude-code", claude_tree, hermes_home, execute=True) + stripped = report.get("stripped_secrets", []) + assert "mcp_servers.github.env.GITHUB_TOKEN" in stripped + assert any("Authorization" in s for s in stripped) + + def test_non_secret_header_kept(self, claude_tree, hermes_home): + run_import("claude-code", claude_tree, hermes_home, execute=True) + config = yaml.safe_load((hermes_home / "config.yaml").read_text()) + assert config["mcp_servers"]["remote"]["headers"] == {"X-Region": "us-east"} + + +# --------------------------------------------------------------------------- +# Malformed inputs: per-item skip/error reports, no crashes +# --------------------------------------------------------------------------- + +class TestMalformedInputs: + def test_bad_settings_json_reports_error(self, profile_env, hermes_home): + root = profile_env / ".claude" + root.mkdir() + (root / "settings.json").write_text("{not json!!", encoding="utf-8") + (root / "CLAUDE.md").write_text("- still importable\n", encoding="utf-8") + report = run_import("claude-code", root, hermes_home, execute=True) + errors = [i for i in report["items"] if i["status"] == "error"] + assert any(i["kind"] == "settings" for i in errors) + # CLAUDE.md still imported despite bad settings.json + assert "still importable" in ( + hermes_home / "memories" / "MEMORY.md").read_text() + + def test_bad_claude_json_reports_error(self, profile_env, hermes_home): + root = profile_env / ".claude" + root.mkdir() + (profile_env / ".claude.json").write_text("][", encoding="utf-8") + (root / "CLAUDE.md").write_text("- an entry\n", encoding="utf-8") + report = run_import("claude-code", root, hermes_home, execute=True) + assert any( + i["status"] == "error" and ".claude.json" in (i["source"] or "") + for i in report["items"] + ) + assert report["summary"]["imported"] >= 1 + + def test_bad_config_toml_reports_error(self, profile_env, hermes_home): + root = profile_env / ".codex" + root.mkdir() + (root / "config.toml").write_text("[[[[not toml", encoding="utf-8") + (root / "AGENTS.md").write_text("- rule one\n", encoding="utf-8") + report = run_import("codex", root, hermes_home, execute=True) + errors = [i for i in report["items"] if i["status"] == "error"] + assert any(i["kind"] == "config" for i in errors) + assert "rule one" in (hermes_home / "memories" / "MEMORY.md").read_text() + + def test_missing_source_dir_is_error_not_crash(self, profile_env, hermes_home): + report = run_import( + "claude-code", profile_env / "nope", hermes_home, execute=True) + assert report["summary"]["error"] == 1 + assert report["summary"]["imported"] == 0 + + def test_empty_tree_all_skipped(self, profile_env, hermes_home): + root = profile_env / ".codex" + root.mkdir() + report = run_import("codex", root, hermes_home, execute=True) + assert report["summary"]["imported"] == 0 + assert report["summary"]["error"] == 0 + + +# --------------------------------------------------------------------------- +# Merge semantics & conflicts +# --------------------------------------------------------------------------- + +class TestMergeSemantics: + def test_existing_allowlist_preserved(self, claude_tree, hermes_home): + (hermes_home / "config.yaml").write_text( + yaml.safe_dump({"command_allowlist": ["docker ps"]}), encoding="utf-8") + run_import("claude-code", claude_tree, hermes_home, execute=True) + config = yaml.safe_load((hermes_home / "config.yaml").read_text()) + assert "docker ps" in config["command_allowlist"] + assert "npm run build" in config["command_allowlist"] + + def test_existing_mcp_server_conflicts_without_overwrite( + self, claude_tree, hermes_home): + (hermes_home / "config.yaml").write_text( + yaml.safe_dump({"mcp_servers": {"github": {"command": "mine"}}}), + encoding="utf-8") + report = run_import("claude-code", claude_tree, hermes_home, execute=True) + config = yaml.safe_load((hermes_home / "config.yaml").read_text()) + assert config["mcp_servers"]["github"]["command"] == "mine" + assert any( + i["status"] == "conflict" and i["source"] == "github" + for i in report["items"] + ) + + def test_overwrite_replaces_mcp_server(self, claude_tree, hermes_home): + (hermes_home / "config.yaml").write_text( + yaml.safe_dump({"mcp_servers": {"github": {"command": "mine"}}}), + encoding="utf-8") + run_import("claude-code", claude_tree, hermes_home, execute=True, + overwrite=True) + config = yaml.safe_load((hermes_home / "config.yaml").read_text()) + assert config["mcp_servers"]["github"]["command"] == "npx" + + def test_existing_skill_conflicts_without_overwrite( + self, claude_tree, hermes_home): + dest = hermes_home / "skills" / "claude-code-imports" / "deploy-helper" + dest.mkdir(parents=True) + (dest / "SKILL.md").write_text("mine\n", encoding="utf-8") + report = run_import("claude-code", claude_tree, hermes_home, execute=True) + assert (dest / "SKILL.md").read_text() == "mine\n" + assert any( + i["kind"] == "skill" and i["status"] == "conflict" + for i in report["items"] + ) + + def test_reimport_is_idempotent_for_memory(self, claude_tree, hermes_home): + run_import("claude-code", claude_tree, hermes_home, execute=True) + first = (hermes_home / "memories" / "MEMORY.md").read_text() + report = run_import("claude-code", claude_tree, hermes_home, execute=True) + assert (hermes_home / "memories" / "MEMORY.md").read_text() == first + memory_items = [i for i in report["items"] if i["kind"] == "claude-md"] + assert memory_items[0]["status"] == "skipped" + + +# --------------------------------------------------------------------------- +# CLI wiring +# --------------------------------------------------------------------------- + +class TestCliWiring: + def test_parser_builds_and_parses(self): + import argparse + from hermes_cli.subcommands.import_agent import build_import_agent_parser + + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + called = {} + build_import_agent_parser( + subparsers, cmd_import_agent=lambda a: called.setdefault("ok", a)) + args = parser.parse_args( + ["import-agent", "claude-code", "--dry-run", "--source", "/tmp/x"]) + assert args.agent == "claude-code" + assert args.dry_run is True + assert args.source == "/tmp/x" + args.func(args) + assert "ok" in called + + def test_rejects_unknown_agent(self): + import argparse + from hermes_cli.subcommands.import_agent import build_import_agent_parser + + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + build_import_agent_parser(subparsers, cmd_import_agent=lambda a: None) + with pytest.raises(SystemExit): + parser.parse_args(["import-agent", "cursor"]) + + def test_command_dry_run_via_cli_writes_nothing( + self, claude_tree, hermes_home, capsys): + """End-to-end through import_agent_command with --dry-run.""" + import types + from hermes_cli.agent_import import import_agent_command + + args = types.SimpleNamespace( + agent="claude-code", source=str(claude_tree), dry_run=True, + overwrite=False, yes=False) + import_agent_command(args) + out = capsys.readouterr().out + assert "Dry Run Results" in out + assert "command-allowlist" in out + # Baseline config.yaml/SOUL.md may be seeded by save_config() before + # the preview runs — but nothing from the IMPORT itself may land: + assert not (hermes_home / "memories" / "MEMORY.md").exists() + assert not (hermes_home / "skills" / "claude-code-imports").exists() + config_text = (hermes_home / "config.yaml").read_text(encoding="utf-8") \ + if (hermes_home / "config.yaml").exists() else "" + assert "npm run build" not in config_text + assert "github" not in config_text diff --git a/tests/hermes_cli/test_approvals_suggest.py b/tests/hermes_cli/test_approvals_suggest.py new file mode 100644 index 0000000000..4df202ab1f --- /dev/null +++ b/tests/hermes_cli/test_approvals_suggest.py @@ -0,0 +1,409 @@ +"""Tests for ``hermes approvals suggest`` (hermes_cli/approvals_suggest.py). + +Approval history in Hermes is implied, not ledgered: the session DB +(state.db) stores every assistant ``terminal`` tool call plus its paired +``role='tool'`` result. A dangerous-classified command whose result is not a +BLOCKED/denied/pending marker ran with user consent. These tests build +synthetic state.db fixtures and verify scanning, ranking, safety exclusions, +and the --apply merge path. +""" + +from __future__ import annotations + +import json +import sqlite3 +import time +from argparse import Namespace + +import pytest + +import tools.approval as approval_module +from hermes_cli.approvals_suggest import ( + Proposal, + apply_proposals, + build_proposals, + derive_glob, + is_unsafe_class, + normalize_command, + parse_apply_indices, + scan_approval_history, + suggest_command, +) + + +# --------------------------------------------------------------------------- +# Fixture helpers: synthetic session DB +# --------------------------------------------------------------------------- + +def _make_db(path): + con = sqlite3.connect(path) + con.executescript( + """ + CREATE TABLE messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + session_id TEXT NOT NULL, + role TEXT NOT NULL, + content TEXT, + tool_call_id TEXT, + tool_calls TEXT, + timestamp REAL NOT NULL + ); + """ + ) + con.commit() + return con + + +_ID_COUNTER = [0] + + +def _add_terminal_call(con, command, result="ok: done", ts=None): + """Insert an assistant terminal tool call + its paired tool result.""" + _ID_COUNTER[0] += 1 + call_id = f"call_{_ID_COUNTER[0]}" + ts = ts if ts is not None else time.time() + tool_calls = json.dumps( + [ + { + "id": call_id, + "type": "function", + "function": { + "name": "terminal", + "arguments": json.dumps({"command": command}), + }, + } + ] + ) + con.execute( + "INSERT INTO messages (session_id, role, content, tool_calls, timestamp) " + "VALUES ('s1', 'assistant', '', ?, ?)", + (tool_calls, ts), + ) + con.execute( + "INSERT INTO messages (session_id, role, content, tool_call_id, timestamp) " + "VALUES ('s1', 'tool', ?, ?, ?)", + (result, call_id, ts + 1), + ) + con.commit() + + +@pytest.fixture +def db_path(tmp_path): + path = tmp_path / "state.db" + con = _make_db(path) + yield path, con + con.close() + + +@pytest.fixture +def isolated_allowlist(monkeypatch): + """Fake config-backed allowlist store so no real config.yaml is touched.""" + store = {"patterns": set(), "saves": 0} + + def fake_load(): + return set(store["patterns"]) + + def fake_save(patterns): + store["patterns"] = set(patterns) + store["saves"] += 1 + + monkeypatch.setattr(approval_module, "load_permanent_allowlist", fake_load) + monkeypatch.setattr(approval_module, "save_permanent_allowlist", fake_save) + # apply_proposals also syncs into the in-process set; keep it isolated. + saved = approval_module._permanent_approved.copy() + approval_module._permanent_approved.clear() + yield store + approval_module._permanent_approved.clear() + approval_module._permanent_approved.update(saved) + + +# --------------------------------------------------------------------------- +# Scan +# --------------------------------------------------------------------------- + +class TestScan: + def test_scan_finds_approved_dangerous_commands(self, db_path): + path, con = db_path + for _ in range(3): + _add_terminal_call(con, "git push --force origin main") + # A benign command never enters approval history. + _add_terminal_call(con, "ls -la") + records = scan_approval_history(path, days=0) + commands = [c for c, _ in records] + assert len(commands) == 3 + assert all("git push" in c for c in commands) + + def test_blocked_and_denied_results_are_not_approvals(self, db_path): + path, con = db_path + _add_terminal_call( + con, + "git push --force origin main", + result="BLOCKED: User denied this potentially dangerous action", + ) + _add_terminal_call( + con, + "docker restart web", + result=( + "⚠️ This action is potentially dangerous. " + "Asking the user for approval." + ), + ) + assert scan_approval_history(path, days=0) == [] + + def test_days_window_filters_old_history(self, db_path): + path, con = db_path + old_ts = time.time() - 200 * 86400 + _add_terminal_call(con, "git push --force origin main", ts=old_ts) + _add_terminal_call(con, "git push --force origin main") + assert len(scan_approval_history(path, days=90)) == 1 + assert len(scan_approval_history(path, days=0)) == 2 + + def test_missing_db_returns_empty(self, tmp_path): + assert scan_approval_history(tmp_path / "nope.db", days=0) == [] + + +# --------------------------------------------------------------------------- +# Normalize / glob derivation +# --------------------------------------------------------------------------- + +class TestNormalizeAndGlob: + def test_normalize_folds_home_prefix(self): + import os + + home = os.path.expanduser("~") + normalized = normalize_command(f"git checkout -- {home}/project/file.txt") + assert "~/project/file.txt" in normalized + assert home not in normalized + + def test_derive_glob_uses_first_two_tokens(self): + assert derive_glob("git push --force origin main") == "git push *" + assert derive_glob("docker restart web") == "docker restart *" + + def test_derive_glob_flag_second_token_falls_back_to_root(self): + assert derive_glob("hermes --yolo update") == "hermes --yolo".split()[0] + " *" + + def test_derive_glob_rejects_compound_commands(self): + assert derive_glob("git push --force && rm -rf /tmp/x") is None + assert derive_glob("echo hi; docker restart web") is None + + def test_derive_glob_never_anchors_unsafe_binaries(self): + assert derive_glob("rm -rf ./build") is None + assert derive_glob("sudo apt install foo") is None + assert derive_glob("/bin/rm -rf ./build") is None + assert derive_glob("mkfs.ext4 /dev/sdb1") is None + + +# --------------------------------------------------------------------------- +# Ranking + safety exclusion +# --------------------------------------------------------------------------- + +class TestRankingAndSafety: + def test_ranking_orders_by_frequency(self, db_path): + path, con = db_path + for _ in range(5): + _add_terminal_call(con, "docker restart web") + for _ in range(2): + _add_terminal_call(con, "git push --force origin main") + records = scan_approval_history(path, days=0) + proposals = build_proposals(records, min_count=2) + assert [p.pattern for p in proposals] == ["docker restart *", "git push *"] + assert proposals[0].count == 5 + assert proposals[1].count == 2 + + def test_min_count_threshold(self, db_path): + path, con = db_path + _add_terminal_call(con, "git push --force origin main") + records = scan_approval_history(path, days=0) + assert build_proposals(records, min_count=2) == [] + assert len(build_proposals(records, min_count=1)) == 1 + + def test_rm_rf_never_proposed_even_after_100_approvals(self, db_path): + path, con = db_path + for _ in range(100): + _add_terminal_call(con, "rm -rf ./build") + records = scan_approval_history(path, days=0) + # The commands ARE mined (they ran with approval) ... + assert len(records) == 100 + # ... but the destructive class is unconditionally excluded. + proposals = build_proposals(records, min_count=1) + assert proposals == [] + + def test_unsafe_classes_are_excluded(self): + for desc in ( + "recursive delete", + "git reset --hard (destroys uncommitted changes)", + "sudo with privilege flag (stdin/askpass/shell/list)", + "pipe remote content to shell", + "overwrite system config", + "SQL DROP", + "in-place edit of sensitive credential/SSH/shell-rc path", + "format filesystem", + "kill all processes", + "write to block device", + ): + assert is_unsafe_class(desc), desc + + def test_benign_classes_are_not_excluded(self): + for desc in ( + "git force push (rewrites remote history)", + "docker restart/stop/kill (container lifecycle)", + "hermes update (restarts gateway, kills running agents)", + "stop/restart system service", + ): + assert not is_unsafe_class(desc), desc + + def test_existing_allowlist_entries_are_skipped(self, db_path): + path, con = db_path + for _ in range(3): + _add_terminal_call(con, "git push --force origin main") + records = scan_approval_history(path, days=0) + proposals = build_proposals(records, existing={"git push *"}, min_count=1) + assert proposals == [] + + def test_hardline_commands_never_mined(self, db_path): + path, con = db_path + # Even if a hardline command somehow shows an executed result in the + # DB, the miner refuses it (defense in depth). + for _ in range(5): + _add_terminal_call(con, "rm -rf /") + assert scan_approval_history(path, days=0) == [] + + +# --------------------------------------------------------------------------- +# --apply / dry-run +# --------------------------------------------------------------------------- + +def _args(db, **kw): + base = dict( + db=str(db), days=0, min_count=1, limit=20, + apply_indices=None, json=False, + ) + base.update(kw) + return Namespace(**base) + + +class TestApply: + def test_parse_apply_indices(self): + assert parse_apply_indices("1,3", 5) == [0, 2] + assert parse_apply_indices(" 2 ", 2) == [1] + with pytest.raises(ValueError): + parse_apply_indices("0", 3) + with pytest.raises(ValueError): + parse_apply_indices("4", 3) + with pytest.raises(ValueError): + parse_apply_indices("a,b", 3) + with pytest.raises(ValueError): + parse_apply_indices("", 3) + + def test_apply_merges_and_persists(self, isolated_allowlist): + isolated_allowlist["patterns"] = {"podman *"} + proposals = [ + Proposal(pattern="git push *", kind="glob", count=5), + Proposal(pattern="docker restart *", kind="glob", count=3), + ] + merged = apply_proposals(proposals, [0]) + assert merged == {"podman *", "git push *"} + assert isolated_allowlist["patterns"] == {"podman *", "git push *"} + assert isolated_allowlist["saves"] == 1 + # In-process allowlist synced too (long-lived process consistency). + assert "git push *" in approval_module._permanent_approved + + def test_suggest_apply_end_to_end(self, db_path, isolated_allowlist, capsys): + path, con = db_path + for _ in range(4): + _add_terminal_call(con, "git push --force origin main") + for _ in range(3): + _add_terminal_call(con, "docker restart web") + rc = suggest_command(_args(path, apply_indices="1,2")) + assert rc == 0 + assert isolated_allowlist["patterns"] == {"git push *", "docker restart *"} + out = capsys.readouterr().out + assert "git push *" in out and "docker restart *" in out + + def test_dry_default_writes_nothing(self, db_path, isolated_allowlist, capsys): + path, con = db_path + for _ in range(4): + _add_terminal_call(con, "git push --force origin main") + rc = suggest_command(_args(path)) + assert rc == 0 + assert isolated_allowlist["saves"] == 0 + assert isolated_allowlist["patterns"] == set() + out = capsys.readouterr().out + assert "git push *" in out + assert "Nothing has been changed" in out + + def test_apply_out_of_range_errors_without_writing( + self, db_path, isolated_allowlist, capsys + ): + path, con = db_path + for _ in range(4): + _add_terminal_call(con, "git push --force origin main") + rc = suggest_command(_args(path, apply_indices="7")) + assert rc == 1 + assert isolated_allowlist["saves"] == 0 + + +class TestJsonOutput: + def test_json_proposal_output(self, db_path, isolated_allowlist, capsys): + path, con = db_path + for _ in range(4): + _add_terminal_call(con, "git push --force origin main") + rc = suggest_command(_args(path, json=True)) + assert rc == 0 + payload = json.loads(capsys.readouterr().out) + assert payload["proposals"][0]["pattern"] == "git push *" + assert payload["proposals"][0]["count"] == 4 + assert payload["proposals"][0]["n"] == 1 + assert isolated_allowlist["saves"] == 0 + + def test_json_apply_output(self, db_path, isolated_allowlist, capsys): + path, con = db_path + for _ in range(4): + _add_terminal_call(con, "git push --force origin main") + rc = suggest_command(_args(path, apply_indices="1", json=True)) + assert rc == 0 + payload = json.loads(capsys.readouterr().out) + assert payload["applied"] == ["git push *"] + assert isolated_allowlist["patterns"] == {"git push *"} + + +# --------------------------------------------------------------------------- +# Parser wiring +# --------------------------------------------------------------------------- + +class TestParserWiring: + def test_build_approvals_parser_wires_suggest(self): + import argparse + + from hermes_cli.subcommands.approvals import build_approvals_parser + + sentinel = object() + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + build_approvals_parser(subparsers, cmd_approvals=lambda a: sentinel) + + args = parser.parse_args( + ["approvals", "suggest", "--apply", "1,3", "--json", + "--days", "30", "--min-count", "5", "--limit", "10"] + ) + assert args.approvals_command == "suggest" + assert args.apply_indices == "1,3" + assert args.json is True + assert args.days == 30 + assert args.min_count == 5 + assert args.limit == 10 + assert args.func(args) is sentinel + + def test_suggest_defaults_are_dry_and_bounded(self): + import argparse + + from hermes_cli.subcommands.approvals import build_approvals_parser + + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + build_approvals_parser(subparsers, cmd_approvals=lambda a: None) + args = parser.parse_args(["approvals", "suggest"]) + assert args.apply_indices is None + assert args.json is False + assert args.days == 90 + assert args.min_count == 2 diff --git a/tests/hermes_cli/test_commands.py b/tests/hermes_cli/test_commands.py index d6587d503b..b962f3fbdf 100644 --- a/tests/hermes_cli/test_commands.py +++ b/tests/hermes_cli/test_commands.py @@ -120,6 +120,16 @@ class TestResolveCommand: assert topic.name == "topic" assert "topic" in GATEWAY_KNOWN_COMMANDS + def test_context_command_registered_with_ctx_alias(self): + ctx = resolve_command("context") + assert ctx is not None + assert ctx.name == "context" + assert resolve_command("ctx").name == "context" + assert "all" in (ctx.subcommands or ()) + # Available on both CLI and gateway surfaces + assert not ctx.cli_only and not ctx.gateway_only + assert "context" in GATEWAY_KNOWN_COMMANDS + def test_leading_slash_stripped(self): assert resolve_command("/help").name == "help" assert resolve_command("/bg").name == "background" diff --git a/tests/hermes_cli/test_config.py b/tests/hermes_cli/test_config.py index e62fa1a3d7..22935d0bbe 100644 --- a/tests/hermes_cli/test_config.py +++ b/tests/hermes_cli/test_config.py @@ -2385,3 +2385,35 @@ class TestProviderEnabledRuntimeGate: assert "disabled" not in str(e).lower() except Exception: pass # any non-ValueError is fine; we only gate the disabled path + + +# --------------------------------------------------------------------------- +# DEFAULT_CONFIG must not carry a duplicate "kanban" key +# --------------------------------------------------------------------------- + +def test_default_config_kanban_block_not_dropped_by_duplicate_key(): + """DEFAULT_CONFIG previously declared ``"kanban"`` twice, so Python kept + only the second literal and silently dropped the first — losing the + ``auto_subscribe_on_create`` default. Both sets of defaults must survive. + """ + kanban = DEFAULT_CONFIG["kanban"] + # From the first (dropped) block: + assert kanban.get("auto_subscribe_on_create") is True + # From the second block: + assert "dispatch_in_gateway" in kanban + assert "auto_decompose" in kanban + + +def test_default_config_has_no_duplicate_top_level_keys(): + """Guard against any duplicate key silently shadowing a default.""" + import ast + import hermes_cli.config as cfg_mod + + src = open(cfg_mod.__file__, encoding="utf-8").read() + tree = ast.parse(src) + for node in ast.walk(tree): + if isinstance(node, ast.Dict): + keys = [k.value for k in node.keys if isinstance(k, ast.Constant)] + if "model" in keys and "kanban" in keys: # the DEFAULT_CONFIG literal + dupes = {k for k in keys if keys.count(k) > 1} + assert not dupes, f"duplicate DEFAULT_CONFIG keys: {sorted(dupes)}" diff --git a/tests/hermes_cli/test_dashboard_admin_endpoints.py b/tests/hermes_cli/test_dashboard_admin_endpoints.py index 974fe734dd..693a056cbf 100644 --- a/tests/hermes_cli/test_dashboard_admin_endpoints.py +++ b/tests/hermes_cli/test_dashboard_admin_endpoints.py @@ -740,6 +740,8 @@ class TestSessionManagementEndpoints: body = r.json() assert body["matched"] >= 1 assert "oldest_started_at" in body and "newest_started_at" in body + assert "oldest_last_active" in body and "newest_last_active" in body + assert all("last_active" in session for session in body["sessions"]) def test_prune_explicit_older_than_kept_with_attr_filter(self): # Explicit older_than_days is honored even alongside attribute filters. diff --git a/tests/hermes_cli/test_dashboard_lifecycle_flags.py b/tests/hermes_cli/test_dashboard_lifecycle_flags.py index 1d2745a987..8bd741d041 100644 --- a/tests/hermes_cli/test_dashboard_lifecycle_flags.py +++ b/tests/hermes_cli/test_dashboard_lifecycle_flags.py @@ -30,8 +30,7 @@ def _ns(**kw): class TestDashboardStatus: def test_status_no_processes(self, capsys): - with patch("hermes_cli.main._find_stale_dashboard_pids", - return_value=[]), \ + with patch("hermes_cli.main._scan_dashboard_processes", return_value=[]), \ pytest.raises(SystemExit) as exc: cmd_dashboard(_ns(status=True)) assert exc.value.code == 0 @@ -39,8 +38,13 @@ class TestDashboardStatus: assert "No hermes dashboard processes running" in out def test_status_with_processes(self, capsys): - with patch("hermes_cli.main._find_stale_dashboard_pids", - return_value=[12345, 12346]), \ + processes = [ + (12345, "hermes dashboard --port 9119"), + (12346, "python -m hermes_cli.main dashboard --host 0.0.0.0 --port 9120"), + ] + with patch("hermes_cli.main._scan_dashboard_processes", return_value=processes), \ + patch("gateway.status._pid_exists", return_value=True), \ + patch("hermes_cli.main._dashboard_listening", return_value=True), \ pytest.raises(SystemExit) as exc: cmd_dashboard(_ns(status=True)) # Status is informational — always exits 0. @@ -50,6 +54,42 @@ class TestDashboardStatus: assert "PID 12345" in out assert "PID 12346" in out + def test_status_ignores_headless_serve_children_and_non_listeners(self, capsys): + processes = [ + (11111, "hermes serve --port 0"), + (22222, "hermes dashboard --port 9119"), + (33333, "hermes dashboard --port 9120"), + ] + + def fake_listening(host, port): + return port == 9119 + + with patch("hermes_cli.main._scan_dashboard_processes", return_value=processes), \ + patch("gateway.status._pid_exists", return_value=True), \ + patch("hermes_cli.main._dashboard_listening", side_effect=fake_listening), \ + pytest.raises(SystemExit) as exc: + cmd_dashboard(_ns(status=True)) + + assert exc.value.code == 0 + out = capsys.readouterr().out + assert "1 hermes dashboard process(es) running" in out + assert "PID 22222" in out + assert "PID 11111" not in out + assert "PID 33333" not in out + + def test_status_ignores_dead_pids(self, capsys): + with patch( + "hermes_cli.main._scan_dashboard_processes", + return_value=[(12345, "hermes dashboard --port 9119")], + ), \ + patch("gateway.status._pid_exists", return_value=False), \ + pytest.raises(SystemExit) as exc: + cmd_dashboard(_ns(status=True)) + + assert exc.value.code == 0 + out = capsys.readouterr().out + assert "No hermes dashboard processes running" in out + def test_status_does_not_try_to_import_fastapi(self): """`--status` must not require dashboard runtime deps — it's a process-table scan only. We prove this by making fastapi import @@ -60,8 +100,7 @@ class TestDashboardStatus: raise ImportError("fastapi missing") return orig_import(name, *a, **kw) - with patch("hermes_cli.main._find_stale_dashboard_pids", - return_value=[]), \ + with patch("hermes_cli.main._scan_dashboard_processes", return_value=[]), \ patch("builtins.__import__", side_effect=fake_import), \ pytest.raises(SystemExit) as exc: cmd_dashboard(_ns(status=True)) @@ -131,8 +170,7 @@ class TestLifecycleFlagsTakePrecedence: a new server.""" def test_status_wins_over_stop(self, capsys): - with patch("hermes_cli.main._find_stale_dashboard_pids", - return_value=[]), \ + with patch("hermes_cli.main._scan_dashboard_processes", return_value=[]), \ patch("hermes_cli.main._kill_stale_dashboard_processes") as mock_kill, \ pytest.raises(SystemExit): cmd_dashboard(_ns(status=True, stop=True)) @@ -174,8 +212,7 @@ class TestArgparseWiring: # be too invasive. Instead parse args as if via the CLI by # intercepting parse_args. This is overkill for a smoke test — # we just want to know the flags don't KeyError. - with patch("hermes_cli.main._find_stale_dashboard_pids", - return_value=[]), \ + with patch("hermes_cli.main._scan_dashboard_processes", return_value=[]), \ pytest.raises(SystemExit) as exc: mod.cmd_dashboard(_ns(status=True)) assert exc.value.code == 0 diff --git a/tests/hermes_cli/test_diff_command.py b/tests/hermes_cli/test_diff_command.py new file mode 100644 index 0000000000..f190c80135 --- /dev/null +++ b/tests/hermes_cli/test_diff_command.py @@ -0,0 +1,190 @@ +"""Tests for the CLI ``/diff`` command handler. + +``/diff`` shows git changes in the working directory (unstaged + untracked by +default; ``staged``/``all`` modes) and ``/diff session`` shows the cumulative +checkpoint-baseline diff of everything Hermes changed. These drive the mixin +handler against real git repos (default modes) and a stubbed checkpoint +manager (session mode), asserting rendering, ``--stat``, and graceful +degradation. +""" + +import contextlib +import io +import shutil +import subprocess + +import pytest + +from hermes_cli.cli_commands_mixin import CLICommandsMixin + +requires_git = pytest.mark.skipif( + shutil.which("git") is None, reason="git required" +) + + +class _Console: + def __init__(self, sink): + self._sink = sink + + def print(self, obj, **kwargs): + self._sink.write(getattr(obj, "plain", str(obj)) + "\n") + + +class _Mgr: + def __init__(self, result, enabled=True): + self.enabled = enabled + self._result = result + self.calls = [] + + def session_diff(self, cwd): + self.calls.append(cwd) + return self._result + + +class _Agent: + def __init__(self, mgr): + self._checkpoint_mgr = mgr + + +class _Stub(CLICommandsMixin): + def __init__(self, agent=None): + self.agent = agent + + +def _run(stub, command): + buf = io.StringIO() + stub.console = _Console(buf) + with contextlib.redirect_stdout(buf): + stub._handle_diff_command(command) + return buf.getvalue() + + +def _git(repo, *args): + subprocess.run(["git", *args], cwd=repo, check=True, capture_output=True, + env={"GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", + "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t", + "HOME": str(repo), + "PATH": __import__("os").environ["PATH"]}) + + +@pytest.fixture() +def repo(tmp_path, monkeypatch): + d = tmp_path / "repo" + d.mkdir() + _git(d, "init", "-q") + (d / "main.py").write_text("print('hello')\n") + _git(d, "add", "-A") + _git(d, "commit", "-q", "-m", "init") + monkeypatch.setenv("TERMINAL_CWD", str(d)) + return d + + +# --------------------------------------------------------------------------- +# Default (working-tree) mode — real git +# --------------------------------------------------------------------------- + +@requires_git +def test_diff_clean_repo_reports_no_changes(repo): + out = _run(_Stub(), "/diff") + assert "No changes" in out + + +@requires_git +def test_diff_shows_unstaged_changes(repo): + (repo / "main.py").write_text("print('changed')\n") + out = _run(_Stub(), "/diff") + assert "Unstaged" in out + assert "-print('hello')" in out + assert "+print('changed')" in out + + +@requires_git +def test_diff_lists_untracked_files(repo): + (repo / "newfile.py").write_text("n = 1\n") + out = _run(_Stub(), "/diff") + assert "Untracked" in out + assert "newfile.py" in out + assert "+n = 1" in out + + +@requires_git +def test_diff_stat_suppresses_body(repo): + (repo / "main.py").write_text("print('changed')\n") + out = _run(_Stub(), "/diff --stat") + assert "main.py" in out + assert "+print('changed')" not in out + + +@requires_git +def test_diff_staged_mode(repo): + (repo / "main.py").write_text("print('staged')\n") + _git(repo, "add", "main.py") + out = _run(_Stub(), "/diff staged") + assert "Staged" in out + assert "+print('staged')" in out + + +@requires_git +def test_diff_non_git_directory_is_graceful(tmp_path, monkeypatch): + plain = tmp_path / "plain" + plain.mkdir() + monkeypatch.setenv("TERMINAL_CWD", str(plain)) + out = _run(_Stub(), "/diff") + assert "not a git repository" in out.lower() + + +# --------------------------------------------------------------------------- +# Session mode — stubbed checkpoint manager +# --------------------------------------------------------------------------- + +def test_diff_session_prints_stat_and_diff(tmp_path, monkeypatch): + monkeypatch.setenv("TERMINAL_CWD", str(tmp_path)) + mgr = _Mgr({ + "success": True, + "stat": " main.py | 2 +-", + "diff": "--- a/main.py\n+++ b/main.py\n-print('hello')\n+print('v3')\n", + }) + out = _run(_Stub(_Agent(mgr)), "/diff session") + assert " main.py | 2 +-" in out + assert "+print('v3')" in out + assert mgr.calls # session_diff was consulted + + +def test_diff_session_stat_only_suppresses_body(tmp_path, monkeypatch): + monkeypatch.setenv("TERMINAL_CWD", str(tmp_path)) + mgr = _Mgr({ + "success": True, + "stat": " main.py | 2 +-", + "diff": "+print('v3')\n", + }) + out = _run(_Stub(_Agent(mgr)), "/diff session --stat") + assert " main.py | 2 +-" in out + assert "+print('v3')" not in out + + +def test_diff_session_empty_reports_no_changes(tmp_path, monkeypatch): + monkeypatch.setenv("TERMINAL_CWD", str(tmp_path)) + mgr = _Mgr({"success": True, "stat": "", "diff": "", "empty": True}) + out = _run(_Stub(_Agent(mgr)), "/diff session") + assert "No changes" in out + + +def test_diff_session_disabled_explains_how_to_enable(tmp_path, monkeypatch): + monkeypatch.setenv("TERMINAL_CWD", str(tmp_path)) + mgr = _Mgr({"success": True, "stat": "", "diff": ""}, enabled=False) + out = _run(_Stub(_Agent(mgr)), "/diff session") + assert "not enabled" in out.lower() + assert not mgr.calls # short-circuits before touching the store + + +def test_diff_session_without_agent_is_graceful(tmp_path, monkeypatch): + monkeypatch.setenv("TERMINAL_CWD", str(tmp_path)) + out = _run(_Stub(agent=None), "/diff session") + assert "No active agent session" in out + + +def test_diff_session_failure_surfaces_error(tmp_path, monkeypatch): + monkeypatch.setenv("TERMINAL_CWD", str(tmp_path)) + mgr = _Mgr({"success": False, "error": "boom"}) + out = _run(_Stub(_Agent(mgr)), "/diff session") + assert "boom" in out diff --git a/tests/hermes_cli/test_doctor.py b/tests/hermes_cli/test_doctor.py index c439aaf0ce..76ba521104 100644 --- a/tests/hermes_cli/test_doctor.py +++ b/tests/hermes_cli/test_doctor.py @@ -32,6 +32,26 @@ class TestDoctorPlatformHints: assert doctor._python_install_cmd() == "uv pip install" assert doctor._system_package_install_cmd("ripgrep") == "sudo apt install ripgrep" + def test_sqlite_upgrade_hint_recreates_docker_containers(self, monkeypatch): + monkeypatch.setattr(doctor, "detect_install_method", lambda _root: "docker") + + hint = doctor._sqlite_upgrade_hint() + + assert "docker pull nousresearch/hermes-agent:latest" in hint + assert "recreate all Hermes containers" in hint + assert "hermes update" not in hint + + def test_sqlite_upgrade_hint_keeps_git_runtime_repair(self): + hint = doctor._sqlite_upgrade_hint("git") + + assert "run `hermes update`" in hint + + def test_sqlite_upgrade_hint_uses_nix_package_manager(self): + hint = doctor._sqlite_upgrade_hint("nix") + + assert "Nix source that installed it" in hint + assert "hermes update" not in hint + class TestProviderEnvDetection: def test_detects_openai_api_key(self): diff --git a/tests/hermes_cli/test_init_command.py b/tests/hermes_cli/test_init_command.py new file mode 100644 index 0000000000..2123f3ce4d --- /dev/null +++ b/tests/hermes_cli/test_init_command.py @@ -0,0 +1,117 @@ +"""Tests for /init — generate or update AGENTS.md from a project scan. + +Covers the shared prompt builder (hermes_cli.init_command.build_init_prompt) +and the slash-command registry wiring. /init has no engine and no model tool: +it builds a guidance-laden prompt that the live agent runs as a normal turn +(the /learn pattern), so these are the load-bearing behavior contracts. +""" + +from hermes_cli.init_command import ( + _QUALITY_BAR, + build_init_prompt, + build_init_prompt_for_cwd, +) + + +class TestBuildInitPrompt: + def test_includes_the_cwd(self): + prompt = build_init_prompt("/home/alice/projects/acme") + assert "/home/alice/projects/acme" in prompt + + def test_mentions_agents_md(self): + prompt = build_init_prompt("/tmp/proj") + assert "AGENTS.md" in prompt + + def test_fresh_generation_when_no_existing_file(self): + prompt = build_init_prompt("/tmp/proj", existing_file=None) + assert "generate an AGENTS.md" in prompt + # No merge discipline block for a fresh file. + assert "MERGE DISCIPLINE" not in prompt + + def test_merge_not_overwrite_when_existing_file_passed(self): + existing = "# My Project\n\nAlways run `make lint` before committing.\n" + prompt = build_init_prompt("/tmp/proj", existing_file=existing) + low = prompt.lower() + # Update mode, with explicit merge-not-overwrite discipline. + assert "UPDATE the existing AGENTS.md" in prompt + assert "merge" in low + assert "do not overwrite" in low or "not overwrite" in low + assert "preserve" in low + # And it carries the current content so the agent can merge. + assert existing.strip() in prompt + + def test_empty_existing_file_still_triggers_update_mode(self): + # An existing-but-empty AGENTS.md is still an update, not a fresh gen + # (None means "no file"; "" means "empty file"). + prompt = build_init_prompt("/tmp/proj", existing_file="") + assert "UPDATE the existing AGENTS.md" in prompt + + def test_includes_extra_notes_verbatim(self): + notes = "focus on the test setup, and mention the flaky e2e suite" + prompt = build_init_prompt("/tmp/proj", extra=notes) + assert notes in prompt + + def test_no_notes_section_when_extra_empty(self): + assert "USER NOTES" not in build_init_prompt("/tmp/proj", extra=" ") + assert "USER NOTES" in build_init_prompt("/tmp/proj", extra="hi") + + def test_always_includes_the_quality_bar(self): + for existing in (None, "# old content"): + prompt = build_init_prompt("/tmp/proj", existing_file=existing) + assert _QUALITY_BAR in prompt + + def test_quality_bar_demands_exact_commands_and_conciseness(self): + low = _QUALITY_BAR.lower() + assert "100 lines" in low + assert "never invent" in low + assert "no generic advice" in low + + def test_references_read_only_scan_tools(self): + prompt = build_init_prompt("/tmp/proj") + for tool in ("read_file", "search_files", "write_file"): + assert tool in prompt + + +class TestBuildInitPromptForCwd: + def test_defaults_to_process_cwd(self, tmp_path, monkeypatch): + monkeypatch.chdir(tmp_path) + prompt = build_init_prompt_for_cwd() + assert str(tmp_path) in prompt + assert "generate an AGENTS.md" in prompt + + def test_reads_existing_agents_md(self, tmp_path): + (tmp_path / "AGENTS.md").write_text( + "# Existing\n\nRun `tox -e py311`.\n", encoding="utf-8" + ) + prompt = build_init_prompt_for_cwd(cwd=str(tmp_path)) + assert "UPDATE the existing AGENTS.md" in prompt + assert "Run `tox -e py311`." in prompt + + def test_passes_extra_through(self, tmp_path): + prompt = build_init_prompt_for_cwd(cwd=str(tmp_path), extra="keep it short") + assert "keep it short" in prompt + + +class TestInitRegistryWiring: + def test_init_is_registered_and_resolves(self): + from hermes_cli.commands import resolve_command + + cmd = resolve_command("init") + assert cmd is not None + assert cmd.name == "init" + + def test_init_is_in_tools_and_skills_category(self): + from hermes_cli.commands import resolve_command + + assert resolve_command("init").category == "Tools & Skills" + + def test_init_works_on_the_gateway(self): + # /init is a both-surfaces command like /learn, not CLI-only. + from hermes_cli.commands import GATEWAY_KNOWN_COMMANDS + + assert "init" in GATEWAY_KNOWN_COMMANDS + + def test_init_is_not_cli_only(self): + from hermes_cli.commands import resolve_command + + assert not resolve_command("init").cli_only diff --git a/tests/hermes_cli/test_install_cua_driver.py b/tests/hermes_cli/test_install_cua_driver.py index bf69f7fae8..bd532ac7fb 100644 --- a/tests/hermes_cli/test_install_cua_driver.py +++ b/tests/hermes_cli/test_install_cua_driver.py @@ -21,8 +21,11 @@ cleanly on missing-arch assets, and the upgrade path uses from __future__ import annotations +import sys from unittest.mock import patch +import pytest + class TestInstallCuaDriverUpgrade: def test_upgrade_on_unsupported_platform_is_silent_noop(self): @@ -126,6 +129,141 @@ class TestInstallCuaDriverUpgrade: runner.assert_called_once() +class TestRequireConfirmedUpdate: + """`hermes update` passes require_confirmed_update=True: the full + upstream installer (multi-minute, output captured, plus install.ps1's + 600s lock window on Windows) may only run when the driver's native + ``check-update`` verb positively confirms a newer release. An + indeterminate check (old driver, offline, GitHub rate-limited, probe + timeout) keeps the installed version and returns fast. + + Explicit `hermes computer-use install --upgrade` keeps the old + fall-through (require_confirmed_update=False): a force-refresh should + still reinstall when the check can't answer. + """ + + def _install(self, system, check_state, require_confirmed): + from unittest.mock import MagicMock + + from hermes_cli import tools_config + + exe = "cua-driver" + (".exe" if system == "Windows" else "") + with patch("platform.system", return_value=system), \ + patch.object(tools_config.shutil, "which", + side_effect=lambda n: "/x/" + n + if n in {"cua-driver", "curl", "powershell"} else None), \ + patch.object(tools_config, "_resolved_cua_driver_cmd", + return_value="/x/" + exe), \ + patch.object(tools_config, "_cua_install_target_writable", + return_value=True), \ + patch("tools.computer_use.cua_backend.cua_driver_update_check", + return_value=check_state), \ + patch.object(tools_config, "_run_cua_driver_installer", + return_value=True) as runner, \ + patch("subprocess.run", + return_value=MagicMock(stdout="cua-driver 0.5.0", returncode=0)), \ + patch.object(tools_config, "_print_success"), \ + patch.object(tools_config, "_print_warning"), \ + patch.object(tools_config, "_print_info") as info: + ok = tools_config.install_cua_driver( + upgrade=True, require_confirmed_update=require_confirmed + ) + return ok, runner, info + + def test_indeterminate_check_keeps_installed_version(self): + ok, runner, info = self._install("Windows", None, require_confirmed=True) + assert ok is True + runner.assert_not_called() + assert any( + "keeping the installed version" in call.args[0] + for call in info.call_args_list + ) + + def test_indeterminate_check_points_at_force_path(self): + ok, runner, info = self._install("Darwin", None, require_confirmed=True) + assert ok is True + runner.assert_not_called() + assert any( + "computer-use install --upgrade" in call.args[0] + for call in info.call_args_list + ) + + def test_confirmed_update_still_runs_installer(self): + state = {"current_version": "0.5.0", "latest_version": "0.6.0", + "update_available": True} + ok, runner, _ = self._install("Windows", state, require_confirmed=True) + assert ok is True + runner.assert_called_once() + + def test_up_to_date_short_circuits(self): + state = {"current_version": "0.6.0", "latest_version": "0.6.0", + "update_available": False} + ok, runner, _ = self._install("Windows", state, require_confirmed=True) + assert ok is True + runner.assert_not_called() + + def test_explicit_upgrade_still_falls_through_on_indeterminate(self): + # `hermes computer-use install --upgrade` (default flag): the old + # behaviour — indeterminate check re-runs the installer. + ok, runner, _ = self._install("Darwin", None, require_confirmed=False) + assert ok is True + runner.assert_called_once() + + +class TestUpdateCheckTimeoutDefaults: + """cua_driver_update_check: platform-sensitive default timeout. + + 8s is fine on POSIX but too tight for Windows first-spawn (Defender / + SmartScreen scanning), and a false timeout is what used to trigger the + full reinstall fall-through during `hermes update`. + """ + + def _captured_timeout(self, platform_name): + from unittest.mock import MagicMock + from tools.computer_use import cua_backend + + captured = {} + + def fake_run(cmd, **kw): + captured["timeout"] = kw.get("timeout") + m = MagicMock() + m.stdout = '{"update_available": false, "current_version": "1.0"}' + return m + + with patch("tools.computer_use.cua_backend.resolve_cua_driver_cmd", + return_value="/x/cua-driver"), \ + patch("tools.computer_use.cua_backend.sys.platform", platform_name), \ + patch("tools.computer_use.cua_backend.subprocess.run", + side_effect=fake_run): + cua_backend.cua_driver_update_check() + return captured.get("timeout") + + def test_windows_default_is_generous(self): + assert self._captured_timeout("win32") == 25.0 + + def test_posix_default_unchanged(self): + assert self._captured_timeout("linux") == 8.0 + + def test_explicit_timeout_wins(self): + from unittest.mock import MagicMock + from tools.computer_use import cua_backend + + captured = {} + + def fake_run(cmd, **kw): + captured["timeout"] = kw.get("timeout") + m = MagicMock() + m.stdout = "{}" + return m + + with patch("tools.computer_use.cua_backend.resolve_cua_driver_cmd", + return_value="/x/cua-driver"), \ + patch("tools.computer_use.cua_backend.subprocess.run", + side_effect=fake_run): + cua_backend.cua_driver_update_check(timeout=3.0) + assert captured.get("timeout") == 3.0 + + class TestArchProbeRemoval: """Regression tests for the deletion of `_check_cua_driver_asset_for_arch`. @@ -194,7 +332,11 @@ class TestArchProbeRemoval: urlopen.assert_not_called() -class TestStaleInstallLockClear: +@pytest.mark.skipif( + sys.platform == "win32", + reason="POSIX installer uses the .install.lock.d directory protocol", +) +class TestPosixStaleInstallLockClear: """_clear_stale_cua_install_lock: pre-clears the upstream installer's concurrent-install lock only when the holder is provably dead (or the lock is old and pid-less). Issue #58762.""" @@ -256,6 +398,87 @@ class TestStaleInstallLockClear: tools_config._clear_stale_cua_install_lock() # must not raise +class TestWindowsStaleInstallLockClearDispatch: + def test_windows_branch_uses_file_lock_probe(self): + from hermes_cli import tools_config + + with patch.object(tools_config.sys, "platform", "win32"), \ + patch.object( + tools_config, "_clear_stale_windows_cua_install_lock" + ) as clear_windows: + tools_config._clear_stale_cua_install_lock() + + clear_windows.assert_called_once_with() + + +@pytest.mark.skipif( + sys.platform != "win32", + reason="requires native Win32 FileShare semantics", +) +class TestWindowsStaleInstallLockClear: + def _make_lock(self, tmp_path): + import os + + home = tmp_path / ".cua-driver" + home.mkdir() + lock = home / "install.lock" + lock.write_text("pid=stale\n", encoding="utf-8") + os.environ["CUA_DRIVER_RS_HOME"] = str(home) + return lock + + def teardown_method(self): + import os + + os.environ.pop("CUA_DRIVER_RS_HOME", None) + + def test_unlocked_lock_file_is_cleared(self, tmp_path): + from hermes_cli import tools_config + + lock = self._make_lock(tmp_path) + with patch.object(tools_config, "_print_info"): + tools_config._clear_stale_cua_install_lock() + + assert not lock.exists() + + def test_lock_held_with_file_share_none_is_kept(self, tmp_path): + import ctypes + from ctypes import wintypes + from hermes_cli import tools_config + + lock = self._make_lock(tmp_path) + kernel32 = ctypes.WinDLL("kernel32", use_last_error=True) + create_file = kernel32.CreateFileW + create_file.argtypes = [ + wintypes.LPCWSTR, + wintypes.DWORD, + wintypes.DWORD, + wintypes.LPVOID, + wintypes.DWORD, + wintypes.DWORD, + wintypes.HANDLE, + ] + create_file.restype = wintypes.HANDLE + close_handle = kernel32.CloseHandle + close_handle.argtypes = [wintypes.HANDLE] + close_handle.restype = wintypes.BOOL + handle = create_file( + str(lock), + 0x80000000 | 0x40000000, # GENERIC_READ | GENERIC_WRITE + 0, # FileShare::None, matching install.ps1 + None, + 3, # OPEN_EXISTING + 0x00000080, # FILE_ATTRIBUTE_NORMAL + None, + ) + assert handle != wintypes.HANDLE(-1).value + + try: + tools_config._clear_stale_cua_install_lock() + assert lock.exists() + finally: + assert close_handle(handle) + + class TestInstallerTimeoutKillsProcessGroup: """On timeout the whole installer process group must be killed, so the `curl | bash` grandchildren can't survive holding the install lock.""" @@ -264,11 +487,11 @@ class TestInstallerTimeoutKillsProcessGroup: import os import signal import subprocess - import sys as _sys from unittest.mock import MagicMock from hermes_cli import tools_config killed = {} + sigkill = getattr(signal, "SIGKILL", signal.SIGTERM) fake_proc = MagicMock() fake_proc.pid = 12345 @@ -283,10 +506,15 @@ class TestInstallerTimeoutKillsProcessGroup: killed["sig"] = sig with patch("platform.system", return_value="Linux"), \ + patch.object(signal, "SIGKILL", sigkill, create=True), \ patch("subprocess.run", return_value=MagicMock(returncode=0, stderr="")), \ patch("subprocess.Popen", return_value=fake_proc), \ - patch.object(tools_config.os, "getpgid", return_value=99999), \ - patch.object(tools_config.os, "killpg", side_effect=fake_killpg), \ + patch.object( + tools_config.os, "getpgid", return_value=99999, create=True + ), \ + patch.object( + tools_config.os, "killpg", side_effect=fake_killpg, create=True + ), \ patch.object(tools_config, "_clear_stale_cua_install_lock"), \ patch.object(tools_config, "_print_warning"), \ patch.object(tools_config, "_print_info"): @@ -294,7 +522,7 @@ class TestInstallerTimeoutKillsProcessGroup: assert ok is False assert killed.get("pgid") == 99999 - assert killed.get("sig") == signal.SIGKILL + assert killed.get("sig") == sigkill # Post-kill reap happened. assert fake_proc.communicate.call_count == 2 @@ -329,6 +557,69 @@ class TestInstallerTimeoutKillsProcessGroup: assert captured.get("start_new_session") is True + def test_windows_timeout_kills_descendants_and_parent(self): + import subprocess + from unittest.mock import MagicMock + from hermes_cli import tools_config + + child = MagicMock() + parent = MagicMock() + parent.children.return_value = [child] + + fake_proc = MagicMock() + fake_proc.pid = 12345 + fake_proc.communicate.side_effect = [ + subprocess.TimeoutExpired(cmd="powershell", timeout=1), + ("", None), + ] + + with patch("platform.system", return_value="Windows"), \ + patch("subprocess.Popen", return_value=fake_proc), \ + patch("psutil.Process", return_value=parent), \ + patch.object(tools_config, "_clear_stale_cua_install_lock"), \ + patch.object(tools_config, "_print_warning"), \ + patch.object(tools_config, "_print_info"): + ok = tools_config._run_cua_driver_installer( + label="Refreshing", verbose=False + ) + + assert ok is False + parent.children.assert_called_once_with(recursive=True) + child.kill.assert_called_once_with() + parent.kill.assert_called_once_with() + fake_proc.kill.assert_not_called() + assert fake_proc.communicate.call_count == 2 + + def test_windows_tree_enumeration_failure_falls_back_to_direct_kill(self): + import psutil + import subprocess + from unittest.mock import MagicMock + from hermes_cli import tools_config + + parent = MagicMock() + parent.children.side_effect = psutil.AccessDenied(pid=12345) + + fake_proc = MagicMock() + fake_proc.pid = 12345 + fake_proc.communicate.side_effect = [ + subprocess.TimeoutExpired(cmd="powershell", timeout=1), + ("", None), + ] + + with patch("platform.system", return_value="Windows"), \ + patch("subprocess.Popen", return_value=fake_proc), \ + patch("psutil.Process", return_value=parent), \ + patch.object(tools_config, "_clear_stale_cua_install_lock"), \ + patch.object(tools_config, "_print_warning"), \ + patch.object(tools_config, "_print_info"): + ok = tools_config._run_cua_driver_installer( + label="Refreshing", verbose=False + ) + + assert ok is False + fake_proc.kill.assert_called_once_with() + assert fake_proc.communicate.call_count == 2 + class TestInstallerNoShell: """The POSIX installer path must not use shell=True or command diff --git a/tests/hermes_cli/test_kanban_core_functionality.py b/tests/hermes_cli/test_kanban_core_functionality.py index 0e898999c1..e75a90b289 100644 --- a/tests/hermes_cli/test_kanban_core_functionality.py +++ b/tests/hermes_cli/test_kanban_core_functionality.py @@ -522,16 +522,31 @@ def test_notify_sub_crud(kanban_home): kb.add_notify_sub( conn, task_id=tid, platform="telegram", chat_id="123", user_id="u1", notifier_profile="default", + delivery_metadata={ + "chat_type": "dm", + "telegram_reply_to_message_id": "42", + }, ) subs = kb.list_notify_subs(conn, tid) assert len(subs) == 1 assert subs[0]["platform"] == "telegram" assert subs[0]["notifier_profile"] == "default" + assert subs[0]["delivery_metadata"] == { + "chat_type": "dm", + "telegram_reply_to_message_id": "42", + } # Duplicate add is a no-op. kb.add_notify_sub( conn, task_id=tid, platform="telegram", chat_id="123", + delivery_metadata={ + "chat_type": "dm", + "telegram_reply_to_message_id": "43", + }, ) assert len(kb.list_notify_subs(conn, tid)) == 1 + assert kb.list_notify_subs(conn, tid)[0]["delivery_metadata"][ + "telegram_reply_to_message_id" + ] == "43" # Distinct thread is a new row. kb.add_notify_sub( conn, task_id=tid, platform="telegram", chat_id="123", @@ -587,6 +602,9 @@ def test_notify_claim_is_single_owner_and_rewindable(kanban_home): try: tid = kb.create_task(conn1, title="x", assignee="w") kb.add_notify_sub(conn1, task_id=tid, platform="telegram", chat_id="123") + # New subs start caught up at the task's current MAX(task_events.id) + # (the `created` event) — issue #29905. + initial_cursor = int(kb.list_notify_subs(conn1, tid)[0]["last_event_id"]) kb.complete_task(conn1, tid, result="ok") old_cursor, claimed_cursor, events = kb.claim_unseen_events_for_sub( @@ -596,7 +614,7 @@ def test_notify_claim_is_single_owner_and_rewindable(kanban_home): chat_id="123", kinds=["completed", "blocked"], ) - assert old_cursor == 0 + assert old_cursor == initial_cursor assert claimed_cursor > old_cursor assert [ev.kind for ev in events] == ["completed"] @@ -4786,3 +4804,49 @@ def test_dispatch_once_stale_disabled_when_timeout_zero(kanban_home, monkeypatch ) assert res.stale == [], "stale_timeout_seconds=0 should disable detection" assert kb.get_task(conn, t).status == "running" + + +def test_notify_sub_starts_caught_up_on_active_task(kanban_home): + """A new subscription must NOT replay historical terminal events. + + Regression for issue #29905: `kanban_notify_subs.last_event_id` defaulted + to 0, so subscribing to a task that already had terminal events in + `task_events` replayed the entire backlog on the next notifier tick — 27 + stale subs produced a 100+ message burst at gateway boot. The cursor now + snaps to the task's MAX(task_events.id) at creation: only events that + occur AFTER subscribing are delivered. + """ + conn = kb.connect() + try: + tid = kb.create_task(conn, title="old task", assignee="w") + # Historical terminal activity BEFORE anyone subscribes. + kb.complete_task(conn, tid, result="done long ago") + + kb.add_notify_sub(conn, task_id=tid, platform="telegram", chat_id="123") + sub = kb.list_notify_subs(conn, tid)[0] + assert int(sub["last_event_id"]) > 0, ( + "cursor must snap to MAX(task_events.id) at subscription time" + ) + _, events = kb.unseen_events_for_sub( + conn, task_id=tid, platform="telegram", chat_id="123", + kinds=["completed", "blocked", "gave_up", "crashed", "timed_out"], + ) + assert events == [], "historical events must not replay to a new sub" + finally: + conn.close() + + +def test_notify_sub_on_fresh_task_still_gets_future_events(kanban_home): + """The caught-up snap must not lose events that happen AFTER subscribing.""" + conn = kb.connect() + try: + tid = kb.create_task(conn, title="fresh", assignee="w") + kb.add_notify_sub(conn, task_id=tid, platform="telegram", chat_id="123") + kb.complete_task(conn, tid, result="ok") + _, events = kb.unseen_events_for_sub( + conn, task_id=tid, platform="telegram", chat_id="123", + kinds=["completed"], + ) + assert [ev.kind for ev in events] == ["completed"] + finally: + conn.close() diff --git a/tests/hermes_cli/test_kanban_count_notify_subs.py b/tests/hermes_cli/test_kanban_count_notify_subs.py new file mode 100644 index 0000000000..f1361e29c5 --- /dev/null +++ b/tests/hermes_cli/test_kanban_count_notify_subs.py @@ -0,0 +1,98 @@ +"""Tests for ``kanban_db.count_notify_subs`` — the read-only subscription probe. + +The gateway notifier uses it to skip boards with zero subscriptions BEFORE +any writable ``connect()``: the probe must never create the DB file, never +run schema init/migration, and never write — that first-open cost on every +tick is exactly what the zero-sub early exit avoids. It must also never +UNDER-count: rows sitting in a not-yet-checkpointed WAL still count, or the +notifier would skip a board that has a live subscription. +""" + +from __future__ import annotations + +import sqlite3 +from pathlib import Path + +import pytest + +from hermes_cli import kanban_db as kb + + +@pytest.fixture +def kanban_home(tmp_path, monkeypatch): + home = tmp_path / ".hermes" + home.mkdir() + monkeypatch.setenv("HERMES_HOME", str(home)) + monkeypatch.setenv("HERMES_KANBAN_HOME", str(home)) + monkeypatch.setattr(Path, "home", lambda: tmp_path) + return home + + +def test_missing_db_counts_zero_and_creates_nothing(kanban_home): + db_path = kb.kanban_db_path(board="default") + assert not db_path.exists() + assert kb.count_notify_subs(board="default") == 0 + assert not db_path.exists(), "read-only probe must not create the DB" + + +def test_counts_rows_via_board_resolution(kanban_home): + conn = kb.connect(board="default") + try: + tid = kb.create_task(conn, title="t", assignee="w") + kb.add_notify_sub(conn, task_id=tid, platform="telegram", chat_id="c1") + kb.add_notify_sub(conn, task_id=tid, platform="telegram", chat_id="c2") + finally: + conn.close() + assert kb.count_notify_subs(board="default") == 2 + + +def test_probe_is_read_only_and_sees_uncheckpointed_wal_rows(kanban_home): + """A sub committed by a still-open writer (rows only in the WAL, not yet + checkpointed into the main DB file) must be counted — under-counting + would make the notifier skip a board that has a live subscription. And + the probe itself must be read-only: the writer's connection stays the + only writer.""" + conn = kb.connect(board="default") + try: + tid = kb.create_task(conn, title="t", assignee="w") + kb.add_notify_sub(conn, task_id=tid, platform="telegram", chat_id="c1") + # Writer still open: the row lives in the -wal, not the main file. + assert kb.count_notify_subs(board="default") == 1 + finally: + conn.close() + + +def test_legacy_db_without_subs_table_counts_zero_and_stays_unmigrated(tmp_path): + legacy = tmp_path / "legacy.db" + conn = sqlite3.connect(legacy) + try: + conn.execute("CREATE TABLE something_else (id INTEGER)") + conn.commit() + finally: + conn.close() + assert kb.count_notify_subs(db_path=legacy) == 0 + # The probe must not have run schema init on the foreign/legacy DB. + conn = sqlite3.connect(legacy) + try: + tables = { + r[0] for r in conn.execute( + "SELECT name FROM sqlite_master WHERE type='table'" + ) + } + finally: + conn.close() + assert "kanban_notify_subs" not in tables, ( + "read-only probe must never create schema" + ) + + +def test_explicit_db_path_overrides_board(kanban_home, tmp_path): + pinned = tmp_path / "pinned.db" + conn = kb.connect(db_path=pinned) + try: + tid = kb.create_task(conn, title="t", assignee="w") + kb.add_notify_sub(conn, task_id=tid, platform="telegram", chat_id="c1") + finally: + conn.close() + assert kb.count_notify_subs(pinned) == 1 + assert kb.count_notify_subs(board="default") == 0 diff --git a/tests/hermes_cli/test_kanban_db.py b/tests/hermes_cli/test_kanban_db.py index f4e5523525..0904a877b6 100644 --- a/tests/hermes_cli/test_kanban_db.py +++ b/tests/hermes_cli/test_kanban_db.py @@ -3096,17 +3096,23 @@ class TestSharedBoardPaths: assert kb.kanban_db_path() == default_home / "kanban.db" assert kb.workspaces_root() == default_home / "kanban" / "workspaces" - def test_dispatcher_spawn_injects_kanban_db_and_workspaces_root( + def test_dispatcher_spawn_injects_kanban_paths_without_stale_session( self, tmp_path, monkeypatch ): - # The dispatcher's `_default_spawn` must inject HERMES_KANBAN_DB - # and HERMES_KANBAN_WORKSPACES_ROOT into the worker env so the - # worker converges on the dispatcher's paths even when the - # `-p ` flag rewrites HERMES_HOME. + # The dispatcher must pin board paths while stripping any unrelated + # HERMES_SESSION_* identity inherited from the long-lived gateway. default_home = tmp_path / ".hermes" default_home.mkdir() self._set_home(monkeypatch, tmp_path, default_home) + from gateway import session_context as sc + + # A dispatcher can launch before the gateway binds its first session. + monkeypatch.setattr(sc, "_session_context_engaged", False) + sc.reset_session_vars() + for key in sc._VAR_MAP: + monkeypatch.setenv(key, "stale-routing-value") + captured = {} class _FakePopen: @@ -3144,6 +3150,8 @@ class TestSharedBoardPaths: ) assert env["HERMES_KANBAN_TASK"] == "t_dispatch_env" assert env["HERMES_KANBAN_BRANCH"] == "wt/t_dispatch_env" + for key in sc._VAR_MAP: + assert key not in env # --------------------------------------------------------------------------- diff --git a/tests/hermes_cli/test_kanban_db_init.py b/tests/hermes_cli/test_kanban_db_init.py index 7db5d2009e..643c55ec3f 100644 --- a/tests/hermes_cli/test_kanban_db_init.py +++ b/tests/hermes_cli/test_kanban_db_init.py @@ -115,6 +115,7 @@ def test_legacy_text_pk_tables_rebuilt_to_integer_autoincrement(tmp_path, monkey lei = {r["name"]: r for r in conn.execute("PRAGMA table_info(kanban_notify_subs)")} assert lei["last_event_id"]["type"].upper() == "INTEGER" + assert "delivery_metadata" in lei # Data preserved across the rebuild. assert len(conn.execute("SELECT * FROM task_events").fetchall()) == 2 diff --git a/tests/hermes_cli/test_kanban_notify.py b/tests/hermes_cli/test_kanban_notify.py index 07b1fa201b..63b327ceef 100644 --- a/tests/hermes_cli/test_kanban_notify.py +++ b/tests/hermes_cli/test_kanban_notify.py @@ -26,6 +26,109 @@ def kanban_home(tmp_path, monkeypatch): return home +def _assert_inherited_notify_sub(subs: list[dict]) -> None: + assert len(subs) == 1 + assert subs[0]["platform"] == "telegram" + assert subs[0]["chat_id"] == "chat1" + assert subs[0]["thread_id"] == "topic1" + assert subs[0]["user_id"] == "user1" + assert subs[0]["notifier_profile"] == "default" + + +def test_create_task_inherits_parent_notify_subscriptions(kanban_home): + conn = kb.connect() + try: + parent = kb.create_task(conn, title="parent", assignee="worker1") + kb.add_notify_sub( + conn, + task_id=parent, + platform="telegram", + chat_id="chat1", + thread_id="topic1", + user_id="user1", + notifier_profile="default", + ) + + child = kb.create_task(conn, title="child", parents=[parent], assignee="worker1") + + subs = kb.list_notify_subs(conn, child) + finally: + conn.close() + + _assert_inherited_notify_sub(subs) + + +def test_link_tasks_inherits_parent_notify_subscriptions_without_replaying_old_child_events(kanban_home): + conn = kb.connect() + try: + parent = kb.create_task(conn, title="parent", assignee="worker1") + child = kb.create_task(conn, title="child", assignee="worker1") + with kb.write_txn(conn): + kb._append_event(conn, child, kind="blocked", payload={"reason": "old"}) + kb.add_notify_sub( + conn, + task_id=parent, + platform="telegram", + chat_id="chat1", + thread_id="topic1", + user_id="user1", + notifier_profile="default", + ) + + kb.link_tasks(conn, parent, child) + + subs = kb.list_notify_subs(conn, child) + _, old_events = kb.unseen_events_for_sub( + conn, + task_id=child, + platform="telegram", + chat_id="chat1", + thread_id="topic1", + kinds=["blocked"], + ) + finally: + conn.close() + + _assert_inherited_notify_sub(subs) + assert old_events == [] + + +def test_decompose_triage_task_inherits_root_notify_subscriptions(kanban_home): + conn = kb.connect() + try: + root = kb.create_task(conn, title="triage root", triage=True, assignee="orchestrator") + kb.add_notify_sub( + conn, + task_id=root, + platform="telegram", + chat_id="chat1", + thread_id="topic1", + user_id="user1", + notifier_profile="default", + ) + + child_ids = kb.decompose_triage_task( + conn, + root, + root_assignee="orchestrator", + children=[ + {"title": "first child", "assignee": "worker1"}, + {"title": "second child", "assignee": "worker2", "parents": [0]}, + ], + author="triager", + auto_promote=False, + ) + + assert child_ids is not None + child_subs = [kb.list_notify_subs(conn, child_id) for child_id in child_ids] + finally: + conn.close() + + assert len(child_subs) == 2 + for subs in child_subs: + _assert_inherited_notify_sub(subs) + + @pytest.mark.asyncio async def test_notifier_unsubs_after_completed_event(kanban_home): """ @@ -348,6 +451,9 @@ async def test_notifier_skips_subscription_owned_by_other_profile(kanban_home): notifier_profile="default", ) kb.complete_task(conn, tid, result="done") + # New subs start caught up at the creation-time MAX(task_events.id) + # (issue #29905); claiming the completion would advance past this. + pre_claim_cursor = int(kb.list_notify_subs(conn, tid)[0]["last_event_id"]) finally: conn.close() @@ -383,7 +489,9 @@ async def test_notifier_skips_subscription_owned_by_other_profile(kanban_home): finally: conn.close() assert len(subs) == 1 - assert int(subs[0]["last_event_id"]) == 0, "wrong profile must not claim the event" + assert int(subs[0]["last_event_id"]) == pre_claim_cursor, ( + "wrong profile must not claim the event" + ) @pytest.mark.asyncio @@ -458,12 +566,15 @@ async def test_gateway_create_autosubscribes_on_explicit_board(kanban_home): source = SimpleNamespace( platform=Platform.TELEGRAM, chat_id="chat1", - thread_id="th1", + chat_type="dm", + thread_id="20197", user_id="u1", ) event = SimpleNamespace( text='/kanban --board projx create "hello" --assignee alice', source=source, + message_id="462", + reply_to_message_id=None, ) out = await GatewayRunner._handle_kanban_command(runner, event) @@ -480,7 +591,14 @@ async def test_gateway_create_autosubscribes_on_explicit_board(kanban_home): assert [t.title for t in tasks] == ["hello"] assert len(subs) == 1 assert subs[0]["chat_id"] == "chat1" - assert subs[0]["thread_id"] == "th1" + assert subs[0]["thread_id"] == "20197" + assert subs[0]["delivery_metadata"] == { + "chat_type": "dm", + "direct_messages_topic_id": "20197", + "telegram_dm_topic_reply_fallback": True, + "telegram_reply_to_message_id": "462", + "thread_id": "20197", + } conn = kb.connect(board="default") try: diff --git a/tests/hermes_cli/test_managed_uv.py b/tests/hermes_cli/test_managed_uv.py index 167f2c6e8c..4ce791af6c 100644 --- a/tests/hermes_cli/test_managed_uv.py +++ b/tests/hermes_cli/test_managed_uv.py @@ -1067,3 +1067,151 @@ class TestListAvailablePatches: monkeypatch.setattr(managed_uv.subprocess, "run", fake_run) assert managed_uv._list_available_patches("uv", "3.11", cwd=tmp_path, env={}) == [] + + +# --------------------------------------------------------------------------- +# _refresh_managed_uv_catalog + provisioning retry (issue #72093) +# --------------------------------------------------------------------------- + +class TestRefreshManagedUvCatalog: + """The managed uv is UV_UNMANAGED_INSTALL'd, so `uv self update` is + disabled and its python-build-standalone catalog freezes at bootstrap + age. python-build-standalone re-releases the same patch versions with + fixed SQLite, so a stale catalog makes provisioning fail forever with + no newer patch number to retry (issue #72093).""" + + def test_foreign_uv_path_is_never_refreshed(self, tmp_path): + import hermes_cli.managed_uv as managed_uv + + _make_executable(tmp_path / "bin" / "uv") + foreign = tmp_path / "elsewhere" / "uv" + _make_executable(foreign) + with patch("hermes_cli.managed_uv.get_hermes_home", return_value=tmp_path), \ + patch("hermes_cli.managed_uv.platform.system", return_value="Linux"), \ + patch("hermes_cli.managed_uv._install_uv") as mock_install: + assert managed_uv._refresh_managed_uv_catalog(str(foreign)) is False + mock_install.assert_not_called() + + def test_version_change_reports_true(self, tmp_path): + import hermes_cli.managed_uv as managed_uv + + uv_path = tmp_path / "bin" / "uv" + _make_executable(uv_path) + versions = iter(["uv 0.1.0", "uv 0.2.0"]) + with patch("hermes_cli.managed_uv.get_hermes_home", return_value=tmp_path), \ + patch("hermes_cli.managed_uv.platform.system", return_value="Linux"), \ + patch("hermes_cli.managed_uv._install_uv"), \ + patch( + "hermes_cli.managed_uv._uv_version_string", + side_effect=lambda _uv: next(versions), + ): + assert managed_uv._refresh_managed_uv_catalog(str(uv_path)) is True + + def test_same_version_reports_false(self, tmp_path): + import hermes_cli.managed_uv as managed_uv + + uv_path = tmp_path / "bin" / "uv" + _make_executable(uv_path) + with patch("hermes_cli.managed_uv.get_hermes_home", return_value=tmp_path), \ + patch("hermes_cli.managed_uv.platform.system", return_value="Linux"), \ + patch("hermes_cli.managed_uv._install_uv"), \ + patch( + "hermes_cli.managed_uv._uv_version_string", + return_value="uv 0.1.0", + ): + assert managed_uv._refresh_managed_uv_catalog(str(uv_path)) is False + + def test_installer_failure_reports_false(self, tmp_path): + import hermes_cli.managed_uv as managed_uv + + uv_path = tmp_path / "bin" / "uv" + _make_executable(uv_path) + with patch("hermes_cli.managed_uv.get_hermes_home", return_value=tmp_path), \ + patch("hermes_cli.managed_uv.platform.system", return_value="Linux"), \ + patch( + "hermes_cli.managed_uv._install_uv", + side_effect=RuntimeError("network down"), + ): + assert managed_uv._refresh_managed_uv_catalog(str(uv_path)) is False + + +class TestRepairRetriesAfterUvRefresh: + def _run_repair(self, tmp_path, *, refresh_result, second_attempt): + """Drive repair with the first provisioning attempt failing.""" + from hermes_cli.managed_uv import repair_vulnerable_runtime + + root, live, sentinel = _make_runtime_install(tmp_path) + current = _runtime_info(live / "bin" / "python", (3, 50, 4)) + + attempts = [] + + def fake_install(uv_bin, *, project_root, current): + attempts.append(uv_bin) + if len(attempts) == 1: + return None + return second_attempt(project_root) + + with patch("hermes_cli.managed_uv.platform.system", return_value="Linux"), \ + patch( + "hermes_cli.managed_uv.probe_sqlite_runtime", + return_value=current, + ), \ + patch( + "hermes_cli.managed_uv._install_safe_python_generation", + side_effect=fake_install, + ), \ + patch( + "hermes_cli.managed_uv._refresh_managed_uv_catalog", + return_value=refresh_result, + ) as mock_refresh, \ + patch( + "hermes_cli.managed_uv._stage_candidate_venv", + return_value=None, + ): + result = repair_vulnerable_runtime("uv", project_root=root) + return result, attempts, mock_refresh, sentinel + + def test_no_retry_when_refresh_did_not_change_uv(self, tmp_path): + result, attempts, mock_refresh, sentinel = self._run_repair( + tmp_path, + refresh_result=False, + second_attempt=lambda root: None, + ) + assert result.status == "failed" + assert len(attempts) == 1 + mock_refresh.assert_called_once_with("uv") + assert sentinel.read_text(encoding="utf-8") == "live" + + def test_retries_once_after_successful_refresh(self, tmp_path): + result, attempts, mock_refresh, sentinel = self._run_repair( + tmp_path, + refresh_result=True, + second_attempt=lambda root: None, + ) + # Second attempt ran (and also failed) — exactly one retry, no loop. + assert result.status == "failed" + assert len(attempts) == 2 + mock_refresh.assert_called_once_with("uv") + assert sentinel.read_text(encoding="utf-8") == "live" + + def test_retry_success_proceeds_to_staging(self, tmp_path): + def second_attempt(root): + generation = root / ".hermes-runtime" / "python" / "generation-retry" + candidate_python = generation / "bin" / "python" + candidate_python.parent.mkdir(parents=True) + candidate_python.write_text("candidate", encoding="utf-8") + return generation, candidate_python, _runtime_info( + candidate_python, (3, 53, 1) + ) + + result, attempts, mock_refresh, sentinel = self._run_repair( + tmp_path, + refresh_result=True, + second_attempt=second_attempt, + ) + # Provisioning succeeded on retry; staging (mocked to None) is what + # failed — proving the retry result flows into the normal pipeline. + assert result.status == "failed" + assert "replacement environment" in result.detail + assert len(attempts) == 2 + assert sentinel.read_text(encoding="utf-8") == "live" diff --git a/tests/hermes_cli/test_memory_setup.py b/tests/hermes_cli/test_memory_setup.py index 487f0949d7..499d2235d0 100644 --- a/tests/hermes_cli/test_memory_setup.py +++ b/tests/hermes_cli/test_memory_setup.py @@ -230,3 +230,76 @@ def test_write_env_vars_plain_value_roundtrips(tmp_path): env_path = tmp_path / ".env" memory_setup._write_env_vars(env_path, {"PROVIDER_API_KEY": "sk-plain-1234"}) assert env_path.read_text(encoding="utf-8") == "PROVIDER_API_KEY=sk-plain-1234\n" + + +# --------------------------------------------------------------------------- +# _provider_pip_dependencies — mode-aware dep expansion (#70636) +# --------------------------------------------------------------------------- + +def test_provider_pip_dependencies_passthrough_for_non_hindsight(): + deps = memory_setup._provider_pip_dependencies("mem0", ["mem0ai>=2.0.10,<3"]) + assert deps == ["mem0ai>=2.0.10,<3"] + + +def test_provider_pip_dependencies_adds_hindsight_all_for_local_embedded(tmp_path, monkeypatch): + """local_embedded Hindsight needs hindsight-all (daemon + embedder), not + just the declared hindsight-client — a venv rebuild that stripped + hindsight-embed must be healed by the update-time refresh (#70636).""" + import json + monkeypatch.setattr(memory_setup, "get_hermes_home", lambda: tmp_path) + (tmp_path / "hindsight").mkdir() + (tmp_path / "hindsight" / "config.json").write_text( + json.dumps({"mode": "local_embedded"}), encoding="utf-8" + ) + deps = memory_setup._provider_pip_dependencies("hindsight", ["hindsight-client>=0.6.1"]) + assert deps == ["hindsight-client>=0.6.1", "hindsight-all"] + + +def test_provider_pip_dependencies_legacy_local_alias(tmp_path, monkeypatch): + import json + monkeypatch.setattr(memory_setup, "get_hermes_home", lambda: tmp_path) + (tmp_path / "hindsight").mkdir() + (tmp_path / "hindsight" / "config.json").write_text( + json.dumps({"mode": "local"}), encoding="utf-8" + ) + deps = memory_setup._provider_pip_dependencies("hindsight", ["hindsight-client>=0.6.1"]) + assert "hindsight-all" in deps + + +def test_provider_pip_dependencies_cloud_hindsight_unchanged(tmp_path, monkeypatch): + import json + monkeypatch.setattr(memory_setup, "get_hermes_home", lambda: tmp_path) + (tmp_path / "hindsight").mkdir() + (tmp_path / "hindsight" / "config.json").write_text( + json.dumps({"mode": "cloud"}), encoding="utf-8" + ) + deps = memory_setup._provider_pip_dependencies("hindsight", ["hindsight-client>=0.6.1"]) + assert deps == ["hindsight-client>=0.6.1"] + + +def test_install_dependencies_force_reinstalls_versioned_specs(tmp_path, monkeypatch): + """force=True hands every declared spec (version ranges intact) to pip, + so a downgraded/stripped bridge package is restored on hermes update.""" + import yaml as _yaml + + plugin_dir = tmp_path / "mem0" + plugin_dir.mkdir() + (plugin_dir / "plugin.yaml").write_text( + _yaml.safe_dump({"pip_dependencies": ["mem0ai>=2.0.10,<3"]}), encoding="utf-8" + ) + monkeypatch.setattr( + "plugins.memory.find_provider_dir", lambda name: plugin_dir + ) + + installed = [] + + def fake_pip_install(args, timeout=120): + installed.append(args) + return SimpleNamespace(returncode=0, stderr="") + + monkeypatch.setattr("hermes_cli.tools_config._pip_install", fake_pip_install) + + memory_setup._install_dependencies("mem0", force=True) + + assert installed, "force=True must reach the pip install step" + assert any("mem0ai>=2.0.10,<3" in args for args in installed) diff --git a/tests/hermes_cli/test_model_normalize.py b/tests/hermes_cli/test_model_normalize.py index 77ece21011..564c188e96 100644 --- a/tests/hermes_cli/test_model_normalize.py +++ b/tests/hermes_cli/test_model_normalize.py @@ -232,19 +232,33 @@ class TestDeepseekVSeriesPassThrough: assert result == "deepseek-v4-flash" -# ── DeepSeek regressions (existing behaviour still holds) ────────────── +# ── DeepSeek post-2026-07-24 alias remapping ─────────────────────────── class TestDeepseekCanonicalAndReasonerMapping: - """Canonical pass-through and reasoner-keyword folding stay intact.""" + """Retired aliases and fuzzy names rewrite to deepseek-v4-flash. + + DeepSeek cut off ``deepseek-chat`` / ``deepseek-reasoner`` on + 2026-07-24; sending them on the wire returns HTTP 400. + """ @pytest.mark.parametrize("model,expected", [ - ("deepseek-chat", "deepseek-chat"), - ("deepseek-reasoner", "deepseek-reasoner"), - ("DEEPSEEK-CHAT", "deepseek-chat"), + ("deepseek-chat", "deepseek-v4-flash"), + ("deepseek-reasoner", "deepseek-v4-flash"), + ("DEEPSEEK-CHAT", "deepseek-v4-flash"), + ("DEEPSEEK-REASONER", "deepseek-v4-flash"), + ("deepseek/deepseek-reasoner", "deepseek-v4-flash"), + ("deepseek-v4-pro", "deepseek-v4-pro"), + ("deepseek-v4-flash", "deepseek-v4-flash"), ]) - def test_canonical_models_pass_through(self, model, expected): + def test_retired_aliases_and_canonicals(self, model, expected): assert _normalize_for_deepseek(model) == expected + def test_provider_path_rewrites_reasoner(self): + assert ( + normalize_model_for_provider("deepseek-reasoner", "deepseek") + == "deepseek-v4-flash" + ) + @pytest.mark.parametrize("model", [ "deepseek-r1", "deepseek-r1-0528", @@ -252,8 +266,8 @@ class TestDeepseekCanonicalAndReasonerMapping: "deepseek-reasoning-preview", "deepseek-cot-experimental", ]) - def test_reasoner_keywords_map_to_reasoner(self, model): - assert _normalize_for_deepseek(model) == "deepseek-reasoner" + def test_reasoner_keywords_map_to_v4_flash(self, model): + assert _normalize_for_deepseek(model) == "deepseek-v4-flash" @pytest.mark.parametrize("model", [ "deepseek-chat-v3.1", # 'chat' prefix, not V-series pattern @@ -261,5 +275,5 @@ class TestDeepseekCanonicalAndReasonerMapping: "something-random", "gpt-5", # non-DeepSeek names still fall through ]) - def test_unknown_names_fall_back_to_chat(self, model): - assert _normalize_for_deepseek(model) == "deepseek-chat" + def test_unknown_names_fall_back_to_v4_flash(self, model): + assert _normalize_for_deepseek(model) == "deepseek-v4-flash" diff --git a/tests/hermes_cli/test_models.py b/tests/hermes_cli/test_models.py index 89a3d9fed7..0804ee9f5e 100644 --- a/tests/hermes_cli/test_models.py +++ b/tests/hermes_cli/test_models.py @@ -252,12 +252,18 @@ class TestDetectProviderForModel: assert result[0] == "anthropic" def test_deepseek_model_detected(self): - """deepseek-chat should resolve to deepseek provider.""" + """Retired deepseek-chat alias still resolves to deepseek for /model.""" result = detect_provider_for_model("deepseek-chat", "openai-codex") assert result is not None # Provider is deepseek (direct) or openrouter (fallback) depending on creds assert result[0] in {"deepseek", "openrouter"} + def test_deepseek_v4_model_detected(self): + """Current DeepSeek V4 IDs resolve to the deepseek provider.""" + result = detect_provider_for_model("deepseek-v4-flash", "openai-codex") + assert result is not None + assert result[0] in {"deepseek", "openrouter"} + def test_current_provider_model_returns_none(self): """Models belonging to the current provider should not trigger a switch.""" assert detect_provider_for_model("gpt-5.3-codex", "openai-codex") is None diff --git a/tests/hermes_cli/test_prompt_size.py b/tests/hermes_cli/test_prompt_size.py index e536c97130..f95e8c0b3c 100644 --- a/tests/hermes_cli/test_prompt_size.py +++ b/tests/hermes_cli/test_prompt_size.py @@ -2,6 +2,7 @@ import json import sys +from pathlib import Path from types import SimpleNamespace import pytest @@ -9,6 +10,7 @@ import pytest from hermes_cli.prompt_size import ( _SKILLS_BLOCK_RE, _build_inspection_agent, + _compute_skills_breakdown, compute_prompt_breakdown, render_breakdown, ) @@ -155,6 +157,120 @@ def test_skills_block_regex_matches_tagged_block(): assert m.group(0).endswith("") +def test_toolsets_breakdown_reconciles_and_sorted(isolated_home): + """Per-toolset schema bytes attribute every tool exactly once. + + Each resolved tool belongs to one registry toolset, so the grand total of + per-toolset json bytes equals the whole-array total minus JSON framing + (``2 * count`` bytes: brackets + ``", "`` separators between items). + """ + data = compute_prompt_breakdown("cli") + toolsets = data["toolsets_breakdown"] + assert toolsets # CLI always resolves at least terminal + file + for ts in toolsets: + assert set(ts) >= {"toolset", "tool_count", "json_bytes"} + assert ts["tool_count"] >= 1 + assert ts["json_bytes"] > 0 + # Sorted largest-first. + byte_sizes = [ts["json_bytes"] for ts in toolsets] + assert byte_sizes == sorted(byte_sizes, reverse=True) + # Every tool attributed to exactly one toolset. + assert sum(ts["tool_count"] for ts in toolsets) == data["tools"]["count"] + # Bytes reconcile to the existing whole-array total. + grand = sum(ts["json_bytes"] for ts in toolsets) + assert grand == data["tools"]["json_bytes"] - 2 * data["tools"]["count"] + + +def test_skills_breakdown_shape_sorted_and_attributed(isolated_home): + """Per-skill breakdown reports index-line + on-disk SKILL.md bytes. + + Seeded before the first build (skills prompt is cached per-process). + """ + _seed_skill(isolated_home, "small-skill", "short desc") + _seed_skill(isolated_home, "big-skill", "a much longer description " * 20) + data = compute_prompt_breakdown("cli") + skills = data["skills_breakdown"] + names = {s["name"] for s in skills} + assert {"small-skill", "big-skill"} <= names + for s in skills: + assert set(s) >= {"name", "index_line_bytes", "skill_md_bytes", "path"} + assert s["index_line_bytes"] > 0 + # Sorted largest-first by on-disk SKILL.md size. + md_sizes = [s["skill_md_bytes"] or 0 for s in skills] + assert md_sizes == sorted(md_sizes, reverse=True) + # On-disk bytes match the real file; big-skill's SKILL.md is the larger. + by_name = {s["name"]: s for s in skills} + big = by_name["big-skill"] + assert big["path"] and Path(big["path"]).stat().st_size == big["skill_md_bytes"] + assert big["skill_md_bytes"] > by_name["small-skill"]["skill_md_bytes"] + # Per-skill index lines are a subset of the whole block, + # so they never exceed it (on-disk SKILL.md bytes are separate and don't). + assert sum(s["index_line_bytes"] for s in skills) <= data["skills_index"]["bytes"] + + +def test_skills_breakdown_unmapped_name_is_none(): + """A skill line with no matching SKILL.md on disk reports None, not a crash.""" + block = ( + "\n" + " demo:\n" + " - phantom-skill: not on disk\n" + "\n" + ) + entries = _compute_skills_breakdown(block) + assert len(entries) == 1 + assert entries[0]["name"] == "phantom-skill" + assert entries[0]["skill_md_bytes"] is None + assert entries[0]["path"] == "" + assert entries[0]["index_line_bytes"] > 0 + + +def test_skills_breakdown_parses_namespaced_names(): + """Namespaced names (``ns:skill``) survive the ``name: desc`` split.""" + block = ( + "\n" + " plugins:\n" + " - codex:rescue: rescue helper\n" + "\n" + ) + entries = _compute_skills_breakdown(block) + assert [e["name"] for e in entries] == ["codex:rescue"] + + +def test_skills_breakdown_attributes_demoted_category_shared_line(isolated_home): + """A real posture-demoted category retains every skill in the breakdown.""" + from agent.prompt_builder import build_skills_system_prompt + + _seed_skill(isolated_home, "alpha-skill", "alpha description") + _seed_skill(isolated_home, "beta-skill", "beta description") + prompt = build_skills_system_prompt(compact_categories=frozenset({"demo"})) + skills_match = _SKILLS_BLOCK_RE.search(prompt) + assert skills_match is not None + skills_block = skills_match.group(0) + shared_line = next( + line for line in skills_block.splitlines() if "demo [names only]" in line + ) + + entries = _compute_skills_breakdown(skills_block) + by_name = {entry["name"]: entry for entry in entries} + assert set(by_name) == {"alpha-skill", "beta-skill"} + + shared_line_bytes = len(shared_line.encode("utf-8")) + assert sum(entry["index_line_bytes"] for entry in entries) == shared_line_bytes + for entry in entries: + assert entry["index_line_total_bytes"] == shared_line_bytes + assert entry["index_line_shared_bytes"] > 0 + assert entry["index_line_skill_count"] == 2 + + +def test_render_includes_per_component_tables(isolated_home): + """The rendered report gains the two new sorted tables (additive).""" + _seed_skill(isolated_home, "demo-skill", "a demo skill") + data = compute_prompt_breakdown("cli") + out = render_breakdown(data) + assert "Toolsets by size" in out + assert "Skills by size" in out + + def test_render_breakdown_is_plain_text(isolated_home): data = compute_prompt_breakdown("cli") out = render_breakdown(data) diff --git a/tests/hermes_cli/test_session_filters.py b/tests/hermes_cli/test_session_filters.py index 8eb721ae41..165b3ccb2e 100644 --- a/tests/hermes_cli/test_session_filters.py +++ b/tests/hermes_cli/test_session_filters.py @@ -72,14 +72,18 @@ class TestBuildPruneFilters: def test_newer_than_sets_lower_bound_only(self): f = build_prune_filters(_ns(newer_than="5h")) assert f["started_before"] is None - assert f["started_after"] == pytest.approx(time.time() - 18000, abs=5) + assert f["started_after"] is None + assert f["last_active_after"] == pytest.approx( + time.time() - 18000, abs=5 + ) assert f["older_than_days"] is None # no implicit 90d cap def test_older_than_bare_days(self): f = build_prune_filters(_ns(older_than="90")) - assert f["started_before"] == pytest.approx( + assert f["last_active_before"] == pytest.approx( time.time() - 90 * 86400, abs=5 ) + assert f["started_before"] is None assert f["started_after"] is None def test_window_before_and_after(self): @@ -87,14 +91,19 @@ class TestBuildPruneFilters: assert f["started_after"] < f["started_before"] def test_inverted_window_rejected(self): - with pytest.raises(ValueError, match="Empty time window"): + with pytest.raises(ValueError, match="Empty start-time window"): build_prune_filters(_ns(after="2h", before="10h")) - def test_tighter_bound_wins(self): - # --older-than 1d and --before 5h both set the upper bound; - # 1d ago is earlier (tighter for "older than") so it wins. + def test_inverted_activity_window_rejected(self): + with pytest.raises(ValueError, match="Empty activity window"): + build_prune_filters(_ns(newer_than="2h", older_than="10h")) + + def test_activity_and_start_bounds_are_independent(self): f = build_prune_filters(_ns(older_than="1d", before="5h")) assert f["started_before"] == pytest.approx( + time.time() - 5 * 3600, abs=5 + ) + assert f["last_active_before"] == pytest.approx( time.time() - 86400, abs=5 ) @@ -141,7 +150,7 @@ class TestBuildPruneFilters: def test_describe_filters_mentions_active_parts(self): f = build_prune_filters(_ns(newer_than="5h", source="cli")) desc = describe_filters(f) - assert "started after" in desc + assert "last active after" in desc assert "source 'cli'" in desc def test_describe_filters_empty(self): diff --git a/tests/hermes_cli/test_sessions_delete.py b/tests/hermes_cli/test_sessions_delete.py index 0c54da1cf1..a52b415c1a 100644 --- a/tests/hermes_cli/test_sessions_delete.py +++ b/tests/hermes_cli/test_sessions_delete.py @@ -145,6 +145,7 @@ def _run_prune(monkeypatch, capsys, argv_tail, candidates=None): "source": "cron", "title": "oldest run", "started_at": 1_600_000_000.0, + "last_active": 1_600_000_050.0, "ended_at": 1_600_000_100.0, "message_count": 2, "archived": 0, @@ -154,6 +155,7 @@ def _run_prune(monkeypatch, capsys, argv_tail, candidates=None): "source": "cron", "title": "newest run", "started_at": 1_700_000_000.0, + "last_active": 1_700_000_050.0, "ended_at": 1_700_000_100.0, "message_count": 4, "archived": 0, @@ -185,8 +187,8 @@ def test_sessions_prune_bare_keeps_90_day_default(monkeypatch, capsys): import time as _time filters, _out = _run_prune(monkeypatch, capsys, []) - assert filters["started_before"] is not None - assert filters["started_before"] == pytest.approx( + assert filters["last_active_before"] is not None + assert filters["last_active_before"] == pytest.approx( _time.time() - 90 * 86400, abs=60 ) @@ -194,6 +196,8 @@ def test_sessions_prune_bare_keeps_90_day_default(monkeypatch, capsys): def test_sessions_prune_source_matches_all_ages(monkeypatch, capsys): """--source alone suppresses the implicit 90-day cutoff (all ages).""" filters, _out = _run_prune(monkeypatch, capsys, ["--source", "cron"]) + assert filters["last_active_before"] is None + assert filters["last_active_after"] is None assert filters["started_before"] is None assert filters["started_after"] is None assert filters["source"] == "cron" @@ -206,7 +210,7 @@ def test_sessions_prune_source_with_explicit_time_respected(monkeypatch, capsys) filters, _out = _run_prune( monkeypatch, capsys, ["--source", "cron", "--older-than", "30"] ) - assert filters["started_before"] == pytest.approx( + assert filters["last_active_before"] == pytest.approx( _time.time() - 30 * 86400, abs=60 ) assert filters["source"] == "cron" @@ -218,5 +222,5 @@ def test_sessions_prune_preview_shows_oldest_newest(monkeypatch, capsys): _filters, out = _run_prune(monkeypatch, capsys, ["--source", "cron"]) assert "2 session(s) match" in out - assert f"oldest {format_epoch(1_600_000_000.0)}" in out - assert f"newest {format_epoch(1_700_000_000.0)}" in out + assert f"oldest activity {format_epoch(1_600_000_050.0)}" in out + assert f"newest activity {format_epoch(1_700_000_050.0)}" in out diff --git a/tests/hermes_cli/test_sessions_export_md_cli.py b/tests/hermes_cli/test_sessions_export_md_cli.py index 665da274c9..5ebf86c580 100644 --- a/tests/hermes_cli/test_sessions_export_md_cli.py +++ b/tests/hermes_cli/test_sessions_export_md_cli.py @@ -189,11 +189,11 @@ def test_sessions_export_md_bulk_dry_run_lists_candidates(monkeypatch, tmp_path, class FakeDB: def list_prune_candidates(self, **kwargs): # Export flows through the shared prune-filter machinery: - # --older-than 30 becomes a started_before epoch bound, source + # --older-than 30 becomes a last-active epoch bound, source # passes through, and archived is tri-state None (export includes # archived sessions). assert kwargs.get("source") == "cron" - assert kwargs.get("started_before") is not None + assert kwargs.get("last_active_before") is not None assert kwargs.get("archived") is None return [{"id": "s1", "source": "cron"}, {"id": "s2", "source": "cron"}] @@ -444,7 +444,7 @@ def test_sessions_export_md_accepts_duration_age_grammar(monkeypatch, tmp_path, class FakeDB: def list_prune_candidates(self, **kwargs): - assert kwargs.get("started_before") is not None + assert kwargs.get("last_active_before") is not None return [{"id": "s1", "source": "cli"}] def close(self): diff --git a/tests/hermes_cli/test_skills_hub.py b/tests/hermes_cli/test_skills_hub.py index 9b2c775ccf..579b3e97a2 100644 --- a/tests/hermes_cli/test_skills_hub.py +++ b/tests/hermes_cli/test_skills_hub.py @@ -92,7 +92,7 @@ def _capture_update(monkeypatch, results) -> tuple[str, list[tuple[str, str, boo monkeypatch.setattr(hub, "HubLockFile", lambda: type("L", (), { "get_installed": lambda self, name: {"install_path": "category/" + name} })()) - monkeypatch.setattr(cli_hub, "do_install", lambda identifier, category="", force=False, console=None: installs.append((identifier, category, force))) + monkeypatch.setattr(cli_hub, "do_install", lambda identifier, category="", force=False, console=None, source_id=None: installs.append((identifier, category, force))) do_update(console=console) return sink.getvalue(), installs @@ -249,6 +249,123 @@ def test_do_update_reinstalls_outdated_skills(monkeypatch): assert "Updated 1 skill" in output +# --------------------------------------------------------------------------- +# Cross-registry hijack regression tests +# +# An update must never change a skill's source registry. Skill names are not +# namespaced across registries, so an unconstrained name resolve can install a +# different author's same-named skill over the user's files. +# --------------------------------------------------------------------------- + + +def test_do_update_pins_install_to_locked_source(monkeypatch): + """do_update must forward the lockfile's `source` to do_install. + + Without the pin, a bare identifier like "reddit" reaches + _resolve_short_name()'s fuzzy catalog search inside do_install and can + resolve to a same-named skill in another registry. + """ + import tools.skills_hub as hub + import hermes_cli.skills_hub as cli_hub + + sink = StringIO() + console = Console(file=sink, force_terminal=False, color_system=None) + calls = [] + + monkeypatch.setattr(hub, "check_for_skill_updates", lambda **_kwargs: [ + {"name": "reddit", "identifier": "reddit", "source": "clawhub", + "status": "update_available"}, + ]) + monkeypatch.setattr(hub, "HubLockFile", lambda: type("L", (), { + "get_installed": lambda self, name: {"install_path": "category/" + name} + })()) + monkeypatch.setattr( + cli_hub, "do_install", + lambda identifier, category="", force=False, console=None, source_id=None: + calls.append({"identifier": identifier, "source_id": source_id}), + ) + + do_update(console=console) + + assert calls == [{"identifier": "reddit", "source_id": "clawhub"}] + + +def test_do_install_refuses_unknown_pinned_source(monkeypatch, hub_env): + """A pinned source with no matching adapter must abort, not fall back. + + Falling back to the full source router is what allowed a foreign registry + to satisfy the install. + """ + import tools.skills_hub as hub + + sink = StringIO() + console = Console(file=sink, force_terminal=False, color_system=None) + resolved = [] + + monkeypatch.setattr(hub, "create_source_router", lambda auth=None: []) + monkeypatch.setattr(hub, "GitHubAuth", lambda: object()) + monkeypatch.setattr( + "hermes_cli.skills_hub._resolve_short_name", + lambda name, sources, c: resolved.append(name) or "", + ) + + do_install("reddit", source_id="clawhub", console=console) + + assert resolved == [], "must not attempt a fuzzy resolve when the pin is unsatisfiable" + assert "provenance" in sink.getvalue() + + +def test_check_for_skill_updates_does_not_fall_back_across_registries(): + """An entry whose source has no adapter reports `unavailable`. + + Previously `candidate_sources ... or sources` fell back to every source, so + a same-named skill in another registry could satisfy the fetch and be + reported as this entry's update -- the step that preceded the overwrite. + The foreign source here returns a *valid* bundle with a different hash, so + the old code reports `update_available` (sourced from the wrong registry) + while the fixed code reports `unavailable`. + """ + from tools.skills_hub import check_for_skill_updates + + class _ForeignBundle: + name = "reddit" + files = {"SKILL.md": "# a different author's reddit skill"} + source = "skills.sh" + identifier = "skills-sh/someone-else/reddit" + trust_level = "community" + metadata: dict = {} + + class _ForeignSource: + """skills-sh adapter; must NOT be consulted for a clawhub-locked entry.""" + + def source_id(self): + return "skills-sh" + + def fetch(self, identifier): + return _ForeignBundle() + + def inspect(self, identifier): + return _ForeignBundle() + + lock = _DummyLockFile([ + {"name": "reddit", "identifier": "reddit", "source": "clawhub", + "content_hash": "hash-of-the-clawhub-copy"}, + ]) + + results = check_for_skill_updates( + lock=lock, # type: ignore[arg-type] # duck-typed double, matches _DummyLockFile usage above + sources=[_ForeignSource()], # type: ignore[list-item] + ) + + assert len(results) == 1 + assert results[0]["source"] == "clawhub", "provenance must be preserved" + assert results[0]["status"] == "unavailable", ( + "a clawhub-locked skill must not be matched against a skills-sh bundle; " + "reporting update_available here is the cross-registry hijack" + ) + assert "bundle" not in results[0], "must not carry a foreign registry's bundle" + + def test_handle_skills_slash_search_accepts_chatconsole_without_status_errors(): results = [type("R", (), { "name": "kubernetes", diff --git a/tests/hermes_cli/test_update_autostash.py b/tests/hermes_cli/test_update_autostash.py index d89d830b14..94fd27949f 100644 --- a/tests/hermes_cli/test_update_autostash.py +++ b/tests/hermes_cli/test_update_autostash.py @@ -480,6 +480,94 @@ def test_cmd_update_succeeds_with_extras(monkeypatch, tmp_path): assert ".[all]" in install_cmds[0] +def test_refresh_active_memory_provider_dependencies_reinstalls_active_provider(monkeypatch): + """#53272/#70636: update must re-run the active provider's dep install.""" + recorded = [] + + monkeypatch.setattr( + "hermes_cli.config.load_config", + lambda: {"memory": {"provider": "mem0"}}, + ) + monkeypatch.setattr( + "hermes_cli.memory_setup._install_dependencies", + lambda provider_name, force=False: recorded.append((provider_name, force)), + ) + + hermes_main._refresh_active_memory_provider_dependencies() + + assert recorded == [("mem0", True)] + + +@pytest.mark.parametrize( + "memory_cfg", + [ + {}, # no provider configured + {"provider": ""}, # empty provider + {"provider": "default"}, # built-in store + {"provider": "mem0", "enabled": False}, # memory disabled + ], +) +def test_refresh_active_memory_provider_dependencies_skips_inactive(monkeypatch, memory_cfg): + recorded = [] + + monkeypatch.setattr( + "hermes_cli.config.load_config", + lambda: {"memory": memory_cfg}, + ) + monkeypatch.setattr( + "hermes_cli.memory_setup._install_dependencies", + lambda provider_name, force=False: recorded.append((provider_name, force)), + ) + + hermes_main._refresh_active_memory_provider_dependencies() + + assert recorded == [] + + +def test_refresh_active_memory_provider_dependencies_never_raises(monkeypatch): + """A provider install failure must not block the rest of the update.""" + monkeypatch.setattr( + "hermes_cli.config.load_config", + lambda: {"memory": {"provider": "hindsight"}}, + ) + + def boom(provider_name, force=False): + raise RuntimeError("pip exploded") + + monkeypatch.setattr("hermes_cli.memory_setup._install_dependencies", boom) + + hermes_main._refresh_active_memory_provider_dependencies() # must not raise + + +def test_cmd_update_refreshes_active_memory_provider_dependencies(monkeypatch, tmp_path): + """The git-pull update path must invoke the memory-provider refresh.""" + _setup_update_mocks(monkeypatch, tmp_path) + monkeypatch.setattr("shutil.which", lambda name: "/usr/bin/uv" if name == "uv" else None) + monkeypatch.setattr(hermes_main, "_is_termux_env", lambda env=None: False) + + refresh_calls = [] + monkeypatch.setattr( + hermes_main, + "_refresh_active_memory_provider_dependencies", + lambda: refresh_calls.append(True), + ) + + def fake_run(cmd, **kwargs): + if cmd == ["git", "rev-parse", "--abbrev-ref", "HEAD"]: + return SimpleNamespace(stdout="main\n", stderr="", returncode=0) + if cmd == ["git", "rev-list", "HEAD..origin/main", "--count"]: + return SimpleNamespace(stdout="1\n", stderr="", returncode=0) + if cmd == ["git", "pull", "--ff-only", "origin", "main"]: + return SimpleNamespace(stdout="Updating\n", stderr="", returncode=0) + return SimpleNamespace(returncode=0, stdout="", stderr="") + + monkeypatch.setattr(hermes_main.subprocess, "run", fake_run) + + hermes_main.cmd_update(SimpleNamespace()) + + assert refresh_calls == [True] + + def test_install_with_optional_fallback_honors_custom_group(monkeypatch): """Termux update path should target .[termux-all] when requested.""" calls = [] diff --git a/tests/hermes_cli/test_update_gateway_launcher_refresh.py b/tests/hermes_cli/test_update_gateway_launcher_refresh.py new file mode 100644 index 0000000000..59c8d5e9bd --- /dev/null +++ b/tests/hermes_cli/test_update_gateway_launcher_refresh.py @@ -0,0 +1,170 @@ +"""Legacy pythonw launcher normalization + post-update launcher refresh. + +Covers the two halves of the "legacy pythonw gateways survive updates +forever" gap: + +1. ``gateway_windows._resolve_detached_python`` — normalizes a legacy + ``pythonw.exe`` interpreter (pre-aa2ae36c3f launchers / argv snapshots) + to the sibling console ``python.exe`` so respawns and regenerated + launchers use the hidden-console design (#54220/#56747) and don't die + with ``RuntimeError: sys.stderr is None`` (#71671). +2. ``hermes_cli.main._refresh_windows_gateway_launchers`` — ``hermes + update`` regenerates the installed Scheduled Task / Startup launcher + scripts instead of leaving install-time artifacts stale forever. + +Windows-specific paths are exercised via ``_is_windows`` patching so they +run on any host (same approach as test_update_venv_health). +""" + +from __future__ import annotations + +from pathlib import Path +from unittest import mock + +import hermes_cli.gateway_windows as gateway_windows +import hermes_cli.main as cli_main + + +# --------------------------------------------------------------------------- +# _resolve_detached_python: legacy pythonw normalization +# --------------------------------------------------------------------------- + + +def _make_venv(tmp_path: Path, *, with_console_python: bool) -> tuple[Path, Path]: + scripts = tmp_path / "venv" / "Scripts" + scripts.mkdir(parents=True) + pythonw = scripts / "pythonw.exe" + pythonw.write_text("", encoding="utf-8") + python = scripts / "python.exe" + if with_console_python: + python.write_text("", encoding="utf-8") + return pythonw, python + + +def test_resolve_detached_python_swaps_legacy_pythonw_for_console_sibling(tmp_path): + pythonw, python = _make_venv(tmp_path, with_console_python=True) + + exe, venv_dir, extra = gateway_windows._resolve_detached_python(str(pythonw)) + + assert exe == str(python) + assert venv_dir == tmp_path / "venv" + assert extra == [] + + +def test_resolve_detached_python_keeps_pythonw_when_no_console_sibling(tmp_path): + """A failed respawn is worse than a console-less gateway — never swap to + an interpreter that doesn't exist.""" + pythonw, _python = _make_venv(tmp_path, with_console_python=False) + + exe, venv_dir, extra = gateway_windows._resolve_detached_python(str(pythonw)) + + assert exe == str(pythonw) + assert venv_dir == tmp_path / "venv" + assert extra == [] + + +def test_resolve_detached_python_leaves_console_python_untouched(tmp_path): + _pythonw, python = _make_venv(tmp_path, with_console_python=True) + + exe, venv_dir, _extra = gateway_windows._resolve_detached_python(str(python)) + + assert exe == str(python) + assert venv_dir == tmp_path / "venv" + + +def test_restart_spec_normalizes_legacy_pythonw_argv(tmp_path): + """A pre-rework Scheduled Task argv snapshot (leading pythonw.exe) must be + respawned through the console python + hidden-console launch, with every + argument after the interpreter preserved verbatim.""" + pythonw, python = _make_venv(tmp_path, with_console_python=True) + + # Pre-import so the function's lazy imports resolve from sys.modules + # instead of re-importing under the win32 platform patch (see the + # TestWindowlessGatewayRestartSpec comment in + # tests/tools/test_windows_native_support.py). + import hermes_cli.config # noqa: F401 + import hermes_cli.gateway # noqa: F401 + + argv = [str(pythonw), "-m", "hermes_cli.main", "gateway", "run"] + with mock.patch.object(gateway_windows.sys, "platform", "win32"), mock.patch.object( + gateway_windows, "_stable_gateway_working_dir", return_value=str(tmp_path) + ), mock.patch("hermes_cli.config.get_hermes_home", return_value=str(tmp_path)): + new_argv, cwd, env = gateway_windows.windowless_gateway_restart_spec(list(argv)) + + assert new_argv[0] == str(python) + assert new_argv[1:] == argv[1:] + assert cwd == str(tmp_path) + assert env["VIRTUAL_ENV"] == str(tmp_path / "venv") + + +# --------------------------------------------------------------------------- +# _refresh_windows_gateway_launchers: hermes update regenerates launchers +# --------------------------------------------------------------------------- + + +def test_refresh_is_noop_off_windows(): + with mock.patch.object(cli_main, "_is_windows", return_value=False), mock.patch.object( + gateway_windows, "is_installed" + ) as is_installed: + cli_main._refresh_windows_gateway_launchers() + is_installed.assert_not_called() + + +@mock.patch.object(cli_main, "_is_windows", return_value=True) +def test_refresh_rewrites_launchers_when_installed(_winp): + with mock.patch.object(gateway_windows, "is_installed", return_value=True), mock.patch.object( + gateway_windows, "_write_task_script" + ) as write_script: + cli_main._refresh_windows_gateway_launchers() + write_script.assert_called_once_with() + + +@mock.patch.object(cli_main, "_is_windows", return_value=True) +def test_refresh_skips_when_no_autostart_installed(_winp): + with mock.patch.object(gateway_windows, "is_installed", return_value=False), mock.patch.object( + gateway_windows, "_write_task_script" + ) as write_script: + cli_main._refresh_windows_gateway_launchers() + write_script.assert_not_called() + + +@mock.patch.object(cli_main, "_is_windows", return_value=True) +def test_refresh_failure_never_raises(_winp): + with mock.patch.object(gateway_windows, "is_installed", return_value=True), mock.patch.object( + gateway_windows, "_write_task_script", side_effect=OSError("locked") + ): + cli_main._refresh_windows_gateway_launchers() # must not raise + + +@mock.patch.object(cli_main, "_is_windows", return_value=True) +def test_resume_after_update_refreshes_launchers_first(_winp): + """The resume path regenerates launchers before any respawn, including the + cold-start-only shape (no gateway was running, autostart installed).""" + calls: list[str] = [] + with mock.patch.object( + cli_main, + "_refresh_windows_gateway_launchers", + side_effect=lambda: calls.append("refresh"), + ), mock.patch.object( + cli_main, + "_cold_start_windows_gateway_after_update", + side_effect=lambda: calls.append("cold_start"), + ): + cli_main._resume_windows_gateways_after_update( + { + "resume_needed": True, + "profiles": {}, + "unmapped_pids": [], + "unmapped": [], + "cold_start_if_installed": True, + } + ) + + assert calls == ["refresh", "cold_start"] + + +def test_resume_after_update_noop_token_skips_refresh(): + with mock.patch.object(cli_main, "_refresh_windows_gateway_launchers") as refresh: + cli_main._resume_windows_gateways_after_update(None) + cli_main._resume_windows_gateways_after_update({"resume_needed": False}) + refresh.assert_not_called() diff --git a/tests/hermes_cli/test_update_stale_dashboard.py b/tests/hermes_cli/test_update_stale_dashboard.py index fd26590786..bb60a33c03 100644 --- a/tests/hermes_cli/test_update_stale_dashboard.py +++ b/tests/hermes_cli/test_update_stale_dashboard.py @@ -21,6 +21,7 @@ from unittest.mock import patch, MagicMock import pytest from hermes_cli.main import ( + _finish_dashboard_update_cleanup, _find_stale_dashboard_pids, _kill_stale_dashboard_processes, _restart_managed_dashboard_service, @@ -46,6 +47,7 @@ def _refresh_bindings_against_live_module(): ordering within the worker. The fix lives in the test module because the two pollutants above are load-bearing for their own tests. """ + global _finish_dashboard_update_cleanup global _find_stale_dashboard_pids global _kill_stale_dashboard_processes global _restart_managed_dashboard_service @@ -55,6 +57,7 @@ def _refresh_bindings_against_live_module(): if live is None: live = importlib.import_module("hermes_cli.main") + _finish_dashboard_update_cleanup = live._finish_dashboard_update_cleanup _find_stale_dashboard_pids = live._find_stale_dashboard_pids _kill_stale_dashboard_processes = live._kill_stale_dashboard_processes _restart_managed_dashboard_service = live._restart_managed_dashboard_service @@ -237,8 +240,9 @@ class TestKillStaleDashboardPosix: def test_no_stale_processes_is_a_noop(self, capsys): with patch("hermes_cli.main._find_stale_dashboard_pids", return_value=[]): - _kill_stale_dashboard_processes() + result = _kill_stale_dashboard_processes() assert capsys.readouterr().out == "" + assert result == {"matched": [], "killed": [], "failed": []} def test_sigterm_graceful_exit(self, capsys): """Processes that exit on SIGTERM (the probe gets ProcessLookupError) @@ -258,13 +262,16 @@ class TestKillStaleDashboardPosix: return_value=[12345, 12346]), \ patch("os.kill", side_effect=fake_kill), \ patch("time.sleep"): - _kill_stale_dashboard_processes() + result = _kill_stale_dashboard_processes() # Both got SIGTERM. sigterms = [pid for pid, sig in killed_signals if sig == _signal.SIGTERM] assert sorted(sigterms) == [12345, 12346] # No SIGKILL was needed. assert not any(sig == _signal.SIGKILL for _, sig in killed_signals) + assert result["matched"] == [12345, 12346] + assert result["killed"] == [12345, 12346] + assert result["failed"] == [] out = capsys.readouterr().out assert "Stopping 2 dashboard" in out @@ -514,6 +521,44 @@ class TestBackCompatAlias: assert _warn_stale_dashboard_processes is _kill_stale_dashboard_processes +class TestDashboardUpdateCleanup: + """The git and Windows ZIP update paths share this final cleanup.""" + + def test_all_failed_stops_do_not_claim_the_dashboard_was_stopped(self, capsys): + with patch( + "hermes_cli.main._kill_stale_dashboard_processes", + return_value={"matched": [12345], "killed": [], "failed": [(12345, "denied")], + "unrecovered": []}, + ): + _finish_dashboard_update_cleanup([]) + + assert "stopped during update" not in capsys.readouterr().out + + def test_auto_restarted_stop_prints_no_notice(self, capsys): + """A killed process that was auto-restarted (systemd unit or argv + respawn) must not trigger the manual-relaunch warning.""" + with patch( + "hermes_cli.main._kill_stale_dashboard_processes", + return_value={"matched": [12345], "killed": [12345], "failed": [], + "unrecovered": []}, + ): + _finish_dashboard_update_cleanup([]) + + assert "stopped during update" not in capsys.readouterr().out + + def test_unrecovered_stop_prints_shared_update_notice(self, capsys): + with patch( + "hermes_cli.main._kill_stale_dashboard_processes", + return_value={"matched": [12345], "killed": [12345], "failed": [], + "unrecovered": [12345]}, + ): + _finish_dashboard_update_cleanup([]) + + out = capsys.readouterr().out + assert "stopped during update and could not be auto-restarted" in out + assert "hermes dashboard --port " in out + + class TestWindowsWmicEncoding: """Regression tests for #17049 — the Windows wmic branch must not crash `hermes update` on non-UTF-8 system locales (e.g. cp936 on zh-CN). @@ -562,3 +607,238 @@ class TestWindowsWmicEncoding: ) # Must not raise. assert _find_stale_dashboard_pids() == [] + + +class TestSupervisedBackendRestart: + """After the kill, systemd-supervised PIDs get their owning unit + restarted (#68934) — SIGTERM reads as a clean stop to systemd, so + Restart=on-failure never fires on its own.""" + + def _live(self): + return sys.modules["hermes_cli.main"] + + def test_supervised_pid_restarts_owning_unit(self, capsys): + """A killed PID whose cgroup names a custom unit → systemctl restart.""" + live = self._live() + + def fake_kill(pid, sig): + if sig == 0: + raise ProcessLookupError + + with patch.object(live, "_restart_managed_dashboard_service", return_value=False), \ + patch.object(live, "_find_stale_dashboard_pids", return_value=[4321]), \ + patch.object(live, "_get_pid_cgroup_path", + return_value="/system.slice/hermes-serve.service"), \ + patch.object(live, "_get_systemd_service_for_pid", + return_value="hermes-serve.service"), \ + patch.object(live, "_try_restart_systemd_service", return_value=True) as restart, \ + patch("os.kill", side_effect=fake_kill), \ + patch("time.sleep"): + _kill_stale_dashboard_processes(restart_managed=True) + + restart.assert_called_once_with( + "hermes-serve.service", "/system.slice/hermes-serve.service" + ) + out = capsys.readouterr().out + assert "✓ restarted systemd service hermes-serve.service" in out + # Supervised restart succeeded — no manual hint. + assert "when you're ready" not in out + + def test_supervised_restart_failure_prints_hint(self, capsys): + live = self._live() + + def fake_kill(pid, sig): + if sig == 0: + raise ProcessLookupError + + with patch.object(live, "_restart_managed_dashboard_service", return_value=False), \ + patch.object(live, "_find_stale_dashboard_pids", return_value=[4321]), \ + patch.object(live, "_get_pid_cgroup_path", + return_value="/system.slice/hermes-serve.service"), \ + patch.object(live, "_get_systemd_service_for_pid", + return_value="hermes-serve.service"), \ + patch.object(live, "_try_restart_systemd_service", return_value=False), \ + patch("os.kill", side_effect=fake_kill), \ + patch("time.sleep"): + _kill_stale_dashboard_processes(restart_managed=True) + + out = capsys.readouterr().out + assert "⚠ hermes-serve.service" in out + assert "Restart anything not auto-restarted" in out + + def test_same_unit_restarted_once_for_multiple_pids(self, capsys): + """Two killed PIDs in the same unit → one systemctl restart.""" + live = self._live() + + def fake_kill(pid, sig): + if sig == 0: + raise ProcessLookupError + + with patch.object(live, "_restart_managed_dashboard_service", return_value=False), \ + patch.object(live, "_find_stale_dashboard_pids", return_value=[111, 222]), \ + patch.object(live, "_get_pid_cgroup_path", + return_value="/system.slice/hermes-serve.service"), \ + patch.object(live, "_get_systemd_service_for_pid", + return_value="hermes-serve.service"), \ + patch.object(live, "_try_restart_systemd_service", return_value=True) as restart, \ + patch("os.kill", side_effect=fake_kill), \ + patch("time.sleep"): + _kill_stale_dashboard_processes(restart_managed=True) + + assert restart.call_count == 1 + + def test_stop_path_never_restarts(self, capsys): + """`hermes dashboard --stop` (restart_managed=False) must stay a stop: + no cgroup snapshot, no unit restart, no respawn.""" + live = self._live() + + def fake_kill(pid, sig): + if sig == 0: + raise ProcessLookupError + + with patch.object(live, "_find_stale_dashboard_pids", return_value=[4321]), \ + patch.object(live, "_get_pid_cgroup_path") as cg, \ + patch.object(live, "_try_restart_systemd_service") as restart, \ + patch.object(live, "_respawn_dashboard_processes") as respawn, \ + patch("os.kill", side_effect=fake_kill), \ + patch("time.sleep"): + _kill_stale_dashboard_processes(reason="requested via --stop") + + cg.assert_not_called() + restart.assert_not_called() + respawn.assert_not_called() + out = capsys.readouterr().out + assert "Restart the dashboard when you're ready" in out + + +class TestManualBackendRespawn: + """Manually-started dashboards/serves have their argv captured before the + kill and are respawned detached after the update (#40449).""" + + def _live(self): + return sys.modules["hermes_cli.main"] + + def test_manual_pid_respawned_with_captured_argv(self, capsys): + live = self._live() + argv = ["/usr/bin/python3", "-m", "hermes_cli.main", "serve", "--port", "8300"] + + def fake_kill(pid, sig): + if sig == 0: + raise ProcessLookupError + + with patch.object(live, "_restart_managed_dashboard_service", return_value=False), \ + patch.object(live, "_find_stale_dashboard_pids", return_value=[5555]), \ + patch.object(live, "_get_pid_cgroup_path", return_value="/user.slice/user-1000.slice/session-3.scope"), \ + patch.object(live, "_get_systemd_service_for_pid", return_value=None), \ + patch.object(live, "_dashboard_cmdline_for_pid", return_value=argv) as capture, \ + patch.object(live, "_respawn_dashboard_processes", return_value=[]) as respawn, \ + patch("os.kill", side_effect=fake_kill), \ + patch("time.sleep"): + _kill_stale_dashboard_processes(restart_managed=True) + + capture.assert_called_once_with(5555) + respawn.assert_called_once_with([argv]) + out = capsys.readouterr().out + assert "when you're ready" not in out + + def test_argv_capture_failure_falls_back_to_hint(self, capsys): + live = self._live() + + def fake_kill(pid, sig): + if sig == 0: + raise ProcessLookupError + + with patch.object(live, "_restart_managed_dashboard_service", return_value=False), \ + patch.object(live, "_find_stale_dashboard_pids", return_value=[5555]), \ + patch.object(live, "_get_pid_cgroup_path", return_value=None), \ + patch.object(live, "_get_systemd_service_for_pid", return_value=None), \ + patch.object(live, "_dashboard_cmdline_for_pid", return_value=None), \ + patch.object(live, "_respawn_dashboard_processes") as respawn, \ + patch("os.kill", side_effect=fake_kill), \ + patch("time.sleep"): + _kill_stale_dashboard_processes(restart_managed=True) + + respawn.assert_not_called() + out = capsys.readouterr().out + assert "Restart anything not auto-restarted" in out + + def test_respawn_adds_no_open_to_dashboard_commands(self, tmp_path, monkeypatch): + """Respawned `dashboard` argv gains --no-open; `serve` argv untouched.""" + live = self._live() + monkeypatch.setenv("HERMES_HOME", str(tmp_path / ".hermes")) + spawned: list[list[str]] = [] + + class _FakePopen: + def __init__(self, cmd, **kwargs): + spawned.append(list(cmd)) + + with patch.object(live.subprocess, "Popen", _FakePopen): + failed = live._respawn_dashboard_processes([ + ["hermes", "dashboard", "--port", "8300"], + ["hermes", "serve", "--host", "0.0.0.0"], + ]) + + assert failed == [] + assert spawned[0] == ["hermes", "dashboard", "--port", "8300", "--no-open"] + assert spawned[1] == ["hermes", "serve", "--host", "0.0.0.0"] + + def test_respawn_failure_returned(self, tmp_path, monkeypatch, capsys): + live = self._live() + monkeypatch.setenv("HERMES_HOME", str(tmp_path / ".hermes")) + + with patch.object(live.subprocess, "Popen", side_effect=OSError("no such file")): + failed = live._respawn_dashboard_processes([["hermes", "serve"]]) + + assert failed == [["hermes", "serve"]] + out = capsys.readouterr().out + assert "✗ failed to restart" in out + + +class TestCmdlineCapture: + """_dashboard_cmdline_for_pid reads /proc on Linux, ps on macOS.""" + + def _live(self): + return sys.modules["hermes_cli.main"] + + def test_reads_proc_cmdline_when_available(self, tmp_path, monkeypatch): + live = self._live() + proc_file = tmp_path / "cmdline" + proc_file.write_bytes(b"/usr/bin/python3\x00-m\x00hermes_cli.main\x00serve\x00") + + real_exists = os.path.exists + + def fake_exists(path): + if path == "/proc/777/cmdline": + return True + return real_exists(path) + + real_open = open + + def fake_open(path, *a, **kw): + if path == "/proc/777/cmdline": + return real_open(proc_file, *a, **kw) + return real_open(path, *a, **kw) + + with patch.object(live.os.path, "exists", fake_exists), \ + patch("builtins.open", fake_open): + argv = live._dashboard_cmdline_for_pid(777) + + assert argv == ["/usr/bin/python3", "-m", "hermes_cli.main", "serve"] + + def test_falls_back_to_ps_without_proc(self, monkeypatch): + live = self._live() + + def fake_run(args, *a, **kw): + assert args == ["ps", "-p", "888", "-o", "command="] + return MagicMock(returncode=0, stdout="hermes serve --port 8300\n", stderr="") + + with patch.object(live.os.path, "exists", return_value=False), \ + patch("subprocess.run", side_effect=fake_run): + argv = live._dashboard_cmdline_for_pid(888) + + assert argv == ["hermes", "serve", "--port", "8300"] + + def test_returns_none_on_windows(self, monkeypatch): + live = self._live() + monkeypatch.setattr(live.sys, "platform", "win32") + assert live._dashboard_cmdline_for_pid(123) is None diff --git a/tests/hermes_cli/test_user_providers_model_switch.py b/tests/hermes_cli/test_user_providers_model_switch.py index 8c743e71b9..877042977f 100644 --- a/tests/hermes_cli/test_user_providers_model_switch.py +++ b/tests/hermes_cli/test_user_providers_model_switch.py @@ -390,6 +390,9 @@ def test_list_authenticated_providers_user_openai_official_url_fallback(monkeypa """User providers: api.openai.com with no models list uses native curated fallback.""" monkeypatch.setattr("agent.models_dev.fetch_models_dev", lambda: {}) monkeypatch.setattr("hermes_cli.providers.HERMES_OVERLAYS", {}) + # No models: list → un-narrowed → section 3 probes; simulate the keyless + # probe failing (401) so the curated fallback is exercised hermetically. + monkeypatch.setattr("hermes_cli.models.fetch_api_models", lambda *a, **k: None) user_providers = { "openai-direct": { @@ -413,6 +416,9 @@ def test_list_authenticated_providers_fallback_to_default_only(monkeypatch): """When no models array is provided, should fall back to default_model.""" monkeypatch.setattr("agent.models_dev.fetch_models_dev", lambda: {}) monkeypatch.setattr("hermes_cli.providers.HERMES_OVERLAYS", {}) + # default_model-only entries are un-narrowed, so section 3 probes the + # live endpoint; simulate it being unreachable to test the fallback. + monkeypatch.setattr("hermes_cli.models.fetch_api_models", lambda *a, **k: None) user_providers = { "simple-provider": { @@ -554,6 +560,9 @@ def test_list_authenticated_providers_no_duplicate_labels_across_schemas(monkeyp """ monkeypatch.setattr("agent.models_dev.fetch_models_dev", lambda: {}) monkeypatch.setattr("hermes_cli.providers.HERMES_OVERLAYS", {}) + # Singular ``model:``-only entries are un-narrowed → section 3 now probes + # them; stub the probe so the test stays hermetic (endpoints are fake). + monkeypatch.setattr("hermes_cli.models.fetch_api_models", lambda *a, **k: None) shared_entries = [ ("endpoint-a", "http://a.local/v1"), @@ -1173,6 +1182,53 @@ def test_section3_probes_no_key_endpoint_without_explicit_models(monkeypatch): assert row["total_models"] == 3 +def test_section3_probes_no_key_endpoint_with_singular_default_model(monkeypatch): + """A providers: entry with no api_key and only a singular ``default_model`` + (no explicit ``models:`` list) must still probe /v1/models — the singular + field is just the active selection, not the user narrowing the endpoint. + + Regression for #40554 / PR #68984 (@vigilancetech-com): section 3 derived + ``has_explicit_models`` from the merged models list, so the lone + ``default_model`` entry suppressed live discovery and the /model picker + showed a one-line menu for local no-auth endpoints. + """ + monkeypatch.setattr("agent.models_dev.fetch_models_dev", lambda: {}) + monkeypatch.setattr("hermes_cli.providers.HERMES_OVERLAYS", {}) + + probed = {} + + def _fake_fetch(api_key, api_url, **kwargs): + probed["called"] = True + probed["api_key"] = api_key + return ["live-model-1", "live-model-2", "live-model-3"] + + monkeypatch.setattr("hermes_cli.models.fetch_api_models", _fake_fetch) + + user_providers = { + "local-ollama": { + "name": "Local Ollama", + "api": "http://localhost:11434/v1", + "default_model": "llama3", + # No api_key, no models: list — singular default only. + } + } + + providers = list_authenticated_providers( + current_provider="local-ollama", + user_providers=user_providers, + custom_providers=[], + max_models=50, + ) + + assert probed.get("called") is True, ( + "singular default_model must not suppress live discovery" + ) + assert probed["api_key"] == "" + row = next(p for p in providers if p["slug"] == "local-ollama") + assert row["models"] == ["live-model-1", "live-model-2", "live-model-3"] + assert row["total_models"] == 3 + + def test_section3_skips_probe_when_no_key_but_explicit_models(monkeypatch): """A no-key endpoint WITH an explicit models: list is the user narrowing a public endpoint to a subset — skip live discovery and keep the list.""" diff --git a/tests/hermes_cli/test_web_server.py b/tests/hermes_cli/test_web_server.py index 895b0ddf79..24ef3d0f8c 100644 --- a/tests/hermes_cli/test_web_server.py +++ b/tests/hermes_cli/test_web_server.py @@ -2186,7 +2186,9 @@ class TestWebServerEndpoints: assert row["profile"] == "default" assert row["is_default_profile"] is True assert isinstance(data.get("errors"), list) - assert data["recents"]["total"] >= 1 + # Pagination reports "was this window capped?" per profile, not an exact + # COUNT(*) — one row against a 20-row cap means nothing more to load. + assert data["recents"]["profiles_truncated"]["default"] is False def test_sessions_endpoint_reads_requested_profile(self): """The machine dashboard's global profile switcher must retarget @@ -3659,6 +3661,42 @@ class TestWebServerEndpoints: finally: platform_registry.unregister("ircfake") + def test_messaging_catalog_prefers_plugin_label_over_enum_pseudo_member(self): + """A plugin platform that leaked into Platform.__members__ as a pseudo- + member must still render with its plugin label, not a title-cased id. + + Regression: Platform("") caches a pseudo-member in the enum; + the catalog iterated the enum FIRST and claimed the id with no plugin + metadata, so bundled plugin platforms (irc, ntfy, photon, …) rendered + as nameless "Irc"/"Ntfy" cards with empty descriptions. + """ + from gateway.config import Platform + from gateway.platform_registry import PlatformEntry, platform_registry + + entry = PlatformEntry( + name="pseudofake", + label="Pseudo Fake (plugin label)", + adapter_factory=lambda cfg: None, + check_fn=lambda: True, + source="plugin", + ) + platform_registry.register(entry) + try: + # Materialize the enum pseudo-member the way any earlier config + # read would (Platform(value) on a registered plugin platform). + member = Platform("pseudofake") + assert member.value == "pseudofake" + assert "PSEUDOFAKE" in Platform.__members__ + + resp = self.client.get("/api/messaging/platforms") + ids = {row["id"]: row for row in resp.json()["platforms"]} + assert "pseudofake" in ids + assert ids["pseudofake"]["name"] == "Pseudo Fake (plugin label)" + finally: + platform_registry.unregister("pseudofake") + Platform._value2member_map_.pop("pseudofake", None) + Platform._member_map_.pop("PSEUDOFAKE", None) + def test_update_messaging_platform_saves_env_and_enablement(self): from hermes_cli.config import load_config, load_env diff --git a/tests/plugins/model_providers/test_deepseek_profile.py b/tests/plugins/model_providers/test_deepseek_profile.py index 8c316a3808..d54b291d8d 100644 --- a/tests/plugins/model_providers/test_deepseek_profile.py +++ b/tests/plugins/model_providers/test_deepseek_profile.py @@ -1,10 +1,10 @@ """Unit tests for the DeepSeek provider profile's thinking-mode wiring. -DeepSeek V4 (and the legacy ``deepseek-reasoner``) expects every request to -carry an explicit ``extra_body.thinking`` parameter. Omitting it makes the -server default to thinking-mode ON, which then enforces the -``reasoning_content``-must-be-echoed-back contract on subsequent turns and -breaks the conversation with HTTP 400 (#15700, #17212, #17825). +DeepSeek V4 expects every request to carry an explicit ``extra_body.thinking`` +parameter. Omitting it makes the server default to thinking-mode ON, which +then enforces the ``reasoning_content``-must-be-echoed-back contract on +subsequent turns and breaks the conversation with HTTP 400 (#15700, #17212, +#17825). These tests pin the profile's wire-shape contract so DeepSeek requests stay correctly shaped without going live. @@ -106,7 +106,7 @@ class TestDeepSeekThinkingWireShape: class TestDeepSeekModelGating: - """V4 family + ``deepseek-reasoner`` get thinking; V3 stays untouched.""" + """V4 family gets thinking; V3 / unknown stay untouched.""" @pytest.mark.parametrize( "model", @@ -114,7 +114,6 @@ class TestDeepSeekModelGating: "deepseek-v4-pro", "deepseek-v4-flash", "deepseek-v4-future-variant", - "deepseek-reasoner", "DEEPSEEK-V4-PRO", # case-insensitive ], ) @@ -127,7 +126,6 @@ class TestDeepSeekModelGating: @pytest.mark.parametrize( "model", [ - "deepseek-chat", # V3 alias "deepseek-v3-0324", # explicit V3 "deepseek-v3.1", # V3 minor revisions "", # bare/unknown @@ -168,11 +166,11 @@ class TestDeepSeekFullKwargsIntegration: assert kwargs["reasoning_effort"] == "high" assert kwargs["extra_body"] == {"thinking": {"type": "enabled"}} - def test_v3_chat_full_kwargs_omit_thinking(self, deepseek_profile): + def test_v3_full_kwargs_omit_thinking(self, deepseek_profile): from agent.transports.chat_completions import ChatCompletionsTransport kwargs = ChatCompletionsTransport().build_kwargs( - model="deepseek-chat", + model="deepseek-v3-0324", messages=[{"role": "user", "content": "ping"}], tools=None, provider_profile=deepseek_profile, @@ -195,12 +193,18 @@ class TestDeepSeekAuxModel: system. """ - def test_profile_advertises_deepseek_chat(self, deepseek_profile): - assert deepseek_profile.default_aux_model == "deepseek-chat" + def test_profile_advertises_deepseek_v4_flash(self, deepseek_profile): + assert deepseek_profile.default_aux_model == "deepseek-v4-flash" - def test_consumer_api_returns_deepseek_chat(self): + def test_fallback_models_are_v4_only(self, deepseek_profile): + assert deepseek_profile.fallback_models == ( + "deepseek-v4-pro", + "deepseek-v4-flash", + ) + + def test_consumer_api_returns_deepseek_v4_flash(self): from agent.auxiliary_client import _get_aux_model_for_provider - assert _get_aux_model_for_provider("deepseek") == "deepseek-chat" + assert _get_aux_model_for_provider("deepseek") == "deepseek-v4-flash" def test_consumer_api_returns_non_empty(self): from agent.auxiliary_client import _get_aux_model_for_provider diff --git a/tests/test_hermes_state.py b/tests/test_hermes_state.py index 6f3704fa3e..e99785ae56 100644 --- a/tests/test_hermes_state.py +++ b/tests/test_hermes_state.py @@ -3008,6 +3008,31 @@ class TestPruneSessions: assert session is not None assert session["id"] == "new" + def test_age_preview_and_prune_use_last_activity(self, db): + old_ts = time.time() - 100 * 86400 + for sid in ("inactive", "recently-active"): + db.create_session(session_id=sid, source="telegram") + db._conn.execute( + "UPDATE sessions SET started_at = ? WHERE id = ?", + (old_ts, sid), + ) + db.end_session("inactive", end_reason="agent_close") + db.append_message( + "recently-active", + role="user", + content="A recent message in a long-lived conversation.", + ) + db.end_session("recently-active", end_reason="agent_close") + db._conn.commit() + + candidates = db.list_prune_candidates(older_than_days=90) + + assert [row["id"] for row in candidates] == ["inactive"] + assert candidates[0]["last_active"] == pytest.approx(old_ts) + assert db.prune_sessions(older_than_days=90) == 1 + assert db.get_session("inactive") is None + assert db.get_session("recently-active") is not None + def test_prune_skips_active_sessions(self, db): db.create_session(session_id="active", source="cli") # Backdate but don't end @@ -5548,6 +5573,39 @@ class TestAutoMaintenance: # Active session's transcript is untouched assert (sessions_dir / "new.jsonl").exists() + def test_auto_prune_preserves_old_session_with_recent_activity(self, db, tmp_path): + """Retention is based on activity, not when a conversation began.""" + sessions_dir = tmp_path / "sessions" + sessions_dir.mkdir() + + db.create_session(session_id="long-lived", source="telegram") + db._conn.execute( + "UPDATE sessions SET started_at = ? WHERE id = ?", + (time.time() - 100 * 86400, "long-lived"), + ) + db._conn.commit() + db.append_message( + "long-lived", + role="user", + content="This conversation was active today.", + ) + db.end_session("long-lived", end_reason="agent_close") + transcript = sessions_dir / "long-lived.jsonl" + transcript.write_text('{"role":"user","content":"recent"}\n') + + result = db.maybe_auto_prune_and_vacuum( + retention_days=90, + vacuum=False, + sessions_dir=sessions_dir, + ) + + assert result["pruned"] == 0 + assert db.get_session("long-lived") is not None + assert [m["content"] for m in db.get_messages("long-lived")] == [ + "This conversation was active today." + ] + assert transcript.exists() + def test_auto_prune_without_sessions_dir_preserves_files(self, db, tmp_path): """Backward-compat: no sessions_dir = DB-only cleanup (legacy behavior).""" sessions_dir = tmp_path / "sessions" diff --git a/tests/test_install_macos_launcher.py b/tests/test_install_macos_launcher.py new file mode 100644 index 0000000000..fd46c347a7 --- /dev/null +++ b/tests/test_install_macos_launcher.py @@ -0,0 +1,89 @@ +"""Regression coverage for the user-facing macOS Hermes launcher.""" + +from __future__ import annotations + +import os +import re +import shutil +import stat +import subprocess +from pathlib import Path + + +REPO_ROOT = Path(__file__).resolve().parent.parent +INSTALL_SH = REPO_ROOT / "scripts" / "install.sh" + + +def _make_executable(path: Path, content: str) -> None: + path.write_text(content, encoding="utf-8") + path.chmod(path.stat().st_mode | stat.S_IXUSR) + + +def _setup_path_function() -> str: + match = re.search( + r"^setup_path\(\) \{\n.*?^}\n", + INSTALL_SH.read_text(encoding="utf-8"), + re.MULTILINE | re.DOTALL, + ) + assert match is not None, "setup_path function not found in scripts/install.sh" + return match.group(0) + + +def test_venv_launcher_bypasses_uv_console_script_that_requires_realpath(tmp_path: Path) -> None: + """Stock macOS must start Hermes even when its uv console script needs realpath.""" + install_dir = tmp_path / "install" + venv_bin = install_dir / "venv" / "bin" + command_dir = tmp_path / "command" + minimal_path = tmp_path / "minimal-path" + result = tmp_path / "launch-result" + venv_bin.mkdir(parents=True) + minimal_path.mkdir() + + dirname = shutil.which("dirname") + assert dirname is not None + (minimal_path / "dirname").symlink_to(dirname) + + _make_executable( + venv_bin / "python", + '#!/bin/sh\nprintf "%s\\n" "$@" > "$LAUNCH_RESULT"\n', + ) + (install_dir / "hermes").write_text("# source entrypoint\n", encoding="utf-8") + _make_executable( + venv_bin / "hermes", + "#!/bin/sh\n" + f'PATH="{minimal_path}"\n' + "'''exec' \"$(dirname -- \"$(realpath -- \"$0\")\")\"/'python3' \"$0\" \"$@\"\n" + "' '''\n", + ) + + harness = "\n".join( + [ + "set -e", + 'get_command_link_dir() { printf "%s" "$COMMAND_LINK_DIR"; }', + 'get_command_link_display_dir() { printf "%s" "$COMMAND_LINK_DIR"; }', + "log_info() { :; }", + "log_success() { :; }", + _setup_path_function(), + "setup_path", + ] + ) + env = os.environ | { + "USE_VENV": "true", + "INSTALL_DIR": str(install_dir), + "DISTRO": "macos", + "COMMAND_LINK_DIR": str(command_dir), + } + subprocess.run(["/bin/bash", "-c", harness], env=env, check=True) + + completed = subprocess.run( + [command_dir / "hermes", "--version"], + env=os.environ | {"LAUNCH_RESULT": str(result)}, + text=True, + capture_output=True, + ) + + assert completed.returncode == 0, completed.stderr + assert result.read_text(encoding="utf-8").splitlines() == [ + str(install_dir / "hermes"), + "--version", + ] diff --git a/tests/test_install_sh_bootstrap_marker.py b/tests/test_install_sh_bootstrap_marker.py new file mode 100644 index 0000000000..6eab5d6599 --- /dev/null +++ b/tests/test_install_sh_bootstrap_marker.py @@ -0,0 +1,109 @@ +"""install.sh must stamp the desktop bootstrap-complete marker. + +The marker at ``$INSTALL_DIR/.hermes-bootstrap-complete`` is what the desktop +app (apps/desktop/electron/main.ts) and the macOS launcher fast path +(apps/bootstrap-installer) use to decide "a real install finished here." +install.sh never wrote it, so a CLI-installed Mac/Linux box re-ran first-run +bootstrap on every desktop launch (#60721). + +These exercise the real shell function against a temp checkout rather than +asserting on the text of install.sh. +""" + +import json +import subprocess +from pathlib import Path + +import pytest + +REPO_ROOT = Path(__file__).resolve().parent.parent +INSTALL_SH = REPO_ROOT / "scripts" / "install.sh" + + +def run_write_marker(install_dir, *, commit="", branch="main"): + """Source install.sh and invoke write_bootstrap_marker in isolation. + + install.sh guards its own entrypoint behind MANIFEST_MODE/STAGE_NAME/main, + so sourcing it with --help-less argv defines the functions without running + an install. + """ + script = f""" +set -e +INSTALL_DIR={install_dir!s} +INSTALL_COMMIT={commit!r} +BRANCH={branch!r} +# Pull in the function definitions without triggering an install. +eval "$(sed -n '/^write_bootstrap_marker()/,/^}}/p' {INSTALL_SH!s})" +log_warn() {{ echo "WARN: $*" >&2; }} +write_bootstrap_marker +""" + return subprocess.run( + ["bash", "-c", script], capture_output=True, text=True, timeout=30 + ) + + +def make_checkout(tmp_path): + install_dir = tmp_path / "hermes-agent" + install_dir.mkdir() + subprocess.run(["git", "init", "-q"], cwd=install_dir, check=True) + subprocess.run( + ["git", "-c", "user.email=t@t", "-c", "user.name=t", "commit", "-q", + "--allow-empty", "-m", "init"], + cwd=install_dir, + check=True, + ) + return install_dir + + +def test_marker_matches_the_schema_the_desktop_validates(tmp_path): + """Desktop's isBootstrapComplete() needs schemaVersion 1 + a >=7 char commit.""" + install_dir = make_checkout(tmp_path) + + result = run_write_marker(install_dir) + assert result.returncode == 0, result.stderr + + marker = install_dir / ".hermes-bootstrap-complete" + assert marker.is_file(), "install.sh must stamp the bootstrap marker" + + payload = json.loads(marker.read_text()) + assert payload["schemaVersion"] == 1 + assert len(payload["pinnedCommit"]) >= 7 + assert payload["pinnedBranch"] == "main" + assert payload["completedAt"].endswith("Z") + + +def test_marker_publish_leaves_no_temp_sibling(tmp_path): + """The launcher predicate is existence-only, so the write must be atomic.""" + install_dir = make_checkout(tmp_path) + + run_write_marker(install_dir) + + assert (install_dir / ".hermes-bootstrap-complete").is_file() + assert not (install_dir / ".hermes-bootstrap-complete.tmp").exists() + + +def test_explicit_commit_pin_wins_over_head(tmp_path): + install_dir = make_checkout(tmp_path) + pinned = "abcdef1234567890abcdef1234567890abcdef12" + + run_write_marker(install_dir, commit=pinned) + + payload = json.loads((install_dir / ".hermes-bootstrap-complete").read_text()) + assert payload["pinnedCommit"] == pinned + + +def test_no_marker_written_when_head_cannot_be_resolved(tmp_path): + """A malformed marker is worse than none: absent means a clean re-bootstrap.""" + install_dir = tmp_path / "not-a-checkout" + install_dir.mkdir() + + result = run_write_marker(install_dir) + + assert result.returncode == 0, "an unresolvable HEAD must not fail the install" + assert not (install_dir / ".hermes-bootstrap-complete").exists() + + +def test_missing_install_dir_is_not_fatal(tmp_path): + result = run_write_marker(tmp_path / "does-not-exist") + + assert result.returncode == 0 diff --git a/tests/test_packaging_metadata.py b/tests/test_packaging_metadata.py index c4a7070650..3e128e78a5 100644 --- a/tests/test_packaging_metadata.py +++ b/tests/test_packaging_metadata.py @@ -64,6 +64,14 @@ def test_faster_whisper_is_not_a_base_dependency(): # [dev]) so we pin it directly in every extra that exposes a server surface and # enforce the floor in both pyproject and the committed lockfile. _STARLETTE_CVE_FLOOR = (1, 0, 1) +_UPDATE_DOWNGRADE_GUARD_FLOORS = { + # `hermes update` reinstalls exact pins from pyproject/lazy_deps. These + # reviewed CVE pins must not slide back to stale versions that downgrade + # already-patched user environments. + "cryptography": (48, 0, 1), + "starlette": (1, 3, 1), + "python-multipart": (0, 0, 32), +} def _version_tuple(spec: str) -> tuple[int, ...]: @@ -141,6 +149,40 @@ def test_locked_starlette_is_not_vulnerable_to_cve_2026_48710(): ) +def test_update_cve_pins_do_not_downgrade_reviewed_current_versions(): + """`hermes update` must not reinstall stale reviewed CVE pins. + + The project intentionally exact-pins reviewed dependency versions. When + security pins get stale, update reinstalls can downgrade environments that + already contain newer fixed versions. Guard the reviewed CVE packages + across pyproject, lazy_deps, and the committed lockfile. + """ + pins = _pins_from_specs(_pyproject_pinned_specs() + _lazy_deps_pinned_specs()) + for package, floor in _UPDATE_DOWNGRADE_GUARD_FLOORS.items(): + versions = pins.get(package) + assert versions, f"{package} is no longer exact-pinned; update this guard" + below_floor = sorted( + version for version in versions + if _version_tuple(version) < floor + ) + assert not below_floor, ( + f"{package} exact pin(s) {below_floor} are below the reviewed " + f"anti-downgrade floor {'.'.join(map(str, floor))}; bump the pin " + "and regenerate uv.lock" + ) + locked_versions = _locked_versions(package) + assert locked_versions, f"{package} is missing from uv.lock" + locked_below_floor = sorted( + version for version in locked_versions + if _version_tuple(version) < floor + ) + assert not locked_below_floor, ( + f"uv.lock resolves {package} version(s) {locked_below_floor} below " + f"the reviewed anti-downgrade floor {'.'.join(map(str, floor))}; " + "regenerate uv.lock after bumping the pin" + ) + + # --------------------------------------------------------------------------- # Dependency-pin consistency: pyproject extras <-> tools/lazy_deps.py # @@ -182,6 +224,15 @@ def _pins_from_specs(specs): return pins +def _locked_versions(package: str) -> set[str]: + lock = tomllib.loads((REPO_ROOT / "uv.lock").read_text(encoding="utf-8")) + return { + pkg["version"] + for pkg in lock.get("package", []) + if _canonical(pkg["name"]) == _canonical(package) + } + + def _pyproject_pinned_specs(): data = tomllib.loads((REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8")) specs = list(data["project"].get("dependencies", [])) diff --git a/tests/test_project_metadata.py b/tests/test_project_metadata.py index 1456c74217..4d685011cc 100644 --- a/tests/test_project_metadata.py +++ b/tests/test_project_metadata.py @@ -225,3 +225,124 @@ def test_shared_metrics_schema_is_packaged(): package_data = _load_package_data() assert "observability/schemas/*.json" in package_data["hermes_cli"] + + +def _uv_lock_version(package: str) -> str: + """Resolved version of ``package`` in uv.lock, or fail loudly.""" + versions = _uv_lock_versions(package) + assert versions, f"{package} not found in uv.lock" + assert len(versions) == 1, f"{package} resolves to multiple versions in uv.lock: {versions}" + return next(iter(versions)) + + +def _uv_lock_versions(package: str) -> set[str]: + """All resolved versions of ``package`` in uv.lock (normally 0 or 1).""" + import re + + lock_path = Path(__file__).resolve().parents[1] / "uv.lock" + lock = lock_path.read_text(encoding="utf-8") + return { + m.group(1) + for m in re.finditer( + rf'\[\[package\]\]\nname = "{re.escape(package)}"\nversion = "([^"]+)"', + lock, + ) + } + + +def test_every_lazy_deps_exact_pin_matches_uv_lock(): + """Class invariant for #60783/#60685: one version per package, everywhere. + + Any package that is BOTH exact-pinned in ``tools/lazy_deps.py`` AND + resolved in the committed uv.lock is a *shared* package: the core + install ships the locked version, and the ``hermes update`` lazy-refresh + pass re-asserts the LAZY_DEPS pin whenever the package is present + (``active_features()``). If the two disagree, every update churns the + package — and when the lazy pin is older, it force-DOWNGRADES a version + another consumer needs (huggingface-hub==1.2.3 vs transformers' + >=1.5.0 broke Hindsight local embeddings; stale aiohttp pins reopened + patched CVEs in #31817). Contract: for every such package, pin == + locked version. When bumping a pin, regenerate the lock in the same + commit (`uv lock --upgrade-package `), and vice versa. + """ + from tools.lazy_deps import LAZY_DEPS + + drift = {} + seen = set() + for feature, specs in LAZY_DEPS.items(): + for package, pin in _exact_pins(specs).items(): + if (package, pin) in seen: + continue + seen.add((package, pin)) + locked = _uv_lock_versions(package) + if not locked: + # Lazy-only package never resolved by the core lock — no + # shared-version hazard. + continue + if pin not in locked: + drift.setdefault(package, {})[feature] = { + "lazy_pin": pin, + "uv_lock": sorted(locked), + } + + assert not drift, ( + "LAZY_DEPS exact pins must match the uv.lock resolved version for " + "every package the core lock also ships — otherwise `hermes update` " + "churns/downgrades the shared package out from under its other " + "consumers (#60783, #31817). Bump the pin AND run " + "`uv lock --upgrade-package ` in the same commit. Drift: " + f"{drift}" + ) + + +def test_huggingface_hub_lazy_pin_matches_uv_lock(): + """The whole tree must converge on ONE huggingface-hub version (#60783). + + huggingface-hub is a shared dependency: the core lock resolves it (via + faster-whisper/tokenizers, and transformers/sentence-transformers when + local Hindsight embeddings are installed), and LAZY_DEPS + ['tool.trace_upload'] exact-pins it. Because active_features() activates + a feature from mere package presence, the `hermes update` lazy-refresh + pass re-asserts the LAZY_DEPS pin on every install where hub is present. + If that pin drifts from the lock's resolved version, every update churns + the shared package — and a pin below transformers' floor (>=1.5.0) + force-downgrades it and breaks the Hindsight local daemon on startup. + """ + from tools.lazy_deps import LAZY_DEPS + + lazy_pin = _exact_pins(LAZY_DEPS["tool.trace_upload"]).get("huggingface-hub") + assert lazy_pin, "tool.trace_upload must exact-pin huggingface-hub" + + locked = _uv_lock_version("huggingface-hub") + assert lazy_pin == locked, ( + "LAZY_DEPS['tool.trace_upload'] pins huggingface-hub==" + f"{lazy_pin} but uv.lock resolves {locked}. These must move in " + "lockstep (bump the pin AND run `uv lock --upgrade-package " + "huggingface-hub`), or `hermes update` will churn/downgrade the " + "shared package and break Hindsight local embeddings (#60783)." + ) + + +def test_huggingface_hub_lazy_pin_inside_transformers_window(): + """The hub pin must stay in transformers' accepted range (#60783). + + transformers (pulled by sentence-transformers for Hindsight + local/local_embedded embeddings) requires huggingface-hub>=1.5.0,<2. + An exact pin outside that window makes the lazy-refresh downgrade the + shared package below what the embedding stack imports, and the + Hindsight daemon fails on startup. Contract, not a snapshot: any + future exact pin is fine as long as it stays inside the window. + """ + from packaging.specifiers import SpecifierSet + from packaging.version import Version + + from tools.lazy_deps import LAZY_DEPS + + pin = _exact_pins(LAZY_DEPS["tool.trace_upload"]).get("huggingface-hub") + assert pin, "tool.trace_upload must exact-pin huggingface-hub" + transformers_window = SpecifierSet(">=1.5.0,<2") + assert Version(pin) in transformers_window, ( + f"huggingface-hub=={pin} falls outside transformers' accepted " + "range (>=1.5.0,<2). The lazy refresh would downgrade the shared " + "package and break Hindsight local embeddings (#60783)." + ) diff --git a/tests/test_tui_gateway_queue_on_busy.py b/tests/test_tui_gateway_queue_on_busy.py index ea13596ef6..1fffb7db3f 100644 --- a/tests/test_tui_gateway_queue_on_busy.py +++ b/tests/test_tui_gateway_queue_on_busy.py @@ -66,7 +66,9 @@ def test_busy_interrupt_mode_redirects_active_turn(monkeypatch): assert resp["result"]["status"] == "redirected" assert seen == ["redirect"] - assert session["inflight_turn"]["user"] == "redirect" + # Appended, not overwritten: the original prompt must stay recoverable. + assert session["inflight_turn"]["user"] == "original request" + assert session["inflight_turn"]["corrections"] == ["redirect"] assert session.get("queued_prompt") is None diff --git a/tests/test_tui_gateway_server.py b/tests/test_tui_gateway_server.py index 7b7d6b2a6d..6d3bae7b61 100644 --- a/tests/test_tui_gateway_server.py +++ b/tests/test_tui_gateway_server.py @@ -94,6 +94,7 @@ def test_session_context_uses_session_cwd(monkeypatch, tmp_path): session_key = "cwd-key" project = tmp_path / "project" project.mkdir() + (project / ".git").mkdir() launcher = tmp_path / "apps" / "desktop" launcher.mkdir(parents=True) @@ -566,6 +567,155 @@ def _write_profile_cfg(home: Path, cwd: str | None) -> Path: return home +def test_profile_scoped_mcp_discovery_uses_target_home(monkeypatch, tmp_path): + """MCP discovery must start under the selected profile's HERMES_HOME.""" + from hermes_cli import mcp_startup + from hermes_constants import get_hermes_home + from tui_gateway import entry + + profile_home = tmp_path / "profiles" / "sheepyr" + profile_home.mkdir(parents=True) + + (profile_home / "config.yaml").write_text( + "mcp_servers:\n" + " bluesky_sheepyr:\n" + " command: test-command\n", + encoding="utf-8", + ) + + monkeypatch.setenv("HERMES_HOME", str(tmp_path / "default")) + token = set_hermes_home_override(str(profile_home)) + + seen = [] + + monkeypatch.setattr(mcp_startup, "_mcp_discovery_started", False) + monkeypatch.setattr(mcp_startup, "_mcp_discovery_thread", None) + # ensure_mcp_discovery_started flips this module global; monkeypatch it so + # the enablement doesn't leak into sibling tests in this file. + monkeypatch.setattr(entry, "_mcp_discovery_enabled", False) + monkeypatch.setattr( + mcp_startup, + "_discover_mcp_tools_without_interactive_oauth", + lambda: seen.append(str(get_hermes_home())), + ) + + try: + entry.ensure_mcp_discovery_started() + thread = mcp_startup._mcp_discovery_thread + assert thread is not None + thread.join(timeout=2) + finally: + reset_hermes_home_override(token) + mcp_startup._mcp_discovery_thread = None + mcp_startup._mcp_discovery_started = False + + assert seen == [str(profile_home)] + + +def test_profile_scoped_agent_build_starts_mcp_discovery_in_profile_home( + monkeypatch, tmp_path +): + """Agent construction must start MCP discovery under the selected profile.""" + import threading + + from hermes_constants import get_hermes_home + + profile_home = tmp_path / "profiles" / "sheepyr" + profile_home.mkdir(parents=True) + + monkeypatch.setenv("HERMES_HOME", str(tmp_path / "default")) + + seen = [] + built = threading.Event() + + monkeypatch.setattr( + server, + "_make_agent", + lambda *args, **kwargs: built.set() + or type("Agent", (), {"model": "test"})(), + ) + monkeypatch.setattr( + "tui_gateway.entry.ensure_mcp_discovery_started", + lambda: seen.append(str(get_hermes_home())), + ) + monkeypatch.setattr(server, "_wire_callbacks", lambda _sid: None) + monkeypatch.setattr(server, "_SlashWorker", lambda *args: None) + monkeypatch.setattr(server, "_attach_worker", lambda *args: None) + monkeypatch.setattr(server, "_config_model_target", lambda: ("", "")) + + ready = threading.Event() + sid = "test-sid" + session = { + "agent_ready": ready, + "session_key": "test-key", + "profile_home": str(profile_home), + } + + server._sessions[sid] = session + try: + server._start_agent_build(sid, session) + assert built.wait(timeout=2) + finally: + server._sessions.pop(sid, None) + + assert seen == [str(profile_home)] + + +def test_profile_scoped_agent_build_installs_secret_scope(monkeypatch, tmp_path): + """Agent construction must install the selected profile's secret scope. + + Without it, get_secret() falls through to process os.environ, so a session + "switched" to profile X resolves credentials from the LAUNCH profile's + .env (#67605 item 2). + """ + import threading + + from agent.secret_scope import current_secret_scope + + profile_home = tmp_path / "profiles" / "grace" + profile_home.mkdir(parents=True) + (profile_home / ".env").write_text( + "PROXMOX_TOKEN=grace-secret\n", encoding="utf-8" + ) + + monkeypatch.setenv("HERMES_HOME", str(tmp_path / "default")) + + scopes = [] + built = threading.Event() + + def _fake_make_agent(*args, **kwargs): + scope = current_secret_scope() + scopes.append(dict(scope) if scope else None) + built.set() + return type("Agent", (), {"model": "test"})() + + monkeypatch.setattr(server, "_make_agent", _fake_make_agent) + monkeypatch.setattr( + "tui_gateway.entry.ensure_mcp_discovery_started", lambda: None + ) + monkeypatch.setattr(server, "_wire_callbacks", lambda _sid: None) + monkeypatch.setattr(server, "_SlashWorker", lambda *args: None) + monkeypatch.setattr(server, "_attach_worker", lambda *args: None) + monkeypatch.setattr(server, "_config_model_target", lambda: ("", "")) + + ready = threading.Event() + sid = "test-secret-sid" + session = { + "agent_ready": ready, + "session_key": "test-secret-key", + "profile_home": str(profile_home), + } + + server._sessions[sid] = session + try: + server._start_agent_build(sid, session) + assert built.wait(timeout=2) + finally: + server._sessions.pop(sid, None) + + assert scopes == [{"PROXMOX_TOKEN": "grace-secret"}] + + def test_profile_configured_cwd_reads_target_profile(tmp_path): """A profile's own terminal.cwd is read from its config.yaml.""" project = tmp_path / "proj" @@ -1456,12 +1606,24 @@ def test_history_to_messages_preserves_tool_calls_for_resume_display(): assert server._history_to_messages(history) == [ {"role": "user", "text": "first prompt"}, - {"context": "Searching files for resume", "name": "search_files", "role": "tool"}, + {"context": "resume", "name": "search_files", "role": "tool"}, {"role": "assistant", "text": "first answer"}, {"role": "user", "text": "second prompt"}, ] +def test_tool_ctx_sends_an_arg_preview_not_a_phrased_label(): + # Clients phrase their own verb around this string: the TUI renders + # `Terminal("")` and the desktop prepends "Running"/"Ran". Sending a + # pre-phrased label made both stutter ("Ran Running sleep 70 + 2 commands") + # and stood in for the real command in the desktop's `$` transcript. + assert server._tool_ctx("terminal", {"command": 'sleep 70; echo "a"; echo "b"'}) == ( + "sleep 70 + 2 commands" + ) + assert server._tool_ctx("read_file", {"path": "/tmp/demo/package.json"}) == "package.json" + assert server._tool_ctx("web_search", {"query": "weather in NYC"}) == "weather in NYC" + + def test_history_to_messages_keeps_reasoning_only_assistant_turn(): # A thinking-only assistant turn (reasoning present, no visible text) is # persisted and recallable, but was dropped from the resumed session view @@ -7369,11 +7531,56 @@ def test_session_redirect_calls_capable_core_agent(monkeypatch): "text": "use Postgres", } assert calls == ["use Postgres"] - assert session["inflight_turn"]["user"] == "use Postgres" + # The correction is recorded alongside the prompt that started the turn, + # never over it — resume must be able to rebuild both bubbles. + assert session["inflight_turn"]["user"] == "original request" + assert session["inflight_turn"]["corrections"] == ["use Postgres"] assert session.get("last_active") is not None assert before is None or session["last_active"] >= before +def test_session_redirect_records_correction_without_erasing_prompt(): + """A redirect must not overwrite the turn's original user text. + + The inflight snapshot is the only thing session.resume can replay, so + overwriting ``user`` erased the prompt that started the turn and the + client repainted the thread with the user's message missing. + """ + session = {} + server._start_inflight_turn(session, "remove the session counts") + server._append_inflight_delta(session, "Moving.") + server._record_inflight_correction(session, "hurry up") + server._record_inflight_correction(session, "and the worktree ones") + + snapshot = server._inflight_snapshot(session) + assert snapshot is not None + + assert snapshot["user"] == "remove the session counts" + assert snapshot["corrections"] == ["hurry up", "and the worktree ones"] + + +def test_inflight_snapshot_omits_corrections_when_none_recorded(): + session = {} + server._start_inflight_turn(session, "just the prompt") + + snapshot = server._inflight_snapshot(session) + assert snapshot is not None + assert "corrections" not in snapshot + + +def test_new_turn_does_not_inherit_prior_turn_corrections(): + session = {} + server._start_inflight_turn(session, "first prompt") + server._record_inflight_correction(session, "first correction") + server._start_inflight_turn(session, "second prompt") + + snapshot = server._inflight_snapshot(session) + assert snapshot is not None + + assert snapshot["user"] == "second prompt" + assert "corrections" not in snapshot + + def test_session_redirect_queues_during_agent_build_window(monkeypatch): # A fresh turn flips running=True and builds the agent asynchronously, so # session["agent"] is briefly None. A correction landing here must queue @@ -10700,12 +10907,14 @@ def test_session_most_recent_handles_db_unavailable(monkeypatch): # ── verification.status ────────────────────────────────────────────── -def test_verification_status_returns_recorded_evidence(tmp_path): - home = tmp_path / ".hermes" - home.mkdir() - token = set_hermes_home_override(home) +def test_verification_status_returns_recorded_evidence(tmp_path, monkeypatch): + profile_home = tmp_path / "profiles" / "verify" + profile_home.mkdir(parents=True) + monkeypatch.setattr(server, "_profile_home", lambda p: profile_home if p == "verify" else None) + token = set_hermes_home_override(profile_home) project = tmp_path / "project" project.mkdir() + (project / ".git").mkdir() (project / "package.json").write_text( json.dumps({"scripts": {"test": "vitest"}}), encoding="utf-8", @@ -10726,7 +10935,7 @@ def test_verification_status_returns_recorded_evidence(tmp_path): { "id": "1", "method": "verification.status", - "params": {"cwd": str(project), "session_id": "sid"}, + "params": {"cwd": str(project), "session_id": "sid", "profile": "verify"}, } ) finally: @@ -11656,22 +11865,22 @@ def test_make_agent_waits_for_shared_mcp_discovery(monkeypatch): def test_make_agent_nested_max_turns_takes_priority(monkeypatch): _setup_make_agent_mocks( - monkeypatch, {"agent": {"max_turns": 500}, "max_turns": 100} + monkeypatch, {"agent": {"max_turns": 400}, "max_turns": 100} ) with patch("run_agent.AIAgent") as mock_agent: server._make_agent("sid1", "key1") - assert mock_agent.call_args.kwargs["max_iterations"] == 500 + assert mock_agent.call_args.kwargs["max_iterations"] == 400 -def test_make_agent_defaults_to_90(monkeypatch): +def test_make_agent_defaults_to_500(monkeypatch): _setup_make_agent_mocks(monkeypatch, {}) with patch("run_agent.AIAgent") as mock_agent: server._make_agent("sid1", "key1") - assert mock_agent.call_args.kwargs["max_iterations"] == 90 + assert mock_agent.call_args.kwargs["max_iterations"] == 500 def test_make_agent_uses_session_runtime_overrides(monkeypatch): @@ -13705,6 +13914,30 @@ def test_clarify_callback_uses_configured_timeout(monkeypatch): assert captured["payload"] == {"question": "Pick one", "choices": ["a", "b"]} +def test_clarify_callback_multi_select_hint(monkeypatch): + """multi_select=True adds the hint to the payload; the single-select + payload shape stays byte-identical to the pre-multi-select protocol + (older renderers must never see the extra field).""" + captured = {} + + def fake_block(event, sid, payload, timeout=300): + captured.update(payload=payload) + return "answer" + + monkeypatch.setattr(server, "_block", fake_block) + cb = server._agent_cbs("sid-1")["clarify_callback"] + + cb("Pick many", ["a", "b"], multi_select=True) + assert captured["payload"] == { + "question": "Pick many", + "choices": ["a", "b"], + "multi_select": True, + } + + cb("Pick one", ["a", "b"], multi_select=False) + assert captured["payload"] == {"question": "Pick one", "choices": ["a", "b"]} + + @pytest.mark.parametrize( ("configured", "expected"), [(0, None), (-1, None), (42, 42)], diff --git a/tests/test_tui_gateway_ws.py b/tests/test_tui_gateway_ws.py index 3fba217776..ad41ba9dad 100644 --- a/tests/test_tui_gateway_ws.py +++ b/tests/test_tui_gateway_ws.py @@ -9,13 +9,14 @@ from tui_gateway import server from tui_gateway import ws as ws_mod -def test_ws_startup_starts_background_mcp_discovery(monkeypatch): - """The desktop app and dashboard chat reach the agent through this WS - sidecar, not through tui_gateway.entry.main() (which spawns the discovery - thread for the stdio TUI). handle_ws must start discovery itself, otherwise - _make_agent's wait_for_mcp_discovery no-ops and the agent snapshots an - MCP-less tool list. Regression test for #38945.""" +def test_ws_does_not_own_mcp_discovery_startup(monkeypatch): + """WebSocket transport must not start MCP discovery itself. + + MCP discovery ownership belongs to the profile-scoped agent build path. + The WS layer only establishes the transport and emits gateway readiness. + """ calls = [] + monkeypatch.setattr( mcp_startup, "start_background_mcp_discovery", @@ -41,7 +42,7 @@ def test_ws_startup_starts_background_mcp_discovery(monkeypatch): finally: server._sessions.clear() - assert calls == [{"logger": ws_mod._log, "thread_name": "tui-ws-mcp-discovery"}] + assert calls == [] def _run_disconnect(monkeypatch, seed): @@ -188,6 +189,37 @@ def test_ws_write_loop_stall_does_not_latch_transport(monkeypatch): loop.close() +def test_ws_starts_mcp_discovery_before_ready(monkeypatch): + import tui_gateway.entry as entry + + calls = [] + events = [] + + monkeypatch.setattr(server, "_WS_ORPHAN_REAP_GRACE_S", 0) + monkeypatch.setattr(entry, "ensure_mcp_discovery_started", lambda: calls.append("mcp")) + + class FakeWS: + async def accept(self): + events.append("accept") + + async def send_text(self, line): + if '"gateway.ready"' in line: + events.append(f"ready_after_{len(calls)}") + + async def receive_text(self): + raise ws_mod._WebSocketDisconnect() + + async def close(self): + pass + + asyncio.run(ws_mod.handle_ws(FakeWS())) + + # Discovery moved to profile-aware agent construction. WebSocket transport + # should not start MCP discovery before a profile has been bound. + assert calls == [] + assert events == ["accept", "ready_after_0"] + + def test_ws_transport_serializes_concurrent_sends(): active_sends = 0 max_active_sends = 0 diff --git a/tests/tools/test_async_delegation.py b/tests/tools/test_async_delegation.py index cc6082ec66..1d7d92b40e 100644 --- a/tests/tools/test_async_delegation.py +++ b/tests/tools/test_async_delegation.py @@ -229,6 +229,394 @@ def test_interrupt_all_signals_running_children(): assert evt["status"] == "interrupted" +def _fast_stale_monitor(monkeypatch, *, idle=0.15, in_tool=0.3, grace=0.15): + """Shrink the stale-monitor cadence so tests run in milliseconds.""" + monkeypatch.setattr(ad, "_STALE_CHECK_INTERVAL", 0.03) + monkeypatch.setattr(ad, "_STALE_IDLE_SECONDS", idle) + monkeypatch.setattr(ad, "_STALE_IN_TOOL_SECONDS", in_tool) + monkeypatch.setattr(ad, "_STALL_GRACE_SECONDS", grace) + + +def test_stalled_runner_is_interrupted_then_finalized(monkeypatch): + _fast_stale_monitor(monkeypatch) + gate = threading.Event() + interrupted = {"count": 0} + + def stuck_runner(): + gate.wait(timeout=10) + return {"status": "completed", "summary": "too late"} + + def interrupt_fn(): + interrupted["count"] += 1 + + res = ad.dispatch_async_delegation( + goal="stuck child", context=None, toolsets=None, role="leaf", + model="m", session_key="", runner=stuck_runner, + interrupt_fn=interrupt_fn, max_async_children=1, + # Frozen progress token: the child never advances an API call. + progress_fn=lambda: ((0, None), False), + ) + assert res["status"] == "dispatched" + + evt = _drain_for(res["delegation_id"], timeout=5.0) + try: + assert evt is not None + assert evt["type"] == "async_delegation" + assert evt["status"] == "stalled" + assert evt["delegation_id"] == res["delegation_id"] + assert evt["api_calls"] == 0 + assert "stalled" in evt["error"] + # Interrupt was requested BEFORE force-finalization (grace window). + assert interrupted["count"] >= 1 + assert ad.active_count() == 0 + finally: + gate.set() + + # If the ignored runner eventually returns, it must not enqueue a second + # completion for a delegation the monitor already finalized. + assert _drain_one(timeout=0.5) is None + + +def test_progressing_runner_is_never_stalled(monkeypatch): + """A child that keeps advancing is left alone no matter how long it runs.""" + _fast_stale_monitor(monkeypatch) + gate = threading.Event() + ticks = {"n": 0} + + def slow_but_alive_runner(): + gate.wait(timeout=10) + return {"status": "completed", "summary": "done", "api_calls": 7} + + def progress_fn(): + # Token advances on every sample — simulates a child making steady + # API-call progress. + ticks["n"] += 1 + return (ticks["n"], None), False + + res = ad.dispatch_async_delegation( + goal="slow child", context=None, toolsets=None, role="leaf", + model="m", session_key="", runner=slow_but_alive_runner, + max_async_children=1, progress_fn=progress_fn, + ) + assert res["status"] == "dispatched" + + # Run well past the (shrunk) idle threshold — several monitor sweeps. + time.sleep(0.6) + assert ad.active_count() == 1 + assert process_registry.completion_queue.empty() + + gate.set() + evt = _drain_for(res["delegation_id"], timeout=5.0) + assert evt is not None + assert evt["status"] == "completed" + assert evt["summary"] == "done" + + +def test_stalling_runner_that_honors_interrupt_keeps_its_result(monkeypatch): + """Interrupt-responsive children finalize through the NORMAL path. + + The monitor's interrupt gives a wedged-looking child a grace window; if + the runner returns during it, the real result (partial work, api_calls) + is delivered instead of a synthetic stalled event. + """ + _fast_stale_monitor(monkeypatch, grace=5.0) + interrupted = threading.Event() + + def runner(): + # "Wedged" until interrupted, then unwinds and reports partial work. + interrupted.wait(timeout=10) + return { + "status": "interrupted", + "summary": "partial work saved", + "api_calls": 3, + } + + res = ad.dispatch_async_delegation( + goal="responsive child", context=None, toolsets=None, role="leaf", + model="m", session_key="", runner=runner, + interrupt_fn=interrupted.set, max_async_children=1, + progress_fn=lambda: ((3, None), False), + ) + assert res["status"] == "dispatched" + + evt = _drain_for(res["delegation_id"], timeout=5.0) + assert evt is not None + assert evt["status"] == "interrupted" + assert evt["summary"] == "partial work saved" + assert evt["api_calls"] == 3 + assert ad.active_count() == 0 + + +def test_streaming_child_counts_as_alive(monkeypatch): + """A child mid-stream (api_call_count frozen, last_activity_ts ticking) + must never be stalled — streamed chunks tick _touch_activity, and the + progress token includes that timestamp (same liveness signal as the + compaction inactivity budget, PR #71508).""" + _fast_stale_monitor(monkeypatch) + gate = threading.Event() + now = {"ts": 1000.0} + + def progress_fn(): + # api_call_count and current_tool frozen (long streaming response in + # flight), but the activity timestamp advances with every chunk. + now["ts"] += 1.0 + return ((1, None, now["ts"]),), False + + res = ad.dispatch_async_delegation( + goal="streaming child", context=None, toolsets=None, role="leaf", + model="m", session_key="", max_async_children=1, + runner=lambda: (gate.wait(timeout=10), {"status": "completed", "summary": "streamed"})[1], + progress_fn=progress_fn, + ) + assert res["status"] == "dispatched" + + time.sleep(0.6) # several sweeps past the shrunk idle threshold + assert ad.active_count() == 1 + assert process_registry.completion_queue.empty() + + gate.set() + evt = _drain_for(res["delegation_id"], timeout=5.0) + assert evt is not None + assert evt["status"] == "completed" + + +def test_stalled_event_carries_structured_stall_metadata(monkeypatch): + """The terminal stalled event must expose machine-readable stall context + (#51690) — quiet duration, tripped threshold, phase, grace — mirroring + the sync path's timeout_seconds/timed_out_after_seconds/timeout_phase.""" + _fast_stale_monitor(monkeypatch) + gate = threading.Event() + + res = ad.dispatch_async_delegation( + goal="stall metadata", context=None, toolsets=None, role="leaf", + model="m", session_key="", max_async_children=1, + runner=lambda: {} if gate.wait(timeout=10) else {}, + progress_fn=lambda: ((0, "terminal"), True), + ) + assert res["status"] == "dispatched" + + evt = _drain_for(res["delegation_id"], timeout=5.0) + try: + assert evt is not None + assert evt["status"] == "stalled" + assert evt["stalled_after_quiet_seconds"] >= 0.3 # in-tool threshold + assert evt["stall_threshold_seconds"] == ad._STALE_IN_TOOL_SECONDS + assert evt["stall_phase"] == "in_tool" + assert evt["stall_grace_seconds"] == ad._STALL_GRACE_SECONDS + finally: + gate.set() + + +def test_list_async_delegations_exposes_live_activity(monkeypatch): + """list_async_delegations must expose per-child live activity sampled + from progress_fn plus seconds_since_progress, for /agents UIs (#51690).""" + monkeypatch.setattr(ad, "_STALE_CHECK_INTERVAL", 0.03) + gate = threading.Event() + base_ts = time.time() - 12.0 + + res = ad.dispatch_async_delegation( + goal="live listing", context=None, toolsets=None, role="leaf", + model="m", session_key="", max_async_children=1, + runner=lambda: {} if gate.wait(timeout=10) else {}, + progress_fn=lambda: (((3, "web_search", base_ts),), True), + ) + try: + time.sleep(0.1) # let the monitor stamp _progress_ts at least once + item = next( + d for d in ad.list_async_delegations() + if d["delegation_id"] == res["delegation_id"] + ) + assert item["status"] == "running" + assert item["in_tool"] is True + assert "seconds_since_progress" in item + (child,) = item["children_activity"] + assert child["api_calls"] == 3 + assert child["current_tool"] == "web_search" + assert 10.0 <= child["seconds_since_activity"] <= 20.0 + # Callables and private bookkeeping must never leak. + assert "progress_fn" not in item + assert "interrupt_fn" not in item + assert not any(k.startswith("_") for k in item) + finally: + gate.set() + + +def test_stalled_batch_is_interrupted_then_finalized(monkeypatch): + _fast_stale_monitor(monkeypatch) + gate = threading.Event() + interrupted = {"count": 0} + + def stuck_batch(): + gate.wait(timeout=10) + return {"results": [{"status": "completed", "summary": "too late"}]} + + def interrupt_fn(): + interrupted["count"] += 1 + + res = ad.dispatch_async_delegation_batch( + goals=["a", "b"], context="ctx", toolsets=None, role="leaf", + model="m", session_key="", runner=stuck_batch, + interrupt_fn=interrupt_fn, max_async_children=1, + progress_fn=lambda: (((0, None), (0, None)), False), + ) + assert res["status"] == "dispatched" + + evt = _drain_for(res["delegation_id"], timeout=5.0) + try: + assert evt is not None + assert evt["type"] == "async_delegation" + assert evt["status"] == "stalled" + assert evt["is_batch"] is True + assert evt["goals"] == ["a", "b"] + assert evt["results"] == [] + assert "stalled" in evt["error"] + assert interrupted["count"] >= 1 + assert ad.active_count() == 0 + finally: + gate.set() + + assert _drain_one(timeout=0.5) is None + + +def test_in_tool_stall_uses_higher_threshold(monkeypatch): + """A frozen child inside a tool gets the in-tool ceiling, not the idle one.""" + _fast_stale_monitor(monkeypatch, idle=0.1, in_tool=10.0, grace=0.1) + gate = threading.Event() + + def runner(): + gate.wait(timeout=10) + return {"status": "completed", "summary": "long tool finished"} + + res = ad.dispatch_async_delegation( + goal="long tool child", context=None, toolsets=None, role="leaf", + model="m", session_key="", runner=runner, max_async_children=1, + # Frozen token but in_tool=True — a legitimately slow terminal + # command / web fetch. Must NOT be stalled at the idle threshold. + progress_fn=lambda: ((1, "terminal"), True), + ) + assert res["status"] == "dispatched" + + time.sleep(0.5) # far past idle threshold, well under in-tool threshold + assert ad.active_count() == 1 + assert process_registry.completion_queue.empty() + + gate.set() + evt = _drain_for(res["delegation_id"], timeout=5.0) + assert evt is not None + assert evt["status"] == "completed" + + +def test_stall_stays_finalizing_until_durable_persistence(tmp_path, monkeypatch): + _fast_stale_monitor(monkeypatch) + gate = threading.Event() + persist_entered = threading.Event() + allow_persist = threading.Event() + real_persist = ad._persist_completion + + def blocking_persist(event, result): + persist_entered.set() + allow_persist.wait(timeout=5) + real_persist(event, result) + + def stuck_runner(): + gate.wait(timeout=10) + return {"status": "completed", "summary": "too late"} + + monkeypatch.setenv("HERMES_HOME", str(tmp_path)) + monkeypatch.setattr(ad, "_persist_completion", blocking_persist) + dispatched = ad.dispatch_async_delegation( + goal="durable stall", context=None, toolsets=None, role="leaf", + model="m", session_key="owner", runner=stuck_runner, + max_async_children=1, progress_fn=lambda: ((0, None), False), + ) + + try: + assert persist_entered.wait(timeout=5) + assert ad.active_count() == 1 + record = next( + item for item in ad.list_async_delegations() + if item["delegation_id"] == dispatched["delegation_id"] + ) + assert record["status"] == "finalizing" + assert process_registry.completion_queue.empty() + + allow_persist.set() + evt = _drain_for(dispatched["delegation_id"]) + assert evt is not None + assert evt["status"] == "stalled" + assert ad.active_count() == 0 + durable = ad.get_durable_delegation(dispatched["delegation_id"]) + assert durable["state"] == "stalled" + assert durable["delivery_state"] == "pending" + finally: + allow_persist.set() + gate.set() + + +def test_stalled_completion_restores_once_after_process_restart(tmp_path): + repo = os.path.dirname(os.path.dirname(os.path.dirname(__file__))) + env = {**os.environ, "HERMES_HOME": str(tmp_path), "PYTHONPATH": repo} + producer = r''' +import json +import threading +import time +from tools import async_delegation as ad +ad._STALE_CHECK_INTERVAL = 0.03 +ad._STALE_IDLE_SECONDS = 0.1 +ad._STALL_GRACE_SECONDS = 0.1 +gate = threading.Event() +r = ad.dispatch_async_delegation( + goal="restart stall", context=None, toolsets=None, role="leaf", model="m", + session_key="owner-session", parent_session_id="durable-parent", + runner=lambda: gate.wait(timeout=60), + progress_fn=lambda: ((0, None), False), +) +deadline = time.time() + 10 +while ad.active_count() and time.time() < deadline: + time.sleep(.01) +row = ad.get_durable_delegation(r["delegation_id"]) +print(json.dumps({"delegation_id": r["delegation_id"], "row": row}, sort_keys=True)) +''' + first = subprocess.run( + [sys.executable, "-c", producer], cwd=repo, env=env, + text=True, capture_output=True, timeout=30, check=True, + ) + produced = json.loads(first.stdout.strip().splitlines()[-1]) + delegation_id = produced["delegation_id"] + assert produced["row"]["state"] == "stalled" + assert produced["row"]["delivery_state"] == "pending" + + consumer = r''' +import json +from tools.process_registry import process_registry +evt = process_registry.completion_queue.get_nowait() +print(json.dumps({"event": evt, "remaining": process_registry.completion_queue.qsize()}, sort_keys=True)) +''' + second = subprocess.run( + [sys.executable, "-c", consumer], cwd=repo, env=env, + text=True, capture_output=True, timeout=15, check=True, + ) + restored = json.loads(second.stdout.strip().splitlines()[-1]) + assert restored["remaining"] == 0 + assert restored["event"]["delegation_id"] == delegation_id + assert restored["event"]["status"] == "stalled" + assert restored["event"]["restored"] is True + + acker = f''' +from tools import async_delegation as ad +assert ad.mark_completion_delivered({delegation_id!r}) +''' + subprocess.run( + [sys.executable, "-c", acker], cwd=repo, env=env, + text=True, capture_output=True, timeout=15, check=True, + ) + probe = subprocess.run( + [sys.executable, "-c", "from tools.process_registry import process_registry; print(process_registry.completion_queue.qsize())"], + cwd=repo, env=env, text=True, capture_output=True, timeout=15, check=True, + ) + assert probe.stdout.strip().splitlines()[-1] == "0" + + def test_completed_records_pruned_to_cap(): # Run more than the retention cap quickly; ensure list doesn't grow forever. for i in range(ad._MAX_RETAINED_COMPLETED + 10): @@ -767,6 +1155,57 @@ def test_delegate_task_background_batch_runs_as_one_unit(monkeypatch): assert _drain_one() is None +def test_delegate_task_background_passes_progress_fn_to_async_registry(monkeypatch): + import json + from unittest.mock import MagicMock + import tools.delegate_tool as dt + + parent = MagicMock() + parent._delegate_depth = 0 + parent.session_id = "sess" + parent._interrupt_requested = False + parent._active_children = [] + parent._active_children_lock = None + + fake_child = MagicMock() + fake_child._delegate_role = "leaf" + fake_child._subagent_id = "s1" + fake_child.get_activity_summary.return_value = { + "api_call_count": 4, + "current_tool": "terminal", + "last_activity_ts": 1234.5, + } + + creds = { + "model": "m", "provider": None, "base_url": None, "api_key": None, + "api_mode": None, "command": None, "args": None, + } + captured = {} + + def fake_dispatch(**kwargs): + captured.update(kwargs) + return {"status": "dispatched", "delegation_id": "deleg_progress"} + + monkeypatch.setattr(dt, "_build_child_agent", lambda **kw: fake_child) + monkeypatch.setattr(dt, "_resolve_delegation_credentials", lambda *a, **k: creds) + monkeypatch.setattr(ad, "dispatch_async_delegation_batch", fake_dispatch) + + out = dt.delegate_task(goal="background stall guard", background=True, parent_agent=parent) + + parsed = json.loads(out) + assert parsed["status"] == "dispatched" + assert parsed["delegation_id"] == "deleg_progress" + # The dispatch wires a live progress sampler over the child agents so the + # async registry's stale monitor can watch the detached batch. The token + # includes last_activity_ts so streamed chunks count as liveness (each + # chunk ticks _touch_activity), not just completed API calls. + progress_fn = captured["progress_fn"] + assert callable(progress_fn) + token, in_tool = progress_fn() + assert token == ((4, "terminal", 1234.5),) + assert in_tool is True + + def test_model_dispatch_forces_background(): """The MODEL-facing dispatch path forces background=True for any top-level delegation (single task OR batch), and keeps it off for an orchestrator diff --git a/tests/tools/test_checkpoint_manager.py b/tests/tools/test_checkpoint_manager.py index b72c9b954d..93099dc6c7 100644 --- a/tests/tools/test_checkpoint_manager.py +++ b/tests/tools/test_checkpoint_manager.py @@ -1416,3 +1416,53 @@ class TestOrphanPruneRequiresObservableDeletion: after = json.loads(meta_path.read_text()) assert after["workdir_parent_dev"] == before["workdir_parent_dev"] assert after["workdir_parent_ino"] == before["workdir_parent_ino"] + + +# ========================================================================= +# session_diff — cumulative "what changed" view that powers /diff session +# ========================================================================= + +class TestSessionDiff: + def test_no_checkpoints_is_empty_success(self, mgr, work_dir): + """With nothing edited yet, session_diff succeeds and reports empty.""" + result = mgr.session_diff(str(work_dir)) + assert result["success"] is True + assert result.get("empty") is True + assert result["diff"] == "" + + def test_cumulative_diff_spans_all_edits(self, mgr, work_dir): + """The diff covers the first edit through the latest working tree.""" + # First checkpoint captures the pre-edit state (main.py == hello). + mgr.ensure_checkpoint(str(work_dir), "before edit 1") + (work_dir / "main.py").write_text("print('v2')\n") + mgr.new_turn() + mgr.ensure_checkpoint(str(work_dir), "before edit 2") + (work_dir / "main.py").write_text("print('v3')\n") + + result = mgr.session_diff(str(work_dir)) + assert result["success"] is True + assert not result.get("empty") + # Baseline is the earliest retained checkpoint. + assert result["baseline"] == mgr.list_checkpoints(str(work_dir))[-1]["hash"] + # Cumulative: the original line is removed, the final line added; the + # intermediate "v2" is neither in the baseline nor the working tree. + assert "-print('hello')" in result["diff"] + assert "+print('v3')" in result["diff"] + assert "v2" not in result["diff"] + + def test_includes_newly_added_files(self, mgr, work_dir): + mgr.ensure_checkpoint(str(work_dir), "baseline") + (work_dir / "feature.py").write_text("x = 1\n") + + result = mgr.session_diff(str(work_dir)) + assert result["success"] is True + assert "feature.py" in result["diff"] + assert "+x = 1" in result["diff"] + + def test_no_changes_since_baseline_reports_empty(self, mgr, work_dir): + """A checkpoint with no subsequent edits yields an empty diff.""" + mgr.ensure_checkpoint(str(work_dir), "baseline") + result = mgr.session_diff(str(work_dir)) + assert result["success"] is True + assert result.get("empty") is True + assert result["diff"] == "" diff --git a/tests/tools/test_clarify_gateway.py b/tests/tools/test_clarify_gateway.py index fab1ebedcc..c8f2a432e0 100644 --- a/tests/tools/test_clarify_gateway.py +++ b/tests/tools/test_clarify_gateway.py @@ -439,3 +439,120 @@ class TestUnlimitedWait: t.join(timeout=5.0) assert not t.is_alive() assert result_box["r"] == "B" + + +class TestMultiSelectTextFallback: + """Multi-select clarifies via the gateway text fallback. + + The adapter's numbered-list fallback asks the user to reply with + comma/space-separated numbers; _coerce_text_response must map those to a + JSON array of choice labels (which _parse_multi_select_response on the + tool side decodes into a list). + """ + + def setup_method(self): + _clear_clarify_state() + + def _register_multi(self, cid="m1", choices=("A", "B", "C")): + from tools import clarify_gateway as cm + entry = cm.register(cid, "sk", "Pick some", list(choices), multi_select=True) + # Text fallback path always flips awaiting_text on. + cm.mark_awaiting_text(cid) + return entry + + def test_register_stores_multi_select_flag(self): + entry = self._register_multi() + assert entry.multi_select is True + assert entry.signature()["multi_select"] is True + + def test_register_default_multi_select_false(self): + from tools import clarify_gateway as cm + entry = cm.register("s1", "sk", "Q?", ["A"]) + assert entry.multi_select is False + assert entry.signature()["multi_select"] is False + + def test_multi_select_without_choices_is_ignored(self): + """multi_select on an open-ended clarify is meaningless — dropped.""" + from tools import clarify_gateway as cm + entry = cm.register("s2", "sk", "Q?", None, multi_select=True) + assert entry.multi_select is False + + def test_comma_separated_numbers(self): + import json + from tools import clarify_gateway as cm + entry = self._register_multi() + coerced = cm._coerce_text_response(entry, "1, 3") + assert json.loads(coerced) == ["A", "C"] + + def test_space_separated_numbers(self): + import json + from tools import clarify_gateway as cm + entry = self._register_multi() + coerced = cm._coerce_text_response(entry, "1 3") + assert json.loads(coerced) == ["A", "C"] + + def test_single_number(self): + import json + from tools import clarify_gateway as cm + entry = self._register_multi() + coerced = cm._coerce_text_response(entry, "2") + assert json.loads(coerced) == ["B"] + + def test_choice_labels_comma_separated(self): + import json + from tools import clarify_gateway as cm + entry = self._register_multi() + coerced = cm._coerce_text_response(entry, "a, C") + assert json.loads(coerced) == ["A", "C"] + + def test_out_of_range_number_rejected_but_custom_text_kept(self): + """Out-of-range numbers don't parse as a selection; awaiting_text + mode falls back to accepting the raw text as a custom answer.""" + from tools import clarify_gateway as cm + entry = self._register_multi() + assert cm._coerce_multi_select_text(entry, "1, 9") is None + # awaiting_text (text fallback) keeps the raw reply as custom text + assert cm._coerce_text_response(entry, "1, 9") == "1, 9" + + def test_out_of_range_rejected_for_native_button_ui(self): + """Without awaiting_text (button UI), a bad selection rejects the + reply entirely so it flows through as a normal message.""" + from tools import clarify_gateway as cm + entry = cm.register("m2", "sk", "Pick some", ["A", "B"], multi_select=True) + assert cm._coerce_text_response(entry, "5") is None + assert cm._coerce_text_response(entry, "random prose") is None + + def test_duplicate_selections_deduped(self): + import json + from tools import clarify_gateway as cm + entry = self._register_multi() + coerced = cm._coerce_text_response(entry, "1, 1, 2") + assert json.loads(coerced) == ["A", "B"] + + def test_resolve_text_response_end_to_end(self): + """resolve_text_response_for_session delivers the JSON array to the waiter.""" + import json + from tools import clarify_gateway as cm + self._register_multi(cid="m3") + result_box = {} + + def waiter(): + result_box["r"] = cm.wait_for_response("m3", timeout=5) + + t = threading.Thread(target=waiter) + t.start() + time.sleep(0.05) + assert cm.resolve_text_response_for_session("sk", "1,2") is True + t.join(timeout=5) + assert json.loads(result_box["r"]) == ["A", "B"] + + def test_single_select_regression_numeric(self): + """Single-select coercion unchanged: '2' maps to the choice label string.""" + from tools import clarify_gateway as cm + entry = cm.register("s3", "sk", "Q?", ["A", "B", "C"]) + assert cm._coerce_text_response(entry, "2") == "B" + + def test_single_select_regression_label(self): + from tools import clarify_gateway as cm + entry = cm.register("s4", "sk", "Q?", ["A", "B"]) + assert cm._coerce_text_response(entry, "b") == "B" diff --git a/tests/tools/test_clarify_tool.py b/tests/tools/test_clarify_tool.py index 0c38961dd8..aaf1d87845 100644 --- a/tests/tools/test_clarify_tool.py +++ b/tests/tools/test_clarify_tool.py @@ -257,3 +257,267 @@ class TestClarifySchema: def test_max_choices_is_four(self): """MAX_CHOICES constant should be 4.""" assert MAX_CHOICES == 4 + + def test_schema_multi_select_optional(self): + """multi_select should not be in required list.""" + assert "multi_select" not in CLARIFY_SCHEMA["parameters"]["required"] + + def test_schema_multi_select_is_boolean(self): + """multi_select should be a boolean parameter.""" + ms_spec = CLARIFY_SCHEMA["parameters"]["properties"].get("multi_select") + assert ms_spec is not None + assert ms_spec["type"] == "boolean" + + def test_schema_multi_select_default_false(self): + """multi_select should default to false (not in required).""" + # The model should treat it as false when omitted + assert "multi_select" not in CLARIFY_SCHEMA["parameters"]["required"] + + +class TestClarifyToolMultiSelect: + """Tests for multi_select (checkbox) support added to clarify_tool.""" + + def test_multi_select_false_keeps_existing_behavior(self): + """When multi_select=False, user_response should be a single string.""" + def mock_callback(question, choices): + return "blue" + + result = json.loads(clarify_tool( + "What color?", + choices=["red", "blue", "green"], + multi_select=False, + callback=mock_callback, + )) + assert result["user_response"] == "blue" + assert isinstance(result["user_response"], str) + + def test_multi_select_true_returns_list(self): + """When multi_select=True, user_response should be a list of strings.""" + def mock_callback(question, choices): + return "red, blue" + + result = json.loads(clarify_tool( + "Which colors?", + choices=["red", "blue", "green"], + multi_select=True, + callback=mock_callback, + )) + assert result["user_response"] == ["red", "blue"] + assert isinstance(result["user_response"], list) + + def test_multi_select_single_choice_still_list(self): + """Even a single selection should be a list when multi_select=True.""" + def mock_callback(question, choices): + return "red" + + result = json.loads(clarify_tool( + "Which color?", + choices=["red", "blue"], + multi_select=True, + callback=mock_callback, + )) + assert result["user_response"] == ["red"] + assert isinstance(result["user_response"], list) + + def test_multi_select_with_json_array_response(self): + """Callback can return a JSON array string for multi-select.""" + def mock_callback(question, choices): + return '["red", "blue"]' + + result = json.loads(clarify_tool( + "Which colors?", + choices=["red", "blue", "green"], + multi_select=True, + callback=mock_callback, + )) + assert result["user_response"] == ["red", "blue"] + + def test_multi_select_no_choices_falls_back_to_single_string(self): + """When choices is None, multi_select has no effect on response type.""" + def mock_callback(question, choices): + return "free form answer" + + result = json.loads(clarify_tool( + "What do you think?", + multi_select=True, + callback=mock_callback, + )) + # Without choices, falls back to single string response + assert result["user_response"] == "free form answer" + assert isinstance(result["user_response"], str) + + def test_multi_select_default_is_false(self): + """Default multi_select should be False (backward compatible).""" + def mock_callback(question, choices): + return "picked" + + result = json.loads(clarify_tool( + "Pick one", + choices=["a", "b"], + callback=mock_callback, + )) + assert result["user_response"] == "picked" + assert isinstance(result["user_response"], str) + + def test_multi_select_callback_receives_flag(self): + """Callback should receive multi_select keyword argument when supported.""" + received_flag = [] + + def mock_callback(question, choices, **kwargs): + received_flag.append(kwargs.get("multi_select")) + return "a, b" + + clarify_tool( + "Pick", + choices=["a", "b", "c"], + multi_select=True, + callback=mock_callback, + ) + assert received_flag == [True] + + def test_multi_select_backward_compatible_callback(self): + """Callback that does not accept multi_select keyword should still work.""" + def mock_callback(question, choices): + return "a, b" + + result = json.loads(clarify_tool( + "Pick", + choices=["a", "b", "c"], + multi_select=True, + callback=mock_callback, + )) + assert result["user_response"] == ["a", "b"] + + def test_multi_select_empty_selection_returns_empty_list(self): + """Empty response should produce empty list when multi_select=True.""" + def mock_callback(question, choices): + return "" + + result = json.loads(clarify_tool( + "Which?", + choices=["a", "b"], + multi_select=True, + callback=mock_callback, + )) + assert result["user_response"] == [] + + def test_multi_select_whitespace_choices_stripped(self): + """Individual selections should be stripped of whitespace.""" + def mock_callback(question, choices): + return " a , b , c " + + result = json.loads(clarify_tool( + "Which?", + choices=["a", "b", "c"], + multi_select=True, + callback=mock_callback, + )) + assert result["user_response"] == ["a", "b", "c"] + + def test_multi_select_choices_offered_preserved(self): + """choices_offered should match what was passed in, not the response.""" + def mock_callback(question, choices): + return "red, blue" + + result = json.loads(clarify_tool( + "Which?", + choices=["red", "blue", "green"], + multi_select=True, + callback=mock_callback, + )) + assert result["choices_offered"] == ["red", "blue", "green"] + + def test_multi_select_max_choices_enforced(self): + """MAX_CHOICES enforcement should still work with multi_select.""" + choices_passed = [] + + def mock_callback(question, choices): + choices_passed.extend(choices or []) + return "a, b, c, d" + + many_choices = ["a", "b", "c", "d", "e", "f"] + clarify_tool( + "Pick some", + choices=many_choices, + multi_select=True, + callback=mock_callback, + ) + assert len(choices_passed) == MAX_CHOICES + + +class TestInvokeCallbackDispatch: + """_invoke_callback uses signature inspection, never a TypeError retry.""" + + def test_internal_typeerror_not_swallowed_or_retried(self): + """A compatible callback that raises TypeError internally must be + invoked exactly once and its error surfaced — not retried with the + legacy 2-arg form (which would prompt the user twice).""" + from tools.clarify_tool import _invoke_callback + calls = [] + + def bad_callback(question, choices, multi_select=False): + calls.append(1) + raise TypeError("internal bug") + + import pytest + with pytest.raises(TypeError, match="internal bug"): + _invoke_callback(bad_callback, "Q?", ["a"], True) + assert len(calls) == 1 + + def test_legacy_two_arg_callback_supported(self): + from tools.clarify_tool import _invoke_callback + seen = {} + + def legacy(question, choices): + seen["args"] = (question, choices) + return "ok" + + assert _invoke_callback(legacy, "Q?", ["a"], True) == "ok" + assert seen["args"] == ("Q?", ["a"]) + + def test_var_keyword_callback_receives_flag(self): + from tools.clarify_tool import _invoke_callback + seen = {} + + def kw_cb(question, choices, **kwargs): + seen.update(kwargs) + return "ok" + + _invoke_callback(kw_cb, "Q?", ["a"], True) + assert seen.get("multi_select") is True + + +class TestRegistryMultiSelectPassThrough: + """The registered tool handler must forward multi_select from tool args.""" + + def test_handler_passes_multi_select(self): + from tools.registry import registry + entry = registry.get_entry("clarify") + seen = {} + + def cb(question, choices, multi_select=False): + seen["multi"] = multi_select + return "a, b" + + result = json.loads(entry.handler( + {"question": "Pick", "choices": ["a", "b"], "multi_select": True}, + callback=cb, + )) + assert seen["multi"] is True + assert result["user_response"] == ["a", "b"] + + def test_handler_default_single_select(self): + from tools.registry import registry + entry = registry.get_entry("clarify") + seen = {} + + def cb(question, choices, multi_select=False): + seen["multi"] = multi_select + return "a" + + result = json.loads(entry.handler( + {"question": "Pick", "choices": ["a", "b"]}, + callback=cb, + )) + assert seen["multi"] is False + assert result["user_response"] == "a" diff --git a/tests/tools/test_computer_use.py b/tests/tools/test_computer_use.py index d25bfde38c..d0ac4d54b9 100644 --- a/tests/tools/test_computer_use.py +++ b/tests/tools/test_computer_use.py @@ -1305,7 +1305,7 @@ class TestLazyMcpInstall: from tools import lazy_deps assert lazy_deps.feature_specs("tool.computer_use") == ( "mcp==1.26.0", - "starlette==1.0.1", + "starlette==1.3.1", ) def test_start_lazy_installs_mcp(self): diff --git a/tests/tools/test_delegate_subagent_timeout_diagnostic.py b/tests/tools/test_delegate_subagent_timeout_diagnostic.py index daaaf4301f..d290d60194 100644 --- a/tests/tools/test_delegate_subagent_timeout_diagnostic.py +++ b/tests/tools/test_delegate_subagent_timeout_diagnostic.py @@ -282,3 +282,47 @@ class TestRunSingleChildTimeoutDump: if logs_dir.is_dir(): dumps = list(logs_dir.glob("subagent-timeout-*.log")) assert dumps == [] + + # ── explicit timeout metadata (#51690, salvaged from PR #60378) ──── + + def test_timeout_result_carries_structured_metadata(self, hermes_home, monkeypatch): + """Parents must be able to distinguish a child_timeout_seconds kill + from other failures without parsing the error string.""" + child = _StubChild(api_call_count=0, hang_seconds=10.0) + result = self._invoke_with_short_timeout(child, monkeypatch) + + assert result["status"] == "timeout" + assert result["timeout_seconds"] == 0.3 + assert result["timed_out_after_seconds"] == result["duration_seconds"] + assert result["timeout_phase"] == "before_first_llm_call" + + def test_timeout_phase_after_llm_calls(self, hermes_home, monkeypatch): + child = _StubChild(api_call_count=5, hang_seconds=10.0) + result = self._invoke_with_short_timeout(child, monkeypatch) + + assert result["timeout_phase"] == "after_llm_calls" + assert result["timeout_seconds"] == 0.3 + + def test_non_timeout_error_has_null_timeout_metadata(self, hermes_home, monkeypatch): + """The metadata fields are timeout-specific — a child that raises + must report them as None so consumers can key on presence.""" + from tools import delegate_tool + monkeypatch.setattr(delegate_tool, "_get_child_timeout", lambda: 30.0) + + child = _StubChild(api_call_count=1, hang_seconds=0.0) + + def _boom(*a, **kw): + raise RuntimeError("child crashed") + + child.run_conversation = _boom + parent = MagicMock() + parent._touch_activity = MagicMock() + parent._current_task_id = None + result = delegate_tool._run_single_child( + task_index=0, goal="test goal", child=child, parent_agent=parent, + ) + + assert result["status"] == "error" + assert result["timeout_seconds"] is None + assert result["timed_out_after_seconds"] is None + assert result["timeout_phase"] is None diff --git a/tests/tools/test_denial_circuit_breaker.py b/tests/tools/test_denial_circuit_breaker.py new file mode 100644 index 0000000000..919df114ca --- /dev/null +++ b/tests/tools/test_denial_circuit_breaker.py @@ -0,0 +1,276 @@ +"""Tests for the consecutive-denial circuit breaker in smart approvals. + +After ``approvals.denial_breaker_threshold`` consecutive guardian DENY +verdicts in one session, the deny message returned to the model escalates +from "Do NOT retry" to a hard-stop CIRCUIT BREAKER instruction. Any +approval resets the tally. State is per-session and capped in size. + +Follows the existing smart-approval mocking patterns from +tests/tools/test_execute_code_approval_cluster.py: monkeypatch +``_smart_approve`` / ``_get_approval_mode`` on the module and drive the +public guard entry points. +""" + +from __future__ import annotations + +import pytest + +from tools import approval as A + +BREAKER_MARKER = "CIRCUIT BREAKER:" + + +@pytest.fixture +def breaker_session(monkeypatch): + """A clean gateway smart-mode session with the guardian forced to DENY. + + Uses the gateway path with a notify callback that resolves 'deny' + (user denies the smart-DENY override) so the guard returns a definitive + BLOCKED message — the channel the breaker text rides on. + """ + monkeypatch.setenv("HERMES_GATEWAY_SESSION", "1") + monkeypatch.delenv("HERMES_INTERACTIVE", raising=False) + monkeypatch.delenv("HERMES_CRON_SESSION", raising=False) + monkeypatch.delenv("HERMES_EXEC_ASK", raising=False) + monkeypatch.setattr(A, "_get_approval_mode", lambda: "smart") + monkeypatch.setattr(A, "_YOLO_MODE_FROZEN", False) + monkeypatch.setattr(A, "_smart_approve", lambda _c, _d: "deny") + monkeypatch.setattr(A, "_get_denial_breaker_threshold", lambda: 3) + monkeypatch.setattr( + A, "detect_dangerous_command", + lambda command: (True, "breaker-test-danger", f"risk:{command}"), + ) + monkeypatch.setattr( + "tools.tirith_security.check_command_security", + lambda _command: {"action": "allow", "findings": [], "summary": ""}, + raising=False, + ) + + session_key = "breaker-test-session" + token = A.set_current_session_key(session_key) + A._reset_denials(session_key) + with A._lock: + A._permanent_approved.discard("breaker-test-danger") + A._permanent_approved.discard("execute_code") + A._session_approved.get(session_key, set()).discard("breaker-test-danger") + A._session_approved.get(session_key, set()).discard("execute_code") + A._gateway_queues.pop(session_key, None) + A._gateway_notify_cbs.pop(session_key, None) + try: + yield session_key + finally: + A.reset_current_session_key(token) + A._reset_denials(session_key) + with A._lock: + A._gateway_queues.pop(session_key, None) + A._gateway_notify_cbs.pop(session_key, None) + + +def _register_resolver(session_key: str, result): + """Notify callback resolving the newest queued approval with *result*.""" + def cb(_approval_data): + with A._lock: + entries = A._gateway_queues.get(session_key, []) + if entries: + entries[-1].result = result + entries[-1].event.set() + with A._lock: + A._gateway_notify_cbs[session_key] = cb + + +def _denied_terminal(command="dangerous thing"): + return A.check_all_command_guards(command, "local") + + +def _denied_execute_code(code="print('x')"): + return A.check_execute_code_guard(code, "local") + + +# --------------------------------------------------------------------------- +# (a) Two denials -> normal message; third -> breaker text present +# --------------------------------------------------------------------------- + +def test_breaker_trips_on_third_consecutive_denial(breaker_session): + _register_resolver(breaker_session, "deny") + + first = _denied_terminal("dangerous one") + second = _denied_terminal("dangerous two") + third = _denied_terminal("dangerous three") + + assert first["approved"] is False + assert BREAKER_MARKER not in first["message"] + assert second["approved"] is False + assert BREAKER_MARKER not in second["message"] + assert third["approved"] is False + assert BREAKER_MARKER in third["message"] + assert "3 consecutive commands were blocked" in third["message"] + assert "STOP attempting variations" in third["message"] + + +# --------------------------------------------------------------------------- +# (b) An approval resets the tally +# --------------------------------------------------------------------------- + +def test_approval_resets_tally(breaker_session, monkeypatch): + _register_resolver(breaker_session, "deny") + _denied_terminal("dangerous one") + _denied_terminal("dangerous two") + + # Guardian approves the next command → tally resets. + monkeypatch.setattr(A, "_smart_approve", lambda _c, _d: "approve") + ok = _denied_terminal("benign command") + assert ok["approved"] is True and ok.get("smart_approved") is True + + # Back to denials: the count restarts, so the next deny is #1, not #3. + monkeypatch.setattr(A, "_smart_approve", lambda _c, _d: "deny") + after = _denied_terminal("dangerous again") + assert after["approved"] is False + assert BREAKER_MARKER not in after["message"] + + +def test_human_approval_resets_tally(breaker_session): + _register_resolver(breaker_session, "deny") + _denied_terminal("dangerous one") + _denied_terminal("dangerous two") + + # User overrides the smart DENY (one-operation approval) → tally resets. + _register_resolver(breaker_session, "once") + ok = _denied_terminal("dangerous but user says yes") + assert ok["approved"] is True and ok.get("user_approved") is True + + _register_resolver(breaker_session, "deny") + after = _denied_terminal("dangerous again") + assert after["approved"] is False + assert BREAKER_MARKER not in after["message"] + + +# --------------------------------------------------------------------------- +# (c) Threshold 0 disables the breaker +# --------------------------------------------------------------------------- + +def test_threshold_zero_disables_breaker(breaker_session, monkeypatch): + monkeypatch.setattr(A, "_get_denial_breaker_threshold", lambda: 0) + _register_resolver(breaker_session, "deny") + for i in range(5): + res = _denied_terminal(f"dangerous {i}") + assert res["approved"] is False + assert BREAKER_MARKER not in res["message"] + + +# --------------------------------------------------------------------------- +# (d) Tally is per-session — two session keys are independent +# --------------------------------------------------------------------------- + +def test_tally_is_per_session(breaker_session): + other = "breaker-other-session" + A._reset_denials(other) + try: + assert A._record_denial(breaker_session) == 1 + assert A._record_denial(breaker_session) == 2 + # A different session starts from zero. + assert A._record_denial(other) == 1 + # And its denial did not advance the first session's count. + assert A._record_denial(breaker_session) == 3 + # Resetting one session leaves the other intact. + A._reset_denials(breaker_session) + assert A._record_denial(other) == 2 + assert A._record_denial(breaker_session) == 1 + finally: + A._reset_denials(other) + + +# --------------------------------------------------------------------------- +# (e) BOTH call paths increment: terminal guard and execute_code guard +# --------------------------------------------------------------------------- + +@pytest.mark.parametrize("deny_call", [_denied_terminal, _denied_execute_code], + ids=["terminal", "execute_code"]) +def test_both_paths_increment_and_trip(breaker_session, deny_call): + _register_resolver(breaker_session, "deny") + for _ in range(2): + res = deny_call() + assert res["approved"] is False + assert BREAKER_MARKER not in res["message"] + tripped = deny_call() + assert tripped["approved"] is False + assert BREAKER_MARKER in tripped["message"] + + +def test_paths_share_one_session_tally(breaker_session): + """Denials from the terminal and execute_code paths accumulate together.""" + _register_resolver(breaker_session, "deny") + assert BREAKER_MARKER not in _denied_terminal("dangerous one")["message"] + assert BREAKER_MARKER not in _denied_execute_code()["message"] + tripped = _denied_terminal("dangerous three") + assert BREAKER_MARKER in tripped["message"] + + +# --------------------------------------------------------------------------- +# Headless hard-deny path (no cli/gateway/ask override) also increments +# --------------------------------------------------------------------------- + +def test_headless_smart_deny_increments_and_trips(monkeypatch): + monkeypatch.delenv("HERMES_GATEWAY_SESSION", raising=False) + monkeypatch.delenv("HERMES_INTERACTIVE", raising=False) + monkeypatch.delenv("HERMES_CRON_SESSION", raising=False) + monkeypatch.setenv("HERMES_EXEC_ASK", "0") + monkeypatch.setattr(A, "_get_approval_mode", lambda: "smart") + monkeypatch.setattr(A, "_YOLO_MODE_FROZEN", False) + monkeypatch.setattr(A, "_smart_approve", lambda _c, _d: "deny") + monkeypatch.setattr(A, "_get_denial_breaker_threshold", lambda: 3) + monkeypatch.setattr(A, "_is_interactive_cli", lambda: True) + monkeypatch.setattr( + A, "detect_dangerous_command", + lambda command: (True, "headless-breaker-danger", f"risk:{command}"), + ) + monkeypatch.setattr( + "tools.tirith_security.check_command_security", + lambda _command: {"action": "allow", "findings": [], "summary": ""}, + raising=False, + ) + # CLI-interactive path: the owner denies via the prompt callback. + monkeypatch.setattr(A, "prompt_dangerous_approval", + lambda *args, **kwargs: "deny") + + session_key = "headless-breaker-session" + token = A.set_current_session_key(session_key) + A._reset_denials(session_key) + with A._lock: + A._permanent_approved.discard("headless-breaker-danger") + A._session_approved.get(session_key, set()).discard( + "headless-breaker-danger") + try: + first = A.check_all_command_guards("dangerous h1", "local") + second = A.check_all_command_guards("dangerous h2", "local") + third = A.check_all_command_guards("dangerous h3", "local") + assert BREAKER_MARKER not in first["message"] + assert BREAKER_MARKER not in second["message"] + assert BREAKER_MARKER in third["message"] + finally: + A.reset_current_session_key(token) + A._reset_denials(session_key) + + +# --------------------------------------------------------------------------- +# Eviction cap: the tally dict never grows past _DENIAL_TALLY_MAX_SESSIONS +# --------------------------------------------------------------------------- + +def test_tally_evicts_oldest_sessions(): + with A._lock: + saved = dict(A._denial_tally) + A._denial_tally.clear() + try: + for i in range(A._DENIAL_TALLY_MAX_SESSIONS + 10): + A._record_denial(f"evict-session-{i}") + with A._lock: + assert len(A._denial_tally) == A._DENIAL_TALLY_MAX_SESSIONS + # Oldest entries were evicted, newest survive. + assert "evict-session-0" not in A._denial_tally + assert ( + f"evict-session-{A._DENIAL_TALLY_MAX_SESSIONS + 9}" + in A._denial_tally + ) + finally: + with A._lock: + A._denial_tally.clear() + A._denial_tally.update(saved) diff --git a/tests/tools/test_kanban_tools.py b/tests/tools/test_kanban_tools.py index 38ba049eee..5751d082a7 100644 --- a/tests/tools/test_kanban_tools.py +++ b/tests/tools/test_kanban_tools.py @@ -2415,6 +2415,8 @@ def _sub_index(subs): "chat_id": getattr(s, "chat_id", None), "thread_id": getattr(s, "thread_id", None), "user_id": getattr(s, "user_id", None), + "delivery_metadata": getattr(s, "delivery_metadata", None), + "notifier_profile": getattr(s, "notifier_profile", None), }) return out @@ -2426,8 +2428,10 @@ def test_create_subscribes_gateway_session(monkeypatch, worker_env): from tools import kanban_tools as kt monkeypatch.setenv("HERMES_SESSION_PLATFORM", "telegram") monkeypatch.setenv("HERMES_SESSION_CHAT_ID", "chat-42") - monkeypatch.setenv("HERMES_SESSION_THREAD_ID", "thread-7") + monkeypatch.setenv("HERMES_SESSION_CHAT_TYPE", "dm") + monkeypatch.setenv("HERMES_SESSION_THREAD_ID", "20197") monkeypatch.setenv("HERMES_SESSION_USER_ID", "user-9") + monkeypatch.setenv("HERMES_SESSION_MESSAGE_ID", "msg-11") out = kt._handle_create({ "title": "auto-sub gateway", @@ -2443,8 +2447,39 @@ def test_create_subscribes_gateway_session(monkeypatch, worker_env): s = subs[0] assert s["platform"] == "telegram" assert s["chat_id"] == "chat-42" - assert s["thread_id"] == "thread-7" + assert s["thread_id"] == "20197" assert s["user_id"] == "user-9" + assert s["delivery_metadata"] == { + "chat_type": "dm", + "direct_messages_topic_id": "20197", + "telegram_dm_topic_reply_fallback": True, + "telegram_reply_to_message_id": "msg-11", + "thread_id": "20197", + } + + +def test_create_subscribes_gateway_session_with_active_profile_when_env_missing(monkeypatch, worker_env): + """Gateway auto-subscribe rows must be owned by the active profile even + when session/env profile markers are missing. Otherwise every Telegram + gateway with the same chat_id can deliver another bot's Kanban event.""" + from tools import kanban_tools as kt + monkeypatch.setenv("HERMES_SESSION_PLATFORM", "telegram") + monkeypatch.setenv("HERMES_SESSION_CHAT_ID", "chat-42") + monkeypatch.delenv("HERMES_SESSION_PROFILE", raising=False) + monkeypatch.delenv("HERMES_PROFILE", raising=False) + monkeypatch.setattr("hermes_cli.profiles.get_active_profile_name", lambda: "spanorama") + + out = kt._handle_create({ + "title": "auto-sub active profile", + "assignee": "peer", + }) + d = json.loads(out) + assert d["ok"] is True + assert d["subscribed"] is True, d + + subs = _sub_index(_list_subs_for_task(d["task_id"])) + assert len(subs) == 1 + assert subs[0]["notifier_profile"] == "spanorama" def test_create_subscribes_tui_session_via_session_key(monkeypatch, worker_env): diff --git a/tests/tools/test_lazy_deps.py b/tests/tools/test_lazy_deps.py index 2b319ae049..0063e76806 100644 --- a/tests/tools/test_lazy_deps.py +++ b/tests/tools/test_lazy_deps.py @@ -293,6 +293,22 @@ class TestIsSatisfiedVersionAware: self._fake_version(monkeypatch, {"mautrix": "0.20.0"}) assert ld._is_satisfied("mautrix[encryption]==0.21.0") is False + def test_trace_upload_hub_at_core_locked_version_is_current(self, monkeypatch): + """#60783 regression: refresh must not churn the shared hub install. + + huggingface-hub arrives in the venv via the core lock (transformers / + sentence-transformers for local Hindsight, faster-whisper, tokenizers). + With the LAZY_DEPS pin held in lockstep with uv.lock, the version the + core installs satisfies the trace-upload spec, so the `hermes update` + lazy-refresh pass reports "current" instead of reinstalling — the + downgrade that used to break the Hindsight daemon can't happen. + """ + spec = ld.LAZY_DEPS["tool.trace_upload"][0] + pinned = ld._specifier_from_spec(spec).lstrip("=") + self._fake_version(monkeypatch, {"huggingface-hub": pinned}) + assert ld._is_satisfied(spec) is True + assert ld.feature_missing("tool.trace_upload") == () + # --------------------------------------------------------------------------- # active_features + refresh_active_features (Piece A — hermes update wiring) @@ -304,7 +320,7 @@ class TestActiveFeatures: monkeypatch.setattr(ld, "_is_present", lambda spec: False) assert ld.active_features() == [] - def test_finds_features_with_at_least_one_package_installed(self, monkeypatch): + def test_finds_features_with_anchor_package_installed(self, monkeypatch): # Pretend only honcho-ai is installed; nothing else. monkeypatch.setattr( ld, "_is_present", @@ -316,16 +332,24 @@ class TestActiveFeatures: assert "memory.hindsight" not in active assert "platform.slack" not in active - def test_multi_package_feature_active_if_any_present(self, monkeypatch): - # platform.slack has 3 packages; only one needs to be present - # for the feature to count as active (user activated it before, - # one transitive may have been uninstalled separately). + def test_multi_package_feature_active_if_anchor_present(self, monkeypatch): + # platform.slack has multiple packages; the first spec is its anchor. monkeypatch.setattr( ld, "_is_present", lambda spec: ld._pkg_name_from_spec(spec) == "slack-bolt", ) assert "platform.slack" in ld.active_features() + def test_shared_dependency_does_not_activate_feature(self, monkeypatch): + # asyncpg is a generic dependency that may be installed for unrelated + # reasons. It must not make hermes update try to refresh Matrix unless + # the Matrix anchor package (mautrix) is present. + monkeypatch.setattr( + ld, "_is_present", + lambda spec: ld._pkg_name_from_spec(spec) == "asyncpg", + ) + assert "platform.matrix" not in ld.active_features() + class TestRefreshActiveFeatures: def test_no_active_features_returns_empty(self, monkeypatch): diff --git a/tests/tools/test_session_search.py b/tests/tools/test_session_search.py index bd538ebd4c..39bc1cf96b 100644 --- a/tests/tools/test_session_search.py +++ b/tests/tools/test_session_search.py @@ -381,18 +381,98 @@ class TestScrollShape: assert result["success"] is False def test_scroll_rejects_current_session_lineage(self, db): - _seed_modpack_sessions(db) - # Grab some valid id from s_oldest - disc = json.loads(session_search(query="modpack", limit=3, db=db)) - match = [r for r in disc["results"] if r["session_id"] == "s_oldest"] - if match: - mid = match[0]["match_message_id"] - result = json.loads(session_search( - session_id="s_oldest", around_message_id=mid, db=db, - current_session_id="s_oldest", - )) - assert result["success"] is False - assert "current session" in result.get("error", "").lower() + db.create_session("s_current", source="cli") + mid = db.append_message("s_current", role="user", content="still live") + + result = json.loads(session_search( + session_id="s_current", around_message_id=mid, db=db, + current_session_id="s_current", + )) + + assert result["success"] is False + assert "current session" in result.get("error", "").lower() + + def test_scroll_allows_compacted_anchor_in_current_session(self, db): + db.create_session("s_current", source="cli") + db.append_message( + "s_current", role="user", content="history removed from live context" + ) + db.archive_and_compact("s_current", [ + {"role": "assistant", "content": "Compacted history summary"}, + ]) + + discovery = json.loads(session_search( + query="history removed", db=db, current_session_id="s_current", + )) + assert discovery["count"] == 1 + anchor = discovery["results"][0] + + result = json.loads(session_search( + session_id=anchor["session_id"], + around_message_id=anchor["match_message_id"], + db=db, + current_session_id="s_current", + )) + + assert result["success"] is True + assert any( + message["id"] == anchor["match_message_id"] + for message in result["messages"] + ) + + def test_scroll_allows_compression_ended_parent_from_continuation(self, db): + db.create_session("s_parent", source="cli") + mid = db.append_message( + "s_parent", role="user", content="history summarized into child" + ) + db.end_session("s_parent", "compression") + db.create_session("s_current", source="cli", parent_session_id="s_parent") + + result = json.loads(session_search( + session_id="s_parent", around_message_id=mid, db=db, + current_session_id="s_current", + )) + + assert result["success"] is True + assert any(message["id"] == mid for message in result["messages"]) + + def test_scroll_rejects_active_delegation_child_in_current_lineage(self, db): + db.create_session("s_current", source="cli") + db.create_session( + "s_delegate", source="delegate", parent_session_id="s_current" + ) + mid = db.append_message( + "s_delegate", role="assistant", content="live delegated result" + ) + + result = json.loads(session_search( + session_id="s_delegate", around_message_id=mid, db=db, + current_session_id="s_current", + )) + + assert result["success"] is False + assert "current session" in result.get("error", "").lower() + + def test_scroll_rejects_rewound_anchor_in_compression_parent(self, db): + db.create_session("s_parent", source="cli") + mid = db.append_message( + "s_parent", role="user", content="message removed by rewind" + ) + db._conn.execute( + "UPDATE messages SET active = 0, compacted = 0 WHERE id = ?", + (mid,), + ) + db._conn.commit() + db.end_session("s_parent", "compression") + db.create_session("s_current", source="cli", parent_session_id="s_parent") + + result = json.loads(session_search( + session_id="s_parent", around_message_id=mid, db=db, + current_session_id="s_current", + )) + + assert result["success"] is False + assert "current session" in result.get("error", "").lower() def test_scroll_invalid_around_message_id_errors(self, db): _seed_modpack_sessions(db) diff --git a/tests/tools/test_smart_approval_policy.py b/tests/tools/test_smart_approval_policy.py new file mode 100644 index 0000000000..cffee87783 --- /dev/null +++ b/tests/tools/test_smart_approval_policy.py @@ -0,0 +1,139 @@ +"""Tests for the operator-customizable smart-approval policy. + +``approvals.smart_policy`` (config.yaml) lets operators append their own +rules to the smart-approval guardian's system prompt. Security invariants +under test: + + 1. Empty/missing policy leaves the prompts exactly as they were. + 2. A non-empty policy appears in the SYSTEM message sent to call_llm + (the trusted channel), under a clearly delimited section. + 3. The policy text NEVER appears in the user message — the user message + carries the untrusted command text, and mixing trusted operator rules + into that channel would dilute the guard's trust boundary. + +Inspired by ChatGPT Work's customizable auto-review guardian policy. +""" + +import unittest +from unittest.mock import MagicMock, patch + +from tools.approval import _get_smart_policy, _smart_approve + +POLICY_TEXT = "Always ESCALATE commands that modify anything under /etc." + + +def _make_response(answer: str): + """Build a mock LLM response with the given one-word answer.""" + mock_response = MagicMock() + mock_response.choices = [MagicMock()] + mock_response.choices[0].message.content = answer + return mock_response + + +def _messages_from(mock_call_llm): + """Extract the messages list passed to call_llm.""" + call_args = mock_call_llm.call_args + return call_args.kwargs.get("messages") or call_args[1].get("messages", []) + + +class TestGetSmartPolicy(unittest.TestCase): + """Unit tests for the config reader.""" + + @patch("tools.approval._get_approval_config") + def test_missing_key_returns_empty(self, mock_cfg): + mock_cfg.return_value = {"mode": "smart"} + assert _get_smart_policy() == "" + + @patch("tools.approval._get_approval_config") + def test_non_string_value_returns_empty(self, mock_cfg): + mock_cfg.return_value = {"smart_policy": ["not", "a", "string"]} + assert _get_smart_policy() == "" + + @patch("tools.approval._get_approval_config") + def test_whitespace_only_returns_empty(self, mock_cfg): + mock_cfg.return_value = {"smart_policy": " \n "} + assert _get_smart_policy() == "" + + @patch("tools.approval._get_approval_config") + def test_policy_text_is_stripped(self, mock_cfg): + mock_cfg.return_value = {"smart_policy": f" {POLICY_TEXT}\n"} + assert _get_smart_policy() == POLICY_TEXT + + +class TestSmartApprovePolicyInjection(unittest.TestCase): + """Verify how the operator policy is (and is not) wired into the prompts. + + Follows the mocking pattern of test_smart_approval_injection.py: + ``call_llm`` is patched at its source module (``agent.auxiliary_client``) + because _smart_approve imports it lazily inside the function. The + config read is isolated by patching ``tools.approval._get_approval_config`` + so tests never touch a real config.yaml. + """ + + @patch("tools.approval._get_approval_config") + @patch("agent.auxiliary_client.call_llm") + def test_empty_policy_leaves_prompts_unchanged(self, mock_call_llm, mock_cfg): + """With no policy configured, prompts must be byte-identical to the + prompts produced when the key is present but empty.""" + mock_call_llm.return_value = _make_response("ESCALATE") + + mock_cfg.return_value = {} # key missing entirely + _smart_approve("rm -rf /tmp/x", "recursive delete") + messages_missing = _messages_from(mock_call_llm) + + mock_cfg.return_value = {"smart_policy": ""} # key present, empty + _smart_approve("rm -rf /tmp/x", "recursive delete") + messages_empty = _messages_from(mock_call_llm) + + assert messages_missing == messages_empty + sys_content = messages_missing[0]["content"] + assert "Additional policy rules from the operator" not in sys_content + + @patch("tools.approval._get_approval_config") + @patch("agent.auxiliary_client.call_llm") + def test_policy_appears_in_system_message(self, mock_call_llm, mock_cfg): + """A non-empty policy must land in the system message, delimited.""" + mock_call_llm.return_value = _make_response("ESCALATE") + mock_cfg.return_value = {"smart_policy": POLICY_TEXT} + + _smart_approve("rm -rf /etc/nginx", "recursive delete") + + messages = _messages_from(mock_call_llm) + assert messages[0]["role"] == "system" + sys_content = messages[0]["content"] + assert POLICY_TEXT in sys_content + assert "Additional policy rules from the operator" in sys_content + # Baseline hardening must survive the append + assert "UNTRUSTED" in sys_content + + @patch("tools.approval._get_approval_config") + @patch("agent.auxiliary_client.call_llm") + def test_policy_never_in_user_message(self, mock_call_llm, mock_cfg): + """The policy is trusted; the user message carries untrusted command + text. They must never share a channel.""" + mock_call_llm.return_value = _make_response("ESCALATE") + mock_cfg.return_value = {"smart_policy": POLICY_TEXT} + + _smart_approve("rm -rf /etc/nginx", "recursive delete") + + messages = _messages_from(mock_call_llm) + assert messages[1]["role"] == "user" + user_content = messages[1]["content"] + assert POLICY_TEXT not in user_content + assert "Additional policy rules from the operator" not in user_content + # The command itself must still be there, XML-fenced + assert "rm -rf /etc/nginx" in user_content + assert "" in user_content + + @patch("tools.approval._get_approval_config") + @patch("agent.auxiliary_client.call_llm") + def test_config_read_failure_does_not_break_approval(self, mock_call_llm, mock_cfg): + """If the config reader itself blows up, _smart_approve fails safe.""" + mock_call_llm.return_value = _make_response("APPROVE") + mock_cfg.side_effect = RuntimeError("config unreadable") + # _smart_approve's outer try/except catches this and escalates + assert _smart_approve("echo hi", "flagged") == "escalate" + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/tools/test_snapshot_multiline_session_env_injection.py b/tests/tools/test_snapshot_multiline_session_env_injection.py new file mode 100644 index 0000000000..ced25ec169 --- /dev/null +++ b/tests/tools/test_snapshot_multiline_session_env_injection.py @@ -0,0 +1,99 @@ +"""Newline in bridged session env must not become shell code via the snapshot. + +Regression for issue #71296: bash 3.2 ``export -p`` prints a value containing +a newline as a multi-line ``declare -x NAME="…`` block. The old line-based +``grep -vE`` filter removed only the opener; continuation lines (e.g. +``curl … | bash #`` smuggled into a Matrix room/display name) persisted into +the shared terminal snapshot and executed on the next ``source``, with stdout +discarded by the wrapper. +""" + +from __future__ import annotations + +import os +import shlex +import subprocess +import sys +from pathlib import Path + +import pytest + +from tools.environments.base import _export_dump_excluding_session_vars + + +def _bash() -> str: + return "/bin/bash" if os.path.exists("/bin/bash") else "bash" + + +def _run_dump_and_source( + *, + tmp_path: Path, + env_name: str, + env_value: str, + marker: Path, +) -> subprocess.CompletedProcess: + snap = tmp_path / "snap" + dump = _export_dump_excluding_session_vars(shlex.quote(str(snap))) + q_snap = shlex.quote(str(snap)) + q_marker = shlex.quote(str(marker)) + script = f""" +set -e +export {env_name} +{dump} +if grep -qE 'pwned|touch |{env_name}' {q_snap}; then + echo "LEAKED_INTO_SNAPSHOT" >&2 + exit 2 +fi +bash -c 'source {q_snap} >/dev/null 2>&1 || true' +if [ -e {q_marker} ]; then + echo "PAYLOAD_EXECUTED" >&2 + exit 3 +fi +if ! grep -qE '^declare -x PATH=' {q_snap}; then + echo "PATH_MISSING" >&2 + exit 4 +fi +""" + env = os.environ.copy() + env[env_name] = env_value + return subprocess.run( + [_bash(), "-c", script], + cwd=str(tmp_path), + capture_output=True, + text=True, + env=env, + ) + + +@pytest.mark.skipif(sys.platform == "win32", reason="POSIX bash snapshot path") +def test_multiline_session_chat_name_not_executed_via_snapshot(tmp_path: Path): + """Continuation lines of HERMES_SESSION_CHAT_NAME must not run on source.""" + marker = tmp_path / "pwned" + chat_name = f"demo\ntouch {marker} #" + proc = _run_dump_and_source( + tmp_path=tmp_path, + env_name="HERMES_SESSION_CHAT_NAME", + env_value=chat_name, + marker=marker, + ) + assert proc.returncode == 0, ( + f"rc={proc.returncode}\nstdout={proc.stdout!r}\nstderr={proc.stderr!r}" + ) + assert not marker.exists() + + +@pytest.mark.skipif(sys.platform == "win32", reason="POSIX bash snapshot path") +def test_multiline_session_user_name_not_executed_via_snapshot(tmp_path: Path): + """Same hole via HERMES_SESSION_USER_NAME (display-name path).""" + marker = tmp_path / "pwned_user" + user_name = f"alice\ntouch {marker} #" + proc = _run_dump_and_source( + tmp_path=tmp_path, + env_name="HERMES_SESSION_USER_NAME", + env_value=user_name, + marker=marker, + ) + assert proc.returncode == 0, ( + f"rc={proc.returncode}\nstdout={proc.stdout!r}\nstderr={proc.stderr!r}" + ) + assert not marker.exists() diff --git a/tests/tools/test_snapshot_session_id_leak.py b/tests/tools/test_snapshot_session_id_leak.py index c48555988a..523235d30b 100644 --- a/tests/tools/test_snapshot_session_id_leak.py +++ b/tests/tools/test_snapshot_session_id_leak.py @@ -56,13 +56,19 @@ def test_regex_preserves_user_env(): def test_export_snippet_shape(): snippet = _export_dump_excluding_session_vars("/tmp/snap.tmp.$BASHPID") assert "export -p" in snippet - assert "grep -vE" in snippet + # Unset-by-name (not line-grep): multi-line declare values must not leave + # continuation lines in the snapshot (issue #71296). + assert "unset" in snippet + assert "${!HERMES_SESSION_*}" in snippet + assert "${!HERMES_CRON_AUTO_DELIVER_*}" in snippet + assert "HERMES_UI_SESSION_ID" in snippet + assert "grep -vE" not in snippet assert "/tmp/snap.tmp.$BASHPID" in snippet - # The redirection must be attached to a brace group wrapping the pipeline, - # NOT to the grep segment: a redirect on grep expands $BASHPID inside - # grep's pipeline subshell (a different PID than the parent shell that - # expands the follow-up ``mv`` operand), silently orphaning the dump and - # breaking snapshot env persistence entirely. + # The redirection must be attached to a brace group wrapping the dump, + # NOT to a pipeline segment: a redirect on a pipeline segment expands + # $BASHPID inside that segment's subshell (a different PID than the parent + # that expands the follow-up ``mv`` operand), silently orphaning the dump + # and breaking snapshot env persistence entirely. assert snippet.lstrip().startswith("{ ") assert "|| true; }" in snippet assert snippet.rstrip().endswith("> /tmp/snap.tmp.$BASHPID") diff --git a/tests/tools/test_working_diff.py b/tests/tools/test_working_diff.py new file mode 100644 index 0000000000..d1b0759aa4 --- /dev/null +++ b/tests/tools/test_working_diff.py @@ -0,0 +1,111 @@ +"""Tests for tools.working_diff.collect_working_diff — the git collection +layer shared by the CLI and gateway ``/diff`` command. + +Runs against real temporary git repositories (no mocks) so the staged / +unstaged / untracked semantics are proven against actual git behaviour. +""" + +import shutil +import subprocess + +import pytest + +from tools.working_diff import collect_working_diff + +pytestmark = pytest.mark.skipif( + shutil.which("git") is None, reason="git required for working-diff tests" +) + + +def _git(repo, *args): + subprocess.run( + ["git", *args], cwd=repo, check=True, capture_output=True, + env={"HOME": str(repo), "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", + "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t", + "PATH": __import__("os").environ["PATH"]}, + ) + + +@pytest.fixture() +def repo(tmp_path): + d = tmp_path / "repo" + d.mkdir() + _git(d, "init", "-q") + (d / "tracked.py").write_text("print('hello')\n") + _git(d, "add", "-A") + _git(d, "commit", "-q", "-m", "init") + return d + + +def test_clean_repo_reports_empty(repo): + result = collect_working_diff(str(repo)) + assert result["success"] is True + assert result.get("empty") is True + assert result["diff"] == "" + + +def test_unstaged_change_appears_in_default_mode(repo): + (repo / "tracked.py").write_text("print('changed')\n") + result = collect_working_diff(str(repo)) + assert result["success"] is True + assert "-print('hello')" in result["diff"] + assert "+print('changed')" in result["diff"] + assert "tracked.py" in result["stat"] + + +def test_untracked_file_appears_as_addition(repo): + (repo / "brand_new.py").write_text("x = 1\n") + result = collect_working_diff(str(repo)) + assert result["success"] is True + assert "brand_new.py" in result["untracked"] + assert "+x = 1" in result["diff"] + assert not result.get("empty") + + +def test_staged_mode_shows_only_staged(repo): + (repo / "tracked.py").write_text("print('staged')\n") + _git(repo, "add", "tracked.py") + (repo / "unstaged.py").write_text("y = 2\n") # untracked, must not appear + + result = collect_working_diff(str(repo), mode="staged") + assert result["success"] is True + assert "+print('staged')" in result["diff"] + assert "unstaged.py" not in result["diff"] + + +def test_all_mode_spans_staged_unstaged_and_untracked(repo): + (repo / "tracked.py").write_text("print('staged')\n") + _git(repo, "add", "tracked.py") + (repo / "extra.py").write_text("z = 3\n") + + result = collect_working_diff(str(repo), mode="all") + assert result["success"] is True + assert "+print('staged')" in result["diff"] + assert "+z = 3" in result["diff"] + + +def test_paths_filter_restricts_output(repo): + (repo / "tracked.py").write_text("print('changed')\n") + (repo / "other.py").write_text("o = 1\n") + _git(repo, "add", "other.py") + _git(repo, "commit", "-q", "-m", "add other") + (repo / "other.py").write_text("o = 2\n") + + result = collect_working_diff(str(repo), paths=["tracked.py"]) + assert result["success"] is True + assert "tracked.py" in result["diff"] + assert "other.py" not in result["diff"] + + +def test_non_git_directory_fails_cleanly(tmp_path): + plain = tmp_path / "plain" + plain.mkdir() + result = collect_working_diff(str(plain)) + assert result["success"] is False + assert "not a git repository" in result["error"].lower() + + +def test_unknown_mode_rejected(repo): + result = collect_working_diff(str(repo), mode="bogus") + assert result["success"] is False + assert "bogus" in result["error"] diff --git a/tests/tui_gateway/test_billing_rpc.py b/tests/tui_gateway/test_billing_rpc.py index 3d29993bfd..3259ac6fb2 100644 --- a/tests/tui_gateway/test_billing_rpc.py +++ b/tests/tui_gateway/test_billing_rpc.py @@ -16,7 +16,7 @@ import pytest import tui_gateway.server as srv import hermes_cli.nous_billing as nb import agent.billing_view as bv -from agent.billing_view import BillingState, CardInfo, MonthlyCap +from agent.billing_view import BillingState, CardInfo, MonthlyCap, PaymentMethodInfo def _call(method: str, params: dict) -> dict: @@ -41,6 +41,11 @@ def test_billing_state_serializes_decimals_as_strings(monkeypatch): min_usd=Decimal("10"), max_usd=Decimal("10000"), card=CardInfo(brand="visa", last4="4242"), + payment_method=PaymentMethodInfo( + kind="link", + email="billing@example.com", + resolved_via="customerDefault", + ), monthly_cap=MonthlyCap( limit_usd=Decimal("1000"), spent_this_month_usd=Decimal("180"), is_default_ceiling=True ), @@ -53,7 +58,18 @@ def test_billing_state_serializes_decimals_as_strings(monkeypatch): assert res["balance_usd"] == "142.5" assert res["balance_display"] == "$142.50" assert res["charge_presets"] == ["100", "250"] - assert res["card"]["masked"] == "visa ····4242" + assert res["card"] == { + "brand": "visa", + "last4": "4242", + "masked": "visa ····4242", + "display": "visa ····4242", + "resolved_via": None, + } + assert res["payment_method"] == { + "kind": "link", + "email": "billing@example.com", + "resolved_via": "customerDefault", + } assert res["monthly_cap"]["is_default_ceiling"] is True assert res["is_admin"] is True and res["can_charge"] is True @@ -67,6 +83,77 @@ def test_billing_state_fail_open(monkeypatch): assert res["ok"] is True and res["logged_in"] is False +@pytest.mark.parametrize( + "raw_payment_method,expected", + [ + ( + { + "kind": "card", + "brand": "visa", + "last4": "4242", + "wallet": "apple_pay", + "paymentMethodId": "pm_card", + "resolvedVia": "subPin", + }, + { + "kind": "card", + "brand": "visa", + "last4": "4242", + "wallet": "apple_pay", + "resolved_via": "subPin", + }, + ), + ( + { + "kind": "link", + "email": "billing@example.com", + "resolvedVia": "customerDefault", + }, + { + "kind": "link", + "email": "billing@example.com", + "resolved_via": "customerDefault", + }, + ), + # A kind added after this gateway shipped: normalised to "unknown", + # keeping the real name for logs and neutral copy. + ( + {"kind": "future_method", "resolvedVia": "subPin"}, + {"kind": "unknown", "raw_kind": "future_method", "resolved_via": "subPin"}, + ), + ], +) +def test_billing_state_carries_payment_method_from_server_to_client( + monkeypatch, raw_payment_method, expected +): + payload = { + "org": {"id": "org_1", "name": "Acme", "role": "OWNER"}, + "balanceUsd": "10", + "paymentMethod": raw_payment_method, + } + monkeypatch.setattr( + bv, + "build_billing_state", + lambda *a, **kw: bv.billing_state_from_payload(payload), + ) + + res = _call("billing.state", {}) + + assert res["payment_method"] == expected + + +def test_billing_state_serializes_absent_payment_method(monkeypatch): + monkeypatch.setattr( + bv, + "build_billing_state", + lambda *a, **kw: BillingState(logged_in=False), + ) + + res = _call("billing.state", {}) + + assert res["payment_method"] is None + + # --------------------------------------------------------------------------- # billing.charge — typed error envelopes # --------------------------------------------------------------------------- diff --git a/tests/tui_gateway/test_kanban_notify_poller.py b/tests/tui_gateway/test_kanban_notify_poller.py new file mode 100644 index 0000000000..fd4374bb0b --- /dev/null +++ b/tests/tui_gateway/test_kanban_notify_poller.py @@ -0,0 +1,281 @@ +"""Tests for the TUI-side kanban notification poller (issue #59890). + +``kanban_create`` auto-subscribes TUI/desktop sessions with +``platform="tui"`` / ``chat_id=HERMES_SESSION_KEY``, but no component ever +read those rows back: the gateway notifier skips them (no "tui" messaging +adapter) and the TUI notification poller only watched process completions. +``last_event_id`` stayed 0 forever and no notification was ever delivered. + +These tests cover the delivery half that now lives in tui_gateway/server.py: +``_collect_kanban_notifications`` (cursor claim + formatting + terminal +unsubscribe) and ``_format_kanban_event_text``. +""" + +from types import SimpleNamespace + +from hermes_cli import kanban_db as kb +from tui_gateway.server import ( + _collect_kanban_notifications, + _format_kanban_event_text, +) + +SESSION_KEY = "tui-session-key-1" + + +def _session(key: str = SESSION_KEY) -> dict: + return {"session_key": key} + + +def _create_subscribed_task(*, chat_id: str = SESSION_KEY, platform: str = "tui"): + conn = kb.connect() + try: + tid = kb.create_task(conn, title="notify tui", assignee="worker") + kb.add_notify_sub(conn, task_id=tid, platform=platform, chat_id=chat_id) + return tid + finally: + conn.close() + + +def _complete(tid: str, summary: str = "all done") -> None: + conn = kb.connect() + try: + kb.complete_task(conn, tid, summary=summary) + finally: + conn.close() + + +def _sub_rows(tid: str) -> list: + conn = kb.connect() + try: + return kb.list_notify_subs(conn, task_id=tid) + finally: + conn.close() + + +class TestCollectKanbanNotifications: + def test_delivers_completed_event_and_unsubscribes(self): + tid = _create_subscribed_task() + _complete(tid, summary="shipped the fix") + + texts = _collect_kanban_notifications(_session()) + + assert len(texts) == 1 + assert tid in texts[0] + assert "done" in texts[0] + assert "shipped the fix" in texts[0] + # Task is at a final status -> subscription removed. + assert _sub_rows(tid) == [] + + def test_claim_advances_cursor_so_second_poll_is_empty(self): + tid = _create_subscribed_task() + conn = kb.connect() + try: + kb.block_task(conn, tid, reason="waiting on review") + finally: + conn.close() + + first = _collect_kanban_notifications(_session()) + second = _collect_kanban_notifications(_session()) + + assert len(first) == 1 + assert "blocked" in first[0] + assert "waiting on review" in first[0] + assert second == [] + # Blocked is not a final status -> subscription stays alive so a + # respawned task's next terminal event still reaches the user. + assert len(_sub_rows(tid)) == 1 + + def test_ignores_other_sessions_and_platforms(self): + tid_other_session = _create_subscribed_task(chat_id="some-other-session") + tid_gateway = _create_subscribed_task(platform="telegram", chat_id="chat-1") + # New subs start caught up at creation time (issue #29905); record the + # pre-completion cursors so we can assert they were never claimed. + pre_cursors = { + tid: _sub_rows(tid)[0]["last_event_id"] + for tid in (tid_other_session, tid_gateway) + } + _complete(tid_other_session) + _complete(tid_gateway) + + texts = _collect_kanban_notifications(_session()) + + assert texts == [] + # Foreign subscriptions untouched: cursors unclaimed, rows still there. + for tid in (tid_other_session, tid_gateway): + rows = _sub_rows(tid) + assert len(rows) == 1 + assert rows[0]["last_event_id"] == pre_cursors[tid] + + def test_no_session_key_is_a_noop(self): + tid = _create_subscribed_task() + _complete(tid) + + assert _collect_kanban_notifications({"session_key": ""}) == [] + assert _collect_kanban_notifications({"session_key": None}) == [] + assert len(_sub_rows(tid)) == 1 + + def test_profile_scoped_session_reads_the_shared_board(self, tmp_path): + """The kanban board is shared across profiles BY DESIGN (see the + hermes_cli/kanban_db.py module docstring): ``kanban_home()`` anchors on + ``get_default_hermes_root()``, which resolves the process env and + ignores context-local profile overrides. A Desktop session bound to a + non-launch profile (``session["profile_home"]``) must therefore still + have its subscription claimed from the one shared board — the poller + needs no per-profile home binding. + """ + from hermes_constants import ( + reset_hermes_home_override, + set_hermes_home_override, + ) + + tid = _create_subscribed_task() + _complete(tid, summary="cross-profile delivery") + + other_profile_home = tmp_path / "profiles" / "reviewer" + other_profile_home.mkdir(parents=True) + session = { + "session_key": SESSION_KEY, + "profile_home": str(other_profile_home), + } + # Simulate the strictest case: a context-local profile override is + # active while the poller collects (as a profile-bound RPC would set). + token = set_hermes_home_override(str(other_profile_home)) + try: + texts = _collect_kanban_notifications(session) + finally: + reset_hermes_home_override(token) + + assert len(texts) == 1 + assert tid in texts[0] + assert "cross-profile delivery" in texts[0] + assert _sub_rows(tid) == [] + + +class TestFormatKanbanEventText: + SUB = {"task_id": "t_abc123"} + TASK = SimpleNamespace(title="build the thing", assignee="worker", result=None) + + def test_silent_kinds_return_none(self): + for kind in ("archived", "unblocked"): + ev = SimpleNamespace(kind=kind, payload={}) + assert _format_kanban_event_text(self.SUB, self.TASK, ev, "main") is None + + def test_blocked_includes_reason(self): + ev = SimpleNamespace(kind="blocked", payload={"reason": "needs creds"}) + text = _format_kanban_event_text(self.SUB, self.TASK, ev, "main") + assert "t_abc123" in text + assert "blocked" in text + assert "needs creds" in text + assert "[main]" in text + assert "@worker" in text + + def test_completed_prefers_payload_summary(self): + ev = SimpleNamespace(kind="completed", payload={"summary": "first line\nsecond"}) + text = _format_kanban_event_text(self.SUB, self.TASK, ev, "") + assert "done" in text + assert "first line" in text + assert "second" not in text + + def test_timed_out_with_bad_payload_does_not_raise(self): + ev = SimpleNamespace(kind="timed_out", payload={"limit_seconds": "not-a-number"}) + text = _format_kanban_event_text(self.SUB, self.TASK, ev, "") + assert "timed out" in text + + +class TestNotificationPollerLoopKanbanWiring: + """Drive a real TUI subscription through ``_notification_poller_loop``. + + Covers the wiring above ``_collect_kanban_notifications``: status.update + emission, agent-turn dispatch when the session is idle, and the + busy-session pending buffer that flushes once the session goes idle. + """ + + def _start_poller(self, session: dict, monkeypatch): + import threading + import tui_gateway.server as server + + emits: list = [] + submits: list = [] + monkeypatch.setattr(server, "_KANBAN_POLL_SECONDS", 0.01) + monkeypatch.setattr( + server, "_emit", lambda event, sid, payload=None: emits.append((event, payload)) + ) + monkeypatch.setattr( + server, + "_run_prompt_submit", + lambda rid, sid, sess, text: submits.append(text), + ) + stop = threading.Event() + thread = threading.Thread( + target=server._notification_poller_loop, + args=(stop, "sid-poller-test", session), + daemon=True, + ) + thread.start() + return stop, thread, emits, submits + + @staticmethod + def _wait_for(predicate, timeout: float = 5.0) -> bool: + import time as _time + + deadline = _time.monotonic() + timeout + while _time.monotonic() < deadline: + if predicate(): + return True + _time.sleep(0.02) + return False + + def _poller_session(self, *, running: bool = False) -> dict: + import threading + + return { + "session_key": SESSION_KEY, + "history_lock": threading.Lock(), + "running": running, + } + + def test_idle_session_gets_status_update_and_agent_turn(self, monkeypatch): + tid = _create_subscribed_task() + _complete(tid, summary="poller e2e done") + session = self._poller_session(running=False) + + stop, thread, emits, submits = self._start_poller(session, monkeypatch) + try: + assert self._wait_for(lambda: submits), "agent turn was never dispatched" + finally: + stop.set() + thread.join(timeout=5) + + status_texts = [p["text"] for e, p in emits if e == "status.update" and p] + assert any(tid in t for t in status_texts), status_texts + assert any(e == "message.start" for e, _ in emits) + assert any(tid in text for text in submits), submits + assert session["running"] is True # poller claimed the turn + assert not session.get("_kanban_pending") + + def test_busy_session_buffers_then_flushes_when_idle(self, monkeypatch): + tid = _create_subscribed_task() + _complete(tid, summary="buffered while busy") + session = self._poller_session(running=True) + + stop, thread, emits, submits = self._start_poller(session, monkeypatch) + try: + # Busy: the status line appears and the event is buffered, but no + # agent turn is dispatched while another turn is running. + assert self._wait_for( + lambda: any(e == "status.update" for e, _ in emits) + and session.get("_kanban_pending") + ) + assert not submits + + with session["history_lock"]: + session["running"] = False + + assert self._wait_for(lambda: submits), "pending batch never flushed" + finally: + stop.set() + thread.join(timeout=5) + + assert any(tid in text for text in submits), submits + assert session["_kanban_pending"] == [] + assert session["running"] is True diff --git a/tools/approval.py b/tools/approval.py index ae9d096e0d..9b238c67da 100644 --- a/tools/approval.py +++ b/tools/approval.py @@ -2018,6 +2018,81 @@ _session_approved: dict[str, set] = {} _session_yolo: set[str] = set() _permanent_approved: set = set() +# ========================================================================= +# Consecutive-denial circuit breaker for smart approvals +# ========================================================================= +# Nothing stops the model from retrying variants of a smart-denied command — +# each retry burns another guardian LLM call and agent iteration. After +# ``approvals.denial_breaker_threshold`` consecutive guardian DENY verdicts +# in one session (default 3; 0 disables), the deny message returned to the +# model escalates to a hard-stop instruction. Any approval resets the tally. +# This changes only the TOOL RESULT text — no message-history surgery, no +# interrupts — so it is prompt-cache-invariant by construction. Inspired by +# ChatGPT Work's auto-review circuit breaker (3 consecutive denials). +_denial_tally: dict[str, int] = {} +# Plain dict with a small cap so an army of short-lived session keys cannot +# grow it without bound; oldest (least recently denied) entries are evicted. +_DENIAL_TALLY_MAX_SESSIONS = 256 + + +def _get_denial_breaker_threshold() -> int: + """Read ``approvals.denial_breaker_threshold`` from config. + + Defaults to 3 consecutive guardian denials; 0 (or negative) disables + the breaker entirely. + """ + try: + return int(_get_approval_config().get("denial_breaker_threshold", 3)) + except (ValueError, TypeError): + return 3 + + +def _record_denial(session_key: str) -> int: + """Increment and return the session's consecutive guardian-denial count. + + Pop-and-reinsert keeps actively-denying sessions at the most-recent end + of the dict so eviction (insertion-ordered) drops genuinely idle keys. + """ + with _lock: + count = _denial_tally.pop(session_key, 0) + 1 + _denial_tally[session_key] = count + while len(_denial_tally) > _DENIAL_TALLY_MAX_SESSIONS: + _denial_tally.pop(next(iter(_denial_tally))) + return count + + +def _reset_denials(session_key: str) -> None: + """Clear the session's consecutive-denial tally (an approval happened).""" + with _lock: + _denial_tally.pop(session_key, None) + + +def _denial_breaker_addendum(session_key: str) -> str: + """Return the escalated hard-stop text when the breaker has tripped. + + Read-only: callers increment via :func:`_record_denial` on the guardian + DENY verdict; this just checks the session's tally against the + configured threshold. Returns '' below the threshold (or when + disabled), otherwise a leading-space addendum the caller appends + verbatim to the deny message returned to the model. + """ + with _lock: + count = _denial_tally.get(session_key, 0) + threshold = _get_denial_breaker_threshold() + if threshold <= 0 or count < threshold: + return "" + logger.warning( + "Smart-approval circuit breaker tripped for session %s: " + "%d consecutive denials (threshold %d)", + session_key, count, threshold, + ) + return ( + f" CIRCUIT BREAKER: {count} consecutive commands were blocked by " + "the security reviewer. STOP attempting variations of this " + "operation. Report the blocked operation to the user and either " + "ask them to run it manually or use /approve." + ) + # ========================================================================= # Blocking gateway approval (mirrors CLI's synchronous input() flow) # ========================================================================= @@ -2563,6 +2638,21 @@ def _strip_line_comment(line: str) -> str: return line +def _get_smart_policy() -> str: + """Read the operator's custom smart-approval policy text from config. + + ``approvals.smart_policy`` (string, default empty) lets operators append + their own rules to the smart-approval guardian's system prompt — e.g. + "always ESCALATE anything touching /etc" or "APPROVE docker compose + restarts in ~/deploys". Inspired by ChatGPT Work's customizable + auto-review guardian policy. + """ + policy = _get_approval_config().get("smart_policy", "") + if not isinstance(policy, str): + return "" + return policy.strip() + + def _smart_approve(command: str, description: str) -> str: """Use the auxiliary LLM to assess risk and decide approval. @@ -2607,6 +2697,21 @@ def _smart_approve(command: str, description: str) -> str: "Respond with exactly one word: APPROVE, DENY, or ESCALATE" ) + # Operator-customizable policy (approvals.smart_policy). Appended to + # the SYSTEM prompt only — the trusted channel. It must NEVER be + # placed in the user message next to the block: the command + # text is untrusted (potentially prompt-injected) input, and mixing + # trusted operator rules into that channel would both dilute the + # trust boundary the guard relies on and teach the guard to accept + # policy-looking text adjacent to commands. + operator_policy = _get_smart_policy() + if operator_policy: + system_prompt += ( + "\n\nAdditional policy rules from the operator (these are " + "TRUSTED instructions, unlike the command text):\n" + f"{operator_policy}" + ) + user_prompt = ( f"The following command was flagged as: {description}\n\n" f"\n{sanitized_command}\n\n\n" @@ -3400,19 +3505,27 @@ def check_all_command_guards(command: str, env_type: str, # Approve this command only. Pattern-level persistence would let one # benign command suppress review of later commands that happen to # match the same broad detector category. + _reset_denials(session_key) logger.debug("Smart approval: auto-approved '%s' (%s)", command[:60], combined_desc_for_llm) return {"approved": True, "message": None, "smart_approved": True, "description": combined_desc_for_llm} elif verdict == "deny" and not (is_cli or is_gateway or is_ask): + _record_denial(session_key) + breaker_addendum = _denial_breaker_addendum(session_key) return { "approved": False, "message": f"BLOCKED by smart approval: {combined_desc_for_llm}. " - "The command was assessed as genuinely dangerous. Do NOT retry.", + "The command was assessed as genuinely dangerous. " + f"Do NOT retry.{breaker_addendum}", "smart_denied": True, } elif verdict == "deny": + # Guardian DENY that falls through to a one-operation human + # override still counts toward the consecutive-denial breaker; + # a subsequent human approval resets the tally below. + _record_denial(session_key) smart_denied_for_owner = True # An interactive owner may override DENY for this operation only. # ESCALATE follows the normal, potentially persistent manual behavior. @@ -3507,6 +3620,7 @@ def check_all_command_guards(command: str, env_type: str, reason_addendum = "" if outcome == "denied" and deny_reason: reason_addendum = f' Reason given by the user: "{deny_reason}".' + breaker_addendum = _denial_breaker_addendum(session_key) return { "approved": False, "message": ( @@ -3516,7 +3630,7 @@ def check_all_command_guards(command: str, env_type: str, f"same outcome via a different command. Stop the " f"current workflow and wait for the user to respond " f"before taking any further destructive or " - f"irreversible action.{timeout_addendum}" + f"irreversible action.{timeout_addendum}{breaker_addendum}" ), "pattern_key": primary_key, "description": combined_desc, @@ -3537,6 +3651,9 @@ def check_all_command_guards(command: str, env_type: str, approve_permanent(key) save_permanent_allowlist(_permanent_approved) + # A human approval (including an ESCALATE-then-approve or a + # smart-DENY owner override) resets the consecutive-denial tally. + _reset_denials(session_key) return {"approved": True, "message": None, "user_approved": True, "description": combined_desc} @@ -3601,6 +3718,7 @@ def check_all_command_guards(command: str, env_type: str, ) if choice == "deny": + breaker_addendum = _denial_breaker_addendum(session_key) return { "approved": False, "message": ( @@ -3608,8 +3726,8 @@ def check_all_command_guards(command: str, env_type: str, "to this action. Do NOT retry this command, do NOT rephrase " "it, and do NOT attempt the same outcome via a different " "command. Stop the current workflow and wait for the user " - "to respond before taking any further destructive or " - "irreversible action." + f"to respond before taking any further destructive or " + f"irreversible action.{breaker_addendum}" ), "pattern_key": primary_key, "description": combined_desc, @@ -3630,6 +3748,8 @@ def check_all_command_guards(command: str, env_type: str, approve_permanent(key) save_permanent_allowlist(_permanent_approved) + # A human approval resets the consecutive-denial tally. + _reset_denials(session_key) return {"approved": True, "message": None, "user_approved": True, "description": combined_desc} @@ -3731,16 +3851,19 @@ def check_execute_code_guard(code: str, env_type: str, verdict = _smart_approve(command, description) _observe_smart_approval_verdict(observer_payload, verdict) if verdict == "approve": + _reset_denials(session_key) logger.debug("Smart approval: auto-approved execute_code for session %s", session_key) return {"approved": True, "message": None, "smart_approved": True, "description": description} if verdict == "deny" and not (is_gateway or is_ask): + _record_denial(session_key) + breaker_addendum = _denial_breaker_addendum(session_key) return { "approved": False, "message": ("BLOCKED by smart approval: execute_code script " "execution was assessed as genuinely dangerous. " - "Do NOT retry."), + f"Do NOT retry.{breaker_addendum}"), "smart_denied": True, "pattern_key": pattern_key, "description": description, @@ -3748,6 +3871,10 @@ def check_execute_code_guard(code: str, env_type: str, "user_consent": False, } if verdict == "deny": + # Guardian DENY that falls through to a one-operation human + # override still counts toward the consecutive-denial breaker; + # a subsequent human approval resets the tally below. + _record_denial(session_key) smart_denied_for_owner = True # Interactive DENY falls through to one-operation human approval; # ESCALATE retains the normal manual approval behavior. @@ -3829,13 +3956,14 @@ def check_execute_code_guard(code: str, env_type: str, reason_addendum = "" if resolved and choice == "deny" and deny_reason: reason_addendum = f' Reason given by the user: "{deny_reason}".' + breaker_addendum = _denial_breaker_addendum(session_key) return { "approved": False, "message": ( f"BLOCKED: execute_code script {reason}.{reason_addendum} The " f"user has NOT consented to running this code. Do NOT retry, " f"do NOT rephrase the script, and do NOT attempt the same " - f"outcome via a different tool.{addendum}" + f"outcome via a different tool.{addendum}{breaker_addendum}" ), "pattern_key": pattern_key, "description": description, @@ -3856,6 +3984,8 @@ def check_execute_code_guard(code: str, env_type: str, save_permanent_allowlist(_permanent_approved) # choice == "once": no persistence — approval lasts this single call only. + # A human approval resets the consecutive-denial tally. + _reset_denials(session_key) return {"approved": True, "message": None, "user_approved": True, "description": description} diff --git a/tools/async_delegation.py b/tools/async_delegation.py index 7e88899e58..dbe0b2f107 100644 --- a/tools/async_delegation.py +++ b/tools/async_delegation.py @@ -85,6 +85,36 @@ _MAX_DURABLE_PENDING = 1000 _MAX_DELIVERY_ATTEMPTS = 8 _DB_LOCK = threading.Lock() +# --------------------------------------------------------------------------- +# Stale-delegation detection (progress-based, on by default) +# --------------------------------------------------------------------------- +# A detached runner that wedges before returning (e.g. stuck inside its first +# model API call — #60203) never reaches its ``finally`` finalizer, so no +# completion event is ever published: the delegation shows "dispatched" +# forever and the owning session looks silent until a process restart. We do +# NOT fix this with a wall-clock timeout — legitimate heavy subagent work +# (deep reviews, research fan-outs, slow reasoning models) must never be +# killed for taking long (see delegate_tool.DEFAULT_CHILD_TIMEOUT rationale). +# Instead a single monitor thread watches per-dispatch PROGRESS (api-call +# count + current tool, via an injected ``progress_fn``): a child that is +# advancing is left alone forever; a child with NO progress past the stale +# threshold is interrupted, given a grace window to unwind and deliver its +# partial results through the normal finalize path, and only force-finalized +# with a terminal ``stalled`` event if it never returns. +# +# Thresholds mirror the sync-path heartbeat staleness monitor in +# delegate_tool: idle (not inside a tool) stays tight so a wedged first API +# call is caught quickly; in-tool is much higher so legitimately slow tools +# (long terminal commands, big fetches) get time to finish. +_STALE_CHECK_INTERVAL = 30.0 # seconds between monitor sweeps +_STALE_IDLE_SECONDS = 450.0 # no progress, no current tool → stalled +_STALE_IN_TOOL_SECONDS = 1200.0 # no progress while inside a tool → stalled +_STALL_GRACE_SECONDS = 120.0 # after interrupt, time for the runner to return + +_monitor_lock = threading.Lock() +_monitor_thread: Optional[threading.Thread] = None +_monitor_stop = threading.Event() + def _db_path(): return get_hermes_home() / "state.db" @@ -505,7 +535,10 @@ def _get_executor(max_workers: int) -> ThreadPoolExecutor: def active_count() -> int: """Number of async delegations currently running.""" with _records_lock: - return sum(1 for r in _records.values() if r.get("status") in {"running", "finalizing"}) + return sum( + 1 for r in _records.values() + if r.get("status") in {"running", "stalling", "finalizing"} + ) def _new_delegation_id() -> str: @@ -572,6 +605,7 @@ def dispatch_async_delegation( origin_session_id: str = "", interrupt_fn: Optional[Callable[[], None]] = None, max_async_children: int = _DEFAULT_MAX_ASYNC_CHILDREN, + progress_fn: Optional[Callable[[], tuple]] = None, ) -> Dict[str, Any]: """Spawn ``runner`` on the daemon executor and return a handle immediately. @@ -596,6 +630,14 @@ def dispatch_async_delegation( interrupt_fn Optional callable to signal the child to stop (used on shutdown / explicit cancel). + progress_fn + Optional zero-arg callable returning ``(token, in_tool)`` where + ``token`` is any comparable snapshot of the child's progress (api + call count + current tool) and ``in_tool`` says whether the child is + currently inside a tool call. Sampled by the stale monitor; a frozen + token past the stale threshold marks the delegation stuck (see the + stale-detection block at the top of this module). When omitted, the + delegation is not monitored. max_async_children Concurrency cap. When at capacity the dispatch is REJECTED (the caller should fall back to sync or tell the user) rather than queued, so a @@ -624,13 +666,19 @@ def dispatch_async_delegation( "dispatched_at": dispatched_at, "completed_at": None, "interrupt_fn": interrupt_fn, + "progress_fn": progress_fn, + # Stale-monitor bookkeeping (see _stale_monitor_loop). + "_progress_token": None, + "_progress_ts": dispatched_at, + "_interrupted_at": None, } # Capacity check and record insert under ONE lock hold — checking # active_count() separately would let two concurrent dispatches (e.g. # from different gateway sessions) both pass the check and exceed the cap. with _records_lock: running = sum( - 1 for r in _records.values() if r.get("status") == "running" + 1 for r in _records.values() + if r.get("status") in ("running", "stalling") ) if running >= max_async_children: return { @@ -679,6 +727,8 @@ def dispatch_async_delegation( "status": "rejected", "error": f"Failed to schedule async delegation: {exc}", } + if progress_fn is not None: + _ensure_stale_monitor() logger.info( "Dispatched async delegation %s (session_key=%s): %s", @@ -689,19 +739,37 @@ def dispatch_async_delegation( def _finalize(delegation_id: str, result: Dict[str, Any], status: str) -> None: """Mark a record complete and push the completion event onto the queue.""" + claimed = _begin_finalization(delegation_id) + if claimed is None: + return + event_record, _interrupt_fn = claimed + + _push_completion_event(event_record, result, status) + _finish_finalization(delegation_id, status) + + +def _begin_finalization( + delegation_id: str, +) -> Optional[tuple[Dict[str, Any], Optional[Callable[[], None]]]]: + """Atomically claim terminal delivery while keeping the record active.""" with _records_lock: record = _records.get(delegation_id) - if record is None: + if record is None or record.get("status") not in ("running", "stalling"): return # Stay active until durable persistence and queue publication finish; # otherwise process shutdown can kill this daemon worker in the narrow # gap after status flips but before SQLite is committed. record["status"] = "finalizing" record["completed_at"] = time.time() + interrupt_fn = record.get("interrupt_fn") record["interrupt_fn"] = None # drop the closure; child is done + record["progress_fn"] = None # stop stale-monitor sampling event_record = dict(record) - _push_completion_event(event_record, result, status) + return event_record, interrupt_fn + + +def _finish_finalization(delegation_id: str, status: str) -> None: with _records_lock: record = _records.get(delegation_id) if record is not None: @@ -757,6 +825,16 @@ def _push_completion_event( "completed_at": completed_at, "exit_reason": result.get("exit_reason"), } + # Structured stall metadata (#51690) — additive, present only on + # stall-monitor finalizations. + for _k in ( + "stalled_after_quiet_seconds", + "stall_threshold_seconds", + "stall_phase", + "stall_grace_seconds", + ): + if _k in result: + evt[_k] = result[_k] _persist_completion(evt, result) try: process_registry.completion_queue.put(evt) @@ -783,6 +861,7 @@ def dispatch_async_delegation_batch( interrupt_fn: Optional[Callable[[], None]] = None, max_async_children: int = _DEFAULT_MAX_ASYNC_CHILDREN, delegation_id: Optional[str] = None, + progress_fn: Optional[Callable[[], tuple]] = None, ) -> Dict[str, Any]: """Dispatch a WHOLE fan-out batch as ONE background unit. @@ -828,10 +907,15 @@ def dispatch_async_delegation_batch( "completed_at": None, "interrupt_fn": interrupt_fn, "is_batch": True, + "progress_fn": progress_fn, + "_progress_token": None, + "_progress_ts": dispatched_at, + "_interrupted_at": None, } with _records_lock: running = sum( - 1 for r in _records.values() if r.get("status") == "running" + 1 for r in _records.values() + if r.get("status") in ("running", "stalling") ) if running >= max_async_children: return { @@ -884,6 +968,8 @@ def dispatch_async_delegation_batch( "status": "rejected", "error": f"Failed to schedule async delegation batch: {exc}", } + if progress_fn is not None: + _ensure_stale_monitor() logger.info( "Dispatched async delegation batch %s (%d task(s), session_key=%s)", @@ -896,22 +982,26 @@ def _finalize_batch( delegation_id: str, combined: Dict[str, Any], status: str ) -> None: """Mark a batch record complete and push ONE combined completion event.""" - with _records_lock: - record = _records.get(delegation_id) - if record is None: - return - record["status"] = "finalizing" - record["completed_at"] = time.time() - record["interrupt_fn"] = None - event_record = dict(record) + claimed = _begin_finalization(delegation_id) + if claimed is None: + return + event_record, _interrupt_fn = claimed + _push_batch_completion_event(event_record, combined, status) + _finish_finalization(delegation_id, status) + + +def _push_batch_completion_event( + event_record: Dict[str, Any], combined: Dict[str, Any], status: str +) -> None: + """Push a combined async-delegation batch completion event.""" try: from tools.process_registry import process_registry except Exception as exc: # pragma: no cover logger.error( "Async delegation batch %s finished but process_registry import " "failed; result lost: %s", - delegation_id, exc, + event_record.get("delegation_id"), exc, ) return @@ -919,7 +1009,7 @@ def _finalize_batch( completed_at = event_record.get("completed_at") or time.time() evt = { "type": "async_delegation", - "delegation_id": delegation_id, + "delegation_id": event_record.get("delegation_id"), "session_key": event_record.get("session_key", ""), "origin_ui_session_id": event_record.get("origin_ui_session_id", ""), "origin_session_id": event_record.get("origin_session_id", ""), @@ -944,6 +1034,16 @@ def _finalize_batch( "dispatched_at": dispatched_at, "completed_at": completed_at, } + # Structured stall metadata (#51690) — additive, present only on + # stall-monitor finalizations. + for _k in ( + "stalled_after_quiet_seconds", + "stall_threshold_seconds", + "stall_phase", + "stall_grace_seconds", + ): + if _k in combined: + evt[_k] = combined[_k] _persist_completion(evt, combined) try: process_registry.completion_queue.put(evt) @@ -951,26 +1051,281 @@ def _finalize_batch( logger.error( "Async delegation batch %s: failed to enqueue completion event; " "result lost: %s", - delegation_id, exc, + event_record.get("delegation_id"), exc, ) - finally: + + +def _ensure_stale_monitor() -> None: + """Start (once) the module-level stale-delegation monitor thread. + + One daemon thread serves every dispatch; it exits on its own when no + monitorable records remain, and is restarted by the next dispatch that + carries a ``progress_fn``. + """ + global _monitor_thread + with _monitor_lock: + if _monitor_thread is not None and _monitor_thread.is_alive(): + return + _monitor_stop.clear() + _monitor_thread = threading.Thread( + target=_stale_monitor_loop, + name="async-delegate-stale-monitor", + daemon=True, + ) + _monitor_thread.start() + + +def _stale_monitor_loop() -> None: + """Sweep running delegations for stalled progress. + + Per sweep, for every running record with a ``progress_fn``: + + - Sample ``(token, in_tool)``. A changed token refreshes the record's + progress timestamp — a child that keeps advancing is never touched, no + matter how long it runs. + - A frozen token past the idle/in-tool threshold marks the record + ``stalling``: we call ``interrupt_fn`` so a responsive-but-slow child + can unwind and deliver its (partial) result through the normal + ``_finalize`` path with full fidelity. + - A ``stalling`` record whose runner still hasn't returned after the + grace window is force-finalized with one terminal ``stalled`` event so + the owning session hears an outcome and the async slot frees. A late + runner return after that is ignored by ``_begin_finalization``. + """ + while not _monitor_stop.wait(_STALE_CHECK_INTERVAL): + now = time.time() + stalled: List[tuple] = [] # (delegation_id, is_batch, quiet_for, in_tool) + expired: List[str] = [] # stalling past grace → force-finalize + any_monitorable = False with _records_lock: - record = _records.get(delegation_id) - if record is not None: - record["status"] = status - _prune_completed_locked() + for record in _records.values(): + status = record.get("status") + if status == "stalling": + any_monitorable = True + interrupted_at = record.get("_interrupted_at") or now + if now - interrupted_at >= _STALL_GRACE_SECONDS: + expired.append(record["delegation_id"]) + continue + if status != "running": + continue + progress_fn = record.get("progress_fn") + if progress_fn is None: + continue + any_monitorable = True + try: + token, in_tool = progress_fn() + except Exception: + # An unreadable child must not look permanently healthy — + # keep the last timestamp running instead of refreshing it. + token, in_tool = record.get("_progress_token"), False + if token != record.get("_progress_token"): + record["_progress_token"] = token + record["_progress_ts"] = now + continue + quiet_for = now - (record.get("_progress_ts") or now) + limit = ( + _STALE_IN_TOOL_SECONDS if in_tool else _STALE_IDLE_SECONDS + ) + if quiet_for >= limit: + record["status"] = "stalling" + record["_interrupted_at"] = now + # Structured stall context for the terminal event and + # status listings (#51690): how long progress was frozen, + # which threshold applied, and whether the child was + # inside a tool when it went quiet. + record["_stall_quiet_seconds"] = round(quiet_for, 2) + record["_stall_threshold_seconds"] = limit + record["_stall_in_tool"] = bool(in_tool) + stalled.append( + ( + record["delegation_id"], + bool(record.get("is_batch")), + quiet_for, + in_tool, + ) + ) + for delegation_id, _is_batch, quiet_for, in_tool in stalled: + logger.warning( + "Async delegation %s made no progress for %.0fs " + "(in_tool=%s) — interrupting; grace window %.0fs", + delegation_id, quiet_for, in_tool, _STALL_GRACE_SECONDS, + ) + with _records_lock: + record = _records.get(delegation_id) + fn = record.get("interrupt_fn") if record else None + if callable(fn): + try: + fn() + except Exception as exc: + logger.debug( + "Async delegation %s stall interrupt failed: %s", + delegation_id, exc, + ) + for delegation_id in expired: + _finalize_stalled(delegation_id) + if not any_monitorable: + return + + +def _finalize_stalled(delegation_id: str) -> None: + """Force-finalize a stalling delegation whose runner never returned.""" + claimed = _begin_finalization(delegation_id) + if claimed is None: + return + event_record, _interrupt_fn = claimed + + completed_at = event_record.get("completed_at") or time.time() + duration = round( + completed_at - (event_record.get("dispatched_at") or completed_at), + 2, + ) + quiet_seconds = event_record.get("_stall_quiet_seconds") + threshold_seconds = event_record.get("_stall_threshold_seconds") + stall_in_tool = event_record.get("_stall_in_tool") + error = ( + f"Async delegation {delegation_id} stalled: the detached subagent " + "stopped making progress (no new API calls, tool activity, or " + "streamed tokens), did not respond to interruption, and never " + "produced a completion event. The worker may be wedged inside a " + "model API call — this is a known failure mode of long-lived " + "gateway processes (#60203). Re-dispatch the task if it is still " + "needed." + ) + logger.error( + "Async delegation %s force-finalized as stalled after %.0fs", + delegation_id, duration, + ) + # Structured stall metadata (#51690): lets parents and UIs distinguish + # a stall-monitor kill from other failures without parsing the error + # string, mirroring the sync path's timeout_seconds/timed_out_after_ + # seconds/timeout_phase fields. + stall_meta = { + "stalled_after_quiet_seconds": quiet_seconds, + "stall_threshold_seconds": threshold_seconds, + "stall_phase": ( + "in_tool" if stall_in_tool + else "idle" if stall_in_tool is not None + else None + ), + "stall_grace_seconds": _STALL_GRACE_SECONDS, + } + if event_record.get("is_batch"): + _push_batch_completion_event( + event_record, + { + "results": [], + "error": error, + "total_duration_seconds": duration, + **stall_meta, + }, + "stalled", + ) + else: + _push_completion_event( + event_record, + { + "status": "stalled", + "summary": None, + "error": error, + "api_calls": 0, + "duration_seconds": duration, + "exit_reason": "stalled", + **stall_meta, + }, + "stalled", + ) + _finish_finalization(delegation_id, "stalled") + + +def _children_activity_from_token(token: Any, now: float) -> Optional[List]: + """Parse a progress token into per-child activity dicts (best-effort). + + delegate_tool's ``_batch_progress`` emits one ``(api_call_count, + current_tool, last_activity_ts)`` tuple per child. Foreign token shapes + (custom dispatchers) degrade to ``None`` entries rather than raising — + the token contract is intentionally opaque to the registry. + """ + try: + parts = list(token) + except TypeError: + return None + out: List[Optional[Dict[str, Any]]] = [] + for part in parts: + if isinstance(part, (list, tuple)) and len(part) >= 2: + entry: Dict[str, Any] = { + "api_calls": part[0], + "current_tool": part[1], + } + if len(part) >= 3 and isinstance(part[2], (int, float)): + entry["seconds_since_activity"] = round( + max(0.0, now - float(part[2])), 1 + ) + out.append(entry) + else: + out.append(None) + return out def list_async_delegations() -> List[Dict[str, Any]]: """Snapshot of async delegations (running + recently completed). - Safe to call from any thread. Excludes the non-serialisable interrupt_fn. + Safe to call from any thread. Excludes the non-serialisable callables + and private monitor bookkeeping, but exposes computed live-status + fields for UIs (#51690): + + - ``seconds_since_progress``: how long the stale monitor has seen a + frozen progress token (running/stalling records). + - ``children_activity``: per-child ``{api_calls, current_tool, + seconds_since_activity}`` sampled live from the dispatch's + ``progress_fn``. + - ``stalled_after_quiet_seconds`` / ``stall_threshold_seconds`` / + ``stall_in_tool``: stall context once the monitor has tripped. """ + now = time.time() + samplers: Dict[str, Callable] = {} with _records_lock: - return [ - {k: v for k, v in r.items() if k != "interrupt_fn"} - for r in _records.values() - ] + items = [] + for r in _records.values(): + item = { + k: v + for k, v in r.items() + if k not in {"interrupt_fn", "progress_fn"} + and not k.startswith("_") + } + status = r.get("status") + if status in ("running", "stalling"): + ts = r.get("_progress_ts") + if ts: + item["seconds_since_progress"] = round(now - ts, 1) + fn = r.get("progress_fn") + if callable(fn): + samplers[r["delegation_id"]] = fn + if status in ("stalling", "stalled"): + for src, dst in ( + ("_stall_quiet_seconds", "stalled_after_quiet_seconds"), + ("_stall_threshold_seconds", "stall_threshold_seconds"), + ("_stall_in_tool", "stall_in_tool"), + ): + if r.get(src) is not None: + item[dst] = r.get(src) + items.append(item) + + # Sample live activity OUTSIDE the lock — progress_fn reads child-agent + # attributes and must never run under _records_lock (a slow or broken + # sampler would block every dispatch/finalize in the process). + for item in items: + fn = samplers.get(item.get("delegation_id")) + if fn is None: + continue + try: + token, in_tool = fn() + except Exception: + continue + activity = _children_activity_from_token(token, now) + if activity is not None: + item["children_activity"] = activity + item["in_tool"] = bool(in_tool) + return items def interrupt_all(reason: str = "shutdown") -> int: @@ -983,7 +1338,8 @@ def interrupt_all(reason: str = "shutdown") -> int: count = 0 with _records_lock: targets = [ - r for r in _records.values() if r.get("status") == "running" + r for r in _records.values() + if r.get("status") in ("running", "stalling") ] for r in targets: fn = r.get("interrupt_fn") @@ -1031,7 +1387,7 @@ def interrupt_for_session( with _records_lock: targets = [ r for r in _records.values() - if r.get("status") == "running" + if r.get("status") in ("running", "stalling") and ( (origin_ui_session_id and str(r.get("origin_ui_session_id") or "") == origin_ui_session_id) or (session_key and str(r.get("session_key") or "") == session_key) @@ -1058,12 +1414,18 @@ def interrupt_for_session( def _reset_for_tests() -> None: - """Test-only: clear all state and tear down the executor.""" - global _executor, _executor_max_workers + """Test-only: clear all state and tear down the executor + monitor.""" + global _executor, _executor_max_workers, _monitor_thread with _executor_lock: if _executor is not None: _executor.shutdown(wait=False) _executor = None _executor_max_workers = 0 + _monitor_stop.set() + with _monitor_lock: + thread = _monitor_thread + _monitor_thread = None + if thread is not None and thread.is_alive(): + thread.join(timeout=2) with _records_lock: _records.clear() diff --git a/tools/checkpoint_manager.py b/tools/checkpoint_manager.py index 27d3680725..a1993187ff 100644 --- a/tools/checkpoint_manager.py +++ b/tools/checkpoint_manager.py @@ -880,6 +880,38 @@ class CheckpointManager: "diff": diff_out if ok_diff else "", } + def session_diff(self, working_dir: str) -> Dict: + """Show the cumulative diff of everything changed in this directory. + + This powers ``/diff session``. It answers "what has Hermes changed + here?" by diffing the *earliest retained checkpoint* — the snapshot + taken before the first recorded edit — against the current working + tree. Because checkpoints are captured just before each file-mutating + tool call, that baseline is the pre-edit state, so the diff covers the + first edit and everything after it. + + Note: checkpoints are a persistent per-project ref, so the earliest + *retained* checkpoint may predate the current session (or, after + pruning, postdate its true start). It is an approximation of "what + Hermes changed", not an exact per-session ledger. + + Returns the same shape as :meth:`diff` (``{"success", "stat", + "diff"}``). When no checkpoints exist yet — nothing has been edited — + the call still *succeeds* with empty output and ``"empty": True`` so + callers can show a friendly "no changes" message rather than an error. + """ + checkpoints = self.list_checkpoints(working_dir) + if not checkpoints: + return {"success": True, "stat": "", "diff": "", "empty": True} + + baseline = checkpoints[-1].get("hash") or "" + result = self.diff(working_dir, baseline) + if result.get("success"): + result.setdefault("baseline", baseline) + if not result.get("stat") and not result.get("diff"): + result["empty"] = True + return result + def restore(self, working_dir: str, commit_hash: str, file_path: str = None) -> Dict: """Restore files to a checkpoint state.""" hash_err = _validate_commit_hash(commit_hash) diff --git a/tools/clarify_gateway.py b/tools/clarify_gateway.py index bb7ed4a970..76bb3b4d09 100644 --- a/tools/clarify_gateway.py +++ b/tools/clarify_gateway.py @@ -51,6 +51,7 @@ class _ClarifyEntry: session_key: str question: str choices: Optional[List[str]] + multi_select: bool = False event: threading.Event = field(default_factory=threading.Event) response: Optional[str] = None awaiting_text: bool = False # set when user picked "Other" or clarify is open-ended @@ -61,6 +62,7 @@ class _ClarifyEntry: "session_key": self.session_key, "question": self.question, "choices": list(self.choices) if self.choices else None, + "multi_select": bool(self.multi_select), } @@ -80,6 +82,7 @@ def register( session_key: str, question: str, choices: Optional[List[str]], + multi_select: bool = False, ) -> _ClarifyEntry: """Register a pending clarify request and return the entry. @@ -91,6 +94,7 @@ def register( session_key=session_key, question=question, choices=list(choices) if choices else None, + multi_select=bool(multi_select) and bool(choices), # Open-ended (no choices) → next message IS the response, no buttons needed. awaiting_text=not bool(choices), ) @@ -205,6 +209,14 @@ def _coerce_text_response(entry: _ClarifyEntry, response: str) -> Optional[str]: - Accept exact choice label matches (case-insensitive) - Reject arbitrary prose (return None) so the message continues as a normal turn + For multi-select clarifies (entry.multi_select=True): + - Accept several numbers separated by commas and/or spaces ("1,3" / "1 3") + - Accept exact choice label matches (single or comma-separated) + - Out-of-range numbers reject the whole reply (return None) so the user + can retry instead of silently getting a partial selection + - Selections are returned as a JSON array string, which the clarify + tool's ``_parse_multi_select_response`` decodes back into a list + For text fallback or awaiting_text mode: - Accept any text (numeric/label/custom) after passing through coercion @@ -219,6 +231,14 @@ def _coerce_text_response(entry: _ClarifyEntry, response: str) -> Optional[str]: # Open-ended: accept any text return text + if entry.multi_select: + coerced = _coerce_multi_select_text(entry, text) + if coerced is not None: + return coerced + # Not a parseable selection — accept as custom text only in + # awaiting_text mode (the "Other" path); otherwise reject. + return text if entry.awaiting_text else None + # Try numeric selection first (always valid for multi-choice) try: idx = int(text) - 1 @@ -241,6 +261,58 @@ def _coerce_text_response(entry: _ClarifyEntry, response: str) -> Optional[str]: return None +def _coerce_multi_select_text(entry: _ClarifyEntry, text: str) -> Optional[str]: + """Parse a typed multi-select reply into a JSON array of choice labels. + + Accepts numbers and/or exact labels separated by commas (and, for + all-numeric replies, bare spaces): "1,3", "1 3", "staging, prod". + Returns ``None`` when any token is out of range or unrecognised so the + caller can reject the reply cleanly instead of resolving a partial or + wrong selection. + """ + import json as _json + + if not text: + return None + choices = entry.choices or [] + + # Split on commas first; if no commas and every whitespace-separated + # token is numeric, treat spaces as separators too ("1 3"). + if "," in text: + tokens = [t.strip() for t in text.split(",") if t.strip()] + else: + parts = text.split() + if len(parts) > 1 and all(p.strip().isdigit() for p in parts): + tokens = [p.strip() for p in parts] + else: + tokens = [text] + + selected: List[str] = [] + for token in tokens: + if token.isdigit(): + idx = int(token) - 1 + if 0 <= idx < len(choices): + label = str(choices[idx]).strip() + if label not in selected: + selected.append(label) + continue + return None # out-of-range number → reject whole reply + # Exact label match (case-insensitive) + matched = None + for choice in choices: + if token.casefold() == str(choice).strip().casefold(): + matched = str(choice).strip() + break + if matched is None: + return None + if matched not in selected: + selected.append(matched) + + if not selected: + return None + return _json.dumps(selected, ensure_ascii=False) + + def resolve_text_response_for_session(session_key: str, response: str) -> bool: """Resolve the oldest pending clarify in ``session_key`` from typed text. diff --git a/tools/clarify_tool.py b/tools/clarify_tool.py index e831d38fb4..88e9762ca7 100644 --- a/tools/clarify_tool.py +++ b/tools/clarify_tool.py @@ -6,6 +6,9 @@ Allows the agent to present structured multiple-choice questions or open-ended prompts to the user. In CLI mode, choices are navigable with arrow keys. On messaging platforms, choices are rendered as a numbered list. +Supports both single-select (radio) and multi-select (checkbox) modes via the +``multi_select`` parameter. + The actual user-interaction logic lives in the platform layer (cli.py for CLI, gateway/run.py for messaging). This module defines the schema, validation, and a thin dispatcher that delegates to a platform-provided callback. @@ -53,21 +56,82 @@ def _flatten_choice(c) -> str: return str(c).strip() +def _invoke_callback(callback, question, choices, multi_select): + """Invoke the platform callback, passing multi_select if supported. + + Uses signature inspection (not a ``TypeError`` retry) to decide whether + the callback accepts the ``multi_select`` keyword — a retry-on-TypeError + approach would re-invoke a *compatible* callback that raised TypeError + internally, potentially prompting the user twice. + """ + import inspect + + accepts_multi = False + try: + sig = inspect.signature(callback) + params = sig.parameters + accepts_multi = "multi_select" in params or any( + p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values() + ) + except (TypeError, ValueError): + # Builtins / C callables without introspectable signatures: + # be conservative and use the legacy 2-arg form. + accepts_multi = False + + if accepts_multi: + return callback(question, choices, multi_select=multi_select) + return callback(question, choices) + + +def _parse_multi_select_response(raw_response) -> List[str]: + """Parse a multi-select response into a list of cleaned choice strings. + + Handles three forms: + - Already a list → stringify + strip each element + - JSON array → parse and strip + - Comma-separated → split, strip, drop empties + """ + if isinstance(raw_response, list): + return [str(r).strip() for r in raw_response if str(r).strip()] + + raw = str(raw_response).strip() + + # Try JSON array + if raw.startswith("["): + try: + parsed = json.loads(raw) + if isinstance(parsed, list): + return [str(p).strip() for p in parsed if str(p).strip()] + except json.JSONDecodeError: + pass + + # Fall back to comma-separated + return [s.strip() for s in raw.split(",") if s.strip()] + + def clarify_tool( question: str, choices: Optional[List[str]] = None, + multi_select: bool = False, callback: Optional[Callable] = None, ) -> str: """ Ask the user a question, optionally with multiple-choice options. Args: - question: The question text to present. - choices: Up to 4 predefined answer choices. When omitted the - question is purely open-ended. - callback: Platform-provided function that handles the actual UI - interaction. Signature: callback(question, choices) -> str. - Injected by the agent runner (cli.py / gateway). + question: The question text to present. + choices: Up to 4 predefined answer choices. When omitted the + question is purely open-ended. + multi_select: When True, the user can select multiple choices + (checkboxes). The ``user_response`` in the output JSON + will be a list of strings instead of a single string. + Has no effect when ``choices`` is omitted. + callback: Platform-provided function that handles the actual UI + interaction. Signature: + ``callback(question, choices, multi_select=False) -> str``. + The optional ``multi_select`` keyword is passed so the + platform can render checkboxes instead of radio buttons. + Injected by the agent runner (cli.py / gateway). Returns: JSON string with the user's response. @@ -99,17 +163,22 @@ def clarify_tool( ) try: - user_response = callback(question, choices) + raw_response = _invoke_callback(callback, question, choices, multi_select) except Exception as exc: return json.dumps( {"error": f"Failed to get user input: {exc}"}, ensure_ascii=False, ) + if multi_select and choices is not None: + user_response = _parse_multi_select_response(raw_response) + else: + user_response = str(raw_response).strip() + return json.dumps({ "question": question, "choices_offered": choices, - "user_response": str(user_response).strip(), + "user_response": user_response, }, ensure_ascii=False) @@ -126,10 +195,12 @@ CLARIFY_SCHEMA = { "name": "clarify", "description": ( "Ask the user a question when you need clarification, feedback, or a " - "decision before proceeding. Supports two modes:\n\n" - "1. **Multiple choice** — provide up to 4 choices. The user picks one " + "decision before proceeding. Supports three modes:\n\n" + "1. **Single-select multiple choice** — provide up to 4 choices. The user picks one " "or types their own answer via a 5th 'Other' option.\n" - "2. **Open-ended** — omit choices entirely. The user types a free-form " + "2. **Multi-select multiple choice** — set multi_select=true. The user can select " + "multiple options via checkboxes. user_response will be a list of selected choices.\n" + "3. **Open-ended** — omit choices entirely. The user types a free-form " "response.\n\n" "CRITICAL: when you are offering options, put each option ONLY in the " "`choices` array — NEVER enumerate the options inside the `question` " @@ -169,6 +240,15 @@ CLARIFY_SCHEMA = { "entirely ONLY for a genuinely open-ended free-text question." ), }, + "multi_select": { + "type": "boolean", + "description": ( + "When true, the user can select MULTIPLE options (like checkboxes). " + "The user_response will be a list of selected choices. " + "When false (default), single selection (radio). " + "Has no effect when choices is omitted (open-ended question)." + ), + }, }, "required": ["question"], }, @@ -185,6 +265,7 @@ registry.register( handler=lambda args, **kw: clarify_tool( question=args.get("question", ""), choices=args.get("choices"), + multi_select=args.get("multi_select", False), callback=kw.get("callback")), check_fn=check_clarify_requirements, emoji="❓", diff --git a/tools/computer_use/cua_backend.py b/tools/computer_use/cua_backend.py index 98b98ec0be..79912814e4 100644 --- a/tools/computer_use/cua_backend.py +++ b/tools/computer_use/cua_backend.py @@ -557,18 +557,26 @@ def cua_driver_binary_available() -> bool: return resolve_cua_driver_cmd() is not None -def cua_driver_update_check(*, timeout: float = 8.0) -> Optional[Dict[str, Any]]: +def cua_driver_update_check(*, timeout: Optional[float] = None) -> Optional[Dict[str, Any]]: """Run ``cua-driver check-update --json`` and return its parsed state. The payload mirrors the ``check_for_update`` MCP tool: ``{current_version, latest_version, update_available, ...}``. + ``timeout`` defaults to 8s on POSIX and 25s on Windows — first-spawn of + the exe there routinely eats several seconds in Defender/SmartScreen + scanning, and a false timeout is expensive: callers treat ``None`` as + indeterminate, and the ``install_cua_driver(upgrade=True)`` path used to + fall through to a full multi-minute reinstall on it. + Returns ``None`` (callers should stay quiet) when the result is indeterminate: the binary is missing, the driver is too old to support the verb (it predates trycua/cua#1734), the GitHub check failed (an ``error`` field is set), or the output didn't parse. Best-effort; never raises. """ + if timeout is None: + timeout = 25.0 if sys.platform == "win32" else 8.0 driver_cmd = resolve_cua_driver_cmd() if not driver_cmd: return None diff --git a/tools/delegate_tool.py b/tools/delegate_tool.py index dc0e5181f4..67ff2caab5 100644 --- a/tools/delegate_tool.py +++ b/tools/delegate_tool.py @@ -2099,8 +2099,11 @@ def _run_single_child( _err = ( f"Subagent timed out after {child_timeout}s with " f"{child_api_calls} API call(s) completed — likely " - f"stuck on a slow API call or unresponsive network request." + f"stuck on a slow API call, tool call, or unresponsive " + f"network request." ) + if diagnostic_path: + _err += f" Diagnostic: {diagnostic_path}" else: _err = str(_timeout_exc) @@ -2112,6 +2115,13 @@ def _run_single_child( "exit_reason": "timeout" if is_timeout else "error", "api_calls": child_api_calls, "duration_seconds": duration, + "timeout_seconds": child_timeout if is_timeout else None, + "timed_out_after_seconds": duration if is_timeout else None, + "timeout_phase": ( + "before_first_llm_call" if is_timeout and child_api_calls == 0 + else "after_llm_calls" if is_timeout + else None + ), "_child_role": getattr(child, "_delegate_role", None), "diagnostic_path": diagnostic_path, } @@ -3062,6 +3072,38 @@ def delegate_task( except Exception: pass + def _batch_progress(): + # Progress token for the async registry's stale monitor: the + # combined (api_call_count, current_tool, last_activity_ts) of + # every child. last_activity_ts is ticked by _touch_activity on + # every streamed chunk ("receiving stream response"), every tool + # transition, and every API-call start/completion — so a child + # streaming a long response is alive even though api_call_count + # only advances when the call completes (same liveness signal as + # the compaction inactivity budget, PR #71508). A fully frozen + # token past the stale threshold means the detached batch is + # wedged (e.g. stuck inside the first model API call — #60203). + # in_tool=True while ANY child is inside a tool so legitimately + # slow tools get the higher staleness ceiling, mirroring the + # sync-path heartbeat monitor. + parts = [] + in_tool = False + for _c in _child_agents: + try: + _summary = _c.get_activity_summary() + _tool = _summary.get("current_tool") + parts.append( + ( + _summary.get("api_call_count", 0), + _tool, + _summary.get("last_activity_ts"), + ) + ) + in_tool = in_tool or bool(_tool) + except Exception: + parts.append(None) + return tuple(parts), in_tool + _goals = [t["goal"] for t in task_list] dispatch = dispatch_async_delegation_batch( goals=_goals, @@ -3081,6 +3123,7 @@ def delegate_task( # Reuse the live-transcript directory's id (when created) so the # returned delegation_id matches cache/delegation/live//. delegation_id=live_deleg_id, + progress_fn=_batch_progress, ) if dispatch.get("status") == "dispatched": diff --git a/tools/environments/base.py b/tools/environments/base.py index 74c33aff75..ffd891516b 100644 --- a/tools/environments/base.py +++ b/tools/environments/base.py @@ -397,7 +397,9 @@ def _cwd_marker(session_id: str) -> str: # set), not Hermes' per-turn session identity. # # Kept in sync with gateway.session_context._VAR_MAP: every bridged name starts -# with one of these prefixes. +# with one of these prefixes (or is HERMES_UI_SESSION_ID). Used by unit tests +# as the Python-side contract for the exclusion set; the dump path unsets by +# name/prefix instead of grepping declare lines (see below / issue #71296). _SNAPSHOT_EXCLUDED_ENV_REGEX = ( "^declare -x (HERMES_SESSION_|HERMES_UI_SESSION_ID|HERMES_CRON_AUTO_DELIVER_)" ) @@ -407,24 +409,31 @@ def _export_dump_excluding_session_vars(tmp_path: str) -> str: """Return a shell snippet that dumps ``export -p`` to *tmp_path* minus the per-session bridged vars (see ``_SNAPSHOT_EXCLUDED_ENV_REGEX``). - ``export -p`` emits one ``declare -x NAME="value"`` line per exported var. - We drop the HERMES_SESSION_* / UI / CRON_AUTO_DELIVER lines so they never - persist across sessions in the shared snapshot. ``grep -vE`` returns exit 1 - when it filters everything, so ``|| true`` keeps the pipeline's success - contract intact for the callers that chain on it. + Unset the bridged vars in a subshell *before* ``export -p``. A line-based + ``grep -vE`` filter is unsafe: bash 3.2 prints a value containing a newline + as a multi-line ``declare -x NAME="…`` block, so only the opener matches the + regex and continuation lines (e.g. ``curl … | bash #`` smuggled into a + Matrix room/display name via ``HERMES_SESSION_CHAT_NAME``) land in the + snapshot and execute on the next ``source`` (issue #71296). Unsetting first + means ``export -p`` never emits those vars — including any continuation + lines. ``|| true`` keeps the success contract for callers that chain on it. - The pipeline MUST be wrapped in a brace group with the redirection applied - to the group, not to the last pipeline segment. *tmp_path* typically embeds - ``$BASHPID`` for concurrency-safe temp names; a redirection attached - directly to ``grep`` is expanded inside grep's own pipeline subshell, where - ``$BASHPID`` resolves to the grep subshell's PID — while the caller's - follow-up ``mv $tmp`` expands in the parent shell to a DIFFERENT PID. The - dump then lands in an orphaned temp file and the snapshot silently never - updates (all exported-env persistence breaks). The brace-group redirect is - expanded in the current shell, keeping both expansions consistent. + The dump MUST be wrapped in a brace group with the redirection applied to + the group. *tmp_path* typically embeds ``$BASHPID`` for concurrency-safe + temp names; a redirection attached to a pipeline segment would expand + ``$BASHPID`` inside that segment's subshell (a different PID than the + parent that expands the follow-up ``mv``), silently orphaning the dump. + The brace-group redirect is expanded in the current shell, keeping both + expansions consistent. """ + # ${!PREFIX*} is bash 3.2+ name-prefix expansion; empty matches are fine + # because ``unset`` with only missing names is ignored under 2>/dev/null. return ( - f"{{ export -p | grep -vE '{_SNAPSHOT_EXCLUDED_ENV_REGEX}' || true; }} " + "{ ( " + "unset ${!HERMES_SESSION_*} ${!HERMES_CRON_AUTO_DELIVER_*} " + "HERMES_UI_SESSION_ID 2>/dev/null; " + "export -p; " + ") || true; } " f"> {tmp_path}" ) @@ -689,11 +698,11 @@ class BaseEnvironment(ABC): # Chain mv on the export succeeding so a failed/partial dump never # replaces a good snapshot; drop the temp on failure so it isn't # orphaned (cleaned up wholesale in LocalEnvironment.cleanup too). - # NOTE: the redirection must be attached to a brace group, not to the - # grep pipeline segment — ``_snap_tmp`` embeds ``$BASHPID``, and a - # redirect on grep is expanded inside grep's pipeline subshell (a - # different PID than the parent shell that expands the ``mv`` operand), - # silently orphaning the dump. See _export_dump_excluding_session_vars. + # NOTE: the redirection must be attached to a brace group — ``_snap_tmp`` + # embeds ``$BASHPID``, and a redirect on a pipeline segment expands + # inside that segment's subshell (a different PID than the parent that + # expands the ``mv`` operand), silently orphaning the dump. See + # _export_dump_excluding_session_vars. if self._snapshot_ready: parts.append( f"{{ {_export_dump_excluding_session_vars(_snap_tmp)} " diff --git a/tools/kanban_tools.py b/tools/kanban_tools.py index 46991b4a47..c3188a1989 100644 --- a/tools/kanban_tools.py +++ b/tools/kanban_tools.py @@ -1272,10 +1272,10 @@ def _maybe_auto_subscribe(conn: Any, task_id: str) -> bool: Subscription paths: - - **Gateway** (telegram/discord/slack/etc): ``HERMES_SESSION_PLATFORM`` - and ``HERMES_SESSION_CHAT_ID`` are set in ContextVars by the - messaging gateway before agent dispatch. The notification poller - already keys off these, so we just register a row. + - **Gateway** (telegram/discord/slack/etc): ``HERMES_SESSION_PLATFORM``, + ``HERMES_SESSION_CHAT_ID``, and ``HERMES_SESSION_CHAT_TYPE`` are set in + ContextVars by the messaging gateway before agent dispatch. The + notification poller already keys off these, so we just register a row. - **TUI** (herm desktop / herm TUI): the platform/chat_id ContextVars are intentionally cleared (TUI is a single-channel local UI, not @@ -1333,18 +1333,43 @@ def _maybe_auto_subscribe(conn: Any, task_id: str) -> bool: chat_id = session_key thread_id = get_session_env("HERMES_SESSION_THREAD_ID", "") or None user_id = get_session_env("HERMES_SESSION_USER_ID", "") or None + chat_type = get_session_env("HERMES_SESSION_CHAT_TYPE", "") or None + message_id = get_session_env("HERMES_SESSION_MESSAGE_ID", "") or "" notifier_profile = ( get_session_env("HERMES_SESSION_PROFILE", "") or os.environ.get("HERMES_PROFILE") ) + if not notifier_profile: + try: + from hermes_cli.profiles import get_active_profile_name + notifier_profile = get_active_profile_name() or "default" + except Exception: + notifier_profile = "default" + delivery_metadata: dict[str, Any] = {} + if thread_id: + delivery_metadata["thread_id"] = thread_id + if chat_type: + delivery_metadata["chat_type"] = chat_type + if ( + platform.lower() == "telegram" + and thread_id + and (chat_type or "").lower() in {"dm", "direct", "private"} + ): + delivery_metadata["telegram_dm_topic_reply_fallback"] = True + if str(thread_id) not in {"", "1"}: + delivery_metadata["direct_messages_topic_id"] = str(thread_id) + if message_id: + delivery_metadata["telegram_reply_to_message_id"] = str(message_id) # Lazy-import to keep the module-level dependency light from hermes_cli import kanban_db as _kb _kb.add_notify_sub( conn, task_id=task_id, platform=platform, chat_id=chat_id, + chat_type=chat_type, thread_id=thread_id, user_id=user_id, notifier_profile=notifier_profile, + delivery_metadata=delivery_metadata or None, ) return True except Exception as _exc: diff --git a/tools/lazy_deps.py b/tools/lazy_deps.py index 1c119aabca..0cabac21b2 100644 --- a/tools/lazy_deps.py +++ b/tools/lazy_deps.py @@ -222,8 +222,8 @@ LAZY_DEPS: dict[str, tuple[str, ...]] = { "tool.dashboard": ( "fastapi==0.133.1", "uvicorn[standard]==0.41.0", - "starlette==1.0.1", # CVE-2026-48710 (BadHost) — keep lazy-install in sync with pyproject [web] - "python-multipart==0.0.27", # FastAPI UploadFile/Form for streaming uploads (NS-501) + "starlette==1.3.1", # CVE-2026-48710 (BadHost) — keep lazy-install in sync with pyproject [web] + "python-multipart==0.0.32", # FastAPI UploadFile/Form for streaming uploads (NS-501) ), # Vision image-resize recovery (Pillow). Pillow is now a CORE dependency # (pyproject `dependencies`), so this entry is a belt-and-suspenders fallback @@ -238,10 +238,23 @@ LAZY_DEPS: dict[str, tuple[str, ...]] = { # installs so computer_use never dead-ends on `No module named 'mcp'`. "tool.computer_use": ( "mcp==1.26.0", - "starlette==1.0.1", # CVE-2026-48710 — keep in sync with pyproject [computer-use] + "starlette==1.3.1", # CVE-2026-48710 — keep in sync with pyproject [computer-use] ), # HF Agent Trace Viewer upload (hermes trace upload / /upload-trace). - "tool.trace_upload": ("huggingface-hub==1.2.3",), + # + # huggingface-hub is a SHARED dependency: transformers (pulled by + # sentence-transformers for local Hindsight embeddings) requires + # >=1.5.0,<2, and faster-whisper/tokenizers depend on it transitively. + # Because active_features() marks a feature active from mere package + # presence, the `hermes update` lazy-refresh pass re-asserts THIS pin on + # every install where hub is present — so an exact pin below 1.5.0 + # force-downgrades the shared package and breaks Hindsight startup + # (#60783). Policy: keep the exact pin (no ranges — security posture), + # but it MUST stay inside transformers' accepted window and MUST match + # uv.lock so the whole tree converges on ONE hub version + # (tests/test_project_metadata.py enforces both). When bumping: update + # here AND `uv lock --upgrade-package huggingface-hub` in lockstep. + "tool.trace_upload": ("huggingface-hub==1.24.0",), } @@ -864,8 +877,12 @@ def feature_install_command(feature: str) -> Optional[str]: def active_features() -> list[str]: """Return the list of features the user has ever lazy-installed. - A feature counts as "active" if at least one of its declared packages - is currently installed in the venv (presence check, ignoring version). + A feature counts as "active" if its anchor package (the first declared + spec) is currently installed in the venv (presence check, ignoring + version). We intentionally do NOT treat shared helper packages as proof + that a backend was enabled: for example ``platform.matrix`` depends on + generic packages like ``asyncpg``/``aiosqlite`` that can be installed for + unrelated reasons, while the actual Matrix adapter anchor is ``mautrix``. Features the user has never enabled stay quiet. Used by ``hermes update`` to figure out which lazy backends need a @@ -873,7 +890,7 @@ def active_features() -> list[str]: """ active = [] for feature, specs in LAZY_DEPS.items(): - if any(_is_present(s) for s in specs): + if specs and _is_present(specs[0]): active.append(feature) return active diff --git a/tools/send_message_tool.py b/tools/send_message_tool.py index 9c1d41eaf0..809a522f67 100644 --- a/tools/send_message_tool.py +++ b/tools/send_message_tool.py @@ -62,7 +62,7 @@ _EMAIL_TARGET_RE = re.compile(r"^\s*[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2 # never read. Map the exceptions so the error guidance is actually actionable. _HOME_CHANNEL_ENV_OVERRIDES = {"email": "EMAIL_HOME_ADDRESS"} _IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".gif"} -_VIDEO_EXTS = {".mp4", ".mov", ".avi", ".mkv", ".3gp"} +_VIDEO_EXTS = {".mp4", ".mov", ".avi", ".mkv", ".webm", ".3gp"} _AUDIO_EXTS = {".ogg", ".opus", ".mp3", ".wav", ".m4a", ".flac"} _VOICE_EXTS = {".ogg", ".opus"} # Telegram's Bot API sendAudio only accepts MP3 / M4A. Other audio diff --git a/tools/session_search_tool.py b/tools/session_search_tool.py index e305467f05..99a9684c28 100644 --- a/tools/session_search_tool.py +++ b/tools/session_search_tool.py @@ -160,6 +160,25 @@ def _is_compression_ended(db, session_id: str) -> bool: return False +def _get_message_storage_state(db, message_id) -> Optional[Dict[str, Any]]: + """Return the owning session and visibility flags for *message_id*.""" + if not message_id: + return None + try: + with db._lock: + cursor = db._conn.execute( + "SELECT session_id, active, compacted FROM messages WHERE id = ?", + (message_id,), + ) + row = cursor.fetchone() + except Exception: + logging.debug( + "message storage-state lookup failed for %s", message_id, exc_info=True + ) + return None + return dict(row) if row is not None else None + + def _is_compacted_message(db, message_id) -> bool: """Return True if *message_id* is a compaction-archived row. @@ -173,18 +192,8 @@ def _is_compacted_message(db, message_id) -> bool: Returns False on any error so the caller falls back to the safe default (skip the current session). """ - if not message_id: - return False - try: - with db._lock: - cursor = db._conn.execute( - "SELECT active, compacted FROM messages WHERE id = ?", (message_id,) - ) - row = cursor.fetchone() - except Exception: - logging.debug("is_compacted_message lookup failed for %s", message_id, exc_info=True) - return False - return row is not None and row["active"] == 0 and row["compacted"] == 1 + state = _get_message_storage_state(db, message_id) + return state is not None and state["active"] == 0 and state["compacted"] == 1 def _annotate_rebuild_status(db, payload: Dict[str, Any]) -> None: @@ -481,16 +490,40 @@ def _scroll( window = 5 window = max(1, min(window, 20)) - # Reject scrolling inside the active session lineage — those messages are - # already in context. + # Locate the anchor before applying the current-lineage guard. Discovery + # intentionally surfaces two kinds of same-lineage history that are no + # longer in live context: in-place compacted rows, and rows owned by a + # legacy session that ended via compression. Scroll must preserve that + # distinction instead of rejecting the discovery result it just returned. + anchor_state = _get_message_storage_state(db, around_message_id) + owning_session_id = ( + anchor_state.get("session_id") if anchor_state is not None else None + ) + if current_session_id: - a_root = _resolve_lineage(db, session_id) + anchor_session_id = owning_session_id or session_id + a_root = _resolve_lineage(db, anchor_session_id) c_root = _resolve_lineage(db, current_session_id) if a_root and c_root and a_root == c_root: - return tool_error( - "scroll rejected: anchor lives in the current session lineage (already in your active context)", - success=False, + is_compacted_anchor = ( + anchor_state is not None + and anchor_state["active"] == 0 + and anchor_state["compacted"] == 1 ) + is_inactive_non_compacted_anchor = ( + anchor_state is not None + and anchor_state["active"] == 0 + and anchor_state["compacted"] != 1 + ) + is_compression_history = ( + not is_inactive_non_compacted_anchor + and _is_compression_ended(db, anchor_session_id) + ) + if not (is_compacted_anchor or is_compression_history): + return tool_error( + "scroll rejected: anchor lives in the current session lineage (already in your active context)", + success=False, + ) # Session existence check try: @@ -515,18 +548,7 @@ def _scroll( # child sessions). Locate the real owning session and refetch. rebind_warning = None if not messages: - owning = None - try: - conn = getattr(db, "_conn", None) - if conn is not None: - row = conn.execute( - "SELECT session_id FROM messages WHERE id = ?", - (around_message_id,), - ).fetchone() - owning = row[0] if row else None - except Exception as e: - logging.debug("owning-session lookup failed: %s", e, exc_info=True) - owning = None + owning = owning_session_id if owning and owning != session_id: a_root = _resolve_lineage(db, session_id) o_root = _resolve_lineage(db, owning) diff --git a/tools/skills_hub.py b/tools/skills_hub.py index bb44e5e686..ab186b403d 100644 --- a/tools/skills_hub.py +++ b/tools/skills_hub.py @@ -3742,7 +3742,22 @@ def check_for_skill_updates( for entry in installed: identifier = entry.get("identifier", "") source_name = entry.get("source", "") - candidate_sources = [src for src in sources if _source_matches(src, source_name)] or sources + candidate_sources = [src for src in sources if _source_matches(src, source_name)] + if not candidate_sources: + # No adapter for the recorded source (e.g. a tap was removed, or the + # source was renamed upstream). Previously this fell back to *all* + # sources, which meant a same-named skill in a DIFFERENT registry + # could satisfy the fetch and be reported as an update for this + # entry -- silently reassigning provenance. Skill names are not + # namespaced across registries, so that fallback is unsafe by + # construction. Report unavailable instead and let the user decide. + results.append({ + "name": entry.get("name", ""), + "identifier": identifier, + "source": source_name, + "status": "unavailable", + }) + continue bundle = None for src in candidate_sources: diff --git a/tools/working_diff.py b/tools/working_diff.py new file mode 100644 index 0000000000..cc0d0df101 --- /dev/null +++ b/tools/working_diff.py @@ -0,0 +1,130 @@ +"""Working-tree git diff collection shared by the CLI and gateway ``/diff``. + +The ``/diff`` slash command answers "what changed here?" on every surface. +This module holds the surface-agnostic collection logic so the CLI (colored +terminal output) and the gateway (fenced, truncated messages) render the same +underlying data. + +Modes +----- +- ``working`` (default): unstaged changes plus untracked files — what you'd + lose with ``git checkout . && git clean -fd``. +- ``staged``: changes already staged for commit (``git diff --cached``). +- ``all``: everything since HEAD (staged + unstaged) plus untracked files. + +Untracked files are folded in via ``git diff --no-index /dev/null `` so +brand-new files show up as additions instead of being silently invisible +(mirrors Codex CLI's ``/diff`` behaviour). +""" + +from __future__ import annotations + +import os +import shutil +import subprocess +from typing import Dict, List + +_GIT_TIMEOUT = 15 +_MAX_UNTRACKED_FILES = 50 # sanity cap so a node_modules explosion can't hang us + +VALID_MODES = ("working", "staged", "all") + + +def _run(args: List[str], cwd: str, timeout: int = _GIT_TIMEOUT): + """Run git, returning (returncode, stdout). Never raises on git failure.""" + proc = subprocess.run( + ["git", "-c", "core.quotePath=false", *args], + cwd=cwd, capture_output=True, text=True, timeout=timeout, + ) + return proc.returncode, proc.stdout + + +def _untracked_files(cwd: str) -> List[str]: + code, out = _run(["ls-files", "--others", "--exclude-standard"], cwd) + if code != 0: + return [] + return [line for line in out.splitlines() if line.strip()] + + +def _untracked_diff(cwd: str, files: List[str]) -> str: + """Render untracked files as new-file diffs via ``git diff --no-index``.""" + chunks: List[str] = [] + for rel in files[:_MAX_UNTRACKED_FILES]: + try: + # --no-index exits 1 when the files differ — that's the success + # path here, so ignore the return code and keep the output. + _, out = _run( + ["diff", "--no-index", "--", os.devnull, rel], cwd, + ) + if out.strip(): + chunks.append(out.rstrip("\n")) + except (subprocess.TimeoutExpired, OSError): + continue + if len(files) > _MAX_UNTRACKED_FILES: + chunks.append( + f"... ({len(files) - _MAX_UNTRACKED_FILES} more untracked files not shown)" + ) + return "\n".join(chunks) + + +def collect_working_diff(cwd: str, mode: str = "working", + paths: List[str] | None = None) -> Dict: + """Collect a git diff of the working directory. + + Returns ``{"success", "stat", "diff", "untracked", "empty"}`` on success or + ``{"success": False, "error": ...}`` when git is unavailable / not a repo. + ``paths`` optionally restricts the diff to specific pathspecs (passed + through to git verbatim, so quoted paths with spaces survive). + """ + if mode not in VALID_MODES: + return {"success": False, + "error": f"Unknown mode '{mode}'. Use: {', '.join(VALID_MODES)}"} + + if not shutil.which("git"): + return {"success": False, "error": "git is not installed or not on PATH."} + + try: + code, _ = _run(["rev-parse", "--is-inside-work-tree"], cwd, timeout=5) + except (subprocess.TimeoutExpired, OSError) as e: + return {"success": False, "error": f"git failed: {e}"} + if code != 0: + return {"success": False, "error": "Not a git repository."} + + if mode == "staged": + base_args = ["diff", "--cached"] + elif mode == "all": + base_args = ["diff", "HEAD"] + else: # working + base_args = ["diff"] + + pathspec = ["--", *paths] if paths else [] + + try: + _, stat_out = _run([*base_args, "--stat", *pathspec], cwd) + _, diff_out = _run([*base_args, *pathspec], cwd, timeout=_GIT_TIMEOUT * 2) + + untracked: List[str] = [] + untracked_diff = "" + if mode in ("working", "all") and not paths: + untracked = _untracked_files(cwd) + if untracked: + untracked_diff = _untracked_diff(cwd, untracked) + except subprocess.TimeoutExpired: + return {"success": False, "error": "git diff timed out."} + except OSError as e: + return {"success": False, "error": f"git failed: {e}"} + + stat = stat_out.strip() + diff = diff_out.strip() + if untracked_diff: + diff = f"{diff}\n{untracked_diff}".strip() + + result = { + "success": True, + "stat": stat, + "diff": diff, + "untracked": untracked, + } + if not stat and not diff and not untracked: + result["empty"] = True + return result diff --git a/tui_gateway/compute_host.py b/tui_gateway/compute_host.py index 102d8e6d47..d1c46dd9c2 100644 --- a/tui_gateway/compute_host.py +++ b/tui_gateway/compute_host.py @@ -436,12 +436,15 @@ class ComputeHost: profile_home = str(frame.get("profile_home") or "") session_db = None home_token = None + secret_token = None try: if profile_home: from hermes_constants import set_hermes_home_override + from agent.secret_scope import build_profile_secret_scope, set_secret_scope from hermes_state import SessionDB home_token = set_hermes_home_override(profile_home) + secret_token = set_secret_scope(build_profile_secret_scope(Path(profile_home))) session_db = SessionDB(db_path=Path(profile_home) / "state.db") agent = server._make_agent( sid, @@ -457,8 +460,10 @@ class ComputeHost: if home_token is not None: try: from hermes_constants import reset_hermes_home_override + from agent.secret_scope import reset_secret_scope reset_hermes_home_override(home_token) + reset_secret_scope(secret_token) except Exception: pass try: diff --git a/tui_gateway/entry.py b/tui_gateway/entry.py index e4c87be4a1..bf41c12018 100644 --- a/tui_gateway/entry.py +++ b/tui_gateway/entry.py @@ -24,20 +24,23 @@ from tui_gateway.transport import TeeTransport logger = logging.getLogger(__name__) -# Handle for the background MCP tool-discovery thread (see main()). The first -# agent build briefly joins this so already-spawning fast servers land before -# the agent snapshots its tool list (see wait_for_mcp_discovery). +# Handle for the background MCP tool-discovery thread (see +# ensure_mcp_discovery_started). The first agent build briefly joins this so +# already-spawning fast servers land before the agent snapshots its tool list +# (see wait_for_mcp_discovery). Stays None when discovery is delegated to the +# shared owner in hermes_cli.mcp_startup — the wait/in-flight/join helpers +# below consult both owners. _mcp_discovery_thread = None -# True once main() decided this TUI process has MCP servers configured and -# spawned discovery through the shared owner. Lets wait_for_mcp_discovery -# re-invoke the (idempotent) spawn on later agent builds so the -# retry-after-zero-connected allowance in -# hermes_cli.mcp_startup.start_background_mcp_discovery can actually fire for -# the stdio TUI — without this, main()'s single spawn is the only call and a -# first run that connected nothing latches the process MCP-less. Kept as a -# flag (rather than re-probing config) so non-MCP sessions never pay the -# tools.mcp_tool import on the per-agent-build wait path. +# True once ensure_mcp_discovery_started decided this process has MCP servers +# configured and spawned discovery through the shared owner. Lets +# wait_for_mcp_discovery re-invoke the (idempotent) spawn on later agent +# builds so the retry-after-zero-connected allowance in +# hermes_cli.mcp_startup.start_background_mcp_discovery can actually fire — +# without this, the single spawn is the only call and a first run that +# connected nothing latches the process MCP-less. Kept as a flag (rather than +# re-probing config) so non-MCP sessions never pay the tools.mcp_tool import +# on the per-agent-build wait path. _mcp_discovery_enabled = False @@ -243,17 +246,18 @@ def wait_for_mcp_discovery(timeout: "float | None" = None) -> None: bound = timeout if timeout is not None else 0.75 thread.join(timeout=bound) return - # The stdio TUI spawns discovery via the shared owner (see main()); wait - # on it so the first agent build still catches fast servers. Re-invoke - # the idempotent spawn first: if the previous run finished with zero - # connected servers, start_background_mcp_discovery's - # retry-after-zero-connected allowance kicks off a fresh discovery run - # here instead of leaving the TUI latched MCP-less for the session. - # Only the stdio TUI (which spawned discovery through the shared owner) - # should delegate to the startup wait here — for every other surface - # (dashboard /api/ws) _make_agent already calls - # hermes_cli.mcp_startup.wait_for_mcp_discovery directly, and delegating - # unconditionally would make that bounded wait run twice per agent build. + # Discovery is spawned via the shared owner (ensure_mcp_discovery_started + # → hermes_cli.mcp_startup); wait on it so the first agent build still + # catches fast servers. Re-invoke the idempotent spawn first: if the + # previous run finished with zero connected servers, + # start_background_mcp_discovery's retry-after-zero-connected allowance + # kicks off a fresh discovery run here instead of leaving the process + # latched MCP-less for the session. In multi-profile processes this + # retry runs under the CALLER's profile context (agent build binds the + # session profile's HERMES_HOME first), so a launch profile with no + # mcp_servers no longer starves selected profiles of discovery (#67605). + # Gated on _mcp_discovery_enabled so non-MCP sessions never pay the + # tools.mcp_tool import on the per-agent-build wait path. if not _mcp_discovery_enabled: return try: @@ -338,57 +342,71 @@ def join_mcp_discovery(timeout: float | None = None) -> bool: _recovery_times: list[float] = [] + +def _has_configured_mcp_servers() -> bool: + """Return whether startup should attempt MCP discovery. + + Keep this cheap so non-MCP users do not pay the MCP SDK import cost. + """ + try: + from hermes_cli.config import read_raw_config + + mcp_servers = (read_raw_config() or {}).get("mcp_servers") + return isinstance(mcp_servers, dict) and len(mcp_servers) > 0 + except Exception: + # Be conservative: if we can't decide, fall back to attempting + # discovery. The caller starts it in the background. + return True + + +def ensure_mcp_discovery_started() -> None: + """Start background MCP discovery for the current profile context, once. + + ``main()`` calls this for the stdio/TUI path. WebSocket/Desktop + entrypoints can accept sessions without running ``main()``, so the + agent-build path (``server._start_agent_build``) also calls it AFTER + binding the session profile's HERMES_HOME override — the shared owner in + ``hermes_cli.mcp_startup`` captures the caller's context-local override + and propagates it into the discovery thread, so discovery reads the + SELECTED profile's ``mcp_servers``, not the launch profile's (#67605). + + Delegating to the shared owner (instead of a hand-rolled thread) keeps + the process-wide start lock, the retry-after-zero-connected allowance, + and interactive-OAuth suppression. + + Known limitation: MCP tool registration is process-global, so in a + multi-profile process the FIRST profile that builds an agent wins the + discovery slot. Full per-profile MCP registries are tracked in #67605. + """ + global _mcp_discovery_enabled + + if not _has_configured_mcp_servers(): + return + _mcp_discovery_enabled = True + try: + from hermes_cli.mcp_startup import start_background_mcp_discovery + + start_background_mcp_discovery( + logger=logger, thread_name="tui-mcp-discovery" + ) + except Exception: + logger.warning( + "Background MCP tool discovery failed to start", exc_info=True + ) + + def main(): _install_sidecar_publisher() - # MCP tool discovery — runs in a background daemon thread so a slow or - # unreachable MCP server can't freeze TUI startup. Previously this ran - # inline before ``gateway.ready``, which meant any configured-but-down - # server stalled the whole shell on "summoning hermes…" for the full - # connect-retry backoff (e.g. a dead stdio/http server burns 1+2+4s of - # retries → ~7s of dead air before the composer appears). Discovery is - # idempotent and registers tools into the shared registry as servers - # connect. The agent isn't built until the first prompt, at which point - # ``_make_agent`` briefly joins this thread (``wait_for_mcp_discovery``, - # bounded) so already-spawning fast servers land in the tool snapshot — - # a dead server is simply not waited on past the bound. ``/reload-mcp`` - # rebuilds the snapshot for servers that connect later in the session. - # - # Cold-start guard: importing ``tools.mcp_tool`` transitively pulls the - # full MCP SDK (mcp, pydantic, httpx, jsonschema, starlette parsers — - # ~200ms on macOS). The overwhelming majority of users have no - # ``mcp_servers`` configured, in which case every byte of that import is - # wasted. Check the config first (cheap) and only spawn the discovery - # thread when there's actually MCP work to do, so the import cost stays - # off the path entirely for the common case. - try: - from hermes_cli.config import read_raw_config - _mcp_servers = (read_raw_config() or {}).get("mcp_servers") - _has_mcp_servers = isinstance(_mcp_servers, dict) and len(_mcp_servers) > 0 - except Exception: - # Be conservative: if we can't decide, fall back to attempting - # discovery (still backgrounded, so it can't block startup). - _has_mcp_servers = True - if _has_mcp_servers: - # Spawn via the shared owner in hermes_cli.mcp_startup instead of - # a hand-rolled thread, so the stdio TUI gets the same restart - # semantics as every other surface: a discovery run that completed - # with zero connected servers may be retried by a later spawn call - # instead of latching the process into a no-MCP-tools state. - # wait_for_mcp_discovery/mcp_discovery_in_flight/ - # join_mcp_discovery below already consult that owner. - global _mcp_discovery_enabled - _mcp_discovery_enabled = True - try: - from hermes_cli.mcp_startup import start_background_mcp_discovery - - start_background_mcp_discovery( - logger=logger, thread_name="tui-mcp-discovery" - ) - except Exception: - logger.warning( - "Background MCP tool discovery failed to start", exc_info=True - ) + # MCP tool discovery — backgrounded so a slow or unreachable MCP server + # can't freeze TUI startup (a dead stdio/http server burns 1+2+4s of + # connect retries → ~7s of dead air before the composer appears). The + # agent isn't built until the first prompt, at which point _make_agent + # briefly joins the discovery thread (wait_for_mcp_discovery, bounded) so + # already-spawning fast servers land in the tool snapshot. The config + # gate inside ensure_mcp_discovery_started keeps the ~200ms MCP SDK + # import cost entirely off the path for users with no mcp_servers. + ensure_mcp_discovery_started() if not write_json({ "jsonrpc": "2.0", diff --git a/tui_gateway/server.py b/tui_gateway/server.py index d5277dadca..46fe7bb0fb 100644 --- a/tui_gateway/server.py +++ b/tui_gateway/server.py @@ -18,6 +18,11 @@ from datetime import datetime from pathlib import Path from typing import Any, NamedTuple, Optional +from agent.secret_scope import ( + build_profile_secret_scope, + reset_secret_scope, + set_secret_scope, +) from hermes_constants import ( get_hermes_home, get_hermes_home_override, @@ -1840,6 +1845,7 @@ def _start_agent_build(sid: str, session: dict) -> None: worker = None notify_registered = False home_token = None + secret_token = None profile_home = current.get("profile_home") try: tokens = _set_session_context(key) @@ -1849,12 +1855,26 @@ def _start_agent_build(sid: str, session: dict) -> None: session_db = None if profile_home: home_token = set_hermes_home_override(profile_home) + try: + from agent.secret_scope import build_profile_secret_scope, set_secret_scope + + secret_token = set_secret_scope(build_profile_secret_scope(Path(profile_home))) + except Exception: + pass try: from hermes_state import SessionDB session_db = SessionDB(db_path=Path(profile_home) / "state.db") except Exception: session_db = None + + try: + from tui_gateway.entry import ensure_mcp_discovery_started + + ensure_mcp_discovery_started() + except Exception: + logger.warning("MCP discovery startup failed", exc_info=True) + try: # Lazy-resumed (watch) sessions carry the stored conversation # id — pass it through so the upgrade continues that session @@ -1961,6 +1981,13 @@ def _start_agent_build(sid: str, session: dict) -> None: finally: if home_token is not None: reset_hermes_home_override(home_token) + if secret_token is not None: + try: + from agent.secret_scope import reset_secret_scope + + reset_secret_scope(secret_token) + except Exception: + pass # _attach_worker already closed the worker if this session was # reaped mid-build; only the late notify registration can still # leak (session.close unregistered before _build registered it). @@ -4503,10 +4530,20 @@ def _session_info(agent, session: dict | None = None) -> dict: def _tool_ctx(name: str, args: dict) -> str: - try: - from agent.display import build_tool_label + """Argument preview for a tool row — never a phrased label. - return build_tool_label(name, args, max_len=80) or "" + Clients own their own phrasing: the TUI wraps this as ``Terminal("...")`` + and the desktop prepends its own localized verb ("Running"/"Ran"). Sending + ``build_tool_label`` here instead of the raw preview stutters the verb on + both surfaces ("Running Running sleep 70 + 2 commands") and leaks a display + label into the desktop's ``args.context``, where it stands in for the real + command. The friendly labels belong on the CLI spinner, which builds them + from ``build_tool_label`` at its own call sites. + """ + try: + from agent.display import build_tool_preview + + return build_tool_preview(name, args, max_len=80) or "" except Exception: return "" @@ -5003,10 +5040,19 @@ def _agent_cbs(sid: str) -> dict: "notice_clear_callback": lambda key: _emit( "notification.clear", sid, {"key": key} ), - "clarify_callback": lambda q, c: _block( + "clarify_callback": lambda q, c, multi_select=False: _block( "clarify.request", sid, - {"question": q, "choices": c}, + # multi_select is a pass-through hint: renderers with checkbox + # support can honor it; older renderers ignore the extra field + # and stay single-select (a single answer still parses as a + # one-element list on the tool side). Only emitted when True so + # single-select payloads keep the exact pre-multi-select shape. + ( + {"question": q, "choices": c, "multi_select": True} + if multi_select + else {"question": q, "choices": c} + ), timeout=_clarify_timeout_seconds(), ), # read_terminal tool (desktop GUI): same blocking bridge as clarify — the @@ -5757,7 +5803,7 @@ def _make_agent( _pr = _load_provider_routing() return AIAgent( model=model, - max_iterations=_cfg_max_turns(cfg, 90), + max_iterations=_cfg_max_turns(cfg, 500), provider=runtime.get("provider"), base_url=runtime.get("base_url"), api_key=runtime.get("api_key"), @@ -6347,16 +6393,25 @@ def _append_inflight_delta(session: dict, delta: Any) -> None: session["inflight_turn"] = turn -def _replace_inflight_user(session: dict, text: Any) -> None: - """Reflect an accepted correction as the live turn's current user text.""" - user = _inflight_text(text) - if not user: +def _record_inflight_correction(session: dict, text: Any) -> None: + """Record an accepted mid-turn correction on the live turn. + + The correction is appended, never written over ``user``: a resuming client + must be able to rebuild BOTH bubbles. Overwriting the slot erased the + prompt that started the turn from the only snapshot resume can read, so a + reconnect (or a dev hot-reload that wipes the renderer cache) repainted the + thread with the user's original message missing. + """ + correction = _inflight_text(text) + if not correction: return turn = session.get("inflight_turn") if not isinstance(turn, dict): return turn = dict(turn) - turn["user"] = user + corrections = list(turn.get("corrections") or []) + corrections.append(correction) + turn["corrections"] = corrections turn["updated_at"] = time.time() session["inflight_turn"] = turn @@ -6649,7 +6704,7 @@ def _handle_busy_submit( try: if agent.redirect(plain_text): with session["history_lock"]: - _replace_inflight_user(session, plain_text) + _record_inflight_correction(session, plain_text) session["last_active"] = time.time() return _ok(rid, {"status": "redirected"}) except Exception: @@ -6720,6 +6775,11 @@ def _inflight_snapshot(session: dict) -> dict | None: "streaming": streaming, "user": user, } + corrections = [c for c in (turn.get("corrections") or []) if str(c).strip()] + if corrections: + # Mid-turn redirects. Carried alongside the original prompt (not over + # it) so resume can rebuild every user bubble the turn produced. + snapshot["corrections"] = [str(c) for c in corrections] if error: # Retained failed turn (see _fail_inflight_turn): carry the error # semantics so a resuming client can rebuild the failed-turn bubble @@ -7055,6 +7115,7 @@ def _(rid, params: dict) -> dict: @method("verification.status") +@_profile_scoped def _(rid, params: dict) -> dict: """Best known coding verification evidence for a cwd/session. @@ -7461,6 +7522,11 @@ def _(rid, params: dict) -> dict: home_token = ( set_hermes_home_override(str(profile_home)) if profile_home is not None else None ) + secret_token = ( + set_secret_scope(build_profile_secret_scope(Path(str(profile_home)))) + if profile_home is not None + else None + ) try: db.reopen_session(target) # One lineage SELECT feeds both projections (see the interactive resume @@ -7502,6 +7568,8 @@ def _(rid, params: dict) -> dict: finally: if home_token is not None: reset_hermes_home_override(home_token) + if secret_token is not None: + reset_secret_scope(secret_token) # Double-checked locking: another concurrent resume may have created the # live session while we were building. Re-check under the lock; if it won, @@ -7532,6 +7600,11 @@ def _(rid, params: dict) -> dict: if profile_home is not None else None ) + init_secret_token = ( + set_secret_scope(build_profile_secret_scope(Path(str(profile_home)))) + if profile_home is not None + else None + ) try: _init_session( sid, @@ -7546,6 +7619,8 @@ def _(rid, params: dict) -> dict: finally: if init_home_token is not None: reset_hermes_home_override(init_home_token) + if init_secret_token is not None: + reset_secret_scope(init_secret_token) if sid in _sessions: if stored_runtime_overrides.get("model_override") is not None: _sessions[sid]["model_override"] = stored_runtime_overrides[ @@ -9343,6 +9418,32 @@ def _serialize_billing_state(state) -> dict: "display": state.card.display, "resolved_via": state.card.resolved_via, } + payment_method = None + if state.payment_method is not None: + pm = state.payment_method + # Each kind sends only its own fields. Emitting every key with nulls + # would contradict the shared type — a client checking `'brand' in pm` + # would read every Link method as a card. + if pm.kind == "card": + payment_method = { + "kind": "card", + "brand": pm.brand, + "last4": pm.last4, + "wallet": pm.wallet, + "resolved_via": pm.resolved_via, + } + elif pm.kind == "link": + payment_method = { + "kind": "link", + "email": pm.email, + "resolved_via": pm.resolved_via, + } + else: + payment_method = { + "kind": "unknown", + "raw_kind": pm.raw_kind, + "resolved_via": pm.resolved_via, + } monthly_cap = None if state.monthly_cap is not None: mc = state.monthly_cap @@ -9392,6 +9493,7 @@ def _serialize_billing_state(state) -> dict: "min_usd": _s(state.min_usd), "max_usd": _s(state.max_usd), "card": card, + "payment_method": payment_method, "monthly_cap": monthly_cap, "auto_reload": auto_reload, "portal_url": state.portal_url, @@ -10671,7 +10773,7 @@ def _(rid, params: dict) -> dict: return _err(rid, 5000, f"redirect failed: {exc}") if accepted: with session["history_lock"]: - _replace_inflight_user(session, text) + _record_inflight_correction(session, text) session["last_active"] = time.time() return _ok( rid, @@ -11039,6 +11141,158 @@ def _notification_event_dedup_key(evt: dict) -> tuple: return (evt_sid, evt_type) +# Mirror gateway/kanban_watchers.py TERMINAL_KINDS: claim silent kinds too so +# the cursor advances past them and they can't wedge a later completed/blocked +# event behind an unclaimed row. +_KANBAN_NOTIFY_KINDS = ( + "completed", "blocked", "gave_up", "crashed", "timed_out", + "status", "archived", "unblocked", +) +_KANBAN_SILENT_KINDS = frozenset({"archived", "unblocked"}) +_KANBAN_POLL_SECONDS = 5.0 + + +def _format_kanban_event_text(sub: dict, task, ev, board_slug: str) -> Optional[str]: + """Single-line notification text for one kanban event. + + Wording mirrors the gateway notifier (gateway/kanban_watchers.py) so a + task completion reads the same in the TUI as it does on Telegram. + Returns None for kinds that are claimed but intentionally silent. + """ + kind = getattr(ev, "kind", "") + if not kind or kind in _KANBAN_SILENT_KINDS: + return None + task_id = sub.get("task_id", "") + title = (getattr(task, "title", None) or task_id)[:120] + board_tag = f"[{board_slug}] " if board_slug else "" + who = getattr(task, "assignee", None) or "" + tag = f"@{who} " if who else "" + payload = getattr(ev, "payload", None) or {} + if kind == "completed": + handoff = "" + summary = payload.get("summary") + if summary: + lines = str(summary).strip().splitlines() + handoff = f"\n{lines[0][:200]}" if lines else "" + elif getattr(task, "result", None): + lines = str(task.result).strip().splitlines() + handoff = f"\n{lines[0][:160]}" if lines else "" + return f"✔ {board_tag}{tag}Kanban {task_id} done — {title}{handoff}" + if kind == "blocked": + reason = f": {str(payload.get('reason'))[:160]}" if payload.get("reason") else "" + return f"⏸ {board_tag}{tag}Kanban {task_id} blocked{reason}" + if kind == "gave_up": + err = f"\n{str(payload.get('error'))[:200]}" if payload.get("error") else "" + return f"✖ {board_tag}{tag}Kanban {task_id} gave up after repeated spawn failures{err}" + if kind == "crashed": + return f"✖ {board_tag}{tag}Kanban {task_id} worker crashed (pid gone); dispatcher will retry" + if kind == "timed_out": + limit = 0 + try: + limit = int(payload.get("limit_seconds") or 0) + except (TypeError, ValueError): + pass + return f"⏱ {board_tag}{tag}Kanban {task_id} timed out (max_runtime={limit}s); will retry" + if kind == "status": + return f"🔄 {board_tag}{tag}Kanban {task_id} → {payload.get('status') or ''}" + return None + + +def _collect_kanban_notifications(session: dict) -> list: + """Claim unseen terminal kanban events for this TUI session's subscriptions. + + ``kanban_create`` auto-subscribes TUI/desktop sessions with + ``platform="tui"`` and ``chat_id=HERMES_SESSION_KEY`` (see + tools/kanban_tools.py ``_maybe_auto_subscribe``). The gateway notifier + can't deliver those — there is no "tui" messaging adapter — so this + poller is the delivery path for them (issue #59890). Uses the same + atomic cursor-claim (``claim_unseen_events_for_sub``) as the gateway + notifier, so a subscription is delivered exactly once even if a gateway + and a TUI poll the same board DB. + + Returns the list of formatted notification texts (may be empty). + """ + session_key = str(session.get("session_key") or "") + if not session_key or session.get("_finalized"): + return [] + try: + from hermes_cli import kanban_db as _kb + except Exception: + return [] + texts: list = [] + try: + boards = _kb.list_boards(include_archived=False) + except Exception: + try: + boards = [_kb.read_board_metadata(_kb.DEFAULT_BOARD)] + except Exception: + return [] + # Poll each resolved DB path once — multiple slugs can point at the same + # DB when HERMES_KANBAN_DB pins the board path (same guard as the gateway + # notifier). + seen_db_paths: set = set() + for board_meta in boards: + slug = (board_meta or {}).get("slug") or _kb.DEFAULT_BOARD + db_path = (board_meta or {}).get("db_path") + try: + resolved = ( + str(Path(db_path).expanduser().resolve()) + if db_path else str(_kb.kanban_db_path(slug).resolve()) + ) + except Exception: + resolved = f"slug:{slug}" + if resolved in seen_db_paths: + continue + seen_db_paths.add(resolved) + try: + conn = _kb.connect(board=slug) + except Exception: + continue + try: + try: + subs = _kb.list_notify_subs(conn) + except Exception: + continue + for sub in subs: + if (sub.get("platform") or "").lower() != "tui": + continue + if sub.get("chat_id") != session_key: + continue + _old, _new, events = _kb.claim_unseen_events_for_sub( + conn, + task_id=sub["task_id"], + platform=sub["platform"], + chat_id=sub["chat_id"], + thread_id=sub.get("thread_id") or "", + kinds=_KANBAN_NOTIFY_KINDS, + ) + if not events: + continue + task = _kb.get_task(conn, sub["task_id"]) + for ev in events: + text = _format_kanban_event_text(sub, task, ev, slug) + if text: + texts.append(text) + # Unsubscribe only at a truly final status (done/archived); + # blocked/crashed subs stay live so a respawned task's next + # terminal event still reaches the user (same rule as the + # gateway notifier). + if task and getattr(task, "status", "") in {"done", "archived"}: + try: + _kb.remove_notify_sub( + conn, + task_id=sub["task_id"], + platform=sub["platform"], + chat_id=sub["chat_id"], + thread_id=sub.get("thread_id") or "", + ) + except Exception: + pass + finally: + conn.close() + return texts + + def _notification_poller_loop( stop_event: threading.Event, sid: str, session: dict ) -> None: @@ -11051,11 +11305,56 @@ def _notification_poller_loop( The completion_queue is process-global. In multi-session Desktop each poller requeues events owned by another live session and drops addressed events whose owner is gone; ownerless legacy notifications remain global. + + Also polls ``kanban_notify_subs`` every ``_KANBAN_POLL_SECONDS`` for this + session's TUI kanban subscriptions and delivers terminal task events the + same way (status.update + agent turn) — the delivery path + tools/kanban_tools.py documents for platform="tui" rows (issue #59890). """ from tools.process_registry import process_registry, format_process_notification _emitted = set() # dedup re-queued events so same completion isn't emitted 50 times while session is busy + _last_kanban_poll = 0.0 while not stop_event.is_set() and not session.get("_finalized"): + _now = time.monotonic() + if _now - _last_kanban_poll >= _KANBAN_POLL_SECONDS: + _last_kanban_poll = _now + try: + _kanban_texts = _collect_kanban_notifications(session) + except Exception as _kb_exc: + print( + f"[tui_gateway] kanban notification poll failed: " + f"{type(_kb_exc).__name__}: {_kb_exc}", + file=sys.stderr, + ) + _kanban_texts = [] + if _kanban_texts: + for _kb_text in _kanban_texts: + _emit("status.update", sid, {"kind": "process", "text": _kb_text}) + # Events are cursor-claimed (never re-queued), so buffer them + # until the session is idle instead of dropping the agent turn. + session.setdefault("_kanban_pending", []).extend(_kanban_texts) + _pending = session.get("_kanban_pending") or [] + if _pending: + _batch: list = [] + with session["history_lock"]: + if not session.get("running"): + session["running"] = True + _batch = list(_pending) + session["_kanban_pending"] = [] + if _batch: + rid = f"__notif__{int(time.time() * 1000)}" + try: + _emit("message.start", sid) + _run_prompt_submit(rid, sid, session, "\n".join(_batch)) + except Exception as exc: + print( + f"[tui_gateway] kanban notification dispatch failed: " + f"{type(exc).__name__}: {exc}", + file=sys.stderr, + ) + with session["history_lock"]: + session["running"] = False try: evt = process_registry.completion_queue.get(timeout=0.5) except Exception: @@ -11372,6 +11671,7 @@ def _run_prompt_submit( approval_token = None session_tokens = [] home_token = None # per-turn HERMES_HOME override for a resumed remote profile + secret_token = None goal_followup = None # set by the post-turn goal hook below tts_queue = None # streaming-TTS feed for this turn (voice mode) one_turn_restore = session.pop("one_turn_model_restore", None) @@ -11404,6 +11704,7 @@ def _run_prompt_submit( _profile_home_str = session.get("profile_home") if _profile_home_str: home_token = set_hermes_home_override(_profile_home_str) + secret_token = set_secret_scope(build_profile_secret_scope(Path(_profile_home_str))) # The sudo password callback is thread-local (tools.terminal_tool # _callback_tls), so wiring it on the build thread doesn't reach this # turn thread — terminal sudo prompts would fall through to /dev/tty @@ -11927,6 +12228,8 @@ def _run_prompt_submit( pass if home_token is not None: reset_hermes_home_override(home_token) + if secret_token is not None: + reset_secret_scope(secret_token) _clear_session_context(session_tokens) # Clear the per-turn interim callback so a stale closure from # this turn can't fire during a later turn on the same agent. @@ -13068,6 +13371,70 @@ def _(rid, params: dict) -> dict: agent.verbose_logging = nv == "verbose" return _ok(rid, {"key": key, "value": nv}) + if key == "focus": + # Focus view — display-only reduced-output mode (/focus). Composes with + # the tool_progress machinery rather than duplicating it: enabling it + # pins tool_progress to "off" (the same value /verbose off uses) after + # stashing the configured mode, and disabling it restores that mode. + # Nothing about the request payload changes. + from hermes_cli.focus_view import ( + FOCUS_TOOL_PROGRESS_MODE, + normalize_tool_progress_mode, + resolve_focus_arg, + ) + + cfg_f = _load_cfg() + _display_f = cfg_f.get("display") + d_f: dict = _display_f if isinstance(_display_f, dict) else {} + cur_focus = bool(d_f.get("focus_view", False)) + action, target = resolve_focus_arg(str(value or ""), cur_focus) + if action == "usage": + return _err(rid, 4002, f"unknown focus value: {value} (use on|off|status)") + if action == "status" or target is None: + return _ok( + rid, + { + "key": key, + "value": "on" if cur_focus else "off", + "tool_progress": _load_tool_progress_mode(), + }, + ) + + if target: + saved = normalize_tool_progress_mode( + (d_f.get("focus_saved_tool_progress") or _load_tool_progress_mode()) + if cur_focus + else _load_tool_progress_mode() + ) + _write_config_key("display.focus_saved_tool_progress", saved) + _write_config_key("display.tool_progress", FOCUS_TOOL_PROGRESS_MODE) + effective = FOCUS_TOOL_PROGRESS_MODE + else: + saved = normalize_tool_progress_mode( + d_f.get("focus_saved_tool_progress") or "all" + ) + _write_config_key("display.tool_progress", saved) + effective = saved + _write_config_key("display.focus_view", bool(target)) + + if session: + session["focus_view"] = bool(target) + session["tool_progress_mode"] = effective + agent_f = session.get("agent") + if agent_f is not None: + try: + agent_f.tool_progress_mode = effective + except Exception: + pass + return _ok( + rid, + { + "key": key, + "value": "on" if target else "off", + "tool_progress": effective, + }, + ) + if key in {"approval_mode", "approvals.mode"}: raw = str(value or "").strip().lower() if raw not in _APPROVAL_MODES: @@ -14255,6 +14622,13 @@ def _(rid, params: dict) -> dict: display.get("tui_statusbar", "top") if isinstance(display, dict) else "top" ) return _ok(rid, {"value": _coerce_statusbar(raw)}) + if key == "focus": + display = _load_cfg().get("display") + on = bool(display.get("focus_view", False)) if isinstance(display, dict) else False + return _ok( + rid, + {"value": "on" if on else "off", "tool_progress": _load_tool_progress_mode()}, + ) if key == "mouse": display = _load_cfg().get("display") return _ok(rid, {"value": _display_mouse_tracking(display)}) @@ -14713,6 +15087,7 @@ _PENDING_INPUT_COMMANDS: frozenset[str] = frozenset( "moa", "undo", "learn", + "init", "compress", "compact", } @@ -15064,6 +15439,14 @@ def _(rid, params: dict) -> dict: from agent.learn_prompt import build_learn_prompt return _ok(rid, {"type": "send", "message": build_learn_prompt(arg)}) + if name == "init": + # Generate-or-update AGENTS.md: build the guidance-laden prompt and + # submit it as a normal agent turn (same pattern as /learn). The live + # agent scans the project with its own read-only tools and writes or + # merge-updates AGENTS.md via write_file. Works on any backend. + from hermes_cli.init_command import build_init_prompt_for_cwd + + return _ok(rid, {"type": "send", "message": build_init_prompt_for_cwd(extra=arg)}) if name == "moa": # /moa is one-shot sugar only: run a single prompt through the default # MoA preset, then restore the prior model. To *switch* to a MoA preset @@ -15127,6 +15510,49 @@ def _(rid, params: dict) -> dict: except Exception as exc: return _err(rid, 5030, f"moa unavailable: {exc}") + if name == "focus": + # /focus is display-only. Route it through the same config.set branch the + # Ink TUI slash command uses so both surfaces share one state machine and + # one persistence path. Returns a plain notice line for the transcript. + from hermes_cli.focus_view import ( + format_focus_status, + format_focus_toggle_message, + resolve_focus_arg, + ) + + _display_focus = _load_cfg().get("display") + _d_focus: dict = _display_focus if isinstance(_display_focus, dict) else {} + _cur_focus = bool(_d_focus.get("focus_view", False)) + _action, _target = resolve_focus_arg(arg, _cur_focus) + if _action == "usage": + return _err(rid, 4004, "usage: /focus [on|off|status]") + if _action == "status": + _saved = _d_focus.get("focus_saved_tool_progress") or _load_tool_progress_mode() + return _ok( + rid, + {"type": "exec", "output": format_focus_status(_cur_focus, _saved)}, + ) + _res = _methods["config.set"]( + rid, + { + "key": "focus", + "value": "on" if _target else "off", + "session_id": params.get("session_id", ""), + }, + ) + if "error" in _res: + return _res + _payload = _res.get("result") or {} + return _ok( + rid, + { + "type": "exec", + "output": format_focus_toggle_message( + bool(_target), _payload.get("tool_progress") or "all" + ), + }, + ) + if name == "retry": if not session: return _err(rid, 4001, "no active session to retry") @@ -17566,7 +17992,7 @@ def _(rid, params: dict) -> dict: { "title": "Agent", "rows": [ - ["Max Turns", str(_cfg_max_turns(cfg, 90))], + ["Max Turns", str(_cfg_max_turns(cfg, 500))], ["Toolsets", ", ".join(cfg.get("enabled_toolsets", [])) or "all"], ["Verbose", str(cfg.get("verbose", False))], ], diff --git a/tui_gateway/ws.py b/tui_gateway/ws.py index 11469f93c2..795f85c13e 100644 --- a/tui_gateway/ws.py +++ b/tui_gateway/ws.py @@ -303,22 +303,6 @@ async def handle_ws(ws: Any) -> None: transport = WSTransport(ws, asyncio.get_running_loop(), peer=peer) - # The desktop app and dashboard chat reach the agent through this WS - # sidecar, NOT through tui_gateway.entry.main() (the stdio TUI path that - # spawns the background MCP discovery thread). Without starting it here, - # discovery never runs in this process: _make_agent only *waits* on the - # thread (wait_for_mcp_discovery), which no-ops when it was never - # created, so the agent snapshots an MCP-less tool list and the only way - # to surface MCP tools is a manual /reload-mcp. Start it once per - # process here (idempotent, config-gated) before gateway.ready so the - # first agent build can pick up already-spawning servers. (#38945) - from hermes_cli.mcp_startup import start_background_mcp_discovery - - start_background_mcp_discovery( - logger=_log, - thread_name="tui-ws-mcp-discovery", - ) - ready_ok = await transport.write_async( { "jsonrpc": "2.0", diff --git a/ui-tui/src/app/interfaces.ts b/ui-tui/src/app/interfaces.ts index 485c0ec28e..d82fa1a90e 100644 --- a/ui-tui/src/app/interfaces.ts +++ b/ui-tui/src/app/interfaces.ts @@ -324,6 +324,9 @@ export interface UiState { compact: boolean detailsMode: DetailsMode detailsModeCommandOverride: boolean + // Focus view (/focus) — display-only reduced-output mode. Drives the + // persistent `◉ focus` status-bar badge; never affects request payloads. + focusView: boolean info: null | SessionInfo liveSessionCount: number inlineDiffs: boolean diff --git a/ui-tui/src/app/slash/commands/core.ts b/ui-tui/src/app/slash/commands/core.ts index 8fdbedce9f..b69d2e89b4 100644 --- a/ui-tui/src/app/slash/commands/core.ts +++ b/ui-tui/src/app/slash/commands/core.ts @@ -554,6 +554,40 @@ export const coreCommands: SlashCommand[] = [ } }, + { + help: 'toggle focus view — show only your prompt and the final response [on|off|status]', + name: 'focus', + run: (arg, ctx) => { + const mode = arg.trim().toLowerCase() + const current = ctx.ui.focusView + + // `/focus status` reports without writing, matching the CLI surface. + if (mode === 'status' || mode === 'show' || mode === '?') { + return ctx.transcript.sys( + current ? 'focus view on — only your prompt and the final response' : 'focus view off' + ) + } + + const next = flagFromArg(mode, current) + + if (next === null) { + return ctx.transcript.sys('usage: /focus [on|off|status]') + } + + // Display-only: Python owns the tool_progress stash/restore so /focus off + // returns to whatever /verbose mode the user had. Optimistically patch the + // badge so the status bar flips on the same frame. + patchUiState({ focusView: next }) + ctx.gateway.rpc('config.set', { key: 'focus', value: next ? 'on' : 'off' }).catch(() => {}) + + queueMicrotask(() => + ctx.transcript.sys( + next ? 'focus view enabled — just your prompt and the final response' : 'focus view disabled' + ) + ) + } + }, + { aliases: ['sb'], help: 'status bar position (on|off|top|bottom)', diff --git a/ui-tui/src/app/uiStore.ts b/ui-tui/src/app/uiStore.ts index f311e8f2ce..fe7a6674da 100644 --- a/ui-tui/src/app/uiStore.ts +++ b/ui-tui/src/app/uiStore.ts @@ -16,6 +16,7 @@ const buildUiState = (): UiState => ({ compact: false, detailsMode: 'collapsed', detailsModeCommandOverride: false, + focusView: false, indicatorStyle: DEFAULT_INDICATOR_STYLE, info: null, liveSessionCount: 0, diff --git a/ui-tui/src/app/useConfigSync.ts b/ui-tui/src/app/useConfigSync.ts index 6a1e503211..e8dd8b1334 100644 --- a/ui-tui/src/app/useConfigSync.ts +++ b/ui-tui/src/app/useConfigSync.ts @@ -275,6 +275,7 @@ export const applyDisplay = ( compact: !!d.tui_compact, detailsMode: resolveDetailsMode(d), detailsModeCommandOverride: false, + focusView: !!d.focus_view, indicatorStyle: normalizeIndicatorStyle(d.tui_status_indicator), inlineDiffs: d.inline_diffs !== false, mouseTracking: normalizeMouseTracking(d), diff --git a/ui-tui/src/components/appChrome.tsx b/ui-tui/src/components/appChrome.tsx index 97994e8272..7758255765 100644 --- a/ui-tui/src/components/appChrome.tsx +++ b/ui-tui/src/components/appChrome.tsx @@ -434,6 +434,7 @@ export function GoodVibesHeart({ tick, t }: { tick: number; t: Theme }) { export function StatusRule({ battery, + focusView, cwdLabel, cols, busy, @@ -570,6 +571,11 @@ export function StatusRule({ // so it consumes tail budget LAST and drops first on a narrow terminal. const showDevCredits = !!devCreditsText && fits(SEP + stringWidth(devCreditsText)) + // Focus-view badge. Pinned (not tail-budgeted) on purpose: the whole point of + // the indicator is that the user can never be in reduced-output mode without + // seeing it, so it must not drop off a narrow terminal. + const showFocus = !!focusView + const handleSessionCountClick = (event: { stopImmediatePropagation?: () => void }) => { event.stopImmediatePropagation?.() onSessionCountClick?.() @@ -634,6 +640,12 @@ export function StatusRule({ ) : null} + {showFocus ? ( + + {' │ '} + ◉ focus + + ) : null} {showBar ? ( {' │ '} @@ -811,6 +823,8 @@ export function TranscriptScrollbar({ scrollRef, t }: TranscriptScrollbarProps) interface StatusRuleProps { battery?: BatteryInfo | null + // Focus view (/focus) badge — display-only reduced-output indicator. + focusView?: boolean bgCount: number lastTurnEndedAt?: null | number liveSessionCount: number diff --git a/ui-tui/src/components/appLayout.tsx b/ui-tui/src/components/appLayout.tsx index 1b4ba084fb..660fcb881d 100644 --- a/ui-tui/src/components/appLayout.tsx +++ b/ui-tui/src/components/appLayout.tsx @@ -492,6 +492,7 @@ const StatusRulePane = memo(function StatusRulePane({ busy={ui.busy} cols={composer.cols} cwdLabel={status.cwdLabel} + focusView={ui.focusView} indicatorStyle={ui.indicatorStyle} lastTurnEndedAt={status.lastTurnEndedAt} liveSessionCount={ui.liveSessionCount} diff --git a/ui-tui/src/gatewayTypes.ts b/ui-tui/src/gatewayTypes.ts index 719ffe9938..63219a1ab7 100644 --- a/ui-tui/src/gatewayTypes.ts +++ b/ui-tui/src/gatewayTypes.ts @@ -81,6 +81,8 @@ export interface ConfigDisplayConfig { bell_on_complete?: boolean busy_input_mode?: string details_mode?: string + /** Focus view (/focus) — display-only reduced-output mode. */ + focus_view?: boolean inline_diffs?: boolean mouse_tracking?: boolean | null | number | string sections?: Record diff --git a/uv.lock b/uv.lock index 3a636ad943..dee539ca97 100644 --- a/uv.lock +++ b/uv.lock @@ -249,7 +249,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/9a/7d/b22cb9a0d4f396ee0 [[package]] name = "alibabacloud-tea-openapi" -version = "0.4.4" +version = "0.4.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "alibabacloud-credentials" }, @@ -258,9 +258,9 @@ dependencies = [ { name = "cryptography" }, { name = "darabonba-core" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/30/93/138bcdc8fc596add73e37cf2073798f285284d1240bda9ee02f9384fc6be/alibabacloud_tea_openapi-0.4.4.tar.gz", hash = "sha256:1b0917bc03cd49417da64945e92731716d53e2eb8707b235f54e45b7473221ce", size = 21960, upload-time = "2026-03-26T10:16:16.792Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/73/fb0c4d44759791ecdf269fc715c1e810fa1aba3981bfaaf8a01f61899296/alibabacloud_tea_openapi-0.4.5.tar.gz", hash = "sha256:75fa1f4360a46e41f5bf5f8d4917e52efb6f64885839bc1328c35590670c97b9", size = 26616, upload-time = "2026-07-14T13:15:39.364Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f5/5a/6bfc4506438c1809c486f66217ad11eab78157192b3d5707b4e2f4212f6c/alibabacloud_tea_openapi-0.4.4-py3-none-any.whl", hash = "sha256:cea6bc1fe35b0319a8752cb99eb0ecb0dab7ca1a71b99c12970ba0867410995f", size = 26236, upload-time = "2026-03-26T10:16:15.861Z" }, + { url = "https://files.pythonhosted.org/packages/8d/ec/6b368a10e9c2e8b1b394c69b96ac213ae66e8c4895e0baa1ffaf7178fd32/alibabacloud_tea_openapi-0.4.5-py3-none-any.whl", hash = "sha256:338979095c7beda80a5b413c31262892cafdc12069dde4ce4fc2e4f7ce0fc609", size = 33333, upload-time = "2026-07-14T13:15:38.365Z" }, ] [[package]] @@ -675,14 +675,14 @@ wheels = [ [[package]] name = "click" -version = "8.3.1" +version = "8.4.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } +sdist = { url = "https://files.pythonhosted.org/packages/76/d4/81420972a676e8ffea40450d8c8c92943e7218a78fe9b64359836cc9876b/click-8.4.2.tar.gz", hash = "sha256:9a6cea6e60b17ebe0a44c5cc636d94f09bd66142c1cd7d8b4cd731c4917a15f6", size = 338000, upload-time = "2026-06-24T17:45:15.148Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" }, + { url = "https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl", hash = "sha256:e6f9f66136c816745b9d65817da91d61d957fb16e02e4dcd0552553c5a197b76", size = 119243, upload-time = "2026-06-24T17:45:13.73Z" }, ] [[package]] @@ -721,47 +721,47 @@ wheels = [ [[package]] name = "cryptography" -version = "46.0.7" +version = "48.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/47/93/ac8f3d5ff04d54bc814e961a43ae5b0b146154c89c61b47bb07557679b18/cryptography-46.0.7.tar.gz", hash = "sha256:e4cfd68c5f3e0bfdad0d38e023239b96a2fe84146481852dffbcca442c245aa5", size = 750652, upload-time = "2026-04-08T01:57:54.692Z" } +sdist = { url = "https://files.pythonhosted.org/packages/12/45/870e7f4bef50e5f53b9f51d4428aee5290eedf58ba443f16b1ebb7ab8e66/cryptography-48.0.1.tar.gz", hash = "sha256:266f4ee051abb2f725b74ef8072b521ce1feacf685a3364fa6a6b45548db791a", size = 832989, upload-time = "2026-06-09T22:32:31.8Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/5d/4a8f770695d73be252331e60e526291e3df0c9b27556a90a6b47bccca4c2/cryptography-46.0.7-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:ea42cbe97209df307fdc3b155f1b6fa2577c0defa8f1f7d3be7d31d189108ad4", size = 7179869, upload-time = "2026-04-08T01:56:17.157Z" }, - { url = "https://files.pythonhosted.org/packages/5f/45/6d80dc379b0bbc1f9d1e429f42e4cb9e1d319c7a8201beffd967c516ea01/cryptography-46.0.7-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b36a4695e29fe69215d75960b22577197aca3f7a25b9cf9d165dcfe9d80bc325", size = 4275492, upload-time = "2026-04-08T01:56:19.36Z" }, - { url = "https://files.pythonhosted.org/packages/4a/9a/1765afe9f572e239c3469f2cb429f3ba7b31878c893b246b4b2994ffe2fe/cryptography-46.0.7-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5ad9ef796328c5e3c4ceed237a183f5d41d21150f972455a9d926593a1dcb308", size = 4426670, upload-time = "2026-04-08T01:56:21.415Z" }, - { url = "https://files.pythonhosted.org/packages/8f/3e/af9246aaf23cd4ee060699adab1e47ced3f5f7e7a8ffdd339f817b446462/cryptography-46.0.7-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:73510b83623e080a2c35c62c15298096e2a5dc8d51c3b4e1740211839d0dea77", size = 4280275, upload-time = "2026-04-08T01:56:23.539Z" }, - { url = "https://files.pythonhosted.org/packages/0f/54/6bbbfc5efe86f9d71041827b793c24811a017c6ac0fd12883e4caa86b8ed/cryptography-46.0.7-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:cbd5fb06b62bd0721e1170273d3f4d5a277044c47ca27ee257025146c34cbdd1", size = 4928402, upload-time = "2026-04-08T01:56:25.624Z" }, - { url = "https://files.pythonhosted.org/packages/2d/cf/054b9d8220f81509939599c8bdbc0c408dbd2bdd41688616a20731371fe0/cryptography-46.0.7-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:420b1e4109cc95f0e5700eed79908cef9268265c773d3a66f7af1eef53d409ef", size = 4459985, upload-time = "2026-04-08T01:56:27.309Z" }, - { url = "https://files.pythonhosted.org/packages/f9/46/4e4e9c6040fb01c7467d47217d2f882daddeb8828f7df800cb806d8a2288/cryptography-46.0.7-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:24402210aa54baae71d99441d15bb5a1919c195398a87b563df84468160a65de", size = 3990652, upload-time = "2026-04-08T01:56:29.095Z" }, - { url = "https://files.pythonhosted.org/packages/36/5f/313586c3be5a2fbe87e4c9a254207b860155a8e1f3cca99f9910008e7d08/cryptography-46.0.7-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:8a469028a86f12eb7d2fe97162d0634026d92a21f3ae0ac87ed1c4a447886c83", size = 4279805, upload-time = "2026-04-08T01:56:30.928Z" }, - { url = "https://files.pythonhosted.org/packages/69/33/60dfc4595f334a2082749673386a4d05e4f0cf4df8248e63b2c3437585f2/cryptography-46.0.7-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:9694078c5d44c157ef3162e3bf3946510b857df5a3955458381d1c7cfc143ddb", size = 4892883, upload-time = "2026-04-08T01:56:32.614Z" }, - { url = "https://files.pythonhosted.org/packages/c7/0b/333ddab4270c4f5b972f980adef4faa66951a4aaf646ca067af597f15563/cryptography-46.0.7-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:42a1e5f98abb6391717978baf9f90dc28a743b7d9be7f0751a6f56a75d14065b", size = 4459756, upload-time = "2026-04-08T01:56:34.306Z" }, - { url = "https://files.pythonhosted.org/packages/d2/14/633913398b43b75f1234834170947957c6b623d1701ffc7a9600da907e89/cryptography-46.0.7-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:91bbcb08347344f810cbe49065914fe048949648f6bd5c2519f34619142bbe85", size = 4410244, upload-time = "2026-04-08T01:56:35.977Z" }, - { url = "https://files.pythonhosted.org/packages/10/f2/19ceb3b3dc14009373432af0c13f46aa08e3ce334ec6eff13492e1812ccd/cryptography-46.0.7-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5d1c02a14ceb9148cc7816249f64f623fbfee39e8c03b3650d842ad3f34d637e", size = 4674868, upload-time = "2026-04-08T01:56:38.034Z" }, - { url = "https://files.pythonhosted.org/packages/1a/bb/a5c213c19ee94b15dfccc48f363738633a493812687f5567addbcbba9f6f/cryptography-46.0.7-cp311-abi3-win32.whl", hash = "sha256:d23c8ca48e44ee015cd0a54aeccdf9f09004eba9fc96f38c911011d9ff1bd457", size = 3026504, upload-time = "2026-04-08T01:56:39.666Z" }, - { url = "https://files.pythonhosted.org/packages/2b/02/7788f9fefa1d060ca68717c3901ae7fffa21ee087a90b7f23c7a603c32ae/cryptography-46.0.7-cp311-abi3-win_amd64.whl", hash = "sha256:397655da831414d165029da9bc483bed2fe0e75dde6a1523ec2fe63f3c46046b", size = 3488363, upload-time = "2026-04-08T01:56:41.893Z" }, - { url = "https://files.pythonhosted.org/packages/a7/7f/cd42fc3614386bc0c12f0cb3c4ae1fc2bbca5c9662dfed031514911d513d/cryptography-46.0.7-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:462ad5cb1c148a22b2e3bcc5ad52504dff325d17daf5df8d88c17dda1f75f2a4", size = 7165618, upload-time = "2026-04-08T01:57:10.645Z" }, - { url = "https://files.pythonhosted.org/packages/a5/d0/36a49f0262d2319139d2829f773f1b97ef8aef7f97e6e5bd21455e5a8fb5/cryptography-46.0.7-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:84d4cced91f0f159a7ddacad249cc077e63195c36aac40b4150e7a57e84fffe7", size = 4270628, upload-time = "2026-04-08T01:57:12.885Z" }, - { url = "https://files.pythonhosted.org/packages/8a/6c/1a42450f464dda6ffbe578a911f773e54dd48c10f9895a23a7e88b3e7db5/cryptography-46.0.7-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:128c5edfe5e5938b86b03941e94fac9ee793a94452ad1365c9fc3f4f62216832", size = 4415405, upload-time = "2026-04-08T01:57:14.923Z" }, - { url = "https://files.pythonhosted.org/packages/9a/92/4ed714dbe93a066dc1f4b4581a464d2d7dbec9046f7c8b7016f5286329e2/cryptography-46.0.7-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:5e51be372b26ef4ba3de3c167cd3d1022934bc838ae9eaad7e644986d2a3d163", size = 4272715, upload-time = "2026-04-08T01:57:16.638Z" }, - { url = "https://files.pythonhosted.org/packages/b7/e6/a26b84096eddd51494bba19111f8fffe976f6a09f132706f8f1bf03f51f7/cryptography-46.0.7-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:cdf1a610ef82abb396451862739e3fc93b071c844399e15b90726ef7470eeaf2", size = 4918400, upload-time = "2026-04-08T01:57:19.021Z" }, - { url = "https://files.pythonhosted.org/packages/c7/08/ffd537b605568a148543ac3c2b239708ae0bd635064bab41359252ef88ed/cryptography-46.0.7-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1d25aee46d0c6f1a501adcddb2d2fee4b979381346a78558ed13e50aa8a59067", size = 4450634, upload-time = "2026-04-08T01:57:21.185Z" }, - { url = "https://files.pythonhosted.org/packages/16/01/0cd51dd86ab5b9befe0d031e276510491976c3a80e9f6e31810cce46c4ad/cryptography-46.0.7-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:cdfbe22376065ffcf8be74dc9a909f032df19bc58a699456a21712d6e5eabfd0", size = 3985233, upload-time = "2026-04-08T01:57:22.862Z" }, - { url = "https://files.pythonhosted.org/packages/92/49/819d6ed3a7d9349c2939f81b500a738cb733ab62fbecdbc1e38e83d45e12/cryptography-46.0.7-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:abad9dac36cbf55de6eb49badd4016806b3165d396f64925bf2999bcb67837ba", size = 4271955, upload-time = "2026-04-08T01:57:24.814Z" }, - { url = "https://files.pythonhosted.org/packages/80/07/ad9b3c56ebb95ed2473d46df0847357e01583f4c52a85754d1a55e29e4d0/cryptography-46.0.7-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:935ce7e3cfdb53e3536119a542b839bb94ec1ad081013e9ab9b7cfd478b05006", size = 4879888, upload-time = "2026-04-08T01:57:26.88Z" }, - { url = "https://files.pythonhosted.org/packages/b8/c7/201d3d58f30c4c2bdbe9b03844c291feb77c20511cc3586daf7edc12a47b/cryptography-46.0.7-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:35719dc79d4730d30f1c2b6474bd6acda36ae2dfae1e3c16f2051f215df33ce0", size = 4449961, upload-time = "2026-04-08T01:57:29.068Z" }, - { url = "https://files.pythonhosted.org/packages/a5/ef/649750cbf96f3033c3c976e112265c33906f8e462291a33d77f90356548c/cryptography-46.0.7-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7bbc6ccf49d05ac8f7d7b5e2e2c33830d4fe2061def88210a126d130d7f71a85", size = 4401696, upload-time = "2026-04-08T01:57:31.029Z" }, - { url = "https://files.pythonhosted.org/packages/41/52/a8908dcb1a389a459a29008c29966c1d552588d4ae6d43f3a1a4512e0ebe/cryptography-46.0.7-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a1529d614f44b863a7b480c6d000fe93b59acee9c82ffa027cfadc77521a9f5e", size = 4664256, upload-time = "2026-04-08T01:57:33.144Z" }, - { url = "https://files.pythonhosted.org/packages/4b/fa/f0ab06238e899cc3fb332623f337a7364f36f4bb3f2534c2bb95a35b132c/cryptography-46.0.7-cp38-abi3-win32.whl", hash = "sha256:f247c8c1a1fb45e12586afbb436ef21ff1e80670b2861a90353d9b025583d246", size = 3013001, upload-time = "2026-04-08T01:57:34.933Z" }, - { url = "https://files.pythonhosted.org/packages/d2/f1/00ce3bde3ca542d1acd8f8cfa38e446840945aa6363f9b74746394b14127/cryptography-46.0.7-cp38-abi3-win_amd64.whl", hash = "sha256:506c4ff91eff4f82bdac7633318a526b1d1309fc07ca76a3ad182cb5b686d6d3", size = 3472985, upload-time = "2026-04-08T01:57:36.714Z" }, - { url = "https://files.pythonhosted.org/packages/63/0c/dca8abb64e7ca4f6b2978769f6fea5ad06686a190cec381f0a796fdcaaba/cryptography-46.0.7-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:fc9ab8856ae6cf7c9358430e49b368f3108f050031442eaeb6b9d87e4dcf4e4f", size = 3476879, upload-time = "2026-04-08T01:57:38.664Z" }, - { url = "https://files.pythonhosted.org/packages/3a/ea/075aac6a84b7c271578d81a2f9968acb6e273002408729f2ddff517fed4a/cryptography-46.0.7-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d3b99c535a9de0adced13d159c5a9cf65c325601aa30f4be08afd680643e9c15", size = 4219700, upload-time = "2026-04-08T01:57:40.625Z" }, - { url = "https://files.pythonhosted.org/packages/6c/7b/1c55db7242b5e5612b29fc7a630e91ee7a6e3c8e7bf5406d22e206875fbd/cryptography-46.0.7-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d02c738dacda7dc2a74d1b2b3177042009d5cab7c7079db74afc19e56ca1b455", size = 4385982, upload-time = "2026-04-08T01:57:42.725Z" }, - { url = "https://files.pythonhosted.org/packages/cb/da/9870eec4b69c63ef5925bf7d8342b7e13bc2ee3d47791461c4e49ca212f4/cryptography-46.0.7-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:04959522f938493042d595a736e7dbdff6eb6cc2339c11465b3ff89343b65f65", size = 4219115, upload-time = "2026-04-08T01:57:44.939Z" }, - { url = "https://files.pythonhosted.org/packages/f4/72/05aa5832b82dd341969e9a734d1812a6aadb088d9eb6f0430fc337cc5a8f/cryptography-46.0.7-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:3986ac1dee6def53797289999eabe84798ad7817f3e97779b5061a95b0ee4968", size = 4385479, upload-time = "2026-04-08T01:57:46.86Z" }, - { url = "https://files.pythonhosted.org/packages/20/2a/1b016902351a523aa2bd446b50a5bc1175d7a7d1cf90fe2ef904f9b84ebc/cryptography-46.0.7-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:258514877e15963bd43b558917bc9f54cf7cf866c38aa576ebf47a77ddbc43a4", size = 3412829, upload-time = "2026-04-08T01:57:48.874Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bc/ee4137cbbe105652c0ee4252792b78fc8e7afa4b8e61d9d5dc05a7f45731/cryptography-48.0.1-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:3e4a1a3232eef2e6c732827d5722db29a0cc8b27af2a4d865b094cf954be9ca1", size = 8008324, upload-time = "2026-06-09T22:31:00.702Z" }, + { url = "https://files.pythonhosted.org/packages/d5/85/6379d42181bfc713094f081360fc5784d6c816b599d45e7f082502d173ce/cryptography-48.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:32143b24adb918f078134e1e230f1eb8cc04886b92c28b5f0041aaf3e5699225", size = 4696243, upload-time = "2026-06-09T22:32:33.446Z" }, + { url = "https://files.pythonhosted.org/packages/9c/87/c85d147b53323c7eb4d850920c8901377323c2a0ff8d79c262d4fee89aa2/cryptography-48.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0d27a5696721ef7a672b8c810f6aded391058e0b9486e63e6d93baf765da691", size = 4713235, upload-time = "2026-06-09T22:31:40.141Z" }, + { url = "https://files.pythonhosted.org/packages/79/58/67cbf8cf1ee7c54b439ca07bbecf8362c07afc11a3724fea70f745784add/cryptography-48.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eb86ce1af36fe65041b6db9a8bb064ee621a7e5fded0f80d475ec243477cd242", size = 4702323, upload-time = "2026-06-09T22:31:42.191Z" }, + { url = "https://files.pythonhosted.org/packages/89/c6/24266ac10c47f6cd2a865f4446062b466da1d1f10b27189eac00e61bf0c9/cryptography-48.0.1-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:b024e784ad6c077ee0147b35ea9cbfc1e34e1fd4c1dcca214c2794d73a12df08", size = 5300085, upload-time = "2026-06-09T22:31:58.703Z" }, + { url = "https://files.pythonhosted.org/packages/d2/bb/cc4b78784f97efc8c5874c2a9743708d172be6663024b34a0467885ae0c8/cryptography-48.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3752f2dbc8f07a30aad2932c986cea495b03bb554887828225da104f732852b6", size = 4746137, upload-time = "2026-06-09T22:31:31.01Z" }, + { url = "https://files.pythonhosted.org/packages/1f/52/0c44de3f5267f8fbe8e835138017522a333436166e406f0db9b9e6e3033f/cryptography-48.0.1-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:bd81490cd5801d755cf97bb68ac191f14b708470b1c7cf4580f669b9c9264cd8", size = 4333867, upload-time = "2026-06-09T22:32:28.096Z" }, + { url = "https://files.pythonhosted.org/packages/9a/2e/772d7adbfa931537bc401640b7cac9976bff689bda187833e5d63b428e49/cryptography-48.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:66fd0771e7b9c6dcd44cf1120690d2338d16d72795cf40cae2786a39eba65429", size = 4701805, upload-time = "2026-06-09T22:31:38.284Z" }, + { url = "https://files.pythonhosted.org/packages/f8/a3/b06844f303873493c963caf581c04df31c7035e0c1b0f02c4814d319ec80/cryptography-48.0.1-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:3fd2ca57062b241c856670b073487d2e86c4637937ca5601e48f97bf8e11fc8f", size = 5258461, upload-time = "2026-06-09T22:31:04.187Z" }, + { url = "https://files.pythonhosted.org/packages/9f/13/8b765e2e12b07c74941caadb9d1c8fdc006c4dfbf2b8f2d610519758954d/cryptography-48.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:0ee6ea481db1ab889cba043ec1eda17bb9c1ea79db6722f779c3667f9f70322f", size = 4745488, upload-time = "2026-06-09T22:32:30.07Z" }, + { url = "https://files.pythonhosted.org/packages/2e/aa/48972bce55049b32a94f4907eda4d75fa385aad8a39506cc2fc72196ecf0/cryptography-48.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f2ceef93cb096aa3c4cc4b5c94ca6131f9196d28c64d6111533402a9b2054d41", size = 4830256, upload-time = "2026-06-09T22:31:43.868Z" }, + { url = "https://files.pythonhosted.org/packages/47/a2/e5079a032fb85cf6005046ca92bbd78b0c82dad2b5751ab8c311659da06f/cryptography-48.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9bd3f92d76217892b15df84ca256c2c113d386fdda7a7d8691aeeced976507c6", size = 4979117, upload-time = "2026-06-09T22:31:05.845Z" }, + { url = "https://files.pythonhosted.org/packages/b7/a0/8f50cae9c74e718ed769d63ed5c74bd0ea830c9550a74629cebd1b9c7bc7/cryptography-48.0.1-cp311-abi3-win32.whl", hash = "sha256:b9a32b876490d66c8bcc9963ef220199569748434ab01a9d6aaeabf88e7f5158", size = 3304154, upload-time = "2026-06-09T22:32:16.845Z" }, + { url = "https://files.pythonhosted.org/packages/c5/69/0572c77dbace6fef72f33755bd52ea399c71367250d366237f8691826b9e/cryptography-48.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:39489bfca54c7a1f6b297efcd8bc608ab92d16c4ca631b0cad4da46724588b24", size = 3817138, upload-time = "2026-06-09T22:32:00.388Z" }, + { url = "https://files.pythonhosted.org/packages/ca/6c/00fa2a95997164c8b2072ce327c23d4ab20809ccc323ea5fab91e53a4bba/cryptography-48.0.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:4fdc69f8e4316bcf0c8c8ec1f26f285d12e8142d88d96c876a59a03be3f6ae67", size = 7987408, upload-time = "2026-06-09T22:32:20.777Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d9/45f309a7e4e5f3f8f121d6d3be9e94024a7726ec598d6e08ae04edb2f04d/cryptography-48.0.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48fe40804d4caa2288f24e70ca8c64c42dd826da0ad7e4f1b41b2128d679e6c8", size = 4690196, upload-time = "2026-06-09T22:31:54.74Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9f/a1bc8bcc798811b8527eb374bbccf30a3f3e806829d967118222bf1125eb/cryptography-48.0.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:86be3b1b0b6bf09482fb50a979c508d2950ed95f5621ec77f4e385962006b83a", size = 4696782, upload-time = "2026-06-09T22:31:45.615Z" }, + { url = "https://files.pythonhosted.org/packages/66/c2/81a4fb4e4373c500bb526bc337ac5719dd31dd15b970b84a238168c6aa08/cryptography-48.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4ab0a343c807bbcd90c971cd1ecf072937cd01847a9e002bef88fb47ac6be577", size = 4696618, upload-time = "2026-06-09T22:31:11.564Z" }, + { url = "https://files.pythonhosted.org/packages/e5/0b/aa68b221dde92d09cb29a024ede17550ee21e77a404e59fc093c82bb51e1/cryptography-48.0.1-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9621de99d2da096006b629979efd8ae7eb2d8b822488d0c89ee4000c306c59b1", size = 5289970, upload-time = "2026-06-09T22:31:20.368Z" }, + { url = "https://files.pythonhosted.org/packages/78/13/fba657f958d2af66ea959a4ba01212632089249d34af1ae48054136344d7/cryptography-48.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:88c852a0ae366e262e5a1744b685e6a433dc8788dd2a277e418bf4904203609d", size = 4731873, upload-time = "2026-06-09T22:31:22.253Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4c/9a964756d24a26b3e34dfcb16f961b89838786e6700b635b0d1e3adff4b6/cryptography-48.0.1-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:43c5835e2cb98c8733d86f57d6fc879b613f5c3478607281c3e36daffc6dd8a6", size = 4330804, upload-time = "2026-06-09T22:31:36.56Z" }, + { url = "https://files.pythonhosted.org/packages/4b/0f/a10f3a6eb12950a10e3a874070283aa2dd5875b2bfd15fad8a3e17b3f13e/cryptography-48.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:fe0180af5bf9236518a087e35bf2d9a347d5f5f51e63c579d683ddff424e3d46", size = 4696217, upload-time = "2026-06-09T22:31:13.351Z" }, + { url = "https://files.pythonhosted.org/packages/f3/6f/5cd12f951165ea73ef85266775d97e4c763b2474ccfd816dd69d3a18d6f8/cryptography-48.0.1-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:b7a2d1a937a738a881737cec135a38bb61470589b17515b9f73f571d0ae10401", size = 5245252, upload-time = "2026-06-09T22:32:02.193Z" }, + { url = "https://files.pythonhosted.org/packages/68/ab/8aaa12e4516ec4464033ab79b6f3b592bd5a92102467c4ace8a0d970203f/cryptography-48.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:b74ca3b8e5ecdd833bf6a002ca41b4793bb27fb8f1c06ffaf2643c9e9140e31b", size = 4731388, upload-time = "2026-06-09T22:32:04.019Z" }, + { url = "https://files.pythonhosted.org/packages/1b/24/50027ea4dca85ec1f40688f3c24fb32ccacd520583c9592c3cc95628e6fb/cryptography-48.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2c37f2461406063b417837f5f3daab668652acd82423efcd7f0a9f04be972de1", size = 4824186, upload-time = "2026-06-09T22:32:18.707Z" }, + { url = "https://files.pythonhosted.org/packages/52/41/04cb5eb17085ade6f50cc611fb657df6a0f5885350de8764ece89c050197/cryptography-48.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:86fe77abb1bd87afb251d4d02ada7ecf53a32cee9b67d976abb2e45a13297475", size = 4964539, upload-time = "2026-06-09T22:31:18.793Z" }, + { url = "https://files.pythonhosted.org/packages/36/bf/ed70785c496e89d7e73b7cda2d21f2447fd6d4e821714b8d04ff217fed92/cryptography-48.0.1-cp39-abi3-win32.whl", hash = "sha256:6b2c0c3e6ccf3ade7750f836ef3ee36eea250cc467d45c256895573ac08cc6f1", size = 3282307, upload-time = "2026-06-09T22:30:53.162Z" }, + { url = "https://files.pythonhosted.org/packages/b3/ff/371ea7d252656ee1eb6d83eeeef3d1d0c6baf1d6497687d081ea03814670/cryptography-48.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:9a49ca6c81417f6a5edb50375a60cccdd70fa0a91a5211829dbea74eba94d2ac", size = 3793408, upload-time = "2026-06-09T22:32:15.191Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d3/eb4e394e587341fdad09a09101fa76478ead3a78b0ad63e55c22f0d75c02/cryptography-48.0.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:08a597acce1ff37f347400087776599e2348a3a8bc53b44120e463cd274efe4a", size = 3951747, upload-time = "2026-06-09T22:31:23.871Z" }, + { url = "https://files.pythonhosted.org/packages/e0/4a/3f43451b4f858bfceaaaffc649e6e787e8d4fb332a1d443af39ab02cc8f1/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:735824ec41b7f74a7c45fb1591349333e4c696cb6c044e5f46356e560143e4cd", size = 4641226, upload-time = "2026-06-09T22:31:02.532Z" }, + { url = "https://files.pythonhosted.org/packages/73/4e/855584c2c23b09e4ce2d3b9c30e983e679cd60b068c513c6bbdb91e11782/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:92a46e1d638daa264ba2971c0b0489c9409787943efae4d60ffda3d091ef832c", size = 4668958, upload-time = "2026-06-09T22:32:06.213Z" }, + { url = "https://files.pythonhosted.org/packages/42/3b/d35750e41d803d1e516fd6d6011f065424924da7af1748cef4cc9cb3ede1/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:7e234ac052af99f2700826a5c29ea99d9c1b1f80341cde62d11c8154dc8e0bd9", size = 4640793, upload-time = "2026-06-09T22:32:26.331Z" }, + { url = "https://files.pythonhosted.org/packages/ca/aa/cdb7181fe865285e87e96825aaab239400f1de0c3bfba9bd9769b79f1a92/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:33842cf0888951cef5bc7ac724ab844a42044c1727b967b7f8997289a0464f92", size = 4668505, upload-time = "2026-06-09T22:31:27.534Z" }, + { url = "https://files.pythonhosted.org/packages/5d/8c/ce3823c06c2804f194f9e64f0d67fa3f4094a39f2bb1a990cd03603af8fc/cryptography-48.0.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6184ca7b174f28d7c703f1290d4b297217c45355f77a98f67e9b7f14549ac54a", size = 3742204, upload-time = "2026-06-09T22:31:34.773Z" }, ] [[package]] @@ -793,15 +793,17 @@ wheels = [ [[package]] name = "darabonba-core" -version = "1.0.5" +version = "1.0.8" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohttp" }, { name = "alibabacloud-tea" }, { name = "requests" }, + { name = "websocket-client" }, ] +sdist = { url = "https://files.pythonhosted.org/packages/f5/83/9321ccdb7a800c2cb97d8fa34bead5f20141f27f804594fd1fd815c4cd07/darabonba_core-1.0.8.tar.gz", hash = "sha256:f1661960b368e342d3d36434be82d264b70a01c49e843921d8a4dacd217376ae", size = 27604, upload-time = "2026-07-13T02:07:34.093Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/66/d3/a7daaee544c904548e665829b51a9fa2572acb82c73ad787a8ff90273002/darabonba_core-1.0.5-py3-none-any.whl", hash = "sha256:671ab8dbc4edc2a8f88013da71646839bb8914f1259efc069353243ef52ea27c", size = 24580, upload-time = "2025-12-12T07:53:59.494Z" }, + { url = "https://files.pythonhosted.org/packages/6d/88/38800ca22f39a31fdb75c7b2867c61d3af5e2792cee0b72942a639c88a79/darabonba_core-1.0.8-py3-none-any.whl", hash = "sha256:ac093fdd40f88f2f9dfbbbfd7bc143495a3cb031f35b397c98d24edfa6b69483", size = 30957, upload-time = "2026-07-13T02:07:33.138Z" }, ] [[package]] @@ -1749,7 +1751,7 @@ requires-dist = [ { name = "certifi", specifier = "==2026.5.20" }, { name = "concurrent-log-handler", marker = "sys_platform == 'win32'", specifier = "==0.9.29" }, { name = "croniter", specifier = "==6.0.0" }, - { name = "cryptography", specifier = "==46.0.7" }, + { name = "cryptography", specifier = "==48.0.1" }, { name = "daytona", marker = "extra == 'daytona'", specifier = "==0.155.0" }, { name = "debugpy", marker = "extra == 'dev'", specifier = "==1.8.20" }, { name = "defusedxml", marker = "extra == 'wecom'", specifier = "==0.7.1" }, @@ -1819,7 +1821,7 @@ requires-dist = [ { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = "==1.3.0" }, { name = "python-dotenv", specifier = "==1.2.2" }, { name = "python-multipart", specifier = ">=0.0.9,<1" }, - { name = "python-multipart", marker = "extra == 'web'", specifier = "==0.0.27" }, + { name = "python-multipart", marker = "extra == 'web'", specifier = "==0.0.32" }, { name = "python-telegram-bot", extras = ["webhooks"], marker = "extra == 'messaging'", specifier = "==22.6" }, { name = "python-telegram-bot", extras = ["webhooks"], marker = "extra == 'termux'", specifier = "==22.6" }, { name = "pywin32", marker = "sys_platform == 'win32'", specifier = ">=306,<312" }, @@ -1839,10 +1841,10 @@ requires-dist = [ { name = "slack-sdk", marker = "extra == 'messaging'", specifier = "==3.43.0" }, { name = "slack-sdk", marker = "extra == 'slack'", specifier = "==3.43.0" }, { name = "sounddevice", marker = "extra == 'voice'", specifier = "==0.5.5" }, - { name = "starlette", marker = "extra == 'computer-use'", specifier = "==1.0.1" }, - { name = "starlette", marker = "extra == 'dev'", specifier = "==1.0.1" }, - { name = "starlette", marker = "extra == 'mcp'", specifier = "==1.0.1" }, - { name = "starlette", marker = "extra == 'web'", specifier = "==1.0.1" }, + { name = "starlette", marker = "extra == 'computer-use'", specifier = "==1.3.1" }, + { name = "starlette", marker = "extra == 'dev'", specifier = "==1.3.1" }, + { name = "starlette", marker = "extra == 'mcp'", specifier = "==1.3.1" }, + { name = "starlette", marker = "extra == 'web'", specifier = "==1.3.1" }, { name = "supermemory", marker = "extra == 'supermemory'", specifier = "==3.50.0" }, { name = "tenacity", specifier = "==9.1.4" }, { name = "ty", marker = "extra == 'dev'", specifier = "==0.0.21" }, @@ -1857,26 +1859,18 @@ provides-extras = ["anthropic", "exa", "firecrawl", "parallel-web", "fal", "edge [[package]] name = "hf-xet" -version = "1.3.1" +version = "1.5.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a6/d0/73454ef7ca885598a3194d07d5c517d91a840753c5b35d272600d7907f64/hf_xet-1.3.1.tar.gz", hash = "sha256:513aa75f8dc39a63cc44dbc8d635ccf6b449e07cdbd8b2e2d006320d2e4be9bb", size = 641393, upload-time = "2026-02-25T00:57:56.701Z" } +sdist = { url = "https://files.pythonhosted.org/packages/63/39/67be8d71f900d9a55761b6022821d6679fb56c64f1b6063d5af2c2606727/hf_xet-1.5.2.tar.gz", hash = "sha256:73044bd31bae33c984af832d19c752a0dffb67518fee9ddbd91d616e1101cf47", size = 903674, upload-time = "2026-07-16T17:29:56.833Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/56/79/9b6a5614230d7a871442d8d8e1c270496821638ba3a9baac16a5b9166200/hf_xet-1.3.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:08b231260c68172c866f7aa7257c165d0c87887491aafc5efeee782731725366", size = 3759716, upload-time = "2026-02-25T00:57:41.052Z" }, - { url = "https://files.pythonhosted.org/packages/d4/de/72acb8d7702b3cf9b36a68e8380f3114bf04f9f21cf9e25317457fe31f00/hf_xet-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0810b69c64e96dee849036193848007f665dca2311879c9ea8693f4fc37f1795", size = 3518075, upload-time = "2026-02-25T00:57:39.605Z" }, - { url = "https://files.pythonhosted.org/packages/1d/5c/ed728d8530fec28da88ee882b522fccf00dc98e9d7bae4cdb0493070cb17/hf_xet-1.3.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ecd38f98e7f0f41108e30fd4a9a5553ec30cf726df7473dd3e75a1b6d56728c2", size = 4174369, upload-time = "2026-02-25T00:57:32.697Z" }, - { url = "https://files.pythonhosted.org/packages/3c/db/785a0e20aa3086948a26573f1d4ff5c090e63564bf0a52d32eb5b4d82e8d/hf_xet-1.3.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:65411867d46700765018b1990eb1604c3bf0bf576d9e65fc57fdcc10797a2eb9", size = 3953249, upload-time = "2026-02-25T00:57:30.096Z" }, - { url = "https://files.pythonhosted.org/packages/c4/6a/51b669c1e3dbd9374b61356f554e8726b9e1c1d6a7bee5d727d3913b10ad/hf_xet-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1684c840c60da12d76c2a031ba40e4b154fdbf9593836fcf5ff090d95a033c61", size = 4152989, upload-time = "2026-02-25T00:57:48.308Z" }, - { url = "https://files.pythonhosted.org/packages/df/31/de07e26e396f46d13a09251df69df9444190e93e06a9d30d639e96c8a0ed/hf_xet-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b3012c0f2ce1f0863338491a2bc0fd3f84aded0e147ab25f230da1f5249547fd", size = 4390709, upload-time = "2026-02-25T00:57:49.845Z" }, - { url = "https://files.pythonhosted.org/packages/e3/c1/fcb010b54488c2c112224f55b71f80e44d1706d9b764a0966310b283f86e/hf_xet-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:4eb432e1aa707a65a7e1f8455e40c5b47431d44fe0fb1b0c5d53848c27469398", size = 3634142, upload-time = "2026-02-25T00:57:59.063Z" }, - { url = "https://files.pythonhosted.org/packages/da/a6/9ef49cc601c68209979661b3e0b6659fc5a47bfb40f3ebf29eae9ee09e5c/hf_xet-1.3.1-cp313-cp313t-win_arm64.whl", hash = "sha256:e56104c84b2a88b9c7b23ba11a2d7ed0ccbe96886b3f985a50cedd2f0e99853f", size = 3494918, upload-time = "2026-02-25T00:57:57.654Z" }, - { url = "https://files.pythonhosted.org/packages/75/f8/c2da4352c0335df6ae41750cf5bab09fdbfc30d3b4deeed9d621811aa835/hf_xet-1.3.1-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:581d1809a016f7881069d86a072168a8199a46c839cf394ff53970a47e4f1ca1", size = 3761755, upload-time = "2026-02-25T00:57:43.621Z" }, - { url = "https://files.pythonhosted.org/packages/c0/e5/a2f3eaae09da57deceb16a96ebe9ae1f6f7b9b94145a9cd3c3f994e7782a/hf_xet-1.3.1-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:329c80c86f2dda776bafd2e4813a46a3ee648dce3ac0c84625902c70d7a6ddba", size = 3523677, upload-time = "2026-02-25T00:57:42.3Z" }, - { url = "https://files.pythonhosted.org/packages/61/cd/acbbf9e51f17d8cef2630e61741228e12d4050716619353efc1ac119f902/hf_xet-1.3.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2973c3ff594c3a8da890836308cae1444c8af113c6f10fe6824575ddbc37eca7", size = 4178557, upload-time = "2026-02-25T00:57:35.399Z" }, - { url = "https://files.pythonhosted.org/packages/df/4f/014c14c4ae3461d9919008d0bed2f6f35ba1741e28b31e095746e8dac66f/hf_xet-1.3.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ed4bfd2e6d10cb86c9b0f3483df1d7dd2d0220f75f27166925253bacbc1c2dbe", size = 3958975, upload-time = "2026-02-25T00:57:34.004Z" }, - { url = "https://files.pythonhosted.org/packages/86/50/043f5c5a26f3831c3fa2509c17fcd468fd02f1f24d363adc7745fbe661cb/hf_xet-1.3.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:713913387cc76e300116030705d843a9f15aee86158337eeffb9eb8d26f47fcd", size = 4158298, upload-time = "2026-02-25T00:57:51.14Z" }, - { url = "https://files.pythonhosted.org/packages/08/9c/b667098a636a88358dbeb2caf90e3cb9e4b961f61f6c55bb312793424def/hf_xet-1.3.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e5063789c9d21f51e9ed4edbee8539655d3486e9cad37e96b7af967da20e8b16", size = 4395743, upload-time = "2026-02-25T00:57:52.783Z" }, - { url = "https://files.pythonhosted.org/packages/70/37/4db0e4e1534270800cfffd5a7e0b338f2137f8ceb5768000147650d34ea9/hf_xet-1.3.1-cp37-abi3-win_amd64.whl", hash = "sha256:607d5bbc2730274516714e2e442a26e40e3330673ac0d0173004461409147dee", size = 3638145, upload-time = "2026-02-25T00:58:02.167Z" }, - { url = "https://files.pythonhosted.org/packages/4e/46/1ba8d36f8290a4b98f78898bdce2b0e8fe6d9a59df34a1399eb61a8d877f/hf_xet-1.3.1-cp37-abi3-win_arm64.whl", hash = "sha256:851b1be6597a87036fe7258ce7578d5df3c08176283b989c3b165f94125c5097", size = 3500490, upload-time = "2026-02-25T00:58:00.667Z" }, + { url = "https://files.pythonhosted.org/packages/de/ba/2b70603c7552db82baeb2623e2336898304a17328845151be4fe1f48d420/hf_xet-1.5.2-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f922b8f5fb84f1dd3d7ab7a1316354a1bca9b1c73ecfc19c76e51a2a49d29799", size = 4033760, upload-time = "2026-07-16T17:29:43.884Z" }, + { url = "https://files.pythonhosted.org/packages/60/ac/b097a86a1e4a6098f3a79382643ab09d5733d87ccc864877ad1e12b49b70/hf_xet-1.5.2-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:045f84440c55cdeb659cf1a1dd48c77bcd0d2e93632e2fea8f2c3bdee79f38ed", size = 3841438, upload-time = "2026-07-16T17:29:45.539Z" }, + { url = "https://files.pythonhosted.org/packages/d3/35/db860aa3a0780660324a506ad4b3d322ddc6ecbba4b9340aed0942cbf21c/hf_xet-1.5.2-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db78c39c83d6279daddc98e2238f373ab8980685556d42472b4ec51abcf03e8c", size = 4428006, upload-time = "2026-07-16T17:29:46.996Z" }, + { url = "https://files.pythonhosted.org/packages/af/6b/832dd980af4b0c3ae0660e309285f2ffcdff2faa38129390dbb47aa4a3f9/hf_xet-1.5.2-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7db73c810500c54c6760be8c39d4b2e476974de85424c50063efc22fdda13025", size = 4221099, upload-time = "2026-07-16T17:29:48.525Z" }, + { url = "https://files.pythonhosted.org/packages/9e/05/ae50f0d34e3254e6c3e208beb2519f6b8673016fc4b3643badaf6450d186/hf_xet-1.5.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6395cfe3c9cbead4f16b31808b0e67eac428b66c656f856e99636adaddea878f", size = 4420766, upload-time = "2026-07-16T17:29:50.092Z" }, + { url = "https://files.pythonhosted.org/packages/07/a9/c050bc2743a2bcd68928bfee157b08681667a164a24ec95fbfcfcd717e08/hf_xet-1.5.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:cde8cd167126bb6109b2ceb19b844433a4988643e8f3e01dd9dd0e4a34535097", size = 4636716, upload-time = "2026-07-16T17:29:51.62Z" }, + { url = "https://files.pythonhosted.org/packages/e9/f8/68b01c5c2edb56ac9a67b3d076ffddcb90867abaee923923eb34e7a14e76/hf_xet-1.5.2-cp38-abi3-win_amd64.whl", hash = "sha256:ecf63d1cb69a9a7319910f8f83fcf9b46e7a32dfcf4b8f8eeddb55f647306e65", size = 3988373, upload-time = "2026-07-16T17:29:53.395Z" }, + { url = "https://files.pythonhosted.org/packages/39/c6/988383e9dc17294d536fcbcd6fd16eed882e411ad16c954984a53e47b09c/hf_xet-1.5.2-cp38-abi3-win_arm64.whl", hash = "sha256:1da28519496eb7c8094c11e4d25509b4a468457a0302d58136099db2fd9a671d", size = 3816957, upload-time = "2026-07-16T17:29:54.991Z" }, ] [[package]] @@ -2007,23 +2001,22 @@ wheels = [ [[package]] name = "huggingface-hub" -version = "1.4.1" +version = "1.24.0" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "click" }, { name = "filelock" }, { name = "fsspec" }, { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, { name = "httpx" }, { name = "packaging" }, { name = "pyyaml" }, - { name = "shellingham" }, { name = "tqdm" }, - { name = "typer-slim" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c4/fc/eb9bc06130e8bbda6a616e1b80a7aa127681c448d6b49806f61db2670b61/huggingface_hub-1.4.1.tar.gz", hash = "sha256:b41131ec35e631e7383ab26d6146b8d8972abc8b6309b963b306fbcca87f5ed5", size = 642156, upload-time = "2026-02-06T09:20:03.013Z" } +sdist = { url = "https://files.pythonhosted.org/packages/df/9b/d3bb4e7d792835daf34dd7091bbc7d7b4e0437d9388f1ea7239cce49f478/huggingface_hub-1.24.0.tar.gz", hash = "sha256:18431ff4daae0749aa9ba102fc952e314c98e1d30ebdec5319d85ca0a83e1ae5", size = 921848, upload-time = "2026-07-17T09:54:01.022Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d5/ae/2f6d96b4e6c5478d87d606a1934b5d436c4a2bce6bb7c6fdece891c128e3/huggingface_hub-1.4.1-py3-none-any.whl", hash = "sha256:9931d075fb7a79af5abc487106414ec5fba2c0ae86104c0c62fd6cae38873d18", size = 553326, upload-time = "2026-02-06T09:20:00.728Z" }, + { url = "https://files.pythonhosted.org/packages/5f/c3/aeaaf3911d2529614be18d1c8b5496afc185560e76568063d517283318af/huggingface_hub-1.24.0-py3-none-any.whl", hash = "sha256:6ed4120a84a6beec900640aa7e346bd766a6b7341e41526fef5dc8bd81fb7d59", size = 771904, upload-time = "2026-07-17T09:53:59.106Z" }, ] [[package]] @@ -3462,11 +3455,11 @@ wheels = [ [[package]] name = "python-multipart" -version = "0.0.27" +version = "0.0.32" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/69/9b/f23807317a113dc36e74e75eb265a02dd1a4d9082abc3c1064acd22997c4/python_multipart-0.0.27.tar.gz", hash = "sha256:9870a6a8c5a20a5bf4f07c017bd1489006ff8836cff097b6933355ee2b49b602", size = 44043, upload-time = "2026-04-27T10:51:26.649Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/99/78/4126abcbdbd3c559d43e0db7f7b9173fc6befe45d39a2856cc0b8ec2a5a6/python_multipart-0.0.27-py3-none-any.whl", hash = "sha256:6fccfad17a27334bd0193681b369f476eda3409f17381a2d65aa7df3f7275645", size = 29254, upload-time = "2026-04-27T10:51:24.997Z" }, + { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" }, ] [[package]] @@ -3991,15 +3984,15 @@ wheels = [ [[package]] name = "starlette" -version = "1.0.1" +version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, { name = "typing-extensions", marker = "python_full_version < '3.13'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/08/a3/84e821cc54b4ab50ae6dbc6ac3800a651b65ec35f045cc73785380654057/starlette-1.0.1.tar.gz", hash = "sha256:512399c5f1de7fac99c88572212ded9ddeddef2fb32afa82d724000e88b38f4f", size = 2659596, upload-time = "2026-05-21T21:58:58.433Z" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0", size = 2703240, upload-time = "2026-06-12T09:23:11.602Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/e1/b2df4bc09a1e51ff664c1e17018a4274b42e5e9352e4a478ea540512dc88/starlette-1.0.1-py3-none-any.whl", hash = "sha256:7c0e69b2ee1c848bd54669d908500117a3ee13de603a21427e5c6fc1adf98dcd", size = 72802, upload-time = "2026-05-21T21:58:56.551Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", hash = "sha256:c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6", size = 73632, upload-time = "2026-06-12T09:23:10.017Z" }, ] [[package]] @@ -4173,18 +4166,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" }, ] -[[package]] -name = "typer-slim" -version = "0.24.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typer" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a7/a7/e6aecc4b4eb59598829a3b5076a93aff291b4fdaa2ded25efc4e1f4d219c/typer_slim-0.24.0.tar.gz", hash = "sha256:f0ed36127183f52ae6ced2ecb2521789995992c521a46083bfcdbb652d22ad34", size = 4776, upload-time = "2026-02-16T22:08:51.2Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a7/24/5480c20380dfd18cf33d14784096dca45a24eae6102e91d49a718d3b6855/typer_slim-0.24.0-py3-none-any.whl", hash = "sha256:d5d7ee1ee2834d5020c7c616ed5e0d0f29b9a4b1dd283bdebae198ec09778d0e", size = 3394, upload-time = "2026-02-16T22:08:49.92Z" }, -] - [[package]] name = "types-certifi" version = "2021.10.8.3" @@ -4395,6 +4376,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" }, ] +[[package]] +name = "websocket-client" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" }, +] + [[package]] name = "websockets" version = "15.0.1" diff --git a/web/src/App.tsx b/web/src/App.tsx index 79f7e48535..cd35eea3dc 100644 --- a/web/src/App.tsx +++ b/web/src/App.tsx @@ -1,4 +1,6 @@ import { + lazy, + Suspense, useCallback, useEffect, useMemo, @@ -72,25 +74,27 @@ import { ProfileSwitcher } from "@/components/ProfileSwitcher"; import { ProfileScopeBanner } from "@/components/ProfileScopeBanner"; import { useSystemActions } from "@/contexts/useSystemActions"; import type { SystemAction } from "@/contexts/system-actions-context"; -import ConfigPage from "@/pages/ConfigPage"; -import DocsPage from "@/pages/DocsPage"; -import EnvPage from "@/pages/EnvPage"; -import FilesPage from "@/pages/FilesPage"; -import SessionsPage from "@/pages/SessionsPage"; -import LogsPage from "@/pages/LogsPage"; -import AnalyticsPage from "@/pages/AnalyticsPage"; -import ModelsPage from "@/pages/ModelsPage"; -import CronPage from "@/pages/CronPage"; -import ProfilesPage from "@/pages/ProfilesPage"; -import ProfileBuilderPage from "@/pages/ProfileBuilderPage"; -import SkillsPage from "@/pages/SkillsPage"; -import PluginsPage from "@/pages/PluginsPage"; -import McpPage from "@/pages/McpPage"; -import PairingPage from "@/pages/PairingPage"; -import ChannelsPage from "@/pages/ChannelsPage"; -import WebhooksPage from "@/pages/WebhooksPage"; -import SystemPage from "@/pages/SystemPage"; -import ChatPage from "@/pages/ChatPage"; +// Route pages are lazy-loaded so the initial dashboard shell does not pay for +// every admin surface (and heavy deps like xterm) up front. +const ConfigPage = lazy(() => import("@/pages/ConfigPage")); +const DocsPage = lazy(() => import("@/pages/DocsPage")); +const EnvPage = lazy(() => import("@/pages/EnvPage")); +const FilesPage = lazy(() => import("@/pages/FilesPage")); +const SessionsPage = lazy(() => import("@/pages/SessionsPage")); +const LogsPage = lazy(() => import("@/pages/LogsPage")); +const AnalyticsPage = lazy(() => import("@/pages/AnalyticsPage")); +const ModelsPage = lazy(() => import("@/pages/ModelsPage")); +const CronPage = lazy(() => import("@/pages/CronPage")); +const ProfilesPage = lazy(() => import("@/pages/ProfilesPage")); +const ProfileBuilderPage = lazy(() => import("@/pages/ProfileBuilderPage")); +const SkillsPage = lazy(() => import("@/pages/SkillsPage")); +const PluginsPage = lazy(() => import("@/pages/PluginsPage")); +const McpPage = lazy(() => import("@/pages/McpPage")); +const PairingPage = lazy(() => import("@/pages/PairingPage")); +const ChannelsPage = lazy(() => import("@/pages/ChannelsPage")); +const WebhooksPage = lazy(() => import("@/pages/WebhooksPage")); +const SystemPage = lazy(() => import("@/pages/SystemPage")); +const ChatPage = lazy(() => import("@/pages/ChatPage")); import { LanguageSwitcher } from "@/components/LanguageSwitcher"; import { ThemeSwitcher } from "@/components/ThemeSwitcher"; import { useI18n } from "@/i18n"; @@ -99,9 +103,25 @@ import { PluginPage, PluginSlot, usePlugins } from "@/plugins"; import type { PluginManifest } from "@/plugins"; import { useTheme } from "@/themes"; import { isDashboardEmbeddedChatEnabled } from "@/lib/dashboard-flags"; +import { latchChatActivation } from "@/lib/chat-activation"; import { api } from "@/lib/api"; import type { StatusResponse, UpdateCheckResponse } from "@/lib/api"; +function RouteFallback({ label = "Loading…" }: { label?: string }) { + return ( +

+
+ + {label} +
+
+ ); +} + function RootRedirect() { return ; } @@ -127,8 +147,10 @@ const CHAT_NAV_ITEM: NavItem = { * inline near the bottom of this file — so the PTY child, WebSocket, * and xterm instance survive when the user visits another tab and comes * back. A `display:none` toggle hides the terminal without unmounting. - * Routing still owns the URL so /chat deep-links, browser back/forward, - * and nav highlight keep working. + * The host itself is still deferred until the first /chat visit so the + * xterm chunk is not downloaded on unrelated pages. Routing still owns + * the URL so /chat deep-links, browser back/forward, and nav highlight + * keep working. */ const BUILTIN_ROUTES_CORE: Record = { "/": RootRedirect, @@ -378,6 +400,13 @@ export default function App() { const normalizedPath = pathname.replace(/\/$/, "") || "/"; const isChatRoute = normalizedPath === "/chat"; const embeddedChat = isDashboardEmbeddedChatEnabled(); + // Defer mounting the persistent chat host (and its xterm chunk) until the + // user has actually opened /chat at least once. Sticky after that so the + // PTY survives later tab switches. + const [chatHostMounted, setChatHostMounted] = useState(isChatRoute); + useEffect(() => { + setChatHostMounted((prev) => latchChatActivation(prev, isChatRoute)); + }, [isChatRoute]); // `dashboard.show_token_analytics` gates the Analytics nav item. The // page itself remains reachable by URL (it renders an explanation when @@ -737,35 +766,28 @@ export default function App() { )} > - - {routes.map(({ key, path, element }) => ( - - ))} - - } - /> - + }> + + {routes.map(({ key, path, element }) => ( + + ))} + + } + /> + + {embeddedChat && !chatOverriddenByPlugin && (pluginsLoading ? ( isChatRoute ? ( -
-
- - Loading chat… -
-
+ ) : null - ) : ( + ) : chatHostMounted ? (
- + + ) : null + } + > + +
- ))} + ) : isChatRoute ? ( + + ) : null)}
diff --git a/web/src/components/AuthWidget.tsx b/web/src/components/AuthWidget.tsx index 94d1b572c6..93657bf854 100644 --- a/web/src/components/AuthWidget.tsx +++ b/web/src/components/AuthWidget.tsx @@ -45,7 +45,14 @@ export function AuthWidget({ className }: AuthWidgetProps) { const [hidden, setHidden] = useState(false); const [error, setError] = useState(null); + // Loopback / --insecure mode: the auth gate is off, so /api/auth/me is a + // guaranteed 401. Don't fire the request at all — it only produces console + // noise ("Failed to load resource: 401") on every dashboard load. + const gated = + typeof window !== "undefined" && !!window.__HERMES_AUTH_REQUIRED__; + useEffect(() => { + if (!gated) return; let cancelled = false; api .getAuthMe() @@ -70,7 +77,10 @@ export function AuthWidget({ className }: AuthWidgetProps) { return () => { cancelled = true; }; - }, []); + }, [gated]); + + // Nothing to show in ungated mode — there is no logged-in identity. + if (!gated) return null; if (hidden) return null; diff --git a/web/src/components/ModelPickerDialog.tsx b/web/src/components/ModelPickerDialog.tsx index e73c959e6f..1b280123c1 100644 --- a/web/src/components/ModelPickerDialog.tsx +++ b/web/src/components/ModelPickerDialog.tsx @@ -217,15 +217,22 @@ export function ModelPickerDialog(props: Props) { // Fuzzy-ranked providers: match on name + slug + the provider's model ids so // typing a model name surfaces its provider (preserves the prior behaviour // where a model match also revealed its provider). - const filteredProviders = useMemo( - () => - fuzzyRank( - providers, - trimmedQuery, - (p) => `${p.name} ${p.slug} ${(p.models ?? []).join(" ")}`, - ).map((r) => r.item), - [providers, trimmedQuery], - ); + // + // With no query, float providers that actually have models to the top + // (stable within each group). A fresh install lists ~40 providers and only + // a couple are configured — burying "OpenRouter · 37 models" under a wall + // of "0 models" rows made the picker feel broken. + const filteredProviders = useMemo(() => { + const ranked = fuzzyRank( + providers, + trimmedQuery, + (p) => `${p.name} ${p.slug} ${(p.models ?? []).join(" ")}`, + ).map((r) => r.item); + if (trimmedQuery) return ranked; + const withModels = ranked.filter((p) => (p.models ?? []).length > 0); + const withoutModels = ranked.filter((p) => (p.models ?? []).length === 0); + return [...withModels, ...withoutModels]; + }, [providers, trimmedQuery]); // A query that matched the SELECTED provider by name/slug (not its models) // located that provider — it shouldn't also hide that provider's models diff --git a/web/src/lib/log-classify.test.ts b/web/src/lib/log-classify.test.ts new file mode 100644 index 0000000000..ea9178390e --- /dev/null +++ b/web/src/lib/log-classify.test.ts @@ -0,0 +1,50 @@ +import { describe, expect, it } from "vitest"; +import { classifyLine } from "./log-classify"; + +const TS = "2026-07-26 13:07:45,228"; + +describe("classifyLine", () => { + it("classifies by the structured level token", () => { + expect(classifyLine(`${TS} INFO run_agent: client created`)).toBe("info"); + expect(classifyLine(`${TS} DEBUG registry: scanned 12 tools`)).toBe( + "debug", + ); + expect(classifyLine(`${TS} WARNING hermes_state: WAL disabled`)).toBe( + "warning", + ); + expect(classifyLine(`${TS} ERROR gateway: connect failed`)).toBe("error"); + expect(classifyLine(`${TS} CRITICAL agent: giving up`)).toBe("error"); + }); + + it("does NOT flag INFO lines whose payload mentions errors", () => { + // Regression: these rendered red with the old substring heuristic. + expect( + classifyLine( + `${TS} INFO tui_gateway.ws: ws closed peer=127.0.0.1:43212 parse_errors=0 dispatch_crashes=0 send_failures=1`, + ), + ).toBe("info"); + expect(classifyLine(`${TS} INFO logs: rotating errors.log`)).toBe("info"); + expect( + classifyLine(`${TS} INFO retry: recovered from FatalError subclass`), + ).toBe("info"); + }); + + it("does NOT let payload text spoof a higher level", () => { + expect( + classifyLine(`${TS} INFO chat: user said "ERROR ERROR ERROR"`), + ).toBe("info"); + expect(classifyLine(`${TS} DEBUG probe: WARNING string seen`)).toBe( + "debug", + ); + }); + + it("falls back to word-boundary matching for untimestamped lines", () => { + expect(classifyLine("ValueError: bad input")).toBe("info"); // no bare token + expect(classifyLine("ERROR: something broke")).toBe("error"); + expect(classifyLine("Traceback (most recent call last):")).toBe("error"); + expect(classifyLine(" WARNING low disk")).toBe("warning"); + expect(classifyLine("errors=0 all good")).toBe("info"); + expect(classifyLine("wrote to errors.log")).toBe("info"); + expect(classifyLine("just a plain line")).toBe("info"); + }); +}); diff --git a/web/src/lib/log-classify.ts b/web/src/lib/log-classify.ts new file mode 100644 index 0000000000..51379b16aa --- /dev/null +++ b/web/src/lib/log-classify.ts @@ -0,0 +1,36 @@ +/** + * Log-line level classification for the dashboard Logs page. + * + * Prefers the structured level token emitted by hermes_logging + * ("2026-07-26 13:07:45,228 INFO …"); falls back to word-boundary matching + * for untimestamped lines (tracebacks, wrapped continuations). Plain + * substring matching is deliberately avoided — INFO lines carrying payloads + * like "parse_errors=0" or paths like "errors.log" must not render red. + */ + +export type LogLevel = "error" | "warning" | "info" | "debug"; + +// Level token as emitted by hermes_logging, anchored to the line head so +// payload text can't spoof the level. +const LEVEL_TOKEN_RE = + /^\d{4}-\d{2}-\d{2}[ T][\d:,.]+\s+(DEBUG|INFO|WARNING|WARN|ERROR|CRITICAL|FATAL)\b/; + +export function classifyLine(line: string): LogLevel { + const token = LEVEL_TOKEN_RE.exec(line)?.[1]; + if (token) { + if (token === "ERROR" || token === "CRITICAL" || token === "FATAL") + return "error"; + if (token === "WARNING" || token === "WARN") return "warning"; + if (token === "DEBUG") return "debug"; + return "info"; + } + const upper = line.toUpperCase(); + if ( + /\b(ERROR|CRITICAL|FATAL)\b/.test(upper) || + upper.startsWith("TRACEBACK (") + ) + return "error"; + if (/\b(WARNING|WARN)\b/.test(upper)) return "warning"; + if (/\bDEBUG\b/.test(upper)) return "debug"; + return "info"; +} diff --git a/web/src/lib/resolve-page-title.test.ts b/web/src/lib/resolve-page-title.test.ts new file mode 100644 index 0000000000..8b2f5694b9 --- /dev/null +++ b/web/src/lib/resolve-page-title.test.ts @@ -0,0 +1,56 @@ +import { describe, expect, it } from "vitest"; +import { resolvePageTitle } from "./resolve-page-title"; +import type { Translations } from "@/i18n/types"; + +// Minimal translations stub — only the fields resolvePageTitle touches. +const t = { + app: { + webUi: "Web UI", + nav: { + analytics: "Analytics", + chat: "Chat", + config: "Config", + cron: "Cron", + documentation: "Documentation", + keys: "Keys", + logs: "Logs", + models: "Models", + profiles: "Profiles", + plugins: "Plugins", + sessions: "Sessions", + skills: "Skills", + }, + }, +} as unknown as Translations; + +describe("resolvePageTitle", () => { + it("uses i18n nav keys for translated routes", () => { + expect(resolvePageTitle("/sessions", t, [])).toBe("Sessions"); + expect(resolvePageTitle("/env", t, [])).toBe("Keys"); + }); + + it("renders initialisms and literal labels correctly", () => { + // Regression: the naive capitalize fallback produced "Mcp". + expect(resolvePageTitle("/mcp", t, [])).toBe("MCP"); + expect(resolvePageTitle("/system", t, [])).toBe("System"); + expect(resolvePageTitle("/channels", t, [])).toBe("Channels"); + expect(resolvePageTitle("/webhooks", t, [])).toBe("Webhooks"); + expect(resolvePageTitle("/pairing", t, [])).toBe("Pairing"); + expect(resolvePageTitle("/files", t, [])).toBe("Files"); + }); + + it("prefers plugin tab labels", () => { + expect( + resolvePageTitle("/kanban", t, [{ path: "/kanban", label: "Kanban" }]), + ).toBe("Kanban"); + }); + + it("falls back to capitalized path segment for unknown routes", () => { + expect(resolvePageTitle("/whatever", t, [])).toBe("Whatever"); + }); + + it("treats root as sessions and trailing slashes as equivalent", () => { + expect(resolvePageTitle("/", t, [])).toBe("Sessions"); + expect(resolvePageTitle("/mcp/", t, [])).toBe("MCP"); + }); +}); diff --git a/web/src/lib/resolve-page-title.ts b/web/src/lib/resolve-page-title.ts index 2b25e1a446..15fa5b3824 100644 --- a/web/src/lib/resolve-page-title.ts +++ b/web/src/lib/resolve-page-title.ts @@ -15,6 +15,18 @@ const BUILTIN: Record = { "/docs": "documentation", }; +// Built-in routes without an i18n nav key. Keep these in sync with the +// sidebar labels in App.tsx — the naive capitalize fallback below mangles +// initialisms ("/mcp" → "Mcp") and can't match multi-word labels. +const BUILTIN_LITERAL: Record = { + "/files": "Files", + "/mcp": "MCP", + "/channels": "Channels", + "/webhooks": "Webhooks", + "/pairing": "Pairing", + "/system": "System", +}; + export function resolvePageTitle( pathname: string, t: Translations, @@ -32,6 +44,10 @@ export function resolvePageTitle( if (key) { return t.app.nav[key]; } + const literal = BUILTIN_LITERAL[normalized]; + if (literal) { + return literal; + } // Derive title from pathname: "/profiles" → "Profiles" const segment = normalized.slice(1); if (segment) { diff --git a/web/src/pages/ChatPage.tsx b/web/src/pages/ChatPage.tsx index f7432d267c..81b6b30751 100644 --- a/web/src/pages/ChatPage.tsx +++ b/web/src/pages/ChatPage.tsx @@ -26,7 +26,7 @@ import { Button } from "@nous-research/ui/ui/components/button"; import { Typography } from "@nous-research/ui/ui/components/typography/index"; import { cn } from "@/lib/utils"; import { Copy, PanelRight, RotateCcw, X } from "lucide-react"; -import { useCallback, useEffect, useMemo, useRef, useState } from "react"; +import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react"; import { createPortal } from "react-dom"; import { useSearchParams } from "react-router-dom"; @@ -407,17 +407,16 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) { return () => mql.removeEventListener("change", onChange); }, []); - useEffect(() => { - // When hidden (non-chat tab) we must not register the header button — - // another page owns the header's end slot at that point. - if (!isActive) { - setEnd(null); - return; - } - if (!narrow) { - setEnd(null); - return; - } + useLayoutEffect(() => { + // When hidden (non-chat tab) another page owns the header's end slot. + // Don't touch it AT ALL — the persistent chat host mounts (plugin + // manifests resolving) and updates AFTER the routed page's layout + // effect has already filled the slot, so even a "defensive" + // setEnd(null) here wipes that page's header buttons (Cron "Create", + // Profiles "Build", …). Ownership rule: only write to the slot while + // /chat is the active route AND the narrow layout needs the button; + // the effect cleanup handles removal on every transition out. + if (!isActive || !narrow) return; setEnd( )} diff --git a/web/src/pages/LogsPage.tsx b/web/src/pages/LogsPage.tsx index 94dd3957b0..50163cad31 100644 --- a/web/src/pages/LogsPage.tsx +++ b/web/src/pages/LogsPage.tsx @@ -17,25 +17,16 @@ import { Label } from "@nous-research/ui/ui/components/label"; import { useI18n } from "@/i18n"; import { usePageHeader } from "@/contexts/usePageHeader"; import { PluginSlot } from "@/plugins"; +// Level classification is unit-tested in @/lib/log-classify; it prefers the +// structured level token and falls back to word-boundary matching so payload +// text like "parse_errors=0" can't render an INFO line red. +import { classifyLine } from "@/lib/log-classify"; const FILES = ["agent", "errors", "gateway"] as const; const LEVELS = ["ALL", "DEBUG", "INFO", "WARNING", "ERROR"] as const; const COMPONENTS = ["all", "gateway", "agent", "tools", "cli", "cron"] as const; const LINE_COUNTS = [50, 100, 200, 500] as const; -function classifyLine(line: string): "error" | "warning" | "info" | "debug" { - const upper = line.toUpperCase(); - if ( - upper.includes("ERROR") || - upper.includes("CRITICAL") || - upper.includes("FATAL") - ) - return "error"; - if (upper.includes("WARNING") || upper.includes("WARN")) return "warning"; - if (upper.includes("DEBUG")) return "debug"; - return "info"; -} - const LINE_COLORS: Record = { error: "text-destructive", warning: "text-warning", diff --git a/web/src/pages/SessionsPage.tsx b/web/src/pages/SessionsPage.tsx index b721821ac3..f14ebee63d 100644 --- a/web/src/pages/SessionsPage.tsx +++ b/web/src/pages/SessionsPage.tsx @@ -614,10 +614,14 @@ function SessionRow({ )}
- - {(session.model ?? t.common.unknown).split("/").pop()} - - · + {session.model && ( + <> + + {session.model.split("/").pop()} + + · + + )} {session.message_count} {t.common.msgs} @@ -1752,19 +1756,29 @@ export default function SessionsPage() { className="flex min-w-0 max-w-full flex-col gap-2 border border-border p-3 sm:flex-row sm:items-center sm:justify-between" >
- - {s.title ?? t.common.untitled} + + {s.title ?? + (s.preview + ? s.preview.slice(0, 60) + : t.common.untitled)} - - {(s.model ?? t.common.unknown).split("/").pop()} - {" "} - · {s.message_count} {t.common.msgs} ·{" "} + {s.model && ( + <> + + {s.model.split("/").pop()} + {" "} + ·{" "} + + )} + {s.message_count} {t.common.msgs} ·{" "} {timeAgo(s.last_active)} - {s.preview && ( + {s.preview && s.title && (

{s.preview}

diff --git a/web/vite.config.ts b/web/vite.config.ts index 6521751af9..6a04b624a1 100644 --- a/web/vite.config.ts +++ b/web/vite.config.ts @@ -86,6 +86,51 @@ export default defineConfig({ build: { outDir: "../hermes_cli/web_dist", emptyOutDir: true, + // Shell stays a bit over Vite's 500 kB default after vendor splits; + // page/xterm chunks load on demand. Keep a modest ceiling so a true + // regression still warns. + chunkSizeWarningLimit: 600, + // Split heavy vendors so the first dashboard paint does not download + // xterm/three/plot/etc. until a route actually needs them. Lazy page + // imports in App.tsx create the route boundaries; these groups keep + // shared node_modules out of every page chunk. + rolldownOptions: { + output: { + codeSplitting: { + minSize: 20_000, + groups: [ + { + name: "react-vendor", + test: /node_modules[\\/](react|react-dom|scheduler|react-router|react-router-dom)([\\/]|$)/, + }, + { + name: "xterm", + test: /node_modules[\\/]@xterm[\\/]/, + }, + { + name: "three", + test: /node_modules[\\/](three|@react-three)([\\/]|$)/, + }, + { + name: "plot", + test: /node_modules[\\/]@observablehq[\\/]plot([\\/]|$)/, + }, + { + name: "motion", + test: /node_modules[\\/](motion|framer-motion)([\\/]|$)/, + }, + { + name: "ui", + test: /node_modules[\\/]@nous-research[\\/]ui([\\/]|$)/, + }, + { + name: "vendor", + test: /node_modules[\\/]/, + }, + ], + }, + }, + }, }, server: { proxy: { diff --git a/website/docs/developer-guide/agent-loop.md b/website/docs/developer-guide/agent-loop.md index da904d2ef0..24cee51082 100644 --- a/website/docs/developer-guide/agent-loop.md +++ b/website/docs/developer-guide/agent-loop.md @@ -181,7 +181,7 @@ These tools modify agent state directly and return synthetic tool results withou The agent tracks iterations via `IterationBudget`: -- Default: 90 iterations (configurable via `agent.max_turns`) +- Default: 500 iterations (configurable via `agent.max_turns`) - Each agent gets its own budget. Subagents get independent budgets capped at `delegation.max_iterations` (default 50) — total iterations across parent + subagents can exceed the parent's cap - At 100%, the agent stops and returns a summary of work done diff --git a/website/docs/guides/migrate-from-openclaw.md b/website/docs/guides/migrate-from-openclaw.md index 38a27e6226..669497bd1c 100644 --- a/website/docs/guides/migrate-from-openclaw.md +++ b/website/docs/guides/migrate-from-openclaw.md @@ -8,6 +8,10 @@ description: "Complete guide to migrating your OpenClaw / Clawdbot setup to Herm `hermes claw migrate` imports your OpenClaw (or legacy Clawdbot/Moldbot) setup into Hermes. This guide covers exactly what gets migrated, the config key mappings, and what to verify after migration. +:::note +Coming from **Claude Code** or **OpenAI Codex CLI** instead? Use [`hermes import-agent`](../user-guide/import-from-other-agents.md). +::: + :::tip If your OpenClaw setup was multi-provider, `hermes setup --portal` collapses it to one OAuth — 300+ models plus the Tool Gateway in a single login. See [Nous Portal](/integrations/nous-portal). ::: diff --git a/website/docs/guides/python-library.md b/website/docs/guides/python-library.md index 24d1aecc95..1fb0387400 100644 --- a/website/docs/guides/python-library.md +++ b/website/docs/guides/python-library.md @@ -309,7 +309,7 @@ print(review) | `disabled_toolsets` | `List[str]` | `None` | Blacklist specific toolsets | | `save_trajectories` | `bool` | `False` | Save conversations to JSONL | | `ephemeral_system_prompt` | `str` | `None` | Custom system prompt (not saved to trajectories) | -| `max_iterations` | `int` | `90` | Max tool-calling iterations per conversation | +| `max_iterations` | `int` | `500` | Max tool-calling iterations per conversation | | `skip_context_files` | `bool` | `False` | Skip loading AGENTS.md files | | `skip_memory` | `bool` | `False` | Disable persistent memory read/write | | `api_key` | `str` | `None` | API key (falls back to env vars) | @@ -329,5 +329,5 @@ print(review) :::warning - **Thread safety**: Create one `AIAgent` per thread or task. Never share an instance across concurrent calls. - **Resource cleanup**: The agent automatically cleans up resources (terminal sessions, browser instances) when a conversation ends. If you're running in a long-lived process, ensure each conversation completes normally. -- **Iteration limits**: The default `max_iterations=90` is generous. For simple Q&A use cases, consider lowering it (e.g., `max_iterations=10`) to prevent runaway tool-calling loops and control costs. +- **Iteration limits**: The default `max_iterations=500` is generous. For simple Q&A use cases, consider lowering it (e.g., `max_iterations=10`) to prevent runaway tool-calling loops and control costs. ::: diff --git a/website/docs/guides/run-hermes-with-nous-portal.md b/website/docs/guides/run-hermes-with-nous-portal.md index d25a628bbf..1f64f03d6a 100644 --- a/website/docs/guides/run-hermes-with-nous-portal.md +++ b/website/docs/guides/run-hermes-with-nous-portal.md @@ -228,7 +228,7 @@ The quarantine clears automatically on successful re-login. ### Model I want isn't in the `/model` picker -The Portal catalog mirrors OpenRouter's model list (300+). If a model is missing, try typing the OpenRouter-style slug directly: +The Portal catalog draws on OpenRouter's model list (300+) plus models served through proprietary or secondary providers. If a model is missing, try typing the OpenRouter-style slug directly: ```bash /model anthropic/claude-opus-4.6 diff --git a/website/docs/integrations/nous-portal.md b/website/docs/integrations/nous-portal.md index c47adb1073..fcf20f8574 100644 --- a/website/docs/integrations/nous-portal.md +++ b/website/docs/integrations/nous-portal.md @@ -42,7 +42,11 @@ The Portal proxies a curated catalog of agentic models from across the ecosystem | **Hermes** | Hermes-4-70B, Hermes-4-405B (chat, see [note below](#a-note-on-hermes-4)) | | **+ everything else** | 280+ additional models — the full agentic frontier | -Routing happens through OpenRouter under the hood, so model availability and failover behavior matches what you'd get with an OpenRouter key — just billed against your Nous subscription instead. Switch between Claude Sonnet 4.6 for code and Gemini 3 Pro for long context with `/model` mid-session — no new credentials, no top-ups, no surprise zero-balance errors. +Under the hood, the Portal routes each model to the backend best suited for it — some models go through OpenRouter, others through proprietary or secondary providers, and the routing for a given model can change over time. Everything is billed against your Nous subscription either way. Switch between Claude Sonnet 4.6 for code and Gemini 3 Pro for long context with `/model` mid-session — no new credentials, no top-ups, no surprise zero-balance errors. + +:::note +Because routing is per-model and not always through OpenRouter, OpenRouter-specific request extensions (such as `provider` routing preferences, `session_id` sticky routing, or top-level `cache_control`) are not part of the Portal's API contract and may be ignored depending on which backend serves the model. +::: ### The Nous Tool Gateway @@ -251,7 +255,7 @@ Your Portal refresh token was invalidated (password change, manual revoke, or se ### Want to use a specific provider model that the Portal doesn't expose -The Portal proxies through OpenRouter, so any model that OpenRouter supports is generally available. If a specific model isn't appearing in `/model`, try the OpenRouter-style slug directly: +The Portal routes each model to a suitable backend — some through OpenRouter, others through proprietary or secondary providers — so most models OpenRouter supports are generally available. If a specific model isn't appearing in `/model`, try the OpenRouter-style slug directly: ```bash /model anthropic/claude-opus-4.6 diff --git a/website/docs/reference/cli-commands.md b/website/docs/reference/cli-commands.md index cdf16ad1c2..9084e81fae 100644 --- a/website/docs/reference/cli-commands.md +++ b/website/docs/reference/cli-commands.md @@ -85,6 +85,7 @@ hermes [global-options] [subcommand/options] | `hermes sessions` | Browse, export, prune, rename, and delete sessions. | | `hermes insights` | Show token/cost/activity analytics. | | `hermes claw` | OpenClaw migration helpers. | +| `hermes import-agent` | Import a Claude Code (`~/.claude`) or Codex CLI (`~/.codex`) setup. | | `hermes dashboard` | Launch the web dashboard for managing config, API keys, and sessions. | | `hermes desktop` (alias `gui`) | Build and launch the native Electron desktop app. | | `hermes profile` | Manage profiles — multiple isolated Hermes instances. | @@ -120,7 +121,7 @@ Common options: | `--ignore-rules` | Skip auto-injection of `AGENTS.md`, `SOUL.md`, `.cursorrules`, persistent memory, and preloaded skills. Combine with `--ignore-user-config` for a fully isolated run. | | `--safe-mode` | Troubleshooting mode: disable ALL customizations — user config, rules/memory injection, plugins, shell hooks, and MCP servers (implies `--ignore-user-config` and `--ignore-rules`). Use to isolate whether a problem comes from your setup or from Hermes itself. | | `--source ` | Session source tag for filtering (default: `cli`). Use `tool` for third-party integrations that should not appear in user session lists. | -| `--max-turns ` | Maximum tool-calling iterations per conversation turn (default: 90, or `agent.max_turns` in config). | +| `--max-turns ` | Maximum tool-calling iterations per conversation turn (default: 500, or `agent.max_turns` in config). | Examples: @@ -1507,6 +1508,24 @@ hermes claw migrate --preset user-data --overwrite hermes claw migrate --source /home/user/old-openclaw ``` +## `hermes import-agent` + +```bash +hermes import-agent [claude-code|codex] [options] +``` + +Import a **Claude Code** (`~/.claude`) or **OpenAI Codex CLI** (`~/.codex`) setup into Hermes. Maps `CLAUDE.md`/`AGENTS.md` instructions to memory entries, `Bash(...)` permission allow/deny rules to `command_allowlist`/`approvals.deny`, MCP servers to `mcp_servers` in `config.yaml`, and skill directories into `~/.hermes/skills/`. Always previews before applying; API keys and credentials are never imported. + +| Option | Description | +| --- | --- | +| `agent` | `claude-code` or `codex` (default: auto-detect). | +| `--source ` | Custom source directory (default: `~/.claude` or `~/.codex`). | +| `--dry-run` | Preview only — write nothing. | +| `--overwrite` | Replace conflicting MCP servers / skills (default: skip). | +| `--yes`, `-y` | Skip confirmation prompts. | + +See the **[import guide](../user-guide/import-from-other-agents.md)** for the full mapping tables. + ## `hermes serve` ```bash diff --git a/website/docs/reference/environment-variables.md b/website/docs/reference/environment-variables.md index 9473ac605c..3626529740 100644 --- a/website/docs/reference/environment-variables.md +++ b/website/docs/reference/environment-variables.md @@ -733,7 +733,7 @@ Advanced per-platform knobs for throttling the outbound message batcher. Most us | Variable | Description | |----------|-------------| -| `HERMES_MAX_ITERATIONS` | Max tool-calling iterations per conversation (default: 90) | +| `HERMES_MAX_ITERATIONS` | Max tool-calling iterations per conversation (default: 500) | | `HERMES_INFERENCE_MODEL` | Override model name at process level (takes priority over `config.yaml` for the session). Also settable via `-m`/`--model` flag. | | `HERMES_YOLO_MODE` | Set to `1` to bypass dangerous-command approval prompts. Equivalent to `--yolo`. | | `HERMES_ACCEPT_HOOKS` | Auto-approve any unseen shell hooks declared in `config.yaml` without a TTY prompt. Equivalent to `--accept-hooks` or `hooks_auto_accept: true`. | diff --git a/website/docs/reference/slash-commands.md b/website/docs/reference/slash-commands.md index ce78b22e38..a8c1db8d4f 100644 --- a/website/docs/reference/slash-commands.md +++ b/website/docs/reference/slash-commands.md @@ -46,6 +46,7 @@ Type `/` in the CLI to open the autocomplete menu. Built-in commands are case-in | `/title` | Set a title for the current session (usage: /title My Session Name) | | `/compress [here [N] \| focus topic]` | Manually compress conversation context (flush memories + summarize). `/compress here [N]` summarizes everything except the most recent N exchanges (default 2), kept verbatim — pick your own compression boundary. A focus topic narrows what a full summary preserves. | | `/rollback` | List or restore filesystem checkpoints (usage: /rollback [number]) | +| `/diff [staged\|all\|session] [--stat] [path...]` | Show git changes in the working directory. Default: unstaged changes plus untracked files. `staged` shows what's staged for commit, `all` everything since HEAD, and `session` the cumulative diff of everything Hermes changed here (from the earliest retained checkpoint baseline — requires checkpoints to be enabled; complements `/rollback diff `). `--stat` prints just the changed-file summary; path arguments restrict the diff. | | `/snapshot [create\|restore \|prune]` (alias: `/snap`) | Create or restore state snapshots of Hermes config/state. `create [label]` saves a snapshot, `restore ` reverts to it, `prune [N]` removes old snapshots, or list all with no args. | | `/stop` | Kill all running background processes | | `/queue ` (alias: `/q`) | Queue a prompt for the next turn (doesn't interrupt the current agent response). | @@ -58,6 +59,7 @@ Type `/` in the CLI to open the autocomplete menu. Built-in commands are case-in | `/egress [status]` | Show Docker egress proxy status — enabled/configured/running state, credential source, token mappings, uncovered providers, and next remediation step. Works in CLI, TUI, Desktop chat, and messaging gateway. | | `/redraw` | Force a full UI repaint (recovers from terminal drift after tmux resize, mouse selection artifacts, etc.) | | `/status` | Show session info — model, provider, profile, session ID, working directory, title, created/updated timestamps, token totals, agent-running state — followed by a local **Session recap** block (recent user/assistant turn counts, tool result count, top tools used, last few files touched, the latest user prompt, and the latest assistant reply). The recap is computed locally from the in-memory conversation; no LLM call, no prompt-cache impact. | +| `/context [all]` (alias: `/ctx`) | Visual context-window breakdown. On the CLI/TUI: a 5×20 glyph block grid (each cell ≈ 1% of the model window) plus an estimated per-category table — system prompt, tool definitions, rules, skills index, MCP, subagents, memory, conversation — versus free space. On messaging platforms: a usage gauge with auto-compression threshold/headroom, compression stats, cumulative throughput, and the same category table in plain text. `/context all` appends per-skill and per-toolset cost listings (index cost vs SKILL.md load cost; schema tokens per toolset). Read-only and computed locally — no LLM call, no prompt-cache impact. | | `/agents` (alias: `/tasks`) | Show active agents and running tasks across the current session. | | `/background ` (alias: `/bg`, `/btw`) | Run a prompt in a separate background session. The agent processes your prompt independently — your current session stays free for other work. Results appear as a panel when the task finishes. See [CLI Background Sessions](/user-guide/cli#background-sessions). | | `/branch [name]` (alias: `/fork`) | Branch the current session (explore a different path) | @@ -72,6 +74,7 @@ Type `/` in the CLI to open the autocomplete menu. Built-in commands are case-in | `/codex-runtime [auto\|codex_app_server\|on\|off]` | Toggle the optional [Codex app-server runtime](../user-guide/features/codex-app-server-runtime) for OpenAI/Codex models. `auto` (default) uses Hermes' standard chat completions; `codex_app_server` hands turns to a `codex app-server` subprocess for native shell, apply_patch, ChatGPT subscription auth, and migrated Codex plugins. Effective on next session. | | `/personality` | Set a predefined personality | | `/verbose` | Cycle tool progress display: off → new → all → verbose. Can be [enabled for messaging](#notes) via config. | +| `/focus [on\|off\|status]` | Toggle **focus view** — a display-only reduced-output mode showing just your prompt and the final response. Composes with `/verbose`: turning it on snaps tool progress to `off` and remembers your previous mode, and `/focus off` restores it. Each turn ends with a dim recovery line (`⋯ 7 tool lines hidden · /focus off to show`) and a persistent `◉ focus` badge sits in the status bar so you always know you're in the reduced view. Nothing is sent differently to the model — detail is hidden, never discarded. | | `/fast [normal\|fast\|status]` | Toggle fast mode — OpenAI Priority Processing / Anthropic Fast Mode. Options: `normal`, `fast`, `status`. | | `/reasoning` | Manage reasoning effort and display (usage: /reasoning [level\|show\|hide]) | | `/skin` | Show or change the display skin/theme | @@ -95,6 +98,7 @@ Type `/` in the CLI to open the autocomplete menu. Built-in commands are case-in | `/memory [pending\|approve\|reject\|approval]` | Review pending memory writes staged by the write-approval gate (`memory.write_approval`) and toggle the gate. See [Controlling memory writes](/user-guide/features/memory#controlling-memory-writes-write_approval). | | `/bundles` | List configured skill bundles — `/` slash aliases that preload several skills at once. Configure under `bundles:` in `~/.hermes/config.yaml`. See [Skill Bundles](/user-guide/features/skills#skill-bundles). | | `/learn ` | Distill a reusable skill from anything you describe — a directory, a URL, the workflow you just walked the agent through, or pasted notes. Open-ended: the agent gathers the sources with its own tools and authors a `SKILL.md` following the house authoring standards. Works in the CLI, the messaging gateway, the TUI, and the dashboard Skills page. | +| `/init [notes]` | Generate or update `AGENTS.md` project instructions from a repo scan (port of Codex `/init`). The agent inspects manifests, layout, and toolchain configs with its read-only tools, then writes a concise `AGENTS.md` — or, if one exists, merge-updates it preserving your content. Optional notes steer the emphasis. Works in the CLI, the messaging gateway, and the TUI. | | `/cron` | Manage scheduled tasks (list, add/create, edit, pause, resume, run, remove) | | `/suggestions [accept\|dismiss N\|catalog\|clear]` (alias: `/suggest`) | Review suggested automations. Use `/suggestions` to list pending suggestions, `/suggestions accept ` to create the proposed automation, `/suggestions dismiss ` to reject one, `/suggestions catalog` to add curated starter automations, and `/suggestions clear` to clear resolved suggestion records. Accepted jobs preserve the current surface as the delivery origin. | | `/blueprint [name] [slot=value ...]` (alias: `/bp`) | Set up an automation from a blueprint template. Bare `/blueprint` lists the catalog; `/blueprint ` starts a guided slot-filling flow on the next agent turn; `/blueprint slot=value ...` creates the job directly. | @@ -230,6 +234,7 @@ The messaging gateway supports the following built-in commands inside Telegram, | `/reasoning [level\|show\|hide]` | Change reasoning effort or toggle reasoning display. | | `/voice [on\|off\|tts\|join\|channel\|leave\|status]` | Control spoken replies in chat. `join`/`channel`/`leave` manage Discord voice-channel mode. | | `/rollback [number]` | List or restore filesystem checkpoints. | +| `/diff [staged\|all\|session] [--stat]` | Show git changes in the working directory (fenced and truncated to platform message limits). `session` shows the cumulative diff of everything Hermes changed; `--stat` shows just the summary. | | `/background ` | Run a prompt in a separate background session. Results are delivered back to the same chat when the task finishes. See [Messaging Background Sessions](/user-guide/messaging/#background-sessions). | | `/queue ` (alias: `/q`) | Queue a prompt for the next turn without interrupting the current one. | | `/steer ` | Inject a message after the next tool call without interrupting — the model picks it up on its next iteration rather than as a new turn. | @@ -255,11 +260,13 @@ The messaging gateway supports the following built-in commands inside Telegram, ## Notes -- `/skin`, `/snapshot`, `/reload`, `/tools`, `/toolsets`, `/browser`, `/config`, `/cron`, `/platforms`, `/paste`, `/image`, `/statusbar`, `/battery`, `/plugins`, `/busy`, `/indicator`, `/redraw`, `/clear`, `/history`, `/save`, `/copy`, `/handoff`, `/billing`, and `/quit` are **CLI-only** commands. +- `/skin`, `/snapshot`, `/reload`, `/tools`, `/toolsets`, `/browser`, `/config`, `/cron`, `/platforms`, `/paste`, `/image`, `/statusbar`, `/battery`, `/focus`, `/plugins`, `/busy`, `/indicator`, `/redraw`, `/clear`, `/history`, `/save`, `/copy`, `/handoff`, `/billing`, and `/quit` are **CLI-only** commands. - `/skills` is **CLI-only for search/browse/install**; its write-approval review subcommands (`pending`, `approve`, `reject`, `diff`, `approval`) also work on messaging platforms when `skills.write_approval` is on. `/memory` works on **both** surfaces. - `/verbose` is **CLI-only by default**, but can be enabled for messaging platforms by setting `display.tool_progress_command: true` in `config.yaml`. When enabled, it cycles the `display.tool_progress` mode and saves to config. +- `/focus` and `/verbose` share one suppression path (`display.tool_progress`), so they can never contradict each other: `/focus on` pins tool progress to `off` and stashes your mode under `display.focus_saved_tool_progress`; `/focus off` restores it; cycling `/verbose` while focus is on takes the mode back and clears the focus badge. Focus view is display-only — it never changes conversation history, the system prompt, or anything sent to the model, so it has zero prompt-cache impact. - `/sethome`, `/update`, `/restart`, `/approve`, `/deny`, `/topic`, `/platform`, and `/commands` are **messaging-only** commands. -- `/status`, `/egress`, `/version`, `/background`, `/queue`, `/steer`, `/voice`, `/reload-mcp`, `/reload-skills`, `/rollback`, `/debug`, `/fast`, `/footer`, `/curator`, `/kanban`, `/credits`, `/suggestions`, `/blueprint`, `/learn`, `/sessions`, and `/yolo` work in **both** the CLI and the messaging gateway. +- `/status`, `/egress`, `/version`, `/background`, `/queue`, `/steer`, `/voice`, `/reload-mcp`, `/reload-skills`, `/rollback`, `/debug`, `/fast`, `/footer`, `/curator`, `/kanban`, `/credits`, `/suggestions`, `/blueprint`, `/learn`, `/init`, `/sessions`, and `/yolo` work in **both** the CLI and the messaging gateway. +- `/status`, `/egress`, `/version`, `/background`, `/queue`, `/steer`, `/voice`, `/reload-mcp`, `/reload-skills`, `/rollback`, `/diff`, `/debug`, `/fast`, `/footer`, `/curator`, `/kanban`, `/credits`, `/suggestions`, `/blueprint`, `/learn`, `/sessions`, and `/yolo` work in **both** the CLI and the messaging gateway. - `/voice join`, `/voice channel`, and `/voice leave` are only meaningful on Discord. - In the TUI, `/sessions` shows live sessions in the current TUI process. Use `/resume [name]` or `hermes --tui --resume ` for saved or closed transcripts. diff --git a/website/docs/user-guide/cli.md b/website/docs/user-guide/cli.md index ca10b14584..aa479f03c9 100644 --- a/website/docs/user-guide/cli.md +++ b/website/docs/user-guide/cli.md @@ -135,6 +135,7 @@ Common examples: | `/reasoning high` | Increase reasoning effort | | `/title My Session` | Name the current session | | `/status` | Show session info — model/profile/tokens/duration — followed by a local **Session recap** block (recent turn counts, top tools used, files touched, latest user prompt + assistant reply). Pure local compute; no LLM call. | +| `/context [all]` | Visual context-usage breakdown — glyph block grid + per-category token table (system prompt / tools / skills / memory / conversation / free space). `/context all` adds per-skill and per-toolset costs. | | `/sessions` | Open an interactive session picker right inside the classic CLI (same surface the TUI uses). Type to filter, arrow keys to navigate, Enter to resume. | For the full built-in CLI and messaging lists, see [Slash Commands Reference](../reference/slash-commands.md). diff --git a/website/docs/user-guide/configuration.md b/website/docs/user-guide/configuration.md index 96ce47b7f6..f7b015bba1 100644 --- a/website/docs/user-guide/configuration.md +++ b/website/docs/user-guide/configuration.md @@ -854,13 +854,13 @@ See [Memory Providers](/user-guide/features/memory-providers) for the analogous ## Iteration Budget -When the agent is working on a complex task with many tool calls, it can burn through its iteration budget (default: 90 turns). Hermes does **not** inject mid-task pressure warnings — earlier builds warned the model at 70%/90% budget, which caused models to abandon complex tasks prematurely and was removed in April 2026. +When the agent is working on a complex task with many tool calls, it can burn through its iteration budget (default: 500 turns). Hermes does **not** inject mid-task pressure warnings — earlier builds warned the model at 70%/90% budget, which caused models to abandon complex tasks prematurely and was removed in April 2026. -Instead, when the budget is actually exhausted (90/90), Hermes injects one message asking the model to wrap up and allows a single **grace call** so it can deliver a final response. If that grace call still doesn't produce text, the agent is asked to summarise what it accomplished. +Instead, when the budget is actually exhausted (500/500), Hermes injects one message asking the model to wrap up and allows a single **grace call** so it can deliver a final response. If that grace call still doesn't produce text, the agent is asked to summarise what it accomplished. ```yaml agent: - max_turns: 90 # Max iterations per conversation turn (default: 90) + max_turns: 500 # Max iterations per conversation turn (default: 500) api_max_retries: 3 # Retries per provider before fallback engages (default: 3) ``` @@ -1510,6 +1510,7 @@ This controls both the `text_to_speech` tool and spoken replies in voice mode (` display: tool_progress: all # off | new | all | verbose tool_progress_command: false # Enable /verbose slash command in messaging gateway + focus_view: false # CLI focus view (/focus) — reduced output, display-only platforms: {} # Per-platform display overrides (see below) tool_progress_overrides: {} # DEPRECATED — use display.platforms instead interim_assistant_messages: true # Gateway: send natural mid-turn assistant updates as separate messages @@ -1524,6 +1525,8 @@ display: show_cost: false # Show estimated $ cost in the CLI status bar timestamps: false # When true, prefixes user and assistant labels with [HH:MM] timestamps in the CLI / TUI transcript tool_preview_length: 0 # Max chars for tool call previews (0 = no limit, show full paths/commands) + turn_summary: true # CLI only: print a one-line post-turn accounting footer after each interactive turn + spinner_token_flow: true # CLI only: append live cumulative turn tokens to the spinner timer runtime_footer: # Gateway: append a runtime-context footer to final replies enabled: false fields: ["model", "context_pct", "cwd"] @@ -1532,6 +1535,33 @@ display: language: en # UI language for static messages (approval prompts, some gateway replies). en | zh | zh-hant | ja | de | es | fr | tr | uk | af | ko | it | ga | pt | ru | hu ``` +### Per-turn summary and spinner token flow + +`display.turn_summary` (default `true`) prints one dim accounting line after each **interactive CLI** turn, summarising what that turn actually did: + +``` +⋯ 12.4s · edited 2 files +18 -3 · read 4 files · ran 3 commands +``` + +The tally is observed from the tool-progress feed the CLI already receives, so it costs nothing extra. Details: + +- Wall time is the turn's real duration (`2m05s` past the one-minute mark). +- Tool calls are grouped by verb (`edited`, `read`, `ran`, `searched`, …) with correct pluralisation; plugin/MCP tools without a curated verb collapse into `called N tools`. +- `+X -Y` line deltas appear only when the tool result already reports a diff (currently `patch`). Hermes never shells out to git to compute them, so a `write_file` edit is counted without a delta. +- **Failed tool calls are not counted** — a denied write never renders as a successful edit (see the [file-mutation verifier](#file-mutation-verifier) for the complementary warning). +- Long turns cap at four verb segments plus a `+N more` tail so the line never wraps. +- A fast turn with no tool calls prints nothing at all. + +`display.spinner_token_flow` (default `true`) appends the running turn's cumulative output tokens to the CLI spinner's live timer: + +``` + ⚡ Reading cli.py ( 2.3s · ↓ 1.2k tok) +``` + +The count is per-turn (session totals are baselined at turn start) and updates as each API call in the turn reports usage. Nothing renders before the first usage report lands, so you never see a misleading `↓ 0 tok`. + +Both keys are display-only and CLI-only: they are suppressed in quiet mode, when `display.tool_progress` is `off`, in single-query/`-Q` batch runs, and in gateway/messaging surfaces (those use `display.runtime_footer` instead). Set either key to `false` to turn it off. + ### File-mutation verifier When `display.file_mutation_verifier` is `true` (default), Hermes appends a one-line advisory to the assistant's final response whenever a `write_file` or `patch` call failed during the turn and was never superseded by a successful write to the same path. This catches the "batch of parallel patches, half silently fail, model summarises success" class of over-claim without requiring you to manually run `git status` after every edit. @@ -1587,6 +1617,18 @@ In the CLI, cycle through these modes with `/verbose`. To use `/verbose` in mess Tool progress requires a gateway adapter that can display progress updates safely. Platforms without message editing support, including Signal, suppress tool-progress bubbles even if `/verbose` saves a non-`off` mode. +### Focus view (`/focus`, CLI + TUI) + +`display.focus_view: true` enables **focus view** — a reduced-output display mode for when you want the answer, not the play-by-play. It is a thin layer over the same `tool_progress` machinery rather than a second suppression path: + +- turning it on pins `tool_progress` to `off` and stashes your previous mode in `display.focus_saved_tool_progress`; +- `/focus off` restores that mode exactly, so a `/verbose verbose` setup survives a round trip; +- each completed turn ends with a dim recovery line — `⋯ 7 tool lines hidden · /focus off to show` — counted against your *pre-focus* mode, so it never claims to have hidden lines you had already turned off; +- a persistent `◉ focus` badge sits in the status bar (both the prompt_toolkit CLI and the Ink TUI) so the reduced mode is never invisible; +- cycling `/verbose` while focus is on hands the mode back to `/verbose` and clears the badge. + +Focus view is **display-only**. It never edits conversation history, the system prompt, tool schemas, or any request payload — hidden detail is suppressed on screen, never discarded, and prompt caching is completely unaffected. + ### Runtime-metadata footer (gateway only) When `display.runtime_footer.enabled: true`, Hermes appends a small runtime-context footer to the **final** message of each gateway turn. The current footer can show the model, context-window percentage, and current working directory. Off by default; opt in per-gateway if your team wants every reply to include this provenance. @@ -2011,6 +2053,15 @@ Smart mode is particularly useful for reducing approval fatigue — it lets the Setting `approvals.mode: off` disables all safety checks for terminal commands. Only use this in trusted, sandboxed environments. ::: +### Denial circuit breaker + +`approvals.denial_breaker_threshold` (default `3`) guards against the agent retrying variations of a command the smart-approval reviewer keeps denying — each retry burns another guardian LLM call. After that many consecutive denials in a session, the deny message escalates to a hard-stop instruction telling the agent to stop, report the blocked operation, and ask you to run it manually or `/approve`. Any approval resets the count; set `0` to disable: + +```yaml +approvals: + denial_breaker_threshold: 3 # 0 disables the breaker +``` + ### Deny rules `approvals.deny` is a list of glob patterns that block matching terminal commands unconditionally — even under `--yolo`, `/yolo`, or `mode: off`. It's the user-editable counterpart to the built-in hardline blocklist: @@ -2024,6 +2075,18 @@ approvals: Patterns are case-insensitive fnmatch globs and must be quoted in YAML (a bare leading `*` is a parse error). See [Security — User-Defined Deny Rules](/user-guide/security#user-defined-deny-rules-approvalsdeny) for details. +### Custom smart-approval policy + +`approvals.smart_policy` lets you append your own rules to the smart-approval reviewer's instructions. When set, the text is added to the guardian LLM's system prompt (the trusted channel — never alongside the untrusted command text), so you can tighten or relax its judgment for your environment without editing code: + +```yaml +approvals: + smart_policy: | + Always ESCALATE commands that modify anything under /etc. + APPROVE docker compose restarts in ~/deploys — they are routine here. +``` + + ## Checkpoints Automatic filesystem snapshots before destructive file operations. See the [Checkpoints & Rollback](/user-guide/checkpoints-and-rollback) for details. diff --git a/website/docs/user-guide/import-from-other-agents.md b/website/docs/user-guide/import-from-other-agents.md new file mode 100644 index 0000000000..53f8d7b230 --- /dev/null +++ b/website/docs/user-guide/import-from-other-agents.md @@ -0,0 +1,54 @@ +--- +sidebar_position: 9 +title: "Import from Other Agents" +description: "One-command import of a Claude Code (~/.claude) or OpenAI Codex CLI (~/.codex) setup into Hermes — instructions, allowlists, MCP servers, skills, and memories." +--- + +# Import from Other Agents + +`hermes import-agent` imports your existing **Claude Code** or **OpenAI Codex CLI** setup into Hermes with one command. It follows the same preview-first pattern as [`hermes claw migrate`](../guides/migrate-from-openclaw.md): you always see a per-item plan before anything is written, and `--dry-run` never touches disk. + +```bash +hermes import-agent # auto-detect ~/.claude or ~/.codex +hermes import-agent claude-code # import from ~/.claude +hermes import-agent codex # import from ~/.codex +hermes import-agent claude-code --dry-run # preview only +hermes import-agent codex --source /path/to/.codex # custom location +hermes import-agent claude-code --overwrite --yes # replace conflicts, skip prompts +``` + +## What gets imported + +### Claude Code (`~/.claude`) + +| Claude Code | Hermes | +|---|---| +| `CLAUDE.md` (global instructions) | Memory entries in `~/.hermes/memories/MEMORY.md` | +| `settings.json` → `permissions.allow` (`Bash(...)` rules) | `command_allowlist` in `config.yaml` | +| `settings.json` → `permissions.deny` (`Bash(...)` rules) | `approvals.deny` in `config.yaml` | +| `mcpServers` (from `~/.claude.json` and `settings.json`) | `mcp_servers` in `config.yaml` | +| `skills//` (dirs with `SKILL.md`) | `~/.hermes/skills/claude-code-imports//` | +| `commands/*.md` (slash commands) | Skipped with a note — convert them into skills | + +Claude's `Bash(npm run test:*)` prefix rules become `npm run test*` globs. Non-`Bash` permission rules (`Read(...)`, `WebFetch`, ...) gate Claude-specific tools and are reported as unmapped rather than imported. + +### Codex CLI (`~/.codex`) + +| Codex CLI | Hermes | +|---|---| +| `AGENTS.md` (global instructions) | Memory entries in `~/.hermes/memories/MEMORY.md` | +| `config.toml` → `[mcp_servers.*]` | `mcp_servers` in `config.yaml` | +| `memories/*.md` | Memory entries in `~/.hermes/memories/MEMORY.md` | +| `skills//` (dirs with `SKILL.md`) | `~/.hermes/skills/codex-imports//` | + +## What is never imported + +**API keys and credentials.** Credential files (`~/.claude/.credentials.json`, `~/.codex/auth.json`) are never read, and MCP server environment variables or headers with secret-looking names (`*_TOKEN`, `*_API_KEY`, `Authorization`, ...) are stripped and listed in the report so you can re-add them deliberately. Run `hermes setup` to configure providers, or add secrets to `~/.hermes/.env`. + +## Behavior notes + +- **Preview first, always.** The command prints the full plan before applying; in non-interactive sessions it stops at the preview unless you pass `--yes`. +- **Merges, not replaces.** Memory entries are deduplicated against your existing `MEMORY.md`; allowlist/denylist patterns merge with what's already in `config.yaml`. +- **Conflicts are skipped by default.** An MCP server or skill that already exists in Hermes is reported as a conflict; pass `--overwrite` to replace it. +- **Malformed files don't abort the run.** A broken `settings.json` or `config.toml` becomes a per-item error in the report while everything else still imports. +- Coming from OpenClaw instead? Use [`hermes claw migrate`](../guides/migrate-from-openclaw.md). diff --git a/website/docs/user-guide/messaging/telegram.md b/website/docs/user-guide/messaging/telegram.md index 1ea240fabf..346a00456c 100644 --- a/website/docs/user-guide/messaging/telegram.md +++ b/website/docs/user-guide/messaging/telegram.md @@ -538,6 +538,7 @@ Hermes Agent works in Telegram group chats with a few considerations: - `/command@botusername` (Telegram's bot-menu command form that includes the bot name) - matches for one of your configured regex wake words in `telegram.mention_patterns` - In groups with multiple Hermes bots, `telegram.exclusive_bot_mentions` keeps routing deterministic. When a message explicitly mentions one or more Telegram bot usernames, only the mentioned bot profiles process it; other Hermes bots ignore it before reply and wake-word fallbacks run. This is enabled by default. +- Renaming the bot's `@username` in BotFather is picked up automatically — Hermes follows the new handle for mention routing without a gateway restart. Collectible (Fragment) usernames that don't end in `bot` are supported too. - Use `telegram.ignored_threads` to keep Hermes silent in specific Telegram forum topics, even when the group would otherwise allow free responses or mention-triggered replies - If `telegram.require_mention` is left unset or false, Hermes keeps the previous open-group behavior and responds to normal group messages it can see diff --git a/website/docs/user-guide/security.md b/website/docs/user-guide/security.md index bb1d453db8..c94ee53ea1 100644 --- a/website/docs/user-guide/security.md +++ b/website/docs/user-guide/security.md @@ -233,6 +233,43 @@ These patterns are loaded at startup and silently approved in all future session Use `hermes config edit` to review or remove patterns from your permanent allowlist. ::: +### Mining Approval History (`hermes approvals suggest`) + +Instead of answering the same prompt session after session, you can mine your +past approval decisions into allowlist proposals: + +```bash +hermes approvals suggest # dry run — prints a numbered proposal +hermes approvals suggest --apply 1,3 # merge picks into command_allowlist +hermes approvals suggest --json # machine-readable output +``` + +The command scans the session database (`~/.hermes/state.db`) for +dangerous-classified commands that actually executed — i.e. commands you +approved — aggregates them into patterns (`git push *`, or the dangerous-class +key for compound commands), and ranks them by approval frequency: + +``` +Proposed command_allowlist additions (from approval history, last 90 days): + + 1. git push * — approved 14x + 2. docker restart/stop/kill (container lifecycle) — approved 9x (class key) +``` + +Safety rules: + +- **Nothing is ever applied automatically** — the default run is read-only; + only an explicit `--apply N[,M...]` writes to `config.yaml`. +- **Destructive classes are never proposed**, no matter how often they were + approved: recursive deletes, `sudo`, disk/device writes, credential and + system-config edits, pipe-to-shell, SQL DROP/TRUNCATE, process kills, and + every hardline class are excluded outright. `rm -rf build/` approved 100 + times still never yields an `rm` entry. +- Proposals already covered by your existing `command_allowlist` are skipped. + +Useful flags: `--days N` (history window, default 90), `--min-count N` +(minimum approvals to qualify, default 2), `--limit N`, and `--db PATH`. + ## File Write Safety {#file-write-safety} Before `write_file` or `patch` touches disk, Hermes checks the target path against a denylist and an optional sandbox. Blocked writes return an error to the agent immediately — **there is no approval prompt** and no way to override from the chat UI. The model may still claim the edit succeeded; when `display.file_mutation_verifier` is on (default), trust the [file-mutation verifier footer](./configuration.md#file-mutation-verifier) over the assistant's closing summary. diff --git a/website/docs/user-guide/sessions.md b/website/docs/user-guide/sessions.md index 50e5236317..e154209f6b 100644 --- a/website/docs/user-guide/sessions.md +++ b/website/docs/user-guide/sessions.md @@ -419,7 +419,7 @@ If the title is already in use by another session, an error is shown. ### Prune Old Sessions ```bash -# Delete ended sessions older than 90 days (default) +# Delete ended sessions inactive for 90 days (default) hermes sessions prune # Custom age threshold — bare numbers are days @@ -461,8 +461,10 @@ hermes sessions prune --older-than 30 --yes Time values (`--older-than`, `--newer-than`, `--before`, `--after`) accept a duration (`5h`, `30m`, `2d`, `1w`), a bare number of days, or an ISO timestamp (`2026-07-05`, `2026-07-05 14:30`). `--older-than`/`--before` set -the upper bound; `--newer-than`/`--after` set the lower bound. Combine both -for a window. +the upper bound; `--newer-than`/`--after` set the lower bound. The +`--older-than`/`--newer-than` pair uses latest message activity (falling back +to session start for empty sessions); `--before`/`--after` explicitly uses +session start time. Combine either pair for a window. Attribute filters: `--source` (platform, exact), `--title` / `--model` / `--branch` (case-insensitive substring), `--provider` (billing provider, @@ -688,7 +690,7 @@ Key tables in `state.db`: - Gateway sessions auto-reset based on the configured reset policy - Before reset, the agent saves memories and skills from the expiring session -- Opt-in auto-pruning: when `sessions.auto_prune` is `true`, ended sessions older than `sessions.retention_days` (default 90) are pruned at CLI/gateway startup +- Opt-in auto-pruning: when `sessions.auto_prune` is `true`, ended sessions inactive for `sessions.retention_days` (default 90) are pruned at CLI/gateway startup - After a prune that actually removed rows, `state.db` is `VACUUM`ed to reclaim disk space (SQLite does not shrink the file on plain DELETE) - Pruning runs at most once per `sessions.min_interval_hours` (default 24); the last-run timestamp is tracked inside `state.db` itself so it's shared across every Hermes process in the same `HERMES_HOME` @@ -697,12 +699,14 @@ Default is **off** — session history is valuable for `session_search` recall, ```yaml sessions: auto_prune: true # opt in — default is false - retention_days: 90 # keep ended sessions this many days + retention_days: 90 # keep ended sessions active within this window vacuum_after_prune: true # reclaim disk space after a pruning sweep min_interval_hours: 24 # don't re-run the sweep more often than this ``` -Active sessions are never auto-pruned, regardless of age. +Active sessions are never auto-pruned, regardless of age. Ended sessions are +aged from their latest message, so a long-lived conversation used recently is +not deleted merely because it began before the retention window. ### Manual Cleanup diff --git a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/developer-guide/agent-loop.md b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/developer-guide/agent-loop.md index a3f1683891..23e8065e9e 100644 --- a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/developer-guide/agent-loop.md +++ b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/developer-guide/agent-loop.md @@ -181,7 +181,7 @@ for each tool_call in response.tool_calls: agent 通过 `IterationBudget` 追踪迭代次数： -- 默认：90 次迭代（可通过 `agent.max_turns` 配置） +- 默认：500 次迭代（可通过 `agent.max_turns` 配置） - 每个 agent 拥有独立预算。子 agent 获得独立预算，上限为 `delegation.max_iterations`（默认 50）——父 agent 与子 agent 的总迭代次数可超过父 agent 的上限 - 达到 100% 时，agent 停止并返回已完成工作的摘要 diff --git a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/python-library.md b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/python-library.md index 59493c66fc..e25e7c5007 100644 --- a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/python-library.md +++ b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/python-library.md @@ -309,7 +309,7 @@ print(review) | `disabled_toolsets` | `List[str]` | `None` | 黑名单指定工具集 | | `save_trajectories` | `bool` | `False` | 将对话保存为 JSONL | | `ephemeral_system_prompt` | `str` | `None` | 自定义系统 prompt（不保存到轨迹文件） | -| `max_iterations` | `int` | `90` | 每次对话的最大工具调用迭代次数 | +| `max_iterations` | `int` | `500` | 每次对话的最大工具调用迭代次数 | | `skip_context_files` | `bool` | `False` | 跳过加载 AGENTS.md 文件 | | `skip_memory` | `bool` | `False` | 禁用持久化内存的读写 | | `api_key` | `str` | `None` | API 密钥（回退到环境变量） | @@ -329,5 +329,5 @@ print(review) :::warning - **线程安全**：每个线程或任务创建一个 `AIAgent` 实例。切勿在并发调用中共享同一实例。 - **资源清理**：agent 在对话结束时会自动清理资源（终端会话、浏览器实例）。若在长期运行的进程中使用，请确保每次对话正常结束。 -- **迭代限制**：默认的 `max_iterations=90` 较为宽松。对于简单的问答场景，建议适当降低该值（如 `max_iterations=10`），以防止工具调用循环失控并控制成本。 +- **迭代限制**：默认的 `max_iterations=500` 较为宽松。对于简单的问答场景，建议适当降低该值（如 `max_iterations=10`），以防止工具调用循环失控并控制成本。 ::: \ No newline at end of file diff --git a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/run-hermes-with-nous-portal.md b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/run-hermes-with-nous-portal.md index fa860d93ce..0b50318e8e 100644 --- a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/run-hermes-with-nous-portal.md +++ b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/run-hermes-with-nous-portal.md @@ -225,7 +225,7 @@ hermes auth add nous ### 我想要的模型不在 `/model` 选择器中 -Portal 目录镜像了 OpenRouter 的模型列表（300+ 个）。如果某个模型缺失，尝试直接输入 OpenRouter 风格的 slug： +Portal 目录基于 OpenRouter 的模型列表（300+ 个），并补充了通过专有或备用提供商提供的模型。如果某个模型缺失，尝试直接输入 OpenRouter 风格的 slug： ```bash /model anthropic/claude-opus-4.6 diff --git a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/integrations/nous-portal.md b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/integrations/nous-portal.md index 275f77a0e8..771193905b 100644 --- a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/integrations/nous-portal.md +++ b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/integrations/nous-portal.md @@ -38,7 +38,11 @@ Portal 代理了来自整个生态系统的精选 agentic 模型目录——统 | **Hermes** | Hermes-4-70B、Hermes-4-405B（对话，见[下方说明](#a-note-on-hermes-4)） | | **+ 其他所有模型** | 240+ 额外模型——完整的 agentic 前沿生态 | -底层路由通过 OpenRouter 实现，因此模型可用性和故障转移行为与使用 OpenRouter 密钥一致——只是计费走你的 Nous 订阅。在会话中途用 `/model` 即可在 Claude Sonnet 4.6（适合代码）和 Gemini 2.5 Pro（适合长上下文）之间切换——无需新凭证，无需充值，不会遇到余额为零的意外报错。 +底层上，Portal 会为每个模型选择最合适的后端——部分模型通过 OpenRouter 路由，其他模型则通过专有或备用提供商，且某个模型的路由方式可能随时间调整。所有用量都统一计入你的 Nous 订阅。在会话中途用 `/model` 即可在 Claude Sonnet 4.6（适合代码）和 Gemini 2.5 Pro（适合长上下文）之间切换——无需新凭证，无需充值，不会遇到余额为零的意外报错。 + +:::note +由于路由是按模型进行的，并非总是经过 OpenRouter，OpenRouter 专有的请求扩展（如 `provider` 路由偏好、`session_id` 粘性路由或顶层 `cache_control`）不属于 Portal 的 API 契约，可能会被忽略，具体取决于该模型由哪个后端提供服务。 +::: ### Nous Tool Gateway @@ -246,7 +250,7 @@ hermes portal ### 想使用 Portal 未暴露的特定提供商模型 -Portal 通过 OpenRouter 代理，因此 OpenRouter 支持的所有模型通常都可用。如果某个模型未出现在 `/model` 中，可直接尝试 OpenRouter 风格的 slug： +Portal 会为每个模型选择合适的后端——部分模型通过 OpenRouter 路由，其他模型则通过专有或备用提供商——因此 OpenRouter 支持的大多数模型通常都可用。如果某个模型未出现在 `/model` 中，可直接尝试 OpenRouter 风格的 slug： ```bash /model anthropic/claude-opus-4.6 diff --git a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/cli-commands.md b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/cli-commands.md index d4ef1885a6..cd0353bb41 100644 --- a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/cli-commands.md +++ b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/cli-commands.md @@ -108,7 +108,7 @@ hermes chat [options] | `--ignore-user-config` | 忽略 `~/.hermes/config.yaml`，使用内置默认值。`.env` 中的凭据仍会加载。适用于隔离的 CI 运行、可复现的 bug 报告和第三方集成。 | | `--ignore-rules` | 跳过 `AGENTS.md`、`SOUL.md`、`.cursorrules`、持久 memory 和预加载 skill 的自动注入。与 `--ignore-user-config` 组合可实现完全隔离的运行。 | | `--source ` | 用于过滤的会话来源标签（默认：`cli`）。对于不应出现在用户会话列表中的第三方集成，使用 `tool`。 | -| `--max-turns ` | 每个对话轮次的最大工具调用迭代次数（默认：90，或 config 中的 `agent.max_turns`）。 | +| `--max-turns ` | 每个对话轮次的最大工具调用迭代次数（默认：500，或 config 中的 `agent.max_turns`）。 | 示例： diff --git a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/environment-variables.md b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/environment-variables.md index 4b15a846f1..99914065ea 100644 --- a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/environment-variables.md +++ b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/environment-variables.md @@ -526,7 +526,7 @@ Graph 事件（Teams 会议、日历、聊天等）的入站变更通知监听 | 变量 | 描述 | |----------|-------------| -| `HERMES_MAX_ITERATIONS` | 每次对话的最大工具调用迭代次数（默认：90） | +| `HERMES_MAX_ITERATIONS` | 每次对话的最大工具调用迭代次数（默认：500） | | `HERMES_INFERENCE_MODEL` | 在进程级别覆盖模型名称（优先于本次会话的 `config.yaml`）。也可通过 `-m`/`--model` 标志设置。 | | `HERMES_YOLO_MODE` | 设为 `1` 可绕过危险命令审批提示。等同于 `--yolo`。 | | `HERMES_ACCEPT_HOOKS` | 无需 TTY 提示自动批准 `config.yaml` 中声明的任何未见过的 shell hook。等同于 `--accept-hooks` 或 `hooks_auto_accept: true`。 | diff --git a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/user-guide/configuration.md b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/user-guide/configuration.md index 6d4c7c14f6..a092445e65 100644 --- a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/user-guide/configuration.md +++ b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/user-guide/configuration.md @@ -637,17 +637,17 @@ context: ## 迭代预算 -当 agent 在处理具有许多工具调用的复杂任务时，它可能会耗尽其迭代预算（默认：90 轮）。Hermes **不会**在任务中途注入压力警告 —— 早期版本会在预算达到 70%/90% 时警告模型，这会导致模型过早放弃复杂任务，该机制已于 2026 年 4 月移除。 +当 agent 在处理具有许多工具调用的复杂任务时，它可能会耗尽其迭代预算（默认：500 轮）。Hermes **不会**在任务中途注入压力警告 —— 早期版本会在预算达到 70%/90% 时警告模型，这会导致模型过早放弃复杂任务，该机制已于 2026 年 4 月移除。 -取而代之的是，当预算真正耗尽（90/90）时，Hermes 注入一条消息要求模型收尾，并允许一次**宽限调用**以便其给出最终响应。如果该宽限调用仍未产生文本，则会要求 agent 总结已完成的工作。 +取而代之的是，当预算真正耗尽（500/500）时，Hermes 注入一条消息要求模型收尾，并允许一次**宽限调用**以便其给出最终响应。如果该宽限调用仍未产生文本，则会要求 agent 总结已完成的工作。 ```yaml agent: - max_turns: 90 # 每次对话轮次的最大迭代次数（默认：90） + max_turns: 500 # 每次对话轮次的最大迭代次数（默认：500） api_max_retries: 3 # 回退启动前每个 provider 的重试次数（默认：3） ``` -当迭代预算完全耗尽时，CLI 向用户显示通知：`⚠ Iteration budget reached (90/90) — response may be incomplete`。 +当迭代预算完全耗尽时，CLI 向用户显示通知：`⚠ Iteration budget reached (500/500) — response may be incomplete`。 `agent.api_max_retries` 控制 Hermes 在回退 provider 切换启动**之前**对瞬时错误（速率限制、连接断开、5xx）重试 provider API 调用的次数。默认为 `3` —— 总共四次尝试。如果您配置了[回退 providers](/user-guide/features/fallback-providers) 并希望更快地故障转移，请将其降至 `0`，这样主 provider 上的第一个瞬时错误会立即切换到回退，而不是对不稳定的端点进行重试。