diff --git a/Resources/shell-integration/cmux-bash-integration.bash b/Resources/shell-integration/cmux-bash-integration.bash index 242dcb7d..643fc841 100644 --- a/Resources/shell-integration/cmux-bash-integration.bash +++ b/Resources/shell-integration/cmux-bash-integration.bash @@ -100,7 +100,7 @@ _cmux_report_tty_once() { _CMUX_TTY_REPORTED=1 { _cmux_send "report_tty $_CMUX_TTY_NAME --tab=$CMUX_TAB_ID --panel=$CMUX_PANEL_ID" - } >/dev/null 2>&1 & + } >/dev/null 2>&1 & disown } _cmux_ports_kick() { @@ -112,7 +112,7 @@ _cmux_ports_kick() { _CMUX_PORTS_LAST_RUN=$SECONDS { _cmux_send "ports_kick --tab=$CMUX_TAB_ID --panel=$CMUX_PANEL_ID" - } >/dev/null 2>&1 & + } >/dev/null 2>&1 & disown } _cmux_prompt_command() { @@ -161,7 +161,7 @@ _cmux_prompt_command() { { local qpwd="${pwd//\"/\\\"}" _cmux_send "report_pwd \"${qpwd}\" --tab=$CMUX_TAB_ID --panel=$CMUX_PANEL_ID" - } >/dev/null 2>&1 & + } >/dev/null 2>&1 & disown fi # Branch can change via aliases/tools while an older probe is still in flight. @@ -211,6 +211,7 @@ _cmux_prompt_command() { fi } >/dev/null 2>&1 & _CMUX_GIT_JOB_PID=$! + disown _CMUX_GIT_JOB_STARTED_AT=$now fi @@ -254,6 +255,7 @@ _cmux_prompt_command() { fi } >/dev/null 2>&1 & _CMUX_PR_JOB_PID=$! + disown _CMUX_PR_JOB_STARTED_AT=$now fi fi @@ -262,6 +264,7 @@ _cmux_prompt_command() { if (( now - _CMUX_PORTS_LAST_RUN >= 10 )); then _cmux_ports_kick fi + } _cmux_install_prompt_command() { diff --git a/Sources/Workspace.swift b/Sources/Workspace.swift index 969819ee..a45cf6ed 100644 --- a/Sources/Workspace.swift +++ b/Sources/Workspace.swift @@ -1956,11 +1956,21 @@ final class Workspace: Identifiable, ObservableObject { guard let paneId = sourcePaneId else { return nil } let inheritedConfig = inheritedTerminalConfig(preferredPanelId: panelId, inPane: paneId) + // Inherit working directory: prefer the source panel's reported cwd, + // fall back to the workspace's current directory. + let splitWorkingDirectory: String? = panelDirectories[panelId] + ?? (currentDirectory.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty + ? nil : currentDirectory) +#if DEBUG + dlog("split.cwd panelId=\(panelId.uuidString.prefix(5)) panelDir=\(panelDirectories[panelId] ?? "nil") currentDir=\(currentDirectory) resolved=\(splitWorkingDirectory ?? "nil")") +#endif + // Create the new terminal panel. let newPanel = TerminalPanel( workspaceId: id, context: GHOSTTY_SURFACE_CONTEXT_SPLIT, configTemplate: inheritedConfig, + workingDirectory: splitWorkingDirectory, portOrdinal: portOrdinal ) panels[newPanel.id] = newPanel diff --git a/docs/assets/split-cwd-inheritance-demo.gif b/docs/assets/split-cwd-inheritance-demo.gif new file mode 100644 index 00000000..5a1c1c9c Binary files /dev/null and b/docs/assets/split-cwd-inheritance-demo.gif differ diff --git a/tests/test_split_cwd_inheritance.py b/tests/test_split_cwd_inheritance.py new file mode 100644 index 00000000..6677ee8e --- /dev/null +++ b/tests/test_split_cwd_inheritance.py @@ -0,0 +1,213 @@ +#!/usr/bin/env python3 +""" +End-to-end test for split CWD inheritance. + +Verifies that new split panes and new workspace tabs inherit the current +working directory from the source terminal. + +Requires: + - cmux running with allowAll socket mode + - bash shell integration sourced (cmux-bash-integration.bash) + +Run with a tagged instance: + CMUX_TAG= python3 tests/test_split_cwd_inheritance.py +""" + +from __future__ import annotations + +import os +import sys +import time +from pathlib import Path + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from cmux import cmux # noqa: E402 + + +def _parse_sidebar_state(text: str) -> dict[str, str]: + data: dict[str, str] = {} + for raw in (text or "").splitlines(): + line = raw.rstrip("\n") + if not line or line.startswith(" "): + continue + if "=" not in line: + continue + k, v = line.split("=", 1) + data[k.strip()] = v.strip() + return data + + +def _wait_for(predicate, timeout: float, interval: float, label: str): + start = time.time() + last_error: Exception | None = None + while time.time() - start < timeout: + try: + value = predicate() + if value: + return value + except Exception as e: + last_error = e + time.sleep(interval) + extra = "" + if last_error is not None: + extra = f" Last error: {last_error}" + raise AssertionError(f"Timed out waiting for {label}.{extra}") + + +def _wait_for_focused_cwd( + client: cmux, + expected: str, + timeout: float = 12.0, + exclude_panel: str | None = None, +) -> dict[str, str]: + """Wait for focused_cwd to match expected. + + If exclude_panel is given, also require that focused_panel differs from + that value — ensuring we're checking the *new* pane, not the original. + """ + def pred(): + state = _parse_sidebar_state(client.sidebar_state()) + cwd = state.get("focused_cwd", "") + if cwd != expected: + return None + if exclude_panel and state.get("focused_panel", "") == exclude_panel: + return None + return state + label = f"focused_cwd={expected!r}" + if exclude_panel: + label += f" (panel != {exclude_panel})" + return _wait_for(pred, timeout=timeout, interval=0.3, label=label) + + +def _send_cd_and_wait( + client: cmux, + target: str, + timeout: float = 12.0, +) -> dict[str, str]: + """cd to target and wait for sidebar focused_cwd to reflect it.""" + client.send(f"cd {target}\n") + return _wait_for_focused_cwd(client, target, timeout=timeout) + + +def main() -> int: + tag = os.environ.get("CMUX_TAG", "") + + socket_path = None + if tag: + socket_path = f"/tmp/cmux-debug-{tag}.sock" + client = cmux(socket_path=socket_path) + client.connect() + + # Use resolved paths to avoid /tmp -> /private/tmp symlink mismatch on macOS + test_dir_a = str(Path("/tmp/cmux_split_cwd_test_a").resolve()) + test_dir_b = str(Path("/tmp/cmux_split_cwd_test_b").resolve()) + os.makedirs(test_dir_a, exist_ok=True) + os.makedirs(test_dir_b, exist_ok=True) + + passed = 0 + failed = 0 + + def check(name: str, condition: bool, detail: str = ""): + nonlocal passed, failed + if condition: + print(f" PASS {name}") + passed += 1 + else: + print(f" FAIL {name}{': ' + detail if detail else ''}") + failed += 1 + + print("=== Split CWD Inheritance Tests ===") + + # --- Setup: cd to test_dir_a in workspace 1 --- + print(" [setup] cd to test_dir_a and wait for shell integration...") + _send_cd_and_wait(client, test_dir_a) + state = _parse_sidebar_state(client.sidebar_state()) + check("setup: focused_cwd is test_dir_a", state.get("focused_cwd") == test_dir_a, + f"got {state.get('focused_cwd')!r}") + + # --- Test 1: New split inherits test_dir_a --- + print(" [test1] creating right split from test_dir_a...") + # Record the original panel so we can verify focus moves to the NEW pane. + original_panel = state.get("focused_panel", "") + split_result = client.new_split("right") + if not split_result: + check("split created", False) + print(f"\n{passed} passed, {failed} failed") + client.close() + return 1 + check("split created", True) + + # Wait for the NEW pane (different panel ID) to report test_dir_a. + time.sleep(4) # wait for new bash to start + run PROMPT_COMMAND + try: + state = _wait_for_focused_cwd( + client, test_dir_a, timeout=15.0, exclude_panel=original_panel, + ) + new_panel = state.get("focused_panel", "") + check("test1: focus moved to new pane", new_panel != original_panel, + f"original={original_panel!r}, current={new_panel!r}") + check("test1: split inherited test_dir_a", + state.get("focused_cwd") == test_dir_a, + f"focused_cwd={state.get('focused_cwd')!r}") + except AssertionError: + state = _parse_sidebar_state(client.sidebar_state()) + check("test1: split inherited test_dir_a", False, + f"focused_cwd={state.get('focused_cwd')!r}, focused_panel={state.get('focused_panel')!r}") + + # --- Test 2: New workspace tab inherits CWD --- + # First cd to test_dir_b so we have a different dir to inherit + print(" [test2] cd to test_dir_b, then creating new workspace tab...") + _send_cd_and_wait(client, test_dir_b) + state = _parse_sidebar_state(client.sidebar_state()) + original_tab = state.get("tab", "") + + tab_result = client.new_tab() + if not tab_result: + check("new tab created", False) + print(f"\n{passed} passed, {failed} failed") + client.close() + return 1 + check("new tab created", True) + + # New workspace should be a different tab AND inherit test_dir_b + time.sleep(4) + try: + def _new_tab_with_cwd(): + s = _parse_sidebar_state(client.sidebar_state()) + tab_id = s.get("tab", "") + cwd = s.get("focused_cwd", "") + if tab_id != original_tab and cwd == test_dir_b: + return s + return None + + state = _wait_for( + _new_tab_with_cwd, timeout=15.0, interval=0.3, + label=f"new tab with focused_cwd={test_dir_b!r}", + ) + check("test2: focus moved to new tab", state.get("tab") != original_tab, + f"original={original_tab!r}, current={state.get('tab')!r}") + check("test2: new workspace inherited test_dir_b", + state.get("focused_cwd") == test_dir_b, + f"focused_cwd={state.get('focused_cwd')!r}") + except AssertionError: + state = _parse_sidebar_state(client.sidebar_state()) + check("test2: new workspace inherited test_dir_b", False, + f"focused_cwd={state.get('focused_cwd')!r}, tab={state.get('tab')!r}") + + print(f"\n{passed} passed, {failed} failed") + + client.close() + + # Cleanup + for d in [test_dir_a, test_dir_b]: + try: + os.rmdir(d) + except OSError: + pass + + return 1 if failed else 0 + + +if __name__ == "__main__": + sys.exit(main())