Add default directory action to session/window kebab menus

guysmoilov · guysmoilov · commit f619bf8a6a49 · 2026-02-18T00:29:51.000+02:00
diff --git a/src/backend/server.ts b/src/backend/server.ts
@@ -236,6 +236,16 @@ export const createTmuxMobileServer = (
       case "swap_window":
         await deps.tmux.swapWindow(message.session, message.srcIndex, message.dstIndex);
         return;
+      case "set_session_default_directory":
+        await deps.tmux.setSessionDefaultDirectory(message.session, message.directory ?? null);
+        return;
+      case "set_window_default_directory":
+        await deps.tmux.setWindowDefaultDirectory(
+          message.session,
+          message.windowIndex,
+          message.directory ?? null
+        );
+        return;
       case "auth":
         return;
       default: {
diff --git a/src/backend/tmux/cli-executor.ts b/src/backend/tmux/cli-executor.ts
@@ -9,6 +9,8 @@ const execFileAsync = promisify(execFile);
 const SESSION_FMT = "#{session_name}\t#{session_attached}\t#{session_windows}";
 const WINDOW_FMT = "#{window_index}\t#{window_name}\t#{window_active}\t#{window_panes}";
 const PANE_FMT = "#{pane_index}\t#{pane_id}\t#{pane_current_command}\t#{pane_active}\t#{pane_width}x#{pane_height}";
+const SESSION_DEFAULT_DIRECTORY_OPTION = "@tmux_mobile_session_default_directory";
+const WINDOW_DEFAULT_DIRECTORY_OPTION = "@tmux_mobile_window_default_directory";
 
 interface TmuxCliExecutorOptions {
   socketName?: string;
@@ -77,6 +79,23 @@ export class TmuxCliExecutor implements TmuxGateway {
     }
   }
 
+  private async showOption(args: string[]): Promise<string | null> {
+    try {
+      const value = await this.runTmux(["show-options", "-qv", ...args]);
+      return value === "" ? null : value;
+    } catch {
+      return null;
+    }
+  }
+
+  private async getSessionDefaultDirectory(session: string): Promise<string | null> {
+    return this.showOption(["-t", session, SESSION_DEFAULT_DIRECTORY_OPTION]);
+  }
+
+  private async getWindowDefaultDirectory(windowId: string): Promise<string | null> {
+    return this.showOption(["-w", "-t", windowId, WINDOW_DEFAULT_DIRECTORY_OPTION]);
+  }
+
   public async listSessions() {
     const output = await this.runTmuxMaybeNoServer(["list-sessions", "-F", SESSION_FMT]);
     if (!output) {
@@ -120,7 +139,12 @@ export class TmuxCliExecutor implements TmuxGateway {
   }
 
   public async newWindow(session: string): Promise<void> {
-    await this.runTmux(["new-window", "-t", session]);
+    const defaultDirectory = await this.getSessionDefaultDirectory(session);
+    const args = ["new-window", "-t", session];
+    if (defaultDirectory) {
+      args.push("-c", defaultDirectory);
+    }
+    await this.runTmux(args);
   }
 
   public async killWindow(session: string, windowIndex: number): Promise<void> {
@@ -132,7 +156,20 @@ export class TmuxCliExecutor implements TmuxGateway {
   }
 
   public async splitWindow(paneId: string, orientation: "h" | "v"): Promise<void> {
-    await this.runTmux(["split-window", `-${orientation}`, "-t", paneId]);
+    const [windowId, sessionName] = await Promise.all([
+      this.runTmux(["display-message", "-p", "-t", paneId, "#{window_id}"]),
+      this.runTmux(["display-message", "-p", "-t", paneId, "#{session_name}"])
+    ]);
+    const windowDirectory = await this.getWindowDefaultDirectory(windowId);
+    const sessionDirectory = await this.getSessionDefaultDirectory(sessionName);
+    const defaultDirectory = windowDirectory ?? sessionDirectory;
+
+    const args = ["split-window", `-${orientation}`];
+    if (defaultDirectory) {
+      args.push("-c", defaultDirectory);
+    }
+    args.push("-t", paneId);
+    await this.runTmux(args);
   }
 
   public async killPane(paneId: string): Promise<void> {
@@ -170,4 +207,56 @@ export class TmuxCliExecutor implements TmuxGateway {
   public async swapWindow(session: string, srcIndex: number, dstIndex: number): Promise<void> {
     await this.runTmux(["swap-window", "-s", `${session}:${srcIndex}`, "-t", `${session}:${dstIndex}`]);
   }
+
+  public async setSessionDefaultDirectory(
+    session: string,
+    directory: string | null
+  ): Promise<void> {
+    if (!directory) {
+      await this.runTmux([
+        "set-option",
+        "-u",
+        "-t",
+        session,
+        SESSION_DEFAULT_DIRECTORY_OPTION
+      ]);
+      return;
+    }
+
+    await this.runTmux([
+      "set-option",
+      "-t",
+      session,
+      SESSION_DEFAULT_DIRECTORY_OPTION,
+      directory
+    ]);
+  }
+
+  public async setWindowDefaultDirectory(
+    session: string,
+    windowIndex: number,
+    directory: string | null
+  ): Promise<void> {
+    const target = `${session}:${windowIndex}`;
+    if (!directory) {
+      await this.runTmux([
+        "set-option",
+        "-u",
+        "-w",
+        "-t",
+        target,
+        WINDOW_DEFAULT_DIRECTORY_OPTION
+      ]);
+      return;
+    }
+
+    await this.runTmux([
+      "set-option",
+      "-w",
+      "-t",
+      target,
+      WINDOW_DEFAULT_DIRECTORY_OPTION,
+      directory
+    ]);
+  }
 }
diff --git a/src/backend/tmux/types.ts b/src/backend/tmux/types.ts
@@ -26,6 +26,12 @@ export interface TmuxGateway {
   respawnPane(paneId: string): Promise<void>;
   breakPane(paneId: string): Promise<void>;
   swapWindow(session: string, srcIndex: number, dstIndex: number): Promise<void>;
+  setSessionDefaultDirectory(session: string, directory: string | null): Promise<void>;
+  setWindowDefaultDirectory(
+    session: string,
+    windowIndex: number,
+    directory: string | null
+  ): Promise<void>;
 }
 
 export const buildSnapshot = async (
diff --git a/src/backend/types/protocol.ts b/src/backend/types/protocol.ts
@@ -16,7 +16,9 @@ export type ControlClientMessage =
   | { type: "kill_session"; session: string }
   | { type: "respawn_pane"; paneId: string }
   | { type: "break_pane"; paneId: string }
-  | { type: "swap_window"; session: string; srcIndex: number; dstIndex: number };
+  | { type: "swap_window"; session: string; srcIndex: number; dstIndex: number }
+  | { type: "set_session_default_directory"; session: string; directory?: string }
+  | { type: "set_window_default_directory"; session: string; windowIndex: number; directory?: string };
 
 export interface TmuxSessionSummary {
   name: string;
diff --git a/src/frontend/App.tsx b/src/frontend/App.tsx
@@ -657,6 +657,22 @@ export const App = () => {
                             sendControl({ type: "rename_session", session: session.name, newName });
                           }
                         }}>Rename</button>
+                        <button onClick={() => {
+                          setOpenMenu(null);
+                          const directory = window.prompt(
+                            "Default directory for new panes in this session (leave blank to clear)",
+                            ""
+                          );
+                          if (directory === null) {
+                            return;
+                          }
+                          const normalizedDirectory = directory.trim();
+                          sendControl({
+                            type: "set_session_default_directory",
+                            session: session.name,
+                            directory: normalizedDirectory || undefined
+                          });
+                        }}>Set Default Directory</button>
                         <button onClick={() => {
                           setOpenMenu(null);
                           sendControl({ type: "new_window", session: session.name });
@@ -720,6 +736,23 @@ export const App = () => {
                                 sendControl({ type: "rename_window", session: activeSession.name, windowIndex: windowState.index, newName });
                               }
                             }}>Rename</button>
+                            <button onClick={() => {
+                              setOpenMenu(null);
+                              const directory = window.prompt(
+                                "Default directory for new panes in this window (leave blank to clear)",
+                                ""
+                              );
+                              if (directory === null) {
+                                return;
+                              }
+                              const normalizedDirectory = directory.trim();
+                              sendControl({
+                                type: "set_window_default_directory",
+                                session: activeSession.name,
+                                windowIndex: windowState.index,
+                                directory: normalizedDirectory || undefined
+                              });
+                            }}>Set Default Directory</button>
                             <button onClick={() => {
                               setOpenMenu(null);
                               sendControl({ type: "split_pane", paneId: windowState.panes[0]?.id ?? "", orientation: "h" });
diff --git a/tests/harness/fakeTmux.ts b/tests/harness/fakeTmux.ts
@@ -59,6 +59,8 @@ const buildDefaultSession = (name: string): SessionNode => ({
 export class FakeTmuxGateway implements TmuxGateway {
   private sessions: SessionNode[] = [];
   private failSwitchClient = false;
+  private readonly sessionDefaultDirectories = new Map<string, string>();
+  private readonly windowDefaultDirectories = new Map<string, string>();
   public readonly calls: string[] = [];
 
   public constructor(seedSessions: string[] = [], options: FakeTmuxOptions = {}) {
@@ -136,6 +138,7 @@ export class FakeTmuxGateway implements TmuxGateway {
       window.active = false;
     }
     const nextIndex = session.windows.at(-1)?.index ?? -1;
+    const defaultDirectory = this.sessionDefaultDirectories.get(sessionName);
     session.windows.push({
       index: nextIndex + 1,
       name: `win-${nextIndex + 1}`,
@@ -144,7 +147,7 @@ export class FakeTmuxGateway implements TmuxGateway {
         {
           index: 0,
           id: `%${paneCounter++}`,
-          command: "bash",
+          command: defaultDirectory ? `bash@${defaultDirectory}` : "bash",
           active: true,
           width: 120,
           height: 40
@@ -171,15 +174,22 @@ export class FakeTmuxGateway implements TmuxGateway {
   }
 
   public async splitWindow(paneId: string, orientation: "h" | "v"): Promise<void> {
-    this.calls.push(`splitWindow:${paneId}:${orientation}`);
     const { session, window } = this.findByPane(paneId);
+    const windowKey = `${session.name}:${window.index}`;
+    const defaultDirectory =
+      this.windowDefaultDirectories.get(windowKey) ?? this.sessionDefaultDirectories.get(session.name);
+    this.calls.push(
+      defaultDirectory
+        ? `splitWindow:${paneId}:${orientation}:${defaultDirectory}`
+        : `splitWindow:${paneId}:${orientation}`
+    );
     for (const pane of window.panes) {
       pane.active = false;
     }
     window.panes.push({
       index: window.panes.length,
       id: `%${paneCounter++}`,
-      command: "bash",
+      command: defaultDirectory ? `bash@${defaultDirectory}` : "bash",
       active: true,
       width: orientation === "h" ? 60 : 120,
       height: orientation === "v" ? 20 : 40
@@ -215,6 +225,36 @@ export class FakeTmuxGateway implements TmuxGateway {
     return `captured ${lines} lines for ${paneId}`;
   }
 
+  public async setSessionDefaultDirectory(
+    session: string,
+    directory: string | null
+  ): Promise<void> {
+    this.calls.push(
+      `setSessionDefaultDirectory:${session}:${directory ?? "<unset>"}`
+    );
+    if (!directory) {
+      this.sessionDefaultDirectories.delete(session);
+      return;
+    }
+    this.sessionDefaultDirectories.set(session, directory);
+  }
+
+  public async setWindowDefaultDirectory(
+    session: string,
+    windowIndex: number,
+    directory: string | null
+  ): Promise<void> {
+    const key = `${session}:${windowIndex}`;
+    this.calls.push(
+      `setWindowDefaultDirectory:${session}:${windowIndex}:${directory ?? "<unset>"}`
+    );
+    if (!directory) {
+      this.windowDefaultDirectories.delete(key);
+      return;
+    }
+    this.windowDefaultDirectories.set(key, directory);
+  }
+
   public setFailSwitchClient(value: boolean): void {
     this.failSwitchClient = value;
   }
diff --git a/tests/integration/server.test.ts b/tests/integration/server.test.ts
@@ -182,6 +182,57 @@ describe("tmux mobile server", () => {
     control.close();
   });
 
+  test("applies session and window default directories for new panes", async () => {
+    await runningServer.stop();
+    await startWithSessions(["main"]);
+
+    const control = await openSocket(`${baseWsUrl}/ws/control`);
+    control.send(JSON.stringify({ type: "auth", token: "test-token" }));
+
+    await waitForMessage(control, (msg: { type: string }) => msg.type === "attached");
+    const snapshot = await buildSnapshot(tmux);
+    const paneId = snapshot.sessions[0].windowStates[0].panes[0].id;
+
+    control.send(
+      JSON.stringify({
+        type: "set_session_default_directory",
+        session: "main",
+        directory: "/tmp/session-default"
+      })
+    );
+    control.send(JSON.stringify({ type: "split_pane", paneId, orientation: "h" }));
+
+    control.send(
+      JSON.stringify({
+        type: "set_window_default_directory",
+        session: "main",
+        windowIndex: 0,
+        directory: "/tmp/window-default"
+      })
+    );
+    control.send(JSON.stringify({ type: "split_pane", paneId, orientation: "v" }));
+
+    control.send(
+      JSON.stringify({
+        type: "set_window_default_directory",
+        session: "main",
+        windowIndex: 0
+      })
+    );
+    control.send(JSON.stringify({ type: "split_pane", paneId, orientation: "h" }));
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(tmux.calls).toContain("setSessionDefaultDirectory:main:/tmp/session-default");
+    expect(tmux.calls).toContain("setWindowDefaultDirectory:main:0:/tmp/window-default");
+    expect(tmux.calls).toContain("setWindowDefaultDirectory:main:0:<unset>");
+    expect(tmux.calls).toContain(`splitWindow:${paneId}:h:/tmp/session-default`);
+    expect(tmux.calls).toContain(`splitWindow:${paneId}:v:/tmp/window-default`);
+    expect(tmux.calls.filter((call) => call === `splitWindow:${paneId}:h:/tmp/session-default`)).toHaveLength(2);
+
+    control.close();
+  });
+
   test("stop is idempotent when called repeatedly", async () => {
     await runningServer.stop();
     await runningServer.stop();
