mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-05-08 03:01:47 +00:00
906881c38b
When the user pastes a long slash command like \`/goal <long prose>\` into
\`hermes chat\`, the input flows into \`_detect_file_drop()\`, whose
\`starts_like_path\` prefilter accepts anything starting with \`/\` and
forwards it to \`_resolve_attachment_path()\`. That helper calls
\`Path.exists()\` which invokes \`os.stat()\`, which raises
\`OSError(errno=ENAMETOOLONG)\` — 63 on macOS, 36 on Linux — when the
candidate exceeds NAME_MAX (typically 255 bytes).
The OSError propagates up to the broad \`except Exception\` in
\`process_loop\` (cli.py:11798), gets logged at WARNING level, and the
user's input is silently dropped. From the user's POV the chat prompt
hangs — the only signal is in agent.log:
WARNING cli: process_loop unhandled error (msg may be lost):
[Errno 63] File name too long: "/goal Drive the space board..."
This affects any slash command with prose-length arguments — \`/goal\`
in particular but also \`/skill\`, \`/cron\`, custom user commands.
Fix: wrap the \`exists()\`/\`is_file()\` calls in try/except OSError so
structurally-invalid path candidates cleanly return None. The slash-
command dispatch path downstream (cli.py:11718) then handles the
input correctly.
Tests: two new regression cases in test_cli_file_drop.py cover the
original \`/goal\` reproducer and a synthetic long path. All 35 file-
drop tests pass.
Reproducer (without the fix):
python -c "from cli import _detect_file_drop;
_detect_file_drop('/goal ' + 'a'*300)"
→ OSError: [Errno 63] File name too long
252 lines
9.8 KiB
Python
252 lines
9.8 KiB
Python
"""Tests for _detect_file_drop — file path detection that prevents
|
|
dragged/pasted absolute paths from being mistaken for slash commands."""
|
|
|
|
import os
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from cli import _detect_file_drop
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Fixtures
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@pytest.fixture()
|
|
def tmp_image(tmp_path):
|
|
"""Create a temporary .png file and return its path."""
|
|
img = tmp_path / "screenshot.png"
|
|
img.write_bytes(b"\x89PNG\r\n\x1a\n") # minimal PNG header
|
|
return img
|
|
|
|
|
|
@pytest.fixture()
|
|
def tmp_text(tmp_path):
|
|
"""Create a temporary .py file and return its path."""
|
|
f = tmp_path / "main.py"
|
|
f.write_text("print('hello')\n")
|
|
return f
|
|
|
|
|
|
@pytest.fixture()
|
|
def tmp_image_with_spaces(tmp_path):
|
|
"""Create a file whose name contains spaces (like macOS screenshots)."""
|
|
img = tmp_path / "Screenshot 2026-04-01 at 7.25.32 PM.png"
|
|
img.write_bytes(b"\x89PNG\r\n\x1a\n")
|
|
return img
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: returns None for non-file inputs
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestNonFileInputs:
|
|
def test_regular_slash_command(self):
|
|
assert _detect_file_drop("/help") is None
|
|
|
|
def test_unknown_slash_command(self):
|
|
assert _detect_file_drop("/xyz") is None
|
|
|
|
def test_slash_command_with_args(self):
|
|
assert _detect_file_drop("/config set key value") is None
|
|
|
|
def test_empty_string(self):
|
|
assert _detect_file_drop("") is None
|
|
|
|
def test_non_slash_input(self):
|
|
assert _detect_file_drop("hello world") is None
|
|
|
|
def test_non_string_input(self):
|
|
assert _detect_file_drop(42) is None
|
|
|
|
def test_nonexistent_path(self):
|
|
assert _detect_file_drop("/nonexistent/path/to/file.png") is None
|
|
|
|
def test_directory_not_file(self, tmp_path):
|
|
"""A directory path should not be treated as a file drop."""
|
|
assert _detect_file_drop(str(tmp_path)) is None
|
|
|
|
def test_long_slash_command_does_not_raise(self):
|
|
"""Regression: long pasted slash commands like `/goal <long prose>`
|
|
used to raise OSError(ENAMETOOLONG, errno 63 macOS / 36 Linux)
|
|
from `Path.exists()` inside `_resolve_attachment_path`, which
|
|
propagated up to `process_loop`'s catch-all and silently lost
|
|
the user's input. The fix wraps the stat call in a try/except
|
|
OSError and returns None, letting the slash-command dispatch
|
|
path handle the input downstream.
|
|
|
|
Reproducer: paste a `/goal` followed by ~430 chars of prose.
|
|
Without the fix this triggers ENAMETOOLONG; with the fix it
|
|
cleanly returns None (file-drop = no), so `_looks_like_slash_command`
|
|
gets a chance to dispatch it.
|
|
"""
|
|
# 430-char `/goal` payload — well above NAME_MAX (255 bytes) on
|
|
# all common filesystems.
|
|
long_goal = (
|
|
"/goal " + ("Drive the board: triage triage-status items, "
|
|
"unblock spillover tasks where work is shipped, "
|
|
"advance P1 items by decomposing where needed. ") * 4
|
|
)
|
|
assert len(long_goal) > 255 # confirms it would have triggered ENAMETOOLONG
|
|
assert _detect_file_drop(long_goal) is None
|
|
|
|
def test_path_longer_than_namemax_does_not_raise(self):
|
|
"""Defensive: a single token longer than NAME_MAX should return
|
|
None, not raise. Could happen with absurdly long synthetic inputs
|
|
from prompt-injection attempts or fuzzers."""
|
|
very_long_path = "/" + ("a" * 300)
|
|
assert _detect_file_drop(very_long_path) is None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: image file detection
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestImageFileDrop:
|
|
def test_simple_image_path(self, tmp_image):
|
|
result = _detect_file_drop(str(tmp_image))
|
|
assert result is not None
|
|
assert result["path"] == tmp_image
|
|
assert result["is_image"] is True
|
|
assert result["remainder"] == ""
|
|
|
|
def test_image_with_trailing_text(self, tmp_image):
|
|
user_input = f"{tmp_image} analyze this please"
|
|
result = _detect_file_drop(user_input)
|
|
assert result is not None
|
|
assert result["path"] == tmp_image
|
|
assert result["is_image"] is True
|
|
assert result["remainder"] == "analyze this please"
|
|
|
|
@pytest.mark.parametrize("ext", [".png", ".jpg", ".jpeg", ".gif", ".webp",
|
|
".bmp", ".tiff", ".tif", ".svg", ".ico"])
|
|
def test_all_image_extensions(self, tmp_path, ext):
|
|
img = tmp_path / f"test{ext}"
|
|
img.write_bytes(b"fake")
|
|
result = _detect_file_drop(str(img))
|
|
assert result is not None
|
|
assert result["is_image"] is True
|
|
|
|
def test_uppercase_extension(self, tmp_path):
|
|
img = tmp_path / "photo.JPG"
|
|
img.write_bytes(b"fake")
|
|
result = _detect_file_drop(str(img))
|
|
assert result is not None
|
|
assert result["is_image"] is True
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: non-image file detection
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestNonImageFileDrop:
|
|
def test_python_file(self, tmp_text):
|
|
result = _detect_file_drop(str(tmp_text))
|
|
assert result is not None
|
|
assert result["path"] == tmp_text
|
|
assert result["is_image"] is False
|
|
assert result["remainder"] == ""
|
|
|
|
def test_non_image_with_trailing_text(self, tmp_text):
|
|
user_input = f"{tmp_text} review this code"
|
|
result = _detect_file_drop(user_input)
|
|
assert result is not None
|
|
assert result["is_image"] is False
|
|
assert result["remainder"] == "review this code"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: backslash-escaped spaces (macOS drag-and-drop)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestEscapedSpaces:
|
|
def test_escaped_spaces_in_path(self, tmp_image_with_spaces):
|
|
r"""macOS drags produce paths like /path/to/my\ file.png"""
|
|
escaped = str(tmp_image_with_spaces).replace(' ', '\\ ')
|
|
result = _detect_file_drop(escaped)
|
|
assert result is not None
|
|
assert result["path"] == tmp_image_with_spaces
|
|
assert result["is_image"] is True
|
|
|
|
def test_escaped_spaces_with_trailing_text(self, tmp_image_with_spaces):
|
|
escaped = str(tmp_image_with_spaces).replace(' ', '\\ ')
|
|
user_input = f"{escaped} what is this?"
|
|
result = _detect_file_drop(user_input)
|
|
assert result is not None
|
|
assert result["path"] == tmp_image_with_spaces
|
|
assert result["remainder"] == "what is this?"
|
|
|
|
def test_unquoted_spaces_in_path(self, tmp_image_with_spaces):
|
|
result = _detect_file_drop(str(tmp_image_with_spaces))
|
|
assert result is not None
|
|
assert result["path"] == tmp_image_with_spaces
|
|
assert result["is_image"] is True
|
|
assert result["remainder"] == ""
|
|
|
|
def test_unquoted_spaces_with_trailing_text(self, tmp_image_with_spaces):
|
|
user_input = f"{tmp_image_with_spaces} what is this?"
|
|
result = _detect_file_drop(user_input)
|
|
assert result is not None
|
|
assert result["path"] == tmp_image_with_spaces
|
|
assert result["remainder"] == "what is this?"
|
|
|
|
def test_mixed_escaped_and_literal_spaces_in_path(self, tmp_path):
|
|
img = tmp_path / "Screenshot 2026-04-21 at 1.04.43 PM.png"
|
|
img.write_bytes(b"\x89PNG\r\n\x1a\n")
|
|
mixed = str(img).replace("Screenshot ", "Screenshot\\ ").replace("2026-04-21 ", "2026-04-21\\ ").replace("at ", "at\\ ")
|
|
result = _detect_file_drop(mixed)
|
|
assert result is not None
|
|
assert result["path"] == img
|
|
assert result["is_image"] is True
|
|
assert result["remainder"] == ""
|
|
|
|
def test_file_uri_image_path(self, tmp_image_with_spaces):
|
|
uri = tmp_image_with_spaces.as_uri()
|
|
result = _detect_file_drop(uri)
|
|
assert result is not None
|
|
assert result["path"] == tmp_image_with_spaces
|
|
assert result["is_image"] is True
|
|
|
|
def test_tilde_prefixed_path(self, tmp_path, monkeypatch):
|
|
home = tmp_path / "home"
|
|
img = home / "storage" / "shared" / "Pictures" / "cat.png"
|
|
img.parent.mkdir(parents=True, exist_ok=True)
|
|
img.write_bytes(b"\x89PNG\r\n\x1a\n")
|
|
monkeypatch.setenv("HOME", str(home))
|
|
|
|
result = _detect_file_drop("~/storage/shared/Pictures/cat.png what is this?")
|
|
|
|
assert result is not None
|
|
assert result["path"] == img
|
|
assert result["is_image"] is True
|
|
assert result["remainder"] == "what is this?"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: edge cases
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestEdgeCases:
|
|
def test_path_with_no_extension(self, tmp_path):
|
|
f = tmp_path / "Makefile"
|
|
f.write_text("all:\n\techo hi\n")
|
|
result = _detect_file_drop(str(f))
|
|
assert result is not None
|
|
assert result["is_image"] is False
|
|
|
|
def test_path_that_looks_like_command_but_is_file(self, tmp_path):
|
|
"""A file literally named 'help' inside a directory starting with /."""
|
|
f = tmp_path / "help"
|
|
f.write_text("not a command\n")
|
|
result = _detect_file_drop(str(f))
|
|
assert result is not None
|
|
assert result["is_image"] is False
|
|
|
|
def test_symlink_to_file(self, tmp_image, tmp_path):
|
|
link = tmp_path / "link.png"
|
|
link.symlink_to(tmp_image)
|
|
result = _detect_file_drop(str(link))
|
|
assert result is not None
|
|
assert result["is_image"] is True
|