poll terminal session state for non regular shells

Author: icecrasher321

apps/desktop/src/main/terminal/index.ts

@@ -58,6 +58,13 @@ const INPUT_ECHO_MS = 250
 /** Enough of the screen to show whether the input took, without a wall of it. */
 const INPUT_SCREEN_LINES = 60
 
+/**
+ * How often the active terminal's directory is reconciled against the OS.
+ * Fast enough that a `cd` renames the tab about as soon as the user looks at
+ * it, slow enough that the lookup is nowhere near a hot path.
+ */
+const CWD_POLL_MS = 1_000
+
 function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
@@ -117,6 +124,7 @@ export class TerminalService {
   private nextId = 1
   private sink: TerminalSink | null = null
   private lastEmittedTabs: string | null = null
+  private cwdTimer: NodeJS.Timeout | null = null
 
   constructor(private readonly options: TerminalServiceOptions = {}) {}
 
@@ -125,6 +133,32 @@ export class TerminalService {
     // A new sink has seen nothing, so the dedupe baseline has to reset or the
     // panel would wait for an unrelated change before learning the tab list.
     this.lastEmittedTabs = null
+    if (sink) this.startCwdWatch()
+    else this.stopCwdWatch()
+  }
+
+  /**
+   * Keeps the visible tab's directory honest without depending on the shell.
+   *
+   * Only the active session is polled, and only while a panel is attached and
+   * nothing is running in the foreground (a running command owns the label
+   * anyway), so this costs one cheap lookup a second at most — the reason it
+   * samples rather than watching every keystroke.
+   */
+  private startCwdWatch(): void {
+    if (this.cwdTimer) return
+    this.cwdTimer = setInterval(() => {
+      const active = this.activeId ? this.sessions.get(this.activeId) : null
+      if (!active || active.isBusy) return
+      void active.refreshCwd()
+    }, CWD_POLL_MS)
+    this.cwdTimer.unref?.()
+  }
+
+  private stopCwdWatch(): void {
+    if (!this.cwdTimer) return
+    clearInterval(this.cwdTimer)
+    this.cwdTimer = null
   }
 
   getTabs(): TerminalTabsState {
@@ -173,6 +207,7 @@ export class TerminalService {
     }
     this.activeId = terminalId
     this.emitTabs()
+    void this.sessions.get(terminalId)?.refreshCwd()
     return this.getTabs()
   }
 
@@ -201,6 +236,7 @@ export class TerminalService {
   }
 
   dispose(): void {
+    this.stopCwdWatch()
     for (const session of this.sessions.values()) session.dispose()
     this.sessions.clear()
     this.activeId = null

apps/desktop/src/main/terminal/process-cwd.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+import { parseLsofCwd, readProcessCwd } from '@/main/terminal/process-cwd'
+
+describe('parseLsofCwd', () => {
+  it('picks the path out of lsof field output', () => {
+    expect(parseLsofCwd('p123\nfcwd\nn/Users/me/project\n')).toBe('/Users/me/project')
+  })
+
+  it('keeps paths containing spaces intact', () => {
+    expect(parseLsofCwd('p1\nfcwd\nn/Users/me/My Code/app\n')).toBe('/Users/me/My Code/app')
+  })
+
+  it('returns null when no path field is present', () => {
+    expect(parseLsofCwd('')).toBeNull()
+    expect(parseLsofCwd('p123\nfcwd\n')).toBeNull()
+    // A field line that is not an absolute path is not a cwd.
+    expect(parseLsofCwd('p123\nnrelative/path\n')).toBeNull()
+  })
+})
+
+describe('readProcessCwd', () => {
+  it('rejects invalid pids without touching the OS', async () => {
+    await expect(readProcessCwd(0)).resolves.toBeNull()
+    await expect(readProcessCwd(-1)).resolves.toBeNull()
+    await expect(readProcessCwd(Number.NaN)).resolves.toBeNull()
+  })
+
+  it('resolves this process to a real directory', async () => {
+    const cwd = await readProcessCwd(process.pid)
+    // Unsupported platforms report null rather than guessing.
+    if (process.platform !== 'darwin' && process.platform !== 'linux') {
+      expect(cwd).toBeNull()
+      return
+    }
+    expect(cwd?.startsWith('/')).toBe(true)
+  })
+
+  it('returns null for a pid that does not exist', async () => {
+    await expect(readProcessCwd(2_147_483_600)).resolves.toBeNull()
+  })
+})

apps/desktop/src/main/terminal/process-cwd.ts

@@ -0,0 +1,91 @@
+/**
+ * Reads a running process's working directory from the OS.
+ *
+ * The shell announces `cd` through its shell-integration hooks, but only when
+ * those hooks are installed — a shell we cannot instrument (fish, nushell), a
+ * config that clobbers the prompt hooks, or a shell started before the hooks
+ * loaded leaves the reported directory frozen at spawn. Asking the OS for the
+ * shell's real cwd needs no cooperation from the shell at all, so it is the
+ * source of truth the tab title falls back on. This mirrors how VS Code
+ * resolves a terminal's cwd (`lsof` on macOS, procfs on Linux).
+ */
+import { spawn } from 'node:child_process'
+import { readlink } from 'node:fs/promises'
+import { createLogger } from '@sim/logger'
+
+const logger = createLogger('DesktopTerminalProcessCwd')
+
+/** A hung `lsof` must never wedge the poller; the call is best-effort. */
+const LOOKUP_TIMEOUT_MS = 2_000
+
+/**
+ * The current working directory of `pid`, or null when it cannot be resolved
+ * (process gone, permission denied, unsupported platform). Never throws.
+ */
+export async function readProcessCwd(pid: number): Promise<string | null> {
+  if (!Number.isInteger(pid) || pid <= 0) return null
+  if (process.platform === 'linux') return readProcCwd(pid)
+  if (process.platform === 'darwin') return readLsofCwd(pid)
+  return null
+}
+
+/** Linux: the kernel exposes the cwd as a symlink, so no subprocess is needed. */
+async function readProcCwd(pid: number): Promise<string | null> {
+  try {
+    return await readlink(`/proc/${pid}/cwd`)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * macOS has no procfs, so the cwd comes from `lsof`. The query is narrowed to
+ * one process and one descriptor (`-a -d cwd -p <pid>`) and asks for field
+ * output (`-Fn`), which prints `n<path>` — far cheaper than an unfiltered
+ * `lsof` that would enumerate every open file on the system.
+ */
+function readLsofCwd(pid: number): Promise<string | null> {
+  return new Promise((resolve) => {
+    let child: ReturnType<typeof spawn>
+    try {
+      child = spawn('lsof', ['-a', '-d', 'cwd', '-p', String(pid), '-Fn'], {
+        stdio: ['ignore', 'pipe', 'ignore'],
+      })
+    } catch (error) {
+      logger.warn('Could not run lsof for terminal cwd', { error: (error as Error).message })
+      resolve(null)
+      return
+    }
+
+    let stdout = ''
+    let settled = false
+    const finish = (value: string | null) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(value)
+    }
+
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL')
+      finish(null)
+    }, LOOKUP_TIMEOUT_MS)
+
+    child.stdout?.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString()
+    })
+    child.on('error', () => finish(null))
+    child.on('close', () => finish(parseLsofCwd(stdout)))
+  })
+}
+
+/**
+ * Picks the path out of `lsof -Fn` field output, whose lines are a one-letter
+ * field type followed by the value (`n/Users/me/project`).
+ */
+export function parseLsofCwd(stdout: string): string | null {
+  for (const line of stdout.split('\n')) {
+    if (line.startsWith('n/')) return line.slice(1)
+  }
+  return null
+}

