aiwcli 0.15.7 → 0.17.0

package/dist/lib/multiplexers/psmux.js

@@ -1,15 +1,15 @@
 /**
  * PsmuxMultiplexer — unified psmux (Windows ConPTY) backend.
- * Consolidates PsmuxLauncher + launchInPsmuxSession + command building from pane-driver.
+ * Composes with PowerShellAdapter for command building.
+ * Owns: version checking, session readiness polling, bootstrap defaults.
  */
 import { existsSync, readdirSync, writeFileSync } from 'node:fs';
 import * as os from 'node:os';
 import path from 'node:path';
-import { cleanClaudeEnv, getLastLine, spawnAttached, splitFlagFromDimensions } from '../mux-utils.js';
-import { cleanupSentinelIpc, createSentinelIpcPaths } from '../runtime/sentinel-ipc.js';
+import { sanitizedProcessEnv } from '../env-sanitizer.js';
+import { PANE_HOLD_MESSAGE, buildBootstrapPrompt, getLastLine, spawnAttached, splitFlagFromDimensions } from '../mux-utils.js';
 import { execFileAsync, findExecutable } from '../runtime/subprocess-utils.js';
-import { wrapSentinelPowerShell } from '../sentinel-wrapper.js';
-import { quoteForPowerShell, toEncodedPowerShell } from '../shell-quoting.js';
+import { PowerShellAdapter } from '../shell-adapters/powershell-adapter.js';
 const MIN_VERSION = { major: 0, minor: 4, patch: 0 };
 const ATTACH_RETRY_DELAY_MS = 200;
 const SESSION_READY_BACKOFF_MS = [50, 100, 150, 250];
@@ -37,27 +37,9 @@ export function parseVersionString(stdout) {
         patch: Number(match[3]),
     };
 }
