aiwcli 0.15.7 → 0.17.0

package/dist/lib/shell-adapters/bash-adapter.js

@@ -0,0 +1,69 @@
+/**
+ * BashAdapter — ShellAdapter for bash (Unix + MSYS2/Git Bash on Windows).
+ * Delegates to low-level primitives in shell-quoting.ts, sentinel-wrapper.ts, etc.
+ */
+import { REPL_NESTING_VARS } from '../env-sanitizer.js';
+import { execFileAsync, findExecutable } from '../runtime/subprocess-utils.js';
+import { wrapSentinelSh } from '../sentinel-wrapper.js';
+import { quoteForSh } from '../shell-quoting.js';
+import { toMsysPosixPath } from '../tmux-primitives.js';
+export class BashAdapter {
+    dialect = 'bash';
+    quote(value) {
+        return quoteForSh(value);
+    }
+    buildEnvPreamble(env) {
+        return Object.entries(env)
+            .map(([key, value]) => `${key}=${this.quote(value)}`)
+            .join(' ');
+    }
+    buildToolCommand(params) {
+        const { toolPath, args, env, mode, promptPath, promptText } = params;
+        const envPrefix = this.buildEnvPreamble(env);
+        const commandArgs = this.appendPromptArg(args, mode, promptText);
+        const argPart = commandArgs.map((arg) => this.quote(arg)).join(' ');
+        const base = [envPrefix, this.quote(toolPath), argPart]
+            .filter(Boolean)
+            .join(' ');
+        if (mode === 'exec' && promptPath) {
+            return `${base} < ${this.quote(promptPath)}`;
+        }
+        return base;
+    }
+    wrapSentinel(params) {
+        return wrapSentinelSh(params);
+    }
+    async resolveToolPath(toolName, nativePath) {
+        if (process.platform !== 'win32')
+            return nativePath;
+        // On Windows, resolve tool from bash's perspective (MSYS2/Git Bash PATH)
+        const bash = findExecutable('bash');
+        if (!bash)
+            return null;
+        const result = await execFileAsync(bash, ['-lc', `command -v ${toolName}`], {
+            timeout: 3000,
+            env: { ...process.env, MSYS_NO_PATHCONV: '1' },
+        });
+        return result.exitCode === 0 ? result.stdout.trim() || null : null;
+    }
+    buildNestingCleanup() {
+        const pathFix = 'export PATH="/usr/bin:/usr/local/bin:/mingw64/bin:$PATH";';
+        const unset = `unset ${REPL_NESTING_VARS.join(' ')};`;
+        return `${pathFix} ${unset}`;
+    }
+    normalizeCwd(cwd) {
+        return toMsysPosixPath(cwd);
+    }
+    wrapQuickExitRetry(command, toolPath, thresholdSec = 10) {
+        const warmup = `${toolPath} --version >/dev/null 2>&1`;
+        return `${warmup}; _qr_t0=$SECONDS; ${command}; if [ $((SECONDS - _qr_t0)) -lt ${thresholdSec} ]; then ${command}; fi`;
+    }
+    encodeForExecution(command) {
+        return command;
+    }
+    appendPromptArg(args, mode, promptText) {
+        if (mode !== 'repl' || promptText === undefined)
+            return args;
+        return [...args, promptText];
+    }
+}

package/dist/lib/shell-adapters/index.d.ts

@@ -0,0 +1,5 @@
+export { BashAdapter } from './bash-adapter.js';
+export { PowerShellAdapter } from './powershell-adapter.js';
+export type { SentinelWrapOptions, ShellAdapter, ToolCommandParams } from './shell-adapter.js';
+import type { ShellAdapter } from './shell-adapter.js';
+export declare function shellAdapterForBackend(backend: string): ShellAdapter;

package/dist/lib/shell-adapters/index.js

@@ -0,0 +1,7 @@
+export { BashAdapter } from './bash-adapter.js';
+export { PowerShellAdapter } from './powershell-adapter.js';
+import { BashAdapter } from './bash-adapter.js';
+import { PowerShellAdapter } from './powershell-adapter.js';
+export function shellAdapterForBackend(backend) {
+    return backend === 'psmux' ? new PowerShellAdapter() : new BashAdapter();
+}

