@redscope-ai/redscope 1.0.0

package/dist/chunk-rpshz4dy.js

@@ -0,0 +1,614 @@
+// @bun
+import {
+  init_registry,
+  registerTmuxBackend
+} from "./chunk-gmdy2w3z.js";
+import"./chunk-q0e485mg.js";
+import"./chunk-2kcgxnvp.js";
+import"./chunk-14p6wvsq.js";
+import"./chunk-6s0q1s5r.js";
+import"./chunk-3w9sye8h.js";
+import"./chunk-nzxfj0gq.js";
+import"./chunk-vr0n9pv9.js";
+import"./chunk-9a9g5hbj.js";
+import"./chunk-ptxteaeh.js";
+import"./chunk-w4p5t920.js";
+import"./chunk-rgyzsbs3.js";
+import"./chunk-q3b4n194.js";
+import"./chunk-kywtr3jg.js";
+import"./chunk-eewg66y1.js";
+import"./chunk-71sdcaq6.js";
+import"./chunk-9hn8e6h1.js";
+import"./chunk-7qey87th.js";
+import"./chunk-zw62m6n3.js";
+import"./chunk-1w20m7gw.js";
+import"./chunk-zzf074w3.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-24kv69g3.js";
+import"./chunk-hzxzvzw8.js";
+import"./chunk-30wnahyg.js";
+import"./chunk-ztmb7geg.js";
+import"./chunk-tbdkekz3.js";
+import"./chunk-65zbgg1n.js";
+import"./chunk-4spgkgr3.js";
+import"./chunk-60fkafk2.js";
+import"./chunk-50m3a23z.js";
+import"./chunk-6hygvrhn.js";
+import"./chunk-7tfdhkpy.js";
+import"./chunk-8gv2pjby.js";
+import"./chunk-g06pm4n9.js";
+import"./chunk-2p369q9z.js";
+import"./chunk-z0jgeax8.js";
+import"./chunk-w68wc625.js";
+import"./chunk-6hr7742d.js";
+import {
+  getLeaderPaneId,
+  init_detection,
+  isInsideTmux,
+  isTmuxAvailable
+} from "./chunk-xyg1sk2w.js";
+import {
+  HIDDEN_SESSION_NAME,
+  SWARM_SESSION_NAME,
+  SWARM_VIEW_WINDOW_NAME,
+  TMUX_COMMAND,
+  getSwarmSocketName,
+  init_constants
+} from "./chunk-935nrvdb.js";
+import"./chunk-8zz4z1q3.js";
+import"./chunk-fncpkzs5.js";
+import"./chunk-hqxp6b72.js";
+import"./chunk-m2c3bjv1.js";
+import"./chunk-jhtccjc9.js";
+import"./chunk-7nvday0n.js";
+import"./chunk-vxbjzggp.js";
+import"./chunk-yc1stfve.js";
+import"./chunk-8yvsnrkr.js";
+import"./chunk-5mmhfbxb.js";
+import"./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import"./chunk-8kct9arg.js";
+import {
+  count,
+  init_array
+} from "./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import {
+  init_sleep,
+  sleep
+} from "./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-7qx3xhv3.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-dbts5q5p.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-q44zc68f.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import"./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-92bjkrf2.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import {
+  init_debug,
+  init_log,
+  logError,
+  logForDebugging
+} from "./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.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 createTeammateWindowInSwarmView(name, color) {
+    const windowName = `teammate-${name.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase()}`;
+    const { windowTarget } = await this.createExternalSwarmSession();
+    const result = await runTmuxInSwarm([
+      "new-window",
+      "-t",
+      SWARM_SESSION_NAME,
+      "-n",
+      windowName,
+      "-P",
+      "-F",
+      "#{pane_id}"
+    ]);
+    if (result.code !== 0) {
+      throw new Error(`Failed to create tmux window: ${result.stderr || "Unknown error"}`);
+    }
+    const paneId = result.stdout.trim();
+    await this.setPaneTitle(paneId, name, color, true);
+    await this.setPaneBorderColor(paneId, color, true);
+    return { paneId, isFirstTeammate: false, windowName };
+  }
+  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
+};