@costrict/csc 4.0.1

package/dist/chunk-6mzwkxka.js

@@ -0,0 +1,591 @@
+// @bun
+import {
+  init_registry,
+  registerTmuxBackend
+} from "./chunk-97kwfkef.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-s2jznn2t.js";
+import"./chunk-zejm280k.js";
+import"./chunk-var1et7e.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-enz148g9.js";
+import"./chunk-jmt3t5ka.js";
+import"./chunk-3x2jaxpw.js";
+import"./chunk-wm26jyc3.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-3vxgde8h.js";
+import"./chunk-9k8qsaph.js";
+import"./chunk-bnrctxq5.js";
+import"./chunk-9663bsk0.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-gr2j2pnw.js";
+import"./chunk-m7gb3xym.js";
+import"./chunk-zgjh33vv.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-39jcea92.js";
+import"./chunk-reta5k4w.js";
+import"./chunk-3z9478wf.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-eq5csq9z.js";
+import"./chunk-qezabsdm.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-3sj7jkgr.js";
+import"./chunk-62xkxk9z.js";
+import"./chunk-ers3hn71.js";
+import"./chunk-5krq9sjq.js";
+import"./chunk-85em0j2s.js";
+import {
+  getLeaderPaneId,
+  init_detection,
+  isInsideTmux,
+  isTmuxAvailable
+} from "./chunk-dmfnhfbm.js";
+import {
+  HIDDEN_SESSION_NAME,
+  SWARM_SESSION_NAME,
+  SWARM_VIEW_WINDOW_NAME,
+  TMUX_COMMAND,
+  getSwarmSocketName,
+  init_constants
+} from "./chunk-4jm600zv.js";
+import"./chunk-ew2qn2ct.js";
+import"./chunk-3bes9fg8.js";
+import"./chunk-ygj29dpk.js";
+import"./chunk-6km733xr.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-z915v06p.js";
+import"./chunk-rw0b3wq4.js";
+import"./chunk-ms3y5kf0.js";
+import"./chunk-pfc94kdv.js";
+import"./chunk-kwdta9bw.js";
+import"./chunk-3dy7fxmg.js";
+import"./chunk-qp1047f9.js";
+import"./chunk-3ns6ys7f.js";
+import"./chunk-6aspnjtj.js";
+import"./chunk-1dz5e26z.js";
+import {
+  count,
+  init_array
+} from "./chunk-1cwdhk7a.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-64c1avct.js";
+import"./chunk-qbrsmra3.js";
+import {
+  init_sleep,
+  sleep
+} from "./chunk-8g5pe1gr.js";
+import"./chunk-5j8wked2.js";
+import"./chunk-v4t6dyyh.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-xzc7k2hh.js";
+import"./chunk-rcpmj2s6.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-dkzwgrsa.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-ztf1hdpb.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-fk80f449.js";
+import"./chunk-g338npwr.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-yjkamwzv.js";
+import"./chunk-13hhjhs8.js";
+import"./chunk-rpmxbsc4.js";
+import"./chunk-qnfx3qtx.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-2wz9qb4j.js";
+import"./chunk-b81hd3m6.js";
+import {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-56r79b2b.js";
+import"./chunk-nneembm7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-z6e5jp2w.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-nh3cd07f.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/swarm/backends/TmuxBackend.ts
+function waitForPaneShellReady() {
+  return sleep(PANE_SHELL_INIT_DELAY_MS);
+}
+function acquirePaneCreationLock() {
+  let release;
+  const newLock = new Promise((resolve) => {
+    release = resolve;
+  });
+  const previousLock = paneCreationLock;
+  paneCreationLock = newLock;
+  return previousLock.then(() => release);
+}
+function getTmuxColorName(color) {
+  const tmuxColors = {
+    red: "red",
+    blue: "blue",
+    green: "green",
+    yellow: "yellow",
+    purple: "magenta",
+    orange: "colour208",
+    pink: "colour205",
+    cyan: "cyan"
+  };
+  return tmuxColors[color];
+}
+function runTmuxInUserSession(args) {
+  return execFileNoThrow(TMUX_COMMAND, args);
+}
+function runTmuxInSwarm(args) {
+  return execFileNoThrow(TMUX_COMMAND, ["-L", getSwarmSocketName(), ...args]);
+}
+
+class TmuxBackend {
+  type = "tmux";
+  displayName = "tmux";
+  supportsHideShow = true;
+  async isAvailable() {
+    return isTmuxAvailable();
+  }
+  async isRunningInside() {
+    return isInsideTmux();
+  }
+  async createTeammatePaneInSwarmView(name, color) {
+    const releaseLock = await acquirePaneCreationLock();
+    try {
+      const insideTmux = await this.isRunningInside();
+      if (insideTmux) {
+        return await this.createTeammatePaneWithLeader(name, color);
+      }
+      return await this.createTeammatePaneExternal(name, color);
+    } finally {
+      releaseLock();
+    }
+  }
+  async sendCommandToPane(paneId, command, useExternalSession = false) {
+    const runTmux = useExternalSession ? runTmuxInSwarm : runTmuxInUserSession;
+    const result = await runTmux(["send-keys", "-t", paneId, command, "Enter"]);
+    if (result.code !== 0) {
+      throw new Error(`Failed to send command to pane ${paneId}: ${result.stderr}`);
+    }
+  }
+  async setPaneBorderColor(paneId, color, useExternalSession = false) {
+    const tmuxColor = getTmuxColorName(color);
+    const runTmux = useExternalSession ? runTmuxInSwarm : runTmuxInUserSession;
+    await runTmux([
+      "select-pane",
+      "-t",
+      paneId,
+      "-P",
+      `bg=default,fg=${tmuxColor}`
+    ]);
+    await runTmux([
+      "set-option",
+      "-p",
+      "-t",
+      paneId,
+      "pane-border-style",
+      `fg=${tmuxColor}`
+    ]);
+    await runTmux([
+      "set-option",
+      "-p",
+      "-t",
+      paneId,
+      "pane-active-border-style",
+      `fg=${tmuxColor}`
+    ]);
+  }
+  async setPaneTitle(paneId, name, color, useExternalSession = false) {
+    const tmuxColor = getTmuxColorName(color);
+    const runTmux = useExternalSession ? runTmuxInSwarm : runTmuxInUserSession;
+    await runTmux(["select-pane", "-t", paneId, "-T", name]);
+    await runTmux([
+      "set-option",
+      "-p",
+      "-t",
+      paneId,
+      "pane-border-format",
+      `#[fg=${tmuxColor},bold] #{pane_title} #[default]`
+    ]);
+  }
+  async enablePaneBorderStatus(windowTarget, useExternalSession = false) {
+    const target = windowTarget || await this.getCurrentWindowTarget();
+    if (!target) {
+      return;
+    }
+    const runTmux = useExternalSession ? runTmuxInSwarm : runTmuxInUserSession;
+    await runTmux([
+      "set-option",
+      "-w",
+      "-t",
+      target,
+      "pane-border-status",
+      "top"
+    ]);
+  }
+  async rebalancePanes(windowTarget, hasLeader) {
+    if (hasLeader) {
+      await this.rebalancePanesWithLeader(windowTarget);
+    } else {
+      await this.rebalancePanesTiled(windowTarget);
+    }
+  }
+  async killPane(paneId, useExternalSession = false) {
+    const runTmux = useExternalSession ? runTmuxInSwarm : runTmuxInUserSession;
+    const result = await runTmux(["kill-pane", "-t", paneId]);
+    return result.code === 0;
+  }
+  async hidePane(paneId, useExternalSession = false) {
+    const runTmux = useExternalSession ? runTmuxInSwarm : runTmuxInUserSession;
+    await runTmux(["new-session", "-d", "-s", HIDDEN_SESSION_NAME]);
+    const result = await runTmux([
+      "break-pane",
+      "-d",
+      "-s",
+      paneId,
+      "-t",
+      `${HIDDEN_SESSION_NAME}:`
+    ]);
+    if (result.code === 0) {
+      logForDebugging(`[TmuxBackend] Hidden pane ${paneId}`);
+    } else {
+      logForDebugging(`[TmuxBackend] Failed to hide pane ${paneId}: ${result.stderr}`);
+    }
+    return result.code === 0;
+  }
+  async showPane(paneId, targetWindowOrPane, useExternalSession = false) {
+    const runTmux = useExternalSession ? runTmuxInSwarm : runTmuxInUserSession;
+    const result = await runTmux([
+      "join-pane",
+      "-h",
+      "-s",
+      paneId,
+      "-t",
+      targetWindowOrPane
+    ]);
+    if (result.code !== 0) {
+      logForDebugging(`[TmuxBackend] Failed to show pane ${paneId}: ${result.stderr}`);
+      return false;
+    }
+    logForDebugging(`[TmuxBackend] Showed pane ${paneId} in ${targetWindowOrPane}`);
+    await runTmux(["select-layout", "-t", targetWindowOrPane, "main-vertical"]);
+    const panesResult = await runTmux([
+      "list-panes",
+      "-t",
+      targetWindowOrPane,
+      "-F",
+      "#{pane_id}"
+    ]);
+    const panes = panesResult.stdout.trim().split(`
+`).filter(Boolean);
+    if (panes[0]) {
+      await runTmux(["resize-pane", "-t", panes[0], "-x", "30%"]);
+    }
+    return true;
+  }
+  async getCurrentPaneId() {
+    const leaderPane = getLeaderPaneId();
+    if (leaderPane) {
+      return leaderPane;
+    }
+    const result = await execFileNoThrow(TMUX_COMMAND, [
+      "display-message",
+      "-p",
+      "#{pane_id}"
+    ]);
+    if (result.code !== 0) {
+      logForDebugging(`[TmuxBackend] Failed to get current pane ID (exit ${result.code}): ${result.stderr}`);
+      return null;
+    }
+    return result.stdout.trim();
+  }
+  async getCurrentWindowTarget() {
+    if (cachedLeaderWindowTarget) {
+      return cachedLeaderWindowTarget;
+    }
+    const leaderPane = getLeaderPaneId();
+    const args = ["display-message"];
+    if (leaderPane) {
+      args.push("-t", leaderPane);
+    }
+    args.push("-p", "#{session_name}:#{window_index}");
+    const result = await execFileNoThrow(TMUX_COMMAND, args);
+    if (result.code !== 0) {
+      logForDebugging(`[TmuxBackend] Failed to get current window target (exit ${result.code}): ${result.stderr}`);
+      return null;
+    }
+    cachedLeaderWindowTarget = result.stdout.trim();
+    return cachedLeaderWindowTarget;
+  }
+  async getCurrentWindowPaneCount(windowTarget, useSwarmSocket = false) {
+    const target = windowTarget || await this.getCurrentWindowTarget();
+    if (!target) {
+      return null;
+    }
+    const args = ["list-panes", "-t", target, "-F", "#{pane_id}"];
+    const result = useSwarmSocket ? await runTmuxInSwarm(args) : await runTmuxInUserSession(args);
+    if (result.code !== 0) {
+      logError(new Error(`[TmuxBackend] Failed to get pane count for ${target} (exit ${result.code}): ${result.stderr}`));
+      return null;
+    }
+    return count(result.stdout.trim().split(`
+`), Boolean);
+  }
+  async hasSessionInSwarm(sessionName) {
+    const result = await runTmuxInSwarm(["has-session", "-t", sessionName]);
+    return result.code === 0;
+  }
+  async createExternalSwarmSession() {
+    const sessionExists = await this.hasSessionInSwarm(SWARM_SESSION_NAME);
+    if (!sessionExists) {
+      const result = await runTmuxInSwarm([
+        "new-session",
+        "-d",
+        "-s",
+        SWARM_SESSION_NAME,
+        "-n",
+        SWARM_VIEW_WINDOW_NAME,
+        "-P",
+        "-F",
+        "#{pane_id}"
+      ]);
+      if (result.code !== 0) {
+        throw new Error(`Failed to create swarm session: ${result.stderr || "Unknown error"}`);
+      }
+      const paneId = result.stdout.trim();
+      const windowTarget2 = `${SWARM_SESSION_NAME}:${SWARM_VIEW_WINDOW_NAME}`;
+      logForDebugging(`[TmuxBackend] Created external swarm session with window ${windowTarget2}, pane ${paneId}`);
+      return { windowTarget: windowTarget2, paneId };
+    }
+    const listResult = await runTmuxInSwarm([
+      "list-windows",
+      "-t",
+      SWARM_SESSION_NAME,
+      "-F",
+      "#{window_name}"
+    ]);
+    const windows = listResult.stdout.trim().split(`
+`).filter(Boolean);
+    const windowTarget = `${SWARM_SESSION_NAME}:${SWARM_VIEW_WINDOW_NAME}`;
+    if (windows.includes(SWARM_VIEW_WINDOW_NAME)) {
+      const paneResult = await runTmuxInSwarm([
+        "list-panes",
+        "-t",
+        windowTarget,
+        "-F",
+        "#{pane_id}"
+      ]);
+      const panes = paneResult.stdout.trim().split(`
+`).filter(Boolean);
+      return { windowTarget, paneId: panes[0] || "" };
+    }
+    const createResult = await runTmuxInSwarm([
+      "new-window",
+      "-t",
+      SWARM_SESSION_NAME,
+      "-n",
+      SWARM_VIEW_WINDOW_NAME,
+      "-P",
+      "-F",
+      "#{pane_id}"
+    ]);
+    if (createResult.code !== 0) {
+      throw new Error(`Failed to create swarm-view window: ${createResult.stderr || "Unknown error"}`);
+    }
+    return { windowTarget, paneId: createResult.stdout.trim() };
+  }
+  async createTeammatePaneWithLeader(teammateName, teammateColor) {
+    const currentPaneId = await this.getCurrentPaneId();
+    const windowTarget = await this.getCurrentWindowTarget();
+    if (!currentPaneId || !windowTarget) {
+      throw new Error("Could not determine current tmux pane/window");
+    }
+    const paneCount = await this.getCurrentWindowPaneCount(windowTarget);
+    if (paneCount === null) {
+      throw new Error("Could not determine pane count for current window");
+    }
+    const isFirstTeammate = paneCount === 1;
+    let splitResult;
+    if (isFirstTeammate) {
+      splitResult = await execFileNoThrow(TMUX_COMMAND, [
+        "split-window",
+        "-t",
+        currentPaneId,
+        "-h",
+        "-l",
+        "70%",
+        "-P",
+        "-F",
+        "#{pane_id}"
+      ]);
+    } else {
+      const listResult = await execFileNoThrow(TMUX_COMMAND, [
+        "list-panes",
+        "-t",
+        windowTarget,
+        "-F",
+        "#{pane_id}"
+      ]);
+      const panes = listResult.stdout.trim().split(`
+`).filter(Boolean);
+      const teammatePanes = panes.slice(1);
+      const teammateCount = teammatePanes.length;
+      const splitVertically = teammateCount % 2 === 1;
+      const targetPaneIndex = Math.floor((teammateCount - 1) / 2);
+      const targetPane = teammatePanes[targetPaneIndex] || teammatePanes[teammatePanes.length - 1];
+      splitResult = await execFileNoThrow(TMUX_COMMAND, [
+        "split-window",
+        "-t",
+        targetPane,
+        splitVertically ? "-v" : "-h",
+        "-P",
+        "-F",
+        "#{pane_id}"
+      ]);
+    }
+    if (splitResult.code !== 0) {
+      throw new Error(`Failed to create teammate pane: ${splitResult.stderr}`);
+    }
+    const paneId = splitResult.stdout.trim();
+    logForDebugging(`[TmuxBackend] Created teammate pane for ${teammateName}: ${paneId}`);
+    await this.setPaneBorderColor(paneId, teammateColor);
+    await this.setPaneTitle(paneId, teammateName, teammateColor);
+    await this.rebalancePanesWithLeader(windowTarget);
+    await waitForPaneShellReady();
+    return { paneId, isFirstTeammate };
+  }
+  async createTeammatePaneExternal(teammateName, teammateColor) {
+    const { windowTarget, paneId: firstPaneId } = await this.createExternalSwarmSession();
+    const paneCount = await this.getCurrentWindowPaneCount(windowTarget, true);
+    if (paneCount === null) {
+      throw new Error("Could not determine pane count for swarm window");
+    }
+    const isFirstTeammate = !firstPaneUsedForExternal && paneCount === 1;
+    let paneId;
+    if (isFirstTeammate) {
+      paneId = firstPaneId;
+      firstPaneUsedForExternal = true;
+      logForDebugging(`[TmuxBackend] Using initial pane for first teammate ${teammateName}: ${paneId}`);
+      await this.enablePaneBorderStatus(windowTarget, true);
+    } else {
+      const listResult = await runTmuxInSwarm([
+        "list-panes",
+        "-t",
+        windowTarget,
+        "-F",
+        "#{pane_id}"
+      ]);
+      const panes = listResult.stdout.trim().split(`
+`).filter(Boolean);
+      const teammateCount = panes.length;
+      const splitVertically = teammateCount % 2 === 1;
+      const targetPaneIndex = Math.floor((teammateCount - 1) / 2);
+      const targetPane = panes[targetPaneIndex] || panes[panes.length - 1];
+      const splitResult = await runTmuxInSwarm([
+        "split-window",
+        "-t",
+        targetPane,
+        splitVertically ? "-v" : "-h",
+        "-P",
+        "-F",
+        "#{pane_id}"
+      ]);
+      if (splitResult.code !== 0) {
+        throw new Error(`Failed to create teammate pane: ${splitResult.stderr}`);
+      }
+      paneId = splitResult.stdout.trim();
+      logForDebugging(`[TmuxBackend] Created teammate pane for ${teammateName}: ${paneId}`);
+    }
+    await this.setPaneBorderColor(paneId, teammateColor, true);
+    await this.setPaneTitle(paneId, teammateName, teammateColor, true);
+    await this.rebalancePanesTiled(windowTarget);
+    await waitForPaneShellReady();
+    return { paneId, isFirstTeammate };
+  }
+  async rebalancePanesWithLeader(windowTarget) {
+    const listResult = await runTmuxInUserSession([
+      "list-panes",
+      "-t",
+      windowTarget,
+      "-F",
+      "#{pane_id}"
+    ]);
+    const panes = listResult.stdout.trim().split(`
+`).filter(Boolean);
+    if (panes.length <= 2) {
+      return;
+    }
+    await runTmuxInUserSession([
+      "select-layout",
+      "-t",
+      windowTarget,
+      "main-vertical"
+    ]);
+    const leaderPane = panes[0];
+    await runTmuxInUserSession(["resize-pane", "-t", leaderPane, "-x", "30%"]);
+    logForDebugging(`[TmuxBackend] Rebalanced ${panes.length - 1} teammate panes with leader`);
+  }
+  async rebalancePanesTiled(windowTarget) {
+    const listResult = await runTmuxInSwarm([
+      "list-panes",
+      "-t",
+      windowTarget,
+      "-F",
+      "#{pane_id}"
+    ]);
+    const panes = listResult.stdout.trim().split(`
+`).filter(Boolean);
+    if (panes.length <= 1) {
+      return;
+    }
+    await runTmuxInSwarm(["select-layout", "-t", windowTarget, "tiled"]);
+    logForDebugging(`[TmuxBackend] Rebalanced ${panes.length} teammate panes with tiled layout`);
+  }
+}
+var firstPaneUsedForExternal = false, cachedLeaderWindowTarget = null, paneCreationLock, PANE_SHELL_INIT_DELAY_MS = 200;
+var init_TmuxBackend = __esm(() => {
+  init_debug();
+  init_execFileNoThrow();
+  init_log();
+  init_array();
+  init_sleep();
+  init_constants();
+  init_detection();
+  init_registry();
+  paneCreationLock = Promise.resolve();
+  registerTmuxBackend(TmuxBackend);
+});
+init_TmuxBackend();
+
+export {
+  TmuxBackend
+};