@iloom/cli 0.10.2 → 0.11.0

package/dist/index.js

@@ -8,6 +8,54 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/platform-detect.ts
+import { readFileSync } from "fs";
+function isWSL() {
+  if (cachedIsWSL !== void 0) {
+    return cachedIsWSL;
+  }
+  if (process.platform !== "linux") {
+    cachedIsWSL = false;
+    return false;
+  }
+  if (process.env.WSL_DISTRO_NAME) {
+    cachedIsWSL = true;
+    return true;
+  }
+  try {
+    const procVersion = readFileSync("/proc/version", "utf-8");
+    cachedIsWSL = /microsoft|wsl/i.test(procVersion);
+    return cachedIsWSL;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      cachedIsWSL = false;
+      return false;
+    }
+    cachedIsWSL = false;
+    return false;
+  }
+}
+function detectTerminalEnvironment() {
+  const platform = process.platform;
+  if (platform === "darwin") return "darwin";
+  if (platform === "win32") return "win32";
+  if (platform === "linux") {
+    return isWSL() ? "wsl" : "linux";
+  }
+  return "unsupported";
+}
+function detectWSLDistro() {
+  const distro = process.env.WSL_DISTRO_NAME;
+  if (!distro) return void 0;
+  return distro;
+}
+var cachedIsWSL;
+var init_platform_detect = __esm({
+  "src/utils/platform-detect.ts"() {
+    "use strict";
+  }
+});
+
 // src/utils/env.ts
 import path from "path";
 import dotenvFlow from "dotenv-flow";
@@ -110,65 +158,19 @@ var init_env = __esm({
   }
 });
 
-// src/utils/terminal.ts
-import { execa } from "execa";
+// src/utils/terminal-backends/command-builder.ts
 import { existsSync } from "fs";
