@industry-theme/xterm-terminal-panel 0.1.0

package/dist/index.js

@@ -0,0 +1,1933 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/components/ThemedTerminal.tsx
+import { FitAddon } from "@xterm/addon-fit";
+import { SearchAddon } from "@xterm/addon-search";
+import { WebLinksAddon } from "@xterm/addon-web-links";
+import { Terminal } from "@xterm/xterm";
+import {
+  ChevronDown,
+  ExternalLink,
+  Monitor,
+  Terminal as TerminalIcon,
+  X
+} from "lucide-react";
+import {
+  forwardRef,
+  useEffect,
+  useImperativeHandle,
+  useRef,
+  useState
+} from "react";
+import"@xterm/xterm/css/xterm.css";
+
+// src/utils/terminalTheme.ts
+function createTerminalTheme(theme) {
+  return {
+    background: theme.colors.background,
+    foreground: theme.colors.text,
+    cursor: theme.colors.primary,
+    cursorAccent: theme.colors.background,
+    selectionBackground: theme.colors.primary + "40",
+    selectionForeground: theme.colors.text,
+    selectionInactiveBackground: theme.colors.backgroundSecondary,
+    black: "#000000",
+    red: "#ff5555",
+    green: "#50fa7b",
+    yellow: "#f1fa8c",
+    blue: "#6272a4",
+    magenta: "#bd93f9",
+    cyan: "#8be9fd",
+    white: "#bfbfbf",
+    brightBlack: "#4d4d4d",
+    brightRed: "#ff6e67",
+    brightGreen: "#5af78e",
+    brightYellow: "#f4f99d",
+    brightBlue: "#6cadff",
+    brightMagenta: "#ff92d0",
+    brightCyan: "#9aedfe",
+    brightWhite: "#e6e6e6"
+  };
+}
+function getTerminalCSSVariables(theme) {
+  return {
+    "--terminal-bg": theme.colors.background,
+    "--terminal-fg": theme.colors.text,
+    "--terminal-border": theme.colors.border,
+    "--terminal-header-bg": theme.colors.backgroundSecondary || theme.colors.background,
+    "--terminal-font-family": 'Menlo, Monaco, "Courier New", monospace',
+    "--terminal-font-size": "14px"
+  };
+}
+
+// src/components/ThemedTerminal.tsx
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+var ThemedTerminal = forwardRef(({
+  theme,
+  onData,
+  onResize,
+  onReady,
+  onLinkClick,
+  onScrollPositionChange,
+  className = "",
+  hideHeader = false,
+  headerTitle = "Terminal",
+  headerSubtitle,
+  headerBadge,
+  autoFocus = true,
+  isVisible = true,
+  scrollbarStyle = "overlay",
+  onClose,
+  onDestroy,
+  onPopOut,
+  overlayState,
+  cursorBlink = true,
+  cursorStyle = "block",
+  scrollback = 1e4,
+  fontFamily,
+  fontSize = 14,
+  enableWebGL = false,
+  enableUnicode11 = false,
+  enableSearch = true,
+  enableWebLinks = true
+}, ref) => {
+  const terminalRef = useRef(null);
+  const [terminal, setTerminal] = useState(null);
+  const fitAddonRef = useRef(null);
+  const searchAddonRef = useRef(null);
+  const resizeTimeoutRef = useRef(null);
+  const isVisibleRef = useRef(isVisible);
+  const isScrollLockedRef = useRef(true);
+  useEffect(() => {
+    isVisibleRef.current = isVisible;
+  }, [isVisible]);
+  const getScrollPosition = () => {
+    if (!terminal) {
+      return {
+        isAtTop: false,
+        isAtBottom: true,
+        isScrollLocked: isScrollLockedRef.current
+      };
+    }
+    const scrollY = terminal.buffer.active.viewportY;
+    const scrollback2 = terminal.buffer.active.baseY;
+    const isAtTop = scrollY === 0;
+    const isAtBottom = scrollY + terminal.rows >= scrollback2 + terminal.rows;
+    return {
+      isAtTop,
+      isAtBottom,
+      isScrollLocked: isScrollLockedRef.current
+    };
+  };
+  useImperativeHandle(ref, () => ({
+    write: (data) => {
+      if (terminal) {
+        terminal.write(data, () => {
+          if (isScrollLockedRef.current) {
+            terminal.scrollToBottom();
+          }
+        });
+      } else {
+        console.warn("[ThemedTerminal] write called but terminal is null!");
+      }
+    },
+    writeln: (data) => {
+      if (terminal) {
+        terminal.writeln(data);
+        if (isScrollLockedRef.current) {
+          terminal.scrollToBottom();
+        }
+      }
+    },
+    scrollToBottom: () => {
+      if (terminal) {
+        terminal.scrollToBottom();
+        isScrollLockedRef.current = true;
+      }
+    },
+    focus: () => {
+      if (terminal) {
+        terminal.focus();
+      }
+    },
+    blur: () => {
+      if (terminal) {
+        terminal.blur();
+      }
+    },
+    clear: () => {
+      if (terminal) {
+        terminal.clear();
+      }
+    },
+    reset: () => {
+      if (terminal) {
+        terminal.reset();
+      }
+    },
+    getTerminal: () => terminal,
+    resize: (cols, rows) => {
+      if (terminal) {
+        terminal.resize(cols, rows);
+      }
+    },
+    selectAll: () => {
+      if (terminal) {
+        terminal.selectAll();
+      }
+    },
+    clearSelection: () => {
+      if (terminal) {
+        terminal.clearSelection();
+      }
+    },
+    findNext: (searchTerm, searchOptions) => {
+      if (searchAddonRef.current) {
+        return searchAddonRef.current.findNext(searchTerm, searchOptions);
+      }
+      return false;
+    },
+    findPrevious: (searchTerm, searchOptions) => {
+      if (searchAddonRef.current) {
+        return searchAddonRef.current.findPrevious(searchTerm, searchOptions);
+      }
+      return false;
+    },
+    clearSearch: () => {
+      if (searchAddonRef.current) {
+        searchAddonRef.current.clearDecorations();
+      }
+    },
+    fit: () => {
+      if (fitAddonRef.current && terminal) {
+        fitAddonRef.current.fit();
+        if (isScrollLockedRef.current) {
+          requestAnimationFrame(() => {
+            terminal.scrollToBottom();
+          });
+        }
+      }
+    },
+    isScrollLocked: () => isScrollLockedRef.current,
+    getScrollPosition
+  }), [terminal]);
+  useEffect(() => {
+    if (!terminalRef.current || terminal) {
+      return;
+    }
+    const term = new Terminal({
+      cursorBlink,
+      cursorStyle,
+      fontSize,
+      fontFamily: fontFamily || 'Menlo, Monaco, "Courier New", monospace',
+      theme: createTerminalTheme(theme),
+      scrollback,
+      allowProposedApi: true,
+      lineHeight: 1,
+      letterSpacing: 0,
+      rightClickSelectsWord: true,
+      smoothScrollDuration: 0,
+      drawBoldTextInBrightColors: true,
+      windowsMode: false,
+      fontWeight: "normal",
+      fontWeightBold: "bold"
+    });
+    const fitAddon = new FitAddon;
+    fitAddonRef.current = fitAddon;
+    term.loadAddon(fitAddon);
+    if (enableSearch) {
+      const searchAddon = new SearchAddon;
+      searchAddonRef.current = searchAddon;
+      term.loadAddon(searchAddon);
+    }
+    if (enableUnicode11) {
+      import("@xterm/addon-unicode11").then(({ Unicode11Addon }) => {
+        const unicode11Addon = new Unicode11Addon;
+        term.loadAddon(unicode11Addon);
+        term.unicode.activeVersion = "11";
+      }).catch(() => {
+        console.warn("[Terminal] Unicode11Addon not available");
+      });
+    }
+    if (enableWebLinks) {
+      const webLinksAddon = new WebLinksAddon((event, uri) => {
+        event.preventDefault();
+        if (onLinkClick) {
+          const isLocalhost = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?/i.test(uri);
+          onLinkClick(uri, isLocalhost);
+        }
+      });
+      term.loadAddon(webLinksAddon);
+    }
+    term.open(terminalRef.current);
+    const scrollDisposable = term.onScroll(() => {
+      const scrollY = term.buffer.active.viewportY;
+      const scrollback2 = term.buffer.active.baseY;
+      const isAtTop = scrollY === 0;
+      const isAtBottom = scrollY + term.rows >= scrollback2 + term.rows;
+      if (onScrollPositionChange) {
+        onScrollPositionChange({
+          isAtTop,
+          isAtBottom,
+          isScrollLocked: isScrollLockedRef.current
+        });
+      }
+    });
+    if (enableWebGL) {
+      import("@xterm/addon-webgl").then(({ WebglAddon }) => {
+        try {
+          const webglAddon = new WebglAddon;
+          webglAddon.onContextLoss(() => {
+            webglAddon.dispose();
+            console.warn("[Terminal] WebGL context lost, falling back to canvas renderer");
+          });
+          term.loadAddon(webglAddon);
+        } catch (e) {
+          console.warn("[Terminal] WebGL renderer not supported, using canvas renderer", e);
+        }
+      }).catch(() => {
+        console.warn("[Terminal] WebglAddon not available");
+      });
+    }
+    setTerminal(term);
+    const performFit = () => {
+      if (!fitAddonRef.current || !terminalRef.current || !term || !isVisibleRef.current) {
+        return;
+      }
+      fitAddonRef.current.fit();
+      if (isScrollLockedRef.current) {
+        requestAnimationFrame(() => {
+          term.scrollToBottom();
+        });
+      }
+    };
+    const handleResize = () => {
+      if (resizeTimeoutRef.current) {
+        clearTimeout(resizeTimeoutRef.current);
+      }
+      resizeTimeoutRef.current = setTimeout(() => {
+        performFit();
+      }, 100);
+    };
+    const resizeObserver = new ResizeObserver(() => {
+      handleResize();
+    });
+    if (terminalRef.current) {
+      resizeObserver.observe(terminalRef.current);
+    }
+    performFit();
+    return () => {
+      resizeObserver.disconnect();
+      scrollDisposable.dispose();
+      if (resizeTimeoutRef.current) {
+        clearTimeout(resizeTimeoutRef.current);
+      }
+      term.dispose();
+    };
+  }, [theme, onLinkClick, cursorBlink, cursorStyle, scrollback, fontSize, fontFamily, enableSearch, enableWebLinks, enableUnicode11, enableWebGL]);
+  useEffect(() => {
+    if (!terminal || !onReady) {
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      onReady(terminal.cols, terminal.rows);
+    }, 100);
+    return () => {
+      clearTimeout(timeoutId);
+    };
+  }, [terminal, onReady]);
+  useEffect(() => {
+    if (!terminal || !onData) {
+      return;
+    }
+    const disposable = terminal.onData((data) => {
+      onData(data);
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }, [terminal, onData]);
+  useEffect(() => {
+    if (!terminal || !onResize)
+      return;
+    const disposable = terminal.onResize((size) => {
+      onResize(size.cols, size.rows);
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }, [terminal, onResize]);
+  useEffect(() => {
+    const terminalElement = terminalRef.current;
+    if (!terminalElement)
+      return;
+    const handleKeyDown = (e) => {
+      if (e.key === " " || e.key === "Space") {
+        e.stopPropagation();
+      }
+    };
+    terminalElement.addEventListener("keydown", handleKeyDown, true);
+    return () => {
+      terminalElement.removeEventListener("keydown", handleKeyDown, true);
+    };
+  }, []);
+  useEffect(() => {
+    if (terminal && autoFocus && isVisible) {
+      setTimeout(() => {
+        terminal.focus();
+      }, 50);
+    }
+  }, [terminal, autoFocus, isVisible]);
+  useEffect(() => {
+    if (terminal && isVisible && fitAddonRef.current) {
+      setTimeout(() => {
+        fitAddonRef.current?.fit();
+        if (isScrollLockedRef.current) {
+          terminal.scrollToBottom();
+        }
+      }, 50);
+    }
+  }, [isVisible, terminal]);
+  const handleDestroy = () => {
+    if (onDestroy) {
+      const confirmed = window.confirm("Are you sure you want to close this terminal session? This will terminate any running processes.");
+      if (confirmed) {
+        onDestroy();
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", {
+    className,
+    style: {
+      display: "flex",
+      flexDirection: "column",
+      height: "100%",
+      width: "100%",
+      backgroundColor: theme.colors.background
+    },
+    children: [
+      !hideHeader && /* @__PURE__ */ jsxs("div", {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "space-between",
+          padding: "8px 16px",
+          borderBottom: `1px solid ${theme.colors.border}`,
+          backgroundColor: theme.colors.backgroundSecondary || theme.colors.background
+        },
+        children: [
+          /* @__PURE__ */ jsxs("div", {
+            style: { display: "flex", alignItems: "center", gap: "8px" },
+            children: [
+              /* @__PURE__ */ jsx(TerminalIcon, {
+                size: 16,
+                color: theme.colors.text
+              }),
+              /* @__PURE__ */ jsx("span", {
+                style: {
+                  fontSize: "14px",
+                  color: theme.colors.text,
+                  fontWeight: "500"
+                },
+                children: headerTitle
+              }),
+              headerSubtitle && /* @__PURE__ */ jsx("span", {
+                style: {
+                  fontSize: "12px",
+                  color: theme.colors.textSecondary
+                },
+                children: headerSubtitle
+              }),
+              headerBadge && /* @__PURE__ */ jsxs(Fragment, {
+                children: [
+                  /* @__PURE__ */ jsx("span", {
+                    style: {
+                      fontSize: "12px",
+                      color: theme.colors.textSecondary
+                    },
+                    children: "•"
+                  }),
+                  /* @__PURE__ */ jsx("span", {
+                    style: {
+                      fontSize: "12px",
+                      color: headerBadge.color || theme.colors.primary
+                    },
+                    children: headerBadge.label
+                  })
+                ]
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsxs("div", {
+            style: { display: "flex", gap: "8px" },
+            children: [
+              onPopOut && /* @__PURE__ */ jsx("button", {
+                type: "button",
+                "aria-label": "Pop out terminal to new window",
+                onClick: onPopOut,
+                style: {
+                  padding: "4px",
+                  backgroundColor: "transparent",
+                  border: "none",
+                  cursor: "pointer",
+                  color: theme.colors.textSecondary,
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  borderRadius: "4px",
+                  transition: "all 0.2s"
+                },
+                onMouseEnter: (e) => {
+                  e.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
+                  e.currentTarget.style.color = theme.colors.primary;
+                },
+                onMouseLeave: (e) => {
+                  e.currentTarget.style.backgroundColor = "transparent";
+                  e.currentTarget.style.color = theme.colors.textSecondary;
+                },
+                title: "Open terminal in new window",
+                children: /* @__PURE__ */ jsx(ExternalLink, {
+                  size: 16
+                })
+              }),
+              onClose && /* @__PURE__ */ jsx("button", {
+                type: "button",
+                "aria-label": "Hide terminal",
+                onClick: onClose,
+                style: {
+                  padding: "4px",
+                  backgroundColor: "transparent",
+                  border: "none",
+                  cursor: "pointer",
+                  color: theme.colors.textSecondary,
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  borderRadius: "4px",
+                  transition: "all 0.2s"
+                },
+                onMouseEnter: (e) => {
+                  e.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
+                  e.currentTarget.style.color = theme.colors.text;
+                },
+                onMouseLeave: (e) => {
+                  e.currentTarget.style.backgroundColor = "transparent";
+                  e.currentTarget.style.color = theme.colors.textSecondary;
+                },
+                title: "Hide terminal (keeps session running)",
+                children: /* @__PURE__ */ jsx(ChevronDown, {
+                  size: 16
+                })
+              }),
+              onDestroy && /* @__PURE__ */ jsx("button", {
+                type: "button",
+                "aria-label": "Close terminal session",
+                onClick: handleDestroy,
+                style: {
+                  padding: "4px",
+                  backgroundColor: "transparent",
+                  border: "none",
+                  cursor: "pointer",
+                  color: theme.colors.textSecondary,
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  borderRadius: "4px",
+                  transition: "all 0.2s"
+                },
+                onMouseEnter: (e) => {
+                  e.currentTarget.style.backgroundColor = "#ff4444";
+                  e.currentTarget.style.color = "#ffffff";
+                },
+                onMouseLeave: (e) => {
+                  e.currentTarget.style.backgroundColor = "transparent";
+                  e.currentTarget.style.color = theme.colors.textSecondary;
+                },
+                title: "Close terminal session (terminate process)",
+                children: /* @__PURE__ */ jsx(X, {
+                  size: 16
+                })
+              })
+            ]
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx("div", {
+        ref: terminalRef,
+        className: `terminal-container-fix ${scrollbarStyle === "hidden" ? "hide-scrollbar" : scrollbarStyle === "thin" ? "thin-scrollbar" : scrollbarStyle === "auto-hide" ? "auto-hide-scrollbar" : ""}`,
+        style: {
+          flex: 1,
+          overflow: "hidden",
+          position: "relative",
+          width: "100%",
+          height: "100%",
+          minHeight: 0
+        },
+        children: overlayState && /* @__PURE__ */ jsxs("div", {
+          style: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0,
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            backgroundColor: theme.colors.background,
+            opacity: overlayState.opacity ?? 1,
+            gap: "16px",
+            padding: "32px",
+            zIndex: 10
+          },
+          children: [
+            /* @__PURE__ */ jsx(Monitor, {
+              size: 48,
+              color: theme.colors.textSecondary
+            }),
+            /* @__PURE__ */ jsx("div", {
+              style: {
+                fontSize: "16px",
+                fontWeight: "500",
+                color: theme.colors.text,
+                textAlign: "center"
+              },
+              children: overlayState.message
+            }),
+            overlayState.subtitle && /* @__PURE__ */ jsx("div", {
+              style: {
+                fontSize: "14px",
+                color: theme.colors.textSecondary,
+                textAlign: "center",
+                maxWidth: "400px"
+              },
+              children: overlayState.subtitle
+            }),
+            overlayState.actions && overlayState.actions.length > 0 && /* @__PURE__ */ jsx("div", {
+              style: {
+                display: "flex",
+                gap: "12px",
+                marginTop: "8px"
+              },
+              children: overlayState.actions.map((action) => /* @__PURE__ */ jsxs("button", {
+                type: "button",
+                onClick: action.onClick,
+                style: {
+                  padding: "8px 16px",
+                  backgroundColor: action.primary ? theme.colors.primary : "transparent",
+                  color: action.primary ? "#ffffff" : theme.colors.text,
+                  border: action.primary ? "none" : `1px solid ${theme.colors.border}`,
+                  borderRadius: "6px",
+                  cursor: "pointer",
+                  fontSize: "14px",
+                  fontWeight: "500",
+                  display: "flex",
+                  alignItems: "center",
+                  gap: "8px",
+                  transition: "all 0.2s"
+                },
+                onMouseEnter: (e) => {
+                  if (action.primary) {
+                    e.currentTarget.style.opacity = "0.8";
+                  } else {
+                    e.currentTarget.style.backgroundColor = theme.colors.backgroundSecondary;
+                  }
+                },
+                onMouseLeave: (e) => {
+                  if (action.primary) {
+                    e.currentTarget.style.opacity = "1";
+                  } else {
+                    e.currentTarget.style.backgroundColor = "transparent";
+                  }
+                },
+                children: [
+                  action.icon,
+                  action.label
+                ]
+              }, action.label))
+            })
+          ]
+        })
+      })
+    ]
+  });
+});
+ThemedTerminal.displayName = "ThemedTerminal";
+// src/components/ThemedTerminalWithProvider.tsx
+import { useTheme } from "@principal-ade/industry-theme";
+import { forwardRef as forwardRef2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ThemedTerminalWithProvider = forwardRef2((props, ref) => {
+  const { theme } = useTheme();
+  return /* @__PURE__ */ jsx2(ThemedTerminal, {
+    ref,
+    theme,
+    ...props
+  });
+});
+ThemedTerminalWithProvider.displayName = "ThemedTerminalWithProvider";
+// src/hooks/useThemedTerminal.ts
+import { useTheme as useTheme2 } from "@principal-ade/industry-theme";
+import { useMemo } from "react";
+function useThemedTerminal() {
+  const { theme } = useTheme2();
+  const terminalOptions = useMemo(() => ({
+    cursorBlink: true,
+    fontSize: 14,
+    fontFamily: 'Menlo, Monaco, "Courier New", monospace',
+    theme: createTerminalTheme(theme),
+    scrollback: 1e4,
+    allowProposedApi: true,
+    lineHeight: 1,
+    letterSpacing: 0,
+    rightClickSelectsWord: true,
+    smoothScrollDuration: 0,
+    drawBoldTextInBrightColors: true,
+    windowsMode: false,
+    fontWeight: "normal",
+    fontWeightBold: "bold"
+  }), [theme]);
+  const getTerminalOptions = (overrides) => {
+    return {
+      ...terminalOptions,
+      ...overrides,
+      theme: overrides?.theme ? { ...terminalOptions.theme, ...overrides.theme } : terminalOptions.theme
+    };
+  };
+  const getCSSVariables = () => getTerminalCSSVariables(theme);
+  return {
+    theme,
+    getTerminalOptions,
+    getCSSVariables
+  };
+}
+// src/panels/TerminalPanel.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { Lock, Unlock, ArrowDown } from "lucide-react";
+import { useTheme as useTheme3 } from "@principal-ade/industry-theme";
+
+// src/panel-types/index.ts
+function getTerminalSessions(context) {
+  const slice = context.getSlice("terminal");
+  return slice?.data ?? [];
+}
+function getTerminalSession(context, sessionId) {
+  const sessions = getTerminalSessions(context);
+  return sessions.find((s) => s.id === sessionId);
+}
+function isTerminalLoading(context) {
+  return context.isSliceLoading("terminal");
+}
+function getRepositoryPath(context) {
+  return context.currentScope.repository?.path ?? null;
+}
+function getWorkspacePath(context) {
+  return context.currentScope.workspace?.path ?? null;
+}
+function getTerminalDirectory(context, terminalScope = "repository") {
+  switch (terminalScope) {
+    case "workspace":
+      return getWorkspacePath(context);
+    case "repository":
+      return getRepositoryPath(context) ?? getWorkspacePath(context);
+    default:
+      return getRepositoryPath(context) ?? getWorkspacePath(context);
+  }
+}
+function getTerminalSlice(context) {
+  return context.getSlice("terminal");
+}
+
+// src/panels/TerminalPanel.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var TerminalPanel = ({
+  context,
+  actions,
+  events: _events,
+  terminalScope = "repository"
+}) => {
+  const { theme } = useTheme3();
+  const [sessionId, setSessionId] = useState2(null);
+  const [error, setError] = useState2(null);
+  const [isInitializing, setIsInitializing] = useState2(true);
+  const [usingMessagePort, setUsingMessagePort] = useState2(false);
+  const [scrollPosition, setScrollPosition] = useState2({
+    isAtTop: false,
+    isAtBottom: true,
+    isScrollLocked: false
+  });
+  const terminalRef = useRef2(null);
+  const dataPortRef = useRef2(null);
+  const terminalDirectory = getTerminalDirectory(context, terminalScope);
+  const pendingSessionIdRef = useRef2(null);
+  useEffect2(() => {
+    let mounted = true;
+    let unsubscribePortReady = null;
+    const initTerminal = async () => {
+      try {
+        if (!actions.createTerminalSession) {
+          throw new Error("Terminal actions not available. Host must provide createTerminalSession action.");
+        }
+        if (!actions.onTerminalPortReady) {
+          throw new Error("MessagePort support not available. Host must provide onTerminalPortReady action.");
+        }
+        unsubscribePortReady = actions.onTerminalPortReady((data, port) => {
+          if (data.sessionId === pendingSessionIdRef.current || data.sessionId === sessionId) {
+            console.info(`[TerminalPanel] Received MessagePort for session ${data.sessionId}`);
+            dataPortRef.current = port;
+            if (typeof port.start === "function") {
+              port.start();
+            }
+            if (mounted) {
+              setUsingMessagePort(true);
+            }
+          }
+        });
+        const id = await actions.createTerminalSession({
+          cwd: terminalDirectory || undefined
+        });
+        pendingSessionIdRef.current = id;
+        if (actions.claimTerminalOwnership) {
+          await actions.claimTerminalOwnership(id);
+        }
+        if (mounted) {
+          setSessionId(id);
+          setIsInitializing(false);
+        }
+      } catch (err) {
+        if (mounted) {
+          setError(err instanceof Error ? err.message : String(err));
+          setIsInitializing(false);
+        }
+      }
+    };
+    initTerminal();
+    return () => {
+      mounted = false;
+      if (unsubscribePortReady) {
+        unsubscribePortReady();
+      }
+      if (pendingSessionIdRef.current && actions.destroyTerminalSession) {
+        actions.destroyTerminalSession(pendingSessionIdRef.current);
+      }
+      if (dataPortRef.current) {
+        if (typeof dataPortRef.current.close === "function") {
+          dataPortRef.current.close();
+        }
+        dataPortRef.current = null;
+      }
+    };
+  }, []);
+  useEffect2(() => {
+    if (usingMessagePort)
+      return;
+    if (!sessionId)
+      return;
+    const timeout = setTimeout(() => {
+      if (!dataPortRef.current) {
+        console.error("[TerminalPanel] MessagePort not received after timeout - terminal data will not be displayed");
+        setError("MessagePort not available. Terminal data streaming requires MessagePort support from the host.");
+      }
+    }, 5000);
+    return () => clearTimeout(timeout);
+  }, [sessionId, usingMessagePort]);
+  useEffect2(() => {
+    if (!usingMessagePort || !dataPortRef.current)
+      return;
+    const port = dataPortRef.current;
+    let lastWriteTime = 0;
+    let cursorMovedToHome = false;
+    let autoScrollTimeout = null;
+    const handleMessage = (event) => {
+      if (event.data?.type === "DATA" && terminalRef.current) {
+        const data = event.data.data;
+        if (data.includes("\x1B[H")) {
+          cursorMovedToHome = true;
+          lastWriteTime = Date.now();
+        }
+        terminalRef.current.write(data);
+        if (cursorMovedToHome && scrollPosition.isScrollLocked) {
+          if (autoScrollTimeout) {
+            clearTimeout(autoScrollTimeout);
+          }
+          autoScrollTimeout = setTimeout(() => {
+            const now = Date.now();
+            const timeSinceLastWrite = now - lastWriteTime;
+            if (timeSinceLastWrite >= 100 && cursorMovedToHome && terminalRef.current) {
+              terminalRef.current.write("\x1B[9999;1H");
+              cursorMovedToHome = false;
+            }
+          }, 100);
+        }
+        lastWriteTime = Date.now();
+      }
+    };
+    port.onmessage = handleMessage;
+    console.info("[TerminalPanel] Listening on MessagePort for terminal data");
+    return () => {
+      port.onmessage = null;
+      if (autoScrollTimeout) {
+        clearTimeout(autoScrollTimeout);
+      }
+    };
+  }, [usingMessagePort, scrollPosition.isScrollLocked]);
+  const handleTerminalData = (data) => {
+    if (sessionId && actions.writeToTerminal) {
+      actions.writeToTerminal(sessionId, data);
+    }
+  };
+  const hasNotifiedPtyRef = useRef2(false);
+  const handleTerminalResize = (cols, rows) => {
+    if (sessionId && actions.resizeTerminal) {
+      const isInitialNotification = !hasNotifiedPtyRef.current;
+      actions.resizeTerminal(sessionId, cols, rows);
+      if (isInitialNotification && actions.writeToTerminal) {
+        setTimeout(() => {
+          actions.writeToTerminal(sessionId, "\f");
+        }, 50);
+      }
+      hasNotifiedPtyRef.current = true;
+    }
+  };
+  useEffect2(() => {
+    hasNotifiedPtyRef.current = false;
+  }, [sessionId]);
+  const handleScrollPositionChange = (position) => {
+    setScrollPosition(position);
+  };
+  const sessionInfo = sessionId ? getTerminalSession(context, sessionId) : undefined;
+  if (error) {
+    return /* @__PURE__ */ jsxs2("div", {
+      style: {
+        padding: "20px",
+        color: "#ef4444",
+        backgroundColor: "#1a1a1a",
+        height: "100%",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        flexDirection: "column",
+        gap: "10px"
+      },
+      children: [
+        /* @__PURE__ */ jsx3("div", {
+          style: { fontSize: "16px", fontWeight: "bold" },
+          children: "Terminal Error"
+        }),
+        /* @__PURE__ */ jsx3("div", {
+          style: { fontSize: "14px", opacity: 0.8 },
+          children: error
+        })
+      ]
+    });
+  }
+  if (isInitializing || !sessionId) {
+    return /* @__PURE__ */ jsx3("div", {
+      style: {
+        padding: "20px",
+        color: "#a0a0a0",
+        backgroundColor: "#1a1a1a",
+        height: "100%",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center"
+      },
+      children: "Initializing terminal..."
+    });
+  }
+  const handleScrollToBottom = () => {
+    terminalRef.current?.scrollToBottom();
+  };
+  const handleToggleScrollLock = () => {
+    if (scrollPosition.isScrollLocked) {
+      const terminal = terminalRef.current?.getTerminal();
+      if (terminal) {
+        terminal.scrollLines(-1);
+      }
+    } else {
+      terminalRef.current?.scrollToBottom();
+    }
+  };
+  return /* @__PURE__ */ jsxs2("div", {
+    style: { height: "100%", width: "100%", display: "flex", flexDirection: "column" },
+    children: [
+      /* @__PURE__ */ jsxs2("div", {
+        style: {
+          display: "flex",
+          gap: "8px",
+          padding: "8px 12px",
+          backgroundColor: theme.colors.backgroundSecondary,
+          borderBottom: `1px solid ${theme.colors.border}`,
+          alignItems: "center"
+        },
+        children: [
+          /* @__PURE__ */ jsxs2("span", {
+            style: {
+              fontSize: "12px",
+              color: theme.colors.textSecondary,
+              marginRight: "auto",
+              fontFamily: theme.fonts.monospace
+            },
+            children: [
+              sessionInfo?.cwd || "Terminal",
+              " • ",
+              sessionInfo?.shell
+            ]
+          }),
+          /* @__PURE__ */ jsxs2("button", {
+            onClick: handleToggleScrollLock,
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: "4px",
+              fontSize: "11px",
+              padding: "4px 8px",
+              borderRadius: "4px",
+              backgroundColor: scrollPosition.isScrollLocked ? `${theme.colors.success}22` : `${theme.colors.warning}22`,
+              color: scrollPosition.isScrollLocked ? theme.colors.success : theme.colors.warning,
+              border: `1px solid ${scrollPosition.isScrollLocked ? `${theme.colors.success}44` : `${theme.colors.warning}44`}`,
+              cursor: "pointer",
+              transition: "opacity 0.2s"
+            },
+            onMouseEnter: (e) => e.currentTarget.style.opacity = "0.8",
+            onMouseLeave: (e) => e.currentTarget.style.opacity = "1",
+            title: scrollPosition.isScrollLocked ? "Click to unlock scroll" : "Click to lock scroll to bottom",
+            children: [
+              scrollPosition.isScrollLocked ? /* @__PURE__ */ jsx3(Lock, {
+                size: 12
+              }) : /* @__PURE__ */ jsx3(Unlock, {
+                size: 12
+              }),
+              /* @__PURE__ */ jsx3("span", {
+                children: scrollPosition.isScrollLocked ? "Locked" : "Unlocked"
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsxs2("button", {
+            onClick: handleScrollToBottom,
+            disabled: scrollPosition.isAtBottom,
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: "4px",
+              fontSize: "11px",
+              padding: "4px 10px",
+              borderRadius: "4px",
+              backgroundColor: scrollPosition.isAtBottom ? theme.colors.backgroundHover : theme.colors.accent,
+              color: scrollPosition.isAtBottom ? theme.colors.textTertiary : theme.colors.text,
+              border: `1px solid ${theme.colors.border}`,
+              cursor: scrollPosition.isAtBottom ? "not-allowed" : "pointer",
+              transition: "opacity 0.2s",
+              opacity: scrollPosition.isAtBottom ? 0.5 : 1
+            },
+            onMouseEnter: (e) => !scrollPosition.isAtBottom && (e.currentTarget.style.opacity = "0.8"),
+            onMouseLeave: (e) => !scrollPosition.isAtBottom && (e.currentTarget.style.opacity = "1"),
+            title: "Scroll to bottom and lock",
+            children: [
+              /* @__PURE__ */ jsx3(ArrowDown, {
+                size: 12
+              }),
+              /* @__PURE__ */ jsx3("span", {
+                children: "Bottom"
+              })
+            ]
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx3("div", {
+        style: { flex: 1 },
+        children: /* @__PURE__ */ jsx3(ThemedTerminalWithProvider, {
+          ref: terminalRef,
+          onData: handleTerminalData,
+          onResize: handleTerminalResize,
+          onScrollPositionChange: handleScrollPositionChange,
+          hideHeader: true,
+          autoFocus: true,
+          convertEol: true,
+          cursorBlink: true,
+          scrollback: 1e4,
+          enableWebGL: true,
+          enableUnicode11: true,
+          enableSearch: true,
+          enableWebLinks: true
+        })
+      })
+    ]
+  });
+};
+// src/panels/TabbedTerminalPanel.tsx
+import React, {
+  useState as useState3,
+  useCallback,
+  useEffect as useEffect3,
+  useRef as useRef3
+} from "react";
+import { Terminal as TerminalIcon2, X as X2, Plus, Lock as Lock2, Unlock as Unlock2, ArrowDown as ArrowDown2, Box, Boxes } from "lucide-react";
+import { useTheme as useTheme4 } from "@principal-ade/industry-theme";
+import { jsx as jsx4, jsxs as jsxs3, Fragment as Fragment2 } from "react/jsx-runtime";
+var TerminalTabContentInner = ({ tab, sessionId, isActive, isVisible, actions, terminalContext, onSessionCreated, onScrollPositionChange, isForeign = false }, ref) => {
+  const terminalRef = useRef3(null);
+  const [localSessionId, setLocalSessionId] = useState3(sessionId);
+  const [isInitialized, setIsInitialized] = useState3(false);
+  const hasInitializedRef = useRef3(false);
+  const [scrollPosition, setScrollPosition] = useState3({
+    isAtTop: false,
+    isAtBottom: true,
+    isScrollLocked: false
+  });
+  const [shouldRenderTerminal, setShouldRenderTerminal] = useState3(true);
+  const [ownerWindowId, setOwnerWindowId] = useState3(null);
+  const needsRefreshOnResizeRef = useRef3(false);
+  const claimAndConnect = useCallback(async (targetSessionId, force = false) => {
+    try {
+      if (actions.claimTerminalOwnership) {
+        await actions.claimTerminalOwnership(targetSessionId, force);
+      }
+      if (force && actions.requestTerminalDataPort) {
+        await actions.requestTerminalDataPort(targetSessionId);
+      }
+      setShouldRenderTerminal(true);
+      setOwnerWindowId(null);
+      if (force) {
+        needsRefreshOnResizeRef.current = true;
+      }
+    } catch (error) {
+      console.error("[TerminalTabContent] Failed to claim ownership:", error);
+      throw error;
+    }
+  }, [actions]);
+  useEffect3(() => {
+    if (hasInitializedRef.current) {
+      return;
+    }
+    hasInitializedRef.current = true;
+    let mounted = true;
+    const initSession = async () => {
+      try {
+        if (sessionId) {
+          if (isForeign && actions.checkTerminalOwnership) {
+            const status = await actions.checkTerminalOwnership(sessionId);
+            if (status.ownedByWindowId && !status.ownedByThisWindow) {
+              setShouldRenderTerminal(false);
+              setOwnerWindowId(status.ownedByWindowId);
+            }
+          } else {
+            await claimAndConnect(sessionId);
+          }
+          setLocalSessionId(sessionId);
+          setIsInitialized(true);
+          return;
+        }
+        if (!actions.createTerminalSession) {
+          return;
+        }
+        const newSessionId = await actions.createTerminalSession({
+          cwd: tab.directory,
+          command: tab.command,
+          context: `${terminalContext}:${tab.id}`
+        });
+        if (!mounted)
+          return;
+        setLocalSessionId(newSessionId);
+        setIsInitialized(true);
+        onSessionCreated(tab.id, newSessionId);
+        await claimAndConnect(newSessionId);
+      } catch (error) {
+        console.error("[TerminalTabContent] Failed to create session:", error);
+      }
+    };
+    initSession();
+    return () => {
+      mounted = false;
+    };
+  }, []);
+  useEffect3(() => {
+    if (!localSessionId || !isInitialized || !shouldRenderTerminal) {
+      return;
+    }
+    if (!actions.onTerminalData) {
+      return;
+    }
+    const unsubscribe = actions.onTerminalData(localSessionId, (data) => {
+      if (terminalRef.current) {
+        terminalRef.current.write(data);
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [localSessionId, isInitialized, actions, shouldRenderTerminal]);
+  const handleData = useCallback((data) => {
+    if (localSessionId && actions.writeToTerminal) {
+      actions.writeToTerminal(localSessionId, data);
+    }
+  }, [localSessionId, actions]);
+  const handleResize = useCallback((cols, rows) => {
+    if (localSessionId && actions.resizeTerminal) {
+      actions.resizeTerminal(localSessionId, cols, rows);
+    }
+  }, [localSessionId, actions]);
+  const handleReady = useCallback((cols, rows) => {
+    if (localSessionId && actions.resizeTerminal) {
+      const shouldForce = needsRefreshOnResizeRef.current;
+      if (shouldForce) {
+        needsRefreshOnResizeRef.current = false;
+      }
+      actions.resizeTerminal(localSessionId, cols, rows, shouldForce);
+    }
+  }, [localSessionId, actions]);
+  useEffect3(() => {
+    if (!localSessionId || !actions.onOwnershipLost) {
+      return;
+    }
+    const unsubscribe = actions.onOwnershipLost((data) => {
+      if (data.sessionId === localSessionId) {
+        setShouldRenderTerminal(false);
+        setOwnerWindowId(data.newOwnerWindowId);
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [localSessionId, actions]);
+  const handleTakeControl = useCallback(async () => {
+    if (!localSessionId) {
+      return;
+    }
+    await claimAndConnect(localSessionId, true);
+  }, [localSessionId, claimAndConnect]);
+  const handleScrollPositionChange = useCallback((position) => {
+    setScrollPosition(position);
+    onScrollPositionChange?.(tab.id, position);
+  }, [tab.id, onScrollPositionChange]);
+  const handleScrollToBottom = useCallback(() => {
+    terminalRef.current?.scrollToBottom();
+  }, []);
+  const handleToggleScrollLock = useCallback(() => {
+    if (scrollPosition.isScrollLocked) {
+      const terminal = terminalRef.current?.getTerminal();
+      if (terminal) {
+        terminal.scrollLines(-1);
+      }
+    } else {
+      terminalRef.current?.scrollToBottom();
+    }
+  }, [scrollPosition.isScrollLocked]);
+  React.useImperativeHandle(ref, () => ({
+    scrollToBottom: handleScrollToBottom,
+    toggleScrollLock: handleToggleScrollLock
+  }), [handleScrollToBottom, handleToggleScrollLock]);
+  if (!isInitialized) {
+    return /* @__PURE__ */ jsx4("div", {
+      style: {
+        display: isActive ? "flex" : "none",
+        height: "100%",
+        alignItems: "center",
+        justifyContent: "center",
+        color: "#888"
+      },
+      children: "Initializing terminal..."
+    });
+  }
+  const overlayState = !shouldRenderTerminal ? {
+    message: "This terminal is active in another window",
+    subtitle: ownerWindowId ? `Window ID: ${ownerWindowId}` : "Another window owns this terminal session",
+    actions: [
+      {
+        label: "Take Control",
+        onClick: handleTakeControl,
+        primary: true
+      }
+    ],
+    opacity: 1
+  } : undefined;
+  return /* @__PURE__ */ jsx4("div", {
+    style: {
+      display: isActive ? "flex" : "none",
+      flexDirection: "column",
+      height: "100%",
+      width: "100%"
+    },
+    children: /* @__PURE__ */ jsx4(ThemedTerminalWithProvider, {
+      ref: terminalRef,
+      onData: shouldRenderTerminal ? handleData : undefined,
+      onResize: shouldRenderTerminal ? handleResize : undefined,
+      onReady: shouldRenderTerminal ? handleReady : undefined,
+      onScrollPositionChange: shouldRenderTerminal ? handleScrollPositionChange : undefined,
+      hideHeader: true,
+      autoFocus: isActive && shouldRenderTerminal,
+      isVisible: isVisible && isActive,
+      convertEol: true,
+      cursorBlink: shouldRenderTerminal,
+      scrollback: 1e4,
+      enableWebGL: true,
+      enableUnicode11: true,
+      enableSearch: true,
+      enableWebLinks: true,
+      overlayState
+    }, shouldRenderTerminal ? "active" : "overlay")
+  });
+};
+var TerminalTabContent = React.memo(React.forwardRef(TerminalTabContentInner));
+TerminalTabContent.displayName = "TerminalTabContent";
+var TabbedTerminalPanel = ({
+  context: _context,
+  actions,
+  events: _events,
+  terminalContext,
+  directory,
+  hideHeader = false,
+  isVisible = true,
+  onTabsChange,
+  initialTabs = [],
+  showAllTerminals = false,
+  onShowAllTerminalsChange
+}) => {
+  const { theme } = useTheme4();
+  const [ownedTabs, setOwnedTabs] = useState3(initialTabs);
+  const [foreignTabs, setForeignTabs] = useState3([]);
+  const [activeTabId, setActiveTabId] = useState3(null);
+  const [sessionIds, setSessionIds] = useState3(new Map);
+  const [hoveredTabId, setHoveredTabId] = useState3(null);
+  const [scrollPositions, setScrollPositions] = useState3(new Map);
+  const tabs = React.useMemo(() => {
+    const sortedForeignTabs = [...foreignTabs].sort((a, b) => a.label.localeCompare(b.label));
+    return [...ownedTabs, ...sortedForeignTabs];
+  }, [ownedTabs, foreignTabs]);
+  const tabRefsMap = useRef3(new Map);
+  const hasInitializedRef = useRef3(false);
+  const isCreatingTabRef = useRef3(false);
+  const headerRef = useRef3(null);
+  const [isCompact, setIsCompact] = useState3(false);
+  useEffect3(() => {
+    if (!headerRef.current)
+      return;
+    const observer = new ResizeObserver((entries) => {
+      const width = entries[0]?.contentRect.width ?? 0;
+      setIsCompact(width < 400);
+    });
+    observer.observe(headerRef.current);
+    return () => observer.disconnect();
+  }, []);
+  const handleTabScrollPositionChange = useCallback((tabId, position) => {
+    setScrollPositions((prev) => new Map(prev).set(tabId, position));
+  }, []);
+  const defaultScrollPosition = {
+    isAtTop: false,
+    isAtBottom: true,
+    isScrollLocked: false
+  };
+  const activeScrollPosition = activeTabId ? scrollPositions.get(activeTabId) ?? defaultScrollPosition : undefined;
+  const handleScrollToBottom = useCallback(() => {
+    if (activeTabId) {
+      tabRefsMap.current.get(activeTabId)?.scrollToBottom();
+    }
+  }, [activeTabId]);
+  const handleToggleScrollLock = useCallback(() => {
+    if (activeTabId) {
+      tabRefsMap.current.get(activeTabId)?.toggleScrollLock();
+    }
+  }, [activeTabId]);
+  const restoreOwnedSessions = useCallback(async () => {
+    try {
+      let sessions = [];
+      if (actions.listTerminalSessions) {
+        sessions = await actions.listTerminalSessions();
+      }
+      const ownedSessions = sessions.filter((session) => session.context?.startsWith(terminalContext));
+      if (ownedSessions.length > 0 && initialTabs.length === 0) {
+        const restoredTabs = [];
+        const restoredSessionIds = new Map;
+        ownedSessions.forEach((session, index) => {
+          const tabId = `tab-restored-${session.id}`;
+          const sessionCwd = session.cwd || directory;
+          const tab = {
+            id: tabId,
+            label: sessionCwd.split("/").pop() || sessionCwd,
+            directory: sessionCwd,
+            isActive: index === 0
+          };
+          restoredTabs.push(tab);
+          restoredSessionIds.set(tabId, session.id);
+        });
+        setOwnedTabs(restoredTabs);
+        setSessionIds(restoredSessionIds);
+        setActiveTabId(restoredTabs[0]?.id || null);
+        onTabsChange?.(restoredTabs);
+      } else if (initialTabs.length > 0) {
+        setOwnedTabs(initialTabs);
+        setActiveTabId(initialTabs.find((t) => t.isActive)?.id || initialTabs[0]?.id || null);
+      }
+    } catch (err) {
+      console.error("[TabbedTerminalPanel] Failed to restore owned sessions:", err);
+    }
+  }, [terminalContext, initialTabs, onTabsChange, actions, directory]);
+  const fetchForeignSessions = useCallback(async () => {
+    try {
+      if (!actions.listTerminalSessions) {
+        return;
+      }
+      const sessions = await actions.listTerminalSessions();
+      const foreignSessions = sessions.filter((session) => !session.context?.startsWith(terminalContext));
+      const foreignTabsList = [];
+      const newSessionIds = new Map;
+      foreignSessions.forEach((session) => {
+        const tabId = `tab-foreign-${session.id}`;
+        const sessionCwd = session.cwd || "/";
+        const tab = {
+          id: tabId,
+          label: sessionCwd.split("/").pop() || sessionCwd,
+          directory: sessionCwd,
+          isActive: false
+        };
+        foreignTabsList.push(tab);
+        newSessionIds.set(tabId, session.id);
+      });
+      setForeignTabs(foreignTabsList);
+      setSessionIds((prev) => {
+        const updated = new Map(prev);
+        newSessionIds.forEach((v, k) => updated.set(k, v));
+        return updated;
+      });
+    } catch (err) {
+      console.error("[TabbedTerminalPanel] Failed to fetch foreign sessions:", err);
+    }
+  }, [terminalContext, actions]);
+  const clearForeignTabs = useCallback(() => {
+    setForeignTabs((prevForeign) => {
+      const foreignTabIds = new Set(prevForeign.map((t) => t.id));
+      setSessionIds((prev) => {
+        const updated = new Map(prev);
+        foreignTabIds.forEach((id) => updated.delete(id));
+        return updated;
+      });
+      return [];
+    });
+  }, []);
+  useEffect3(() => {
+    if (hasInitializedRef.current)
+      return;
+    hasInitializedRef.current = true;
+    restoreOwnedSessions();
+  }, []);
+  useEffect3(() => {
+    if (showAllTerminals) {
+      fetchForeignSessions();
+    } else {
+      clearForeignTabs();
+    }
+  }, [showAllTerminals, fetchForeignSessions, clearForeignTabs]);
+  const switchTab = useCallback((tabId) => {
+    setOwnedTabs((prevTabs) => prevTabs.map((t) => ({
+      ...t,
+      isActive: t.id === tabId
+    })));
+    setForeignTabs((prevTabs) => prevTabs.map((t) => ({
+      ...t,
+      isActive: t.id === tabId
+    })));
+    setActiveTabId(tabId);
+  }, []);
+  const addNewTab = useCallback((label, command, targetDirectory) => {
+    const targetDir = targetDirectory || directory;
+    const directoryName = targetDir.split("/").pop() || targetDir;
+    const newTab = {
+      id: `tab-${Date.now()}`,
+      label: label || directoryName,
+      directory: targetDir,
+      command,
+      isActive: true
+    };
+    setOwnedTabs((prevTabs) => {
+      const updatedTabs = prevTabs.map((t) => ({ ...t, isActive: false }));
+      const newTabs = [...updatedTabs, newTab];
+      onTabsChange?.(newTabs);
+      return newTabs;
+    });
+    setForeignTabs((prevTabs) => prevTabs.map((t) => ({ ...t, isActive: false })));
+    setActiveTabId(newTab.id);
+  }, [directory, onTabsChange]);
+  const isForeignTab = useCallback((tabId) => {
+    return tabId.startsWith("tab-foreign-");
+  }, []);
+  const closeTab = useCallback(async (tabId) => {
+    const sessionId = sessionIds.get(tabId);
+    const isForeign = isForeignTab(tabId);
+    if (!isForeign && sessionId && actions.destroyTerminalSession) {
+      try {
+        await actions.destroyTerminalSession(sessionId);
+      } catch (err) {
+        console.error("[TabbedTerminalPanel] Failed to destroy session:", err);
+      }
+    }
+    setSessionIds((prev) => {
+      const newMap = new Map(prev);
+      newMap.delete(tabId);
+      return newMap;
+    });
+    const findNextActiveTab = (allTabs) => {
+      const remaining = allTabs.filter((t) => t.id !== tabId);
+      if (activeTabId === tabId && remaining.length > 0) {
+        const newActive = remaining[remaining.length - 1];
+        return newActive.id;
+      }
+      return remaining.length === 0 ? null : activeTabId;
+    };
+    if (isForeign) {
+      setForeignTabs((prevTabs) => {
+        const newTabs = prevTabs.filter((t) => t.id !== tabId);
+        const nextActiveId = findNextActiveTab([...ownedTabs, ...newTabs]);
+        if (nextActiveId !== activeTabId) {
+          setActiveTabId(nextActiveId);
+          if (nextActiveId) {
+            setOwnedTabs((owned) => owned.map((t) => ({ ...t, isActive: t.id === nextActiveId })));
+          }
+        }
+        return newTabs.map((t) => ({ ...t, isActive: t.id === nextActiveId }));
+      });
+    } else {
+      setOwnedTabs((prevTabs) => {
+        const newTabs = prevTabs.filter((t) => t.id !== tabId);
+        const nextActiveId = findNextActiveTab([...newTabs, ...foreignTabs]);
+        if (nextActiveId !== activeTabId) {
+          setActiveTabId(nextActiveId);
+          if (nextActiveId) {
+            setForeignTabs((foreign) => foreign.map((t) => ({ ...t, isActive: t.id === nextActiveId })));
+          }
+        }
+        onTabsChange?.(newTabs);
+        return newTabs.map((t) => ({ ...t, isActive: t.id === nextActiveId }));
+      });
+    }
+  }, [activeTabId, sessionIds, actions, onTabsChange, isForeignTab, ownedTabs, foreignTabs]);
+  const handleSessionCreated = useCallback((tabId, sessionId) => {
+    setSessionIds((prev) => new Map(prev).set(tabId, sessionId));
+  }, []);
+  const tabsRef = useRef3(tabs);
+  const activeTabIdRef = useRef3(activeTabId);
+  const addNewTabRef = useRef3(addNewTab);
+  const closeTabRef = useRef3(closeTab);
+  const switchTabRef = useRef3(switchTab);
+  useEffect3(() => {
+    tabsRef.current = tabs;
+    activeTabIdRef.current = activeTabId;
+    addNewTabRef.current = addNewTab;
+    closeTabRef.current = closeTab;
+    switchTabRef.current = switchTab;
+  }, [tabs, activeTabId, addNewTab, closeTab, switchTab]);
+  useEffect3(() => {
+    const handleKeyDown = (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === "t") {
+        e.preventDefault();
+        e.stopPropagation();
+        if (isCreatingTabRef.current)
+          return;
+        isCreatingTabRef.current = true;
+        addNewTabRef.current?.();
+        setTimeout(() => {
+          isCreatingTabRef.current = false;
+        }, 500);
+        return;
+      }
+      if ((e.metaKey || e.ctrlKey) && e.key === "w") {
+        const currentActiveTabId = activeTabIdRef.current;
+        const currentTabs = tabsRef.current;
+        if (currentActiveTabId && currentTabs.length > 0) {
+          e.preventDefault();
+          e.stopPropagation();
+          closeTabRef.current?.(currentActiveTabId);
+        }
+        return;
+      }
+      if ((e.metaKey || e.ctrlKey) && e.key >= "1" && e.key <= "9") {
+        e.preventDefault();
+        const currentTabs = tabsRef.current;
+        const keyNum = parseInt(e.key, 10);
+        const tabIndex = keyNum === 9 ? currentTabs.length - 1 : keyNum - 1;
+        if (tabIndex >= 0 && tabIndex < currentTabs.length) {
+          const targetTab = currentTabs[tabIndex];
+          if (targetTab) {
+            switchTabRef.current?.(targetTab.id);
+          }
+        }
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, []);
+  return /* @__PURE__ */ jsxs3("div", {
+    style: {
+      display: "flex",
+      flexDirection: "column",
+      height: "100%",
+      backgroundColor: theme.colors.background
+    },
+    children: [
+      !hideHeader && /* @__PURE__ */ jsxs3("div", {
+        ref: headerRef,
+        style: {
+          display: "flex",
+          alignItems: "stretch",
+          height: "41px",
+          flexShrink: 0,
+          boxSizing: "border-box"
+        },
+        children: [
+          /* @__PURE__ */ jsx4("div", {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: "4px",
+              padding: "0 8px",
+              borderRight: `1px solid ${theme.colors.border}`,
+              borderBottom: `1px solid ${theme.colors.border}`,
+              boxSizing: "border-box"
+            },
+            children: /* @__PURE__ */ jsx4("button", {
+              onClick: () => onShowAllTerminalsChange?.(!showAllTerminals),
+              style: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                width: "28px",
+                height: "28px",
+                border: "none",
+                borderRadius: "4px",
+                backgroundColor: showAllTerminals ? `${theme.colors.primary}22` : "transparent",
+                cursor: "pointer",
+                color: showAllTerminals ? theme.colors.primary : theme.colors.textSecondary
+              },
+              onMouseEnter: (e) => {
+                if (!showAllTerminals) {
+                  e.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
+                }
+              },
+              onMouseLeave: (e) => {
+                if (!showAllTerminals) {
+                  e.currentTarget.style.backgroundColor = "transparent";
+                }
+              },
+              title: showAllTerminals ? "Showing all terminals (click to filter by context)" : "Show all terminals",
+              children: showAllTerminals ? /* @__PURE__ */ jsx4(Boxes, {
+                size: 14
+              }) : /* @__PURE__ */ jsx4(Box, {
+                size: 14
+              })
+            })
+          }),
+          /* @__PURE__ */ jsx4("div", {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              flex: 1,
+              overflow: "hidden",
+              borderBottom: `1px solid ${theme.colors.border}`,
+              boxSizing: "border-box"
+            },
+            children: tabs.map((tab) => /* @__PURE__ */ jsxs3("div", {
+              onClick: (e) => {
+                e.stopPropagation();
+                switchTab(tab.id);
+              },
+              onMouseEnter: () => setHoveredTabId(tab.id),
+              onMouseLeave: () => setHoveredTabId(null),
+              style: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                gap: "6px",
+                padding: "6px 8px",
+                backgroundColor: tab.isActive ? theme.colors.background : theme.colors.backgroundSecondary,
+                borderBottom: `1px solid ${theme.colors.border}`,
+                cursor: "pointer",
+                fontSize: theme.fontSizes[1],
+                fontWeight: tab.isActive ? theme.fontWeights.semibold : theme.fontWeights.body,
+                fontFamily: theme.fonts.body,
+                color: tab.isActive ? theme.colors.text : theme.colors.textSecondary,
+                whiteSpace: "nowrap",
+                transition: "all 0.2s",
+                flex: 1,
+                minWidth: 0,
+                height: "100%",
+                position: "relative",
+                boxSizing: "border-box"
+              },
+              children: [
+                hoveredTabId === tab.id && /* @__PURE__ */ jsx4("button", {
+                  onClick: (e) => {
+                    e.stopPropagation();
+                    closeTab(tab.id);
+                  },
+                  style: {
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    width: "16px",
+                    height: "16px",
+                    borderRadius: "3px",
+                    border: "none",
+                    backgroundColor: "transparent",
+                    cursor: "pointer",
+                    color: theme.colors.textSecondary,
+                    padding: 0,
+                    position: "absolute",
+                    left: "8px"
+                  },
+                  onMouseEnter: (e) => {
+                    e.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
+                  },
+                  onMouseLeave: (e) => {
+                    e.currentTarget.style.backgroundColor = "transparent";
+                  },
+                  children: /* @__PURE__ */ jsx4(X2, {
+                    size: 12
+                  })
+                }),
+                /* @__PURE__ */ jsx4("span", {
+                  title: tab.directory,
+                  children: tab.label
+                })
+              ]
+            }, tab.id))
+          }),
+          /* @__PURE__ */ jsxs3("div", {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: "4px",
+              padding: "0 8px",
+              borderLeft: `1px solid ${theme.colors.border}`,
+              borderBottom: `1px solid ${theme.colors.border}`,
+              boxSizing: "border-box"
+            },
+            children: [
+              activeTabId && activeScrollPosition && /* @__PURE__ */ jsxs3(Fragment2, {
+                children: [
+                  /* @__PURE__ */ jsxs3("button", {
+                    onClick: handleToggleScrollLock,
+                    style: {
+                      display: "flex",
+                      alignItems: "center",
+                      gap: "4px",
+                      fontSize: "11px",
+                      padding: isCompact ? "4px 6px" : "4px 8px",
+                      borderRadius: "4px",
+                      backgroundColor: activeScrollPosition.isScrollLocked ? `${theme.colors.success}22` : `${theme.colors.warning}22`,
+                      color: activeScrollPosition.isScrollLocked ? theme.colors.success : theme.colors.warning,
+                      border: `1px solid ${activeScrollPosition.isScrollLocked ? `${theme.colors.success}44` : `${theme.colors.warning}44`}`,
+                      cursor: "pointer",
+                      transition: "opacity 0.2s"
+                    },
+                    onMouseEnter: (e) => e.currentTarget.style.opacity = "0.8",
+                    onMouseLeave: (e) => e.currentTarget.style.opacity = "1",
+                    title: activeScrollPosition.isScrollLocked ? "Click to unlock scroll" : "Click to lock scroll to bottom",
+                    children: [
+                      activeScrollPosition.isScrollLocked ? /* @__PURE__ */ jsx4(Lock2, {
+                        size: 12
+                      }) : /* @__PURE__ */ jsx4(Unlock2, {
+                        size: 12
+                      }),
+                      !isCompact && /* @__PURE__ */ jsx4("span", {
+                        children: activeScrollPosition.isScrollLocked ? "Locked" : "Unlocked"
+                      })
+                    ]
+                  }),
+                  /* @__PURE__ */ jsxs3("button", {
+                    onClick: handleScrollToBottom,
+                    disabled: activeScrollPosition.isAtBottom,
+                    style: {
+                      display: "flex",
+                      alignItems: "center",
+                      gap: "4px",
+                      fontSize: "11px",
+                      padding: isCompact ? "4px 6px" : "4px 8px",
+                      borderRadius: "4px",
+                      backgroundColor: activeScrollPosition.isAtBottom ? theme.colors.backgroundHover : theme.colors.accent,
+                      color: activeScrollPosition.isAtBottom ? theme.colors.textTertiary : theme.colors.text,
+                      border: `1px solid ${theme.colors.border}`,
+                      cursor: activeScrollPosition.isAtBottom ? "not-allowed" : "pointer",
+                      transition: "opacity 0.2s",
+                      opacity: activeScrollPosition.isAtBottom ? 0.5 : 1
+                    },
+                    onMouseEnter: (e) => !activeScrollPosition.isAtBottom && (e.currentTarget.style.opacity = "0.8"),
+                    onMouseLeave: (e) => !activeScrollPosition.isAtBottom && (e.currentTarget.style.opacity = "1"),
+                    title: "Scroll to bottom and lock",
+                    children: [
+                      /* @__PURE__ */ jsx4(ArrowDown2, {
+                        size: 12
+                      }),
+                      !isCompact && /* @__PURE__ */ jsx4("span", {
+                        children: "Bottom"
+                      })
+                    ]
+                  })
+                ]
+              }),
+              /* @__PURE__ */ jsx4("button", {
+                onClick: () => addNewTab(),
+                style: {
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  width: "28px",
+                  height: "28px",
+                  border: "none",
+                  borderRadius: "4px",
+                  backgroundColor: "transparent",
+                  cursor: "pointer",
+                  color: theme.colors.textSecondary
+                },
+                onMouseEnter: (e) => {
+                  e.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
+                },
+                onMouseLeave: (e) => {
+                  e.currentTarget.style.backgroundColor = "transparent";
+                },
+                title: "New terminal (Cmd+T)",
+                children: /* @__PURE__ */ jsx4(Plus, {
+                  size: 14
+                })
+              })
+            ]
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsxs3("div", {
+        style: {
+          flex: 1,
+          display: "flex",
+          flexDirection: "column",
+          overflow: "hidden",
+          width: "100%",
+          minHeight: 0
+        },
+        children: [
+          tabs.map((tab) => /* @__PURE__ */ jsx4(TerminalTabContent, {
+            ref: (ref) => {
+              if (ref) {
+                tabRefsMap.current.set(tab.id, ref);
+              } else {
+                tabRefsMap.current.delete(tab.id);
+              }
+            },
+            tab,
+            sessionId: sessionIds.get(tab.id) || null,
+            isActive: tab.id === activeTabId,
+            isVisible,
+            actions,
+            terminalContext,
+            onSessionCreated: handleSessionCreated,
+            onScrollPositionChange: handleTabScrollPositionChange,
+            isForeign: tab.id.startsWith("tab-foreign-")
+          }, tab.id)),
+          tabs.length === 0 && /* @__PURE__ */ jsxs3("div", {
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              alignItems: "center",
+              justifyContent: "center",
+              height: "100%",
+              color: theme.colors.textSecondary
+            },
+            children: [
+              /* @__PURE__ */ jsx4(TerminalIcon2, {
+                size: 32,
+                style: { opacity: 0.5, marginBottom: "16px" }
+              }),
+              /* @__PURE__ */ jsx4("p", {
+                children: "No terminal sessions"
+              }),
+              /* @__PURE__ */ jsx4("button", {
+                onClick: () => addNewTab(),
+                style: {
+                  marginTop: "16px",
+                  padding: "8px 16px",
+                  backgroundColor: theme.colors.primary,
+                  color: theme.colors.background,
+                  border: "none",
+                  borderRadius: "4px",
+                  cursor: "pointer",
+                  fontSize: theme.fontSizes[1],
+                  fontFamily: theme.fonts.body
+                },
+                children: "New Terminal"
+              })
+            ]
+          })
+        ]
+      })
+    ]
+  });
+};
+TabbedTerminalPanel.displayName = "TabbedTerminalPanel";
+// src/panel-exports.ts
+var panels = [
+  {
+    metadata: {
+      id: "com.principal.terminal",
+      name: "Terminal",
+      icon: "⚡",
+      version: "0.1.0",
+      author: "Principal",
+      description: "Integrated terminal emulator with industry theming",
+      slices: ["terminal"]
+    },
+    component: TerminalPanel,
+    onMount: async (context) => {
+      console.log("Terminal Panel mounted for repository:", context.currentScope.repository?.path);
+      if (!context.hasSlice("terminal")) {
+        console.warn("Terminal data slice not available in context");
+      }
+    },
+    onUnmount: async (_context) => {
+      console.log("Terminal Panel unmounting");
+    }
+  }
+];
+var onPackageLoad = async () => {
+  console.log("Panel package loaded - Terminal Panel Extension");
+};
+var onPackageUnload = async () => {
+  console.log("Panel package unloading - Terminal Panel Extension");
+};
+export {
+  useThemedTerminal,
+  panels,
+  onPackageUnload,
+  onPackageLoad,
+  isTerminalLoading,
+  getWorkspacePath,
+  getTerminalSlice,
+  getTerminalSessions,
+  getTerminalSession,
+  getTerminalDirectory,
+  getTerminalCSSVariables,
+  getRepositoryPath,
+  createTerminalTheme,
+  ThemedTerminalWithProvider,
+  ThemedTerminal,
+  TerminalPanel,
+  TabbedTerminalPanel
+};