package/dist/lib/shell-adapters/powershell-adapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * PowerShellAdapter — ShellAdapter for PowerShell (Windows, psmux backend).
+ * Delegates to low-level primitives in shell-quoting.ts, sentinel-wrapper.ts, etc.
+ */
+import type { SentinelWrapOptions, ShellAdapter, ToolCommandParams } from './shell-adapter.js';
+export declare class PowerShellAdapter implements ShellAdapter {
+    readonly dialect: "powershell";
+    quote(value: string): string;
+    buildEnvPreamble(env: Record<string, string>): string;
+    buildToolCommand(params: ToolCommandParams): string;
+    wrapSentinel(params: SentinelWrapOptions): string;
+    resolveToolPath(_toolName: string, nativePath: string): Promise<string | null>;
+    buildNestingCleanup(): string;
+    normalizeCwd(cwd: string): string;
+    wrapQuickExitRetry(command: string, _toolPath: string, _thresholdSec?: number): string;
+    encodeForExecution(command: string): string;
+    private appendPromptArg;
+}

package/dist/lib/shell-adapters/powershell-adapter.js

@@ -0,0 +1,62 @@
+/**
+ * PowerShellAdapter — ShellAdapter for PowerShell (Windows, psmux backend).
+ * Delegates to low-level primitives in shell-quoting.ts, sentinel-wrapper.ts, etc.
+ */
+import path from 'node:path';
+import { REPL_NESTING_VARS } from '../env-sanitizer.js';
+import { buildBootstrapPrompt } from '../mux-utils.js';
+import { wrapSentinelPowerShell } from '../sentinel-wrapper.js';
+import { quoteForPowerShell, toEncodedPowerShell } from '../shell-quoting.js';
+export class PowerShellAdapter {
+    dialect = 'powershell';
+    quote(value) {
+        return quoteForPowerShell(value);
+    }
+    buildEnvPreamble(env) {
+        return Object.entries(env)
+            .map(([key, value]) => `$env:${key}=${this.quote(value)}`)
+            .join('; ');
+    }
+    buildToolCommand(params) {
+        const { toolPath, args, env, mode, promptPath } = params;
+        const envPrefix = this.buildEnvPreamble(env);
+        const commandArgs = this.appendPromptArg(args, mode, promptPath);
+        const argArray = commandArgs.map((arg) => this.quote(arg)).join(', ');
+        const invocation = `& ${this.quote(toolPath)}${argArray ? ` @(${argArray})` : ''}`;
+        const body = mode === 'exec' && promptPath
+            ? `Get-Content -Raw -Path ${this.quote(promptPath)} | ${invocation}`
+            : invocation;
+        return [envPrefix, body].filter(Boolean).join('; ');
+    }
+    wrapSentinel(params) {
+        return wrapSentinelPowerShell(params);
+    }
+    async resolveToolPath(_toolName, nativePath) {
+        return nativePath;
+    }
+    buildNestingCleanup() {
+        return REPL_NESTING_VARS
+            .map((v) => `Remove-Item Env:\\${v} -ErrorAction SilentlyContinue`)
+            .join('; ') + ';';
+    }
+    normalizeCwd(cwd) {
+        return cwd;
+    }
+    wrapQuickExitRetry(command, _toolPath, _thresholdSec) {
+        // Quick-exit retry not implemented for PowerShell — inline retry handles it
+        return command;
+    }
+    encodeForExecution(command) {
+        return toEncodedPowerShell(command);
+    }
+    appendPromptArg(args, mode, promptPath) {
+        if (mode !== 'repl' || !promptPath)
+            return args;
+        const absolutePromptPath = path.resolve(promptPath);
+        const formatted = process.platform === 'win32'
+            ? absolutePromptPath.replaceAll('\\', '/')
+            : absolutePromptPath;
+        const bootstrap = buildBootstrapPrompt(formatted);
+        return [...args, bootstrap];
+    }
+}

package/dist/lib/shell-adapters/shell-adapter.d.ts

