Merge pull request 'Allow /stop without target argument' (#13) from feat/unify-start-stop-args into main

Reviewed-on: #13

README.md

@@ -8,11 +8,11 @@
 1. 로컬에서 Claude 또는 Codex를 tmux 세션으로 미리 실행
    - Claude: `tmux new -s claude claude`
    - Codex: `tmux new -s codex codex`
-2. Slack에서 `/start-claude` 또는 `/start-codex` 실행
+2. Slack에서 `/start claude` 또는 `/start codex` 실행
 3. 브릿지가 기존 tmux 세션에 attach
-4. Slack 채널 메시지가 CLI 입력으로 전달됨
+4. Slack 채널 메시지가 CLI 입력으로 전달됨 (기본: 엔터 미포함)
 5. CLI 출력이 Slack으로 다시 전송됨
-6. `/stop-claude`로 브릿지 연결 해제 (tmux 세션은 유지)
+6. `/stop claude` 또는 `/stop codex`로 브릿지 연결 해제 (tmux 세션은 유지)
 
 ## 빠른 시작
 
@@ -37,8 +37,8 @@ cp .env.example .env
 - `SLACK_ALLOWED_CHANNEL_ID`
 
 선택 환경 변수:
-- `TMUX_SESSION_NAME` (기본: `claude`, `/start-claude` 대상)
+- `TMUX_SESSION_NAME` (기본: `claude`, `/start claude` 대상)
-- `CODEX_TMUX_SESSION_NAME` (기본: `codex`, `/start-codex` 대상)
+- `CODEX_TMUX_SESSION_NAME` (기본: `codex`, `/start codex` 대상)
 - `PTY_READ_TIMEOUT` (기본: `5`)
 - `OUTPUT_BUFFER_INTERVAL` (기본: `2.0`)
 - `OUTPUT_SETTLE_SECONDS` (기본: `4.0`, 출력이 잠잠해진 뒤 전송 대기 시간)
@@ -55,10 +55,8 @@ cp .env.example .env
 - Socket Mode 활성화
 - Bot Token Scopes에 `chat:write`, `commands` 추가
 - Slash Commands 생성:
-  - `/start-claude`
+  - `/start`
-  - `/stop-claude`
+  - `/stop`
-  - `/start-codex`
-  - `/stop-codex`
 - 앱을 워크스페이스에 설치 후 토큰을 `.env`에 반영
 
 ## 실행
@@ -80,9 +78,10 @@ python -m lazy_enter
 ```
 
 실행 후 Slack의 허용된 채널에서:
-- `/start-claude`, `/start-codex`: 기존 세션에 연결
+- `/start claude`, `/start codex`: 기존 세션에 연결
-- 일반 메시지 전송: 현재 연결된 CLI(Claude/Codex)로 입력 전달
+- 일반 메시지 전송: 현재 연결된 CLI(Claude/Codex)로 입력만 전달 (엔터 미포함)
-- `/stop-claude`, `/stop-codex`: 브릿지 연결 해제 (세션 유지)
+- `!e`, `!enter` 전송: 엔터 키만 전달 (현재 프롬프트 제출)
+- `/stop claude`, `/stop codex`: 브릿지 연결 해제 (세션 유지)
 
 ## 테스트 및 품질 점검
 

src/lazy_enter/bridge.py

@@ -18,6 +18,8 @@ logger = logging.getLogger(__name__)
 class Bridge:
     """Slack ↔ CLI 프로세스 간의 중계기."""
 
+    ENTER_COMMANDS = {"!e", "!enter"}
+
     def __init__(self, config: Config | None = None) -> None:
         self.config = config or Config()
         self.slack = SlackHandler(self.config)
@@ -39,22 +41,32 @@ class Bridge:
 
     def _handle_message(self, text: str, channel: str) -> None:
         """Slack 메시지를 PTY 프로세스로 전달한다."""
+        if not self.pty or not self.pty.is_alive:
+            self.slack.send_message(channel, ":warning: 연결된 세션이 없습니다.")
+            return
+
+        if text.strip().lower() in self.ENTER_COMMANDS:
+            self.pty.send_enter()
+            self._last_sent_output = ""
+            self._last_sent_fingerprint = None
+            self._last_input_at = time.monotonic()
+            self._input_idle_reported = False
+            logger.info("엔터 입력 전달")
+            return
+
         if self._is_blocked_input(text):
             self.slack.send_message(
                 channel, ":no_entry: 차단된 명령 패턴이 감지되었습니다."
             )
             return
 
-        if self.pty and self.pty.is_alive:
         self.pty.send(text)
         # 입력 이후 출력은 동일 문자열이어도 한 번 더 전달한다.
         self._last_sent_output = ""
         self._last_sent_fingerprint = None
         self._last_input_at = time.monotonic()
         self._input_idle_reported = False
-            logger.info("입력 전달: %s", text)
+        logger.info("입력 전달(엔터 미포함): %s", text)
-        else:
-            self.slack.send_message(channel, ":warning: 연결된 세션이 없습니다.")
 
     @staticmethod
     def _is_blocked_input(text: str) -> bool:
@@ -84,11 +96,10 @@ class Bridge:
 
     def _handle_command(self, action: str, target: str, channel: str) -> None:
         """슬래시 커맨드를 처리한다."""
+        if action == "start":
             if target not in {"claude", "codex"}:
                 self.slack.send_message(channel, ":warning: 지원하지 않는 대상입니다.")
                 return
-
-        if action == "start":
             self._start_session(channel, target)
         elif action == "stop":
             self._stop_session(channel)

src/lazy_enter/pty_manager.py

@@ -47,13 +47,20 @@ class PtyManager:
             timeout=None,
         )
 
-    def send(self, text: str) -> None:
+    def send(self, text: str, submit: bool = False) -> None:
         """프로세스에 텍스트 입력을 전달한다."""
         if not self.is_alive:
             raise RuntimeError("프로세스가 실행 중이 아닙니다.")
         assert self._process is not None
         logger.debug("입력 전송: %s", text)
+        if submit:
             self._process.sendline(text)
+            return
+        self._process.send(text)
+
+    def send_enter(self) -> None:
+        """엔터 키 입력만 전송한다."""
+        self.send("", submit=True)
 
     def read_output(self, timeout: float = 5) -> str:
         """프로세스의 출력을 읽는다."""

src/lazy_enter/slack_handler.py

@@ -58,8 +58,31 @@ class SlackHandler:
             if self._on_message_callback:
                 self._on_message_callback(text, channel_id)
 
-        @self.app.command("/start-claude")
+        @self.app.command("/start")
-        def handle_start_claude(ack: Callable[..., None], body: dict) -> None:
+        def handle_start(ack: Callable[..., None], body: dict) -> None:
+            ack()
+            user_id = body.get("user_id", "")
+            channel_id = body.get("channel_id", "")
+            target = self._parse_target(body.get("text", ""))
+
+            if not self._is_authorized(user_id, channel_id):
+                return
+
+            if target is None:
+                self.send_message(
+                    channel_id,
+                    (
+                        ":warning: 대상은 `claude` 또는 `codex`여야 합니다. "
+                        "예: `/start codex`"
+                    ),
+                )
+                return
+
+            if self._on_command_callback:
+                self._on_command_callback("start", target, channel_id)
+
+        @self.app.command("/stop")
+        def handle_stop(ack: Callable[..., None], body: dict) -> None:
             ack()
             user_id = body.get("user_id", "")
             channel_id = body.get("channel_id", "")
@@ -68,43 +91,15 @@ class SlackHandler:
                 return
 
             if self._on_command_callback:
-                self._on_command_callback("start", "claude", channel_id)
+                self._on_command_callback("stop", "", channel_id)
 
-        @self.app.command("/stop-claude")
+    @staticmethod
-        def handle_stop_claude(ack: Callable[..., None], body: dict) -> None:
+    def _parse_target(text: str) -> str | None:
-            ack()
+        """슬래시 커맨드 인자에서 대상을 파싱한다."""
-            user_id = body.get("user_id", "")
+        first_token = text.strip().split(maxsplit=1)[0].lower() if text.strip() else ""
-            channel_id = body.get("channel_id", "")
+        if first_token in {"claude", "codex"}:
-
+            return first_token
-            if not self._is_authorized(user_id, channel_id):
+        return None
-                return
-
-            if self._on_command_callback:
-                self._on_command_callback("stop", "claude", channel_id)
-
-        @self.app.command("/start-codex")
-        def handle_start_codex(ack: Callable[..., None], body: dict) -> None:
-            ack()
-            user_id = body.get("user_id", "")
-            channel_id = body.get("channel_id", "")
-
-            if not self._is_authorized(user_id, channel_id):
-                return
-
-            if self._on_command_callback:
-                self._on_command_callback("start", "codex", channel_id)
-
-        @self.app.command("/stop-codex")
-        def handle_stop_codex(ack: Callable[..., None], body: dict) -> None:
-            ack()
-            user_id = body.get("user_id", "")
-            channel_id = body.get("channel_id", "")
-
-            if not self._is_authorized(user_id, channel_id):
-                return
-
-            if self._on_command_callback:
-                self._on_command_callback("stop", "codex", channel_id)
 
     def on_message(self, callback: Callable[[str, str], None]) -> None:
         """메시지 수신 콜백을 등록한다."""

tests/test_bridge.py

@@ -46,6 +46,7 @@ class FakePtyManager:
         self.cli_name = cli_name
         self._alive = False
         self.sent_inputs: list[str] = []
+        self.enter_count = 0
         FakePtyManager.instances.append(self)
 
     @property
@@ -61,6 +62,9 @@ class FakePtyManager:
     def send(self, text: str) -> None:
         self.sent_inputs.append(text)
 
+    def send_enter(self) -> None:
+        self.enter_count += 1
+
     def read_output(self, timeout: float = 5) -> str:
         return ""
 
@@ -128,6 +132,21 @@ def test_unknown_target_is_rejected(monkeypatch) -> None:
     )
 
 
+def test_stop_command_ignores_empty_target(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+    bridge._handle_command("start", "codex", "C1")
+
+    bridge._handle_command("stop", "", "C1")
+
+    assert bridge.pty is None
+    assert bridge._active_target is None
+    assert bridge.slack.sent_messages[-1] == (
+        "C1",
+        ":electric_plug: 세션 연결이 해제되었습니다.",
+    )
+
+
 def test_handle_message_resets_last_sent_output_after_input(monkeypatch) -> None:
     FakePtyManager.instances.clear()
     bridge = _make_bridge(monkeypatch)
@@ -143,6 +162,45 @@ def test_handle_message_resets_last_sent_output_after_input(monkeypatch) -> None
     assert bridge._last_sent_fingerprint is None
 
 
+def test_handle_message_enter_command_sends_enter_only(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "codex", "C1")
+    pty = FakePtyManager.instances[-1]
+
+    bridge._handle_message("!enter", "C1")
+
+    assert pty.sent_inputs == []
+    assert pty.enter_count == 1
+
+
+def test_handle_message_short_enter_alias_sends_enter_only(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "codex", "C1")
+    pty = FakePtyManager.instances[-1]
+
+    bridge._handle_message("!e", "C1")
+
+    assert pty.sent_inputs == []
+    assert pty.enter_count == 1
+
+
+def test_handle_message_bang_is_plain_input(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "codex", "C1")
+    pty = FakePtyManager.instances[-1]
+
+    bridge._handle_message("!", "C1")
+
+    assert pty.sent_inputs == ["!"]
+    assert pty.enter_count == 0
+
+
 def test_split_message_preserves_all_content(monkeypatch) -> None:
     bridge = _make_bridge(monkeypatch)
     chunks = bridge._split_message("line1\nline2\nline3", max_length=7)

tests/test_pty_manager.py

@@ -13,11 +13,18 @@ class FakeSpawn:
     def __init__(self, *_args: object, **_kwargs: object) -> None:
         self.before = ""
         self._alive = True
+        self.sent: list[str] = []
+        self.sentline: list[str] = []
 
     def isalive(self) -> bool:
         return self._alive
 
     def sendline(self, _text: str) -> None:
+        self.sentline.append(_text)
+        return None
+
+    def send(self, _text: str) -> None:
+        self.sent.append(_text)
         return None
 
     def expect(self, *_args: object, **_kwargs: object) -> None:
@@ -82,3 +89,33 @@ def test_start_and_stop_attach(monkeypatch: pytest.MonkeyPatch):
 
     pty.stop()
     assert not pty.is_alive
+
+
+def test_send_and_send_enter_are_separated(monkeypatch: pytest.MonkeyPatch):
+    def fake_run(
+        _cmd: Sequence[str],
+        check: bool,
+        capture_output: bool,
+        text: bool,
+    ):
+        assert check is False
+        assert capture_output is True
+        assert text is True
+
+        class Result:
+            returncode = 0
+
+        return Result()
+
+    monkeypatch.setattr("lazy_enter.pty_manager.subprocess.run", fake_run)
+    monkeypatch.setattr("lazy_enter.pty_manager.pexpect.spawn", FakeSpawn)
+
+    pty = PtyManager("claude")
+    pty.start()
+    assert pty._process is not None
+
+    pty.send("status")
+    pty.send_enter()
+
+    assert pty._process.sent == ["status"]
+    assert pty._process.sentline == [""]

tests/test_slack_handler.py

@@ -0,0 +1,168 @@
+"""Slack 슬래시 커맨드 파싱 테스트."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from lazy_enter.config import Config
+
+
+class FakeClient:
+    def __init__(self) -> None:
+        self.messages: list[dict[str, str | None]] = []
+
+    def chat_postMessage(  # noqa: N802
+        self, channel: str, text: str, thread_ts: str | None = None
+    ) -> None:
+        self.messages.append(
+            {
+                "channel": channel,
+                "text": text,
+                "thread_ts": thread_ts,
+            }
+        )
+
+
+class FakeApp:
+    def __init__(self, token: str) -> None:
+        self.token = token
+        self.client = FakeClient()
+        self.command_handlers: dict[str, Callable[..., None]] = {}
+        self.event_handlers: dict[str, Callable[..., None]] = {}
+
+    def event(self, name: str) -> Callable[[Callable[..., None]], Callable[..., None]]:
+        def decorator(func: Callable[..., None]) -> Callable[..., None]:
+            self.event_handlers[name] = func
+            return func
+
+        return decorator
+
+    def command(
+        self, name: str
+    ) -> Callable[[Callable[..., None]], Callable[..., None]]:
+        def decorator(func: Callable[..., None]) -> Callable[..., None]:
+            self.command_handlers[name] = func
+            return func
+
+        return decorator
+
+
+class FakeSocketModeHandler:
+    def __init__(self, app: FakeApp, app_token: str) -> None:
+        self.app = app
+        self.app_token = app_token
+
+    def start(self) -> None:
+        return None
+
+    def close(self) -> None:
+        return None
+
+
+def _build_handler(monkeypatch):
+    from lazy_enter import slack_handler as slack_handler_module
+
+    monkeypatch.setattr(slack_handler_module, "App", FakeApp)
+    monkeypatch.setattr(
+        slack_handler_module, "SocketModeHandler", FakeSocketModeHandler
+    )
+
+    config = Config()
+    config.allowed_user_id = "U1"
+    config.allowed_channel_id = "C1"
+    return slack_handler_module.SlackHandler(config)
+
+
+def _capture_commands(handler) -> list[tuple[str, str, str]]:
+    called: list[tuple[str, str, str]] = []
+
+    def callback(action: str, target: str, channel: str) -> None:
+        called.append((action, target, channel))
+
+    handler.on_command(callback)
+    return called
+
+
+def test_start_command_routes_target_from_text(monkeypatch) -> None:
+    handler = _build_handler(monkeypatch)
+    called = _capture_commands(handler)
+    acked: list[bool] = []
+
+    start_handler = handler.app.command_handlers["/start"]
+    start_handler(
+        lambda: acked.append(True),
+        {"user_id": "U1", "channel_id": "C1", "text": "codex"},
+    )
+
+    assert acked == [True]
+    assert called == [("start", "codex", "C1")]
+
+
+def test_start_command_normalizes_target(monkeypatch) -> None:
+    handler = _build_handler(monkeypatch)
+    called = _capture_commands(handler)
+
+    start_handler = handler.app.command_handlers["/start"]
+    start_handler(
+        lambda: None,
+        {"user_id": "U1", "channel_id": "C1", "text": "  Claude   now  "},
+    )
+
+    assert called == [("start", "claude", "C1")]
+
+
+def test_stop_command_ignores_target_text(monkeypatch) -> None:
+    handler = _build_handler(monkeypatch)
+    called = _capture_commands(handler)
+
+    stop_handler = handler.app.command_handlers["/stop"]
+    stop_handler(
+        lambda: None,
+        {"user_id": "U1", "channel_id": "C1", "text": "claude"},
+    )
+
+    assert called == [("stop", "", "C1")]
+
+
+def test_stop_command_without_target_routes_immediately(monkeypatch) -> None:
+    handler = _build_handler(monkeypatch)
+    called = _capture_commands(handler)
+
+    stop_handler = handler.app.command_handlers["/stop"]
+    stop_handler(
+        lambda: None,
+        {"user_id": "U1", "channel_id": "C1", "text": ""},
+    )
+
+    assert called == [("stop", "", "C1")]
+    assert handler.app.client.messages == []
+
+
+def test_invalid_target_sends_warning_message(monkeypatch) -> None:
+    handler = _build_handler(monkeypatch)
+    called = _capture_commands(handler)
+
+    start_handler = handler.app.command_handlers["/start"]
+    start_handler(
+        lambda: None,
+        {"user_id": "U1", "channel_id": "C1", "text": "gpt"},
+    )
+
+    assert called == []
+    assert handler.app.client.messages[-1]["channel"] == "C1"
+    assert "claude" in str(handler.app.client.messages[-1]["text"])
+    assert "codex" in str(handler.app.client.messages[-1]["text"])
+
+
+def test_unauthorized_command_is_ignored(monkeypatch) -> None:
+    handler = _build_handler(monkeypatch)
+    called = _capture_commands(handler)
+
+    start_handler = handler.app.command_handlers["/start"]
+    start_handler(
+        lambda: None,
+        {"user_id": "U2", "channel_id": "C1", "text": "codex"},
+    )
+
+    assert called == []
+    assert handler.app.client.messages == []