santree 0.3.0 → 0.5.0

package/dist/lib/dashboard/external-editor.js

@@ -0,0 +1,74 @@
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+// GUI editors that detach by default and need a `--wait` flag to make spawnSync
+// block until the file is closed. Terminal editors (vim, nvim, nano, emacs -nw)
+// already block, so they aren't listed here.
+const GUI_EDITORS_NEEDING_WAIT = new Set([
+    "zed",
+    "code",
+    "code-insiders",
+    "cursor",
+    "windsurf",
+    "subl",
+]);
+/**
+ * Open the user's editor on a temp file seeded with `initial`, then return the
+ * saved content. Empty buffer is treated as cancel (matches `git commit`).
+ *
+ * Editor resolution: SANTREE_EDITOR > VISUAL > EDITOR > "vim".
+ */
+export function editExternally(initial, ext = "md") {
+    const editorRaw = process.env["SANTREE_EDITOR"] || process.env["VISUAL"] || process.env["EDITOR"] || "vim";
+    const filePath = path.join(os.tmpdir(), `santree-edit-${Date.now()}.${ext.replace(/^\./, "")}`);
+    try {
+        fs.writeFileSync(filePath, initial);
+    }
+    catch {
+        return { ok: false, content: initial, cancelled: false };
+    }
+    const parts = editorRaw.split(/\s+/).filter(Boolean);
+    const cmd = parts[0] ?? "vim";
+    const baseArgs = parts.slice(1);
+    const needsWait = GUI_EDITORS_NEEDING_WAIT.has(path.basename(cmd)) &&
+        !baseArgs.includes("--wait") &&
+        !baseArgs.includes("-w");
+    const args = [...baseArgs, ...(needsWait ? ["--wait"] : []), filePath];
+    const wasRaw = process.stdin.isTTY ? process.stdin.isRaw : false;
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+        try {
+            process.stdin.setRawMode(false);
+        }
+        catch { }
+    }
+    const result = spawnSync(cmd, args, { stdio: "inherit" });
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+        try {
+            process.stdin.setRawMode(wasRaw);
+        }
+        catch { }
+    }
+    if (result.error || result.status !== 0) {
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch { }
+        return { ok: false, content: initial, cancelled: false };
+    }
+    let content;
+    try {
+        content = fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return { ok: false, content: initial, cancelled: false };
+    }
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch { }
+    if (content.trim().length === 0) {
+        return { ok: true, content: "", cancelled: true };
+    }
+    return { ok: true, content, cancelled: false };
+}

package/dist/lib/dashboard/theme.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dashboard theme detection — picks light vs dark based on the terminal's
+ * actual background color (queried via OSC 11) or an explicit override from
+ * SANTREE_THEME (`light` / `dark` / `auto`, default `auto`).
+ *
+ * Most foreground colors used in the dashboard are terminal-native names
+ * (`green`, `red`, `yellow`, `cyan`, etc.) that the terminal renders in a
+ * scheme-appropriate way, so the only piece of styling that needs to flip
+ * is the selection background. That's the surface this module exposes.
+ */
+export type ThemeMode = "light" | "dark";
+export interface DashboardTheme {
+    mode: ThemeMode;
+    selectionBg: string;
+}
+export declare function getThemeForMode(mode: ThemeMode): DashboardTheme;
+/**
+ * Query the terminal for its background color via OSC 11 and resolve the
+ * detected ThemeMode within `timeoutMs`. Falls back to `dark` on timeout or
+ * non-TTY stdin/stdout.
+ *
+ * The returned promise never rejects — failures resolve to `dark`.
+ */
+export declare function detectTerminalTheme(timeoutMs?: number): Promise<ThemeMode>;

package/dist/lib/dashboard/theme.js

