tmux-ide 1.3.1 → 2.1.0

package/dist/lib/sizes.js

@@ -1,36 +0,0 @@
-/**
- * Compute absolute sizes for items where some have explicit sizes and others don't.
- * Items with `size` (e.g. "70%") keep their value; remaining space is split equally
- * among items without a size.
- */
-export function computeSizes(items) {
-    let claimed = 0;
-    let unclaimed = 0;
-    for (const item of items) {
-        if (item.size) {
-            claimed += parseFloat(item.size);
-        }
-        else {
-            unclaimed++;
-        }
-    }
-    const remaining = Math.max(0, 100 - claimed);
-    const defaultSize = unclaimed > 0 ? remaining / unclaimed : 0;
-    return items.map((item) => (item.size ? parseFloat(item.size) : defaultSize));
-}
-/**
- * Convert absolute sizes (e.g. [70, 30]) to tmux split percentages for sequential splits.
- * Returns array of -p values (one per split after the first item).
- *
- * Each tmux split divides the current pane. The percentage given to -p is
- * the portion allocated to the NEW (bottom/right) pane.
- */
-export function toSplitPercents(sizes) {
-    const percents = [];
-    for (let i = 1; i < sizes.length; i++) {
-        const remaining = sizes.slice(i - 1).reduce((a, b) => a + b, 0);
-        const topShare = sizes[i - 1];
-        percents.push(Math.round(((remaining - topShare) / remaining) * 100));
-    }
-    return percents;
-}

package/dist/lib/tmux.d.ts

@@ -1,42 +0,0 @@
-import { execFileSync, spawn } from "node:child_process";
-import { TmuxError } from "./errors.ts";
-import type { SessionState } from "../types.ts";
-export { TmuxError };
-export declare function getSessionState(session: string): SessionState;
-export declare function attachSession(session: string): void;
-export declare function hasSession(session: string): boolean;
-export declare function killSession(session: string): {
-    stopped: boolean;
-    reason: string | null;
-};
-export declare function listPanes(session: string): {
-    index: number;
-    title: string | undefined;
-    width: number;
-    height: number;
-    active: boolean;
-}[];
-export declare function createDetachedSession(session: string, cwd: string, { cols, lines }?: {
-    cols?: number;
-    lines?: number;
-}): string;
-export declare function setSessionEnvironment(session: string, key: string, value: string | number): void;
-export declare function splitPane(targetPane: string, direction: string, cwd: string, percent: number): string;
-export declare function sendLiteral(targetPane: string, text: string): void;
-export declare function getPaneCurrentCommand(targetPane: string): string;
-export declare function selectPane(targetPane: string): void;
-export declare function setPaneTitle(targetPane: string, title: string): void;
-export declare function runSessionCommand(args: string[]): void;
-export declare function startSessionMonitor(session: string, monitorScript: string): void;
-export declare function stopSessionMonitor(session: string): void;
-export declare function getSessionVariable(session: string, name: string): string | null;
-export declare function setSessionVariable(session: string, name: string, value: string): void;
-type Executor = typeof execFileSync;
-type Spawner = typeof spawn;
-/** @internal Replace the executor for testing. Returns a restore function. */
-export declare function _setExecutor(fn: Executor): () => void;
-/** @internal Replace the spawner for testing. Returns a restore function. */
-export declare function _setSpawner(fn: Spawner): () => void;
-declare global {
-    var __tmuxIdeVerbose: boolean | undefined;
-}

package/dist/lib/tmux.js

