dmux 5.3.0 → 5.5.0

package/dist/services/DmuxFocusService.js

@@ -0,0 +1,671 @@
+import { createHash, randomUUID } from 'crypto';
+import { spawn, spawnSync } from 'child_process';
+import { createConnection } from 'node:net';
+import { EventEmitter } from 'events';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import os from 'os';
+import path from 'path';
+import { LogService } from './LogService.js';
+import { TmuxService } from './TmuxService.js';
+import { SettingsManager } from '../utils/settingsManager.js';
+import { buildFocusToken, buildFocusWindowTitle, buildTerminalTitleSequence, mapTerminalProgramToBundleId, parseTmuxSocketPath, supportsNativeDmuxHelper, } from '../utils/focusDetection.js';
+import { getBundledNotificationSoundDefinitions, pickNotificationSound, } from '../utils/notificationSounds.js';
+import { resolvePackagePath } from '../utils/runtimePaths.js';
+const HELPER_RECONNECT_DELAY_MS = 1000;
+const HELPER_SOCKET_WAIT_TIMEOUT_MS = 5000;
+const FOCUS_SYNC_INTERVAL_MS = 350;
+const ATTENTION_FLASH_STEP_MS = 250;
+const ATTENTION_FLASH_SEQUENCE_LENGTH = 12;
+const ATTENTION_FLASH_FALLBACK_BG = 'colour237';
+function isTestEnvironment() {
+    return process.env.NODE_ENV === 'test'
+        || process.env.VITEST === 'true'
+        || typeof process.env.VITEST !== 'undefined';
+}
+function getHelperRuntimePaths() {
+    const helperBaseDir = path.join(os.homedir(), '.dmux', 'native-helper');
+    const appPath = path.join(helperBaseDir, 'dmux-helper.app');
+    const contentsPath = path.join(appPath, 'Contents');
+    const resourcesPath = path.join(contentsPath, 'Resources');
+    return {
+        sourcePath: resolvePackagePath('native', 'macos', 'dmux-helper.swift'),
+        infoPlistSourcePath: resolvePackagePath('native', 'macos', 'dmux-helper-Info.plist'),
+        iconSourcePath: resolvePackagePath('native', 'macos', 'dmux-helper-icon.png'),
+        soundSourceDir: resolvePackagePath('native', 'macos', 'sounds'),
+        appPath,
+        executablePath: path.join(contentsPath, 'MacOS', 'dmux-helper'),
+        resourcesPath,
+        infoPlistPath: path.join(contentsPath, 'Info.plist'),
+        bundleIconPngPath: path.join(resourcesPath, 'dmux-helper.png'),
+        bundleIconIcnsPath: path.join(resourcesPath, 'dmux-helper.icns'),
+        versionPath: path.join(helperBaseDir, 'version.txt'),
+        socketPath: path.join(helperBaseDir, 'run', 'dmux-helper.sock'),
+    };
+}
+const HELPER_BUNDLE_BUILD_VERSION = '1';
+function readTmuxGlobalEnvironment(name) {
+    if (!process.env.TMUX) {
+        return undefined;
+    }
+    const result = spawnSync('tmux', ['show-environment', '-g', name], {
+        stdio: 'pipe',
+        encoding: 'utf-8',
+    });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    const line = result.stdout.trim();
+    if (!line || line === `-${name}`) {
+        return undefined;
+    }
+    const prefix = `${name}=`;
+    if (!line.startsWith(prefix)) {
+        return undefined;
+    }
+    return line.slice(prefix.length);
+}
+function resolveTerminalProgram() {
+    const terminalProgram = process.env.TERM_PROGRAM?.trim();
+    if (terminalProgram && terminalProgram.toLowerCase() !== 'tmux') {
+        return terminalProgram;
+    }
+    return readTmuxGlobalEnvironment('TERM_PROGRAM') ?? terminalProgram;
+}
+function resolveTmuxSocketPath() {
+    const parsedFromEnv = parseTmuxSocketPath(process.env.TMUX);
+    if (parsedFromEnv) {
+        return parsedFromEnv;
+    }
+    if (!process.env.TMUX) {
+        return undefined;
+    }
+    const result = spawnSync('tmux', ['display-message', '-p', '#{socket_path}'], {
+        stdio: 'pipe',
+        encoding: 'utf-8',
+    });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    const socketPath = result.stdout.trim();
+    return socketPath || undefined;
+}
+function buildHelperVersionHash(parts) {
+    const hash = createHash('sha1');
+    hash.update(HELPER_BUNDLE_BUILD_VERSION);
+    for (const part of parts) {
+        hash.update(part);
+    }
+    return hash.digest('hex');
+}
+function shiftHexColor(hex, delta) {
+    const match = hex.trim().match(/^#([0-9a-fA-F]{6})$/);
+    if (!match) {
+        return null;
+    }
+    const value = match[1];
+    const channels = [0, 2, 4].map((offset) => Math.max(0, Math.min(255, Number.parseInt(value.slice(offset, offset + 2), 16) + delta)));
+    return `#${channels.map((channel) => channel.toString(16).padStart(2, '0')).join('')}`;
+}
+function buildAttentionFlashWindowStyle(baseStyle) {
+    const normalized = baseStyle.trim();
+    const bgPattern = /(^|,)\s*bg=([^,\s]+)/;
+    const match = normalized.match(bgPattern);
+    let nextBackground = ATTENTION_FLASH_FALLBACK_BG;
+    if (match?.[2]) {
+        const currentBackground = match[2].trim();
+        const colourMatch = currentBackground.match(/^colour(\d{1,3})$/i);
+        if (colourMatch) {
+            const currentValue = Number.parseInt(colourMatch[1], 10);
+            const nextValue = currentValue >= 248
+                ? Math.max(0, currentValue - 1)
+                : Math.min(255, currentValue + 1);
+            nextBackground = `colour${nextValue}`;
+        }
+        else if (currentBackground === 'default') {
+            nextBackground = ATTENTION_FLASH_FALLBACK_BG;
+        }
+        else {
+            nextBackground = shiftHexColor(currentBackground, 14) ?? ATTENTION_FLASH_FALLBACK_BG;
+        }
+    }
+    if (!match) {
+        return normalized ? `${normalized},bg=${nextBackground}` : `bg=${nextBackground}`;
+    }
+    return normalized.replace(bgPattern, (_full, prefix) => `${prefix}bg=${nextBackground}`);
+}
+function runBuildTool(executable, args) {
+    const result = spawnSync(executable, args, {
+        stdio: 'pipe',
+        encoding: 'utf-8',
+    });
+    return {
+        ok: result.status === 0,
+        output: (result.stderr || result.stdout || '').trim(),
+    };
+}
+async function buildHelperBundleIcon(iconSourcePath, iconIcnsPath) {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dmux-helper-icon-'));
+    const iconsetDir = path.join(tempDir, 'dmux-helper.iconset');
+    try {
+        await fs.mkdir(iconsetDir, { recursive: true });
+        const sizes = [16, 32, 128, 256, 512];
+        for (const size of sizes) {
+            const oneX = path.join(iconsetDir, `icon_${size}x${size}.png`);
+            const twoX = path.join(iconsetDir, `icon_${size}x${size}@2x.png`);
+            let result = runBuildTool('/usr/bin/sips', [
+                '-z',
+                String(size),
+                String(size),
+                iconSourcePath,
+                '--out',
+                oneX,
+            ]);
+            if (!result.ok) {
+                throw new Error(result.output || 'sips failed building helper icon');
+            }
+            result = runBuildTool('/usr/bin/sips', [
+                '-z',
+                String(size * 2),
+                String(size * 2),
+                iconSourcePath,
+                '--out',
+                twoX,
+            ]);
+            if (!result.ok) {
+                throw new Error(result.output || 'sips failed building helper icon');
+            }
+        }
+        const iconutilResult = runBuildTool('/usr/bin/iconutil', [
+            '-c',
+            'icns',
+            iconsetDir,
+            '-o',
+            iconIcnsPath,
+        ]);
+        if (!iconutilResult.ok) {
+            throw new Error(iconutilResult.output || 'iconutil failed building helper icon');
+        }
+    }
+    finally {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    }
+}
+async function ensureHelperBundle(paths) {
+    if (!existsSync(paths.sourcePath) || !existsSync(paths.infoPlistSourcePath)) {
+        return { ready: false, rebuilt: false };
+    }
+    const bundledSoundAssets = getBundledNotificationSoundDefinitions().map((definition) => ({
+        resourceFileName: definition.resourceFileName,
+        sourcePath: path.join(paths.soundSourceDir, definition.resourceFileName),
+    }));
+    const [sourceTemplate, infoPlistTemplate, iconBuffer, soundAssets, currentVersion] = await Promise.all([
+        fs.readFile(paths.sourcePath, 'utf-8'),
+        fs.readFile(paths.infoPlistSourcePath, 'utf-8'),
+        existsSync(paths.iconSourcePath)
+            ? fs.readFile(paths.iconSourcePath)
+            : Promise.resolve(null),
+        Promise.all(bundledSoundAssets
+            .filter((asset) => existsSync(asset.sourcePath))
+            .map(async (asset) => ({
+            ...asset,
+            buffer: await fs.readFile(asset.sourcePath),
+        }))),
+        existsSync(paths.versionPath)
+            ? fs.readFile(paths.versionPath, 'utf-8').catch(() => '')
+            : Promise.resolve(''),
+    ]);
+    const expectedVersion = buildHelperVersionHash([
+        sourceTemplate,
+        infoPlistTemplate,
+        iconBuffer ?? 'no-icon',
+        ...soundAssets.flatMap((asset) => [asset.resourceFileName, asset.buffer]),
+    ]);
+    const needsBuild = !existsSync(paths.executablePath)
+        || !existsSync(paths.infoPlistPath)
+        || (iconBuffer !== null && !existsSync(paths.bundleIconPngPath))
+        || soundAssets.some((asset) => !existsSync(path.join(paths.resourcesPath, asset.resourceFileName)))
+        || currentVersion.trim() !== expectedVersion;
+    if (!needsBuild) {
+        return { ready: true, rebuilt: false };
+    }
+    await fs.rm(paths.appPath, { recursive: true, force: true });
+    await fs.mkdir(path.dirname(paths.executablePath), { recursive: true });
+    await fs.mkdir(paths.resourcesPath, { recursive: true });
+    await fs.writeFile(paths.infoPlistPath, infoPlistTemplate, 'utf-8');
+    if (iconBuffer !== null) {
+        await fs.writeFile(paths.bundleIconPngPath, iconBuffer);
+        try {
+            await buildHelperBundleIcon(paths.bundleIconPngPath, paths.bundleIconIcnsPath);
+        }
+        catch {
+            // The helper can still set the bundled PNG as its runtime icon.
+        }
+    }
+    await Promise.all(soundAssets.map(async (asset) => {
+        await fs.writeFile(path.join(paths.resourcesPath, asset.resourceFileName), asset.buffer);
+    }));
+    const result = spawnSync('swiftc', [
+        '-O',
+        paths.sourcePath,
+        '-o',
+        paths.executablePath,
+        '-framework',
+        'AppKit',
+        '-framework',
+        'ApplicationServices',
+    ], {
+        stdio: 'pipe',
+        encoding: 'utf-8',
+    });
+    if (result.status !== 0) {
+        return { ready: false, rebuilt: false };
+    }
+    await fs.writeFile(paths.versionPath, expectedVersion, 'utf-8');
+    return {
+        ready: true,
+        rebuilt: true,
+    };
+}
+export function parseHelperSocketOwnerProcessIds(lsofOutput, socketPath, currentProcessId = process.pid) {
+    return lsofOutput
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.endsWith(socketPath))
+        .map((line) => {
+        const match = line.match(/^\S+\s+(\d+)\s+/);
+        return match ? Number.parseInt(match[1], 10) : Number.NaN;
+    })
+        .filter((value, index, values) => (Number.isFinite(value)
+        && value > 0
+        && value !== currentProcessId
+        && values.indexOf(value) === index));
+}
+function findHelperSocketOwnerProcessIds(socketPath) {
+    const result = spawnSync('lsof', ['-nP', '-U', socketPath], {
+        stdio: 'pipe',
+        encoding: 'utf-8',
+    });
+    if (result.status !== 0) {
+        return [];
+    }
+    // Only kill the helper process that owns the socket path itself.
+    // Connected clients show up as peer links (`->...`) and must be left alone.
+    return parseHelperSocketOwnerProcessIds(result.stdout, socketPath);
+}
+async function stopRunningHelper(socketPath) {
+    const pids = findHelperSocketOwnerProcessIds(socketPath);
+    if (pids.length === 0) {
+        return true;
+    }
+    for (const pid of pids) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // Ignore races where the helper exits between lookup and signal delivery.
+        }
+    }
+    const deadline = Date.now() + 2000;
+    while (Date.now() < deadline) {
+        const activePids = findHelperSocketOwnerProcessIds(socketPath);
+        if (activePids.length === 0) {
+            break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    await fs.rm(socketPath, { force: true }).catch(() => undefined);
+    return findHelperSocketOwnerProcessIds(socketPath).length === 0;
+}
+async function waitForHelperSocket(socketPath, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (existsSync(socketPath)) {
+            const connected = await new Promise((resolve) => {
+                const probe = createConnection(socketPath);
+                let settled = false;
+                const finish = (value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    probe.destroy();
+                    resolve(value);
+                };
+                probe.once('connect', () => finish(true));
+                probe.once('error', () => finish(false));
+            });
+            if (connected) {
+                return true;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 150));
+    }
+    return false;
+}
+async function ensureHelperRunning(logger) {
+    const helperPaths = getHelperRuntimePaths();
+    const { executablePath, socketPath } = helperPaths;
+    const binaryStatus = await ensureHelperBundle(helperPaths);
+    if (!binaryStatus.ready) {
+        logger.warn('dmux helper app bundle is unavailable on this system', 'focus-helper');
+        return null;
+    }
+    const alreadyRunning = await waitForHelperSocket(socketPath, 250);
+    if (alreadyRunning && !binaryStatus.rebuilt) {
+        return socketPath;
+    }
+    if (alreadyRunning && binaryStatus.rebuilt) {
+        const stopped = await stopRunningHelper(socketPath);
+        if (!stopped) {
+            logger.warn('Failed to restart dmux helper after rebuilding it', 'focus-helper');
+            return socketPath;
+        }
+    }
+    await fs.mkdir(path.dirname(socketPath), { recursive: true });
+    const child = spawn(executablePath, ['--socket', socketPath, '--poll-ms', '250'], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    const started = await waitForHelperSocket(socketPath, HELPER_SOCKET_WAIT_TIMEOUT_MS);
+    if (!started) {
+        logger.warn('Timed out waiting for dmux helper to start', 'focus-helper');
+        return null;
+    }
+    return socketPath;
+}
+export class DmuxFocusService extends EventEmitter {
+    options;
+    logger = LogService.getInstance();
+    tmuxService = TmuxService.getInstance();
+    instanceId = randomUUID();
+    token = buildFocusToken(this.instanceId);
+    terminalProgram = supportsNativeDmuxHelper()
+        ? resolveTerminalProgram()
+        : undefined;
+    bundleId = mapTerminalProgramToBundleId(this.terminalProgram);
+    tmuxSocketPath = supportsNativeDmuxHelper()
+        ? resolveTmuxSocketPath()
+        : undefined;
+    terminalTitle;
+    baseTitle;
+    helperSocketPath = null;
+    helperSocket = null;
+    helperFocused = false;
+    reconnectTimer = null;
+    syncInterval = null;
+    lineBuffer = '';
+    active = false;
+    titleApplied = false;
+    fullyFocusedPaneId = null; // tmux pane id
+    flashingTmuxPaneIds = new Set();
+    constructor(options) {
+        super();
+        this.options = options;
+        this.baseTitle = `dmux ${options.projectName}`;
+        this.terminalTitle = buildFocusWindowTitle(options.projectName, this.token);
+    }
+    resolveAttentionNotificationSoundName() {
+        const settingsManager = new SettingsManager(this.options.projectRoot ?? process.cwd());
+        const selectedSound = pickNotificationSound(settingsManager.getSettings().enabledNotificationSounds);
+        return selectedSound.resourceFileName;
+    }
+    async start() {
+        if (!supportsNativeDmuxHelper() || !process.env.TMUX || isTestEnvironment()) {
+            return;
+        }
+        this.active = true;
+        const helperSocketPath = await ensureHelperRunning(this.logger);
+        if (!helperSocketPath) {
+            return;
+        }
+        this.helperSocketPath = helperSocketPath;
+        this.writeTerminalTitle(this.terminalTitle);
+        this.titleApplied = true;
+        this.syncInterval = setInterval(() => {
+            void this.syncFocusedPaneState();
+        }, FOCUS_SYNC_INTERVAL_MS);
+        this.connectToHelper();
+    }
+    stop() {
+        this.active = false;
+        if (this.syncInterval) {
+            clearInterval(this.syncInterval);
+            this.syncInterval = null;
+        }
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.helperSocket) {
+            this.helperSocket.destroy();
+            this.helperSocket = null;
+        }
+        this.helperFocused = false;
+        this.setFullyFocusedPaneId(null);
+        if (this.titleApplied) {
+            this.writeTerminalTitle(this.baseTitle);
+            this.titleApplied = false;
+        }
+    }
+    connectToHelper() {
+        if (!this.active || !this.helperSocketPath) {
+            return;
+        }
+        this.lineBuffer = '';
+        const socket = createConnection(this.helperSocketPath);
+        this.helperSocket = socket;
+        socket.on('connect', () => {
+            const subscribeMessage = {
+                type: 'subscribe',
+                instanceId: this.instanceId,
+                titleToken: this.token,
+                bundleId: this.bundleId,
+                terminalProgram: this.terminalProgram,
+            };
+            socket.write(`${JSON.stringify(subscribeMessage)}\n`);
+        });
+        socket.on('data', (chunk) => {
+            this.lineBuffer += chunk.toString('utf-8');
+            let newlineIndex = this.lineBuffer.indexOf('\n');
+            while (newlineIndex >= 0) {
+                const line = this.lineBuffer.slice(0, newlineIndex).trim();
+                this.lineBuffer = this.lineBuffer.slice(newlineIndex + 1);
+                if (line) {
+                    this.handleHelperMessage(line);
+                }
+                newlineIndex = this.lineBuffer.indexOf('\n');
+            }
+        });
+        socket.on('error', () => {
+            this.handleHelperDisconnect();
+        });
+        socket.on('close', () => {
+            this.handleHelperDisconnect();
+        });
+    }
+    handleHelperMessage(line) {
+        try {
+            const message = JSON.parse(line);
+            if (message.type !== 'focus-state' || message.instanceId !== this.instanceId) {
+                return;
+            }
+            this.helperFocused = message.fullyFocused;
+            void this.syncFocusedPaneState();
+        }
+        catch {
+            // Ignore malformed helper output and keep current state.
+        }
+    }
+    handleHelperDisconnect() {
+        if (this.helperSocket) {
+            this.helperSocket.destroy();
+            this.helperSocket = null;
+        }
+        this.helperFocused = false;
+        this.setFullyFocusedPaneId(null);
+        if (!this.active || this.reconnectTimer) {
+            return;
+        }
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connectToHelper();
+        }, HELPER_RECONNECT_DELAY_MS);
+    }
+    getFullyFocusedPaneId() {
+        return this.fullyFocusedPaneId;
+    }
+    isPaneFullyFocused(tmuxPaneId) {
+        return this.fullyFocusedPaneId === tmuxPaneId;
+    }
+    setPaneAttentionIndicator(tmuxPaneId, enabled) {
+        if (enabled) {
+            this.tmuxService.setPaneOptionSync(tmuxPaneId, '@dmux_attention', '1');
+            return;
+        }
+        this.tmuxService.unsetPaneOptionSync(tmuxPaneId, '@dmux_attention');
+    }
+    async getPaneAttentionSurface(tmuxPaneId) {
+        if (!this.active || !this.helperFocused) {
+            return 'background';
+        }
+        try {
+            const [currentPaneId, currentWindowId, paneWindowId] = await Promise.all([
+                this.tmuxService.getCurrentPaneId(),
+                this.tmuxService.getCurrentWindowId(),
+                this.tmuxService.getPaneWindowId(tmuxPaneId),
+            ]);
+            if (currentPaneId === tmuxPaneId) {
+                return 'fully-focused';
+            }
+            if (currentWindowId && paneWindowId && currentWindowId === paneWindowId) {
+                return 'same-window';
+            }
+        }
+        catch {
+            return 'background';
+        }
+        return 'background';
+    }
+    async flashPaneAttention(tmuxPaneId) {
+        if (this.flashingTmuxPaneIds.has(tmuxPaneId)) {
+            return;
+        }
+        this.flashingTmuxPaneIds.add(tmuxPaneId);
+        const existingPaneStyle = this.tmuxService.getPaneOptionSync(tmuxPaneId, 'window-style');
+        const baseStyle = existingPaneStyle || this.tmuxService.getGlobalOptionSync('window-style');
+        const flashStyle = buildAttentionFlashWindowStyle(baseStyle);
+        const restorePaneStyle = () => {
+            if (existingPaneStyle) {
+                this.tmuxService.setPaneOptionSync(tmuxPaneId, 'window-style', existingPaneStyle);
+            }
+            else {
+                this.tmuxService.unsetPaneOptionSync(tmuxPaneId, 'window-style');
+            }
+        };
+        for (let step = 0; step < ATTENTION_FLASH_SEQUENCE_LENGTH; step += 1) {
+            setTimeout(() => {
+                if (!this.active) {
+                    restorePaneStyle();
+                    this.flashingTmuxPaneIds.delete(tmuxPaneId);
+                    return;
+                }
+                if (step % 2 === 0) {
+                    this.tmuxService.setPaneOptionSync(tmuxPaneId, 'window-style', flashStyle);
+                }
+                else {
+                    restorePaneStyle();
+                }
+                if (step === ATTENTION_FLASH_SEQUENCE_LENGTH - 1) {
+                    restorePaneStyle();
+                    this.flashingTmuxPaneIds.delete(tmuxPaneId);
+                }
+            }, step * ATTENTION_FLASH_STEP_MS);
+        }
+    }
+    async sendAttentionNotification(request) {
+        if (!supportsNativeDmuxHelper() || isTestEnvironment()) {
+            return false;
+        }
+        const socketPath = await this.ensureHelperSocketPath();
+        if (!socketPath) {
+            return false;
+        }
+        const payload = {
+            type: 'notify',
+            title: request.title,
+            subtitle: request.subtitle,
+            body: request.body,
+            soundName: this.resolveAttentionNotificationSoundName(),
+            titleToken: this.token,
+            bundleId: this.bundleId,
+            tmuxPaneId: request.tmuxPaneId,
+            tmuxSocketPath: this.tmuxSocketPath,
+        };
+        return new Promise((resolve) => {
+            const socket = createConnection(socketPath);
+            let settled = false;
+            const finish = (value) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                socket.destroy();
+                resolve(value);
+            };
+            socket.once('connect', () => {
+                socket.write(`${JSON.stringify(payload)}\n`, (error) => {
+                    finish(!error);
+                });
+            });
+            socket.once('error', () => {
+                finish(false);
+            });
+        });
+    }
+    async ensureHelperSocketPath() {
+        if (this.helperSocketPath) {
+            const helperReady = await waitForHelperSocket(this.helperSocketPath, 100);
+            if (helperReady) {
+                return this.helperSocketPath;
+            }
+        }
+        const helperSocketPath = await ensureHelperRunning(this.logger);
+        if (!helperSocketPath) {
+            return null;
+        }
+        this.helperSocketPath = helperSocketPath;
+        return helperSocketPath;
+    }
+    async syncFocusedPaneState() {
+        if (!this.active || !this.helperFocused) {
+            this.setFullyFocusedPaneId(null);
+            return;
+        }
+        try {
+            const currentPaneId = await this.tmuxService.getCurrentPaneId();
+            if (!currentPaneId) {
+                this.setFullyFocusedPaneId(null);
+                return;
+            }
+            this.setFullyFocusedPaneId(currentPaneId);
+        }
+        catch {
+            this.setFullyFocusedPaneId(null);
+        }
+    }
+    setFullyFocusedPaneId(paneId) {
+        if (this.fullyFocusedPaneId === paneId) {
+            return;
+        }
+        this.fullyFocusedPaneId = paneId;
+        this.emit('focus-changed', {
+            fullyFocusedPaneId: paneId,
+            helperFocused: this.helperFocused,
+        });
+    }
+    writeTerminalTitle(title) {
+        process.stdout.write(buildTerminalTitleSequence(title, Boolean(process.env.TMUX)));
+    }
+}
+//# sourceMappingURL=DmuxFocusService.js.map