@@ -0,0 +1,113 @@
+/**
+ * Dashboard theme detection — picks light vs dark based on the terminal's
+ * actual background color (queried via OSC 11) or an explicit override from
+ * SANTREE_THEME (`light` / `dark` / `auto`, default `auto`).
+ *
+ * Most foreground colors used in the dashboard are terminal-native names
+ * (`green`, `red`, `yellow`, `cyan`, etc.) that the terminal renders in a
+ * scheme-appropriate way, so the only piece of styling that needs to flip
+ * is the selection background. That's the surface this module exposes.
+ */
+const DARK = { mode: "dark", selectionBg: "#1e3a5f" };
+const LIGHT = { mode: "light", selectionBg: "#bfdbfe" };
+export function getThemeForMode(mode) {
+    return mode === "light" ? LIGHT : DARK;
+}
+/**
+ * Honor SANTREE_THEME env override. Returns null when set to `auto` or
+ * unset/invalid — caller should fall back to terminal detection.
+ */
+function envOverride() {
+    const raw = process.env["SANTREE_THEME"]?.toLowerCase().trim();
+    if (raw === "light")
+        return "light";
+    if (raw === "dark")
+        return "dark";
+    return null;
+}
+/**
+ * Compute relative luminance from sRGB components in the 0..1 range. Uses
+ * Rec. 709 coefficients — good enough to decide light vs dark.
+ */
+function luminance(r, g, b) {
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+/**
+ * Parse an OSC 11 color response. Terminals reply with one of:
+ *   \x1b]11;rgb:RRRR/GGGG/BBBB\x07
+ *   \x1b]11;rgb:RR/GG/BB\x1b\\
+ * Component widths can be 2 or 4 hex digits. Returns luminance in 0..1, or
+ * null if the buffer doesn't contain a recognisable response.
+ */
+function parseOsc11(buf) {
+    const m = buf.match(/\x1b\]11;rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)/);
+    if (!m)
+        return null;
+    const conv = (hex) => parseInt(hex, 16) / (hex.length >= 4 ? 65535 : 255);
+    const r = conv(m[1]);
+    const g = conv(m[2]);
+    const b = conv(m[3]);
+    return luminance(r, g, b);
+}
+/**
+ * Query the terminal for its background color via OSC 11 and resolve the
+ * detected ThemeMode within `timeoutMs`. Falls back to `dark` on timeout or
+ * non-TTY stdin/stdout.
+ *
+ * The returned promise never rejects — failures resolve to `dark`.
+ */
+export function detectTerminalTheme(timeoutMs = 150) {
+    const override = envOverride();
+    if (override)
+        return Promise.resolve(override);
+    return new Promise((resolve) => {
+        if (!process.stdout.isTTY || !process.stdin.isTTY) {
+            resolve("dark");
+            return;
+        }
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        let buf = "";
+        let settled = false;
+        const finish = (mode) => {
+            if (settled)
+                return;
+            settled = true;
+            stdin.removeListener("data", onData);
+            clearTimeout(timer);
+            if (!wasRaw) {
+                try {
+                    stdin.setRawMode(false);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            resolve(mode);
+        };
+        const onData = (chunk) => {
+            buf += chunk.toString("utf-8");
+            const lum = parseOsc11(buf);
+            if (lum !== null)
+                finish(lum > 0.5 ? "light" : "dark");
+        };
+        try {
+            if (!wasRaw)
+                stdin.setRawMode(true);
+        }
+        catch {
+            finish("dark");
+            return;
+        }
+        stdin.on("data", onData);
+        const timer = setTimeout(() => finish("dark"), timeoutMs);
+        // Send the OSC 11 query. The terminal's response is consumed by onData
+        // above and never reaches Ink's input handlers.
+        try {
+            process.stdout.write("\x1b]11;?\x07");
+        }
+        catch {
+            finish("dark");
+        }
+    });
+}

package/dist/lib/dashboard/types.d.ts

@@ -23,6 +23,11 @@ export interface WorktreeInfo {
     gitStatus: string;
     sessionState: "waiting" | "idle" | "active" | null;
     sessionMessage: string | null;
+    diffStats: {
+        filesChanged: number;
+        insertions: number;
+        deletions: number;
+    } | null;
 }
 export interface DashboardIssue {
     issue: LinearAssignedIssue;
@@ -58,7 +63,13 @@ export interface EnrichedReviewPR {
     worktree: WorktreeInfo | null;
 }
 export type DashboardTab = "issues" | "reviews";
-export type ActionOverlay = "mode-select" | "context-input" | "base-select" | "confirm-delete" | "confirm-setup" | "commit" | "pr-create" | null;
+export type ActionOverlay = "mode-select" | "context-input" | "base-select" | "confirm-delete" | "confirm-setup" | "commit" | "pr-create" | "diff" | null;
+export type DiffFileStatus = "M" | "A" | "D" | "R" | "C" | "U" | "?";
+export interface DiffFile {
+    path: string;
+    status: DiffFileStatus;
+    oldPath?: string;
+}
 export type CommitPhase = "idle" | "confirm-stage" | "awaiting-message" | "committing" | "pushing" | "done" | "error";
 export type PrCreatePhase = "idle" | "choose-mode" | "pushing" | "filling" | "review" | "confirm" | "creating" | "done" | "error";
 export interface DashboardState {
@@ -103,6 +114,18 @@ export interface DashboardState {
     contextInputValue: string;
     contextInputMode: "plan" | "implement" | null;
     contextInputPhase: "editing" | "review";
+    diffTicketId: string | null;
+    diffWorktreePath: string | null;
+    diffBaseBranch: string | null;
+    diffMergeBase: string | null;
+    diffFiles: DiffFile[];
+    diffFileIndex: number;
+    diffFileScrollOffset: number;
+    diffContent: string | null;
+    diffContentScrollOffset: number;
+    diffLoadingFiles: boolean;
+    diffLoadingContent: boolean;
+    diffError: string | null;
 }
 export type DashboardAction = {
     type: "SET_DATA";
@@ -237,6 +260,34 @@ export type DashboardAction = {
     type: "CONTEXT_INPUT_EDIT";
 } | {
     type: "CONTEXT_INPUT_DONE";
+} | {
+    type: "DIFF_OPEN";
+    ticketId: string;
+    worktreePath: string;
+    baseBranch: string;
+} | {
+    type: "DIFF_FILES_LOADED";
+    files: DiffFile[];
+    mergeBase: string;
+} | {
+    type: "DIFF_FILES_ERROR";
+    error: string;
+} | {
+    type: "DIFF_FILE_SELECT";
+    index: number;
+} | {
+    type: "DIFF_FILE_SCROLL";
+    offset: number;
+} | {
+    type: "DIFF_CONTENT_LOADING";
+} | {
+    type: "DIFF_CONTENT_LOADED";
+    content: string;
+} | {
+    type: "DIFF_CONTENT_SCROLL";
+    offset: number;
+} | {
+    type: "DIFF_CLOSE";
 };
 export declare const initialState: DashboardState;
 export declare function reducer(state: DashboardState, action: DashboardAction): DashboardState;

package/dist/lib/dashboard/types.js

@@ -41,6 +41,18 @@ export const initialState = {
     contextInputValue: "",
     contextInputMode: null,
     contextInputPhase: "editing",
+    diffTicketId: null,
+    diffWorktreePath: null,
+    diffBaseBranch: null,
+    diffMergeBase: null,
+    diffFiles: [],
+    diffFileIndex: 0,
+    diffFileScrollOffset: 0,
+    diffContent: null,
+    diffContentScrollOffset: 0,
+    diffLoadingFiles: false,
+    diffLoadingContent: false,
+    diffError: null,
 };
 export function reducer(state, action) {
     switch (action.type) {
@@ -273,6 +285,75 @@ export function reducer(state, action) {
                 contextInputValue: "",
                 contextInputPhase: "editing",
             };
+        case "DIFF_OPEN":
+            return {
+                ...state,
+                overlay: "diff",
+                diffTicketId: action.ticketId,
+                diffWorktreePath: action.worktreePath,
+                diffBaseBranch: action.baseBranch,
+                diffMergeBase: null,
+                diffFiles: [],
+                diffFileIndex: 0,
+                diffFileScrollOffset: 0,
+                diffContent: null,
+                diffContentScrollOffset: 0,
+                diffLoadingFiles: true,
+                diffLoadingContent: false,
+                diffError: null,
+            };
+        case "DIFF_FILES_LOADED":
+            return {
+                ...state,
+                diffFiles: action.files,
+                diffMergeBase: action.mergeBase,
+                diffFileIndex: 0,
+                diffFileScrollOffset: 0,
+                diffLoadingFiles: false,
+                diffError: null,
+            };
+        case "DIFF_FILES_ERROR":
+            return {
+                ...state,
+                diffLoadingFiles: false,
+                diffError: action.error,
+            };
+        case "DIFF_FILE_SELECT":
+            return {
+                ...state,
+                diffFileIndex: action.index,
+                diffContentScrollOffset: 0,
+            };
+        case "DIFF_FILE_SCROLL":
+            return { ...state, diffFileScrollOffset: action.offset };
+        case "DIFF_CONTENT_LOADING":
+            return { ...state, diffLoadingContent: true, diffContent: null };
+        case "DIFF_CONTENT_LOADED":
+            return {
+                ...state,
+                diffContent: action.content,
+                diffLoadingContent: false,
+                diffContentScrollOffset: 0,
+            };
+        case "DIFF_CONTENT_SCROLL":
+            return { ...state, diffContentScrollOffset: action.offset };
+        case "DIFF_CLOSE":
+            return {
+                ...state,
+                overlay: null,
+                diffTicketId: null,
+                diffWorktreePath: null,
+                diffBaseBranch: null,
+                diffMergeBase: null,
+                diffFiles: [],
+                diffFileIndex: 0,
+                diffFileScrollOffset: 0,
+                diffContent: null,
+                diffContentScrollOffset: 0,
+                diffLoadingFiles: false,
+                diffLoadingContent: false,
+                diffError: null,
+            };
         default:
             return state;
     }

package/dist/lib/git.d.ts

@@ -190,6 +190,26 @@ export declare function getCommitsAhead(baseBranch: string): number;
  * Returns 0 on failure.
  */
 export declare function getCommitsAheadAsync(cwd: string, baseBranch: string): Promise<number>;
+/**
+ * Read the SANTREE_DIFF_TOOL env var, returning the configured pager command
+ * (e.g. "delta", "diff-so-fancy") or null if unset/invalid.
+ *
+ * The value is restricted to a safe shell-token character set since it ends
+ * up in arguments passed to spawn() — even though we never use shell:true,
+ * keeping the surface tight defends against accidental misconfigurations.
+ */
+export declare function getDiffTool(): string | null;
+export interface DiffShortstat {
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+}
+/**
+ * Compute branch-only diff stats vs base (uses merge-base, like a GitHub PR
+ * diff). Includes both committed and uncommitted changes. Returns zeros on
+ * failure or when there are no changes.
+ */
+export declare function getDiffShortstatAsync(cwd: string, baseBranch: string): Promise<DiffShortstat>;
 /**
  * Check if a branch exists on the remote (origin).
  * Runs: `git ls-remote --heads origin <branchName>`
@@ -257,11 +277,13 @@ export declare function getDiffContent(baseBranch: string): string | null;
  */
 export declare function readSessionState(repoRoot: string, ticketId: string): SessionState | null;
 /**
- * Check if a claude process is running in a tmux window for the given ticket.
- * Windows are named after ticket IDs (possibly with suffixes like " !" or " ~").
- * Gets the pane PID and walks the process tree looking for a "claude" process.
+ * Check if a session for the given ticket is still alive in the active multiplexer.
+ * Delegates to the configured multiplexer (tmux: pane_pid + pgrep claude;
+ * cmux: workspace lookup; none: always false). Callers should also consult the
+ * .santree/session-states/<ticketId>.json file — that's the authoritative signal
+ * written by Claude Code hooks, while this is the "is the terminal still up" backstop.
  */
-export declare function isSessionAliveInTmux(ticketId: string): boolean;
+export declare function isSessionAlive(ticketId: string): boolean;
 /**
  * Delete the session state file for a given ticket.
  */

package/dist/lib/git.js

@@ -3,6 +3,7 @@ import { promisify } from "util";
 import * as path from "path";
 import * as fs from "fs";
 import { run, runAsync } from "./exec.js";
+import { getMultiplexer } from "./multiplexer/index.js";
 const execAsync = promisify(exec);
 /**
  * Find the toplevel directory of the current git repository.
@@ -467,6 +468,43 @@ export async function getCommitsAheadAsync(cwd, baseBranch) {
     const output = await runAsync(`git -C "${cwd}" rev-list --count ${baseBranch}..HEAD`);
     return output ? parseInt(output, 10) || 0 : 0;
 }
+/**
+ * Read the SANTREE_DIFF_TOOL env var, returning the configured pager command
+ * (e.g. "delta", "diff-so-fancy") or null if unset/invalid.
+ *
+ * The value is restricted to a safe shell-token character set since it ends
+ * up in arguments passed to spawn() — even though we never use shell:true,
+ * keeping the surface tight defends against accidental misconfigurations.
+ */
+export function getDiffTool() {
+    const raw = process.env["SANTREE_DIFF_TOOL"];
+    if (!raw || !raw.trim())
+        return null;
+    const tool = raw.trim();
+    if (!/^[a-zA-Z0-9_\-/.+]+$/.test(tool))
+        return null;
+    return tool;
+}
+/**
+ * Compute branch-only diff stats vs base (uses merge-base, like a GitHub PR
+ * diff). Includes both committed and uncommitted changes. Returns zeros on
+ * failure or when there are no changes.
+ */
+export async function getDiffShortstatAsync(cwd, baseBranch) {
+    const mergeBase = await runAsync(`git -C "${cwd}" merge-base "${baseBranch}" HEAD`);
+    const ref = mergeBase ?? baseBranch;
+    const out = await runAsync(`git -C "${cwd}" diff --shortstat "${ref}"`);
+    if (!out)
+        return { filesChanged: 0, insertions: 0, deletions: 0 };
+    const fm = out.match(/(\d+) files? changed/);
+    const im = out.match(/(\d+) insertions?\(\+\)/);
+    const dm = out.match(/(\d+) deletions?\(-\)/);
+    return {
+        filesChanged: fm ? parseInt(fm[1], 10) : 0,
+        insertions: im ? parseInt(im[1], 10) : 0,
+        deletions: dm ? parseInt(dm[1], 10) : 0,
+    };
+}
 /**
  * Check if a branch exists on the remote (origin).
  * Runs: `git ls-remote --heads origin <branchName>`
@@ -610,40 +648,14 @@ export function readSessionState(repoRoot, ticketId) {
     }
 }
 /**
- * Check if a claude process is running in a tmux window for the given ticket.
- * Windows are named after ticket IDs (possibly with suffixes like " !" or " ~").
- * Gets the pane PID and walks the process tree looking for a "claude" process.
+ * Check if a session for the given ticket is still alive in the active multiplexer.
+ * Delegates to the configured multiplexer (tmux: pane_pid + pgrep claude;
+ * cmux: workspace lookup; none: always false). Callers should also consult the
+ * .santree/session-states/<ticketId>.json file — that's the authoritative signal
+ * written by Claude Code hooks, while this is the "is the terminal still up" backstop.
  */
-export function isSessionAliveInTmux(ticketId) {
-    try {
-        const output = execSync('tmux list-windows -F "#{window_name}\t#{pane_pid}"', {
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "ignore"],
-        }).trim();
-        for (const line of output.split("\n")) {
-            const [name, pidStr] = line.split("\t");
-            if (!name?.startsWith(ticketId))
-                continue;
-            if (!pidStr)
-                return false;
-            // Check if any descendant of the shell PID is a claude process
-            try {
-                const ps = execSync(`pgrep -P ${pidStr} -a`, {
-                    encoding: "utf-8",
-                    stdio: ["pipe", "pipe", "ignore"],
-                }).trim();
-                return ps.split("\n").some((proc) => proc.includes("claude"));
-            }
-            catch {
-                // pgrep exits 1 when no matches — shell has no children
-                return false;
-            }
-        }
-    }
-    catch {
-        // tmux not available or not in a tmux session
-    }
-    return false;
+export function isSessionAlive(ticketId) {
+    return getMultiplexer().isSessionAlive(ticketId);
 }
 /**
  * Delete the session state file for a given ticket.

package/dist/lib/multiplexer/cmux.d.ts

@@ -0,0 +1,2 @@
+import type { Multiplexer } from "./types.js";
+export declare const cmuxMultiplexer: Multiplexer;

package/dist/lib/multiplexer/cmux.js

@@ -0,0 +1,97 @@
+import { execSync } from "child_process";
+import { shellEscape } from "./types.js";
+const CMUX_TIMEOUT_MS = 2000;
+function cmuxRun(cmd) {
+    try {
+        const stdout = execSync(cmd, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
+            timeout: CMUX_TIMEOUT_MS,
+        });
+        return { ok: true, stdout };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function findWorkspaceByTitle(title) {
+    // `--json` is a global flag and must precede the subcommand.
+    const result = cmuxRun("cmux --json list-workspaces");
+    if (!result.ok)
+        return null;
+    try {
+        const parsed = JSON.parse(result.stdout);
+        const items = parsed.workspaces ?? [];
+        return items.find((w) => w.title === title) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export const cmuxMultiplexer = {
+    kind: "cmux",
+    isActive() {
+        return !!process.env["CMUX_SURFACE_ID"];
+    },
+    async createWindow({ name, cwd, command }) {
+        // `new-workspace` accepts --name, --cwd, --command in a single atomic call.
+        // `--command` sends "<text>\n" to the new surface after creation. cmux #1472 means
+        // programmatically created workspaces have dead PTYs, so the command may not actually
+        // execute — but the workspace + name are created, which is the visible win.
+        const parts = [`cmux new-workspace --name ${shellEscape(name)} --cwd ${shellEscape(cwd)}`];
+        if (command)
+            parts.push(`--command ${shellEscape(command)}`);
+        const created = cmuxRun(parts.join(" "));
+        if (!created.ok) {
+            return { ok: false, reason: "failed", message: "cmux new-workspace failed" };
+        }
+        return { ok: true };
+    },
+    async selectWindow(name) {
+        const ws = findWorkspaceByTitle(name);
+        if (!ws?.ref) {
+            return { ok: false, reason: "failed", message: `no cmux workspace named ${name}` };
+        }
+        const result = cmuxRun(`cmux select-workspace --workspace ${shellEscape(ws.ref)}`);
+        return result.ok ? { ok: true } : { ok: false, reason: "failed" };
+    },
+    renameWindow(currentName, newName) {
+        // `workspace-action --action rename --title <text>` defaults to the caller's
+        // workspace via $CMUX_WORKSPACE_ID. When `currentName` is provided we look up
+        // that specific workspace's ref instead.
+        let target = "";
+        if (currentName) {
+            const ws = findWorkspaceByTitle(currentName);
+            if (!ws?.ref) {
+                return { ok: false, reason: "failed", message: "cmux workspace not found" };
+            }
+            target = ` --workspace ${shellEscape(ws.ref)}`;
+        }
+        const result = cmuxRun(`cmux workspace-action --action rename --title ${shellEscape(newName)}${target}`);
+        return result.ok ? { ok: true } : { ok: false, reason: "failed" };
+    },
+    sendCommand(_name, _command) {
+        // Blocked by manaflow-ai/cmux#1472 — programmatically created workspaces have
+        // dead PTYs, so post-creation `cmux send` / `send-key` silently drop input.
+        // Initial command-on-create works via `new-workspace --command`; this path is for
+        // follow-up sends to an existing workspace, which doesn't.
+        return {
+            ok: false,
+            reason: "unsupported",
+            message: "blocked by manaflow-ai/cmux#1472",
+        };
+    },
+    isSessionAlive(ticketId) {
+        const result = cmuxRun("cmux --json list-workspaces");
+        if (!result.ok)
+            return false;
+        try {
+            const parsed = JSON.parse(result.stdout);
+            const items = parsed.workspaces ?? [];
+            return items.some((w) => typeof w.title === "string" && w.title.startsWith(ticketId));
+        }
+        catch {
+            return false;
+        }
+    },
+};

package/dist/lib/multiplexer/index.d.ts

@@ -0,0 +1,4 @@
+import type { Multiplexer, MultiplexerKind } from "./types.js";
+export type { CreateWindowOpts, Multiplexer, MultiplexerKind, SessionResult } from "./types.js";
+export declare function getMultiplexer(): Multiplexer;
+export declare function getMultiplexerKind(): MultiplexerKind;

package/dist/lib/multiplexer/index.js

@@ -0,0 +1,20 @@
+import { cmuxMultiplexer } from "./cmux.js";
+import { noneMultiplexer } from "./none.js";
+import { tmuxMultiplexer } from "./tmux.js";
+export function getMultiplexer() {
+    const explicit = process.env["SANTREE_MULTIPLEXER"]?.toLowerCase();
+    if (explicit === "tmux")
+        return tmuxMultiplexer;
+    if (explicit === "cmux")
+        return cmuxMultiplexer;
+    if (explicit === "none")
+        return noneMultiplexer;
+    if (process.env["TMUX"])
+        return tmuxMultiplexer;
+    if (process.env["CMUX_SURFACE_ID"])
+        return cmuxMultiplexer;
+    return noneMultiplexer;
+}
+export function getMultiplexerKind() {
+    return getMultiplexer().kind;
+}

package/dist/lib/multiplexer/none.d.ts

@@ -0,0 +1,2 @@
+import type { Multiplexer } from "./types.js";
+export declare const noneMultiplexer: Multiplexer;