@@ -1,225 +0,0 @@
-import { execFileSync, spawn } from "node:child_process";
-import { TmuxError } from "./errors.js";
-const DEBUG = process.env.TMUX_IDE_DEBUG === "1";
-const SESSION_NOT_FOUND_PATTERNS = ["can't find session", "can't find window", "unknown target"];
-const TMUX_UNAVAILABLE_PATTERNS = [
-    "failed to connect to server",
-    "no server running",
-    "error connecting to",
-    "connection refused",
-];
-export { TmuxError };
-export function getSessionState(session) {
-    try {
-        runTmux(["has-session", "-t", session]);
-        return { running: true, reason: null };
-    }
-    catch (error) {
-        if (error instanceof TmuxError) {
-            if (error.code === "SESSION_NOT_FOUND") {
-                return { running: false, reason: "SESSION_NOT_FOUND" };
-            }
-            if (error.code === "TMUX_UNAVAILABLE") {
-                return { running: false, reason: "TMUX_UNAVAILABLE" };
-            }
-        }
-        throw error;
-    }
-}
-export function attachSession(session) {
-    runTmux(["attach", "-t", session], { stdio: "inherit" });
-}
-export function hasSession(session) {
-    try {
-        runTmux(["has-session", "-t", session]);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof TmuxError &&
-            (error.code === "SESSION_NOT_FOUND" || error.code === "TMUX_UNAVAILABLE")) {
-            return false;
-        }
-        throw error;
-    }
-}
-export function killSession(session) {
-    try {
-        runTmux(["kill-session", "-t", session]);
-        return { stopped: true, reason: null };
-    }
-    catch (error) {
-        if (error instanceof TmuxError) {
-            if (error.code === "SESSION_NOT_FOUND") {
-                return { stopped: false, reason: "SESSION_NOT_FOUND" };
-            }
-            if (error.code === "TMUX_UNAVAILABLE") {
-                return { stopped: false, reason: "TMUX_UNAVAILABLE" };
-            }
-        }
-        throw error;
-    }
-}
-export function listPanes(session) {
-    const raw = runTmux([
-        "list-panes",
-        "-t",
-        session,
-        "-F",
-        "#{pane_index}|#{pane_title}|#{pane_width}|#{pane_height}|#{pane_active}",
-    ], { encoding: "utf-8" }).trim();
-    if (!raw)
-        return [];
-    return raw.split("\n").map((line) => {
-        const [index, title, width, height, active] = line.split("|");
-        return {
-            index: Number.parseInt(index, 10),
-            title,
-            width: Number.parseInt(width, 10),
-            height: Number.parseInt(height, 10),
-            active: active === "1",
-        };
-    });
-}
-export function createDetachedSession(session, cwd, { cols, lines } = {}) {
-    return runTmux([
-        "new-session",
-        "-d",
-        "-P",
-        "-F",
-        "#{pane_id}",
-        "-s",
-        session,
-        "-c",
-        cwd,
-        "-x",
-        String(cols ?? 200),
-        "-y",
-        String(lines ?? 50),
-    ], { encoding: "utf-8" }).trim();
-}
-export function setSessionEnvironment(session, key, value) {
-    runTmux(["set-environment", "-t", session, key, String(value)]);
-}
-export function splitPane(targetPane, direction, cwd, percent) {
-    return runTmux([
-        "split-window",
-        "-P",
-        "-F",
-        "#{pane_id}",
-        "-t",
-        targetPane,
-        direction === "vertical" ? "-v" : "-h",
-        "-c",
-        cwd,
-        "-p",
-        String(percent),
-    ], { encoding: "utf-8" }).trim();
-}
-export function sendLiteral(targetPane, text) {
-    runTmux(["send-keys", "-t", targetPane, "-l", "--", text], { stdio: "inherit" });
-    runTmux(["send-keys", "-t", targetPane, "Enter"], { stdio: "inherit" });
-}
-export function getPaneCurrentCommand(targetPane) {
-    return runTmux(["display-message", "-p", "-t", targetPane, "#{pane_current_command}"], {
-        encoding: "utf-8",
-    }).trim();
-}
-export function selectPane(targetPane) {
-    runTmux(["select-pane", "-t", targetPane], { stdio: "inherit" });
-}
-export function setPaneTitle(targetPane, title) {
-    runTmux(["select-pane", "-t", targetPane, "-T", title], { stdio: "inherit" });
-}
-export function runSessionCommand(args) {
-    runTmux(args, { stdio: "inherit" });
-}
-export function startSessionMonitor(session, monitorScript) {
-    const child = _spawner("node", [monitorScript, session], {
-        detached: true,
-        stdio: "ignore",
-    });
-    child.unref();
-    // Store PID as tmux session variable for later cleanup
-    runTmux(["set-option", "-t", session, "@monitor_pid", String(child.pid)]);
-}
-export function stopSessionMonitor(session) {
-    try {
-        const pid = runTmux(["show-option", "-gqvt", session, "@monitor_pid"], {
-            encoding: "utf-8",
-        }).trim();
-        if (pid)
-            process.kill(parseInt(pid, 10));
-    }
-    catch {
-        /* session or process already gone */
-    }
-}
-export function getSessionVariable(session, name) {
-    try {
-        const raw = runTmux(["show-option", "-gqvt", session, name], {
-            encoding: "utf-8",
-        });
-        return raw.trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-export function setSessionVariable(session, name, value) {
-    runTmux(["set-option", "-t", session, name, value]);
-}
-let _executor = execFileSync;
-let _spawner = spawn;
-/** @internal Replace the executor for testing. Returns a restore function. */
-export function _setExecutor(fn) {
-    const prev = _executor;
-    _executor = fn;
-    return () => {
-        _executor = prev;
-    };
-}
-/** @internal Replace the spawner for testing. Returns a restore function. */
-export function _setSpawner(fn) {
-    const prev = _spawner;
-    _spawner = fn;
-    return () => {
-        _spawner = prev;
-    };
-}
-function runTmux(args, options = {}) {
-    if (DEBUG || globalThis.__tmuxIdeVerbose) {
-        console.error(`  [tmux] ${args.join(" ")}`);
-    }
-    const execOptions = {
-        stdio: ["ignore", "pipe", "pipe"],
-        ...options,
-    };
-    try {
-        return _executor("tmux", args, execOptions);
-    }
-    catch (error) {
-        throw classifyTmuxError(error);
-    }
-}
-function classifyTmuxError(error) {
-    const detail = getErrorDetail(error).toLowerCase();
-    if (SESSION_NOT_FOUND_PATTERNS.some((pattern) => detail.includes(pattern))) {
-        return new TmuxError("tmux session was not found", "SESSION_NOT_FOUND", {
-            cause: error,
-        });
-    }
-    if (TMUX_UNAVAILABLE_PATTERNS.some((pattern) => detail.includes(pattern))) {
-        return new TmuxError("tmux is unavailable or its socket is inaccessible", "TMUX_UNAVAILABLE", {
-            cause: error,
-        });
-    }
-    return new TmuxError("tmux command failed", "TMUX_ERROR", { cause: error });
-}
-function getErrorDetail(error) {
-    const stderr = error?.stderr;
-    if (typeof stderr === "string" && stderr.length > 0)
-        return stderr;
-    if (Buffer.isBuffer(stderr) && stderr.length > 0)
-        return stderr.toString("utf-8");
-    return error?.message ?? "";
-}

package/dist/lib/yaml-io.d.ts

@@ -1,10 +0,0 @@
-import type { IdeConfig } from "../types.ts";
-export declare function readConfig(dir: string): {
-    config: IdeConfig;
-    configPath: string;
-};
-export declare function writeConfig(dir: string, config: IdeConfig): string;
-export declare function getSessionName(dir: string): {
-    name: string;
-    source: "config" | "fallback";
-};

package/dist/lib/yaml-io.js

@@ -1,24 +0,0 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import { resolve, basename } from "node:path";
-import yaml from "js-yaml";
-export function readConfig(dir) {
-    const configPath = resolve(dir, "ide.yml");
-    const raw = readFileSync(configPath, "utf-8");
-    const config = yaml.load(raw);
-    return { config, configPath };
-}
-export function writeConfig(dir, config) {
-    const configPath = resolve(dir, "ide.yml");
-    const out = yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' });
-    writeFileSync(configPath, out);
-    return configPath;
-}
-export function getSessionName(dir) {
-    try {
-        const { config } = readConfig(dir);
-        return { name: config.name ?? basename(dir), source: config.name ? "config" : "fallback" };
-    }
-    catch {
-        return { name: basename(dir), source: "fallback" };
-    }
-}

package/dist/ls.d.ts

@@ -1,3 +0,0 @@
-export declare function ls({ json }?: {
-    json?: boolean;
-}): Promise<void>;

package/dist/ls.js

@@ -1,35 +0,0 @@
-import { execSync } from "node:child_process";
-export async function ls({ json } = {}) {
-    let raw;
-    try {
-        raw = execSync('tmux list-sessions -F "#{session_name}|#{session_created}|#{session_attached}"', { encoding: "utf-8" }).trim();
-    }
-    catch {
-        if (json) {
-            console.log(JSON.stringify({ sessions: [] }));
-        }
-        else {
-            console.log("No tmux sessions running.");
-        }
-        return;
-    }
-    const sessions = raw.split("\n").map((line) => {
-        const [name, created, attached] = line.split("|");
-        return {
-            name,
-            created: new Date(parseInt(created) * 1000).toISOString(),
-            attached: attached !== "0",
-        };
-    });
-    if (json) {
-        console.log(JSON.stringify({ sessions }, null, 2));
-        return;
-    }
-    // Table output
-    console.log("SESSION".padEnd(24) + "CREATED".padEnd(22) + "ATTACHED");
-    console.log("─".repeat(54));
-    for (const s of sessions) {
-        const date = new Date(s.created).toLocaleString();
-        console.log(s.name.padEnd(24) + date.padEnd(22) + (s.attached ? "yes" : "no"));
-    }
-}

package/dist/restart.d.ts

@@ -1,4 +0,0 @@
-export declare function restart(targetDir: string | undefined, { json, attach }?: {
-    json?: boolean;
-    attach?: boolean;
-}): Promise<void>;

package/dist/restart.js

@@ -1,13 +0,0 @@
-import { resolve } from "node:path";
-import { getSessionName } from "./lib/yaml-io.js";
-import { launch } from "./launch.js";
-import { killSession } from "./lib/tmux.js";
-export async function restart(targetDir, { json, attach } = {}) {
-    const dir = resolve(targetDir ?? ".");
-    const { name: session } = getSessionName(dir);
-    const result = killSession(session);
-    if (result.stopped) {
-        console.log(`Stopped session "${session}"`);
-    }
-    await launch(dir, { json, attach });
-}

package/dist/status.d.ts

@@ -1,3 +0,0 @@
-export declare function status(targetDir: string | undefined, { json }?: {
-    json?: boolean;
-}): Promise<void>;

package/dist/status.js

@@ -1,29 +0,0 @@
-import { resolve } from "node:path";
-import { existsSync } from "node:fs";
-import { getSessionName } from "./lib/yaml-io.js";
-import { getSessionState, listPanes } from "./lib/tmux.js";
-export async function status(targetDir, { json } = {}) {
-    const dir = resolve(targetDir ?? ".");
-    const { name: session } = getSessionName(dir);
-    const configExists = existsSync(resolve(dir, "ide.yml"));
-    const state = getSessionState(session);
-    const running = state.running;
-    let panes = [];
-    if (running)
-        panes = listPanes(session);
-    const data = { session, running, configExists, panes };
-    if (json) {
-        console.log(JSON.stringify(data, null, 2));
-        return;
-    }
-    console.log(`Session: ${session}`);
-    console.log(`Running: ${running ? "yes" : "no"}`);
-    console.log(`Config:  ${configExists ? "ide.yml found" : "no ide.yml"}`);
-    if (panes.length > 0) {
-        console.log(`\nPanes:`);
-        for (const p of panes) {
-            const active = p.active ? " (active)" : "";
-            console.log(`  ${p.index}: ${p.title} [${p.width}x${p.height}]${active}`);
-        }
-    }
-}

package/dist/stop.d.ts

@@ -1,3 +0,0 @@
-export declare function stop(targetDir: string | undefined, { json }?: {
-    json?: boolean;
-}): Promise<void>;

package/dist/stop.js

@@ -1,21 +0,0 @@
-import { resolve } from "node:path";
-import { getSessionName } from "./lib/yaml-io.js";
-import { outputError } from "./lib/output.js";
-import { killSession, stopSessionMonitor } from "./lib/tmux.js";
-export async function stop(targetDir, { json } = {}) {
-    const dir = resolve(targetDir ?? ".");
-    const { name: session } = getSessionName(dir);
-    // Stop the session monitor before killing the session
-    stopSessionMonitor(session);
-    const result = killSession(session);
-    if (result.stopped) {
-        if (json) {
-            console.log(JSON.stringify({ stopped: session }));
-        }
-        else {
-            console.log(`Stopped session "${session}"`);
-        }
-        return;
-    }
-    outputError(`No active session "${session}" found`, "NOT_RUNNING");
-}

package/dist/types.d.ts

@@ -1,41 +0,0 @@
-export interface IdeConfig {
-    name?: string;
-    before?: string;
-    team?: {
-        name: string;
-    };
-    rows: Row[];
-    theme?: ThemeConfig;
-}
-export interface Row {
-    size?: string;
-    panes: Pane[];
-}
-export interface Pane {
-    title?: string;
-    command?: string;
-    dir?: string;
-    size?: string;
-    focus?: boolean;
-    env?: Record<string, string | number>;
-    role?: "lead" | "teammate";
-    task?: string;
-}
-export interface ThemeConfig {
-    accent?: string;
-    border?: string;
-    bg?: string;
-    fg?: string;
-}
-export type TmuxCommand = string[];
-export interface PaneAction {
-    targetPane: string;
-    title: string | null;
-    chdir: string | null;
-    exports: string[];
-    command: string | null;
-}
-export interface SessionState {
-    running: boolean;
-    reason: string | null;
-}

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/validate.d.ts

@@ -1,4 +0,0 @@
-export declare function validateConfig(config: unknown): string[];
-export declare function validate(targetDir: string | undefined, { json }?: {
-    json?: boolean;
-}): Promise<void>;