tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/lib/project-onboard.js

@@ -0,0 +1,108 @@
+/**
+ * Project onboard — composes a sensible `ide.yml` from a small set of
+ * inputs (project name, agent count, optional dev/test commands) and
+ * writes it to disk so the project can be registered.
+ *
+ * `composeIdeYml` is the pure-logic bit (string in → string out) so the
+ * shape of the generated config is exhaustively unit-tested without
+ * touching the filesystem. The wrapper around `writeConfig` lives in the
+ * server route, which calls this function and then `registerProject`.
+ */
+import yaml from "js-yaml";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+export class OnboardConflictError extends Error {
+    code = "IDE_YML_EXISTS";
+    constructor(path) {
+        super(`ide.yml already exists at ${path}`);
+        this.name = "OnboardConflictError";
+    }
+}
+export class OnboardInvalidInputError extends Error {
+    code = "INVALID_INPUT";
+    constructor(message) {
+        super(message);
+        this.name = "OnboardInvalidInputError";
+    }
+}
+/**
+ * Build the `IdeConfig` value the wizard should write. Pure: same input →
+ * same output, no io.
+ *
+ * Layout shape:
+ *   - Row 0 (70%): N Claude panes, first focused. When `agents > 1`, the
+ *     `team:` block is added so Claude Code launches with team mode.
+ *   - Row 1 (30%): Dev pane (if `devCommand` set) + Shell pane.
+ */
+export function composeIdeYmlConfig(input) {
+    if (!Number.isInteger(input.agents) || input.agents < 1 || input.agents > 3) {
+        throw new OnboardInvalidInputError(`agents must be an integer between 1 and 3 (got ${input.agents})`);
+    }
+    const cleanName = input.name.trim();
+    if (!cleanName) {
+        throw new OnboardInvalidInputError("name must be a non-empty string");
+    }
+    const agentsCount = input.agents;
+    const useTeam = agentsCount > 1;
+    const customNames = input.agentNames;
+    if (customNames !== undefined) {
+        if (customNames.length !== agentsCount) {
+            throw new OnboardInvalidInputError(`agentNames length (${customNames.length}) must equal agents (${agentsCount})`);
+        }
+        for (const name of customNames) {
+            if (typeof name !== "string" || name.trim() === "") {
+                throw new OnboardInvalidInputError("agentNames entries must be non-empty strings");
+            }
+        }
+    }
+    const topPanes = [];
+    for (let i = 0; i < agentsCount; i++) {
+        const fallback = useTeam ? (i === 0 ? "Lead" : `Teammate ${i}`) : `Claude ${i + 1}`;
+        const customTitle = customNames?.[i]?.trim();
+        const pane = {
+            title: customTitle && customTitle.length > 0 ? customTitle : fallback,
+            command: "claude",
+        };
+        if (useTeam) {
+            pane.role = i === 0 ? "lead" : "teammate";
+        }
+        if (i === 0) {
+            pane.focus = true;
+        }
+        topPanes.push(pane);
+    }
+    const bottomPanes = [];
+    const devCommand = input.devCommand?.trim();
+    if (devCommand) {
+        bottomPanes.push({ title: "Dev", command: devCommand });
+    }
+    bottomPanes.push({ title: "Shell" });
+    const rows = [{ size: "70%", panes: topPanes }, { panes: bottomPanes }];
+    const config = {
+        name: cleanName,
+        rows,
+    };
+    if (useTeam) {
+        config.team = { name: cleanName };
+    }
+    return config;
+}
+/**
+ * Render a composed `IdeConfig` as YAML. Wrapper over `js-yaml` with the
+ * same options used elsewhere so the output shape is identical.
+ */
+export function composeIdeYml(input) {
+    const config = composeIdeYmlConfig(input);
+    return yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' });
+}
+/**
+ * Reject onboarding when `ide.yml` already exists. The caller writes the
+ * file separately via `writeConfig`; this helper exists so the route can
+ * 409 cleanly without ever overwriting user content.
+ */
+export function assertNoExistingIdeYml(dir, exists = existsSync) {
+    const path = join(dir, "ide.yml");
+    if (exists(path)) {
+        throw new OnboardConflictError(path);
+    }
+}

