aiwcli 0.15.5 → 0.17.0

package/dist/capabilities/launch/control-plane/execute-launch.js

@@ -0,0 +1,261 @@
+import path from 'node:path';
+import { checkVersionCompatibility, detectMultiplexer, ensureLspPatch, findExecutable, findToolPath, getClaudeCodeVersion, launchTerminal, ProcessSpawnError, quoteForSh, spawnProcess, } from '../../../platform/launch.js';
+import { EXIT_CODES } from '../../../types/index.js';
+import { clearProcessNestingVars, isCalledFromRepl } from '../../../lib/env-sanitizer.js';
+import { PromptFileManager } from '../../../lib/prompt-file-manager.js';
+import { SentinelManager } from '../../../lib/sentinel-manager.js';
+import { formatPathWarning } from '../../../lib/spawn-errors.js';
+import { buildSpawnedWindowArgs, parseExtraEnv, resolvePromptText, } from '../runtime-core/launch-options.js';
+import { buildInlineArgs, buildSessionRequest, buildSplitRequest, formatSessionLaunchMessage, formatSplitSuccessMessage, formatVersionCheckMessages, QUICK_EXIT_THRESHOLD_MS, resolveInlineFallbackMessage, resolveSessionFallbackWarning, resolveToolConfig, resolveToolModeDebugMessage, shouldRetry, toJsonLaunchResult, } from '../runtime-core/launch-decisions.js';
+async function runPreflightWarmup(command, host) {
+    try {
+        const result = await spawnProcess(command, ['--version'], { stdio: 'pipe' });
+        host.debug(`${command} preflight: exit=${result}`);
+    }
+    catch {
+        host.debug(`${command} preflight failed (non-fatal)`);
+    }
+}
+async function spawnInlineWithRetry(command, args, retryOnQuickExit, host) {
+    if (retryOnQuickExit) {
+        await runPreflightWarmup(command, host);
+    }
+    const start = Date.now();
+    let exitCode = await spawnProcess(command, args);
+    if (retryOnQuickExit && shouldRetry(Date.now() - start)) {
+        host.debug(`${command} exited in <${QUICK_EXIT_THRESHOLD_MS}ms — retrying (first-run init behavior)`);
+        exitCode = await spawnProcess(command, args);
+    }
+    return exitCode;
+}
+export async function executeLaunch(request, dependencies) {
+    const { cwd, flags, interactiveTty, platform, readPromptFile } = request;
+    const { host, now, pid, tempDir, writePromptFile } = dependencies;
+    // 1. Capture REPL context BEFORE clearing env vars (injectable for testing)
+    const calledFromRepl = (dependencies.isCalledFromRepl ?? isCalledFromRepl)();
+    (dependencies.clearNestingVars ?? clearProcessNestingVars)();
+    // Pure decision: resolve tool config
+    const toolConfig = resolveToolConfig(flags, platform);
+    const { cliCommand, cliArgs, launchFlag, toolMode } = toolConfig;
+    const disableMux = flags['no-tmux'];
+    const wantJson = flags.json;
+    const wantWait = flags.wait;
+    if (toolConfig.needsLspPatch) {
+        await ensureLspPatch({
+            debugLog: (message) => host.debug(message),
+            warn(message) {
+                host.warn(message);
+            },
+        });
+    }
+    let extraEnv = {};
+    try {
+        extraEnv = parseExtraEnv(flags.env);
+    }
+    catch (error) {
+        host.error(error instanceof Error ? error.message : '--env must be a valid JSON object string', {
+            exit: EXIT_CODES.INVALID_USAGE,
+        });
+    }
+    const promptPath = flags['prompt-path']?.trim() || undefined;
+    const promptText = resolvePromptText(flags.prompt, flags['prompt-file'], readPromptFile);
+    // 2. Handle --new (terminal window)
+    if (flags.new) {
+        host.debug(`Launching new terminal in: ${cwd}`);
+        let promptFilePath;
+        if (!promptPath && promptText) {
+            promptFilePath = path.join(tempDir, `aiwcli-prompt-${now()}-${pid}.txt`);
+            writePromptFile(promptFilePath, promptText);
+        }
+        const launchArgs = buildSpawnedWindowArgs({
+            useCodex: flags.codex,
+            useDevin: flags.devin,
+            disableTmux: disableMux,
+            ...(promptPath ? { promptPath } : {}),
+            ...(promptFilePath ? { promptFilePath } : {}),
+            ...(flags.env ? { rawEnvJson: flags.env } : {}),
+            ...(flags['tmux-session'] ? { tmuxSessionFlag: flags['tmux-session'] } : {}),
+        });
+        const launchCmd = launchArgs.map((arg) => quoteForSh(arg)).join(' ');
+        const result = await launchTerminal({
+            cwd,
+            command: launchCmd,
+            windowsShellPreference: platform === 'win32' ? 'mintty' : 'default',
+            debugLog: (message) => host.debug(message),
+        });
+        if (!result.success) {
+            host.error(`Failed to launch new terminal: ${result.error}`, { exit: EXIT_CODES.GENERAL_ERROR });
+        }
+        host.log(`New terminal launched with aiw launch${launchFlag ? ` ${launchFlag}` : ''}`);
+        return;
+    }
+    const toolDebugMsg = resolveToolModeDebugMessage(toolMode);
+    if (toolDebugMsg)
+        host.debug(toolDebugMsg);
+    // 3. Detect multiplexer + version check
+    const [versionCheck, mux] = await Promise.all([
+        toolConfig.skipVersionCheck
+            ? null
+            : getClaudeCodeVersion().then((v) => checkVersionCompatibility(v)),
+        disableMux ? null : detectMultiplexer(platform),
+    ]);
+    if (versionCheck) {
+        const msgs = formatVersionCheckMessages(versionCheck);
+        for (const line of msgs.debugLines)
+            host.debug(line);
+        if (msgs.warning)
+            host.warn(msgs.warning);
+    }
+    // 4. Resolve strategy — backend decides
+    const resolved = mux?.resolveStrategy({ calledFromRepl, platform, disableMux })
+        ?? { strategy: 'inline', reason: 'No multiplexer available' };
+    if (!mux || resolved.strategy === 'inline' || resolved.strategy === 'unavailable') {
+        // Pure decision: resolve fallback message
+        host.logInfo(resolveInlineFallbackMessage({
+            disableMux,
+            hasMux: Boolean(mux),
+            interactiveTty,
+            platform,
+            resolvedReason: resolved.reason,
+        }));
+        try {
+            // Pure decision: build inline args
+            const inlineArgs = buildInlineArgs(cliArgs, toolMode, promptText, promptPath);
+            const exitCode = await spawnInlineWithRetry(cliCommand, inlineArgs, toolConfig.retryOnQuickExit, host);
+            host.exit(exitCode);
+        }
+        catch (error) {
+            if (error instanceof ProcessSpawnError) {
+                host.error(error.message, { exit: EXIT_CODES.ENVIRONMENT_ERROR });
+            }
+            host.error('Unexpected launch failure.', { exit: EXIT_CODES.GENERAL_ERROR });
+        }
+        return;
+    }
+    // Lifecycle managers
+    const sentinelMgr = new SentinelManager();
+    const promptMgr = new PromptFileManager({ tempDir, now, pid });
+    // When --json is used without --wait, sentinel ownership transfers to the
+    // JSON caller (e.g. skill scripts).  The CLI must NOT clean up the sentinel
+    // directory because the caller polls for sentinel.txt to detect pane close.
+    let sentinelOwnershipTransferred = false;
+    let exitCode = 0;
+    try {
+        const strategy = resolved.strategy;
+        if (strategy === 'split') {
+            // 5a. Split pane
+            host.logInfo(`Inside ${mux.backend} session — splitting new pane`);
+            const sentinelPath = sentinelMgr.create(cliCommand);
+            let effectivePromptPath = promptPath;
+            if (!effectivePromptPath && promptText) {
+                effectivePromptPath = promptMgr.materialize(promptText);
+            }
+            // Pure decision: build split request (fixes cliArgs mutation bug)
+            const splitParams = buildSplitRequest({
+                cliArgs,
+                toolMode,
+                effectivePromptPath,
+                extraEnv,
+                cwd,
+                split: flags.split ?? 'auto',
+                sentinelPath,
+                retryOnQuickExit: toolConfig.retryOnQuickExit,
+            });
+            const splitResult = await mux.split({
+                toolName: cliCommand,
+                args: splitParams.toolArgs,
+                env: splitParams.env,
+                cwd: splitParams.cwd,
+                mode: splitParams.mode,
+                split: splitParams.split,
+                promptPath: splitParams.splitPromptPath,
+                sentinelPath: splitParams.sentinelPath,
+                holdPane: splitParams.holdPane,
+                retryOnQuickExit: splitParams.retryOnQuickExit,
+            });
+            if (wantJson) {
+                const jsonExitCode = wantWait && splitResult.launched && splitResult.sentinelPath
+                    ? await sentinelMgr.waitForExit(splitResult.sentinelPath)
+                    : splitResult.exitCode ?? null;
+                // When returning sentinel path to caller without waiting, transfer
+                // ownership so the finally block does not delete the directory.
+                if (!wantWait && splitResult.launched && splitResult.sentinelPath) {
+                    sentinelOwnershipTransferred = true;
+                }
+                host.log(JSON.stringify(toJsonLaunchResult(splitResult, jsonExitCode)));
+                host.exit(jsonExitCode ?? 0);
+            }
+            if (splitResult.launched) {
+                host.logInfo(formatSplitSuccessMessage(mux.backend, splitResult.handle));
+                if (wantWait && splitResult.sentinelPath) {
+                    const waitedExitCode = await sentinelMgr.waitForExit(splitResult.sentinelPath);
+                    host.exit(waitedExitCode ?? 1);
+                }
+                return;
+            }
+            host.logWarning(`Pane split failed (${splitResult.reason}), launching directly`);
+            // Pure decision: build inline args for fallback
+            const fallbackArgs = buildInlineArgs(cliArgs, toolMode, promptText, promptPath);
+            exitCode = await spawnInlineWithRetry(cliCommand, fallbackArgs, toolConfig.retryOnQuickExit, host);
+        }
+        else {
+            // 5b. Create session
+            const resolvedPath = findToolPath(cliCommand) ?? findExecutable(cliCommand);
+            if (resolvedPath) {
+                // Pure decision: build session request
+                const sessionParams = buildSessionRequest({
+                    cliArgs,
+                    toolMode,
+                    promptPath,
+                    promptText,
+                    tmuxSessionFlag: flags['tmux-session'],
+                    cwd,
+                    now: now(),
+                    pid,
+                });
+                host.logInfo(formatSessionLaunchMessage(mux.backend, sessionParams.sessionName, sessionParams.reattach));
+                const result = await mux.createSession({
+                    sessionName: sessionParams.sessionName,
+                    reattach: sessionParams.reattach,
+                    toolPath: resolvedPath,
+                    toolArgs: sessionParams.toolArgs,
+                    cwd,
+                    promptText: sessionParams.promptText,
+                });
+                if (result.launched) {
+                    exitCode = result.exitCode ?? 0;
+                    if (wantJson) {
+                        host.log(JSON.stringify(toJsonLaunchResult(result, exitCode)));
+                        host.exit(exitCode);
+                    }
+                }
+                else {
+                    // Pure decision: resolve fallback warning
+                    if (result.reason) {
+                        host.logWarning(resolveSessionFallbackWarning(mux.backend, result.reason));
+                    }
+                    const fallbackArgs = buildInlineArgs(cliArgs, toolMode, promptText, promptPath);
+                    exitCode = await spawnInlineWithRetry(cliCommand, fallbackArgs, toolConfig.retryOnQuickExit, host);
+                }
+            }
+            else {
+                host.logWarning(formatPathWarning(cliCommand));
+                const fallbackArgs = buildInlineArgs(cliArgs, toolMode, promptText, promptPath);
+                exitCode = await spawnInlineWithRetry(cliCommand, fallbackArgs, toolConfig.retryOnQuickExit, host);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ProcessSpawnError) {
+            host.error(error.message, { exit: EXIT_CODES.ENVIRONMENT_ERROR });
+        }
+        host.error('Unexpected launch failure.', { exit: EXIT_CODES.GENERAL_ERROR });
+    }
+    finally {
+        if (!sentinelOwnershipTransferred) {
+            sentinelMgr.cleanupAll();
+        }
+        promptMgr.cleanup();
+    }
+    host.exit(exitCode);
+}

package/dist/capabilities/launch/runtime-core/launch-decisions.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Pure decision functions extracted from execute-launch.ts.
+ * No side effects — all functions are deterministic string/config transforms.
+ */
+import type { LaunchResult } from '../../../platform/launch.js';
+import type { InlineFallbackContext, JsonLaunchResult, LaunchFlags, SessionRequestParams, SplitRequestParams, ToolConfig, ToolMode } from '../contracts.js';
+export declare const QUICK_EXIT_THRESHOLD_MS = 10000;
+/**
+ * Return the debug message for tool mode, or undefined if none (claude has no special message).
+ */
+export declare function resolveToolModeDebugMessage(toolMode: ToolMode): string | undefined;
+/**
+ * Format version check results into debug lines and an optional warning.
+ */
+export declare function formatVersionCheckMessages(versionCheck: {
+    compatible: boolean;
+    version?: null | string;
+    warning?: string;
+}): {
+    debugLines: string[];
+    warning?: string | undefined;
+};
+/**
+ * Format the success message after a split pane launch.
+ */
+export declare function formatSplitSuccessMessage(backend: string, handle?: string): string;
+/**
+ * Format the info message when launching in a session.
+ */
+export declare function formatSessionLaunchMessage(backend: string, sessionName: string, reattach: boolean): string;
+/**
+ * Determine which CLI tool to launch and its configuration.
+ */
+export declare function resolveToolConfig(flags: Pick<LaunchFlags, 'codex' | 'devin'>, platform: NodeJS.Platform): ToolConfig;
+/**
+ * Decide the informational message to log when falling back to inline mode.
+ */
+export declare function resolveInlineFallbackMessage(ctx: InlineFallbackContext): string;
+/**
+ * Build the args array for an inline process spawn.
+ * Always returns a new array — never mutates input.
+ */
+export declare function buildInlineArgs(cliArgs: readonly string[], toolMode: ToolMode, promptText: string | undefined, promptPath: string | undefined): string[];
+/**
+ * Build split pane parameters.
+ * Returns a new toolArgs array — fixes the cliArgs mutation bug.
+ */
+export declare function buildSplitRequest(params: {
+    cliArgs: readonly string[];
+    cwd: string;
+    effectivePromptPath: string | undefined;
+    extraEnv: Record<string, string>;
+    retryOnQuickExit: boolean;
+    sentinelPath: string;
+    split: 'auto' | 'horizontal' | 'vertical';
+    toolMode: ToolMode;
+}): SplitRequestParams;
+/**
+ * Build session creation parameters.
+ */
+export declare function buildSessionRequest(params: {
+    cliArgs: readonly string[];
+    cwd: string;
+    now: number;
+    pid: number;
+    promptPath: string | undefined;
+    promptText: string | undefined;
+    tmuxSessionFlag: string | undefined;
+    toolMode: ToolMode;
+}): SessionRequestParams;
+/**
+ * Decide warning message when session creation fails and we fall back inline.
+ */
+export declare function resolveSessionFallbackWarning(backend: string, reason: string | undefined): string;
+/**
+ * Pure timing decision for retry logic.
+ */
+export declare function shouldRetry(elapsedMs: number, threshold?: number): boolean;
+/**
+ * Convert a LaunchResult to JSON-serializable form.
+ */
+export declare function toJsonLaunchResult(result: LaunchResult, exitCode: null | number): JsonLaunchResult;

package/dist/capabilities/launch/runtime-core/launch-decisions.js

@@ -0,0 +1,202 @@
+/**
+ * Pure decision functions extracted from execute-launch.ts.
+ * No side effects — all functions are deterministic string/config transforms.
+ */
+import path from 'node:path';
+import { buildUniqueSessionName, sanitizeSessionName } from './launch-options.js';
+export const QUICK_EXIT_THRESHOLD_MS = 10_000;
+/**
+ * Return the debug message for tool mode, or undefined if none (claude has no special message).
+ */
+export function resolveToolModeDebugMessage(toolMode) {
+    if (toolMode === 'codex')
+        return 'Launching Codex with --yolo flag';
+    if (toolMode === 'devin')
+        return 'Launching Devin with --permission-mode dangerous';
+    return undefined;
+}
+/**
+ * Format version check results into debug lines and an optional warning.
+ */
+export function formatVersionCheckMessages(versionCheck) {
+    return {
+        debugLines: [
+            `Claude Code version: ${versionCheck.version ?? 'unknown'}`,
+            `Compatibility status: ${versionCheck.compatible ? 'compatible' : 'incompatible'}`,
+        ],
+        ...(versionCheck.warning ? { warning: versionCheck.warning } : {}),
+    };
+}
+/**
+ * Format the success message after a split pane launch.
+ */
+export function formatSplitSuccessMessage(backend, handle) {
+    if (handle) {
+        return `Launched in ${backend} pane: ${handle}`;
+    }
+    return `Launched in ${backend}`;
+}
+/**
+ * Format the info message when launching in a session.
+ */
+export function formatSessionLaunchMessage(backend, sessionName, reattach) {
+    if (reattach) {
+        return `Launching in ${backend} session: ${sessionName} (reuse/attach)`;
+    }
+    return `Launching in new ${backend} session: ${sessionName}`;
+}
+function buildCodexArgs(platform) {
+    if (platform !== 'win32')
+        return ['--yolo'];
+    return ['-c', 'shell_type="bash"', '--yolo'];
+}
+function buildDevinArgs() {
+    return ['--permission-mode', 'dangerous'];
+}
+/**
+ * Determine which CLI tool to launch and its configuration.
+ */
+export function resolveToolConfig(flags, platform) {
+    if (flags.devin) {
+        return {
+            cliCommand: 'devin',
+            cliArgs: buildDevinArgs(),
+            launchFlag: '--devin',
+            toolMode: 'devin',
+            retryOnQuickExit: true,
+            needsLspPatch: false,
+            skipVersionCheck: true,
+        };
+    }
+    if (flags.codex) {
+        return {
+            cliCommand: 'codex',
+            cliArgs: buildCodexArgs(platform),
+            launchFlag: '--codex',
+            toolMode: 'codex',
+            retryOnQuickExit: false,
+            needsLspPatch: false,
+            skipVersionCheck: true,
+        };
+    }
+    return {
+        cliCommand: 'claude',
+        cliArgs: ['--dangerously-skip-permissions'],
+        launchFlag: '',
+        toolMode: 'claude',
+        retryOnQuickExit: false,
+        needsLspPatch: platform === 'win32',
+        skipVersionCheck: false,
+    };
+}
+/**
+ * Decide the informational message to log when falling back to inline mode.
+ */
+export function resolveInlineFallbackMessage(ctx) {
+    if (!ctx.hasMux) {
+        if (ctx.disableMux) {
+            return 'Multiplexer disabled via --no-tmux — launching inline';
+        }
+        if (!ctx.interactiveTty) {
+            return 'Non-interactive terminal — launching inline';
+        }
+        if (ctx.platform === 'win32') {
+            return 'No multiplexer found — launching inline. Run inside WezTerm or install psmux for session management.';
+        }
+        return 'No multiplexer found — launching inline. Install tmux for session management.';
+    }
+    return ctx.resolvedReason ?? 'Launching inline';
+}
+/**
+ * Build the args array for an inline process spawn.
+ * Always returns a new array — never mutates input.
+ */
+export function buildInlineArgs(cliArgs, toolMode, promptText, promptPath) {
+    if (toolMode === 'devin' && promptPath) {
+        return [...cliArgs, '--prompt-file', promptPath];
+    }
+    if (promptText) {
+        return [...cliArgs, promptText];
+    }
+    return [...cliArgs];
+}
+/**
+ * Build split pane parameters.
+ * Returns a new toolArgs array — fixes the cliArgs mutation bug.
+ */
+export function buildSplitRequest(params) {
+    let toolArgs;
+    let splitPromptPath;
+    if (params.toolMode === 'devin' && params.effectivePromptPath) {
+        toolArgs = [...params.cliArgs, '--prompt-file', params.effectivePromptPath];
+        splitPromptPath = undefined;
+    }
+    else {
+        toolArgs = [...params.cliArgs];
+        splitPromptPath = params.effectivePromptPath;
+    }
+    return {
+        toolArgs,
+        splitPromptPath,
+        env: params.extraEnv,
+        cwd: params.cwd,
+        mode: 'repl',
+        split: params.split,
+        sentinelPath: params.sentinelPath,
+        holdPane: false,
+        retryOnQuickExit: params.retryOnQuickExit,
+    };
+}
+/**
+ * Build session creation parameters.
+ */
+export function buildSessionRequest(params) {
+    const sessionFromFlag = params.tmuxSessionFlag?.trim();
+    const reattach = Boolean(sessionFromFlag && sessionFromFlag.length > 0);
+    const sessionName = reattach
+        ? sanitizeSessionName(sessionFromFlag)
+        : buildUniqueSessionName(`aiw-${path.basename(params.cwd)}`, params.now, params.pid);
+    const toolArgs = params.toolMode === 'devin' && params.promptPath
+        ? [...params.cliArgs, '--prompt-file', params.promptPath]
+        : [...params.cliArgs];
+    const promptText = params.toolMode === 'devin' ? undefined : params.promptText;
+    return { sessionName, reattach, toolArgs, promptText };
+}
+/**
+ * Decide warning message when session creation fails and we fall back inline.
+ */
+export function resolveSessionFallbackWarning(backend, reason) {
+    if (!reason)
+        return 'Session creation failed — launching inline';
+    if (reason.includes('not found') || reason.includes('unavailable')) {
+        const hint = backend === 'psmux' ? ' Install with: winget install psmux' : '';
+        return `${backend} unavailable — launching inline.${hint}`;
+    }
+    if (reason.includes('too old')) {
+        const hint = backend === 'psmux' ? ' Update with: winget upgrade psmux' : '';
+        return `${reason} — launching inline.${hint}`;
+    }
+    if (backend === 'psmux' && reason.includes('attach failed')) {
+        return `${reason} — launching inline. Recovery: run "psmux kill-server" and relaunch if this persists.`;
+    }
+    return `${reason} — launching inline`;
+}
+/**
+ * Pure timing decision for retry logic.
+ */
+export function shouldRetry(elapsedMs, threshold = QUICK_EXIT_THRESHOLD_MS) {
+    return elapsedMs < threshold;
+}
+/**
+ * Convert a LaunchResult to JSON-serializable form.
+ */
+export function toJsonLaunchResult(result, exitCode) {
+    return {
+        launched: result.launched,
+        backend: result.backend,
+        handle: result.handle ?? null,
+        sentinelPath: result.sentinelPath ?? null,
+        exitCode,
+        reason: result.reason ?? null,
+    };
+}

package/dist/capabilities/launch/runtime-core/launch-options.d.ts

@@ -0,0 +1,14 @@
+export interface BuildSpawnedWindowArgsParams {
+    disableTmux: boolean;
+    promptFilePath?: string | undefined;
+    promptPath?: string | undefined;
+    rawEnvJson?: string | undefined;
+    tmuxSessionFlag?: string | undefined;
+    useCodex: boolean;
+    useDevin?: boolean;
+}
+export declare function parseExtraEnv(raw: string | undefined): Record<string, string>;
+export declare function resolvePromptText(promptFlag: string | undefined, promptFileFlag: string | undefined, readFile: (filePath: string) => string | undefined): string | undefined;
+export declare function buildSpawnedWindowArgs(params: BuildSpawnedWindowArgsParams): string[];
+export declare function sanitizeSessionName(input: string): string;
+export declare function buildUniqueSessionName(base: string, now?: number, pid?: number): string;

package/dist/capabilities/launch/runtime-core/launch-options.js

@@ -0,0 +1,69 @@
+export function parseExtraEnv(raw) {
+    if (!raw)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('--env must be a valid JSON object string');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('--env must be a valid JSON object string');
+    }
+    return parsed;
+}
+export function resolvePromptText(promptFlag, promptFileFlag, readFile) {
+    const promptText = promptFlag?.trim();
+    if (promptText)
+        return promptText;
+    const promptFilePath = promptFileFlag?.trim();
+    if (!promptFilePath)
+        return undefined;
+    try {
+        const fromFile = readFile(promptFilePath)?.trim();
+        return fromFile || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function buildSpawnedWindowArgs(params) {
+    const { useCodex, useDevin, disableTmux, promptFilePath, promptPath, rawEnvJson, tmuxSessionFlag } = params;
+    const parts = ['aiw', 'launch', '--spawned-window'];
+    if (useDevin)
+        parts.push('--devin');
+    else if (useCodex)
+        parts.push('--codex');
+    if (disableTmux)
+        parts.push('--no-tmux');
+    const tmuxSession = tmuxSessionFlag?.trim();
+    if (tmuxSession) {
+        parts.push('--tmux-session', tmuxSession);
+    }
+    const envJson = rawEnvJson?.trim();
+    if (envJson) {
+        parts.push('--env', envJson);
+    }
+    if (promptPath) {
+        parts.push('--prompt-path', promptPath);
+    }
+    else if (promptFilePath) {
+        parts.push('--prompt-file', promptFilePath);
+    }
+    return parts;
+}
+export function sanitizeSessionName(input) {
+    const trimmed = input.trim().toLowerCase();
+    const safe = trimmed
+        .replaceAll(/[^a-z0-9_-]/g, '-')
+        .replaceAll(/-+/g, '-')
+        .replaceAll(/^[-_]+|[-_]+$/g, '');
+    return safe || 'aiw';
+}
+export function buildUniqueSessionName(base, now = Date.now(), pid = process.pid) {
+    const safeBase = sanitizeSessionName(base);
+    const timestamp = now.toString(36);
+    const pidPart = pid.toString(36);
+    return sanitizeSessionName(`${safeBase}-${timestamp}-${pidPart}`);
+}

package/dist/cli/base-command.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+import { type Ora } from 'ora';
+export default abstract class BaseCommand extends Command {
+    static baseFlags: {
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    init(): Promise<void>;
+    protected isQuiet(): boolean;
+    protected logDebug(message: string): void;
+    protected logError(message: string): void;
+    protected logInfo(message: string): void;
+    protected logSuccess(message: string): void;
+    protected logWarning(message: string): void;
+    abstract run(): Promise<void>;
+    protected spinner(text: string): Ora;
+}