aiwcli 0.15.4 → 0.15.7

package/dist/lib/hooks-merger.js

@@ -1,22 +1,33 @@
 import { mergeArraysWithDedup, mergeConfigByEventType } from './generic-merge.js';
 /**
- * Check if two hook commands are equivalent
+ * Check if two hook actions are equivalent
  */
-function areHookCommandsEqual(a, b) {
-    return a.type === b.type && a.command === b.command && a.timeout === b.timeout;
+function areHookActionsEqual(a, b) {
+    if (a.type !== b.type)
+        return false;
+    if (a.type === 'command') {
+        return (b.type === 'command' &&
+            a.command === b.command &&
+            a.timeout === b.timeout &&
+            a.async === b.async &&
+            a.blockOnFail === b.blockOnFail);
+    }
+    return b.type === 'prompt' && a.prompt === b.prompt && a.timeout === b.timeout && a.async === b.async;
 }
 /**
  * Check if two hook matchers are equivalent
  */
 function areHookMatchersEqual(a, b) {
-    if (a.matcher !== b.matcher || a.once !== b.once) {
+    const matcherA = a.matcher ?? '*';
+    const matcherB = b.matcher ?? '*';
+    if (matcherA !== matcherB || a.once !== b.once) {
         return false;
     }
     if (a.hooks.length !== b.hooks.length) {
         return false;
     }
     // Check if all hooks are equivalent (order-independent)
-    return a.hooks.every((hookA) => b.hooks.some((hookB) => areHookCommandsEqual(hookA, hookB)));
+    return a.hooks.every((hookA) => b.hooks.some((hookB) => areHookActionsEqual(hookA, hookB)));
 }
 /**
  * Merge hooks configurations from template into existing
@@ -65,30 +76,25 @@ export function mergeClaudeSettings(existing, template) {
         ...existing.env,
         ...template.env,
     };
-    // Merge enabled plugins (template values override)
-    const mergedEnabledPlugins = {
-        ...existing.enabledPlugins,
-        ...template.enabledPlugins,
-    };
+    // Merge enabled plugins only if template explicitly defines them
+    const mergedEnabledPlugins = template.enabledPlugins && Object.keys(template.enabledPlugins).length > 0
+        ? { ...existing.enabledPlugins, ...template.enabledPlugins }
+        : existing.enabledPlugins;
     // Merge hooks using dedicated function
     const mergedHooks = mergeHooks(existing.hooks, template.hooks);
-    // Merge methods tracking (existing takes precedence, template adds new)
-    const mergedMethods = {
-        ...template.methods,
-        ...existing.methods,
-    };
     // Create merged settings
     const merged = {
         ...existing,
         ...template,
         permissions: mergedPermissions,
         env: mergedEnv,
-        enabledPlugins: mergedEnabledPlugins,
         hooks: mergedHooks,
     };
-    // Only add methods if there are any (avoid setting to undefined)
-    if (Object.keys(mergedMethods).length > 0) {
-        merged.methods = mergedMethods;
+    // Only add enabledPlugins if there are unknown (avoid overriding user-scoped plugins)
+    if (mergedEnabledPlugins && Object.keys(mergedEnabledPlugins).length > 0) {
+        merged.enabledPlugins = mergedEnabledPlugins;
     }
+    // Drop legacy install metadata from prior settings files.
+    delete merged.methods;
     return merged;
 }

package/dist/lib/ide-path-resolver.d.ts

@@ -30,10 +30,16 @@ export declare class IdePathResolver {
     /**
      * Get path to a folder within the .aiwcli container
      *
-     * @param folderName - Folder name within .aiwcli (e.g., '_shared', '_bmad')
+     * @param folderName - Folder name within .aiwcli (e.g., '_core', '_bmad')
      * @returns Absolute path to the folder
      */
     getAiwcliFolder(folderName: string): string;
+    /**
+     * Get the .aiwcli/state directory path
+     *
+     * @returns Absolute path to .aiwcli/state directory
+     */
+    getAiwcliStateDir(): string;
     /**
      * Get path to a file/folder within .claude directory
      *
@@ -53,6 +59,12 @@ export declare class IdePathResolver {
      * @returns Absolute path to Claude settings file
      */
     getClaudeSettings(): string;
+    /**
+     * Get the core runtime folder path within .aiwcli
+     *
+     * @returns Absolute path to _core directory
+     */
+    getCoreFolder(): string;
     /**
      * Get IDE directory path by IDE name
      *
@@ -60,6 +72,12 @@ export declare class IdePathResolver {
      * @returns Absolute path to IDE directory
      */
     getIdeDir(ideName: string): string;
+    /**
+     * Get install state file path.
+     *
+     * @returns Absolute path to install-state.json
+     */
+    getInstallStatePath(): string;
     /**
      * Get method-specific folder path within .aiwcli
      * Convention: _{methodName} (e.g., _bmad, _gsd, _cc-native)
@@ -74,12 +92,6 @@ export declare class IdePathResolver {
      * @returns Absolute path to project root
      */
     getProjectRoot(): string;
-    /**
-     * Get the shared folder path within .aiwcli
-     *
-     * @returns Absolute path to _shared directory
-     */
-    getSharedFolder(): string;
     /**
      * Get path to a file/folder within .windsurf directory
      *

package/dist/lib/ide-path-resolver.js

@@ -35,12 +35,20 @@ export class IdePathResolver {
     /**
      * Get path to a folder within the .aiwcli container
      *
-     * @param folderName - Folder name within .aiwcli (e.g., '_shared', '_bmad')
+     * @param folderName - Folder name within .aiwcli (e.g., '_core', '_bmad')
      * @returns Absolute path to the folder
      */
     getAiwcliFolder(folderName) {
         return join(this.getAiwcliContainer(), folderName);
     }
+    /**
+     * Get the .aiwcli/state directory path
+     *
+     * @returns Absolute path to .aiwcli/state directory
+     */
+    getAiwcliStateDir() {
+        return join(this.getAiwcliContainer(), 'state');
+    }
     /**
      * Get path to a file/folder within .claude directory
      *
@@ -66,6 +74,14 @@ export class IdePathResolver {
     getClaudeSettings() {
         return this.getClaude('settings.json');
     }
+    /**
+     * Get the core runtime folder path within .aiwcli
+     *
+     * @returns Absolute path to _core directory
+     */
+    getCoreFolder() {
+        return this.getAiwcliFolder('_core');
+    }
     /**
      * Get IDE directory path by IDE name
      *
@@ -75,6 +91,14 @@ export class IdePathResolver {
     getIdeDir(ideName) {
         return join(this.projectRoot, `.${ideName}`);
     }
+    /**
+     * Get install state file path.
+     *
+     * @returns Absolute path to install-state.json
+     */
+    getInstallStatePath() {
+        return join(this.getAiwcliStateDir(), 'install-state.json');
+    }
     /**
      * Get method-specific folder path within .aiwcli
      * Convention: _{methodName} (e.g., _bmad, _gsd, _cc-native)
@@ -93,14 +117,6 @@ export class IdePathResolver {
     getProjectRoot() {
         return this.projectRoot;
     }
-    /**
-     * Get the shared folder path within .aiwcli
-     *
-     * @returns Absolute path to _shared directory
-     */
-    getSharedFolder() {
-        return this.getAiwcliFolder('_shared');
-    }
     /**
      * Get path to a file/folder within .windsurf directory
      *

package/dist/lib/install-state.d.ts

@@ -0,0 +1,34 @@
+interface CoreState {
+    assetVersion: string;
+    installed: boolean;
+    installedAt: string;
+}
+interface IdeState {
+    managed: boolean;
+}
+interface MethodState {
+    idePaths: string[];
+    ides: string[];
+    installed: boolean;
+    installedAt: string;
+    runtimePaths: string[];
+}
+export interface InstallState {
+    core: CoreState;
+    ides: Record<string, IdeState>;
+    initializedAt: string;
+    methods: Record<string, MethodState>;
+    updatedAt: string;
+    version: 1;
+}
+export declare function readInstallState(targetDir: string): Promise<InstallState | undefined>;
+export declare function writeInstallState(targetDir: string, state: InstallState): Promise<void>;
+export declare function ensureInstallState(targetDir: string): Promise<InstallState>;
+export declare function markCoreInstalled(targetDir: string, ides: string[]): Promise<void>;
+export declare function markCoreRemoved(targetDir: string): Promise<void>;
+export declare function markMethodInstalled(targetDir: string, method: string, ides: string[]): Promise<void>;
+export declare function markMethodRemoved(targetDir: string, method: string): Promise<void>;
+export declare function getInstalledMethodsFromState(targetDir: string): Promise<string[]>;
+export declare function getInstalledMethods(targetDir: string): Promise<string[]>;
+export declare function deleteInstallStateIfPresent(targetDir: string): Promise<void>;
+export {};

package/dist/lib/install-state.js

@@ -0,0 +1,161 @@
+import { promises as fs } from 'node:fs';
+import { IdePathResolver } from './ide-path-resolver.js';
+import { pathExists } from './paths.js';
+const CORE_RUNTIME_FOLDERS = new Set(['_core']);
+const RESERVED_AIWCLI_FOLDERS = new Set(['_output', 'state', ...CORE_RUNTIME_FOLDERS]);
+const VERSION = 1;
+export async function readInstallState(targetDir) {
+    const statePath = new IdePathResolver(targetDir).getInstallStatePath();
+    try {
+        const content = await fs.readFile(statePath, 'utf8');
+        const parsed = JSON.parse(content);
+        if (parsed.version !== VERSION || !parsed.core || !parsed.methods || !parsed.ides)
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function writeInstallState(targetDir, state) {
+    const resolver = new IdePathResolver(targetDir);
+    const statePath = resolver.getInstallStatePath();
+    await fs.mkdir(resolver.getAiwcliStateDir(), { recursive: true });
+    await fs.writeFile(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+export async function ensureInstallState(targetDir) {
+    const existing = await readInstallState(targetDir);
+    if (existing)
+        return existing;
+    const now = new Date().toISOString();
+    const initial = {
+        version: VERSION,
+        initializedAt: now,
+        updatedAt: now,
+        core: {
+            installed: await hasLegacyCoreRuntime(targetDir),
+            assetVersion: 'v1',
+            installedAt: now,
+        },
+        methods: await discoverLegacyMethods(targetDir, now),
+        ides: {},
+    };
+    return initial;
+}
+export async function markCoreInstalled(targetDir, ides) {
+    const state = await ensureInstallState(targetDir);
+    const now = new Date().toISOString();
+    await backfillMissingMethodsFromDisk(targetDir, state, now);
+    state.core = { installed: true, assetVersion: 'v1', installedAt: now };
+    for (const ide of ides) {
+        state.ides[ide] = { managed: true };
+    }
+    state.updatedAt = now;
+    await writeInstallState(targetDir, state);
+}
+export async function markCoreRemoved(targetDir) {
+    const state = await readInstallState(targetDir);
+    if (!state)
+        return;
+    state.core.installed = false;
+    state.updatedAt = new Date().toISOString();
+    await writeInstallState(targetDir, state);
+}
+export async function markMethodInstalled(targetDir, method, ides) {
+    const state = await ensureInstallState(targetDir);
+    const now = new Date().toISOString();
+    await backfillMissingMethodsFromDisk(targetDir, state, now);
+    state.methods[method] = {
+        installed: true,
+        installedAt: now,
+        ides: [...ides],
+        runtimePaths: [`.aiwcli/_${method}`],
+        idePaths: ides.flatMap((ide) => ideRootPaths(ide, method)),
+    };
+    for (const ide of ides) {
+        state.ides[ide] = { managed: true };
+    }
+    state.updatedAt = now;
+    await writeInstallState(targetDir, state);
+}
+export async function markMethodRemoved(targetDir, method) {
+    const state = await ensureInstallState(targetDir);
+    const now = new Date().toISOString();
+    await backfillMissingMethodsFromDisk(targetDir, state, now);
+    if (method in state.methods) {
+        delete state.methods[method];
+        state.updatedAt = now;
+        await writeInstallState(targetDir, state);
+    }
+}
+export async function getInstalledMethodsFromState(targetDir) {
+    const state = await readInstallState(targetDir);
+    if (!state)
+        return [];
+    return Object.entries(state.methods)
+        .filter(([, methodState]) => methodState.installed)
+        .map(([name]) => name);
+}
+export async function getInstalledMethods(targetDir) {
+    const installed = await getInstalledMethodsFromState(targetDir);
+    if (installed.length > 0)
+        return installed;
+    return discoverLegacyMethodNames(targetDir);
+}
+export async function deleteInstallStateIfPresent(targetDir) {
+    const resolver = new IdePathResolver(targetDir);
+    const stateDir = resolver.getAiwcliStateDir();
+    const statePath = resolver.getInstallStatePath();
+    if (!(await pathExists(statePath)))
+        return;
+    await fs.rm(statePath, { force: true });
+    try {
+        if ((await fs.readdir(stateDir)).length === 0)
+            await fs.rmdir(stateDir);
+    }
+    catch {
+        // Ignore cleanup errors for missing/non-empty state directories.
+    }
+}
+async function backfillMissingMethodsFromDisk(targetDir, state, installedAt) {
+    const discoveredMethods = await discoverLegacyMethods(targetDir, installedAt);
+    for (const [method, methodState] of Object.entries(discoveredMethods)) {
+        state.methods[method] ??= methodState;
+    }
+}
+async function discoverLegacyMethods(targetDir, installedAt) {
+    const methodNames = await discoverLegacyMethodNames(targetDir);
+    return Object.fromEntries(methodNames.map((method) => [method, {
+            installed: true,
+            installedAt,
+            ides: [],
+            runtimePaths: [`.aiwcli/_${method}`],
+            idePaths: [],
+        }]));
+}
+async function discoverLegacyMethodNames(targetDir) {
+    const containerDir = new IdePathResolver(targetDir).getAiwcliContainer();
+    try {
+        const entries = await fs.readdir(containerDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith('_') && !RESERVED_AIWCLI_FOLDERS.has(entry.name))
+            .map((entry) => entry.name.slice(1))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+async function hasLegacyCoreRuntime(targetDir) {
+    const resolver = new IdePathResolver(targetDir);
+    return pathExists(resolver.getCoreFolder());
+}
+function ideRootPaths(ide, method) {
+    if (ide === 'claude')
+        return [`.claude/commands/${method}`, `.claude/agents/${method}`];
+    if (ide === 'codex')
+        return [];
+    if (ide === 'windsurf')
+        return [`.windsurf/workflows/${method}`];
+    return [`.${ide}/${method}`];
+}

package/dist/lib/launch-options.d.ts

@@ -0,0 +1 @@
+export { buildSpawnedWindowArgs, type BuildSpawnedWindowArgsParams, buildUniqueSessionName, parseExtraEnv, resolvePromptText, sanitizeSessionName, } from '../capabilities/launch/runtime-core/launch-options.js';

package/dist/lib/launch-options.js

@@ -0,0 +1 @@
+export { buildSpawnedWindowArgs, buildUniqueSessionName, parseExtraEnv, resolvePromptText, sanitizeSessionName, } from '../capabilities/launch/runtime-core/launch-options.js';

package/dist/lib/lsp-patch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Patches the npm-installed Claude Code cli.js to add `shell: true` on Windows
+ * for LSP subprocess spawning, then renames the native binary so the npm shim
+ * takes precedence on PATH.
+ *
+ * Safe ordering: locate → backup → patch → verify → rename.
+ * Never throws. On unknown failure, emits a warning and returns.
+ */
+export declare function ensureLspPatch(options: {
+    debugLog: (msg: string) => void;
+    warn: (msg: string) => void;
+}): Promise<void>;

package/dist/lib/lsp-patch.js

@@ -0,0 +1,156 @@
+import { execSync } from 'node:child_process';
+import { copyFileSync, existsSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import * as os from 'node:os';
+import path from 'node:path';
+// Temporary workaround until upstream LSP spawn bug is fixed.
+// Tracks: https://github.com/anthropics/claude-code/issues/17136
+//         https://github.com/anthropics/claude-code/issues/19658
+/**
+ * Regex matching the LSP spawn options in Claude Code's bundled cli.js.
+ * The single-letter variable name changes across versions (X in v2.1.63, D in v2.1.69),
+ * so we capture the variable name dynamically.
+ */
+const SPAWN_PATTERN = /\{stdio:\["pipe","pipe","pipe"\],env:([A-Za-z_$][\w$]*)\?\.env\?\{\.\.\.globalThis\.process\.env,\.\.\.\1\.env\}:void 0,cwd:\1\?\.cwd,windowsHide:!0\}/;
+/** Build the replacement string with the captured variable name and shell:true. */
+function buildReplacement(varName) {
+    return `{stdio:["pipe","pipe","pipe"],env:${varName}?.env?{...globalThis.process.env,...${varName}.env}:void 0,cwd:${varName}?.cwd,windowsHide:!0,shell:process.platform==="win32"}`;
+}
+/**
+ * Patches the npm-installed Claude Code cli.js to add `shell: true` on Windows
+ * for LSP subprocess spawning, then renames the native binary so the npm shim
+ * takes precedence on PATH.
+ *
+ * Safe ordering: locate → backup → patch → verify → rename.
+ * Never throws. On unknown failure, emits a warning and returns.
+ */
+export async function ensureLspPatch(options) {
+    const { debugLog, warn } = options;
+    try {
+        // Step 1 — Guard: only applies on Windows
+        if (process.platform !== 'win32')
+            return;
+        // Step 2 — Locate npm cli.js
+        let npmPrefix;
+        try {
+            npmPrefix = execSync('npm config get prefix', { timeout: 3000, encoding: 'utf8' }).trim();
+        }
+        catch {
+            debugLog('LSP patch: could not determine npm prefix, skipping');
+            return;
+        }
+        const cliJsPath = path.join(npmPrefix, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+        if (!existsSync(cliJsPath)) {
+            warn('Windows LSP fix requires: npm i -g @anthropic-ai/claude-code');
+            return;
+        }
+        // Step 3 — Locate npm shim
+        const shimPath = path.join(npmPrefix, 'claude.cmd');
+        if (!existsSync(shimPath)) {
+            warn('npm claude.cmd shim not found, skipping LSP patch');
+            return;
+        }
+        // Step 4 — Read cli.js and check patch status
+        let content;
+        try {
+            content = readFileSync(cliJsPath, 'utf8');
+        }
+        catch {
+            warn('LSP patch: cannot read cli.js, skipping');
+            return;
+        }
+        if (content.includes('shell:process.platform==="win32"')) {
+            debugLog('LSP patch: already applied');
+            renamNativeBinary(debugLog, warn);
+            return;
+        }
+        // Step 5 — Patch cli.js (with diagnostic detection)
+        const match = SPAWN_PATTERN.exec(content);
+        if (!match) {
+            // Distinguish: upstream fixed vs pattern restructured
+            if (content.includes('shell:process.platform==="win32"') || content.includes("shell:process.platform==='win32'")) {
+                // Upstream added shell:true natively — patch is obsolete
+                debugLog('LSP patch: upstream now includes shell:true — patch no longer needed!');
+                renamNativeBinary(debugLog, warn);
+                return;
+            }
+            // Pattern restructured — needs manual update
+            const spawnSnippet = content.match(/\{stdio:\["pipe","pipe","pipe"\][^}]{0,200}\}/)?.[0] ?? '(spawn pattern not found)';
+            warn(`LSP patch: spawn pattern changed in new Claude Code version — manual update needed.\n` +
+                `  Current pattern: ${spawnSnippet}\n` +
+                `  Update SPAWN_PATTERN in: packages/cli/src/lib/lsp-patch.ts`);
+            return;
+        }
+        const patched = content.replace(SPAWN_PATTERN, buildReplacement(match[1]));
+        // Backup original (only if .bak doesn't already exist)
+        const bakPath = cliJsPath + '.bak';
+        if (!existsSync(bakPath)) {
+            try {
+                copyFileSync(cliJsPath, bakPath);
+                debugLog(`LSP patch: backed up cli.js to ${bakPath}`);
+            }
+            catch {
+                // Non-fatal — continue with patch
+                debugLog('LSP patch: could not create backup, continuing');
+            }
+        }
+        // Atomic write: write to tmp, then rename over original
+        const tmpPath = cliJsPath + '.tmp';
+        try {
+            writeFileSync(tmpPath, patched, 'utf8');
+            renameSync(tmpPath, cliJsPath);
+            debugLog('LSP patch: applied successfully');
+        }
+        catch (error) {
+            const { code } = error;
+            if (code === 'EACCES' || code === 'EPERM') {
+                warn('LSP patch: permission denied writing cli.js');
+            }
+            else {
+                warn(`LSP patch: write failed — ${code ?? error}`);
+            }
+            return;
+        }
+        // Step 6 — Rename native binary
+        renamNativeBinary(debugLog, warn);
+    }
+    catch (error) {
+        // Catch-all: never let this function throw
+        warn(`LSP patch: unexpected error — ${error}`);
+    }
+}
+/**
+ * Renames the native Claude binary in ~/.local/bin/ so the npm shim
+ * (which points to the patched cli.js) takes precedence on PATH.
+ */
+function renamNativeBinary(debugLog, warn) {
+    const localBin = path.join(os.homedir(), '.local', 'bin');
+    for (const name of ['claude.exe', 'claude']) {
+        const src = path.join(localBin, name);
+        if (!existsSync(src))
+            continue;
+        try {
+            const stat = statSync(src);
+            // Native Bun binary is ~242MB; npm shim is tiny
+            if (stat.size <= 1_000_000)
+                continue;
+            const ext = path.extname(name);
+            const base = path.basename(name, ext);
+            const target = path.join(localBin, `${base}-native${ext}`);
+            if (existsSync(target)) {
+                debugLog(`LSP patch: ${target} already exists, skipping rename`);
+                continue;
+            }
+            renameSync(src, target);
+            debugLog(`LSP patch: renamed ${src} → ${target}`);
+        }
+        catch (error) {
+            const { code } = error;
+            if (code === 'EACCES' || code === 'EPERM') {
+                warn(`Cannot rename ${src} — rename manually to ${src.replace(name, name.replace('claude', 'claude-native'))}`);
+            }
+            else {
+                debugLog(`LSP patch: rename failed for ${src} — ${code ?? error}`);
+            }
+        }
+    }
+}

package/dist/lib/multiplexer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Unified multiplexer abstraction.
+ * Single interface for tmux (Unix) and psmux (Windows) backends.
+ * Factory: detectMultiplexer() → Multiplexer | null
+ */
+export type MultiplexerBackend = 'psmux' | 'tmux';
+export type SplitDirection = 'auto' | 'h' | 'v';
+export interface SplitPaneOptions {
+    args: string[];
+    autoClose?: boolean | undefined;
+    cwd?: string | undefined;
+    env?: Record<string, string> | undefined;
+    holdMessage?: string | undefined;
+    holdPane?: boolean | undefined;
+    mode?: 'exec' | 'repl' | undefined;
+    promptPath?: string | undefined;
+    sentinel?: boolean | undefined;
+    split?: SplitDirection | undefined;
+    splitTarget?: string | undefined;
+    toolName: string;
+}
+export interface SplitPaneResult {
+    backend: MultiplexerBackend;
+    exitCode?: number | undefined;
+    launched: boolean;
+    paneId?: string | undefined;
+    reason?: string | undefined;
+    sentinelPath?: string | undefined;
+    stderr?: string | undefined;
+}
+export interface CreateSessionOptions {
+    enableMouse?: boolean | undefined;
+    promptText?: string | undefined;
+    reattach?: boolean | undefined;
+    sessionName: string;
+    toolArgs: string[];
+    toolPath: string;
+}
+export interface CreateSessionResult {
+    exitCode: number;
+    reason?: string | undefined;
+    usedMux: boolean;
+}
+export interface Multiplexer {
+    readonly backend: MultiplexerBackend;
+    createSession(options: CreateSessionOptions): Promise<CreateSessionResult>;
+    isInsideSession(): boolean;
+    kill(paneId: string): Promise<void>;
+    splitPane(options: SplitPaneOptions): Promise<SplitPaneResult>;
+}
+/**
+ * Detect the best available multiplexer for the current platform.
+ * Windows → PsmuxMultiplexer (if installed and meets version requirement)
+ * Unix → TmuxMultiplexer (if tmux binary on PATH)
+ * Returns null if no multiplexer is available.
+ */
+export declare function detectMultiplexer(platform?: NodeJS.Platform): Promise<Multiplexer | null>;

package/dist/lib/multiplexer.js

@@ -0,0 +1,19 @@
+/**
+ * Unified multiplexer abstraction.
+ * Single interface for tmux (Unix) and psmux (Windows) backends.
+ * Factory: detectMultiplexer() → Multiplexer | null
+ */
+/**
+ * Detect the best available multiplexer for the current platform.
+ * Windows → PsmuxMultiplexer (if installed and meets version requirement)
+ * Unix → TmuxMultiplexer (if tmux binary on PATH)
+ * Returns null if no multiplexer is available.
+ */
+export async function detectMultiplexer(platform = process.platform) {
+    if (platform === 'win32') {
+        const { PsmuxMultiplexer } = await import('./multiplexers/psmux.js');
+        return PsmuxMultiplexer.create();
+    }
+    const { TmuxMultiplexer } = await import('./multiplexers/tmux.js');
+    return TmuxMultiplexer.create();
+}