-/** @internal */
-export function buildCommandArgs(args, mode, promptPath) {
-    if (mode !== 'repl' || !promptPath)
-        return args;
-    const absolutePromptPath = path.resolve(promptPath);
-    const bootstrap = `Read startup instructions from this file path before taking action: ${formatPromptPathForBootstrap(absolutePromptPath)}. Use that file as the initial context.`;
-    return [...args, bootstrap];
-}
-/** @internal */
-export function buildPowerShellToolCommand(params) {
-    const { toolPath, args, env, mode, promptPath } = params;
-    const envPrefix = Object.entries(env)
-        .map(([key, value]) => `$env:${key}=${quoteForPowerShell(value)}`)
-        .join('; ');
-    const commandArgs = buildCommandArgs(args, mode, promptPath);
-    const argArray = commandArgs.map((arg) => quoteForPowerShell(arg)).join(', ');
-    const invocation = `& ${quoteForPowerShell(toolPath)}${argArray ? ` @(${argArray})` : ''}`;
-    const body = mode === 'exec' && promptPath
-        ? `Get-Content -Raw -Path ${quoteForPowerShell(promptPath)} | ${invocation}`
-        : invocation;
-    return [envPrefix, body].filter(Boolean).join('; ');
+/** @internal — translate unified SplitDirection to psmux flag. */
+export function toPsmuxSplitFlag(direction) {
+    return direction === 'horizontal' ? '-h' : '-v';
 }
 /** @internal */
 export function buildCreateSessionArgs(params) {
@@ -82,15 +64,11 @@ export function buildAttachArgs(sessionName) {
 export class PsmuxMultiplexer {
     backend = 'psmux';
     psmuxPath;
+    shell;
     constructor(psmuxPath) {
         this.psmuxPath = psmuxPath;
+        this.shell = new PowerShellAdapter();
     }
-    /**
-     * Check if psmux is installed and meets version requirements.
-     * Checks PATH first, then probes the winget install directory
-     * (winget install doesn't always add packages to PATH).
-     * Returns a PsmuxMultiplexer instance or null.
-     */
     static async create() {
         if (process.platform !== 'win32')
             return null;
@@ -107,48 +85,40 @@ export class PsmuxMultiplexer {
             return null;
         return new PsmuxMultiplexer(psmuxPath);
     }
-    /**
-     * Create a new psmux session.
-     * Injects PSMUX_PANE=1 into the PowerShell command so child processes
-     * can detect they're inside a psmux session.
-     */
+    resolveStrategy(ctx) {
+        if (ctx.disableMux) {
+            return { strategy: 'inline', reason: 'Multiplexer disabled via --no-tmux' };
+        }
+        if (Boolean(process.env.PSMUX_PANE)) {
+            return { strategy: 'split', reason: 'Inside psmux session' };
+        }
+        return { strategy: 'create-session', reason: 'Outside psmux — will create new session' };
+    }
     async createSession(options) {
-        const { sessionName, reattach, enableMouse = true } = options;
+        const { sessionName, reattach, enableMouse = true, cwd } = options;
         let promptFilePath;
         if (options.promptText) {
             promptFilePath = path.join(os.tmpdir(), `aiwcli-prompt-${Date.now()}-${process.pid}.txt`);
             writeFileSync(promptFilePath, options.promptText, { encoding: 'utf8', mode: 0o600 });
         }
-        // Build the PowerShell command to run inside the psmux session
-        const shellCommand = buildPsmuxShellCommand(options, promptFilePath);
-        // Inject PSMUX_PANE=1 for inside-session detection
-        const commandWithEnv = `$env:PSMUX_PANE='1'; ${shellCommand}`;
+        const shellCommand = buildPsmuxShellCommand(this.shell, options, promptFilePath);
+        // Inject PSMUX_PANE=1 for inside-session detection + nesting cleanup
+        const nestingCleanup = this.shell.buildNestingCleanup();
+        const commandWithEnv = `$env:PSMUX_PANE='1'; ${nestingCleanup} ${shellCommand}`;
         const psmuxArgs = buildCreateSessionArgs({
             sessionName,
-            cwd: process.cwd(),
-            encodedCommand: toEncodedPowerShell(commandWithEnv),
+            cwd,
+            encodedCommand: this.shell.encodeForExecution(commandWithEnv),
         });
-        if (reattach) {
-            const exists = await this.hasSession(sessionName);
-            if (!exists) {
-                const detachedCreate = await execFileAsync(this.psmuxPath, psmuxArgs, { timeout: 5000 });
-                if (detachedCreate.exitCode !== 0) {
-                    const stderr = detachedCreate.stderr.trim();
-                    return {
-                        exitCode: detachedCreate.exitCode ?? 1,
-                        usedMux: false,
-                        reason: stderr ? `psmux new-session failed: ${stderr}` : 'psmux new-session failed',
-                    };
-                }
-            }
-        }
-        else {
+        const shouldCreate = !reattach || !(await this.hasSession(sessionName));
+        if (shouldCreate) {
             const detachedCreate = await execFileAsync(this.psmuxPath, psmuxArgs, { timeout: 5000 });
             if (detachedCreate.exitCode !== 0) {
                 const stderr = detachedCreate.stderr.trim();
                 return {
+                    launched: false,
                     exitCode: detachedCreate.exitCode ?? 1,
-                    usedMux: false,
+                    backend: this.backend,
                     reason: stderr ? `psmux new-session failed: ${stderr}` : 'psmux new-session failed',
                 };
             }
@@ -156,112 +126,88 @@ export class PsmuxMultiplexer {
         const ready = await this.waitForSessionReady(sessionName);
         if (!ready) {
             return {
+                launched: false,
                 exitCode: 1,
-                usedMux: false,
+                backend: this.backend,
                 reason: `psmux session '${sessionName}' not ready for attach`,
             };
         }
         await this.applyBootstrapDefaults(enableMouse);
         const attachArgs = buildAttachArgs(sessionName);
-        const env = cleanClaudeEnv();
+        const env = sanitizedProcessEnv();
         const firstAttach = await spawnAttached(this.psmuxPath, attachArgs, env, this.backend);
-        if (firstAttach.usedMux || firstAttach.exitCode !== 1)
+        if (firstAttach.launched || (firstAttach.exitCode !== undefined && firstAttach.exitCode !== 1))
             return firstAttach;
         await waitMs(ATTACH_RETRY_DELAY_MS);
         const secondAttach = await spawnAttached(this.psmuxPath, attachArgs, env, this.backend);
-        if (secondAttach.usedMux || secondAttach.exitCode !== 1)
+        if (secondAttach.launched || (secondAttach.exitCode !== undefined && secondAttach.exitCode !== 1))
             return secondAttach;
         return {
             ...secondAttach,
             reason: 'psmux attach failed after retry (auth/session readiness race)',
-            usedMux: false,
+            launched: false,
         };
     }
-    /**
-     * Detect if we're inside a psmux session we created.
-     * Uses PSMUX_PANE env var that we inject in createSession().
-     */
-    isInsideSession() {
-        return Boolean(process.env.PSMUX_PANE);
-    }
-    async kill(paneId) {
-        if (!paneId)
+    async kill(handle) {
+        if (!handle)
             return;
-        await execFileAsync(this.psmuxPath, ['kill-pane', '-t', paneId], { timeout: 3000 });
+        await execFileAsync(this.psmuxPath, ['kill-pane', '-t', handle], { timeout: 3000 });
     }
-    async splitPane(options) {
-        const mode = options.mode ?? 'repl';
-        const args = options.args ?? [];
-        const envVars = options.env ?? {};
-        const cwd = options.cwd ?? process.cwd();
-        // Resolve tool path — psmux uses native Windows paths directly
-        const toolPath = findExecutable(options.toolName);
-        if (!toolPath) {
-            return { launched: false, backend: this.backend, reason: `${options.toolName} not found on PATH` };
+    async split(options) {
+        const { toolName, args, env, cwd, mode, sentinelPath } = options;
+        const nativePath = findExecutable(toolName);
+        if (!nativePath) {
+            return { launched: false, backend: this.backend, reason: `${toolName} not found on PATH` };
         }
-        // Sentinel IPC
-        const useSentinel = options.sentinel !== false;
-        const sentinel = useSentinel ? createSentinelIpcPaths(`aiwcli-pane-${options.toolName}`) : null;
         try {
-            const baseCommand = buildPowerShellToolCommand({
-                toolPath,
+            const baseCommand = this.shell.buildToolCommand({
+                toolPath: nativePath,
                 args,
-                env: envVars,
+                env,
                 mode,
                 ...(options.promptPath ? { promptPath: options.promptPath } : {}),
             });
-            let paneCommand = baseCommand;
-            if (sentinel) {
-                const holdMessage = options.holdMessage ?? '[aiwcli] Driver exited. Pane held open.';
-                paneCommand = wrapSentinelPowerShell({
-                    command: baseCommand,
-                    sentinelPath: sentinel.sentinelPath,
-                    autoClose: Boolean(options.autoClose),
-                    holdPane: Boolean(options.holdPane),
-                    holdMessage,
-                });
-            }
-            // Wrap in PowerShell using -EncodedCommand to avoid double-quote expansion issues
-            const effectivePaneCommand = toEncodedPowerShell(paneCommand);
+            const holdMessage = PANE_HOLD_MESSAGE;
+            const wrappedCommand = this.shell.wrapSentinel({
+                command: baseCommand,
+                sentinelPath,
+                autoClose: false,
+                holdPane: false,
+                holdMessage,
+            });
+            const effectiveCommand = this.shell.encodeForExecution(wrappedCommand);
             // Resolve split direction
-            const splitDirection = options.split ?? 'auto';
+            const splitDirection = options.split;
             let splitFlag;
             if (splitDirection === 'auto') {
                 splitFlag = await this.resolveAutoSplit();
             }
             else {
-                splitFlag = splitDirection === 'v' ? '-v' : '-h';
+                splitFlag = toPsmuxSplitFlag(splitDirection);
             }
             await this.applyBootstrapDefaults();
-            // Build psmux split-window command
             const psmuxArgs = buildSplitWindowArgs({
                 splitFlag,
-                encodedCommand: effectivePaneCommand,
+                encodedCommand: effectiveCommand,
                 cwd,
-                splitTarget: options.splitTarget,
             });
             const split = await execFileAsync(this.psmuxPath, psmuxArgs, { timeout: 5000 });
             if (split.exitCode !== 0) {
-                if (sentinel)
-                    cleanupSentinelIpc(sentinel);
                 return {
                     launched: false,
                     backend: this.backend,
                     reason: 'psmux split-window failed',
-                    stderr: split.stderr.trim() || undefined,
                 };
             }
-            const paneId = getLastLine(split.stdout) || undefined;
+            const handle = getLastLine(split.stdout) || undefined;
             return {
                 launched: true,
                 backend: this.backend,
-                paneId,
-                sentinelPath: sentinel?.sentinelPath,
+                handle,
+                sentinelPath,
             };
         }
         catch (error) {
-            if (sentinel)
-                cleanupSentinelIpc(sentinel);
             return {
                 launched: false,
                 backend: this.backend,
@@ -314,9 +260,6 @@ export class PsmuxMultiplexer {
         return poll(0);
     }
 }
-// Probe winget package dir for psmux.exe.
-// winget install drops the binary under %LOCALAPPDATA%/Microsoft/WinGet/Packages/
-// but does not always add it to PATH.
 function findPsmuxInWinget() {
     const localAppData = process.env.LOCALAPPDATA;
     if (!localAppData)
@@ -346,25 +289,22 @@ export function buildPsmuxBootstrapCommands(enableMouse = true) {
     return commands;
 }
 /** @internal */
-export function buildPsmuxShellCommand(opts, promptFilePath) {
+export function buildPsmuxShellCommand(shell, opts, promptFilePath) {
     const { toolPath, toolArgs } = opts;
     const cmdParts = [];
-    cmdParts.push(`& ${quoteForPowerShell(toolPath)}`);
+    cmdParts.push(`& ${shell.quote(toolPath)}`);
     for (const arg of toolArgs) {
-        cmdParts.push(quoteForPowerShell(arg));
+        cmdParts.push(shell.quote(arg));
     }
     if (promptFilePath) {
-        const bootstrap = `Read startup instructions from this file path before taking action: ${formatPromptPathForBootstrap(promptFilePath)}. Use that file as the initial context.`;
-        cmdParts.push(quoteForPowerShell(bootstrap));
+        const formatted = process.platform === 'win32'
+            ? promptFilePath.replaceAll('\\', '/')
+            : promptFilePath;
+        const bootstrap = buildBootstrapPrompt(formatted);
+        cmdParts.push(shell.quote(bootstrap));
     }
     return cmdParts.join(' ');
 }
-/** @internal */
-export function formatPromptPathForBootstrap(promptPath) {
-    if (process.platform !== 'win32')
-        return promptPath;
-    return promptPath.replaceAll('\\', '/');
-}
 async function runBootstrapCommands(psmuxPath, commands, index = 0) {
     const command = commands[index];
     if (!command)

package/dist/lib/multiplexers/tmux.d.ts

@@ -1,21 +1,12 @@
 /**
  * TmuxMultiplexer — unified tmux backend.
- * Consolidates TmuxLauncher + launchInTmuxSession + command building from pane-driver.
+ * Composes with BashAdapter for command building.
+ * Owns: split direction resolution, tmux session config, Windows bootstrap.
  */
-import type { CreateSessionOptions, CreateSessionResult, Multiplexer, SplitPaneOptions, SplitPaneResult } from '../multiplexer.js';
-/** @internal */
-export declare function buildEnvPrefix(env: Record<string, string>): string;
-/** @internal */
-export declare function buildShToolCommand(params: {
-    args: string[];
-    env: Record<string, string>;
-    mode: 'exec' | 'repl';
-    promptPath?: string;
-    promptText?: string | undefined;
-    toolPath: string;
-}): string;
-/** @internal */
-export declare function buildCommandArgs(args: string[], mode: 'exec' | 'repl', promptText?: string): string[];
+import type { CreateSessionOptions, LaunchResult, Multiplexer, ResolvedStrategy, SplitOptions, StrategyContext } from '../multiplexer.js';
+import { type TmuxSplitFlag } from '../tmux-pane-placement.js';
+/** @internal — translate unified SplitDirection to tmux flag. */
+export declare function toTmuxSplitFlag(direction: 'horizontal' | 'vertical'): TmuxSplitFlag;
 /** @internal */
 export declare function withWindowsTmuxBootstrap(command: string, platform?: NodeJS.Platform): string;
 /** @internal */
@@ -35,10 +26,11 @@ export declare function buildTmuxCreateSessionArgs(params: {
 export declare class TmuxMultiplexer implements Multiplexer {
     readonly backend: "tmux";
     private readonly tmuxPath;
+    private readonly shell;
     private constructor();
     static create(): null | TmuxMultiplexer;
-    createSession(options: CreateSessionOptions): Promise<CreateSessionResult>;
-    isInsideSession(): boolean;
-    kill(paneId: string): Promise<void>;
-    splitPane(options: SplitPaneOptions): Promise<SplitPaneResult>;
+    resolveStrategy(ctx: StrategyContext): ResolvedStrategy;
+    createSession(options: CreateSessionOptions): Promise<LaunchResult>;
+    kill(handle: string): Promise<void>;
+    split(options: SplitOptions): Promise<LaunchResult>;
 }