-function detectPlatform() {
-  const platform = process.platform;
-  if (platform === "darwin") return "darwin";
-  if (platform === "linux") return "linux";
-  if (platform === "win32") return "win32";
-  return "unsupported";
-}
-async function detectDarkMode() {
-  const platform = detectPlatform();
-  if (platform !== "darwin") {
-    return "light";
-  }
-  try {
-    const result = await execa("defaults", ["read", "-g", "AppleInterfaceStyle"]);
-    return result.stdout.trim().toLowerCase() === "dark" ? "dark" : "light";
-  } catch {
-    return "light";
-  }
-}
-async function detectITerm2() {
-  const platform = detectPlatform();
-  if (platform !== "darwin") return false;
-  return existsSync("/Applications/iTerm.app");
-}
-async function openTerminalWindow(options) {
-  const platform = detectPlatform();
-  if (platform !== "darwin") {
-    throw new Error(
-      `Terminal window launching not yet supported on ${platform}. Currently only macOS is supported.`
-    );
-  }
-  const hasITerm2 = await detectITerm2();
-  const applescript = hasITerm2 ? await buildITerm2SingleTabScript(options) : await buildAppleScript(options);
-  try {
-    await execa("osascript", ["-e", applescript]);
-    if (!hasITerm2) {
-      await execa("osascript", ["-e", 'tell application "Terminal" to activate']);
-    }
-  } catch (error) {
-    throw new Error(
-      `Failed to open terminal window: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-}
-async function buildAppleScript(options) {
+async function buildCommandSequence(options) {
   const {
     workspacePath,
     command,
-    backgroundColor,
     port,
     includeEnvSetup,
     includePortExport
   } = options;
   const commands = [];
   if (workspacePath) {
-    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
+    commands.push(`cd '${escapeSingleQuotes(workspacePath)}'`);
   }
   if (includeEnvSetup && workspacePath) {
     const sourceCommands = await buildEnvSourceCommands(
@@ -184,25 +186,50 @@ async function buildAppleScript(options) {
     commands.push(command);
   }
   const fullCommand = commands.join(" && ");
-  const historyFreeCommand = ` ${fullCommand}`;
+  return ` ${fullCommand}`;
+}
+function escapeSingleQuotes(s) {
+  return s.replace(/'/g, "'\\''");
+}
+function rgbToHex(rgb) {
+  const toHex = (n) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
+  return `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
+}
+var init_command_builder = __esm({
+  "src/utils/terminal-backends/command-builder.ts"() {
+    "use strict";
+    init_env();
+  }
+});
+
+// src/utils/terminal-backends/darwin.ts
+var darwin_exports = {};
+__export(darwin_exports, {
+  DarwinBackend: () => DarwinBackend,
+  detectITerm2: () => detectITerm2
+});
+import { execa } from "execa";
+import { existsSync as existsSync2 } from "fs";
+function detectITerm2() {
+  return existsSync2("/Applications/iTerm.app");
+}
+function escapeForAppleScript(command) {
+  return command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function buildTerminalAppScript(options) {
+  const command = await buildCommandSequence(options);
   let script = `tell application "Terminal"
 `;
-  script += `  set newTab to do script "${escapeForAppleScript(historyFreeCommand)}"
+  script += `  set newTab to do script "${escapeForAppleScript(command)}"
 `;
-  if (backgroundColor) {
-    const { r, g, b } = backgroundColor;
+  if (options.backgroundColor) {
+    const { r, g, b } = options.backgroundColor;
     script += `  set background color of newTab to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
 `;
   }
   script += `end tell`;
   return script;
 }
-function escapePathForAppleScript(path8) {
-  return path8.replace(/'/g, "'\\''");
-}
-function escapeForAppleScript(command) {
-  return command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
 async function buildITerm2SingleTabScript(options) {
   const command = await buildCommandSequence(options);
   let script = 'tell application id "com.googlecode.iterm2"\n';
@@ -225,38 +252,531 @@ async function buildITerm2SingleTabScript(options) {
   script += "end tell";
   return script;
 }
-async function buildCommandSequence(options) {
-  const {
-    workspacePath,
-    command,
-    port,
-    includeEnvSetup,
-    includePortExport
-  } = options;
-  const commands = [];
-  if (workspacePath) {
-    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
+async function buildITerm2MultiTabScript(optionsArray) {
+  if (optionsArray.length < 2) {
+    throw new Error("buildITerm2MultiTabScript requires at least 2 terminal options");
   }
-  if (includeEnvSetup && workspacePath) {
-    const sourceCommands = await buildEnvSourceCommands(
-      workspacePath,
-      async (p) => existsSync(p)
-    );
-    commands.push(...sourceCommands);
+  let script = 'tell application id "com.googlecode.iterm2"\n';
+  script += "  create window with default profile\n";
+  script += "  set newWindow to current window\n";
+  const options1 = optionsArray[0];
+  if (!options1) {
+    throw new Error("First terminal option is undefined");
+  }
+  const command1 = await buildCommandSequence(options1);
+  script += "  set s1 to current session of newWindow\n\n";
+  if (options1.backgroundColor) {
+    const { r, g, b } = options1.backgroundColor;
+    script += `  set background color of s1 to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
   }
-  if (includePortExport && port !== void 0) {
-    commands.push(`export PORT=${port}`);
+  script += `  tell s1 to write text "${escapeForAppleScript(command1)}"
+
+`;
+  if (options1.title) {
+    script += `  set name of s1 to "${escapeForAppleScript(options1.title)}"
+
+`;
   }
-  if (command) {
-    commands.push(command);
+  for (let i = 1; i < optionsArray.length; i++) {
+    const options = optionsArray[i];
+    if (!options) {
+      throw new Error(`Terminal option at index ${i} is undefined`);
+    }
+    const command = await buildCommandSequence(options);
+    const sessionVar = `s${i + 1}`;
+    script += "  tell newWindow\n";
+    script += `    set newTab${i} to (create tab with default profile)
+`;
+    script += "  end tell\n";
+    script += `  set ${sessionVar} to current session of newTab${i}
+
+`;
+    if (options.backgroundColor) {
+      const { r, g, b } = options.backgroundColor;
+      script += `  set background color of ${sessionVar} to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+    }
+    script += `  tell ${sessionVar} to write text "${escapeForAppleScript(command)}"
+
+`;
+    if (options.title) {
+      script += `  set name of ${sessionVar} to "${escapeForAppleScript(options.title)}"
+
+`;
+    }
   }
-  const fullCommand = commands.join(" && ");
-  return ` ${fullCommand}`;
+  script += "  activate\n";
+  script += "end tell";
+  return script;
+}
+var DarwinBackend;
+var init_darwin = __esm({
+  "src/utils/terminal-backends/darwin.ts"() {
+    "use strict";
+    init_command_builder();
+    DarwinBackend = class {
+      constructor() {
+        this.name = "darwin";
+      }
+      async openSingle(options) {
+        const hasITerm2 = detectITerm2();
+        const applescript = hasITerm2 ? await buildITerm2SingleTabScript(options) : await buildTerminalAppScript(options);
+        try {
+          await execa("osascript", ["-e", applescript]);
+          if (!hasITerm2) {
+            await execa("osascript", ["-e", 'tell application "Terminal" to activate']);
+          }
+        } catch (error) {
+          throw new Error(
+            `Failed to open terminal window: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+      async openMultiple(optionsArray) {
+        const hasITerm2 = detectITerm2();
+        if (hasITerm2) {
+          const applescript = await buildITerm2MultiTabScript(optionsArray);
+          try {
+            await execa("osascript", ["-e", applescript]);
+          } catch (error) {
+            throw new Error(
+              `Failed to open iTerm2 window: ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        } else {
+          for (let i = 0; i < optionsArray.length; i++) {
+            const options = optionsArray[i];
+            if (!options) {
+              throw new Error(`Terminal option at index ${i} is undefined`);
+            }
+            await this.openSingle(options);
+            if (i < optionsArray.length - 1) {
+              await new Promise((resolve) => globalThis.setTimeout(resolve, 1e3));
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/utils/terminal-backends/wsl.ts
+var wsl_exports = {};
+__export(wsl_exports, {
+  WSLBackend: () => WSLBackend
+});
+import { execa as execa2 } from "execa";
+function buildTabArgs(shellCommand, options, distro) {
+  const args = ["new-tab"];
+  if (options.title) {
+    args.push("--title", options.title);
+  }
+  if (options.backgroundColor) {
+    args.push("--tabColor", rgbToHex(options.backgroundColor));
+  }
+  args.push("wsl.exe");
+  if (distro) {
+    args.push("-d", distro);
+  }
+  args.push("-e", "bash", "-lic", shellCommand);
+  return args;
+}
+var WSLBackend;
+var init_wsl = __esm({
+  "src/utils/terminal-backends/wsl.ts"() {
+    "use strict";
+    init_command_builder();
+    init_platform_detect();
+    WSLBackend = class {
+      constructor() {
+        this.name = "wsl";
+      }
+      async openSingle(options) {
+        const rawCommand = (await buildCommandSequence(options)).trim();
+        const shellCommand = rawCommand ? `${rawCommand}; exec bash` : "exec bash";
+        const distro = detectWSLDistro();
+        const args = buildTabArgs(shellCommand, options, distro);
+        try {
+          await execa2("wt.exe", args);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          if (message.includes("ENOENT") || message.includes("not found")) {
+            throw new Error(
+              "Windows Terminal (wt.exe) is not available. Install Windows Terminal from the Microsoft Store: https://aka.ms/terminal"
+            );
+          }
+          throw new Error(`Failed to open Windows Terminal tab: ${message}`);
+        }
+      }
+      async openMultiple(optionsArray) {
+        const distro = detectWSLDistro();
+        const allArgs = [];
+        for (let i = 0; i < optionsArray.length; i++) {
+          const options = optionsArray[i];
+          if (!options) {
+            throw new Error(`Terminal option at index ${i} is undefined`);
+          }
+          const rawCommand = (await buildCommandSequence(options)).trim();
+          const shellCommand = rawCommand ? `${rawCommand}; exec bash` : "exec bash";
+          const tabArgs = buildTabArgs(shellCommand, options, distro);
+          if (i > 0) {
+            allArgs.push(";");
+          }
+          allArgs.push(...tabArgs);
+        }
+        try {
+          await execa2("wt.exe", allArgs);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          if (message.includes("ENOENT") || message.includes("not found")) {
+            throw new Error(
+              "Windows Terminal (wt.exe) is not available. Install Windows Terminal from the Microsoft Store: https://aka.ms/terminal"
+            );
+          }
+          throw new Error(`Failed to open Windows Terminal tabs: ${message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/utils/terminal-backends/linux.ts
+var linux_exports = {};
+__export(linux_exports, {
+  LinuxBackend: () => LinuxBackend,
+  detectLinuxTerminal: () => detectLinuxTerminal
+});
+import { execa as execa3 } from "execa";
+async function detectLinuxTerminal() {
+  for (const terminal of TERMINAL_EMULATORS) {
+    try {
+      await execa3("which", [terminal]);
+      return terminal;
+    } catch (error) {
+      if (error instanceof Error && "exitCode" in error) {
+        continue;
+      }
+      throw error;
+    }
+  }
+  return null;
+}
+var TERMINAL_EMULATORS, LinuxBackend;
+var init_linux = __esm({
+  "src/utils/terminal-backends/linux.ts"() {
+    "use strict";
+    init_command_builder();
+    init_logger();
+    TERMINAL_EMULATORS = ["gnome-terminal", "konsole", "xterm"];
+    LinuxBackend = class {
+      constructor() {
+        this.name = "linux";
+      }
+      async openSingle(options) {
+        const terminal = await this.resolveTerminal();
+        await this.openSingleWithTerminal(options, terminal);
+      }
+      async openMultiple(optionsArray) {
+        const terminal = await this.resolveTerminal();
+        for (let i = 0; i < optionsArray.length; i++) {
+          const options = optionsArray[i];
+          if (!options) {
+            throw new Error(`Terminal option at index ${i} is undefined`);
+          }
+          await this.openSingleWithTerminal(options, terminal);
+        }
+      }
+      async resolveTerminal() {
+        const terminal = await detectLinuxTerminal();
+        if (!terminal) {
+          throw new Error(
+            "No supported GUI terminal emulator found. Install gnome-terminal, konsole, or xterm \u2014 or use tmux for headless environments."
+          );
+        }
+        return terminal;
+      }
+      async openSingleWithTerminal(options, terminal) {
+        if (options.backgroundColor) {
+          logger.debug(
+            "Terminal background colors are not supported via CLI on Linux terminal emulators."
+          );
+        }
+        const shellCommand = (await buildCommandSequence(options)).trim();
+        const keepAliveCommand = shellCommand ? `${shellCommand}; exec bash` : "exec bash";
+        await this.execTerminal(terminal, keepAliveCommand, options.title);
+      }
+      async execTerminal(terminal, command, title) {
+        try {
+          switch (terminal) {
+            case "gnome-terminal": {
+              const args = ["--tab"];
+              if (title) {
+                args.push("--title", title);
+              }
+              args.push("--", "bash", "-lic", command);
+              await execa3("gnome-terminal", args);
+              break;
+            }
+            case "konsole": {
+              const args = ["--new-tab"];
+              if (title) {
+                args.push("-p", `tabtitle=${title}`);
+              }
+              args.push("-e", "bash", "-lic", command);
+              await execa3("konsole", args);
+              break;
+            }
+            case "xterm": {
+              const args = [];
+              if (title) {
+                args.push("-title", title);
+              }
+              args.push("-e", "bash", "-lic", command);
+              await execa3("xterm", args);
+              break;
+            }
+          }
+        } catch (error) {
+          throw new Error(
+            `Failed to open ${terminal}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/utils/terminal-backends/tmux.ts
+var tmux_exports = {};
+__export(tmux_exports, {
+  TmuxBackend: () => TmuxBackend,
+  isTmuxAvailable: () => isTmuxAvailable
+});
+import { execa as execa4 } from "execa";
+async function isTmuxAvailable() {
+  try {
+    await execa4("which", ["tmux"]);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "exitCode" in error) {
+      return false;
+    }
+    throw error;
+  }
+}
+function sanitizeSessionName(title) {
+  return title.replace(/[.:]/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 64);
+}
+function sanitizeWindowName(title) {
+  return title.replace(/[.:]/g, "-").substring(0, 32);
+}
+async function sessionExists(sessionName) {
+  try {
+    await execa4("tmux", ["has-session", "-t", sessionName]);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "exitCode" in error) {
+      return false;
+    }
+    throw error;
+  }
+}
+var TmuxBackend;
+var init_tmux = __esm({
+  "src/utils/terminal-backends/tmux.ts"() {
+    "use strict";
+    init_command_builder();
+    init_logger();
+    TmuxBackend = class {
+      constructor() {
+        this.name = "tmux";
+      }
+      async openSingle(options) {
+        const shellCommand = (await buildCommandSequence(options)).trim();
+        const command = shellCommand ? `${shellCommand}; exec bash` : "bash";
+        if (options.backgroundColor) {
+          logger.debug("Terminal background colors are not supported in tmux sessions.");
+        }
+        const sessionName = options.title ? sanitizeSessionName(`iloom-${options.title}`) : `iloom-${Date.now()}`;
+        const windowName = options.title ? sanitizeWindowName(options.title) : "main";
+        const iloomSession = await this.findIloomSession();
+        if (iloomSession) {
+          const args = ["new-window", "-t", iloomSession, "-n", windowName, "bash", "-lic", command];
+          try {
+            await execa4("tmux", args);
+            logger.info(`Added tmux window "${windowName}" to session "${iloomSession}"`);
+          } catch (error) {
+            throw new Error(
+              `Failed to add tmux window: ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        } else {
+          const args = ["new-session", "-d", "-s", sessionName, "-n", windowName, "bash", "-lic", command];
+          try {
+            await execa4("tmux", args);
+            logger.info(`Created tmux session "${sessionName}" \u2014 attach with: tmux attach -t ${sessionName}`);
+          } catch (error) {
+            throw new Error(
+              `Failed to create tmux session: ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        }
+      }
+      async openMultiple(optionsArray) {
+        if (optionsArray.length === 0) return;
+        const firstOptions = optionsArray[0];
+        if (!firstOptions) {
+          throw new Error("First terminal option is undefined");
+        }
+        const sessionName = firstOptions.title ? sanitizeSessionName(`iloom-${firstOptions.title}`) : `iloom-${Date.now()}`;
+        const finalSessionName = await sessionExists(sessionName) ? `${sessionName}-${Date.now()}` : sessionName;
+        if (firstOptions.backgroundColor) {
+          logger.debug("Terminal background colors are not supported in tmux sessions.");
+        }
+        const firstShellCommand = (await buildCommandSequence(firstOptions)).trim();
+        const firstCommand = firstShellCommand ? `${firstShellCommand}; exec bash` : "bash";
+        const firstName = firstOptions.title ? sanitizeWindowName(firstOptions.title) : "window-1";
+        try {
+          await execa4("tmux", [
+            "new-session",
+            "-d",
+            "-s",
+            finalSessionName,
+            "-n",
+            firstName,
+            "bash",
+            "-lic",
+            firstCommand
+          ]);
+        } catch (error) {
+          throw new Error(
+            `Failed to create tmux session: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+        for (let i = 1; i < optionsArray.length; i++) {
+          const options = optionsArray[i];
+          if (!options) {
+            throw new Error(`Terminal option at index ${i} is undefined`);
+          }
+          if (options.backgroundColor) {
+            logger.debug("Terminal background colors are not supported in tmux sessions.");
+          }
+          const shellCommand = (await buildCommandSequence(options)).trim();
+          const command = shellCommand ? `${shellCommand}; exec bash` : "bash";
+          const windowName = options.title ? sanitizeWindowName(options.title) : `window-${i + 1}`;
+          try {
+            await execa4("tmux", [
+              "new-window",
+              "-t",
+              finalSessionName,
+              "-n",
+              windowName,
+              "bash",
+              "-lic",
+              command
+            ]);
+          } catch (error) {
+            throw new Error(
+              `Failed to add tmux window "${windowName}": ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        }
+        logger.info(
+          `Created tmux session "${finalSessionName}" with ${optionsArray.length} windows \u2014 attach with: tmux attach -t ${finalSessionName}`
+        );
+      }
+      /**
+       * Look for an existing iloom tmux session to add windows to.
+       * Returns the session name if found, null otherwise.
+       */
+      async findIloomSession() {
+        try {
+          const result = await execa4("tmux", ["list-sessions", "-F", "#{session_name}"]);
+          const sessions = result.stdout.split("\n").filter(Boolean);
+          return sessions.find((s) => s.startsWith("iloom-")) ?? null;
+        } catch (error) {
+          if (error instanceof Error && "exitCode" in error) {
+            return null;
+          }
+          throw error;
+        }
+      }
+    };
+  }
+});
+
+// src/utils/terminal-backends/index.ts
+async function getTerminalBackend() {
+  const env = detectTerminalEnvironment();
+  switch (env) {
+    case "darwin": {
+      const { DarwinBackend: DarwinBackend2 } = await Promise.resolve().then(() => (init_darwin(), darwin_exports));
+      return new DarwinBackend2();
+    }
+    case "wsl": {
+      const { WSLBackend: WSLBackend2 } = await Promise.resolve().then(() => (init_wsl(), wsl_exports));
+      return new WSLBackend2();
+    }
+    case "linux": {
+      const hasDisplay = !!(process.env.DISPLAY ?? process.env.WAYLAND_DISPLAY);
+      if (hasDisplay) {
+        const { detectLinuxTerminal: detectLinuxTerminal2 } = await Promise.resolve().then(() => (init_linux(), linux_exports));
+        if (await detectLinuxTerminal2()) {
+          const { LinuxBackend: LinuxBackend2 } = await Promise.resolve().then(() => (init_linux(), linux_exports));
+          return new LinuxBackend2();
+        }
+      }
+      const { isTmuxAvailable: isTmuxAvailable2, TmuxBackend: TmuxBackend2 } = await Promise.resolve().then(() => (init_tmux(), tmux_exports));
+      if (await isTmuxAvailable2()) {
+        return new TmuxBackend2();
+      }
+      throw new Error(
+        "No supported terminal found on Linux. Install tmux for headless environments, or set DISPLAY and install a GUI terminal (gnome-terminal, konsole, xterm)."
+      );
+    }
+    default:
+      throw new Error(
+        `Terminal window launching is not supported on ${env}. Supported platforms: macOS, WSL (Windows Terminal), Linux (GUI terminals or tmux).`
+      );
+  }
+}
+var init_terminal_backends = __esm({
+  "src/utils/terminal-backends/index.ts"() {
+    "use strict";
+    init_platform_detect();
+  }
+});
+
+// src/utils/terminal.ts
+import { execa as execa5 } from "execa";
+function detectPlatform() {
+  const env = detectTerminalEnvironment();
+  if (env === "wsl") return "linux";
+  return env;
+}
+async function detectDarkMode() {
+  const platform = detectPlatform();
+  if (platform !== "darwin") {
+    return "light";
+  }
+  try {
+    const result = await execa5("defaults", ["read", "-g", "AppleInterfaceStyle"]);
+    return result.stdout.trim().toLowerCase() === "dark" ? "dark" : "light";
+  } catch {
+    return "light";
+  }
+}
+async function openTerminalWindow(options) {
+  const backend = await getTerminalBackend();
+  await backend.openSingle(options);
 }
 var init_terminal = __esm({
   "src/utils/terminal.ts"() {
     "use strict";
-    init_env();
+    init_terminal_backends();
+    init_darwin();
+    init_platform_detect();
   }
 });
 
@@ -527,15 +1047,16 @@ var init_SettingsManager = __esm({
         z.enum(["claude", "gemini", "codex"]),
         z.string()
       ).optional().describe('Map of review providers to model names. Keys: claude, gemini, codex. Values: model name strings (e.g., "sonnet", "gemini-3-pro-preview", "gpt-5.2-codex")'),
-      review: z.boolean().optional().describe("Whether artifacts from this agent should be reviewed before posting (defaults to false)")
+      review: z.boolean().optional().describe("Whether artifacts from this agent should be reviewed before posting (defaults to false)"),
+      swarmReview: z.boolean().optional().describe("Whether artifacts from this agent should be reviewed in swarm mode. Defaults to false if not set (review is off in swarm mode for speed and cost unless explicitly enabled).")
     });
     AgentSettingsSchema = BaseAgentSettingsSchema.extend({
-      agents: z.record(z.string(), BaseAgentSettingsSchema).optional().describe("Nested per-agent settings. Only meaningful under the iloom-swarm-worker agent entry for sub-agent timeout configuration."),
       subAgentTimeout: z.number().min(1, "Sub-agent timeout must be at least 1 minute").max(120, "Sub-agent timeout cannot exceed 120 minutes").default(10).describe("Timeout in minutes for sub-agent claude -p invocations in swarm mode. Applies to each phase agent (evaluator, analyzer, planner, implementer) when invoked via the Bash tool. Default: 10 minutes. Only meaningful under the iloom-swarm-worker agent entry.")
     });
     SpinAgentSettingsSchema = z.object({
       model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for spin orchestrator"),
-      swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Model for the spin orchestrator when running in swarm mode. Overrides spin.model for swarm workflows.")
+      swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Model for the spin orchestrator when running in swarm mode. Overrides spin.model for swarm workflows."),
+      postSwarmReview: z.boolean().default(true).describe("Run a full code review after swarm completion, auto-fixing issues with confidence 80+. Defaults to true.")
     });
     PlanCommandSettingsSchema = z.object({
       model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for plan command"),
@@ -730,7 +1251,8 @@ var init_SettingsManager = __esm({
       ),
       spin: z.object({
         model: z.enum(["sonnet", "opus", "haiku"]).optional(),
-        swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional()
+        swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional(),
+        postSwarmReview: z.boolean().optional()
       }).optional().describe("Spin orchestrator configuration"),
       plan: z.object({
         model: z.enum(["sonnet", "opus", "haiku"]).optional(),
@@ -1071,7 +1593,7 @@ __export(color_exports, {
   getDarkColorPalette: () => getDarkColorPalette,
   hexToRgb: () => hexToRgb,
   lightenColor: () => lightenColor,
-  rgbToHex: () => rgbToHex,
+  rgbToHex: () => rgbToHex2,
   saturateColor: () => saturateColor,
   selectDistinctColor: () => selectDistinctColor
 });
@@ -1148,7 +1670,7 @@ function getDarkColorPalette() {
     // 15: Dark rust
   ];
 }
-function rgbToHex(r, g, b) {
+function rgbToHex2(r, g, b) {
   if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
     throw new Error("RGB values must be between 0 and 255");
   }
@@ -1178,7 +1700,7 @@ function generateColorFromBranchName(branchName, themeMode = "light") {
   if (!rgb) {
     throw new Error(`Invalid color index: ${index}`);
   }
-  const hex = rgbToHex(rgb.r, rgb.g, rgb.b);
+  const hex = rgbToHex2(rgb.r, rgb.g, rgb.b);
   return {
     rgb,
     hex,
@@ -1222,7 +1744,7 @@ function selectDistinctColor(branchName, usedHexColors, themeMode = "light") {
     if (isDistinct) {
       return {
         rgb: candidateRgb,
-        hex: rgbToHex(candidateRgb.r, candidateRgb.g, candidateRgb.b),
+        hex: rgbToHex2(candidateRgb.r, candidateRgb.g, candidateRgb.b),
         index: i
       };
     }
@@ -1279,7 +1801,7 @@ import fs2 from "fs-extra";
 // src/utils/git.ts
 init_SettingsManager();
 import path4 from "path";
-import { execa as execa2 } from "execa";
+import { execa as execa6 } from "execa";
 
 // src/lib/MetadataManager.ts
 import path3 from "path";
@@ -1321,6 +1843,7 @@ var MetadataManager = class {
       prUrls: data.prUrls ?? {},
       draftPrNumber: data.draftPrNumber ?? null,
       oneShot: data.oneShot ?? null,
+      complexity: data.complexity ?? null,
       capabilities: data.capabilities ?? [],
       state: data.state ?? null,
       childIssueNumbers: data.childIssueNumbers ?? [],
@@ -1392,6 +1915,7 @@ var MetadataManager = class {
         capabilities: input.capabilities,
         ...input.draftPrNumber && { draftPrNumber: input.draftPrNumber },
         ...input.oneShot && { oneShot: input.oneShot },
+        ...input.complexity && { complexity: input.complexity },
         ...input.state && { state: input.state },
         ...input.childIssueNumbers && input.childIssueNumbers.length > 0 && { childIssueNumbers: input.childIssueNumbers },
         ...input.parentLoom && { parentLoom: input.parentLoom },
@@ -1624,7 +2148,7 @@ var GitCommandError = class extends Error {
 };
 async function executeGitCommand(args, options) {
   try {
-    const result = await execa2("git", args, {
+    const result = await execa6("git", args, {
       cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
       timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
       encoding: "utf8",
@@ -2686,9 +3210,9 @@ var GitHubError = class extends Error {
 
 // src/utils/github.ts
 init_logger();
-import { execa as execa3 } from "execa";
+import { execa as execa7 } from "execa";
 async function executeGhCommand(args, options) {
-  const result = await execa3("gh", args, {
+  const result = await execa7("gh", args, {
     cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
     timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
     encoding: "utf8"
@@ -2854,7 +3378,7 @@ async function createIssue(title, body, options) {
   if (!repo) {
     execaOptions.cwd = process.cwd();
   }
-  const result = await execa3("gh", args, execaOptions);
+  const result = await execa7("gh", args, execaOptions);
   const urlMatch = result.stdout.trim().match(/https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/);
   if (!(urlMatch == null ? void 0 : urlMatch[1])) {
     throw new Error(`Failed to parse issue URL from gh output: ${result.stdout}`);
@@ -5039,14 +5563,14 @@ var DatabaseManager = class {
 
 // src/utils/claude.ts
 init_logger();
-import { execa as execa4 } from "execa";
-import { existsSync as existsSync2 } from "fs";
+import { execa as execa8 } from "execa";
+import { existsSync as existsSync3 } from "fs";
 import { join } from "path";
 import { createHash as createHash3, randomUUID } from "crypto";
 init_terminal();
 async function detectClaudeCli() {
   try {
-    await execa4("command", ["-v", "claude"], {
+    await execa8("command", ["-v", "claude"], {
       shell: true,
       timeout: 5e3
     });
@@ -5076,7 +5600,7 @@ function parseJsonStreamOutput(output) {
   }
 }
 async function launchClaude(prompt, options = {}) {
-  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents, sessionId, noSessionPersistence, outputFormat, verbose, jsonMode, passthroughStdout, env: extraEnv, signal } = options;
+  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents, pluginDir, sessionId, noSessionPersistence, outputFormat, verbose, jsonMode, passthroughStdout, env: extraEnv, signal } = options;
   const log = getLogger();
   const args = [];
   if (headless) {
@@ -5114,6 +5638,9 @@ async function launchClaude(prompt, options = {}) {
   if (agents) {
     args.push("--agents", JSON.stringify(agents));
   }
+  if (pluginDir) {
+    args.push("--plugin-dir", pluginDir);
+  }
   if (sessionId) {
     args.push("--session-id", sessionId);
   }
@@ -5133,7 +5660,7 @@ async function launchClaude(prompt, options = {}) {
   }
   try {
     if (headless && passthroughStdout) {
-      const subprocess = execa4("claude", args, {
+      const subprocess = execa8("claude", args, {
         input: prompt,
         timeout: 0,
         ...addDir && { cwd: addDir },
@@ -5165,7 +5692,7 @@ async function launchClaude(prompt, options = {}) {
         ...isDebugMode && { stdio: ["pipe", "pipe", "pipe"] }
         // Enable streaming in debug mode
       };
-      const subprocess = execa4("claude", args, execaOptions);
+      const subprocess = execa8("claude", args, execaOptions);
       attachAbortSignal(subprocess);
       const isJsonStreamFormat = args.includes("--output-format") && args.includes("stream-json");
       let outputBuffer = "";
@@ -5219,7 +5746,7 @@ async function launchClaude(prompt, options = {}) {
       }
     } else {
       try {
-        const interactiveSubprocess = execa4("claude", [...args, "--", prompt], {
+        const interactiveSubprocess = execa8("claude", [...args, "--", prompt], {
           ...addDir && { cwd: addDir },
           stdio: ["inherit", "inherit", "pipe"],
           // Capture stderr to detect session conflicts
@@ -5251,7 +5778,7 @@ async function launchClaude(prompt, options = {}) {
             return true;
           });
           resumeArgs.push("--resume", conflictSessionId);
-          const resumeSubprocess = execa4("claude", resumeArgs, {
+          const resumeSubprocess = execa8("claude", resumeArgs, {
             ...addDir && { cwd: addDir },
             stdio: "inherit",
             timeout: 0,
@@ -5295,7 +5822,7 @@ async function launchClaude(prompt, options = {}) {
             env: claudeEnv,
             ...isDebugMode && { stdio: ["pipe", "pipe", "pipe"] }
           };
-          const subprocess = execa4("claude", resumeArgs, execaOptions);
+          const subprocess = execa8("claude", resumeArgs, execaOptions);
           const isJsonStreamFormat = resumeArgs.includes("--output-format") && resumeArgs.includes("stream-json");
           let outputBuffer = "";
           let isStreaming = false;
@@ -5341,7 +5868,7 @@ async function launchClaude(prompt, options = {}) {
             return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
           }
         } else {
-          await execa4("claude", resumeArgs, {
+          await execa8("claude", resumeArgs, {
             ...addDir && { cwd: addDir },
             stdio: "inherit",
             timeout: 0,
@@ -5386,7 +5913,7 @@ async function launchClaudeInNewTerminalWindow(_prompt, options) {
       );
     }
   }
-  const hasEnvFile = existsSync2(join(workspacePath, ".env"));
+  const hasEnvFile = existsSync3(join(workspacePath, ".env"));
   await openTerminalWindow({
     workspacePath,
     command: launchCommand,