@psnext/slingcli 2.5.20260621-1 → 2.5.20260629-1

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/theme/theme.js

@@ -378,6 +378,11 @@ function getCustomThemeInfos() {
     }
     return result;
 }
+function assertThemeNameIsValid(name) {
+    if (name.includes("/")) {
+        throw new Error(`Invalid theme name "${name}": theme names cannot contain "/" because it is reserved for automatic light/dark theme settings.`);
+    }
+}
 function parseThemeJson(label, json) {
     if (!validateThemeJson.Check(json)) {
         const errors = Array.from(validateThemeJson.Errors(json));
@@ -409,7 +414,9 @@ function parseThemeJson(label, json) {
         }
         throw new Error(errorMessage);
     }
-    return json;
+    const themeJson = json;
+    assertThemeNameIsValid(themeJson.name);
+    return themeJson;
 }
 function parseThemeJsonContent(label, content) {
     let json;
@@ -489,6 +496,31 @@ export function getThemeByName(name) {
         return undefined;
     }
 }
+export function parseAutoThemeSetting(themeSetting) {
+    if (!themeSetting)
+        return undefined;
+    const slashIndex = themeSetting.indexOf("/");
+    if (slashIndex === -1 || themeSetting.indexOf("/", slashIndex + 1) !== -1) {
+        return undefined;
+    }
+    const lightTheme = themeSetting.slice(0, slashIndex).trim();
+    const darkTheme = themeSetting.slice(slashIndex + 1).trim();
+    if (!lightTheme || !darkTheme) {
+        return undefined;
+    }
+    return { lightTheme, darkTheme };
+}
+export function resolveThemeSetting(themeSetting, terminalTheme) {
+    const autoTheme = parseAutoThemeSetting(themeSetting);
+    if (autoTheme) {
+        return terminalTheme === "light" ? autoTheme.lightTheme : autoTheme.darkTheme;
+    }
+    if (themeSetting?.includes("/"))
+        return undefined;
+    if (typeof themeSetting === "string")
+        return themeSetting;
+    return undefined;
+}
 function getColorFgBgBackgroundIndex(colorfgbg) {
     const parts = colorfgbg.split(";");
     for (let i = parts.length - 1; i >= 0; i--) {
@@ -548,6 +580,17 @@ export async function detectTerminalBackgroundTheme({ ui, timeoutMs, env, }) {
     }
     return detectTerminalBackgroundFromEnv({ env });
 }
+export async function detectTerminalThemeForAuto({ ui, timeoutMs, env, }) {
+    try {
+        const colorScheme = await ui.queryTerminalColorScheme?.({ timeoutMs });
+        if (colorScheme)
+            return colorScheme;
+    }
+    catch {
+        // Fall back to OSC 11 / COLORFGBG detection when color-scheme DSR is unsupported.
+    }
+    return (await detectTerminalBackgroundTheme({ ui, timeoutMs, env })).theme;
+}
 export function getDefaultTheme() {
     return detectTerminalBackgroundFromEnv().theme;
 }
@@ -580,6 +623,7 @@ export function setRegisteredThemes(themes) {
     registeredThemes.clear();
     for (const theme of themes) {
         if (theme.name) {
+            assertThemeNameIsValid(theme.name);
             registeredThemes.set(theme.name, theme);
         }
     }

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/rpc/rpc-client.js

@@ -298,6 +298,20 @@ export class RpcClient {
         const response = await this.send({ type: "get_fork_messages" });
         return this.getData(response).messages;
     }
+    /**
+     * Get session entries in append order, optionally only those after the `since` entry id.
+     */
+    async getEntries(since) {
+        const response = await this.send({ type: "get_entries", since });
+        return this.getData(response);
+    }
+    /**
+     * Get the session entry tree.
+     */
+    async getTree() {
+        const response = await this.send({ type: "get_tree" });
+        return this.getData(response);
+    }
     /**
      * Get text of last assistant message.
      */

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/rpc/rpc-mode.js

@@ -477,6 +477,22 @@ export async function runRpcMode(runtimeHost) {
                 const messages = session.getUserMessagesForForking();
                 return success(id, "get_fork_messages", { messages });
             }
+            case "get_entries": {
+                const sessionManager = session.sessionManager;
+                let entries = sessionManager.getEntries();
+                if (command.since !== undefined) {
+                    const sinceIndex = entries.findIndex((e) => e.id === command.since);
+                    if (sinceIndex === -1) {
+                        return error(id, "get_entries", `Entry not found: ${command.since}`);
+                    }
+                    entries = entries.slice(sinceIndex + 1);
+                }
+                return success(id, "get_entries", { entries, leafId: sessionManager.getLeafId() });
+            }
+            case "get_tree": {
+                const sessionManager = session.sessionManager;
+                return success(id, "get_tree", { tree: sessionManager.getTree(), leafId: sessionManager.getLeafId() });
+            }
             case "get_last_assistant_text": {
                 const text = session.getLastAssistantText();
                 return success(id, "get_last_assistant_text", { text });
@@ -528,7 +544,7 @@ export async function runRpcMode(runtimeHost) {
             }
             default: {
                 const unknownCommand = command;
-                return error(undefined, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
+                return error(id, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
             }
         }
     };

package/node_modules/@earendil-works/pi-coding-agent/dist/package-manager-cli.js

@@ -2,7 +2,7 @@ import { Markdown } from "@earendil-works/pi-tui";
 import chalk from "chalk";
 import { selectConfig } from "./cli/config-selector.js";
 import { createProjectTrustContext } from "./cli/project-trust.js";
-import { APP_NAME, detectInstallMethod, getAgentDir, getPackageDir, getSelfUpdateCommand, getSelfUpdateUnavailableInstruction, PACKAGE_NAME, VERSION, } from "./config.js";
+import { APP_NAME, CONFIG_DIR_NAME, detectInstallMethod, getAgentDir, getPackageDir, getSelfUpdateCommand, getSelfUpdateUnavailableInstruction, PACKAGE_NAME, VERSION, } from "./config.js";
 import { DefaultPackageManager } from "./core/package-manager.js";
 import { resolveProjectTrusted } from "./core/project-trust.js";
 import { DefaultResourceLoader } from "./core/resource-loader.js";
@@ -43,7 +43,7 @@ function getPackageCommandUsage(command) {
         case "remove":
             return `${APP_NAME} remove <source> [-l] [--approve|--no-approve]`;
         case "update":
-            return `${APP_NAME} update [source|self|pi] [--self] [--extensions] [--extension <source>] [--approve|--no-approve] [--force]`;
+            return `${APP_NAME} update [source|self|pi] [--self|--extensions|--all] [--extension <source>] [--approve|--no-approve] [--force]`;
         case "list":
             return `${APP_NAME} list [--approve|--no-approve]`;
     }
@@ -57,7 +57,7 @@ function printPackageCommandHelp(command) {
 Install a package and add it to settings.
 
 Options:
-  -l, --local       Install project-locally (.pi/settings.json)
+  -l, --local       Install project-locally (${CONFIG_DIR_NAME}/settings.json)
   -a, --approve     Trust project-local files for this command
   -na, --no-approve Ignore project-local files for this command
 
@@ -78,7 +78,7 @@ Remove a package and its source from settings.
 Alias: ${APP_NAME} uninstall <source> [-l]
 
 Options:
-  -l, --local       Remove from project settings (.pi/settings.json)
+  -l, --local       Remove from project settings (${CONFIG_DIR_NAME}/settings.json)
   -a, --approve     Trust project-local files for this command
   -na, --no-approve Ignore project-local files for this command
 
@@ -94,15 +94,17 @@ Examples:
 Update pi and installed packages.
 
 Options:
-  --self                  Update pi only
+  --self                  Update pi only (default when no target is given)
   --extensions            Update installed packages only
+  --all                   Update pi and installed packages
   --extension <source>    Update one package only
   -a, --approve           Trust project-local files for this command
   -na, --no-approve       Ignore project-local files for this command
   --force                 Reinstall pi even if the current version is latest
 
 Short forms:
-  ${APP_NAME} update                Update pi and all extensions
+  ${APP_NAME} update                Update pi only
+  ${APP_NAME} update --all          Update pi and all extensions
   ${APP_NAME} update <source>       Update one package
   ${APP_NAME} update pi             Update pi only (self works as alias to pi)
 `);
@@ -143,6 +145,7 @@ function parsePackageCommand(args) {
     let source;
     let selfFlag = false;
     let extensionsFlag = false;
+    let allFlag = false;
     let extensionFlagSource;
     for (let index = 0; index < rest.length; index++) {
         const arg = rest[index];
@@ -177,6 +180,15 @@ function parsePackageCommand(args) {
             }
             continue;
         }
+        if (arg === "--all") {
+            if (command === "update") {
+                allFlag = true;
+            }
+            else {
+                invalidOption = invalidOption ?? arg;
+            }
+            continue;
+        }
         if (arg === "--approve" || arg === "-a") {
             projectTrustOverride = true;
             continue;
@@ -225,10 +237,19 @@ function parsePackageCommand(args) {
         }
     }
     let updateTarget;
+    let showExtensionsSkippedNote = false;
     if (command === "update") {
+        if (allFlag && (selfFlag || extensionsFlag || extensionFlagSource)) {
+            conflictingOptions =
+                conflictingOptions ?? "--all cannot be combined with --self, --extensions, or --extension";
+        }
+        if (allFlag && source) {
+            conflictingOptions = conflictingOptions ?? "--all cannot be combined with a positional source";
+        }
         if (extensionFlagSource) {
-            if (selfFlag || extensionsFlag) {
-                conflictingOptions = conflictingOptions ?? "--extension cannot be combined with --self or --extensions";
+            if (selfFlag || extensionsFlag || allFlag) {
+                conflictingOptions =
+                    conflictingOptions ?? "--extension cannot be combined with --self, --extensions, or --all";
             }
             if (source) {
                 conflictingOptions = conflictingOptions ?? "--extension cannot be combined with a positional source";
@@ -241,13 +262,17 @@ function parsePackageCommand(args) {
                 updateTarget = extensionsFlag ? { type: "all" } : { type: "self" };
             }
             else {
-                if (extensionsFlag || selfFlag) {
+                if (extensionsFlag || selfFlag || allFlag) {
                     conflictingOptions =
-                        conflictingOptions ?? "positional update targets cannot be combined with --self or --extensions";
+                        conflictingOptions ??
+                            "positional update targets cannot be combined with --self, --extensions, or --all";
                 }
                 updateTarget = { type: "extensions", source };
             }
         }
+        else if (allFlag) {
+            updateTarget = { type: "all" };
+        }
         else if (selfFlag && extensionsFlag) {
             updateTarget = { type: "all" };
         }
@@ -258,13 +283,15 @@ function parsePackageCommand(args) {
             updateTarget = { type: "extensions" };
         }
         else {
-            updateTarget = { type: "all" };
+            updateTarget = { type: "self" };
+            showExtensionsSkippedNote = true;
         }
     }
     return {
         command,
         source,
         updateTarget,
+        showExtensionsSkippedNote,
         local,
         force,
         projectTrustOverride,
@@ -281,9 +308,9 @@ function updateTargetIncludesSelf(target) {
 function updateTargetIncludesExtensions(target) {
     return target.type === "all" || target.type === "extensions";
 }
-function printSelfUpdateUnavailable(npmCommand, updatePackageName = PACKAGE_NAME) {
+function printSelfUpdateUnavailable(npmCommand, updatePackageTarget = PACKAGE_NAME) {
     console.error(`error: ${APP_NAME} cannot self-update this installation.`);
-    console.error(getSelfUpdateUnavailableInstruction(PACKAGE_NAME, npmCommand, updatePackageName));
+    console.error(getSelfUpdateUnavailableInstruction(PACKAGE_NAME, npmCommand, updatePackageTarget));
     const entrypoint = process.argv[1];
     if (entrypoint) {
         console.error("");
@@ -313,21 +340,30 @@ function printSelfUpdateNote(note) {
     console.log();
 }
 async function getSelfUpdatePlan(force) {
-    if (force) {
-        return { packageName: PACKAGE_NAME, shouldRun: true };
-    }
+    let latestRelease;
     try {
-        const latestRelease = await getLatestPiRelease(VERSION);
-        const packageName = latestRelease?.packageName ?? PACKAGE_NAME;
-        if (!latestRelease || packageName !== PACKAGE_NAME || isNewerPackageVersion(latestRelease.version, VERSION)) {
-            return { packageName, shouldRun: true, ...(latestRelease?.note ? { note: latestRelease.note } : {}) };
-        }
+        latestRelease = await getLatestPiRelease(VERSION);
     }
-    catch {
-        return { packageName: PACKAGE_NAME, shouldRun: true };
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not determine latest ${APP_NAME} version: ${message}`);
+    }
+    if (!latestRelease) {
+        throw new Error(`Could not determine latest ${APP_NAME} version.`);
+    }
+    const packageName = latestRelease.packageName ?? PACKAGE_NAME;
+    const installSpec = `${packageName}@${latestRelease.version}`;
+    if (force || packageName !== PACKAGE_NAME || isNewerPackageVersion(latestRelease.version, VERSION)) {
+        return {
+            packageName,
+            installSpec,
+            version: latestRelease.version,
+            ...(latestRelease.note ? { note: latestRelease.note } : {}),
+            shouldRun: true,
+        };
     }
     console.log(chalk.green(`${APP_NAME} is already up to date (v${VERSION})`));
-    return { packageName: PACKAGE_NAME, shouldRun: false };
+    return { packageName, installSpec, version: latestRelease.version, shouldRun: false };
 }
 async function runSelfUpdate(command) {
     console.log(chalk.dim(`Updating ${APP_NAME} with ${command.display}...`));
@@ -555,7 +591,10 @@ export async function handlePackageCommand(args, runtimeOptions = {}) {
                 return true;
             }
             case "update": {
-                const target = options.updateTarget ?? { type: "all" };
+                const target = options.updateTarget ?? { type: "self" };
+                if (options.showExtensionsSkippedNote) {
+                    console.log(chalk.dim(`Extensions are skipped. Run ${APP_NAME} update --extensions to update extensions.`));
+                }
                 if (updateTargetIncludesExtensions(target)) {
                     const updateSource = target.type === "extensions" ? target.source : undefined;
                     await packageManager.update(updateSource);
@@ -578,9 +617,13 @@ export async function handlePackageCommand(args, runtimeOptions = {}) {
                         process.exitCode = 1;
                         return true;
                     }
-                    const selfUpdateCommand = getSelfUpdateCommand(PACKAGE_NAME, selfUpdateNpmCommand, selfUpdatePlan.packageName);
+                    const selfUpdateTarget = {
+                        packageName: selfUpdatePlan.packageName,
+                        installSpec: selfUpdatePlan.installSpec,
+                    };
+                    const selfUpdateCommand = getSelfUpdateCommand(PACKAGE_NAME, selfUpdateNpmCommand, selfUpdateTarget);
                     if (!selfUpdateCommand) {
-                        printSelfUpdateUnavailable(selfUpdateNpmCommand, selfUpdatePlan.packageName);
+                        printSelfUpdateUnavailable(selfUpdateNpmCommand, selfUpdateTarget);
                         process.exitCode = 1;
                         return true;
                     }
@@ -600,7 +643,7 @@ export async function handlePackageCommand(args, runtimeOptions = {}) {
                         process.exitCode = 1;
                         return true;
                     }
-                    console.log(chalk.green(`Updated ${APP_NAME}`));
+                    console.log(chalk.green(`Updated ${APP_NAME} from ${VERSION} to ${selfUpdatePlan.version}`));
                 }
                 return true;
             }

package/node_modules/@earendil-works/pi-coding-agent/dist/rpc-entry.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { APP_NAME } from "./config.js";
+import { configureHttpDispatcher } from "./core/http-dispatcher.js";
+import { main } from "./main.js";
+process.title = `${APP_NAME}-rpc`;
+process.env.PI_CODING_AGENT = "true";
+process.emitWarning = (() => { });
+configureHttpDispatcher();
+main(["--mode", "rpc", ...process.argv.slice(2)]);
+//# sourceMappingURL=rpc-entry.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/utils/image-convert.js

@@ -1,31 +1,18 @@
 import { applyExifOrientation } from "./exif-orientation.js";
 import { loadPhoton } from "./photon.js";
-/**
- * Convert image to PNG format for terminal display.
- * Kitty graphics protocol requires PNG format (f=100).
- */
-export async function convertToPng(base64Data, mimeType) {
-    // Already PNG, no conversion needed
-    if (mimeType === "image/png") {
-        return { data: base64Data, mimeType };
-    }
+export async function convertImageBytesToPng(bytes) {
     const photon = await loadPhoton();
     if (!photon) {
         // Photon not available, can't convert
         return null;
     }
     try {
-        const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
         const rawImage = photon.PhotonImage.new_from_byteslice(bytes);
         const image = applyExifOrientation(photon, rawImage, bytes);
         if (image !== rawImage)
             rawImage.free();
         try {
-            const pngBuffer = image.get_bytes();
-            return {
-                data: Buffer.from(pngBuffer).toString("base64"),
-                mimeType: "image/png",
-            };
+            return new Uint8Array(image.get_bytes());
         }
         finally {
             image.free();
@@ -36,4 +23,23 @@ export async function convertToPng(base64Data, mimeType) {
         return null;
     }
 }
+/**
+ * Convert image to PNG format for terminal display.
+ * Kitty graphics protocol requires PNG format (f=100).
+ */
+export async function convertToPng(base64Data, mimeType) {
+    // Already PNG, no conversion needed
+    if (mimeType === "image/png") {
+        return { data: base64Data, mimeType };
+    }
+    const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
+    const pngBytes = await convertImageBytesToPng(bytes);
+    if (!pngBytes) {
+        return null;
+    }
+    return {
+        data: Buffer.from(pngBytes).toString("base64"),
+        mimeType: "image/png",
+    };
+}
 //# sourceMappingURL=image-convert.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/utils/image-process.js

@@ -0,0 +1,83 @@
+import { convertImageBytesToPng } from "./image-convert.js";
+import { formatDimensionNote, resizeImage } from "./image-resize.js";
+function baseMimeType(mimeType) {
+    return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+function normalizeSupportedImageMimeType(mimeType) {
+    switch (baseMimeType(mimeType)) {
+        case "image/png":
+            return "image/png";
+        case "image/jpeg":
+        case "image/jpg":
+            return "image/jpeg";
+        case "image/gif":
+            return "image/gif";
+        case "image/webp":
+            return "image/webp";
+        default:
+            return null;
+    }
+}
+async function normalizeImage(bytes, mimeType) {
+    const normalizedMimeType = normalizeSupportedImageMimeType(mimeType);
+    if (normalizedMimeType) {
+        return { bytes, mimeType: normalizedMimeType };
+    }
+    const pngBytes = await convertImageBytesToPng(bytes);
+    if (!pngBytes) {
+        return null;
+    }
+    return {
+        bytes: pngBytes,
+        mimeType: "image/png",
+        convertedFrom: baseMimeType(mimeType),
+    };
+}
+function conversionHint(from, to) {
+    if (!from || from === to)
+        return undefined;
+    return `[Image converted from ${from} to ${to}.]`;
+}
+export async function processImage(bytes, mimeType, options) {
+    const autoResizeImages = options?.autoResizeImages ?? true;
+    const normalized = await normalizeImage(bytes, mimeType);
+    if (!normalized) {
+        return {
+            ok: false,
+            message: "[Image omitted: could not be converted to a supported inline image format.]",
+        };
+    }
+    if (autoResizeImages) {
+        const resized = await resizeImage(normalized.bytes, normalized.mimeType, options?.resizeOptions);
+        if (!resized) {
+            return {
+                ok: false,
+                message: "[Image omitted: could not be resized below the inline image size limit.]",
+            };
+        }
+        const hints = [];
+        const convertedHint = conversionHint(normalized.convertedFrom, resized.mimeType);
+        if (convertedHint)
+            hints.push(convertedHint);
+        const dimensionNote = formatDimensionNote(resized);
+        if (dimensionNote)
+            hints.push(dimensionNote);
+        return {
+            ok: true,
+            data: resized.data,
+            mimeType: resized.mimeType,
+            hints,
+        };
+    }
+    const hints = [];
+    const convertedHint = conversionHint(normalized.convertedFrom, normalized.mimeType);
+    if (convertedHint)
+        hints.push(convertedHint);
+    return {
+        ok: true,
+        data: Buffer.from(normalized.bytes).toString("base64"),
+        mimeType: normalized.mimeType,
+        hints,
+    };
+}
+//# sourceMappingURL=image-process.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/utils/mime.js

@@ -14,6 +14,9 @@ export function detectSupportedImageMimeType(buffer) {
     if (startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP")) {
         return "image/webp";
     }
+    if (startsWithAscii(buffer, 0, "BM") && isBmp(buffer)) {
+        return "image/bmp";
+    }
     return null;
 }
 export async function detectSupportedImageMimeTypeFromFile(filePath) {
@@ -46,12 +49,50 @@ function isAnimatedPng(buffer) {
     }
     return false;
 }
+function isBmp(buffer) {
+    if (buffer.length < 26)
+        return false;
+    const declaredFileSize = readUint32LE(buffer, 2);
+    const pixelDataOffset = readUint32LE(buffer, 10);
+    const dibHeaderSize = readUint32LE(buffer, 14);
+    if (declaredFileSize !== 0 && declaredFileSize < 26)
+        return false;
+    if (pixelDataOffset < 14 + dibHeaderSize)
+        return false;
+    if (declaredFileSize !== 0 && pixelDataOffset >= declaredFileSize)
+        return false;
+    let colorPlanes;
+    let bitsPerPixel;
+    if (dibHeaderSize === 12) {
+        colorPlanes = readUint16LE(buffer, 22);
+        bitsPerPixel = readUint16LE(buffer, 24);
+    }
+    else if (dibHeaderSize >= 40 && dibHeaderSize <= 124) {
+        if (buffer.length < 30)
+            return false;
+        colorPlanes = readUint16LE(buffer, 26);
+        bitsPerPixel = readUint16LE(buffer, 28);
+    }
+    else {
+        return false;
+    }
+    return colorPlanes === 1 && [1, 4, 8, 16, 24, 32].includes(bitsPerPixel);
+}
+function readUint16LE(buffer, offset) {
+    return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
+}
 function readUint32BE(buffer, offset) {
     return ((buffer[offset] ?? 0) * 0x1000000 +
         ((buffer[offset + 1] ?? 0) << 16) +
         ((buffer[offset + 2] ?? 0) << 8) +
         (buffer[offset + 3] ?? 0));
 }
+function readUint32LE(buffer, offset) {
+    return ((buffer[offset] ?? 0) +
+        ((buffer[offset + 1] ?? 0) << 8) +
+        ((buffer[offset + 2] ?? 0) << 16) +
+        (buffer[offset + 3] ?? 0) * 0x1000000);
+}
 function startsWith(buffer, bytes) {
     if (buffer.length < bytes.length)
         return false;

package/node_modules/@earendil-works/pi-coding-agent/dist/utils/shell.js

@@ -5,6 +5,13 @@ import { getBinDir } from "../config.js";
 /**
  * Find bash executable on PATH (cross-platform)
  */
+function isLegacyWslBashPath(path) {
+    const normalized = path.replace(/\//g, "\\").toLowerCase();
+    return /^[a-z]:\\windows\\(?:system32|sysnative)\\bash\.exe$/.test(normalized);
+}
+function getBashShellConfig(shell) {
+    return isLegacyWslBashPath(shell) ? { shell, args: ["-s"], commandTransport: "stdin" } : { shell, args: ["-c"] };
+}
 function findBashOnPath() {
     if (process.platform === "win32") {
         // Windows: Use 'where' and verify file exists (where can return non-existent paths)
@@ -52,7 +59,7 @@ export function getShellConfig(customShellPath) {
     // 1. Check user-specified shell path
     if (customShellPath) {
         if (existsSync(customShellPath)) {
-            return { shell: customShellPath, args: ["-c"] };
+            return getBashShellConfig(customShellPath);
         }
         throw new Error(`Custom shell path not found: ${customShellPath}`);
     }
@@ -69,13 +76,13 @@ export function getShellConfig(customShellPath) {
         }
         for (const path of paths) {
             if (existsSync(path)) {
-                return { shell: path, args: ["-c"] };
+                return getBashShellConfig(path);
             }
         }
         // 3. Fallback: search bash.exe on PATH (Cygwin, MSYS2, WSL, etc.)
         const bashOnPath = findBashOnPath();
         if (bashOnPath) {
-            return { shell: bashOnPath, args: ["-c"] };
+            return getBashShellConfig(bashOnPath);
         }
         throw new Error(`No bash shell found. Options:\n` +
             `  1. Install Git for Windows: https://git-scm.com/download/win\n` +
@@ -85,11 +92,11 @@ export function getShellConfig(customShellPath) {
     }
     // Unix: try /bin/bash, then bash on PATH, then fallback to sh
     if (existsSync("/bin/bash")) {
-        return { shell: "/bin/bash", args: ["-c"] };
+        return getBashShellConfig("/bin/bash");
     }
     const bashOnPath = findBashOnPath();
     if (bashOnPath) {
-        return { shell: bashOnPath, args: ["-c"] };
+        return getBashShellConfig(bashOnPath);
     }
     return { shell: "sh", args: ["-c"] };
 }