apps/desktop/src/main/terminal/session.ts

@@ -24,6 +24,7 @@ import {
   type TerminalTabState,
 } from '@sim/terminal-protocol'
 import { Terminal as HeadlessTerminal } from '@xterm/headless'
+import { readProcessCwd } from '@/main/terminal/process-cwd'
 import {
   buildShellLaunch,
   createNonce,
@@ -317,6 +318,25 @@ export class TerminalSession {
     return this.pty.pid
   }
 
+  /**
+   * Reconciles the tracked cwd with the shell's real one, read from the OS.
+   *
+   * The shell-integration hooks report `cd` instantly when they are installed,
+   * but they cannot be relied on alone: a shell we cannot instrument, a config
+   * that overrides the prompt hooks, or a session whose hooks never loaded
+   * would otherwise leave the tab labelled with the directory the shell
+   * started in — the user's home, whose basename is their username. Asking the
+   * OS needs no cooperation from the shell, so it is what makes the label
+   * correct in every case.
+   */
+  async refreshCwd(): Promise<void> {
+    if (this.disposed) return
+    const cwd = await readProcessCwd(this.pty.pid)
+    if (this.disposed || !cwd || cwd === this.cwd) return
+    this.cwd = cwd
+    this.emitState()
+  }
+
   /**
    * The shell's environment. tmux invocations made on this terminal's behalf
    * reuse it so they reach the same server socket the user's client is on.