@@ -0,0 +1,45 @@
+/**
+ * ShellAdapter interface — abstracts shell-dialect differences for command building.
+ * BashAdapter and PowerShellAdapter implement this for their respective shells.
+ */
+export interface ToolCommandParams {
+    toolPath: string;
+    args: string[];
+    env: Record<string, string>;
+    mode: 'exec' | 'repl';
+    promptPath?: string | undefined;
+    promptText?: string | undefined;
+}
+export interface SentinelWrapOptions {
+    command: string;
+    sentinelPath: string;
+    autoClose: boolean;
+    autoCloseCommand?: string | undefined;
+    holdPane: boolean;
+    holdMessage: string;
+}
+export interface ShellAdapter {
+    readonly dialect: 'bash' | 'powershell';
+    /** Quote a value for safe inclusion in a shell command. */
+    quote(value: string): string;
+    /** Build env var assignments as a command preamble (KEY=val for bash, $env:KEY=val for PS). */
+    buildEnvPreamble(env: Record<string, string>): string;
+    /** Build a complete tool invocation command (env + tool + args + prompt handling). */
+    buildToolCommand(params: ToolCommandParams): string;
+    /** Wrap a command with sentinel exit-code tracking and optional pane hold. */
+    wrapSentinel(params: SentinelWrapOptions): string;
+    /**
+     * Resolve a tool path for the shell dialect.
+     * On Windows with bash, resolves via `command -v` in bash.
+     * On Unix or PowerShell, returns nativePath as-is.
+     */
+    resolveToolPath(toolName: string, nativePath: string): Promise<string | null>;
+    /** Build a shell snippet that clears REPL nesting env vars. */
+    buildNestingCleanup(): string;
+    /** Normalize a cwd path for the shell dialect (e.g. Windows→POSIX for bash). */
+    normalizeCwd(cwd: string): string;
+    /** Wrap a command with warmup + quick-exit retry logic. */
+    wrapQuickExitRetry(command: string, toolPath: string, thresholdSec?: number): string;
+    /** Encode a command for safe execution (identity for bash, Base64 for PowerShell). */
+    encodeForExecution(command: string): string;
+}

package/dist/lib/shell-adapters/shell-adapter.js

@@ -0,0 +1,5 @@
+/**
+ * ShellAdapter interface — abstracts shell-dialect differences for command building.
+ * BashAdapter and PowerShellAdapter implement this for their respective shells.
+ */
+export {};

package/dist/lib/spawn-errors.d.ts

@@ -1,4 +1,7 @@
 import { ProcessSpawnError } from './errors.js';