package/packages/daemon/dist/lib/project-probe.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Project probe — inspects a directory and returns identity facts (name from
+ * basename, ide.yml presence, git origin/branch). Pure-ish wrapper over a few
+ * filesystem and git child-process calls; the io functions are pluggable for
+ * tests so we don't need a full mock filesystem.
+ *
+ * All git invocations are hard-bounded by a 2s timeout — we never want a
+ * single misbehaving repo to hang an HTTP request.
+ */
+export interface ProjectProbe {
+    name: string;
+    dir: string;
+    hasIdeYml: boolean;
+    gitOrigin: string | null;
+    gitBranch: string | null;
+}
+/**
+ * Pluggable io for tests. The defaults are real fs/child_process calls — pass
+ * `io` overrides to drive the probe deterministically in unit tests.
+ */
+export interface ProbeIo {
+    exists(path: string): boolean;
+    runGit(args: string[], cwd: string): Promise<string | null>;
+}
+/**
+ * Replace dangerous filename characters and collapse whitespace so the
+ * default `name` is safe to use as a tmux session name and a registry key.
+ */
+export declare function sanitizeName(raw: string): string;
+/**
+ * Probe a directory and return its identity. Never throws — returns nulls for
+ * any field that can't be determined. The caller decides what's a hard error
+ * (e.g. dir doesn't exist).
+ */
+export declare function probeProject(dir: string, io?: ProbeIo): Promise<ProjectProbe>;

package/packages/daemon/dist/lib/project-probe.js

