aimux-cli 0.1.0

package/dist/tmux-runtime-manager.js

@@ -0,0 +1,794 @@
+import { createHash } from "node:crypto";
+import { basename, dirname, join } from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "./config.js";
+import { debug } from "./debug.js";
+import { getProjectStateDirFor } from "./paths.js";
+export function isDashboardWindowName(name) {
+    return name === "dashboard" || name.startsWith("dashboard-");
+}
+export const MANAGED_TMUX_SESSION_OPTIONS = Object.freeze({
+    prefix: "C-a",
+    prefix2: "C-b",
+    mouse: "on",
+    extendedKeys: "always",
+    extendedKeysFormat: "csi-u",
+});
+export const MANAGED_TMUX_TERMINAL_FEATURES = Object.freeze(["xterm*:extkeys", "xterm*:hyperlinks"]);
+export const MANAGED_TMUX_AGENT_WINDOW_OPTIONS = Object.freeze({
+    allowPassthrough: "on",
+});
+const MODIFIED_ENTER_HEX = "1b 5b 31 33 3b 32 75";
+const DEFAULT_EXEC = (args, options) => execFileSync("tmux", args, {
+    cwd: options?.cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+}).trim();
+const DEFAULT_INTERACTIVE_EXEC = (args, options) => {
+    const result = spawnSync("tmux", args, {
+        cwd: options?.cwd,
+        stdio: "inherit",
+    });
+    if (result.status !== 0) {
+        throw new Error(result.stderr?.toString() || `tmux ${args.join(" ")} failed`);
+    }
+};
+export class TmuxRuntimeManager {
+    exec;
+    interactiveExec;
+    constructor(exec = DEFAULT_EXEC, interactiveExec = DEFAULT_INTERACTIVE_EXEC) {
+        this.exec = exec;
+        this.interactiveExec = interactiveExec;
+    }
+    isAvailable() {
+        try {
+            this.exec(["-V"]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getVersion() {
+        try {
+            return this.exec(["-V"]);
+        }
+        catch {
+            return null;
+        }
+    }
+    getProjectSession(projectRoot) {
+        const projectId = createHash("sha1").update(projectRoot).digest("hex").slice(0, 10);
+        const slug = basename(projectRoot).replace(/[^a-zA-Z0-9_-]+/g, "-") || "project";
+        let prefix = "aimux";
+        try {
+            prefix = loadConfig().runtime.tmux.sessionPrefix || "aimux";
+        }
+        catch { }
+        return {
+            projectRoot,
+            projectId,
+            sessionName: `${prefix}-${slug}-${projectId}`,
+        };
+    }
+    getProjectClientSessionName(hostSessionName, clientSuffix) {
+        return `${hostSessionName}-client-${clientSuffix}`;
+    }
+    isClientSessionName(sessionName) {
+        return /-client-[a-f0-9]{8}$/.test(sessionName);
+    }
+    getOpenSessionName(sessionName, insideTmux = this.isInsideTmux()) {
+        return this.resolveOpenSessionName(sessionName, insideTmux);
+    }
+    peekOpenSessionName(sessionName, insideTmux = this.isInsideTmux()) {
+        if (!this.isManagedSessionName(sessionName) || this.isClientSessionName(sessionName))
+            return sessionName;
+        const clientSuffix = this.resolveClientSuffix(insideTmux);
+        if (!clientSuffix)
+            return sessionName;
+        return this.getProjectClientSessionName(sessionName, clientSuffix);
+    }
+    ensureClientSession(hostSessionName, clientSessionName, projectRoot) {
+        const dashboardName = `dashboard-${clientSessionName.match(/-client-([a-f0-9]{8})$/)?.[1] ?? "client"}`;
+        const clientSessionExists = this.hasSession(clientSessionName);
+        const hostDashboard = this.listWindows(hostSessionName).find((window) => isDashboardWindowName(window.name));
+        const existingDashboard = clientSessionExists
+            ? this.listWindows(clientSessionName).find((window) => isDashboardWindowName(window.name))
+            : undefined;
+        const needsRecreate = !!hostDashboard &&
+            !!existingDashboard &&
+            (existingDashboard.id === hostDashboard.id || existingDashboard.name === "dashboard");
+        if (needsRecreate) {
+            this.exec(["kill-session", "-t", clientSessionName]);
+        }
+        if (!clientSessionExists || needsRecreate) {
+            this.exec([
+                "new-session",
+                "-d",
+                "-s",
+                clientSessionName,
+                "-c",
+                projectRoot,
+                "-n",
+                dashboardName,
+                "sh",
+                "-lc",
+                "tail -f /dev/null",
+            ], { cwd: projectRoot });
+            this.configureSession(clientSessionName, projectRoot);
+            this.exec(["set-option", "-t", clientSessionName, "@aimux-host-session", hostSessionName]);
+            return;
+        }
+        this.configureSession(clientSessionName, projectRoot);
+        this.exec(["set-option", "-t", clientSessionName, "@aimux-host-session", hostSessionName]);
+    }
+    ensureLinkedWindow(clientSessionName, target) {
+        const existing = this.getTargetByWindowId(clientSessionName, target.windowId);
+        if (existing)
+            return existing;
+        this.exec(["link-window", "-d", "-s", target.windowId, "-t", clientSessionName]);
+        const linked = this.getTargetByWindowId(clientSessionName, target.windowId);
+        if (!linked) {
+            throw new Error(`Failed to link window ${target.windowId} into tmux session ${clientSessionName}`);
+        }
+        return linked;
+    }
+    getSessionPrefix() {
+        try {
+            return loadConfig().runtime.tmux.sessionPrefix || "aimux";
+        }
+        catch {
+            return "aimux";
+        }
+    }
+    isManagedSessionName(sessionName) {
+        return sessionName.startsWith(`${this.getSessionPrefix()}-`);
+    }
+    hasSession(sessionName) {
+        try {
+            this.exec(["has-session", "-t", sessionName]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    ensureProjectSession(projectRoot, dashboardCommand) {
+        const session = this.getProjectSession(projectRoot);
+        const exists = this.hasSession(session.sessionName);
+        if (!exists) {
+            const argv = dashboardCommand && dashboardCommand.args.length >= 0
+                ? [
+                    "new-session",
+                    "-d",
+                    "-s",
+                    session.sessionName,
+                    "-c",
+                    dashboardCommand.cwd,
+                    "-n",
+                    "dashboard",
+                    dashboardCommand.command,
+                    ...dashboardCommand.args,
+                ]
+                : [
+                    "new-session",
+                    "-d",
+                    "-s",
+                    session.sessionName,
+                    "-c",
+                    projectRoot,
+                    "-n",
+                    "dashboard",
+                    "sh",
+                    "-lc",
+                    "printf ''",
+                ];
+            this.exec(argv, { cwd: projectRoot });
+        }
+        this.configureSession(session.sessionName, projectRoot);
+        return session;
+    }
+    listWindows(sessionName) {
+        const raw = this.exec([
+            "list-windows",
+            "-t",
+            sessionName,
+            "-F",
+            "#{window_id}\t#{window_index}\t#{window_name}\t#{window_active}\t#{window_activity}",
+        ]);
+        if (!raw)
+            return [];
+        return raw
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            const [id, index, name, active, activity] = line.split("\t");
+            return {
+                id,
+                index: Number(index),
+                name,
+                active: active === "1",
+                activity: activity ? Number(activity) : undefined,
+            };
+        });
+    }
+    listSessionNames() {
+        const raw = this.exec(["list-sessions", "-F", "#{session_name}"]);
+        if (!raw)
+            return [];
+        return raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+    }
+    getTargetByWindowId(sessionName, windowId) {
+        const window = this.listWindows(sessionName).find((entry) => entry.id === windowId);
+        if (!window)
+            return null;
+        return {
+            sessionName,
+            windowId: window.id,
+            windowIndex: window.index,
+            windowName: window.name,
+        };
+    }
+    hasWindow(target) {
+        return this.getTargetByWindowId(target.sessionName, target.windowId) !== null;
+    }
+    isWindowAlive(target) {
+        try {
+            const paneDead = this.exec(["display-message", "-p", "-t", target.windowId, "#{pane_dead}"]).trim();
+            return paneDead !== "1";
+        }
+        catch {
+            return false;
+        }
+    }
+    ensureDashboardWindow(sessionName, projectRoot, dashboardCommand) {
+        const dashboardName = this.getDashboardWindowName();
+        const existing = this.listWindows(sessionName).find((window) => window.name === dashboardName);
+        if (existing) {
+            this.renameWindow(existing.id, dashboardName);
+            return {
+                sessionName,
+                windowId: existing.id,
+                windowIndex: existing.index,
+                windowName: dashboardName,
+            };
+        }
+        const argv = dashboardCommand && dashboardCommand.args.length >= 0
+            ? [
+                "new-window",
+                "-d",
+                "-t",
+                sessionName,
+                "-c",
+                dashboardCommand.cwd,
+                "-n",
+                dashboardName,
+                dashboardCommand.command,
+                ...dashboardCommand.args,
+            ]
+            : ["new-window", "-d", "-t", sessionName, "-c", projectRoot, "-n", dashboardName, "sh", "-lc", "printf ''"];
+        this.exec(argv, {
+            cwd: projectRoot,
+        });
+        const created = this.listWindows(sessionName).find((window) => window.name === dashboardName);
+        if (!created) {
+            throw new Error(`Failed to create dashboard window in tmux session ${sessionName}`);
+        }
+        return {
+            sessionName,
+            windowId: created.id,
+            windowIndex: created.index,
+            windowName: created.name,
+        };
+    }
+    createWindow(sessionName, name, cwd, command, args, options = {}) {
+        const argv = [
+            "new-window",
+            ...(options.detached ? ["-d"] : []),
+            "-P",
+            "-t",
+            sessionName,
+            "-c",
+            cwd,
+            "-n",
+            name,
+            "-F",
+            "#{window_id}\t#{window_index}\t#{window_name}",
+            command,
+            ...args,
+        ];
+        const raw = this.exec(argv, { cwd });
+        const [windowId, index, windowName] = raw.split("\t");
+        return {
+            sessionName,
+            windowId,
+            windowIndex: Number(index),
+            windowName,
+        };
+    }
+    killWindow(target) {
+        this.exec(["kill-window", "-t", target.windowId]);
+    }
+    killSession(sessionName) {
+        this.exec(["kill-session", "-t", sessionName]);
+    }
+    renameWindow(windowTarget, name) {
+        this.exec(["rename-window", "-t", windowTarget, name]);
+    }
+    respawnWindow(target, spec) {
+        this.exec(["respawn-window", "-k", "-t", target.windowId, "-c", spec.cwd, spec.command, ...spec.args], {
+            cwd: spec.cwd,
+        });
+    }
+    selectWindow(target) {
+        this.exec(["select-window", "-t", target.windowId]);
+    }
+    sendFocusIn(target) {
+        this.exec(["send-keys", "-t", target.windowId, "-H", "1b", "5b", "49"]);
+    }
+    switchClientToTarget(clientTty, target) {
+        debug(`tmux switchClientToTarget: client=${clientTty} target=${target.windowId}`, "fork");
+        this.exec(["switch-client", "-c", clientTty, "-t", target.windowId]);
+    }
+    displayWindowMenu(title, items) {
+        if (items.length === 0)
+            return;
+        const args = ["display-menu", "-T", title, "-x", "P", "-y", "P"];
+        for (const item of items) {
+            args.push(item.label, "", `select-window -t ${item.target.windowId}`);
+        }
+        this.exec(args);
+    }
+    displayWindowMenuForClient(clientTty, title, items) {
+        if (items.length === 0)
+            return;
+        const args = ["display-menu", "-c", clientTty, "-T", title, "-x", "P", "-y", "P"];
+        for (const item of items) {
+            args.push(item.label, "", `select-window -t ${item.target.windowId}`);
+        }
+        this.exec(args);
+    }
+    captureTarget(target, options = {}) {
+        const startLine = options.startLine ?? "-";
+        return this.exec(["capture-pane", "-p", "-J", "-t", target.windowId, "-S", String(startLine)]);
+    }
+    listClients() {
+        const raw = this.exec(["list-clients", "-F", "#{client_tty}\t#{session_name}\t#{window_id}\t#{client_name}"]);
+        if (!raw)
+            return [];
+        return raw
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            const [tty, sessionName, windowId, name] = line.split("\t");
+            return { tty, sessionName, windowId, name };
+        });
+    }
+    findClientByTty(clientTty) {
+        const normalized = clientTty.trim();
+        if (!normalized)
+            return null;
+        return this.listClients().find((client) => client.tty === normalized) ?? null;
+    }
+    getAttachedClientForTarget(target) {
+        const clientPrefix = `${target.sessionName}-client-`;
+        const clients = this.listClients().filter((client) => client.sessionName === target.sessionName || client.sessionName.startsWith(clientPrefix));
+        if (clients.length === 0)
+            return null;
+        return clients.find((client) => client.windowId === target.windowId) ?? clients[0] ?? null;
+    }
+    sendText(target, text) {
+        if (!text)
+            return;
+        debug(`tmux sendText: target=${target.windowId} bytes=${Buffer.byteLength(text)} preview=${JSON.stringify(text.slice(0, 180))}`, "fork");
+        this.exec(["send-keys", "-t", target.windowId, "-l", text]);
+    }
+    sendEnter(target) {
+        debug(`tmux sendEnter: target=${target.windowId}`, "fork");
+        this.exec(["send-keys", "-t", target.windowId, "Enter"]);
+    }
+    sendClientEnter(clientTty) {
+        debug(`tmux sendClientEnter: client=${clientTty}`, "fork");
+        this.exec(["send-keys", "-K", "-c", clientTty, "Enter"]);
+    }
+    sendClientCarriageReturn(clientTty, target) {
+        debug(`tmux sendClientCarriageReturn: client=${clientTty} target=${target.windowId}`, "fork");
+        this.exec(["send-keys", "-c", clientTty, "-t", target.windowId, "-H", "0d"]);
+    }
+    sendCarriageReturn(target) {
+        debug(`tmux sendCarriageReturn: target=${target.windowId}`, "fork");
+        this.exec(["send-keys", "-t", target.windowId, "-H", "0d"]);
+    }
+    sendEscape(target) {
+        debug(`tmux sendEscape: target=${target.windowId}`, "fork");
+        this.exec(["send-keys", "-t", target.windowId, "-H", "1b"]);
+    }
+    sendModifiedEnter(target) {
+        debug(`tmux sendModifiedEnter: target=${target.windowId} hex=${MODIFIED_ENTER_HEX}`, "fork");
+        this.exec(["send-keys", "-t", target.windowId, "-H", ...MODIFIED_ENTER_HEX.split(" ")]);
+    }
+    sendKey(target, key) {
+        debug(`tmux sendKey: target=${target.windowId} key=${key}`, "fork");
+        this.exec(["send-keys", "-t", target.windowId, key]);
+    }
+    setWindowMetadata(target, metadata) {
+        const windowTarget = typeof target === "string" ? target : target.windowId;
+        this.exec(["set-window-option", "-q", "-t", windowTarget, "@aimux-meta", JSON.stringify(metadata)]);
+    }
+    setWindowOption(target, key, value) {
+        const windowTarget = typeof target === "string" ? target : target.windowId;
+        this.exec(["set-window-option", "-q", "-t", windowTarget, key, value]);
+    }
+    setSessionOption(sessionName, key, value) {
+        this.exec(["set-option", "-t", sessionName, key, value]);
+    }
+    applyManagedAgentWindowPolicy(target, toolConfigKey) {
+        this.setWindowOption(target, "@aimux-tool", toolConfigKey);
+        this.setWindowOption(target, "allow-passthrough", MANAGED_TMUX_AGENT_WINDOW_OPTIONS.allowPassthrough);
+    }
+    getWindowOption(target, key) {
+        const windowTarget = typeof target === "string" ? target : target.windowId;
+        try {
+            const value = this.exec(["show-window-options", "-v", "-t", windowTarget, key]);
+            return value.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getWindowMetadata(target) {
+        const windowTarget = typeof target === "string" ? target : target.windowId;
+        try {
+            const raw = this.exec(["show-window-options", "-v", "-t", windowTarget, "@aimux-meta"]);
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    listManagedWindows(sessionName) {
+        const windows = this.listWindows(sessionName);
+        const managed = [];
+        for (const window of windows) {
+            const target = {
+                sessionName,
+                windowId: window.id,
+                windowIndex: window.index,
+                windowName: window.name,
+            };
+            const metadata = this.getWindowMetadata(target);
+            if (!metadata)
+                continue;
+            managed.push({ target, metadata });
+        }
+        return managed;
+    }
+    findManagedWindow(sessionName, matcher) {
+        if (!matcher.sessionId && !matcher.backendSessionId)
+            return null;
+        for (const entry of this.listManagedWindows(sessionName)) {
+            if (matcher.sessionId && entry.metadata.sessionId === matcher.sessionId)
+                return entry;
+            if (matcher.backendSessionId && entry.metadata.backendSessionId === matcher.backendSessionId)
+                return entry;
+        }
+        return null;
+    }
+    attachSession(sessionName, windowIndex) {
+        const target = windowIndex === undefined ? sessionName : `${sessionName}:${windowIndex}`;
+        this.interactiveExec(["attach-session", "-t", target]);
+    }
+    detachClient() {
+        this.interactiveExec(["detach-client"]);
+    }
+    switchToLastClientSession() {
+        this.interactiveExec(["switch-client", "-l"]);
+    }
+    currentClientSession() {
+        try {
+            return this.exec(["display-message", "-p", "#{client_session}"]);
+        }
+        catch {
+            return null;
+        }
+    }
+    displayMessage(format, target) {
+        try {
+            const args = target ? ["display-message", "-p", "-t", target, format] : ["display-message", "-p", format];
+            const value = this.exec(args);
+            return value.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getSessionOption(sessionName, key) {
+        try {
+            const value = this.exec(["show-options", "-v", "-t", sessionName, key]);
+            return value.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    setReturnSession(sessionName, returnSessionName) {
+        this.exec(["set-option", "-t", sessionName, "@aimux-return-session", returnSessionName]);
+    }
+    getReturnSession(sessionName) {
+        try {
+            const value = this.exec(["show-options", "-v", "-t", sessionName, "@aimux-return-session"]);
+            return value.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    leaveManagedSession(options = {}) {
+        const activeSession = options.insideTmux
+            ? (this.currentClientSession() ?? options.sessionName)
+            : options.sessionName;
+        if (options.insideTmux && activeSession) {
+            const returnSession = this.getReturnSession(activeSession);
+            const managedPrefix = `${this.getSessionPrefix()}-`;
+            const isExternalReturn = returnSession && returnSession !== activeSession && !returnSession.startsWith(managedPrefix);
+            if (isExternalReturn) {
+                try {
+                    this.interactiveExec(["switch-client", "-t", returnSession]);
+                    return;
+                }
+                catch { }
+            }
+        }
+        this.detachClient();
+    }
+    switchClient(sessionName, windowIndex = 0) {
+        this.interactiveExec(["switch-client", "-t", `${sessionName}:${windowIndex}`]);
+    }
+    isInsideTmux(env = process.env) {
+        return Boolean(env.TMUX);
+    }
+    openTarget(target, options = {}) {
+        const sessionName = options.alreadyResolved
+            ? target.sessionName
+            : this.resolveOpenSessionName(target.sessionName, options.insideTmux === true);
+        const effectiveTarget = sessionName !== target.sessionName && !isDashboardWindowName(target.windowName)
+            ? this.ensureLinkedWindow(sessionName, target)
+            : {
+                ...target,
+                sessionName,
+            };
+        if (options.insideTmux) {
+            const current = this.currentClientSession();
+            if (current && current !== sessionName) {
+                this.setReturnSession(sessionName, current);
+            }
+            this.switchClient(sessionName, effectiveTarget.windowIndex);
+            return;
+        }
+        this.attachSession(sessionName, effectiveTarget.windowIndex);
+    }
+    configureSession(sessionName, projectRoot) {
+        const controlScript = this.getControlScriptShellCommand();
+        const statuslineCommand = this.getStatuslineCommandSpec();
+        const projectStateDir = getProjectStateDirFor(projectRoot);
+        this.exec(["set-option", "-t", sessionName, "@aimux-project-root", projectRoot]);
+        this.exec(["set-option", "-t", sessionName, "prefix", MANAGED_TMUX_SESSION_OPTIONS.prefix]);
+        this.exec(["set-option", "-t", sessionName, "prefix2", MANAGED_TMUX_SESSION_OPTIONS.prefix2]);
+        this.exec(["set-option", "-t", sessionName, "mouse", MANAGED_TMUX_SESSION_OPTIONS.mouse]);
+        this.exec(["set-option", "-t", sessionName, "focus-events", "on"]);
+        this.exec(["set-option", "-t", sessionName, "extended-keys", MANAGED_TMUX_SESSION_OPTIONS.extendedKeys]);
+        this.exec([
+            "set-option",
+            "-t",
+            sessionName,
+            "extended-keys-format",
+            MANAGED_TMUX_SESSION_OPTIONS.extendedKeysFormat,
+        ]);
+        for (const feature of MANAGED_TMUX_TERMINAL_FEATURES) {
+            this.ensureTerminalFeature(sessionName, feature);
+        }
+        this.exec(["unbind-key", "-T", "root", "C-j"]);
+        this.exec(["unbind-key", "-T", "root", "S-Enter"]);
+        this.exec(["unbind-key", "-T", "root", "WheelUpPane"]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "root",
+            "C-j",
+            "if-shell",
+            "-F",
+            "#{m/r:^(claude|codex)$,#{@aimux-tool}}",
+            `send-keys -H ${MODIFIED_ENTER_HEX}`,
+            "send-keys C-j",
+        ]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "root",
+            "S-Enter",
+            "if-shell",
+            "-F",
+            "#{m/r:^(claude|codex)$,#{@aimux-tool}}",
+            `send-keys -H ${MODIFIED_ENTER_HEX}`,
+            "send-keys S-Enter",
+        ]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "root",
+            "WheelUpPane",
+            "if-shell",
+            "-F",
+            "#{m/r:^(claude|codex)$,#{@aimux-tool}}",
+            "copy-mode -e",
+            "if-shell -F '#{||:#{alternate_on},#{pane_in_mode},#{mouse_any_flag}}' 'send-keys -M' 'copy-mode -e'",
+        ]);
+        this.exec(["unbind-key", "-T", "prefix", "s"]);
+        this.exec(["unbind-key", "-T", "prefix", "n"]);
+        this.exec(["unbind-key", "-T", "prefix", "p"]);
+        this.exec(["unbind-key", "-T", "prefix", "d"]);
+        this.exec(["unbind-key", "-T", "prefix", "u"]);
+        this.exec(["bind-key", "-T", "prefix", "C-a", "send-prefix"]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "prefix",
+            "n",
+            "run-shell",
+            "-b",
+            `${controlScript} next --project-root ${shellQuote(projectRoot)} --project-state-dir ${shellQuote(projectStateDir)} --current-client-session '#{client_session}' --client-tty '#{client_tty}' --current-window '#{window_name}' --current-window-id '#{window_id}' --current-path '#{pane_current_path}' --pane-id '#{pane_id}' >/dev/null 2>&1`,
+        ]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "prefix",
+            "p",
+            "run-shell",
+            "-b",
+            `${controlScript} prev --project-root ${shellQuote(projectRoot)} --project-state-dir ${shellQuote(projectStateDir)} --current-client-session '#{client_session}' --client-tty '#{client_tty}' --current-window '#{window_name}' --current-window-id '#{window_id}' --current-path '#{pane_current_path}' --pane-id '#{pane_id}' >/dev/null 2>&1`,
+        ]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "prefix",
+            "s",
+            "run-shell",
+            "-b",
+            `${controlScript} menu --project-root ${shellQuote(projectRoot)} --project-state-dir ${shellQuote(projectStateDir)} --current-client-session '#{client_session}' --client-tty '#{client_tty}' --current-window '#{window_name}' --current-window-id '#{window_id}' --current-path '#{pane_current_path}' --pane-id '#{pane_id}' >/dev/null 2>&1`,
+        ]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "prefix",
+            "u",
+            "run-shell",
+            "-b",
+            `${controlScript} attention --project-root ${shellQuote(projectRoot)} --project-state-dir ${shellQuote(projectStateDir)} --current-client-session '#{client_session}' --client-tty '#{client_tty}' --current-window '#{window_name}' --current-window-id '#{window_id}' --current-path '#{pane_current_path}' --pane-id '#{pane_id}' >/dev/null 2>&1`,
+        ]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "prefix",
+            "d",
+            "run-shell",
+            "-b",
+            `${controlScript} dashboard --project-root ${shellQuote(projectRoot)} --project-state-dir ${shellQuote(projectStateDir)} --current-client-session '#{client_session}' --client-tty '#{client_tty}' --current-window '#{window_name}' --current-window-id '#{window_id}' --current-path '#{pane_current_path}' --pane-id '#{pane_id}' >/dev/null 2>&1`,
+        ]);
+        this.exec(["set-option", "-t", sessionName, "status", "2"]);
+        this.exec(["set-option", "-t", sessionName, "status-interval", "0"]);
+        this.exec(["set-option", "-t", sessionName, "status-style", "bg=colour236,fg=colour252"]);
+        this.exec(["set-option", "-t", sessionName, "message-style", "bg=colour24,fg=colour255,bold"]);
+        this.exec(["set-option", "-t", sessionName, "message-command-style", "bg=colour24,fg=colour255"]);
+        this.exec(["set-option", "-t", sessionName, "window-status-separator", " "]);
+        this.exec(["set-option", "-t", sessionName, "window-status-format", ""]);
+        this.exec(["set-option", "-t", sessionName, "window-status-current-format", ""]);
+        const top = `${statuslineCommand.command} ${statuslineCommand.args.map(shellQuote).join(" ")} --line top --project-state-dir ${shellQuote(projectStateDir)} --current-session '#{session_name}' --current-window '#{window_name}' --current-window-id '#{window_id}'`;
+        const bottom = `${statuslineCommand.command} ${statuslineCommand.args.map(shellQuote).join(" ")} --line bottom --project-state-dir ${shellQuote(projectStateDir)} --current-session '#{session_name}' --current-window '#{window_name}' --current-window-id '#{window_id}'`;
+        this.exec(["set-option", "-t", sessionName, "status-left", ""]);
+        this.exec(["set-option", "-t", sessionName, "status-right", ""]);
+        this.exec([
+            "set-option",
+            "-t",
+            sessionName,
+            "status-format[0]",
+            `#[bg=colour238,fg=colour255,bold] #(${top}) #[default]`,
+        ]);
+        this.exec([
+            "set-option",
+            "-t",
+            sessionName,
+            "status-format[1]",
+            `#[bg=colour236,fg=colour252] #(${bottom}) #[default]`,
+        ]);
+    }
+    refreshStatus() {
+        try {
+            this.exec(["refresh-client", "-S"]);
+        }
+        catch { }
+    }
+    ensureTerminalFeature(sessionName, feature) {
+        const current = this.getSessionOption(sessionName, "terminal-features");
+        const features = current
+            ?.split("\n")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        if (features?.includes(feature))
+            return;
+        this.exec(["set-option", "-as", "-t", sessionName, "terminal-features", `,${feature}`]);
+    }
+    resolveOpenSessionName(sessionName, insideTmux) {
+        if (!this.isManagedSessionName(sessionName) || this.isClientSessionName(sessionName))
+            return sessionName;
+        const clientSuffix = this.resolveClientSuffix(insideTmux);
+        if (!clientSuffix)
+            return sessionName;
+        const clientSessionName = this.getProjectClientSessionName(sessionName, clientSuffix);
+        const projectRoot = this.getSessionOption(sessionName, "@aimux-project-root");
+        if (projectRoot) {
+            this.ensureClientSession(sessionName, clientSessionName, projectRoot);
+        }
+        return clientSessionName;
+    }
+    getDashboardWindowName() {
+        const clientSuffix = this.resolveClientSuffix(this.isInsideTmux());
+        if (!clientSuffix)
+            return "dashboard";
+        return `dashboard-${clientSuffix}`;
+    }
+    normalizeClientSuffix(value) {
+        if (/^[a-f0-9]{8}$/.test(value))
+            return value;
+        return createHash("sha1").update(value).digest("hex").slice(0, 8);
+    }
+    resolveClientSuffix(insideTmux) {
+        const override = process.env.AIMUX_CLIENT_KEY?.trim();
+        if (override)
+            return this.normalizeClientSuffix(override);
+        if (insideTmux) {
+            const currentSession = this.currentClientSession();
+            if (currentSession) {
+                const match = currentSession.match(/-client-([a-f0-9]{8})$/);
+                if (match)
+                    return match[1];
+            }
+            const clientTty = this.displayMessage("#{client_tty}");
+            const clientPid = this.displayMessage("#{client_pid}");
+            if (clientTty || clientPid)
+                return this.normalizeClientSuffix(`${clientTty ?? "tty"}:${clientPid ?? "pid"}`);
+            return null;
+        }
+        try {
+            const tty = execFileSync("tty", {
+                encoding: "utf8",
+                stdio: ["inherit", "pipe", "ignore"],
+            }).trim();
+            return this.normalizeClientSuffix(tty);
+        }
+        catch {
+            return null;
+        }
+    }
+    getStatuslineCommandSpec() {
+        const currentFile = fileURLToPath(import.meta.url);
+        const scriptPath = join(dirname(currentFile), "..", "scripts", "tmux-statusline.sh");
+        return {
+            cwd: process.cwd(),
+            command: "sh",
+            args: [scriptPath],
+        };
+    }
+    getControlScriptShellCommand() {
+        const currentFile = fileURLToPath(import.meta.url);
+        const scriptPath = join(dirname(currentFile), "..", "scripts", "tmux-control.sh");
+        return `sh ${shellQuote(scriptPath)}`;
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+//# sourceMappingURL=tmux-runtime-manager.js.map