tmux-ide 1.2.0 → 1.3.1

package/src/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/src/lib/tmux.js

@@ -1,234 +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") {
-      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 = spawn("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]);
-}
-
-function runTmux(args, options = {}) {
-  if (DEBUG || globalThis.__tmuxIdeVerbose) {
-    console.error(`  [tmux] ${args.join(" ")}`);
-  }
-
-  const execOptions = {
-    stdio: ["ignore", "pipe", "pipe"],
-    ...options,
-  };
-
-  try {
-    return execFileSync("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/src/lib/yaml-io.js

@@ -1,26 +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/src/ls.js

@@ -1,40 +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/src/restart.js

@@ -1,16 +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/src/status.js

@@ -1,35 +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/src/stop.js

@@ -1,25 +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/src/validate.js

@@ -1,154 +0,0 @@
-import { resolve } from "node:path";
-import { readConfig } from "./lib/yaml-io.js";
-import { outputError } from "./lib/output.js";
-
-export function validateConfig(config) {
-  const errors = [];
-
-  if (config == null || typeof config !== "object" || Array.isArray(config)) {
-    errors.push("config must be an object");
-    return errors;
-  }
-
-  if (config.name !== undefined && typeof config.name !== "string") {
-    errors.push("'name' must be a string");
-  }
-
-  if (config.before !== undefined && typeof config.before !== "string") {
-    errors.push("'before' must be a string");
-  }
-
-  if (!Array.isArray(config.rows)) {
-    errors.push("'rows' must be an array");
-  } else if (config.rows.length === 0) {
-    errors.push("'rows' must not be empty");
-  } else {
-    for (let i = 0; i < config.rows.length; i++) {
-      const row = config.rows[i];
-      if (!row.panes || !Array.isArray(row.panes)) {
-        errors.push(`rows[${i}].panes must be an array`);
-        continue;
-      }
-      if (row.panes.length === 0) {
-        errors.push(`rows[${i}].panes must not be empty`);
-      }
-      if (row.size !== undefined) {
-        validateSize(row.size, `rows[${i}].size`, errors);
-      }
-      for (let j = 0; j < row.panes.length; j++) {
-        const pane = row.panes[j];
-        if (pane.title !== undefined && typeof pane.title !== "string") {
-          errors.push(`rows[${i}].panes[${j}].title must be a string`);
-        }
-        if (pane.command !== undefined && typeof pane.command !== "string") {
-          errors.push(`rows[${i}].panes[${j}].command must be a string`);
-        }
-        if (pane.dir !== undefined && typeof pane.dir !== "string") {
-          errors.push(`rows[${i}].panes[${j}].dir must be a string`);
-        }
-        if (pane.focus !== undefined && typeof pane.focus !== "boolean") {
-          errors.push(`rows[${i}].panes[${j}].focus must be a boolean`);
-        }
-        if (pane.env !== undefined) {
-          if (pane.env == null || typeof pane.env !== "object" || Array.isArray(pane.env)) {
-            errors.push(`rows[${i}].panes[${j}].env must be an object`);
-          } else {
-            for (const [key, val] of Object.entries(pane.env)) {
-              if (typeof val !== "string" && typeof val !== "number") {
-                errors.push(`rows[${i}].panes[${j}].env.${key} must be a string or number`);
-              }
-            }
-          }
-        }
-        if (pane.size !== undefined) {
-          validateSize(pane.size, `rows[${i}].panes[${j}].size`, errors);
-        }
-        if (pane.role !== undefined) {
-          if (pane.role !== "lead" && pane.role !== "teammate") {
-            errors.push(`rows[${i}].panes[${j}].role must be "lead" or "teammate"`);
-          }
-        }
-        if (pane.task !== undefined && typeof pane.task !== "string") {
-          errors.push(`rows[${i}].panes[${j}].task must be a string`);
-        }
-      }
-    }
-  }
-
-  // Validate team config
-  if (config.team !== undefined) {
-    if (config.team == null || typeof config.team !== "object" || Array.isArray(config.team)) {
-      errors.push("'team' must be an object");
-    } else {
-      if (config.team.name === undefined) {
-        errors.push("'team.name' is required when team is specified");
-      } else if (typeof config.team.name !== "string") {
-        errors.push("'team.name' must be a string");
-      }
-      if (config.team.model !== undefined && typeof config.team.model !== "string") {
-        errors.push("'team.model' must be a string");
-      }
-      if (config.team.permissions !== undefined && !Array.isArray(config.team.permissions)) {
-        errors.push("'team.permissions' must be an array");
-      }
-    }
-  }
-
-  if (config.theme !== undefined) {
-    if (config.theme == null || typeof config.theme !== "object" || Array.isArray(config.theme)) {
-      errors.push("'theme' must be an object");
-    } else {
-      for (const key of ["accent", "border", "bg", "fg"]) {
-        if (config.theme[key] !== undefined && typeof config.theme[key] !== "string") {
-          errors.push(`theme.${key} must be a string`);
-        }
-      }
-    }
-  }
-
-  return errors;
-}
-
-function validateSize(value, path, errors) {
-  const s = String(value);
-  if (!/^\d+%$/.test(s)) {
-    errors.push(`${path} "${value}" must be a percentage (e.g. "50%")`);
-    return;
-  }
-  const num = parseInt(s, 10);
-  if (num === 0) {
-    errors.push(`${path} must not be 0%`);
-  } else if (num > 100) {
-    errors.push(`${path} must not exceed 100%`);
-  }
-}
-
-export async function validate(targetDir, { json } = {}) {
-  const dir = resolve(targetDir ?? ".");
-  let config;
-
-  try {
-    ({ config } = readConfig(dir));
-  } catch (e) {
-    outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR");
-    return;
-  }
-
-  const errors = validateConfig(config);
-  const valid = errors.length === 0;
-
-  if (json) {
-    console.log(JSON.stringify({ valid, errors }, null, 2));
-    return;
-  }
-
-  if (valid) {
-    console.log("✓ ide.yml is valid");
-  } else {
-    console.log("✗ ide.yml has errors:");
-    for (const e of errors) {
-      console.log(`  - ${e}`);
-    }
-    process.exitCode = 1;
-  }
-}