+export declare function getInstallInstruction(command: string): string;
+export declare function formatCommandNotFoundMessage(command: string): string;
+export declare function formatPathWarning(command: string): string;
 export declare function classifySpawnError(command: string, error: NodeJS.ErrnoException): ProcessSpawnError;
 export declare function resolveWindowsSpawnArgs(command: string, args: string[], cmdExists: (commandName: string) => boolean): null | {
     args: string[];

package/dist/lib/spawn-errors.js

@@ -1,7 +1,21 @@
 import { ProcessSpawnError } from './errors.js';
+const INSTALL_INSTRUCTIONS = {
+    claude: 'Install Claude Code from https://claude.ai/download.',
+    codex: 'Install Codex from npm.',
+    devin: 'Install Devin from https://cli.devin.ai.',
+};
+export function getInstallInstruction(command) {
+    return INSTALL_INSTRUCTIONS[command] ?? 'Check that the command exists and is executable.';
+}
+export function formatCommandNotFoundMessage(command) {
+    return `Command not found: ${command}. ${getInstallInstruction(command)}`;
+}
+export function formatPathWarning(command) {
+    return `${command} not found on PATH (${getInstallInstruction(command).replace(/\.$/, '')})`;
+}
 export function classifySpawnError(command, error) {
     if (error.code === 'ENOENT') {
-        return new ProcessSpawnError(`Command not found: ${command}. Install Claude Code from https://claude.ai/download.`, 'ENOENT');
+        return new ProcessSpawnError(formatCommandNotFoundMessage(command), 'ENOENT');
     }
     if (error.code === 'EACCES') {
         return new ProcessSpawnError(`Permission denied: ${command}. Check file permissions.`, 'EACCES');

package/dist/lib/spinner.d.ts

@@ -12,8 +12,3 @@ import { type Ora } from 'ora';
 export declare function createSpinner(text: string, flags?: {
     quiet?: boolean;
 }): Ora;
-/**
- * Helper for common "loading" operations with spinner.
- * Automatically handles success/failure and cleanup.
- */
-export declare function withSpinner<T>(text: string, operation: () => Promise<T>): Promise<T>;

package/dist/lib/spinner.js

@@ -16,19 +16,3 @@ export function createSpinner(text, flags) {
         text,
     });
 }
-/**
- * Helper for common "loading" operations with spinner.
- * Automatically handles success/failure and cleanup.
- */
-export async function withSpinner(text, operation) {
-    const spinner = createSpinner(text).start();
-    try {
-        const result = await operation();
-        spinner.succeed();
-        return result;
-    }
-    catch (error) {
-        spinner.fail();
-        throw error;
-    }
-}

package/dist/lib/template-installer.d.ts

@@ -74,6 +74,16 @@ export declare function shouldExclude(name: string): boolean;
  * @param excludeIdeFolders - If true, exclude IDE config folders (.claude, .windsurf, etc.)
  */
 export declare function copyDir(src: string, dest: string, excludeIdeFolders?: boolean): Promise<void>;
+/**
+ * Merge source directory into destination, skipping existing files.
+ * Unlike copyDir, this preserves existing files in destination.
+ *
+ * @param src - Source directory path
+ * @param dest - Destination directory path
+ */
+export declare function mergeDirectory(src: string, dest: string, options?: {
+    exclude?: (name: string) => boolean;
+}): Promise<void>;
 /**
  * Install template with IDE-specific folder selection.
  *

package/dist/lib/template-installer.js

@@ -128,16 +128,16 @@ export async function copyDir(src, dest, excludeIdeFolders = false) {
  * @param src - Source directory path
  * @param dest - Destination directory path
  */
-async function mergeDirectory(src, dest) {
+export async function mergeDirectory(src, dest, options) {
     await fs.mkdir(dest, { recursive: true });
     const entries = await fs.readdir(src, { withFileTypes: true });
     const ops = entries
-        .filter((entry) => !shouldExclude(entry.name))
+        .filter((entry) => !(options?.exclude?.(entry.name)))
         .map(async (entry) => {
         const srcPath = join(src, entry.name);
         const destPath = join(dest, entry.name);
         if (entry.isDirectory()) {
-            await mergeDirectory(srcPath, destPath);
+            await mergeDirectory(srcPath, destPath, options);
         }
         else if (!(await pathExists(destPath))) {
             await fs.copyFile(srcPath, destPath);
@@ -229,7 +229,7 @@ export async function installTemplate(config) {
             }
             else {
                 // No method-namespaced child — copy the entire subdirectory, merging with existing
-                await mergeDirectory(subdirSrc, subdirDest);
+                await mergeDirectory(subdirSrc, subdirDest, { exclude: shouldExclude });
             }
         });
         await Promise.all(subdirOps);

package/dist/lib/terminal-strategy.d.ts

@@ -4,6 +4,7 @@ export interface TerminalConfig {
 }
 export type WindowsShellPreference = 'default' | 'git-bash' | 'mintty';
 export type WindowsTerminalStrategy = 'git-bash-in-wt' | 'mintty' | 'powershell-fallback' | 'windows-terminal';
+export declare function defaultShell(): string;
 export declare const LINUX_TERMINALS: TerminalConfig[];
 export declare function resolveWindowsTerminalStrategy(preference: WindowsShellPreference, gitBashPath: null | string, minttyExists: boolean, powershellCmd: string): WindowsTerminalStrategy[];
 export declare function detectPowerShell(isAvailable: (command: string) => boolean): string;

package/dist/lib/terminal-strategy.js

@@ -1,9 +1,15 @@
-export const LINUX_TERMINALS = [
-    { cmd: 'gnome-terminal', getArgs: (command) => ['--', 'bash', '-c', `${command}; exec bash`] },
-    { cmd: 'konsole', getArgs: (command) => ['-e', `bash -c "${command}; exec bash"`] },
-    { cmd: 'xterm', getArgs: (command) => ['-e', `bash -c "${command}; exec bash"`] },
-    { cmd: 'x-terminal-emulator', getArgs: (command) => ['-e', `bash -c "${command}; exec bash"`] },
-];
+export function defaultShell() {
+    return process.env.SHELL || 'bash';
+}
+export const LINUX_TERMINALS = (() => {
+    const shell = defaultShell();
+    return [
+        { cmd: 'x-terminal-emulator', getArgs: (command) => ['-e', `${shell} -c "${command}; exec ${shell}"`] },
+        { cmd: 'gnome-terminal', getArgs: (command) => ['--', shell, '-c', `${command}; exec ${shell}`] },
+        { cmd: 'konsole', getArgs: (command) => ['-e', `${shell} -c "${command}; exec ${shell}"`] },
+        { cmd: 'xterm', getArgs: (command) => ['-e', `${shell} -c "${command}; exec ${shell}"`] },
+    ];
+})();
 export function resolveWindowsTerminalStrategy(preference, gitBashPath, minttyExists, powershellCmd) {
     const strategies = [];
     if (preference === 'mintty') {

package/dist/lib/terminal.d.ts

@@ -6,9 +6,9 @@
  *
  * ## Supported Platforms
  * - **Windows**: Windows Terminal (wt.exe) with PowerShell 7 (pwsh) fallback to PowerShell 5.1
- * - **macOS**: Terminal.app via AppleScript
+ * - **macOS**: Terminal.app via `open` + temporary `.command` script
  * - **WSL**: Windows Terminal (wt.exe) via wsl.exe, falls back to Linux emulators
- * - **Linux**: gnome-terminal, konsole, xterm, x-terminal-emulator (in order of preference)
+ * - **Linux**: x-terminal-emulator, gnome-terminal, konsole, xterm (in order of preference)
  *
  * ## Usage
  * ```typescript
@@ -36,7 +36,9 @@ export interface SpawnArgs {
 /** @internal */
 export declare function resolveTerminalPlatform(platform: NodeJS.Platform, isWSLResult: boolean): 'darwin' | 'linux' | 'windows' | 'wsl';
 /** @internal */
-export declare function buildMacTerminalSpawnArgs(cwd: string, command: string): SpawnArgs;
+export declare function buildMacTerminalScriptContent(cwd: string, command: string, shellPath?: string): string;
+/** @internal */
+export declare function buildMacTerminalSpawnArgs(scriptPath: string): SpawnArgs;
 /** @internal */
 export declare function buildWindowsTerminalSpawnArgs(cwd: string, command: string, powershellCmd: string): SpawnArgs;
 /** @internal */
@@ -92,9 +94,9 @@ interface TerminalLaunchResult {
  * This function automatically detects the platform and uses the appropriate
  * terminal emulator:
  * - **Windows**: Windows Terminal (wt.exe) with PowerShell, falls back to PowerShell directly
- * - **macOS**: Terminal.app via AppleScript
+ * - **macOS**: Terminal.app via `open` + temporary `.command` script
  * - **WSL**: Windows Terminal (wt.exe) via wsl.exe, falls back to Linux terminals
- * - **Linux**: Tries gnome-terminal, konsole, xterm, x-terminal-emulator in order
+ * - **Linux**: Tries x-terminal-emulator, gnome-terminal, konsole, xterm in order
  *
  * The terminal is launched in detached mode, allowing the parent process to exit
  * without affecting the new terminal.

package/dist/lib/terminal.js

@@ -6,9 +6,9 @@
  *
  * ## Supported Platforms
  * - **Windows**: Windows Terminal (wt.exe) with PowerShell 7 (pwsh) fallback to PowerShell 5.1
- * - **macOS**: Terminal.app via AppleScript
+ * - **macOS**: Terminal.app via `open` + temporary `.command` script
  * - **WSL**: Windows Terminal (wt.exe) via wsl.exe, falls back to Linux emulators
- * - **Linux**: gnome-terminal, konsole, xterm, x-terminal-emulator (in order of preference)
+ * - **Linux**: x-terminal-emulator, gnome-terminal, konsole, xterm (in order of preference)
  *
  * ## Usage
  * ```typescript
@@ -28,14 +28,15 @@
  * @module lib/terminal
  */
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { cleanClaudeEnv } from './mux-utils.js';
+import { sanitizedProcessEnv as cleanClaudeEnv } from './env-sanitizer.js';
 import { isCommandAvailable } from './runtime/executable-policy.js';
 import { isWindowsPlatform } from './runtime/platform-adapter.js';
 import { findMsysBash } from './runtime/tmux-preflight.js';
 import { escapeSingleQuotedPath } from './shell-quoting.js';
-import { detectPowerShell, findAvailableLinuxTerminal, isWSL, resolveWindowsTerminalStrategy, } from './terminal-strategy.js';
+import { defaultShell, detectPowerShell, findAvailableLinuxTerminal, isWSL, resolveWindowsTerminalStrategy, } from './terminal-strategy.js';
 /** @internal */
 export function resolveTerminalPlatform(platform, isWSLResult) {
     if (isWindowsPlatform(platform))
@@ -47,13 +48,20 @@ export function resolveTerminalPlatform(platform, isWSLResult) {
     return 'linux';
 }
 /** @internal */
-export function buildMacTerminalSpawnArgs(cwd, command) {
+export function buildMacTerminalScriptContent(cwd, command, shellPath = defaultShell()) {
     const escapedPath = escapeSingleQuotedPath(cwd, 'bash');
-    const fullCommand = `cd '${escapedPath}' && ${command}`;
-    const escapedCommand = fullCommand.replaceAll('\\', '\\\\').replaceAll('"', String.raw `\"`);
+    const escapedShell = escapeSingleQuotedPath(shellPath, 'bash');
+    const fullCommand = `cd '${escapedPath}' && ${command}; exec '${escapedShell}' -l`;
+    const escapedCommand = escapeSingleQuotedPath(fullCommand, 'bash');
+    return `#!/bin/sh
+exec '${escapedShell}' -lc '${escapedCommand}'
+`;
+}
+/** @internal */
+export function buildMacTerminalSpawnArgs(scriptPath) {
     return {
-        command: 'osascript',
-        args: ['-e', `tell application "Terminal" to do script "${escapedCommand}"`],
+        command: 'open',
+        args: ['-a', 'Terminal', scriptPath],
     };
 }
 /** @internal */
@@ -84,10 +92,11 @@ export function buildLinuxTerminalSpawnArgs(cwd, command, terminalInfo) {
 /** @internal */
 export function buildWSLTerminalSpawnArgs(cwd, command) {
     const escapedPath = escapeSingleQuotedPath(cwd, 'bash');
-    const bashCmd = `cd '${escapedPath}' && ${command}; exec bash`;
+    const shell = defaultShell();
+    const shellCmd = `cd '${escapedPath}' && ${command}; exec ${shell}`;
     return {
         command: 'wt.exe',
-        args: ['wsl.exe', '--', 'bash', '-c', bashCmd],
+        args: ['wsl.exe', '--', shell, '-c', shellCmd],
     };
 }
 /**
@@ -206,16 +215,30 @@ async function launchWindowsTerminal(cwd, command, shellPreference, debugLog) {
     return tryStrategies();
 }
 /**
- * Launch macOS Terminal.app with command.
+ * Launch macOS Terminal.app with a temporary `.command` script.
+ *
+ * Avoids AppleScript/Automation prompts by delegating to `open(1)` instead of
+ * sending Apple Events to Terminal.app.
  *
  * @param cwd - Working directory
  * @param command - Command to execute
  * @param debugLog - Optional debug logging function
  */
 async function launchMacTerminal(cwd, command, debugLog) {
+    const scriptPath = path.join(tmpdir(), `aiwcli-terminal-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.command`);
+    try {
+        writeFileSync(scriptPath, buildMacTerminalScriptContent(cwd, command), {
+            encoding: 'utf8',
+            mode: 0o700,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: `Failed to prepare Terminal launch script: ${message}` };
+    }
     return new Promise((resolve) => {
-        const spawnArgs = buildMacTerminalSpawnArgs(cwd, command);
-        debugLog?.(`Launching macOS Terminal with command: cd '${escapeSingleQuotedPath(cwd, 'bash')}' && ${command}`);
+        const spawnArgs = buildMacTerminalSpawnArgs(scriptPath);
+        debugLog?.(`Launching macOS Terminal with script: ${scriptPath}`);
         const terminal = spawn(spawnArgs.command, spawnArgs.args, {
             detached: true,
             stdio: 'ignore',
@@ -229,9 +252,9 @@ async function launchMacTerminal(cwd, command, debugLog) {
     });
 }
 /**
- * Launch Windows Terminal (wt.exe) from WSL, running the command inside a new bash session.
+ * Launch Windows Terminal (wt.exe) from WSL, running the command inside a new shell session.
  *
- * Uses wt.exe → wsl.exe → bash so the new terminal inherits the correct WSL distro.
+ * Uses wt.exe → wsl.exe → $SHELL so the new terminal inherits the correct WSL distro.
  * Claude Code nesting-detection vars are stripped via cleanClaudeEnv().
  *
  * @param cwd - Working directory (WSL path)
@@ -293,9 +316,9 @@ async function launchLinuxTerminal(cwd, command, debugLog) {
  * This function automatically detects the platform and uses the appropriate
  * terminal emulator:
  * - **Windows**: Windows Terminal (wt.exe) with PowerShell, falls back to PowerShell directly
- * - **macOS**: Terminal.app via AppleScript
+ * - **macOS**: Terminal.app via `open` + temporary `.command` script
  * - **WSL**: Windows Terminal (wt.exe) via wsl.exe, falls back to Linux terminals
- * - **Linux**: Tries gnome-terminal, konsole, xterm, x-terminal-emulator in order
+ * - **Linux**: Tries x-terminal-emulator, gnome-terminal, konsole, xterm in order
  *
  * The terminal is launched in detached mode, allowing the parent process to exit
  * without affecting the new terminal.

package/dist/lib/tmux-primitives.d.ts

@@ -1,5 +1,3 @@
 export { quoteForSh } from './shell-quoting.js';
-/** Fixed tmux server socket. Multiple named sessions share one server. */
-export declare const TMUX_SOCKET_PATH: string;
 /** Convert Windows path to MSYS2 POSIX path for tmux args. C:\foo\bar → /c/foo/bar */
 export declare function toMsysPosixPath(winPath: string): string;

package/dist/lib/tmux-primitives.js

@@ -1,8 +1,4 @@
-import * as os from 'node:os';
-import path from 'node:path';
 export { quoteForSh } from './shell-quoting.js';
-/** Fixed tmux server socket. Multiple named sessions share one server. */
-export const TMUX_SOCKET_PATH = path.join(os.tmpdir(), 'aiwcli-tmux.sock');
 /** Convert Windows path to MSYS2 POSIX path for tmux args. C:\foo\bar → /c/foo/bar */
 export function toMsysPosixPath(winPath) {
     if (process.platform !== 'win32')

package/dist/lib/tmux-session.js

@@ -2,6 +2,7 @@ import { execSync } from 'node:child_process';
 import { writeFileSync } from 'node:fs';
 import * as os from 'node:os';
 import path from 'node:path';
+import { buildBootstrapPrompt } from './mux-utils.js';
 import { resolveExecutable } from './runtime/executable-policy.js';
 import { isNonWindowsPlatform, resolveTmuxColorModeForPlatform, } from './runtime/platform-adapter.js';
 import { quoteForSh } from './tmux-primitives.js';
@@ -46,7 +47,7 @@ export function buildShellCommand(opts) {
     if (promptText) {
         const tmpFile = path.join(os.tmpdir(), `aiwcli-prompt-${Date.now()}-${process.pid}.txt`);
         writeFileSync(tmpFile, promptText, { encoding: 'utf8', mode: 0o600 });
-        const bootstrap = `Read startup instructions from this file path before taking action: ${tmpFile}. Use that file as the initial context.`;
+        const bootstrap = buildBootstrapPrompt(tmpFile);
         cmdParts.push(quoteForSh(bootstrap));
     }
     // Export COLORTERM only when truecolor is intentionally enabled.

package/dist/lib/windsurf-hooks-hierarchy.js

@@ -1,6 +1,5 @@
-import { promises as fs } from 'node:fs';
-import { join } from 'node:path';
-import { pathExists } from './paths.js';
+import { IdePathResolver } from './ide-path-resolver.js';
+import { readJsonFile, writeJsonFile } from './json-io.js';
 /**
  * Read Windsurf hooks from file
  *
@@ -8,14 +7,7 @@ import { pathExists } from './paths.js';
  * @returns Parsed hooks or undefined if file doesn't exist or is invalid
  */
 export async function readWindsurfHooks(path) {
-    try {
-        const content = await fs.readFile(path, 'utf8');
-        return JSON.parse(content);
-    }
-    catch {
-        // File doesn't exist or invalid JSON
-        return undefined;
-    }
+    return readJsonFile(path);
 }
 /**
  * Write Windsurf hooks to file
@@ -28,17 +20,7 @@ export async function readWindsurfHooks(path) {
  * @throws Error if write fails
  */
 export async function writeWindsurfHooks(path, hooks) {
-    // Create parent directory if it doesn't exist
-    const dir = join(path, '..');
-    await fs.mkdir(dir, { recursive: true });
-    // Backup existing file if it exists
-    if (await pathExists(path)) {
-        const backupPath = `${path}.backup`;
-        await fs.copyFile(path, backupPath);
-    }
-    // Write hooks with pretty formatting
-    const content = JSON.stringify(hooks, null, 2);
-    await fs.writeFile(path, content, 'utf8');
+    return writeJsonFile(path, hooks, { backup: true });
 }
 /**
  * Get the target hooks file for template hook merging
@@ -51,5 +33,6 @@ export async function writeWindsurfHooks(path, hooks) {
  * @returns Path to target hooks file
  */
 export function getTargetHooksFile(projectDir) {
-    return join(projectDir, '.windsurf', 'hooks.json');
+    const resolver = new IdePathResolver(projectDir);
+    return resolver.getWindsurfHooks();
 }

package/dist/platform/launch.d.ts

@@ -1,6 +1,7 @@
 export { ProcessSpawnError } from '../lib/errors.js';
 export { ensureLspPatch } from '../lib/lsp-patch.js';
-export { detectMultiplexer, type SplitPaneResult } from '../lib/multiplexer.js';
+export { detectMultiplexer, type LaunchResult, type SplitDirection } from '../lib/multiplexer.js';
+export { REPL_NESTING_VARS } from '../lib/env-sanitizer.js';
 export { readSentinelExitCode, waitForSentinelFile } from '../lib/runtime/sentinel-ipc.js';
 export { findExecutable } from '../lib/runtime/subprocess-utils.js';
 export { quoteForSh } from '../lib/shell-quoting.js';

package/dist/platform/launch.js

@@ -1,6 +1,7 @@
 export { ProcessSpawnError } from '../lib/errors.js';
 export { ensureLspPatch } from '../lib/lsp-patch.js';
 export { detectMultiplexer } from '../lib/multiplexer.js';
+export { REPL_NESTING_VARS } from '../lib/env-sanitizer.js';
 export { readSentinelExitCode, waitForSentinelFile } from '../lib/runtime/sentinel-ipc.js';
 export { findExecutable } from '../lib/runtime/subprocess-utils.js';
 export { quoteForSh } from '../lib/shell-quoting.js';

package/dist/templates/CLAUDE.md

@@ -27,7 +27,6 @@ packages/cli/src/templates/
 │       ├── runtime/                  #   Core runtime helpers
 │       ├── context/                  #   Context CRUD, selection, formatting, plans, tasks
 │       ├── hooks/                    #   Hook utility APIs
-│       ├── agent-exec/               #   Agent execution backends
 │       └── templates/                #   Output formatters, plan context templates
 │
 ├── cc-native/                        # CC-Native method template