@@ -0,0 +1,61 @@
+/**
+ * Project probe — inspects a directory and returns identity facts (name from
+ * basename, ide.yml presence, git origin/branch). Pure-ish wrapper over a few
+ * filesystem and git child-process calls; the io functions are pluggable for
+ * tests so we don't need a full mock filesystem.
+ *
+ * All git invocations are hard-bounded by a 2s timeout — we never want a
+ * single misbehaving repo to hang an HTTP request.
+ */
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, isAbsolute, resolve } from "node:path";
+const GIT_TIMEOUT_MS = 2_000;
+const realIo = {
+    exists: existsSync,
+    runGit: (args, cwd) => new Promise((resolveResult) => {
+        execFile("git", ["-C", cwd, ...args], { timeout: GIT_TIMEOUT_MS, encoding: "utf-8" }, (err, stdout) => {
+            if (err) {
+                resolveResult(null);
+                return;
+            }
+            resolveResult(stdout.trim());
+        });
+    }),
+};
+/**
+ * Replace dangerous filename characters and collapse whitespace so the
+ * default `name` is safe to use as a tmux session name and a registry key.
+ */
+export function sanitizeName(raw) {
+    return raw
+        .trim()
+        .replace(/\s+/g, "-")
+        .replace(/[^A-Za-z0-9._-]/g, "")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Probe a directory and return its identity. Never throws — returns nulls for
+ * any field that can't be determined. The caller decides what's a hard error
+ * (e.g. dir doesn't exist).
+ */
+export async function probeProject(dir, io = realIo) {
+    const absoluteDir = isAbsolute(dir) ? dir : resolve(dir);
+    const rawName = basename(absoluteDir);
+    const sanitized = sanitizeName(rawName);
+    const name = sanitized.length > 0 ? sanitized : "project";
+    const hasIdeYml = io.exists(`${absoluteDir}/ide.yml`);
+    const [gitOrigin, gitBranch] = await Promise.all([
+        io.runGit(["config", "--get", "remote.origin.url"], absoluteDir),
+        io.runGit(["branch", "--show-current"], absoluteDir),
+    ]);
+    return {
+        name,
+        dir: absoluteDir,
+        hasIdeYml,
+        // Treat empty string as null — branch --show-current returns "" on a
+        // detached HEAD.
+        gitOrigin: gitOrigin && gitOrigin.length > 0 ? gitOrigin : null,
+        gitBranch: gitBranch && gitBranch.length > 0 ? gitBranch : null,
+    };
+}

package/packages/daemon/dist/lib/project-registry.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Project registry — persists the list of projects the user has registered
+ * with tmux-ide via the dashboard. Stored at `~/.tmux-ide/projects.json`,
+ * written atomically via temp+rename (same approach as task-store).
+ *
+ * The pure decider (`applyAction`) is exported separately from the io-bound
+ * accessors so tests can reason about state transitions without hitting the
+ * filesystem. The module also exposes a `projectRegistryEmitter` that the
+ * `/ws/events` channel listens on to broadcast `projects.changed` frames.
+ */
+import { EventEmitter } from "node:events";
+import { type RegisteredProject } from "../schemas/registry.ts";
+import { type ProbeIo, type ProjectProbe } from "./project-probe.ts";
+export declare class ProjectRegistryError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class ProjectAlreadyRegisteredError extends ProjectRegistryError {
+    readonly suggestion: string;
+    constructor(name: string, suggestion: string);
+}
+export declare class ProjectNotFoundError extends ProjectRegistryError {
+    constructor(name: string);
+}
+export declare class ProjectDirNotFoundError extends ProjectRegistryError {
+    constructor(dir: string);
+}
+export type RegistryAction = {
+    type: "register";
+    project: RegisteredProject;
+} | {
+    type: "unregister";
+    name: string;
+} | {
+    type: "replace";
+    project: RegisteredProject;
+};
+export declare function applyAction(state: readonly RegisteredProject[], action: RegistryAction): RegisteredProject[];
+/**
+ * Resolve a unique name for a probed project, appending `-2`, `-3`, … until
+ * we don't collide with an existing entry.
+ */
+export declare function resolveUniqueName(state: readonly RegisteredProject[], desired: string): string;
+/**
+ * Build a `RegisteredProject` value from a probe + chosen name + timestamp.
+ * Pure — separated from `registerProject` so tests can verify the shape
+ * without io.
+ */
+export declare function buildRegisteredProject(probe: ProjectProbe, name: string, registeredAt: string): RegisteredProject;
+export declare const projectRegistryEmitter: EventEmitter<any>;
+export declare function listProjects(): RegisteredProject[];
+export declare function getProject(name: string): RegisteredProject | null;
+export interface RegisterInput {
+    dir: string;
+    name?: string;
+    /** Pluggable io for tests. */
+    io?: ProbeIo;
+    /** Override `Date.now()` for deterministic tests. */
+    now?: () => Date;
+    /** Override existsSync for the dir-validity check (tests). */
+    exists?: (path: string) => boolean;
+}
+export declare function registerProject(input: RegisterInput): Promise<RegisteredProject>;
+export declare function unregisterProject(name: string): void;
+export interface ProbeOptions {
+    io?: ProbeIo;
+}
+/**
+ * Re-probe a registered project by name, persist the refreshed snapshot, and
+ * broadcast the change. Throws if the project isn't registered.
+ */
+export declare function refreshProject(name: string, options?: ProbeOptions): Promise<RegisteredProject>;
+/** Reset the in-memory cache. Tests use this between cases. */
+export declare function _resetCacheForTests(): void;
+/** Force a re-read from disk on next access. */
+export declare function _invalidateCacheForTests(): void;

package/packages/daemon/dist/lib/project-registry.js

@@ -0,0 +1,230 @@
+/**
+ * Project registry — persists the list of projects the user has registered
+ * with tmux-ide via the dashboard. Stored at `~/.tmux-ide/projects.json`,
+ * written atomically via temp+rename (same approach as task-store).
+ *
+ * The pure decider (`applyAction`) is exported separately from the io-bound
+ * accessors so tests can reason about state transitions without hitting the
+ * filesystem. The module also exposes a `projectRegistryEmitter` that the
+ * `/ws/events` channel listens on to broadcast `projects.changed` frames.
+ */
+import { EventEmitter } from "node:events";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { z } from "zod";
+import { RegisteredProjectSchemaZ } from "../schemas/registry.js";
+import { probeProject, sanitizeName } from "./project-probe.js";
+const REGISTRY_DIR_ENV = "TMUX_IDE_REGISTRY_DIR";
+const RegistryFileSchemaZ = z.object({
+    version: z.literal(1),
+    projects: z.array(RegisteredProjectSchemaZ),
+});
+// ---------------------------------------------------------------------------
+// Typed errors — never use stringly-typed catches at the boundary
+// ---------------------------------------------------------------------------
+export class ProjectRegistryError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "ProjectRegistryError";
+        this.code = code;
+    }
+}
+export class ProjectAlreadyRegisteredError extends ProjectRegistryError {
+    suggestion;
+    constructor(name, suggestion) {
+        super(`Project "${name}" is already registered`, "ALREADY_REGISTERED");
+        this.name = "ProjectAlreadyRegisteredError";
+        this.suggestion = suggestion;
+    }
+}
+export class ProjectNotFoundError extends ProjectRegistryError {
+    constructor(name) {
+        super(`Project "${name}" not found in registry`, "NOT_FOUND");
+        this.name = "ProjectNotFoundError";
+    }
+}
+export class ProjectDirNotFoundError extends ProjectRegistryError {
+    constructor(dir) {
+        super(`Directory "${dir}" does not exist`, "DIR_NOT_FOUND");
+        this.name = "ProjectDirNotFoundError";
+    }
+}
+export function applyAction(state, action) {
+    switch (action.type) {
+        case "register":
+            return [...state, action.project];
+        case "unregister":
+            return state.filter((p) => p.name !== action.name);
+        case "replace":
+            return state.map((p) => (p.name === action.project.name ? action.project : p));
+    }
+}
+/**
+ * Resolve a unique name for a probed project, appending `-2`, `-3`, … until
+ * we don't collide with an existing entry.
+ */
+export function resolveUniqueName(state, desired) {
+    const used = new Set(state.map((p) => p.name));
+    if (!used.has(desired))
+        return desired;
+    let counter = 2;
+    while (used.has(`${desired}-${counter}`))
+        counter++;
+    return `${desired}-${counter}`;
+}
+/**
+ * Build a `RegisteredProject` value from a probe + chosen name + timestamp.
+ * Pure — separated from `registerProject` so tests can verify the shape
+ * without io.
+ */
+export function buildRegisteredProject(probe, name, registeredAt) {
+    return {
+        name,
+        dir: probe.dir,
+        hasIdeYml: probe.hasIdeYml,
+        gitOrigin: probe.gitOrigin,
+        gitBranch: probe.gitBranch,
+        registeredAt,
+    };
+}
+// ---------------------------------------------------------------------------
+// Module-level emitter — listened on by ws-events.handleWsEventsConnection
+// ---------------------------------------------------------------------------
+export const projectRegistryEmitter = new EventEmitter();
+// One listener per connected ws-events client; can grow with tabs.
+projectRegistryEmitter.setMaxListeners(0);
+// ---------------------------------------------------------------------------
+// Persistence — io-bound, single mutex (registry is small + writes are rare)
+// ---------------------------------------------------------------------------
+function registryDir() {
+    const override = process.env[REGISTRY_DIR_ENV];
+    if (override && override.length > 0)
+        return override;
+    return join(homedir(), ".tmux-ide");
+}
+function registryPath() {
+    return join(registryDir(), "projects.json");
+}
+let cache = null;
+function readDisk() {
+    const path = registryPath();
+    if (!existsSync(path))
+        return [];
+    const raw = readFileSync(path, "utf-8");
+    if (raw.trim().length === 0)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        console.warn("[project-registry] %s contains invalid JSON; ignoring", path);
+        return [];
+    }
+    const result = RegistryFileSchemaZ.safeParse(parsed);
+    if (!result.success) {
+        console.warn("[project-registry] %s failed schema validation; ignoring (%s)", path, result.error.issues
+            .slice(0, 3)
+            .map((i) => `${i.path.join(".")}: ${i.message}`)
+            .join("; "));
+        return [];
+    }
+    return result.data.projects;
+}
+function writeDisk(projects) {
+    const path = registryPath();
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    const file = { version: 1, projects };
+    const tmpPath = `${path}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(file, null, 2) + "\n");
+    renameSync(tmpPath, path);
+}
+function ensureCache() {
+    if (cache !== null)
+        return cache;
+    cache = readDisk();
+    return cache;
+}
+function commit(next) {
+    cache = next;
+    writeDisk(next);
+    projectRegistryEmitter.emit("change");
+}
+// ---------------------------------------------------------------------------
+// Public api
+// ---------------------------------------------------------------------------
+export function listProjects() {
+    // Return a defensive copy so callers can't mutate the cache.
+    return [...ensureCache()];
+}
+export function getProject(name) {
+    return ensureCache().find((p) => p.name === name) ?? null;
+}
+export async function registerProject(input) {
+    const exists = input.exists ?? existsSync;
+    const absoluteDir = isAbsolute(input.dir) ? input.dir : resolve(input.dir);
+    if (!exists(absoluteDir)) {
+        throw new ProjectDirNotFoundError(absoluteDir);
+    }
+    const probe = await probeProject(absoluteDir, input.io);
+    const state = ensureCache();
+    // If a name was explicitly requested, treat collisions as hard errors and
+    // suggest an alternative. If no name was given, auto-resolve via -2/-3/…
+    const desired = input.name ? sanitizeName(input.name) : probe.name;
+    const cleaned = desired.length > 0 ? desired : probe.name;
+    let resolvedName;
+    if (input.name) {
+        if (state.some((p) => p.name === cleaned)) {
+            throw new ProjectAlreadyRegisteredError(cleaned, resolveUniqueName(state, cleaned));
+        }
+        resolvedName = cleaned;
+    }
+    else {
+        resolvedName = resolveUniqueName(state, cleaned);
+    }
+    // Reject re-registering the same dir (different name). Probe again under a
+    // different name is fine, but we want to avoid duplicate dirs in the list.
+    const dupDir = state.find((p) => p.dir === probe.dir);
+    if (dupDir) {
+        throw new ProjectAlreadyRegisteredError(dupDir.name, dupDir.name);
+    }
+    const now = (input.now ?? (() => new Date()))();
+    const project = buildRegisteredProject(probe, resolvedName, now.toISOString());
+    commit(applyAction(state, { type: "register", project }));
+    return project;
+}
+export function unregisterProject(name) {
+    const state = ensureCache();
+    if (!state.some((p) => p.name === name)) {
+        throw new ProjectNotFoundError(name);
+    }
+    commit(applyAction(state, { type: "unregister", name }));
+}
+/**
+ * Re-probe a registered project by name, persist the refreshed snapshot, and
+ * broadcast the change. Throws if the project isn't registered.
+ */
+export async function refreshProject(name, options = {}) {
+    const state = ensureCache();
+    const existing = state.find((p) => p.name === name);
+    if (!existing)
+        throw new ProjectNotFoundError(name);
+    const probe = await probeProject(existing.dir, options.io);
+    const refreshed = buildRegisteredProject(probe, existing.name, existing.registeredAt);
+    commit(applyAction(state, { type: "replace", project: refreshed }));
+    return refreshed;
+}
+// ---------------------------------------------------------------------------
+// Test helpers — never call from production code
+// ---------------------------------------------------------------------------
+/** Reset the in-memory cache. Tests use this between cases. */
+export function _resetCacheForTests() {
+    cache = null;
+}
+/** Force a re-read from disk on next access. */
+export function _invalidateCacheForTests() {
+    cache = null;
+}

package/packages/daemon/dist/lib/session-monitor.d.ts

@@ -0,0 +1,15 @@
+interface MonitorPane {
+    id: string;
+    pid: string;
+    cmd?: string;
+    title?: string;
+    role?: string;
+    type?: string;
+    name?: string;
+}
+export declare function computePortPanes(panes: MonitorPane[], { listeners, tree }?: {
+    listeners?: Set<string>;
+    tree?: Map<string, string>;
+}): Set<string>;
+export declare function computeAgentStates(panes: MonitorPane[]): Map<string, "busy" | "idle" | null>;
+export {};

package/packages/daemon/dist/lib/session-monitor.js

@@ -0,0 +1,103 @@
+import { execFileSync } from "node:child_process";
+const SPINNERS = /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⠂⠒⠢⠆⠐⠠⠄◐◓◑◒|/\\-] /;
+// --- Port detection (pure helpers) ---
+function getListeningPids() {
+    // Returns Set of PIDs that have a listening TCP port in range 1024-20000
+    try {
+        const raw = execFileSync("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-FpPn"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        });
+        const pids = new Set();
+        let currentPid = null;
+        for (const line of raw.split("\n")) {
+            if (line.startsWith("p")) {
+                currentPid = line.slice(1);
+            }
+            else if (line.startsWith("n") && currentPid) {
+                const match = line.match(/:(\d+)$/);
+                if (match) {
+                    const port = parseInt(match[1], 10);
+                    if (port >= 1024 && port <= 20000)
+                        pids.add(currentPid);
+                }
+            }
+        }
+        return pids;
+    }
+    catch {
+        return new Set();
+    }
+}
+function getProcessTree() {
+    // Returns Map<pid, ppid>
+    try {
+        const raw = execFileSync("ps", ["-axo", "pid=,ppid="], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        });
+        const tree = new Map();
+        for (const line of raw.trim().split("\n")) {
+            const parts = line.trim().split(/\s+/);
+            if (parts.length === 2)
+                tree.set(parts[0], parts[1]);
+        }
+        return tree;
+    }
+    catch {
+        return new Map();
+    }
+}
+export function computePortPanes(panes, { listeners, tree } = {}) {
+    // Walk up from each listening PID to find which pane owns it
+    const resolvedListeners = listeners ?? getListeningPids();
+    const resolvedTree = tree ?? getProcessTree();
+    if (resolvedListeners.size === 0)
+        return new Set();
+    const panePids = new Map(panes.map((p) => [p.pid, p.id]));
+    const result = new Set();
+    for (const listenerPid of resolvedListeners) {
+        let pid = listenerPid;
+        while (pid && pid !== "0") {
+            if (panePids.has(pid)) {
+                result.add(panePids.get(pid));
+                break;
+            }
+            pid = resolvedTree.get(pid);
+        }
+    }
+    return result;
+}
+// --- Agent detection ---
+export function computeAgentStates(panes) {
+    // Returns Map<paneId, "busy" | "idle" | null>
+    const states = new Map();
+    for (const pane of panes) {
+        const role = pane.role ?? "";
+        // Primary: use @ide_role pane option if available
+        if (role === "lead" || role === "teammate") {
+            states.set(pane.id, SPINNERS.test(pane.title ?? "") ? "busy" : "idle");
+            continue;
+        }
+        // Fallback: command-based detection for pre-upgrade sessions
+        const cmd = (pane.cmd ?? "").toLowerCase();
+        if (!cmd.includes("claude") && !cmd.includes("codex")) {
+            states.set(pane.id, null);
+            continue;
+        }
+        states.set(pane.id, SPINNERS.test(pane.title ?? "") ? "busy" : "idle");
+    }
+    return states;
+}
+// The per-session tick loop / orchestrator bootstrap that used to live
+// here was orphaned by the canonical-tree fold — `daemon-embed.ts` owns
+// both responsibilities now (see `startEmbeddedDaemon` + its
+// orchestrator branch). Removing the legacy CLI block also fixes the
+// esbuild-bundle case where `import.meta.url`-vs-`process.argv[1]`
+// resolved to true at the bin/cli.js entry, causing the daemon's
+// session monitor to hijack every CLI invocation (see N1 of
+// docs/npm-distribution-audit.md). The pure exports above
+// (`computeAgentStates`, `computePortPanes`) remain — that's what
+// `daemon-embed.ts` actually imports.

package/packages/daemon/dist/lib/session-options.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Composable builders for tmux session configuration.
+ * Each returns an array of tmux command arrays.
+ */
+import type { ThemeConfig, TmuxCommand } from "../types.ts";
+export declare function buildSessionOptions(session: string, { theme }?: {
+    theme?: ThemeConfig;
+}): TmuxCommand[];
+export declare function themeOptions(session: string, theme: ThemeConfig): TmuxCommand[];
+export declare function borderOptions(session: string, theme: ThemeConfig): TmuxCommand[];
+export declare function behaviorOptions(session: string): TmuxCommand[];
+export declare function statusBarOptions(session: string, theme: ThemeConfig): TmuxCommand[];
+export declare function keyBindings(): TmuxCommand[];