@wzwjustdoit/dsh-plugin-git-bash 0.0.0-stage → 0.4.0

package/client.js

@@ -0,0 +1,736 @@
+window.__ModuleLoader__.load({
+  id: "@wzwjustdoit/dsh-plugin-git-bash",
+  factory: (require) => {
+    const module = { exports: {} };
+    const {
+      createElement,
+      useEffect,
+      useState,
+      useSyncExternalStore,
+    } = require("react");
+    const {
+      IconChevronDownOutline14,
+      IconFolderOpenOutline16,
+    } = require("@deepseek-ai/dsh-client-ui-primitives");
+
+    const SLOT = "tool.call.toolview";
+    const SETTINGS_SLOT = "settings.plugin.item";
+    const SETTINGS_TAB_SLOT = "settings.plugins.tab";
+    const SETTINGS_NAMESPACE = "shell";
+    const LOCALE_NAMESPACE = "git-bash.settings";
+    const PRIORITY = -100;
+    const WRAP_ATTR = "data-dsh-git-bash-wrap";
+    const STYLE_ID = "dsh-plugin-git-bash-command-wrap";
+    const SETTINGS_STYLE_ID = "dsh-plugin-git-bash-settings";
+    const STYLE_OWNER = {};
+    const COMMAND_WRAP_CSS = `
+[${WRAP_ATTR}] [class*="_command_"] {
+  white-space: pre-wrap !important;
+  overflow-wrap: anywhere !important;
+  word-break: normal !important;
+  overflow: visible !important;
+  text-overflow: clip !important;
+}
+`;
+    const SETTINGS_CSS = `
+[data-dsh-git-bash-settings] {
+  list-style: none;
+  color: var(--dsw-alias-label-primary);
+  background: var(--dsw-alias-bg-layer-3);
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+  transition: border-color 0.16s, background 0.16s;
+}
+[data-dsh-git-bash-settings]:hover,
+[data-dsh-git-bash-settings][data-open="true"] {
+  border-color: var(--dsw-alias-label-dimmed);
+}
+[data-dsh-git-bash-settings][data-open="true"] {
+  background: var(--dsw-alias-bg-layer-2);
+}
+.dgb-settings-header {
+  appearance: none;
+  width: 100%;
+  min-height: 68px;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 14px 16px;
+  color: inherit;
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+  background: transparent;
+  border: 0;
+  border-radius: 8px;
+}
+.dgb-settings-header:focus-visible,
+.dgb-settings-button:focus-visible,
+.dgb-settings-reset:focus-visible,
+.dgb-settings-input:focus-visible {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 2px;
+}
+.dgb-settings-head-text {
+  min-width: 0;
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  gap: 4px;
+}
+.dgb-settings-title {
+  font-size: 15px;
+  font-weight: 600;
+  line-height: 1.4;
+}
+.dgb-settings-description {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 13px;
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+}
+.dgb-settings-overridden {
+  flex: none;
+  padding: 1px 8px;
+  color: var(--dsw-alias-label-secondary);
+  background: var(--dsw-alias-bg-module-platform);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 17px;
+  white-space: nowrap;
+}
+.dgb-settings-chevron {
+  flex: none;
+  color: var(--dsw-alias-label-tertiary);
+  transition: transform 0.16s;
+}
+.dgb-settings-chevron-open {
+  transform: rotate(180deg);
+}
+.dgb-settings-body {
+  margin: 0 16px;
+  padding: 0 0 8px;
+  border-top: 1px solid var(--dsw-alias-border-l2);
+}
+.dgb-settings-readonly,
+.dgb-settings-message,
+.dgb-settings-hint {
+  margin: 0;
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 12px;
+  line-height: 1.5;
+}
+.dgb-settings-readonly {
+  padding-top: 12px;
+}
+.dgb-settings-field {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 12px 0;
+}
+.dgb-settings-field-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.dgb-settings-label {
+  min-width: 0;
+  flex: 1;
+  font-size: 13px;
+  font-weight: 500;
+  line-height: 1.5;
+}
+.dgb-settings-field-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+}
+.dgb-settings-reset {
+  padding: 0;
+  color: var(--dsw-alias-label-secondary);
+  font: inherit;
+  font-size: 12px;
+  line-height: 1.5;
+  cursor: pointer;
+  background: transparent;
+  border: 0;
+}
+.dgb-settings-reset:hover:not(:disabled) {
+  color: var(--dsw-alias-label-primary);
+}
+.dgb-settings-input-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.dgb-settings-input {
+  min-width: 0;
+  height: 34px;
+  flex: 1 1 260px;
+  padding: 0 12px;
+  color: var(--dsw-alias-label-primary);
+  font: inherit;
+  font-size: 13px;
+  line-height: 1.5;
+  background: var(--dsw-alias-bg-layer-3);
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+}
+.dgb-settings-input[aria-invalid="true"] {
+  border-color: var(--dsw-alias-state-error-primary);
+}
+.dgb-settings-input:disabled,
+.dgb-settings-button:disabled,
+.dgb-settings-reset:disabled {
+  color: var(--dsw-alias-label-tertiary);
+  cursor: default;
+}
+.dgb-settings-button {
+  min-height: 34px;
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  gap: 7px;
+  padding: 5px 12px;
+  color: var(--dsw-alias-label-secondary);
+  font: inherit;
+  font-size: 13px;
+  line-height: 1.5;
+  cursor: pointer;
+  background: transparent;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+}
+.dgb-settings-button:hover:not(:disabled) {
+  color: var(--dsw-alias-label-primary);
+  background: var(--dsw-alias-bg-layer-3);
+}
+.dgb-settings-button-primary {
+  color: var(--dsw-alias-label-primary-foreground);
+  background: var(--dsw-alias-button-primary-fill);
+  border-color: transparent;
+}
+.dgb-settings-button-primary:hover:not(:disabled) {
+  color: var(--dsw-alias-label-primary-foreground);
+  background: var(--dsw-alias-button-primary-hover);
+}
+.dgb-settings-button-primary:disabled {
+  color: var(--dsw-alias-label-tertiary);
+  background: var(--dsw-alias-button-primary-dimmed);
+}
+.dgb-settings-error {
+  color: var(--dsw-alias-state-error-primary);
+}
+.dgb-settings-field-footer {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 8px 0 4px;
+}
+.dgb-settings-message {
+  min-width: 0;
+  flex: 1;
+}
+@media (max-width: 560px) {
+  .dgb-settings-header {
+    align-items: flex-start;
+  }
+  .dgb-settings-input-row {
+    align-items: stretch;
+    flex-direction: column;
+  }
+  .dgb-settings-input {
+    width: 100%;
+    flex-basis: 34px;
+  }
+  .dgb-settings-picker {
+    width: 100%;
+  }
+}
+`;
+
+    function installStyle(id, content) {
+      if (typeof document === "undefined") return () => {};
+      let style = document.getElementById(id);
+      if (style === null) {
+        style = document.createElement("style");
+        style.id = id;
+        document.head.appendChild(style);
+      }
+      style.textContent = content;
+      style.__dshGitBashOwner = STYLE_OWNER;
+      return () => {
+        if (style.__dshGitBashOwner === STYLE_OWNER) style.remove();
+      };
+    }
+
+    function installCommandWrapStyle() {
+      return installStyle(STYLE_ID, COMMAND_WRAP_CSS);
+    }
+
+    function installSettingsStyle() {
+      return installStyle(SETTINGS_STYLE_ID, SETTINGS_CSS);
+    }
+
+    function parseArguments(block) {
+      const raw = "kind" in block ? block.call?.argsRaw : block.argsRaw;
+      if (typeof raw !== "string" || raw === "") return null;
+      try {
+        const value = JSON.parse(raw);
+        return typeof value === "object" && value !== null ? value : null;
+      } catch {
+        return null;
+      }
+    }
+
+    function flattenContent(content) {
+      return content.map((block) => {
+        if (block?.type === "text" && typeof block.text === "string") return block.text;
+        return JSON.stringify(block, null, 2);
+      }).join("\n");
+    }
+
+    function parseTerminalOutput(output) {
+      const signal = output.match(/(?:\r?\n)?\[killed by signal: ([^\]\r\n]+)\]\s*$/);
+      if (signal !== null) {
+        return { output: output.slice(0, signal.index), signal: signal[1] };
+      }
+      const exit = output.match(/(?:\r?\n)?\[exit code: (-?\d+)\]\s*$/);
+      if (exit !== null) {
+        return { output: output.slice(0, exit.index), exitCode: Number(exit[1]) };
+      }
+      return { output };
+    }
+
+    function addNestedTerminalViews(block) {
+      const settled = "kind" in block;
+      if (block.callView !== null) return block;
+      if (settled && (block.resultView !== null || block.isError)) return block;
+
+      const args = parseArguments(block);
+      if (args === null || typeof args.command !== "string" || args.command === "") return block;
+      const callView = {
+        card: "terminal",
+        title: args.command,
+        ...(typeof args.description === "string" ? { description: args.description } : {}),
+        ...(typeof args.workdir === "string" ? { cwd: args.workdir } : {}),
+      };
+      if (!settled) return { ...block, callView };
+
+      return {
+        ...block,
+        callView,
+        resultView: {
+          card: "terminal",
+          ...parseTerminalOutput(flattenContent(block.content)),
+        },
+      };
+    }
+
+    const settingsLocales = {
+      en: {
+        title: "Git Bash",
+        description: "Select the Git for Windows used by Bash commands: one for the startup script and danger-full-access, one for the confined modes.",
+        unsaved: "Unsaved",
+        overridden: "Overridden",
+        reset: "Reset to default",
+        readOnly: "This deployment stores settings read-only.",
+        pathLabel: "Git Bash executable (startup script / danger-full-access)",
+        pathHint: "Leave blank to auto-detect Git for Windows. The path must point to bash.exe.",
+        confinedPathLabel: "Git Bash executable (read-only / workspace-write)",
+        confinedPathHint: "Use a DIFFERENT Git installation than the one above. Leave blank to fall back to the same one.",
+        invalidPath: "Enter an absolute Windows path ending in bash.exe, or leave it blank.",
+        browse: "Select Git installation folder",
+        browsing: "Selecting...",
+        browseTitle: "Open the Windows folder picker",
+        discard: "Discard",
+        save: "Save",
+        saving: "Saving...",
+        saveFailed: "That bash.exe is unavailable or invalid. Check the path and try again.",
+        pickerFailed: "The Windows folder picker could not be opened.",
+      },
+      zh: {
+        title: "Git Bash",
+        description: "选择 Bash 命令使用的 Git for Windows：一份给启动脚本与 danger-full-access，另一份给受限模式。",
+        unsaved: "未保存",
+        overridden: "已覆盖",
+        reset: "恢复默认",
+        readOnly: "本部署的设置为只读。",
+        pathLabel: "Git Bash 可执行文件（启动脚本 / danger-full-access）",
+        pathHint: "留空会自动探测 Git for Windows；路径必须指向 bash.exe。",
+        confinedPathLabel: "Git Bash 可执行文件（read-only / workspace-write）",
+        confinedPathHint: "请使用与上一项【不同】的 Git 安装；留空则回落到同一份。",
+        invalidPath: "请输入以 bash.exe 结尾的 Windows 绝对路径，或留空自动探测。",
+        browse: "选择 Git 安装目录",
+        browsing: "选择中...",
+        browseTitle: "打开 Windows 原生目录选择窗口",
+        discard: "放弃修改",
+        save: "保存",
+        saving: "保存中...",
+        saveFailed: "该 bash.exe 不可用或路径无效，请检查后重试。",
+        pickerFailed: "无法打开 Windows 原生目录选择窗口。",
+      },
+    };
+
+    function hasOwn(value, key) {
+      return typeof value === "object" && value !== null &&
+        Object.prototype.hasOwnProperty.call(value, key);
+    }
+
+    function isGitBashExecutablePath(value) {
+      return /^(?:$|(?:[A-Z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+[\\/]|%[^%]+%[\\/])(?:.*[\\/])?bash\.exe)$/i
+        .test(value.trim());
+    }
+
+    function appendWindowsPath(directory, suffix) {
+      return directory.endsWith("\\") ? directory + suffix : directory + "\\" + suffix;
+    }
+
+    function gitBashExecutableFromDirectory(directory) {
+      let normalized = typeof directory === "string" ? directory.trim().replace(/\//g, "\\") : "";
+      normalized = normalized.replace(/\\+$/, "");
+      if (/^[A-Za-z]:$/.test(normalized)) normalized += "\\";
+      if (normalized === "" || /(?:^|\\)bash\.exe$/i.test(normalized)) return normalized;
+      if (/(?:^|\\)bin$/i.test(normalized)) return appendWindowsPath(normalized, "bash.exe");
+      if (/(?:^|\\)usr$/i.test(normalized)) return appendWindowsPath(normalized, "bin\\bash.exe");
+      return appendWindowsPath(normalized, "bin\\bash.exe");
+    }
+
+    function fieldOf(value, field) {
+      return typeof value?.[field] === "string" ? value[field] : "";
+    }
+
+    // One path field: label, input, native folder picker, per-field override
+    // badge and reset. Both `executable` and `confinedExecutable` share it, so
+    // they stay consistent without duplicating the interaction logic.
+    function GitBashPathField(props) {
+      const { field, idBase, label, hint, invalidHint, placeholder, scope, pickDirectory, t, busy } = props;
+      const snapshot = useSyncExternalStore(
+        (listener) => scope.subscribe(listener),
+        () => scope.getSnapshot(),
+        () => scope.getSnapshot(),
+      );
+      const effective = fieldOf(snapshot.value, field);
+      const inherited = fieldOf(snapshot.base, field);
+      const overridden = hasOwn(snapshot.user, field);
+      const writable = props.writable;
+      const [text, setText] = useState(effective);
+      const [dirty, setDirty] = useState(false);
+      const [resetPending, setResetPending] = useState(false);
+      const [picking, setPicking] = useState(false);
+      const [message, setMessage] = useState("");
+
+      useEffect(() => {
+        if (dirty) return;
+        setText(effective);
+      }, [dirty, effective, snapshot.revision]);
+
+      const trimmed = text.trim();
+      const willUnset = resetPending || trimmed === "";
+      const invalid = !willUnset && !isGitBashExecutablePath(trimmed);
+      const previewOverridden = dirty ? !willUnset : overridden;
+      const fieldBusy = busy || picking;
+
+      const edit = (value) => {
+        setText(value);
+        setDirty(value.trim() !== effective.trim());
+        setResetPending(false);
+        setMessage("");
+      };
+      const reset = () => {
+        setText(inherited);
+        setDirty(true);
+        setResetPending(true);
+        setMessage("");
+      };
+      const discard = () => {
+        setText(effective);
+        setDirty(false);
+        setResetPending(false);
+        setMessage("");
+      };
+      const browse = async () => {
+        setPicking(true);
+        setMessage("");
+        try {
+          const directory = await pickDirectory();
+          if (directory !== null) edit(gitBashExecutableFromDirectory(directory));
+        } catch {
+          setMessage(t("pickerFailed"));
+        } finally {
+          setPicking(false);
+        }
+      };
+      const save = async () => {
+        if (!dirty || invalid || !writable) return;
+        setMessage("");
+        try {
+          if (willUnset) await scope.unset(field);
+          else await scope.set(field, trimmed);
+
+          const latest = scope.getSnapshot();
+          const accepted = willUnset
+            ? !hasOwn(latest.user, field)
+            : hasOwn(latest.user, field) && latest.user[field] === trimmed;
+          if (!accepted) {
+            setMessage(t("saveFailed"));
+            return;
+          }
+
+          setText(fieldOf(latest.value, field));
+          setDirty(false);
+          setResetPending(false);
+        } catch {
+          setMessage(t("saveFailed"));
+        }
+      };
+
+      const inputId = "plugin-config-git-bash-" + idBase;
+      const hintId = inputId + "-hint";
+
+      return createElement("div", { className: "dgb-settings-field" },
+        createElement("div", { className: "dgb-settings-field-head" },
+          createElement("label", {
+            className: "dgb-settings-label",
+            htmlFor: inputId,
+          }, t(label)),
+          previewOverridden ? createElement("span", { className: "dgb-settings-field-actions" },
+            createElement("span", { className: "dgb-settings-overridden" }, t("overridden")),
+            createElement("button", {
+              type: "button",
+              className: "dgb-settings-reset",
+              disabled: !writable || fieldBusy,
+              onClick: reset,
+            }, t("reset")),
+          ) : null,
+        ),
+        createElement("div", { className: "dgb-settings-input-row" },
+          createElement("input", {
+            id: inputId,
+            className: "dgb-settings-input",
+            type: "text",
+            autoComplete: "off",
+            spellCheck: false,
+            value: text,
+            placeholder,
+            disabled: !writable || fieldBusy,
+            "aria-describedby": hintId,
+            ...(invalid ? {
+              "aria-invalid": true,
+              "aria-errormessage": hintId,
+            } : {}),
+            onChange: (event) => edit(event.target.value),
+          }),
+          createElement("button", {
+            type: "button",
+            className: "dgb-settings-button dgb-settings-picker",
+            title: t("browseTitle"),
+            disabled: !writable || fieldBusy,
+            onClick: browse,
+          },
+          createElement(IconFolderOpenOutline16, {}),
+          t(picking ? "browsing" : "browse")),
+        ),
+        createElement("p", {
+          id: hintId,
+          className: invalid ? "dgb-settings-hint dgb-settings-error" : "dgb-settings-hint",
+          ...(invalid ? { role: "alert" } : {}),
+        }, t(invalid ? invalidHint : hint)),
+        createElement("div", { className: "dgb-settings-field-footer" },
+          message ? createElement("p", {
+            className: "dgb-settings-message dgb-settings-error",
+            role: "status",
+          }, message) : null,
+          createElement("button", {
+            type: "button",
+            className: "dgb-settings-button",
+            disabled: !dirty || fieldBusy,
+            onClick: discard,
+          }, t("discard")),
+          createElement("button", {
+            type: "button",
+            className: "dgb-settings-button dgb-settings-button-primary",
+            disabled: !dirty || invalid || !writable || fieldBusy,
+            onClick: save,
+          }, t("save")),
+        ),
+      );
+    }
+
+    function GitBashSettingsCard(props) {
+      const { scope, pickDirectory, t } = props;
+      const snapshot = useSyncExternalStore(
+        (listener) => scope.subscribe(listener),
+        () => scope.getSnapshot(),
+        () => scope.getSnapshot(),
+      );
+      // Gate on `executable` alone: it predates `confinedExecutable`, so an
+      // older host schema (without the new field) still renders the first
+      // field rather than hiding the whole card.
+      const supported = snapshot.status === "ready" && hasOwn(snapshot.value, "executable");
+      const writable = supported && snapshot.writable;
+      const [open, setOpen] = useState(false);
+
+      if (!supported) return null;
+
+      const fieldProps = { scope, pickDirectory, t, writable };
+
+      return createElement("li", {
+        "data-dsh-git-bash-settings": "",
+        "data-open": open ? "true" : undefined,
+      },
+      createElement("button", {
+        type: "button",
+        className: "dgb-settings-header",
+        "aria-expanded": open,
+        onClick: () => setOpen(!open),
+      },
+      createElement("span", { className: "dgb-settings-head-text" },
+        createElement("span", { className: "dgb-settings-title" }, t("title")),
+        createElement("span", { className: "dgb-settings-description" }, t("description")),
+      ),
+      createElement(IconChevronDownOutline14, {
+        className: open
+          ? "dgb-settings-chevron dgb-settings-chevron-open"
+          : "dgb-settings-chevron",
+      })),
+      open ? createElement("div", { className: "dgb-settings-body" },
+        !writable ? createElement("p", {
+          className: "dgb-settings-readonly",
+          role: "status",
+        }, t("readOnly")) : null,
+        createElement(GitBashPathField, {
+          ...fieldProps,
+          field: "executable",
+          idBase: "executable",
+          label: "pathLabel",
+          hint: "pathHint",
+          invalidHint: "invalidPath",
+          placeholder: "C:\\Program Files\\Git\\bin\\bash.exe",
+        }),
+        createElement(GitBashPathField, {
+          ...fieldProps,
+          field: "confinedExecutable",
+          idBase: "confined-executable",
+          label: "confinedPathLabel",
+          hint: "confinedPathHint",
+          invalidHint: "invalidPath",
+          placeholder: "D:\\PortableGit\\usr\\bin\\bash.exe",
+        }),
+      ) : null);
+    }
+
+    function installSettingsNamespaceDedupe(ctx) {
+      let stop = () => {};
+      const install = () => {
+        const configurableTab = ctx.slots.entries(SETTINGS_TAB_SLOT)
+          .find((entry) => entry.options.id === "configurable");
+        if (configurableTab === undefined) return false;
+        const store = configurableTab.inject().hooks.configurablePlugins;
+        if (store === undefined) return false;
+        const dedupe = () => {
+          const snapshot = store.getSnapshot();
+          const namespaces = [...new Set(snapshot.namespaces)];
+          if (namespaces.length === snapshot.namespaces.length) return;
+          store.set({ ...snapshot, namespaces });
+        };
+        stop = store.subscribe(dedupe);
+        dedupe();
+        return true;
+      };
+      ctx.effect(() => {
+        if (install()) return stop;
+        const off = ctx.slots.subscribe(SETTINGS_TAB_SLOT, () => {
+          if (install()) off();
+        });
+        return () => {
+          off();
+          stop();
+        };
+      }, "git-bash: deduplicate shadowed settings namespaces");
+    }
+
+    function apply(ctx) {
+      ctx.effect(() => {
+        const disposeCommandStyle = installCommandWrapStyle();
+        const disposeSettingsStyle = installSettingsStyle();
+        return () => {
+          disposeSettingsStyle();
+          disposeCommandStyle();
+        };
+      }, "git-bash: client styles");
+
+      const t = ctx.locale.bind(LOCALE_NAMESPACE);
+      ctx.effect(() => ctx.locale.register(LOCALE_NAMESPACE, settingsLocales),
+        "git-bash: settings dictionaries");
+      // The configurable settings tab collects namespaces from raw keyed entries, so
+      // shadowed cards (same key, different priority) yield duplicate namespaces.
+      installSettingsNamespaceDedupe(ctx);
+      // DSH 0.2 dropped the `settingsScope` service. Register the configuration
+      // card only when the host still exposes it; the Bash terminal row below is
+      // independent of settings, so the entry activates either way.
+      const settingsScope = ctx.get("settingsScope");
+      if (settingsScope !== undefined) {
+        const scope = settingsScope.bind({ namespace: SETTINGS_NAMESPACE });
+        ctx.slots.inject(SETTINGS_SLOT, () => ctx.slots.register({
+          name: SETTINGS_SLOT,
+          key: SETTINGS_NAMESPACE,
+          priority: PRIORITY,
+          locale: LOCALE_NAMESPACE,
+          inject: () => ({
+            scope,
+            pickDirectory: () => ctx.uiWorkspace.pickDirectory(),
+            t,
+          }),
+        }, GitBashSettingsCard));
+      }
+
+      ctx.slots.inject(SLOT, () => {
+        const original = ctx.slots.entries(SLOT)
+          .filter((entry) => entry.options.key === "bash" && entry.options.priority !== PRIORITY)
+          .sort((left, right) => (left.options.priority ?? 0) - (right.options.priority ?? 0))[0];
+        if (original === undefined) return undefined;
+
+        function GitBashRow(props) {
+          const block = addNestedTerminalViews(props.block);
+          const row = createElement(original.component, { ...props, block });
+          if (block === props.block) return row;
+          return createElement("div", {
+            [WRAP_ATTR]: "",
+            style: { display: "contents" },
+          }, row);
+        }
+
+        return ctx.slots.register({
+          name: SLOT,
+          key: "bash",
+          priority: PRIORITY,
+          locale: "conversation",
+        }, GitBashRow);
+      });
+    }
+
+    // `settingsScope` is intentionally absent: DSH 0.2 removed that service, and
+    // listing it here keeps the whole client entry pending forever (the host
+    // reports "1 entry did not activate"). The settings card wiring below probes
+    // for it at runtime instead.
+    const inject = [
+      "slots",
+      "locale",
+      "connection",
+      "remote",
+      "uiWorkspace",
+    ];
+    module.exports = {
+      apply,
+      inject,
+      gitBashExecutableFromDirectory,
+      isGitBashExecutablePath,
+    };
+    return module.exports;
+  },
+});