didericis-claude
1c11110da5
Apple's container exec --interactive --tty does not put the host terminal into raw mode before starting its I/O relay. In cooked (canonical) mode the kernel line discipline buffers modifier-key escape sequences — e.g. Shift+Enter in modifyOtherKeys mode generates \x1b[13;2~ — until a carriage-return arrives, so they never reach Claude Code inside the container. Add pty_forward.py, a stdlib-only wrapper (modelled on the existing smolmachines pty_resize.py) that sets the host terminal to raw mode via tty.setraw(), spawns the container exec command, and restores the original terminal attributes on exit. Falls back to a bare subprocess.run when stdin is not a TTY (piped invocations, CI) or when termios operations fail. Also retain the --env TERM=<host> forwarding from the previous commit: without TERM inside the container session, Claude Code cannot determine which modifier-key protocol to enable even with raw mode correctly set. Non-TTY exec paths (bottle.exec, cp_in) are unaffected.
110 lines
3.9 KiB
Python
110 lines
3.9 KiB
Python
"""Bottle handle for Apple's `container` CLI."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
from typing import Callable, cast
|
|
|
|
from ...agent_provider import PromptMode, prompt_args
|
|
from .. import Bottle, ExecResult
|
|
from ..terminal import exec_shell_script
|
|
from . import pty_forward as _pty_forward
|
|
|
|
|
|
_PTY_FORWARD_SCRIPT = _pty_forward.__file__
|
|
|
|
|
|
class MacosContainerBottle(Bottle):
|
|
def __init__(
|
|
self,
|
|
container: str,
|
|
teardown: Callable[[], None],
|
|
prompt_path_in_container: str | None,
|
|
*,
|
|
agent_command: str = "claude",
|
|
agent_prompt_mode: PromptMode = "append_file",
|
|
agent_provider_template: str = "claude",
|
|
terminal_title: str = "",
|
|
terminal_color: str = "",
|
|
agent_workdir: str = "/home/node",
|
|
):
|
|
self.name = container
|
|
self._teardown = teardown
|
|
self.prompt_path = prompt_path_in_container
|
|
self._agent_prompt_mode = agent_prompt_mode
|
|
self.agent_command = agent_command
|
|
self.terminal_title = terminal_title
|
|
self.terminal_color = terminal_color
|
|
self.agent_provider_template = agent_provider_template
|
|
self.agent_workdir = agent_workdir
|
|
self._closed = False
|
|
|
|
def agent_argv(self, argv: list[str], *, tty: bool = True) -> list[str]:
|
|
full_argv = list(argv)
|
|
full_argv.extend(
|
|
prompt_args(
|
|
cast(PromptMode, self._agent_prompt_mode),
|
|
self.prompt_path,
|
|
argv=full_argv,
|
|
)
|
|
)
|
|
container_exec = ["container", "exec"]
|
|
if tty:
|
|
container_exec.extend(["--interactive", "--tty"])
|
|
# Forward TERM so Claude Code can enable modifier-key protocols
|
|
# (e.g. modifyOtherKeys / kitty protocol). Without it the inner
|
|
# PTY session has no terminal-type context and Shift+Enter is
|
|
# indistinguishable from plain Enter.
|
|
term = os.environ.get("TERM", "xterm-256color")
|
|
container_exec.extend(["--env", f"TERM={term}"])
|
|
if self.agent_workdir and self.agent_workdir != "/home/node":
|
|
container_exec.extend(["--workdir", self.agent_workdir])
|
|
container_exec.extend([self.name, self.agent_command, *full_argv])
|
|
if tty:
|
|
# Wrap with the raw-mode forwarder: container exec does not put
|
|
# the host terminal into raw mode itself, so the line discipline
|
|
# buffers modifier-key sequences until CR. The wrapper sets raw
|
|
# mode before exec and restores it on exit.
|
|
return [sys.executable, _PTY_FORWARD_SCRIPT, "--", *container_exec]
|
|
return container_exec
|
|
|
|
def exec_agent(self, argv: list[str], *, tty: bool = True) -> int:
|
|
agent_argv = self.agent_argv(argv, tty=tty)
|
|
script = (
|
|
exec_shell_script(agent_argv, self.terminal_title, self.terminal_color)
|
|
if tty else None
|
|
)
|
|
if script is None:
|
|
return subprocess.run(agent_argv, check=False).returncode
|
|
return subprocess.run(["sh", "-lc", script], check=False).returncode
|
|
|
|
def exec(self, script: str, *, user: str = "node") -> ExecResult:
|
|
result = subprocess.run(
|
|
["container", "exec", "--user", user, "--interactive",
|
|
self.name, "sh", "-s"],
|
|
input=script,
|
|
capture_output=True,
|
|
text=True,
|
|
check=False,
|
|
)
|
|
return ExecResult(
|
|
returncode=result.returncode,
|
|
stdout=result.stdout,
|
|
stderr=result.stderr,
|
|
)
|
|
|
|
def cp_in(self, host_path: str, container_path: str) -> None:
|
|
subprocess.run(
|
|
["container", "cp", host_path, f"{self.name}:{container_path}"],
|
|
stdout=subprocess.DEVNULL,
|
|
check=True,
|
|
)
|
|
|
|
def close(self) -> None:
|
|
if self._closed:
|
|
return
|
|
self._closed = True
|
|
self._teardown()
|